FreeRTOS: इंटरप्रोसेस संचार

नमस्ते इस लेख में मैं घटनाओं के साथ इंटरप्रोसेस डेटा एक्सचेंज और सिंक्रनाइज़ेशन की विधि का वर्णन करने का प्रयास करूंगा।
अन्य भागों के लिए लिंक:
FreeRTOS: परिचय।
FreeRTOS: म्यूटेक्स और महत्वपूर्ण खंड।

किसी भी बहु-थ्रेडेड ओएस को बहु-थ्रेडेड वातावरण का समर्थन करने के उपयुक्त साधनों के बिना पूरा नहीं माना जाएगा। FreeRTOS के पास इसके लिए आपकी जरूरत की सभी चीजें हैं:

• कार्यों या ISR के बीच डेटा के आदान-प्रदान के लिए कतारें।
• बाइनरी सेमाफोर और घटनाओं के साथ सिंक्रोनाइज़ेशन के लिए सेमाफोर की गिनती (व्यवधान)।
• संसाधन साझा करने के लिए म्यूटेक्स (उदाहरण के लिए, पोर्ट)।
• एक कोड क्षेत्र बनाने के लिए महत्वपूर्ण अनुभाग, जिसका निष्पादन अनुसूचक द्वारा बाधित नहीं किया जा सकता है।

कतार।

फ्रीआरटीओएस का उपयोग करते हुए लिखे गए प्रोग्राम स्वतंत्र कार्यों का एक सेट हैं, या मिनी-सबप्रोग्राम जो डेटा के आदान-प्रदान के लिए एक कुशल और थ्रेड-सुरक्षित तंत्र की आवश्यकता होती है, फ्रीआरटीओएस के मामले में, ये कतारें हैं।
एक कतार एक साधारण FIFO है (हालाँकि आप कतार की शुरुआत में लिख सकते हैं, अंत तक नहीं), एक बफर जो ज्ञात आकार के तत्वों की एक निश्चित संख्या को संग्रहीत कर सकता है। एक कतार में लिखना बाइट डेटा को बफ़र में कॉपी करना है, पढ़ना डेटा की प्रतिलिपि बनाना और इसे कतार से हटाना है।
टूटे हुए डेटा को पढ़ने / लिखने के डर के बिना, कतारें वास्तव में, स्वतंत्र वस्तुएं हैं जिनमें कई लेखक और पाठक हो सकते हैं। डेटा को पढ़ते समय, वैकल्पिक रूप से, हम उस समय को निर्दिष्ट कर सकते हैं जिसके दौरान कार्य को नए डेटा की प्रतीक्षा करनी चाहिए। डेटा रिकॉर्ड करते समय, हम इस बार भी संकेत कर सकते हैं, लेकिन पहले से ही कतार में जगह के लिए इंतजार करना होगा।

आइए हम FreeRTOS में कतारों के साथ काम करने के मुख्य कार्यों पर अधिक विस्तार से विचार करें।
किसी भी कतार का उपयोग करने से पहले, इसे बनाया जाना चाहिए। कतार के लिए RAM मेमोरी को FreeRTOS ढेर से आवंटित किया गया है, और इसका आकार डेटा आकार + कतार संरचना के आकार के बराबर है। कोड में, प्रत्येक कतार को उसके हैंडल द्वारा दर्शाया जाता है, जैसे कि xQueueHandle।

xQueueHandle xQueueCreate(unsigned portBASE_TYPE uxQueueLength, unsigned portBASE_TYPE uxItemSize); 

uxQueueLength - उन तत्वों की अधिकतम संख्या जो कतार प्रति यूनिट समय स्टोर कर सकती है।
uxItemSize - कतार के प्रत्येक तत्व का आकार।
वापसी xQueueHandle, या NULL - यदि कतार बनाई जाती है, तो संबंधित हैंडल वापस हो जाएगा, यदि नहीं, तो। यदि पर्याप्त मेमोरी नहीं है, तो NULL को वापस कर दिया जाएगा।

कतार में लिखने के लिए, विशेष कार्यों का भी उपयोग किया जाता है:

 portBASE_TYPE xQueueSendToFront(xQueueHandle xQueue, const void * pvItemToQueue, portTickType xTicksToWait); portBASE_TYPE xQueueSendToBack(xQueueHandle xQueue, const void * pvItemToQueue, portTickType xTicksToWait); //   portBASE_TYPE xQueueSend(xQueueHandle xQueue, const void * pvItemToQueue, portTickType xTicksToWait); 

xQueue - डेटा को लिखने के लिए कतार का हैंडल।
pvItemToQueue - पंक्तिबद्ध होने के लिए एक सूचक।
xTicksToWait - वह समय जिसके दौरान कार्य पंक्तिबद्ध स्थान पर होना चाहिए ताकि कतार में जगह दिखाई दे सके। आप portMAX_DELAY को निर्दिष्ट कर सकते हैं ताकि कार्य अनिश्चित समय के लिए बंद अवस्था में हो, अर्थात जब तक कतार में एक जगह दिखाई न दे।
वापसी pdPASS, या irQUEUE_FULL - यदि नया तत्व सफलतापूर्वक कतार में लिखा जाता है, तो फ़ंक्शन pdPASS देता है, अगर पर्याप्त जगह नहीं है और xTicksToWait निर्दिष्ट नहीं है, तो कार्य कतार में एक स्थान की प्रतीक्षा करने के लिए अवरुद्ध समय पर जाएगा।

डेटा को पढ़ने के लिए, 2 फ़ंक्शन का उपयोग किया जाता है, मुख्य अंतर, जो यह है कि xQueueReceive कतार से तत्व को निकालता है, और xQueuePeek नहीं करता है।

 portBASE_TYPE xQueueReceive(xQueueHandle xQueue, const void * pvBuffer, portTickType xTicksToWait); portBASE_TYPE xQueuePeek(xQueueHandle xQueue, const void * pvBuffer, portTickType xTicksToWait); 

xQueue - डेटा को लिखने के लिए कतार का हैंडल।
pvBuffer - मेमोरी बफ़र को सूचक जिसमें कतार से डेटा पढ़ा जाएगा। बफर प्रकार = कतार तत्वों का प्रकार।
xTicksToWait - उस समय के दौरान जब कतार में डेटा दिखाई देने के लिए कार्य एक बंद अवस्था में होना चाहिए। आप portMAX_DELAY को निर्दिष्ट कर सकते हैं ताकि कार्य अनिश्चित समय के लिए बंद अवस्था में हो, अर्थात जब तक नया डेटा कतार में नहीं दिखता। आगे मैं बताऊंगा कि गेटकीपर टास्क बनाने के लिए इसका उपयोग कैसे किया जाता है।
वापसी pdPASS, या इरकुइज_EMPTY - यदि नया आइटम सफलतापूर्वक कतार से पढ़ा गया था, तो फ़ंक्शन pdPASS देता है, यदि कतार खाली है और xTicksToWait निर्दिष्ट है, तो कार्य कतार में नए डेटा की प्रतीक्षा करने के लिए एक अवरुद्ध समय पर जाएगा।

कतार में वस्तुओं की संख्या देखने के लिए, आप फ़ंक्शन का उपयोग कर सकते हैं

 unsigned portBASE_TYPE uxQueueMessagesWaiting( xQueueHandle xQueue ); 

महत्वपूर्ण: उपरोक्त कार्यों का उपयोग ISRs (व्यवधान) में नहीं किया जा सकता है और उनके लिए एक विशेष प्रत्यय ISR के साथ विशेष संस्करण हैं, जिनका व्यवहार पिछले मापदंडों को छोड़कर पिछले कार्यों के समान है:

 portBASE_TYPE xQueueSendToFrontFromISR( xQueueHandle xQueue, void *pvItemToQueue, portBASE_TYPE *pxHigherPriorityTaskWoken ); portBASE_TYPE xQueueSendToBackFromISR(xQueueHandle xQueue, void *pvItemToQueue, portBASE_TYPE *pxHigherPriorityTaskWoken); portBASE_TYPE xQueueReceiveFromISR(xQueueHandle xQueue, const void *pvBuffer, portBASE_TYPE *pxHigherPriorityTaskWoken); 

pxHigherPriorityTaskWoken - चूंकि कतार में लिखने से डेटा की प्रतीक्षा करने वाले कार्य को अनलॉक किया जा सकता है और वर्तमान कार्य की तुलना में उच्च प्राथमिकता हो सकती है, हमें मजबूरन संदर्भ स्विचिंग करने की आवश्यकता होती है (इसके लिए हमें taskYIELD () मैक्रो को कॉल करना होगा)। यदि आवश्यक हो, तो यह पैरामीटर pdTRUE के बराबर होगा।

कतारों के कुशल उपयोग के बारे में कुछ शब्द। उदाहरण के लिए, UART पर विचार करें - एक विशिष्ट दृष्टिकोण के साथ, प्रत्येक प्राप्त बाइट को तुरंत कतार में लिखा जाता है, जो इसके कारण इसके लायक नहीं है यह काफी अक्षम है, पहले से ही काफी कम आवृत्तियों पर। आईएसआर में बुनियादी डेटा प्रसंस्करण को अंजाम देना और फिर इसे कतार में स्थानांतरित करना अधिक कुशल है, लेकिन यह समझना महत्वपूर्ण है कि आईएसआर कोड जितना संभव हो उतना कम होना चाहिए।

तथाकथित द्वारपाल कार्य के एक उदाहरण पर विचार करें (मुझे नहीं पता कि यह कैसे सही ढंग से अनुवाद करना है, अगर कोई मुझे बताता है, तो मैं आभारी रहूंगा :))।
गेटकीपर कार्य एक सरल विधि है जो मल्टीथ्रेडेड प्रोग्रामिंग की मुख्य समस्याओं से बचती है: प्राथमिकताओं को निष्क्रिय करना, और कार्य को गतिरोध में लाना।
गेटकीपर कार्य एकमात्र तरीका है जिसकी संसाधन तक सीधी पहुंच है, अन्य सभी कार्यों को इस कार्य के माध्यम से संसाधन तक पहुंचने की आवश्यकता है।
एक साधारण कंकाल द्वारपाल कार्य पर विचार करें। यह एक विशुद्ध रूप से दूर का उदाहरण है, लेकिन जो सामान्य सिद्धांत को समझने में मदद करेगा। मान लेते हैं कि हमें कुछ डेटा सुरक्षित रूप से भेजने की आवश्यकता है, उदाहरण के लिए, UART के माध्यम से।

 // Gatekeeper    . void vGatekeeperTask( void *pvParameteres ) { char oneByte; //   -   ,      UART ,         . for( ;; ) { //    . //     portMAX_DELAY    ,      . //     ,     . xQueueReceive( xDataQueue, &oneByte, portMAX_DELAY); //    ,     . vSendByteToUART( oneByte ); //    . } } 

इस प्रकार, कोई भी कार्य जो यूएआरटी का उपयोग करके एक बाइट भेजना चाहता है, वह उपयोगिता कार्यों में से एक का उपयोग कर सकता है, उदाहरण के लिए, यह:

 void vUARTPutByte( char byte) { //      ,       ,    . xQueueSend( xDataQueue, &byte, 0 ); } 

यह भी ध्यान देने योग्य है कि आपको सीमित नहीं होना चाहिए, केवल कतार के डेटा प्रकार के रूप में चार है, लेकिन आप संरचनाओं का उपयोग करके पूरे पाइप लाइन को व्यवस्थित कर सकते हैं।

बाइनरी सेमाफोर्स।

जब भी कोई घटना होती है (उदाहरण के लिए, एक बटन दबाने) कार्य को अनलॉक करने के लिए बाइनरी सेमाफोर का उपयोग किया जा सकता है।
विशिष्ट कार्य परिदृश्य: जब एक निश्चित व्यवधान ISR में प्रवेश करता है, तो हम सेमीफ़ोर को छोड़ देते हैं , कार्य के परिणामस्वरूप, इंतज़ार कर रहे सेमाफ़ोर सेमाफ़ोर लेते हैं और किसी भी ऑपरेशन के लिए अनलॉक की गई स्थिति छोड़ देते हैं। यह तंत्र निम्नलिखित आकृति में दिखाया गया है।

सभी प्रकार के सेमाफोर को संग्रहीत करने के लिए, xSemaphoreHandle डेटा प्रकार का उपयोग किया जाता है ।
सेमाफोर के साथ काम करने के कार्यों पर विचार करें:

 void vSemaphoreCreateBinary( xSemaphoreHandle xSemaphore ); 

xSemaphore - यह फ़ंक्शन एक मैक्रो का उपयोग करके कार्यान्वित किया जाता है, इसलिए आपको संभाल के मूल्य को पास करने की आवश्यकता है, न कि इसके लिए एक सूचक। यदि सेमाफोर सफलतापूर्वक बनाया गया है, तो xSemaphore NULL नहीं है।

सेमाफोर को "लेने" के लिए, एक विशेष फ़ंक्शन का उपयोग किया जाता है:

 portBASE_TYPE xSemaphoreTake( xSemaphoreHandle xSemaphore, portTickType xTicksToWait ); 

xSemaphore - सेमाफोर संभाल लिया जाए।
xTicksToWait - उस समय के दौरान जब कार्य एक बंद अवस्था में होना चाहिए, जिसके बाद सेमाफोर उपलब्ध होगा। आप portMAX_DELAY को निर्दिष्ट कर सकते हैं ताकि कार्य अनिश्चित समय के लिए बंद अवस्था में हो, अर्थात जब तक सेमाफोर उपलब्ध नहीं होता।
वापसी pdPASS, या pdFALSE - pdPASS - यदि सेमाफोर प्राप्त होता है, तो pdFALSE - यदि सेमीफोर अनुपलब्ध है।

सेमाफोर को "देने" के लिए, विशेष कार्यों का भी उपयोग किया जाता है। मैं ISR संस्करण पर विचार करूंगा क्योंकि सबसे अधिक बार, ISRs के साथ संयोजन में सेमाफोर का उपयोग किया जाता है।

 portBASE_TYPE xSemaphoreGiveFromISR( xSemaphoreHandle xSemaphore, portBASE_TYPE *pxHigherPriorityTaskWoken ); 

xSemaphore - semaphore हैंडल को दिया जाना है।
pxHigherPriorityTaskWoken - चूंकि सेमाफोर के "ट्रांसफर" से सेमीफोर डेटा के लिए प्रतीक्षा करने वाले कार्य को अनलॉक करने का कारण बन सकता है जिसमें वर्तमान कार्य की तुलना में अधिक प्राथमिकता है, हमें एक मजबूर संदर्भ स्विच करने की आवश्यकता है (इसके लिए हमें taskYIELD () मैक्रो) को कॉल करने की आवश्यकता है। यदि आवश्यक हो, तो यह पैरामीटर pdTRUE के बराबर होगा।
वापसी pdPASS, या pdFALSE - pdPASS - यदि सेमाफोर दिया जाता है, तो pdFALSE - यदि सेमाफोर पहले से ही उपलब्ध है, लेकिन संसाधित नहीं है।

एक उदाहरण के रूप में, मैं एक छोटा प्रोग्राम कोड दूंगा, ISR के लिए मैंने एक pseudocode लिखा था:

 xSemaphoreHandle xButtonSemaphore; void vButtonHandlerTask( void *pvParameteres ) { for( ;; ) { xSemaphoreTake( xButtonSemaphore, portMAX_DELAY ); //       . } } void main() { //   vInitSystem(); vSemaphoreCreateBinary( xButtonSemaphore ); if( xButtonSemaphore != NULL ) { //  .      ,     ! xTaskCreate( &vButtonHandlerTask, (signed char *)"GreenBlink", configMINIMAL_STACK_SIZE, NULL, 1, NULL ); //  , ..   . vTaskStartScheduler(); } //      ,      ,     .       . for( ;; ) { } } ISR_FUNCTION processButton() { portBASE_TYPE xTaskWoken; if( buttonOnPressed ) { xSemaphoreGiveFromISR( xButtonSemaphore, &xTaskWoken ); if( xTaskWoken == pdTRUE) { taskYIELD(); } } } 

गिनती के सेमाफोर।

एक विशिष्ट स्थिति पर विचार करें जो सेमीफोर का उपयोग करते समय मौजूद है:
1. एक घटना थी जो एक रुकावट का कारण बनी।
2. ISR "सेमाफोर" देता है वेटिंग टास्क सेमाफोर को अनलॉक करता है।
3. इंतजार करने वाला कार्य "अर्ध" लेता है।
4. वांछित कोड को निष्पादित करने के बाद, कार्य फिर से एक बंद स्थिति में चला जाता है, नई घटनाओं की प्रतीक्षा कर रहा है।
यह एल्गोरिथ्म ठीक काम करता है, लेकिन उच्च आवृत्तियों पर नहीं। उच्च आवृत्तियों पर, गिनती के सेमाफोर का उपयोग करना आवश्यक है, जो, एक नियम के रूप में, 2 मामलों में उपयोग किया जाता है:

• घटनाओं के साथ सिंक्रनाइज़ेशन के लिए भी, लेकिन उच्च आवृत्तियों पर।
• संसाधन प्रबंधन। इस मामले में, सेमाफोर की संख्या उपलब्ध संसाधनों की मात्रा को इंगित करती है।

जैसा कि ऊपर उल्लेख किया गया है, xSemaphoreHandle डेटा प्रकार का उपयोग सभी प्रकार के सेमाफोर को संग्रहीत करने के लिए किया जाता है, और चूंकि यह सेमाफोर का उपयोग करने से पहले बनाया जाना चाहिए, आपको गिने हुए सेमाफोर बनाने के लिए एक विशेष फ़ंक्शन का उपयोग करने की आवश्यकता है:

 xSemaphoreHandle xSemaphoreCreateCounting( unsigned portBASE_TYPE uxMaxCount, unsigned portBASE_TYPE uxInitialCount ); 

uxMaxCount - एक काउंटर की अधिकतम संख्या, जो स्टोर कर सकती है। एक कतार के साथ सादृश्य द्वारा, यह कतार की लंबाई है।
uxInitialCount - सेमाफोर बनाने के बाद काउंटर वैल्यू।
रिटर्न NULL नहीं है - यदि सेमीफ़ोर बनाया गया था, तो फ़ंक्शन एक गैर-NULL मान लौटाता है।
अन्यथा, पिछले वाले के समान फ़ंक्शन का उपयोग सेमाफोरस की गिनती के साथ काम करने के लिए किया जाता है।