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

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

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

సెమాఫోర్ అంటే ఏమిటి?

మునుపటి ట్యుటోరియల్లో, మేము టాస్క్ ప్రాధాన్యతల గురించి చర్చించాము మరియు అధిక ప్రాధాన్యత కలిగిన పని తక్కువ ప్రాధాన్యతనిచ్చే పనిని ముందస్తుగా తెలుసుకుంటుందని తెలుసుకోండి, కాబట్టి అధిక ప్రాధాన్యత కలిగిన పనిని అమలు చేసేటప్పుడు తక్కువ ప్రాధాన్యత కలిగిన పనిలో డేటా అవినీతి జరిగే అవకాశం ఉంది ఎందుకంటే ఇది ఇంకా అమలు కాలేదు మరియు మొత్తం అప్లికేషన్ యొక్క డేటా నష్టం మరియు పనిచేయకపోవటానికి కారణమయ్యే సెన్సార్ నుండి డేటా ఈ పనికి నిరంతరం వస్తోంది.

కాబట్టి, డేటా నష్టం నుండి వనరులను రక్షించాల్సిన అవసరం ఉంది మరియు ఇక్కడ సెమాఫోర్ ఒక ముఖ్యమైన పాత్ర పోషిస్తుంది.

సెమాఫోర్ ఒక సిగ్నలింగ్ విధానం, దీనిలో వేచి ఉన్న స్థితిలో ఉన్న పని అమలు కోసం మరొక పని ద్వారా సూచించబడుతుంది. మరో మాటలో చెప్పాలంటే, ఒక టాస్క్ 1 తన పనిని పూర్తి చేసినప్పుడు, అది ఒక జెండాను చూపుతుంది లేదా ఒక జెండాను 1 ద్వారా పెంచుతుంది, ఆపై ఈ జెండాను మరొక పని (టాస్క్ 2) అందుకుంటుంది, అది ఇప్పుడు తన పనిని చేయగలదని చూపిస్తుంది. టాస్క్ 2 దాని పనిని పూర్తి చేసినప్పుడు జెండా 1 తగ్గుతుంది.

కాబట్టి, ప్రాథమికంగా, ఇది “ఇవ్వండి” మరియు “టేక్” విధానం మరియు సెమాఫోర్ అనేది పూర్ణాంక వేరియబుల్, ఇది వనరులకు ప్రాప్యతను సమకాలీకరించడానికి ఉపయోగించబడుతుంది.

FreeRTOS లో సెమాఫోర్ రకాలు:

సెమాఫోర్ రెండు రకాలు.

బైనరీ సెమాఫోర్
సెమాఫోర్ లెక్కింపు

1. బైనరీ సెమాఫోర్: దీనికి రెండు పూర్ణాంక విలువలు 0 మరియు 1. ఇది పొడవు యొక్క క్యూకు కొంతవరకు సమానంగా ఉంటుంది 1. ఉదాహరణకు, మనకు టాస్క్ 1 మరియు టాస్క్ 2 అనే రెండు పనులు ఉన్నాయి. టాస్క్ 1 టాస్క్ 2 కి డేటాను పంపుతుంది కాబట్టి టాస్క్ 2 క్యూ ఐటెమ్ 1 ఉంటే నిరంతరం తనిఖీ చేస్తుంది, అప్పుడు అది 1 అయ్యే వరకు వేచి ఉండాల్సిన డేటాను చదవగలదు. డేటా తీసుకున్న తరువాత, టాస్క్ 2 క్యూను తగ్గించి 0 చేయండి అంటే మళ్ళీ టాస్క్ 1 టాస్క్ 2 కు డేటాను పంపగలదు.

పై ఉదాహరణ నుండి, బైనరీ సెమాఫోర్ పనుల మధ్య లేదా పనుల మధ్య సమకాలీకరణకు మరియు అంతరాయానికి ఉపయోగించబడుతుందని చెప్పవచ్చు.

2. సెమాఫోర్ను లెక్కించడం: ఇది 0 కన్నా ఎక్కువ విలువలను కలిగి ఉంది మరియు 1 కన్నా ఎక్కువ పొడవు యొక్క క్యూ గురించి ఆలోచించవచ్చు. ఈ సెమాఫోర్ సంఘటనలను లెక్కించడానికి ఉపయోగించబడుతుంది. ఈ వినియోగ దృష్టాంతంలో, ఈవెంట్ జరిగిన ప్రతిసారీ ఈవెంట్ హ్యాండ్లర్ ఒక సెమాఫోర్‌ను 'ఇస్తాడు' (సెమాఫోర్ కౌంట్ విలువను పెంచుతుంది), మరియు ఒక హ్యాండ్లర్ టాస్క్ ఒక ఈవెంట్‌ను ప్రాసెస్ చేసిన ప్రతిసారీ సెమాఫోర్‌ను 'తీసుకుంటుంది' (సెమాఫోర్ కౌంట్ విలువను తగ్గిస్తుంది).

కాబట్టి, కౌంట్ విలువ సంభవించిన సంఘటనల సంఖ్య మరియు ప్రాసెస్ చేయబడిన సంఖ్య మధ్య వ్యత్యాసం.

ఇప్పుడు, మన FreeRTOS కోడ్‌లో సెమాఫోర్‌ను ఎలా ఉపయోగించాలో చూద్దాం.

FreeRTOS లో సెమాఫోర్‌ను ఎలా ఉపయోగించాలి?

FreeRTOS ఒక సెమాఫోర్ సృష్టించడానికి, సెమాఫోర్ తీసుకోవటానికి మరియు సెమాఫోర్ ఇవ్వడానికి వేర్వేరు API లకు మద్దతు ఇస్తుంది.

ఇప్పుడు, ఒకే కెర్నల్ ఆబ్జెక్ట్ కోసం రెండు రకాల API లు ఉండవచ్చు. మేము ఒక ISR నుండి సెమాఫోర్ ఇవ్వవలసి వస్తే, అప్పుడు సాధారణ సెమాఫోర్ API ఉపయోగించబడదు. మీరు అంతరాయ రక్షిత API లను ఉపయోగించాలి.

ఈ ట్యుటోరియల్‌లో, మేము బైనరీ సెమాఫోర్‌ను ఉపయోగిస్తాము ఎందుకంటే అర్థం చేసుకోవడం మరియు అమలు చేయడం సులభం. అంతరాయ కార్యాచరణ ఇక్కడ ఉపయోగించబడుతున్నందున, మీరు ISR ఫంక్షన్‌లో అంతరాయ రక్షిత API లను ఉపయోగించాలి. మేము ఒక పనిని అంతరాయంతో సమకాలీకరించమని చెబుతున్నప్పుడు, దీని అర్థం ISR తర్వాత పనిని విధి స్థితిలో ఉంచడం.

సెమాఫోర్ సృష్టిస్తోంది:

ఏదైనా కెర్నల్ వస్తువును ఉపయోగించడానికి, మేము మొదట దానిని సృష్టించాలి. బైనరీ సెమాఫోర్ సృష్టించడానికి, vSemaphoreCreateBinary () ను ఉపయోగించండి .

ఈ API ఏ పరామితిని తీసుకోదు మరియు SemaphoreHandle_t రకం వేరియబుల్‌ను అందిస్తుంది. సెమాఫోర్ను నిల్వ చేయడానికి గ్లోబల్ వేరియబుల్ పేరు sema_v సృష్టించబడుతుంది.

సెమాఫోర్హ్యాండిల్_టి సెమా_వి; sema_v = xSemaphoreCreateBinary ();

సెమాఫోర్ ఇవ్వడం:

సెమాఫోర్ ఇవ్వడానికి, రెండు వెర్షన్లు ఉన్నాయి- ఒకటి అంతరాయానికి మరియు మరొకటి సాధారణ పనికి.

xSemaphoreGive (): ఈ API ఒక వాదనను మాత్రమే తీసుకుంటుంది, ఇది సెమాఫోర్ సృష్టించేటప్పుడు పైన ఇచ్చిన విధంగా సెమా_వి వంటి సెమాఫోర్ యొక్క వేరియబుల్ పేరు. మీరు సమకాలీకరించాలనుకునే ఏదైనా సాధారణ పని నుండి దీనిని పిలుస్తారు.
xSemaphoreGiveFromISR (): ఇది xSemaphoreGive () యొక్క అంతరాయ రక్షిత API వెర్షన్. మేము ఒక ISR మరియు సాధారణ పనిని సమకాలీకరించాల్సిన అవసరం వచ్చినప్పుడు, అప్పుడు ISR ఫంక్షన్ నుండి xSemaphoreGiveFromISR () ను ఉపయోగించాలి.

సెమాఫోర్ తీసుకొని:

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

xSemaphoreTake (SemaphoreHandle_t xSemaphore, TickType_t xTicksToWait);

x సెమాఫోర్ : మా విషయంలో తీసుకోవలసిన సెమాఫోర్ పేరు sema_v.

xTicksToWait: సెమాఫోర్ అందుబాటులోకి రావడానికి ఆ పని బ్లాక్ చేయబడిన స్థితిలో వేచి ఉండే గరిష్ట సమయం. మా ప్రాజెక్ట్‌లో, సెమా_వి లభ్యమయ్యే వరకు టాస్క్_1 నిరోధిత స్థితిలో నిరవధికంగా వేచి ఉండటానికి xTicksToWait ని portMAX_DELAY కు సెట్ చేస్తాము .

ఇప్పుడు, ఈ API లను ఉపయోగించుకుందాం మరియు కొన్ని పనులను చేయడానికి కోడ్ రాయండి.

ఇక్కడ ఒక పుష్-బటన్ మరియు రెండు LED లు ఇంటర్‌ఫేస్ చేయబడతాయి. పుష్-బటన్ ఆర్డునో యునో యొక్క పిన్ 2 కు జతచేయబడిన అంతరాయ బటన్‌గా పనిచేస్తుంది. ఈ బటన్ నొక్కినప్పుడు అంతరాయం ఏర్పడుతుంది మరియు పిన్ 8 కి అనుసంధానించబడిన LED ఆన్ చేయబడుతుంది మరియు మీరు దాన్ని మళ్ళీ నొక్కినప్పుడు అది ఆఫ్ అవుతుంది.

కాబట్టి, బటన్ నొక్కినప్పుడు xSemaphoreGiveFromISR () ను ISR ఫంక్షన్ నుండి పిలుస్తారు మరియు xSemaphoreTake () ఫంక్షన్ టాస్క్‌లెడ్ ఫంక్షన్ నుండి పిలువబడుతుంది.

సిస్టమ్ మల్టీ టాస్కింగ్ అనిపించేలా చేయడానికి, ఇతర LED లను పిన్ 7 తో కనెక్ట్ చేయండి, ఇది ఎల్లప్పుడూ మెరిసే స్థితిలో ఉంటుంది.

సెమాఫోర్ కోడ్ వివరణ

Arduino IDE ని తెరవడం ద్వారా కోడ్ రాయడం ప్రారంభిద్దాం

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

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

2. సెమాఫోర్ విలువలను నిల్వ చేయడానికి సెమాఫోర్హ్యాండిల్_టి రకం వేరియబుల్ ప్రకటించండి.

సెమాఫోర్హ్యాండిల్_టి అంతరాయం సెమాఫోర్;

3. శూన్య సెటప్ () లో, xTaskCreate () API ని ఉపయోగించి రెండు టాస్క్‌లను (టాస్క్‌లెడ్ మరియు టాస్క్‌బ్లింక్) సృష్టించండి, ఆపై xSemaphoreCreateBinary () ను ఉపయోగించి ఒక సెమాఫోర్‌ను సృష్టించండి. సమాన ప్రాధాన్యతలతో ఒక పనిని సృష్టించండి మరియు తరువాత ఈ సంఖ్యతో ఆడటానికి ప్రయత్నించండి. అలాగే, పిన్ 2 ను ఇన్‌పుట్‌గా కాన్ఫిగర్ చేయండి మరియు అంతర్గత పుల్-అప్ రెసిస్టర్‌ను ప్రారంభించండి మరియు అంతరాయ పిన్‌ను అటాచ్ చేయండి. చివరగా, క్రింద చూపిన విధంగా షెడ్యూలర్‌ను ప్రారంభించండి.

శూన్య సెటప్ () { పిన్‌మోడ్ (2, INPUT_PULLUP); xTaskCreate (టాస్క్‌లెడ్, "లెడ్", 128, NULL, 0, NULL); x టాస్క్‌క్రియేట్ (టాస్క్‌బ్లింక్, "లెడ్‌బ్లింక్", 128, ఎన్‌యుఎల్ఎల్, 0, ఎన్‌యుఎల్ఎల్); interruptSemaphore = xSemaphoreCreateBinary (); if (interruptSemaphore! = NULL) { attachInterrupt (DigitalPinToInterrupt (2), debounceInterrupt, LOW); } }

4. ఇప్పుడు, ISR ఫంక్షన్‌ను అమలు చేయండి. ఒక ఫంక్షన్ చేసి, అటాచ్ఇంటరప్ట్ () ఫంక్షన్ యొక్క రెండవ ఆర్గ్యుమెంట్ వలె పేరు పెట్టండి . అంతరాయం సరిగ్గా పనిచేయడానికి, మీరు మిల్లీస్ లేదా మైక్రో ఫంక్షన్‌ను ఉపయోగించి పుష్బటన్ యొక్క డీబౌన్స్ సమస్యను తొలగించాలి మరియు డీబౌన్సింగ్ సమయాన్ని సర్దుబాటు చేయాలి. ఈ ఫంక్షన్ నుండి, క్రింద చూపిన విధంగా ఇంటర్‌రప్ట్‌హ్యాండ్లర్ () ఫంక్షన్‌కు కాల్ చేయండి.

long debouncing_time = 150; అస్థిర సంతకం చేయని దీర్ఘ చివరి_మిక్రోస్; void debounceInterrupt () { if ((long) (micros () - last_micros)> = debouncing_time * 1000) { interruptHandler (); last_micros = మైక్రోలు (); } }

లో interruptHandler () ఫంక్షన్, కాల్ xSemaphoreGiveFromISR () API.

void interruptHandler () { xSemaphoreGiveFromISR (interruptSemaphore, NULL); }

ఈ ఫంక్షన్ LED ని ఆన్ చేయడానికి టాస్క్‌లెడ్‌కు సెమాఫోర్ ఇస్తుంది.

5. ఒక సృష్టించు TaskLed ఫంక్షన్ మరియు లోపల అయితే లూప్, కాల్ xSemaphoreTake () API మరియు సెమాఫోర్ విజయవంతంగా తీసుకున్న లేదా లేకపోతే తనిఖీ. ఇది pdPASS (అంటే 1) కు సమానంగా ఉంటే, క్రింద చూపిన విధంగా LED టోగుల్ చేయండి.

void TaskLed (void * pvParameters) { (void) pvParameters; పిన్ మోడ్ (8, U ట్పుట్); అయితే (1) { if (xSemaphoreTake (interruptSemaphore, portMAX_DELAY) == pdPASS) { DigitalWrite (8,! DigitalRead (8%); } } }

6. అలాగే, పిన్ 7 కి కనెక్ట్ చేయబడిన ఇతర LED లను బ్లింక్ చేయడానికి ఒక ఫంక్షన్‌ను సృష్టించండి.

void TaskLed1 (void * pvParameters) { (void) pvParameters; పిన్ మోడ్ (7, U ట్పుట్); (1) { డిజిటల్ రైట్ (7, హై); vTaskDelay (200 / portTICK_PERIOD_MS); డిజిటల్ రైట్ (7, తక్కువ); vTaskDelay (200 / portTICK_PERIOD_MS); } }

7. శూన్య లూప్ ఫంక్షన్ ఖాళీగా ఉంటుంది. మర్చిపోవద్దు.

శూన్య లూప్ () {}

అంతే, ఈ ట్యుటోరియల్ చివరిలో పూర్తి కోడ్ చూడవచ్చు. ఇప్పుడు, ఈ కోడ్‌ను అప్‌లోడ్ చేసి, సర్క్యూట్ రేఖాచిత్రం ప్రకారం LED లు మరియు పుష్-బటన్‌ను Arduino UNO తో కనెక్ట్ చేయండి.

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

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

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

ఇప్పుడు, మ్యూటెక్స్ అంటే ఏమిటి మరియు ఫ్రీఆర్టోస్ ఎలా ఉపయోగించాలో చూద్దాం.

మ్యూటెక్స్ అంటే ఏమిటి?

సెమాఫోర్ పైన వివరించినట్లుగా, సిగ్నలింగ్ మెకానిజం, అదేవిధంగా, మ్యూటెక్స్ అనేది సెమాఫోర్ వలె కాకుండా లాకింగ్ మెకానిజం, ఇది పెరుగుదల మరియు తగ్గింపు కోసం ప్రత్యేక విధులను కలిగి ఉంటుంది, కానీ మ్యూటెక్స్‌లో, ఫంక్షన్ స్వయంగా తీసుకుంటుంది మరియు ఇస్తుంది. భాగస్వామ్య వనరుల అవినీతిని నివారించడానికి ఇది ఒక సాంకేతికత.

భాగస్వామ్య వనరును రక్షించడానికి, ఒకరు వనరుకు టోకెన్ కార్డు (మ్యూటెక్స్) ను కేటాయిస్తారు. ఈ కార్డు ఉన్నవారు ఇతర వనరులను యాక్సెస్ చేయవచ్చు. కార్డు తిరిగి వచ్చే వరకు ఇతరులు వేచి ఉండాలి. ఈ విధంగా, ఒక వనరు మాత్రమే పనిని యాక్సెస్ చేయగలదు మరియు ఇతరులు వారి అవకాశం కోసం వేచి ఉంటారు.

ఉదాహరణ సహాయంతో FreeRTOS లోని మ్యూటెక్స్‌ను అర్థం చేసుకుందాం.

ఇక్కడ మనకు మూడు పనులు ఉన్నాయి, ఒకటి ఎల్‌సిడిలో డేటాను ముద్రించడానికి ఒకటి, ఎల్‌సిడి డేటాను ఎల్‌సిడి టాస్క్‌కు పంపడం రెండవది మరియు ఎల్‌సిడిలో ఉష్ణోగ్రత డేటాను పంపే చివరి పని. కాబట్టి ఇక్కడ రెండు పనులు ఒకే వనరును పంచుకుంటాయి అంటే ఎల్‌సిడి. LDR టాస్క్ మరియు టెంపరేచర్ టాస్క్ ఒకేసారి డేటాను పంపితే, అప్పుడు డేటాలో ఒకటి పాడైపోవచ్చు లేదా కోల్పోవచ్చు.

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

దిగువ రేఖాచిత్రంలో మీరు మ్యూటెక్స్ మరియు సెమాఫోర్స్ యొక్క పనిని గమనించవచ్చు.

FreeRTOS లో Mutex ను ఎలా ఉపయోగించాలి?

మ్యూటాక్స్‌ను సెమాఫోర్స్ మాదిరిగానే ఉపయోగిస్తారు. మొదట, దాన్ని సృష్టించండి, ఆపై సంబంధిత API లను ఉపయోగించి ఇవ్వండి.

మ్యూటెక్స్ సృష్టిస్తోంది:

మ్యూటెక్స్ సృష్టించడానికి, xSemaphoreCreateMutex () API ని ఉపయోగించండి . ముటెక్స్ ఒక రకమైన బైనరీ సెమాఫోర్ అని దాని పేరు సూచించినట్లు. అవి వేర్వేరు సందర్భాలలో మరియు ప్రయోజనాలలో ఉపయోగించబడతాయి. బైనరీ సెమాఫోర్ అనేది సమకాలీకరించే పనుల కోసం, అయితే భాగస్వామ్య వనరును రక్షించడానికి మ్యూటెక్స్ ఉపయోగించబడుతుంది.

ఈ API ఎటువంటి వాదనను తీసుకోదు మరియు SemaphoreHandle_t రకం వేరియబుల్‌ను అందిస్తుంది. మ్యూటెక్స్ సృష్టించలేకపోతే, xSemaphoreCreateMutex () NULL ను తిరిగి ఇస్తుంది.

సెమాఫోర్హ్యాండిల్_టి మ్యూటెక్స్_వి; mutex_v = xSemaphoreCreateMutex ();

మ్యూటెక్స్ తీసుకోవడం:

ఒక పని వనరును యాక్సెస్ చేయాలనుకున్నప్పుడు, అది xSemaphoreTake () API ని ఉపయోగించడం ద్వారా మ్యూటెక్స్ తీసుకుంటుంది. ఇది బైనరీ సెమాఫోర్ వలె ఉంటుంది. ఇది రెండు పారామితులను కూడా తీసుకుంటుంది.

x సెమాఫోర్: మా విషయంలో తీసుకోవలసిన మ్యూటెక్స్ పేరు mutex_v .

xTicksToWait: మ్యూటెక్స్ అందుబాటులోకి రావడానికి ఇది బ్లాక్ చేయబడిన స్థితిలో వేచి ఉండే గరిష్ట సమయం. మా ప్రాజెక్ట్ లో, మేము సెట్ చేస్తుంది xTicksToWait వరకు portMAX_DELAY నిరోధిత రాష్ట్రంలో నిరవధికంగా వేచి వరకు task_1 చేయడానికి mutex_v అందుబాటులో ఉంది.

మ్యూటెక్స్ ఇవ్వడం:

భాగస్వామ్య వనరును యాక్సెస్ చేసిన తరువాత, టాస్క్ మ్యూటెక్స్‌ను తిరిగి ఇవ్వాలి, తద్వారా ఇతర పనులు దీన్ని యాక్సెస్ చేయగలవు. మ్యూటెక్స్‌ను తిరిగి ఇవ్వడానికి xSemaphoreGive () API ఉపయోగించబడుతుంది.

XSemaphoreGive () ఫంక్షన్ మా వాదనలో ఇవ్వవలసిన మ్యూటెక్స్ అయిన ఒక వాదన మాత్రమే తీసుకుంటుంది mutex_v.

పై API లను ఉపయోగించి, Arduino IDE ని ఉపయోగించి FreeRTOS కోడ్‌లో మ్యూటెక్స్‌ను అమలు చేద్దాం.

మ్యూటెక్స్ కోడ్ వివరణ

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

1. హెడర్ ఫైల్స్ సెమాఫోర్ లాగానే ఉంటాయి.

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

2. మ్యూటెక్స్ విలువలను నిల్వ చేయడానికి సెమాఫోర్హ్యాండిల్_టి రకం వేరియబుల్ ప్రకటించండి.

సెమాఫోర్హ్యాండిల్_టి మ్యూటెక్స్_వి;

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

శూన్య సెటప్ () { Serial.begin (9600); mutex_v = xSemaphoreCreateMutex (); if (mutex_v == NULL) { Serial.println ("మ్యూటెక్స్ సృష్టించబడదు"); } x టాస్క్‌క్రియేట్ (టాస్క్ 1, "టాస్క్ 1", 128, ఎన్‌యుఎల్ఎల్, 1, ఎన్‌యుఎల్ఎల్); xTaskCreate (టాస్క్ 2, "టాస్క్ 2", 128, NULL, 1, NULL); }

4. ఇప్పుడు, టాస్క్ 1 మరియు టాస్క్ 2 కోసం టాస్క్ ఫంక్షన్లను చేయండి. ఒక లో అయితే పని ఫంక్షన్ యొక్క లూప్, సీరియల్ మానిటర్ ఒక సందేశాన్ని ప్రింటింగ్ ముందు మనం ఉపయోగిస్తున్న ఒక mutex తీసుకోవాలని xSemaphoreTake () ఆపై సందేశాన్ని ప్రింట్ ఆపై తిరిగి ఉపయోగించి mutex xSemaphoreGive (). అప్పుడు కొంత ఆలస్యం ఇవ్వండి.

శూన్యమైన టాస్క్ 1 (శూన్యమైన * పివిపారామీటర్లు) { అయితే (1) { x సెమాఫోర్ టేక్ (మ్యూటెక్స్_వి, పోర్ట్ మాక్స్_డెలే); సీరియల్.ప్రింట్ల్న్ ("టాస్క్ 1 నుండి హాయ్"); xSemaphoreGive (mutex_v); vTaskDelay (pdMS_TO_TICKS (1000%); } }

అదేవిధంగా, టాస్క్ 2 ఫంక్షన్‌ను 500 ఎంఎస్‌ల ఆలస్యంతో అమలు చేయండి.

5. శూన్య లూప్ () ఖాళీగా ఉంటుంది.

ఇప్పుడు, ఈ కోడ్‌ను Arduino UNO లో అప్‌లోడ్ చేసి, సీరియల్ మానిటర్‌ను తెరవండి.

టాస్క్ 1 మరియు టాస్క్ 2 నుండి సందేశాలు ముద్రించడాన్ని మీరు చూస్తారు.

మ్యూటెక్స్ యొక్క పనిని పరీక్షించడానికి, xSemaphoreGive (mutex_v) ను వ్యాఖ్యానించండి ; ఏదైనా పని నుండి. ప్రోగ్రామ్ చివరి ముద్రణ సందేశంలో వేలాడుతుందని మీరు చూడవచ్చు .

Arduino తో FreeRTOS లో సెమాఫోర్ మరియు మ్యూటెక్స్ ఈ విధంగా అమలు చేయవచ్చు. సెమాఫోర్ మరియు మ్యూటెక్స్ గురించి మరింత సమాచారం కోసం, మీరు FreeRTOS యొక్క అధికారిక డాక్యుమెంటేషన్‌ను సందర్శించవచ్చు.

సెమాఫోర్ మరియు మ్యూట్స్ కోసం పూర్తి సంకేతాలు మరియు వీడియో క్రింద ఇవ్వబడ్డాయి.