Arduino-timingmethoden met Millis(): 4 stappen

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:16

In dit artikel introduceren we de millis(); functie en gebruik het om verschillende timingvoorbeelden te maken.

Milli? Niets te maken met lip-syncers… hopelijk herkende je milli als het numerieke voorvoegsel voor duizendsten; dat is een maateenheid vermenigvuldigen met 0,001 (of tien tot de macht van min 3).

Interessant is dat onze Arduino-systemen het aantal milliseconden (duizenden seconden) tellen vanaf het begin van een sketch die loopt totdat de telling het maximale aantal bereikt dat kan worden opgeslagen in het variabele type unsigned long (een 32-bits [vier byte] integer – dat varieert van nul tot (2^32)-1 (2^32)-1, of 4294967295 milliseconden wordt omgezet in 49.71027-oneven dagen.

De teller wordt gereset wanneer de Arduino wordt gereset, deze de maximale waarde bereikt of een nieuwe schets wordt geüpload. Om de waarde van de teller op een bepaald moment te krijgen, roept u gewoon de functie aan, bijvoorbeeld:

start=millis();

Waar start een niet-ondertekende lange variabele is. Hier is een heel eenvoudig voorbeeld om millis() in actie te laten zien:

/* millis() demonstratie */

ongetekende lange start, geëindigd, verstreken;

ongeldige setup()

{ Serieel.begin (9600); }

lege lus()

{ Serial.println("Start…"); start=millis(); vertraging (1000); klaar=millis(); Serial.println("Voltooid"); verstreken=voltooid-start; Serial.print (verstreken); Serial.println ("verstreken milliseconden"); Serieel.println(); vertraging (500); }

De schets slaat de huidige milli-telling op in start, wacht dan een seconde en slaat dan de waarde van millis opnieuw op in voltooid. Ten slotte berekent het de verstreken tijd van de vertraging. In de volgende screendump van de seriële monitor kun je zien dat de duur niet altijd precies 1000 milliseconden was, zoals in de afbeelding te zien is.

Stap 1:

Simpel gezegd, de millis-functie maakt gebruik van een interne teller in de ATmega-microcontroller in het hart van je Arduino. Deze teller verhoogt elke klokcyclus - wat gebeurt (in standaard Arduino en compatibele apparaten) met een kloksnelheid van 16 Mhz. Deze snelheid wordt geregeld door het kristal op het Arduino-bord (het zilveren ding met T16.000 erop gestempeld).

Stap 2:

De nauwkeurigheid van het kristal kan variëren afhankelijk van de buitentemperatuur en de tolerantie van het kristal zelf. Dit heeft op zijn beurt invloed op de nauwkeurigheid van uw millis-resultaat. Anekdotische ervaring heeft gemeld dat de afwijking in timingnauwkeurigheid ongeveer drie of vier seconden per periode van vierentwintig uur kan zijn.

Als je een bord gebruikt of je eigen versie die een keramische resonator gebruikt in plaats van een kristal, houd er dan rekening mee dat ze niet zo nauwkeurig zijn en de mogelijkheid van hogere driftniveaus introduceren. Als u een veel hoger niveau van timingnauwkeurigheid nodig hebt, overweeg dan specifieke timer-IC's zoals de Maxim DS3231.

Nu kunnen we de millis gebruiken voor verschillende timingfuncties. Zoals aangetoond in de vorige voorbeeldschets, kunnen we de verstreken tijd berekenen. Om dit idee verder te ontwikkelen, laten we een eenvoudige stopwatch maken. Dit kan zo eenvoudig of zo complex zijn als nodig is, maar in dit geval gaan we richting eenvoudig.

Vanuit het hardwareperspectief hebben we twee knoppen - Start en Stop - met de 10k ohm pull-down-weerstanden aangesloten op respectievelijk digitale pinnen 2 en 3. Wanneer de gebruiker op start drukt, zal de schets de waarde voor millis noteren - en nadat op stop is gedrukt, zal de schets opnieuw de waarde voor millis noteren, de verstreken tijd berekenen en weergeven. De gebruiker kan dan op start drukken om het proces te herhalen, of stoppen voor bijgewerkte gegevens. Hier is de schets:

/* Supereenvoudige stopwatch met millis(); */

ongetekende lange start, geëindigd, verstreken;

ongeldige setup()

{ Serieel.begin (9600); pinMode(2, INPUT); // startknop pinMode (3, INPUT); // stopknop Serial.println ("Druk op 1 voor Start/reset, 2 voor verstreken tijd"); }

void displayResult()

{ float h, m, s, ms; niet ondertekend lang over; verstreken=voltooid-start; h=int(verstreken/3600000); over=verstreken%3600000; m=int(meer dan/60000); over=meer dan%60000; s=int(meer dan/1000); ms=meer dan%1000; Serial.print("Ruwe verstreken tijd: "); Serial.println (verstreken); Serial.print("Verstreken tijd: "); Serial.print(h, 0); Serial.print("h "); Serieafdruk (m, 0); Serial.print("m "); Serieafdruk(ken, 0); Serial.print("s"); Serial.print (ms, 0); Serieel.println("ms"); Serieel.println(); }

lege lus()

{if (digitalRead(2)==HOOG) { start=millis(); vertraging (200); // voor debounce Serial.println ("Gestart …"); } if (digitalRead(3)==HIGH) {finished=millis(); vertraging (200); // voor debounce displayResult (); } }

De aanroepen naar delay() worden gebruikt om de switches te debouncen - deze zijn optioneel en het gebruik ervan is afhankelijk van uw hardware. De afbeelding is een voorbeeld van de seriële monitoruitvoer van de schets - de stopwatch is gestart en vervolgens zes keer op knop twee gedrukt gedurende tijdsperioden.

Stap 3: Snelheidsmeter…

Als je een sensor had aan het begin en einde van een vaste afstand, zou de snelheid berekend kunnen worden: snelheid = afstand ÷ tijd.

Je kunt ook een snelheidsmeter maken voor een beweging op wielen, bijvoorbeeld een fiets. Op dit moment hebben we geen fiets om mee te rommelen, maar we kunnen het proces om dat te doen beschrijven - het is vrij eenvoudig. (Disclaimer - doe dit op eigen risico enz.)

Laten we eerst de nodige wiskunde bekijken. U moet de omtrek van het wiel weten. Hardware - je hebt een sensor nodig. Bijvoorbeeld - een reed-schakelaar en magneet. Beschouw de reed-schakelaar als een normaal open knop en sluit zoals gewoonlijk aan met een pull-down-weerstand van 10k ohm.

Anderen kunnen een hall-effectsensor gebruiken - elk voor zich). Onthoud uit de wiskundeles, om de omtrek te berekenen - gebruik de formule: omtrek = 2πr waarbij r de straal van de cirkel is.

Nu je de wielomtrek hebt, kan deze waarde worden beschouwd als onze 'vaste afstand', en daarom kan de snelheid worden berekend door de verstreken tijd tussen een volledige omwenteling te meten.

Uw sensor - eenmaal gemonteerd - zou op dezelfde manier moeten werken als een normaal open knop die elke rotatie wordt ingedrukt. Onze schets meet de tijd die is verstreken tussen elke puls van de sensor.

Om dit te doen, zal ons voorbeeld de sensoruitgang hebben aangesloten op digitale pin 2 - omdat het een onderbreking activeert om de snelheid te berekenen. De schets zal anders de snelheid weergeven op een normale I2C-interface LCD-module. De I2C-interface wordt aanbevolen, omdat hiervoor slechts 4 draden nodig zijn van het Arduino-bord naar het LCD - hoe minder draden, hoe beter.

Hier is de schets voor uw inzage:

/*Basis snelheidsmeter met millis(); */

#include "Wire.h" // voor I2C bus LCD

#include "LiquidCrystal_I2C.h" // voor I2C bus LCD-module - https://bit.ly/m7K5wt LiquidCrystal_I2C lcd (0x27, 16, 2); // stel het LCD-adres in op 0x27 voor een display van 16 tekens en 2 regels

vlotter start, klaar;

float verstreken, tijd; float circMetric=1,2; // wielomtrek tov sensorpositie (in meters) float circImperial; // met 1 kilometer = 0.621371192 mijl float speedk, speedm; // bevat berekende snelheidswaarden in metrisch en imperiaal

ongeldige setup()

{ attachInterrupt(0, speedCalc, RISING); // interrupt aangeroepen wanneer sensoren digitale 2 high sturen (elke wielrotatie) start=millis(); // instellen LCD lcd.init(); // initialiseer de lcd lcd.backlight(); // zet LCD-achtergrondverlichting lcd.clear(); lcd.println(" Draag een helm! "); vertraging (3000); lcd.wissen(); Serieel.begin(115200); circImperial=circMetric*.62137; // converteer metrisch naar imperiaal voor MPH-berekeningen}

void speedCalc()

{ verstreken=millis()-start; start=millis(); speedk=(3600*circMetric)/verstreken; // km/h snelheidm=(3600*circImperial)/verstreken; // Mijl per uur }

lege lus()

{ lcd.setCursor (0, 0); lcd.print(int(speedk)); lcd.print(" km/u "); lcd.print(int(speedm)); lcd.print(" MPH "); lcd.setCursor(0, 1); lcd.print(int(verstreken)); lcd.print(" ms/rev "); vertraging (1000); // pas aan voor persoonlijke voorkeur om flikkering te minimaliseren}

Er gebeurt niet zoveel - elke keer dat het wiel één omwenteling voltooit, gaat het signaal van de sensor van laag naar hoog - waardoor een onderbreking wordt geactiveerd die de functie speedCalc() aanroept.

Dit neemt een aflezing van millis() en berekent vervolgens het verschil tussen de huidige aflezing en de vorige aflezing - deze waarde wordt de tijd om de afstand af te leggen (dit is de omtrek van het wiel ten opzichte van de sensor - opgeslagen in

float circMetric=1,2;

en wordt gemeten in meters). Het berekent tenslotte de snelheid in km/u en MPH. Tussen interrupts geeft de schets de bijgewerkte snelheidsgegevens op het LCD-scherm weer, evenals de onbewerkte tijdswaarde voor elke omwenteling omwille van de nieuwsgierigheid. In het echte leven denk ik niet dat iemand een LCD op een fiets zou monteren, misschien zou een LED-display relevanter zijn.

In de tussentijd kunt u zien hoe dit voorbeeld werkt in de volgende korte videoclip. In plaats van een combinatie van fietswiel en reed-schakelaar/magneet, heb ik de blokgolfuitgang van een functiegenerator aangesloten op de interrupt-pin om de pulsen van de sensor te simuleren, zodat je een idee krijgt van hoe het werkt.

Stap 4:

Dat vat voorlopig het gebruik van millis() samen. Er is ook de micros(); functie die microseconden telt.

Dus daar heb je het - nog een praktische functie waarmee meer problemen kunnen worden opgelost via de wereld van Arduino. Zoals altijd is het nu aan jou en je verbeelding om iets te vinden om te controleren of andere streken uit te halen.

Dit bericht aangeboden door pmdway.com - alles voor makers en elektronica-enthousiastelingen, met gratis levering wereldwijd.