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

మునుపటి ట్యుటోరియల్‌లో, మేము ఆర్డునో యునోలో ఫ్రీఆర్‌టిఒఎస్‌ను పరిచయం చేసాము మరియు మెరిసే ఎల్‌ఇడి కోసం ఒక పనిని సృష్టించాము. ఇప్పుడు, ఈ ట్యుటోరియల్‌లో, మేము RTOS API ల యొక్క ముందస్తు భావనలలోకి ప్రవేశిస్తాము మరియు విభిన్న పనుల మధ్య కమ్యూనికేషన్ గురించి తెలుసుకుంటాము. ఇక్కడ మేము ఒక పని నుండి మరొక పనికి డేటాను బదిలీ చేయడానికి క్యూ గురించి తెలుసుకుంటాము మరియు 16x2 LCD మరియు LDR లను Arduino Uno తో ఇంటర్‌ఫేస్ చేయడం ద్వారా క్యూ API ల యొక్క పనిని ప్రదర్శిస్తాము.

క్యూల గురించి చర్చించే ముందు, కేటాయించిన పనితో పనులు పూర్తయినప్పుడు దాన్ని తొలగించడంలో సహాయపడే మరో FreeRTOS API ని చూద్దాం. కేటాయించిన మెమరీని ఖాళీ చేయడానికి కొన్నిసార్లు పనిని తొలగించాల్సిన అవసరం ఉంది. మునుపటి ట్యుటోరియల్ యొక్క కొనసాగింపుగా, మేము ఒక కోడ్‌ను తొలగించడానికి అదే కోడ్‌లో vTaskDelete () API ఫంక్షన్‌ను ఉపయోగిస్తాము. ఒక పని తనను తాను తొలగించడానికి vTaskDelete () API ఫంక్షన్‌ను లేదా ఏదైనా ఇతర పనిని ఉపయోగించవచ్చు.

ఈ API ని ఉపయోగించడానికి, మీరు FreeRTOSConfig.h ఫైల్‌ను కాన్ఫిగర్ చేయాలి. అప్లికేషన్ ప్రకారం FreeRTOS కు అనుగుణంగా ఈ ఫైల్ ఉపయోగించబడుతుంది. షెడ్యూలింగ్ అల్గోరిథంలు మరియు అనేక ఇతర పారామితులను మార్చడానికి ఇది ఉపయోగించబడుతుంది. మీ PC యొక్క డాక్యుమెంట్స్ ఫోల్డర్‌లో సాధారణంగా లభించే Arduino డైరెక్టరీలో ఫైల్‌ను చూడవచ్చు. నా విషయంలో, ఇది క్రింద చూపిన విధంగా \ పత్రాలు \ Arduino \ లైబ్రరీలలో \ FreeRTOS \ src లో లభిస్తుంది .

ఇప్పుడు, ఏదైనా టెక్స్ట్ ఎడిటర్ ఉపయోగించి ఈ ఫైల్‌ను తెరిచి , # INCLUDE_vTaskDelete ని నిర్వచించండి మరియు దాని విలువ '1' అని నిర్ధారించుకోండి (1 అంటే ఎనేబుల్ మరియు 0 అంటే డిసేబుల్). ఇది అప్రమేయంగా 1 అయితే దాని కోసం తనిఖీ చేస్తుంది.

పారామితులను సెట్ చేయడానికి మేము మా తదుపరి ట్యుటోరియల్లో ఈ కాన్ఫిగర్ ఫైల్‌ను తరచుగా ఉపయోగిస్తాము.

ఇప్పుడు, ఒక పనిని ఎలా తొలగించాలో చూద్దాం.

FreeRTOS Arduino లో టాస్క్‌ను తొలగిస్తోంది

ఒక పనిని తొలగించడానికి, మేము vTaskDelete () API ఫంక్షన్‌ను ఉపయోగించాలి. ఇది ఒక వాదన మాత్రమే తీసుకుంటుంది.

vTaskDelete (TaskHandle_t pxTaskToDelete);

pxTaskToDelete: ఇది తొలగించాల్సిన పని యొక్క హ్యాండిల్. ఇది xTaskCreate () API యొక్క 6 ^వ వాదనకు సమానం . మునుపటి ట్యుటోరియల్‌లో, ఈ వాదన NULL గా సెట్ చేయబడింది, అయితే మీరు ఏదైనా పేరును ఉపయోగించడం ద్వారా టాస్క్ యొక్క విషయాల చిరునామాను పంపవచ్చు. టాస్క్ 2 కోసం టాస్క్ హ్యాండిల్‌ను సెట్ చేయాలనుకుంటే చెప్పండి

TaskHandle_t any_name; ఉదాహరణ: TaskHandle_t xTask2Handle;

ఇప్పుడు, vTaskCreate () API లో 6 ^వ వాదనను ఇలా సెట్ చేయండి

xTaskCreate (TaskBlink2, "task2", 128, NULL, 1, & xTask2Handle);

మీరు ఇచ్చిన హ్యాండిల్‌ని ఉపయోగించి ఈ పని యొక్క కంటెంట్‌ను ఇప్పుడు యాక్సెస్ చేయవచ్చు.

అలాగే, చెల్లుబాటు అయ్యే టాస్క్ హ్యాండిల్ స్థానంలో NULL ను పాస్ చేయడం ద్వారా ఒక పని తనను తాను తొలగించగలదు.

మేము టాస్క్ 3 ను టాస్క్ 3 నుండి తొలగించాలనుకుంటే, మీరు vTaskDelete (NULL) ను వ్రాయాలి ; టాస్క్ 3 ఫంక్షన్ లోపల కానీ మీరు టాస్క్ 3 నుండి టాస్క్ 3 ను తొలగించాలనుకుంటే, అప్పుడు vTaskDelete (xTask3Handle) వ్రాయండి ; టాస్క్ 2 ఫంక్షన్ లోపల.

మునుపటి ట్యుటోరియల్ కోడ్‌లో, టాస్క్ 2 ను టాస్క్ 2 నుండి తొలగించడానికి, కేవలం vTaskDelete (NULL) ను జోడించండి ; లో గర్జన TaskBlink2 (శూన్యమైన * pvParameters) ఫంక్షన్. అప్పుడు పై ఫంక్షన్ ఇలా ఉంటుంది

టాస్క్బ్లింక్ 2 (శూన్యమైన * పివిపారామీటర్లు) { సీరియల్.ప్రింట్ల్న్ (“టాస్క్ 2 రన్ అవుతోంది మరియు తొలగించబోతోంది”); vTaskDelete (NULL); పిన్ మోడ్ (7, U ట్పుట్); (1) { డిజిటల్ రైట్ (7, హై); vTaskDelay (300 / portTICK_PERIOD_MS); digitalWrite (7, LOW); vTaskDelay (300 / portTICK_PERIOD_MS); } }

ఇప్పుడు, కోడ్‌ను అప్‌లోడ్ చేసి, LED లు మరియు సీరియల్ మానిటర్‌ను గమనించండి. రెండవ LED ఇప్పుడు మెరిసేది కాదని మీరు చూస్తారు మరియు తొలగింపు API ని ఎదుర్కొన్న తర్వాత టాస్క్ 2 తొలగించబడుతుంది.

కాబట్టి నిర్దిష్ట పనిని అమలు చేయడాన్ని ఆపడానికి ఈ API ని ఉపయోగించవచ్చు.

ఇప్పుడు, క్యూతో ప్రారంభిద్దాం.

FreeRTOS లో క్యూ అంటే ఏమిటి?

క్యూ అనేది పరిమిత సంఖ్యలో స్థిర పరిమాణ మూలకాలను కలిగి ఉండే డేటా నిర్మాణం మరియు ఇది FIFO పథకంలో నిర్వహించబడుతుంది (ఫస్ట్-ఇన్ ఫస్ట్-అవుట్). క్యూలు టాస్క్-టు-టాస్క్, టాస్క్-టు-ఇంటరప్ట్ మరియు ఇంటరప్ట్-టు-టాస్క్ కమ్యూనికేషన్ మెకానిజమ్‌ను అందిస్తాయి.

క్యూలో ఉంచగల గరిష్ట సంఖ్యల మూలకాలను దాని “పొడవు” అంటారు. క్యూ సృష్టించినప్పుడు ప్రతి మూలకం యొక్క పొడవు మరియు పరిమాణం రెండూ సెట్ చేయబడతాయి.

డేటా బదిలీ కోసం క్యూ ఎలా ఉపయోగించబడుతుందనేదానికి ఉదాహరణ ఇక్కడ లభించే FreeRTOS డాక్యుమెంటేషన్‌లో బాగా వివరించబడింది. ఇచ్చిన ఉదాహరణను మీరు సులభంగా అర్థం చేసుకోవచ్చు.

క్యూలను అర్థం చేసుకున్న తరువాత, క్యూను సృష్టించే విధానాన్ని అర్థం చేసుకోవడానికి ప్రయత్నిద్దాం మరియు దానిని మా FreeRTOS కోడ్‌లో అమలు చేయడానికి ప్రయత్నిద్దాం.

FreeRTOS లో క్యూ సృష్టిస్తోంది

మొదట, FreeRTOS క్యూ మరియు Arduino Uno సహాయంతో అమలు చేయాల్సిన సమస్య ప్రకటనను వివరించండి.

మేము LDR సెన్సార్ విలువను 16 * 2 LCD లో ప్రింట్ చేయాలనుకుంటున్నాము. కాబట్టి ఇప్పుడు రెండు పనులు ఉన్నాయి

1. టాస్క్ 1 LDR యొక్క అనలాగ్ విలువలను పొందుతోంది.
2. టాస్క్ 2 ఎల్‌సిడిలో అనలాగ్ విలువను ప్రింట్ చేస్తోంది.

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

క్యూలతో పనిచేయడానికి మూడు విధులు ఉన్నాయి

1. క్యూ సృష్టిస్తోంది
2. డేటాను క్యూకు పంపుతోంది
3. క్యూ నుండి డేటాను స్వీకరిస్తోంది

1. క్యూ సృష్టించడం

క్యూ సృష్టించడానికి, xQueueCreate () ఫంక్షన్ API ని ఉపయోగించండి. దీనికి రెండు వాదనలు పడుతుంది.

xQueueCreate (UBaseType_t uxQueueLength, UBaseType_t uxItemSize);

uxQueueLength: క్యూ సృష్టించబడుతున్న గరిష్ట సంఖ్యలు ఏ సమయంలోనైనా కలిగి ఉంటాయి.

uxItemSize: క్యూలో నిల్వ చేయగల ప్రతి డేటా ఐటెమ్ యొక్క బైట్ల పరిమాణం.

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

క్యూహ్యాండిల్_టి క్యూ 1; queue1 = xQueueCreate (4, sizeof (int));

ఇది పూర్ణాంక పరిమాణం యొక్క కుప్ప మెమరీలో 4 మూలకాల క్యూను సృష్టిస్తుంది (ప్రతి బ్లాక్ యొక్క 2 బైట్లు) మరియు తిరిగి వచ్చే విలువను క్యూ 1 హ్యాండిల్ వేరియబుల్‌కు నిల్వ చేస్తుంది.

2. FreeRTOS లో క్యూకు డేటాను పంపడం

విలువలను క్యూకు పంపడానికి, FreeRTOS ఈ ప్రయోజనం కోసం API యొక్క 2 వేరియంట్‌లను కలిగి ఉంది.

1. xQueueSendToBack (): క్యూ వెనుక (తోక) కు డేటాను పంపడానికి ఉపయోగిస్తారు.
2. xQueueSendToFront (): క్యూ ముందు (తల) కు డేటాను పంపడానికి ఉపయోగిస్తారు.

ఇప్పుడు , xQueueSend () xQueueSendToBack () కు సమానం మరియు సరిగ్గా సమానం .

ఈ API లన్నీ 3 వాదనలు తీసుకుంటాయి.

xQueueSendToBack (QueueHandle_t xQueue, const void * pvItemToQueue, TickType_t xTicksToWait);

xQueue: డేటా పంపబడుతున్న క్యూ యొక్క హ్యాండిల్ (వ్రాయబడింది). ఈ వేరియబుల్ xQueueCreate API యొక్క తిరిగి విలువను నిల్వ చేయడానికి ఉపయోగించినది.

pvItemToQueue: క్యూలో కాపీ చేయవలసిన డేటాకు పాయింటర్.

xTicksToWait: క్యూలో స్థలం అందుబాటులోకి వచ్చే వరకు వేచి ఉండటానికి పని బ్లాక్ చేయబడిన స్థితిలో ఉండాలి.

చేస్తోంది xTicksToWait వరకు portMAX_DELAY పని (అవుట్ టైమింగ్ లేకుండా) నిరవధికంగా వేచి కారణం అవుతుంది, అందించిన INCLUDE_vTaskSuspend 1 కు సెట్ FreeRTOSConfig.h else మీరు స్థూల ఉపయోగించవచ్చు () pdMS_TO_TICKS పేలు పేర్కొన్న సమయంలోకి మిల్లీసెకన్లలో పేర్కొనాలి ఒక సమయం మార్చేందుకు.

3. FreeRTOS లో క్యూ నుండి డేటాను స్వీకరించడం

క్యూ నుండి ఒక అంశాన్ని స్వీకరించడానికి (చదవడానికి), xQueueReceive () ఉపయోగించబడుతుంది. అందుకున్న అంశం క్యూ నుండి తీసివేయబడుతుంది.

ఈ API మూడు వాదనలు కూడా తీసుకుంటుంది.

xQueueReceive (QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait);

మొదటి మరియు మూడవ వాదనలు API పంపినట్లే. రెండవ వాదన మాత్రమే భిన్నంగా ఉంటుంది.

const pvBuffer: అందుకున్న డేటా కాపీ చేయబడే మెమరీకి పాయింటర్.

మీరు మూడు API లను అర్థం చేసుకున్నారని ఆశిస్తున్నాము. ఇప్పుడు, మేము ఈ API లను Arduino IDE లో అమలు చేస్తాము మరియు మేము పైన వివరించిన సమస్య ప్రకటనను పరిష్కరించడానికి ప్రయత్నిస్తాము.

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

ఇది బ్రెడ్‌బోర్డ్‌లో కనిపిస్తుంది:

Arduino IDE లో FreeRTOS క్యూను అమలు చేస్తోంది

మా అప్లికేషన్ కోసం కోడ్ రాయడం ప్రారంభిద్దాం.

1. మొదట, Arduino IDE ని తెరిచి, Arduino_FreeRTOS.h హెడర్ ఫైల్‌ను చేర్చండి. ఇప్పుడు, క్యూ వంటి ఏదైనా కెర్నల్ ఆబ్జెక్ట్ ఉపయోగించినట్లయితే, దాని హెడర్ ఫైల్ను చేర్చండి. మేము 16 * 2 LCD ని ఉపయోగిస్తున్నందున దాని కోసం లైబ్రరీని కూడా చేర్చండి.

# చేర్చండి # చేర్చండి # చేర్చండి

2. క్యూలోని విషయాలను నిల్వ చేయడానికి క్యూ హ్యాండిల్‌ను ప్రారంభించండి. అలాగే, ఎల్‌సిడి పిన్ నంబర్లను ప్రారంభించండి.

క్యూహ్యాండిల్_టి క్యూ_1; లిక్విడ్ క్రిస్టల్ ఎల్సిడి (7, 8, 9, 10, 11, 12);

3. శూన్య సెటప్ () లో, 9600 బాడ్ రేట్‌తో LCD మరియు సీరియల్ మానిటర్‌ను ప్రారంభించండి. సంబంధిత API లను ఉపయోగించి క్యూ మరియు రెండు పనులను సృష్టించండి. ఇక్కడ మనం పూర్ణాంక రకంతో పరిమాణం 4 యొక్క క్యూను సృష్టిస్తాము. సమాన ప్రాధాన్యతలతో ఒక పనిని సృష్టించండి మరియు తరువాత ఈ సంఖ్యతో ఆడటానికి ప్రయత్నించండి. చివరగా, క్రింద చూపిన విధంగా షెడ్యూలర్‌ను ప్రారంభించండి.

శూన్య సెటప్ () { Serial.begin (9600); lcd.begin (16, 2); queue_1 = xQueueCreate (4, sizeof (int)); if (queue_1 == NULL) { Serial.println ("క్యూ సృష్టించబడదు"); } x టాస్క్‌క్రియేట్ (టాస్క్‌డిస్ప్లే, "డిస్ప్లే_టాస్క్", 128, ఎన్‌యుఎల్ఎల్, 1, ఎన్‌యుఎల్ఎల్); x టాస్క్‌క్రియేట్ (టాస్క్‌ఎల్‌డిఆర్, "ఎల్‌డిఆర్_టాస్క్", 128, ఎన్‌యుఎల్ఎల్, 1, ఎన్‌యుఎల్ఎల్); vTaskStartScheduler (); }

4. ఇప్పుడు, టాస్క్డిస్ప్లే మరియు టాస్క్ఎల్డిఆర్ అనే రెండు ఫంక్షన్లను చేయండి . లో TaskLDR ఫంక్షన్, మేము LDR Arduino UNO యొక్క A0 పిన్ కనెక్ట్ చేసి ఒక వేరియబుల్ అనలాగ్ పిన్ A0 చదవండి. ఇప్పుడు వేరియబుల్‌లో నిల్వ చేసిన విలువను xQueueSend API లో పంపించడం ద్వారా పంపండి మరియు క్రింద చూపిన విధంగా vTaskDelay () API ని ఉపయోగించి 1 సెకను తర్వాత స్థితిని నిరోధించే పనిని పంపండి.

శూన్యమైన టాస్క్‌ఎల్‌డిఆర్ (శూన్యమైన * పివిపారామీటర్లు) { int ప్రస్తుత_ఇన్సెన్సిటీ; అయితే (1) { Serial.println ("టాస్క్ 1"); current_intensive = అనలాగ్ రీడ్ (A0); సీరియల్.ప్రింట్ల్న్ (ప్రస్తుత_ఇన్సెన్సిటీ); xQueueSend (క్యూ_1, & ప్రస్తుత_ఇన్సెన్సిటీ, పోర్ట్ MAX_DELAY); vTaskDelay (1000 / portTICK_PERIOD_MS); } }

5. అదేవిధంగా, ఒక ఫంక్షన్ చేయడానికి TaskDisplay మరియు ఆమోదించింది అని ఒక వేరియబుల్ విలువలు స్వీకరించేందుకు xQueueReceive ఫంక్షన్. అలాగే, క్యూ నుండి డేటాను విజయవంతంగా స్వీకరించగలిగితే xQueueReceive () pdPASS ను తిరిగి ఇస్తుంది మరియు క్యూ ఖాళీగా ఉంటే errQUEUE_EMPTY ని అందిస్తుంది .

ఇప్పుడు, lcd.print () ఫంక్షన్‌ను ఉపయోగించి విలువలను LCD కి ప్రదర్శించండి.

శూన్యమైన టాస్క్‌డిస్ప్లే (శూన్యమైన * పివిపారామీటర్లు) { పూర్ణాంక తీవ్రత = 0; అయితే (1) { Serial.println ("టాస్క్ 2"); if (xQueueReceive (క్యూ_1, & తీవ్రత, portMAX_DELAY) == pdPASS) { lcd.clear (); lcd.setCursor (0, 0); lcd.print ("తీవ్రత:"); lcd.setCursor (11, 0); lcd.print (తీవ్రత); } } }

అంతే. మేము క్యూ అమలులో కోడింగ్ భాగాన్ని పూర్తి చేసాము. పని చేసే వీడియోతో పూర్తి కోడ్ చివరిలో చూడవచ్చు.

ఇప్పుడు, సర్క్యూట్ రేఖాచిత్రం ప్రకారం ఎల్‌సిడి మరియు ఎల్‌డిఆర్‌ను ఆర్డునో యుఎన్‌ఓతో కనెక్ట్ చేయండి. సీరియల్ మానిటర్ తెరిచి పనులను గమనించండి. పనులు మారడం మరియు కాంతి తీవ్రతకు అనుగుణంగా LDR విలువలు మారుతున్నట్లు మీరు చూస్తారు.

గమనిక: లైబ్రరీలలో ఫంక్షన్ అమలు ఆలస్యం కారణంగా వేర్వేరు సెన్సార్ల కోసం తయారు చేయబడిన చాలా లైబ్రరీలకు ఫ్రీఆర్టిఓఎస్ కెర్నల్ మద్దతు ఇవ్వదు. ఆలస్యం CPU ని పూర్తిగా ఆపివేస్తుంది, కాబట్టి, FreeRTOS కెర్నల్ కూడా పనిచేయడం ఆపివేస్తుంది మరియు కోడ్ మరింత అమలు చేయదు మరియు ఇది తప్పుగా ప్రవర్తించడం ప్రారంభిస్తుంది. కాబట్టి, మేము లైబ్రరీలను ఫ్రీఆర్టోస్‌తో పనిచేయడానికి ఆలస్యం చేయవలసి ఉంటుంది.