Arduino freertos apmācība 1

Iegultās ierīcēs esošo OS sauc par RTOS (reāllaika operētājsistēmu). Iegultās ierīcēs reāllaika uzdevumi ir izšķiroši, ja laika noteikšanai ir ļoti liela nozīme. Reāllaika uzdevumi ir laika noteicošie, tas nozīmē, ka reakcijas laiks uz jebkuru notikumu vienmēr ir nemainīgs, lai varētu garantēt, ka jebkurš konkrēts notikums notiks noteiktā laikā. RTOS ir paredzēts lietojumprogrammu darbināšanai ar ļoti precīzu laiku un augstu uzticamības pakāpi. RTOS palīdz arī daudzuzdevumu veikšanā ar vienu kodolu.

Mēs jau apskatījām apmācību par to, kā izmantot RTOS iegultās sistēmās, kur jūs varat uzzināt vairāk par RTOS, atšķirību starp vispārējas nozīmes OS un RTOS, dažādiem RTOS veidiem utt.

Šajā apmācībā mēs sāksim ar FreeRTOS. FreeRTOS ir iegulto ierīču RTOS klase, kas ir pietiekami maza, lai to varētu darbināt ar 8/16 bitu mikrokontrolleriem, lai gan tā izmantošana nav ierobežota tikai ar šiem mikrokontrolleriem. Tas ir pilnīgi atvērtā koda kods, un tā kods ir pieejams vietnē github. Ja mēs zinām dažus RTOS pamatjēdzienus, tad FreeRTOS ir ļoti viegli izmantot, jo tam ir labi dokumentēti API, kurus var tieši izmantot kodā, nezinot kodēšanas aizmugures daļu. Pilnīgu FreeRTOS dokumentāciju var atrast šeit.

Tā kā FreeRTOS var darboties ar 8 bitu MCU, to var palaist arī uz Arduino Uno dēļa. Mums vienkārši jālejupielādē FreeRTOS bibliotēka un pēc tam jāsāk koda ieviešana, izmantojot API. Šī apmācība ir paredzēta pilnīgi iesācējam, tālāk ir norādītas tēmas, kuras mēs aplūkosim šajā Arduino FreeRTOS apmācībā:

1. Kā darbojas RTOS
2. Daži bieži lietoti termini RTOS
3. FreeRTOS instalēšana Arduino IDE
4. Kā izveidot FreeRTOS uzdevumus ar piemēru

Kā darbojas RTOS?

Pirms sākt darbu ar RTOS, redzēsim, kas ir uzdevums. Uzdevums ir koda gabals, kuru CPU var ieplānot izpildei. Tātad, ja vēlaties veikt kādu uzdevumu, tas jāplāno, izmantojot kodola aizkavi vai pārtraucot. Šo darbu veic kodolā esošais plānotājs. Viena kodola procesorā plānotājs palīdz uzdevumiem izpildīt noteiktu laika daļu, taču šķiet, ka vienlaikus tiek izpildīti dažādi uzdevumi. Katrs uzdevums notiek atbilstoši tam piešķirtajai prioritātei.

Tagad redzēsim, kas notiek RTOS kodolā, ja mēs vēlamies izveidot uzdevumu LED mirgošanai ar vienas sekundes intervālu un izvirzīt šo uzdevumu visaugstākajā prioritātē.

Papildus LED uzdevumam būs vēl viens uzdevums, ko izveido kodols, tas ir dēvēts par dīkstāves uzdevumu. Dīkstāves uzdevums tiek izveidots, ja izpildei nav pieejams neviens uzdevums. Šis uzdevums vienmēr darbojas ar zemāko prioritāti, ti, ar 0 prioritāti. Ja mēs analizējam iepriekš doto grafiku grafikā, var redzēt, ka izpilde sākas ar LED uzdevumu un tā darbojas noteiktu laiku, bet atlikušo laiku, dīkstāves uzdevums darbojas līdz brīdim, kad notiek atzīmes pārtraukums. Tad kodols izlemj, kurš uzdevums jāveic, atbilstoši uzdevuma prioritātei un LED uzdevuma kopējam pagājušajam laikam. Kad ir pabeigta 1 sekunde, kodols vēlreiz izvēlas izpildāmo uzdevumu, lai to izpildītu, jo tam ir augstāka prioritāte nekā dīkstāves uzdevumam, mēs varam arī teikt, ka LED uzdevums aizkavē dīkstāves uzdevumu. Ja ar vienu un to pašu prioritāti ir vairāk nekā divi uzdevumi, tie noteiktu laiku tiks izpildīti apļa veidā.

Zem stāvokļa diagrammas, jo tā parāda nedarbojošā uzdevuma pārslēgšanos uz darbības stāvokli.

Katrs jaunizveidotais uzdevums iet gatavībā (nedarbojas stāvoklī). Ja izveidotajam uzdevumam (1. uzdevums) ir visaugstākā prioritāte nekā citiem uzdevumiem, tas tiks pārvietots uz darbības stāvokli. Ja šo darbojošo uzdevumu mēģina veikt cits uzdevums, tas atkal atgriezīsies gatavajā stāvoklī. Citādi, ja uzdevums1 ir bloķēts, izmantojot bloķēšanas API, centrālais procesors neiesaistīsies šajā uzdevumā līdz lietotāja definētajam noildzienam.

Ja 1. uzdevums ir apturēts darbības stāvoklī, izmantojot Suspend API, tad 1. uzdevums nonāks apturētā stāvoklī, un tas vairs nav pieejams plānotājam. Ja atsāksiet 1. uzdevumu apturētā stāvoklī, tas atgriezīsies gatavajā stāvoklī, kā redzat bloku diagrammā.

Šī ir pamatideja par to, kā Tasks darbojas un maina savus stāvokļus. Šajā apmācībā mēs realizēsim divus uzdevumus Arduino Uno, izmantojot FreeRTOS API.

RTOS bieži lietotie termini

1. Uzdevums: Tas ir koda gabals, kuru izpildes laikā CPU var ieplānot.

2. Plānotājs: tā ir atbildīga par uzdevuma izvēli no gatavā stāvokļa saraksta līdz darbības stāvoklim. Plānotāji bieži tiek ieviesti, lai tie visu datoru resursus aizņemtu (tāpat kā slodzes līdzsvarošanā).

3. Priekšrocība: tā ir darbība, kas uz laiku pārtrauc jau izpildītu uzdevumu ar nolūku to izņemt no darbības stāvokļa bez tā sadarbības.

4. Konteksta pārslēgšana: prioritārā prioritārā režīmā plānotājs salīdzina izpildāmo uzdevumu prioritāti ar gatavu uzdevumu saraksta prioritāti katrā sistēmas darbības pārtraukumā. Ja sarakstā ir kāds uzdevums, kura prioritāte ir augstāka nekā izpildāmā uzdevuma izpilde, notiek konteksta maiņa. Būtībā šajā procesā dažādu uzdevumu saturs tiek saglabāts to attiecīgajā kaudzes atmiņā.

5. Plānošanas politikas veidi:

1. Iepriekšēja plānošana: šāda veida plānošanā uzdevumi tiek izpildīti ar vienādu laika daļu, neņemot vērā prioritātes.
2. Uz prioritātēm balstīts preventīvs: vispirms tiks izpildīts augstas prioritātes uzdevums.
3. Kooperatīva plānošana: Konteksta maiņa notiks tikai sadarbojoties skrienošajiem uzdevumiem. Uzdevums darbosies nepārtraukti, līdz tiks izsaukts uzdevuma ienesīgums.

6. Kodola objekti: lai norādītu uzdevumu veikt kādu darbu, tiek izmantots sinhronizācijas process. Lai veiktu šo procesu, tiek izmantoti kodola objekti. Daži kodola objekti ir Notikumi, Semafori, Rindas, Mutex, Pastkastes utt. Mēs redzēsim, kā šos objektus izmantot gaidāmajās apmācībās.

No iepriekšminētās diskusijas mēs esam ieguvuši dažas pamatidejas par RTOS koncepciju, un tagad mēs varam ieviest FreeRTOS projektu Arduino. Tātad, sāksim, instalējot FreeRTOS bibliotēkas Arduino IDE.

Arduino FreeRTOS bibliotēkas instalēšana

1. Atveriet Arduino IDE un dodieties uz Sketch -> Include Library -> Manage Libraries . Meklējiet FreeRTOS un instalējiet bibliotēku, kā parādīts zemāk.

Bibliotēku var lejupielādēt no github un pievienot.zip failu sadaļā Sketch-> Include Library -> Add.zip file.

Tagad restartējiet Arduino IDE. Šajā bibliotēkā ir sniegti daži koda piemēri, kurus var atrast arī failā -> Piemēri -> FreeRTOS, kā parādīts zemāk.

Šeit mēs uzrakstīsim kodu no nulles, lai saprastu darbību, vēlāk jūs varat pārbaudīt kodu piemērus un tos izmantot.

Ķēdes shēma

Zemāk ir shēma, lai izveidotu mirgojošu LED uzdevumu, izmantojot FreeRTOS uz Arduino:

Arduino FreeRTOS piemērs - FreeRTOS uzdevumu izveide Arduino IDE

Apskatīsim pamata struktūru, lai uzrakstītu FreeRTOS projektu.

1. Vispirms iekļaujiet Arduino FreeRTOS galvenes failu kā

# iekļaut

2. Piešķiriet visu to funkciju prototipu, kuras rakstāt izpildei, kas ir rakstīts kā

void 1. uzdevums (void * pvParameters); void 2. uzdevums (void * pvParameters); .. ….

3. Tagad funkcijā void setup () izveidojiet uzdevumus un palaidiet uzdevumu plānotāju.

Lai izveidotu uzdevumu, iestatīšanas funkcijā ar noteiktiem parametriem / argumentiem tiek izsaukta xTaskCreate () API.

xTaskCreate (TaskFunction_t pvTaskCode, const char * const pcName, uint16_t usStackDepth, void * pvParameters, UBaseType_t uxPriority, TaskHandle_t * pxCreatedTask);

Veidojot jebkuru uzdevumu, ir jānodod 6 argumenti. Apskatīsim, kādi ir šie argumenti

1. pvTaskCode: Tas ir vienkārši rādītājs funkcijai, kas īsteno uzdevumu (faktiski tikai funkcijas nosaukums).
2. pcName: aprakstošs uzdevuma nosaukums. To neizmanto FreeRTOS. Tas ir iekļauts tikai atkļūdošanas nolūkos.
3. usStackDepth: Katram uzdevumam ir sava unikālā kaudze, kuru kodols piešķir uzdevumam, kad uzdevums tiek izveidots. Vērtība norāda vārdu skaitu, ko var ievietot kaudzē, nevis baitu skaitu. Piemēram, ja kaudze ir 32 bitu plata un usStackDepth tiek ievadīts kā 100, tad RAM tiks piešķirti 400 baiti kaudzes vietas (100 * 4 baiti). Izmantojiet to saprātīgi, jo Arduino Uno ir tikai 2 KB RAM.
4. pvParameters: Uzdevuma ievades parametrs (var būt NULL).
5. uxPriority: uzdevuma prioritāte (0 ir zemākā prioritāte).
6. pxCreatedTask: To var izmantot, lai nodotu rokturi izveidotajam uzdevumam. Pēc tam šo rokturi var izmantot, lai atsauktu uzdevumu API izsaukumos, kas, piemēram, maina uzdevuma prioritāti vai izdzēš uzdevumu (var būt NULL).

Uzdevuma izveides piemērs

xTaskCreate (uzdevums1, "uzdevums1", 128, NULL, 1, NULL); xTaskCreate (uzdevums2, "uzdevums2", 128, NULL, 2, NULL);

Šeit 2. uzdevumam ir augstāka prioritāte, un tāpēc tas tiek izpildīts pirmais.

4. Pēc uzdevuma izveides palaidiet plānotāju tukšā iestatījumā, izmantojot vTaskStartScheduler (); API.

5. Void loop () funkcija paliks tukša, jo mēs nevēlamies nevienu uzdevumu izpildīt manuāli un bezgalīgi. Tā kā uzdevumu izpildi tagad veic plānotājs.

6. Tagad mums ir jāievieš uzdevumu funkcijas un jāuzraksta loģika, kuru vēlaties izpildīt šo funkciju iekšpusē. Funkcijas nosaukumam jābūt tādam pašam kā xTaskCreate () API pirmajam argumentam.

void task1 (void * pvParameters) { while (1) { .. ..//jūsu loģika } }

7. Lielākajai daļai koda ir nepieciešama aizkaves funkcija, lai apturētu darbojošos uzdevumu, taču RTOS nav ieteicams izmantot funkciju Delay (), jo tas aptur CPU un līdz ar to arī RTOS pārtrauc darboties. Tātad FreeRTOS ir kodola API, lai bloķētu uzdevumu uz noteiktu laiku.

vTaskDelay (const TickType_t xTicksToDelay);

Šo API var izmantot aizkavēšanās nolūkos. Šī API aizkavē uzdevumu noteiktam ērču skaitam. Faktiskais laiks, kurā uzdevums paliek bloķēts, ir atkarīgs no atzīmes. Pastāvīgo portTICK_PERIOD_MS var izmantot, lai aprēķinātu reāllaiku no ērču likmes.

Tas nozīmē, ja vēlaties 200ms kavēšanos, vienkārši uzrakstiet šo rindu

vTaskDelay (200 / portTICK_PERIOD_MS);

Tāpēc šai apmācībai mēs izmantosim šīs FreeRTOS API, lai īstenotu trīs uzdevumus.

Izmantojamās API:

1. xTaskCreate ();
2. vTaskStartScheduler ();
3. vTaskDelay ();

Izveidojamais uzdevums šai apmācībai:

1. LED mirgo pie digitālās tapas 8 ar 200 ms frekvenci
2. LED mirgo pie digitālās tapas 7 ar 300 ms frekvenci
3. Drukājiet numurus sērijveida monitorā ar 500 ms frekvenci.

FreeRTOS uzdevuma ieviešana Arduino IDE

1. No iepriekš minētā pamata struktūras skaidrojuma iekļaujiet Arduino FreeRTOS galvenes failu. Tad izveidojiet funkciju prototipus. Tā kā mums ir trīs uzdevumi, izveidojiet trīs funkcijas un to prototipus.

#include void TaskBlink1 (void * pvParameters); void TaskBlink2 (void * pvParameters); void Taskprint (void * pvParameters);

2. Funkcijā void setup () inicializējiet sērijveida sakarus ar ātrumu 9600 biti sekundē un izveidojiet visus trīs uzdevumus, izmantojot xTaskCreate () API. Sākumā visu uzdevumu prioritātes iestatiet kā “1” un palaidiet plānotāju.

void setup () { Sērijas.sākt (9600); xTaskCreate (TaskBlink1, "Task1", ​​128, NULL, 1, NULL); xTaskCreate (TaskBlink2, "Task2", 128, NULL, 1, NULL); xTaskCreate (Taskprint, "Task3", 128, NULL, 1, NULL); vTaskStartScheduler (); }

3. Tagad izpildiet visas trīs funkcijas, kā parādīts 1. uzdevuma gaismas diode.

void TaskBlink1 (void * pvParameters) { pinMode (8, OUTPUT); kamēr (1) { digitalWrite (8, HIGH); vTaskDelay (200 / portTICK_PERIOD_MS); digitalWrite (8, LOW); vTaskDelay (200 / portTICK_PERIOD_MS); } }

Līdzīgi ieviesiet funkciju TaskBlink2. Task3 funkcija tiks rakstīta kā

void Taskprint (void * pvParameters) { int skaitītājs = 0; kamēr (1) { skaitītājs ++; Serial.println (skaitītājs); vTaskDelay (500 / portTICK_PERIOD_MS); } }

Tieši tā. Mēs esam veiksmīgi pabeiguši FreeRTOS Arduino projektu Arduino Uno. Šīs apmācības beigās varat atrast pilnu kodu kopā ar videoklipu.

Visbeidzot, pievienojiet divus gaismas diodes pie digitālās tapas 7 un 8, augšupielādējiet kodu savā Arduino dēlī un atveriet sērijas monitoru. Jūs redzēsiet, ka skaitītājs darbojas vienreiz 500 ms laikā ar uzdevuma nosaukumu, kā parādīts zemāk.

Novērojiet arī gaismas diodes, tās mirgo dažādos laika intervālos. Mēģiniet spēlēt ar prioritātes argumentu funkcijā xTaskCreate . Mainiet numuru un novērojiet uzvedību sērijveida monitorā un gaismas diodēs.

Tagad jūs varat saprast pirmos divus paraugu kodus, kuros tiek izveidoti analogās lasīšanas un digitālās lasīšanas uzdevumi. Tādā veidā jūs varat veikt vairāk iepriekšēju projektu, izmantojot tikai Arduino Uno un FreeRTOS API.