👎🏻 🛀 🤘🏿 एम्बेडेड के लिए सॉफ्टवेयर डिजाइन के लिए दो दृष्टिकोण 👩🏽‍🍳 🥥 🤘🏼

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

मुझे लगता है कि कहानी के दौरान यह भी स्पष्ट होगा कि किन विशेष मामलों में यह पहली बार उपयोग करने लायक है, और जिसमें आप दूसरे के बिना नहीं कर सकते।

मुझे उम्मीद है कि यह उन सभी के लिए दिलचस्प होगा जो एम्बेडेड सिस्टम के लिए विकास की दुनिया में देखना चाहते हैं। उन लोगों के लिए जो पहले से ही एक कुत्ते को एम्बेडेड में खा चुके हैं, सबसे अधिक संभावना है कि कुछ भी नया नहीं होगा।

थोड़ा सा सिद्धांत (उन लोगों के लिए जो बहुत पहले कदम उठाते हैं)।

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

उदाहरण के लिए, आप किसी प्रकार के सेंसर को एडीसी इनपुट से जोड़ सकते हैं, उदाहरण के लिए, एक तापमान सेंसर, जो जब बिजली की आपूर्ति की जाती है, तो तापमान को इस एडीसी द्वारा मापा वोल्टेज में परिवर्तित करता है।

और नियंत्रक के आउटपुट में, जिसे GPIO (सामान्य प्रयोजन इनपुट-आउटपुट) कहा जाता है, आप उदाहरण के लिए, एक एलईडी कनेक्ट कर सकते हैं (या मोटर की तरह अधिक शक्तिशाली, लेकिन एक एम्पलीफायर के माध्यम से)।

SPI, RS232, USB, आदि। नियंत्रक बाहरी दुनिया के साथ और अधिक जटिल तरीके से संवाद कर सकता है - एक पूर्व निर्धारित प्रोटोकॉल का उपयोग करके संदेश प्राप्त करना और भेजना।

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

बेहतर ढंग से कल्पना करने के लिए कि आपको क्या करना है, यहां पर्यावरण के कुछ उदाहरण दिए गए हैं, जिनके साथ आपको काम करना है: फ्लैश नियंत्रक (एक हार्ड डिस्क के अनुरूप) का आकार 16-256 किलोबाइट है, रैम का आकार 64-25 किलोग्राम किलोबाइट है! और ऐसे माहौल में, न केवल एक एप्लिकेशन लॉन्च करना संभव है, बल्कि मल्टीटास्किंग के लिए पूर्ण समर्थन के साथ एक वास्तविक समय ऑपरेटिंग सिस्टम भी है!

नीचे दिए गए उदाहरण छद्म कोड में हैं, कभी-कभी सी के समान है। कार्यान्वयन विवरण के बिना, जहां यह समझने के लिए आवश्यक नहीं है।

तो, "सुपर साइकिल" दृष्टिकोण।

इस दृष्टिकोण में कार्यक्रम सरल दिखता है:

int main() { while(1) { doSomething(); doSomethingElse(); doSomethingMore(); } }

एक अनंत लूप जिसमें नियंत्रक क्रमिक रूप से वह सब कुछ करता है जो उसे करने की आवश्यकता होती है।

सबसे दिलचस्प, निश्चित रूप से, एम्बेडेड सिस्टम में बाह्य उपकरणों (बहुत ADCs, SPI, GPIO, आदि) के साथ काम है। नियंत्रक बाहरी बाह्य उपकरणों के साथ दो तरीकों से काम कर सकता है: पूछताछ करना या बाधित करना। पहले मामले में, यदि हम चाहते हैं, उदाहरण के लिए, RS232 कंसोल से एक चरित्र को पढ़ने के लिए, तो हम समय-समय पर यह देखने के लिए जांच करेंगे कि क्या कोई चरित्र है जब तक हम इसे प्राप्त नहीं करते। दूसरे मामले में, हम RS232 नियंत्रक को कॉन्फ़िगर करते हैं ताकि यह एक बाधा उत्पन्न करे जो एक नया प्रतीक दिखाई देता है।

पहले दृष्टिकोण का प्रदर्शन। उदाहरण के लिए, हम तापमान की निगरानी करना चाहते हैं, और यदि यह निर्धारित सीमा से अधिक है, तो एलईडी को प्रकाश दें। यह कुछ इस तरह दिखेगा:

 int main() { init_adc(); init_gpio_as_out(); while (1) { int temperature = readTemperature(); if (temperature > TEMPERATURE_LIMIT) { turnLedOn(); } else { turnLedOff(); } }

अब तक, सब कुछ सरल और स्पष्ट होना चाहिए। (मैं तापमान पढ़ने और एलईडी को हेरफेर करने के कार्य नहीं दूंगा - यह इस लेख का उद्देश्य नहीं है)।

लेकिन क्या होगा अगर हमें दी गई आवृत्ति पर कुछ करने की आवश्यकता है? ऊपर के उदाहरण में, तापमान को जितनी बार संभव हो जांचा जाएगा। और अगर, उदाहरण के लिए, हमें दूसरी बार एक एलईडी को ब्लिंक करने की आवश्यकता है? या 10 मिलीसेकंड के अंतराल के साथ सेंसर से सख्ती से पूछताछ करें?

फिर टाइमर बचाव के लिए आते हैं (जो लगभग किसी भी माइक्रोकंट्रोलर के पास है)। वे काम करते हैं ताकि वे किसी दिए गए आवृत्ति पर एक बाधा उत्पन्न करें। पलक झपकते एलईडी फिर कुछ इस तरह दिखेगी:

 volatile int interrupt_happened = 0; interrupt void timer_int_handler() { interrupt_happened = 1; clear_interrupt_condition(); } int main() { init_timer(1_SECOND_INTERVAL, timer_int_handler); while (1) { if (interrupt_happened) { ledToggle(); interrupt_happened = 0; } } }

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

इस सबसे वैश्विक वैरिएबल को अस्थिर पहचानकर्ता के साथ घोषित किया जाना चाहिए - अन्यथा ऑप्टिमाइज़र केवल उस कोड को निकाल सकता है जो उसके दृष्टिकोण से उपयोग नहीं किया गया है।

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

 volatile uint millisecond_counter = 0; interrupt void timer_int_handler() { ++millisecond_counter; clear_interrupt_condition(); } int main() { init_timer(1_MILLISECOND_INTERVAL, timer_int_handler); while (1) { uint timestart1 = millisecond_counter; uint timestart2 = millisecond_counter; if (millisecond_counter – timestart1 > 1000) // 1 second interval { led1Toggle(); timestart1 = millisecond_counter; } if (millisecond_counter – timestart2 > 333) // 1/3 second interval { led2Toggle(); timestart2 = millisecond_counter; } } }

ध्यान दें कि हमें मिलीसेकंड काउंटर के अतिप्रवाह की निगरानी करने की आवश्यकता नहीं है, क्योंकि अहस्ताक्षरित प्रकार का उपयोग किया जाता है।

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

और यहां सवाल उठता है - एक स्ट्रिंग को कंसोल पर आउटपुट करने के रूप में इस तरह के एक भोज को कैसे लागू किया जाए? जैसे एक स्पष्ट समाधान

 void sendString(char * str) { foreach (ch in str) { put_ch(ch); } }

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

 int main { while (1) { … if (something) { send_string("something_happened"); } … if (10_millisecond_timeout()) { value = readADC(); } } }

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

और अगर अचानक इस चक्र में कहीं कोई त्रुटि आ जाती है, तो पूरी प्रणाली "गिर जाएगी"। अधिभार की प्रतिक्रिया सहित (जो मैं वास्तव में अनुमति नहीं देना चाहूंगा, क्या आप?)।

हालांकि सैद्धांतिक रूप से, पहली समस्या के साथ कुछ और किया जा सकता है। उदाहरण के लिए, किसी चीज़ को किसी रेखा के साथ मुद्रित करने के सबसे सरल लेकिन सबसे लंबे कार्य को प्रतिस्थापित करें:

 int position = 0; int send_string(char * str) { if (position < strlen(str) { put_ch(str[position]; ++position; return 1; } else { return 0; } }

और इस समारोह में एक साधारण कॉल कुछ इस तरह है:

 int main { while (1) { … if (something) { do_print = 1; position = 0; } if (do_print) { do_print = send_string("something_happened"); } … if (10_millisecond_timeout()) { value = readADC(); } } }

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

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

बेशक, यह सब वास्तविक है। लेकिन जिन लोगों को लिखने के कम से कम एक साल बाद यह सब करना है, मैं ईर्ष्या नहीं करूंगा।

"सामान्य चक्र" डिजाइन की एक और समस्या सिस्टम लोड को मापने की जटिलता है। मान लीजिए कि आपके पास कोड है:

 interrupt void external_interrupt_handler() { interrupt_happened = 1; clear_interrupt_condition(); } int main() { while (1) { if (interrupt_happened) { doSomething(); interrupt_happened = 0; } } }

सिस्टम किसी भी तरह से बाहर से आने वाली रुकावट का जवाब देता है। और सवाल यह है - प्रणाली प्रति सेकंड इस तरह के कितने व्यवधानों को संभाल सकती है? 100 ईवेंट प्रति सेकंड संसाधित करते समय प्रोसेसर कितना व्यस्त होगा?

आपके लिए यह मापना बहुत मुश्किल होगा कि प्रोसेसिंग इवेंट्स में कितना समय बिताया गया था, और चर "कितना कोई व्यवधान है?" आखिरकार, सब कुछ एक चक्र में किया जाता है!

और यहाँ दूसरा तरीका बचाव का आता है।

वास्तविक समय ऑपरेटिंग सिस्टम के अनुप्रयोग।

इसके अनुप्रयोग का उदाहरण देने का सबसे आसान तरीका एक ही उदाहरण है: एक सेंसर का एक साथ मतदान एक आवृत्ति के साथ और एक लंबी डिबग लाइन को कंसोल में आउटपुट करना।

 void SensorPollingTask() { while (1) { value = SensorRead(); if (value > LIMIT) { doSomething(); } taskDelay(10_MILLISECOND_DELAY); } } void DebugTask() { dbg_task_queue = os_queue_create(); while (1) { char * str = os_queue_read(dbg_task_queue); foreach (ch in str) { put_ch(ch); } } } void OtherTask() { other_task_init(); … while(1) { … // we want to do a dbg_printout here os_queue_put("Long Debug Output String"); … } } int main() { os_task_create(SensorPollingTask, HIGH_PRIORITY); os_task_create(DebugTask, LOW_PRIORITY); os_task_create(OtherTask, OTHER_PRIORITY); os_start_sheduler(); }

जैसा कि आप देख सकते हैं, मुख्य फ़ंक्शन में अब एक मुख्य अनंत लूप नहीं है। इसके बजाय, प्रत्येक कार्य में एक अलग अनंत लूप होता है। (हाँ, os_start_sheduler () फ़ंक्शन; कभी भी नियंत्रण वापस नहीं करेगा!)। और सबसे महत्वपूर्ण बात, इन कार्यों में प्राथमिकताएं हैं। ऑपरेटिंग सिस्टम खुद को वह प्रदान करेगा जिसकी हमें आवश्यकता है - ताकि उच्च प्राथमिकता वाला कार्य सबसे पहले किया जाए, और कम प्राथमिकता के साथ - केवल तब जब उसके पास समय हो।

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

 interrupt void overcurrent_handler() { os_semaphore_give(overcurrent_semaphore); clear_interrupt_condition(); } void OvercurrentTask() { os_sem_create(overcurrent_semaphore); while (1) { os_semaphore_take(overcurrent_semaphore); DoOvercurrentActions(); } }

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

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

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

इसके अलावा, ओएस का उपयोग करने का प्लस सरल और अधिक समझ में आने वाला कोड है (क्योंकि हम कार्यों को उसी के अनुसार कोड में वर्गीकृत कर सकते हैं, वैश्विक चर से बचते हुए, सुपर मशीन के साथ डिजाइन का उपयोग करते समय आवश्यक अन्य कचरा)।

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

"चारों ओर खेल" के लिए आप फ्री ओपन सोर्स प्रोजेक्ट फ्रीआरटीओएस ले सकते हैं, जो काफी स्थिर और सीखने में आसान है। हालांकि इस विशेष ओएस का उपयोग करके असामान्य और वाणिज्यिक परियोजनाएं नहीं।

एम्बेडेड के लिए सॉफ्टवेयर डिजाइन के लिए दो दृष्टिकोण

थोड़ा सा सिद्धांत (उन लोगों के लिए जो बहुत पहले कदम उठाते हैं)।

तो, "सुपर साइकिल" दृष्टिकोण।

वास्तविक समय ऑपरेटिंग सिस्टम के अनुप्रयोग।

More articles: