Arduino Timing Methods With Millis (): 4 trin

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:28

I denne artikel introducerer vi millis (); funktion og brug den til at oprette forskellige timingeksempler.

Millis? Intet at gøre med læbesynkronisering … forhåbentlig genkendte du milli som værende det numeriske præfiks for en tusindedele; det er at multiplicere en måleenhed med 0,001 (eller ti med effekten af minus 3).

Interessant nok vil vores Arduino-systemer tælle antallet af millisekunder (tusinder af et sekund) fra starten af en skitse, der kører, indtil tællingen når det maksimale antal, der kan lagres i variabeltypen usigneret langt (et 32-bit [fire byte] heltal -der spænder fra nul til (2^32) -1. (2^32) -1 eller 4294967295 millisekunder konverteres til 49,71027-ulige dage.

Tælleren nulstilles, når Arduino nulstilles, den når den maksimale værdi, eller en ny skitse uploades. For at få værdien af tælleren på et bestemt tidspunkt, skal du bare ringe til funktionen - for eksempel:

start = millis ();

Hvor start er en usigneret lang variabel. Her er et meget enkelt eksempel for at vise dig millis () i aktion:

/ * millis () demonstration */

usigneret lang start, færdig, forløbet;

ugyldig opsætning ()

{Serial.begin (9600); }

hulrum ()

{Serial.println ("Start …"); start = millis (); forsinkelse (1000); færdig = millis (); Serial.println ("Færdig"); forløbet = færdigstart; Serial.print (forløbet); Serial.println ("forløbet millisekunder"); Serial.println (); forsinkelse (500); }

Skitsen gemmer det aktuelle millis tal i starten, venter derefter et sekund og gemmer derefter værdien af millis igen i færdig. Endelig beregner den den forløbne tid for forsinkelsen. I den følgende skærmdump på den serielle skærm kan du se, at varigheden ikke altid var præcis 1000 millisekunder, som vist på billedet.

Trin 1:

For at sige det enkelt gør millis -funktionen brug af en intern tæller i ATmega -mikrokontrolleren i hjertet af din Arduino. Denne tæller øger hver urcyklus - hvilket sker (i standard Arduino og kompatible) med en hastighed på 16 Mhz. Denne hastighed styres af krystallen på Arduino -tavlen (sølvtingen med T16.000 stemplet på den).

Trin 2:

Krystalnøjagtighed kan variere afhængigt af ydre temperatur og tolerancen for selve krystallen. Dette vil igen påvirke nøjagtigheden af dit millis resultat. Anekdotisk erfaring har rapporteret, at driften i timingnøjagtighed kan være omkring tre eller fire sekunder pr. 24 timer.

Hvis du bruger et tavle eller din egen version, der bruger en keramisk resonator i stedet for en krystal, skal du bemærke, at de ikke er så præcise og vil introducere muligheden for højere driftsniveauer. Hvis du har brug for et meget højere niveau af timingnøjagtighed, skal du overveje specifikke timer -IC'er som f.eks. Maxim DS3231.

Nu kan vi gøre brug af millis til forskellige timingfunktioner. Som vist i den foregående eksempelskitse, kan vi beregne forløbet tid. For at tage denne idé videre, lad os lave et simpelt stopur. At gøre det kan være så enkelt eller så komplekst som nødvendigt, men i dette tilfælde vil vi bevæge os mod det enkle.

Med hensyn til hardware har vi to knapper-Start og Stop-med 10k ohm pull-down modstande tilsluttet henholdsvis digitale pins 2 og 3. Når brugeren trykker på start, vil skitsen notere værdien for millis - derefter efter at der er trykket på stop, vil skitsen igen notere værdien for millis, beregne og vise den forløbne tid. Brugeren kan derefter trykke på start for at gentage processen eller stoppe for opdaterede data. Her er skitsen:

/* Superbaseret stopur ved hjælp af millis (); */

usigneret lang start, færdig, forløbet;

ugyldig opsætning ()

{Serial.begin (9600); pinMode (2, INPUT); // startknap pinMode (3, INPUT); // stop -knap Serial.println ("Tryk på 1 for Start/reset, 2 for forløbet tid"); }

void displayResult ()

{float h, m, s, ms; usigneret længe over; forløbet = færdigstart; h = int (forløbet/3600000); over = forløbet%3600000; m = int (over/60000); over = over%60000; s = int (over/1000); ms = over%1000; Serial.print ("Rå forløbet tid:"); Serial.println (forløbet); Serial.print ("Forløbet tid:"); Serial.print (h, 0); Serial.print ("h"); Serial.print (m, 0); Serial.print ("m"); Serial.print (r, 0); Serial.print ("s"); Serial.print (ms, 0); Serial.println ("ms"); Serial.println (); }

hulrum ()

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

Opkaldene til forsinkelse () bruges til at afbryde switchene - disse er valgfri, og deres brug afhænger af din hardware. Billedet er et eksempel på skitsens serielle monitorudgang - stopuret er startet, og derefter trykkes to gange seks gange på tværs af perioder.

Trin 3: Speedometer …

Hvis du havde en sensor i begyndelsen og slutningen af en fast distance, kunne hastigheden beregnes: hastighed = afstand ÷ tid.

Du kan også lave et speedometer til en bevægelsesform på hjul, for eksempel en cykel. På nuværende tidspunkt har vi ikke en cykel at rode med, men vi kan beskrive processen til at gøre det - det er ret simpelt. (Ansvarsfraskrivelse - gør det på egen risiko osv.)

Lad os først og fremmest gennemgå den nødvendige matematik. Du skal kende hjulets omkreds. Hardware - du skal bruge en sensor. For eksempel - en sivkontakt og magnet. Betragt reedkontakten som en normalt åben knap, og tilslut som normalt med en 10k ohm pull-down-modstand.

Andre kan bruge en hall-effekt sensor-hver til sin egen). Husk fra matematikklassen, for at beregne omkredsen - brug formlen: omkreds = 2πr, hvor r er cirkelens radius.

Nu hvor du har hjulets omkreds, kan denne værdi betragtes som vores 'faste afstand', og derfor kan hastigheden beregnes ved at måle den forløbne tid mellem en fuld rotation.

Din sensor-når den er monteret-skal fungere på samme måde som en normalt åben knap, der skubbes ved hver rotation. Vores skitse måler den tid, der er gået mellem hver puls fra sensoren.

For at gøre dette vil vores eksempel have sensoroutput tilsluttet digital pin 2 - da det vil udløse en afbrydelse til at beregne hastigheden. Skitsen vil ellers vise hastigheden på et normalt I2C-interface LCD-modul. I2C -grænsefladen foreslås, da dette kun kræver 4 ledninger fra Arduino -kortet til LCD -skærmen - jo færre ledninger jo bedre.

Her er skitsen til din gennemgang:

/*Grundlæggende speedometer ved hjælp af millis (); */

#inkluderer "Wire.h" // til I2C bus LCD

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

flyde start, færdig;

float forløbet, tid; float circMetric = 1,2; // hjulomkrets i forhold til sensorposition (i meter) float circImperial; // ved hjælp af 1 kilometer = 0,621371192 miles float speedk, speedm; // holder beregnede hastighedsværdier i metrisk og imperial

ugyldig opsætning ()

{attachInterrupt (0, speedCalc, RISING); // afbrydelse kaldes, når sensorer sender digital 2 høj (hver hjulrotation) start = millis (); // opsæt LCD lcd.init (); // initialiser lcd lcd.backlight (); // Tænd LCD -baggrundsbelysning lcd.clear (); lcd.println ("Brug hjelm!"); forsinkelse (3000); lcd.clear (); Serial.begin (115200); circImperial = circMetric*.62137; // konverter metrisk til imperial til MPH -beregninger}

tomrumshastighedCalc ()

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

hulrum ()

{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øbet)); lcd.print ("ms/rev"); forsinkelse (1000); // juster efter personlig præference for at minimere flimmer}

Der sker ikke så meget - hver gang hjulet gennemfører en omdrejning vil signalet fra sensoren gå fra lavt til højt - hvilket udløser en afbrydelse, der kalder funktionen speedCalc ().

Dette tager en aflæsning af millis () og beregner derefter forskellen mellem den aktuelle aflæsning og den forrige aflæsning - denne værdi bliver tiden til at dække afstanden (som er hjulets omkreds i forhold til sensoren - lagret i

float circMetric = 1,2;

og måles i meter). Det beregner endelig hastigheden i km/t og MPH. Mellem afbrydelser viser skitsen de opdaterede hastighedsdata på LCD'et samt råtidsværdien for hver revolution for nysgerrighedens skyld. I virkeligheden tror jeg ikke, at nogen ville montere en LCD på en cykel, måske ville et LED -display være mere relevant.

I mellemtiden kan du se, hvordan dette eksempel fungerer i det følgende korte videoklip. I stedet for et cykelhjul og sivkontakt/magnetkombination har jeg tilsluttet kvadratbølgeudgangen fra en funktionsgenerator til afbryderstiften for at simulere impulserne fra sensoren, så du kan få en idé om, hvordan det fungerer.

Trin 4:

Det opsummerer næsten brugen af millis () foreløbig. Der er også mikroerne (); funktion, der tæller mikrosekunder.

Så der har du det - en anden praktisk funktion, der kan gøre det muligt at løse flere problemer via Arduinos verden. Som altid er det nu op til dig og din fantasi at finde noget at kontrollere eller komme op til andre shenanigans.

Dette indlæg blev bragt til dig af pmdway.com - alt for producenter og elektronikentusiaster, med gratis levering over hele verden.