ఆర్డునో ఫ్రీర్టోస్ ట్యుటోరియల్ 1

ఎంబెడెడ్ పరికరాల్లో ఉన్న OS ని RTOS (రియల్ టైమ్ ఆపరేటింగ్ సిస్టమ్) అంటారు. పొందుపరిచిన పరికరాల్లో, సమయం చాలా ముఖ్యమైన పాత్ర పోషిస్తున్న చోట నిజ-సమయ పనులు కీలకం. రియల్ టైమ్ టాస్క్‌లు టైమ్ డిటెర్మినిస్టిక్ అంటే ఏదైనా సంఘటనకు ప్రతిస్పందన సమయం ఎల్లప్పుడూ స్థిరంగా ఉంటుంది, తద్వారా ఏదైనా నిర్దిష్ట సంఘటన నిర్ణీత సమయంలో సంభవిస్తుందని హామీ ఇవ్వవచ్చు. RTOS అనువర్తనాలను చాలా ఖచ్చితమైన సమయంతో మరియు అధిక స్థాయి విశ్వసనీయతతో అమలు చేయడానికి రూపొందించబడింది. RTOS ఒకే కోర్తో మల్టీ టాస్కింగ్‌లో సహాయపడుతుంది.

RTOS, సాధారణ-ప్రయోజన OS మరియు RTOS మధ్య వ్యత్యాసం, వివిధ రకాల RTOS మొదలైన వాటి గురించి మీరు మరింత తెలుసుకోగలిగే ఎంబెడెడ్ సిస్టమ్స్‌లో RTOS ను ఎలా ఉపయోగించాలో మేము ఇప్పటికే ఒక ట్యుటోరియల్‌ను కవర్ చేసాము.

ఈ ట్యుటోరియల్‌లో, మేము FreeRTOS తో ప్రారంభిస్తాము. FreeRTOS అనేది ఎంబెడెడ్ పరికరాల కోసం RTOS యొక్క తరగతి, ఇది 8/16-బిట్ మైక్రోకంట్రోలర్‌లలో అమలు చేయడానికి సరిపోతుంది, అయినప్పటికీ దీని ఉపయోగం ఈ మైక్రోకంట్రోలర్‌లకు మాత్రమే పరిమితం కాదు. ఇది పూర్తిగా ఓపెన్ సోర్స్ మరియు దాని కోడ్ గితుబ్‌లో అందుబాటులో ఉంది. RTOS యొక్క కొన్ని ప్రాథమిక అంశాలు మనకు తెలిస్తే, ఫ్రీఆర్టిఓఎస్ ను ఉపయోగించడం చాలా సులభం ఎందుకంటే ఇది చక్కగా డాక్యుమెంట్ చేయబడిన API లను కలిగి ఉంది, ఇది కోడింగ్ యొక్క బ్యాకెండ్ భాగాన్ని తెలుసుకోకుండా నేరుగా కోడ్‌లో ఉపయోగించవచ్చు. పూర్తి FreeRTOS డాక్యుమెంటేషన్ ఇక్కడ చూడవచ్చు.

FreeRTOS 8-బిట్ MCU లో నడుస్తుంది కాబట్టి ఇది Arduino Uno బోర్డులో కూడా నడుస్తుంది. మేము FreeRTOS లైబ్రరీని డౌన్‌లోడ్ చేసి, ఆపై API లను ఉపయోగించి కోడ్‌ను అమలు చేయడం ప్రారంభించాలి. ఈ ట్యుటోరియల్ పూర్తి అనుభవశూన్యుడు కోసం ఉద్దేశించబడింది, క్రింద ఉన్న విషయాలు, మేము ఈ ఆర్డునో ఫ్రీఆర్టిఓఎస్ ట్యుటోరియల్ లో కవర్ చేస్తాము:

1. RTOS ఎలా పనిచేస్తుంది
2. RTOS లో తరచుగా ఉపయోగించే కొన్ని పదాలు
3. Arduino IDE లో FreeRTOS ని ఇన్‌స్టాల్ చేస్తోంది
4. ఉదాహరణతో FreeRTOS విధులను ఎలా సృష్టించాలి

RTOS ఎలా పనిచేస్తుంది?

RTOS పనితో ప్రారంభించే ముందు, టాస్క్ అంటే ఏమిటో చూద్దాం. టాస్క్ అనేది కోడ్ యొక్క భాగం, ఇది అమలు చేయడానికి CPU లో షెడ్యూల్ చేయదగినది. కాబట్టి, మీరు కొంత పనిని చేయాలనుకుంటే, అది కెర్నల్ ఆలస్యాన్ని ఉపయోగించి లేదా అంతరాయాలను ఉపయోగించి షెడ్యూల్ చేయాలి. ఈ పని కెర్నల్‌లో ఉన్న షెడ్యూలర్ చేత చేయబడుతుంది. సింగిల్-కోర్ ప్రాసెసర్‌లో, షెడ్యూలర్ ఒక నిర్దిష్ట సమయ స్లైస్‌లో అమలు చేయడానికి పనులకు సహాయపడుతుంది, కాని వేర్వేరు పనులు ఒకేసారి అమలు చేస్తున్నట్లు అనిపిస్తుంది. ప్రతి పని దానికి ఇచ్చిన ప్రాధాన్యత ప్రకారం నడుస్తుంది.

ఇప్పుడు, ఒక సెకను విరామంతో LED బ్లింక్ కోసం ఒక పనిని సృష్టించాలనుకుంటే మరియు RTOS కెర్నల్‌లో ఏమి జరుగుతుందో చూద్దాం మరియు ఈ పనిని అత్యధిక ప్రాధాన్యతతో ఉంచండి.

LED టాస్క్ కాకుండా, కెర్నల్ చేత సృష్టించబడిన మరో టాస్క్ ఉంటుంది, దీనిని ఐడిల్ టాస్క్ అంటారు. అమలు కోసం ఏ పని అందుబాటులో లేనప్పుడు నిష్క్రియ పని సృష్టించబడుతుంది. ఈ పని ఎల్లప్పుడూ తక్కువ ప్రాధాన్యతతో నడుస్తుంది, అంటే 0 ప్రాధాన్యత. పైన ఇచ్చిన టైమింగ్ గ్రాఫ్‌ను మేము విశ్లేషిస్తే, అమలు ఒక ఎల్‌ఈడీ టాస్క్‌తో మొదలవుతుందని మరియు అది ఒక నిర్దిష్ట సమయం వరకు నడుస్తుందని, ఆపై మిగిలిన సమయం వరకు, టిక్ అంతరాయం ఏర్పడే వరకు పనిలేకుండా ఉండే పని నడుస్తుంది. అప్పుడు టాస్క్ యొక్క ప్రాధాన్యత మరియు LED టాస్క్ యొక్క మొత్తం గడిచిన సమయం ప్రకారం ఏ పనిని అమలు చేయాలో కెర్నల్ నిర్ణయిస్తుంది. 1 సెకను పూర్తయినప్పుడు, కెర్నల్ పనికిరాని పనిని మళ్ళీ ఎన్నుకుంటుంది, ఎందుకంటే అది నిష్క్రియ పని కంటే ఎక్కువ ప్రాధాన్యతనిస్తుంది, LED పని పనిలేకుండా చేసే పనికి ముందుగానే ఉంటుందని కూడా మేము చెప్పగలం. ఒకే ప్రాధాన్యతతో రెండు కంటే ఎక్కువ పనులు ఉంటే, అవి నిర్దిష్ట సమయానికి రౌండ్-రాబిన్ పద్ధతిలో నడుస్తాయి.

రన్నింగ్ టాస్క్ రన్నింగ్ స్టేట్‌లోకి మారడాన్ని చూపించినట్లు స్టేట్ రేఖాచిత్రం క్రింద .

కొత్తగా సృష్టించిన ప్రతి పని రెడీ స్థితిలో ఉంటుంది (నడుస్తున్న స్థితిలో భాగం). సృష్టించిన పని (టాస్క్ 1) కి ఇతర పనులకన్నా ఎక్కువ ప్రాధాన్యత ఉంటే, అది నడుస్తున్న స్థితికి వెళుతుంది. ఈ రన్నింగ్ టాస్క్ ఇతర టాస్క్ ద్వారా ముందుగానే ఉంటే, అది మళ్ళీ సిద్ధంగా ఉన్న స్థితికి వెళుతుంది. API ని నిరోధించడం ద్వారా టాస్క్ 1 నిరోధించబడితే, వినియోగదారు నిర్వచించిన సమయం ముగిసే వరకు CPU ఈ పనితో నిమగ్నమై ఉండదు.

సస్పెండ్ API లను ఉపయోగించి నడుస్తున్న స్థితిలో టాస్క్ 1 నిలిపివేయబడితే, టాస్క్ 1 సస్పెండ్ చేయబడిన స్థితికి వెళుతుంది మరియు అది మళ్ళీ షెడ్యూలర్‌కు అందుబాటులో ఉండదు. మీరు సస్పెండ్ చేయబడిన స్థితిలో టాస్క్ 1 ను తిరిగి ప్రారంభిస్తే, అది బ్లాక్ రేఖాచిత్రంలో మీరు చూడగలిగినట్లుగా తిరిగి సిద్ధంగా ఉన్న స్థితికి వెళుతుంది.

టాస్క్‌లు తమ రాష్ట్రాలను ఎలా నడుపుతాయి మరియు మారుస్తాయి అనే ప్రాథమిక ఆలోచన ఇది. ఈ ట్యుటోరియల్‌లో, మేము ఫ్రీఆర్టిఓఎస్ ఎపిఐని ఉపయోగించి ఆర్డునో యునోలో రెండు పనులను అమలు చేస్తాము.

RTOS లో తరచుగా ఉపయోగించే పదాలు

1. టాస్క్: ఇది అమలు చేయడానికి CPU లో షెడ్యూల్ చేయగల కోడ్ యొక్క భాగం.

2. షెడ్యూలర్: సిద్ధంగా ఉన్న రాష్ట్ర జాబితా నుండి నడుస్తున్న స్థితికి ఒక పనిని ఎంచుకోవడం బాధ్యత. షెడ్యూలర్లు తరచూ అమలు చేయబడతాయి కాబట్టి అవి అన్ని కంప్యూటర్ వనరులను బిజీగా ఉంచుతాయి (లోడ్ బ్యాలెన్సింగ్‌లో వలె).

3. ప్రీమిప్షన్: ఇది ఇప్పటికే అమలులో ఉన్న పనిని దాని సహకారం లేకుండా నడుస్తున్న స్థితి నుండి తొలగించాలనే ఉద్దేశ్యంతో తాత్కాలికంగా అంతరాయం కలిగించే చర్య.

4. కాంటెక్స్ట్ స్విచింగ్: ప్రాధాన్యత-ఆధారిత ప్రీమిప్షన్‌లో, షెడ్యూలర్ ప్రతి సిస్టిక్ అంతరాయంలో రెడీ టాస్క్ జాబితా యొక్క ప్రాధాన్యతతో పనులను అమలు చేసే ప్రాధాన్యతను పోల్చాడు. జాబితాలో ఏదైనా పని ఉంటే, దాని పని కంటే ఎక్కువ ప్రాధాన్యత ఉంటే కాంటెక్స్ట్ స్విచ్ జరుగుతుంది. సాధారణంగా, ఈ ప్రక్రియలో వేర్వేరు పనుల విషయాలు వాటి స్టాక్ మెమరీలో సేవ్ చేయబడతాయి.

5. షెడ్యూలింగ్ విధానాల రకాలు:

1. ప్రీమెప్టివ్ షెడ్యూలింగ్: ఈ రకమైన షెడ్యూలింగ్‌లో, పనులు ప్రాధాన్యతలను పరిగణనలోకి తీసుకోకుండా సమాన సమయ స్లైస్‌తో నడుస్తాయి.
2. ప్రాధాన్యత-ఆధారిత ప్రీమిటివ్: అధిక ప్రాధాన్యత కలిగిన పని మొదట నడుస్తుంది.
3. సహకార షెడ్యూలింగ్: నడుస్తున్న పనుల సహకారంతో మాత్రమే సందర్భ మార్పిడి జరుగుతుంది. టాస్క్ దిగుబడిని పిలిచే వరకు టాస్క్ నిరంతరం నడుస్తుంది.

6. కెర్నల్ ఆబ్జెక్ట్స్: కొంత పనిని నిర్వహించడానికి సిగ్నలింగ్ కోసం, సమకాలీకరణ ప్రక్రియ ఉపయోగించబడుతుంది. ఈ ప్రక్రియను నిర్వహించడానికి కెర్నల్ వస్తువులు ఉపయోగించబడతాయి. కొన్ని కెర్నల్ వస్తువులు ఈవెంట్స్, సెమాఫోర్స్, క్యూస్, మ్యూటెక్స్, మెయిల్‌బాక్స్‌లు మొదలైనవి. రాబోయే ట్యుటోరియల్‌లలో ఈ వస్తువులను ఎలా ఉపయోగించాలో చూద్దాం.

పై చర్చ నుండి, మాకు RTOS భావన గురించి కొన్ని ప్రాథమిక ఆలోచనలు వచ్చాయి మరియు ఇప్పుడు మేము Arduino లో FreeRTOS ప్రాజెక్ట్ను అమలు చేయవచ్చు. కాబట్టి, Arduino IDE లో FreeRTOS లైబ్రరీలను ఇన్‌స్టాల్ చేయడం ద్వారా ప్రారంభిద్దాం.

Arduino FreeRTOS లైబ్రరీని ఇన్‌స్టాల్ చేస్తోంది

1. Arduino IDE తెరిచి స్కెచ్ -> లైబ్రరీని చేర్చండి -> లైబ్రరీలను నిర్వహించండి . FreeRTOS కోసం శోధించండి మరియు క్రింద చూపిన విధంగా లైబ్రరీని ఇన్‌స్టాల్ చేయండి.

మీరు లైబ్రరీని గితుబ్ నుండి డౌన్‌లోడ్ చేసుకోవచ్చు మరియు.zip ఫైల్‌ను స్కెచ్-> లైబ్రరీని చేర్చండి ->.zip ఫైల్‌ను జోడించండి .

ఇప్పుడు, Arduino IDE ని పున art ప్రారంభించండి. ఈ లైబ్రరీ కొన్ని ఉదాహరణ కోడ్‌ను అందిస్తుంది, అది క్రింద చూపిన విధంగా ఫైల్ -> ఉదాహరణలు -> FreeRTOS లో కూడా చూడవచ్చు.

పనిని అర్థం చేసుకోవడానికి ఇక్కడ మేము మొదటి నుండి కోడ్ వ్రాస్తాము, తరువాత మీరు ఉదాహరణ కోడ్‌లను తనిఖీ చేసి వాటిని ఉపయోగించవచ్చు.

సర్క్యూట్ రేఖాచిత్రం

Arduino లో FreeRTOS ను ఉపయోగించి మెరిసే LED పనిని సృష్టించడానికి సర్క్యూట్ రేఖాచిత్రం క్రింద ఉంది:

Arduino FreeRTOS ఉదాహరణ- Arduino IDE లో FreeRTOS పనులను సృష్టించడం

FreeRTOS ప్రాజెక్ట్ రాయడానికి ప్రాథమిక నిర్మాణాన్ని చూద్దాం.

1. మొదట, Arduino FreeRTOS హెడర్ ఫైల్‌ను ఇలా చేర్చండి

# చేర్చండి

2. అమలు కోసం మీరు వ్రాస్తున్న అన్ని ఫంక్షన్ల యొక్క ఫంక్షన్ ప్రోటోటైప్ ఇవ్వండి

శూన్యమైన టాస్క్ 1 (శూన్యమైన * పివిపారామీటర్లు); శూన్యమైన టాస్క్ 2 (శూన్యమైన * పివిపారామీటర్లు); .. ….

3. ఇప్పుడు, శూన్య సెటప్ () ఫంక్షన్‌లో, టాస్క్‌లను సృష్టించండి మరియు టాస్క్ షెడ్యూలర్‌ను ప్రారంభించండి.

విధిని సృష్టించడానికి, xTaskCreate () API ని కొన్ని పారామితులు / వాదనలతో సెటప్ ఫంక్షన్‌లో పిలుస్తారు.

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

ఏదైనా పనిని సృష్టించేటప్పుడు 6 వాదనలు ఉన్నాయి. ఈ వాదనలు ఏమిటో చూద్దాం

1. pvTaskCode: ఇది విధిని అమలు చేసే ఫంక్షన్‌కు ఒక పాయింటర్ (ప్రభావంలో, ఫంక్షన్ పేరు మాత్రమే).
2. pcName: విధికి వివరణాత్మక పేరు. దీన్ని FreeRTOS ఉపయోగించదు. ఇది డీబగ్గింగ్ ప్రయోజనాల కోసం పూర్తిగా చేర్చబడింది.
3. usStackDepth: ప్రతి పనికి దాని స్వంత ప్రత్యేకమైన స్టాక్ ఉంది, అది విధిని సృష్టించినప్పుడు కెర్నల్ చేత కేటాయించబడుతుంది. విలువ స్టాక్ పట్టుకోగల పదాల సంఖ్యను నిర్దేశిస్తుంది, బైట్ల సంఖ్య కాదు. ఉదాహరణకు, స్టాక్ 32-బిట్స్ వెడల్పు మరియు usStackDepth 100 గా దాటితే, అప్పుడు 400 బైట్ల స్టాక్ స్థలం RAM లో కేటాయించబడుతుంది (100 * 4 బైట్లు). Arduino Uno కి 2Kbytes RAM మాత్రమే ఉన్నందున దీన్ని తెలివిగా వాడండి.
4. pvParameters: టాస్క్ ఇన్పుట్ పరామితి (NULL కావచ్చు).
5. uxPriority: పని యొక్క ప్రాధాన్యత (0 అతి తక్కువ ప్రాధాన్యత).
6. pxCreatedTask: సృష్టించబడుతున్న పనికి హ్యాండిల్ ఇవ్వడానికి ఇది ఉపయోగపడుతుంది. ఈ హ్యాండిల్‌ను API కాల్‌లలో టాస్క్‌ను సూచించడానికి ఉపయోగించవచ్చు, ఉదాహరణకు, టాస్క్ ప్రాధాన్యతను మార్చండి లేదా టాస్క్‌ను తొలగించండి (NULL కావచ్చు).

పని సృష్టి యొక్క ఉదాహరణ

x టాస్క్‌క్రియేట్ (టాస్క్ 1, "టాస్క్ 1", 128, ఎన్‌యుఎల్ఎల్, 1, ఎన్‌యుఎల్ఎల్); x టాస్క్‌క్రియేట్ (టాస్క్ 2, "టాస్క్ 2", 128, ఎన్‌యుఎల్ఎల్, 2, ఎన్‌యుఎల్ఎల్);

ఇక్కడ, టాస్క్ 2 కి అధిక ప్రాధాన్యత ఉంది మరియు అందువల్ల మొదట అమలు చేస్తుంది.

4. విధిని సృష్టించిన తరువాత, vTaskStartScheduler () ను ఉపయోగించి శూన్యమైన సెటప్‌లో షెడ్యూలర్‌ను ప్రారంభించండి ; API.

5. శూన్య లూప్ () ఫంక్షన్ ఖాళీగా ఉంటుంది, ఎందుకంటే మనం ఏ పనిని మానవీయంగా మరియు అనంతంగా అమలు చేయకూడదనుకుంటున్నాము. ఎందుకంటే టాస్క్ ఎగ్జిక్యూషన్ ఇప్పుడు షెడ్యూలర్ చేత నిర్వహించబడుతుంది.

6. ఇప్పుడు, మేము టాస్క్ ఫంక్షన్లను అమలు చేయాలి మరియు మీరు ఈ ఫంక్షన్లలో అమలు చేయాలనుకుంటున్న తర్కాన్ని వ్రాయాలి. ఫంక్షన్ పేరు xTaskCreate () API యొక్క మొదటి వాదన వలె ఉండాలి.

void task1 (void * pvParameters) { ఉండగా (1) { .. ..// మీ తర్కం } }

7. నడుస్తున్న పనిని ఆపడానికి చాలా కోడ్‌కు ఆలస్యం ఫంక్షన్ అవసరం, అయితే RTOS లో ఇది CPU ని ఆపివేస్తున్నందున ఆలస్యం () ఫంక్షన్‌ను ఉపయోగించమని సూచించబడలేదు మరియు అందువల్ల RTOS కూడా పనిచేయడం ఆపివేస్తుంది. కాబట్టి ఒక నిర్దిష్ట సమయం కోసం పనిని నిరోధించడానికి FreeRTOS కు కెర్నల్ API ఉంది.

vTaskDelay (const TickType_t xTicksToDelay);

ఈ API ఆలస్యం ప్రయోజనాల కోసం ఉపయోగించవచ్చు. ఈ API ఇచ్చిన సంఖ్యలో పేలుల కోసం పనిని ఆలస్యం చేస్తుంది. పని నిరోధించబడిన వాస్తవ సమయం టిక్ రేటుపై ఆధారపడి ఉంటుంది. టిక్ రేట్ నుండి నిజ సమయాన్ని లెక్కించడానికి స్థిరమైన portTICK_PERIOD_MS ను ఉపయోగించవచ్చు.

దీని అర్థం మీకు 200ms ఆలస్యం కావాలంటే, ఈ పంక్తిని వ్రాయండి

vTaskDelay (200 / portTICK_PERIOD_MS);

కాబట్టి ఈ ట్యుటోరియల్ కోసం, మేము మూడు పనులను అమలు చేయడానికి ఈ FreeRTOS API లను ఉపయోగిస్తాము.

ఉపయోగించాల్సిన API లు:

1. x టాస్క్ క్రియేట్ ();
2. vTaskStartScheduler ();
3. vTaskDelay ();

ఈ ట్యుటోరియల్ కోసం సృష్టించాల్సిన పని:

1. 200ms ఫ్రీక్వెన్సీతో డిజిటల్ పిన్ 8 వద్ద LED బ్లింక్
2. 300ms ఫ్రీక్వెన్సీతో డిజిటల్ పిన్ 7 వద్ద LED బ్లింక్
3. 500ms ఫ్రీక్వెన్సీతో సీరియల్ మానిటర్‌లో సంఖ్యలను ముద్రించండి.

Arduino IDE లో FreeRTOS టాస్క్ అమలు

1. పై ప్రాథమిక నిర్మాణ వివరణ నుండి, Arduino FreeRTOS హెడర్ ఫైల్‌ను చేర్చండి. అప్పుడు ఫంక్షన్ ప్రోటోటైప్‌లను చేయండి. మనకు మూడు పనులు ఉన్నందున, మూడు విధులు చేయండి మరియు ఇది ప్రోటోటైప్స్.

# శూన్యమైన టాస్క్‌బ్లింక్ 1 (శూన్యమైన * పివిపారామీటర్లు); టాస్క్బ్లింక్ 2 (శూన్యమైన * పివిపారామీటర్లు); శూన్య టాస్క్‌ప్రింట్ (శూన్యమైన * పివిపారామీటర్లు);

2. శూన్య సెటప్ () ఫంక్షన్‌లో, సెకనుకు 9600 బిట్స్ వద్ద సీరియల్ కమ్యూనికేషన్‌ను ప్రారంభించండి మరియు xTaskCreate () API ని ఉపయోగించి మూడు పనులను సృష్టించండి. ప్రారంభంలో, అన్ని పనుల యొక్క ప్రాధాన్యతలను '1' గా చేసి, షెడ్యూలర్‌ను ప్రారంభించండి.

శూన్య సెటప్ () { Serial.begin (9600); x టాస్క్‌క్రియేట్ (టాస్క్‌బ్లింక్ 1, "టాస్క్ 1", 128, ఎన్‌యుఎల్ఎల్, 1, ఎన్‌యుఎల్ఎల్); x టాస్క్‌క్రియేట్ (టాస్క్‌బ్లింక్ 2, "టాస్క్ 2", 128, ఎన్‌యుఎల్ఎల్, 1, ఎన్‌యుఎల్ఎల్); x టాస్క్‌క్రియేట్ (టాస్క్‌ప్రింట్, "టాస్క్ 3", 128, ఎన్‌యుఎల్ఎల్, 1, ఎన్‌యుఎల్ఎల్); vTaskStartScheduler (); }

3. ఇప్పుడు, టాస్క్ 1 ఎల్ఇడి బ్లింక్ కోసం క్రింద చూపిన విధంగా మూడు ఫంక్షన్లను అమలు చేయండి.

టాస్క్బ్లింక్ 1 (శూన్యమైన * పివిపారామీటర్లు) { పిన్ మోడ్ (8, U ట్పుట్); (1) { డిజిటల్ రైట్ (8, హై); vTaskDelay (200 / portTICK_PERIOD_MS); డిజిటల్ రైట్ (8, తక్కువ); vTaskDelay (200 / portTICK_PERIOD_MS); } }

అదేవిధంగా, టాస్క్‌బ్లింక్ 2 ఫంక్షన్‌ను అమలు చేయండి. టాస్క్ 3 ఫంక్షన్ ఇలా వ్రాయబడుతుంది

శూన్య టాస్క్‌ప్రింట్ (శూన్యమైన * పివిపారామీటర్లు) { int కౌంటర్ = 0; (1) { కౌంటర్ ++; సీరియల్.ప్రింట్ల్న్ (కౌంటర్); vTaskDelay (500 / portTICK_PERIOD_MS); } }

అంతే. Arduino Uno కోసం FreeRTOS Arduino ప్రాజెక్ట్‌ను విజయవంతంగా పూర్తి చేసాము. ఈ ట్యుటోరియల్ చివరిలో మీరు వీడియోతో పాటు పూర్తి కోడ్‌ను కనుగొనవచ్చు.

చివరగా, డిజిటల్ పిన్ 7 మరియు 8 వద్ద రెండు ఎల్‌ఇడిలను కనెక్ట్ చేసి, మీ ఆర్డునో బోర్డులో కోడ్‌ను అప్‌లోడ్ చేసి సీరియల్ మానిటర్‌ను తెరవండి. క్రింద చూపిన విధంగా టాస్క్ పేరుతో 500 మీటర్లకు ఒకసారి కౌంటర్ నడుస్తున్నట్లు మీరు చూస్తారు.

అలాగే, LED లను గమనించండి, అవి వేర్వేరు సమయ వ్యవధిలో మెరిసిపోతున్నాయి. XTaskCreate ఫంక్షన్‌లో ప్రాధాన్యతా వాదనతో ఆడటానికి ప్రయత్నించండి. సంఖ్యను మార్చండి మరియు సీరియల్ మానిటర్ మరియు LED లలో ప్రవర్తనను గమనించండి.

ఇప్పుడు, అనలాగ్ రీడ్ మరియు డిజిటల్ రీడ్ టాస్క్‌లు సృష్టించబడిన మొదటి రెండు ఉదాహరణ కోడ్‌లను మీరు అర్థం చేసుకోవచ్చు. ఈ విధంగా, మీరు కేవలం Arduino Uno మరియు FreeRTOS API లను ఉపయోగించి మరింత ముందస్తు ప్రాజెక్టులను చేయవచ్చు.