Semaforo con Arduino - guida pratica per montarlo bene

Un piccolo semaforo costruito con Arduino è uno di quei progetti che sembrano semplici solo in superficie: in realtà ti fanno toccare con mano LED, resistenze, uscite digitali e logica di temporizzazione in modo molto concreto. Io lo trovo perfetto per capire come ragiona un microcontrollore, perché il risultato si vede subito e ogni errore emerge in pochi secondi.

In questa guida trovi tutto quello che serve per realizzarlo bene: materiali, collegamenti, sketch base, varianti più utili e gli sbagli che fanno perdere tempo ai principianti. L’obiettivo è ottenere un modello ordinato, affidabile e facile da estendere, non solo tre luci che lampeggiano a caso.

Materiali e budget per partire bene

Per il primo prototipo io partirei da componenti semplici, facili da trovare e poco costosi. La regola che seguo sempre è questa: meglio pochi pezzi chiari che un modulo più “furbo” ma opaco, soprattutto se il progetto serve per imparare come si muove davvero un Arduino.

Se hai già una scheda compatibile in casa, il costo reale del progetto si abbassa parecchio: spesso resti sotto i 5 euro di spesa aggiuntiva. Io consiglio Arduino Uno se vuoi lavorare con calma e vedere bene i collegamenti; Nano se preferisci un montaggio più compatto. In entrambi i casi il microcontrollore fa la stessa cosa: esegue il programma e comanda le uscite digitali. Una volta scelti i pezzi, il passo decisivo è il cablaggio, perché lì si gioca la riuscita del progetto.

Come collegare i componenti senza sbagliare

Il punto delicato non è accendere un LED, ma capire il verso giusto dei componenti e il ruolo della resistenza in serie. Io consiglio sempre di cablare prima il rosso, poi il giallo e infine il verde: lavorare in ordine riduce gli errori e rende il debug molto più semplice.

• Collega il catodo di ogni LED a GND.
• Metti una resistenza in serie a ciascun anodo: non è un dettaglio, è la protezione che evita di stressare il LED.
• Usa tre pin digitali liberi, per esempio 8, 9 e 10.
• Evita i pin 0 e 1 se vuoi caricare lo sketch senza complicazioni con la seriale.
• Tieni la breadboard ordinata: un cavo corto in più vale più di una spiegazione teorica quando devi correggere un errore.
• Se i binari di alimentazione della breadboard sono interrotti a metà, mettili in comune con un ponticello.

Con i LED discreti, il circuito più pulito è sempre lo stesso: pin Arduino, resistenza, anodo del LED, catodo a massa. Se usi resistenze da 220 Ω o 330 Ω sei in una zona sicura e molto comune nei progetti didattici. A questo punto il circuito è pronto per lo sketch, e lì conviene restare essenziali.

Lo sketch base che fa accendere il ciclo

Per una prima prova non serve nessuna libreria esterna: Arduino gestisce tutto con le sue funzioni di base. Io preferisco partire con un ciclo semplice e leggibile, così capisci subito come si comporta ogni fase e puoi cambiare i tempi senza toccare la logica.

const int rosso = 8;
const int giallo = 9;
const int verde = 10;

void setLuci(bool r, bool g, bool v) {
  digitalWrite(rosso, r ? HIGH : LOW);
  digitalWrite(giallo, g ? HIGH : LOW);
  digitalWrite(verde, v ? HIGH : LOW);
}

void setup() {
  pinMode(rosso, OUTPUT);
  pinMode(giallo, OUTPUT);
  pinMode(verde, OUTPUT);
}

void loop() {
  setLuci(true, false, false);
  delay(5000);

  setLuci(true, true, false);
  delay(1000);

  setLuci(false, false, true);
  delay(5000);

  setLuci(false, true, false);
  delay(2000);
}

La sequenza è volutamente lineare: rosso, rosso più giallo, verde, giallo. Se vuoi adattare il ritmo, modifica solo i valori di delay(): 5000 significa 5 secondi, 1000 significa 1 secondo. Io uso questa base per fare i primi test su breadboard, poi passo a una logica più robusta quando aggiungo pulsanti o altri semafori. Ed è proprio lì che il progetto smette di essere solo un esercizio e diventa una piccola simulazione credibile.

Come farlo diventare un progetto davvero utile

Una volta che il ciclo base funziona, il passo successivo non è complicarlo a caso ma aggiungere solo ciò che ha uno scopo didattico o pratico. Qui Arduino mostra il suo lato migliore: puoi partire da un modello minimale e arrivare a una simulazione di incrocio molto più convincente senza cambiare piattaforma.

Versione con pulsante pedonale

È la variante che consiglio più spesso in ambito scolastico o per chi vuole imparare a leggere un ingresso digitale. Il pulsante ti costringe a ragionare in termini di stato: il semaforo non cambia solo perché il tempo è scaduto, ma perché qualcuno ha chiesto l’attraversamento. In questa versione la differenza tra INPUT e INPUT_PULLUP diventa subito concreta, e vale la pena capirla bene.

Due semafori sincronizzati

Se vuoi alzare il livello, il secondo passo sensato è gestire due semafori opposti. È qui che la logica a stati torna davvero utile, perché devi evitare che entrambe le direzioni risultino verdi nello stesso momento. Io considero questa versione molto istruttiva perché ti obbliga a separare il codice in funzioni chiare, invece di accumulare istruzioni una dietro l’altra.

Leggi anche: Arduino non è un chip - ecco cosa indica davvero

Simulazione prima del montaggio reale

Se il tuo obiettivo è imparare, delay() va benissimo all’inizio. Se invece vuoi costruire un sistema che reagisce a un pulsante o coordina più luci, conviene passare presto a una macchina a stati basata su millis(). Da qui in poi il margine di crescita è alto, ma anche gli errori diventano più facili da commettere se non tieni il codice ordinato.

Gli errori che vedo più spesso nei primi montaggi

Qui di solito si perde più tempo che nel codice. Io controllo sempre questi punti prima ancora di sospettare un bug nello sketch: orientamento del LED, resistenza mancante, massa comune, pin sbagliato o alimentazione confusa. Nella pratica, il 90% dei problemi di un primo prototipo nasce da uno di questi dettagli.

• LED montato al contrario: se il verso è invertito, non si accende e sembra che il problema sia nel programma.
• Resistenza dimenticata o messa nel punto sbagliato: il LED può sembrare funzionare, ma non è un uso corretto del componente.
• Pin 0 e 1 usati per le luci: spesso creano conflitti con l’upload dello sketch.
• Massa non comune: senza un GND condiviso, il circuito non ha un riferimento coerente.
• Tempi gestiti con delay() mentre cerchi di leggere un pulsante: il programma resta bloccato e il bottone “non risponde”.
• Breadboard cablata in modo disordinato: più fili hai, più serve una logica visiva pulita per capire cosa stai facendo.

Io aggiungo sempre un’ultima distinzione importante: questo è un modello didattico, non un dispositivo di sicurezza. Serve a capire logiche e tempi, non a comandare un impianto reale. Se lo tieni a mente, il progetto resta chiaro e non ti aspetti da lui più di quello che può offrire. A questo punto l’unica domanda sensata è quanto vuoi spingerti oltre la versione base.

Le estensioni che fanno davvero salire di livello il progetto

Se il ciclo a tre luci funziona, il miglior upgrade non è aggiungere LED a caso ma riscrivere la logica in modo più elegante. Io farei tre passi: prima una macchina a stati, poi un pulsante pedonale, infine un contenitore più curato. È una progressione semplice, ma molto più solida di un progetto gonfiato in fretta.

• Usa enum o costanti chiare per nominare gli stati del semaforo.
• Passa a millis() quando vuoi evitare blocchi e gestire più eventi.
• Aggiungi un buzzer solo se ti serve davvero, per esempio in una versione pensata per studenti più piccoli o per segnalazioni sonore.
• Se costruisci la parte fisica, disegna subito la disposizione dei LED: un progetto bello da vedere è anche più facile da usare.

Per me questa è la soglia in cui un semplice modello diventa un progetto ben fatto: pochi componenti, logica pulita e margine per crescere senza rifare tutto da capo. Se resti su questa linea, il risultato finale sarà molto più utile di una copia approssimativa di un semaforo reale, perché ti avrà insegnato davvero come ragiona un sistema controllato da microcontrollore.