C ++ में हार्डवेयर रजिस्टरों के साथ काम करने के 10 ++ तरीके (उदाहरण के लिए, IAR और Cortex M)

_{अंजीर। आई कियोको}

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

आपको शायद दाढ़ी वाला किस्सा याद है, और शायद एक सच्ची कहानी है कि कैसे एक छात्र से बैरोमीटर का उपयोग करके इमारत की ऊंचाई को मापने के तरीके के बारे में पूछा गया था। छात्र ने मेरी राय में, लगभग 20 या 30 तरीकों का हवाला दिया, जिसमें शिक्षक द्वारा अपेक्षित प्रत्यक्ष (दबाव में अंतर) का उल्लेख किए बिना।

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

विधि 1. स्पष्ट और स्पष्ट रूप से सबसे अच्छा नहीं

सबसे सामान्य विधि, जिसका उपयोग C ++ में भी किया जाता है, निर्माता से हेडर फ़ाइल से रजिस्टर संरचनाओं के विवरण का उपयोग करना है। प्रदर्शन के लिए, मैं STM32F411 माइक्रोकंट्रोलर के दो पोर्ट ए रजिस्टर (ODR - आउटपुट डेटा रजिस्टर और IDR - इनपुट डेटा रजिस्टर) ले जाऊंगा ताकि मैं "कढ़ाई" "हैलो वर्ल्ड" कर सकूं - एलईडी को ब्लिंक करें।

int main() { GPIOA->ODR ^= (1 << 5) ; GPIOA->IDR ^= (1 << 5) ; //,      } 

आइए देखें कि यहां क्या होता है और यह डिज़ाइन कैसे काम करता है। माइक्रोप्रोसेसर हेडर में GPIO_TypeDef संरचना और इस GPIOA संरचना के लिए एक सूचक परिभाषा GPIOA है। यह इस तरह दिखता है:

 typedef struct { __IO uint32_t MODER; //port mode register, Address offset: 0x00 __IO uint32_t OTYPER; //port output type register, Address offset: 0x04 __IO uint32_t OSPEEDR; //port output speed register, Address offset: 0x08 __IO uint32_t PUPDR; //port pull-up/pull-down register, Address offset: 0x0C __IO uint32_t IDR; //port input data register, Address offset: 0x10 __IO uint32_t ODR; //port output data register, Address offset: 0x14 __IO uint32_t BSRR; //port bit set/reset register, Address offset: 0x18 __IO uint32_t LCKR; //port configuration lock register, Address offset: 0x1C __IO uint32_t AFR[2]; //alternate function registers, Address offset: 0x20-0x24 } GPIO_TypeDef; #define PERIPH_BASE 0x40000000U //Peripheral base address in the alias region #define AHB1PERIPH_BASE (PERIPH_BASE + 0x00020000U) #define GPIOA_BASE (AHB1PERIPH_BASE + 0x0000U) #define GPIOA ((GPIO_TypeDef *) GPIOA_BASE) 

इसे साधारण मानव शब्दों में कहें, तो GPIO_TypeDef प्रकार की पूरी संरचना GPIO_TypeDef पते पर "लेट" GPIOA_BASE , और जब आप संरचना के एक विशिष्ट क्षेत्र का संदर्भ देते हैं, तो आप अनिवार्य रूप से इस संरचना के पते का उल्लेख करते हैं - इस संरचना के एक तत्व को ऑफसेट करें। यदि आप #define GPIOA , तो कोड इस तरह दिखेगा:

 ((GPIO_TypeDef *) GPIOA_BASE)->ODR ^= (1 << 5) ; ((GPIO_TypeDef *) GPIOA_BASE)->IDR ^= (1 << 5) ; // 

C ++ प्रोग्रामिंग भाषा के संबंध में, पूर्णांक पता GPIO_TypeDef संरचना में पॉइंटर प्रकार में परिवर्तित हो जाता है। लेकिन C ++ में, C रूपांतरण का उपयोग करते समय, कंपाइलर निम्नलिखित अनुक्रम में रूपांतरण करने की कोशिश करता है:

• const_cast
• static_cast
• स्थिर_कास्ट const_cast के बगल में,
• reinterpret_cast
• const_cast के बगल में reinterpret_cast

यानी यदि कंपाइलर const_cast का उपयोग करके प्रकार को परिवर्तित नहीं कर सका, तो वह static_cast और इतने पर लागू करने का प्रयास करता है। नतीजतन, कॉल:

 ((GPIO_TypeDef *) GPIOA_BASE)->ODR ^= (1 << 5) ; 

ऐसा कुछ नहीं है:

 reinterpret_cast<GPIO_TypeDef *> (GPIOA_BASE)->ODR ^= (1 << 5) ; 

वास्तव में, सी ++ अनुप्रयोगों के लिए, इस तरह से पते पर संरचना को "खींच" करना सही होगा:

 GPIO_TypeDef * GPIOA{reinterpret_cast<GPIO_TypeDef *>(GPIOA_BASE)} ; 

किसी भी मामले में, टाइप रूपांतरण के कारण, C ++ के लिए इस दृष्टिकोण का एक बड़ा ऋण है। यह इस तथ्य में constexpr है कि reinterpret_cast उपयोग न तो कंस्ट्रक्टर constexpr और फ़ंक्शंस में किया जा सकता है, न ही टेम्पलेट मापदंडों में, और यह माइक्रोकंट्रोलर्स के लिए C ++ सुविधाओं के उपयोग को काफी कम करता है।
मैं इसे उदाहरणों के साथ समझाऊंगा। ऐसा करना संभव है:

  struct Test { const int a; const int b; } ; template<Test* mystruct> constexpr const int Geta() { return mystruct->a; } Test test{1,2}; int main() { Geta<&test>() ; } 

लेकिन आप ऐसा पहले से नहीं कर सकते:

 template<GPIO_TypeDef * mystruct> constexpr volatile uint32_t GetIdr() { return mystruct->IDR; } int main() { //GPIOA  reinterpret_cast<GPIO_TypeDef *> (GPIOA_BASE) //  ,        GetIdr<GPIOA>() ; // } //      : struct Port { constexpr Port(GPIO_TypeDef * ptr): port(*ptr) {} GPIO_TypeDef & port ; } //  GPIOA  reinterpret_cast,   //  constexpr      constexpr Port portA{GPIOA}; //    

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

आकर्षण आते हैं

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

विपक्ष

• मेटाप्रोग्रामिंग का सीमित उपयोग
• कॉन्स्टैक्स निर्माणकर्ताओं में उपयोग करने में असमर्थता
• कक्षाओं में रैपर का उपयोग करते समय, रैम की अतिरिक्त खपत इस संरचना का एक उद्देश्य है
• आप बेवकूफ बना सकते हैं

अब आइए विधि संख्या 2 देखें

विधि 2. क्रूर

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

 *reinterpret_cast<volatile uint32_t *>(GpioaOdrAddr) ^= (1 <<5) ; *reinterpret_cast<volatile uint32_t *>(GpioaIdrAddr) ^= (1 <<5) ; // 

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

विधि 3. स्पष्ट और स्पष्ट रूप से अधिक सही

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

 template<uint32_t addr, uint32_t pinNum> struct Pin { using Registers = GPIO_TypeDef ; __forceinline static void Toggle() { //     addr Registers *GpioPort{reinterpret_cast<Registers*>(addr)}; GpioPort->ODR ^= (1 << pinNum) ; } }; int main() { using Led1 = Pin<GPIOA_BASE, 5> ; Led1::Toggle() ; } 

मेरी दृष्टि से, कोई विशेष मंत्र नहीं हैं। सिद्धांत रूप में, एक कार्य विकल्प। लेकिन फिर भी, आइए अन्य तरीकों पर एक नज़र डालें।

विधि 4. एक्सोटेरिक रैप

समझने योग्य कोड के पारखी के लिए, आप रजिस्टर पर एक आवरण बना सकते हैं ताकि उन्हें एक्सेस करना सुविधाजनक हो और "सुंदर" दिखें, कंस्ट्रक्टर को फिर से परिभाषित करें:

 class Register { public: explicit Register(uint32_t addr) : ptr{ reinterpret_cast<volatile uint32_t *>(addr) } { } __forceinline inline Register& operator^=(const uint32_t right) { *ptr ^= right; return *this; } private: volatile uint32_t *ptr; //    }; int main() { Register Odr{GpioaOdrAddr}; Odr ^= (1 << 5); Register Idr{GpioaIdrAddr}; Idr ^= (1 << 5); // } 

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

विधि 4,5। पैटर्न के साथ एक्सोटेरिक लपेटें

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

 template<uint32_t addr> class Register { public: Register() : ptr{reinterpret_cast<volatile uint32_t *>(addr)} { } __forceinline inline Register &operator^=(const uint32_t right) { *ptr ^= right; return *this; } private: volatile std::uint32_t *ptr; }; int main() { using GpioaOdr = Register<GpioaOdrAddr>; GpioaOdr Odr; Odr ^= (1 << 5); using GpioaIdr = Register<GpioaIdrAddr>; GpioaIdr Idr; Idr ^= (1 << 5); // } 

और इसलिए, एक ही रेक, साइड व्यू।

विधि 5. उचित

जाहिर है, आपको पॉइंटर से छुटकारा पाने की आवश्यकता है, इसलिए चलो ऐसा ही करें, लेकिन अनावश्यक पॉइंटर को कक्षा से हटा दें।

 template<uint32_t addr> class Register { public: __forceinline Register &operator^=(const uint32_t right) { *reinterpret_cast<volatile uint32_t *>(addr) ^= right; return *this; } }; using GpioaOdr = Register<GpioaOdrAddr>; GpioaOdr Odr; Odr ^= (1 << 5); using GpioaIdr = Register<GpioaIdrAddr>; GpioaIdr Idr; Idr ^= (1 << 5); // 

आप यहां रह सकते हैं और थोड़ा सोच सकते हैं। यह विधि तुरंत 2 समस्याओं को हल करती है जो पहले विधि से विरासत में मिली थीं। सबसे पहले, अब मैं टेम्पलेट में Register ऑब्जेक्ट के लिए पॉइंटर का उपयोग कर सकता हूं, और दूसरी बात, मैं इसे constexrp कंस्ट्रक्टर को पास कर सकता हूं।

 template<Register * register> void Xor(uint32_t mask) { *register ^= mask ; } Register<GpioaOdrAddr> GpioaOdr; int main() { Xor<&GpioaOdr>(1 << 5) ; //  } //   struct Port { constexpr Port(Register& ref): register(ref) {} Register & register ; } constexpr Port portA{GpioaOdr}; 

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

आकर्षण आते हैं

• उपयोग में आसानी
• मेटाप्रोग्रामिंग का उपयोग करने की क्षमता
• कंस्ट्रक्टर बिल्डरों में उपयोग करने की क्षमता

विपक्ष

• निर्माता से सत्यापित हेडर फ़ाइल का उपयोग नहीं किया जाता है
• आपको रजिस्टरों के सभी पते स्वयं निर्धारित करने होंगे
• आपको कक्षा रजिस्टर की एक वस्तु बनाने की आवश्यकता है
• आप बेवकूफ बना सकते हैं

बढ़िया है, लेकिन अभी भी बहुत सारे मंत्री हैं ...

विधि 6. उचित से अधिक चिकना

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

 template<uint32_t addr> class Register { public: __forceinline inline static void Xor(const uint32_t mask) { *reinterpret_cast<volatile uint32_t *>(addr) ^= mask; } }; int main() { using namespace Case6 ; using Odr = Register<GpioaOdrAddr>; Odr::Xor(1 << 5); using Idr = Register<GpioaIdrAddr>; Idr::Xor(1 << 5); // } 

एक प्लस जोड़ा गया

• कोई उपरि नहीं। फास्ट कॉम्पैक्ट कोड, विकल्प 1 में समान (जब कक्षाओं में रैपर का उपयोग किया जाता है, तो कोई अतिरिक्त रैम लागत नहीं होती है, क्योंकि ऑब्जेक्ट नहीं बनाया जाता है, लेकिन ऑब्जेक्ट बनाने के बिना स्थिर तरीकों का उपयोग किया जाता है)

आगे बढ़ो ...

विधि 7. मूर्खता को दूर करें

जाहिर है, मैं लगातार कोड में NON-FUNNY कर रहा हूं और रजिस्टर में कुछ लिख रहा हूं, जो वास्तव में लिखने का इरादा नहीं है। यह ठीक है, निश्चित रूप से, लेकिन STUPIDness निषिद्ध होना चाहिए। बकवास करने से मना करें ऐसा करने के लिए, हम सहायक संरचनाओं का परिचय देते हैं:

  struct WriteReg {}; struct ReadReg {}; struct ReadWriteReg: public WriteReg, public ReadReg {}; 

अब हम लिखने के लिए रजिस्टर सेट कर सकते हैं, और रजिस्टर केवल-पढ़ने के लिए हैं:

 template<uint32_t addr, typename RegisterType> class Register { public: //       WriteReg,    // ,  ,       __forceinline template <typename T = RegisterType, class = typename std::enable_if_t<std::is_base_of<WriteReg, T>::value>> Register &operator^=(const uint32_t right) { *reinterpret_cast<volatile uint32_t *>(addr) ^= right; return *this; } }; 

अब आइए हमारे परीक्षण को संकलित करने का प्रयास करें और देखें कि परीक्षण संकलित नहीं करता है, क्योंकि Idr रजिस्टर के लिए ^= ऑपरेटर मौजूद नहीं है:

  int main() { using GpioaOdr = Register<GpioaOdrAddr, WriteReg> ; GpioaOdr Odr ; Odr ^= (1 << 5) ; using GpioaIdr = Register<GpioaIdrAddr, ReadReg> ; GpioaIdr Idr ; Idr ^= (1 << 5) ; //,  Idr    } 

तो, अब अधिक pluses हैं ...

आकर्षण आते हैं

• उपयोग में आसानी
• मेटाप्रोग्रामिंग का उपयोग करने की क्षमता
• कंस्ट्रक्टर बिल्डरों में उपयोग करने की क्षमता
• फास्ट कॉम्पैक्ट कोड, विकल्प 1 में समान
• कक्षाओं में रैपर का उपयोग करते समय, कोई अतिरिक्त रैम लागत नहीं होती है, क्योंकि ऑब्जेक्ट नहीं बनाया जाता है, लेकिन स्टैटिक विधियों का उपयोग वस्तुओं को बनाए बिना किया जाता है
• आप मूर्खता नहीं कर सकते

विपक्ष

• निर्माता से सत्यापित हेडर फ़ाइल का उपयोग नहीं किया जाता है
• आपको रजिस्टरों के सभी पते स्वयं निर्धारित करने होंगे
• आपको कक्षा रजिस्टर की एक वस्तु बनाने की आवश्यकता है

तो आइए अधिक को बचाने के लिए एक वर्ग बनाने का अवसर निकालें

विधि 8. बिना NONSENSE और बिना किसी क्लास ऑब्जेक्ट के

तुरंत कोड:

  struct WriteReg {}; struct ReadReg {}; struct ReadWriteReg: public WriteReg, public ReadReg {}; template<uint32_t addr, typename T> class Register { public: __forceinline template <typename T1 = T, class = typename std::enable_if_t<std::is_base_of<WriteReg, T1>::value>> inline static void Xor(const uint32_t mask) { *reinterpret_cast<volatile int*>(addr) ^= mask; } }; int main { using GpioaOdr = Register<GpioaOdrAddr, WriteReg> ; GpioaOdr::Xor(1 << 5) ; using GpioaIdr = Register<GpioaIdrAddr, ReadReg> ; GpioaIdr::Xor(1 << 5) ; //,  Idr    } 

हम एक और प्लस जोड़ते हैं, हम एक ऑब्जेक्ट नहीं बनाते हैं। लेकिन आगे बढ़ें, हमारे पास अभी भी विपक्ष है

विधि 9. संरचना एकीकरण के साथ विधि 8

पिछली पद्धति में, केवल मामले को परिभाषित किया गया था। लेकिन विधि 1 में, सभी रजिस्टरों को संरचनाओं में संयोजित किया जाता है ताकि आप उन्हें मॉड्यूल द्वारा आसानी से एक्सेस कर सकें। चलिए करते हैं ...

 namespace Case9 { struct WriteReg {}; struct ReadReg {}; struct ReadWriteReg: public WriteReg, public ReadReg {}; template<uint32_t addr, typename T> class Register { public: __forceinline template <typename T1 = T, class = typename std::enable_if_t<std::is_base_of<WriteReg, T1>::value>> inline static void Xor(const uint32_t mask) { *reinterpret_cast<volatile int*>(addr) ^= mask; } }; template<uint32_t addr> struct Gpio { using Moder = Register<addr, ReadWriteReg>; //      using Otyper = Register<addr + OtyperShift, ReadWriteReg> ; using Ospeedr = Register<addr + OspeedrShift,ReadWriteReg> ; using Pupdr = Register<addr + PupdrShift,ReadWriteReg> ; using Idr = Register<addr + IdrShift, ReadReg> ; using Odr = Register<addr + OdrShift, WriteReg> ; }; int main() { using Gpioa = Gpio<GPIOA_BASE> ; Gpioa::Odr::Xor(1 << 5) ; Gpioa::Idr::Xor((1 << 5) ); //,  Idr    } 

यहां माइनस यह है कि संरचनाओं को नए सिरे से पंजीकृत करने की आवश्यकता होगी, और सभी रजिस्टरों के ऑफसेट को कहीं न कहीं याद किया जाना चाहिए और निर्धारित किया जाना चाहिए। यह अच्छा होगा यदि ऑफसेट कंपाइलर द्वारा सेट किए गए थे, और व्यक्ति द्वारा नहीं, लेकिन यह बाद में है, लेकिन अब हम अपने सहयोगी द्वारा सुझाए गए एक और दिलचस्प तरीके पर विचार करेंगे।

विधि 10. संरचना के एक सदस्य को सूचक के माध्यम से रजिस्टर पर लपेटें

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

 template<uint32_t addr, typename T> class RegisterStructWrapper { public: __forceinline template<typename P> inline static void Xor(PT::*member, int mask) { reinterpret_cast<T*>(addr)->*member ^= mask ; //   ,     . } } ; using GpioaWrapper = RegisterStructWrapper<GPIOA_BASE, GPIO_TypeDef> ; int main() { GpioaWrapper::Xor(&GPIO_TypeDef::ODR, (1 << 5)) ; GpioaWrapper::Xor(&GPIO_TypeDef::IDR, (1 << 5)) ; // return 0 ; } 

आकर्षण आते हैं

• उपयोग में आसानी
• मेटाप्रोग्रामिंग का उपयोग करने की क्षमता
• कंस्ट्रक्टर बिल्डरों में उपयोग करने की क्षमता
• फास्ट कॉम्पैक्ट कोड, विकल्प 1 में समान
• कक्षाओं में रैपर का उपयोग करते समय, कोई अतिरिक्त रैम लागत नहीं होती है, क्योंकि ऑब्जेक्ट नहीं बनाया जाता है, लेकिन स्टैटिक विधियों का उपयोग वस्तुओं को बनाए बिना किया जाता है
• निर्माता से सत्यापित हेडर फ़ाइल का उपयोग किया जाता है।
• सभी रजिस्टर पते को स्वयं सेट करने की आवश्यकता नहीं है
• कक्षा रजिस्टर की एक वस्तु बनाने की आवश्यकता नहीं है

विपक्ष

• आप मूर्खता बना सकते हैं और यहां तक ​​कि कोड की समझ पर भी अटकलें लगा सकते हैं।

विधि 10.5। विधि 9 और 10 को मिलाएं

संरचना की शुरुआत के सापेक्ष रजिस्टर की पारी का पता लगाने के लिए, आप सूचक को संरचना के सदस्य के लिए उपयोग कर सकते हैं: volatile uint32_t T::*member , यह बाइट्स में इसकी शुरुआत के सापेक्ष संरचना के सदस्य की ऑफसेट लौटाएगा। उदाहरण के लिए, हमारे पास GPIO_TypeDef संरचना है, फिर पता &GPIO_TypeDef::ODR 0x14 होगा।
हम इस अवसर को हरा देते हैं और कंपाइलर का उपयोग करके विधि 9 से रजिस्टरों के पते की गणना करते हैं:

 struct WriteReg {}; struct ReadReg {}; struct ReadWriteReg: public WriteReg, public ReadReg {}; template<uint32_t addr, typename T, volatile uint32_t T::*member, typename RegType> class Register { public: __forceinline template <typename T1 = RegType, class = typename std::enable_if_t<std::is_base_of<WriteReg, T1>::value>> inline static void Xor(const uint32_t mask) { reinterpret_cast<T*>(addr)->*member ^= mask ; } }; template<uint32_t addr, typename T> struct Gpio { using Moder = Register<addr, GPIO_TypeDef, &GPIO_TypeDef::ODR, ReadWriteReg>; using Otyper = Register<addr, GPIO_TypeDef, &GPIO_TypeDef::OTYPER, ReadWriteReg>; using Ospeedr = Register<addr, GPIO_TypeDef, &GPIO_TypeDef::OSPEEDR, ReadWriteReg>; using Pupdr = Register<addr, GPIO_TypeDef, &GPIO_TypeDef::PUPDR, ReadWriteReg>; using Idr = Register<addr, GPIO_TypeDef, &GPIO_TypeDef::IDR, ReadReg>; using Odr = Register<addr, GPIO_TypeDef, &GPIO_TypeDef::ODR, WriteReg>; } ; 

आप अधिक उत्कृष्ट रूप से रजिस्टरों के साथ काम कर सकते हैं:

 using namespace Case11 ; using Gpioa = Gpio<GPIOA_BASE, GPIO_TypeDef> ; Gpioa::Odr::Xor(1 << 5) ; //Gpioa::Idr::Xor((1 << 5) ); //,  Idr    

जाहिर है, यहां सभी संरचनाओं को फिर से लिखना होगा। यह स्वचालित रूप से किया जा सकता है, फाइटन में कुछ स्क्रिप्ट द्वारा, इनपुट में कुछ stm32f411xe.h की तरह C ++ में उपयोग के लिए संरचनाओं के साथ आपकी फ़ाइल के आउटपुट पर।
किसी भी मामले में, कई अलग-अलग तरीके हैं जो किसी विशेष परियोजना में काम कर सकते हैं।

बोनस। हम Phyton का उपयोग करते हुए भाषा विस्तार और पार्सिम कोड पेश करते हैं

C ++ में रजिस्टरों के साथ काम करने की समस्या काफी समय से है। लोग इसे विभिन्न तरीकों से हल करते हैं। निश्चित रूप से यह बहुत अच्छा होगा यदि भाषा संकलन समय पर कक्षाओं का नाम बदलने जैसी किसी चीज़ का समर्थन करती है। ठीक है, चलो कहते हैं, अगर यह इस तरह थे:

 template<classname = [PortName]> class Gpio[Portname] { __forceinline inline static void Xor(const uint32_t mask) { GPIO[PortName]->ODR ^= mask ; } }; int main() { using GpioA = Gpio<"A"> ; GpioA::Xor(5) ; } 

लेकिन दुर्भाग्य से यह भाषा समर्थन नहीं करती है। इसलिए, जो समाधान लोग उपयोग करते हैं वह पायथन का उपयोग करके कोड पार्सिंग है। यानी कुछ भाषा विस्तार पेश किया गया है। इस एक्सटेंशन का उपयोग करते हुए कोड को पायथन पार्सर को खिलाया जाता है, जो इसे C ++ कोड में बदल देता है। ऐसा कोड कुछ इस तरह दिखता है: (एक उदाहरण मॉडम लाइब्रेरी से लिया गया है; यहां पूर्ण स्रोत हैं ):

 %% set port = gpio["port"] | upper %% set reg = "GPIO" ~ port %% set pin = gpio["pin"] class Gpio{{ port ~ pin }} : public Gpio { __forceinline inline static void Xor() { GPIO{{port}}->ODR ^= 1 << {{pin}} ; } } //        class Gpio5 : public Gpio { __forceinline inline static void Xor() { GPIO->ODR ^= 1 << 5 ; } } //     using Led = Gpio5; Led::Xor(); 

अपडेट: बोनस एसवीडी फाइलें और पैटन पर पार्सर

एक और विकल्प जोड़ना भूल गए। एआरएम प्रत्येक एसवीडी निर्माता के लिए एक रजिस्टर विवरण फ़ाइल जारी करता है। जिससे आप फिर रजिस्टरों के विवरण के साथ C ++ फ़ाइल जनरेट कर सकते हैं। पॉल ओसबोर्न ने इन सभी फाइलों को गिटहब पर संकलित किया है । उन्होंने उन्हें पार्स करने के लिए एक पायथन स्क्रिप्ट भी लिखी।

यह सब ... मेरी कल्पना समाप्त हो गई है। यदि आपके पास अभी भी विचार हैं, तो बेझिझक। सभी विधियों के साथ एक उदाहरण यहाँ निहित है।

संदर्भ

C ++ में टाइपसेफ रजिस्टर रजिस्टर एक्सेस
चीजें बनाना C-++ से हार्डवेयर-सामान करना
सामान बनाना सामान - भाग 3
सामान बनाना - संरचना ओवरले