C ++ 17, tuple और फंतासी का उपयोग करके CortexM पर 4 LED को कैसे ब्लिंक करें

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

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

एक बार फिर, ऐसे छात्रों को अतिरिक्त पुस्तकालयों, जैसे सीएमएसआईएस और उनके हेडर फ़ाइलों को रजिस्टर संरचनाओं के विवरण के साथ जोड़ने के बिना, C ++ 17 भाषा और मानक C ++ पुस्तकालय का उपयोग करके 4 एलइडी को ब्लिंक करने का कार्य दिया गया, और इसी तरह ... कोड के साथ एक जीतता है। रोम में सबसे छोटा आकार और कम से कम खर्च होने वाली रैम होगी। संकलक अनुकूलन मध्यम से अधिक नहीं होना चाहिए। IAR कंपाइलर 8.40.1।
विजेता कैनरी जाता है और परीक्षा के लिए 5 प्राप्त करता है।

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

टास्क की शर्तें

बंदरगाहों पर 4 एलइडी हैं GPIOA.5, GPIOC.5, GPIOC.8, GPIOC.9। उन्हें पलक झपकने की जरूरत है। तुलना करने के लिए कुछ करने के लिए, हमने C में लिखा कोड लिया:

void delay() { for (int i = 0; i < 1000000; ++i){ } } int main() { for(;;) { GPIOA->ODR ^= (1 << 5); GPIOC->ODR ^= (1 << 5); GPIOC->ODR ^= (1 << 8); GPIOC->ODR ^= (1 << 9); delay(); } return 0 ; } 

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

यह कोड स्टैक पर 8 बाइट्स लेता है और मध्यम अनुकूलन पर रोम में 256 बाइट्स

255 बाइट्स आसानी से कोड मेमोरी
रीडओनली डेटा मेमोरी की 1 बाइट
रीडराइटइट डेटा मेमोरी के 8 बाइट्स

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

तो, पूरी आवश्यकताएं हैं:

• मुख्य () फ़ंक्शन में यथासंभव कम कोड होना चाहिए
• आप मैक्रोज़ का उपयोग नहीं कर सकते
• IAR 8.40.1 संकलक C ++ 17 का समर्थन करता है
• CMSIS हेडर फाइल जैसे "#include" stm32f411xe.h "का उपयोग नहीं किया जा सकता है
• आप इनलाइन फ़ंक्शन के लिए __forceinline निर्देश का उपयोग कर सकते हैं
• मध्यम संकलक अनुकूलन

छात्रों का फैसला

सामान्य तौर पर, कई समाधान थे, मैं केवल एक दिखाऊंगा ... यह इष्टतम नहीं है, लेकिन मुझे यह पसंद आया।

चूंकि हेडर का उपयोग नहीं किया जा सकता है, छात्रों ने सबसे पहला काम Gpio वर्ग का किया है, जिसे अपने पते पर पोर्ट रजिस्टरों के लिए एक लिंक स्टोर करना चाहिए। ऐसा करने के लिए, वे एक संरचना ओवरले का उपयोग करते हैं, सबसे अधिक संभावना है कि वे यहां से विचार लेते हैं: संरचना ओवरले :

 class Gpio { public: __forceinline inline void Toggle(const std::uint8_t bitNum) volatile { Odr ^= bitNum ; } private: volatile std::uint32_t Moder; volatile std::uint32_t Otyper; volatile std::uint32_t Ospeedr; volatile std::uint32_t Pupdr; volatile std::uint32_t Idr; volatile std::uint32_t Odr; //    static_assert(sizeof(Gpio) == sizeof(std::uint32_t) * 6); } ; 

जैसा कि आप देख सकते हैं, उन्होंने तुरंत Gpio वर्ग की पहचान उन विशेषताओं के साथ की जो संबंधित रजिस्टरों के पते पर स्थित होनी चाहिए और पैरों की संख्या से राज्य को स्विच करने की एक विधि:
फिर हमने GpioPin लिए संरचना को निर्धारित किया जिसमें GpioPin को सूचक और पैर की संख्या शामिल है:

 struct GpioPin { volatile Gpio* port ; std::uint32_t pinNum ; } ; 

फिर उन्होंने एलइडी की एक सरणी बनाई जो पोर्ट के विशिष्ट पैरों पर बैठती है और प्रत्येक एलईडी के Toggle() विधि को कॉल करके उस पर चली गई:

 const GpioPin leds[] = {{reinterpret_cast<volatile Gpio*>(GpioaBaseAddr), 5}, {reinterpret_cast<volatile Gpio*>(GpiocBaseAddr), 5}, {reinterpret_cast<volatile Gpio*>(GpiocBaseAddr), 9}, {reinterpret_cast<volatile Gpio*>(GpiocBaseAddr), 9} } ; struct LedsDriver { __forceinline static inline void ToggelAll() { for (auto& it: leds) { it.port->Toggle(it.pinNum); } } } ; 

मध्यम अनुकूलन पर उनके कोड के आँकड़े:

रीडऑनली कोड मेमोरी के 275 बाइट्स
रीडओनली डेटा मेमोरी की 1 बाइट
रीडराइटइट डेटा मेमोरी के 8 बाइट्स

एक अच्छा समाधान है, लेकिन यह बहुत सारी मेमोरी लेता है :)

मेरा फैसला

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

 template <std::uint32_t addr> struct Port { //  -  }; 

टेम्प्लेट पैरामीटर के रूप में, इसका एक पोर्ट एड्रेस होगा। "#include "stm32f411xe.h" , उदाहरण के लिए, पोर्ट A के लिए, इसे GPIOA_BASE के रूप में परिभाषित किया गया है। लेकिन हमें हेडर का उपयोग करने की अनुमति नहीं है, इसलिए हमें केवल अपना स्वयं का निरंतर बनाने की आवश्यकता है। परिणामस्वरूप, वर्ग का उपयोग इस तरह किया जा सकता है:

 constexpr std::uint32_t GpioaBaseAddr = 0x4002'0000 ; constexpr std::uint32_t GpiocBaseAddr = 0x4002'0800 ; using PortA = Port<GpioaBaseAddr> ; using PortC = Port<GpiocBaseAddr> ; 

ब्लिंक करने के लिए, आपको टॉगल विधि (const st :: uint8_t bit) की आवश्यकता होती है, जो एक विशेष या ऑपरेशन का उपयोग करके आवश्यक बिट को स्विच करेगा। विधि स्थिर होनी चाहिए, इसे कक्षा में जोड़ें:

 template <std::uint32_t addr> struct Port { //   __forceinline,        __forceinline inline static void Toggle(const std::uint8_t bitNum) { *reinterpret_cast<std::uint32_t*>(addr+20) ^= (1 << bitNum) ; //addr + 20  ODR  } }; 

उत्कृष्ट Port<> है, यह पैरों की स्थिति को स्विच कर सकता है। एलईडी एक विशिष्ट पैर पर बैठता है, इसलिए क्लास Pin बनाना तर्कसंगत है, जिसमें टेम्पलेट पैरामीटर के रूप में Port<> और लेग नंबर होगा। चूंकि Port<> प्रकार टेम्पलेट है, अर्थात विभिन्न बंदरगाहों के लिए अलग, हम केवल सार्वभौमिक प्रकार टी प्रसारित कर सकते हैं।

 template <typename T, std::uint8_t pinNum> struct Pin { __forceinline inline static void Toggle() { T::Toggle(pinNum) ; } } ; 

यह बुरा है कि हम किसी भी प्रकार के T को पास कर सकते हैं जिसमें Toggle() विधि है और यह काम करेगा, हालांकि यह माना जाता है कि हमें केवल Port<> टाइप करना चाहिए। इससे PortBase को बचाने के लिए, हम PortBase बेस क्लास से Port<> इनहेरिट करेंगे, और टेम्प्लेट में हम यह सत्यापित करेंगे कि हमारा पास टाइप वास्तव में PortBase पर आधारित है। हम निम्नलिखित प्राप्त करते हैं:

 constexpr std::uint32_t OdrAddrShift = 20U; struct PortBase { }; template <std::uint32_t addr> struct Port: PortBase { __forceinline inline static void Toggle(const std::uint8_t bit) { *reinterpret_cast<std::uint32_t*>(addr ) ^= (1 << bit) ; } }; template <typename T, std::uint8_t pinNum, class = typename std::enable_if_t<std::is_base_of<PortBase, T>::value>> //   struct Pin { __forceinline inline static void Toggle() { T::Toggle(pinNum) ; } } ; 

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

 using PortA = Port<GpioaBaseAddr> ; using PortC = Port<GpiocBaseAddr> ; using Led1 = Pin<PortA, 5> ; using Led2 = Pin<PortC, 5> ; using Led3 = Pin<PortC, 8> ; using Led4 = Pin<PortC, 9> ; int main() { for(;;) { Led1::Toggle(); Led2::Toggle(); Led3::Toggle(); Led4::Toggle(); delay(); } return 0 ; } 

आसानी से कोड मेमोरी की 271 बाइट्स
रीडओनली डेटा मेमोरी की 1 बाइट
रीडराईट डेटा मेमोरी के 24 बाइट्स

रैम में ये अतिरिक्त 16 बाइट और रोम में 16 बाइट्स कहां से आए। वे इस तथ्य से आए थे कि हम पोर्ट क्लास के टॉगल फ़ंक्शन (const std :: uint8_t bit) के बिट पैरामीटर को पास करते हैं, और कंपाइलर, जब मुख्य फ़ंक्शन में प्रवेश करते हैं, तो स्टैक पर 4 अतिरिक्त रजिस्टरों को बचाता है जिसके माध्यम से यह पैरामीटर गुजरता है, फिर इन का उपयोग करता है रजिस्टर जिसमें प्रत्येक पिन के लिए लेग नंबर के मान संग्रहीत किए जाते हैं और जब मुख्य छोड़ते हैं तो स्टैक से इन रजिस्टरों को पुनर्स्थापित करते हैं। और हालांकि संक्षेप में यह पूरी तरह से बेकार काम है, क्योंकि फंक्शंस में काम किया जाता है, लेकिन कंपाइलर मानक के अनुसार पूर्ण रूप से कार्य करता है।
आप पोर्ट क्लास को सामान्य रूप से निकालकर, Pin क्लास के लिए टेम्प्लेट पैरामीटर के रूप में पोर्ट एड्रेस, और Toggle() विधि के अंदर से छुटकारा पा सकते हैं, ओडीआर रजिस्टर के पते की गणना करें:

 constexpr std::uint32_t OdrAddrShift = 20U; template <std::uint32_t addr, std::uint8_t pinNum, struct Pin { __forceinline inline static void Toggle() { *reinterpret_cast<std::uint32_t*>(addr + OdrAddrShift ) ^= (1 << bit) ; } } ; using Led1 = Pin<GpioaBaseAddr, 5> ; 

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

हम मध्यम पर अनुकूलन डालते हैं और परिणाम देखते हैं:

251 बाइट्स कोड मेमोरी की बाइट
रीडओनली डेटा मेमोरी की 1 बाइट
रीडराइटइट डेटा मेमोरी के 8 बाइट्स

वाह वाह वाह ... हमारे पास 4 बाइट्स कम हैं
यह कैसे हो सकता है? आइए सी + कोड (बाएं) और सी कोड (दाएं) के लिए डिबगर में कोडांतरक पर एक नज़र डालें:



यह देखा जा सकता है कि, सबसे पहले, कंपाइलर ने सभी कार्यों को बिल्ट-इन किया, अब इसमें कोई कॉल नहीं है, और दूसरी बात, यह रजिस्टरों के उपयोग को अनुकूलित करता है। यह देखा जा सकता है, सी कोड के मामले में, कंपाइलर या तो R1 या R2 रजिस्टर का उपयोग पोर्ट एड्रेस को स्टोर करने के लिए करता है और हर बार बिट स्विच होने पर अतिरिक्त ऑपरेशन करता है (रजिस्टर में एड्रेस को R1 या R2 में सहेजें)। दूसरे मामले में, यह केवल आर 1 रजिस्टर का उपयोग करता है, और चूंकि स्विचिंग के लिए अंतिम 3 कॉल हमेशा पोर्ट सी से होते हैं, इसलिए रजिस्टर में समान पोर्ट सी पते को बचाने की कोई आवश्यकता नहीं है। नतीजतन, 2 टीम और 4 बाइट्स बचाए जाते हैं।

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

अब मैं चाहता हूं कि सभी एल ई डी कहीं कंटेनर में हों, और आप विधि को कॉल कर सकते हैं, सब कुछ स्विच कर सकते हैं ... कुछ इस तरह:

 int main() { for(;;) { LedsContainer::ToggleAll() ; delay(); } return 0 ; } 

हम बेवकूफों को फ़ंक्शन में 4 एल ई डी के स्विचिंग को सम्मिलित नहीं करेंगे LEDsContainer :: ToggleAll, क्योंकि यह दिलचस्प नहीं है :)। हम एल ई डी को एक कंटेनर में रखना चाहते हैं और फिर उनके माध्यम से जाते हैं और प्रत्येक पर टॉगल () विधि कहते हैं।

छात्रों ने एलइडी से पॉइंटर्स स्टोर करने के लिए एक सरणी का उपयोग किया। लेकिन मेरे पास अलग-अलग प्रकार हैं, उदाहरण के लिए: Pin<PortA, 5> , Pin<PortC, 5> , और मैं एक सरणी में विभिन्न प्रकारों के लिए पॉइंटर्स स्टोर नहीं कर सकता। आप सभी पिन के लिए एक वर्चुअल बेस क्लास बना सकते हैं, लेकिन फिर वर्चुअल फ़ंक्शंस की एक तालिका दिखाई देगी और मैं छात्रों को जीतने में सफल नहीं होगा।

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

 class LedsContainer { private: constexpr static auto records = std::make_tuple ( Pin<PortA, 5>{}, Pin<PortC, 5>{}, Pin<PortC, 8>{}, Pin<PortC, 9>{} ) ; using tRecordsTuple = decltype(records) ; } 

एक महान कंटेनर है, यह सभी एलईडी स्टोर करता है। अब इसमें ToggleAll() विधि जोड़ें:

 class LedsContainer { public: __forceinline static inline void ToggleAll() { //        } private: constexpr static auto records = std::make_tuple ( Pin<PortA, 5>{}, Pin<PortC, 5>{}, Pin<PortC, 8>{}, Pin<PortC, 9>{} ) ; using tRecordsTuple = decltype(records) ; } 

आप केवल एक ट्यूपल तत्वों के माध्यम से नहीं चल सकते हैं, क्योंकि टपल तत्व केवल संकलन चरण में प्राप्त किया जाना चाहिए। टपल के तत्वों को एक्सेस करने के लिए एक टेम्प्लेट प्राप्त विधि है। खैर यानी अगर हम std::get<0>(records).Toggle() लिखते हैं std::get<0>(records).Toggle() , तो Toggle() विधि को क्लास Pin<PortA, 5> के ऑब्जेक्ट के लिए कहा जाता है, अगर std::get<1>(records).Toggle() Pin<PortA, 5> std::get<1>(records).Toggle() । तब Toggle() विधि को कक्षा Pin<Port, 5> और इतने पर वस्तु के लिए कहा जाता है ...

आप अपने छात्रों की नाक पोंछ सकते हैं और बस लिख सकते हैं:

  __forceinline static inline void ToggleAll() { std::get<0>(records).Toggle(); std::get<1>(records).Toggle(); std::get<2>(records).Toggle(); std::get<3>(records).Toggle(); } 

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

 class class LedsContainer { friend int main() ; public: __forceinline static inline void ToggleAll() { //    3,2,1,0    ,     visit(std::make_index_sequence<std::tuple_size<tRecordsTuple>::value>()); } private: __forceinline template<std::size_t... index> static inline void visit(std::index_sequence<index...>) { Pass((std::get<index>(records).Toggle(), true)...); //    get<3>(records).Toggle(), get<2>(records).Toggle(), get<1>(records).Toggle(), get<0>(records).Toggle() } __forceinline template<typename... Args> static void inline Pass(Args... ) {//      } constexpr static auto records = std::make_tuple ( Pin<PortA, 5>{}, Pin<PortC, 5>{}, Pin<PortC, 8>{}, Pin<PortC, 9>{} ) ; using tRecordsTuple = decltype(records) ; } 

यह डरावना लग रहा है, लेकिन मैंने लेख की शुरुआत में चेतावनी दी कि शिज़नी विधि बहुत सामान्य नहीं है ...

संकलन मंच पर ऊपर से यह सब जादू सचमुच निम्नलिखित है:

 //  LedsContainer::ToggleAll() ; //   4 : Pin<Port, 9>().Toggle() ; Pin<Port, 8>().Toggle() ; Pin<PortC, 5>().Toggle() ; Pin<PortA, 5>().Toggle() ; //     Toggle() inline,   : *reinterpret_cast<std::uint32_t*>(0x40020814 ) ^= (1 << 9) ; *reinterpret_cast<std::uint32_t*>(0x40020814 ) ^= (1 << 8) ; *reinterpret_cast<std::uint32_t*>(0x40020814 ) ^= (1 << 5) ; *reinterpret_cast<std::uint32_t*>(0x40020014 ) ^= (1 << 5) ; 

आगे बढ़ो और अनुकूलन के बिना कोड आकार को संकलित करें और जांच करें:



हम देखते हैं कि मेमोरी ओवरकिल है, 18 बाइट्स अधिक है। समस्याएं समान हैं, साथ ही एक और 12 बाइट्स। मुझे समझ नहीं आया कि वे कहाँ से आए हैं ... शायद कोई समझाएगा।

रीडऑनली कोड मेमोरी के 283 बाइट्स
रीडओनली डेटा मेमोरी की 1 बाइट
रीडराईट डेटा मेमोरी के 24 बाइट्स

अब मध्यम अनुकूलन और लो और निहारना पर एक ही बात ... हमें माथे में सी ++ कार्यान्वयन के समान कोड और अधिक आशावादी सी कोड मिला।

251 बाइट्स कोड मेमोरी की बाइट
रीडओनली डेटा मेमोरी की 1 बाइट
रीडराइटइट डेटा मेमोरी के 8 बाइट्स

जैसा कि आप देख सकते हैं, मैं जीत गया, और कैनरी द्वीप पर चला गया और चेल्याबिंस्क में आराम करने के लिए प्रसन्न हूं :), लेकिन छात्र भी महान थे, उन्होंने सफलतापूर्वक परीक्षा उत्तीर्ण की!

कौन परवाह करता है, कोड यहाँ है

मैं इसका उपयोग कहां कर सकता हूं, ठीक है, मैं साथ आया था, उदाहरण के लिए, जैसे, हमारे पास EEPROM मेमोरी में पैरामीटर हैं और इन मापदंडों का वर्णन करने वाला एक वर्ग है (प्रारंभिक मूल्य के लिए पढ़ें, लिखें, लिखें)। वर्ग टेम्पलेट है, जैसे Param<float<>> , Param<int<>> और आपको उदाहरण के लिए, डिफ़ॉल्ट मानों के लिए सभी मापदंडों को रीसेट करने की आवश्यकता है। यह वह जगह है जहां आप सभी को एक टपल में रख सकते हैं, क्योंकि प्रकार अलग है और प्रत्येक पैरामीटर पर SetToDefault() विधि को कॉल करें। सच है, अगर ऐसे 100 पैरामीटर हैं, तो रोम बहुत खा जाएगा, लेकिन रैम को नुकसान नहीं होगा।

PS मुझे स्वीकार करना चाहिए कि अधिकतम अनुकूलन पर यह कोड C और मेरे समाधान के आकार जैसा है। और प्रोग्रामर के कोड को बेहतर बनाने के सभी प्रयास एक ही कोडांतरक कोड पर आते हैं।

P.S1 अच्छी सलाह के लिए 0xd34df00d धन्यवाद। आप std::apply() साथ एक टपल को खोलना सरल कर सकते हैं। ToggleAll() फ़ंक्शन का कोड फिर इसे सरल करता है:

  __forceinline static inline void ToggleAll() { std::apply([](auto... args) { (args.Toggle(), ...); }, records); } 

दुर्भाग्य से, IAR में, std :: लागू अभी तक वर्तमान संस्करण में लागू नहीं है, लेकिन यह भी काम करेगा, std के साथ कार्यान्वयन देखें :: लागू करें