Timer con Arduino e display a 4 cifre

// ==========================================================
// TIMER ARDUINO CON DISPLAY A 4 CIFRE
// Cablaggio basato sul progetto HS410561K-32
// ==========================================================

// Buzzer collegato al pin D0.
// NOTA: D0 è anche RX della seriale hardware.
const int buzzerPin = 0;

// Segmenti nell'ordine a, b, c, d, e, f, g.
// Mappatura dei segmenti utilizzata nel progetto.
const int segmenti[7] = {
 3, // a
 4, // b
 6, // c
 7, // d
 8, // e
 2, // f
 1 // g
};

// Punto decimale
const int puntoPin = 5;

// Pin che selezionano le quattro cifre
const int cifrePin[4] = {9, 10, 11, 12};

// Pulsante di impostazione del tempo
const int pulsantePin = 13;

// Tabella dei segmenti per i numeri 0...9.
// Ordine: a,b,c,d,e,f,g
const bool numeri[10][7] = {
 {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
};

// Minuti scelti dall'utente
int minutiImpostati = 0;

// Secondi rimanenti durante il countdown
long secondiResidui = 0;

// Momento di riferimento del countdown
unsigned long ultimoSecondo = 0;

// Indice della cifra multiplexata
int cifraCorrente = 0;

// Momento dell'ultimo cambio cifra
unsigned long ultimoRefresh = 0;

// Stato del timer
bool timerAttivo = false;

// ----------------------------------------------------------
// Spegne tutte le cifre.
// Le cifre vengono attivate portando il relativo pin HIGH.
// ----------------------------------------------------------
void spegniCifre() {
 for (int i = 0; i < 4; i++) {
 digitalWrite(cifrePin[i], LOW);
 }
}

// ----------------------------------------------------------
// Imposta i segmenti per visualizzare una cifra.
// I segmenti sono attivi LOW in questo cablaggio.
// ----------------------------------------------------------
void impostaNumero(int numero) {

 for (int i = 0; i < 7; i++) {

 if (numeri[numero][i]) {
 digitalWrite(segmenti[i], LOW);
 } else {
 digitalWrite(segmenti[i], HIGH);
 }
 }
}

// ----------------------------------------------------------
// Aggiorna rapidamente una sola cifra del display.
// Va richiamata molto spesso dal loop().
// ----------------------------------------------------------
void aggiornaDisplay(long secondiDaMostrare) {

 // Limita il valore al formato massimo 59:59.
 if (secondiDaMostrare < 0) secondiDaMostrare = 0;
 if (secondiDaMostrare > 3599) secondiDaMostrare = 3599;

 int minuti = secondiDaMostrare / 60;
 int secondi = secondiDaMostrare % 60;

 int valori[4] = {
 minuti / 10,
 minuti % 10,
 secondi / 10,
 secondi % 10
 };

 // Aggiorna una cifra circa ogni 2 ms.
 if (millis() - ultimoRefresh >= 2) {

 ultimoRefresh = millis();

 // Prima spegne tutte le cifre
 // per evitare immagini fantasma.
 spegniCifre();

 // Prepara i segmenti della cifra corrente
 impostaNumero(valori[cifraCorrente]);

 // Punto decimale come separatore minuti/secondi.
 // È associato alla seconda cifra.
 if (cifraCorrente == 1) {
 digitalWrite(puntoPin, LOW);
 } else {
 digitalWrite(puntoPin, HIGH);
 }

 // Accende soltanto la cifra corrente
 digitalWrite(cifrePin[cifraCorrente], HIGH);

 // Passa alla cifra successiva
 cifraCorrente++;

 if (cifraCorrente > 3) {
 cifraCorrente = 0;
 }
 }
}

// ----------------------------------------------------------
// Impostazione del tempo.
// Tenendo premuto il pulsante, aumenta di un minuto
// circa ogni secondo, fino a 60 e poi riparte da zero.
// ----------------------------------------------------------
void impostaTempo() {

 unsigned long inizioPressione = millis();
 int ultimoMinutoMostrato = -1;

 while (digitalRead(pulsantePin) == HIGH) {

 unsigned long trascorso = millis() - inizioPressione;

 // 1 secondo di pressione = 1 minuto impostato
 int nuovoValore = trascorso / 1000;

 // Dopo 60 minuti riparte da 0
 nuovoValore = nuovoValore % 61;

 if (nuovoValore != ultimoMinutoMostrato) {
 minutiImpostati = nuovoValore;
 ultimoMinutoMostrato = nuovoValore;
 }

 // Durante l'impostazione mostra MM:00
 aggiornaDisplay((long)minutiImpostati * 60);
 }

 // Se è stato scelto almeno un minuto,
 // prepara e avvia il countdown.
 if (minutiImpostati > 0) {
 secondiResidui = (long)minutiImpostati * 60;
 ultimoSecondo = millis();
 timerAttivo = true;
 }
}

// ----------------------------------------------------------
// Segnalazione acustica finale.
// Mantiene il buzzer attivo per circa 5 secondi.
// ----------------------------------------------------------
void allarmeFine() {

 unsigned long inizio = millis();

 digitalWrite(buzzerPin, HIGH);

 while (millis() - inizio < 5000) {

 // Continua a mostrare 00:00
 // mentre il buzzer è attivo.
 aggiornaDisplay(0);
 }

 digitalWrite(buzzerPin, LOW);
}

void setup() {

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

 // Punto decimale
 pinMode(puntoPin, OUTPUT);
 digitalWrite(puntoPin, HIGH);

 // Selezione delle quattro cifre
 for (int i = 0; i < 4; i++) {
 pinMode(cifrePin[i], OUTPUT);
 digitalWrite(cifrePin[i], LOW);
 }

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

 // Buzzer
 pinMode(buzzerPin, OUTPUT);
 digitalWrite(buzzerPin, LOW);
}

void loop() {

 // Se il timer non è attivo,
 // mostra il tempo impostato oppure 00:00.
 if (!timerAttivo) {

 aggiornaDisplay((long)minutiImpostati * 60);

 // Pressione del pulsante = modalità impostazione
 if (digitalRead(pulsantePin) == HIGH) {
 impostaTempo();
 }

 return;
 }

 // Durante il countdown il display va aggiornato
 // continuamente per mantenere il multiplexing.
 aggiornaDisplay(secondiResidui);

 // Ogni secondo riduce il tempo residuo.
 if (millis() - ultimoSecondo >= 1000) {

 ultimoSecondo += 1000;

 if (secondiResidui > 0) {
 secondiResidui--;
 }

 // Quando arriva a zero, termina il timer.
 if (secondiResidui <= 0) {

 timerAttivo = false;

 allarmeFine();

 // Torna pronto per una nuova impostazione.
 minutiImpostati = 0;
 secondiResidui = 0;
 }
 }
}

int minuti = secondiResidui / 60;
int secondi = secondiResidui % 60;

int decineMinuti = minuti / 10;
int unitaMinuti = minuti % 10;

int decineSecondi = secondi / 10;
int unitaSecondi = secondi % 10;