Metode de sincronizare Arduino cu Millis (): 4 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:44

În acest articol introducem millis (); funcția și folosiți-o pentru a crea diverse exemple de sincronizare.

Millis? Nimic de-a face cu sincronizarea buzelor … sperăm că ați recunoscut milli ca fiind prefixul numeric pentru o mieime; adică înmulțind o unitate de măsură cu 0,001 (sau zece la puterea negativului 3).

Interesant este că sistemele noastre Arduino vor număra numărul de milisecunde (mii de secunde) de la începutul unei schițe care rulează până când numărul atinge numărul maxim care poate fi stocat în tipul variabil nesemnificat lung (un întreg pe 32 de biți [patru octeți]) - care variază de la zero la (2 ^ 32) -1. (2 ^ 32) -1 sau 4294967295 milisecunde se convertește în 49,71027-zile impare.

Contorul se resetează atunci când Arduino este resetat, acesta atinge valoarea maximă sau este încărcată o schiță nouă. Pentru a obține valoarea contorului într-un anumit moment, trebuie doar să apelați funcția - de exemplu:

start = milis ();

Unde start este o variabilă lungă nesemnată. Iată un exemplu foarte simplu pentru a vă arăta milis () în acțiune:

/ * demonstrație de milis () * /

început lung nesemnat, terminat, scurs;

configurare nulă ()

{Serial.begin (9600); }

bucla nulă ()

{Serial.println („Start …”); start = milis (); întârziere (1000); terminat = milis (); Serial.println ("Finalizat"); elapsed = terminat-pornit; Serial.print (scurs); Serial.println („milisecunde trecute”); Serial.println (); întârziere (500); }

Schița stochează numărul curent de milis la început, apoi așteaptă o secundă, apoi stochează din nou valoarea milisului la final. În cele din urmă calculează timpul scurs al întârzierii. În următoarea descărcare a ecranului monitorului serial, puteți vedea că durata nu a fost întotdeauna exact de 1000 de milisecunde, așa cum se arată în imagine.

Pasul 1:

Mai simplu spus, funcția millis folosește un contor intern din microcontrolerul ATmega din inima Arduino. Acest contor crește fiecare ciclu de ceas - ceea ce se întâmplă (în Arduino standard și compatibile) la o viteză de ceas de 16 Mhz. Această viteză este controlată de cristalul de pe placa Arduino (chestia argintie cu T16.000 ștampilată pe ea).

Pasul 2:

Precizia cristalului poate varia în funcție de temperatura externă și de toleranța cristalului în sine. La rândul său, aceasta va afecta acuratețea rezultatului dvs. în milioane. Experiența anecdotică a raportat că deriva în precizia de sincronizare poate fi de aproximativ trei sau patru secunde pe o perioadă de douăzeci și patru de ore.

Dacă utilizați o placă sau propria versiune care folosește un rezonator ceramic în locul unui cristal, rețineți că acestea nu sunt la fel de exacte și vor introduce posibilitatea unor niveluri mai ridicate de derivare. Dacă aveți nevoie de un nivel mult mai mare de precizie de sincronizare, luați în considerare circuite integrate specifice temporizatorului, cum ar fi Maxim DS3231.

Acum putem folosi milisul pentru diferite funcții de sincronizare. După cum s-a demonstrat în schița de exemplu anterioară, putem calcula timpul scurs. Pentru a duce mai departe această idee, să facem un simplu cronometru. O astfel de acțiune poate fi la fel de simplă sau complexă pe cât este necesar, dar pentru acest caz ne vom îndrepta către simpli.

Din perspectiva hardware-ului, vom avea două butoane - Start și Stop - cu rezistențele pull-down de 10 k ohm conectate la pinii 2 și respectiv 3 digitali. Când utilizatorul apasă pe start, schița va nota valoarea pentru milis - apoi după apăsarea opririi, schița va nota din nou valoarea pentru milis, calculează și afișează timpul scurs. Utilizatorul poate apăsa apoi Start pentru a repeta procesul sau opri pentru date actualizate. Iată schița:

/ * Cronometru super-bazic folosind millis (); * /

început lung nesemnat, terminat, scurs;

configurare nulă ()

{Serial.begin (9600); pinMode (2, INPUT); // butonul de pornire pinMode (3, INPUT); // opriți butonul Serial.println („Apăsați 1 pentru Start / reset, 2 pentru timpul scurs”); }

display nul Rezultat ()

{plutire h, m, s, ms; nesemnat de mult; elapsed = terminat-pornit; h = int (scurs / 3600000); peste = scurs% 3600000; m = int (peste / 60000); peste = peste% 60000; s = int (peste / 1000); ms = peste% 1000; Serial.print ("Timp brut scurs:"); Serial.println (scurs); Serial.print ("Timp scurs:"); 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 (); }

bucla nulă ()

{if (digitalRead (2) == HIGH) {start = millis (); întârziere (200); // pentru debounce Serial.println ("Început …"); } if (digitalRead (3) == HIGH) {finished = millis (); întârziere (200); // pentru debounce displayResult (); }}

Apelurile către delay () sunt utilizate pentru a renunța la comutatoare - acestea sunt opționale și utilizarea lor va depinde de hardware-ul dvs. Imaginea este un exemplu de ieșire a monitorului serial al schiței - cronometrul a început, apoi butonul de două ori apăsat de șase ori pe perioade de timp.

Pasul 3: Vitezometru …

Dacă ați avea un senzor la începutul și la sfârșitul unei distanțe fixe, viteza ar putea fi calculată: viteză = distanță ÷ timp.

De asemenea, puteți face un vitezometru pentru o formă de mișcare cu roți, de exemplu o bicicletă. În prezent nu avem o bicicletă cu care să ne încurcăm, totuși putem descrie procesul de a face acest lucru - este destul de simplu. (Declinare de responsabilitate - faceți acest lucru pe propriul risc etc.)

În primul rând, să analizăm matematica necesară. Va trebui să cunoașteți circumferința roții. Hardware - veți avea nevoie de un senzor. De exemplu - un întrerupător și magnet. Luați în considerare comutatorul Reed ca fiind un buton normal deschis și conectați-vă ca de obicei cu un rezistor de 10k ohm.

Alții pot folosi un senzor de efect de hală - fiecare pentru al său). Amintiți-vă din clasa de matematică, pentru a calcula circumferința - utilizați formula: circumferință = 2πr unde r este raza cercului.

Acum că aveți circumferința roții, această valoare poate fi considerată drept „distanța fixă” a noastră și, prin urmare, viteza poate fi calculată prin măsurarea timpului scurs între o rotație completă.

Senzorul dvs. - odată montat - ar trebui să acționeze în aceeași metodă ca un buton normal deschis care este apăsat la fiecare rotație. Schița noastră va măsura timpul scurs între fiecare impuls de la senzor.

Pentru a face acest lucru, exemplul nostru va avea ieșirea senzorului conectată la pinul digital 2 - deoarece va declanșa o întrerupere pentru a calcula viteza. Schița va afișa viteza pe un modul LCD normal cu interfață I2C. Se sugerează interfața I2C deoarece acest lucru necesită doar 4 fire de la placa Arduino la LCD - cu cât mai puține fire, cu atât mai bine.

Iată schița pentru examinarea dvs.:

/ * Vitezometru de bază folosind milis (); * /

#includeți „Wire.h” // pentru ecranul LCD al autobuzului I2C

#includeți „LiquidCrystal_I2C.h” // pentru modul LCD pentru magistrala I2C - https://bit.ly/m7K5wt LiquidCrystal_I2C lcd (0x27, 16, 2); // setați adresa LCD la 0x27 pentru un afișaj de 16 caractere și 2 linii

float start, terminat;

plutitor scurs, timp; float circMetric = 1,2; // circumferința roții în raport cu poziția senzorului (în metri) floare circImperial; // folosind 1 kilometru = 0,621371192 mile float speedk, speedm; // deține valori de viteză calculate în metrice și imperiale

configurare nulă ()

{attachInterrupt (0, speedCalc, RISING); // întrerupere apelată când senzorii trimit digital 2 high (fiecare rotație a roții) start = millis (); // configurare LCD lcd.init (); // inițializați lcd lcd.backlight (); // porniți lumina de fundal LCD lcd.clear (); lcd.println („Poartă o cască!”); întârziere (3000); lcd.clear (); Serial.begin (115200); circImperial = circMetric *.62137; // converti metrica in imperial pentru calculele MPH}

void speedCalc ()

{elapsed = millis () - start; start = milis (); speedk = (3600 * circMetric) / scurs; // km / h vitezăm = (3600 * circImperial) / scurs; // Mile pe oră }

bucla nulă ()

{lcd.setCursor (0, 0); lcd.print (int (speedk)); lcd.print („km / h”); lcd.print (int (speedm)); lcd.print ("MPH"); lcd.setCursor (0, 1); lcd.print (int (scurs)); lcd.print ("ms / rev"); întârziere (1000); // reglați pentru preferințele personale pentru a minimiza pâlpâirea}

Nu se întâmplă atât de mult - de fiecare dată când roata finalizează o rotație, semnalul de la senzor va trece de la scăzut la înalt - declanșând o întrerupere care apelează funcția speedCalc ().

Aceasta necesită o citire de milis () și apoi calculează diferența dintre citirea curentă și citirea anterioară - această valoare devine timpul de parcurgere a distanței (care este circumferința roții în raport cu senzorul - stocată în

float circMetric = 1,2;

și se măsoară în metri). În final calculează viteza în km / h și MPH. Între întreruperi, schița afișează datele de viteză actualizate pe ecranul LCD, precum și valoarea brută a timpului pentru fiecare revoluție de dragul curiozității. În viața reală, nu cred că cineva ar monta un LCD pe o bicicletă, poate că un afișaj LED ar fi mai relevant.

Între timp, puteți vedea cum funcționează acest exemplu în următorul videoclip scurt. În loc de o combinație de roți de biciclete și comutator reed / magnet, am conectat ieșirea cu undă pătrată de la un generator de funcții la pinul de întrerupere pentru a simula impulsurile de la senzor, astfel încât să vă puteți face o idee despre cum funcționează.

Pasul 4:

Asta doar rezumă utilizarea millis () pentru moment. Există, de asemenea, micros (); funcție care numără microsecunde.

Așa că o aveți - o altă funcție practică care poate permite rezolvarea mai multor probleme prin lumea Arduino. Ca întotdeauna, acum depinde de dvs. și de imaginația voastră să găsiți ceva de controlat sau să vă ridicați la alți shenanigani.

Această postare ți-a fost adusă de pmdway.com - totul pentru producătorii și pasionații de electronice, cu livrare gratuită în toată lumea.