Arduino -tydmetodes met millis (): 4 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:25

In hierdie artikel stel ons die millis () bekend; funksie en gebruik dit om verskillende voorbeelde van tydsberekening te skep.

Millis? Niks te doen met lip-sinchroniseerders nie … hopelik het u milli erken as die numeriese voorvoegsel vir een duisendste; dit is die vermenigvuldiging van 'n meeteenheid met 0,001 (of tien met die krag van negatief 3).

Interessant genoeg, ons Arduino-stelsels tel die aantal millisekondes (duisende sekondes) vanaf die begin van 'n skets wat loop totdat die telling die maksimum aantal bereik wat in die veranderlike tipe ongetekende lang ('n 32-bis [vier byte] heelgetal gestoor kan word) -wat wissel van nul tot (2^32) -1. (2^32) -1, of 4294967295 millisekondes word omgeskakel na 49.71027 onewe dae.

Die toonbank word teruggestel wanneer die Arduino herstel word, dit bereik die maksimum waarde of 'n nuwe skets word opgelaai. Om die waarde van die teller op 'n spesifieke tydstip te kry, bel die funksie - byvoorbeeld:

begin = millis ();

Waar begin is 'n ongetekende lang veranderlike. Hier is 'n baie eenvoudige voorbeeld om u millis () in aksie te wys:

/ * millis () demonstrasie */

ongetekende lang begin, klaar, verstryk;

leemte opstelling ()

{Serial.begin (9600); }

leemte lus ()

{Serial.println ("Begin …"); begin = millis (); vertraging (1000); klaar = millis (); Serial.println ("klaar"); verstryk = klaar begin; Serial.print (verstryk); Serial.println ("millisekondes verloop"); Serial.println (); vertraging (500); }

Die skets stoor die huidige millis telling in die begin, wag dan 'n sekonde en stoor dan die waarde van millis weer in klaar. Uiteindelik bereken dit die verstreke tyd van die vertraging. In die volgende skermstorting van die seriële monitor kan u sien dat die tydsduur nie altyd presies 1000 millisekondes was nie, soos in die prentjie getoon word.

Stap 1:

Eenvoudig gestel, die millis -funksie maak gebruik van 'n interne teller in die ATmega -mikrobeheerder in die hartjie van jou Arduino. Hierdie toonbank verhoog elke kloksiklus - wat gebeur (in standaard Arduino en versoenbaar) met 'n kloksnelheid van 16 Mhz. Hierdie snelheid word beheer deur die kristal op die Arduino -bord (die silwer ding met T16.000 daarop gestempel).

Stap 2:

Kristal akkuraatheid kan wissel na gelang van die eksterne temperatuur en die toleransie van die kristal self. Dit sal weer die akkuraatheid van u millis -resultaat beïnvloed. Volgens anekdotiese ervaring kan die afname in tydsberekening akkuraatheid ongeveer drie of vier sekondes per vier-en-twintig uur wees.

As u 'n bord of 'n eie weergawe gebruik wat 'n keramiekresonator in plaas van 'n kristal gebruik, moet u daarop let dat dit nie so akkuraat is nie en die moontlikheid van hoër drywingsvlakke kan veroorsaak. As u 'n baie hoër tydsberekening akkuraatheid benodig, oorweeg spesifieke timer IC's, soos die Maxim DS3231.

Nou kan ons die millis gebruik vir verskillende tydsberekeninge. Soos in die vorige voorbeeldskets getoon, kan ons die verstrekte tyd bereken. Om hierdie idee vorentoe te neem, laat ons 'n eenvoudige stophorlosie maak. Dit kan so eenvoudig of so ingewikkeld wees as wat nodig is, maar in hierdie geval sal ons na eenvoudige streef.

Wat die hardeware-perspektief betref, sal ons twee knoppies hê-Start en Stop-met die aftrekweerstands van 10k ohm wat onderskeidelik op digitale penne 2 en 3 gekoppel is. As die gebruiker begin druk, sal die skets die waarde vir millis noteer - nadat die stop gedruk is, sal die skets weer die waarde vir millis noteer, die verloop van tyd bereken en vertoon. Die gebruiker kan dan op start druk om die proses te herhaal, of stop vir opgedateerde data. Hier is die skets:

/* Super-basiese stophorlosie met millis (); */

ongetekende lang begin, klaar, verstryk;

leemte opstelling ()

{Serial.begin (9600); pinMode (2, INVOER); // begin knoppie pinMode (3, INVOER); // stopknoppie Serial.println ("Druk 1 vir Start/reset, 2 vir verstryk tyd"); }

leegte displayResult ()

{float h, m, s, ms; ongetekend lank oor; verstryk = klaar-begin; h = int (verstryk/3600000); oor = verstryk%3600000; m = int (oor/60000); oor = meer as%60000; s = int (oor/1000); ms = meer as%1000; Serial.print ("Rou verstryk tyd:"); Serial.println (verstryk); Serial.print ("Verstreke tyd:"); Reeks.afdruk (h, 0); Serial.print ("h"); Reeks.afdruk (m, 0); Serial.print ("m"); Reeks.afdruk (s, 0); Serial.print ("s"); Serial.print (ms, 0); Serial.println ("ms"); Serial.println (); }

leemte lus ()

{if (digitalRead (2) == HOOG) {start = millis (); vertraging (200); // vir debounce Serial.println ("Begin …"); } if (digitalRead (3) == HOOG) {klaar = millis (); vertraging (200); // vir debounce displayResult (); }}

Die oproepe om te vertraag () word gebruik om die skakelaars uit te skakel - dit is opsioneel en die gebruik daarvan sal afhang van u hardeware. Die beeld is 'n voorbeeld van die seriële monitoruitvoer van die skets - die stophorlosie het begin en die knoppie twee keer ses keer ingedruk.

Stap 3: Snelheidsmeter …

As u 'n sensor aan die begin en einde van 'n vaste afstand gehad het, kan die snelheid bereken word: spoed = afstand ÷ tyd.

U kan ook 'n snelheidsmeter maak vir 'n wielvormige beweging, byvoorbeeld 'n fiets. Op die oomblik het ons nie 'n fiets om mee te mors nie, maar ons kan die proses beskryf - dit is redelik eenvoudig. (Disclaimer - doen dit op eie risiko, ens.)

Kom ons kyk eerstens na die nodige wiskunde. U moet die omtrek van die wiel ken. Hardeware - u benodig 'n sensor. Byvoorbeeld - 'n rietskakelaar en magneet. Beskou die rietskakelaar as 'n normaalweg oop knoppie, en skakel soos gewoonlik met 'n aftrekweerstand van 10k ohm.

Ander kan 'n saal-effek sensor gebruik-elkeen na sy eie). Onthou uit die wiskundeklas om die omtrek te bereken - gebruik die formule: omtrek = 2πr waar r die radius van die sirkel is.

Noudat u die wielomtrek het, kan hierdie waarde as ons 'vaste afstand' beskou word, en daarom kan die snelheid bereken word deur die tydsverloop tussen 'n volle rotasie te meet.

Jou sensor-sodra dit aangebring is-moet op dieselfde metode werk as 'n knoppie wat normaalweg oopgemaak word en wat elke draai gedruk word. Ons skets meet die tyd wat verloop het tussen elke polsslag van die sensor.

Om dit te kan doen, het ons sensor die uitset van die sensor aan die digitale pen 2 gekoppel - aangesien dit 'n onderbreking sal veroorsaak om die snelheid te bereken. Andersins sal die skets die snelheid op 'n normale I2C-koppelvlak-LCD-module vertoon. Die I2C -koppelvlak word voorgestel, aangesien dit slegs 4 drade van die Arduino -bord na die LCD benodig - hoe minder drade, hoe beter.

Hier is die skets vir u lees:

/*Basiese snelheidsmeter met millis (); */

#sluit "Wire.h" // in vir I2C -bus -LCD

#sluit "LiquidCrystal_I2C.h" // in vir I2C -bus LCD -module - https://bit.ly/m7K5wt LiquidCrystal_I2C lcd (0x27, 16, 2); // stel die LCD -adres in op 0x27 vir 'n skerm van 16 tekens en 2 reëls

vlot begin, klaar;

vlot verloop, tyd; float circMetric = 1.2; // wielomtrek relatief tot sensorposisie (in meter) dryfcirculêr; // met behulp van 1 kilometer = 0.621371192 myl float speedk, speedm; // hou berekende snelheidswaarden in metrieke en imperiale

leemte opstelling ()

{attachInterrupt (0, speedCalc, RISING); // onderbreking genoem wanneer sensors digitale 2 hoog stuur (elke wielrotasie) begin = millis (); // instel LCD lcd.init (); // initialiseer die lcd lcd.backlight (); // skakel LCD -agtergrond aan lcd.clear (); lcd.println ("Dra 'n helm!"); vertraging (3000); lcd.clear (); Serial.begin (115200); circImperial = circMetric*.62137; // omskep metriek na imperiaal vir MPH -berekeninge}

leegte snelheidCalc ()

{verstryk = millis ()-begin; begin = millis (); speedk = (3600*circMetric)/verstryk; // km/h speedm = (3600*circImperial)/verstryk; // Myl per uur }

leemte lus ()

{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 (verstryk)); lcd.print ("ms/rev"); vertraging (1000); // pas aan vir persoonlike voorkeur om flikkering te verminder}

Daar gebeur nie veel nie - elke keer as die wiel een omwenteling voltooi, gaan die sein van die sensor van laag na hoog - wat 'n onderbreking veroorsaak wat die funksie speedCalc () noem.

Dit neem 'n lesing van millis () en bereken dan die verskil tussen die huidige lesing en die vorige lesing - hierdie waarde word die tyd om die afstand te dek (wat die omtrek van die wiel is in verhouding tot die sensor - gestoor in

float circMetric = 1.2;

en word in meter gemeet). Dit bereken uiteindelik die spoed in km/h en MPH. Tussen onderbrekings vertoon die skets die nuutste snelheidsdata op die LCD sowel as die rou tydwaarde vir elke omwenteling ter wille van nuuskierigheid. In die regte lewe dink ek nie dat iemand 'n LCD op 'n fiets sou monteer nie, miskien is 'n LED -skerm meer relevant.

Intussen kan u in die volgende kort videogreep sien hoe hierdie voorbeeld werk. In plaas van 'n fietswiel en rietskakelaar/magneetkombinasie, het ek die vierkantsgolfuitset van 'n funksiegenerator aan die onderbrekingspen gekoppel om die pulse van die sensor te simuleer, sodat u 'n idee kan kry van hoe dit werk.

Stap 4:

Dit vat die gebruik van millis () vir eers op. Daar is ook die mikros (); funksie wat mikrosekondes tel.

So daar het u dit - nog 'n praktiese funksie waarmee u meer probleme kan oplos deur die wêreld van Arduino. Soos altyd, is dit nou aan u en u verbeelding om iets te vind wat u kan beheer, of om op te staan vir ander jaloesie.

Hierdie pos word deur pmdway.com aan u gebring - alles vir vervaardigers en elektronika -entoesiaste, met gratis aflewering wêreldwyd.