Guida all’uso di millis() – Lezione 1

Credo che una delle problematiche più ostiche da gestire soprattutto per i neofiti è l’utilizzo degli intervalli di tempo in cui eseguire operazioni con Arduino, mi riferisco all’uso e all’abuso improprio del delay(). Infatti gli studenti scoprono che, sebbene la funzione delay() sia facile da usare, ha degli effetti collaterali importanti; il principale è che ferma l’esecuzione dello sketch Arduino fino a quando non è trascorso il periodo di delay. Quando ciò accade, di solito chi spiega indirizza lo studente sull’esempio di defaut sulla temporizzazione non bloccante che troviamo nell’IDE di Arduino: BlinkWithoutDelay.

Molto spesso però questo confonde ancora di più le idee perché in realtà non si vuole solo far lampeggiare un LED ma si vogliono eseguire più operazioni contemporaneamente, quindi è bene comprendere a fondo il principio di funzionamento del BlinkWithoutDelay prima di poterlo applicare alla propria situazione.

Ho pensato quindi di realizzare qualche post tematico sull’uso di millis(), prendendo spunto dalle spiegazioni che realizzo per gli studenti.

Per usare millis() per la temporizzazione è necessario registrare il momento in cui un’azione si è verificata (ad esempio accensione di un LED ritardata alla pressione di un pulsante) affinché possiate iniziare a contare il tempo trascorso da tale evento, dovrete quindi controllare ad intervalli regolari se il periodo richiesto è trascorso.
Se tale intervallo di tempo non è trascorso allora il vostro programma potrà fare altro fino al prossimo controllo.

Nei programmi che seguono userò i commenti all’interno dello sketch per spiegare l’utilizzo delle varie parti del programma.

Ma cos’è millis()?

La funzione millis() restituisce il numero di millisecondi trascorsi dall’avvio del programma corrente su una scheda Arduino. Questo valore è restituito come un numero di tipo unsigned long.

Come Funziona

Incremento Automatico: il conteggio inizia automaticamente quando il microcontrollore sulla scheda Arduino viene alimentato o resettato. Il conteggio continua ad aumentare fino a che la scheda rimane alimentata.
Overflow: poiché millis() utilizza una variabile di tipo unsigned long, che ha una dimensione di 32 bit su Arduino, il valore massimo che può raggiungere è 4,294,967,295, dopo aver raggiunto questo valore, si andrà in overflow (ovvero Arduino non è in grado di memorizzare un numero più grande) e il valore restituito da millis() ripartirà da zero. Questo avviene dopo circa 49 giorni e 17 ore dall’ultimo reset della scheda.

Utilizzi di millis()

Di seguito una lista non esaustiva di alcuni utilizzi della funzione millis():

Temporizzazione non bloccante: a differenza di delay(), che ferma l’esecuzione del programma per un periodo specificato, millis() può essere utilizzato per realizzare pause o attese senza bloccare altre operazioni. Questo è particolarmente utile in applicazioni multitasking dove altre attività devono continuare ad essere eseguite.
Debounce: viene spesso usata per implementare il debounce di pulsanti o switch, riducendo gli effetti dei rimbalzi meccanici che possono causare letture multiple per una singola pressione.
Esecuzione di azioni a intervalli regolari: può essere utilizzata per eseguire specifiche azioni a intervalli regolari, come leggere sensori, aggiornare display, o inviare dati.

Pratica di utilizzo

Per utilizzare millis() per la temporizzazione, il vostro sketch deve conoscere il valore attuale del tempo (valore restituito da millis()) e questa rilevazione può essere fatto quando volete, in più punti dello sketch ovviamente dovrebbe essere fatta quando serve, ma vediamo cosa vuol dire.

Tipicamente il valore di millis() conviene registrarlo in una variabile ad inizio loop() o all’interno del setup() in questo modo:

millisCorrente = millis();

Regola di utilizzo:

La variabile millisCorrente deve essere stata precedentemente dichiarata.
Deve essere di tipo unsigned long perché millis() restituisce un intero long senza segno.

Regole generali che valgono per tutti i programmi che realizzerete, lo scrivo perchè puntualmente durante le correzioni qualcuno dimentica questa due regolette:

Il nome della variabile, così come accade per tutte le variabili dovrebbe essere autoesplicativa, quindi il suo nome deve dare informazioni: “a cosa serve”
Inoltre è buona regola utilizzare la notazione Camel Case per gestire nomi di variabili composte da più parole, ciò vale anche per le funzioni.

Come spesso accade durante le attività di laboratorio, lascio come semplicissimo esercizio per lo studente il desumere i componenti utilizzati e connessioni dagli sketch di esempio, quindi fate riferimento a quanto indicato in ogni singolo programma, si tratterà semplicemente di connettere dei LED con in serie un resistore da 220 Ohm. Per quanto riguarda l’ultimo esempio fate riferimento al link indicato che rimanda ad un altro post su questo sito.

Siete ora pronti per seguire le spiegazioni successive.

Esempio 1 – blink senza delay versione 1

Per poter introdurre il primo esempio dell’uso di millis() avremo bisogno di altre due variabili per sapere se il periodo impostato è trascorso.

Per comprendere come procedere chiedetevi:

Conosciamo il valore corrente di millis(), ma quando è iniziato il periodo di temporizzazione e quanto è lungo il periodo?

Quindi per farlo, possiamo definire due variabili aggiuntive all’inizio del nostro sketch:

Una variabile per memorizzare il momento in cui l’ultimo evento (o azione) è iniziato. Potremmo chiamarla: millisPrecedente.
Una variabile per definire la durata del periodo di temporizzazione, cioè quanto tempo vogliamo aspettare prima di eseguire di nuovo l’azione. La chiameremo: intervallo.

La chiave per utilizzare millis() per la temporizzazione non bloccante sta nel confrontare continuamente il tempo corrente, millisCorrente con il tempo dall’ultimo evento, millisPrecedente con l’intervallo di tempo desiderato, intervallo. Se questa differenza è maggiore o uguale all’intervallo, allora è il momento di eseguire nuovamente l’azione.

Utilizzando quanto detto il codice che segue permette di far lampeggiare ogni secondo il LED connesso al pin 13 utilizzando millis().

1// Prof. Maffucci Michele
2// Uso della funzione millis()
3 
4// Dichiarazione delle variabili globali
5unsigned long startMillis;          // memorizza l'inizio del periodo di conteggio
6unsigned long millisCorrente;       // valore attuale del millis
7const unsigned long periodo = 1000; // durata del periodo in millisecondi, cioè 1 secondo
8 
9// Pin a cui è collegato il LED
10const int ledPin = 13;
11 
12void setup() {
13  // Inizializza il pin del LED come OUTPUT
14  pinMode(ledPin, OUTPUT);
15  // Memorizza il momento in cui inizia il programma
16  startMillis = millis();
17}
18 
19void loop() {
20  // Aggiorna il valore di millisCorrente ad ogni ciclo
21  millisCorrente = millis();
22 
23// Controlla se è passato il periodo di tempo
24  if (millisCorrente - startMillis >= periodo) {
25    // Cambiare lo stato del LED
26    statoLED();
27    // Reimposta startMillis per il prossimo periodo
28    startMillis = millisCorrente;
29  }
30 
31// in questo punto puoi aggiungere atre attività che devono essere svolte
32}
33 
34void statoLED() {
35  // Controlla lo stato attuale del LED e lo cambia
36  if (digitalRead(ledPin) == HIGH) {
37    digitalWrite(ledPin, LOW); // spegni il LED
38  } else {
39    digitalWrite(ledPin, HIGH); // accendi il LED
40  }
41}

Utilizzando millis(), il programma memorizza il momento in cui l’ultimo cambiamento di stato (accensione/spegnimento) del LED è avvenuto. Ogni volta che il loop() viene eseguito, il programma controlla se è trascorso un secondo dall’ultima azione, se un secondo è passato, cambia lo stato del LED e aggiorna startMillis con il tempo corrente per iniziare un nuovo periodo.

Esempio 2 – blink senza delay versione 2

Vediamo un altro modo più conciso per riscrivere il programma dell’esempio 1, anche in questo caso utilizziamo il pin 13 a cui colleghiamo un LED.

1// Prof. Maffucci Michele
2// Uso della funzione millis()
3 
4unsigned long startMillis;           // memorizza l'inizio del periodo di conteggio
5unsigned long millisCorrente;        // valore attuale del millis
6const unsigned long periodo = 1000;  // valore in millisecondi, ovvero 1 secondo
7const byte ledPin = 13;              // utilizzo del LED sulla sched Arduino
8 
9void setup() {
10  pinMode(ledPin, OUTPUT);  // imposta il pin del LED come OUTPUT
11  startMillis = millis();   // tempo iniziale
12}
13 
14void loop() {
15  millisCorrente = millis();                       // ottiene il "tempo" attuale
16  if (millisCorrente - startMillis >= periodo) {   // verifica se il periodo è trascorso
17    digitalWrite(ledPin, !digitalRead(ledPin));    // cambia lo stato del LED
18    startMillis = millisCorrente;                  // salva l'inizio del periodo corrente
19  }
20}

Esempio 3 – Controllo di Due LED con periodi diversi

Faremo lampeggiare con periodi diversi due LED connessi al pin 11 e 12.

1// Prof. Maffucci Michele
2// Uso della funzione millis()
3// Lampeggio di due LED con periodi diversi
4 
5// Dichiarazione delle variabili globali
6unsigned long millisCorrente;               // valore attuale del millis
7const byte ledPin1 = 11;                    // pin a cui è connesso il LED 1
8const byte ledPin2 = 12;                    // pin a cui è connesso il LED 2
9unsigned long millisPrecedente1 = 0;        // valore del millis precedente per il LED 1
10unsigned long millisPrecedente2 = 0;        // valore del millis precedente per il LED 2 
11const long intervalo1 = 1000;               // 1 secondo - periodo LED 1
12const long intervalo2 = 250;                // 250 millisecondi - periodo LED 2
13 
14void setup() {
15  pinMode(ledPin1, OUTPUT); // Imposta il pin del LED 1 come OUTPUT
16  pinMode(ledPin2, OUTPUT); // Imposta il pin del LED 2 come OUTPUT
17}
18 
19void loop() {
20  millisCorrente = millis();  // Assegna tempo attuale a millisCorrente
21 
22if (millisCorrente - millisPrecedente1 >= intervalo1) {  // verifica se l'intervallo 1 è trascorso
23    millisPrecedente1 = millisCorrente;                    // salva l'inizio del periodo corrente per il LED 1
24    digitalWrite(ledPin1, !digitalRead(ledPin1));          // cambia lo stato del LED 1
25  }
26 
27if (millisCorrente - millisPrecedente2 >= intervalo2) {  // verifica se l'intervallo 2 è trascorso
28    millisPrecedente2 = millisCorrente;                   // salva l'inizio del periodo corrente per il LED 2
29    digitalWrite(ledPin2, !digitalRead(ledPin2));       // cambia lo stato del LED 2
30  }
31}

Esempio 4 – Fading in di un LED senza l’utilizzo del delay

Utilizzeremo per questo esempio un LED connesso al pin 9.

1// Prof. Maffucci Michele
2// Uso della funzione millis() per controllare il feading in di un LED
3 
4int ledPin = 9;                       // pin PWM per il controllo della luminosità
5unsigned long millisPrecedente = 0;   // valore del millis precedente per il LED
6const long intervallo = 20;           // intervallo di aggiornamento della luminosità
7int luminosita = 0;                   // intensità luminosa corrente del LED
8int livelloLuminosita = 5;            // incremento minimo della luminosità
9 
10void setup() {
11  pinMode(ledPin, OUTPUT);  // imposta il pin del LED come OUTPUT
12}
13 
14void loop() {
15  unsigned long millisCorrente = millis();   // assegna a millisCorrente il valore attuale
16 
17// Ogni 20 millisecondi l'intensità luminosa del LED aumenta di 5 unità
18  if(millisCorrente - millisPrecedente >= intervallo) { // verifica se l'intervallo è trascorso
19    millisPrecedente = millisCorrente;                  // salva l'inizio del periodo corrente per il LED
20    analogWrite(ledPin, luminosita);                    // imposta la luminosità del LED 
21    luminosita = luminosita + livelloLuminosita;        // incremento della luminosità
22  }
23}

Esempio 5 – Fading in e fading out di un LED senza l’utilizzo del delay

Utilizzeremo per questo esempio un LED connesso al pin 9.

1// Prof. Maffucci Michele
2// Uso della funzione millis() per controllare il feading in e out di un LED
3 
4int ledPin = 9; // pin PWM per il controllo della luminosità
5unsigned long millisPrecedente = 0; // alore del millis precedente per il LED
6const long intervallo = 20; // intervallo di aggiornamento della luminosità
7int luminosita = 0; // intensità luminosa corrente del LED
8int livelloLuminosita = 5; // incremento minimo della luminosità
9 
10void setup() {
11pinMode(ledPin, OUTPUT); // imposta il pin del LED come OUTPUT
12}
13 
14void loop() {
15unsigned long millisCorrente = millis(); // assegna a millisCorrente il valore attuale
16 
17// Ogni 20 millisecondi l'intensità luminosa del LED aumenta di 5 unità
18if(millisCorrente - millisPrecedente >= intervallo) { // Verifica se l'intervallo è trascorso
19millisPrecedente = millisCorrente; // salva l'inizio del periodo corrente per il LED
20analogWrite(ledPin, luminosita); // imposta la luminosità del LED
21luminosita = luminosita + livelloLuminosita; // incremento della luminosità
22 
23// Cambia direzione del fade quando raggiunge i limiti di luminosità
24if (luminosita <= 0 || luminosita >= 255) {
25livelloLuminosita = -livelloLuminosita; // Inversione di segno per ridurre l'intensità luminosa
26}
27}
28}

Esempio 6 – Utilizzo della funzione millis() per temporizzare le letture di un sensore DHT11 e l’accensione di un LED

Realizziamo ora uno sketch che utilizza millis() per eseguire letture a intervalli regolari e l’accensione di un LED per alcuni secondi durante la lettura in modo che una persona abbia percezione dell’avvenuta rilevazione. Il valore della temperatura e dell’umidità verranno stampati sulla Serial Monitor. Per una spiegazione approfondita sull’uso del sensore DHT 11 si faccia riferimento alla mia spiegazione: “Arduino: utilizzo del sensore di umidità e temperatura DHT11” di seguito utilizzerò parte degli sketch già spiegati e i medesimi schemi di collegamento.

Componenti

DHT 11 su breakout board
LED
Resistore da 220 Ohm da inserire in serie al LED

Utilizzeremo il pin 2 di Arduino per collegare il pin data del sensore ed il pin 13 a cui collegheremo il LED.

1// Prof. Maffucci Michele
2// Utilizzo della funzione millis() per temporizzare
3// le letture di un sensore DHT11 e l'accensione di un LED
4 
5#include "DHT.h"
6 
7// Definizione dei pin e costanti
8#define DHTTYPE DHT11 // tipo di sensore DHT
9const byte pinDHT = 2; // pin a cui è collegato il sensore DHT11
10const byte pinLED = 13; // pin a cui è collegato il LED
11 
12const unsigned long intervalloLettura = 10000; // intervallo tra le letture (10 secondi)
13const unsigned long durataLED = 3000; // durata accensione LED (3 secondi)
14 
15// Variabili globali
16unsigned long tempoPrecedenteLettura = 0; // tempo dell'ultima lettura
17unsigned long tempoInizioLED = 0; // tempo di inizio accensione LED
18bool ledAcceso = false; // stato del LED
19 
20DHT dht(pinDHT, DHTTYPE);
21 
22void setup() {
23// Inizializzazione
24Serial.begin(9600);
25dht.begin();
26pinMode(pinLED, OUTPUT);
27digitalWrite(pinLED, LOW);
28}
29 
30void loop() {
31unsigned long tempoCorrente = millis();
32 
33// Controlliamo se è ora di fare una nuova lettura
34if (tempoCorrente - tempoPrecedenteLettura >= intervalloLettura) {
35// Aggiorna il tempo dell'ultima lettura
36tempoPrecedenteLettura = tempoCorrente;
37 
38// Esegue la lettura del sensore
39float umidita = dht.readHumidity();
40float temperatura = dht.readTemperature();
41 
42// Controlla eventuali errori di lettura
43if (isnan(umidita) || isnan(temperatura)) {
44Serial.println("Errore di lettura dal sensore DHT11");
45} else {
46// Stampa i valori sulla Serial Monitor
47Serial.print("Umidità: ");
48Serial.print(umidita);
49Serial.print("% Temperatura: ");
50Serial.print(temperatura);
51Serial.println("°C");
52 
53// Accende il LED per indicare la lettura
54digitalWrite(pinLED, HIGH);
55ledAcceso = true;
56tempoInizioLED = tempoCorrente;
57}
58}
59 
60// Controllo se il LED deve essere spento
61if (ledAcceso && (tempoCorrente - tempoInizioLED >= durataLED)) {
62digitalWrite(pinLED, LOW);
63ledAcceso = false;
64}
65}

Se avete necessità di ulteriori dettagli chiedete.

Buon Coding a tutti

Michele Maffucci

… my stories, life and work

Guida all’uso di millis() – Lezione 1

Ma cos’è millis()?

Come Funziona

Utilizzi di millis()

Pratica di utilizzo

Esempio 1 – blink senza delay versione 1

Esempio 2 – blink senza delay versione 2

Esempio 3 – Controllo di Due LED con periodi diversi

Esempio 4 – Fading in di un LED senza l’utilizzo del delay

Esempio 5 – Fading in e fading out di un LED senza l’utilizzo del delay

Esempio 6 – Utilizzo della funzione millis() per temporizzare le letture di un sensore DHT11 e l’accensione di un LED

Lascia un commento Annulla risposta

Ma cos’è millis()?

Come Funziona

Utilizzi di millis()

Pratica di utilizzo

Esempio 1 – blink senza delay versione 1

Esempio 2 – blink senza delay versione 2

Esempio 3 – Controllo di Due LED con periodi diversi

Esempio 4 – Fading in di un LED senza l’utilizzo del delay

Esempio 5 – Fading in e fading out di un LED senza l’utilizzo del delay

Esempio 6 – Utilizzo della funzione millis() per temporizzare le letture di un sensore DHT11 e l’accensione di un LED

Condividi:

Articoli correlati:

Lascia un commento Annulla risposta