Arduino Timing Methods With Millis (): 4 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:44

I denna artikel introducerar vi millis (); funktion och använda den för att skapa olika tidsexempel.

Millis? Inget att göra med läppsynkroniserare … förhoppningsvis kände du igen milli som det numeriska prefixet för en tusendel; som multiplicerar en måttenhet med 0,001 (eller tio till effekten av negativ 3).

Intressant nog kommer våra Arduino-system att räkna antalet millisekunder (tusentals sekunder) från början av en skiss som körs tills räkningen når det maximala antalet som kan lagras i den variabla typen osignerat långt (ett 32-bitars [fyra byte] heltal -som sträcker sig från noll till (2^32) -1. (2^32) -1 eller 4294967295 millisekunder konverteras till 49,71027-udda dagar.

Räknaren återställs när Arduino återställs, den når maxvärdet eller en ny skiss laddas upp. För att få värdet på räknaren vid en viss tidpunkt, ring bara funktionen - till exempel:

start = millis ();

Där start är en osignerad lång variabel. Här är ett mycket enkelt exempel för att visa dig millis () i aktion:

/ * millis () demonstration */

osignerad långstart, klar, förfluten;

void setup ()

{Serial.begin (9600); }

void loop ()

{Serial.println ("Start …"); start = millis (); fördröjning (1000); färdig = millis (); Serial.println ("färdig"); förfluten = färdigstart; Serial.print (förflutet); Serial.println ("millisekunder förflutna"); Serial.println (); fördröjning (500); }

Skissen lagrar det aktuella millisiffran i start, väntar sedan en sekund och lagrar sedan värdet på millis igen i färdigt. Slutligen beräknar den fördröjda tidens förflutna tid. I den följande skärmdumpen på den seriella bildskärmen kan du se att varaktigheten inte alltid var exakt 1000 millisekunder, som visas på bilden.

Steg 1:

För att uttrycka det enkelt använder millis -funktionen en intern räknare i ATmega -mikrokontrollern i hjärtat av din Arduino. Denna räknare ökar varje klockcykel - vilket sker (i standard Arduino och kompatibla) med en klockhastighet på 16 Mhz. Denna hastighet styrs av kristallen på Arduino -kortet (silversaken med T16.000 stämplat på den).

Steg 2:

Kristallnoggrannheten kan variera beroende på yttre temperatur och kristallens tolerans. Detta kommer i sin tur att påverka noggrannheten i ditt millisresultat. Anekdotisk erfarenhet har rapporterat att driften i tidsnoggrannheten kan vara cirka tre eller fyra sekunder per tjugofyra timmars period.

Om du använder ett kort eller en egen version som använder en keramisk resonator istället för en kristall, notera att de inte är lika exakta och kommer att introducera möjligheten till högre driftnivåer. Om du behöver en mycket högre nivå av timingnoggrannhet, överväg specifika timer -IC: er som Maxim DS3231.

Nu kan vi använda millis för olika tidsfunktioner. Som visas i föregående exempelskiss kan vi beräkna förfluten tid. För att ta denna idé framåt, låt oss göra ett enkelt stoppur. Att göra det kan vara så enkelt eller så komplext som nödvändigt, men i det här fallet kommer vi att gå mot det enkla.

När det gäller maskinvaruperspektivet kommer vi att ha två knappar-Start och Stop-med 10k ohm neddragningsmotstånd anslutna till digitala stift 2 respektive 3. När användaren trycker på start kommer skissen att notera värdet för millis - sedan efter att stopp har tryckts kommer skissen igen att notera värdet för millis, beräkna och visa förfluten tid. Användaren kan sedan trycka på start för att upprepa processen eller stoppa för uppdaterad data. Här är skissen:

/* Superbasisk stoppur med millis (); */

osignerad långstart, klar, förfluten;

void setup ()

{Serial.begin (9600); pinMode (2, INPUT); // startknapp pinMode (3, INPUT); // stoppknapp Serial.println ("Tryck 1 för Start/återställning, 2 för förfluten tid"); }

void displayResult ()

{float h, m, s, ms; osignerad sedan länge; förfluten = färdigstart; h = int (förfluten/3600000); över = förfluten%3600000; m = int (över/60000); över = över%60000; s = int (över/1000); ms = över%1000; Serial.print ("Rå förfluten tid:"); Serial.println (förfluten); Serial.print ("Förfluten 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 (); }

void loop ()

{if (digitalRead (2) == HIGH) {start = millis (); fördröjning (200); // för debounce Serial.println ("Startade …"); } if (digitalRead (3) == HIGH) {färdig = millis (); fördröjning (200); // för debounce displayResult (); }}

Samtalen för att fördröja () används för att avbryta omkopplarna - dessa är valfria och deras användning beror på din hårdvara. Bilden är ett exempel på skissens seriella bildskärmsutgång - stoppuret har startat och sedan tryckt på knappen två gånger sex gånger över tidsperioder.

Steg 3: Hastighetsmätare …

Om du hade en sensor i början och slutet av ett fast avstånd kunde hastigheten beräknas: hastighet = avstånd ÷ tid.

Du kan också göra en hastighetsmätare för en hjulformad rörelseform, till exempel en cykel. För närvarande har vi ingen cykel att bråka med, men vi kan beskriva processen för att göra det - det är ganska enkelt. (Ansvarsfriskrivning - gör det på egen risk etc.)

Först och främst, låt oss granska den nödvändiga matematiken. Du måste veta hjulets omkrets. Hårdvara - du behöver en sensor. Till exempel - en vassströmbrytare och magnet. Betrakta vassomkopplaren som en normalt öppen knapp och anslut som vanligt med ett 10k ohm neddragbart motstånd.

Andra kan använda en hall-effektsensor-var och en för sig). Kom ihåg från matematikklassen, för att beräkna omkretsen - använd formeln: omkrets = 2πr där r är cirkelns radie.

Nu när du har hjulomkretsen kan detta värde betraktas som vårt "fasta avstånd", och därför kan hastigheten beräknas genom att mäta den förflutna tiden mellan en full rotation.

Din sensor-när den väl är monterad-ska fungera på samma sätt som en normalt öppen knapp som trycks ned varje rotation. Vår skiss mäter tiden som gått mellan varje puls från sensorn.

För att göra detta kommer vårt exempel att sensorutgången är ansluten till digital stift 2 - eftersom det kommer att utlösa ett avbrott för att beräkna hastigheten. Skissen kommer annars att visa hastigheten på en vanlig I2C-gränssnitt LCD-modul. I2C -gränssnittet föreslås eftersom detta endast kräver 4 ledningar från Arduino -kortet till LCD -skärmen - ju mindre ledningar desto bättre.

Här är skissen för din genomgång:

/*Grundläggande hastighetsmätare med millis (); */

#inkludera "Wire.h" // för I2C -buss LCD

#inkludera "LiquidCrystal_I2C.h" // för I2C -buss LCD -modul - https://bit.ly/m7K5wt LiquidCrystal_I2C lcd (0x27, 16, 2); // ställ in LCD -adressen till 0x27 för 16 tecken och 2 raders display

flytstart, färdig;

flottör förfluten, tid; float circMetric = 1,2; // hjulomkrets i förhållande till sensorläge (i meter) flottörcirkelomvandlare; // med 1 kilometer = 0,621371192 miles float speedk, speedm; // håller beräknade hastighetsvärden i metriska och imperiala

void setup ()

{attachInterrupt (0, speedCalc, RISING); // avbrott kallas när sensorer skickar digital 2 hög (varje hjulrotation) start = millis (); // konfigurera LCD lcd.init (); // initiera lcd lcd.backlight (); // slå på LCD -bakgrundsbelysning lcd.clear (); lcd.println ("Använd hjälm!"); fördröjning (3000); lcd.clear (); Serial.begin (115200); circImperial = circMetric*.62137; // konvertera metrisk till imperial för MPH -beräkningar}

void speedCalc ()

{förfluten = millis ()-start; start = millis (); speedk = (3600*circMetric)/förfluten; // km/h speedm = (3600*circImperial)/förfluten; // Mil per timme }

void loop ()

{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 (förfluten)); lcd.print ("ms/rev"); fördröjning (1000); // justera efter personliga preferenser för att minimera flimmer}

Det händer inte så mycket - varje gång hjulet slutar ett varv kommer signalen från sensorn att gå från låg till hög - vilket utlöser ett avbrott som kallar funktionen speedCalc ().

Detta tar en avläsning av millis () och beräknar sedan skillnaden mellan den aktuella avläsningen och den föregående avläsningen - detta värde blir tiden att täcka avståndet (vilket är hjulets omkrets i förhållande till sensorn - lagrad i

float circMetric = 1,2;

och mäts i meter). Den beräknar slutligen hastigheten i km/h och MPH. Mellan avbrotten visar skissen de uppdaterade hastighetsdata på LCD -skärmen samt värdet av rå tid för varje varv för nyfikenhetens skull. I verkligheten tror jag inte att någon skulle montera en LCD -skärm på en cykel, kanske skulle en LED -display vara mer relevant.

Under tiden kan du se hur detta exempel fungerar i följande korta videoklipp. Istället för en kombination av cykelhjul och vassomkopplare/magnet har jag anslutit kvadratvågsutmatningen från en funktionsgenerator till avbrottsstiftet för att simulera pulserna från sensorn, så att du kan få en uppfattning om hur det fungerar.

Steg 4:

Det sammanfattar bara användningen av millis () för tillfället. Det finns också mikron (); funktion som räknar mikrosekunder.

Så där har du det - en annan praktisk funktion som kan tillåta fler problem att lösas via Arduinos värld. Som alltid, nu är det upp till dig och din fantasi att hitta något att kontrollera eller komma upp till andra shenanigans.

Det här inlägget kommer till dig av pmdway.com - allt för tillverkare och elektronikentusiaster, med gratis leverans över hela världen.