C ++ और Cortex M4 माइक्रोकंट्रोलर का उपयोग करके ऑब्जर्वर टेम्पलेट का उपयोग करके स्थैतिक सदस्यता

सभी को अच्छा स्वास्थ्य!

नए साल की पूर्व संध्या पर, मैं माइक्रोकंट्रोलरों पर C ++ के उपयोग के बारे में बात करना जारी रखना चाहता हूं, इस बार मैं ऑब्जर्वर टेम्पलेट का उपयोग करने के बारे में बात करने की कोशिश करूंगा (लेकिन इसके बाद मैं इसे प्रकाशक-सब्सक्राइबर या सिर्फ एक सब्सक्राइबर, इस तरह के एक वाक्य) के साथ-साथ C पर स्थैतिक सदस्यता के कार्यान्वयन के बारे में बताऊंगा। ++ 17 और कुछ अनुप्रयोगों में इस दृष्टिकोण के फायदे।

परिचय

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

टेम्प्लेट का लाभ यह है कि हम प्रकाशक और सब्सक्राइबर के ज्ञान को विशिष्ट वस्तुओं से बंधे बिना प्राप्त करते हैं। हम प्रकाशक और सब्सक्राइबर ऑब्जेक्ट के कार्यान्वयन को प्रभावित किए बिना, किसी को भी किसी पर भी हस्ताक्षर कर सकते हैं।

प्रारंभिक शर्तें

इससे पहले कि हम टेम्पलेट से परिचित हों, हम पहले यह मान लें कि हम विश्वसनीय सॉफ्टवेयर विकसित करना चाहते हैं:

• डायनामिक मेमोरी आवंटन का उपयोग न करें
• पॉइंटर्स के साथ काम कम से कम करें
• हम यथासंभव अधिक से अधिक स्थिरांक का उपयोग करते हैं ताकि कोई भी किसी को यथासंभव बदल न सके
• लेकिन एक ही समय में हम रैम में स्थित कुछ स्थिरांक का उपयोग करते हैं

अब सब्सक्राइबर टेम्पलेट के मानक कार्यान्वयन को देखें।

मानक कार्यान्वयन

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

इसलिए, जब आप बटन दबाते हैं, तो आपको इस प्रेस के बारे में एलईडी को सूचित करने की आवश्यकता होती है। बदले में, एलईडी दबाने के बारे में जानने के बाद विपरीत स्थिति में स्विच करना चाहिए।
यूएमएल में मानक कार्यान्वयन इस प्रकार है ...

यहां ButtonController वर्ग बटन को क्लिक करने और क्लिक के बारे में ग्राहकों को सूचित करने के लिए जिम्मेदार है, और इस मामले में Led ग्राहक है। इन दोनों वर्गों को IPublisher और ISubsriber माध्यम से IPublisher ISubsriber और किसी भी वर्ग को दूसरे के बारे में पता नहीं है। इस प्रकार, ISubscriber इंटरफ़ेस से विरासत में मिली कोई भी वस्तु ButtonController एक घटना की सदस्यता ले सकती है।

चूंकि डायनामिक मेमोरी आवंटन निषिद्ध है, इसलिए मैंने सदस्यता के लिए 3 तत्वों की एक सरणी घोषित की। यानी अधिकतम 3 ग्राहक हो सकते हैं। तो, पहले सन्निकटन में, ButttonsController वर्ग के ग्राहकों को सूचित करने की विधि ButttonsController सकती है

 struct ButtonController : IPublisher { void Run() { for(;;) { if (UserButton::IsPressed()) { Notify() ; } } } void Notify() const override { //          HandleEvent() for(auto it: pSubscribers) { if (it != nullptr) { it->HandleEvent() ; } } } } ; 

सभी नमक Publisher वर्ग की Notify() विधि में है। इस पद्धति में, हम ग्राहकों की सूची पर जाते हैं और उनमें से प्रत्येक पर HandleEvent() कॉल करते हैं, और यह अच्छा है, क्योंकि प्रत्येक ग्राहक अपने तरीके से इस पद्धति को लागू करता है और वहां कर सकता है सब आपका दिल जो भी चाहता है (वास्तव में, आपको सावधान रहना होगा, अन्यथा शैतान जानता है कि ग्राहक वहां क्या कर रहा है, आप उसकी विधि को कॉल कर सकते हैं, उदाहरण के लिए, एक रुकावट से और आपको ग्राहकों को लंबी और बुरी चीजें करने से रोकने के लिए सतर्क रहने की आवश्यकता है)

हमारे मामले में, एलईडी को कुछ भी करने की अनुमति है, इसलिए यह अपने राज्य का स्विचिंग करता है:

 template <typename Port, std::uint32_t pinNum> struct Led: ISubscriber { static void Toggle() { Port::ODR::Toggle(1 << pinNum); } void HandleEvent() override { //  ,    ,  Toggle() ; } }; 

 template<typename Port, std::size_t pinNum> struct Button { static bool IsPressed() { bool result = false; if ((Port::IDR::Read() & (1 << pinNum)) == 0) //   { while ((Port::IDR::Read() & (1 << pinNum)) == 0) //     { }; result = true; } return result; } } ; //     GPIOC.13 using UserButton = Button<GPIOC, 13> ; struct ISubscriber { virtual void HandleEvent() = 0; } ; struct IPublisher { virtual void Notify() const = 0; virtual void Subscribe(ISubscriber* subscriber) = 0; } ; template <typename Port, std::uint32_t pinNum> struct Led: ISubscriber { static void Toggle() { Port::ODR::Toggle(1 << pinNum); } void HandleEvent() override { Toggle() ; } }; struct ButtonController : IPublisher { void Run() { for(; ;) { if (UserButton::IsPressed()) { Notify() ; } } } void Notify() const override { for(auto it: pSubscribers) { if (it != nullptr) { it->HandleEvent() ; } } } void Subscribe(ISubscriber* subscriber) override { if (index < pSubscribers.size()) { pSubscribers[index] = subscriber ; index ++ ; } //   3   ...   } private: std::array<ISubscriber*, 3> pSubscribers ; std::size_t index = 0U ; } ; 

कोड में सदस्यता कैसे दिख सकती है? और इसलिए:

 int main() { //  Led1    5  GPIOC static Led<GPIOC,5> Led1 ; //  Led2    8  GPIOC static Led<GPIOC,8> Led2 ; //  Led3    9  GPIOC static Led<GPIOC,9> Led3 ; ButtonController buttonController ; //  3  buttonController.Subscribe(&Led1) ; buttonController.Subscribe(&Led2) ; buttonController.Subscribe(&Led3) ; //       buttonController.Run() ; } 

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

इसके अलावा, संभावित त्रुटियों का एक जोखिम है, उदाहरण के लिए, यदि कई थ्रेड से कॉल किया गया तो Subsribe() पद्धति को कॉल करते समय कितने आश्चर्यचकित होंगे? हम केवल 3 ग्राहकों तक ही सीमित हैं, और अगर हम 4 एलईडी पर हस्ताक्षर करते हैं तो क्या होगा?

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

खैर, बुरी खबर यह है कि इस तरह के एक वास्तुशिल्प समाधान रोम और रैम दोनों में बहुत अधिक स्थान लेता है। बस मामले में, हम लिखते हैं कि यह समाधान कितने ROM और RAM लेता है:

यानी ROM में कुल 552 बाइट्स और RAM में 21 बाइट्स हैं - एक बटन दबाने और तीन एलईडी को ब्लिंक करने के लिए इतना नहीं कहते हैं।

खैर, इस तरह की परेशानियों से खुद को बचाने के लिए और नियंत्रक संसाधनों की खपत को कम करने के लिए, आइए स्थैतिक सदस्यता के विकल्प पर विचार करें।

स्थैतिक सदस्यता

सदस्यता को स्थिर बनाने के लिए आप कई तरीकों का उपयोग कर सकते हैं। मैं उन्हें इस तरह नाम दूंगा:

• पारंपरिक एक ही दृष्टिकोण है, लेकिन कॉन्स्ट्रेक्स कंस्ट्रक्टर का उपयोग करना और इसके माध्यम से ग्राहकों की सूची सेट करना।
• अपरंपरागत टेम्प्लेट का उपयोग करना - टेम्प्लेट मापदंडों के माध्यम से ग्राहकों की सूची को स्थानांतरित करना। (यहां, एक टेम्पलेट मेटाप्रोग्रामिंग के क्षेत्र से एक परिभाषा है, न कि डिज़ाइन पैटर्न)

स्थैतिक सदस्यता के लिए पारंपरिक दृष्टिकोण

आइए संकलन के स्तर पर सदस्यता लेने का प्रयास करें। ऐसा करने के लिए, हम अपनी वास्तुकला को थोड़ा छोटा करते हैं:

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

 struct ButtonController : IPublisher { template<typename... Args> constexpr ButtonController(Args const*... args): pSubscribers() { std::initializer_list<ISubscriber const*> result = {args...} ; std::size_t index = 0U; for(auto it: result) { if (index < size) { pSubscribers[index] = const_cast<ISubscriber*>(it); } index ++ ; } } private: static constexpr std::size_t size = 3U; ISubscriber* pSubscribers[size] ; } ; 

 struct ISubscriber { virtual void HandleEvent() const = 0; } ; struct IPublisher { virtual void Notify() const = 0; } ; template<typename Port, std::size_t pinNum> struct Button { static bool IsPressed() { bool result = false; if ((Port::IDR::Read() & (1 << pinNum)) == 0) //   { while ((Port::IDR::Read() & (1 << pinNum)) == 0) //     { }; result = true; } return result; } } ; template <typename Port, std::uint32_t pinNum> struct Led: ISubscriber { constexpr Led() { } static void Toggle() { Port::ODR::Toggle(1<<pinNum); } void HandleEvent() const override { Toggle() ; } }; //     GPIOC.13 using UserButton = Button<GPIOC, 13> ; struct ButtonController : IPublisher { template<typename... Args> constexpr ButtonController(Args const*... args): pSubscribers() { std::initializer_list<ISubscriber const*> result = {args...} ; std::size_t index = 0U; for(auto it: result) { if (index < size) { pSubscribers[index] = const_cast<ISubscriber*>(it); } index ++ ; } } void Run() const { for(; ;) { if (UserButton::IsPressed()) { Notify() ; } } } void Notify() const override { for(auto it: pSubscribers) { if (it != nullptr) { it->HandleEvent() ; } } } private: static constexpr std::size_t size = 3U; ISubscriber* pSubscribers[size] ; } ; 

अब संकलन समय पर किया जा सकता है:

 int main() { //  Led1    5  GPIOC static constexpr Led<GPIOC,5> Led1 ; //  Led2    8  GPIOC static constexpr Led<GPIOC,8> Led2 ; //  Led3    9  GPIOC static constexpr Led<GPIOC,9> Led3 ; static constexpr ButtonController buttonController(&Led1, &Led2, &Led3) ; buttonController.Run() ; return 0 ; } ; 

यहां, buttonController ऑब्जेक्ट पूरी तरह से ROM में स्थित है और ग्राहकों को पॉइंटर्स की एक सरणी के साथ:

मुख्य :: बटनकंट्रोलर 0x800'1f04 0x10 डेटा main.o [1]

सब कुछ कुछ भी नहीं लगता है, सिवाय इसके कि हम फिर से केवल 3 ग्राहकों तक सीमित हैं। और प्रकाशक वर्ग के पास एक कॉन्टेक्स्ट कंस्ट्रक्टर होना चाहिए और सामान्य तौर पर ROM में ग्राहकों को एक पॉइंटर की गारंटी देने के लिए पूरी तरह से स्थिर होना चाहिए, अन्यथा, यहां तक ​​कि ज्ञात ग्राहकों के पते के साथ, हमारी वस्तु, सभी सामग्रियों के साथ, फिर से रैम पर जाएगी।

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

आइए देखें कि इस समाधान में मेमोरी के साथ चीजें कैसी हैं:

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

एक छोटा विषयांतर:
आधुनिक माइक्रोकंट्रोलर के लिए 256 kB के ROM के आकार का एक चरण आदर्श है (उदाहरण के लिए, TI कॉर्टेक्स M4 माइक्रोकंट्रोलर में 256 kB का ROM है, और अगला संस्करण पहले से ही 512 kB है)। और यह बहुत अच्छा नहीं होगा, जब 50 अतिरिक्त बाइट्स के कारण, हमें 256 kByte ROM के साथ बड़ा और अधिक महंगा एक नियंत्रक लेना होगा, इसलिए, आभासी कार्यों को त्यागने से बचा जा सकता है ... जितना कि 50 सेंट (256 और 512 kBytes ROM में माइक्रोट्रॉलर के बीच का अंतर) के बारे में है 50-60 सेंट)।

यह 1 माइक्रोकंट्रोलर के लिए हास्यास्पद लगता है, लेकिन प्रति वर्ष 400,000 उपकरणों के बैच पर, आप $ 200,000 बचा सकते हैं। पहले से ही इतना मज़ेदार नहीं है, लेकिन यह देखते हुए कि किस तरह का चूहा। वे 3,000 रूबल के लिए एक डिप्लोमा और एक उपहार कार्ड के साथ प्रस्ताव को पुरस्कृत कर सकते हैं, आभासी कार्यों से इनकार करने और रोम में अतिरिक्त 50 बाइट्स को बचाने की शुद्धता के बारे में बिल्कुल संदेह नहीं है।

अपारंपरिक दृष्टिकोण

आइए देखें कि आप आभासी कार्यों के बिना भी ऐसा कैसे कर सकते हैं और कुछ और रॉम को बचा सकते हैं।

सबसे पहले, आइए जानें कि यह कैसे हो सकता है:

 int main() { //  Led1    5  GPIOC static Led<GPIOC,5> Led1 ; //  Led2    8  GPIOC static Led<GPIOC,8> Led2 ; //  Led3    9  GPIOC static Led<GPIOC,9> Led3 ; //   ButtonController<Led1, Led2, Led3> buttonController ; buttonController.Run() ; return 0 ; } 

हमारा काम दो वस्तुओं प्रकाशक ( ButtonController ) और सब्सक्राइबर ( Led ) को एक-दूसरे से अलग करना है, ताकि वे एक-दूसरे के बारे में न जानें, लेकिन साथ ही ButtonController Led को सूचित कर सके।

आप किसी तरह से ButtonController क्लास की घोषणा कर सकते हैं।

 template <Led<GPIOC,5>& subscriber1, Led<GPIOC,8>& subscriber2, Led<GPIOC,9>& subscriber3> struct ButtonController { void Run() const { for(; ;) { if (UserButton::IsPressed()) { Notify() ; } } } void Notify() const { subscriber1.HandleEvent() ; subscriber2.HandleEvent() ; subscriber3.HandleEvent() ; } ... } ; 

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

सी ++ 17 बचाव के लिए आता है, जहां आप प्रकार को निर्दिष्ट नहीं कर सकते हैं, लेकिन संकलक को आपके लिए प्रकार को कम करने के लिए कहें - यह वही है जो आपको चाहिए। हम पारंपरिक दृष्टिकोण के अनुसार, प्रकाशक और ग्राहक के ज्ञान को प्राप्त कर सकते हैं, जबकि ग्राहकों की संख्या असीमित है।

 template <auto& ... subscribers> struct ButtonController { void Run() const { for(; ;) { if (UserButton::IsPressed()) { Notify() ; } } } void Notify() const { pass((subscribers.HandleEvent() , true)...) ; } ... } ; 

  void Notify() const { pass((subscribers.HandleEvent() , true)...) ; } 

 template<typename... Args> void pass(Args...) const { } } ; 

 pass((subscribers.HandleEvent() , true)...) ; -> pass((Led1.HandleEvent() , true), (Led2.HandleEvent() , true), (Led3.HandleEvent() , true)) ; -> Led1.HandleEvent() ; -> pass(true, (Led2.HandleEvent() , true), (Led3.HandleEvent() , true)) ; -> Led2.HandleEvent() ; -> pass(true, true, (Led3.HandleEvent() , true)) ; -> Led3.HandleEvent() ; -> pass(true, true, true) ; 

लिंक के बजाय, आप पॉइंटर्स का उपयोग कर सकते हैं:

 template <auto* ... subscribers> struct ButtonController { ... } ; 

इसके अलावा: वास्तव में, वामीरह के लिए धन्यवाद जिन्होंने बताया कि ये सभी नृत्य साथ हैं डफ C ++ 17 में pass फ़ंक्शन की आवश्यकता नहीं है। चूंकि ऑपरेटर "," अल्पविराम को गुना अभिव्यक्ति में समर्थित है (जो C ++ 17 मानक में पेश किया गया था), कोड को सरल बनाया गया है:

 template <auto& ... subscribers> struct ButtonController { void Run() const { for(; ;) { if (UserButton::IsPressed()) { Notify() ; } } } void Notify() const { ((subscribers.HandleEvent()), ...) ; } } ; 

वास्तुकला में, यह सामान्य रूप से बहुत सरल लगता है:

मैंने यहां एक और एलसीडी क्लास जोड़ी, लेकिन उदाहरण के लिए, यह दिखाने के लिए कि अब यह ग्राहकों के प्रकार और संख्या से कोई फर्क नहीं पड़ता है, मुख्य बात यह है कि यह HandleEvent() विधि को लागू करेगा।

और सामान्य रूप से सभी कोड भी अब आसान है:

 template<typename Port, std::size_t pinNum> struct Button { static bool IsPressed() { bool result = false; if ((Port::IDR::Read() & (1 << pinNum)) == 0) //   { while ((Port::IDR::Read() & (1 << pinNum)) == 0) //     { }; result = true; } return result; } } ; //     GPIOC.13 using UserButton = Button<GPIOC, 13> ; template <typename Port, std::uint32_t pinNum> struct Led { static void Toggle() { Port::ODR::Toggle(1<<pinNum); } void HandleEvent() const { Toggle() ; } }; template <auto& ... subscribers> struct ButtonController { void Run() const { for(; ;) { if (UserButton::IsPressed()) { Notify() ; } } } void Notify() const { ((subscribers.HandleEvent()), ...) ; } } ; int main() { //  Led1    5  GPIOC static constexpr Led<GPIOC,5> Led1 ; //  Led2    8  GPIOC static constexpr Led<GPIOC,8> Led2 ; //  Led3    9  GPIOC static constexpr Led<GPIOC,9> Led3 ; static constexpr ButtonController<Led1, Led2, Led3> buttonController ; buttonController.Run() ; return 0 ; } 

Notify() कॉल Run() विधि एक सरल अनुक्रमिक कॉल में पतित है

 Led1.HandleEvent() ; Led2.HandleEvent() ; Led3.HandleEvent() ; 

यहाँ स्मृति के बारे में क्या?

ROM कुल 190 बाइट्स और 0 बाइट्स RAM। अब आदेश, यह मानक संस्करण की तुलना में लगभग 3 गुना छोटा है, जबकि यह बिल्कुल एक ही कार्य करता है।

इस प्रकार, यदि आपके पास आवेदन में अग्रिम रूप से ज्ञात ग्राहकों के पते हैं और आप लेख की शुरुआत में परिभाषित शर्तों का पालन करते हैं

आत्मविश्वास के साथ, आप कोड की लाइनों को कम करने और संसाधनों को बचाने के लिए प्रकाशक-सब्सक्राइबर टेम्पलेट के ऐसे कार्यान्वयन का उपयोग कर सकते हैं, और वहां आप देखते हैं और आप न केवल एक उपहार कार्ड का दावा कर सकते हैं, बल्कि वर्ष के परिणामों के आधार पर एक बोनस भी।

IAR 8.40.2 के तहत परीक्षा का उदाहरण यहां दिया गया है

आने के साथ सभी! और नए साल में शुभकामनाएँ!