Microcontrollers के लिए C ++ में, पिन की सूची के साथ काम करें (उदाहरण के रूप में CortexM का उपयोग करके)

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

पिछले लेख में, मैंने इस बारे में लिखने का वादा किया था कि आप बंदरगाहों की सूची के साथ कैसे काम कर सकते हैं।
मुझे तुरंत यह कहना होगा कि 2010 में मेरे पहले से ही सब कुछ पहले से ही तय हो चुका था, यहां लेख है: C ++ में माइक्रोकंट्रोलर्स के इनपुट / आउटपुट पोर्ट के साथ काम करना । जिस व्यक्ति ने 2010 में इसे लिखा है, वह केवल सुंदर है।

मैं थोड़ा शर्मिंदा था कि मैं वही करूंगा जो 10 साल पहले किया गया था, इसलिए मैंने 2020 तक इंतजार नहीं करने का फैसला किया, लेकिन 2019 में इसे करने के लिए 9 साल पहले तक निर्णय को दोहराना होगा, यह इतना गूंगा नहीं होगा।

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

कार्य

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

दरअसल, हम जो करना चाहते हैं वह कोड के साथ दिखाया जा सकता है:

using Pin1 = Pin<GPIO, 1>; using Pin2 = Pin<GPIOB, 1>; using Pin3 = Pin<GPIOA, 1>; using Pin4 = Pin<GPIOC, 2>; using Pin5 = Pin<GPIOA, 3>; int main() { //    Pin    : //   GPIOA  10 GPIOA->BSRR = 10 ; // (1<<1) | (1 << 3) ; //   GPIOB  2 GPIOB->BSRR = 2 ; // (1 << 1) //   GPIOC  6 GPIOB->BSRR = 6 ; // (1 << 1) | (1 << 2); PinsPack<Pin1, Pin2, Pin3, Pin4, Pin5>::Set() ; return 0; } 

इस समस्या को हल करने के लिए चरणों की एक सामान्यीकृत योजना निम्नानुसार प्रस्तुत की जा सकती है:

ठीक है, दूसरे शब्दों में:

संकलक के लिए हमारे लिए करने के लिए:

• सत्यापित करें कि सूची में केवल अनन्य पिन है
• पिन किस पोर्ट पर है, यह निर्धारित करके बंदरगाहों की सूची बनाना
• प्रत्येक पोर्ट में डाले जाने वाले मान की गणना

और फिर कार्यक्रम

• यह मान सेट करें

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

चलो पहली सनक से शुरू करते हैं: यह सत्यापित करते हुए कि सूची में अद्वितीय पिन है।

विशिष्टता के लिए सूची की जाँच करें

आपको याद दिला दूं कि हमारे पास पिंस की एक सूची है:

 PinsPack<Pin1, Pin2, Pin3, Pin4, Pin5> ; 

अकस्मात यह कर सकते हैं:

 PinsPack<Pin1, Pin2, Pin3, Pin4, Pin1> ; //     Pin1 

मैं चाहूंगा कि कंपाइलर इस तरह की गलती पकड़ें और इसके बारे में पियानोवादक को सूचित करें।

हम इस प्रकार के रूप में विशिष्टता के लिए सूची की जाँच करेंगे:

• स्रोत सूची से, डुप्लिकेट के बिना एक नई सूची बनाएं,
• यदि स्रोत सूची का प्रकार और डुप्लिकेट के बिना सूची का प्रकार मेल नहीं खाता है, तो स्रोत सूची में पिन समान था और प्रोग्रामर ने गलती की।
• यदि वे मेल खाते हैं, तो सब कुछ ठीक है, कोई डुप्लिकेट नहीं है।

डुप्लिकेट के बिना एक नई सूची बनाने के लिए, एक सहयोगी ने पहिया को सुदृढ़ करने और लोकी पुस्तकालय से दृष्टिकोण लेने की सलाह नहीं दी। मेरे पास यह दृष्टिकोण है और चुरा लिया है। लगभग 2010 के समान ही है, लेकिन मापदंडों की एक चर संख्या के साथ।

 namespace PinHelper { template<typename ... Types> struct Collection { }; /////////////////   NoDuplicates   LOKI //////////////// template<class X, class Y> struct Glue; template<class T, class... Ts> struct Glue<T, Collection<Ts...>> { using Result = Collection<T, Ts...>; }; template<class Q, class X> struct Erase; template<class Q> struct Erase<Q, Collection<>> { using Result = Collection<>;}; template<class Q, class... Tail> struct Erase<Q, Collection<Q, Tail...>> { using Result = Collection<Tail...>;}; template<class Q, class T, class... Tail> struct Erase<Q, Collection<T, Tail...>> { using Result = typename Glue<T, typename Erase<Q, Collection<Tail...>>::Result>::Result;}; template <class X> struct NoDuplicates; template <> struct NoDuplicates<Collection<>> { using Result = Collection<>; }; template <class T, class... Tail> struct NoDuplicates< Collection<T, Tail...> > { private: using L1 = typename NoDuplicates<Collection<Tail...>>::Result; using L2 = typename Erase<T,L1>::Result; public: using Result = typename Glue<T, L2>::Result; }; ///////////////// LOKI //////////////// } 

अब इसका उपयोग कैसे किया जा सकता है? हां, यह बहुत आसान है:

 using Pin1 = Pin<GPIOC, 1>; using Pin2 = Pin<GPIOB, 1>; using Pin3 = Pin<GPIOA, 1>; using Pin4 = Pin<GPIOC, 2>; using Pin5 = Pin<GPIOA, 3>; using Pin6 = Pin<GPIOC, 1>; int main() { //  Pin1  ,    Pin6      using PinList = Collection<Pin1, Pin2, Pin3, Pin4, Pin1, Pin6> ; using TPins = typename NoDuplicates<PinList>::Result; //  static_assert.        // : Collection<Pin1, Pin2, Pin3, Pin4, Pin1, Pin6> //   : Collection<Pin1, Pin2, Pin3, Pin4> // ,    static_assert(std::is_same<TPins, PinList>::value, ":    ") ; return 0; } 

खैर यानी यदि आपने गलत तरीके से पिन की सूची निर्दिष्ट की है, और गलती से दो समान पिन सूची में इंगित किए गए हैं, तो प्रोग्राम संकलन नहीं करेगा, और कंपाइलर एक त्रुटि देगा: "परेशानी: सूची में समान पिन।"

 //        // PinsPack<Port<GPIOB, 0>, Port<GPIOB, 1> ... Port<GPIOB, 15>> using GpiobPort = typename GeneratePins<15, GPIOB>::type //      using GpioaPort = typename GeneratePins<15, GPIOA>::type int main() { //    :  GPIOA.0  1 Gpioa<0>::Set() ; // GPIOB.1  0 Gpiob<1>::Clear() ; using LcdData = Collection<Gpioa<0>, Gpiob<6>, Gpiob<2>, Gpioa<3>, Gpioc<7>, Gpioa<4>, Gpioc<3>, Gpioc<10>> ; using TPinsLcd = typename NoDuplicates<LcdData>::Result; static_assert(std::is_same<TPinsB, LcdData>::value, ":        LCD") ; // A      LcdData::Write('A'); } 

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

 int main() { return 0 ; } 

आइए कुछ कोड जोड़ें और सूची में पिन सेट करने के लिए Set() विधि बनाने का प्रयास Set() ।

पोर्ट पिन स्थापना विधि

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

 using Pin1 = Pin<GPIOA, 1>; using Pin2 = Pin<GPIOB, 2>; using Pin3 = Pin<GPIOA, 2>; using Pin4 = Pin<GPIOC, 1>; using Pin5 = Pin<GPIOA, 3>; int main() { PinsPack<Pin1, Pin2, Pin3, Pin4, Pin5>::Set() ; //      3   // GPIOA->BSRR = 14 ; // (1<<1) | (1 << 2) | (1 << 3) ; // GPIOB->BSRR = 4 ; // (1 << 2) // GPIOB->BSRR = 2 ; // (1 << 1); } 

इसलिए, हम एक वर्ग की घोषणा करते हैं जिसमें पिंस की एक सूची होगी, और इसमें हम सार्वजनिक स्थैतिक विधि Set() को परिभाषित करते हैं।

 template <typename ...Ts> struct PinsPack { using Pins = PinsPack<Ts...> ; public: __forceinline static void Set(std::size_t mask) { } } ; 

जैसा कि आप देख सकते हैं, Set(size_t mask) विधि किसी प्रकार का मान (मुखौटा) लेती है। यह मुखौटा वह संख्या है जिसे आपको बंदरगाहों में लगाने की आवश्यकता है। डिफ़ॉल्ट रूप से, यह 0xffffffff है, जिसका अर्थ है कि हम सभी पिनों को सूची में रखना चाहते हैं (अधिकतम 32)। यदि आप वहां एक और मूल्य पास करते हैं, उदाहरण के लिए, 7 == 0b111, तो सूची में केवल पहले 3 पिन स्थापित होना चाहिए, और इसी तरह। यानी पिन सूची में मास्क ओवरलेड।

पोर्ट लिस्टिंग

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

हमारे पिन विभिन्न बंदरगाहों को सौंपे गए हैं:

 using Pin1 = Pin<Port<GPIOA>, 1>; using Pin2 = Pin<Port<GPIOB>, 2>; using Pin3 = Pin<Port<GPIOA>, 2>; using Pin4 = Pin<Port<GPIOC>, 1>; using Pin5 = Pin<Port<GPIOA>, 3>; 

इन 5 पिनों में केवल 3 अद्वितीय पोर्ट (GPIOA, GPIOB, GPIOC) हैं। अगर हम PinsPack<Pin1, Pin2, Pin3, Pin4, Pin5> सूची घोषित करते हैं, तो हमें उससे तीन पोर्ट की सूची प्राप्त करने की आवश्यकता है: Collection<Port<GPIOA>, Port<GPIOB>, Port<GPIOC>>

पिन क्लास में पोर्ट का प्रकार होता है और सरलीकृत रूप में ऐसा दिखता है:

 template<typename Port, uint8_t pinNum> struct Pin { using PortType = Port ; static constexpr uint32_t pin = pinNum ; ... } 

इसके अलावा, आपको अभी भी इस सूची के लिए एक संरचना को परिभाषित करने की आवश्यकता है, यह सिर्फ एक टेम्पलेट संरचना होगी जो टेम्पलेट तर्कों की एक चर संख्या लेता है

 template <typename... Types> struct Collection{} ; 

अब हम अद्वितीय बंदरगाहों की एक सूची को परिभाषित करते हैं, और एक ही समय में जांचते हैं कि पिन की सूची में समान पिन नहीं हैं। यह करना आसान है:

 template <typename ...Ts> struct PinsPack { using Pins = PinsPack<Ts...> ; private: //      using TPins = typename NoDuplicates<Collection<Ts...>>::Result; //           static_assert(std::is_same<TPins, Collection<Ts...>>::value, ":    ") ; //     using Ports = typename NoDuplicates<Collection<typename Ts::PortType...>>::Result; ... } ; 

आगे बढ़ो ...

पोर्ट लिस्ट बायपास

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

चूँकि हमें एक सूची को बाईपास करना होगा जिसका आकार निश्चित रूप से ज्ञात नहीं है, फ़ंक्शन एक चर संख्या पैरामीटर के साथ टेम्पलेट होगा।

हम "पुनरावर्ती" के आसपास जाएंगे, जबकि टेम्पलेट में अभी भी पैरामीटर हैं, हम उसी नाम से एक फ़ंक्शन कहेंगे।

 template <typename ...Ts> struct PinsPack { using Pins = PinsPack<Ts...> ; private: __forceinline template<typename Port, typename ...Ports> constexpr static void SetPorts(Collection<Port, Ports...>, std::size_t mask) { // ,       if constexpr (sizeof ...(Ports) != 0U) { Pins::template WritePorts<Ports...>(Collection<Ports...>(), mask) ; } } } 

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

 __forceinline template<typename Port, typename ...Ports> constexpr static void SetPorts(Collection<Port, Ports...>, std::size_t mask) { //      auto result = GetPortValue<Port>(mask) ; //      Port::Set(result) ; if constexpr (sizeof ...(Ports) != 0U) { Pins::template WritePorts<Ports...>(Collection<Ports...>(), mask) ; } } 

इस पद्धति को रनटाइम में निष्पादित किया जाएगा, क्योंकि mask पैरामीटर बाहर से फ़ंक्शन के लिए पारित किया गया है। और इस तथ्य के कारण कि हम गारंटी नहीं दे सकते हैं कि SetPorts() विधि में एक स्थिरांक पारित हो जाएगा, SetPorts() विधि भी रनटाइम पर निष्पादित करना शुरू कर देगी।

और यद्यपि, लेख में C ++ में माइक्रोकंट्रोलर्स के इनपुट / आउटपुट पोर्ट के साथ काम करते हुए, यह लिखा जाता है कि एक समान विधि में कंपाइलर ने निर्धारित किया कि एक स्थिरांक को पारित किया गया था और संकलन चरण में पोर्ट पर लिखने के लिए मूल्य की गणना की गई, मेरे कंपाइलर ने अधिकतम अनुकूलन पर केवल इस तरह की चाल की।
मैं चाहूंगा कि GetValue() किसी भी संकलक सेटिंग्स के साथ संकलन समय पर निष्पादित GetValue() ।

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

एक स्थिर मूल्य के स्पष्ट हस्तांतरण को सुनिश्चित करने के लिए, हम टेम्पलेट में पासिंग mask साथ एक अतिरिक्त विधि बनाएंगे:

 __forceinline template<std::size_t mask, typename Port, typename ...Ports> constexpr static void SetPorts(Collection<Port, Ports...>) { using MyPins = PinsPack<Ts...> ; //    compile time,    value    constexpr auto result = GetPortValue<Port>(mask) ; Port::Set(result) ; if constexpr (sizeof ...(Ports) != 0U) { MyPins::template SetPorts<mask,Ports...>(Collection<Ports...>()) ; } } 

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

पोर्ट में सेट किए जाने वाले मान की गणना

हमारे पास पोर्ट की एक सूची है जो हमें पिन सूची से मिली है, हमारे उदाहरण के लिए यह एक सूची है: Collection<Port<GPIOA>, Port<GPIOB>, Port<GPIOC>> ।
आपको इस सूची का एक तत्व लेने की आवश्यकता है, उदाहरण के लिए, GPIOA पोर्ट, फिर पिन सूची में वे सभी पिन ढूंढें जो इस पोर्ट से जुड़े हैं और पोर्ट में स्थापना के लिए मूल्य की गणना करते हैं। और फिर अगले पोर्ट के साथ भी ऐसा ही करें।

 using Pin1 = Pin<Port<GPIOC>, 1>; using Pin2 = Pin<Port<GPIOB>, 1>; using Pin3 = Pin<Port<GPIOA>, 1>; using Pin4 = Pin<Port<GPIOC>, 2>; using Pin5 = Pin<Port<GPIOA>, 3>; using Pins = PinsPack<Pin1, Pin2, Pin3, Pin4, Pin5> ; 

तो GPIOA पोर्ट के लिए, मान होना चाहिए (1 << 1 ) | (1 << 3) = 10 (1 << 1 ) | (1 << 3) = 10 , और GPIOC पोर्ट के लिए - (1 << 1) | (1 << 2) = 6 (1 << 1) | (1 << 2) = 6 , और GPIOB (1 << 1 ) = 2

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

 template <typename ...Ts> struct PinsPack { using Pins = PinsPack<Ts...> ; private: __forceinline template<class QueryPort> constexpr static auto GetPortValue(std::size_t mask) { std::size_t result = 0; //  ,       // 1. ,        // 2.            // e (.     ), ,  Pin   0  //        10,      //    ( )  (1 << 10)    // 3.    1   // 4.   1-3      pass{(result |= ((std::is_same<QueryPort, typename Ts::PortType>::value ? 1 : 0) & mask) * (1 << Ts::pin), mask >>= 1)...} ; return result; } } ; 

प्रत्येक पोर्ट के पोर्ट के लिए परिकलित मान सेट करना

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

 template <typename ...Ts> struct PinsPack { using Pins = PinsPack<Ts...> ; __forceinline static void Set(std::size_t mask) { //        SetPorts(Ports(), mask) ; } } 

जैसा कि SetPorts() के मामले में SetPorts() एक स्थिर के रूप में mask के हस्तांतरण की गारंटी देने के लिए एक अतिरिक्त टेम्पलेट विधि बनाएंगे, इसे टेम्पलेट विशेषता में पास करेंगे।

 template <typename ...Ts> struct PinsPack { using Pins = PinsPack<Ts...> ; //    0xffffffff,      32  __forceinline template<std::size_t mask = 0xffffffffU> static void Set() { SetPorts<mask>(Ports()) ; } } 

 using namespace PinHelper ; template <typename ...Ts> struct PinsPack { using Pins = PinsPack<Ts...> ; private: using TPins = typename NoDuplicates<Collection<Ts...>>::Result; static_assert(std::is_same<TPins, Collection<Ts...>>::value, ":    ") ; using Ports = typename NoDuplicates<Collection<typename Ts::PortType...>>::Result; template<class Q> constexpr static auto GetPortValue(std::size_t mask) { std::size_t result = 0; auto rmask = mask ; pass{(result |= ((std::is_same<Q, typename Ts::PortType>::value ? 1 : 0) & mask) * (1 << Ts::pin), mask>>=1)...}; pass{(result |= ((std::is_same<Q, typename Ts::PortType>::value ? 1 : 0) & ~rmask) * ((1 << Ts::pin) << 16), rmask>>=1)...}; return result; } __forceinline template<typename Port, typename ...Ports> constexpr static void SetPorts(Collection<Port, Ports...>, std::size_t mask) { auto result = GetPortValue<Port>(mask) ; Port::Set(result & 0xff) ; if constexpr (sizeof ...(Ports) != 0U) { Pins::template SetPorts<Ports...>(Collection<Ports...>(), mask) ; } } __forceinline template<std::size_t mask, typename Port, typename ...Ports> constexpr static void SetPorts(Collection<Port, Ports...>) { constexpr auto result = GetPortValue<Port>(mask) ; Port::Set(result & 0xff) ; if constexpr (sizeof ...(Ports) != 0U) { Pins::template SetPorts<mask, Ports...>(Collection<Ports...>()) ; } } __forceinline template<typename Port, typename ...Ports> constexpr static void WritePorts(Collection<Port, Ports...>, std::size_t mask) { auto result = GetPortValue<Port>(mask) ; Port::Set(result) ; if constexpr (sizeof ...(Ports) != 0U) { Pins::template WritePorts<Ports...>(Collection<Ports...>(), mask) ; } } __forceinline template<std::size_t mask, typename Port, typename ...Ports> constexpr static void WritePorts(Collection<Port, Ports...>) { Port::Set(GetPortValue<Port>(mask)) ; if constexpr (sizeof ...(Ports) != 0U) { Pins::template WritePorts<mask, Ports...>(Collection<Ports...>()) ; } } public: static constexpr size_t size = sizeof ...(Ts) + 1U ; __forceinline static void Set(std::size_t mask ) { SetPorts(Ports(), mask) ; } __forceinline template<std::size_t mask = 0xffffffffU> static void Set() { SetPorts<mask>(Ports()) ; } __forceinline static void Write(std::size_t mask) { WritePorts(Ports(), mask) ; } __forceinline template<std::size_t mask = 0xffffffffU> static void Write() { WritePorts<mask>(Ports()) ; } } ; 

नतीजतन, पूरी चीज इस प्रकार इस्तेमाल की जा सकती है:

 using Pin1 = Pin<GPIOC, 1>; using Pin2 = Pin<GPIOB, 1>; using Pin3 = Pin<GPIOA, 1>; using Pin4 = Pin<GPIOC, 2>; using Pin5 = Pin<GPIOA, 3>; using Pin6 = Pin<GPIOA, 5>; using Pin7 = Pin<GPIOC, 7>; using Pin8 = Pin<GPIOA, 3>; int main() { //1.   ,     3 ,  : // GPIOA->BSRR = (1 << 1) | (1 << 3) // GPIOB->BSRR = (1 << 1) // GPIOC->BSRR = (1 << 1) | (1 << 2) PinsPack<Pin1, Pin2, Pin3, Pin4, Pin5>::Set() ; //   Set<0xffffffffU>() //2.   ,  3 ,  : // GPIOA->BSRR = (1 << 1) // GPIOB->BSRR = (1 << 1) // GPIOC->BSRR = (1 << 1) | (1 << 2) PinsPack<Pin1, Pin2, Pin3, Pin4, Pin5, Pin6>::Set<7>() ; //3.          , //   someRunTimeValue     ,  //  SetPorts   constexpr    PinsPack<Pin1, Pin2, Pin3, Pin4, Pin5>::Set(someRunTimeValue) ; using LcdData = PinsPack<Pin1, Pin2, Pin3, Pin4, Pin5, Pin6, Pin7, Pin8> ; LcdData::Write('A') ; } 

एक और पूरा उदाहरण यहाँ पाया जा सकता है:
https://onlinegdb.com/r1eoXQBRH

गति

जैसा कि आपको याद है, हम अपनी कॉल को 3 लाइनों में बदलना चाहते थे, ए 10 को पोर्ट करने के लिए सेट करें, पोर्ट बी - 2 और पोर्ट सी - 6

 using Pin1 = Pin<GPIO, 1>; using Pin2 = Pin<GPIOB, 1>; using Pin3 = Pin<GPIOA, 1>; using Pin4 = Pin<GPIOC, 2>; using Pin5 = Pin<GPIOA, 3>; int main() { //    Pin    : //   GPIOA  10 GPIOA->BSRR = 10 ; // (1<<1) | (1 << 3) ; //   GPIOB  2 GPIOB->BSRR = 2 ; // (1 << 1) //   GPIOC  6 GPIOB->BSRR = 6 ; // (1 << 1) | (1 << 2); PinsPack<Pin1, Pin2, Pin3, Pin4, Pin5>::Set() ; return 0; } 

आइए देखें कि अनुकूलन के साथ जो हुआ वह पूरी तरह से बंद हो गया।

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

वास्तव में यह सब है। कौन परवाह करता है, कोड यहाँ है ।

एक उदाहरण यहाँ है ।

https://onlinegdb.com/ByeA50wTS