
Dal gesto fisico all’informazione digitale: impariamo a leggere un pulsante, stabilizzare l’ingresso, comandare un LED, riconoscere eventi e contare pressioni reali.
Metodo di studio: per ogni circuito formula prima una previsione (rilasciato/premuto), controlla i collegamenti, poi confronta la lettura e il risultato osservato. La simulazione non sostituisce la verifica sul circuito fisico.
1. Perché Arduino deve leggere il mondo esterno
Nei capitoli precedenti Arduino comandava un LED: il programma decideva quale tensione applicare all’uscita. Un sistema interattivo deve anche ricevere informazioni. Un pulsante, un finecorsa o un sensore digitale modificano una condizione elettrica che un ingresso può leggere.
Un sistema embedded non è utile soltanto quando esegue una sequenza prefissata: spesso deve reagire all’ambiente. Un finecorsa comunica il raggiungimento di una posizione; un interruttore seleziona un modo operativo; un sensore con uscita digitale segnala il superamento di una soglia. In tutti questi casi il microcontrollore non conosce direttamente l’evento fisico: conosce una condizione elettrica.
Esempio pratico: uno studente preme un pulsante collegato a D2; i contatti si chiudono, la tensione del pin cambia, digitalRead() la classifica e un’istruzione if decide se accendere il LED su D8. Questa catena distingue evento, segnale e decisione. Un collegamento sbagliato può far apparire errata una logica software perfettamente corretta.

2. Ingressi e uscite digitali
Sull’Uno R3 i pin D0–D13 possono svolgere funzioni digitali. pinMode(pin, OUTPUT) imposta un’uscita; pinMode(pin, INPUT) un ingresso ad alta impedenza; pinMode(pin, INPUT_PULLUP) un ingresso con richiamo interno verso il positivo. I pin D0/D1 sono normalmente impiegati dalla comunicazione seriale USB ed è opportuno lasciarli liberi negli esempi.
Un’uscita tenta di imporre un livello elettrico; un ingresso osserva la tensione senza misurarla numericamente come farebbe un ADC. HIGH e LOW sono classificazioni logiche, non sinonimi di “pulsante premuto” e “pulsante rilasciato”. I registri interni di direzione e lettura del microcontrollore realizzano queste operazioni, mentre le funzioni Arduino evitano di manipolarli direttamente.
Nel microcontrollore ATmega328P la direzione elettrica dei pin dipende da registri chiamati DDRx (Data Direction Register). I registri PORTx controllano il valore di uscita e, quando il pin è ingresso, l’abilitazione del pull-up; i registri PINx consentono di leggere i livelli presenti. La lettera x identifica il gruppo di pin. Non è necessario manipolarli direttamente: pinMode(), digitalWrite() e digitalRead() forniscono un’interfaccia più semplice e portabile.
Per gli ingressi digitali dell’ATmega328P alimentato a 5 V, il datasheet specifica soglie garantite per LOW e HIGH (nelle condizioni operative indicate): valori al di sotto di circa 0,3·Vcc sono riconosciuti LOW e al di sopra di circa 0,6·Vcc HIGH; tra queste regioni non si deve attribuire un livello garantito. Non interpretare tali soglie come una misura analogica di tensione. È fondamentale evitare un segnale che rimanga nella zona indefinita.
3. Il pulsante: contatti NO, NC e quattro terminali
Un pulsante normalmente aperto (NO) interrompe il collegamento quando è rilasciato e lo chiude durante la pressione; uno normalmente chiuso (NC) si comporta al contrario. Una pressione è quindi un’azione meccanica che modifica la continuità elettrica.
Prima di inserire il pulsante nella breadboard, individuare quali coppie di piedini sono già collegate: nella disposizione comune le due gambe dello stesso lato sono in continuità anche senza pressione, mentre i lati opposti entrano in contatto premendo. Il componente può essere ruotato e disegnato in modo diverso: verificare sempre con un multimetro in modalità continuità.
Quando il pulsante attraversa la scanalatura centrale della breadboard, ogni lato deve essere collegato a un gruppo di fori distinto. Se entrambi i fili finiscono nello stesso nodo già comune, la pressione non produce alcuna variazione elettrica. I pulsanti NC sono utili per applicazioni che richiedono una condizione di riposo chiusa, ma qui impieghiamo pulsanti NO.

4. Ingresso flottante: perché le letture cambiano
Un ingresso configurato INPUT presenta impedenza elevata: assorbe poca corrente e può reagire a minimi accoppiamenti elettrici. Se il pin non è collegato né a 5 V né a GND attraverso una rete adeguata, il suo potenziale non è definito.
Un filo libero può captare disturbi, cariche e variazioni nell’ambiente. digitalRead() può restituire HIGH oppure LOW senza che il pulsante sia stato premuto. Non significa che Arduino “sbagli”: il circuito non ha specificato quale livello debba rappresentare il riposo. La soluzione è dare al nodo una tensione di riferimento tramite pull-up o pull-down.
L’alta impedenza è utile: un ingresso non deve assorbire corrente significativa dal circuito che sta osservando. Ma significa anche che piccole cariche capacitive, cavi lunghi, mani vicine o interferenze possono influire sulla tensione di un nodo lasciato aperto.
Esperimento di osservazione: configurare D2 come INPUT e osservare le letture con un collegamento non determinato; poi aggiungere un resistore da 10 kΩ fra D2 e GND e ripetere. La prima condizione non promette un andamento particolare: potrebbe apparire costante o variabile. Nella seconda il riposo è progettato come LOW. Evitare volutamente il contatto con sorgenti non note o tensioni superiori a quelle consentite.
5. Pull-down esterno: riposo LOW, pressione HIGH
Circuito: 5 V → pulsante NO → nodo D2 → resistore 10 kΩ → GND. Il resistore unisce stabilmente D2 a massa quando il contatto è aperto; D2 legge LOW. Premendo il pulsante, il nodo viene portato a 5 V e legge HIGH.
Analisi del nodo: a pulsante aperto, l’ingresso quasi non assorbe corrente e la resistenza collega D2 a 0 V. A pulsante chiuso, D2 è vicino a 5 V; la corrente attraversa il resistore verso GND e vale circa 0,5 mA. Il pin legge la tensione: non è il percorso di questa corrente, salvo correnti d’ingresso trascurabili.
La resistenza da 10 kΩ definisce il valore a riposo e limita la corrente nel ramo verso massa. Una resistenza molto bassa sprecherebbe corrente; una eccessivamente alta renderebbe il nodo più sensibile ai disturbi. In classe, 10 kΩ è una scelta comune e facilmente verificabile.

6. Pull-up esterno: riposo HIGH, pressione LOW
Circuito complementare: 5 V → resistore 10 kΩ → nodo D2 → pulsante NO → GND. A pulsante rilasciato, il resistore mantiene D2 vicino a 5 V: HIGH. Quando il contatto chiude verso GND, D2 è vicino a 0 V: LOW.
La topologia è complementare al pull-down: ora il resistore tiene l’ingresso vicino al positivo e il contatto chiuso lo porta a massa. La condizione logica di pressione è digitalRead(2) == LOW, non HIGH.
Un errore da evitare è scrivere il programma come se HIGH significasse sempre “acceso” o “premuto”: HIGH descrive un livello elettrico. Quale azione software corrisponda a quel livello dipende dal circuito.
7. INPUT_PULLUP: soluzione interna all’Uno R3
L’ATmega328P integra un pull-up attivabile dal software. Collegare D2 → pulsante NO → GND e configurare pinMode(2, INPUT_PULLUP);. Non è normalmente necessaria una resistenza pull-up esterna in questo semplice circuito.
Il resistore interno è un pull-up debole (per l’ATmega328P, ordine di grandezza tipico: decine di kΩ, nell’intervallo indicato dal datasheet). Per un pulsante vicino alla scheda è normalmente adatto. Per collegamenti lunghi o in ambiente disturbato può essere necessario un progetto elettrico più robusto.
Sull’Uno R3 non è prevista una modalità interna standard INPUT_PULLDOWN: chi vuole un riposo LOW utilizza un resistore esterno verso GND. Il fatto che altre schede Arduino dispongano di pull-down interni non cambia questa caratteristica dell’Uno R3.

8. digitalRead(): tensione, interpretazione e condizione
digitalRead(2) restituisce HIGH o LOW al momento della chiamata. Per trasformare la lettura in una condizione utilizzabile si scrive, per il collegamento INPUT_PULLUP, bool premuto = (digitalRead(2) == LOW);.
Il valore letto è una fotografia del livello nel momento dell’esecuzione: digitalRead() non aspetta una pressione, non interpreta da solo il significato fisico e non elimina il rimbalzo. La variabile booleana premuto introduce una traduzione esplicita tra dato elettrico e significato.
Con pull-down esterno: bool premuto = (digitalRead(2) == HIGH);. Con pull-up: bool premuto = (digitalRead(2) == LOW);. Un buon programma dichiara la configurazione del pin e usa sempre la condizione coerente con il cablaggio.
9. Sketch 1 — Pulsante e monitor seriale
Collegare un pulsante NO fra D2 e GND. Impostare il monitor seriale a 9600 baud. Lo sketch stampa lo stato iniziale e poi soltanto quando cambia il livello, evitando la ripetizione incessante del medesimo messaggio.
const byte PIN_PULSANTE = 2;
int statoPrecedente = HIGH;
void setup() {
pinMode(PIN_PULSANTE, INPUT_PULLUP);
Serial.begin(9600);
statoPrecedente = digitalRead(PIN_PULSANTE);
Serial.println(statoPrecedente == LOW ? "PREMUTO" : "RILASCIATO");
}
void loop() {
int statoAttuale = digitalRead(PIN_PULSANTE);
if (statoAttuale != statoPrecedente) {
Serial.println(statoAttuale == LOW ? "PREMUTO" : "RILASCIATO");
statoPrecedente = statoAttuale;
}
}
setup() prepara il pin e la comunicazione; statoPrecedente conserva l’ultima lettura; loop() legge il pin e pubblica soltanto una variazione. Attenzione: non essendo presente il debounce, una pressione reale può produrre più messaggi a causa dei rimbalzi.
Leggiamo lo sketch passo per passo
const byte PIN_PULSANTE = 2fissa il numero del pin in un solo punto;statoPrecedentericorda l’ultima lettura.- In
setup()il pull-up definisce il riposo HIGH;Serial.begin(9600)avvia la comunicazione; la prima lettura stabilisce uno stato iniziale coerente. - In
loop()la condizionestatoAttuale != statoPrecedenteevita di stampare continuamente lo stesso valore; l’assegnazione finale aggiorna la memoria. - Test atteso: a riposo appare RILASCIATO, premendo PREMUTO, rilasciando RILASCIATO. Un pulsante reale può produrre messaggi extra per effetto dei rimbalzi.
10. Sketch 2 — Pulsante che comanda un LED
D2 va al pulsante NO verso GND. D8 va all’anodo del LED tramite una resistenza da 330 Ω; il catodo va a GND. Il GND di pulsante e LED è il medesimo riferimento elettrico della scheda.
Quando il pulsante è premuto, D2 legge LOW; la condizione booleana premuto diventa vera; D8 va HIGH e il LED si accende. Quando si rilascia, la condizione è falsa e D8 torna LOW.
const byte PIN_PULSANTE = 2;
const byte PIN_LED = 8;
void setup() {
pinMode(PIN_PULSANTE, INPUT_PULLUP);
pinMode(PIN_LED, OUTPUT);
digitalWrite(PIN_LED, LOW);
}
void loop() {
bool premuto = (digitalRead(PIN_PULSANTE) == LOW);
digitalWrite(PIN_LED, premuto ? HIGH : LOW);
}
Lo sketch usa il controllo a livello: la luce segue in ogni istante la condizione del pulsante. La resistenza da 330 Ω limita la corrente del LED e non sostituisce il pull-up interno di D2.
Leggiamo lo sketch passo per passo
pinMode(PIN_LED, OUTPUT)abilita la capacità di pilotare il LED;digitalWrite(PIN_LED, LOW)inizializza la luce spenta.digitalRead(PIN_PULSANTE) == LOWtrasforma la logica attiva bassa in un valore booleano significativo.- L’operatore
?:seleziona HIGH sepremutoè vero e LOW altrimenti: equivale a un sempliceif/else. - Test atteso: LED acceso solo durante la pressione; se rimane sempre acceso controllare cablaggio e polarità della condizione.

11. Sketch 3 — Una pressione commuta lo stato del LED
Con gli stessi collegamenti dello sketch 2, ora una pressione accende il LED e la successiva lo spegne. Serve ricordare ledAcceso, perché lo stato dell’uscita deve sopravvivere al rilascio del pulsante.
Il cambiamento viene riconosciuto soltanto quando la lettura è rimasta stabile per almeno 30 ms. Si considera evento di pressione la transizione stabilizzata a LOW, non ogni iterazione di loop() durante cui D2 resta LOW. Il programma controlla la stabilità in modo non bloccante tramite millis(); il significato completo di questa funzione verrà approfondito in B2.08.
const byte PIN_PULSANTE = 2;
const byte PIN_LED = 8;
const unsigned long DEBOUNCE_MS = 30;
int letturaPrecedente = HIGH;
int statoStabile = HIGH;
unsigned long ultimoCambio = 0;
bool ledAcceso = false;
void setup() {
pinMode(PIN_PULSANTE, INPUT_PULLUP);
pinMode(PIN_LED, OUTPUT);
digitalWrite(PIN_LED, LOW);
letturaPrecedente = digitalRead(PIN_PULSANTE);
statoStabile = letturaPrecedente;
}
void loop() {
int lettura = digitalRead(PIN_PULSANTE);
if (lettura != letturaPrecedente) ultimoCambio = millis();
if (millis() - ultimoCambio >= DEBOUNCE_MS &&
lettura != statoStabile) {
statoStabile = lettura;
if (statoStabile == LOW) {
ledAcceso = !ledAcceso;
digitalWrite(PIN_LED, ledAcceso ? HIGH : LOW);
}
}
letturaPrecedente = lettura;
}
Leggiamo lo sketch passo per passo
ledAccesomemorizza il risultato dell’ultima pressione valida; non coincide con lo stato istantaneo del pulsante.- Ogni variazione di
letturariavviaultimoCambio. Se non cambiano più i campioni per almeno 30 ms, il nuovo livello diventastatoStabile. - Solo quando lo stato stabile passa a LOW,
!ledAccesone inverte il valore edigitalWrite()aggiorna D8. Il rilascio prepara la pressione successiva. - Test atteso: prima pressione LED acceso; rilascio LED acceso; seconda pressione LED spento.
12. Il rimbalzo dei contatti: la fisica dietro le letture
Due superfici metalliche non si incollano idealmente al primo contatto: la loro elasticità, le vibrazioni e le asperità producono una rapida successione di aperture e chiusure. Anche il rilascio può rimbalzare.
Durante la chiusura, le superfici metalliche si urtano e possono separarsi più volte, generando fronti ripetuti in pochi millisecondi. Sul monitor seriale tali fronti possono apparire come una sequenza di pressioni e rilasci, benché l’azione della mano sia stata unica.
Distinguiamo lettura grezza (il valore letto in questo istante), stato stabile (il livello accettato dopo un intervallo senza cambi) ed evento valido (una transizione dello stato stabile usata per aggiornare il programma). Questa distinzione è essenziale per realizzare toggle e contatori corretti.

13. Antirimbalzo software: delay() e suoi limiti
Un metodo elementare consiste nel rilevare una possibile pressione, attendere delay(30) e leggere di nuovo il pin: se è ancora LOW, si considera la pressione più credibile. Tuttavia due letture distanti nel tempo non dimostrano da sole che il segnale sia stato stabile per tutto l’intervallo.
Un’implementazione semplice può inoltre attendere che il pulsante sia rilasciato prima di accettarne un altro, ma blocca le altre attività durante le pause. Per un contatore affidabile con più operazioni contemporanee, è preferibile controllare quando l’ultima variazione è avvenuta, come negli sketch 3 e 4.
Esempio completo — toggle elementare con delay()
Circuito identico allo sketch 2: pulsante fra D2 e GND, LED D8 con resistore serie 330 Ω. Questo programma è volutamente bloccante per confrontarlo con la soluzione a millis().
const byte PIN_PULSANTE = 2;
const byte PIN_LED = 8;
bool ledAcceso = false;
void setup() {
pinMode(PIN_PULSANTE, INPUT_PULLUP);
pinMode(PIN_LED, OUTPUT);
digitalWrite(PIN_LED, LOW);
}
void loop() {
if (digitalRead(PIN_PULSANTE) == LOW) {
delay(30); // Attesa didattica: non garantisce stabilità continua
if (digitalRead(PIN_PULSANTE) == LOW) {
ledAcceso = !ledAcceso;
digitalWrite(PIN_LED, ledAcceso ? HIGH : LOW);
while (digitalRead(PIN_PULSANTE) == LOW) {
// Aspetta il rilascio: il programma resta bloccato
}
delay(30); // Attesa per attenuare i rimbalzi al rilascio
}
}
}
Il primo controllo individua un possibile LOW. Dopo 30 ms il secondo controllo lo conferma; il LED viene commutato e il ciclo while attende il rilascio. In questa versione la CPU non svolge altre attività durante la pressione. La seconda pausa cerca di ridurre i rimbalzi al rilascio.
Limiti importanti: due campionamenti uguali non provano stabilità nell’intero intervallo, il ciclo può restare bloccato se il pulsante rimane premuto e pressioni molto rapide possono sfuggire. Per applicazioni con più compiti concorrenti sono preferibili gli sketch con millis().
14. Antirimbalzo hardware: filtro RC e isteresi
Una rete resistore-condensatore (RC) può attenuare transizioni molto rapide: la tensione sul condensatore non varia istantaneamente. La costante caratteristica è τ = R·C; per esempio con 10 kΩ e 1 µF si ottengono 10 ms.
In un circuito elementare con pull-up e pulsante verso massa, un condensatore collegato fra il nodo del segnale e GND può rallentare le variazioni di tensione, ma va dimensionato considerando il percorso di carica e quello di scarica: le resistenze effettive possono essere differenti. Non collegare condensatori o altri componenti senza avere verificato schema e transitori.
Se il segnale filtrato attraversa lentamente la soglia di commutazione, un ingresso con isteresi (ad esempio tramite un buffer con trigger di Schmitt) distingue una soglia in salita da una in discesa e riduce le transizioni spurie. Il filtro RC non equivale a una logica completa di riconoscimento pressioni: può essere opportuno abbinarlo al controllo software.
La formula τ = R·C descrive una scala temporale del filtro: per 10 kΩ e 1 µF si ha 0,01 s = 10 ms, non “10 ms di debounce garantiti”. Il comportamento finale dipende dalle soglie e dai componenti.
15. Sketch 4 — Contatore con pressione stabilizzata
Lo sketch memorizza il livello stabile separatamente dall’ultima lettura grezza. Ogni variazione grezza azzera il riferimento temporale. Se il nuovo livello persiste per almeno 30 ms, viene accettato. Il contatore aumenta solo quando il nuovo livello stabile è LOW.
Al rilascio si aggiorna lo stato stabile a HIGH, ma non si incrementa il contatore. Una pressione lunga viene contata una sola volta; una nuova pressione viene contata soltanto dopo un rilascio stabilizzato. Aprire il monitor seriale a 9600 baud.
const byte PIN_PULSANTE = 2;
const unsigned long DEBOUNCE_MS = 30;
int letturaPrecedente = HIGH;
int statoStabile = HIGH;
unsigned long ultimoCambio = 0;
unsigned long conteggio = 0;
void setup() {
pinMode(PIN_PULSANTE, INPUT_PULLUP);
Serial.begin(9600);
letturaPrecedente = digitalRead(PIN_PULSANTE);
statoStabile = letturaPrecedente;
Serial.println("Contatore pronto: 0");
}
void loop() {
int lettura = digitalRead(PIN_PULSANTE);
if (lettura != letturaPrecedente) ultimoCambio = millis();
if (millis() - ultimoCambio >= DEBOUNCE_MS &&
lettura != statoStabile) {
statoStabile = lettura;
if (statoStabile == LOW) {
++conteggio;
Serial.print("Pressioni valide: ");
Serial.println(conteggio);
}
}
letturaPrecedente = lettura;
}
L’uso della sottrazione fra valori unsigned long consente il normale funzionamento anche quando millis() torna a zero per overflow, purché gli intervalli considerati siano molto inferiori al periodo di overflow.
Leggiamo lo sketch passo per passo
conteggioparte da zero e aumenta con++conteggiosoltanto nel ramo che accetta uno stato LOW stabile.letturaPrecedenteè il campione grezzo precedente;statoStabilerappresenta invece l’ultimo livello validato. Scambiarli genera errori di conteggio.- La sottrazione
millis() - ultimoCambiomisura il tempo dalla variazione grezza più recente senza bloccare il ciclo. - Test atteso: una pressione lunga vale 1; un rilascio vale 0; dieci cicli completi di pressione e rilascio dovrebbero aumentare il totale di 10, nelle condizioni previste.
16. Polling, fronti e interrupt esterni
Nel polling il ciclo loop() legge ripetutamente D2. Nel rilevamento del fronte il software confronta la lettura corrente con quella precedente. Un interrupt può invece richiamare automaticamente una breve funzione di servizio (ISR) quando si verifica una condizione configurata.
Il polling è semplice, ma una funzione che blocca a lungo il programma può ritardare il riconoscimento dell’evento. Un interrupt può segnalare rapidamente un fronte, ma richiede attenzione: la routine di servizio deve essere breve e l’evento va spesso ulteriormente filtrato nel ciclo principale.
digitalPinToInterrupt(2) rende esplicito che D2 viene usato come sorgente di interrupt esterno, mentre FALLING indica la transizione da HIGH a LOW. Sul circuito INPUT_PULLUP tale fronte coincide con un possibile inizio pressione, non necessariamente con una pressione già validata.
17. Diagnostica e sicurezza
Disconnettere l’alimentazione prima di modificare il cablaggio. Utilizzare solo la bassa tensione della scheda e verificare polarità e collegamenti. Non collegare carichi di potenza direttamente ai pin.
| Errore | Causa | Sintomo | Correzione |
|---|---|---|---|
| Pulsante sulla coppia sbagliata | La coppia scelta è già in continuità | Ingresso sempre fisso | Usare terminali di lati opposti, verificati con tester |
| D2 senza pull-up/down | Nodo ad alta impedenza | Letture casuali | Attivare INPUT_PULLUP o collegare il resistore esterno corretto |
| Interpretazione invertita | INPUT_PULLUP è attivo basso | Messaggi o LED invertiti | Considerare premuto = LOW |
| LED senza resistore | Manca limitazione corrente | LED o pin potenzialmente danneggiati | Inserire 330 Ω in serie |
| Mancanza massa comune | Riferimenti elettrici incoerenti | Comportamento erratico | Unire correttamente i GND della stessa alimentazione |
| 5 V direttamente su GND al premere | Cablaggio errato | Cortocircuito pericoloso | Interrompere alimentazione e correggere il circuito |
| Pressioni multiple | Rimbalzo non filtrato | Contatore incrementa troppo | Debounce e riconoscimento del fronte stabile |
| Monitor seriale illeggibile | Baud differenti | Caratteri incomprensibili | Impostare 9600 baud come nello sketch |
Prima di alimentare, verificare che la breadboard non unisca accidentalmente 5 V e GND. I fori delle file e delle barre laterali non sono universali: controllare l’effettiva continuità; alcune barre di alimentazione sono interrotte a metà. Se il LED non si accende, distinguere tra errore di polarità, resistenza fuori percorso e pin sbagliato.
Per diagnosticare una pressione che sembra funzionare “al contrario”, non cambiare componenti a caso: scrivere su carta lo stato del pulsante, la tensione del nodo e la lettura attesa. Solo dopo verificare lo sketch.
18. Esperimenti Tinkercad T08–T11: circuiti interattivi collaudati
Quattro esperienze progressive su Arduino Uno R3, dalla lettura del pulsante alla gestione del LED e al conteggio delle pressioni con antirimbalzo software. I circuiti sono stati costruiti e collaudati in Tinkercad; premi Avvia simulazione per eseguire il progetto incorporato oppure usa il pulsante arancione per aprirlo in una nuova scheda.
Pulsante NO con pull-down esterno da 10 kΩ
Obiettivo: leggere un ingresso digitale D2 stabilizzato a LOW da una resistenza esterna. Quando il pulsante normalmente aperto viene premuto, D2 riceve +5 V e passa a HIGH.
Sketch essenziale:
const int pulsante = 2;
void setup() {
pinMode(pulsante, INPUT);
Serial.begin(9600);
}
void loop() {
int stato = digitalRead(pulsante);
Serial.println(stato == HIGH
? "PULSANTE PREMUTO - HIGH"
: "PULSANTE RILASCIATO - LOW");
delay(200);
}
Prova: osserva sul Monitor seriale la sequenza LOW → HIGH → LOW durante rilascio, pressione e nuovo rilascio. Esito: collaudo funzionale superato.
Pulsante NO con resistenza INPUT_PULLUP interna
Obiettivo: ottenere una lettura affidabile senza resistenza esterna, usando la resistenza di pull-up integrata nel microcontrollore.
INPUT_PULLUP, il pulsante rilasciato produce HIGH e quello premuto produce LOW.Sketch essenziale:
const int pulsante = 2;
void setup() {
pinMode(pulsante, INPUT_PULLUP);
Serial.begin(9600);
}
void loop() {
int stato = digitalRead(pulsante);
Serial.println(stato == LOW
? "PULSANTE PREMUTO - LOW"
: "PULSANTE RILASCIATO - HIGH");
delay(200);
}
Prova: osserva sul Monitor seriale la sequenza HIGH → LOW → HIGH. Esito: collaudo funzionale superato.
Pulsante D2 che comanda un LED rosso su D8
Obiettivo: usare un ingresso digitale per comandare un’uscita. Il LED si accende quando premi il pulsante e si spegne quando lo rilasci.
INPUT_PULLUP; percorso LED D8 → resistenza 330 Ω → anodo LED → catodo LED → GND.Sketch essenziale:
const int pulsante = 2;
const int led = 8;
void setup() {
pinMode(pulsante, INPUT_PULLUP);
pinMode(led, OUTPUT);
}
void loop() {
digitalWrite(led, digitalRead(pulsante) == LOW ? HIGH : LOW);
}
| Pulsante | D2 | LED D8 |
|---|---|---|
| Rilasciato | HIGH | Spento |
| Premuto | LOW | Acceso |
Esito: accensione e spegnimento del LED collaudati.
Contatore di pressioni con debounce software da 30 ms
Obiettivo: incrementare il contatore una sola volta per ogni pressione stabilizzata, usando millis() senza bloccare il programma con delay(). Il LED su D8 segnala lo stato stabile del pulsante.
INPUT_PULLUP e LED su D8 con resistenza da 330 Ω.Sketch completo:
const byte PIN_PULSANTE = 2;
const byte PIN_LED = 8;
const unsigned long DEBOUNCE_MS = 30;
bool ultimaLettura = HIGH;
bool statoStabile = HIGH;
unsigned long ultimoCambio = 0;
unsigned long contatore = 0;
void setup() {
pinMode(PIN_PULSANTE, INPUT_PULLUP);
pinMode(PIN_LED, OUTPUT);
digitalWrite(PIN_LED, LOW);
Serial.begin(9600);
Serial.println("MEGISTONE T11 - DEBOUNCE");
Serial.println("Contatore iniziale: 0");
}
void loop() {
bool lettura = digitalRead(PIN_PULSANTE);
if (lettura != ultimaLettura) ultimoCambio = millis();
if (millis() - ultimoCambio >= DEBOUNCE_MS) {
if (lettura != statoStabile) {
statoStabile = lettura;
if (statoStabile == LOW) {
contatore++;
digitalWrite(PIN_LED, HIGH);
Serial.print("Pressione valida: ");
Serial.println(contatore);
} else {
digitalWrite(PIN_LED, LOW);
}
}
}
ultimaLettura = lettura;
}
Prova: esegui cinque pressioni complete e controlla che il Monitor seriale mostri Pressione valida: 1 fino a Pressione valida: 5, senza aumenti durante la pressione prolungata. Esito: collaudo funzionale da 0 a 5 superato.
Nota sperimentale: il filtro da 30 ms è implementato nel codice, ma il test su Tinkercad con pressioni normali non dimostra da solo la soppressione di rimbalzi elettrici reali. Per validare specificamente l’antirimbalzo occorre generare e misurare transizioni ravvicinate.
Riproducibilità: esperimenti eseguiti con Arduino Uno R3 virtuale; verifica effettuata con simulazione Tinkercad e Monitor seriale dove previsto. Gli iframe possono richiedere l’abilitazione dei contenuti esterni da parte del browser.
19. Allenati con MEGI — 20 esercizi graduati
Prova a rispondere prima di aprire le soluzioni. Gli esercizi vanno dalla lettura dei livelli alla diagnosi di circuito e software.
- Spiega la differenza fra ingresso e uscita usando l’esempio di un finecorsa e di un LED.
- Disegna una tabella degli stati per un pulsante NO con pull-down esterno: posizione, collegamento del nodo e lettura.
- Stesso esercizio con pull-up esterno da 10 kΩ: che cosa cambia?
- Perché non si deve collegare un pulsante direttamente tra 5 V e GND? Proponi una correzione sicura.
- Due fili sono collegati ai terminali dello stesso lato di un pulsante tattile. Quale sintomo prevedi e come lo verifichi?
- Un pin INPUT apparentemente passa fra HIGH e LOW quando avvicini la mano. Qual è l’ipotesi principale e come la verifichi?
- Completa la condizione per il pulsante D2 con INPUT_PULLUP: bool premuto = (digitalRead(2) == ___);
- Modifica mentalmente lo sketch 2 per un pull-down esterno mantenendo acceso il LED durante la pressione.
- Calcola la corrente su un resistore pull-up da 10 kΩ con pulsante premuto e Vcc=5 V.
- Quale differenza c’è fra il valore grezzo di digitalRead e un evento valido di pressione?
- Perché il comando if (digitalRead(2)==LOW) ledAcceso=!ledAcceso; non realizza un toggle affidabile?
- In una sequenza di letture HIGH, LOW, HIGH, LOW, LOW, quale fenomeno sospetti?
- Nel debounce non bloccante, a cosa servono separatamente letturaPrecedente e statoStabile?
- Completa il frammento: if (millis()-ultimoCambio >= DEBOUNCE_MS && lettura != ______) { … }
- Una pressione dura tre secondi. Quanti incrementi deve fare lo sketch 4, e perché?
- Dopo una pressione il pulsante non viene rilasciato completamente. Il contatore deve armarsi per la successiva?
- Perché due letture separate da delay(30) non dimostrano stabilità per tutti i 30 ms?
- Un filtro RC ha R=10 kΩ e C=1 µF. Calcola τ e spiega perché non coincide con un tempo di debounce garantito.
- Perché un interrupt su FALLING non risolve automaticamente i rimbalzi?
- Progetta un test di accettazione per T11 con almeno tre casi e risultati attesi.
20. Soluzioni guidate dei 20 esercizi
Apri una soluzione per volta, dopo aver formulato la tua risposta.
Soluzione 1 — Spiega la differenza fra ingresso e uscita usando l’esempio di un finecorsa e di un LED.
Il finecorsa cambia il livello osservato da un pin configurato INPUT; il LED riceve il comando da un pin OUTPUT. Nel primo caso Arduino legge, nel secondo impone un livello.
Soluzione 2 — Disegna una tabella degli stati per un pulsante NO con pull-down esterno: posizione, collegamento del nodo e lettura.
Rilasciato: D2 attraverso 10 kΩ a GND, LOW. Premuto: D2 direttamente a 5 V, HIGH. Il resistore conduce circa 0,5 mA durante la pressione.
Soluzione 3 — Stesso esercizio con pull-up esterno da 10 kΩ: che cosa cambia?
Rilasciato: D2 attraverso 10 kΩ a 5 V, HIGH. Premuto: D2 direttamente a GND, LOW; la pressione è attiva bassa.
Soluzione 4 — Perché non si deve collegare un pulsante direttamente tra 5 V e GND? Proponi una correzione sicura.
Alla pressione si chiuderebbe un corto tra alimentazione e massa. Occorre una topologia con pull-up/pull-down resistivo e ingresso collegato al nodo, non un contatto diretto fra rail.
Soluzione 5 — Due fili sono collegati ai terminali dello stesso lato di un pulsante tattile. Quale sintomo prevedi e come lo verifichi?
I terminali potrebbero essere già comuni, quindi lo stato non varia premendo. Si verifica la continuità con multimetro a scheda disalimentata e si scelgono terminali opposti.
Soluzione 6 — Un pin INPUT apparentemente passa fra HIGH e LOW quando avvicini la mano. Qual è l’ipotesi principale e come la verifichi?
Ingresso flottante ad alta impedenza. Si stabilizza con pull-up/pull-down appropriato e si controlla se la lettura a riposo diventa definita.
Soluzione 7 — Completa la condizione per il pulsante D2 con INPUT_PULLUP: bool premuto = (digitalRead(2) == ___);
LOW, perché il pulsante premuto connette D2 a GND.
Soluzione 8 — Modifica mentalmente lo sketch 2 per un pull-down esterno mantenendo acceso il LED durante la pressione.
Configurare D2 con INPUT, installare resistore da 10 kΩ tra D2 e GND e pulsante verso 5 V, quindi usare bool premuto = (digitalRead(2) == HIGH).
Soluzione 9 — Calcola la corrente su un resistore pull-up da 10 kΩ con pulsante premuto e Vcc=5 V.
I=V/R=5/10000 A=0,0005 A, cioè 0,5 mA. È la corrente nel ramo resistore-contatto, non la corrente che alimenta il LED.
Soluzione 10 — Quale differenza c’è fra il valore grezzo di digitalRead e un evento valido di pressione?
Il valore grezzo è una misura logica istantanea; un evento valido è una transizione filtrata e riconosciuta secondo criteri di stabilità, ad esempio HIGH stabile → LOW stabile.
Soluzione 11 — Perché il comando if (digitalRead(2)==LOW) ledAcceso=!ledAcceso; non realizza un toggle affidabile?
Il ciclo loop ripete l’inversione finché il pulsante rimane premuto e il rimbalzo può generare altri cambi: serve rilevare una sola transizione stabile per pressione.
Soluzione 12 — In una sequenza di letture HIGH, LOW, HIGH, LOW, LOW, quale fenomeno sospetti?
Rimbalzo dei contatti o disturbo: una sola pressione meccanica potrebbe produrre ripetuti fronti elettrici; il dato da solo non certifica quale causa senza ulteriori verifiche.
Soluzione 13 — Nel debounce non bloccante, a cosa servono separatamente letturaPrecedente e statoStabile?
letturaPrecedente serve a individuare il cambio grezzo e riavviare il conteggio del tempo; statoStabile conserva il valore accettato dopo l’intervallo senza variazioni.
Soluzione 14 — Completa il frammento: if (millis()-ultimoCambio >= DEBOUNCE_MS && lettura != ______) { … }
statoStabile, perché si aggiorna solo se il livello sufficientemente stabile differisce dal livello già accettato.
Soluzione 15 — Una pressione dura tre secondi. Quanti incrementi deve fare lo sketch 4, e perché?
Uno, se la pressione diventa stabile e poi permane LOW: il conteggio avviene solo sul passaggio dello stato stabile a LOW, non per ogni iterazione di loop.
Soluzione 16 — Dopo una pressione il pulsante non viene rilasciato completamente. Il contatore deve armarsi per la successiva?
No: prima è necessario un rilascio stabilizzato a HIGH, altrimenti non esiste un nuovo evento HIGH→LOW riconosciuto.
Soluzione 17 — Perché due letture separate da delay(30) non dimostrano stabilità per tutti i 30 ms?
Fra le due osservazioni il segnale può essere cambiato più volte senza che il programma se ne accorga; inoltre delay blocca le altre attività.
Soluzione 18 — Un filtro RC ha R=10 kΩ e C=1 µF. Calcola τ e spiega perché non coincide con un tempo di debounce garantito.
τ=RC=10000·0,000001 s=0,01 s=10 ms. È una costante del circuito: per riconoscere livelli affidabili servono anche soglie, isteresi e condizioni reali del pulsante.
Soluzione 19 — Perché un interrupt su FALLING non risolve automaticamente i rimbalzi?
Un contatto che rimbalza può generare molti fronti FALLING e quindi più richieste di interrupt. Occorre un filtro software/hardware e ISR brevi.
Soluzione 20 — Progetta un test di accettazione per T11 con almeno tre casi e risultati attesi.
Esempi: (1) pressione lunga → incremento di 1; (2) rilascio senza nuova pressione → 0 incrementi; (3) cinque cicli completi → +5, in condizioni controllate. Registrare cablaggio, sketch e risultati osservati.
21. Raccordi storici e continuità del percorso
Il capitolo riprende B2.02 — Arduino Uno R3, hardware, IDE e Blink e B2.03 — Uscite digitali, LED e breadboard. Il passo successivo, B2.05, introdurrà ingressi analogici, ADC, potenziometri e PWM.
Gli eventuali progetti Arduino storici della raccolta MEGISTONE saranno collegati qui solo dopo una verifica puntuale degli indirizzi: non inseriamo collegamenti ipotetici. L’approfondimento speciale “Fisica con Arduino” rimane previsto dopo B2.09 e fuori dai 55 articoli numerati.
I raccordi storici devono rimanere collegamenti verificati, non semplici nomi di vecchie lezioni. Il capitolo mantiene i riferimenti agli articoli precedenti e prepara il B2.05 senza anticiparne l’intero percorso di conversione analogico-digitale. L’approfondimento “Fisica con Arduino” resta una decima esperienza aggiuntiva dopo B2.09, fuori dalla numerazione 01–55.
22. Fonti, riproducibilità e nota di revisione
Le seguenti fonti Arduino sono riferimenti tecnici per riprodurre gli esperimenti e verificare i comandi:
- Arduino Uno Rev3
- INPUT, OUTPUT, INPUT_PULLUP
- Button
- InputPullupSerial
- State Change Detection
- Debounce
- attachInterrupt()
Validazione degli esperimenti Tinkercad
Gli sketch e i circuiti di questo capitolo sono stati progettati per Arduino Uno R3.
Gli esperimenti T08, T09, T10 e T11 sono stati realizzati e sottoposti a collaudo funzionale nell’ambiente di simulazione Autodesk Tinkercad Circuits.
- T08 — Pull-down esterno:
verificata la lettura LOW → HIGH → LOW del pulsante con resistenza esterna da 10 kΩ. - T09 — INPUT_PULLUP interno:
verificata la lettura HIGH → LOW → HIGH senza resistenza esterna. - T10 — Pulsante e LED:
verificati accensione e spegnimento del LED su D8, comandato dal pulsante su D2, con resistenza da 330 Ω. - T11 — Contatore con debounce:
verificato il conteggio progressivo di cinque pressioni distinte con algoritmo basato sumillis()e intervallo di 30 ms.
Limiti della validazione
Il filtro antirimbalzo è implementato nel codice, ma non è stata effettuata una prova specifica con rimbalzi elettrici artificialmente generati o misurati.
Le prove Tinkercad confermano il funzionamento degli sketch nelle condizioni simulate, senza sostituire i test su hardware reale.
Non sono dichiarate verifiche di compilazione nell’Arduino IDE installato localmente né misurazioni strumentali sui circuiti fisici.
Riproducibilità e revisione editoriale
Per riprodurre le prove è opportuno documentare
la versione di Arduino IDE, il modello della scheda
Uno R3, i valori effettivi dei resistori, i collegamenti
D2/D8, la velocità del Monitor seriale e le eventuali
differenze tra simulazione e prova fisica.
Il laboratorio virtuale MEGISTONE STEM LAB B2.04,
nelle cinque modalità A–E, è stato sottoposto a
collaudo funzionale su desktop e a verifica di
compatibilità su iPhone 11.
La verifica editoriale dell’articolo comprende
inoltre il controllo delle immagini scientifiche,
dell’indice navigabile, dei collegamenti al laboratorio
e della visualizzazione su WordPress.
Gli iframe Tinkercad T08–T11 devono essere verificati
nell’articolo pubblicato dopo il loro inserimento.
I materiali preesistenti MEGISTONE costituiscono
riferimenti per la revisione didattica.
Testi e figure di terzi non sono ripubblicati
integralmente.