Arduino Timing Methods With Millis (): 4 trinn

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:23

I denne artikkelen introduserer vi millis (); funksjon og sette den i bruk for å lage forskjellige timingeksempler.

Millis? Ingenting å gjøre med leppesynkronisering … forhåpentligvis anerkjente du milli som det numeriske prefikset for en tusendel; det er å multiplisere en måleenhet med 0,001 (eller ti til effekten av minus 3).

Interessant nok vil våre Arduino-systemer telle antall millisekunder (tusenvis av sekunder) fra starten av en skisse som kjører til tellingen når det maksimale antallet som kan lagres i variabeltypen usignert langt (et 32-bits [fire byte] heltall -som varierer fra null til (2^32) -1. (2^32) -1, eller 4294967295 millisekunder konverteres til 49,71027 oddetalls dager.

Telleren nullstilles når Arduino tilbakestilles, den når maksimalverdi eller en ny skisse lastes opp. For å få verdien av telleren ved et bestemt tidspunkt, bare ring funksjonen - for eksempel:

start = millis ();

Hvor start er en usignert lang variabel. Her er et veldig enkelt eksempel for å vise deg millis () i aksjon:

/ * millis () demonstrasjon */

usignert lang start, ferdig, forløpt;

ugyldig oppsett ()

{Serial.begin (9600); }

hulrom ()

{Serial.println ("Start …"); start = millis (); forsinkelse (1000); ferdig = millis (); Serial.println ("Ferdig"); forløpt = ferdig start; Serial.print (forløpt); Serial.println ("millisekunder gått"); Serial.println (); forsinkelse (500); }

Skissen lagrer gjeldende millis telling i start, venter deretter ett sekund og lagrer deretter verdien av millis igjen i ferdig. Til slutt beregner den tiden som er forsinket. I den følgende skjermdumpen til den serielle skjermen kan du se at varigheten ikke alltid var nøyaktig 1000 millisekunder, som vist på bildet.

Trinn 1:

For å si det enkelt, bruker millis -funksjonen en intern teller i ATmega -mikrokontrolleren i hjertet av din Arduino. Denne telleren øker hver klokkesyklus - som skjer (i standard Arduino og kompatible) med en klokkehastighet på 16 Mhz. Denne hastigheten styres av krystallet på Arduino -brettet (sølvtingen med T16.000 stemplet på den).

Steg 2:

Krystallnøyaktigheten kan variere avhengig av ytre temperatur og toleransen til selve krystallen. Dette vil igjen påvirke nøyaktigheten av millis -resultatet. Anekdotisk erfaring har rapportert at driften i tidsnøyaktigheten kan være rundt tre eller fire sekunder per tjuefire timers periode.

Hvis du bruker et brett eller din egen versjon som bruker en keramisk resonator i stedet for en krystall, må du merke at de ikke er like nøyaktige og vil introdusere muligheten for høyere drivnivåer. Hvis du trenger et mye høyere nivå av timingnøyaktighet, bør du vurdere spesifikke timer -ICer som Maxim DS3231.

Nå kan vi gjøre bruk av millis for forskjellige timingfunksjoner. Som vist i forrige eksempelskisse, kan vi beregne forløpt tid. For å ta denne ideen videre, la oss lage en enkel stoppeklokke. Å gjøre det kan være så enkelt eller så komplekst som nødvendig, men for dette tilfellet vil vi gå mot det enkle.

På maskinvareperspektivet vil vi ha to knapper-Start og Stop-med 10k ohm nedtrekksmotstandene koblet til henholdsvis digitale pinner 2 og 3. Når brukeren trykker på start, vil skissen notere verdien for millis - så etter at stoppet er trykket, vil skissen igjen notere verdien for millis, beregne og vise den forløpte tiden. Brukeren kan deretter trykke start for å gjenta prosessen, eller stoppe for oppdaterte data. Her er skissen:

/* Super-grunnleggende stoppeklokke ved bruk av millis (); */

usignert lang start, ferdig, forløpt;

ugyldig oppsett ()

{Serial.begin (9600); pinMode (2, INNGANG); // startknapp pinMode (3, INNGANG); // stoppknapp Serial.println ("Trykk 1 for Start/tilbakestilling, 2 for forløpt tid"); }

void displayResult ()

{float h, m, s, ms; usignert lenge over; forløpt = ferdig start; h = int (forløpt/3600000); over = forløpt%3600000; m = int (over/60000); over = over%60000; s = int (over/1000); ms = over%1000; Serial.print ("Rå forløpt tid:"); Serial.println (forløpt); Serial.print ("Forløpt tid:"); 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 (); }

hulrom ()

{if (digitalRead (2) == HIGH) {start = millis (); forsinkelse (200); // for debounce Serial.println ("Startet …"); } if (digitalRead (3) == HIGH) {ferdig = millis (); forsinkelse (200); // for debounce displayResult (); }}

Samtalene for å forsinke () brukes til å avbryte bryterne - disse er valgfrie og bruken avhenger av maskinvaren din. Bildet er et eksempel på skissens serielle monitorutgang - stoppeklokken har startet, og deretter trykket knappen to ganger seks ganger over perioder.

Trinn 3: Hastighetsmåler …

Hvis du hadde en sensor i begynnelsen og slutten av en fast avstand, kunne hastigheten beregnes: hastighet = avstand ÷ tid.

Du kan også lage et speedometer for en bevegelsesform på hjul, for eksempel en sykkel. For øyeblikket har vi ikke en sykkel å rote med, men vi kan beskrive prosessen for å gjøre det - det er ganske enkelt. (Ansvarsfraskrivelse - gjør det på egen risiko osv.)

La oss først gå gjennom den nødvendige matematikken. Du må vite omkretsen på hjulet. Maskinvare - du trenger en sensor. For eksempel - en sivbryter og magnet. Tenk på sivbryteren som en normalt åpen knapp, og koble til som vanlig med en 10k ohm nedtrekksmotstand.

Andre kan bruke en hall-effekt sensor-hver til sin egen). Husk fra matematikklassen, for å beregne omkretsen - bruk formelen: omkrets = 2πr der r er radiusen til sirkelen.

Nå som du har hjulomkretsen, kan denne verdien betraktes som vår ‘faste avstand’, og derfor kan hastigheten beregnes ved å måle den forløpte tiden mellom en full rotasjon.

Sensoren din-når den er montert-skal fungere på samme måte som en normalt åpen knapp som trykkes hver rotasjon. Skissen vår måler tiden som går mellom hver puls fra sensoren.

For å gjøre dette, vil vårt eksempel ha sensorutgangen koblet til digital pin 2 - da det vil utløse et avbrudd for å beregne hastigheten. Skissen vil ellers vise hastigheten på en normal I2C-grensesnitt LCD-modul. I2C -grensesnittet foreslås, da dette krever bare 4 ledninger fra Arduino -kortet til LCD -en - jo færre ledninger jo bedre.

Her er skissen for gjennomlesning:

/*Grunnleggende hastighetsmåler ved bruk av millis (); */

#inkludere "Wire.h" // for I2C buss LCD

#inkludere "LiquidCrystal_I2C.h" // for I2C buss LCD -modul - https://bit.ly/m7K5wt LiquidCrystal_I2C lcd (0x27, 16, 2); // sett LCD -adressen til 0x27 for 16 tegn og 2 linjers display

flyte start, ferdig;

flyte forløpt, tid; float circMetric = 1,2; // hjulomkrets i forhold til sensorposisjon (i meter) float circImperial; // ved å bruke 1 kilometer = 0,621371192 miles flyte speedk, speedm; // holder beregnede hastighetsverdier i metrisk og imperial

ugyldig oppsett ()

{attachInterrupt (0, speedCalc, RISING); // avbrudd kalles når sensorer sender digital 2 høy (hver hjulrotasjon) start = millis (); // oppsett LCD lcd.init (); // initialiser lcd lcd.backlight (); // slå på LCD -bakgrunnsbelysning lcd.clear (); lcd.println ("Bruk hjelm!"); forsinkelse (3000); lcd.clear (); Serial.begin (115200); circImperial = circMetric*.62137; // konverter metrisk til imperial for MPH -beregninger}

tomrom speedCalc ()

{forløpt = millis ()-start; start = millis (); speedk = (3600*circMetric)/forløpt; // km/t speedm = (3600*circImperial)/forløpt; // Miles i timen}

hulrom ()

{lcd.setCursor (0, 0); lcd.print (int (speedk)); lcd.print ("km/t"); lcd.print (int (speedm)); lcd.print ("MPH"); lcd.setCursor (0, 1); lcd.print (int (forløpt)); lcd.print ("ms/rev"); forsinkelse (1000); // juster for personlig preferanse for å minimere flimmer}

Det skjer ikke så mye - hver gang hjulet fullfører en omdreining vil signalet fra sensoren gå fra lavt til høyt - noe som utløser et avbrudd som kaller funksjonen speedCalc ().

Dette tar en avlesning av millis () og beregner deretter forskjellen mellom gjeldende avlesning og forrige avlesning - denne verdien blir tiden for å dekke avstanden (som er hjulets omkrets i forhold til sensoren - lagret i

float circMetric = 1,2;

og måles i meter). Den beregner til slutt hastigheten i km/t og MPH. Mellom avbruddene viser skissen de oppdaterte hastighetsdataene på LCD -skjermen, samt verdien av rå tid for hver revolusjon for nysgjerrighetens skyld. I virkeligheten tror jeg ikke at noen ville montere en LCD på en sykkel, kanskje en LED -skjerm ville være mer relevant.

I mellomtiden kan du se hvordan dette eksemplet fungerer i det følgende korte videoklippet. I stedet for et sykkelhjul og sivbryter/magnetkombinasjon, har jeg koblet kvadratbølgeutgangen fra en funksjonsgenerator til interrupt-pinnen for å simulere pulser fra sensoren, slik at du kan få en ide om hvordan det fungerer.

Trinn 4:

Det oppsummerer omtrent bruken av millis () for tiden. Det er også mikroene (); funksjon som teller mikrosekunder.

Så der har du det - en annen praktisk funksjon som kan tillate flere problemer å bli løst via Arduinos verden. Som alltid, nå er det opp til deg og din fantasi å finne noe å kontrollere eller komme opp til andre shenanigans.

Dette innlegget ble brakt til deg av pmdway.com - alt for produsenter og elektronikkentusiaster, med gratis levering over hele verden.