Arduino többfeladatos oktatóanyag

A több feladat egy olyan forradalomhoz vezetett, amelyen egy vagy több program egyszerre futtatható, ami növeli a hatékonyságot, rugalmasságot, alkalmazkodóképességet és termelékenységet. Beágyazott rendszerekben a mikrovezérlők képesek kezelni a többfeladatos feladatot is, és két vagy több feladatot egyidejűleg végeznek az aktuális utasítások leállítása nélkül.

Itt ebben az oktatóanyagban megtudhatjuk, hogyan hajtja végre az Arduino a Multitasking funkciót Arduino millis funkciójával. Általában a delay () függvényt használják az Arduino egy olyan időszakos feladatra, mint például a LED villogása, de ez a delay () függvény bizonyos ideig leállítja a programot, és nem engedi más műveletek végrehajtását. Tehát ez a cikk elmagyarázza, hogyan kerülhetjük el a delay () függvény használatát, és millis () -re cserélhetjük, ha egyszerre több feladatot is végrehajtunk, és az Arduinót Multitasking vezérlővé alakítjuk. A részletek elõtt kezdjük a Multitasking lebecsülésével.

Mi az a multitasking?

A multitasking egyszerűen annyit jelent, hogy egyszerre több feladatot vagy programot hajt végre egyszerre. Szinte az összes operációs rendszer multitasking funkcióval rendelkezik. Ez a fajta operációs rendszer MOS (többfeladatos operációs rendszer) néven ismert. Az MOS lehet mobil vagy asztali PC operációs rendszer. A számítógépek többfeladatos kezelésének jó példája, amikor a felhasználók egyszerre futtatják az e-mail alkalmazást, az internetböngészőt, a médialejátszót, a játékokat, és ha a felhasználók nem akarják használni a háttérben futó alkalmazást, ha nincsenek bezárva. A végfelhasználó ezeket az alkalmazásokat egyidejűleg használja, de az operációs rendszer ezt a koncepciót kissé másként értelmezi. Beszéljük meg, hogyan kezeli az OS a többfeladatos feladatot.

Ahogy a képen látható, a CPU elosztja az időt három egyenlő részben, és minden részt hozzárendel minden feladathoz / alkalmazáshoz. Így történik a multitasking a legtöbb rendszerben. A koncepció majdnem ugyanaz lesz az Arduino Multitasking esetében, azzal az eltéréssel, hogy az időeloszlás kicsit más lesz. Mivel az Arduino alacsony frekvencián és RAM-on fut, összehasonlítva a Laptop / Mobile / PC-vel, így az egyes feladatokra szánt idő is eltérő lesz. Az Arduino-nak van egy delay () funkciója is, amelyet széles körben használnak. Mielőtt azonban elkezdenénk, beszéljük meg, miért ne használhatnánk a delay () függvényt egyetlen projektben sem.

Miért hagyja ki a késleltetést () Arduino-ban?

Ha figyelembe vesszük az Arduino referenciadokumentációját, akkor kétféle késleltetési funkció létezik, az első a delay (), a második a delayMicroseconds (). Mindkét függvény azonos a késleltetés szempontjából. Az egyetlen különbség az, hogy a delay () függvényben az átadott egész paraméter milliszekundumban van, azaz ha késleltetést írunk (1000), akkor a késés 1000 milliszekundum, azaz 1 másodperc lesz. Hasonlóan a delayMicroseconds () függvényben, az átadott paraméter mikroszekundumban van, azaz ha delayMicroseconds (1000) értéket írunk, akkor a késés 1000 mikrosekundum, azaz 1 milliszekundum lesz.

Itt jön a lényeg, mindkét funkció szünetelteti a programot a késleltetés funkcióval eltelt ideig. Tehát, ha 1 másodperces késleltetést adunk meg, akkor a processzor nem léphet a következő utasításra, amíg 1 másodperc nem telt el. Hasonlóképpen, ha a késés 10 másodperc, akkor a program 10 másodpercre leáll, és a processzor csak a 10 másodperc elteltével engedélyezi a következő utasítások végrehajtását. Ez akadályozza a mikrovezérlő teljesítményét a sebesség és az utasítások végrehajtása szempontjából.

A késleltetés hátrányának magyarázatára a legjobb példa két nyomógomb használata. Fontolja meg, hogy két LED-et két nyomógomb segítségével szeretnénk váltani. Tehát, ha egy nyomógombot megnyomnak, akkor a megfelelő LED-nek 2 másodpercig világítania kell, hasonlóan, ha a másodikat nyomja, akkor a LED-nek 4 másodpercig világítania kell. De amikor a késleltetést () használjuk, ha a felhasználó megnyomja az első gombot, akkor a program 2 másodpercre leáll, és ha a felhasználó 2 másodperc késés előtt megnyomja a második gombot, akkor a mikrovezérlő nem fogadja el a bemenetet, mivel a program leállítási szakaszban.

Az Arduino hivatalos dokumentációja ezt egyértelműen megemlíti a Notes and Warnings of delay () funkció leírásában. Átnézheti és ellenőrizheti ezt, hogy világosabb legyen.

Miért érdemes millist használni ()?

A késleltetés okozta probléma kiküszöbölése érdekében a fejlesztőnek millis () függvényt kell használnia, amelyet könnyen lehet használni, amint megszokottá válik, és 100% -os CPU-teljesítményt fog használni, anélkül, hogy késleltetné az utasítások végrehajtását. A millis () egy olyan függvény, amely csak az ezredmásodpercek számát adja vissza, amióta az Arduino fórum elkezdte futtatni az aktuális programot, anélkül, hogy a program befagyasztott volna. Körülbelül 50 nap elteltével ez az időszám túlcsordul (azaz visszaáll nullára).

Csakúgy, mint az Arduino-nak a delayMicroseconds (), ugyanúgy a millis () mikrováltozata is mikroszerű (). A különbség a mikroszám és az millis között annyi, hogy a mikroszerű () körülbelül 70 perc múlva túlcsordul, szemben az 50 napos milliszámmal (). Tehát az alkalmazástól függően használhat millisz () vagy mikroszámot ().

Millis () használata késleltetés () helyett:

A millisz () időzítéshez és késleltetéshez való felhasználásához fel kell jegyeznie és tárolnia kell azt az időpontot, amikor a művelet megtörtént, hogy elindítsa az időt, majd időközönként ellenőrizze, hogy a megadott idő letelt-e. Tehát amint említettük, tárolja az aktuális időt egy változóban.

előjel nélküli hosszú áramMillis = millis ();

Még két változóra van szükségünk, hogy megtudjuk, letelt-e a szükséges idő. Az aktuális időt eltároltuk a currentMillis változóban, de azt is tudnunk kell, hogy mikor kezdődött az időzítés és mennyi az időtartam. Tehát az intervallumot és previousMillis nyilvánítják. Az intervallum megmondja az idő késleltetését, és az previosMillis tárolja az esemény legutóbbi bekövetkezését.

aláíratlan hosszú előzőMillis; aláíratlan hosszú periódus = 1000;

Ennek megértéséhez vegyünk egy példát egy egyszerű villogó LED-re. Az = 1000 periódus megmondja, hogy a LED 1 másodpercig vagy 1000 ms-ig villog.

const int ledPin = 4; // a LED pin száma csatlakozik int ledState = LOW; // a LED állapotának beállításához használt aláíratlan hosszú előzőMillis = 0; // tárolja a legutóbbi LED villogását const hosszú időszak = 1000; // időszak, amikor villogni kell ms void setup () { pinMode (ledPin, OUTPUT); // ledpin beállítása kimenetnek } void loop () { unsigned long currentMillis = millis (); // tárolja az aktuális időt, ha (currentMillis - előzőMillis> = időszak) {// ellenőrizze, hogy 1000ms telt-e előzőMillis = currentMillis; // mentse utoljára, amikor pislogott a LED, ha (ledState == LOW) {// ha a LED nem világít, kapcsolja be, és fordítva ledState = HIGH; } else { ledState = LOW; } digitalWrite (ledPin, ledState); // állítsa a ledState LED-et ismét villogni } }

Itt a nyilatkozat = időszak)> ellenőrzi, hogy eltelt-e az 1000 ms. Ha eltelt 1000 ms, akkor a LED villog, és ismét ugyanabba az állapotba kerül. És ez megy tovább. Ennyi, megtanultunk milliseket használni késés helyett. Így nem állítja le a programot bizonyos időközönként.

Az Arduino megszakításai ugyanúgy működnek, mint más mikrovezérlőknél. Az Arduino UNO táblának két különálló csapja van a megszakítások rögzítésére a GPIO 2 és 3 tűkön. Részletesen áttekintettük az Arduino megszakítások oktatóanyagában, ahol többet megtudhat a megszakításokról és azok használatáról.

Itt megmutatjuk az Arduino Multitasking funkciót két feladat egyidejű kezelésével. A feladatok közé tartozik két LED villogása, különböző késleltetéssel, valamint egy nyomógomb, amelyet a LED BE / KI állapotának szabályozására használnak. Tehát három feladatot hajtanak végre egyidejűleg.

Szükséges alkatrészek

• Arduino UNO
• Három LED (bármilyen színű)
• Ellenállások (470, 10k)
• Ugrók
• Kenyérlemez

Kördiagramm

Az Arduino Millis () fuction használatának bemutatására szolgáló kapcsolási rajz nagyon egyszerű, és nincs sok alkatrésze, amelyeket az alábbiakban bemutatunk.

Arduino UNO programozása multitaskinghoz

Az Arduino UNO multitasking programozásához csak a millik () működésének logikája szükséges, amelyet fentebb kifejtettünk. Mielőtt elkezdené programozni az Arduino UNO-t többfeladatos feladatra, javasoljuk, hogy újra és újra használja a villogó LED-et millis használatával , hogy egyértelmű legyen a logika és jól érezze magát a millis (). Ebben az oktatóanyagban a megszakítást a millis () mellett egyidejűleg használják a multitaskinghoz is. A gomb megszakítás lesz. Tehát, amikor megszakítás jön létre, azaz megnyomják a nyomógombot, a LED BE vagy KI állapotba kapcsol.

A programozás a PIN-kódok deklarálásával kezdődik, ahol a LED-ek és a nyomógomb csatlakoztatva vannak.

int led1 = 6; int led2 = 7; int toggleLed = 5; int nyomógomb = 2;

Ezután írunk egy változót a LED-ek állapotának tárolására a jövőbeni felhasználásra.

int ledState1 = LOW; int ledState2 = LOW;

A villogó példa fent leírtak szerint a period és az előző millilisz változók deklarálva vannak összehasonlítva és késleltetve a LED-eket. Az első LED 1 másodpercenként villog, és egy másik LED 200 ms után villog.

aláíratlan hosszú előzőMillis1 = 0; const hosszú periódus1 = 1000; aláíratlan hosszú előzőMillis2 = 0; const hosszú periódus2 = 200;

Egy másik millis funkciót használunk a visszavonási késleltetés előállítására, hogy elkerüljük a nyomógomb többszöri megnyomását. Hasonló megközelítés lesz, mint fent.

int debouncePeriod = 20; int debounceMillis = 0;

A három változót a nyomógomb állapotának megszakításként, a váltó LED és a nyomógomb állapotának tárolására használják.

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

Határozza meg a csap működését, hogy melyik tű működjön INPUT vagy OUTPUT néven.

pinMode (led1, OUTPUT); pinMode (led2, OUTPUT); pinMode (toggleLed, OUTPUT); pinMode (nyomógomb, INPUT);

Most definiálja a megszakító csapot, megadva a megszakítást az ISR és a megszakítási mód definíciójával. Ne feledje, hogy az attachInterrupt () függvény deklarálásakor ajánlott a digitalPinToInterrup (pin_number) használatát a tényleges digitális PIN- kód lefordítására az adott megszakítási számra.

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

A megszakítás alprogram be van írva, és csak a buttonPushed jelzőt változtatja meg. Ne feledje, hogy az alprogram megszakításának a lehető legrövidebbnek kell lennie, ezért próbálja meg megírni, és minimalizálja az extra utasításokat.

void pushButton_ISR () { buttonPushed = true; }

A hurok azzal kezdődik, hogy a milliszám értéket tárolja egy currentMillis változóban, amely tárolja a ciklus minden egyes ismétlésével eltelt idő értékét.

előjel nélküli hosszú áramMillis = millis ();

A multitaskingban összesen három funkció működik: villogjon egy LED 1 másodpercnél, villogjon a második LED 200 ms-nál, és ha megnyomja a nyomógombot, kapcsolja ki / be a LED-et. Tehát három részt írunk ennek a feladatnak a végrehajtásához.

Az első az, hogy a LED állapotot másodpercenként váltogatja az eltelt milliméterek összehasonlításával.

if (currentMillis - előzőMillis1> = időszak1) { előzőMillis1 = currentMillis; if (ledState1 == LOW) { ledState1 = HIGH; } else { ledState1 = LOW; } digitalWrite (led1, ledState1); }

Hasonlóképpen másodszor váltja a LED-et 200 ms után az eltelt milliek összehasonlításával. A magyarázatot a cikk korábban már elmagyarázta.

if (currentMillis - előzőMillis2> = időszak2 ) { előzőMillis2 = currentMillis; if (ledState2 == LOW) { ledState2 = HIGH; } else { ledState2 = LOW; } digitalWrite (led2, ledState2); }

Végül a buttonPushed jelzőt figyeljük, és miután 20ms késleltetési késleltetést generált, csak átkapcsolja a LED állapotát a megszakításként csatolt nyomógombnak.

if (buttonPushed = true) // ellenőrizze, hogy hívják-e az ISR-t { if ((currentMillis - debounceMillis)> debouncePeriod && buttonPushed) // 20 ms visszavonási késleltetést generál a többszörös megnyomás elkerülése érdekében { debounceMillis = currentMillis; // az utolsó visszavonási késleltetési idő mentése, ha (digitalRead (pushButton) == LOW && lastState == HIGH) // a led megváltoztatása a nyomógomb lenyomása után { ledChange =! ledChange; digitalWrite (toggleLed, ledChange); lastState = LOW; } else if (digitalRead (pushButton) == HIGH && lastState == LOW) { lastState = HIGH; } buttonPushed = false; } }

Ezzel befejeződik az Arduino millis () oktatóanyag. Ne feledje, hogy a millis () szokásos megszokása érdekében csak gyakorolja ezt a logikát néhány más alkalmazásban. Kiterjesztheti motorok, szervomotorok, érzékelők és egyéb perifériák használatára is. Ha kétségei vannak, kérjük, írjon a fórumra vagy az alábbi megjegyzésre.

Az alábbiakban a teljes kódot és videót mutatjuk be az Arduino millis funkcióinak használatáról.