Guia da Interface com um teclado de toque capacitivo TTP229

Neste tutorial, faremos a interface de um dispositivo de entrada – especificamente, um teclado de toque capacitivo TTP229 – com o Arduino. O TTP229 é um teclado 4×4 popular que suporta entradas de teclas 8/16 com opções de uma e várias teclas. Curiosamente, ele pode ser conectado a um microcontrolador ou Arduino usando apenas dois pinos.

Os teclados são os dispositivos de entrada mais comuns usados em sistemas embarcados. Nesse caso, um “dispositivo de entrada” se refere a um componente usado para inserir dados ou comandos pelo usuário.

Houve um tempo em que os teclados de matriz, projetados por botões de multiplexação, eram normalmente usados como teclados. No entanto, esses tipos de teclados exigiam muitos pinos para fazer a interface com um controlador/computador e a única maneira pela qual a entrada da tecla poderia ser detectada era por meio do microcontrolador/microprocessador.

Teclados matriciais

Por muito tempo, os teclados de matriz têm sido um componente de interface humana popular para sistemas embarcados. Esses teclados são projetados pela multiplexação de botões em linhas e colunas, que formam uma matriz de botões. Cada botão de pressão está conectado a apenas uma linha e apenas uma coluna.

Os teclados de membrana agora estão disponíveis e vêm nos tamanhos 4×4, 4×3, 4×2, 4×1 e outros. Um teclado de matriz 4×4 possui quatro linhas e quatro colunas. Um teclado de matriz 4×3 possui quatro linhas e três colunas, e um teclado de matriz 4×1 tem quatro linhas e uma coluna.

Este é um diagrama de circuito de um teclado de membrana 4×4:

Como funcionam os teclados matriciais

Para detectar a entrada de um teclado de matriz, as linhas e colunas devem ter interface com o microcontrolador. Isso é feito através da interface de todos os terminais de linha e coluna com os pinos do microcontrolador por meio de resistores limitadores de corrente, que são conectados em série – entre cada terminal e o respectivo pino do controlador.

Os pinos da linha são definidos como saída digital e os pinos da coluna são definidos como entrada digital ou vice-versa. O teclado pode operar ativo-ALTO ou ativo-BAIXO.

Agora, vamos supor que os pinos da linha sejam configurados para a saída digital e os pinos da coluna sejam configurados como uma entrada digital. O controlador é, então, programado de forma que o teclado opere como ativo-ALTO. Cada linha é definida como HIGH, uma após a outra, e a entrada digital de todas as colunas é pesquisada.

Como cada botão está conectado a apenas uma linha e uma coluna, se um botão for pressionado, o sinal lógico (que é ALTO neste exemplo) será detectado, mas para apenas uma das colunas. Como tal, a tecla que é pressionada pode ser identificada. O controlador também pode ser programado para interpretar a entrada da tecla como dados ou um comando.

A entrada analógica é outra maneira de detectar a entrada de um teclado de matriz. Neste método, as linhas são conectadas ao VDD (5V DC) por meio de diferentes valores de resistências. E, as colunas são conectadas ao pino de entrada analógica do microcontrolador por meio dos outros valores das resistências.

Cada botão conecta apenas uma linha e uma coluna. Ao pressionar cada botão, a voltagem do VDD cai em diferentes combinações de resistências. Como resultado, há uma tensão diferente detectada no pino de entrada analógica. Este método requer inspeção manual dos níveis de tensão quando cada botão é pressionado no teclado e de acordo com o design do programa do microcontrolador.

A desvantagem

Embora os teclados de matriz tenham sido uma escolha popular para projetos de microcontroladores, eles têm alguns contras. Por um lado, esses teclados usam botões mecânicos, mas tem havido um esforço em sistemas embarcados para substituir interruptores e botões mecânicos.

Em segundo lugar, vários pinos de E/S digitais são necessários para fazer a interface adequada com um teclado de matriz. Ao usar o método de entrada analógica (que usa um fio para interface), o controlador deve ter um pino de entrada analógica e níveis de tensão que correspondem a cada botão – e deve ser verificado manualmente.

Infelizmente, isso pode levar a erros de entrada quando o dispositivo embutido é usado em amplas condições de operação. As resistências podem mudar, variar ou sofrer danos dependendo das condições ambientais, o que pode levar a erros. Isso ocorre porque o controlador está programado para detectar uma faixa limitada de tensões de cada botão.

Botões de toque capacitivos

Em eletrônica, resistência ou capacitância são normalmente empregadas para detecção de toque. O sensor de toque capacitivo é preferido e usará capacitância mútua ou autocapacitância. Os visores de toque usam configurações de capacitância mútua. Os botões de toque, controles deslizantes e rodas usam configurações de autocapacitância.

Na configuração de capacitância mútua (usada por telas sensíveis ao toque e visores sensíveis ao toque), a capacitância entre um eletrodo receptor e emissor do sensor muda com o toque. Na configuração de autocapacitância (usada por botões de toque e controles deslizantes), a capacitância do sensor muda em relação ao aterramento da placa de circuito impresso (PCB) e ao toque.

Para um botão de toque, sua autocapacitância aumenta quando um dedo humano o toca. Isso acontece por causa da propriedade dielétrica da carne humana e da propriedade condutora do corpo humano. O corpo humano é composto por cerca de 70% de água. Em comparação, a constante dielétrica da água é de 80%, enquanto a do ar é de apenas 1.0006%.

Como resultado, o botão de toque capacitivo tem uma superfície condutora, que é imprensada entre as duas superfícies conectadas ao aterramento do PCB.

Um simples toque do dedo pode aumentar a capacitância da superfície condutora em relação ao aterramento do PCB. Isso ocorre por causa da constante dielétrica alta do dedo. Além disso, devido à natureza condutiva do corpo humano, o dedo atua como um terra virtual formando uma capacitância paralela – o que aumenta ainda mais a autocapacitância do sensor de toque.

Graças às propriedades dielétricas e condutoras do dedo humano, a autocapacitância de um botão de toque capacitivo é aumentada quando tocado. Esta mudança na capacitância está em picofarads e requer circuitos integrados avançados para detecção adequada.

O módulo de toque capacitivo TTP229

O módulo de toque capacitivo TTP229 é um teclado de toque capacitivo 4×4. Módulos de toque semelhantes incluem o TTP226 (teclado de toque capacitivo 4×2) e o TTP224 (teclado de toque capacitivo de 4×1).

O módulo de toque TTP229 é baseado no detector IC TTP229 de 16/8 teclas do touchpad. Por padrão, o módulo vem configurado como 8 teclas que são habilitadas como uma configuração de tecla única.

O IC do teclado de toque capacitivo TTP229
O TTP229 possui sensor capacitivo projetado especificamente para controles de touchpad. Ele possui um regulador embutido para os sensores de toque que permitem uma detecção estável em diversas condições.

O IC pode lidar com 8 ou 16 botões de toque e oferece suporte a opções de uma e várias teclas. Para a tecla única, o mesmo valor é emitido, mesmo se o botão de toque for pressionado várias vezes ou rapidamente. Para o multi-key, valores diferentes são produzidos se o botão de toque for pressionado várias vezes rapidamente.

Além disso, possui 8 saídas separadas para 8 teclas de entrada direta e suporta um barramento compatível com I2C para as oito 8 e 16 teclas de entrada direta. Mesmo para as 8 saídas separadas, os tipos de acionamento de saída (CMOS/Open-Drain/Open-Collector) podem ser selecionados com opções (ativo HIGH/LOW).

O IC requer uma tensão operacional de 2,4 V ~ 5,5 V. Ele tem uma corrente operacional de apenas 20 uA sem carga e uma corrente de dissipação da porta de saída de apenas 8 mA (com alimentação de 3V). Portanto, ele pode ter interface direta com os pinos de E/S digitais de qualquer microcontrolador/processador. O Arduino pode fornecer e absorver corrente de até 40 mA.

Depois que a alimentação é ligada, o IC requer um tempo estável de apenas 0,5 segundos e tem um tempo máximo de ativação de 80 segundos. A sensibilidade pode ser ajustada por uma capacitância de 1 ~ 50pF externa.

O TTP229 também oferece suporte para recalibração automática, que leva no máximo quatro segundos. Existem duas taxas de amostragem disponíveis: 8 Hz para amostragem lenta e 64 Hz para amostragem rápida.

O IC TTP229 tem este diagrama de pinos:

O TTP229 tem esta configuração de pino:

O TTP229 tem este diagrama de blocos:

No módulo de toque, os botões de toque têm interface com o IC TTP229, conforme mostrado neste diagrama de circuito:

Como fica evidente neste diagrama de circuito, o módulo TTP229 possui três conectores. Os ‘Header’ P1 e P2 são conectados aos pinos de opção (TP0 ~ TP7) e o ‘header’ P3 está conectado aos pinos de saída (TP8 ~ TP15).

Esses cabeçalhos estão localizados no módulo conforme mostrado aqui:

Opções de teclado de toque capacitivo TTP229

O teclado de toque capacitivo TTP229 IC oferece várias opções configuráveis. Essas opções podem ser habilitadas conectando ou não os pinos de opção TP0 ~ TP7 ao VSS (o terra do sistema/terra do PCB).

Várias opções de configuração do teclado estão disponíveis no TTP229 IC e suas configurações estão resumidas aqui:

No módulo touchpad, os pinos opcionais estão disponíveis nos conectores P1 e P2. Os pinos de opção TP0 ~ TP7 estão disponíveis no ‘header’ P1 e P2 conforme mostrado aqui:

Por exemplo, por padrão, apenas as 8 teclas de entrada (botões 1 ~ 8) são habilitadas no módulo. Para habilitar as 16 teclas de entrada, a opção TP2 deve primeiro ser conectada ao VSS por meio de um resistor de valor ALTO. Isso pode ser feito encurtando o pino de opção TP2 no cabeçalho P1 usando um jumper, conforme mostrado aqui:

O bug da solda retira os conectores dos conectores P1 e P2 e causa um curto nos pinos opcionais necessários usando as capas dos jumpers. Em seguida, diferentes opções de teclado podem ser habilitadas ou configuradas encurtando ou deixando os pinos de opção desconectados do VSS por meio dos resistores de valor ALTO.

Os resistores estão integrados no módulo. O usuário só precisa encurtar os pinos do cabeçalho ou deixá-los desconectados.

Interface do teclado de toque capacitivo TTP229 com o Arduino

O módulo de teclado de toque capacitivo TTP229 pode ser conectado a qualquer microcontrolador ou ao Arduino usando seu cabeçalho P3. O módulo, por padrão, é configurado para o modo de 8 teclas de entrada. Essas são todas as chaves necessárias para operar em uma configuração de chave única.

Essas 8 teclas de entrada estão disponíveis por meio dos botões de toque de 1 a 8 no teclado. Por padrão, as 8 chaves de entrada têm 8 saídas diretas separadas no cabeçalho P3, conforme mostrado aqui:

No modo de 8 teclas, as teclas de entrada (botões de toque 1 ~ 8) podem ser acessadas diretamente por meio do cabeçalho P3. Os pinos de saída do cabeçalho P3 podem ter interface direta com os pinos de E / S digitais do Arduino (ou qualquer microcontrolador).
Como as saídas diretas são ativas HIGH por padrão, o Arduino deve ser programado para pesquisar o lógico HIGH desses pinos de saída do cabeçalho P3.

Outra maneira de obter a entrada deste teclado sensível ao toque é usando seu barramento compatível com I2C. O barramento compatível com I2C no teclado TTP229 está disponível para os modos de 8 e 16 teclas. Este barramento de dois fios está disponível no cabeçalho P3, conforme mostrado aqui:

Nota:

• Por padrão, o teclado está no modo de 8 teclas.
• O pino SDO no cabeçalho P3 produz os dados seriais de 8 bits, indicando o status dos botões de toque 1 ~ 8.
• O modo de 16 teclas pode ser habilitado encurtando o pino de opção TP2 para o VSS, usando um jumper no cabeçalho P1.
• Quando o modo de 16 teclas é habilitado, o pino SDO no cabeçalho P3 produz os dados seriais de 16 bits, indicando o status dos botões de toque 1 ~ 16.
• Os bits B0 ~ B15 dos dados seriais indicam o status dos botões ouch 1 ~ 16, respectivamente.
• Por padrão, a saída do barramento de 2 fios é a saída CMOS ativa-BAIXA.
• Se o bit for 0, indica que o respectivo botão de toque foi pressionado. Se o bit for 1, indica que o respectivo botão de toque não foi pressionado.

Lendo teclas de toque do módulo TTP229

Se o teclado de toque estiver configurado para o modo de 8 teclas, o status dos botões de toque pode ser detectado por meio de pinos de saída direta ou do barramento de interface de 2 fios. Por padrão, os pinos de saída direta são ALTOS ativos.

Portanto, se o respectivo pino produzir um ALTO lógico, isso indica que ele foi pressionado pelo usuário.

O sinal lógico dos pinos de saída direta pode ser detectado nos pinos de E/S digital do Arduino. No entanto, esse método envolve 8 pinos no Arduino para ler o status dos 8 botões de toque. O status dos botões de toque também pode ser detectado na interface de 2 fios.

Esta interface de 2 fios é compatível com I2C, mas não é exatamente um barramento I2C. Para o modo de 8 teclas, o módulo emite dados de 8 bits que podem ser amostrados aplicando pulsos de clock ao pino SCL. Os bits podem ser amostrados na borda ascendente dos pulsos de clock. Além disso, o usuário precisa amostrar 8 bits aplicando 8 pulsos de clock ao pino SCL.

O teclado sensível ao toque pode ser configurado para um modo de 16 teclas, colocando o pino de opção TP2 em curto com o VSS. Neste modo, o status dos botões de toque 1 ~ 16 pode ser detectado apenas por meio de uma interface de dois fios. O barramento de dois fios emite dados seriais de 16 bits, onde cada bit dos dados pode ser amostrado na borda ascendente dos pulsos de clock aplicados.

Como os bits de dados seriais indicam os botões de toque de status depende da configuração do teclado definida pelos pinos de opção TP0 e TP1. Por padrão, ambos os pinos são conectados ao VDD (lógico HIGH), que define a saída CMOS ativa-HIGH para os pinos de saída direta e a saída CMOS ativa-BAIXA para o barramento de interface de 2 fios.

Se TP1 estiver em curto com o VSS enquanto TP0 estiver conectado ao VDD, os pinos de saída direta são configurados para a saída CMOS ativa-BAIXA e a interface de 2 fios é configurada para a saída CMOS ativa-ALTA.

Se TP0 estiver em curto com o VSS enquanto TP1 for deixado conectado ao VDD, os pinos de saída direta são configurados para dreno aberto, saída ativa-BAIXA e a interface de 2 fios é configurada para saída CMOS ativa-BAIXA.

Se TP0 e TP1 estiverem em curto com o VSS, os pinos de saída direta são configurados para o coletor aberto, saída ativa-HIGH e a interface de 2 fios é configurada para saída CMOS ativa-HIGH.

De acordo com a configuração do teclado definida pelos pinos opcionais TP0 e TP1, os pinos de saída direta podem ser consultados ou os dados seriais da interface de 2 fios podem ser interpretados no sketch do Arduino (ou firmware do microcontrolador).

Receita: Lendo a entrada do touch pad capacitivo TTP229 com entrada de 16 teclas/opção de tecla única usando Arduino
Nesta receita, faremos a interface do teclado de toque capacitivo TTP229 com o Arduino UNO, configurando o teclado para um modo de 16 teclas e uma configuração de tecla única.

Em seguida, leremos o status dos botões de toque do teclado por meio do barramento de interface de 2 fios do teclado. Os botões serão detectados no Monitor Serial do IDE do Arduino.

Componentes necessários

• Arduino UNO x1
• Teclado Capacitivo de Toque TTP229 x1
• Tira de bug (jumpers) x1
• Jumper cap x1
• Fios de ligação
• Computador x1

Conexões de circuito

Configure o teclado TTP229 para um modo de 16 teclas. Para isso, a chave de opção TP2 precisa estar em curto com o VSS. Para fazer isso, solde uma faixa de insetos no cabeçalho P1 enquanto encurta os pinos TP2 usando uma capa de jumper. O módulo do teclado é fornecido 5 Vcc (VDD) e aterrado pelo Arduino UNO.

Os pinos do barramento de interface de 2 fios no teclado podem ser conectados a qualquer um dos pinos de E/S digital do Arduino UNO.

Neste tutorial, os pinos SCL e SDO do cabeçalho P3 do teclado TTP229 fazem interface com os pinos 8 e 9 do Arduino UNO. O Arduino é conectado a um computador e o número da chave do botão de toque pressionado é observado no monitor serial do IDE do Arduino.

O Sketch do Arduino

#define SCL 8
#define SDO 9
byte Key;

byte Read_TTP229_Keypad(void)
{
  byte Num;
  byte Key_State = 0;
  for(Num = 1; Num <= 16; Num++)
  {
    digitalWrite(SCL, LOW);
    if (!digitalRead(SDO))
       Key_State = Num;
    digitalWrite(SCL, HIGH);
  } 
  return Key_State;
}

void setup()
{
   Serial.begin(9600);
   pinMode(SCL, OUTPUT); 
   pinMode(SDO, INPUT);
}

void loop()
{
  Key = Read_TTP229_Keypad();
  if (Key)
     Serial.println(Key);
  delay(1000);
}

Como funciona o projeto

O teclado de toque TTP229 é configurado para um modo de 16 teclas e configuração de tecla única. Nesse modo, o status dos botões de toque só pode ser detectado por meio da interface de 2 fios. O teclado exibe o status das teclas a uma taxa de amostragem padrão de 8 Hz (não alteramos as configurações de hardware do pino opcional TP5).

Nessa taxa de amostragem, o pino SDO produz dados de 16 bits a cada 0,125 segundos. Os bits de saída são amostrados aplicando-se os pulsos de clock de transição ascendente ao pino SCL do teclado.

Os bits de amostra B0 a B15 indicam o status dos botões de toque de 1 a 16, respectivamente. Por padrão, o barramento de interface de 2 fios é configurado para a saída ativa-LOW do CMOS.

Se o respectivo bit for 0, isso indica que o botão de toque correspondente foi pressionado. Se o respectivo bit for 1, isso indica que o botão de toque correspondente não foi pressionado.

Como o teclado emite dados seriais a cada 0,125 segundos, um atraso apropriado deve ser fornecido nos dados de amostragem. Isso ocorre para que, se uma tecla de toque for pressionada por um longo tempo, os dados de entrada não serão lidos várias vezes.

Neste projeto, um atraso de um segundo é fornecido entre cada uma das amostragens para evitar múltiplas entradas não intencionais de qualquer chave. Em cada amostragem, apenas uma tecla pressionada é detectada por vez.

Guia de programação

O sketch do Arduino começa com as atribuições de pinos para os pinos SDO e SCL do teclado de toque. Uma ‘chave’ variável é definida para conter o valor da chave de entrada.

A função definida pelo usuário, Read_TTP229_Keypad (), é definida. Nesta função, os pulsos de relógio são passados para os pinos SCL e os bits (16 bits de dados seriais) do pino SDO do TTP229 são pesquisados.

Se um bit for baixo, o botão de toque respectivo é pressionado e o mesmo número de botão é retornado pela função. Na função setup (), a porta serial é inicializada para 9600 bps. O pino SCL é definido como saída digital, enquanto o pino SDO é definido como entrada digital.

Na função loop(), o Read_TTP229_Keypad () é chamado e o número da tecla que é pressionado é impresso na porta serial em um intervalo de um segundo. À medida que a função loop() continua iterando, o Arduino pesquisa continuamente as teclas que são pressionadas no teclado sensível ao toque em um intervalo de aproximadamente um segundo.

Resultados