Semplice orologio con la funzione millis()
Scandire il tempo con Arduino per gestire azioni temporizzate

Come funziona millis()
I microcontrollori, cuore delle schede Arduino, eseguono le varie operazioni basandosi su un Clock che scandisce il ritmo con il quale queste ultime vengono svolte. Il Clock può essere generato da un oscillatore interno al microcontrollore stesso oppure esterno. Su Arduino UNO R3 il clock a 16 MHz dell’ATmega328P è fornito da un risuonatore ceramico esterno (tolleranza tipica dell’ordine di ±0,5%); altre schede usano clock diversi, ad esempio la UNO R4 lavora a 48 MHz.
Contando gli impulsi di questo clock tramite un timer, la funzione permette di conoscere da quanti millisecondi il microcontrollore è stato alimentato. Tale informazione ci viene fornita dalla funzione Arduino millis(). La precisione dipende dall’oscillatore della scheda: con un risuonatore ceramico l’errore può arrivare a qualche minuto al giorno (la deriva di 1 secondo ogni 10 minuti misurata più avanti corrisponde a circa 1/600 ≈ 1700 ppm, cioè circa 2,4 minuti al giorno).
Overflow di millis()
L’informazione ottenuta deve essere gestita come un’informazione unsigned long e quindi il valore decimale massimo gestibile prima dell’overflow è 4 294 967 295 che corrisponde a (232 – 1). Tale valore, ricordiamo, è espresso in millisecondi. Quindi con dei semplici passaggi matematici possiamo affermare che tale variabile raggiungerà l’overflow prima di resettarsi dopo 49,71 giorni. Lo sketch riportato più avanti gestisce già questa situazione: calcola il tempo trascorso come differenza tra due letture di millis() (adesso – ultimoMillis) e, grazie all’aritmetica modulare degli unsigned long, la sottrazione resta corretta anche a cavallo dell’overflow. L’unica condizione è che la funzione aggiornaTempo() venga chiamata almeno una volta ogni 49,7 giorni, cosa che nel loop() avviene di continuo. I secondi vengono accumulati in una variabile separata, che può contare per circa 136 anni.
NB. Per funzioni avanzate della gestione del tempo è consigliabile adottare un modulo ausiliario RTC, ad esempio basato sul DS3231, che mantiene l’ora anche a scheda spenta grazie alla batteria tampone.
Esempio: contatore del tempo dall’accensione
Funzionamento: quando il microcontrollore riceve il carattere ‘a’ via seriale (tale carattere corrisponde al valore decimale 97 nella tabella ASCII) viene restituita l’informazione del tempo trascorso dall’avvio del microcontrollore.
Lo sketch misura quindi il tempo trascorso dall’accensione (uptime): non conosce l’ora del giorno, che andrebbe impostata ad esempio via seriale oppure letta da un modulo RTC.
Nella variabile secondiTotali andremo ad accumulare il tempo misurato con millis() convertito in secondi (ogni 1000 ms accumulati in accumulatoreMs si aggiunge un secondo). Introduciamo anche due fattori correttivi (da impostare manualmente caso per caso prima di utilizzare tale metodo). Sfruttando una scheda Arduino UNO rev.3 ho notato che il microcontrollore ritarda il valore di millis() di 2 secondi ad ogni accensione/reset, e in seguito, ogni 10 minuti ritarda 1 secondo. Il ritardo iniziale non è un errore di millis(): dopo il reset la scheda esegue prima il bootloader e il conteggio parte solo all’avvio dello sketch. Attenzione: su Arduino UNO l’apertura del Monitor seriale provoca il reset della scheda (linea DTR), quindi il conteggio riparte da zero. Ecco quindi il motivo delle seguenti costanti, che permetteranno di eliminare questi due errori sistematici:
- OFFSET_INIZIALE_S = 2 (secondi aggiunti al conteggio per compensare il ritardo all’avvio).
- CORREZIONE_OGNI_S = 600 (ogni 600 secondi di conteggio, cioè ogni 10 minuti, viene aggiunto 1 secondo).
// Sistema di conteggio del tempo basato sul clock di Arduino.
// Quando riceve il carattere 'a' sulla seriale, stampa da quanti
// giorni, ore, minuti e secondi Arduino è acceso.
// Fattori correttivi misurati sulla scheda dell'autore: da tarare
const unsigned long OFFSET_INIZIALE_S = 2; // +2 secondi iniziali
const unsigned long CORREZIONE_OGNI_S = 600; // +1 secondo ogni 600 s (10 minuti)
unsigned long ultimoMillis = 0; // ultimo valore letto di millis()
unsigned long accumulatoreMs = 0; // millisecondi non ancora convertiti in secondi
unsigned long secondiTotali = 0; // secondi "grezzi" dall'accensione (fino a ~136 anni)
void setup() {
Serial.begin(9600);
}
// Aggiorna il contatore dei secondi. La sottrazione tra unsigned long
// resta corretta anche quando millis() va in overflow (~49,7 giorni).
void aggiornaTempo() {
unsigned long adesso = millis();
accumulatoreMs += adesso - ultimoMillis;
ultimoMillis = adesso;
while (accumulatoreMs >= 1000) {
accumulatoreMs -= 1000;
secondiTotali++;
}
}
void stampaTempo() {
// Applico la correzione: offset iniziale + 1 s ogni 10 minuti
unsigned long t = secondiTotali + secondiTotali / CORREZIONE_OGNI_S + OFFSET_INIZIALE_S;
unsigned long giorni = t / 86400UL;
unsigned long ore = (t % 86400UL) / 3600UL;
unsigned long minuti = (t % 3600UL) / 60UL;
unsigned long secondi = t % 60UL;
Serial.print(giorni); Serial.print(" giorni ");
Serial.print(ore); Serial.print(" ore ");
Serial.print(minuti); Serial.print(" minuti ");
Serial.print(secondi); Serial.println(" secondi");
}
void loop() {
aggiornaTempo();
if (Serial.available() > 0) {
if (Serial.read() == 'a') {
stampaTempo();
}
}
}
Per mostrare il tempo su un display vedi LCD liquidcrystal con Arduino; per l’organizzazione del codice vedi Introduzione alla programmazione Arduino; per un uso di millis() nel debouncing software di un pulsante vedi Circuiti di debouncing e Arduino: input digitali.




