de multitasking heeft de computers geleid tot een revolutie waarbij een of meer programma ‘ s gelijktijdig kunnen draaien, wat de efficiëntie, flexibiliteit, aanpassingsvermogen en productiviteit verhoogt. In embedded systemen kunnen microcontrollers ook Multitasking verwerken en twee of meer taken tegelijkertijd uitvoeren zonder de huidige instructies te stoppen.

hier in deze tutorial zullen we leren hoe Arduino Multitasking uitvoert met de Arduino millis-functie. Over het algemeen wordt een delay() functie gebruikt in Arduino voor een periodieke taak zoals leiden die knipperen maar deze delay() functie stopt het programma voor wat definitieve tijd en staat andere verrichtingen niet toe om uit te voeren. Dus dit artikel legt uit hoe we het gebruik van delay() functie kunnen vermijden en vervangen door millis() om meer dan één taken tegelijkertijd uit te voeren en van de Arduino een Multitasking controller te maken. Voordat we in detail gaan laten we beginnen met understating Multitasking.

Wat is Multitasking?

Multitasking betekent simpelweg meerdere taken of programma ‘ s tegelijkertijd uitvoeren. Bijna alle besturingssystemen zijn voorzien van multitasking. Dit soort besturingssystemen staan bekend als MOS (multitasking operating system). De MOS kan mobiel of desktop pc besturingssysteem. Het goede voorbeeld van multitasking in computers zijn wanneer gebruikers uitvoeren van de e-mailtoepassing, internet browser, mediaspeler, games, op hetzelfde moment en als gebruikers niet willen gebruik maken van de toepassing die het draait op de achtergrond indien niet gesloten. De eindgebruiker gebruikt al deze toepassingen op hetzelfde moment, maar OS neemt dit concept een beetje anders. Laten we bespreken hoe OS multitasking beheert.

Wat is Multitasking in Arduino

zoals te zien in de afbeelding, verdeelt de CPU de tijd in de drie gelijke delen en wijst elk deel toe aan elke taak/toepassing. Dit is hoe de multitasking wordt gedaan in de meeste systemen. Het concept zal bijna hetzelfde zijn voor de Arduino Multitasking, behalve dat de tijdverdeling een beetje anders zal zijn. Aangezien Arduino in lage frequentie loopt en RAM met Laptop/Mobile/PC vergelijken zodat zal de tijd die aan elke taak wordt gegeven ook verschillend zijn. Arduino heeft ook een delay () functie die op grote schaal wordt gebruikt. Maar voordat we beginnen, laten we bespreken waarom we de delay() functie in geen enkel project zouden moeten gebruiken.

waarom delay () overslaan in Arduino?

als de referentiedocumentatie van Arduino wordt bekeken, zijn er twee soorten delayfuncties, de eerste is delay () en de tweede is delaymicroseconden(). Beide functies zijn identiek in termen van het genereren van vertraging. Het enige verschil is dat, in delay () functie, de parameter integer doorgegeven is in milliseconden dwz als we schrijven delay (1000)dan zal de vertraging van 1000 milliseconden dwz 1 seconde. Evenzo in delaymicroseconden () functie, de parameter doorgegeven is in microseconden dwz als we schrijven delaymicroseconden (1000), dan zal de vertraging van 1000 microseconden dwz 1 milliseconden.

Hier komt het punt, beide functies pauzeren het programma voor de hoeveelheid tijd die is verstreken in delay functie. Dus als we een vertraging van 1 seconde geven dan kan de processor niet naar de volgende instructie gaan totdat 1 seconde voorbij is. Evenzo als de vertraging is 10 seconden dan programma zal stoppen voor 10 seconden en de processor zal niet toestaan om te gaan voor de volgende instructies tot de 10 seconden voorbij. Dit belemmert de prestaties van de microcontroller in termen van snelheid en het uitvoeren van de instructies.

het beste voorbeeld om het nadeel van de delay-functie te verklaren is het gebruik van twee drukknoppen. Bedenk dat we twee LEDs willen schakelen met behulp van twee drukknoppen. Dus als een drukknop wordt ingedrukt dan moet de bijbehorende LED gloeien gedurende 2 seconden, op dezelfde manier als de tweede wordt ingedrukt dan LED gloeien gedurende 4 seconden. Maar als we delay () gebruiken, als de gebruiker op de eerste knop drukt dan zal het programma 2 seconden stoppen en als de gebruiker op de tweede knop drukt voor 2 seconden vertraging, dan zal de microcontroller de invoer niet accepteren omdat het programma in de stopfase is.

De officiële documentatie van Arduino vermeldt dit duidelijk in zijn Notes and Warnings of delay () functie beschrijving. U kunt gaan door en check dit uit om het duidelijker te maken.

waarom millis () gebruiken ?

om het probleem veroorzaakt door het gebruik van delay op te lossen, zou een ontwikkelaar de millis() functie moeten gebruiken die gemakkelijk te gebruiken is als je eenmaal gewend bent en het zal 100% CPU prestaties gebruiken zonder enige vertraging te genereren in het uitvoeren van de instructies. millis () is een functie die enkel de hoeveelheid milliseconden retourneert die sinds de Raad van Arduino begonnen het lopende huidige programma zonder het programma te bevriezen zijn verstreken. Dit tijdnummer zal overlopen (dat wil zeggen teruggaan naar nul), na ongeveer 50 dagen.

net zoals Arduino delaymicroseconden () heeft, heeft het ook de micro versie van millis() als micros(). Het verschil tussen micros en millis is dat, de micros () zal overlopen na ongeveer 70 minuten, vergeleken met millis () dat is 50 dagen. Dus afhankelijk van de toepassing kunt u millis() of micros () gebruiken.

Using millis() instead of delay():

om millis() te gebruiken voor timing en vertraging, moet u de tijd registreren en opslaan waarop de actie plaatsvond om de tijd te starten en vervolgens met tussenpozen controleren of de gedefinieerde tijd is verstreken. Dus zoals gezegd, sla de huidige tijd op in een variabele.

unsigned long currentMillis = millis();

we hebben nog twee variabelen nodig om uit te vinden of de vereiste tijd is verstreken. We hebben de huidige tijd opgeslagen in currentmillis variabele maar we moeten ook weten dat wanneer de timing periode begon en hoe lang de periode is. Dus de Interval en previousMillis wordt verklaard. Het interval vertelt ons de vertraging en previosMillis zal de laatste keer dat de gebeurtenis heeft plaatsgevonden opslaan.

unsigned long previousMillis;unsigned long period = 1000;

om dit te begrijpen, nemen we een voorbeeld van een eenvoudige knipperende LED. De periode = 1000 vertellen dat knippert de LED gedurende 1 seconde of 1000ms.

const int ledPin = 4; // the LED pin number connectedint ledState = LOW; // used to set the LED stateunsigned long previousMillis = 0; //will store last time LED was blinkedconst long period = 1000; // period at which to blink in msvoid setup() { pinMode(ledPin, OUTPUT); // set ledpin as output}void loop() { unsigned long currentMillis = millis(); // store the current time if (currentMillis - previousMillis >= period) { // check if 1000ms passed previousMillis = currentMillis; // save the last time you blinked the LED if (ledState == LOW) { // if the LED is off turn it on and vice-versa ledState = HIGH; } else {ledState = LOW;} digitalWrite(ledPin, ledState);//set LED with ledState to blink again }}

Hier de instructie <if (currentMillis – previousMillis >= periode)> controleert of de 1000ms is verstreken. Als 1000ms is overgegaan, dan komt het LEIDENE knipperen en opnieuw in dezelfde staat. En dit gaat maar door. Dat is het, we hebben geleerd om millis te gebruiken in plaats van vertraging. Op deze manier zal het programma niet stoppen voor bepaalde interval.

Interrupts in Arduino werken hetzelfde als in andere microcontrollers. De Arduino UNO-Raad heeft twee afzonderlijke spelden voor het bevestigen van onderbrekingen op GPIO-speld 2 en 3. We hebben het in detail behandeld in Arduino Interrupts Tutorial, waar u meer kunt leren over Interrupts en hoe ze te gebruiken.

Hier zullen we Arduino Multitasking tonen door twee taken tegelijkertijd te behandelen. De taken omvatten knipperen van twee LED ‘ s in verschillende tijdsvertraging samen met een drukknop die zal worden gebruikt om de AAN/UIT-toestand van LED te regelen. Dus drie taken worden gelijktijdig uitgevoerd.

schema voor Arduino Multitasking

vereiste componenten

  • Arduino UNO
  • drie LEDs(elke kleur)
  • weerstanden (470, 10k)
  • Jumpers
  • Breadboard

Circuit diagram

het schema voor het aantonen van het gebruik van Arduino Millis() fuction is zeer eenvoudig en heeft niet veel componenten om aan te sluiten zoals hieronder getoond.

Circuit Diagram voor Arduino Multitasking gebruikend Arduino Millis() functie

programmeren Arduino UNO voor Multitasking

programmeren Arduino UNO voor multitasking zal slechts de logica achter hoe millis() werken vereisen die hierboven wordt uitgelegd. Het wordt geadviseerd om geleid te oefenen knipperen gebruikend millis opnieuw en opnieuw om de logica duidelijk te maken en comfortabel met millis() te maken alvorens aan programma Arduino UNO voor multitasking te beginnen. In deze tutorial wordt de interrupt ook gebruikt met millis() gelijktijdig voor multitasking. De knop zal een interrupt zijn. Dus wanneer een interrupt wordt gegenereerd dat wil zeggen drukknop wordt ingedrukt, schakelt de LED in op of UIT staat.

het programmeren begint met het declareren van pin-nummers waar LEDs en drukknoppen zijn aangesloten.

int led1 = 6;int led2 = 7;int toggleLed = 5;int pushButton = 2;

vervolgens schrijven we een variabele om de status van LEDs op te slaan voor toekomstig gebruik.

int ledState1 = LOW;int ledState2 = LOW;

zoals hierboven in het blink-voorbeeld is uitgelegd, worden de variabelen Voor periode en previousmillis gedeclareerd om leds te vergelijken en vertraging te genereren. De eerste LED knippert na elke 1 seconde en een andere LED knippert na 200ms.

unsigned long previousMillis1 = 0; const long period1 = 1000;unsigned long previousMillis2 = 0;const long period2 = 200; 

een andere millis-functie zal worden gebruikt om de ontkoppelingsvertraging te genereren om meerdere drukken op de drukknop te voorkomen. Er zal een soortgelijke aanpak zijn als hierboven.

int debouncePeriod = 20; int debounceMillis = 0;

De drie variabelen worden gebruikt om de status van de drukknop op te slaan als interrupt, toggle LED en drukknopstatus.

bool buttonPushed = false;int ledChange = LOW; int lastState = HIGH;

Definieer de actie van pin die welke pin zal werken als INPUT of OUTPUT.

 pinMode(led1, OUTPUT); pinMode(led2, OUTPUT); pinMode(toggleLed, OUTPUT); pinMode(pushButton, INPUT);

definieer nu de interrupt pin door interrupt aan te sluiten met de definitie van ISR en interrupt Mode. Merk op dat het wordt aanbevolen om digitalPinToInterrupt(pin_number) te gebruiken bij het declareren attachInterrupt() functie om de werkelijke digitale pin te vertalen naar het specifieke interrupt nummer.

attachInterrupt(digitalPinToInterrupt(pushButton), pushButton_ISR, CHANGE); 

de interrupt subroutine is geschreven en het zal alleen de buttonPushed vlag veranderen. Merk op dat interrupt subroutine zo kort mogelijk moet zijn, dus probeer het te schrijven en minimaliseer de extra instructies.

void pushButton_ISR(){ buttonPushed = true; }

lus begint met het opslaan van de millis-waarde in een currentmillis-variabele die de waarde van de verstreken tijd opslaat elke keer dat de lus itereert.

unsigned long currentMillis = millis();

Er zijn in totaal drie functies in multitasking, knipper met één LED op 1 seconde, knipper met een tweede LED op 200ms en als de drukknop wordt ingedrukt, schakel dan de LED uit/aan. Dus we zullen drie delen schrijven om deze taak uit te voeren.

de eerste schakelt de LED-status na elke 1 seconde aan / uit door de verstreken millis te vergelijken.

 if (currentMillis - previousMillis1 >= period1) { previousMillis1 = currentMillis; if (ledState1 == LOW) { ledState1 = HIGH; } else { ledState1 = LOW; } digitalWrite(led1, ledState1); }

Op dezelfde manier schakelt het de LED na elke 200ms door de verstreken millis te vergelijken. De uitleg wordt al eerder in dit artikel uitgelegd.

 if (currentMillis - previousMillis2 >= period2) { previousMillis2 = currentMillis; if (ledState2 == LOW) { ledState2 = HIGH; } else { ledState2 = LOW; } digitalWrite(led2, ledState2); }

ten slotte wordt de buttonPushed-vlag gemonitord en na het genereren van een debounce-vertraging van 20ms schakelt het alleen de status van de LED die overeenkomt met de drukknop die is aangesloten als interrupt.

 if (buttonPushed = true) // check if ISR is called { if ((currentMillis - debounceMillis) > debouncePeriod && buttonPushed) // generate 20ms debounce delay to avoid multiple presses { debounceMillis = currentMillis; // save the last debounce delay time if (digitalRead(pushButton) == LOW && lastState == HIGH) // change the led after push button is pressed { ledChange = ! ledChange; digitalWrite(toggleLed, ledChange); lastState = LOW; } else if (digitalRead(pushButton) == HIGH && lastState == LOW) { lastState = HIGH; } buttonPushed = false; } }

hiermee eindigt de Arduino millis() Tutorial. Merk op dat om gewoon te worden met millis(), gewoon oefenen om deze logica te implementeren in een aantal andere toepassingen. U kunt het ook uitbreiden om motoren, servomotoren, sensor en andere randapparatuur te gebruiken. In geval van twijfel kunt u schrijven naar ons forum of commentaar hieronder.

volledige code en Video Voor het aantonen van het gebruik van de millis-functie in Arduino wordt hieronder gegeven.

Geef een antwoord

Het e-mailadres wordt niet gepubliceerd.