o funcție Arduino bine cunoscută este delay() care întrerupe programul pentru o cantitate de milisecunde specificată ca parametru.
millis(), pe de altă parte, este o funcție care returnează cantitatea de milisecunde care au trecut de la începerea programului.
la prima vedere vă puteți îndoi de utilitatea acestei funcții. Faptul este că este extrem de util în multe scenarii, adesea „înlocuind” delay() complet. Să ne uităm mai întâi la modul în care putem folosi millis() aproape exact ca delay().
problemele de sincronizare sunt adesea prezente în programare.
folosind Milis () ca întârziere()
int period = 1000;unsigned long time_now = 0;void setup() {Serial.begin(115200);}void loop() {time_now = millis(); Serial.println("Hello"); while(millis() < time_now + period){//wait approx. ms}}
dacă doriți ca codul dvs. să se întrerupă doar pentru 1000 ms la sfârșitul fiecărei iterații de buclă, codul de mai sus este puțin prost. Puteți folosi doar delay(1000) în schimb. Singura diferență între codul de mai sus și un cod cu delay(1000) la sfârșit este că bucla din Codul de mai sus va rula destul de precis o dată pe secundă. Bucla într-un cod cu delay(1000) va rula un pic mai puțin frecvent, deoarece este nevoie de ceva timp pentru a executa Serial.println("Hello").
de ce să folosiți millis() în loc de delay()?
vom analiza acum două avantaje cu millis()comparativ cu delay().
sincronizare exactă
primul avantaj pe care îl vom discuta este sincronizarea exactă. Cod-înțelept, am acoperit acest lucru în ultimul capitol. Cu millis() ne putem asigura că bucla rulează ori de câte ori dorim, indiferent de timpul de execuție (evident, atâta timp cât timpul de execuție este mai puțin timp perioada dorită). Cu delay() acest lucru nu este posibil, deoarece nu știm cât timp este timpul de execuție a buclei.
sincronizarea exactă ca aceasta este foarte utilă atunci când eșantionați la o anumită frecvență sau rulați filtre, printre altele.
non-blocare
celălalt avantaj cu millis() este că nu ne va împiedica să rulăm codul în timp ce „așteptăm”.
să presupunem că vrem să tipărim „Hello” peste serial o dată pe secundă în timp ce facem alte lucruri între timp. Acest lucru nu este posibil cu delay(), deoarece întrerupe întregul cod. Iată o modalitate prin care putem face acest lucru:
int period = 1000;unsigned long time_now = 0;void setup() {Serial.begin(115200);}void loop() {if(millis() >= time_now + period){time_now += period;Serial.println("Hello");} //Run other code}
această bucată de cod este destul de similară cu prima bucată, cu excepția faptului că nu blochează restul programului atunci când nu imprimă peste serial.
exemplu: un planificator simplu
să scriem un exemplu simplu în care creăm un planificator care imprimă anumiți biți de text la intervale diferite.
#define INTERVAL_MESSAGE1 5000#define INTERVAL_MESSAGE2 7000#define INTERVAL_MESSAGE3 11000#define INTERVAL_MESSAGE4 13000unsigned long time_1 = 0;unsigned long time_2 = 0;unsigned long time_3 = 0;unsigned long time_4 = 0;void print_time(unsigned long time_millis);void setup() {Serial.begin(115200);}void loop() {if(millis() >= time_1 + INTERVAL_MESSAGE1){time_1 +=INTERVAL_MESSAGE1;print_time(time_1);Serial.println("I'm message number one!");} if(millis() >= time_2 + INTERVAL_MESSAGE2){time_2 +=INTERVAL_MESSAGE2;print_time(time_2);Serial.println("Hello, I'm the second message.");} if(millis() >= time_3 + INTERVAL_MESSAGE3){time_3 +=INTERVAL_MESSAGE3;print_time(time_3);Serial.println("My name is Message the third.");} if(millis() >= time_4 + INTERVAL_MESSAGE4){time_4 += INTERVAL_MESSAGE4;print_time(time_4);Serial.println("Message four is in the house!");}}void print_time(unsigned long time_millis){Serial.print("Time: ");Serial.print(time_millis/1000);Serial.print("s - ");}
Iată cum arată primele 60 de secunde din Monitorul serial:
acesta este un mod frumos și ușor de a sincroniza execuțiile în codul dvs. Aveți posibilitatea de a rula alt cod simultan, de asemenea.
micros() și debordant
la fel ca delay() are o versiune microsecundă numită delayMicroseconds(), millis()are micros(). Dacă aveți nevoie de o rezoluție mai bună, micros() poate fi calea de urmat.
cu toate acestea, rețineți că micros() se va revărsa după aproximativ 70 de minute, comparativ cu millis() 50 de zile. Aceasta înseamnă că valorile returnate ale funcțiilor vor începe de la zero.
mai important: pentru a afla cum puteți evita problema overflow alltogether, citiți acest post pe blog.
rezumat
millis() și micros() sunt funcții foarte utile pentru a utiliza atunci când se ocupă cu sarcini de sincronizare. Dacă nu sunteți conștienți de acestea, s-ar putea să ajungeți să utilizați delay() în schimb, ceea ce nu va funcționa întotdeauna atât de bine (dacă este deloc).
pentru mai multe sfaturi Arduino & trucuri, a verifica afară nostru Arduino tutoriale blog Categorie. Stay tuned pentru mai mult conținut legate de Arduino în viitor, de asemenea!