Metodi di cronometraggio Arduino con Millis(): 4 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:02

In questo articolo introduciamo il millis(); funzione e utilizzarla per creare vari esempi di temporizzazione.

Milli? Niente a che vedere con i sincronizzatori labiali… si spera che tu abbia riconosciuto milli come il prefisso numerico per i millesimi; cioè moltiplicando un'unità di misura per 0,001 (o dieci alla potenza di 3 negativo).

È interessante notare che i nostri sistemi Arduino conteranno il numero di millisecondi (migliaia di secondo) dall'inizio di uno schizzo in esecuzione fino a quando il conteggio raggiunge il numero massimo che può essere memorizzato nella variabile di tipo unsigned long (un intero a 32 bit [quattro byte] – che va da zero a (2^32)-1. (2^32)-1, o 4294967295 millisecondi convertiti in 49,71027 giorni dispari.

Il contatore si azzera quando l'Arduino viene resettato, raggiunge il valore massimo o viene caricato un nuovo sketch. Per ottenere il valore del contatore in un determinato frangente, basta chiamare la funzione, ad esempio:

inizio=milli();

Dove start è una variabile long senza segno. Ecco un esempio molto semplice per mostrarti millis() in azione:

/* dimostrazione millis() */

inizio lungo non firmato, finito, trascorso;

configurazione nulla()

{ Serial.begin(9600); }

ciclo vuoto()

{ Serial.println("Inizio…"); inizio=milli(); ritardo(1000); finito=milli(); Serial.println("Finito"); trascorso=inizio-finito; Serial.print (scaduto); Serial.println("millisecondi trascorsi"); Serial.println(); ritardo (500); }

Lo schizzo memorizza il conteggio in millis corrente in start, quindi attende un secondo, quindi memorizza nuovamente il valore in millis in finito. Infine calcola il tempo trascorso del ritardo. Nella seguente immagine dello schermo del monitor seriale, puoi vedere che la durata non era sempre esattamente 1000 millisecondi, come mostrato nell'immagine.

Passo 1:

Per dirla semplicemente, la funzione millis utilizza un contatore interno all'interno del microcontrollore ATmega nel cuore del tuo Arduino. Questo contatore incrementa ogni ciclo di clock, cosa che avviene (in Arduino standard e compatibili) a una velocità di clock di 16 Mhz. Questa velocità è controllata dal cristallo sulla scheda Arduino (la cosa d'argento con T16.000 stampato su di essa).

Passo 2:

La precisione del cristallo può variare in base alla temperatura esterna e alla tolleranza del cristallo stesso. Questo a sua volta influenzerà la precisione del risultato in millis. L'esperienza aneddotica ha riportato che la deriva nell'accuratezza dei tempi può essere di circa tre o quattro secondi per un periodo di ventiquattro ore.

Se stai usando una scheda o la tua versione che utilizza un risonatore ceramico invece di un cristallo, nota che non sono così precisi e introdurranno la possibilità di livelli di deriva più elevati. Se hai bisogno di un livello molto più elevato di precisione di temporizzazione, prendi in considerazione circuiti integrati di timer specifici come Maxim DS3231.

Ora possiamo utilizzare i millisecondi per varie funzioni di temporizzazione. Come dimostrato nello schizzo di esempio precedente, possiamo calcolare il tempo trascorso. Per portare avanti questa idea, facciamo un semplice cronometro. Farlo può essere semplice o complesso quanto necessario, ma in questo caso vireremo verso il semplice.

Dal punto di vista hardware, avremo due pulsanti – Start e Stop – con i resistori di pull-down da 10k ohm collegati rispettivamente ai pin digitali 2 e 3. Quando l'utente preme avvia, lo schizzo annoterà il valore in millisecondi, quindi dopo aver premuto Stop, lo schizzo annoterà nuovamente il valore in millisecondi, calcolerà e visualizzerà il tempo trascorso. L'utente può quindi premere start per ripetere il processo o interrompere per i dati aggiornati. Ecco lo schizzo:

/* Cronometro di base utilizzando millis(); */

inizio lungo non firmato, finito, trascorso;

configurazione nulla()

{ Serial.begin(9600); pinMode(2, INGRESSO); // pulsante di avvio pinMode(3, INPUT); // pulsante stop Serial.println("Premi 1 per Start/reset, 2 per il tempo trascorso"); }

void displayResult()

{ float h, m, s, ms; non firmato da tempo; trascorso=inizio-finito; h=int(trascorso/3600000); oltre= trascorso%3600000; m=int(oltre/60000); oltre=oltre%60000; s=int(oltre/1000); ms=oltre%1000; Serial.print("Tempo trascorso grezzo: "); Serial.println (scaduto); Serial.print("Tempo trascorso: "); Serial.print(h, 0); Serial.print("h"); Serial.print(m, 0); Serial.print("m"); Serial.print(s, 0); Serial.print("s"); Serial.print(ms, 0); Serial.println("ms"); Serial.println(); }

ciclo vuoto()

{ if (digitalRead(2)==HIGH) { start=millis(); ritardo(200); // for antirimbalzo Serial.println("Avviato…"); } if (digitalRead(3)==HIGH) { finito=millis(); ritardo(200); // per l'antirimbalzo displayResult(); } }

Le chiamate a delay() vengono utilizzate per eseguire l'antirimbalzo degli switch: sono facoltative e il loro utilizzo dipenderà dal tuo hardware. L'immagine è un esempio dell'output del monitor seriale dello schizzo: il cronometro è stato avviato, quindi il pulsante due è stato premuto sei volte per periodi di tempo.

Passaggio 3: tachimetro…

Se avessi un sensore all'inizio e alla fine di una distanza fissa, la velocità potrebbe essere calcolata: velocità = distanza ÷ tempo.

Puoi anche creare un tachimetro per una forma di movimento su ruote, ad esempio una bicicletta. Al momento non abbiamo una bicicletta con cui scherzare, tuttavia possiamo descrivere il processo per farlo: è abbastanza semplice. (Disclaimer: fallo a tuo rischio, ecc.)

Prima di tutto, rivediamo la matematica necessaria. Dovrai conoscere la circonferenza della ruota. Hardware: avrai bisogno di un sensore. Ad esempio: un interruttore reed e un magnete. Considera l'interruttore reed come un pulsante normalmente aperto e collegalo come al solito con un resistore pull-down da 10k ohm.

Altri possono utilizzare un sensore ad effetto hall, ognuno per conto proprio). Ricorda dalla lezione di matematica, per calcolare la circonferenza, usa la formula: circonferenza = 2πr dove r è il raggio del cerchio.

Ora che hai la circonferenza della ruota, questo valore può essere considerato come la nostra "distanza fissa", e quindi la velocità può essere calcolata misurando il tempo trascorso tra una rotazione completa.

Il sensore, una volta installato, dovrebbe agire nello stesso modo di un pulsante normalmente aperto che viene premuto a ogni rotazione. Il nostro schizzo misurerà il tempo trascorso tra ogni impulso dal sensore.

Per fare ciò, il nostro esempio avrà l'uscita del sensore collegata al pin digitale 2, poiché attiverà un interrupt per calcolare la velocità. Lo schizzo mostrerà altrimenti la velocità su un normale modulo LCD con interfaccia I2C. L'interfaccia I2C è consigliata poiché richiede solo 4 fili dalla scheda Arduino al display LCD: meno fili, meglio è.

Ecco lo schizzo per la tua lettura:

/*Tachimetro di base utilizzando millis(); */

#include "Wire.h" // per LCD bus I2C

#include "LiquidCrystal_I2C.h" // per modulo LCD bus I2C - https://bit.ly/m7K5wt LiquidCrystal_I2C lcd(0x27, 16, 2); // imposta l'indirizzo LCD su 0x27 per un display a 16 caratteri e 2 righe

inizio flottante, finito;

galleggiante trascorso, tempo; float circMetric=1.2; // circonferenza ruota relativa alla posizione del sensore (in metri) float circImperial; // utilizzando 1 chilometro = 0,621371192 miglia float speedk, speedm; // contiene i valori di velocità calcolati in unità metriche e imperiali

configurazione nulla()

{ attachInterrupt(0, speedCalc, RISING); // interrupt chiamato quando i sensori inviano il digitale 2 alto (ogni rotazione della ruota) start=millis(); // imposta LCD lcd.init(); // inizializza il display lcd lcd.backlight(); // attiva la retroilluminazione LCD lcd.clear(); lcd.println("Indossa il casco! "); ritardo (3000); lcd.clear(); Serial.begin(115200); circImperial=circMetric*.62137; // converte la metrica in imperiale per i calcoli MPH }

void speedCalc()

{ trascorso=millis()-inizio; inizio=milli(); speedk=(3600*circMetric)/elapsed; // km/h speedm=(3600*circImperial)/elapsed; // Miglia all'ora }

ciclo vuoto()

{ lcd.setCursor(0, 0); lcd.print(int(velocità)); lcd.print("km/h"); lcd.print(int(velocità)); lcd.print("MPH"); lcd.setCursor(0, 1); lcd.print(int(elapsed)); lcd.print(" ms/rev "); ritardo(1000); // regola le preferenze personali per ridurre al minimo lo sfarfallio }

Non c'è molto da fare: ogni volta che la ruota completa un giro, il segnale dal sensore passerà da basso ad alto, attivando un'interruzione che chiama la funzione speedCalc().

Questo prende una lettura di millis() e poi calcola la differenza tra la lettura attuale e la lettura precedente – questo valore diventa il tempo per percorrere la distanza (che è la circonferenza della ruota rispetto al sensore – memorizzato in

float circMetric=1.2;

e si misura in metri). Infine calcola la velocità in km/he MPH. Tra le interruzioni, lo schizzo visualizza i dati di velocità aggiornati sull'LCD e il valore del tempo grezzo per ogni rivoluzione per curiosità. Nella vita reale non credo che nessuno monterebbe un LCD su una bicicletta, forse un display a LED sarebbe più rilevante.

Nel frattempo, puoi vedere come funziona questo esempio nel seguente breve video clip. Invece di una ruota di bicicletta e una combinazione di interruttore reed/magnete, ho collegato l'uscita a onda quadra di un generatore di funzioni al pin di interruzione per simulare gli impulsi dal sensore, così puoi avere un'idea di come funziona.

Passaggio 4:

Questo riassume quasi l'uso di millis() per il momento. C'è anche il micros(); funzione che conta i microsecondi.

Ecco qua: un'altra pratica funzione che può consentire di risolvere più problemi tramite il mondo di Arduino. Come sempre, ora sta a te e alla tua immaginazione trovare qualcosa da controllare o affrontare altri imbrogli.

Questo post ti è stato presentato da pmdway.com: tutto per i produttori e gli appassionati di elettronica, con consegna gratuita in tutto il mondo.