- Ano ang Multitasking?
- Bakit upang laktawan ang pagkaantala () sa Arduino?
- Bakit gagamit ng millis ()?
- Kinakailangan ang Mga Bahagi
- Diagram ng Circuit
- Programming Arduino UNO para sa Multitasking
Ang multitasking ay humantong sa mga computer sa isang rebolusyon kung saan ang isa o higit pang mga programa ay maaaring tumakbo nang sabay-sabay na nagdaragdag ng kahusayan, kakayahang umangkop, kakayahang umangkop at pagiging produktibo. Sa mga naka-embed na system, ang mga microcontroller ay maaari ring hawakan ang Multitasking at nagsasagawa ng dalawa o higit pang mga gawain nang sabay-sabay nang hindi hinihinto ang kasalukuyang mga tagubilin.
Dito sa tutorial na ito ay matututunan natin kung Paano gumaganap ang Arduino ng Multitasking na may Arduino millis function. Karaniwan ang pagpapaandar na () pagpapaandar ay ginagamit sa Arduino para sa isang pana-panahong gawain tulad ng LED Blinking ngunit ang pagka-antala na () pagpapaandar na ito ay tumigil sa programa para sa ilang tiyak na oras at huwag payagan ang iba pang mga pagpapatakbo na gumanap. Kaya ipinapaliwanag ng artikulong ito kung paano maiiwasan ang paggamit ng pagkaantala () na pagpapaandar at palitan ito ng millis () upang maisagawa ang higit sa isang mga gawain nang sabay-sabay at gawin ang Arduino bilang isang Multitasking controller. Bago magpunta sa detalye magsimula tayo sa understating Multitasking.
Ano ang Multitasking?
Ang ibig sabihin ng multitasking ay nangangahulugan ng pagpapatupad ng higit sa isang gawain o programa nang sabay-sabay. Halos lahat ng mga operating system ay nagtatampok ng multitasking. Ang ganitong uri ng mga operating system ay kilala bilang MOS (multitasking operating system). Ang MOS ay maaaring maging mobile o desktop PC Operating System. Ang magandang halimbawa ng multitasking sa mga computer ay kapag pinatakbo ng mga gumagamit ang email application, internet browser, media player, mga laro, nang sabay at kung ayaw ng mga gumagamit na gamitin ang application ay tumatakbo ito sa background kung hindi sarado. Ginagamit ng end user ang lahat ng mga application na ito nang sabay ngunit kinukuha ng OS ang konseptong ito nang medyo kakaiba. Talakayin natin kung paano pinamamahalaan ng OS ang multitasking.
Tulad ng nakikita sa larawan, hinahati ng CPU ang oras sa tatlong pantay na bahagi at italaga ang bawat bahagi sa bawat gawain / aplikasyon. Ganito ginagawa ang multitasking sa karamihan ng mga system. Ang konsepto ay halos kapareho para sa Arduino Multitasking, maliban sa pamamahagi ng oras ay medyo magkakaiba. Dahil ang Arduino ay tumatakbo sa mababang dalas at ang RAM ay ihinahambing sa Laptop / Mobile / PC kaya't ang oras na ibinigay sa bawat gawain ay magkakaiba rin. Ang Arduino ay mayroon ding pagkaantala () na pag- andar na malawakang ginagamit. Ngunit bago simulan talakayin natin na bakit hindi tayo dapat gumamit ng pagkaantala () na pagpapaandar sa anumang proyekto.
Bakit upang laktawan ang pagkaantala () sa Arduino?
Kung ang sanggunian na dokumentasyon ng Arduino ay isinasaalang-alang pagkatapos ay mayroong dalawang uri ng mga pagpapaandar na pagkaantala, ang una ay pagkaantala () at ang pangalawa ay pagkaantalaMicroseconds (). Ang parehong mga pag-andar ay magkapareho sa mga tuntunin ng pagbuo ng pagkaantala. Ang pagkakaiba lamang ay, sa pagpapaandar () na pagpapaandar, ang parameter na integer na ipinasa ay nasa milliseconds ibig sabihin kung nagsusulat kami ng pagkaantala (1000) kung gayon ang pagkaantala ay 1000 milliseconds ibig sabihin 1 segundo. Katulad din sa pagpapaandar ng delayMicroseconds (), ang parameter na naipasa ay nasa microseconds ibig sabihin kung nagsusulat kami ng delayMicroseconds (1000), kung gayon ang pagkaantala ay 1000 microseconds ie 1 milliseconds.
Narito ang puntong, ang parehong mga pag-andar ay i-pause ang programa para sa dami ng oras na lumipas sa pagka-andar ng pagkaantala. Kaya't kung nagbibigay kami ng pagkaantala ng 1 segundo kung gayon ang processor ay hindi maaaring pumunta sa susunod na tagubilin hanggang sa lumipas ang 1 segundo. Katulad nito kung ang pagkaantala ay 10 segundo kung gayon ang programa ay hihinto sa loob ng 10 segundo at hindi papayag ang processor na pumunta para sa mga susunod na tagubilin hanggang sa lumipas ang 10 segundo. Hinahadlangan nito ang pagganap ng microcontroller sa mga tuntunin ng bilis at pagpapatupad ng mga tagubilin.
Ang pinakamahusay na halimbawa upang ipaliwanag ang drawback ng pagka-antala function ay ang paggamit ng dalawang mga pindutan ng push. Isaalang-alang nais naming i-toggle ang dalawang LEDs gamit ang dalawang mga pindutan ng push. Kaya't kung ang isang pindutan ng push ay naitulak pagkatapos ang katumbas na LED ay dapat na mamula sa loob ng 2 segundo, katulad din kung ang pangalawa ay naitulak sa gayon ang LED ay dapat na mamula ng 4 na segundo. Ngunit kapag gumamit kami ng pagkaantala (), kung ang gumagamit ay pinindot ang unang pindutan pagkatapos ang programa ay titigil sa loob ng 2 segundo at kung pipindutin ng gumagamit ang pangalawang pindutan bago maantala ang 2 segundo, pagkatapos ay hindi tatanggapin ng microcontroller ang input habang ang programa ay sa huminto yugto.
Ang opisyal na dokumentasyon ng Arduino ay malinaw na binabanggit ito sa mga Tala at Babala ng pagkaantala () na paglalarawan sa pag-andar. Maaari kang dumaan at suriin ito upang mas malinaw ito.
Bakit gagamit ng millis ()?
Upang mapagtagumpayan ang problemang sanhi ng paggamit ng pagkaantala, ang isang developer ay dapat gumamit ng millis () function na madaling gamitin kapag naging ugali mo at gagamit ito ng 100% pagganap ng CPU nang hindi bumubuo ng anumang pagkaantala sa pagpapatupad ng mga tagubilin. Ang millis () ay isang pagpapaandar na ibabalik lamang ang dami ng milliseconds na lumipas mula nang simulan ng Arduino board ang kasalukuyang programa nang hindi nagyeyelo ang programa. Ang bilang ng oras na ito ay mag-uumapaw (ibig sabihin babalik sa zero), pagkatapos ng humigit-kumulang na 50 araw.
Tulad din ng Arduino na may delayMicroseconds (), mayroon din itong micro bersyon ng millis () bilang micros (). Ang pagkakaiba sa pagitan ng micros at millis ay iyon, ang micros () ay aapaw pagkatapos ng humigit-kumulang na 70 minuto, kumpara sa millis () na 50 araw. Kaya depende sa application maaari kang gumamit ng millis () o micros ().
Paggamit ng millis () sa halip na pagkaantala ():
Upang magamit ang millis () para sa tiyempo at pagkaantala, kailangan mong i-record at iimbak ang oras kung saan naganap ang pagkilos upang simulan ang oras at pagkatapos ay suriin sa mga agwat kung ang natukoy na oras ay lumipas na. Kaya't ayon sa nakasaad, itago ang kasalukuyang oras sa isang variable.
unsigned long currentMillis = millis ();
Kailangan namin ng dalawa pang variable upang malaman kung lumipas na ang kinakailangang oras. Naimbak namin ang kasalukuyang oras sa variable ng kasalukuyangMillis ngunit kailangan din nating malaman na kailan nagsimula ang tagal ng panahon at gaano katagal ang panahon. Kaya idineklara ang Interval at nakaraangMillis . Sasabihin sa amin ng agwat ang pagkaantala ng oras at iimbak ng previosMillis ang huling oras na naganap ang kaganapan.
unsigned matagal na ang nakaraangMillis; unsigned mahabang panahon = 1000;
Upang maunawaan ito, kumuha tayo ng isang halimbawa ng isang simpleng blinking LED. Sasabihin sa amin ng panahon = 1000 na ang LED ay magpapikit para sa 1 segundo o 1000ms.
Const int ledPin = 4; // ang LED pin number na konektado int ledState = LOW; // used to set the LED state unsigned long nakaraangMillis = 0; // mag-iimbak ng huling oras na ang LED ay kumurap sa mahabang panahon = 1000; // period kung saan magpapikit sa ms void setup () { pinMode (ledPin, OUTPUT); // set ledpin as output } void loop () { unsigned long currentMillis = millis (); // store the current time if (currentMillis - nakaraangMillis> = panahon) {// suriin kung 1000ms ang lumipas nakaraangMillis = 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; } iba pa { ledState = LOW; } digitalWrite (ledPin, ledState); // set LED na may ledState upang kumurap muli } }
Narito, ang pahayag
Ang mga pagkagambala sa Arduino ay gumagana nang pareho sa ibang mga microcontroller. Ang Arduino UNO board ay may dalawang magkakahiwalay na mga pin para sa paglakip ng mga nakakagambala sa GPIO pin 2 at 3. Sinakop namin ito nang detalyado sa Arduino Interrupts Tutorial, kung saan maaari mong malaman ang higit pa tungkol sa Mga Pagkagambala at kung paano ito gamitin.
Ipapakita namin dito ang Arduino Multitasking sa pamamagitan ng paghawak ng dalawang gawain nang sabay. Ang mga gawain ay isasama ang pagpikit ng dalawang LEDs sa magkakaibang pagkaantala ng oras kasama ang isang pindutan ng itulak na gagamitin upang makontrol ang ON / OFF na estado ng LED. Kaya't tatlong gawain ang isasagawa nang sabay-sabay.
Kinakailangan ang Mga Bahagi
- Arduino UNO
- Tatlong LEDs (Anumang Kulay)
- Mga paglaban (470, 10k)
- Mga jumper
- Breadboard
Diagram ng Circuit
Ang circuit diagram para sa pagpapakita ng paggamit ng Arduino Millis () fuction ay napakadali at walang gaanong mga sangkap na ikakabit tulad ng ipinakita sa ibaba.
Programming Arduino UNO para sa Multitasking
Ang Programming Arduino UNO para sa multitasking ay mangangailangan lamang ng lohika sa likod kung paano gumagana ang millis () na ipinaliwanag sa itaas. Inirerekumenda na magsanay ng blink LED gamit ang millis nang paulit -ulit upang linawin ang lohika at gawing komportable ang iyong sarili sa millis () bago simulang i-program ang Arduino UNO para sa multitasking. Sa tutorial na ito ang paggambala ay ginagamit din sa millis () nang sabay-sabay para sa multitasking. Magagambala ang pindutan. Kaya't tuwing ang isang nakakagambala ay nabuo ie push button ay pinindot, ang LED ay lilipat sa ON o OFF state.Nagsisimula ang programa sa pagdedeklara ng mga numero ng pin kung saan nakakonekta ang mga LED at Push Button.
int led1 = 6; int led2 = 7; int toggleLed = 5; int pushbutton = 2;
Susunod na nagsusulat kami ng isang variable upang maiimbak ang katayuan ng mga LED para magamit sa hinaharap.
int ledState1 = LOW; int ledState2 = LOW;
Tulad ng ipinaliwanag sa itaas sa blink halimbawa, ang mga variable para sa panahon at nakaraang millis ay idineklara upang ihambing at makabuo ng pagkaantala para sa mga LED. Ang unang LED blinks pagkatapos ng bawat 1 segundo at isa pang LED blinks pagkatapos ng 200ms.
unsigned matagal na nakaraangMillis1 = 0; Const mahabang panahon1 = 1000; unsigned matagal na nakaraangMillis2 = 0; const mahabang panahon2 = 200;
Ang isa pang pag-andar ng millis ay gagamitin upang makabuo ng pagkaantala ng debounce upang maiwasan ang maraming pagpindot sa pindutan ng push. Magkakaroon ng katulad na diskarte tulad ng nasa itaas.
int debouncePeriod = 20; int debounceMillis = 0;
Gagamitin ang tatlong variable upang maiimbak ang katayuan ng pindutan ng push bilang makagambala, i-toggle ang LED at itulak ang estado ng pindutan.
bool buttonPush = false; int ledChange = Mababa; int lastState = MATAAS;
Tukuyin ang pagkilos ng pin na kung saan ang pin ay gagana bilang INPUT o OUTPUT.
pinMode (led1, OUTPUT); pinMode (led2, OUTPUT); pinMode (toggleLed, OUTPUT); pinMode (pushbutton, INPUT);
Ngayon tukuyin ang makagambala na pin sa pamamagitan ng paglakip ng makagambala sa kahulugan ng ISR at makagambala Mode. Tandaan na inirerekumenda na gumamit ng digitalPinToInterrupt (pin_number) kapag idineklarang function na attachInterrupt () upang isalin ang aktwal na digital pin sa tukoy na numero ng nakakagambala .
attachInterrupt (digitalPinToInterrupt (push Button), pushbutton_ISR, CHANGE);
Ang makagambalang subroutine ay nakasulat at babaguhin lamang nito ang button na Push flag. Tandaan na, ang makagambala na subroutine ay dapat na kasing liit hangga't maaari, kaya subukang isulat ito at i-minimize ang labis na mga tagubilin.
walang bisa ang pushbutton_ISR () { buttonPush = true; }
Nagsisimula ang loop sa pag-iimbak ng halaga ng millis sa isang kasalukuyang variable ngMillis na mag-iimbak ng lumipas ang halaga ng oras sa tuwing umuulit ang loop.
unsigned long currentMillis = millis ();
Mayroong kabuuang tatlong mga pag-andar sa multitasking, kumurap ng isang LED sa 1 segundo, Blink pangalawang LED sa 200ms at Kung ang pindutan ng push ay pinindot pagkatapos ay i-OFF ang OFF / ON LED. Kaya magsusulat kami ng tatlong bahagi upang gawin ang gawaing ito.
Ang una ay ang toggle LED state pagkatapos ng bawat 1 segundo sa pamamagitan ng paghahambing ng millis na lumipas.
kung (currentMillis - nakaraangMillis1> = period1) { nakaraangMillis1 = currentMillis; kung (ledState1 == LOW) { ledState1 = MATAAS; } iba pa { ledState1 = LOW; } digitalWrite (led1, ledState1); }
Katulad nito ang pangalawa ay pinapalitan nito ang LED pagkatapos ng bawat 200ms sa pamamagitan ng paghahambing sa mga lumipas na millis. Ang paliwanag ay ipinaliwanag nang mas maaga sa artikulong ito.
kung (currentMillis - nakaraangMillis2> = period2) { nakaraangMillis2 = currentMillis; kung (ledState2 == LOW) { ledState2 = MATAAS; } iba pa { ledState2 = LOW; } digitalWrite (led2, ledState2); }
Panghuli, sinusubaybayan ang bandila ng buttonPush at pagkatapos makabuo ng isang pagkaantala ng pag-debounce na 20ms ay pinapalitan lamang nito ang estado ng LED na tumutugma upang itulak ang pindutan na nakakabit bilang nakakagambala.
kung (buttonPush = true) // suriin kung ang ISR ay tinawag na { if (((currentMillis - debounceMillis)> debouncePeriod && pindutan ng pindutan) // bumuo ng 20ms pagkaantala ng pag- debug upang maiwasan ang maraming pagpindot { debounceMillis = currentMillis; // i-save ang huling oras ng pagkaantala ng pag-debounce kung (digitalRead (pushbutton) == LOW && lastState == HIGH) // baguhin ang pinangunahan matapos ang pindutan ng push ay pinindot { ledChange =! ledChange; digitalWrite (toggleLed, ledChange); lastState = LOW; } iba pa kung (digitalRead (pushbutton) == TAAS && lastState == LOW) { lastState = HIGH; } buttonPush = false; } }
Tinatapos nito ang Arduino millis () Tutorial. Tandaan na upang maging kaugalian sa millis (), pagsasanay lamang upang ipatupad ang lohika na ito sa ilang iba pang mga application. Maaari mo ring palawakin ito upang magamit ang mga motor, servo motor, sensor at iba pang mga peripheral. Sa kaso ng anumang pag-aalinlangan mangyaring sumulat sa aming forum o puna sa ibaba.
Ang kumpletong code at Video para sa pagpapakita ng paggamit ng millis function sa Arduino ay ibinigay sa ibaba.