Sensor táctil TTP223 con Arduino: modos, conexión y lámpara

El sensor táctil TTP223 es un módulo táctil capacitivo de una sola tecla, muy barato, que sustituye a un pulsador mecánico y detecta tu dedo por el cambio de capacidad. Solo tiene tres pines (VCC, GND e I/O): al tocarlo, la salida pasa a HIGH y, al retirar el dedo, vuelve a LOW. Gracias a esa sencillez se lee en Arduino con digitalRead() igual que un pulsador y, como funciona entre 2 y 5,5 V, también se conecta directamente a un ESP32 o a una Raspberry Pi Pico. Al no tener piezas móviles no se desgasta ni hace clic, y puede esconderse detrás de una capa fina de plástico, vidrio o madera.

En esta guía aprenderás paso a paso qué ocurre dentro del TTP223, cómo usar los puentes de soldadura A y B de la placa para elegir entre modo momentáneo o biestable (toggle) y salida activa en alto o en bajo, cómo construir con Arduino una lámpara táctil que se enciende con un toque corto y se regula con uno largo, cómo hacer que el sensor funcione detrás de un panel, cómo usar varias teclas, en qué se diferencia de los pines táctiles integrados del ESP32 y cómo usarlo en la Pico con MicroPython.

¿Qué es el sensor táctil TTP223 y cómo funciona?

El pad de cobre del módulo y la zona de masa (GND) de la placa forman un pequeño condensador de unos pocos picofaradios. Cuando tu dedo se acerca al pad, tu cuerpo se suma a ese condensador y la capacidad total aumenta unos pocos picofaradios. El oscilador de medida del TTP223, de aproximadamente 1 MHz, detecta ese aumento como un cambio de frecuencia, compara el resultado con un valor de referencia que guarda y cambia la salida si la diferencia es suficiente. La fórmula del condensador de placas paralelas C = ε·A/d también se aplica aquí: cuanto mayor sea el área del pad (A) y más fino el material entre el dedo y el pad (d), mejor será la detección.

El chip fija su valor de referencia por sí mismo. En cuanto le das alimentación, mide su entorno durante unos 0,5 segundos e ignora los toques durante ese tiempo. Después, mientras nadie lo toque, se recalibra aproximadamente cada 4 segundos, de modo que los cambios lentos como la temperatura y la humedad se compensan con el tiempo. Por eso el sensor considera "sin tocar" todo lo que rodea al pad al encenderse: si tu dedo está sobre el pad en el arranque, no te detectará en absoluto.

En la versión TTP223-BA6 que usan estos módulos, algunas opciones vienen fijadas dentro del encapsulado: el chip funciona siempre en modo de bajo consumo y el límite de 100 segundos de "tiempo máximo activado" que tienen otros encapsulados está desactivado. En modo de bajo consumo el chip gasta solo unos pocos microamperios, pero puede tardar hasta unos 220 ms en responder al primer toque. Tras detectar un toque, permanece unos 12 segundos en modo rápido y responde mucho antes a los siguientes. En una lámpara o un timbre no notarás este retardo, pero tenlo en cuenta si construyes un mando de juego que necesite reacciones rápidas.

Pines y conexión del TTP223

Como el pin de salida lleva la señal a HIGH y LOW por sí mismo, en Arduino no necesitas INPUT_PULLUP ni una resistencia externa; basta con declarar el pin como INPUT. Aquí no hay rebotes como en los pulsadores mecánicos, porque el chip solo cambia la salida cuando el toque es estable. Aun así, si quieres que tu código cuente un toque como un único evento, usa la detección de flancos que explicamos en cómo conectar un pulsador.

Elegir el modo con los puentes de soldadura A y B

Junto al chip, el módulo tiene dos pequeñas parejas de pads de soldadura marcadas como A y B. Están conectadas a dos pines de configuración del chip: en la mayoría de los módulos, A elige si la salida es activa en alto o en bajo (AHLB) y B, si el sensor funciona en modo momentáneo o biestable (TOG). Dentro del chip estos pines están llevados a GND mediante una resistencia, así que con los pads abiertos la opción vale "0"; si unes los dos pads con una gota de estaño, pasa a "1". Después de cambiar un puente, lo más seguro es desconectar y volver a conectar la alimentación. Si las marcas de tu placa son distintas, puedes comprobar el modo fácilmente con el LED del primer programa de prueba.

Primera prueba con Arduino: leer un toque

1. Conecta el pin VCC del módulo al pin 5V del Arduino, GND a GND y el pin I/O a D2.
2. Sube el programa de abajo y abre el Monitor Serie a 9600 baudios.
3. Cuando la placa arranque, espera alrededor de un segundo sin tocar el pad; durante ese tiempo el chip se calibra.
4. Toca el pad con el dedo: el LED integrado del Arduino en el pin 13 (y, en la mayoría de los módulos, también el LED de la propia placa) debería encenderse y el número de toques en el Monitor Serie debería subir en uno.
5. Mientras mantengas el dedo sobre el pad, el LED seguirá encendido; el contador, en cambio, solo sube una vez por cada toque nuevo.

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}

La parte más importante del código es la detección de flancos. La lectura anterior se guarda en la variable lastState; si la nueva lectura es HIGH y la anterior era LOW, se trata de un toque nuevo. Sin esta comprobación, el contador subiría en cada vuelta del bucle mientras el dedo siga en el pad, es decir, miles de veces por segundo. La espera de 600 ms en setup() garantiza que el chip haya terminado de calibrarse cuando el Arduino y el módulo se alimentan a la vez. Elegimos D2 porque es uno de los pines de interrupción del Uno; si quieres, también puedes capturar el toque con una interrupción usando attachInterrupt(digitalPinToInterrupt(2), funcion, RISING).

Proyecto: lámpara táctil con Arduino

Ahora vamos a construir una lámpara táctil de verdad: un toque corto la enciende y la apaga, si mantienes el dedo en el pad con la lámpara encendida la luz baja poco a poco, y con el siguiente toque largo vuelve a subir. Como el brillo se ajusta con PWM, conectamos la lámpara a D9, uno de los pines PWM del Uno. Para hacer pruebas basta con un LED y una resistencia de 220 Ω en D9 (calcula el valor correcto con la calculadora de resistencia para LED). Si vas a usar una tira LED de 12 V, intercala un MOSFET de nivel lógico como el IRLZ44N; tienes los detalles en cómo usar un MOSFET con 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}

Fíjate en que el código no tiene ningún delay(): toda la temporización se hace con millis(), así que el bucle sigue girando y no se pierde ningún toque. Tienes más detalles sobre esta técnica en millis() frente a delay(). Como el último brillo queda guardado en la variable brightness, al apagar y encender la lámpara la luz vuelve al nivel que ajustaste por última vez, igual que las lámparas táctiles de escritorio de las tiendas.

Detección a través de materiales finos

La característica más apreciada del TTP223 es que puede funcionar desde dentro de una caja sin agujeros. El plástico, el acrílico, el vidrio, la madera, el papel y la tela dejan pasar el campo eléctrico; el material entre el pad y el dedo actúa como el dieléctrico de un condensador. Cuanto más grueso es el material, mayor es d en la fórmula y menor la capacidad entre el dedo y el pad; duplicar el grosor reduce esa capacidad aproximadamente a la mitad. El vidrio tiene una constante dieléctrica mayor que la mayoría de los plásticos, por lo que un vidrio del mismo grosor suele dar mejores resultados. En la práctica, el módulo suele funcionar sin problemas detrás de un panel de plástico, acrílico o vidrio de 1–3 mm; con paneles más gruesos necesitarás un pad más grande y conviene probar siempre con tu propio material.

• No dejes una cámara de aire: El aire tiene una constante dieléctrica de 1, e incluso un hueco de 1 mm reduce mucho la sensibilidad. Pega el módulo firmemente al panel, con el lado del pad hacia él, usando cinta de doble cara fina o adhesivo.
• Agranda el pad: Para tener una zona táctil más grande, recorta un electrodo de cinta de cobre o papel de aluminio, rasca con cuidado el barniz protector en una esquina del pad y suelda el electrodo con un cable muy corto. Cuanto más largo sea el cable, más capacidad propia añade y más inestable se vuelve el sensor.
• Evita el metal: Los paneles metálicos, los materiales con carga metálica y las pinturas metalizadas concentran el campo eléctrico sobre sí mismos; el sensor o no detecta nada o se dispara solo.
• Reduce el exceso de sensibilidad: Si el sensor se dispara antes de que se acerque el dedo, añade un pequeño condensador cerámico de 5–20 pF (Cs) entre el pad y GND; cuanto mayor sea el valor, menor será la sensibilidad, con 50 pF como límite. Puedes descifrar el código impreso en el condensador (p. ej., 100 = 10 pF, 220 = 22 pF) con la herramienta código de condensadores.
• Primero monta y luego alimenta: Como el chip toma su entorno como referencia al encenderse, conecta la alimentación cuando el panel y la tapa ya estén colocados. Si colocas el panel con el módulo encendido, el chip puede tomarlo como un toque permanente; en ese caso basta con desconectar y volver a conectar la alimentación.

Usar varias teclas táctiles

Cada TTP223 vigila su propio pad de forma independiente; si quieres cuatro teclas, conectas cuatro módulos a cuatro pines digitales distintos, y los módulos comparten VCC y GND. Si las teclas están muy juntas, tu dedo puede afectar también al pad vecino; deja al menos 1–2 cm entre los pads y mantén los módulos lejos de los cables de motores o relés. El programa de abajo usa cuatro TTP223 y un zumbador pasivo para crear un pequeño piano táctil: cada tecla que tocas suena con su nota y el sonido se detiene al levantar el 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 tone() solo puede tocar una nota a la vez, el código elige la primera tecla tocada y solo actualiza la nota cuando cambia, para que el sonido no chisporrotee. En el Uno, tone() usa el Timer2, así que analogWrite no funciona en los pines 3 y 11 mientras suena el zumbador; aquí no es un problema porque el piano solo usa D3 como entrada. Si necesitas muchas teclas, es más ordenado pasar a chips multicanal en lugar de un módulo por tecla: el TTP224 ofrece cuatro teclas con cuatro salidas independientes, el TTP229 lee 8 o 16 teclas mediante una interfaz serie de dos hilos y el MPR121 vigila 12 electrodos por I2C.

ESP32: ¿TTP223 o los pines táctiles integrados?

El ESP32 clásico lleva integrado un sensor táctil capacitivo, y 10 pines (T0–T9) se pueden usar como teclas táctiles sin ningún módulo: GPIO 4, 0, 2, 15, 13, 12, 14, 27, 33 y 32, en ese orden. La función touchRead() devuelve un número en bruto; en el ESP32 clásico ese número baja al tocar, mientras que en el ESP32-S2 y el S3 sube. El ESP32-C3 no tiene sensor táctil. Para ver a fondo los pines integrados, consulta los pines táctiles del ESP32; la tabla de abajo compara las dos opciones.

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}

Al arrancar, este programa mide el valor de T0 sin tocar y usa el 70 % como umbral; observa el valor en bruto en el Monitor Serie (115200 baudios) para ajustar la proporción a tu cableado. Si usas un ESP32-S3, el valor sube al tocar, así que invierte la comparación (por ejemplo, umbral = valor medido × 1,3 y raw > umbral). Otra razón para conectar el TTP223 a GPIO 26 es que es un GPIO RTC: con esp_sleep_enable_ext0_wakeup(GPIO_NUM_26, 1) puedes poner el ESP32 en deep sleep y despertarlo con un toque. Como el TTP223 solo consume unos pocos microamperios, forman una pareja ideal para proyectos con batería; tienes los detalles en deep sleep en el ESP32.

TTP223 con la Raspberry Pi Pico (MicroPython)

El chip RP2040 de la Pico no tiene sensor táctil, así que el TTP223 es la forma más sencilla de añadirle una tecla táctil. Alimenta el módulo desde el pin 3V3(OUT) (pin físico 36) y conecta el pin I/O a GP15 (pin físico 20). El código MicroPython de abajo conmuta el LED integrado de la placa con cada toque. Como captura el toque con una interrupción (IRQ), no se pierde ninguno aunque el bucle principal esté ocupado con otras tareas. Si aún no sabes cómo instalar MicroPython en la Pico, empieza por ¿Qué es la 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)

En las versiones actuales de MicroPython, el nombre Pin("LED") selecciona el LED integrado tanto en la Pico como en la Pico W. Si has soldado el puente B y el módulo está en modo biestable, ni siquiera necesitas la interrupción: basta con escribir led.value(touch.value()) en el bucle, porque ahora es el propio chip quien guarda el estado de encendido y apagado. Aunque la salida del chip no rebota, el bloqueo de 250 ms del código evita que impulsos de ruido cortos en cables largos cambien el LED dos veces.

Ideas de proyectos con el TTP223

• Luz nocturna táctil: Añade un LDR para que la lámpara solo responda al toque cuando esté oscuro.
• Lámpara que cambia de color: Cambia el color de un anillo WS2812B NeoPixel con cada toque y ajusta el brillo con un toque largo.
• Cerradura con clave oculta: Coloca cuatro TTP223 detrás de un panel de acrílico; al tocar las teclas en el orden correcto, un servomotor abre la cerradura.
• Timbre sin agujeros: Pega el sensor dentro de una caja de plástico; al tocarlo, un DFPlayer Mini reproduce el sonido del timbre.
• Interruptor táctil para enchufe: Enciende y apaga una lámpara de escritorio o un ventilador con un módulo de relé.
• Mando a pilas: Mantén un ESP32 en deep sleep; al tocar el TTP223 se despierta y envía una orden por ESP-NOW.

Errores frecuentes y cómo solucionarlos

El TTP223 es la forma más sencilla de añadir una interfaz táctil moderna a tus proyectos con un módulo muy barato: sustituye al pulsador mecánico, funciona detrás de paneles sin agujeros y se entiende con cualquier microcontrolador. Prueba primero a leerlo con la configuración de fábrica y luego afianza la detección de flancos y la lógica del toque largo con los ejemplos de la lámpara y el piano. En la aplicación BlueGrays encontrarás, paso a paso y con esquemas y código, proyectos para encender un LED con un pulsador, un LED de encendido y apagado, proyectos de pulsadores con ESP32 y Pico y el control de una bombilla de red, y podrás convertirlos todos en proyectos táctiles poniendo un TTP223 en lugar del pulsador.