TTP223 Touch Sensor am Arduino: Modi, Anschluss und Touch-Lampe

Der TTP223 Touch Sensor ist ein günstiges kapazitives Touch-Modul mit einer Taste, das einen mechanischen Taster ersetzt und deinen Finger an einer Änderung der Kapazität erkennt. Er hat nur drei Pins (VCC, GND und I/O): Berührst du ihn, geht der Ausgang auf HIGH, nimmst du den Finger weg, fällt er zurück auf LOW. Dank dieser Einfachheit liest du ihn am Arduino wie einen Taster mit digitalRead() aus, und weil er mit 2–5,5 V arbeitet, lässt er sich auch direkt an einen ESP32 oder Raspberry Pi Pico anschließen. Ohne bewegliche Teile nutzt er sich nicht ab, klickt nicht und lässt sich hinter dünnem Kunststoff, Glas oder Holz verstecken.

In dieser Anleitung lernst du Schritt für Schritt, was im TTP223 passiert, wie du mit den Lötbrücken A und B auf der Platine zwischen Tastermodus und Schaltermodus (Toggle) sowie High-aktivem und Low-aktivem Ausgang wählst, wie du eine Arduino-Touch-Lampe baust, die per kurzem Tippen schaltet und bei langem Berühren dimmt, wie der Sensor hinter einer Platte funktioniert, wie du mehrere Tasten nutzt, worin er sich von den eingebauten Touch-Pins des ESP32 unterscheidet und wie du ihn am Pico mit MicroPython verwendest.

Was ist der TTP223 Touch Sensor und wie funktioniert er?

Die Kupferfläche auf dem Modul und die Massefläche (GND) der Platine bilden einen winzigen Kondensator von einigen Pikofarad. Nähert sich dein Finger der Fläche, kommt dein Körper zu diesem Kondensator hinzu und die Gesamtkapazität steigt um einige Pikofarad. Der etwa 1 MHz schnelle Sensoroszillator im TTP223 erkennt diesen Anstieg als Frequenzänderung, vergleicht das Ergebnis mit einem gespeicherten Referenzwert und schaltet den Ausgang um, wenn der Unterschied groß genug ist. Die Formel des Plattenkondensators C = ε·A/d gilt auch hier: Je größer die Fläche (A) und je dünner das Material zwischen Finger und Fläche (d), desto zuverlässiger die Erkennung.

Den Referenzwert legt der Chip selbst fest. Sobald du die Spannung anlegst, misst er etwa 0,5 Sekunden lang seine Umgebung und ignoriert in dieser Zeit Berührungen. Danach kalibriert er sich, solange niemand ihn berührt, etwa alle 4 Sekunden neu, sodass langsame Änderungen wie Temperatur und Luftfeuchtigkeit mit der Zeit ausgeglichen werden. Deshalb betrachtet der Sensor alles, was beim Einschalten an der Fläche ist, als "unberührt": Liegt dein Finger beim Einschalten auf der Fläche, sieht er dich überhaupt nicht.

Bei der auf den Modulen verwendeten Version TTP223-BA6 sind einige Optionen im Gehäuse fest eingestellt: Der Chip läuft immer im Low-Power-Modus, und die bei anderen Gehäusen vorhandene Begrenzung der maximalen Einschaltdauer auf 100 Sekunden ist deaktiviert. Im Low-Power-Modus braucht der Chip nur wenige Mikroampere, kann aber bis zu etwa 220 ms brauchen, um auf die erste Berührung zu reagieren. Nach einer erkannten Berührung bleibt er etwa 12 Sekunden im Fast-Modus und reagiert auf weitere Berührungen deutlich schneller. Bei einer Lampe oder Türklingel merkst du diese Verzögerung nicht, bei einem schnellen Spiele-Controller solltest du sie aber im Hinterkopf behalten.

TTP223 Pinbelegung und Anschluss

Da der Ausgangspin das Signal selbst auf HIGH und LOW treibt, brauchst du am Arduino weder INPUT_PULLUP noch einen externen Widerstand; es reicht, den Pin einfach als INPUT zu definieren. Prellen wie bei mechanischen Tastern gibt es hier nicht, weil der Chip den Ausgang erst ändert, wenn die Berührung stabil ist. Soll dein Code eine Berührung trotzdem als ein einziges Ereignis zählen, nutze die Flankenerkennung, die wir im Artikel Taster am Arduino anschließen erklären.

Moduswahl mit den Lötbrücken A und B

Neben dem Chip findest du auf dem Modul zwei kleine Lötpad-Paare mit der Beschriftung A und B. Sie sind mit zwei Optionspins des Chips verbunden: Bei den meisten Modulen bestimmt A, ob der Ausgang High-aktiv oder Low-aktiv ist (AHLB), und B, ob der Sensor im Tastermodus oder im Schaltermodus (Toggle) arbeitet (TOG). Im Chip sind diese Pins über einen Widerstand auf GND gezogen, daher ist die Option bei offenen Pads "0"; verbindest du die beiden Pads mit einem Tropfen Lötzinn, wird sie zu "1". Nach dem Ändern einer Brücke trennst du am besten kurz die Versorgung. Ist die Beschriftung auf deinem Board anders, kannst du den Modus leicht mit der LED im ersten Testsketch prüfen.

Erster Test mit dem Arduino: Berührung auslesen

1. Verbinde VCC des Moduls mit dem 5V-Pin des Arduino, GND mit GND und den I/O-Pin mit D2.
2. Lade den folgenden Sketch hoch und öffne den seriellen Monitor mit 9600 Baud.
3. Warte nach dem Start etwa eine Sekunde, ohne die Sensorfläche zu berühren; in dieser Zeit kalibriert sich der Chip.
4. Berühre die Fläche mit dem Finger: Die eingebaute LED an Pin 13 des Arduino (bei den meisten Modulen auch die LED auf der Platine) sollte leuchten und die Anzahl der Berührungen im seriellen Monitor um eins steigen.
5. Solange dein Finger auf der Fläche liegt, bleibt die LED an; der Zähler steigt aber bei jeder neuen Berührung nur einmal.

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}

Der wichtigste Teil des Codes ist die Flankenerkennung. Der vorherige Messwert wird in der Variablen lastState gespeichert; ist der neue Wert HIGH und der vorherige LOW, ist das eine neue Berührung. Ohne diese Prüfung würde der Zähler bei jedem Schleifendurchlauf hochzählen, solange dein Finger auf der Fläche liegt, also tausende Male pro Sekunde. Die 600 ms Wartezeit in setup() stellen sicher, dass der Chip mit der Kalibrierung fertig ist, wenn Arduino und Modul gleichzeitig Strom bekommen. D2 haben wir gewählt, weil er ein Interrupt-Pin des Uno ist; wenn du willst, kannst du die Berührung auch per Interrupt mit attachInterrupt(digitalPinToInterrupt(2), funktion, RISING) erfassen.

Projekt: Touch-Lampe mit Arduino

Jetzt bauen wir eine echte Touch-Lampe: Kurzes Tippen schaltet die Lampe ein und aus, hältst du bei eingeschalteter Lampe den Finger auf der Fläche, wird das Licht langsam dunkler, und beim nächsten langen Berühren wieder heller. Da die Helligkeit per PWM eingestellt wird, schließen wir die Lampe an D9 an, einen der PWM-Pins des Uno. Zum Testen reichen an D9 eine LED und ein 220-Ω-Widerstand (den passenden Wert liefert der LED-Vorwiderstandsrechner). Für einen 12-V-LED-Streifen brauchst du dazwischen einen Logic-Level-MOSFET wie den IRLZ44N; Details findest du in MOSFET am 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}

Beachte, dass der Code kein einziges delay() enthält: Das gesamte Timing läuft über millis(), daher dreht die Schleife ständig weiter und verpasst keine Berührung. Mehr zu dieser Technik findest du in millis() statt delay(). Weil die letzte Helligkeit in der Variablen brightness bleibt, leuchtet die Lampe nach dem Aus- und Einschalten wieder auf der zuletzt eingestellten Stufe, genau wie Touch-Tischlampen aus dem Handel.

Erkennung durch dünne Materialien

Die beliebteste Eigenschaft des TTP223 ist, dass er aus einem Gehäuse ohne Löcher heraus funktioniert. Kunststoff, Acryl, Glas, Holz, Papier und Stoff lassen das elektrische Feld durch; das Material zwischen Fläche und Finger wirkt wie das Dielektrikum eines Kondensators. Je dicker das Material, desto größer wird d in der Formel und desto kleiner die Kapazität zwischen Finger und Fläche; die doppelte Dicke halbiert diese Kapazität ungefähr. Glas hat eine höhere Dielektrizitätszahl als die meisten Kunststoffe, deshalb liefert Glas gleicher Dicke meist bessere Ergebnisse. In der Praxis funktioniert das Modul hinter einer 1–3 mm dicken Platte aus Kunststoff, Acryl oder Glas meist problemlos; bei dickeren Platten brauchst du eine größere Sensorfläche und solltest immer mit deinem eigenen Material testen.

• Keinen Luftspalt lassen: Luft hat eine Dielektrizitätszahl von 1, schon ein Spalt von 1 mm senkt die Empfindlichkeit deutlich. Klebe das Modul mit der Sensorseite zur Platte fest mit dünnem doppelseitigem Klebeband oder Kleber an.
• Sensorfläche vergrößern: Für eine größere Touchfläche schneidest du eine Elektrode aus Kupferklebeband oder Alufolie zu, kratzt an einer Ecke der Fläche vorsichtig den Schutzlack ab und lötest die Elektrode mit einem sehr kurzen Draht an. Je länger der Draht, desto mehr Eigenkapazität kommt hinzu und desto instabiler wird der Sensor.
• Kein Metall: Metallplatten, metallhaltige Materialien und Metallic-Lacke sammeln das elektrische Feld auf sich; der Sensor erkennt dann entweder gar nichts oder löst von selbst aus.
• Zu hohe Empfindlichkeit senken: Löst der Sensor aus, bevor dein Finger nahe ist, setze einen kleinen 5–20-pF-Keramikkondensator (Cs) zwischen Sensorfläche und GND; je größer der Wert, desto geringer die Empfindlichkeit, die Obergrenze liegt bei 50 pF. Den Aufdruck auf dem Kondensator (z. B. 100 = 10 pF, 220 = 22 pF) entschlüsselst du mit dem Werkzeug Kondensator-Code.
• Erst montieren, dann einschalten: Weil der Chip beim Einschalten seine Umgebung als Referenz nimmt, schaltest du die Versorgung erst ein, wenn Platte und Deckel montiert sind. Setzt du die Platte bei laufendem Modul ein, kann der Chip sie als Dauerberührung werten; dann genügt es, die Versorgung kurz zu trennen.

Mehrere Touch-Tasten nutzen

Jeder TTP223 überwacht seine eigene Fläche unabhängig; willst du vier Tasten, schließt du vier Module an vier getrennte Digitalpins an, wobei sich die Module VCC und GND teilen. Liegen die Tasten sehr dicht beieinander, kann dein Finger auch die Nachbarfläche beeinflussen; lass mindestens 1–2 cm Abstand zwischen den Flächen und halte die Module von Motor- und Relaisleitungen fern. Der folgende Sketch baut mit vier TTP223 und einem passiven Buzzer ein kleines Touch-Klavier: Jede Taste spielt ihren Ton, und wenn du den Finger hebst, verstummt er.

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}

Da tone() immer nur einen Ton gleichzeitig spielen kann, wählt der Code die erste berührte Taste und ändert den Ton nur, wenn er sich wirklich ändert, damit es nicht knackt. Am Uno nutzt tone() den Timer2, daher funktioniert analogWrite an den Pins 3 und 11 nicht, solange der Buzzer spielt; das stört hier nicht, weil das Klavier D3 nur als Eingang nutzt. Brauchst du viele Tasten, sind Mehrkanal-Chips aufgeräumter als ein Modul pro Taste: Der TTP224 bietet vier Tasten mit vier getrennten Ausgängen, der TTP229 liest 8 oder 16 Tasten über eine Zweidraht-Schnittstelle, und der MPR121 überwacht 12 Elektroden per I2C.

ESP32: TTP223 oder die eingebauten Touch-Pins?

Der klassische ESP32 hat einen kapazitiven Touch-Sensor eingebaut, und 10 Pins (T0–T9) lassen sich ohne Modul als Touch-Tasten nutzen: der Reihe nach GPIO 4, 0, 2, 15, 13, 12, 14, 27, 33 und 32. Die Funktion touchRead() liefert einen Rohwert; beim klassischen ESP32 sinkt dieser Wert bei Berührung, beim ESP32-S2 und S3 steigt er. Der ESP32-C3 hat überhaupt keinen Touch-Sensor. Mehr zu den eingebauten Pins findest du in ESP32 Touch-Pins; die Tabelle unten vergleicht beide Wege.

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}

Dieser Sketch misst beim Start den unberührten T0-Wert und nimmt 70 % davon als Schwelle; beobachte den Rohwert im seriellen Monitor (115200 Baud), um das Verhältnis an deine Verkabelung anzupassen. Nutzt du einen ESP32-S3, steigt der Wert bei Berührung, also kehrst du den Vergleich um (zum Beispiel Schwelle = Messwert × 1,3 und raw > Schwelle). Den TTP223 haben wir auch deshalb an GPIO 26 angeschlossen, weil dieser Pin ein RTC-GPIO ist: Mit esp_sleep_enable_ext0_wakeup(GPIO_NUM_26, 1) schickst du den ESP32 in den Deep Sleep und weckst ihn per Berührung. Da der TTP223 nur wenige Mikroampere braucht, sind die beiden ein ideales Paar für batteriebetriebene Projekte; Details findest du in ESP32 Deep Sleep.

TTP223 am Raspberry Pi Pico (MicroPython)

Der RP2040-Chip des Pico hat keinen Touch-Sensor, deshalb ist der TTP223 der einfachste Weg, dem Pico eine Touch-Taste zu geben. Versorge das Modul über den Pin 3V3(OUT) (physischer Pin 36) und verbinde den I/O-Pin mit GP15 (physischer Pin 20). Der folgende MicroPython-Code schaltet bei jeder Berührung die eingebaute LED um. Weil er die Berührung per Interrupt (IRQ) erfasst, geht keine Berührung verloren, auch wenn die Hauptschleife gerade mit anderem beschäftigt ist. Weißt du noch nicht, wie du MicroPython auf den Pico bringst, beginne mit Was ist der 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)

In aktuellen MicroPython-Versionen wählt der Name Pin("LED") sowohl beim Pico als auch beim Pico W die eingebaute LED. Hast du Brücke B gelötet und das Modul in den Schaltermodus gesetzt, brauchst du nicht einmal den Interrupt: Es genügt, led.value(touch.value()) in die Schleife zu schreiben, denn den Ein/Aus-Zustand hält jetzt der Chip selbst. Auch wenn der Ausgang des Chips nicht prellt, verhindert die 250-ms-Sperre im Code, dass kurze Störimpulse auf langen Leitungen die LED zweimal umschalten.

Projektideen mit dem TTP223

• Touch-Nachtlicht: Ergänze einen LDR, damit die Lampe nur bei Dunkelheit auf Berührung reagiert.
• Farbwechsel-Lampe: Ändere bei jeder Berührung die Farbe eines WS2812B-NeoPixel-Rings und stelle mit langem Berühren die Helligkeit ein.
• Verstecktes Codeschloss: Platziere vier TTP223 hinter einer Acrylplatte; berührst du die Tasten in der richtigen Reihenfolge, öffnet ein Servomotor das Schloss.
• Türklingel ohne Löcher: Klebe den Sensor in ein Kunststoffgehäuse; bei Berührung spielt ein DFPlayer Mini den Klingelton.
• Touch-Schalter für die Steckdose: Schalte eine Tischlampe oder einen Ventilator mit einem Relaismodul ein und aus.
• Batteriebetriebene Fernbedienung: Halte einen ESP32 im Deep Sleep; berührst du den TTP223, wacht er auf und sendet per ESP-NOW einen Befehl.

Häufige Fehler und Lösungen

Der TTP223 ist der einfachste Weg, deinen Projekten mit einem sehr günstigen Modul eine moderne Touch-Bedienung zu geben: Er ersetzt den mechanischen Taster, funktioniert hinter Platten ohne Löcher und versteht sich mit jedem Mikrocontroller. Probiere zuerst das Auslesen in der Werkseinstellung aus und festige dann mit den Beispielen Lampe und Klavier die Flankenerkennung und die Logik für langes Berühren. In der BlueGrays-App findest du Schritt für Schritt Schaltpläne und Code für LED mit Taster, Ein/Aus-LED, Taster-Projekte mit ESP32 und Pico sowie das Schalten einer 230-V-Lampe, und mit einem TTP223 anstelle des Tasters machst du daraus Touch-Projekte.