Arduino freertos டுடோரியல் 3

முந்தைய டுடோரியல்களில், ஃப்ரீஆர்டோஸின் அடிப்படைகளை அர்டுயினோ மற்றும் ஃப்ரீஆர்டோஸ் ஆர்டுயினோவில் உள்ள கியூ கர்னல் பொருளுடன் உள்ளடக்கியுள்ளோம். இப்போது, இந்த மூன்றாவது FreeRTOS டுடோரியலில், FreeRTOS மற்றும் அதன் முன்கூட்டிய API கள் பற்றி மேலும் அறிந்து கொள்வோம், இது பல பணிகள் சார்ந்த தளத்தை இன்னும் ஆழமாக புரிந்துகொள்ள வைக்கும்.

செமாஃபோர் மற்றும் மியூடெக்ஸ் (பரஸ்பர விலக்கு) என்பது ஒத்திசைவு, வள மேலாண்மை மற்றும் வளங்களை ஊழலிலிருந்து பாதுகாக்கப் பயன்படும் கர்னல் பொருள்கள். இந்த டுடோரியலின் முதல் பாதியில், செமாஃபோருக்குப் பின்னால் உள்ள யோசனையைப் பார்ப்போம், அதை எப்படி, எங்கு பயன்படுத்த வேண்டும். இரண்டாவது பாதியில், நாங்கள் முடெக்ஸுடன் தொடருவோம்.

செமாஃபோர் என்றால் என்ன?

முந்தைய டுடோரியல்களில், பணி முன்னுரிமைகள் பற்றி நாங்கள் விவாதித்தோம், மேலும் அதிக முன்னுரிமை பணி குறைந்த முன்னுரிமை பணியை முன்கூட்டியே செய்கிறது என்பதையும் அறிந்து கொள்கிறோம், எனவே அதிக முன்னுரிமை பணியை செயல்படுத்தும்போது தரவு ஊழல் குறைந்த முன்னுரிமை பணியில் நிகழ வாய்ப்புள்ளது, ஏனெனில் அது இன்னும் செயல்படுத்தப்படவில்லை மற்றும் தரவு இழப்பு மற்றும் முழு பயன்பாட்டின் தவறான செயல்பாட்டை ஏற்படுத்தும் சென்சாரிலிருந்து தரவு தொடர்ந்து இந்த பணிக்கு வருகிறது.

எனவே, தரவு இழப்பிலிருந்து வளங்களை பாதுகாக்க வேண்டிய அவசியம் உள்ளது, இங்கு செமாஃபோர் ஒரு முக்கிய பங்கு வகிக்கிறது.

செமாஃபோர் என்பது ஒரு சமிக்ஞை பொறிமுறையாகும், இதில் காத்திருக்கும் நிலையில் உள்ள ஒரு பணி நிறைவேற்றுவதற்கான மற்றொரு பணியால் சமிக்ஞை செய்யப்படுகிறது. வேறு வார்த்தைகளில் கூறுவதானால், ஒரு பணி 1 அதன் வேலையை முடித்ததும், அது ஒரு கொடியைக் காண்பிக்கும் அல்லது ஒரு கொடியை 1 ஆல் அதிகரிக்கும், பின்னர் இந்த கொடி மற்றொரு பணியால் (பணி 2) பெறப்படுகிறது, அது இப்போது தனது வேலையைச் செய்ய முடியும் என்பதைக் காட்டுகிறது. டாஸ்க் 2 அதன் வேலையை முடித்தவுடன் கொடி 1 குறையும்.

எனவே, அடிப்படையில், இது ஒரு “கொடு” மற்றும் “எடுத்துக்கொள்” பொறிமுறையாகும் மற்றும் செமாஃபோர் என்பது ஒரு முழு எண் மாறி, இது வளங்களுக்கான அணுகலை ஒத்திசைக்க பயன்படுகிறது.

FreeRTOS இல் செமாஃபோரின் வகைகள்:

செமாஃபோர் இரண்டு வகையாகும்.

பைனரி செமாஃபோர்
செமாஃபோரை எண்ணுகிறது

1. பைனரி செமாஃபோர்: இது இரண்டு முழு எண் மதிப்புகள் 0 மற்றும் 1. இது நீள வரிசைக்கு ஓரளவு ஒத்திருக்கிறது 1. எடுத்துக்காட்டாக, எங்களிடம் இரண்டு பணிகள் உள்ளன, பணி 1 மற்றும் பணி 2. டாஸ்க் 1 டாஸ்க் 2 க்கு தரவை அனுப்புகிறது, எனவே டாஸ்க் 2 வரிசை உருப்படி 1 இருந்தால் தொடர்ந்து சரிபார்க்கிறது, பின்னர் அது 1 ஆக இருக்கும் வரை காத்திருக்க வேண்டிய தரவை படிக்க முடியும். தரவை எடுத்த பிறகு, டாஸ்க் 2 வரிசையை குறைத்து அதை 0 ஆக மாற்றுகிறது பணி 2 க்கு தரவை அனுப்ப முடியும்.

மேலே உள்ள எடுத்துக்காட்டில் இருந்து, பைனரி செமாஃபோர் பணிகளுக்கு இடையில் அல்லது பணிகளுக்கு இடையில் ஒத்திசைக்கப் பயன்படுகிறது மற்றும் குறுக்கிடுகிறது என்று கூறலாம்.

2. செமாஃபோரை எண்ணுதல்: இது 0 ஐ விட அதிகமான மதிப்புகளைக் கொண்டுள்ளது மற்றும் 1 ஐ விட நீள வரிசை என்று கருதலாம். இந்த செமாஃபோர் நிகழ்வுகளை எண்ணுவதற்குப் பயன்படுத்தப்படுகிறது. இந்த பயன்பாட்டு சூழ்நிலையில், ஒரு நிகழ்வு நிகழும் ஒவ்வொரு முறையும் ஒரு நிகழ்வு கையாளுபவர் ஒரு செமாஃபோரை 'கொடுப்பார்' (செமாஃபோர் எண்ணிக்கை மதிப்பை அதிகரிக்கும்), மேலும் ஒரு நிகழ்வை செயலாக்கும்போதெல்லாம் ஒரு ஹேண்ட்லர் பணி ஒரு செமாஃபோரை 'எடுக்கும்' (செமாஃபோர் எண்ணிக்கை மதிப்பைக் குறைக்கும்).

ஆகையால், எண்ணின் மதிப்பு, நிகழ்ந்த நிகழ்வுகளின் எண்ணிக்கைக்கும் செயலாக்கப்பட்ட எண்ணிற்கும் உள்ள வித்தியாசம்.

இப்போது, எங்கள் FreeRTOS குறியீட்டில் செமாஃபோரை எவ்வாறு பயன்படுத்துவது என்று பார்ப்போம்.

FreeRTOS இல் செமாஃபோரை எவ்வாறு பயன்படுத்துவது?

ஃப்ரீஆர்டோஸ் ஒரு செமாஃபோரை உருவாக்குவதற்கும், ஒரு செமாஃபோரை எடுத்துக்கொள்வதற்கும், ஒரு செமாஃபோரை வழங்குவதற்கும் வெவ்வேறு API களை ஆதரிக்கிறது.

இப்போது, ஒரே கர்னல் பொருளுக்கு இரண்டு வகையான ஏபிஐக்கள் இருக்கலாம். நாம் ஒரு ஐ.எஸ்.ஆரிடமிருந்து செமாஃபோரைக் கொடுக்க வேண்டும் என்றால், சாதாரண செமாஃபோர் ஏபிஐ பயன்படுத்த முடியாது. குறுக்கீடு பாதுகாக்கப்பட்ட API களை நீங்கள் பயன்படுத்த வேண்டும்.

இந்த டுடோரியலில், பைனரி செமாஃபோரைப் பயன்படுத்துவோம், ஏனெனில் அதைப் புரிந்துகொண்டு செயல்படுத்த எளிதானது. குறுக்கீடு செயல்பாடு இங்கே பயன்படுத்தப்படுவதால், ஐ.எஸ்.ஆர் செயல்பாட்டில் குறுக்கீடு பாதுகாக்கப்பட்ட API களைப் பயன்படுத்த வேண்டும். ஒரு பணியை குறுக்கீட்டோடு ஒத்திசைப்பதாக நாங்கள் கூறும்போது, இதன் பொருள் ஐ.எஸ்.ஆருக்குப் பிறகு பணியை இயங்கும் நிலைக்கு வைப்பதாகும்.

ஒரு செமாஃபோரை உருவாக்குதல்:

எந்த கர்னல் பொருளையும் பயன்படுத்த, முதலில் அதை உருவாக்க வேண்டும். பைனரி செமாஃபோரை உருவாக்க, vSemaphoreCreateBinary () ஐப் பயன்படுத்தவும் .

இந்த ஏபிஐ எந்த அளவுருவையும் எடுக்கவில்லை மற்றும் செமாஃபோர்ஹேண்டில்_டி வகை மாறியை வழங்குகிறது. செமாஃபோரை சேமிக்க sema_v என்ற உலகளாவிய மாறி பெயர் உருவாக்கப்பட்டது.

செமாஃபோர்ஹான்டில்_டி செமா_வி; sema_v = xSemaphoreCreateBinary ();

ஒரு செமாஃபோர் கொடுப்பது:

ஒரு செமாஃபோரைக் கொடுப்பதற்கு, இரண்டு பதிப்புகள் உள்ளன- ஒன்று குறுக்கீடு மற்றும் மற்றொன்று சாதாரண பணிக்கு.

xSemaphoreGive (): இந்த ஏபிஐ ஒரு வாதத்தை மட்டுமே எடுக்கும், இது செமாஃபோரை உருவாக்கும் போது மேலே கொடுக்கப்பட்டுள்ளபடி sema_v போன்ற செமாஃபோரின் மாறி பெயர். நீங்கள் ஒத்திசைக்க விரும்பும் எந்தவொரு சாதாரண பணியிலிருந்தும் இதை அழைக்கலாம்.
xSemaphoreGiveFromISR (): இது xSemaphoreGive () இன் குறுக்கீடு பாதுகாக்கப்பட்ட API பதிப்பு. ஒரு ஐ.எஸ்.ஆர் மற்றும் இயல்பான பணியை நாம் ஒத்திசைக்க வேண்டியிருக்கும் போது, ஐ.எஸ்.ஆர் செயல்பாட்டிலிருந்து xSemaphoreGiveFromISR () பயன்படுத்தப்பட வேண்டும்.

ஒரு செமாஃபோர் எடுத்து:

ஒரு செமாஃபோரை எடுக்க, API செயல்பாடு xSemaphoreTake () ஐப் பயன்படுத்தவும். இந்த API இரண்டு அளவுருக்களை எடுக்கும்.

xSemaphoreTake (SemaphoreHandle_t xSemaphore, TickType_t xTicksToWait);

xSemaphore: எங்கள் விஷயத்தில் எடுக்க வேண்டிய செமாஃபோரின் பெயர் sema_v.

xTicksToWait: செமாஃபோர் கிடைக்கும்படி பணி தடுக்கப்பட்ட நிலையில் காத்திருக்கும் அதிகபட்ச நேரம் இது. எங்கள் திட்டம், நாம் அமைக்கும் xTicksToWait செய்ய portMAX_DELAY sema_v கிடைக்கும் வரை தடுக்கப்பட்ட மாநிலத்தில் காலவரையின்றி காத்திருக்க task_1 செய்ய.

இப்போது, இந்த API களைப் பயன்படுத்தி சில பணிகளைச் செய்ய ஒரு குறியீட்டை எழுதுவோம்.

இங்கே ஒரு புஷ்-பொத்தான் மற்றும் இரண்டு எல்.ஈ.டிக்கள் ஒன்றோடொன்று இணைக்கப்பட்டுள்ளன. புஷ்-பொத்தான் ஒரு குறுக்கீடு பொத்தானாக செயல்படும், இது Arduino Uno இன் முள் 2 உடன் இணைக்கப்பட்டுள்ளது. இந்த பொத்தானை அழுத்தும்போது ஒரு குறுக்கீடு உருவாக்கப்படும் மற்றும் முள் 8 உடன் இணைக்கப்பட்ட ஒரு எல்.ஈ.டி இயக்கப்படும், நீங்கள் அதை மீண்டும் அழுத்தும்போது அது முடக்கப்படும்.

எனவே, பொத்தானை அழுத்தும்போது xSemaphoreGiveFromISR () ஐஎஸ்ஆர் செயல்பாட்டிலிருந்து அழைக்கப்படும் மற்றும் xSemaphoreTake () செயல்பாடு டாஸ்க்லெட் செயல்பாட்டிலிருந்து அழைக்கப்படும்.

கணினி பல்பணி பார்க்க, பிற எல்.ஈ.டிகளை முள் 7 உடன் இணைக்கவும், அவை எப்போதும் ஒளிரும் நிலையில் இருக்கும்.

செமாஃபோர் குறியீடு விளக்கம்

Arduino IDE ஐ திறப்பதன் மூலம் குறியீட்டை எழுத ஆரம்பிக்கலாம்

1. முதலில், Arduino_FreeRTOS.h தலைப்பு கோப்பைச் சேர்க்கவும். இப்போது, எந்த கர்னல் பொருளும் வரிசை செமாஃபோர் போல பயன்படுத்தப்பட்டால், அதற்கு ஒரு தலைப்பு கோப்பும் சேர்க்கப்பட வேண்டும்.

# அடங்கும் # அடங்கும்

2. செமாஃபோரின் மதிப்புகளைச் சேமிக்க SemaphoreHandle_t வகை மாறி அறிவிக்கவும்.

செமாஃபோர்ஹான்டில்_டி குறுக்கீடு செமஃபோர்;

3. வெற்றிட அமைப்பில் (), xTaskCreate () API ஐப் பயன்படுத்தி இரண்டு பணிகளை (TaskLED மற்றும் TaskBlink) உருவாக்கி, பின்னர் xSemaphoreCreateBinary () ஐப் பயன்படுத்தி ஒரு செமாஃபோரை உருவாக்கவும். சமமான முன்னுரிமைகளுடன் ஒரு பணியை உருவாக்கி, பின்னர் இந்த எண்ணுடன் விளையாட முயற்சிக்கவும். மேலும், முள் 2 ஐ உள்ளீடாக உள்ளமைத்து, உள் இழுக்கும்-மின்தடையத்தை இயக்கி குறுக்கீடு முள் இணைக்கவும். இறுதியாக, கீழே காட்டப்பட்டுள்ளபடி திட்டமிடலைத் தொடங்கவும்.

வெற்றிட அமைவு () { பின்மோட் (2, INPUT_PULLUP); xTaskCreate (டாஸ்க்லெட், "லெட்", 128, NULL, 0, NULL); xTaskCreate (TaskBlink, "LedBlink", 128, NULL, 0, NULL); interruptSemaphore = xSemaphoreCreateBinary (); if (interruptSemaphore! = NULL) { attachInterrupt (DigitalPinToInterrupt (2), debounceInterrupt, LOW); } }

4. இப்போது, ஐ.எஸ்.ஆர் செயல்பாட்டை செயல்படுத்தவும். ஒரு செயல்பாட்டை உருவாக்கி, இணைப்பு இன்டெரப்ட் () செயல்பாட்டின் இரண்டாவது வாதத்தைப் போலவே பெயரிடவும் . குறுக்கீடு சரியாகச் செய்ய, மில்லிஸ் அல்லது மைக்ரோ செயல்பாட்டைப் பயன்படுத்தி புஷ்பட்டனின் நீக்கம் சிக்கலை நீக்க வேண்டும் மற்றும் குறைக்கும் நேரத்தை சரிசெய்வதன் மூலம். இந்த செயல்பாட்டிலிருந்து, கீழே காட்டப்பட்டுள்ளபடி குறுக்கீடு ஹேண்ட்லர் () செயல்பாட்டை அழைக்கவும்.

நீண்ட debouncing_time = 150; கொந்தளிப்பான கையொப்பமிடாத நீண்ட கடைசி_மைக்ரோஸ்; void debounceInterrupt () { if ((long) (micros () - last_micros)> = debouncing_time * 1000) { interruptHandler (); last_micros = மைக்ரோக்கள் (); } }

இல் interruptHandler () செயல்பாடு, அழைப்பு xSemaphoreGiveFromISR () ஏபிஐ.

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

இந்த செயல்பாடு எல்.ஈ.டியை இயக்க டாஸ்க்லெடிற்கு ஒரு செமாஃபோரை வழங்கும்.

5. ஒரு டாஸ்க்லெட் செயல்பாட்டை உருவாக்கி, அதே நேரத்தில் லூப்பிற்குள், xSemaphoreTake () API ஐ அழைத்து, செமாஃபோர் வெற்றிகரமாக எடுக்கப்பட்டதா இல்லையா என்பதை சரிபார்க்கவும். இது pdPASS க்கு (அதாவது 1) சமமாக இருந்தால், கீழே காட்டப்பட்டுள்ளபடி எல்.ஈ.டி நிலைமாற்றுங்கள்.

void TaskLed (void * pvParameters) { (void) pvParameters; pinMode (8, OUTPUT); (1) { if (xSemaphoreTake (interruptSemaphore, portMAX_DELAY) == pdPASS) { DigitalWrite (8,! DigitalRead (8%); } } }

6. மேலும், முள் 7 உடன் இணைக்கப்பட்ட பிற எல்.ஈ.

void TaskLed1 (void * pvParameters) { (வெற்றிடத்தை) pvParameters; pinMode (7, OUTPUT); (1) { டிஜிட்டல்ரைட் (7, உயர்); vTaskDelay (200 / portTICK_PERIOD_MS); டிஜிட்டல்ரைட் (7, குறைந்த); vTaskDelay (200 / portTICK_PERIOD_MS); } }

7. வெற்றிட வளைய செயல்பாடு காலியாக இருக்கும். அதை மறந்துவிடாதீர்கள்.

void loop () {}

அவ்வளவுதான், இந்த டுடோரியலின் முடிவில் முழுமையான குறியீட்டைக் காணலாம். இப்போது, இந்த குறியீட்டைப் பதிவேற்றி, எல்.ஈ.டி மற்றும் புஷ்-பொத்தானை சுற்று வரைபடத்தின் படி Arduino UNO உடன் இணைக்கவும்.

சுற்று வரைபடம்

குறியீட்டைப் பதிவேற்றிய பிறகு, 200 மீட்டருக்குப் பிறகு எல்.ஈ.டி ஒளிரும் என்பதை நீங்கள் காண்பீர்கள், பொத்தானை அழுத்தும்போது, உடனடியாக இரண்டாவது எல்.ஈ.டி இறுதியில் கொடுக்கப்பட்ட வீடியோவில் காட்டப்பட்டுள்ளபடி ஒளிரும்.

இந்த வழியில், அர்துனோவுடன் ஃப்ரீஆர்டோஸில் செமாஃபோர்களைப் பயன்படுத்தலாம், அங்கு ஒரு பணியிலிருந்து இன்னொரு பணிக்கு எந்த இழப்பும் இல்லாமல் தரவை அனுப்ப வேண்டும்.

இப்போது, மியூடெக்ஸ் என்றால் என்ன, அதை ஃப்ரீஆர்டோஸ் எவ்வாறு பயன்படுத்துவது என்று பார்ப்போம்.

முடெக்ஸ் என்றால் என்ன?

மேலே விளக்கப்பட்டுள்ளபடி செமாஃபோர் ஒரு சமிக்ஞை பொறிமுறையாகும், இதேபோல், முடெக்ஸ் என்பது செமாஃபோரைப் போலல்லாமல் ஒரு பூட்டுதல் பொறிமுறையாகும், இது அதிகரிப்பு மற்றும் குறைப்புக்கு தனித்தனி செயல்பாடுகளைக் கொண்டுள்ளது, ஆனால் மியூடெக்ஸில், செயல்பாடு தன்னைத்தானே எடுத்துக்கொள்கிறது. பகிரப்பட்ட வளங்களின் ஊழலைத் தவிர்க்க இது ஒரு நுட்பமாகும்.

பகிரப்பட்ட வளத்தைப் பாதுகாக்க, ஒருவர் ஆதாரத்திற்கு டோக்கன் கார்டை (மியூடெக்ஸ்) ஒதுக்குகிறார். இந்த அட்டை வைத்திருப்பவர் மற்ற வளத்தை அணுகலாம். அட்டை திரும்பும் வரை மற்றவர்கள் காத்திருக்க வேண்டும். இந்த வழியில், ஒரு வளத்தால் மட்டுமே பணியை அணுக முடியும், மற்றவர்கள் தங்கள் வாய்ப்புக்காக காத்திருக்கிறார்கள்.

ஒரு உதாரணத்தின் உதவியுடன் FreeRTOS இல் Mutex ஐப் புரிந்துகொள்வோம்.

இங்கே எங்களுக்கு மூன்று பணிகள் உள்ளன, ஒன்று எல்சிடியில் தரவை அச்சிடுவதற்கு ஒன்று, எல்சிடி தரவை எல்சிடி பணிக்கு அனுப்புவதற்கு இரண்டாவது மற்றும் எல்சிடியில் வெப்பநிலை தரவை அனுப்புவதற்கான கடைசி பணி. எனவே இங்கே இரண்டு பணிகள் ஒரே வளத்தைப் பகிர்ந்து கொள்கின்றன, அதாவது எல்சிடி. எல்.டி.ஆர் பணி மற்றும் வெப்பநிலை பணி ஒரே நேரத்தில் தரவை அனுப்பினால், தரவுகளில் ஒன்று சிதைக்கப்படலாம் அல்லது இழக்கப்படலாம்.

எனவே தரவு இழப்பைப் பாதுகாக்க, எல்.சி.டி வளத்தை பணி 1 க்கான காட்சி பணியை முடிக்கும் வரை பூட்ட வேண்டும். பின்னர் எல்சிடி பணி திறக்கும், பின்னர் பணி 2 அதன் வேலையைச் செய்ய முடியும்.

கீழேயுள்ள வரைபடத்தில் முடெக்ஸ் மற்றும் செமாஃபோர்களின் செயல்பாட்டை நீங்கள் அவதானிக்கலாம்.

FreeRTOS இல் Mutex ஐ எவ்வாறு பயன்படுத்துவது?

மியூடெக்ஸ் செமாஃபோர்களைப் போலவே பயன்படுத்தப்படுகின்றன. முதலில், அதை உருவாக்கவும், பின்னர் அந்தந்த API களைப் பயன்படுத்தி கொடுக்கவும்.

ஒரு முடெக்ஸ் உருவாக்குதல்:

Mutex ஐ உருவாக்க, xSemaphoreCreateMutex () API ஐப் பயன்படுத்தவும் . மியூடெக்ஸ் ஒரு வகை பைனரி செமாஃபோர் என்று அதன் பெயர் குறிப்பிடுவது போல. அவை வெவ்வேறு சூழல்களிலும் நோக்கங்களிலும் பயன்படுத்தப்படுகின்றன. ஒரு பைனரி செமாஃபோர் என்பது பணிகளை ஒத்திசைப்பதற்கானது, அதே நேரத்தில் பகிர்ந்த வளத்தைப் பாதுகாக்க மியூடெக்ஸ் பயன்படுத்தப்படுகிறது.

இந்த API எந்த வாதத்தையும் எடுக்கவில்லை மற்றும் SemaphoreHandle_t வகை மாறியை வழங்குகிறது. மியூடெக்ஸை உருவாக்க முடியாவிட்டால் , xSemaphoreCreateMutex () NULL ஐத் தருகிறது .

செமாஃபோர்ஹான்டில்_டி மியூடெக்ஸ்_வி; mutex_v = xSemaphoreCreateMutex ();

ஒரு மியூடெக்ஸ் எடுத்து:

ஒரு பணி ஒரு வளத்தை அணுக விரும்பினால், அது xSemaphoreTake () API ஐப் பயன்படுத்தி ஒரு Mutex ஐ எடுக்கும் . இது ஒரு பைனரி செமாஃபோருக்கு சமம். இது இரண்டு அளவுருக்களையும் எடுக்கும்.

xSemaphore: எங்கள் விஷயத்தில் எடுக்கப்பட வேண்டிய Mutex இன் பெயர் mutex_v .

xTicksToWait: மியூடெக்ஸ் கிடைக்கும்படி பணி தடுக்கப்பட்ட நிலையில் காத்திருக்கும் அதிகபட்ச நேரம் இது. எங்கள் திட்டம், நாம் அமைக்கும் xTicksToWait செய்ய portMAX_DELAY வரை தடுக்கப்பட்ட மாநிலத்தில் காலவரையின்றி காத்திருக்க task_1 செய்ய mutex_v கிடைக்கிறது.

ஒரு முடெக்ஸ் கொடுப்பது:

பகிரப்பட்ட வளத்தை அணுகிய பிறகு, பணி முடெக்ஸைத் திருப்பித் தர வேண்டும், இதனால் மற்ற பணிகள் அதை அணுக முடியும். மியூட்டெக்ஸைத் திரும்பக் கொடுக்க xSemaphoreGive () API பயன்படுத்தப்படுகிறது.

XSemaphoreGive () செயல்பாடு ஒரே ஒரு வாதத்தை மட்டுமே எடுக்கும், இது எங்கள் விஷயத்தில் mutex_v இல் கொடுக்கப்பட வேண்டிய Mutex ஆகும்.

மேலே உள்ள API களைப் பயன்படுத்தி, Arduino IDE ஐப் பயன்படுத்தி FreeRTOS குறியீட்டில் Mutex ஐ செயல்படுத்தலாம்.

முடெக்ஸ் குறியீடு விளக்கம்

இங்கே இந்த பகுதிக்கான குறிக்கோள், ஒரு சீரியல் மானிட்டரை பகிரப்பட்ட வளமாகவும் இரண்டு செய்திகளை அச்சிட சீரியல் மானிட்டரை அணுக இரண்டு வெவ்வேறு பணிகளாகவும் பயன்படுத்துவது.

1. தலைப்பு கோப்புகள் ஒரு செமாஃபோரைப் போலவே இருக்கும்.

# அடங்கும் # அடங்கும்

2. முடெக்ஸின் மதிப்புகளைச் சேமிக்க SemaphoreHandle_t வகை மாறி அறிவிக்கவும்.

செமாஃபோர்ஹேண்டில்_டி மியூடெக்ஸ்_வி;

3. வெற்றிட அமைப்பில் (), சீரியல் மானிட்டரை 9600 பாட் வீதத்துடன் துவக்கி, xTaskCreate () API ஐப் பயன்படுத்தி இரண்டு பணிகளை (Task1 மற்றும் Task2) உருவாக்கவும். XSemaphoreCreateMutex () ஐப் பயன்படுத்தி ஒரு Mutex ஐ உருவாக்கவும் . சம முன்னுரிமைகளுடன் ஒரு பணியை உருவாக்கவும், பின்னர் இந்த எண்ணுடன் விளையாட முயற்சிக்கவும்.

void setup () { Serial.begin (9600); mutex_v = xSemaphoreCreateMutex (); if (mutex_v == NULL) { Serial.println ("Mutex ஐ உருவாக்க முடியாது"); } xTaskCreate (Task1, "Task 1", 128, NULL, 1, NULL); xTaskCreate (Task2, "Task 2", 128, NULL, 1, NULL); }

4. இப்போது, பணி 1 மற்றும் பணி 2 க்கான பணி செயல்பாடுகளைச் செய்யுங்கள். ஒரு ஆண்டில் போது பணி செயல்பாடு லூப், சீரியல் மானிட்டர் ஒரு செய்தியை அச்சிடுவதற்கு முன்பு நாங்கள் பயன்படுத்தி ஒரு மூடெக்ஸ் எடுத்துக்கொள்ள வேண்டும் xSemaphoreTake () பயன்படுத்தி மூடெக்ஸ் பின்னர் செய்தி அச்சிட பின்னர் திரும்ப xSemaphoreGive (). பின்னர் சிறிது தாமதம் கொடுங்கள்.

வெற்றிட பணி 1 (வெற்றிடத்தை * pvParameters) { போது (1) { xSemaphoreTake (mutex_v, portMAX_DELAY); Serial.println ("பணி 1 இலிருந்து வணக்கம்"); xSemaphoreGive (mutex_v); vTaskDelay (pdMS_TO_TICKS (1000%); } }

இதேபோல், டாஸ்க் 2 செயல்பாட்டை 500 எம்எஸ் தாமதத்துடன் செயல்படுத்தவும்.

5. வெற்றிட வளையம் () காலியாக இருக்கும்.

இப்போது, இந்த குறியீட்டை Arduino UNO இல் பதிவேற்றி சீரியல் மானிட்டரைத் திறக்கவும்.

பணி 1 மற்றும் பணி 2 இலிருந்து செய்திகள் அச்சிடுவதை நீங்கள் காண்பீர்கள்.

Mutex இன் செயல்பாட்டை சோதிக்க, xSemaphoreGive (mutex_v) என்று கருத்து தெரிவிக்கவும் ; எந்த பணியிலிருந்தும். நிரல் கடைசி அச்சு செய்தியில் தொங்குவதை நீங்கள் காணலாம் .

அராமினோவுடன் ஃப்ரீஆர்டோஸில் செமாஃபோர் மற்றும் மியூடெக்ஸ் செயல்படுத்தப்படுவது இப்படித்தான். செமாஃபோர் மற்றும் முடெக்ஸ் பற்றிய கூடுதல் தகவலுக்கு, நீங்கள் FreeRTOS இன் அதிகாரப்பூர்வ ஆவணங்களைப் பார்வையிடலாம்.

செமாஃபோர் மற்றும் மியூட்களுக்கான முழுமையான குறியீடுகள் மற்றும் வீடியோ கீழே கொடுக்கப்பட்டுள்ளன.