Pin touch ESP32: touchRead, soglia, interrupt e slider capacitivo

I pin touch dell'ESP32 sono GPIO speciali collegati ai sensori tattili capacitivi integrati nel chip. L'ESP32 classico ne ha 10 (T0–T9) e rilevano il tocco su un filo, un pezzo di stagnola o nastro di rame senza alcun modulo aggiuntivo. Basta una sola funzione: touchRead(). Quando il dito si avvicina al pad aggiunge una piccola capacità al circuito, e l'ESP32 ti restituisce questa variazione come numero. Così puoi creare un interruttore touch, un dimmer per luci, uno slider o un pulsante di apertura nascosto senza pulsanti meccanici.

In questa guida vedremo prima quale GPIO corrisponde a quale canale touch e quali è meglio evitare. Poi leggeremo i valori di touchRead, sceglieremo la soglia giusta e scriveremo un pulsante touch affidabile con autocalibrazione e isteresi. Imparerai anche a realizzare pad con stagnola e nastro di rame, a regolare la luminosità di un LED con uno slider a tre pad, a usare gli interrupt con touchAttachInterrupt e a risvegliare l'ESP32 dal deep sleep con un tocco. Le ultime sezioni trattano umidità e disturbi, le differenze dell'ESP32-S3 e un breve esempio in MicroPython.

Come funzionano i pin touch dell'ESP32?

Ogni pin touch è collegato a un circuito di misura dentro il chip. Questo circuito carica e scarica il pin di continuo e conta quanti cicli di carica e scarica si completano in un tempo fisso. Il filo e il pad sul pin si comportano come un piccolo condensatore. Quando avvicini il dito, il tuo corpo aggiunge qualche picofarad a quel condensatore, carica e scarica rallentano e nello stesso tempo si completano meno cicli. Ecco perché sull'ESP32 classico il valore di touchRead scende quando tocchi. Con un filo corto a riposo vedi di solito 40–80; quando lo tocchi con il dito il valore scende a circa 10–25. Questi numeri dipendono da lunghezza del filo, dimensione del pad, scheda e ambiente, quindi non scrivere mai una soglia a memoria: misurala sul tuo montaggio.

Tabella dei pin touch dell'ESP32 (T0–T9)

I canali touch sono collegati solo a certi GPIO; se usi touchRead su un altro pin non ottieni un valore utile. Il core Arduino definisce costanti pronte come T0 e T1 per questi canali, quindi scrivere touchRead(T0) equivale a touchRead(4). Alcuni di questi pin sono pin di strapping, che decidono come si avvia la scheda; funzionano come touch, ma non dovrebbero essere la tua prima scelta.

Realizzare i pad: filo, stagnola e nastro di rame

Qualsiasi superficie conduttiva funziona come pad touch. La più semplice è l'estremità spellata di un cavetto jumper inserito nel pin. Per una superficie più comoda puoi usare un pezzo di stagnola di 2×2 cm o nastro di rame adesivo; il nastro di rame si salda anche, quindi è migliore per i progetti definitivi. Puoi incollare il pad su un cartoncino, all'interno di una scatola di plastica o dietro un pezzo di legno. Il tocco viene rilevato anche attraverso 1–3 mm di plastica, acrilico o vetro; si riduce solo il calo del valore, quindi devi rimisurare la soglia. Tieni corto il filo dal pad all'ESP32: oltre 20–30 cm diventa un'antenna e anche toccare il filo stesso fa scattare il tocco.

Leggere i valori di touchRead e scegliere la soglia

La prima cosa è vedere i numeri reali del tuo montaggio. Lo sketch qui sotto legge otto volte il GPIO 4 (T0) e il GPIO 27 (T7) e stampa la media. Se apri il Plotter seriale dal menu Strumenti dell'IDE Arduino, vedi le due linee in tempo reale e come i valori scendono quando tocchi.

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}

Mentre osservi i valori, annota tre situazioni: pad a riposo, dito sul pad e dito a 1–2 cm dal pad. Per esempio, se leggi 62 a riposo, 14 al tocco e 45 avvicinandoti, una soglia sicura è circa il 60 per cento del valore a riposo, quindi intorno a 37. Con una soglia troppo vicina al valore a riposo scatta già all'avvicinarsi del dito; con una troppo bassa perdi i tocchi leggeri.

Pulsante touch con autocalibrazione

Invece di scrivere un numero fisso come soglia, è molto più affidabile misurare il valore a riposo del pad all'avvio e calcolare la soglia da quello. Lo sketch qui sotto fa la media di 50 letture all'avvio, considera tocco un calo del 40 per cento e cambia lo stato del LED. Considera il pad rilasciato quando il valore torna sopra l'80 per cento del valore a riposo. Usare due soglie separate si chiama isteresi; evita scatti ripetuti quando il valore oscilla proprio sul limite. Se ti interessa la parte meccanica dei pulsanti, leggi l'articolo come collegare un pulsante.

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}

Interrupt touch con touchAttachInterrupt

Invece di chiamare touchRead di continuo, puoi lasciare che l'hardware touch misuri in background e chiami una funzione quando il valore scende sotto una soglia. È ciò che fa touchAttachInterrupt(pin, funzione, soglia). Sull'ESP32 classico l'interrupt scatta quando il valore misurato scende sotto la soglia e si ripete a ogni ciclo di misura finché il dito resta sul pad. Per questo la funzione di interrupt deve solo impostare un flag, mentre il lavoro vero si fa in loop() con un controllo del tempo. Le regole generali degli interrupt sono spiegate nell'articolo interrupt con 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}

In questo esempio la soglia è 40; va bene per un pad che legge circa 60 a riposo, altrimenti cambiala in base ai numeri dello sketch di lettura precedente. L'attributo IRAM_ATTR sulla funzione di interrupt la mette nella memoria veloce; sull'ESP32 è consigliato per le funzioni di interrupt. Per disattivare l'interrupt chiama touchDetachInterrupt(pin). Sull'ESP32 classico puoi anche usare touchInterruptSetThresholdDirection(false) perché l'interrupt scatti quando il valore supera la soglia; è utile per cogliere il momento in cui il dito si solleva.

Slider touch a tre pad

Tre pad in fila bastano per trovare la posizione del dito. Quando il dito è tra due pad, entrambi i valori scendono; guardando quanto è sceso ciascun pad calcoli la posizione con una media pesata. Se tagli i pad a zigzag o a punta di freccia incastrati invece che quadrati, il dito tocca almeno due pad in ogni posizione e lo slider diventa molto più fluido. Tre strisce di nastro di rame larghe 1,5 cm con 1–2 mm di distanza sono un buon inizio.

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}

All'avvio lo sketch salva il valore a riposo di ogni pad e poi a ogni ciclo calcola i cali. Se il calo totale è abbastanza grande, c'è un dito sullo slider e la posizione risulta tra 0 e 1000. Convertiamo questo valore in 0–255 con map() e lo mandiamo al LED con analogWrite(). analogWrite() funziona sia nella versione 2.x sia nella 3.x del core Arduino per ESP32. Trovi come funziona il PWM nell'articolo cos'è il PWM.

Risveglio dal deep sleep con un tocco

In un progetto a batteria puoi mettere l'ESP32 in deep sleep e svegliarlo solo quando qualcuno tocca il pad. In questa modalità i core sono spenti, ma il circuito di misura touch continua a funzionare a basso consumo. La funzione touchSleepWakeUpEnable(pin, soglia) imposta la soglia e attiva il risveglio touch in un colpo solo. Sull'ESP32 classico puoi usare più pad come sorgente di risveglio; su ESP32-S2 e S3 uno solo. Al risveglio, esp_sleep_get_touchpad_wakeup_status() ti dice quale pad ha svegliato la scheda. Abbiamo spiegato dettagli e consumi del deep sleep nell'articolo deep sleep dell'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}

Dopo il risveglio il codice riparte da setup(), perché nel deep sleep la RAM viene cancellata. Per conservare il numero di risvegli abbiamo messo RTC_DATA_ATTR davanti alla variabile; queste variabili stanno nella piccola memoria RTC mantenuta durante il sonno. Poiché la misura touch continua anche nel sonno, il consumo in deep sleep è un po' più alto rispetto al risveglio a timer; tienilo presente quando calcoli l'autonomia della batteria. Il blocco #if nel codice permette allo stesso programma di compilare con la soglia giusta anche su ESP32-S2 e S3.

Pin touch dell'ESP32 con MicroPython

Se hai caricato MicroPython sul tuo ESP32, fai la stessa cosa con la classe TouchPad del modulo machine. Il suo metodo read() restituisce lo stesso valore di touchRead() in Arduino; sull'ESP32 classico scende anche qui al tocco. Per il risveglio si usano esp32.wake_on_touch(True) e il metodo config(soglia) 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)

Il Raspberry Pi Pico non ha un sensore touch capacitivo integrato. Se vuoi un pulsante touch con un Pico o un Arduino Uno, la soluzione più semplice è un modulo TTP223 già pronto; rileva il tocco da solo e ti fornisce un normale segnale digitale.

Umidità, acqua e disturbi

Il rilevamento capacitivo vede l'acqua oltre al dito. Una goccia d'acqua o molta umidità sul pad aumentano la capacità, il valore scende e il pulsante può scattare da solo. Nei progetti per bagno, cucina o esterno, metti il pad dietro una superficie che non trattiene l'acqua, scegli una soglia un po' più bassa e richiedi che il tocco duri almeno 50–100 ms. Anche fili lunghi, relè e motori vicini e un cattivo alimentatore USB fanno oscillare i valori. La tabella riassume i problemi più comuni e le soluzioni.

Pin touch su ESP32-S3 e altri modelli

ESP32-S2 ed ESP32-S3 usano un hardware touch di seconda generazione e differiscono dall'ESP32 classico in tre punti importanti. Primo, i canali sono sui GPIO 1–14 e sono 14; T1 è il GPIO 1 e T14 il GPIO 14. Secondo, i valori sono molto più grandi e salgono al tocco; un pad che legge circa 20.000 a riposo può superare 40.000 quando lo tocchi. Terzo, la soglia di touchAttachInterrupt e touchSleepWakeUpEnable non è un valore assoluto ma un aumento rispetto al valore a riposo. Sull'S3 puoi anche sapere con touchInterruptGetLastStatus(pin) se il pad è ancora premuto. ESP32-C3 ed ESP32-C6 non hanno alcun sensore touch. Se scrivi codice per più modelli, separali con CONFIG_IDF_TARGET_ESP32 come nell'esempio del risveglio.

Idee di progetto con i pin touch

• Lampada da scrivania: un interruttore invisibile in nastro di rame incollato dietro un pannello di legno, con tocco lungo per regolare la luminosità.
• Dimmer a slider: cambia luminosità e colore di una striscia di LED WS2812B con uno slider a tre pad.
• Campanello o blocco note a batteria: l'ESP32 aspetta in deep sleep, si sveglia al tocco del pad e invia una notifica via Wi-Fi.
• Pianoforte di frutta: un giocattolo con fili collegati a banane e mele che suona una nota diversa per ogni frutto; il suono può farlo un buzzer.
• Tastierino segreto: una serratura che si apre quando quattro pad nascosti in una scatola vengono toccati nell'ordine giusto.

I pin touch dell'ESP32 danno al tuo progetto un'interfaccia touch con qualche centimetro di stagnola e poche righe di codice. Nell'app BlueGrays trovi progetti come accendere un LED con l'ESP32, controllare un LED con un pulsante, la luminosità di un LED con il PWM e il deep sleep, ognuno con schema e codice passo per passo; sostituisci i pulsanti con i pad touch di questa guida e crea la tua versione.