🚦 Arduino • LED • Sequenze temporizzate

Semaforo con Arduino: progetto completo con 6 LED

Realizziamo un semaforo a due direzioni usando sei LED, resistenze da 220 Ω e una semplice sequenza temporizzata. È un ottimo esercizio per capire uscite digitali, stati HIGH/LOW e gestione dei tempi con delay().

Difficoltà Principiante
Uscite Pin 2–7
Componenti chiave 6 LED + 6 resistenze
In poche parole: Arduino controlla due gruppi di LED come se fossero due semafori contrapposti. Quando una direzione è verde, l’altra rimane rossa; poi avviene la transizione con il giallo e le due direzioni si scambiano.

Cosa imparerai

  • come comandare più LED contemporaneamente;
  • come usare digitalWrite() con più uscite;
  • come organizzare una sequenza temporale;
  • come rappresentare due stati mutuamente esclusivi;
  • come usare LED e resistenze in un circuito più articolato;
  • come trasformare una sequenza reale in logica di programma.

Come funziona il semaforo

Il progetto simula due semafori che regolano due direzioni opposte. Ogni semaforo è formato da tre LED: rosso, giallo e verde.

Il principio fondamentale è semplice: quando il primo semaforo è rosso, il secondo è verde. Dopo un certo intervallo, il secondo passa al giallo, poi al rosso; a quel punto il primo può diventare verde.

Concetto chiave: il progetto non controlla semplicemente sei LED indipendenti, ma coordina due gruppi di uscite secondo una sequenza precisa.

Materiale necessario

🔌 Arduino Uno
🧩 Breadboard
🔴 2 LED rossi
🟡 2 LED gialli
🟢 2 LED verdi
〰️ 6 resistenze da 220 Ω
🔗 Cavetti jumper

🧰 Kit Arduino consigliato

Per questo e molti altri progetti è comodo avere un kit con LED, resistenze, breadboard e cavetti già inclusi.

👉 Guarda il kit Arduino consigliato

Link di affiliazione Amazon: in qualità di Affiliato Amazon ricevo un guadagno dagli acquisti idonei, senza alcun costo aggiuntivo per te.

📘 Vuoi imparare Arduino passo dopo passo?

Se vuoi approfondire e realizzare progetti più completi, puoi dare un’occhiata anche ai miei libri dedicati ad Arduino. All’interno troverai spiegazioni semplici, schemi chiari e molti progetti pratici pensati per chi parte da zero.

👉 Scopri i miei libri su Arduino

Link di affiliazione Amazon: in qualità di Affiliato Amazon ricevo un guadagno dagli acquisti idonei, senza alcun costo aggiuntivo per te.

Video dimostrativo

Collegamenti dei LED

Semaforo Colore Pin Arduino
1Rosso2
1Giallo3
1Verde4
2Rosso5
2Giallo6
2Verde7
Importante: ogni LED deve avere la propria resistenza di limitazione da 220 Ω. Non collegare i LED direttamente ai pin di Arduino senza resistenza.
Schema semaforo con Arduino e sei LED

Schema originale del semaforo con due gruppi di LED.

Sequenza logica del progetto

Fase Semaforo 1 Semaforo 2
1RossoVerde
2RossoGiallo
3VerdeRosso
4GialloRosso

Codice Arduino commentato

Semaforo con Arduino
// ==========================================================
// SEMAFORO CON ARDUINO
// Due semafori contrapposti con 6 LED
// ==========================================================

// LED del primo semaforo
const int rosso1  = 2;
const int giallo1 = 3;
const int verde1  = 4;

// LED del secondo semaforo
const int rosso2  = 5;
const int giallo2 = 6;
const int verde2  = 7;

void setup() {

  // Configura tutti i pin come uscite
  pinMode(rosso1, OUTPUT);
  pinMode(giallo1, OUTPUT);
  pinMode(verde1, OUTPUT);

  pinMode(rosso2, OUTPUT);
  pinMode(giallo2, OUTPUT);
  pinMode(verde2, OUTPUT);

}

void loop() {

  // --------------------------------------------------------
  // FASE 1
  // Semaforo 1 rosso
  // Semaforo 2 verde
  // --------------------------------------------------------

  digitalWrite(rosso1, HIGH);
  digitalWrite(verde2, HIGH);

  // Il rosso del secondo semaforo deve essere spento
  digitalWrite(rosso2, LOW);

  // Mantiene questa situazione per 5 secondi
  delay(5000);

  // --------------------------------------------------------
  // FASE 2
  // Il secondo semaforo passa al giallo
  // --------------------------------------------------------

  digitalWrite(giallo2, HIGH);

  // Mantiene il giallo per 5 secondi
  delay(5000);

  // --------------------------------------------------------
  // FASE 3
  // Semaforo 1 verde
  // Semaforo 2 rosso
  // --------------------------------------------------------

  digitalWrite(rosso1, LOW);
  digitalWrite(verde1, HIGH);

  digitalWrite(verde2, LOW);
  digitalWrite(giallo2, LOW);
  digitalWrite(rosso2, HIGH);

  // Mantiene questa situazione per 5 secondi
  delay(5000);

  // --------------------------------------------------------
  // FASE 4
  // Il primo semaforo passa al giallo
  // --------------------------------------------------------

  digitalWrite(giallo1, HIGH);

  // Mantiene il giallo per 5 secondi
  delay(5000);

  // Spegne verde e giallo del primo semaforo
  // Il ciclo riparte dalla FASE 1
  digitalWrite(verde1, LOW);
  digitalWrite(giallo1, LOW);

}

Il codice spiegato passo passo

1

Definiamo i sei pin

Ogni LED ha un pin dedicato. Questo rende semplice leggere il codice e associare ogni uscita al colore corretto.

2

Configuriamo le uscite

Tutti i pin vengono impostati come OUTPUT perché Arduino deve pilotare direttamente i LED.

3

Accendiamo una direzione per volta

Quando un semaforo è verde, l’altro rimane rosso. È questa coordinazione che rende il progetto simile a un vero incrocio.

4

Inseriamo la fase gialla

Prima di passare dal verde al rosso, il programma accende il giallo per un intervallo definito.

5

Ripetiamo il ciclo

Terminata la quarta fase, loop() ricomincia automaticamente dalla prima.

Come funziona delay()

Nel progetto originale ogni fase dura 5 secondi perché viene usato delay(5000). Il valore è espresso in millisecondi:

  • delay(1000) = 1 secondo;
  • delay(3000) = 3 secondi;
  • delay(5000) = 5 secondi.
Approfondimento: delay() è perfetto per un primo progetto didattico, ma blocca temporaneamente l’esecuzione del programma. Nei progetti più avanzati conviene usare millis() per gestire i tempi senza fermare Arduino.

Versione evoluta: usare millis() invece di delay()

Quando il progetto cresce, può essere utile evitare i ritardi bloccanti. Con millis() Arduino può continuare a leggere pulsanti, sensori o altri ingressi mentre gestisce il semaforo.

Esempio concettuale con millis()
// Tempo dell'ultimo cambio di fase
unsigned long ultimoCambio = 0;

// Durata di una fase in millisecondi
const unsigned long intervallo = 5000;

void loop() {

  // Legge il tempo trascorso dall'avvio di Arduino
  unsigned long adesso = millis();

  // Se sono trascorsi almeno 5 secondi...
  if (adesso - ultimoCambio >= intervallo) {

    // Aggiorna il riferimento temporale
    ultimoCambio = adesso;

    // Qui possiamo passare alla fase successiva
    // senza bloccare il resto del programma

  }

}

Simulazione online

▶️ Apri la simulazione Tinkercad

Scarica lo sketch

⬇️ Scarica semaforo.ino

Debug rapido

  • controlla che ogni LED abbia la propria resistenza da 220 Ω;
  • verifica la polarità dei LED;
  • controlla che i pin 2–7 corrispondano ai colori definiti nel codice;
  • se due colori rimangono accesi insieme, verifica la sequenza degli HIGH e LOW;
  • assicurati che tutti i catodi siano collegati correttamente a GND;
  • riduci temporaneamente i delay() durante i test per velocizzare le prove.

Varianti del progetto

  • aggiungere un pulsante pedonale;
  • aggiungere un buzzer per il passaggio pedonale;
  • usare un display per mostrare il conto alla rovescia;
  • usare sensori per rilevare il traffico;
  • gestire i tempi con millis() invece di delay();
  • creare un incrocio a quattro direzioni;
  • aggiungere una modalità lampeggiante notturna.

Cosa devi ricordare

  • Ogni LED è controllato da un’uscita digitale.
  • I due semafori devono essere coordinati.
  • HIGH accende il LED, LOW lo spegne.
  • delay() determina la durata delle fasi.
  • Le resistenze proteggono i LED e i pin di Arduino.
  • millis() è una possibile evoluzione per progetti più complessi.

Domande frequenti

Posso usare solo 3 LED?

Sì. Puoi realizzare un solo semaforo usando un LED rosso, uno giallo e uno verde. Questo progetto usa 6 LED per simulare due direzioni.

Perché servono 6 resistenze?

Ogni LED deve avere la propria resistenza di limitazione della corrente.

Posso cambiare la durata delle luci?

Sì. Modifica i valori passati a delay().

Perché usare millis() invece di delay()?

Perché millis() permette di gestire il tempo senza bloccare completamente il programma, utile quando aggiungi pulsanti o sensori.