ESP32 Touch Pins: touchRead, Schwellwert, Interrupt und Slider

Die ESP32 Touch-Pins sind spezielle GPIOs, die mit den im Chip eingebauten kapazitiven Berührungssensoren verbunden sind. Der klassische ESP32 hat 10 davon (T0–T9), und sie erkennen eine Berührung an einem Draht, einem Stück Alufolie oder Kupferband ganz ohne Zusatzmodul. Eine einzige Funktion genügt: touchRead(). Nähert sich dein Finger dem Pad, fügt er der Schaltung eine kleine Kapazität hinzu, und der ESP32 liefert dir diese Änderung als Zahl. So baust du einen Touch-Schalter, einen Lichtdimmer, einen Slider oder einen versteckten Öffner, ganz ohne mechanischen Taster.

In dieser Anleitung sehen wir uns zuerst an, welcher GPIO mit welchem Touch-Kanal verbunden ist und von welchen du besser die Finger lässt. Dann lesen wir touchRead-Werte aus, bestimmen den richtigen Schwellwert und schreiben einen robusten Touch-Taster mit automatischer Kalibrierung und Hysterese. Außerdem lernst du, Pads aus Folie und Kupferband zu bauen, mit einem Slider aus drei Pads die Helligkeit einer LED einzustellen, Interrupts mit touchAttachInterrupt zu nutzen und den ESP32 durch Berühren aus dem Deep Sleep zu wecken. In den letzten Abschnitten geht es um Feuchtigkeit und Störungen, die Unterschiede beim ESP32-S3 und ein kurzes MicroPython-Beispiel.

Wie funktionieren die Touch-Pins des ESP32?

Jeder Touch-Pin ist mit einer Messschaltung im Chip verbunden. Diese Schaltung lädt und entlädt den Pin ständig und zählt, wie viele Lade-Entlade-Zyklen in einer festen Zeit abgeschlossen werden. Draht und Pad am Pin verhalten sich wie ein kleiner Kondensator. Bringst du den Finger in die Nähe, fügt dein Körper diesem Kondensator einige Pikofarad hinzu, Laden und Entladen werden langsamer, und in derselben Zeit werden weniger Zyklen fertig. Deshalb gilt beim klassischen ESP32: Bei Berührung sinkt der touchRead-Wert. Mit einem kurzen Draht siehst du im Ruhezustand meist 40–80; berührst du ihn mit dem Finger, fällt der Wert auf etwa 10–25. Diese Zahlen hängen von Drahtlänge, Padgröße, Board und Umgebung ab, also schreib einen Schwellwert nie aus dem Gedächtnis in den Code, sondern miss ihn an deinem eigenen Aufbau.

ESP32 Touch-Pin-Tabelle (T0–T9)

Die Touch-Kanäle sind nur mit bestimmten GPIOs verbunden; verwendest du touchRead an einem anderen Pin, bekommst du keinen sinnvollen Wert. Der Arduino-Core definiert für diese Kanäle fertige Konstanten wie T0 und T1, touchRead(T0) im Code ist also dasselbe wie touchRead(4). Einige dieser Pins sind Strapping-Pins, die beim Booten festlegen, wie das Board startet; sie funktionieren als Touch-Pins, sollten aber nicht deine erste Wahl sein.

Pads bauen: Draht, Alufolie und Kupferband

Jede leitfähige Fläche taugt als Touch-Pad. Am einfachsten ist das blanke Ende eines Jumperkabels im Pin. Für eine angenehmere Fläche nimmst du ein 2×2 cm großes Stück Alufolie oder selbstklebendes Kupferband; Kupferband lässt sich auch löten und ist daher für feste Projekte besser. Du kannst das Pad auf Karton, die Innenseite einer Kunststoffbox oder die Rückseite eines Holzstücks kleben. Auch durch 1–3 mm Kunststoff, Acryl oder Glas wird eine Berührung erkannt; der Wertabfall wird nur kleiner, deshalb musst du den Schwellwert neu messen. Halte den Draht vom Pad zum ESP32 kurz: Drähte über 20–30 cm werden zur Antenne, und schon das Berühren des Drahts löst aus.

touchRead-Werte auslesen und Schwellwert festlegen

Zuerst willst du die echten Zahlen deines Aufbaus sehen. Der folgende Sketch liest GPIO 4 (T0) und GPIO 27 (T7) je achtmal und gibt den Mittelwert aus. Öffnest du in der Arduino IDE unter Werkzeuge den Seriellen Plotter, siehst du beide Linien live und wie die Werte bei Berührung fallen.

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}

Notiere beim Beobachten drei Zustände: Pad in Ruhe, Finger auf dem Pad und Finger 1–2 cm über dem Pad. Liest du zum Beispiel in Ruhe 62, bei Berührung 14 und bei Annäherung 45, liegt ein sicherer Schwellwert bei etwa 60 Prozent des Ruhewerts, also um 37. Liegt der Schwellwert zu nah am Ruhewert, löst er schon bei Annäherung aus; liegt er zu tief, verpasst du leichte Berührungen.

Touch-Taster mit automatischer Kalibrierung

Statt eine feste Schwellwertzahl zu schreiben, ist es viel zuverlässiger, beim Start den Ruhewert des Pads zu messen und den Schwellwert daraus zu berechnen. Der Sketch unten mittelt beim Start 50 Messungen, wertet einen Abfall um 40 Prozent als Berührung und schaltet die LED um. Als losgelassen gilt das Pad, sobald der Wert wieder über 80 Prozent des Ruhewerts steigt. Zwei getrennte Schwellen nennt man Hysterese; sie verhindert mehrfaches Auslösen, wenn der Wert genau an der Grenze zittert. Wenn dich die mechanische Seite von Tastern interessiert, lies den Artikel Taster anschließen.

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}

Touch-Interrupt mit touchAttachInterrupt

Statt ständig touchRead aufzurufen, kannst du die Touch-Hardware im Hintergrund messen lassen und eine Funktion aufrufen, sobald der Wert unter einen Schwellwert fällt. Genau das macht touchAttachInterrupt(pin, funktion, schwellwert). Beim klassischen ESP32 löst der Interrupt aus, wenn der Messwert unter die Schwelle fällt, und kommt bei jedem Messzyklus erneut, solange der Finger auf dem Pad bleibt. Deshalb setzt die Interrupt-Funktion nur ein Flag, und die eigentliche Arbeit passiert in loop() mit einer Zeitprüfung. Die allgemeinen Regeln für Interrupts erklären wir im Artikel Arduino Interrupt.

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 diesem Beispiel ist der Schwellwert 40; das passt zu einem Pad mit etwa 60 in Ruhe, sonst passe ihn an die Zahlen aus dem Mess-Sketch oben an. Das Attribut IRAM_ATTR an der Interrupt-Funktion legt sie in den schnellen Speicher; beim ESP32 wird es für Interrupt-Funktionen empfohlen. Zum Abschalten des Interrupts rufst du touchDetachInterrupt(pin) auf. Beim klassischen ESP32 kannst du mit touchInterruptSetThresholdDirection(false) außerdem festlegen, dass der Interrupt beim Überschreiten der Schwelle auslöst; praktisch, um das Abheben des Fingers zu erkennen.

Touch-Slider mit drei Pads

Drei Pads nebeneinander genügen, um die Position deines Fingers zu bestimmen. Liegt der Finger zwischen zwei Pads, sinken beide Werte; aus dem Abfall jedes Pads berechnest du die Position mit einem gewichteten Mittelwert. Schneidest du die Pads statt als Quadrate als ineinandergreifende Zickzack- oder Pfeilformen, berührt der Finger an jeder Stelle mindestens zwei Pads und der Slider läuft viel flüssiger. Drei 1,5 cm breite Streifen Kupferband mit 1–2 mm Abstand sind ein guter Anfang.

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}

Der Sketch speichert beim Start den Ruhewert jedes Pads und berechnet dann in jeder Schleife die Abfälle. Ist der Gesamtabfall groß genug, liegt ein Finger auf dem Slider, und die Position ergibt sich zwischen 0 und 1000. Diesen Wert rechnen wir mit map() auf 0–255 um und geben ihn mit analogWrite() an die LED. analogWrite() funktioniert in den Versionen 2.x und 3.x des ESP32-Arduino-Cores. Wie PWM funktioniert, steht im Artikel Was ist PWM.

Durch Berührung aus dem Deep Sleep aufwachen

In einem Batterieprojekt kannst du den ESP32 in den Deep Sleep schicken und nur aufwecken, wenn jemand das Pad berührt. In diesem Modus sind die Kerne aus, aber die Touch-Messschaltung läuft mit wenig Strom weiter. Die Funktion touchSleepWakeUpEnable(pin, schwellwert) setzt den Schwellwert und aktiviert das Touch-Aufwecken in einem Schritt. Beim klassischen ESP32 kannst du mehrere Pads als Weckquelle nutzen, beim ESP32-S2 und S3 nur eines. Nach dem Aufwachen verrät dir esp_sleep_get_touchpad_wakeup_status(), welches Pad geweckt hat. Details und Stromwerte zum Deep Sleep findest du im Artikel ESP32 Deep Sleep.

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}

Nach dem Aufwachen startet der Code wieder bei setup(), weil der RAM im Deep Sleep gelöscht wird. Um die Zahl der Weckvorgänge zu behalten, steht RTC_DATA_ATTR vor der Variablen; solche Variablen liegen im kleinen RTC-Speicher, der im Schlaf erhalten bleibt. Da die Touch-Messung auch im Schlaf weiterläuft, ist der Deep-Sleep-Strom etwas höher als beim Wecken per Timer; berücksichtige das bei der Akkulaufzeit. Der #if-Block im Code sorgt dafür, dass dasselbe Programm auch auf ESP32-S2 und S3 mit dem richtigen Schwellwert kompiliert.

ESP32 Touch-Pins mit MicroPython

Hast du MicroPython auf deinen ESP32 geflasht, erledigst du dasselbe mit der Klasse TouchPad aus dem Modul machine. Ihre Methode read() liefert denselben Wert wie touchRead() in Arduino; beim klassischen ESP32 sinkt er auch hier bei Berührung. Zum Aufwecken nutzt du esp32.wake_on_touch(True) und die Methode config(schwellwert) des Pads.

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)

Der Raspberry Pi Pico hat keinen eingebauten kapazitiven Touch-Sensor. Möchtest du mit einem Pico oder einem Arduino Uno einen Touch-Taster, ist ein fertiges TTP223-Modul die einfachste Lösung; es erkennt die Berührung selbst und liefert dir ein normales digitales Signal.

Feuchtigkeit, Wasser und Störungen

Kapazitive Sensoren erkennen nicht nur Finger, sondern auch Wasser. Ein Wassertropfen oder hohe Luftfeuchtigkeit auf dem Pad erhöht die Kapazität, der Wert sinkt und der Taster kann von selbst auslösen. Bei Projekten in Bad, Küche oder draußen setzt du das Pad hinter eine Fläche, auf der kein Wasser stehen bleibt, wählst einen etwas niedrigeren Schwellwert und verlangst, dass die Berührung mindestens 50–100 ms dauert. Auch lange Drähte, Relais und Motoren in der Nähe sowie ein schlechtes USB-Netzteil lassen die Werte schwanken. Die Tabelle fasst die häufigsten Probleme und Lösungen zusammen.

Touch-Pins beim ESP32-S3 und anderen Modellen

ESP32-S2 und ESP32-S3 nutzen Touch-Hardware der zweiten Generation und unterscheiden sich in drei wichtigen Punkten vom klassischen ESP32. Erstens liegen die Kanäle auf GPIO 1–14, und es sind 14; T1 ist GPIO 1, T14 ist GPIO 14. Zweitens sind die Werte viel größer und steigen bei Berührung; ein Pad mit etwa 20.000 in Ruhe kann bei Berührung über 40.000 gehen. Drittens ist der Schwellwert in touchAttachInterrupt und touchSleepWakeUpEnable kein Absolutwert, sondern ein Anstieg gegenüber dem Ruhewert. Beim S3 erfährst du außerdem mit touchInterruptGetLastStatus(pin), ob das Pad noch gedrückt ist. ESP32-C3 und ESP32-C6 haben überhaupt keinen Touch-Sensor. Schreibst du Code für mehrere Modelle, trenne sie wie im Weck-Beispiel mit CONFIG_IDF_TARGET_ESP32.

Projektideen mit Touch-Pins

• Schreibtischlampe: ein unsichtbarer Ein-/Ausschalter aus Kupferband hinter einer Holzblende, mit langem Berühren zum Dimmen.
• Slider-Dimmer: Helligkeit und Farbe eines WS2812B-LED-Streifens mit einem Slider aus drei Pads ändern.
• Batteriebetriebene Türklingel oder Notizgerät: Der ESP32 wartet im Deep Sleep, wacht bei Berührung des Pads auf und schickt eine Benachrichtigung über WLAN.
• Obstklavier: ein Spielzeug mit Drähten an Bananen und Äpfeln, das für jede Frucht einen anderen Ton spielt; für den Ton eignet sich ein Buzzer.
• Verstecktes Code-Panel: ein Schloss, das öffnet, wenn vier in einer Box versteckte Pads in der richtigen Reihenfolge berührt werden.

Die Touch-Pins des ESP32 geben deinem Projekt mit ein paar Zentimetern Folie und wenigen Codezeilen eine Touch-Bedienung. In der BlueGrays-App findest du Projekte wie ESP32-LED-Blinken, LED-Steuerung per Taster, LED-Helligkeit mit PWM und Deep Sleep, jeweils mit Schaltplan und Code Schritt für Schritt; ersetze die Taster durch die Touch-Pads aus dieser Anleitung und baue deine eigene Version.