Broches tactiles ESP32 : touchRead, seuil, interruption, slider

Les broches tactiles de l'ESP32 (touch pins) sont des GPIO spéciaux reliés aux capteurs tactiles capacitifs intégrés à la puce. L'ESP32 classique en a 10 (T0–T9), et elles détectent que tu touches un fil, un morceau de papier aluminium ou du ruban de cuivre sans aucun module supplémentaire. Une seule fonction suffit : touchRead(). Quand ton doigt s'approche du pad, il ajoute une petite capacité au circuit, et l'ESP32 te donne cette variation sous forme de nombre. Tu peux ainsi faire un interrupteur tactile, un variateur de lumière, un slider ou un bouton d'ouverture caché sans bouton-poussoir mécanique.

Dans ce guide, on voit d'abord quel GPIO est relié à quel canal tactile et lesquels éviter. Ensuite, on lit les valeurs de touchRead, on choisit le bon seuil et on écrit un bouton tactile fiable avec autocalibrage et hystérésis. Tu apprendras aussi à fabriquer des pads en papier aluminium et ruban de cuivre, à régler la luminosité d'une LED avec un slider à trois pads, à utiliser les interruptions avec touchAttachInterrupt et à réveiller l'ESP32 du deep sleep d'un simple toucher. Les dernières parties traitent de l'humidité et des parasites, des différences de l'ESP32-S3 et d'un court exemple en MicroPython.

Comment fonctionnent les broches tactiles de l'ESP32 ?

Chaque broche tactile est reliée à un circuit de mesure dans la puce. Ce circuit charge et décharge la broche en permanence et compte combien de cycles de charge et décharge se terminent en un temps donné. Le fil et le pad reliés à la broche se comportent comme un petit condensateur. Quand tu approches le doigt, ton corps ajoute quelques picofarads à ce condensateur, la charge et la décharge ralentissent et moins de cycles se terminent dans le même temps. C'est pourquoi, sur l'ESP32 classique, la valeur de touchRead baisse quand tu touches. Avec un fil court, tu vois en général 40 à 80 au repos ; quand tu le touches du doigt, la valeur tombe vers 10 à 25. Ces chiffres dépendent de la longueur du fil, de la taille du pad, de la carte et de l'environnement : n'écris donc jamais un seuil de mémoire, mesure-le sur ton propre montage.

Tableau des broches tactiles de l'ESP32 (T0–T9)

Les canaux tactiles ne sont reliés qu'à certains GPIO ; si tu utilises touchRead sur une autre broche, tu n'obtiendras pas de valeur exploitable. Le cœur Arduino définit des constantes toutes prêtes comme T0 et T1 pour ces canaux : écrire touchRead(T0) revient donc à écrire touchRead(4). Certaines de ces broches sont des broches de strapping, qui déterminent la façon dont la carte démarre ; elles fonctionnent en tactile, mais ne devraient pas être ton premier choix.

Fabriquer des pads : fil, papier aluminium et ruban de cuivre

Toute surface conductrice peut servir de pad tactile. Le plus simple est l'extrémité dénudée d'un fil de liaison branché sur la broche. Pour une surface plus agréable, tu peux utiliser un morceau de papier aluminium de 2×2 cm ou du ruban de cuivre adhésif ; le ruban de cuivre se soude aussi, il est donc préférable pour les projets définitifs. Tu peux coller le pad sur du carton, à l'intérieur d'un boîtier en plastique ou au dos d'un morceau de bois. Le toucher est aussi détecté à travers 1 à 3 mm de plastique, d'acrylique ou de verre ; la baisse de valeur est simplement plus faible, il faut donc remesurer le seuil. Garde le fil entre le pad et l'ESP32 court : au-delà de 20 à 30 cm, il devient une antenne, et toucher le fil lui-même déclenche aussi.

Lire les valeurs de touchRead et fixer un seuil

Première étape : voir les vrais chiffres de ton montage. Le sketch ci-dessous lit huit fois le GPIO 4 (T0) et le GPIO 27 (T7) et affiche la moyenne. Si tu ouvres le traceur série depuis le menu Outils de l'IDE Arduino, tu vois les deux courbes en direct et la façon dont les valeurs chutent au toucher.

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}

En observant les valeurs, note trois situations : pad au repos, doigt sur le pad et doigt à 1–2 cm du pad. Par exemple, si tu lis 62 au repos, 14 au toucher et 45 à l'approche, un seuil sûr est d'environ 60 pour cent de la valeur au repos, soit autour de 37. Un seuil trop proche de la valeur au repos déclenche dès que le doigt approche ; un seuil trop bas rate les touchers légers.

Bouton tactile avec autocalibrage

Plutôt que d'écrire un nombre fixe comme seuil, il est bien plus fiable de mesurer la valeur au repos du pad au démarrage et d'en déduire le seuil. Le sketch ci-dessous fait la moyenne de 50 mesures au démarrage, considère une baisse de 40 pour cent comme un toucher et inverse l'état de la LED. Il considère le pad relâché quand la valeur repasse au-dessus de 80 pour cent de la valeur au repos. Utiliser deux seuils distincts s'appelle l'hystérésis ; cela évite les déclenchements répétés quand la valeur tremble juste à la limite. Si la partie mécanique des boutons t'intéresse, lis l'article brancher un bouton-poussoir.

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}

Interruption tactile avec touchAttachInterrupt

Au lieu d'appeler touchRead en permanence, tu peux laisser le matériel tactile mesurer en arrière-plan et appeler une fonction quand la valeur passe sous un seuil. C'est le rôle de touchAttachInterrupt(broche, fonction, seuil). Sur l'ESP32 classique, l'interruption se déclenche quand la valeur mesurée passe sous le seuil, et elle revient à chaque cycle de mesure tant que le doigt reste sur le pad. La fonction d'interruption doit donc seulement lever un drapeau, et le vrai travail se fait dans loop() avec un contrôle de temps. On a expliqué les règles générales des interruptions dans l'article interruptions 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}

Dans cet exemple, le seuil vaut 40 ; il convient à un pad qui lit environ 60 au repos, sinon adapte-le aux chiffres du sketch de lecture précédent. L'attribut IRAM_ATTR placé devant la fonction d'interruption la range en mémoire rapide ; il est recommandé pour les fonctions d'interruption de l'ESP32. Pour désactiver l'interruption, appelle touchDetachInterrupt(broche). Sur l'ESP32 classique, touchInterruptSetThresholdDirection(false) permet aussi de déclencher l'interruption quand la valeur dépasse le seuil ; pratique pour saisir le moment où le doigt se lève.

Slider tactile à trois pads

Trois pads alignés suffisent pour trouver la position du doigt. Quand le doigt est entre deux pads, les deux valeurs baissent ; en regardant de combien chaque pad a baissé, tu calcules la position avec une moyenne pondérée. Si tu découpes les pads en zigzag ou en chevrons imbriqués plutôt qu'en carrés, le doigt touche au moins deux pads à chaque position et le slider devient beaucoup plus fluide. Trois bandes de ruban de cuivre de 1,5 cm de large espacées de 1 à 2 mm sont un bon départ.

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}

Au démarrage, le sketch enregistre la valeur au repos de chaque pad, puis calcule les baisses à chaque passage dans la boucle. Si la baisse totale est assez grande, un doigt est sur le slider et la position est trouvée entre 0 et 1000. On convertit cette valeur en 0–255 avec map() et on l'envoie à la LED avec analogWrite(). analogWrite() fonctionne dans les versions 2.x et 3.x du cœur Arduino pour ESP32. Tu trouveras le fonctionnement du PWM dans l'article qu'est-ce que le PWM.

Réveiller l'ESP32 du deep sleep par un toucher

Dans un projet sur batterie, tu peux mettre l'ESP32 en deep sleep et ne le réveiller que lorsque quelqu'un touche le pad. Dans ce mode, les cœurs sont éteints, mais le circuit de mesure tactile continue de fonctionner à faible consommation. La fonction touchSleepWakeUpEnable(broche, seuil) règle le seuil et active le réveil tactile en une fois. Sur l'ESP32 classique, plusieurs pads peuvent servir de source de réveil ; sur l'ESP32-S2 et le S3, un seul. Au réveil, esp_sleep_get_touchpad_wakeup_status() t'indique quel pad a réveillé la carte. On détaille le deep sleep et ses consommations dans l'article deep sleep de l'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}

Au réveil, le code repart de setup(), car la RAM est effacée en deep sleep. Pour garder le nombre de réveils, on a placé RTC_DATA_ATTR devant la variable ; ces variables sont stockées dans la petite mémoire RTC conservée pendant le sommeil. Comme la mesure tactile continue pendant le sommeil, la consommation en deep sleep est un peu plus élevée qu'avec un réveil par minuterie ; tiens-en compte pour estimer l'autonomie. Le bloc #if du code permet au même programme de compiler avec le bon seuil sur l'ESP32-S2 et le S3.

Broches tactiles de l'ESP32 avec MicroPython

Si tu as installé MicroPython sur ton ESP32, tu fais la même chose avec la classe TouchPad du module machine. Sa méthode read() renvoie la même valeur que touchRead() sous Arduino ; sur l'ESP32 classique, elle baisse aussi au toucher. Pour le réveil, on utilise esp32.wake_on_touch(True) et la méthode config(seuil) du 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)

Le Raspberry Pi Pico n'a pas de capteur tactile capacitif intégré. Pour un bouton tactile avec un Pico ou un Arduino Uno, la solution la plus simple est un module TTP223 tout prêt ; il détecte le toucher lui-même et te fournit un signal numérique ordinaire.

Humidité, eau et parasites

La détection capacitive voit l'eau aussi bien que le doigt. Une goutte d'eau ou une forte humidité sur le pad augmente la capacité, la valeur baisse et le bouton peut se déclencher tout seul. Pour un projet de salle de bains, de cuisine ou d'extérieur, place le pad derrière une surface qui ne retient pas l'eau, choisis un seuil un peu plus bas et exige que le toucher dure au moins 50 à 100 ms. Les fils longs, les relais et moteurs proches et une mauvaise alimentation USB font aussi varier les valeurs. Le tableau résume les problèmes les plus courants et leurs solutions.

Broches tactiles sur l'ESP32-S3 et les autres modèles

L'ESP32-S2 et l'ESP32-S3 utilisent un matériel tactile de deuxième génération et se distinguent de l'ESP32 classique sur trois points importants. D'abord, les canaux sont sur les GPIO 1 à 14 et il y en a 14 ; T1 est le GPIO 1 et T14 le GPIO 14. Ensuite, les valeurs sont bien plus grandes et montent au toucher ; un pad qui lit environ 20 000 au repos peut dépasser 40 000 quand on le touche. Enfin, le seuil de touchAttachInterrupt et de touchSleepWakeUpEnable n'est pas une valeur absolue mais une hausse par rapport à la valeur au repos. Sur le S3, touchInterruptGetLastStatus(broche) indique aussi si le pad est toujours appuyé. L'ESP32-C3 et l'ESP32-C6 n'ont aucun capteur tactile. Si ton code vise plusieurs modèles, sépare-les avec CONFIG_IDF_TARGET_ESP32 comme dans l'exemple de réveil.

Idées de projets avec les broches tactiles

• Lampe de bureau : un interrupteur invisible en ruban de cuivre collé derrière un cache en bois, avec un appui long pour régler la luminosité.
• Variateur à slider : change la luminosité et la couleur d'un ruban de LED WS2812B avec un slider à trois pads.
• Sonnette ou bloc-notes sur batterie : l'ESP32 attend en deep sleep, se réveille quand on touche le pad et envoie une notification en Wi-Fi.
• Piano à fruits : un jouet avec des fils reliés à des bananes et des pommes qui joue une note différente pour chaque fruit ; un buzzer peut produire le son.
• Clavier secret : une serrure qui s'ouvre quand on touche dans le bon ordre quatre pads cachés dans une boîte.

Les broches tactiles de l'ESP32 donnent à ton projet une interface tactile avec quelques centimètres de papier aluminium et quelques lignes de code. Dans l'application BlueGrays, tu trouveras des projets comme allumer une LED avec l'ESP32, commander une LED avec un bouton, régler la luminosité d'une LED en PWM et le deep sleep, chacun avec schéma et code pas à pas ; remplace les boutons par les pads tactiles de ce guide pour créer ta propre version.