TTP223-aanraaksensor met Arduino: modi, bedrading en een aanraaklamp
Zo gebruik je de capacitieve TTP223-aanraaksensor: A/B-jumpers voor tik- of schakelmodus, een Arduino-aanraaklamp, detectie door plastic heen, plus code voor ESP32 en Pico.
De TTP223-aanraaksensor is een goedkope capacitieve aanraakmodule met één toets. Hij vervangt een mechanische drukknop door je vinger te detecteren aan de hand van een verandering in capaciteit. De module heeft maar drie pinnen (VCC, GND en I/O): raak je hem aan, dan wordt de uitgang HIGH, en haal je je vinger weg, dan valt hij terug naar LOW. Door die eenvoud lees je hem op een Arduino met digitalRead() uit, net als een knop, en omdat hij werkt op 2–5,5 V kun je hem ook direct aansluiten op een ESP32 of een Raspberry Pi Pico. Zonder bewegende delen slijt hij niet en klikt hij niet, en je kunt hem verbergen achter een dun laagje plastic, glas of hout.
In deze gids leer je stap voor stap wat er in de TTP223 gebeurt, hoe je met de soldeerjumpers A en B op de print kiest tussen tikmodus en schakelmodus en tussen een actief-hoge of actief-lage uitgang, hoe je een Arduino-aanraaklamp bouwt die schakelt met een korte aanraking en dimt met een lange, hoe je de sensor achter een paneel laat werken, hoe je meerdere toetsen gebruikt, hoe hij zich verhoudt tot de ingebouwde aanraakpinnen van de ESP32 en hoe je hem op de Pico gebruikt met MicroPython.

Wat is de TTP223-aanraaksensor en hoe werkt hij?
Het koperen vlak op de module en het massavlak (GND) van de print vormen samen een piepkleine condensator van een paar picofarad. Komt je vinger in de buurt van het vlak, dan wordt je lichaam aan die condensator toegevoegd en stijgt de totale capaciteit met een paar picofarad. De sensoroscillator van ongeveer 1 MHz in de TTP223 ziet deze stijging als een verandering in frequentie, vergelijkt het resultaat met een referentiewaarde die hij bijhoudt en schakelt de uitgang als het verschil groot genoeg is. De formule voor de condensator met parallelle platen, C = ε·A/d, geldt hier ook: hoe groter het oppervlak van het vlak (A) en hoe dunner het materiaal tussen vinger en vlak (d), hoe sterker de detectie.
De chip bepaalt zijn referentiewaarde zelf. Zodra je spanning aansluit, meet hij ongeveer 0,5 seconden lang zijn omgeving en negeert hij aanrakingen in die tijd. Daarna kalibreert hij zichzelf, zolang niemand hem aanraakt, ongeveer elke 4 seconden opnieuw, zodat langzame veranderingen zoals temperatuur en luchtvochtigheid na verloop van tijd worden gecompenseerd. Daarom beschouwt de sensor alles wat er bij het opstarten rond het vlak is als "niet aangeraakt": ligt je vinger op het vlak als de spanning wordt aangesloten, dan ziet hij je helemaal niet.
| Eigenschap | Waarde |
|---|---|
| Chip | TTP223-BA6 (SOT-23-behuizing met 6 pinnen) |
| Voedingsspanning | 2,0–5,5 V |
| Chipstroom (3 V, zonder led) | Typisch 1,5 µA, max. 3 µA |
| Reactietijd | Tot ~220 ms in energiezuinige modus, ~60 ms in snelle modus |
| Uitgangstype | CMOS (push-pull); het HIGH-niveau is gelijk aan VCC |
| Uitgangsstroom (bij 3 V) | Levert ongeveer 4 mA, neemt 8 mA op |
| Kalibratie bij opstarten | Ongeveer 0,5 s (niet aanraken in deze tijd) |
| Gevoeligheidsinstelling | Condensator (Cs) van 0–50 pF tussen vlak en GND |
| Werktemperatuur | -20 tot +70 °C |
| Modulepinnen | VCC, I/O (SIG of OUT), GND |
In de TTP223-BA6-versie die op deze modules zit, liggen sommige opties vast in de behuizing: de chip werkt altijd in de energiezuinige modus en de limiet van 100 seconden "maximale inschakeltijd" die je bij andere uitvoeringen vindt, is uitgeschakeld. In de energiezuinige modus verbruikt de chip slechts een paar microampère, maar hij kan tot ongeveer 220 ms nodig hebben om op de eerste aanraking te reageren. Zodra een aanraking is gedetecteerd, blijft hij ongeveer 12 seconden in de snelle modus en reageert hij veel sneller op de volgende aanrakingen. In een lamp of deurbel merk je die vertraging niet, maar houd er rekening mee als je een gamecontroller bouwt die snel moet reageren.
TTP223-pinout en bedrading
| TTP223-pin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC | 5V | 3V3 | 3V3(OUT) (pin 36) |
| GND | GND | GND | GND (pin 38) |
| I/O (SIG) | D2 | GPIO 26 | GP15 (pin 20) |
Omdat de uitgangspin het signal actief HIGH en LOW stuurt, heb je op de Arduino geen INPUT_PULLUP of externe weerstand nodig; de pin instellen als INPUT is genoeg. Er is geen contactdender zoals bij mechanische knoppen, omdat de chip zijn uitgang pas verandert als de aanraking stabiel is. Wil je dat je code één aanraking als één gebeurtenis telt, gebruik dan toch de flankdetectie die we uitleggen in Een knop aansluiten.
De modus kiezen met de soldeerjumpers A en B
Naast de chip op de module zitten twee kleine paren soldeerpads met de markering A en B. Ze zijn verbonden met twee optiepinnen van de chip: op de meeste modules bepaalt A of de uitgang actief hoog of actief laag is (AHLB), en B of de sensor in tikmodus of schakelmodus werkt (TOG). In de chip worden deze pinnen via een weerstand naar GND getrokken, dus met open pads is de optie "0"; overbrug je de twee pads met een druppel soldeer, dan wordt de optie "1". Na het wijzigen van een jumper kun je het best de spanning eraf halen en weer aansluiten. Als de markeringen op jouw print anders zijn, kun je de modus eenvoudig controleren met de led in de eerste testsketch.
| A | B | Modus | Bij aanraking | Uitgang bij opstarten |
|---|---|---|---|---|
| Open | Open | Tikmodus, actief hoog (fabrieksinstelling) | HIGH zolang je aanraakt | LOW |
| Overbrugd | Open | Tikmodus, actief laag | LOW zolang je aanraakt | HIGH |
| Open | Overbrugd | Schakelmodus (vergrendelend), actief hoog | Toestand wisselt bij elke aanraking | LOW |
| Overbrugd | Overbrugd | Schakelmodus (vergrendelend), actief laag | Toestand wisselt bij elke aanraking | HIGH |
Eerste test met Arduino: een aanraking uitlezen
- Sluit de VCC-pin van de module aan op de 5V-pin van de Arduino, GND op GND en de I/O-pin op D2.
- Upload de onderstaande sketch en open de Serial Monitor op 9600 baud.
- Wacht nadat het board is gestart ongeveer een seconde zonder het vlak aan te raken; de chip kalibreert zichzelf in die tijd.
- Raak het vlak aan met je vinger: de ingebouwde led van de Arduino op pin 13 (en op de meeste modules ook de led op de module zelf) moet oplichten en de aanraakteller in de Serial Monitor moet met één omhoog gaan.
- De led blijft aan zolang je vinger op het vlak ligt, terwijl de teller maar één keer omhoog gaat voor elke nieuwe aanraking.
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}Het belangrijkste deel van de code is de flankdetectie. De vorige meting wordt opgeslagen in de variabele lastState; is de nieuwe meting HIGH en de vorige LOW, dan is het een nieuwe aanraking. Zonder deze controle zou de teller bij elke ronde van de lus omhoog gaan zolang je vinger op het vlak blijft, dus duizenden keren per seconde. De wachttijd van 600 ms in setup() zorgt ervoor dat de chip klaar is met kalibreren als de Arduino en de module tegelijk spanning krijgen. We kozen D2 omdat het een van de interruptpinnen van de Uno is; als je wilt, kun je de aanraking ook opvangen met een interrupt via attachInterrupt(digitalPinToInterrupt(2), function, RISING).
Project: een Arduino-aanraaklamp
Nu bouwen we een echte aanraaklamp: een korte aanraking schakelt de lamp aan en uit, je vinger op het vlak houden terwijl hij aan is dimt het licht langzaam, en de volgende lange aanraking maakt het weer helderder. Omdat de helderheid wordt ingesteld met PWM, sluiten we de lamp aan op D9, een van de PWM-pinnen van de Uno. Om te testen volstaan een led en een weerstand van 220 Ω op D9 (gebruik de ledweerstandcalculator voor de juiste waarde). Gebruik je een 12V-LED-strip, plaats er dan een logic-level MOSFET zoals de IRLZ44N tussen; zie Een MOSFET gebruiken met Arduino voor details.
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}| Codeonderdeel | Wat het doet |
|---|---|
| touchStart | Legt het moment vast waarop de aanraking begon, met millis() |
| LONG_PRESS = 600 | Aanrakingen langer dan 600 ms tellen als dimcommando |
| dimming | Wordt gezet als er tijdens deze aanraking is gedimd, zodat de lamp niet uitgaat als je je vinger optilt |
| step | Wisselt van teken bij elke lange aanraking, zodat het licht de ene keer dimt en de volgende keer helderder wordt |
| constrain(brightness, 10, 255) | Houdt de helderheid binnen een bereik waarin de lamp nooit helemaal donker wordt |
| Schakelen bij loslaten | De beslissing valt als de vinger loskomt, zodat korte en lange aanrakingen te onderscheiden zijn |
Merk op dat er nergens in de code een delay() staat: alle timing gebeurt met millis(), zodat de lus blijft draaien en nooit een aanraking mist. Meer over deze techniek lees je in millis() vs delay(). Omdat de laatste helderheid in de variabele brightness blijft staan, komt het licht terug op het niveau dat je het laatst hebt ingesteld als je de lamp uit en weer aan zet, net als bij de aanraakbureaulampen die je in winkels vindt.
Detectie door dunne materialen heen
De populairste eigenschap van de TTP223 is dat hij kan werken vanuit een doos zonder gaten. Plastic, acryl, glas, hout, papier en stof laten het elektrische veld door; het materiaal tussen vlak en vinger werkt als het diëlektricum van een condensator. Wordt het materiaal dikker, dan groeit d in de formule en daalt de capaciteit tussen vinger en vlak; een dubbele dikte halveert die capaciteit ongeveer. Glas heeft een hogere diëlektrische constante dan de meeste plastics, dus glas van dezelfde dikte geeft meestal betere resultaten. In de praktijk werkt de module meestal prima achter een paneel van 1–3 mm plastic, acryl of glas; bij dikkere panelen heb je een groter vlak nodig, en test altijd met je eigen materiaal.
- Laat geen luchtspleet: Lucht heeft een diëlektrische constante van 1 en zelfs een spleet van 1 mm verlaagt de gevoeligheid sterk. Plak de module stevig tegen het paneel, met de vlakzijde naar het paneel, met dun dubbelzijdig plakband of lijm.
- Maak het vlak groter: Voor een groter aanraakoppervlak snijd je een elektrode uit kopertape of aluminiumfolie, schraap je voorzichtig de beschermlaag van één hoek van het vlak en soldeer je de elektrode met een heel korte draad eraan vast. Hoe langer de draad, hoe meer capaciteit hij toevoegt en hoe minder stabiel de sensor wordt.
- Vermijd metaal: Metalen panelen, materialen met metaalinhoud en metaalverf trekken het elektrische veld naar zich toe; de sensor detecteert dan niets of schakelt uit zichzelf.
- Verlaag te hoge gevoeligheid: Schakelt de sensor al voordat je vinger dichtbij komt, voeg dan een kleine keramische condensator (Cs) van 5–20 pF toe tussen het vlak en GND; hoe groter de waarde, hoe lager de gevoeligheid, met 50 pF als bovengrens. De markering op de condensator (bijvoorbeeld 100 = 10 pF, 220 = 22 pF) kun je ontcijferen met de tool condensatorcode.
- Eerst monteren, dan inschakelen: Omdat de chip bij het opstarten zijn omgeving als referentie neemt, sluit je pas spanning aan nadat het paneel en het deksel op hun plek zitten. Plaats je het paneel terwijl de module onder spanning staat, dan kan de chip het als een blijvende aanraking zien; haal in dat geval de spanning eraf en sluit hem weer aan.
Meerdere aanraaktoetsen gebruiken
Elke TTP223 bewaakt zijn eigen vlak onafhankelijk; wil je vier toetsen, sluit dan vier modules aan op vier aparte digitale pinnen, waarbij de modules VCC en GND delen. Staan de toetsen heel dicht bij elkaar, dan kan je vinger ook het naburige vlak beïnvloeden; laat minstens 1–2 cm tussen de vlakken en houd de modules uit de buurt van motor- of relaisdraden. De onderstaande sketch gebruikt vier TTP223's en een passieve buzzer voor een kleine aanraakpiano: welke toets je ook aanraakt, die speelt zijn noot, en het geluid stopt als je je vinger optilt.
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}Omdat tone() maar één noot tegelijk kan spelen, kiest de code de eerste toets die wordt aangeraakt en past hij de noot alleen aan als die verandert, zodat het geluid niet kraakt. Op de Uno gebruikt tone() Timer2, dus analogWrite werkt niet op pin 3 en 11 terwijl de buzzer speelt; dat is hier geen probleem omdat de piano D3 alleen als ingang gebruikt. Naarmate het aantal toetsen groeit, is het netter om over te stappen op chips met meerdere kanalen in plaats van één module per toets: de TTP224 biedt vier toetsen met vier aparte uitgangen, de TTP229 leest 8 of 16 toetsen uit via een seriële interface met twee draden en de MPR121 bewaakt 12 elektroden via I2C.
ESP32: TTP223 of de ingebouwde aanraakpinnen?
De klassieke ESP32 heeft een capacitieve aanraaksensor ingebouwd en 10 pinnen (T0–T9) kunnen zonder module als aanraaktoets worden gebruikt: GPIO 4, 0, 2, 15, 13, 12, 14, 27, 33 en 32, in die volgorde. De functie touchRead() geeft een ruw getal terug; op de klassieke ESP32 daalt dit getal als je de pin aanraakt, terwijl het op de ESP32-S2 en S3 stijgt. De ESP32-C3 heeft helemaal geen aanraaksensor. Voor een uitgebreide blik op de ingebouwde pinnen zie je Aanraakpinnen van de ESP32; de onderstaande tabel vergelijkt de twee aanpakken.
| Eigenschap | TTP223-module | Ingebouwde aanraking van de ESP32 |
|---|---|---|
| Extra onderdeel | Nodig (1 toets per module) | Niet nodig; een draad of koperen vlak op de pin volstaat |
| Uitgang | Kant-en-klare digitale HIGH/LOW | Ruw getal; jij kiest de drempel |
| Kalibratie | Gedaan door de chip zelf | Je meet en stelt een drempel in via code |
| Welke boards? | Alle (Uno, Nano, ESP, Pico) | Alleen de ESP32, ESP32-S2 en ESP32-S3 |
| Aantal toetsen | Zoveel als je modules hebt | 10 op de ESP32, 14 op de S2 en S3 |
| Wakker worden uit deep sleep | Via ext0/ext1 op een RTC-GPIO | Met touchSleepWakeUpEnable() |
| Lange draden en luchtvochtigheid | Stabiel, omdat het vlak op de module zit | Metingen driften bij langere draden en de drempel werkt niet meer |
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}Bij het opstarten meet deze sketch de niet-aangeraakte T0-waarde en gebruikt hij 70% daarvan als drempel; bekijk de ruwe waarde in de Serial Monitor (115200 baud) om de verhouding af te stemmen op je eigen bedrading. Gebruik je een ESP32-S3, dan stijgt de waarde bij aanraking, dus draai de vergelijking om (bijvoorbeeld threshold = gemeten waarde × 1.3 en raw > threshold). Een andere reden dat we de TTP223 op GPIO 26 hebben aangesloten, is dat het een RTC-GPIO is: met esp_sleep_enable_ext0_wakeup(GPIO_NUM_26, 1) kun je de ESP32 in deep sleep zetten en met een aanraking wekken. Omdat de TTP223 slechts een paar microampère verbruikt, vormen de twee een prima combinatie voor projecten op batterijen; zie ESP32 deep sleep voor details.
TTP223 met de Raspberry Pi Pico (MicroPython)
De RP2040-chip van de Pico heeft geen aanraaksensor, dus de TTP223 is de eenvoudigste manier om een aanraaktoets aan een Pico toe te voegen. Voed de module via de pin 3V3(OUT) (fysieke pin 36) en sluit de I/O-pin aan op GP15 (fysieke pin 20). De onderstaande MicroPython-code schakelt de ingebouwde led van het board om bij elke aanraking. Omdat hij de aanraking met een interrupt (IRQ) opvangt, gaat er geen aanraking verloren, ook niet als de hoofdlus met ander werk bezig is. Weet je nog niet hoe je MicroPython op de Pico installeert, begin dan met Wat is de 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 actuele MicroPython-versies selecteert de naam Pin("LED") de ingebouwde led van zowel de Pico als de Pico W. Heb je jumper B overbrugd en de module in schakelmodus gezet, dan heb je de interrupt zelfs niet nodig: led.value(touch.value()) in de lus is genoeg, omdat de chip zelf nu de aan/uit-toestand bijhoudt. Hoewel de uitgang van de chip niet dendert, voorkomt de blokkade van 250 ms in de code dat korte stoorpulsen op lange draden de led twee keer omschakelen.
Projectideeën met de TTP223
- Aanraaknachtlampje: Voeg een LDR toe, zodat de lamp alleen op aanraking reageert als het donker is.
- Lamp die van kleur wisselt: Verander bij elke aanraking de kleur van een WS2812B-NeoPixel-ring en stel de helderheid in met een lange aanraking.
- Verborgen codeslot: Plaats vier TTP223's achter een acrylpaneel; raak je de toetsen in de juiste volgorde aan, dan opent een servomotor het slot.
- Deurbel zonder gaten: Plak de sensor aan de binnenkant van een plastic doos; een aanraking laat een DFPlayer Mini een beltoon afspelen.
- Aanraakschakelaar voor een stopcontact: Schakel een bureaulamp of ventilator aan en uit met een relaismodule.
- Afstandsbediening op batterijen: Laat een ESP32 in deep sleep staan; raak je de TTP223 aan, dan wordt hij wakker en stuurt hij een commando met ESP-NOW.
Veelgemaakte fouten en hoe je ze oplost
| Verschijnsel | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Geen reactie op aanraking | Er lag een vinger op het vlak bij het opstarten, of het paneel is te dik | Haal je hand weg en schakel de spanning uit en weer aan; gebruik een dunner paneel of een groter vlak |
| Schakelt uit zichzelf | Te gevoelig, metaal bij het vlak, een ruisende voedingsadapter | Voeg 5–20 pF toe tussen vlak en GND, haal het metaal weg, plaats 100 nF over VCC–GND |
| Blijft de hele tijd als aangeraakt staan | Het paneel of deksel is geplaatst terwijl de module onder spanning stond | Eerst monteren, dan spanning aansluiten |
| Teller gaat meerdere keren omhoog per aanraking | De code leest het niveau, niet de flank | Sla de vorige toestand op en tel alleen bij de overgang LOW→HIGH |
| De eerste aanraking wordt met vertraging gedetecteerd | De chip staat in energiezuinige modus (~220 ms) | Dat is normaal; volgende aanrakingen worden sneller gedetecteerd |
| Pin van ESP32 of Pico beschadigd | De module werd gevoed met 5 V | Voed de module altijd via de 3V3-pin |
| In schakelmodus start de lamp aan bij het inschakelen | Jumper A kiest actief laag | Kies de toestand bij het opstarten met jumper A of keer de logica om in code |
De TTP223 is de eenvoudigste manier om met een heel goedkope module een moderne aanraakinterface aan je projecten toe te voegen: hij vervangt de mechanische knop, werkt achter panelen zonder gaten en kan met elke microcontroller overweg. Probeer hem eerst uit te lezen met de fabrieksinstellingen en oefen daarna flankdetectie en logica voor lange aanrakingen met de lamp- en pianovoorbeelden. In de BlueGrays-app vind je stap voor stap schakelschema's en code voor een led laten branden met een knop, een aan/uit-led met schakelfunctie, ESP32- en Pico-knopprojecten en het schakelen van een lamp op netspanning, en je kunt ze allemaal omvormen tot aanraakprojecten door een TTP223 in plaats van de knop te plaatsen.
Veelgestelde vragen
Op welke spanning werkt de TTP223?
De TTP223-chip werkt op 2,0 tot 5,5 V; op een Arduino Uno wordt hij gevoed met 5 V en op een ESP32 of Raspberry Pi Pico met 3,3 V. Omdat het HIGH-niveau van de uitgang gelijk is aan de voedingsspanning, voed je de module altijd met de logicaspanning van het board waarop hij is aangesloten.
Waar dienen de pads A en B op de TTP223 voor?
A en B zijn optiejumpers die je met soldeer sluit. Op de meeste modules maakt jumper A de uitgang actief laag (LOW bij aanraking) en zet jumper B de sensor in schakelmodus, waarbij de uitgang bij elke aanraking omslaat en zo blijft. Met beide open staat de module in tikmodus en geeft hij HIGH zolang je hem aanraakt.
Werkt de TTP223 door glas of plastic heen?
Ja, hij werkt door plastic, acryl, glas, hout en papier heen, zolang er geen metaal in zit. In de praktijk zijn panelen van 1–3 mm dik meestal prima; dikkere panelen vragen om een vlak dat met kopertape is vergroot. Denk eraan de module zonder luchtspleet op het paneel te plakken.
Waarom schakelt mijn TTP223 uit zichzelf?
De meest voorkomende oorzaken zijn te hoge gevoeligheid, metalen onderdelen bij het vlak, lange elektrodedraden en een ruisende voeding. Een condensator van 5–20 pF tussen het vlak en GND verlaagt de gevoeligheid. Een condensator van 100 nF over VCC en GND plaatsen en een adapter van goede kwaliteit gebruiken lost het probleem meestal ook op.
Hoe schakel ik een lamp op netspanning met een TTP223?
De uitgang van de TTP223 kan maar een paar milliampère leveren, dus hij kan niet rechtstreeks een lamp of relaisspoel aansturen. Sluit de sensor aan op een Arduino en laat de Arduino een relaismodule aansturen; het relais kan alleen aan en uit schakelen, niet dimmen. Houd de netbedrading in een gesloten behuizing en plak het vlak nooit op een oppervlak dat met netspanning is verbonden.
Heb ik een TTP223 nodig voor aanraking op de ESP32?
Nee; de 10 aanraakpinnen van de klassieke ESP32 kun je rechtstreeks gebruiken met touchRead(). Je moet de drempel dan wel in software instellen en de metingen driften bij lange draden. Wil je een kant-en-klare, stabiele digitale uitgang, of gebruik je een board zonder aanraakpinnen zoals de ESP32-C3, dan is de TTP223 praktischer.
Projecten om hierna te bouwen
Alle projecten bekijken
LED schakelen met een knop (aan/uit)
Druk één keer op de knop en het licht gaat aan, druk nog een keer en het gaat uit, net als de lichtschakelaar in je kamer. De Arduino merkt elke druk op en zet de led in de tegenovergestelde toestand.

LED aansturen met een drukknop (Push)
Net als een deurbel: het licht blijft aan zolang je indrukt en gaat uit als je loslaat.

ESP32-ledbesturing met drukknop (Toggle)
Elke keer dat je op de knop drukt, verandert de led van stand: is hij aan, dan gaat hij uit; is hij uit, dan gaat hij aan. Het klassieke togglepatroon. Met debounce filteren we de mechanische ruis van de drukknop weg, zodat één druk precies één wisseling geeft.

Raspberry Pi Pico: led aan/uit met een knop (toggle)
Knop + led, een niveau hoger! Je hoeft de knop niet ingedrukt te houden. Indrukken en loslaten → led aan. Nog een keer → led uit (toggle). Dezelfde schakeling (led GP14, knop GP2), maar andere code. Je leert edge detection (het moment van 1→0 vastleggen), toestand bijhouden en debounce (filter tegen contactdender). led.toggle() van MicroPython wisselt de toestand in één regel. De basis van interactieve knopprojecten.

230V-lamp laten branden met een knop (aan/uit)
Wil je een echte lamp uit huis met een klein knopje aan- en uitzetten? Elke keer dat je op de knop drukt, schakelt de Arduino een relais om en gaat de lamp aan; druk je nog een keer, dan gaat hij uit.

Eenvoudige piano met buzzer en knoppen
Bouw je eigen kleine piano met acht knoppen. Elke knop is één noot, van laag naar hoog: do, re, mi, fa, sol, la, si en hoge do.

ESP32-led dimmen met PWM
De helderheid van de led soepel veranderen van 0 naar max en van max naar 0. We sturen PWM aan met analogWrite() zoals bij Arduino; dezelfde syntaxis werkt zonder problemen met ESP32 Arduino Core 3.0+. Een pindefinitie, pinMode en analogWrite zijn genoeg.

Slimme trap- en gangverlichting
Stap op de trap of in de gang en de lampjes gaan trede voor trede aan, in de richting waarin je loopt.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

