Pines táctiles ESP32: touchRead, umbral, interrupción y slider

Los pines táctiles del ESP32 (touch pins) son GPIO especiales conectados a los sensores táctiles capacitivos integrados en el chip. El ESP32 clásico tiene 10 (T0–T9) y detectan que tocas un cable, un trozo de papel de aluminio o cinta de cobre sin ningún módulo adicional. Basta con una sola función: touchRead(). Cuando tu dedo se acerca al pad, añade una pequeña capacidad al circuito y el ESP32 te entrega ese cambio como un número. Así puedes hacer un interruptor táctil, un regulador de luz, un slider o un botón de apertura oculto sin pulsador mecánico.

En esta guía veremos primero qué GPIO corresponde a cada canal táctil y cuáles conviene evitar. Después leeremos los valores de touchRead, elegiremos el umbral correcto y escribiremos un botón táctil robusto con autocalibración e histéresis. También aprenderás a hacer pads con papel de aluminio y cinta de cobre, a regular el brillo de un LED con un slider de tres pads, a usar interrupciones con touchAttachInterrupt y a despertar el ESP32 del deep sleep con un toque. Las últimas secciones tratan los problemas de humedad y ruido, las diferencias del ESP32-S3 y un ejemplo corto en MicroPython.

¿Cómo funcionan los pines táctiles del ESP32?

Cada pin táctil está conectado a un circuito de medida dentro del chip. Este circuito carga y descarga el pin continuamente y cuenta cuántos ciclos de carga y descarga se completan en un tiempo fijo. El cable y el pad conectados al pin se comportan como un pequeño condensador. Cuando acercas el dedo, tu cuerpo añade unos pocos picofaradios a ese condensador, la carga y la descarga se ralentizan y se completan menos ciclos en el mismo tiempo. Por eso en el ESP32 clásico el valor de touchRead baja al tocar. Con un cable corto sueles ver entre 40 y 80 en reposo; al tocarlo con el dedo el valor cae a unos 10–25. Estos números dependen de la longitud del cable, el tamaño del pad, la placa y el entorno, así que nunca escribas un umbral de memoria: mídelo en tu propio montaje.

Tabla de pines táctiles del ESP32 (T0–T9)

Los canales táctiles solo están conectados a ciertos GPIO; si usas touchRead en otro pin no obtendrás un valor útil. El núcleo de Arduino define constantes como T0 y T1 para estos canales, así que escribir touchRead(T0) es lo mismo que touchRead(4). Algunos de estos pines son pines de strapping, que deciden cómo arranca la placa; funcionan como táctiles, pero no deberían ser tu primera opción.

Hacer pads: cable, papel de aluminio y cinta de cobre

Cualquier superficie conductora sirve como pad táctil. Lo más sencillo es el extremo pelado de un cable jumper conectado al pin. Para una superficie más cómoda puedes usar un trozo de 2×2 cm de papel de aluminio o cinta de cobre adhesiva; la cinta de cobre además se puede soldar, así que es mejor para proyectos permanentes. Puedes pegar el pad a un cartón, al interior de una caja de plástico o detrás de una pieza de madera. El toque también se detecta a través de 1–3 mm de plástico, acrílico o vidrio; solo se reduce la caída del valor, así que tendrás que medir el umbral de nuevo. Mantén corto el cable del pad al ESP32: los cables de más de 20–30 cm se convierten en antenas y tocar el propio cable también dispara.

Leer los valores de touchRead y fijar el umbral

Lo primero es ver los números reales de tu montaje. El siguiente sketch lee ocho veces GPIO 4 (T0) y GPIO 27 (T7) e imprime la media. Si abres el Serial Plotter desde el menú Herramientas del IDE de Arduino, verás las dos líneas en directo y cómo bajan los valores al tocar.

1// ESP32 dokunmatik değer okuma / ESP32 touch value reading
2// GPIO 4 = T0, GPIO 27 = T7
3
4void setup() {
5  Serial.begin(115200);
6  delay(500);
7}
8
9void loop() {
10  uint32_t t0 = 0, t7 = 0;
11  for (int i = 0; i < 8; i++) {      // 8 ölçümün ortalaması / average of 8 readings
12    t0 += touchRead(T0);
13    t7 += touchRead(T7);
14  }
15  Serial.print("T0:");
16  Serial.print(t0 / 8);
17  Serial.print(" T7:");
18  Serial.println(t7 / 8);            // Seri Çizici için / for the Serial Plotter
19  delay(100);
20}

Mientras miras los valores, anota tres situaciones: pad en reposo, dedo sobre el pad y dedo a 1–2 cm del pad. Por ejemplo, si lees 62 en reposo, 14 al tocar y 45 al acercarte, un umbral seguro es aproximadamente el 60 por ciento del valor en reposo, es decir, unos 37. Si pones el umbral demasiado cerca del valor en reposo, saltará al acercar el dedo; si lo pones demasiado bajo, perderás los toques suaves.

Botón táctil con autocalibración

En lugar de escribir un número fijo como umbral, es mucho más fiable medir el valor en reposo del pad al arrancar y calcular el umbral a partir de él. El sketch de abajo promedia 50 lecturas al arrancar, considera toque una caída del 40 por ciento y cambia el estado del LED. Considera que se ha soltado cuando el valor vuelve a superar el 80 por ciento del valor en reposo. Usar dos umbrales distintos se llama histéresis; evita disparos repetidos cuando el valor tiembla justo en el límite. Si te interesa la parte mecánica de los pulsadores, consulta el artículo cómo conectar un pulsador.

1// Otomatik kalibrasyonlu dokunmatik buton / self-calibrating touch button
2// GPIO 4 (T0) dokunma pedi, GPIO 2 kart üstü LED
3// GPIO 4 (T0) touch pad, GPIO 2 onboard LED
4
5const uint8_t DOKUNMA_PIN = T0;   // GPIO 4
6const uint8_t LED_PIN = 2;
7
8uint32_t bosDeger = 0;            // dokunulmamış değer / untouched value
9uint32_t basEsik, birakEsik;      // histerezisli eşikler / thresholds with hysteresis
10bool basili = false;
11bool ledDurum = false;
12
13uint32_t ortalamaOku(uint8_t pin, int adet) {
14  uint32_t toplam = 0;
15  for (int i = 0; i < adet; i++) {
16    toplam += touchRead(pin);
17    delay(2);
18  }
19  return toplam / adet;
20}
21
22void setup() {
23  Serial.begin(115200);
24  pinMode(LED_PIN, OUTPUT);
25  delay(300);                                  // açılışta pede dokunma / do not touch at boot
26  bosDeger = ortalamaOku(DOKUNMA_PIN, 50);
27  basEsik = bosDeger * 60 / 100;               // %40 düşüş = dokunma / 40% drop = touch
28  birakEsik = bosDeger * 80 / 100;             // %20 altına dönünce bırakıldı / released
29  Serial.printf("Bos: %u  Bas: %u  Birak: %u\n", bosDeger, basEsik, birakEsik);
30}
31
32void loop() {
33  uint32_t deger = ortalamaOku(DOKUNMA_PIN, 4);
34
35  if (!basili && deger < basEsik) {            // yeni dokunma / new touch
36    basili = true;
37    ledDurum = !ledDurum;
38    digitalWrite(LED_PIN, ledDurum);
39    Serial.println("Dokunuldu / touched");
40  } else if (basili && deger > birakEsik) {    // parmak çekildi / finger lifted
41    basili = false;
42  }
43  delay(20);
44}

Interrupción táctil con touchAttachInterrupt

En lugar de llamar a touchRead todo el rato, puedes dejar que el hardware táctil mida en segundo plano y llame a una función cuando el valor baje de un umbral. Eso es lo que hace touchAttachInterrupt(pin, función, umbral). En el ESP32 clásico la interrupción salta cuando el valor medido cae por debajo del umbral y se repite en cada ciclo de medida mientras el dedo siga en el pad. Por eso la función de interrupción solo debe activar una bandera y el trabajo real se hace en loop() con un control de tiempo. Explicamos las reglas generales de las interrupciones en el artículo interrupciones en Arduino.

1// touchAttachInterrupt ile dokunma kesmesi / touch interrupt
2// GPIO 27 (T7) pedi; eşik touchRead ile ölçülerek seçilmeli
3// GPIO 27 (T7) pad; pick the threshold from your touchRead values
4
5const uint8_t PED = T7;            // GPIO 27
6const uint16_t ESIK = 40;          // ESP32: değer bunun ALTINA inince tetikler / fires below this
7volatile bool dokunuldu = false;
8
9void IRAM_ATTR dokunmaKesmesi() {
10  dokunuldu = true;                // kesmede yalnız bayrak / only set a flag in the ISR
11}
12
13void setup() {
14  Serial.begin(115200);
15  touchAttachInterrupt(PED, dokunmaKesmesi, ESIK);
16}
17
18void loop() {
19  static unsigned long sonDokunma = 0;
20  if (dokunuldu) {
21    dokunuldu = false;
22    // Parmak durdukça kesme tekrar tekrar gelir; 300 ms'de bir say
23    // The ISR repeats while the finger stays; count once per 300 ms
24    if (millis() - sonDokunma > 300) {
25      sonDokunma = millis();
26      Serial.printf("Dokunma! deger: %u\n", touchRead(PED));
27    }
28  }
29}

En este ejemplo el umbral es 40; sirve para un pad que lee unos 60 en reposo; si no, cámbialo según los números del sketch de lectura anterior. El atributo IRAM_ATTR de la función de interrupción la coloca en memoria rápida; se recomienda en las funciones de interrupción del ESP32. Para desactivar la interrupción, llama a touchDetachInterrupt(pin). En el ESP32 clásico también puedes usar touchInterruptSetThresholdDirection(false) para que la interrupción salte cuando el valor supere el umbral; es útil para captar el momento en que se levanta el dedo.

Slider táctil de tres pads

Tres pads en fila bastan para saber dónde está tu dedo. Cuando el dedo está entre dos pads, los dos valores bajan; mirando cuánto ha bajado cada pad calculas la posición con una media ponderada. Si cortas los pads en forma de zigzag o de punta de flecha entrelazados en vez de cuadrados, el dedo toca al menos dos pads en cualquier posición y el slider va mucho más suave. Tres tiras de cinta de cobre de 1,5 cm de ancho con 1–2 mm de separación son un buen comienzo.

1// Üç pedli dokunmatik kaydırıcı ile LED parlaklığı / 3-pad touch slider dims an LED
2// Pedler: GPIO 13 (T4), GPIO 14 (T6), GPIO 33 (T8); LED: GPIO 26
3// Pads: GPIO 13 (T4), GPIO 14 (T6), GPIO 33 (T8); LED: GPIO 26
4
5const uint8_t pedler[3] = {T4, T6, T8};
6const uint8_t LED_PIN = 26;
7uint32_t bos[3];                   // her pedin boştaki değeri / idle value of each pad
8int parlaklik = 0;
9
10uint32_t oku(uint8_t pin) {
11  uint32_t t = 0;
12  for (int i = 0; i < 4; i++) t += touchRead(pin);
13  return t / 4;
14}
15
16void setup() {
17  Serial.begin(115200);
18  delay(300);
19  for (int p = 0; p < 3; p++) {
20    uint32_t t = 0;
21    for (int i = 0; i < 32; i++) t += touchRead(pedler[p]);
22    bos[p] = t / 32;
23  }
24}
25
26void loop() {
27  long fark[3];
28  long toplam = 0;
29  for (int p = 0; p < 3; p++) {
30    fark[p] = (long)bos[p] - (long)oku(pedler[p]);   // dokununca değer düşer / value drops on touch
31    if (fark[p] < 0) fark[p] = 0;
32    toplam += fark[p];
33  }
34
35  // Toplam düşüş boştaki değerin %25'ini geçerse parmak var
36  // A finger is present if the total drop exceeds 25% of an idle value
37  if (toplam > (long)bos[1] / 4) {
38    // Ağırlıklı ortalama: ped A = 0, ped B = 500, ped C = 1000
39    // Weighted average: pad A = 0, pad B = 500, pad C = 1000
40    long konum = (fark[1] * 500L + fark[2] * 1000L) / toplam;
41    parlaklik = map(konum, 0, 1000, 0, 255);
42    analogWrite(LED_PIN, parlaklik);
43    Serial.printf("Konum: %ld  Parlaklik: %d\n", konum, parlaklik);
44  }
45  delay(30);
46}

Al arrancar, el sketch guarda el valor en reposo de cada pad y en cada vuelta calcula las caídas. Si la caída total es suficiente, hay un dedo sobre el slider y la posición queda entre 0 y 1000. Convertimos ese valor a 0–255 con map() y lo enviamos al LED con analogWrite(). analogWrite() funciona tanto en la versión 2.x como en la 3.x del núcleo Arduino para ESP32. Encontrarás cómo funciona el PWM en el artículo qué es PWM.

Despertar del deep sleep con un toque

En un proyecto con batería puedes poner el ESP32 en deep sleep y despertarlo solo cuando alguien toque el pad. En este modo los núcleos están apagados, pero el circuito de medida táctil sigue funcionando con poco consumo. La función touchSleepWakeUpEnable(pin, umbral) fija el umbral y activa el despertar táctil de una vez. En el ESP32 clásico puedes usar varios pads como fuente de despertar; en el ESP32-S2 y S3 solo uno. Al despertar, esp_sleep_get_touchpad_wakeup_status() te dice qué pad despertó la placa. Contamos los detalles y consumos del deep sleep en el artículo deep sleep del ESP32.

1// Dokunarak deep sleep'ten uyanma / wake from deep sleep by touch
2// GPIO 27 (T7) pedi / GPIO 27 (T7) pad
3
4#if CONFIG_IDF_TARGET_ESP32
5  #define ESIK 40      // ESP32: değer bunun altına inerse uyanır / wakes below this value
6#else
7  #define ESIK 5000    // ESP32-S2/S3: boştaki değere göre artış / rise above the baseline
8#endif
9
10RTC_DATA_ATTR int uyanmaSayisi = 0;   // uykuda korunur / kept during deep sleep
11
12void setup() {
13  Serial.begin(115200);
14  delay(500);
15  uyanmaSayisi++;
16
17  if (esp_sleep_get_wakeup_cause() == ESP_SLEEP_WAKEUP_TOUCHPAD) {
18    Serial.printf("Dokunmayla uyandi, ped: %d\n", (int)esp_sleep_get_touchpad_wakeup_status());
19  } else {
20    Serial.println("Ilk acilis ya da baska neden / first boot or other cause");
21  }
22  Serial.printf("Uyanma sayisi: %d\n", uyanmaSayisi);
23
24  // Burada ölçüm yap, veri gönder... / take readings, send data here...
25  delay(2000);
26
27  touchSleepWakeUpEnable(T7, ESIK);   // T7 pedini uyandırma kaynağı yap / enable T7 as wake source
28  Serial.println("Uyuyorum / going to sleep");
29  Serial.flush();
30  esp_deep_sleep_start();
31}
32
33void loop() {
34}

Tras despertar, el código vuelve a empezar desde setup(), porque la RAM se borra en deep sleep. Para conservar el número de despertares pusimos RTC_DATA_ATTR delante de la variable; estas variables viven en la pequeña memoria RTC que se mantiene durante el sueño. Como la medida táctil sigue activa mientras duerme, el consumo en deep sleep es algo mayor que al despertar por temporizador; tenlo en cuenta al calcular la duración de la batería. El bloque #if del código permite que el mismo programa compile con el umbral correcto también en el ESP32-S2 y S3.

Pines táctiles del ESP32 con MicroPython

Si has cargado MicroPython en tu ESP32, haces lo mismo con la clase TouchPad del módulo machine. Su método read() devuelve el mismo valor que touchRead() en Arduino; en el ESP32 clásico también baja al tocar. Para despertar se usan esp32.wake_on_touch(True) y el método config(umbral) del pad.

1# ESP32 MicroPython dokunmatik pin / ESP32 MicroPython touch pin
2from machine import Pin, TouchPad
3import time
4
5ped = TouchPad(Pin(4))       # GPIO 4 = T0
6led = Pin(2, Pin.OUT)        # kart üstü LED / onboard LED
7
8bos = sum(ped.read() for _ in range(20)) // 20   # dokunulmamış değer / idle value
9esik = bos * 6 // 10
10basili = False
11
12while True:
13    deger = ped.read()
14    if not basili and deger < esik:
15        basili = True
16        led.value(not led.value())   # her dokunuşta LED'i değiştir / toggle on every touch
17        print("dokunuldu", deger)
18    elif basili and deger > bos * 8 // 10:
19        basili = False
20    time.sleep_ms(30)

La Raspberry Pi Pico no tiene sensor táctil capacitivo integrado. Si quieres un botón táctil con una Pico o un Arduino Uno, la solución más sencilla es un módulo TTP223; detecta el toque por sí mismo y te da una señal digital normal.

Humedad, agua y ruido

La detección capacitiva detecta el agua además del dedo. Una gota de agua o mucha humedad sobre el pad aumenta la capacidad, el valor baja y el botón puede dispararse solo. En proyectos de baño, cocina o exterior, coloca el pad detrás de una superficie que no retenga agua, elige un umbral algo más bajo y exige que el toque dure al menos 50–100 ms. Los cables largos, los relés y motores cercanos y una mala fuente USB también hacen oscilar los valores. La tabla resume los problemas más comunes y sus soluciones.

Pines táctiles en el ESP32-S3 y otros modelos

El ESP32-S2 y el ESP32-S3 usan hardware táctil de segunda generación y se diferencian del ESP32 clásico en tres puntos importantes. Primero, los canales están en GPIO 1–14 y son 14; T1 es GPIO 1 y T14 es GPIO 14. Segundo, los valores son mucho mayores y suben al tocar; un pad que lee unos 20.000 en reposo puede superar 40.000 al tocarlo. Tercero, el umbral de touchAttachInterrupt y touchSleepWakeUpEnable no es un valor absoluto, sino un aumento respecto al valor en reposo. En el S3 también puedes saber con touchInterruptGetLastStatus(pin) si el pad sigue pulsado. El ESP32-C3 y el ESP32-C6 no tienen sensor táctil. Si escribes código para varios modelos, sepáralos con CONFIG_IDF_TARGET_ESP32 como en el ejemplo de despertar.

Ideas de proyectos con pines táctiles

• Lámpara de escritorio: un interruptor invisible de cinta de cobre pegado tras una tapa de madera, con toque largo para regular el brillo.
• Regulador con slider: cambia el brillo y el color de una tira de LED WS2812B con un slider de tres pads.
• Timbre o dispositivo de notas con batería: el ESP32 espera en deep sleep, despierta al tocar el pad y envía una notificación por Wi-Fi.
• Piano de frutas: un juguete con cables a plátanos y manzanas que toca una nota distinta en cada fruta; un zumbador puede hacer el sonido.
• Panel de código oculto: una cerradura que se abre cuando se tocan en el orden correcto cuatro pads escondidos dentro de una caja.

Los pines táctiles del ESP32 dan a tu proyecto una interfaz táctil con unos centímetros de papel de aluminio y unas pocas líneas de código. En la app BlueGrays encontrarás proyectos como encender un LED con el ESP32, controlar un LED con un pulsador, el brillo de un LED con PWM y el deep sleep, cada uno con esquema y código paso a paso; cambia los pulsadores por los pads táctiles de esta guía y crea tu propia versión.