Arduino freertos ट्यूटोरियल 1

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

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

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

जैसे कि FreeRTOS 8-बिट MCU पर चल सकता है इसलिए इसे Arduino Uno बोर्ड पर भी चलाया जा सकता है। हमें बस FreeRTOS लाइब्रेरी को डाउनलोड करना है और फिर API का उपयोग करके कोड को लागू करना शुरू करना है। यह ट्यूटोरियल एक पूर्ण शुरुआत के लिए है, नीचे विषय हैं, हम इस Arduino FreeRTOS ट्यूटोरियल में कवर करेंगे:

1. RTOS कैसे काम करता है
2. आरटीओएस में कुछ अक्सर इस्तेमाल किए जाने वाले शब्द
3. Arduino IDE में FreeRTOS की स्थापना
4. उदाहरण के साथ FreeRTOS कार्य कैसे बनाएं

RTOS कैसे काम करता है?

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

अब, आइए देखें कि आरटीओएस कर्नेल में क्या होता है यदि हम एक-दूसरे अंतराल के साथ एलईडी ब्लिंकिंग के लिए एक कार्य बनाना चाहते हैं और इस कार्य को सर्वोच्च प्राथमिकता पर रखते हैं।

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

राज्य आरेख के नीचे के रूप में यह चल रहे राज्य में गैर-चल रहे कार्य के स्विचिंग को दर्शाता है ।

हर नया बनाया गया कार्य रेडी स्टेट (चालू राज्य का हिस्सा नहीं) में जाता है। यदि बनाए गए कार्य (टास्क 1) में अन्य कार्यों की तुलना में सर्वोच्च प्राथमिकता है, तो यह चलने वाले राज्य में चला जाएगा। अगर यह रनिंग टास्क दूसरे टास्क से प्रमोट होता है, तो यह फिर से तैयार अवस्था में चला जाएगा। अधिक यदि टास्क 1 को अवरुद्ध एपीआई का उपयोग करके अवरुद्ध किया जाता है, तो सीपीयू इस कार्य के साथ संलग्न नहीं करेगा, जब तक कि उपयोगकर्ता द्वारा निर्धारित टाइमआउट नहीं होगा।

यदि सस्पेंड एपीआई का उपयोग करके टास्क 1 को रनिंग स्टेट में निलंबित कर दिया जाता है, तो टास्क 1 निलंबित राज्य में चला जाएगा और यह फिर से शेड्यूल करने के लिए उपलब्ध नहीं है। यदि आप निलंबित अवस्था में टास्क 1 को फिर से शुरू करते हैं तो यह तैयार अवस्था में वापस चला जाएगा जैसा कि आप ब्लॉक आरेख में देख सकते हैं।

यह मूल विचार है कि टास्क कैसे चलते हैं और उनके राज्यों को बदलते हैं । इस ट्यूटोरियल में, हम FreeRTOS API का उपयोग करके Arduino Uno में दो कार्यों को कार्यान्वित करेंगे।

आरटीओएस में अक्सर उपयोग किए जाने वाले शब्द

1. कार्य: यह कोड का एक टुकड़ा है जिसे निष्पादित करने के लिए सीपीयू पर शेड्यूल किया जाता है।

2. समयबद्धक: यह तैयार राज्य सूची से चल रहे राज्य के लिए एक कार्य का चयन करने के लिए जिम्मेदार है। अनुसूचियों को अक्सर लागू किया जाता है ताकि वे सभी कंप्यूटर संसाधनों को व्यस्त रखें (जैसा कि लोड संतुलन में)।

3. पूर्वधारणा: यह बिना किसी सहकारिता के चल रहे राज्य से इसे हटाने के इरादे से पहले से ही निष्पादित कार्य को अस्थायी रूप से बाधित करने का कार्य है।

4. संदर्भ स्विचिंग: प्राथमिकता-आधारित पूर्वनिर्धारण में, शेड्यूलर हर सिस्टिक बाधा पर तैयार कार्य सूची की प्राथमिकता के साथ कार्यों को चलाने की प्राथमिकता की तुलना करता है । यदि सूची में कोई कार्य है जिसकी प्राथमिकता कार्य चलाने से अधिक है तो संदर्भ स्विच होता है। मूल रूप से, इस प्रक्रिया में विभिन्न कार्यों की सामग्री उनकी संबंधित स्टैक मेमोरी में बच जाती है।

5. अनुसूचित नीतियों के प्रकार:

1. प्रीमेप्टिव शेड्यूलिंग: इस प्रकार के शेड्यूलिंग में, प्राथमिकताओं पर विचार किए बिना कार्य समान समय स्लाइस के साथ चलते हैं।
2. प्राथमिकता-आधारित प्रीमेप्टिव: उच्च प्राथमिकता वाला कार्य पहले चलेगा।
3. सहकारी निर्धारण: संदर्भ स्विचिंग केवल चल रहे कार्यों के सह-संचालन के साथ होगी। टास्क जब तक कहा जाता है तब तक लगातार चलेगा।

6. कर्नेल ऑब्जेक्ट्स: कुछ कार्य करने के लिए कार्य को संकेत देने के लिए, सिंक्रनाइज़ेशन प्रक्रिया का उपयोग किया जाता है। इस प्रक्रिया को करने के लिए कर्नेल ऑब्जेक्ट का उपयोग किया जाता है। कुछ कर्नेल ऑब्जेक्ट ईवेंट, सेमाफोर, क्व्यू, म्यूटेक्स, मेलबॉक्सेस इत्यादि हैं। हम देखेंगे कि आने वाले ट्यूटोरियल में इन ऑब्जेक्ट्स का उपयोग कैसे किया जाए।

उपरोक्त चर्चा से, हमें RTOS अवधारणा के बारे में कुछ बुनियादी विचार मिले हैं और अब हम Arduino में FreeRTOS परियोजना को लागू कर सकते हैं। तो, आइए Arduino IDE में FreeRTOS लाइब्रेरी स्थापित करके शुरुआत करें ।

Arduino FreeRTOS लाइब्रेरी की स्थापना

1. Arduino IDE खोलें और स्केच पर जाएं -> लाइब्रेरी शामिल करें -> लाइब्रेरी प्रबंधित करें । FreeRTOS के लिए खोजें और लाइब्रेरी को नीचे दिखाए अनुसार स्थापित करें।

आप लाइब्रेरी को github से डाउनलोड कर सकते हैं और स्केच में.zip फ़ाइल जोड़ सकते हैं-> लाइब्रेरी शामिल करें ->.zip फ़ाइल।

अब, Arduino IDE को पुनरारंभ करें। यह लाइब्रेरी कुछ उदाहरण कोड प्रदान करती है, जो फ़ाइल -> उदाहरण -> फ्रीआरटीओएस में नीचे दिखाए गए अनुसार पाया जा सकता है ।

यहां हम कार्य को समझने के लिए खरोंच से कोड लिखेंगे, बाद में आप उदाहरण कोड की जांच कर सकते हैं और उनका उपयोग कर सकते हैं।

सर्किट आरेख

नीचे Arduino पर FreeRTOS का उपयोग करके ब्लिंकिंग एलईडी कार्य बनाने के लिए सर्किट आरेख नीचे दिया गया है:

Arduino FreeRTOS उदाहरण- Arduino IDE में FreeRTOS कार्य बनाना

आइए एक FreeRTOS प्रोजेक्ट लिखने के लिए एक बुनियादी संरचना देखें।

1. सबसे पहले, Arduino FreeRTOS हेडर फ़ाइल को शामिल करें

#शामिल

2. फ़ंक्शन को उन सभी फ़ंक्शनों का प्रोटोटाइप दें जो आप निष्पादन के लिए लिख रहे हैं जो कि लिखा गया है

शून्य टास्क 1 (शून्य * pvParameters); शून्य टास्क 2 (शून्य * pvParameters); .. …।

3. अब, शून्य सेटअप () फ़ंक्शन में, कार्य बनाएं और कार्य शेड्यूलर प्रारंभ करें।

कार्य बनाने के लिए, xTaskCreate () एपीआई को कुछ निश्चित मापदंडों / तर्कों के साथ सेटअप फ़ंक्शन में कहा जाता है ।

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

6 तर्क हैं जो किसी भी कार्य को बनाते समय पारित किए जाने चाहिए। आइए देखें कि ये तर्क क्या हैं

1. pvTaskCode: यह केवल फ़ंक्शन के लिए एक संकेतक है जो कार्य को लागू करता है (प्रभाव में, बस फ़ंक्शन का नाम)।
2. pcName: कार्य के लिए एक वर्णनात्मक नाम। यह FreeRTOS द्वारा उपयोग नहीं किया गया है। यह डीबगिंग उद्देश्यों के लिए विशुद्ध रूप से शामिल है।
3. usStackDepth: प्रत्येक कार्य का अपना एक विशिष्ट स्टैक होता है जिसे कार्य के निर्माण के समय कर्नेल द्वारा आवंटित किया जाता है। मान उन शब्दों की संख्या को निर्दिष्ट करता है जो स्टैक को पकड़ सकते हैं, बाइट्स की संख्या को नहीं। उदाहरण के लिए, यदि स्टैक 32-बिट चौड़ा है और usStackDepth 100 के रूप में पारित किया गया है, तो रैम में स्टैक स्थान के 400 बाइट आवंटित किए जाएंगे (100 * 4 बाइट्स)। इसका बुद्धिमानी से उपयोग करें क्योंकि Arduino Uno में केवल 2Kbytes RAM है।
4. pvParameters: टास्क इनपुट पैरामीटर (NULL हो सकता है)।
5. uxPriority: कार्य की प्राथमिकता (0 सबसे कम प्राथमिकता) है।
6. pxCreatedTask: इसे बनाया जा रहा कार्य को हैंडल करने के लिए उपयोग किया जा सकता है। इस हैंडल का उपयोग एपीआई कॉल में कार्य को संदर्भित करने के लिए किया जा सकता है, उदाहरण के लिए, कार्य प्राथमिकता को बदलें या कार्य को हटा दें (NULL हो सकता है)।

कार्य निर्माण का उदाहरण

xTaskCreate (कार्य 1, "टास्क 1", 128, NULL, 1, NULL); xTaskCreate (कार्य 2, "कार्य 2", 128, NULL, 2, NULL);

यहां, टास्क 2 की उच्च प्राथमिकता है और इसलिए पहले निष्पादित होता है।

4. कार्य बनाने के बाद, vTaskStartScheduler () का उपयोग करके एक शून्य सेटअप में अनुसूचक शुरू करें ; एपीआई।

5. शून्य लूप () फ़ंक्शन खाली रहेगा क्योंकि हम किसी भी कार्य को मैन्युअल रूप से और असीम रूप से नहीं चलाना चाहते हैं। क्योंकि कार्य निष्पादन अब समयबद्धक द्वारा नियंत्रित किया जाता है।

6. अब, हमें टास्क फ़ंक्शंस लागू करना होगा और उस तर्क को लिखना होगा जिसे आप इन फ़ंक्शंस के अंदर निष्पादित करना चाहते हैं। फ़ंक्शन का नाम xTaskCreate () API के पहले तर्क के समान होना चाहिए ।

शून्य कार्य 1 (शून्य * pvParameters) { जबकि (1) { .. ..आपका तर्क } }

7. चल रहे कार्य को रोकने के लिए अधिकांश कोड में देरी फ़ंक्शन की आवश्यकता होती है, लेकिन RTOS में Delay () फ़ंक्शन का उपयोग करने का सुझाव नहीं दिया जाता है क्योंकि यह CPU को रोकता है और इसलिए RTOS भी काम करना बंद कर देता है। तो FreeRTOS में एक विशिष्ट समय के लिए कार्य को अवरुद्ध करने के लिए एक कर्नेल एपीआई है।

vTaskDelay (const TickType_t xTicksToDelay);

इस एपीआई का उपयोग देरी के प्रयोजनों के लिए किया जा सकता है। यह एपीआई दिए गए टिक्स की संख्या के लिए एक कार्य में देरी करता है। वास्तविक समय जिसके लिए कार्य अवरुद्ध रहता है, टिक दर पर निर्भर करता है। टिक पोर्ट दर से वास्तविक समय की गणना करने के लिए निरंतर portTICK_PERIOD_MS का उपयोग किया जा सकता है।

इसका मतलब है कि यदि आप 200ms की देरी चाहते हैं, तो बस इस पंक्ति को लिखें

vTaskDelay (200 / portTICK_PERIOD_MS);

तो इस ट्यूटोरियल के लिए, हम इन फ्रीआरटीओएस एपीआई का उपयोग तीन कार्यों को लागू करने के लिए करेंगे ।

उपयोग किए जाने वाले एपीआई:

1. xTaskCreate ();
2. vTaskStartScheduler ();
3. vTaskDelay ();

इस ट्यूटोरियल के लिए बनाई जाने वाली टास्क:

1. 200ms आवृत्ति के साथ डिजिटल पिन 8 पर एलईडी पलक
2. 300ms आवृत्ति के साथ डिजिटल पिन 7 पर एलईडी पलक
3. 500ms आवृत्ति के साथ सीरियल मॉनिटर में नंबर प्रिंट करें।

Arduino IDE में FreeRTOS कार्य कार्यान्वयन

1. उपरोक्त बुनियादी संरचना स्पष्टीकरण से, Arduino FreeRTOS हेडर फ़ाइल शामिल करें। फिर फंक्शन प्रोटोटाइप बनाएं। जैसा कि हमारे पास तीन कार्य हैं, इसलिए तीन कार्य करें और यह प्रोटोटाइप है।

#include void TaskBlink1 (शून्य * pvParameters); शून्य TaskBlink2 (शून्य * pvParameters); शून्य टास्कप्रिंट (शून्य * pvParameters);

2. शून्य सेटअप () फ़ंक्शन में, धारावाहिक संचार को 9600 बिट प्रति सेकंड पर आरंभ करें और xTaskCreate () एपीआई का उपयोग करके सभी तीन कार्यों को बनाएं । प्रारंभ में, सभी कार्यों को '1' के रूप में प्राथमिकता दें और शेड्यूलर शुरू करें।

शून्य सेटअप () { Serial.begin (9600); xTaskCreate (TaskBlink1, "Task1", ​​128, NULL, 1, NULL); xTaskCreate (TaskBlink2, "Task2", 128, NULL, 1, NULL); xTaskCreate (टास्कप्रिंट, "टास्क 3", 128, NULL, 1, NULL); vTaskStartScheduler (); }

3. अब, सभी तीन कार्यों को लागू करें जैसा कि टास्क 1 एलईडी ब्लिंक के लिए नीचे दिखाया गया है ।

void TaskBlink1 (शून्य * pvParameters) { pinMode (8, OUTPUT); जबकि (1) { digitalWrite (8, उच्च); vTaskDelay (200 / portTICK_PERIOD_MS); digitalWrite (8, LOW); vTaskDelay (200 / portTICK_PERIOD_MS); } }

इसी तरह, टास्कलिंक 2 फ़ंक्शन को लागू करें । टास्क 3 फ़ंक्शन के रूप में लिखा जाएगा

शून्य टास्कप्रिंट (शून्य * pvParameters) { int काउंटर = 0; जबकि (1) { काउंटर ++; सिरियल.प्रिंटल (काउंटर); vTaskDelay (500 / portTICK_PERIOD_MS); } }

बस। हमने Arduino Uno के लिए एक FreeRTOS Arduino प्रोजेक्ट सफलतापूर्वक पूरा किया है । आप इस ट्यूटोरियल के अंत में एक वीडियो के साथ पूर्ण कोड पा सकते हैं।

अंत में, डिजिटल पिन 7 और 8 पर दो एलईडी कनेक्ट करें और अपने Arduino बोर्ड पर कोड अपलोड करें और सीरियल मॉनिटर खोलें। आप देखेंगे कि एक काउंटर 500ms में एक बार चल रहा है, जैसा कि नीचे दिखाया गया है।

इसके अलावा, एल ई डी का निरीक्षण करें, वे अलग-अलग समय के अंतराल पर निमिष कर रहे हैं। XTaskCreate फ़ंक्शन में प्राथमिकता तर्क के साथ खेलने का प्रयास करें । संख्या बदलें और धारावाहिक मॉनिटर और एलईडी पर व्यवहार का निरीक्षण करें।

अब, आप पहले दो उदाहरण कोड समझ सकते हैं जिसमें एनालॉग रीड और डिजिटल रीड टास्क बनाए जाते हैं। इस तरह, आप केवल Arduino Uno और FreeRTOS API का उपयोग करके अधिक अग्रिम परियोजनाएँ बना सकते हैं।