Arduino Delay [Tutorial]

in deze tutorial leert u hoe u de functie delay() correct kunt gebruiken om vertraging toe te voegen tussen 2 acties in uw Arduino-programma ‘ s. Dan zult u ontdekken waarom het gebruik van delay() vaak geen goed idee is als u uw programma ‘ s wilt opschalen, en hoe u dat kunt oplossen.

goed, aan de slag!

Waarom hebt u vertragingen in uw Arduino-programma ‘ s nodig?

een Arduino-programma vertrouwt veel op externe ingangen / uitgangen om te werken.

een eenvoudig voorbeeld: U kunt de toestand van een drukknop 100 keer per seconde controleren of elke 0,5 seconde een LED laten knipperen.

nu, hoe kunt u dat bereiken? Een Arduino programma werkt als volgt:

• Ten eerste wordt de functie setup() eenmaal uitgevoerd.
• dan wordt de functie loop() keer op keer uitgevoerd, totdat u uw Arduino uitschakelt.

elk programma dat u schrijft zal op volle snelheid worden uitgevoerd. Dus als je een LED laat knipperen in je code, wat er gaat gebeuren is dat de LED zal knipperen met een zeer hoge snelheid (meerdere duizenden keer per seconde op zijn minst).

u leert Arduino gebruiken om uw eigen projecten te bouwen?

bekijk Arduino voor Beginners en leer stap voor stap.

Als u de tijd wilt regelen – dat wil zeggen, zorg ervoor dat de LED slechts elke 0,5 seconde knippert en niet op volle snelheid – moet u enige vertraging in uw code toevoegen.

het implementeren van Arduino delay in uw code

de Arduino delay () functie

hier is een code om een LED te laten knipperen (hier kiezen we de ingebouwde LED, U hoeft geen externe LED toe te voegen) elke 0,5 seconden-Dit is een van de meest voorkomende voorbeelden die u zult zien als u begint met Arduino.

#define LED_PIN 13void setup() { pinMode(LED_PIN, OUTPUT);}void loop() { digitalWrite(LED_PIN, HIGH); delay(500); digitalWrite(LED_PIN, LOW); delay(500);}

dus, hoe werkt deze code?

eerst gebruik je een ” define “zodat je het nummer” 13 ” niet meerdere keren in je code hoeft te hard-coderen en het maakt je programma leesbaarder.

u stelt de modus van de pin in op uitgang met de functie pinMode().

dan, in de functie loop(),:

1. zet de LED aan
2. gebruik delay(500) om het programma 500 milliseconden te laten slapen, of 0,5 seconden
3. zet de LED uit
4. gebruik delay(500) om het programma opnieuw te laten slapen gedurende 0,5 seconden
5. en ga terug naar stap 1, omdat de functie loop() steeds opnieuw wordt uitgevoerd.

de functie delay() verwacht dat u een aantal milliseconden – geen seconden – geeft om te slapen. Dus, als je denkt in seconden, vermenigvuldig dan het aantal met 1000 en je hebt de waarde die je nodig hebt.

Maak een Arduino-vertraging van 1 minuut

als u uw Arduino 1 minuut of meerdere minuten wilt laten slapen, dan is dat heel eenvoudig.

neem het aantal minuten, vermenigvuldig het met 60 om het aantal seconden te krijgen, en vermenigvuldig het met 1000 om het aantal milliseconden te krijgen.

Ex: delay(3 * 60 * 1000); zorgt ervoor dat het programma 3 minuten slaapt.

de functie Arduino delaymicroseconden ()

als u nauwkeuriger wilt zijn, kunt u de functie delayMicroseconds() gebruiken. Met delayMicroseconds() kunt u een aantal microseconden om te slapen. De minimale duur voor delay() is 1 milliseconde, dus als u slechts 400 microseconden moet slapen, hebt u hier een nieuwe oplossing.

deze functie kan zeer nuttig zijn bij het communiceren met sommige hardwarecomponenten. Bijvoorbeeld, moet Arduino sommige gegevens naar de component verzenden en dan wat reactie lezen. Laten we zeggen dat de component 6 microseconden nodig heeft om het verzoek te verwerken en nauwkeurige gegevens te leveren.

dan kunt u in uw programma iets als dit hebben:

...void loop() { // send data to component delayMicroseconds(6); // reach out to component again to read data}

non blocking delay-waarom zou u delay()

moeten vermijden dus, nu u begrijpt wat een delay is in Arduino, en hoe het te implementeren met delay() en delayMicroseconds(), laten we eens kijken hoe de delay functionaliteit te gebruiken – maar zonder die functies.

waarom?

wanneer u delay() gebruikt, stopt de uitvoering van uw programma en wordt deze pas hervat nadat de vertraging is beëindigd.

dit is OK als u maar één actie te doen heeft-voorbeeld: knipper met een enkele LED – maar wat als u moet zorgen voor meerdere hardwarecomponenten of communiceren met andere apparaten zoals Arduino boards of uw eigen computer?

in het vorige voorbeeld: hoe kunt u een LED elke 0,5 seconde laten knipperen en een andere elke 0,8 seconde laten knipperen?

in dat geval zit u vrij snel vast. Als u nog steeds delay() wilt gebruiken, kunt u een oplossing vinden waarbij u kortere vertragingen tussen meerdere acties gebruikt, maar dit maakt uw programma ingewikkelder elke keer dat u een nieuwe actie toevoegt.

de oplossing hiervoor is simpelweg om de tijd te controleren zonder de functie delay() te gebruiken, in principe om een manier te vinden om het gedrag van delay() te reproduceren zonder het te gebruiken.

voorbeeld Code – Arduino delay without delay ()

laten we ons blink LED voorbeeld herschrijven zonder delay()te gebruiken.

#define LED_PIN 13unsigned int lastTimeLedBlinked = millis();unsigned int delayBetweenBlink = 500;byte ledState = LOW;void setup() { pinMode(LED_PIN, OUTPUT);}void loop() { unsigned int timeNow = millis(); if (timeNow - lastTimeLedBlinked > delayBetweenBlink) { if (ledState == LOW) { ledState = HIGH; } else { ledState = LOW; } digitalWrite(LED_PIN, ledState); lastTimeLedBlinked = timeNow; }}

laten we deze code regel voor regel analyseren.

initialisatie

#define LED_PIN 13unsigned int lastTimeLedBlinked = millis();unsigned int delayBetweenBlink = 500;byte ledState = LOW;

eerst initialiseert u 3 variabelen in het globale bereik:

• lastTimeLedBlinked: deze variabele wordt gebruikt om de laatste keer dat de LED knipperde op te slaan. Kortom, elke keer dat we de LED laten knipperen, zullen we deze variabele updaten met de huidige tijd – met behulp van de millis() functie.
• delayBetweenBlink: dit is de tijd dat u wilt wachten tussen 2 acties – hier is de actie om de LED te knipperen.
• ledState: we moeten de status van de huidige LED (hoog of laag) opslaan zodat we kunnen weten wat de vorige status was, en dienovereenkomstig actie ondernemen.

waarom in het algemene kader? Nou, wat we van plan zijn is om deze variabelen in de loop() functie bij te werken en ze opnieuw te benaderen de volgende keer dat we binnen de loop()gaan. Als we de variabelen binnen de loop() aanmaken, zullen de variabelen lokale variabelen zijn en dus worden vernietigd wanneer u de loop() functie verlaat. Dus de volgende keer dat loop() opnieuw wordt aangeroepen, zullen alle waarden verloren gaan en zult u opnieuw variabelen aanmaken zonder voorgaande waarde erin. Hier, door de variabelen buiten de functie te creëren, kunnen we ze “overleven” en hun waarde behouden elke keer als we de loop()invoeren.

het implementeren van de Arduino delay functionaliteit in de loop functie

laten we nu eens kijken wat er gebeurt in de loop() functie.

void loop() { unsigned int timeNow = millis();

eerst leest u de huidige tijd met de functie millis().

 if (timeNow - lastTimeLedBlinked > delayBetweenBlink) {

en nu vergelijk je de huidige tijd die je net hebt gelezen, met de vorige keer dat de LED knipperde. Als er genoeg tijd is verstreken (meer dan de waarde opgeslagen in delayBetweenBlink), dan betekent dit dat u de if()kunt invoeren.

deze codestructuur-het lezen van de tijd en het vergelijken met de vorige keer dat u een actie hebt gedaan – is hoe u de functie delay() vervangt. Je berekent hier gewoon een tijdsduur. En zoals je kunt zien, betekent dit dat je programma meer regels bevat voor een eenvoudige toepassing, maar het geeft je veel meer controle en het is veel schaalbaarder.

dus, wat zal er gebeuren? Nou, de loop() zal op volle snelheid worden uitgevoerd. Elke keer, uw programma zal controleren of er genoeg tijd is verstreken. Zo niet, dan eindigt de loop() hier, omdat het de if-structuur niet zal invoeren.

en als er net genoeg tijd is verstreken, voeren we de if()in.

het uitvoeren van de actie

 if (ledState == LOW) { ledState = HIGH; } else { ledState = LOW; } digitalWrite(LED_PIN, ledState);

OK, u hebt zojuist de if() ingevoerd, en hier zult u de actie uitvoeren die u moet doen.

hier laten we de LED knipperen. En omdat we niet direct kunnen weten wat de vorige status voor de LED was (omdat we de loop() vele malen hebben ingevoerd en alle lokale variabelen verloren die erin zijn gemaakt), krijgen we die status van een globale variabele.

wat we doen met deze globale variabele is eenvoudig: als het laag was, zetten we het op hoog, en als het hoog was, zetten we het op laag. En dan, natuurlijk, updaten we de fysieke LED-toestand dienovereenkomstig, met digitalWrite().

 lastTimeLedBlinked = timeNow; }}

ten slotte, en dit is super belangrijk, besparen we de huidige tijd als de laatste keer dat we de LED knipperden. Als we dat niet doen zal het programma de LED op volle snelheid knipperen omdat de conditie in de if() altijd waar zal zijn.

door de vorige tijd in te stellen op de huidige tijd “resetten we de timer”.

in dat voorbeeld wordt de if() slechts om de 500 milliseconden of 0,5 seconden ingevoerd.

en nu is dit geweldig omdat uw programma niet stopt, dus u kunt doorgaan met het uitvoeren van verschillende onafhankelijke acties terwijl u nog steeds “wacht” om de LED te knipperen.

2 acties “tegelijkertijd”

bijvoorbeeld, laten we zeggen dat u elke 0 een LED wilt knipperen.5 seconden, en elke 0.8 seconde een andere.

#define LED_1_PIN 13#define LED_2_PIN 10unsigned int lastTimeLed1Blinked = millis();unsigned int delayBetweenBlink1 = 500;byte led1State = LOW;unsigned int lastTimeLed2Blinked = millis();unsigned int delayBetweenBlink2 = 800;byte led2State = LOW;void setup() { pinMode(LED_1_PIN, OUTPUT); pinMode(LED_2_PIN, OUTPUT);}void loop() { unsigned int timeNow = millis(); // Action 1 - Blink LED 1 if (timeNow - lastTimeLed1Blinked > delayBetweenBlink1) { if (led1State == LOW) { led1State = HIGH; } else { led1State = LOW; } digitalWrite(LED_1_PIN, led1State); lastTimeLed1Blinked = timeNow; } // Action 2 - Blink LED 2 if (timeNow - lastTimeLed2Blinked > delayBetweenBlink2) { if (led2State == LOW) { led2State = HIGH; } else { led2State = LOW; } digitalWrite(LED_2_PIN, led2State); lastTimeLed2Blinked = timeNow; }}

zoals u kunt zien, herhalen we de code structuur voor de tweede actie die we hebben toegevoegd. En beide acties zullen elkaar niet storen!

Recap

Als u een Arduino-vertraging wilt maken zonder delay():

1. Maak een globale variabele om de laatste keer dat u een specifieke actie hebt uitgevoerd op te slaan.
2. Maak een andere globale variabele om de gewenste duur tussen 2 acties op te slaan.
3. in de functie loop(), lees de huidige tijd met millis().
4. gebruik daarna een if-structuur en gebruik de voorwaarde (timeNow - lastTimeActionWasExecuted > delayBetweenActions).
5. zodra u de if() hebt ingevoerd, voert u de actie uit.
6. en nog steeds in de if(), sla de huidige tijd op als de vorige tijd.

u kunt deze stappen herhalen voor elke actie waarvoor u een Arduino-vertraging nodig hebt.

als het ok is om delay() en delaymicroseconden()

te gebruiken, zijn er specifieke gevallen waarin het gebruik van delay() in uw code nog steeds OK is.

hier zijn 2 van deze:

• u moet een component initialiseren tijdens het instellen van uw programma, en dit component heeft wat tijd nodig om geïnitialiseerd te worden – bijvoorbeeld 1,5 seconden. In dit geval is het gebruik van delay(1500) in uw setup() functie prima. In principe zal elke delay() in de setup() functie van uw Arduino programma geen probleem zijn.
• zoals uitgelegd in het delayMicroseconds() deel, moet u een paar microseconden wachten (geen milliseconden!) bij communicatie met een externe component. Als u merkt dat het gebruik van delayMicroseconds() met een klein getal (bijvoorbeeld 10) de rest van uw programma niet verstoort, kunt u het nog steeds gebruiken zonder al te veel zorgen te maken. Maar beschouw het als een uitzondering, niet de algemene regel.

conclusie-Gebruik Arduino delay() met zorg

vanwege de aard van Arduino-programma ‘ s, zult u vaak vertragingen in uw code moeten toevoegen, zodat u kunt kiezen wanneer u bepaalde acties wilt uitvoeren en hoe vaak u ze wilt uitvoeren.

de functies delay() en delayMicroseconds() zijn zeer eenvoudige functies om te gebruiken en werden toegevoegd aan de Arduino taal, zodat complete beginners met iets simpels konden beginnen.

echter, zoals je in deze tutorial zag, kan het gebruik van delay() je heel snel vast laten zitten. Het is dus het beste om eerst te begrijpen waarom je het nodig hebt, hoe je het moet gebruiken, en dan hoe je hetzelfde gedrag kunt krijgen zonder de Arduino delay() functie direct te gebruiken.

zodra u de code structuur hebt begrepen om van delay() af te komen, zult u in staat zijn om uw Arduino programma ‘ s veel te verbeteren, en multitasking zal vrij eenvoudig worden.