Sensor de toque TTP223 com Arduino: modos, ligação e uma luminária de toque

O sensor de toque TTP223 é um módulo de toque capacitivo de uma tecla, bem barato, que substitui um botão mecânico detectando o seu dedo por meio de uma mudança de capacitância. Ele tem só três pinos (VCC, GND e I/O): quando você toca nele, a saída vai para HIGH e, quando você afasta o dedo, ela volta para LOW. Graças a essa simplicidade, você o lê no Arduino com digitalRead(), exatamente como um botão, e, como ele funciona de 2 a 5,5 V, também pode ser ligado diretamente a um ESP32 ou a um Raspberry Pi Pico. Sem partes móveis, ele não se desgasta nem faz clique, e pode ficar escondido atrás de uma camada fina de plástico, vidro ou madeira.

Neste guia você vai aprender passo a passo o que acontece dentro do TTP223, como usar os jumpers de solda A e B da placa para escolher o modo momentâneo ou alternado e uma saída ativa em HIGH ou em LOW, como montar uma luminária de toque com Arduino que liga e desliga com um toque curto e diminui o brilho com um toque longo, como fazer o sensor funcionar atrás de um painel, como usar várias teclas, como ele se compara aos pinos de toque internos do ESP32 e como usá-lo no Pico com MicroPython.

O que é o sensor de toque TTP223 e como ele funciona?

O pad de cobre do módulo e a área de terra (GND) da placa formam um capacitor minúsculo de alguns picofarads. Quando o seu dedo se aproxima do pad, o seu corpo passa a fazer parte desse capacitor e a capacitância total aumenta alguns picofarads. O oscilador do sensor, de cerca de 1 MHz, dentro do TTP223 percebe esse aumento como uma mudança de frequência, compara o resultado com um valor de referência que ele guarda e muda a saída se a diferença for grande o suficiente. A fórmula do capacitor de placas paralelas C = ε·A/d também vale aqui: quanto maior a área do pad (A) e mais fino o material entre o dedo e o pad (d), mais forte a detecção.

O chip define o valor de referência sozinho. No momento em que você liga a alimentação, ele mede o ambiente por cerca de 0,5 segundo e ignora toques durante esse tempo. Depois disso, enquanto ninguém toca nele, ele se recalibra mais ou menos a cada 4 segundos, de modo que mudanças lentas, como temperatura e umidade, são compensadas com o tempo. É por isso que o sensor considera “sem toque” tudo o que está ao redor do pad quando é ligado: se o seu dedo estiver no pad na hora em que ele liga, ele simplesmente não vai enxergar você.

Na versão TTP223-BA6 usada nesses módulos, algumas opções são fixas dentro do encapsulamento: o chip sempre funciona no modo de baixo consumo, e o limite de “tempo máximo ligado” de 100 segundos que existe em outros encapsulamentos fica desativado. No modo de baixo consumo, o chip consome só alguns microampères, mas pode levar até cerca de 220 ms para responder ao primeiro toque. Depois que um toque é detectado, ele fica no modo rápido por cerca de 12 segundos e responde bem mais depressa aos toques seguintes. Você não vai perceber esse atraso em uma luminária ou em uma campainha, mas tenha isso em mente se estiver montando um controle de jogo que precisa de reações rápidas.

Pinagem e ligação do TTP223

Como o pino de saída leva o sinal ativamente para HIGH e LOW, você não precisa de INPUT_PULLUP nem de um resistor externo no Arduino; basta configurar o pino como INPUT. Não há repique dos contatos como nos botões mecânicos, porque o chip só muda a saída quando o toque está estável. Mesmo assim, se você quiser que o código conte um toque como um único evento, use a lógica de detecção de borda que explicamos em Como ligar um botão no Arduino.

Escolhendo o modo com os jumpers de solda A e B

Ao lado do chip, no módulo, há dois pequenos pares de pads de solda marcados com A e B. Eles estão ligados a dois pinos de opção do chip: na maioria dos módulos, o A escolhe se a saída é ativa em HIGH ou ativa em LOW (AHLB), e o B escolhe se o sensor funciona no modo momentâneo ou alternado (TOG). Dentro do chip, esses pinos são puxados para o GND por um resistor; por isso, com os pads abertos, a opção é “0”; una os dois pads com uma gota de solda e a opção passa a ser “1”. Depois de mudar um jumper, o mais seguro é desligar e religar a alimentação. Se as marcações da sua placa forem diferentes, você pode confirmar o modo facilmente com o LED do primeiro sketch de teste.

Primeiro teste com Arduino: lendo um toque

1. Ligue o pino VCC do módulo ao pino 5V do Arduino, o GND ao GND e o pino I/O ao D2.
2. Carregue o sketch abaixo e abra o Monitor Serial em 9600 baud.
3. Depois que a placa iniciar, espere cerca de um segundo sem tocar no pad; o chip se calibra durante esse tempo.
4. Toque no pad com o dedo: o LED interno do Arduino no pino 13 (e, na maioria dos módulos, o LED da própria placa do sensor) deve acender, e a contagem de toques no Monitor Serial deve aumentar em um.
5. O LED fica aceso enquanto o seu dedo estiver no pad, mas o contador só aumenta uma vez a cada novo toque.

1const int TOUCH_PIN = 2;    // TTP223 I/O (SIG) pini / TTP223 I/O (SIG) pin
2const int LED_PIN = 13;     // Uno'nun dahili LED'i / Uno onboard LED
3
4bool lastState = false;
5unsigned long touchCount = 0;
6
7void setup() {
8  Serial.begin(9600);
9  pinMode(TOUCH_PIN, INPUT);   // çıkış push-pull, pull-up gerekmez / push-pull output, no pull-up needed
10  pinMode(LED_PIN, OUTPUT);
11  delay(600);                  // açılış kalibrasyonu bitsin (~0,5 s) / let power-on calibration finish (~0.5 s)
12}
13
14void loop() {
15  bool state = digitalRead(TOUCH_PIN) == HIGH;   // dokunurken true / true while touched
16  digitalWrite(LED_PIN, state ? HIGH : LOW);
17
18  if (state && !lastState) {   // LOW -> HIGH: yeni dokunuş / new touch
19    touchCount++;
20    Serial.print("Dokunus / Touch: ");
21    Serial.println(touchCount);
22  }
23  lastState = state;
24}

A parte mais importante do código é a detecção de borda. A leitura anterior fica guardada na variável lastState; se a nova leitura for HIGH e a anterior era LOW, temos um novo toque. Sem essa verificação, o contador aumentaria a cada volta do loop enquanto o seu dedo ficasse no pad, ou seja, milhares de vezes por segundo. A espera de 600 ms no setup() garante que o chip termine a calibração quando o Arduino e o módulo são alimentados ao mesmo tempo. Escolhemos o D2 porque ele é um dos pinos de interrupção do Uno; se quiser, você também pode capturar o toque com uma interrupção usando attachInterrupt(digitalPinToInterrupt(2), funcao, RISING).

Projeto: uma luminária de toque com Arduino

Agora vamos montar uma luminária de toque de verdade: um toque curto liga e desliga a luminária, manter o dedo no pad com ela acesa diminui a luz devagar, e o próximo toque longo volta a aumentar o brilho. Como o brilho é ajustado com PWM, ligamos a luminária ao D9, um dos pinos PWM do Uno. Para testar, um LED e um resistor de 220 Ω no D9 bastam (use a calculadora de resistor para LED para achar o valor certo). Se você for usar uma fita de LED de 12 V, coloque no meio um MOSFET de nível lógico, como o IRLZ44N; veja os detalhes em Como usar um MOSFET com Arduino.

1const int TOUCH_PIN = 2;                // TTP223 I/O (fabrika ayarı: anlık, aktif yüksek) / factory default: momentary, active high
2const int LAMP_PIN = 9;                 // PWM pini: LED ya da MOSFET kapısı / PWM pin: LED or MOSFET gate
3const unsigned long LONG_PRESS = 600;   // uzun dokunuş eşiği (ms) / long-touch threshold (ms)
4
5bool lampOn = false;
6bool lastTouch = false;
7bool dimming = false;
8int brightness = 255;                   // son parlaklık (10-255) / last brightness (10-255)
9int step = 5;                           // kısma yönü ve adımı / dimming direction and step
10unsigned long touchStart = 0;
11unsigned long lastStep = 0;
12
13void setup() {
14  pinMode(TOUCH_PIN, INPUT);
15  pinMode(LAMP_PIN, OUTPUT);
16  delay(600);                           // TTP223 kalibrasyonu bitsin / let the TTP223 finish calibrating
17}
18
19void loop() {
20  bool touch = digitalRead(TOUCH_PIN) == HIGH;
21  unsigned long now = millis();
22
23  if (touch && !lastTouch) {            // dokunuş başladı / touch started
24    touchStart = now;
25    dimming = false;
26  }
27
28  if (touch && lampOn && now - touchStart > LONG_PRESS) {   // lamba açıkken uzun dokunuş / long touch while the lamp is on
29    if (!dimming) {
30      dimming = true;
31      step = -step;                     // her uzun dokunuşta yön değişir / direction flips on every long touch
32    }
33    if (now - lastStep >= 20) {         // 20 ms'de bir adım / one step every 20 ms
34      lastStep = now;
35      brightness += step;
36      if (brightness <= 10 || brightness >= 255) {
37        brightness = constrain(brightness, 10, 255);
38        step = -step;                   // uca gelince geri dön / bounce back at the ends
39      }
40      analogWrite(LAMP_PIN, brightness);
41    }
42  }
43
44  if (!touch && lastTouch && !dimming) {   // kısa dokunuş bitti: aç/kapa / short touch ended: toggle
45    lampOn = !lampOn;
46    analogWrite(LAMP_PIN, lampOn ? brightness : 0);
47  }
48
49  lastTouch = touch;
50}

Repare que não há delay() em nenhum lugar do código: toda a temporização é feita com millis(), então o loop continua rodando e nunca perde um toque. Você pode ler mais sobre essa técnica em millis() vs delay(). Como o último brilho fica guardado na variável brightness, quando você desliga e liga a luminária de novo a luz volta no último nível que você ajustou, igualzinho às luminárias de mesa com toque que se encontram nas lojas.

Detecção através de materiais finos

A característica mais apreciada do TTP223 é que ele consegue funcionar de dentro de uma caixa sem nenhum furo. Plástico, acrílico, vidro, madeira, papel e tecido deixam o campo elétrico passar; o material entre o pad e o dedo funciona como o dielétrico de um capacitor. À medida que o material fica mais grosso, o d da fórmula aumenta e a capacitância entre o dedo e o pad cai; dobrar a espessura reduz essa capacitância mais ou menos pela metade. O vidro tem uma constante dielétrica maior do que a da maioria dos plásticos, por isso um vidro da mesma espessura costuma dar resultados melhores. Na prática, o módulo costuma funcionar bem atrás de um painel de plástico, acrílico ou vidro de 1–3 mm; com painéis mais grossos você vai precisar de um pad maior, e sempre vale testar com o seu próprio material.

• Não deixe espaço de ar: o ar tem constante dielétrica 1, e até uma folga de 1 mm reduz bastante a sensibilidade. Cole o módulo firmemente no painel, com o lado do pad voltado para ele, usando fita dupla face fina ou cola.
• Aumente o pad: para ter uma área de toque maior, recorte um eletrodo de fita de cobre ou papel-alumínio, raspe com cuidado o verniz protetor de um canto do pad e solde o eletrodo nele com um fio bem curto. Quanto mais longo o fio, mais capacitância ele acrescenta e menos estável o sensor fica.
• Evite metal: painéis de metal, materiais com metal na composição e tintas metálicas concentram o campo elétrico em si mesmos; o sensor ou não detecta nada, ou dispara sozinho.
• Reduza o excesso de sensibilidade: se o sensor disparar antes de o dedo chegar perto, acrescente um pequeno capacitor cerâmico de 5–20 pF (Cs) entre o pad e o GND; quanto maior o valor, menor a sensibilidade, com 50 pF como limite máximo. Você pode decifrar a marcação do capacitor (por exemplo, 100 = 10 pF, 220 = 22 pF) com a ferramenta código de capacitor.
• Primeiro monte, depois ligue: como o chip toma o ambiente como referência ao ser ligado, ligue a alimentação só depois que o painel e a tampa estiverem no lugar. Se você encaixar o painel com o circuito ligado, o chip pode tratá-lo como um toque permanente; nesse caso, basta desligar e religar a alimentação.

Usando várias teclas de toque

Cada TTP223 monitora o próprio pad de forma independente; se você quer quatro teclas, ligue quatro módulos a quatro pinos digitais separados, com os módulos compartilhando VCC e GND. Se as teclas estiverem muito próximas, o seu dedo também pode afetar o pad vizinho; deixe pelo menos 1–2 cm entre os pads e mantenha os módulos longe dos fios de motores ou relés. O sketch abaixo usa quatro TTP223 e um buzzer passivo para fazer um pequeno piano de toque: cada tecla em que você tocar emite a sua nota, e o som para quando você levanta o dedo.

1const int TOUCH_PINS[] = {2, 3, 4, 5};          // dört TTP223 I/O pini / four TTP223 I/O pins
2const int NOTES[]      = {262, 294, 330, 349};  // Do, Re, Mi, Fa (Hz) / C4, D4, E4, F4 (Hz)
3const int KEY_COUNT    = 4;
4const int BUZZER_PIN   = 8;                     // pasif buzzer / passive buzzer
5
6int currentNote = 0;
7
8void setup() {
9  for (int i = 0; i < KEY_COUNT; i++) {
10    pinMode(TOUCH_PINS[i], INPUT);
11  }
12  pinMode(BUZZER_PIN, OUTPUT);
13  delay(600);                                   // sensörlerin kalibrasyonu / sensor calibration
14}
15
16void loop() {
17  int note = 0;
18  for (int i = 0; i < KEY_COUNT; i++) {
19    if (digitalRead(TOUCH_PINS[i]) == HIGH) {   // ilk dokunulan tuş çalar / the first touched key plays
20      note = NOTES[i];
21      break;
22    }
23  }
24  if (note != currentNote) {                    // yalnızca nota değişince güncelle / update only when the note changes
25    currentNote = note;
26    if (note > 0) tone(BUZZER_PIN, note);
27    else noTone(BUZZER_PIN);
28  }
29}

Como o tone() só consegue tocar uma nota por vez, o código escolhe a primeira tecla tocada e só atualiza a nota quando ela muda, para que o som não fique chiando. No Uno, o tone() usa o Timer2, então o analogWrite não funciona nos pinos 3 e 11 enquanto o buzzer está tocando; aqui isso não é problema, porque o piano usa o D3 apenas como entrada. À medida que o número de teclas cresce, fica mais organizado passar para chips multicanal em vez de um módulo por tecla: o TTP224 oferece quatro teclas com quatro saídas separadas, o TTP229 lê 8 ou 16 teclas por uma interface serial de dois fios, e o MPR121 monitora 12 eletrodos por I2C.

ESP32: TTP223 ou os pinos de toque internos?

O ESP32 clássico tem um sensor de toque capacitivo embutido, e 10 pinos (T0–T9) podem ser usados como teclas de toque sem nenhum módulo: GPIO 4, 0, 2, 15, 13, 12, 14, 27, 33 e 32, nessa ordem. A função touchRead() retorna um número bruto; no ESP32 clássico esse número cai quando você toca no pino, enquanto no ESP32-S2 e no S3 ele sobe. O ESP32-C3 não tem nenhum sensor de toque. Para ver os pinos internos em detalhes, confira pinos de toque do ESP32; a tabela abaixo compara as duas abordagens.

1const int TTP223_PIN = 26;   // TTP223 I/O, modül 3,3 V ile beslenir / module powered from 3.3 V
2const int TOUCH_GPIO = 4;    // dahili dokunmatik T0 / built-in touch pad T0
3const int LED_PIN = 2;       // çoğu DevKit'te dahili LED / onboard LED on most DevKits
4int threshold = 0;
5
6void setup() {
7  Serial.begin(115200);
8  pinMode(TTP223_PIN, INPUT);
9  pinMode(LED_PIN, OUTPUT);
10  delay(600);                                  // dokunmadan bekle / wait without touching
11  threshold = touchRead(TOUCH_GPIO) * 0.7;     // dokunulmamış değerin %70'i / 70% of the untouched value
12}
13
14void loop() {
15  int raw = touchRead(TOUCH_GPIO);             // klasik ESP32'de dokununca düşer / drops when touched on the classic ESP32
16  bool builtIn = raw < threshold;
17  bool module = digitalRead(TTP223_PIN) == HIGH;
18  digitalWrite(LED_PIN, (builtIn || module) ? HIGH : LOW);
19  Serial.printf("ham/raw: %d  esik/threshold: %d  T0: %d  TTP223: %d\n", raw, threshold, builtIn, module);
20  delay(100);
21}

Na inicialização, este sketch mede o valor de T0 sem toque e usa 70% dele como limite; acompanhe o valor bruto no Monitor Serial (115200 baud) para ajustar a proporção à sua própria fiação. Se você usa um ESP32-S3, o valor sobe ao tocar, então inverta a comparação (por exemplo, limite = valor medido × 1,3 e raw > limite). Outro motivo para termos ligado o TTP223 ao GPIO 26 é que ele é um RTC GPIO: com esp_sleep_enable_ext0_wakeup(GPIO_NUM_26, 1) você pode colocar o ESP32 em deep sleep e acordá-lo com um toque. Como o TTP223 consome só alguns microampères, os dois formam uma ótima dupla para projetos alimentados por bateria; veja os detalhes em deep sleep do ESP32.

TTP223 com o Raspberry Pi Pico (MicroPython)

O chip RP2040 do Pico não tem sensor de toque, então o TTP223 é a forma mais fácil de adicionar uma tecla de toque a um Pico. Alimente o módulo pelo pino 3V3(OUT) (pino físico 36) e ligue o pino I/O ao GP15 (pino físico 20). O código MicroPython abaixo alterna o LED interno da placa a cada toque. Como ele captura o toque com uma interrupção (IRQ), nenhum toque se perde, mesmo quando o loop principal está ocupado com outras tarefas. Se você ainda não sabe instalar o MicroPython no Pico, comece por O que é o Raspberry Pi Pico?.

1from machine import Pin
2import time
3
4touch = Pin(15, Pin.IN)            # TTP223 I/O -> GP15 (fiziksel pin 20) / physical pin 20
5led = Pin("LED", Pin.OUT)          # dahili LED (Pico ve Pico W) / onboard LED (Pico and Pico W)
6last = 0
7
8def on_touch(pin):
9    global last
10    now = time.ticks_ms()
11    if time.ticks_diff(now, last) > 250:   # bir dokunuşu bir kez say / count each touch once
12        led.toggle()
13        last = now
14
15time.sleep_ms(600)                 # TTP223 açılış kalibrasyonu / TTP223 power-on calibration
16touch.irq(trigger=Pin.IRQ_RISING, handler=on_touch)
17
18while True:
19    print("Dokunma / Touch:", touch.value(), " LED:", led.value())
20    time.sleep(1)

Nas versões atuais do MicroPython, o nome Pin("LED") seleciona o LED interno tanto no Pico quanto no Pico W. Se você uniu o jumper B e colocou o módulo no modo alternado, nem precisa da interrupção: escrever led.value(touch.value()) no loop basta, porque agora é o próprio chip que guarda o estado de liga/desliga. Embora a saída do chip não tenha repique, o bloqueio de 250 ms no código impede que pulsos curtos de ruído em fios longos alternem o LED duas vezes.

Ideias de projetos com TTP223

• Luz noturna de toque: acrescente um LDR para que a luminária só responda ao toque quando estiver escuro.
• Luminária que muda de cor: mude a cor de um anel WS2812B NeoPixel a cada toque e ajuste o brilho com um toque longo.
• Fechadura com senha escondida: coloque quatro TTP223 atrás de um painel de acrílico; tocar nas teclas na ordem certa faz um servo motor abrir a trava.
• Campainha sem furos: cole o sensor dentro de uma caixa plástica; um toque faz um DFPlayer Mini tocar o som da campainha.
• Interruptor de tomada por toque: ligue e desligue uma luminária de mesa ou um ventilador com um módulo relé.
• Controle remoto a bateria: mantenha um ESP32 em deep sleep; quando você toca no TTP223, ele acorda e envia um comando por ESP-NOW.

Erros comuns e como corrigi-los

O TTP223 é a forma mais fácil de adicionar uma interface de toque moderna aos seus projetos com um módulo muito barato: ele substitui o botão mecânico, funciona atrás de painéis sem furos e se dá bem com qualquer microcontrolador. Primeiro experimente lê-lo com a configuração de fábrica e depois pratique a detecção de borda e a lógica de toque longo com os exemplos da luminária e do piano. No app BlueGrays você encontra esquemas do circuito e código passo a passo para acender um LED com um botão, um LED de liga/desliga, projetos com botão para ESP32 e Pico e o acionamento de uma lâmpada da rede elétrica, e pode transformar todos eles em projetos de toque colocando um TTP223 no lugar do botão.