Sensore touch TTP223 con Arduino: modalità, schema e lampada

Il sensore touch TTP223 è un modulo touch capacitivo a un tasto, molto economico, che sostituisce un pulsante meccanico e riconosce il tuo dito grazie a una variazione di capacità. Ha solo tre pin (VCC, GND e I/O): quando lo tocchi l'uscita va a HIGH, quando togli il dito torna a LOW. Grazie a questa semplicità su Arduino lo leggi con digitalRead() proprio come un pulsante e, dato che funziona tra 2 e 5,5 V, si collega direttamente anche a un ESP32 o a un Raspberry Pi Pico. Senza parti mobili non si consuma, non fa clic e si può nascondere dietro un sottile strato di plastica, vetro o legno.

In questa guida imparerai passo dopo passo cosa succede dentro il TTP223, come usare i ponticelli di stagno A e B sulla scheda per scegliere la modalità momentanea o bistabile (toggle) e l'uscita attiva alta o attiva bassa, come costruire con Arduino una lampada touch che si accende con un tocco breve e si regola con un tocco lungo, come far funzionare il sensore dietro un pannello, come usare più tasti, in cosa differisce dai pin touch integrati dell'ESP32 e come usarlo sul Pico con MicroPython.

Che cos'è il sensore touch TTP223 e come funziona?

La piazzola di rame del modulo e l'area di massa (GND) della scheda formano un minuscolo condensatore di pochi picofarad. Quando il dito si avvicina alla piazzola, il tuo corpo si aggiunge a quel condensatore e la capacità totale aumenta di qualche picofarad. L'oscillatore di misura del TTP223, a circa 1 MHz, rileva questo aumento come una variazione di frequenza, confronta il risultato con un valore di riferimento che conserva e cambia l'uscita se la differenza è abbastanza grande. La formula del condensatore a facce piane parallele C = ε·A/d vale anche qui: più grande è l'area della piazzola (A) e più sottile il materiale tra dito e piazzola (d), migliore è il rilevamento.

Il chip stabilisce da solo il proprio valore di riferimento. Appena gli dai alimentazione misura l'ambiente per circa 0,5 secondi e in questo tempo ignora i tocchi. In seguito, finché nessuno lo tocca, si ricalibra circa ogni 4 secondi, così le variazioni lente come temperatura e umidità vengono compensate nel tempo. Per questo il sensore considera "non toccato" tutto ciò che circonda la piazzola all'accensione: se il tuo dito è sulla piazzola quando lo alimenti, non ti vedrà affatto.

Nella versione TTP223-BA6 usata su questi moduli alcune opzioni sono fissate dentro il package: il chip funziona sempre in modalità a basso consumo e il limite di 100 secondi di "tempo massimo di attivazione" presente in altri package è disattivato. In modalità a basso consumo il chip assorbe solo pochi microampere, ma può impiegare fino a circa 220 ms per rispondere al primo tocco. Dopo aver rilevato un tocco resta per circa 12 secondi in modalità veloce e risponde molto più in fretta ai tocchi successivi. In una lampada o in un campanello non noterai questo ritardo, ma tienilo presente se costruisci un controller di gioco che richiede reazioni rapide.

Pinout e collegamento del TTP223

Dato che il pin di uscita porta da solo il segnale a HIGH e a LOW, su Arduino non servono INPUT_PULLUP né una resistenza esterna: basta impostare il pin come INPUT. Qui non ci sono rimbalzi come nei pulsanti meccanici, perché il chip cambia l'uscita solo quando il tocco è stabile. Se però vuoi che il codice conti un tocco come un unico evento, usa il rilevamento del fronte che spieghiamo in come collegare un pulsante.

Scegliere la modalità con i ponticelli A e B

Accanto al chip, sul modulo ci sono due piccole coppie di piazzole di saldatura marcate A e B. Sono collegate a due pin di configurazione del chip: sulla maggior parte dei moduli A sceglie se l'uscita è attiva alta o attiva bassa (AHLB), mentre B sceglie se il sensore lavora in modalità momentanea o bistabile (TOG). All'interno del chip questi pin sono portati a GND da una resistenza, quindi con le piazzole aperte l'opzione vale "0"; se unisci le due piazzole con una goccia di stagno diventa "1". Dopo aver cambiato un ponticello, la cosa più sicura è togliere e ridare alimentazione. Se le scritte sulla tua scheda sono diverse, puoi verificare facilmente la modalità con il LED del primo sketch di prova.

Primo test con Arduino: leggere un tocco

1. Collega il pin VCC del modulo al pin 5V di Arduino, GND a GND e il pin I/O a D2.
2. Carica lo sketch qui sotto e apri il Monitor seriale a 9600 baud.
3. Dopo l'avvio della scheda aspetta circa un secondo senza toccare la piazzola; in questo tempo il chip si calibra.
4. Tocca la piazzola con il dito: il LED integrato di Arduino sul pin 13 (e, sulla maggior parte dei moduli, anche il LED della scheda) dovrebbe accendersi e il numero di tocchi nel Monitor seriale dovrebbe aumentare di uno.
5. Finché tieni il dito sulla piazzola il LED resta acceso, mentre il contatore aumenta una sola volta per ogni nuovo tocco.

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}

La parte più importante del codice è il rilevamento del fronte. La lettura precedente viene salvata nella variabile lastState; se la nuova lettura è HIGH e la precedente era LOW, si tratta di un nuovo tocco. Senza questo controllo il contatore aumenterebbe a ogni ciclo del loop finché il dito resta sulla piazzola, cioè migliaia di volte al secondo. L'attesa di 600 ms in setup() garantisce che il chip abbia finito di calibrarsi quando Arduino e modulo vengono alimentati insieme. Abbiamo scelto D2 perché è uno dei pin di interrupt dell'Uno; se vuoi, puoi catturare il tocco anche con un interrupt usando attachInterrupt(digitalPinToInterrupt(2), funzione, RISING).

Progetto: lampada touch con Arduino

Ora costruiamo una vera lampada touch: un tocco breve la accende e la spegne, se tieni il dito sulla piazzola mentre è accesa la luce si abbassa lentamente e con il tocco lungo successivo torna a salire. Dato che la luminosità si regola in PWM, colleghiamo la lampada a D9, uno dei pin PWM dell'Uno. Per le prove bastano un LED e una resistenza da 220 Ω su D9 (trovi il valore giusto con il calcolatore di resistenza per LED). Se usi una striscia LED a 12 V, inserisci un MOSFET logic level come l'IRLZ44N; i dettagli sono in usare un MOSFET con 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}

Nota che nel codice non c'è nemmeno un delay(): tutta la temporizzazione avviene con millis(), quindi il loop continua a girare e non perde nessun tocco. Trovi altri dettagli su questa tecnica in millis() e delay(). Poiché l'ultima luminosità resta nella variabile brightness, quando spegni e riaccendi la lampada la luce torna al livello impostato per ultimo, proprio come le lampade touch da comodino dei negozi.

Rilevamento attraverso materiali sottili

La caratteristica più amata del TTP223 è che funziona dall'interno di una scatola senza fori. Plastica, acrilico, vetro, legno, carta e tessuto lasciano passare il campo elettrico; il materiale tra piazzola e dito si comporta come il dielettrico di un condensatore. Più il materiale è spesso, più cresce d nella formula e più diminuisce la capacità tra dito e piazzola; raddoppiare lo spessore dimezza all'incirca questa capacità. Il vetro ha una costante dielettrica più alta della maggior parte delle plastiche, quindi a parità di spessore di solito dà risultati migliori. In pratica il modulo funziona quasi sempre senza problemi dietro un pannello di plastica, acrilico o vetro da 1–3 mm; con pannelli più spessi ti servirà una piazzola più grande e conviene sempre provare con il tuo materiale.

• Niente intercapedine d'aria: l'aria ha una costante dielettrica pari a 1 e anche uno spazio di 1 mm riduce molto la sensibilità. Fissa saldamente il modulo al pannello, con il lato della piazzola rivolto verso di esso, usando un nastro biadesivo sottile o della colla.
• Ingrandisci la piazzola: per un'area touch più grande ritaglia un elettrodo da nastro di rame o foglio di alluminio, gratta con delicatezza la vernice protettiva in un angolo della piazzola e salda l'elettrodo con un filo molto corto. Più il filo è lungo, più aggiunge capacità propria e più il sensore diventa instabile.
• Evita il metallo: pannelli metallici, materiali con cariche metalliche e vernici metallizzate concentrano il campo elettrico su di sé; il sensore o non rileva nulla o si attiva da solo.
• Riduci la sensibilità eccessiva: se il sensore scatta prima che il dito si avvicini, aggiungi un piccolo condensatore ceramico da 5–20 pF (Cs) tra la piazzola e GND; più alto è il valore, più bassa è la sensibilità, con 50 pF come limite. Puoi decifrare il codice stampato sul condensatore (ad es. 100 = 10 pF, 220 = 22 pF) con lo strumento codice dei condensatori.
• Prima monta, poi alimenta: poiché all'accensione il chip prende l'ambiente come riferimento, dai alimentazione solo dopo aver montato pannello e coperchio. Se monti il pannello con il modulo acceso, il chip potrebbe considerarlo un tocco permanente; in questo caso basta togliere e ridare alimentazione.

Usare più tasti touch

Ogni TTP223 controlla la propria piazzola in modo indipendente; se vuoi quattro tasti, colleghi quattro moduli a quattro pin digitali separati, con i moduli che condividono VCC e GND. Se i tasti sono molto vicini, il dito può influenzare anche la piazzola accanto; lascia almeno 1–2 cm tra le piazzole e tieni i moduli lontani dai cavi di motori e relè. Lo sketch qui sotto usa quattro TTP223 e un buzzer passivo per creare un piccolo pianoforte touch: ogni tasto che tocchi suona la sua nota e il suono si ferma quando sollevi il dito.

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}

Poiché tone() può suonare una sola nota alla volta, il codice sceglie il primo tasto toccato e aggiorna la nota solo quando cambia, così il suono non gracchia. Sull'Uno tone() usa il Timer2, quindi mentre il buzzer suona analogWrite non funziona sui pin 3 e 11; qui non è un problema, perché il pianoforte usa D3 solo come ingresso. Se ti servono molti tasti, è più ordinato passare a chip multicanale invece di usare un modulo per tasto: il TTP224 offre quattro tasti con quattro uscite separate, il TTP229 legge 8 o 16 tasti tramite un'interfaccia seriale a due fili e l'MPR121 controlla 12 elettrodi via I2C.

ESP32: TTP223 o i pin touch integrati?

L'ESP32 classico ha un sensore touch capacitivo integrato e 10 pin (T0–T9) si possono usare come tasti touch senza alcun modulo: nell'ordine GPIO 4, 0, 2, 15, 13, 12, 14, 27, 33 e 32. La funzione touchRead() restituisce un valore grezzo; sull'ESP32 classico questo valore scende quando tocchi il pin, mentre su ESP32-S2 e S3 sale. L'ESP32-C3 non ha alcun sensore touch. Per approfondire i pin integrati leggi i pin touch dell'ESP32; la tabella qui sotto mette a confronto le due soluzioni.

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}

All'avvio questo sketch misura il valore di T0 non toccato e ne usa il 70% come soglia; osserva il valore grezzo nel Monitor seriale (115200 baud) per adattare il rapporto al tuo cablaggio. Se usi un ESP32-S3, il valore sale quando tocchi, quindi inverti il confronto (per esempio soglia = valore misurato × 1,3 e raw > soglia). Abbiamo collegato il TTP223 a GPIO 26 anche perché è un GPIO RTC: con esp_sleep_enable_ext0_wakeup(GPIO_NUM_26, 1) puoi mettere l'ESP32 in deep sleep e risvegliarlo con un tocco. Dato che il TTP223 consuma solo pochi microampere, i due formano una coppia ideale per i progetti a batteria; trovi i dettagli in deep sleep dell'ESP32.

TTP223 con il Raspberry Pi Pico (MicroPython)

Il chip RP2040 del Pico non ha un sensore touch, quindi il TTP223 è il modo più semplice per aggiungere un tasto touch al Pico. Alimenta il modulo dal pin 3V3(OUT) (pin fisico 36) e collega il pin I/O a GP15 (pin fisico 20). Il codice MicroPython qui sotto cambia lo stato del LED integrato a ogni tocco. Poiché cattura il tocco con un interrupt (IRQ), nessun tocco va perso anche quando il loop principale è impegnato in altro. Se non sai ancora come installare MicroPython sul Pico, parti da Che cos'è il 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)

Nelle versioni attuali di MicroPython il nome Pin("LED") seleziona il LED integrato sia sul Pico sia sul Pico W. Se hai saldato il ponticello B e messo il modulo in modalità bistabile, non serve nemmeno l'interrupt: basta scrivere led.value(touch.value()) nel loop, perché ora è il chip stesso a ricordare lo stato acceso/spento. Anche se l'uscita del chip non rimbalza, il blocco di 250 ms nel codice impedisce che brevi impulsi di disturbo su cavi lunghi cambino il LED due volte.

Idee di progetto con il TTP223

• Luce notturna touch: aggiungi un LDR così la lampada risponde al tocco solo quando è buio.
• Lampada che cambia colore: cambia il colore di un anello WS2812B NeoPixel a ogni tocco e regola la luminosità con un tocco lungo.
• Serratura a combinazione nascosta: metti quattro TTP223 dietro un pannello in acrilico; toccando i tasti nell'ordine giusto un servomotore apre la serratura.
• Campanello senza fori: incolla il sensore dentro una scatola di plastica; al tocco un DFPlayer Mini suona il campanello.
• Interruttore touch per presa: accendi e spegni una lampada da scrivania o un ventilatore con un modulo relè.
• Telecomando a batteria: tieni un ESP32 in deep sleep; quando tocchi il TTP223 si risveglia e invia un comando via ESP-NOW.

Errori comuni e soluzioni

Il TTP223 è il modo più semplice per dare ai tuoi progetti un'interfaccia touch moderna con un modulo molto economico: sostituisce il pulsante meccanico, funziona dietro pannelli senza fori e va d'accordo con qualsiasi microcontrollore. Prova prima a leggerlo con l'impostazione di fabbrica, poi consolida il rilevamento del fronte e la logica del tocco lungo con gli esempi della lampada e del pianoforte. Nell'app BlueGrays trovi passo dopo passo, con schemi e codice, i progetti per accendere un LED con un pulsante, il LED on/off, i progetti con pulsanti per ESP32 e Pico e il comando di una lampadina a 230 V, e puoi trasformarli tutti in progetti touch montando un TTP223 al posto del pulsante.