⏱️ Arduino • Countdown • Display 7 segmenti

Timer countdown con Arduino e display a 1 cifra

Realizziamo un conto alla rovescia da 9 a 0 con un display a 7 segmenti, avviato da un pulsante e completato da LED e buzzer.

DifficoltàIntermedia
Display7 segmenti • 1 cifra
Countdown9 → 0
In poche parole: alla pressione del pulsante Arduino visualizza sul display i numeri da 9 a 0, uno al secondo. Terminato il countdown, attiva una breve segnalazione con LED, buzzer e punto decimale.

Cosa imparerai

  • come funziona un display a 7 segmenti;
  • come associare i segmenti ai pin Arduino;
  • come visualizzare le cifre da 0 a 9;
  • come avviare un countdown con un pulsante;
  • come gestire LED e buzzer al termine del conteggio;
  • come semplificare un sketch usando una tabella di segmenti.

Come funziona il progetto

Il progetto realizza un timer a una cifra: il pulsante avvia un conto alla rovescia da 9 a 0 e, al termine, vengono attivati per alcuni secondi un LED e un buzzer.

Timer Arduino con display a 1 cifra
Arduino timer con display 7 segmenti

Esempi del timer con display a 7 segmenti.

Materiale necessario

🔌 Arduino Uno
🔢 Display 7 segmenti a 1 cifra
🔘 Pulsante o microinterruttore
🔊 Buzzer
💡 LED
〰️ 1 resistenza da 10 kΩ
〰️ 2 resistenze da 220 Ω
🧩 Breadboard e jumper

🧰 Kit Arduino consigliato

Molti progetti del sito utilizzano display, pulsanti, LED, buzzer, resistenze e breadboard. Un kit completo può essere comodo per iniziare.

👉 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.

Schema del circuito

Schema Arduino timer display 1 cifra

Schema di collegamento del timer con display a 1 cifra, pulsante, LED e buzzer.

Pin utilizzati nello sketch

FunzionePin Arduino
Segmenti + punto decimaleD1–D8
PulsanteD11
BuzzerD12
LED finaleD13
Nota importante: lo sketch usa D1, che su Arduino Uno è anche TX della porta seriale. Se vuoi utilizzare anche la seriale, conviene spostare i segmenti su pin che non interferiscano con D0/D1.

Mappatura dei segmenti del display

La mappatura tra pin e segmenti utilizzata nel progetto è la seguente:

PinSegmento
D1g – segmento centrale
D2f – verticale alto sinistra
D3a – segmento superiore
D4b – verticale alto destra
D5DP – punto decimale
D6c – verticale basso destra
D7d – segmento inferiore
D8e – verticale basso sinistra
Tipo di display: la logica dello sketch accende i segmenti portandoli LOW e li spegne con HIGH. Questo comportamento è tipico di un collegamento a logica attiva-bassa, come avviene normalmente con un display ad anodo comune.

Codice Arduino commentato e semplificato

Per rendere il codice più leggibile e facile da modificare usiamo una tabella che descrive i segmenti delle cifre da 0 a 9.

Countdown 9 → 0 con display 7 segmenti
// ==========================================================
// TIMER COUNTDOWN 9 -> 0 CON DISPLAY A 1 CIFRA
// Cablaggio utilizzato nel progetto
// ==========================================================

// Pin dei sette segmenti nell'ordine:
// a, b, c, d, e, f, g
const int segmenti[7] = {
 3, // a = segmento superiore
 4, // b = alto destra
 6, // c = basso destra
 7, // d = segmento inferiore
 8, // e = basso sinistra
 2, // f = alto sinistra
 1 // g = segmento centrale
};

// Punto decimale
const int puntoDecimale = 5;

// Pulsante di avvio
const int pulsantePin = 11;

// Buzzer e LED finali
const int buzzerPin = 12;
const int ledPin = 13;

// Il display usa una logica attiva-bassa:
// LOW = segmento acceso
// HIGH = segmento spento
const int SEGMENTO_ACCESO = LOW;
const int SEGMENTO_SPENTO = HIGH;

// Tabella delle cifre da 0 a 9.
// Ordine dei valori: a,b,c,d,e,f,g
const bool cifre[10][7] = {
 // a b c d e f g
 {1, 1, 1, 1, 1, 1, 0}, // 0
 {0, 1, 1, 0, 0, 0, 0}, // 1
 {1, 1, 0, 1, 1, 0, 1}, // 2
 {1, 1, 1, 1, 0, 0, 1}, // 3
 {0, 1, 1, 0, 0, 1, 1}, // 4
 {1, 0, 1, 1, 0, 1, 1}, // 5
 {1, 0, 1, 1, 1, 1, 1}, // 6
 {1, 1, 1, 0, 0, 0, 0}, // 7
 {1, 1, 1, 1, 1, 1, 1}, // 8
 {1, 1, 1, 1, 0, 1, 1} // 9
};

// Visualizza una cifra da 0 a 9
void mostraCifra(int numero) {

 // Protezione contro valori fuori intervallo
 if (numero < 0 || numero > 9) {
 return;
 }

 // Aggiorna i sette segmenti
 for (int i = 0; i < 7; i++) {

 if (cifre[numero][i]) {
 digitalWrite(segmenti[i], SEGMENTO_ACCESO);
 } else {
 digitalWrite(segmenti[i], SEGMENTO_SPENTO);
 }
 }

 // Il punto decimale resta spento
 digitalWrite(puntoDecimale, HIGH);
}

// Spegne tutti i segmenti del display
void spegniDisplay() {

 for (int i = 0; i < 7; i++) {
 digitalWrite(segmenti[i], SEGMENTO_SPENTO);
 }

 digitalWrite(puntoDecimale, HIGH);
}

// Segnalazione finale:
void allarmeFine() {

 // Ripete 20 lampeggi rapidi.
 for (int i = 0; i < 20; i++) {

 // LED acceso, buzzer disattivato,
 // punto decimale acceso
 digitalWrite(ledPin, HIGH);
 digitalWrite(buzzerPin, LOW);
 digitalWrite(puntoDecimale, LOW);

 delay(70);

 // LED spento, buzzer attivato,
 // punto decimale spento
 digitalWrite(ledPin, LOW);
 digitalWrite(buzzerPin, HIGH);
 digitalWrite(puntoDecimale, HIGH);

 delay(70);
 }

 // Riporta tutto a riposo
 digitalWrite(ledPin, LOW);
 digitalWrite(buzzerPin, LOW);
 digitalWrite(puntoDecimale, HIGH);
}

void setup() {

 // Configura i sette segmenti
 for (int i = 0; i < 7; i++) {
 pinMode(segmenti[i], OUTPUT);
 }

 pinMode(puntoDecimale, OUTPUT);

 // Pulsante con resistenza esterna da 10 kΩ
 pinMode(pulsantePin, INPUT);

 // Uscite finali
 pinMode(buzzerPin, OUTPUT);
 pinMode(ledPin, OUTPUT);

 // Stato iniziale
 spegniDisplay();
 digitalWrite(buzzerPin, LOW);
 digitalWrite(ledPin, LOW);
}

void loop() {

 // Legge il pulsante
 int pulsante = digitalRead(pulsantePin);

 // Il countdown parte solo quando il pulsante è HIGH
 if (pulsante == HIGH) {

 // Conta da 9 a 0
 for (int numero = 9; numero >= 0; numero--) {

 mostraCifra(numero);

 // Ogni numero resta visibile per un secondo
 delay(1000);
 }

 // Spegne il display principale
 spegniDisplay();

 // Segnalazione sonora e luminosa finale
 allarmeFine();

 // Evita di ripartire continuamente se
 // il pulsante viene tenuto premuto
 while (digitalRead(pulsantePin) == HIGH) {
 delay(10);
 }
 }
}

Come funziona il countdown

1. Il pulsante avvia il ciclo

Arduino legge D11. Quando l’ingresso diventa HIGH viene avviato il conto alla rovescia.

2. Il display mostra 9, 8, 7… fino a 0

Un ciclo for decrementa la variabile numero. Ogni cifra resta sul display per 1000 ms.

3. La funzione mostraCifra()

La tabella cifre[10][7] contiene l’elenco dei segmenti che devono essere accesi per ogni numero. Questo sostituisce dieci funzioni quasi uguali e rende lo sketch molto più compatto.

4. Segnalazione finale

Dopo lo zero il display viene spento e per 20 cicli vengono alternati LED, buzzer e punto decimale ogni 70 ms, mantenendo l’idea del progetto.

Perché LOW accende un segmento?

Le routine portano i pin HIGH per spegnere i segmenti e LOW per accendere soltanto quelli necessari alla cifra. Questo indica una logica attiva-bassa.

Se il tuo display lavora al contrario: probabilmente hai un tipo di display diverso o un cablaggio differente. In tal caso non cambiare valori a caso: identifica prima se è ad anodo comune o catodo comune.

Resistenze sui segmenti: attenzione

Ogni segmento del display è un LED e deve avere una corretta limitazione di corrente. Lo schema va quindi seguito con attenzione e, se ricostruisci il circuito, è buona pratica dimensionare una resistenza per ciascun segmento utilizzato, invece di considerare il display come un singolo LED.

INPUT oppure INPUT_PULLUP?

Il progetto usa INPUT e una resistenza esterna da 10 kΩ. È anche possibile usare INPUT_PULLUP; in quel caso il pulsante va collegato verso GND e la logica si inverte: premuto = LOW.

Simulazione Tinkercad

▶️ Apri la simulazione Tinkercad

Scarica lo sketch

⬇️ Scarica arduino_countdown_1_cifra.ino

Debug rapido

  • verifica il tipo di display: anodo comune o catodo comune;
  • controlla con attenzione la piedinatura fisica del display;
  • verifica la corrispondenza tra pin Arduino e segmenti a–g;
  • controlla il pulsante su D11 e la resistenza da 10 kΩ;
  • se le cifre sono deformate, quasi certamente uno o più segmenti sono collegati al pin sbagliato;
  • se tutto appare invertito, controlla la logica attiva-bassa/attiva-alta;
  • se usi D1, evita di usare contemporaneamente la seriale.

Varianti del progetto

  • usare INPUT_PULLUP per il pulsante;
  • aggiungere un secondo pulsante per pausa/reset;
  • spostare i segmenti lontano da D0/D1;
  • usare un driver BCD come CD4511;
  • passare a un display a 4 cifre multiplexato;
  • eliminare i delay() con millis().

Cosa devi ricordare

  • Il countdown parte da 9 e termina a 0.
  • Ogni cifra è una combinazione di sette segmenti.
  • Lo sketch usa D1–D8 per display e punto decimale.
  • D11 legge il pulsante, D12 pilota il buzzer e D13 il LED.
  • La logica è attiva-bassa sui segmenti.
  • Una tabella di segmenti rende il codice molto più semplice da mantenere.

Domande frequenti

Perché alcune cifre vengono visualizzate male?

Controlla la piedinatura del display e la corrispondenza tra segmenti a–g e pin Arduino. I display a 7 segmenti non hanno tutti la stessa disposizione fisica dei piedini.

Perché LOW accende il segmento?

Il progetto usa una logica attiva-bassa, tipica di un collegamento ad anodo comune. Con un catodo comune la logica normalmente si inverte.

Posso evitare di usare i pin D0 e D1?

Sì, ed è consigliabile se vuoi usare anche la seriale. Puoi spostare i segmenti su altri pin e aggiornare l’array nel codice.

Posso trasformarlo in un timer da più di 9 secondi?

Con una sola cifra puoi mostrare direttamente solo 0–9. Per tempi più lunghi conviene usare due o quattro cifre, oppure un LCD/OLED.