माइक्रोकंट्रोलर में निरंतरता आधारित मल्टीटास्किंग

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

सी एक्सटेंशन और सैंपल लाइब्रेरी को लागू करने के कुछ तरीके इस प्रकार हैं:

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

इस लेख में, मैं एडम डंकल के प्रोटोथ्रेड्स लाइब्रेरी को देखता हूं। यह सरल और न्यूनतर है, जिसमें कई हेडर फ़ाइलों में मैक्रोज़ का एक सेट शामिल है, C ++ के साथ संगत है। लाइब्रेरी में वह सब कुछ है जो आपको चाहिए, अन्य पुस्तकालयों, प्लेटफार्मों और संकलक पर कोई निर्भरता नहीं है। डायनेमिक मेमोरी का उपयोग नहीं करता है। यदि आपके पास जीसीसी है, तो पुस्तकालय चर लेबल के उपयोग के माध्यम से अतिरिक्त सुविधाएँ प्रदान करेगा। सामान्य तौर पर, यह पुस्तकालय मुझे एम्बेडेड अनुप्रयोगों के प्रोग्रामिंग के लिए सबसे सुविधाजनक लगता था, जहां विभिन्न प्रकार के आर्किटेक्चर, कंपाइलर और ऑपरेटिंग सिस्टम हैं।
अपनी वेबसाइट पर पुस्तकालय के कार्यों का अच्छी तरह से वर्णन कैसे किया जाता है, मैं केवल एपीआई का संक्षिप्त विवरण और उपयोग के कुछ उदाहरण दूंगा। बेशक, एक पुस्तकालय का उपयोग करना "सिंटैक्टिक शुगर" है और यह सब किया जा सकता है, उदाहरण के लिए, राज्य मशीनों (वास्तव में, पुस्तकालय आपके कार्यों को अंतर्निहित राज्य मशीनों में परिवर्तित करता है)। लेकिन कई कार्यों में, पुस्तकालय कार्यक्रम पाठ की मात्रा को कम करता है, रैखिकता, स्पष्टता बढ़ाता है और, परिणामस्वरूप, विकास के समय और त्रुटियों की संभावना को कम कर सकता है। यदि आप एक राज्य मशीन का उपयोग करके एक समस्या को हल करते हैं और आपके पास एक दर्जन या अधिक राज्य हैं, तो उनमें से कई क्रमिक रूप से चलते हैं, तो सबसे अधिक संभावना है कि प्रोटॉथ्रेड आपके जीवन को सरल बना सकते हैं, और किसी भी मामले में इसका विकल्प होना उपयोगी है। मेरे अनुभव में, प्रोटोथ्रेड्स का उपयोग करके प्रोग्राम के लिए स्रोत कोड राज्य मशीनों का उपयोग करते हुए लिखे गए समकक्ष की तुलना में लगभग 20 से 50% कम है।

इस आलेख में उदाहरण विंडोज के तहत लिखे गए थे, वे मिनगव और विजुअल स्टूडियो में काम करते हैं, लेकिन ध्यान दें! Visual Studio में, DEBUG कॉन्फ़िगरेशन में, प्रोटॉथ्रेड्स लाइब्रेरी, जैसा कि यह है, संकलित नहीं है!
इसका कारण यह है कि वीएस में डिबग कॉन्फ़िगरेशन में __LINE__ मैक्रो किसी कारण से एक फ़ंक्शन कॉल में एक स्थिरांक में बदल जाता है, यह आसानी से इलाज किया जाता है यदि फ़ाइल lc-switch.h को बदल दिया जाता है

#define LC_SET(s) s = __LINE__; case __LINE__: 

पर

 #define LC_SET(s) s = __COUNTER__+1; case (__COUNTER__): 

जीसीसी में, सभी प्लेटफार्मों और प्रोसेसर के तहत, पुस्तकालय बिना बदलाव के काम करता है।
लाइब्रेरी का उपयोग करने के लिए, आपको अपने प्रोजेक्ट में .h फ़ाइलों को डाउनलोड और अनज़िप करना होगा और हेडर को शामिल करना होगा:

 #include "pt.h" 

तो हम पुस्तकालय से क्या प्राप्त कर सकते हैं:

अगली कड़ियों

खुद को जारी रखना बहुत उपयोगी नहीं है, लेकिन वे अन्य कार्यक्रम संरचनाओं के लिए आधार हैं।
जारी रखने की क्षमता वाला एक कार्य इस प्रकार घोषित किया गया है:

 int name(struct pt *pt [,  ]) 

या इस तरह एक मैक्रो का उपयोग कर:

 PT_THREAD(name(struct pt *pt [,  ])) 

पीटी तर्क एक निरंतरता के संदर्भ के लिए एक संकेतक है, जो एक तरह से या किसी अन्य स्थान को संग्रहीत करता है जहां फ़ंक्शन बाधित था।
फ़ंक्शन संदर्भ द्वारा अतिरिक्त तर्कों के माध्यम से परिणाम वापस कर सकता है।
कथनों की शुरुआत से पहले स्ट्रीम के अंत में एक मैक्रो PT_BEGIN (pt) होना चाहिए - PT_END (pt) । यदि आपको प्रत्येक फ़ंक्शन कॉल के साथ कुछ क्रियाएं करने की आवश्यकता होती है, तो उन्हें मैक्रो PT_BEGIN (pt) से पहले रखा जाता है। यह हो सकता है, उदाहरण के लिए, टाइमर, काउंटर आदि के मूल्य को अपडेट करना।
PT_YIELD (pt) कमांड परिणाम देता है और अगली बार फ़ंक्शन को कॉल करने पर, फ़ंक्शन अगले स्टेटमेंट से जारी रहता है।
स्ट्रीम का व्यवधान (उदाहरण के लिए, त्रुटि के मामले में) मैक्रो PT_EXIT (pt) द्वारा किया जाता है। स्ट्रीम के अंत तक या रुकावट के बाद (मैक्रोज़ PT_END (pt) और PT_EXIT (pt) के बाद , PT_RESTART (pt) कमांड के साथ फिर से शुरू होता है, फ़ंक्शन शुरुआत में "रीवाउंड" होता है और अगले कॉल पर फिर से काम करना शुरू कर देगा।
फ़ंक्शन एक रुकावट देता है - फ़ंक्शन के रुकावट का कारण: PT_WAITING - एक घटना की प्रतीक्षा कर रहा है, PT_YIELDED - मान लौटाता है , PT_EXITED - PT_EXIT (pt) कमांड के साथ बाहर निकलें, PT_ENDED - फ़ंक्शन PT_END (pt) के अंत तक पहुंच गया है।
पहली बार एक निरंतरता का उपयोग करने से पहले, आपको PT_INIT (pt) मैक्रो के साथ इसके संदर्भ को इनिशियलाइज़ करना होगा।
चर जिन्हें कॉल के बीच अपने मूल्यों को बनाए रखना चाहिए, उन्हें स्थिर के रूप में घोषित किया जाना चाहिए, या संदर्भ द्वारा फ़ंक्शन में पारित किया जाना चाहिए।

जनरेटर

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

 #include "pt.h" #include <stdio.h> static int fib(struct pt *pt, int max, int* res) { static int a,b; PT_BEGIN(pt); a=0;b=1; while (a<max) { *res=a; PT_YIELD(pt); b+=a; a=ba; } PT_END(pt); } int main(void) { int value; struct pt pt1; PT_INIT(&pt1); while( fib(&pt1, 1000, &value) < PT_EXITED ){ printf("Value %d\n",value); } return 0; } 

coroutine

शास्त्रीय कोरआउट प्रोग्राम थ्रेड होते हैं जो एक दूसरे पर नियंत्रण स्थानांतरित कर सकते हैं, और फिर इंटरप्ट लोकेशन पर लौट सकते हैं। जब कई प्रोग्राम प्रवाह (फ़ंक्शन) के बीच कॉरटाइन्स का उपयोग किया जाता है, तो यह स्पष्ट नहीं है कि मुख्य कार्यक्रम क्या होना चाहिए और "द आर्ट ऑफ़ प्रोग्रामिंग" पुस्तक का उपप्रोग्राम (वॉल्यूम, वॉल्यूम I) क्या होना चाहिए। उदाहरण के लिए, आपके प्रोग्राम का कुछ हिस्सा किसी तरह डेटा का उत्पादन करता है, दूसरा हिस्सा किसी तरह उनका उपभोग करता है। इसके अलावा, उपभोक्ता और निर्माता दोनों ही काफी जटिल हैं। जब आप डेटा प्रोड्यूसर प्रोग्राम लिखते हैं, तो आप डेटा खपत को एक फ़ंक्शन के रूप में कॉल करना चाहते हैं जब आपके पास कुछ डेटा तैयार होता है। लेकिन जब आप किसी डेटा उपभोक्ता को प्रोग्राम करते हैं, तो आप पहले से ही उपभोक्ता को मुख्य प्रोग्राम बनाना चाहते हैं, और जब डेटा प्राप्त करना और प्रोसेस करना संभव हो तो जेनरेशन फ़ंक्शन को कॉल करें। इस मामले में, प्रोग्राम-सबप्रोग्राम रिश्ते के बजाय, कोरटाइन-कोरटाइन संबंध काफी उपयुक्त है। आप अभी भी पहले सभी डेटा को मेमोरी में उत्पन्न कर सकते हैं, और फिर तुरंत उन सभी का उपभोग कर सकते हैं, लेकिन मेमोरी से अधिक डेटा हो सकता है, खासकर एम्बेडेड सिस्टम के लिए। कॉरटीन को निरंतरता के साथ प्राप्त करना भी आसान है।
उदाहरण के लिए, हमें बड़ी मात्रा में xml डेटा उत्पन्न करने की आवश्यकता है, फिर उसे संग्रहित करें, फिर उसे किसी फ़ाइल में सहेजें या नेटवर्क पर स्थानांतरित करें। सादगी के लिए, हम केवल पीढ़ी और भंडारण को लागू करते हैं। स्मृति और फ़ाइल कार्रवाई पर विभिन्न त्रुटि जाँच भी छोड़ दी जाती हैं। makeXmlLine हमारे निर्माता है। इनपुट वाक्य को पार्स करता है और प्रत्येक कॉल के साथ एक XML स्ट्रिंग उत्पन्न करता है। writeXmlLine एक उपभोक्ता है, प्रत्येक कॉल के साथ यह लाइन को फ़ाइल में बचाता है। जब तक निर्माता की कॉरटीन खत्म नहीं हो जाती (परिणाम PT_EXITED लौटाता है ) तब तक कोरआउट को एक-एक करके बुलाया जाता है।

 #include "pt.h" #include <stdio.h> #include <string.h> #include <malloc.h> static int makeXmlLine(struct pt *pt, char* dst, char* src) { static char* text; //   static         char * pch; PT_BEGIN(pt); strcpy(dst,"<?xml version=\"1.0\" encoding=\"Windows-1251\"?>"); PT_YIELD(pt); strcpy(dst,"<text>"); PT_YIELD(pt); text=strdup(src); // strtok   ,    pch = strtok (text," ,.!?:"); while (pch != NULL){ sprintf(dst," <word>%s</word>",pch); PT_YIELD(pt); pch = strtok (NULL, " ,.!?:"); } strcpy(dst,"</text>"); PT_YIELD(pt); *dst=0; //     ,     PT_YIELD(pt); free(text); PT_END(pt); } static int writeXmlLine(struct pt *pt, char* fileName, char* str) { static FILE* file; PT_BEGIN(pt); file=fopen(fileName,"w"); //         while(*str){ fprintf(file,"%s\n",str); PT_YIELD(pt); } fclose(file); PT_END(pt); } int main(void) { struct pt pt1,pt2; char xmlString[128]; PT_INIT(&pt1); PT_INIT(&pt2); //    ,     while (makeXmlLine(&pt1,xmlString, "Hello, world! Pleased to meet you!") < PT_EXITED) writeXmlLine(&pt2,"file.xml",xmlString); return 0; } 

मल्टीटास्किंग

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

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

मल्टीटास्किंग के लिए, प्रोटोथ्रेड्स निम्नलिखित प्राइमेटिव प्रदान करता है:

• मैक्रोज़ PT_WAIT_UNTIL और PT_WAIT_WH किसी विशिष्ट घटना के होने तक एक थ्रेड को ब्लॉक करने के लिए
• मैक्रो PT_WAIT_THREAD , थ्रेड को तब तक रोकें जब तक दूसरा थ्रेड समाप्त न हो जाए
• मैक्रो PT_SPAWN एक धागे को शुरुआत से एक और धागा शुरू करने की अनुमति देता है और इसके खत्म होने की प्रतीक्षा करता है
• मैक्रो PT_SCHEDULE , एक आदिम प्रवाह प्रबंधक, अगले coroutine चरण को निष्पादित करता है और वापस करता है कि उसने अपना काम पूरा किया है या नहीं
• संरचना pt_sem , PT_SEM_INIT , PT_SEM_WAIT , PT_SEM_SIGNAL - सेमाफोर के साथ काम करने के लिए आदिम व्यावहारिक रूप से बेकार हैं

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

हमारे पास 3 धाराएँ होंगी: रैकेट, गेंद और खेल का मैदान। एक और सहायक उपवाक्य विराम देगा।
शेड्यूलर सरल होगा: हम प्रत्येक प्रवाह पर नियंत्रण स्थानांतरित करते हैं, फिर 10ms का ठहराव। यदि कोई प्रवाह समाप्त होता है तो खेल समाप्त होता है (गेंद मैदान से बाहर उड़ सकती है, या हम सभी ईंटों को बाहर निकाल सकते हैं)।

 while (PT_SCHEDULE(printField(&fieldPt)) && PT_SCHEDULE(controlThr(&ctrlPt)) && PT_SCHEDULE(ballThread(&ballPt))) Sleep(10); 

PrintField स्ट्रीम पहले मेमोरी में एक गेम फ़ील्ड बनाता है, फिर, एक लूप में, यह फ़ील्ड परिवर्तन ध्वज की प्रतीक्षा करता है और स्क्रीन पर संपूर्ण फ़ील्ड को फिर से बनाता है। यदि ईंटें समाप्त हो जाती हैं, तो प्रवाह समाप्त हो जाता है।
ControlThr स्ट्रीम फ़ील्ड पर थोड़ा सा खींचती है, एक बटन को दबाए जाने की प्रतीक्षा करता है, और बिट को स्थानांतरित करता है। या "क्ष" दबाकर खेल को बाधित करता है।
पॉज़थ्रेड थ्रेड केवल आवश्यक ठहराव रखता है, जो PT_SPAWN का उपयोग करके एक कार्य को दूसरे से कॉल करने के उदाहरण के लिए बनाया गया है।
बॉलट्रेड थ्रेड गेंद को एक निश्चित गति से पूरे मैदान में घुमाता है, ईंटों को बाहर निकालता है और दीवारों और चमगादड़ों को उछाल देता है। गेंद के मैदान से बाहर उड़ने पर यह प्रवाह समाप्त होता है।

कुछ और सुझाव:
यदि आप gcc का उपयोग करते हैं, तो मैं लाइब्रेरी को जोड़ने से पहले एक #define डालने की सलाह देता हूं, जैसे:

 #define LC_INCLUDE "lc-addrlabels.h" #include "pt.h" 

यह आपको मान एक्सटेंशन के रूप में gcc लेबल का उपयोग करने की अनुमति देता है, और आप स्विच स्टेटमेंट के अंदर निष्पादन प्रवाह को बाधित और स्विच कर सकते हैं। अन्यथा, एक्सटेंशन स्वयं स्विच स्टेटमेंट का उपयोग करके बनाए जाएंगे, वे आपके स्विच के साथ नहीं मिलेंगे।
कृपया ध्यान दें कि धारा के अंत के बाद, यह स्वचालित रूप से फिर से शुरू होता है। SCHEDULE रिटर्न 0 के बाद, आपको या तो इसे कॉल करना बंद करना होगा, या इसे स्ट्रीम के अंत में स्थायी रूप से लॉक करना होगा: PT_WAIT_WHILE (pt, 1)