Pulsante, sensore tilt e touch TTP223: tre modi per dare un comando ad Arduino
Come usare INPUT_PULLUP con pulsante e sensore a sfera, perché il touch TTP223 va letto con INPUT, e come filtrare rimbalzi con millis() su UNO, Mega 2560 e Nano 33 IoT.

Livello: base · Schede: Arduino UNO, Mega 2560, Nano 33 IoT · Componenti: pulsante tattile (o modulo KY-004), sensore tilt a sfera SW-520D (o modulo KY-020), modulo touch TTP223, breadboard, cavetti · Tempo: 45 minuti
Il modo più semplice per dare un comando ad Arduino è chiudere un contatto verso massa e leggere il pin con digitalRead(). Perché la lettura sia affidabile serve però una resistenza che tenga il pin a un livello definito quando il contatto è aperto: è esattamente ciò che fa la modalità INPUT_PULLUP: con INPUT_PULLUP Arduino attiva una resistenza di pull-up interna al microcontrollore, senza aggiungere componenti sulla breadboard. In questo primo articolo della serie sui moduli del kit la useremo con tre sensori che, a prima vista, fanno la stessa cosa: un pulsante, un sensore di inclinazione (tilt) a sfera e un sensore touch capacitivo TTP223.
Dietro lo stesso segnale HIGH/LOW ci sono tre principi fisici diversi: un contatto meccanico che rimbalza, delle sferette che rotolano per gravità e un integrato che misura una variazione di capacità di pochi picofarad. Vedremo come funziona ciascuno, come collegarlo ad Arduino UNO, Mega 2560 e Nano 33 IoT (che lavora a 3,3 V), quale modo del pin scegliere, come filtrare i disturbi con millis() e, alla fine, costruiremo un piccolo interruttore a due comandi con allarme di ribaltamento.
Tre sensori, un solo tipo di segnale
Per il microcontrollore tutti e tre i sensori sono ingressi digitali: il pin viene letto come HIGH se la tensione supera la soglia V_IH e come LOW se scende sotto la soglia V_IL. La differenza sta in come il sensore porta il pin a quei livelli e nei disturbi che aggiunge al segnale. La tabella seguente riassume il confronto, che svilupperemo nelle prossime sezioni.
La distinzione più importante è tra contatto passivo e uscita attiva. Pulsante e tilt sono semplici interruttori: non generano alcuna tensione, si limitano a collegare o scollegare due terminali. Se il pin non ha un riferimento quando il contatto è aperto, resta «flottante» e legge valori casuali. Il TTP223, invece, ha un’uscita CMOS che porta da sola il pin a VCC o a massa: in questo caso la resistenza di pull-up non serve.
INPUT_PULLUP Arduino: come funziona il pull-up interno
Ogni pin digitale di ATmega328P (UNO), ATmega2560 (Mega) e SAMD21 (Nano 33 IoT) contiene una resistenza di pull-up che il programma può collegare tra il pin e l’alimentazione interna VDD. L’istruzione pinMode(pin, INPUT_PULLUP) configura il pin come ingresso e attiva questa resistenza. Con il contatto collegato tra il pin e GND si ottiene il circuito della figura.
A contatto aperto nella resistenza scorre solo la corrente d’ingresso del pin, dell’ordine del microampere, quindi la caduta su Rpu è trascurabile e il pin si trova praticamente a VDD: digitalRead() restituisce HIGH. A contatto chiuso il pin è collegato direttamente a massa e legge LOW, mentre nella resistenza scorre la corrente:
\(I = \frac{V_{DD}}{R_{pu}}\)
Il valore di Rpu non è preciso: per l’ATmega328P il datasheet indica 20–50 kΩ, per il SAMD21 20–60 kΩ (tipico 40 kΩ). Anche nel caso peggiore la corrente resta piccolissima, come mostra il calcolo seguente, quindi tenere premuto un pulsante a lungo non è un problema né per la scheda né per una batteria.
Corrente nel pull-up interno a contatto chiuso (esempio di calcolo) UNO / Mega 2560 (VDD = 5 V, Rpu = 20...50 kOhm) I max = 5 V / 20 kOhm = 0,25 mA I min = 5 V / 50 kOhm = 0,10 mA Nano 33 IoT (VDD = 3,3 V, Rpu = 20...60 kOhm) I max = 3,3 V / 20 kOhm = 0,165 mA I min = 3,3 V / 60 kOhm = 0,055 mA Soglie d'ingresso (dai datasheet) ATmega328P a 5 V : V_IL max = 0,3 x 5 = 1,5 V V_IH min = 0,6 x 5 = 3,0 V SAMD21 a 3,3 V : V_IL max = 0,3 x 3,3 = 0,99 V V_IH min = 0,55 x 3,3 = 1,82 V
Logica invertita: LOW significa «premuto»
Con il pull-up la logica è invertita: riposo = HIGH, azione = LOW. È la fonte di confusione più comune per chi inizia, ma è anche la configurazione più robusta, perché un cavetto che si stacca porta il pin a HIGH (stato di riposo) e non simula una pressione. Nel codice conviene quindi scrivere una costante come PULSANTE_ATTIVO = LOW e confrontare la lettura con quella, invece di disseminare il programma di == LOW. Le configurazioni pull-up e pull-down con resistenze esterne sono descritte nell’articolo Arduino: input digitali.
Perché non basta INPUT
Se si dimentica il pull-up e si usa pinMode(pin, INPUT) con un pulsante verso massa, a contatto aperto il pin non è collegato a nulla. L’ingresso CMOS ha un’impedenza altissima e una piccola capacità: basta avvicinare la mano o il cavetto di un altro segnale perché la tensione indotta superi le soglie e la lettura oscilli in modo casuale. Il sintomo tipico è un LED che si accende «da solo» quando si tocca la breadboard.
Il pulsante: contatto meccanico e rimbalzi
Il pulsante tattile da 6 mm del kit ha quattro terminali collegati a coppie al suo interno: i due terminali di ciascuna coppia sono sempre in contatto, mentre la pressione collega una coppia all’altra. Il modo più sicuro per non sbagliare è usare due terminali in diagonale, che appartengono sicuramente a coppie diverse. In alternativa, con il multimetro in modalità continuità, si individuano i terminali che risultano collegati anche a pulsante rilasciato.
Quando la lamella metallica si chiude non lo fa in modo netto: per elasticità rimbalza alcune volte nell’arco di qualche millisecondo, e Arduino, che legge il pin migliaia di volte al secondo, vede una raffica di pressioni. Il fenomeno e le soluzioni hardware sono trattati in dettaglio nella guida ai circuiti di debouncing; qui useremo la soluzione software: il nuovo stato viene accettato solo se resta stabile per 20–50 ms.
Il modulo KY-004
Alcuni kit forniscono il pulsante già montato su un modulo a tre pin (segnale, +, −) con una resistenza da 10 kΩ a bordo. Lo schema varia da un produttore all’altro: in genere la resistenza fa da pull-up esterno e il pulsante porta il segnale a massa, ma esistono versioni con la logica opposta. Prima di usarlo verifica con il multimetro quale pin va a massa alla pressione. Con la Nano 33 IoT il pin «+» va collegato a 3,3 V, mai a 5 V, perché la resistenza del modulo porterebbe il pin alla tensione di alimentazione.
Il sensore tilt a sfera
Il sensore di inclinazione SW-520D è un piccolo cilindro che contiene due sferette metalliche libere di rotolare. Quando il sensore è dritto, con i terminali in basso, la gravità tiene le sfere sul fondo e chiude il contatto tra i due reofori; inclinandolo oltre un certo angolo le sfere si spostano verso il cappuccio e il contatto si apre. Secondo il datasheet del costruttore il contatto ha una resistenza inferiore a 10 Ω, regge 12 V e cambia stato con inclinazioni dell’ordine di 10–45° a seconda della direzione: i valori precisi dipendono dal modello, quindi vanno verificati con il proprio esemplare.
Elettricamente è un interruttore come il pulsante, quindi si collega tra pin e GND con INPUT_PULLUP: dritto = contatto chiuso = LOW, inclinato = contatto aperto = HIGH. Il comportamento dinamico è però diverso. Mentre il sensore si inclina le sfere rotolano e saltellano, producendo una raffica di aperture e chiusure che può durare decine di millisecondi; anche una vibrazione del tavolo fa «chiacchierare» il contatto. Per questo il tempo di stabilità del filtro software va scelto più lungo che per il pulsante, tipicamente 50–150 ms.
È bene essere chiari sui limiti: il tilt a sfera dice solo «dritto» o «inclinato» e non misura l’angolo. Per conoscere l’inclinazione in gradi servirà un accelerometro, che vedremo più avanti nella serie con il modulo MPU6050. Esiste anche la versione a modulo (KY-020), con le stesse avvertenze sul pin di alimentazione viste per il KY-004.
Il sensore touch capacitivo TTP223
Il modulo touch è una piccola scheda con una piazzola di rame e l’integrato TTP223, un rilevatore di tocco a un canale. La piazzola forma con l’ambiente circostante e con il piano di massa un condensatore di pochi picofarad. Quando si avvicina un dito, il corpo umano (che è un conduttore collegato capacitivamente alla terra) aggiunge capacità in parallelo; l’integrato misura continuamente questa capacità e, se aumenta oltre una soglia rispetto al valore di riferimento, commuta l’uscita. Non c’è alcun contatto metallico: per questo il segnale non ha rimbalzi e la piazzola funziona anche attraverso un sottile strato di plastica o vetro.
Alcuni dati del datasheet sono utili per l’uso pratico:
- Alimentazione da 2,0 a 5,5 V: il modulo funziona sia a 5 V (UNO, Mega) sia a 3,3 V (Nano 33 IoT).
- Uscita CMOS push-pull (pin Q): porta attivamente il pin a VCC o a 0 V. A 3 V il datasheet indica una corrente di 4 mA erogata con VOH ≥ 2,4 V, ben sopra la soglia V_IH di 1,82 V della Nano 33 IoT.
- Tempo di risposta fino a circa 60 ms in modalità veloce e 220 ms in modalità a basso consumo: il TTP223 non è adatto a comandi rapidissimi, ma per un tasto è più che sufficiente.
- Calibrazione all’accensione: nei primi 0,5 s circa dopo l’alimentazione l’integrato misura la capacità «a riposo». In quel momento la piazzola non va toccata, altrimenti il riferimento risulta sbagliato.
- Ricalibrazione automatica: l’integrato aggiorna periodicamente il riferimento per seguire le variazioni lente (umidità, temperatura). Un oggetto appoggiato sulla piazzola per molti secondi finisce quindi per essere «dimenticato»; alcune versioni del chip limitano inoltre la durata massima di un tocco continuo.
Le quattro modalità: diretto o toggle, attivo alto o basso
Il TTP223 ha due ingressi di configurazione, TOG e AHLB, che sul modulo corrispondono ai due ponticelli a saldare marcati di solito A e B. Entrambi hanno una resistenza interna verso massa, quindi a ponticello aperto valgono 0. La modalità predefinita (tutti aperti) è diretta e attiva alta: l’uscita è HIGH finché il dito resta sulla piazzola. Chiudendo il ponticello del toggle l’uscita cambia stato a ogni tocco, come un interruttore bistabile.
Per questo articolo lasciamo i ponticelli aperti: il toggle lo realizziamo via software, così lo stesso codice gestisce allo stesso modo pulsante e touch. Poiché l’uscita è attiva, il pin si configura con pinMode(pin, INPUT). Attivare anche il pull-up non danneggia nulla, perché l’uscita push-pull lo «vince» facilmente, ma è inutile e a uscita bassa fa scorrere un decimo di milliampere in più.
Collegamenti con UNO, Mega 2560 e Nano 33 IoT
Abbiamo scelto i pin D2, D3 e D4 perché esistono con lo stesso nome su tutte e tre le schede, e D2 e D3 supportano gli interrupt esterni su UNO, Mega 2560 e Nano 33 IoT: torneranno utili se in futuro vorrai gestire i comandi con attachInterrupt(), come spiegato nell’articolo sugli interrupt esterni e le ISR. Come «lampada» usiamo il LED integrato LED_BUILTIN, che su tutte e tre le schede è collegato al pin D13.
| Terminale del sensore | Arduino UNO | Arduino Mega 2560 | Arduino Nano 33 IoT |
|---|---|---|---|
| Pulsante, terminale 1 | D2 | D2 | D2 |
| Pulsante, terminale 2 (in diagonale) | GND | GND | GND |
| Tilt SW-520D, terminale 1 | D3 | D3 | D3 |
| Tilt SW-520D, terminale 2 | GND | GND | GND |
| TTP223 VCC | 5V | 5V | 3V3 (mai 5 V) |
| TTP223 I/O (SIG, OUT) | D4 | D4 | D4 |
| TTP223 GND | GND | GND | GND |
| Lampada (LED integrato) | LED_BUILTIN (D13) | LED_BUILTIN (D13) | LED_BUILTIN (D13) |
Attenzione alla Nano 33 IoT
La Nano 33 IoT lavora a 3,3 V e, come precisa la documentazione ufficiale, i suoi pin non tollerano i 5 V: una tensione di 5 V applicata a un ingresso può danneggiare la scheda. Con pulsante e tilt il problema non si pone, perché il pull-up interno è collegato ai 3,3 V. Con il TTP223 invece l’uscita va alla tensione di alimentazione del modulo, quindi il modulo deve essere alimentato dal pin 3V3.
Il pin 5V della Nano 33 IoT, inoltre, non è un’uscita sempre attiva: è collegato all’ingresso USB attraverso un ponticello a saldare (VUSB) che di fabbrica è aperto. Solo dopo averlo chiuso, e solo quando la scheda è alimentata dalla USB, il pin fornisce 5 V; con altre alimentazioni resta senza tensione. Anche quando è attivo, quei 5 V non vanno mai portati su un pin di I/O.
Sketch 1: leggere i tre ingressi sul Monitor seriale
Il primo sketch serve a verificare i collegamenti: legge i tre pin e stampa una riga ogni volta che uno di essi cambia stato. Funziona senza modifiche su tutte e tre le schede. Le righe con while (!Serial ...) attendono al massimo 3 secondi l’apertura della porta USB nativa della Nano 33 IoT, così le prime stampe non vanno perse; su UNO e Mega la condizione è subito falsa e non hanno effetto.
// Lettura di pulsante, tilt e touch TTP223: stampa ogni cambio di stato
// Schede: Arduino UNO, Mega 2560, Nano 33 IoT (stessi pin)
const uint8_t PIN_PULSANTE = 2; // contatto verso GND, pull-up interno
const uint8_t PIN_TILT = 3; // contatto verso GND, pull-up interno
const uint8_t PIN_TOUCH = 4; // uscita push-pull del TTP223
int ultimoPulsante = -1; // -1: valore impossibile, forza la prima stampa
int ultimoTilt = -1;
int ultimoTouch = -1;
void setup() {
Serial.begin(115200);
unsigned long t0 = millis();
while (!Serial && millis() - t0 < 3000) {
// Nano 33 IoT: attende la porta USB nativa (al massimo 3 s)
}
pinMode(PIN_PULSANTE, INPUT_PULLUP);
pinMode(PIN_TILT, INPUT_PULLUP);
pinMode(PIN_TOUCH, INPUT); // il TTP223 pilota il pin da solo
}
void loop() {
int p = digitalRead(PIN_PULSANTE);
int t = digitalRead(PIN_TILT);
int c = digitalRead(PIN_TOUCH);
if (p != ultimoPulsante || t != ultimoTilt || c != ultimoTouch) {
Serial.print("pulsante: ");
Serial.print(p == LOW ? "PREMUTO " : "rilasciato");
Serial.print(" | tilt: ");
Serial.print(t == LOW ? "dritto " : "INCLINATO ");
Serial.print(" | touch: ");
Serial.println(c == HIGH ? "TOCCATO" : "libero");
ultimoPulsante = p;
ultimoTilt = t;
ultimoTouch = c;
}
}
Aprendo il Monitor seriale a 115200 baud e premendo una volta il pulsante si ottiene qualcosa di simile all’esempio seguente. Le righe ripetute sono i rimbalzi del contatto: con alcuni pulsanti non compaiono, con altri sono numerose. Inclinando il sensore tilt le righe ripetute sono di solito molte di più.
Esempio di output (Monitor seriale, 115200 baud) pulsante: rilasciato | tilt: dritto | touch: libero pulsante: PREMUTO | tilt: dritto | touch: libero pulsante: rilasciato | tilt: dritto | touch: libero pulsante: PREMUTO | tilt: dritto | touch: libero pulsante: rilasciato | tilt: dritto | touch: libero pulsante: rilasciato | tilt: dritto | touch: TOCCATO pulsante: rilasciato | tilt: dritto | touch: libero
Sketch 2: debounce non bloccante e mini-progetto
Il secondo sketch è il mini-progetto: un interruttore a due comandi con allarme di ribaltamento, pensato per una scatola o una lampada da tavolo. Il pulsante e la piazzola touch accendono e spengono la lampada (il LED integrato) con un tocco; se la scatola si ribalta, il sensore tilt fa lampeggiare velocemente il LED finché non viene rimessa in piedi.
Per filtrare i disturbi ogni ingresso ha una piccola struttura con l’ultimo stato stabile e l’istante dell’ultimo cambiamento. La funzione aggiorna() accetta il nuovo livello solo se è rimasto invariato per il tempo richiesto e restituisce true nel momento in cui lo stato stabile cambia. Il tempo di stabilità è diverso per ciascun sensore, come visto nella tabella di confronto. Tutto è gestito con millis(): il loop() non si ferma mai e può fare altro, come far lampeggiare il LED. Se la tecnica è nuova, l’articolo Semplice orologio con la funzione millis() ne mostra il principio.
// Mini-progetto: interruttore a due comandi con allarme di ribaltamento
// - pulsante (D2) e touch TTP223 (D4) accendono/spengono la lampada
// - il tilt (D3) fa lampeggiare la lampada se la scatola si ribalta
// Schede: Arduino UNO, Mega 2560, Nano 33 IoT
const uint8_t PIN_PULSANTE = 2;
const uint8_t PIN_TILT = 3;
const uint8_t PIN_TOUCH = 4;
const uint8_t PIN_LAMPADA = LED_BUILTIN; // D13 su tutte e tre le schede
// Livello che significa "evento attivo" per ciascun ingresso
const uint8_t PULSANTE_ATTIVO = LOW; // pull-up: premuto = LOW
const uint8_t TILT_ATTIVO = HIGH; // contatto aperto = inclinato
const uint8_t TOUCH_ATTIVO = HIGH; // TTP223 diretto, attivo alto
// Tempi di stabilita' (punto di partenza, da adattare al proprio modulo)
const uint16_t STABILE_PULSANTE_MS = 25;
const uint16_t STABILE_TILT_MS = 80;
const uint16_t STABILE_TOUCH_MS = 5;
const unsigned long PERIODO_LAMPEGGIO_MS = 100;
struct Ingresso {
uint8_t pin;
uint16_t stabileMs; // tempo minimo di stabilita' richiesto
uint8_t statoStabile; // ultimo stato accettato
uint8_t ultimaLettura; // ultima lettura grezza
unsigned long tCambio; // istante dell'ultima variazione grezza
};
Ingresso pulsante = {PIN_PULSANTE, STABILE_PULSANTE_MS, HIGH, HIGH, 0};
Ingresso tilt = {PIN_TILT, STABILE_TILT_MS, HIGH, HIGH, 0};
Ingresso touch = {PIN_TOUCH, STABILE_TOUCH_MS, LOW, LOW, 0};
bool lampadaAccesa = false;
bool allarme = false;
bool faseLampeggio = false;
unsigned long tLampeggio = 0;
// Legge lo stato attuale e lo usa come stato stabile iniziale
void inizializza(Ingresso &in) {
in.statoStabile = digitalRead(in.pin);
in.ultimaLettura = in.statoStabile;
in.tCambio = millis();
}
// Aggiorna il filtro: restituisce true quando lo stato stabile cambia
bool aggiorna(Ingresso &in) {
uint8_t lettura = digitalRead(in.pin);
unsigned long ora = millis();
if (lettura != in.ultimaLettura) { // variazione grezza: riparte il conteggio
in.ultimaLettura = lettura;
in.tCambio = ora;
}
if (lettura != in.statoStabile && (ora - in.tCambio) >= in.stabileMs) {
in.statoStabile = lettura; // stabile abbastanza a lungo: accettato
return true;
}
return false;
}
void setup() {
Serial.begin(115200);
pinMode(PIN_PULSANTE, INPUT_PULLUP);
pinMode(PIN_TILT, INPUT_PULLUP);
pinMode(PIN_TOUCH, INPUT);
pinMode(PIN_LAMPADA, OUTPUT);
delay(600); // TTP223: non toccare la piazzola durante la calibrazione
inizializza(pulsante);
inizializza(tilt);
inizializza(touch);
allarme = (tilt.statoStabile == TILT_ATTIVO);
}
void loop() {
// Comandi on/off: agiscono solo sul fronte "attivo"
if (aggiorna(pulsante) && pulsante.statoStabile == PULSANTE_ATTIVO) {
lampadaAccesa = !lampadaAccesa;
Serial.println(lampadaAccesa ? "Lampada ON (pulsante)" : "Lampada OFF (pulsante)");
}
if (aggiorna(touch) && touch.statoStabile == TOUCH_ATTIVO) {
lampadaAccesa = !lampadaAccesa;
Serial.println(lampadaAccesa ? "Lampada ON (touch)" : "Lampada OFF (touch)");
}
// Allarme di ribaltamento: segue lo stato filtrato del tilt
if (aggiorna(tilt)) {
allarme = (tilt.statoStabile == TILT_ATTIVO);
Serial.println(allarme ? "ATTENZIONE: scatola ribaltata" : "Scatola di nuovo dritta");
}
if (allarme) {
unsigned long ora = millis();
if (ora - tLampeggio >= PERIODO_LAMPEGGIO_MS) {
tLampeggio = ora;
faseLampeggio = !faseLampeggio;
digitalWrite(PIN_LAMPADA, faseLampeggio ? HIGH : LOW);
}
} else {
digitalWrite(PIN_LAMPADA, lampadaAccesa ? HIGH : LOW);
}
}
Alcuni dettagli meritano attenzione. La sottrazione ora - in.tCambio tra valori unsigned long resta corretta anche quando millis() riparte da zero dopo circa 49,7 giorni. La funzione inizializza() legge lo stato reale dei pin all’avvio: senza di essa, una scatola accesa già inclinata o un dito sul touch genererebbero un falso evento. Il delay(600) in setup() è l’unico ritardo bloccante del programma ed è voluto: lascia al TTP223 il tempo di completare la calibrazione prima della prima lettura. Infine, il comando avviene sul fronte (il passaggio allo stato attivo) e non sul livello: tenendo premuto il pulsante la lampada cambia stato una sola volta.
Esempio di output (Monitor seriale, 115200 baud) Lampada ON (pulsante) Lampada OFF (touch) Lampada ON (touch) ATTENZIONE: scatola ribaltata Scatola di nuovo dritta Lampada OFF (pulsante)
Taratura e regolazione
I tre sensori non hanno trimmer, ma qualche parametro va comunque adattato al proprio montaggio. La procedura seguente è un punto di partenza.
Procedura di messa a punto 1. Carica lo Sketch 1 e verifica che ogni sensore cambi stato nel verso atteso. Se il tilt e' montato capovolto, inverti TILT_ATTIVO nello Sketch 2. 2. Pulsante: se con 25 ms compaiono ancora doppi comandi, porta STABILE_PULSANTE_MS a 40-50 ms (pulsanti usurati rimbalzano di piu'). 3. Tilt: fissa il sensore alla scatola nella posizione definitiva e prova a urtare il tavolo. Se l'allarme scatta per una vibrazione, aumenta STABILE_TILT_MS (100-150 ms). Se reagisce troppo tardi, riducilo. 4. Touch: fissa il modulo dietro un pannello di plastica o legno sottile (pochi mm) e verifica la sensibilita'. Il datasheet prevede un condensatore di regolazione Cs (0-50 pF) sul pin di ingresso: capacita' minore = sensibilita' maggiore. Sui moduli e' gia' saldato o assente; modificarlo richiede saldature SMD. 5. Accendi sempre il sistema senza toccare la piazzola e senza oggetti appoggiati sopra: la calibrazione avviene in quel mezzo secondo.
Se i cavetti verso il pulsante o il tilt sono lunghi (oltre qualche decina di centimetri), il pull-up interno da qualche decina di kΩ diventa sensibile ai disturbi. In quel caso conviene aggiungere una resistenza esterna da 4,7–10 kΩ tra il pin e la tensione di alimentazione della scheda: 5 V per UNO e Mega, 3,3 V per la Nano 33 IoT.
Errori comuni
- Pin flottante: pulsante verso GND con
INPUTinvece diINPUT_PULLUP. Le letture cambiano da sole avvicinando la mano. - Terminali del pulsante sbagliati: usando due terminali della stessa coppia interna il pin è sempre LOW. Usa due terminali in diagonale.
- Logica invertita dimenticata: con il pull-up premuto = LOW. Definisci una costante per il livello attivo invece di scrivere
HIGHoLOWqua e là nel codice. - Touch a 5 V sulla Nano 33 IoT: l’uscita del TTP223 sale alla tensione di alimentazione del modulo e porta 5 V su un pin che non li tollera. Alimentalo dal pin 3V3.
- Piazzola toccata all’accensione: il TTP223 si calibra «con il dito sopra» e poi non riconosce il tocco, o lo vede sempre. Togli e ridai alimentazione senza toccare.
- Ponticelli A/B chiusi per errore: il modulo funziona in toggle o con logica invertita. Confronta il comportamento con la tabella delle modalità.
- Debounce con
delay(): undelay(50)dopo ogni lettura funziona con un solo pulsante, ma blocca il programma e fa perdere gli altri eventi. Usa un filtro conmillis()come nello Sketch 2. - Usare il tilt come sensore d’angolo: dà solo due stati e la soglia dipende dal modello e dalla direzione d’inclinazione. Per misurare gradi serve un accelerometro.
Fonti e approfondimenti
- Arduino Nano 33 IoT (ABX00027): piedinatura completa ufficiale
- Arduino Help Center: abilitare i 5 V sul pin VUSB delle schede Nano
- Arduino Language Reference: attachInterrupt() e pin di interrupt per scheda
- Microchip SAM D21: caratteristiche dei pin di I/O (pull-up, soglie)
- TTP223 (Tontek): datasheet del rilevatore di tocco a un canale










