दक्षता का त्याग किए बिना C ++ में फ़ील्ड रजिस्टर करने के लिए सुरक्षित पहुँच (उदाहरण के रूप में CortexM का उपयोग करके)

परिचय

int main(void) { //      GPIOA //,    AHB1ENR RCC->APB1ENR |= RCC_AHB1ENR_GPIOAEN ; //    ,      RCC->AHB1ENR = RCC_AHB1ENR_GPIOAEN; //,  TIM1    APB2 RCC->APB1ENR |= RCC_APB1ENR_TIM2EN | RCC_APB2ENR_TIM1EN; // - ,        . auto result = GPIOA->BSRR ; if (result & GPIO_BSRR_BS1) { //do something } //-     .   ... GPIOA->IDR = GPIO_IDR_ID5 ; } 

 int main() { uint32 temp = GPIOA->OSPEEDR ; temp &=~ GPIO_OSPEEDR_OSPEED0_Msk ; temp = (GPIO_OSPEEDR_OSPEED0_0 | GPIO_OSPEEDR_OSPEED0_1) ; GPIOA->OSPEEDR = temp; } 

रजिस्टर अमूर्तता

• बिट 0 CEN: काउंटर सक्षम करें
  0: काउंटर सक्षम: अक्षम करें
  1: काउंटर बंद: सक्षम करें
  
• UDIS बिट 1: UEV इवेंट को सक्षम / अक्षम करें
  0: UEV इवेंट सक्षम: सक्षम करें
  1: UEV इवेंट बंद: अक्षम करें
  
• URS बिट 2: UEV इवेंट जनरेशन सोर्स का चयन करें
  0: UGV ओवरफ्लो होने पर या UG सेट करते समय उत्पन्न होता है: कोई भी बिट
  1: UEV केवल अतिप्रवाह पर उत्पन्न होता है: अतिप्रवाह
  
• बिट 3 ओपीएम: वन टाइम ऑपरेशन
  0: टाइमर UEV के बाद आगे की गिनती जारी रखता है: ContinueAfterUEV घटना
  1: टाइमर UEV: StopAfterUEV घटना के बाद बंद हो जाता है
  
• बिट 4 डीआईआर: गणना दिशा
  0: डायरेक्ट अकाउंट: एनकाउंटर
  1: काउंट डाउन : डाउनकाउंटर
  
• बिट 6: 5 सीएमएस: संरेखण मोड
  0: संरेखण मोड 0: CenterAlignedMode0
  1: संरेखण मोड 1: CenterAlignedMode1
  2: संरेखण मोड 2: CenterAlignedMode2
  3: संरेखण मोड 3: CenterAlignedMode3
  
• बिट 7 एपीआरई: एआरआर रजिस्टर के लिए प्रीलोड मोड
  0: TIMx_ARR रजिस्टर बफ़र्ड नहीं है: ARRNotBuffered
  1: TIMx_ARR रजिस्टर बफ़र्ड नहीं है: ARRBuffered
  
• बिट 8: 9 सीकेडी: क्लॉक डिवाइडर
  0: tDTS = tCK_INT: ClockDevidedBy1
  1: tDTS = 2 * tCK_INT: ClockDevidedBy2
  2: tDTS = 4 * tCK_INT: ClockDevidedBy4
  3: आरक्षित: आरक्षित
  

सिस्टम दृश्य विवरण (SVD) फ़ाइल

• डिवाइस स्तर : सिस्टम दृश्य का शीर्ष स्तर का वर्णन डिवाइस है। इस स्तर पर, संपूर्ण रूप से डिवाइस से संबंधित गुणों का वर्णन किया गया है। उदाहरण के लिए, एक उपकरण का नाम, विवरण या संस्करण। न्यूनतम पता योग्य इकाई, साथ ही डेटा बस की थोड़ी गहराई। रजिस्टर विशेषताओं के लिए डिफ़ॉल्ट मान, जैसे कि रजिस्टर आकार, रीसेट मान, और एक्सेस अनुमतियाँ, इस स्तर पर पूरे डिवाइस के लिए सेट की जा सकती हैं और अनुमानित रूप से विवरण के निम्न स्तर से विरासत में मिली हैं।
• माइक्रोकंट्रोलर स्तर: सीपीयू अनुभाग माइक्रोकंट्रोलर की कोर और इसकी विशेषताओं का वर्णन करता है। यदि डिवाइस हेडर फ़ाइल बनाने के लिए SVD फ़ाइल का उपयोग किया जाता है तो यह अनुभाग आवश्यक है।
• परिधीय परत : एक परिधीय उपकरण रजिस्टरों का एक नामित संग्रह है। एक परिधीय उपकरण को डिवाइस के पता स्थान में एक विशिष्ट आधार पते पर मैप किया जाता है।
• रजिस्टर स्तर : एक रजिस्टर एक नामित प्रोग्राम संसाधन है जो एक परिधीय उपकरण के अंतर्गत आता है। रजिस्टरों को डिवाइस के एड्रेस स्पेस में एक विशिष्ट पते पर मैप किया जाता है। यह पता आधार परिधीय पते के सापेक्ष है। इसके अलावा, रजिस्टर के लिए, एक्सेस मोड (रीड / राइट) इंगित किया गया है।
• फ़ील्ड स्तर : जैसा कि ऊपर उल्लेख किया गया है, रजिस्टरों को विभिन्न कार्यक्षमता - फ़ील्ड के बिट्स के टुकड़ों में विभाजित किया जा सकता है। इस स्तर में फ़ील्ड्स के नाम हैं जो एक ही रजिस्टर के भीतर अद्वितीय हैं, उनका आकार, रजिस्टर की शुरुआत के सापेक्ष, साथ ही एक्सेस मोड भी है।
• प्रगणित फ़ील्ड मानों का स्तर : वास्तव में, इन्हें फ़ील्ड मानों का नाम दिया जाता है जिनका उपयोग C, C ++, D, और इसी तरह की सुविधा के लिए किया जा सकता है।

 <peripheral> <name>TIM1</name> <description>Advanced-timers</description> <groupName>TIM</groupName> <baseAddress>0x40010000</baseAddress> <addressBlock> <offset>0x0</offset> <size>0x400</size> <usage>registers</usage> </addressBlock> <registers> <register> <name>CR1</name> <displayName>CR1</displayName> <description>control register 1</description> <addressOffset>0x0</addressOffset> <size>0x20</size> <access>read-write</access> <resetValue>0x0000</resetValue> <fields> <field> <name>CKD</name> <description>Clock division</description> <bitOffset>8</bitOffset> <bitWidth>2</bitWidth> </field> <field> <name>ARPE</name> <description>Auto-reload preload enable</description> <bitOffset>7</bitOffset> <bitWidth>1</bitWidth> </field> <field> <name>CMS</name> <description>Center-aligned mode selection</description> <bitOffset>5</bitOffset> <bitWidth>2</bitWidth> </field> <field> <name>DIR</name> <description>Direction</description> <bitOffset>4</bitOffset> <bitWidth>1</bitWidth> </field> <field> <name>OPM</name> <description>One-pulse mode</description> <bitOffset>3</bitOffset> <bitWidth>1</bitWidth> </field> <field> <name>URS</name> <description>Update request source</description> <bitOffset>2</bitOffset> <bitWidth>1</bitWidth> </field> <field> <name>UDIS</name> <description>Update disable</description> <bitOffset>1</bitOffset> <bitWidth>1</bitWidth> </field> <field> <name>CEN</name> <description>Counter enable</description> <bitOffset>0</bitOffset> <bitWidth>1</bitWidth> </field> </fields> </register> <register> 

कार्यान्वयन

रजिस्टर

  if (TIM1::CR1::CKD::DividedBy2::IsSet()) { TIM1::ARR::Set(10_ms) ; TIM1::CR1::CEN::Enable::Set() ; } 

 *reinterpret_cast<volatile uint32_t *>(0x40010000) = (1U << 5U) ; 

 //      template<uint32_t address, size_t size, typename AccessMode> struct RegisterBase { static constexpr auto Addr = address ; using Type = typename RegisterType<size>::Type ; // Set     , //     __forceinline template<typename T = AccessMode, class = typename std::enable_if_t<std::is_base_of<WriteMode, T>::value>> inline static void Set(Type value) { *reinterpret_cast<volatile Type *>(address) = value ; } // Get    , //    ,    __forceinline template<typename T = AccessMode, class = typename std::enable_if_t<std::is_base_of<ReadMode, T>::value>> inline static Type Get() { return *reinterpret_cast<volatile Type *>(address) ; } } ; 

 //    struct WriteMode {}; struct ReadMode {}; struct ReadWriteMode: public WriteMode, public ReadMode {}; 

 template <uint32_t size> struct RegisterType {} ; template<> struct RegisterType<8> { using Type = uint8_t ; } ; template<> struct RegisterType<16> { using Type = uint16_t ; } ; template<> struct RegisterType<32> { using Type = uint32_t ; } ; template<> struct RegisterType<64> { using Type = uint64_t ; } ; 

 struct TIM1 { struct CR1 : public RegisterBase<0x40010000, 32, ReadWriteMode> { } struct EGR : public RegisterBase<0x40010014, 32, WriteMode> { } } int main() { TIM1::CR1::Set(10) ; auto reg = TIM1::CR1::Get() ; // ,     reg = TIM1::EGR::Get() } 

खेतों

 //        template<typename Reg, size_t offset, size_t size, typename AccessMode> struct RegisterField { using RegType = typename Reg::Type ; using Register = Reg ; static constexpr RegType Offset = offset ; static constexpr RegType Size = size ; using Access = AccessMode ; template<typename T = AccessMode, class = typename std::enable_if_t<std::is_base_of<WriteMode, T>::value>> static void Set(RegType value) { assert(value < (1U << size)) ; //CriticalSection cs ; //    RegType newRegValue = *reinterpret_cast<RegType *>(Register::Address) ; //       newRegValue &= ~ (((1U << size) - 1U) << offset); //    newRegValue |= (value << offset) ; //      *reinterpret_cast<RegType *>(Reg::Address) = newRegValue ; } __forceinline template<typename T = AccessMode, class = typename std::enable_if_t<std::is_base_of<ReadMode, T>::value>> inline static RegType Get() { return ((*reinterpret_cast<RegType *>(Reg::Address)) & (((1U << size) - 1U) << offset)) >> offset ; } }; 

 struct TIM1 { struct CR1 : public RegisterBase<0x40010000, 32, ReadWriteMode> { using CKD = RegisterField<TIM1::CR1, 8, 2, ReadWriteMode> ; using ARPE = RegisterField<TIM1::CR1, 7, 1, ReadWriteMode> ; using CMS = RegisterField<TIM1::CR1, 5, 2, ReadWriteMode> ; using DIR = RegisterField<TIM1::CR1, 4, 1, ReadWriteMode> ; using OPM = RegisterField<TIM1::CR1, 3, 1, ReadWriteMode> ; using URS = RegisterField<TIM1::CR1, 2, 1, ReadWriteMode> ; using UDIS = RegisterField<TIM1::CR1, 1, 1, ReadWriteMode> ; using CEN = RegisterField<TIM1::CR1, 0, 1, ReadWriteMode> ; } } int main() { //   CR1  9   1,  8  0 TIM1::CR1::CKD::Set(2U) ; auto reg = TIM1::CR1::CEN::Get() ; } 

फ़ील्ड मान

 //        template<typename Field, typename Field::Register::Type value> struct FieldValueBase { using RegType = typename Field::Register::Type ; template<typename T = typename Field::Access, class = typename std::enable_if_t<std::is_base_of<WriteMode, T>::value>> static void Set() { RegType newRegValue = *reinterpret_cast<RegType *>(Field::Register::Address) ; newRegValue &= ~ (((1U << Field::Size) - 1U) << Field::Offset); newRegValue |= (value << Field::Offset) ; *reinterpret_cast<RegType *>(Field::Register::Address) = newRegValue ; } __forceinline template<typename T = typename Field::Access, class = typename std::enable_if_t<std::is_base_of<ReadMode, T>::value>> inline static bool IsSet() { return ((*reinterpret_cast<RegType *>(Field::Register::Address)) & static_cast<RegType>(((1U << Field::Size) - 1U) << Field::Offset)) == (value << Field::Offset) ; } }; 

 template <typename Reg, size_t offset, size_t size, typename AccessMode> struct TIM_CR_CKD_Values: public RegisterField<Reg, offset, size, AccessMode> { using DividedBy1 = FieldValue<TIM_CR_CKD_Values, 0U> ; using DividedBy2 = FieldValue<TIM_CR_CKD_Values, 1U> ; using DividedBy4 = FieldValue<TIM_CR_CKD_Values, 2U> ; using Reserved = FieldValue<TIM_CR_CKD_Values, 3U> ; } ; template <typename Reg, size_t offset, size_t size, typename AccessMode> struct TIM_CR_ARPE_Values: public RegisterField<Reg, offset, size, AccessMode> { using ARRNotBuffered = FieldValue<TIM_CR_ARPE_Values, 0U> ; using ARRBuffered = FieldValue<TIM_CR_ARPE_Values, 1U> ; } ; template <typename Reg, size_t offset, size_t size, typename AccessMode> struct TIM_CR_CMS_Values: public RegisterField<Reg, offset, size, AccessMode> { using CenterAlignedMode0 = FieldValue<TIM_CR_CMS_Values, 0U> ; using CenterAlignedMode1 = FieldValue<TIM_CR_CMS_Values, 1U> ; using CenterAlignedMode2 = FieldValue<TIM_CR_CMS_Values, 2U> ; using CenterAlignedMode3 = FieldValue<TIM_CR_CMS_Values, 3U> ; } ; template <typename Reg, size_t offset, size_t size, typename AccessMode> struct TIM_CR_DIR_Values: public RegisterField<Reg, offset, size, AccessMode> { using Upcounter = FieldValue<TIM_CR_DIR_Values, 0U> ; using Downcounter = FieldValue<TIM_CR_DIR_Values, 1U> ; } ; template <typename Reg, size_t offset, size_t size, typename AccessMode> struct TIM_CR_OPM_Values: public RegisterField<Reg, offset, size, AccessMode> { using ContinueAfterUEV = FieldValue<TIM_CR_OPM_Values, 0U> ; using StopAfterUEV = FieldValue<TIM_CR_OPM_Values, 1U> ; } ; template <typename Reg, size_t offset, size_t size, typename AccessMode> struct TIM_CR_URS_Values: public RegisterField<Reg, offset, size, AccessMode> { using Any = FieldValue<TIM_CR_URS_Values, 0U> ; using Overflow = FieldValue<TIM_CR_URS_Values, 1U> ; } ; template <typename Reg, size_t offset, size_t size, typename AccessMode> struct TIM_CR_UDIS_Values: public RegisterField<Reg, offset, size, AccessMode> { using Enable = FieldValue<TIM_CR_UDIS_Values, 0U> ; using Disable = FieldValue<TIM_CR_UDIS_Values, 1U> ; } ; template <typename Reg, size_t offset, size_t size, typename AccessMode> struct TIM_CR_CEN_Values: public RegisterField<Reg, offset, size, AccessMode> { using Disable = FieldValue<TIM_CR_CEN_Values, 0U> ; using Enable = FieldValue<TIM_CR_CEN_Values, 1U> ; } ; 

 struct TIM1 { struct CR1 : public RegisterBase<0x40010000, 32, ReadWriteMode> { using CKD = TIM_CR1_CKD_Values<TIM1::CR1, 8, 2, ReadWriteMode> ; using ARPE = TIM_CR1_ARPE_Values<TIM1::CR1, 7, 1, ReadWriteMode> ; using CMS = TIM_CR1_CMS_Values<TIM1::CR1, 5, 2, ReadWriteMode> ; using DIR = TIM_CR1_DIR_Values<TIM1::CR1, 4, 1, ReadWriteMode> ; using OPM = TIM_CR1_OPM_Values<TIM1::CR1, 3, 1, ReadWriteMode> ; using URS = TIM_CR1_URS_Values<TIM1::CR1, 2, 1, ReadWriteMode> ; using UDIS = TIM_CR1_UDIS_Values<TIM1::CR1, 1, 1, ReadWriteMode> ; using CEN = TIM_CR1_CEN_Values<TIM1::CR1, 0, 1, ReadWriteMode> ; } ; } 

 int main() { if (TIM1::CR1::CKD::DividedBy2::IsSet()) { TIM1::ARR::Set(100U) ; TIM1::CR1::CEN::Enable::Set() ; } } 

 int main() { if((TIM1->CR1 & TIM_CR1_CKD_Msk) == TIM_CR1_CKD_0) { TIM1->ARR = 100U ; regValue = TIM1->CR1 ; regValue &=~(TIM_CR1_CEN_Msk) ; regValue |= TIM_CR1_CEN ; TIM1->CR1 = regValue ; } } 

 int main() { uint32_t regValue = TIM1->CR1 ; regValue &=~(TIM_CR1_CKD_Msk | TIM_CR1_DIR) ; regValue |= (TIM_CR1_CEN | TIM_CR1_CKD_0 | TIM_CR1_CKD_0) ; TIM1->CR1 = regValue ; } 

 int main() { // 1,      Set() TIM1::CR1::Set(TIM1::CR1::DIR::Upcounter, TIM1::CR1::CKD::DividedBy4, TIM1::CR1::CEN::Enable) ; // 2,     TIM1::CR1<TIM1::CR1::DIR::Upcounter, TIM1::CR1::CKD::DividedBy4, TIM1::CR1::CEN::Enable>::Set() ; } 

 //    ,          template<uint32_t address, size_t size, typename AccessMode, typename ...Args> class Register { private: ... 

1. रजिस्टरों में वांछित बिट्स को रीसेट करने के लिए, मानों के पूरे सेट से एक मुखौटा बनाने के लिए।
2. मूल्यों के पूरे सेट से, वांछित बिट्स सेट करने के लिए एक मान उत्पन्न करें।

 //    ,          template<uint32_t address, size_t size, typename AccessMode, typename ...Args> class Register { private: // ,    //     . __forceinline template<typename T> static constexpr auto GetIndividualMask() { Type result = T::Mask << T::Offset ; return result ; } // ,    //       . static constexpr auto GetMask() { //       const auto values = {GetIndividualMask<Args>()...} ; Type result = 0UL; for (auto const v: values) { //       result |= v ; } return result ; } //    __forceinline template<typename T> static constexpr auto GetIndividualValue() { Type result = T::Value << T::Offset ; return result ; } static constexpr auto GetValue() { const auto values = {GetIndividualValue<Args>()...}; Type result = 0UL; for (const auto v: values) { result |= v ; } return result ; } }; 

 //    ,          template<uint32_t address, size_t size, typename AccessMode, typename ...Args> class Register { public: using Type = typename RegisterType<size>::Type; template<typename T = AccessMode, class = typename std::enable_if_t<std::is_base_of<WriteMode, T>::value>> static void Set() { Type newRegValue = *reinterpret_cast<Type *>(address) ; //GetMask()    ,     newRegValue &= ~GetMask() ; //GetValue()    ,     newRegValue |= GetValue() ; //     *reinterpret_cast<Type *>(address) = newRegValue ; } template<typename T = AccessMode, class = typename std::enable_if_t<std::is_base_of<ReadMode, T>::value>> static bool IsSet() { Type newRegValue = *reinterpret_cast<Type *>(address) ; return ((newRegValue & GetMask()) == GetValue()) ; } private: ... 

 int main() { // ,     TIM1::CR1 TIM1::CR1<TIM2::CR1::Enabled, TIM1::CR2::OIS1::OC1OutputIs0>::Set() ; } 

 template<uint32_t address, size_t size, typename AccessMode, typename FieldValueBaseType, typename ...Args> class Register { private: //     BaseType     FieldValueBaseType,    . __forceinline template<typename T, class = typename std::enable_if_t<std::is_same<FieldValueBaseType, typename T::BaseType>::value>> static constexpr auto GetIndividualMask() { Type result = T::Mask << T::Offset ; return result ; } static constexpr auto GetMask() { const auto values = {GetIndividualMask<Args>()...} ; Type result = 0UL; for (auto const v: values) { result |= v ; } return result ; } //     BaseType     FieldValueBaseType,    . __forceinline template<typename T, class = typename std::enable_if_t<std::is_same<FieldValueBaseType, typename T::BaseType>::value>> static constexpr auto GetIndividualValue() { Type result = T::Value << T::Offset ; return result ; } static constexpr auto GetValue() { const auto values = {GetIndividualValue<Args>()...}; Type result = 0UL; for (const auto v: values) { result |= v ; } return result ; } }; 

 struct TIM1 { struct TIM1CR1Base {} ; struct CR1 : public RegisterBase<0x40010000, 32, ReadWriteMode> { using CKD = TIM_CR_CKD_Values<TIM1::CR1, 8, 2, ReadWriteMode, TIM1CR1Base> ; using ARPE = TIM_CR_ARPE_Values<TIM1::CR1, 7, 1, ReadWriteMode, TIM1CR1Base> ; using CMS = TIM_CR_CMS_Values<TIM1::CR1, 5, 2, ReadWriteMode, TIM1CR1Base> ; using DIR = TIM_CR_DIR_Values<TIM1::CR1, 4, 1, ReadWriteMode, TIM1CR1Base> ; using OPM = TIM_CR_OPM_Values<TIM1::CR1, 3, 1, ReadWriteMode, TIM1CR1Base> ; using URS = TIM_CR_URS_Values<TIM1::CR1, 2, 1, ReadWriteMode, TIM1CR1Base> ; using UDIS = TIM_CR_UDIS_Values<TIM1::CR1, 1, 1, ReadWriteMode, TIM1CR1Base> ; using CEN = TIM_CR_CEN_Values<TIM1::CR1, 0, 1, ReadWriteMode, TIM1CR1Base> ; } ; } 

 int main(void) { //     GPIOA //,    AHB1ENR RCC->APB1ENR |= RCC_AHB1ENR_GPIOAEN ; //    ,      RCC->AHB1ENR = RCC_AHB1ENR_GPIOAEN; //,  TIM1    APB2 RCC->APB1ENR |= RCC_APB1ENR_TIM2EN | RCC_APB2ENR_TIM1EN; // - ,        . auto result = GPIOA->BSRR ; if (result & GPIO_BSRR_BS1) { //do something } //-     .   ... GPIOA->IDR = GPIO_IDR_ID5 ; 

 int main(void) { //     GPIOA // ,   APB1ENR   GPIOAEN RCC::APB1ENR::GPIOAEN::Enable::Set() ; // ,     GPIOA RCC::AHB1ENR::GPIOAEN::Enable::Set() ; // , RCC::APB2ENR::TIM1EN::Enable  //   APB1ENR RCC::APB1ENRPack<RCC::APB1ENR::TIM2EN::Enable, RCC::APB2ENR::TIM1EN::Enable>::Set(); // ,  BSRR    auto result = GPIOA::BSRR::Get() ; // ,  Reset    if (GPIOA::BSRR::BS1::Reset::IsSet()) { //do something } // ,       GPIOA::IDR::IDR5::On::Set() } 

गति

 int main() { uint32_t res = RCC->AHB2ENR; res &=~ RCC_AHB1ENR_GPIOAEN_Msk ; res |= RCC_AHB1ENR_GPIOAEN ; RCC->AHB2ENR = res ; res = GPIOA->MODER ; res &=~ (GPIO_MODER_MODER5 | GPIO_MODER_MODER4 | GPIO_MODER_MODER1) ; res |= (GPIO_MODER_MODER5_0 | GPIO_MODER_MODER4_0 | GPIO_MODER_MODER1_0) ; GPIOA->MODER = res ; GPIOA->BSRR = (GPIO_BSRR_BS5 | GPIO_BSRR_BS4 | GPIO_BSRR_BS1) ; return 0 ; } 

 int main() { RCC::AHB1ENR::GPIOAEN::Enable::Set() ; GPIOA::MODERPack< GPIOA::MODER::MODER5::Output, GPIOA::MODER::MODER4::Output, GPIOA::MODER::MODER1::Output>::Set() ; GPIOA::BSRRPack< GPIOA::BSRR::BS5::Set, GPIOA::BSRR::BS4::Set, GPIOA::BSRR::BS1::Set>::Write() ; return 0 ; } 

परिणाम

 #include "gpioaregisters.hpp" //for GPIOA #include "rccregisters.hpp" //for RCC int main() { RCC::AHB1ENR::GPIOAEN::Enable::Set() ; GPIOA::MODER::MODER15::Output::Set() ; GPIOA::MODERPack< GPIOA::MODER::MODER12::Output, GPIOA::MODER::MODER14::Analog >::Set() ; } 

 template <typename Reg, size_t offset, size_t size, typename AccessMode, typename BaseType> struct GPIOA_MODER_MODER_Values: public RegisterField<Reg, offset, size, AccessMode> { using Value0 = FieldValue<GPIOA_MODER_MODER_Values, BaseType, 0U> ; using Value1 = FieldValue<GPIOA_MODER_MODER_Values, BaseType, 1U> ; using Value2 = FieldValue<GPIOA_MODER_MODER_Values, BaseType, 2U> ; using Value3 = FieldValue<GPIOA_MODER_MODER_Values, BaseType, 3U> ; } ; 

 template <typename Reg, size_t offset, size_t size, typename AccessMode, typename BaseType> struct GPIOA_MODER_MODER_Values: public RegisterField<Reg, offset, size, AccessMode> { using Input = FieldValue<GPIOA_MODER_MODER_Values, BaseType, 0U> ; using Output = FieldValue<GPIOA_MODER_MODER_Values, BaseType, 1U> ; using Alternate = FieldValue<GPIOA_MODER_MODER_Values, BaseType, 2U> ; using Analog = FieldValue<GPIOA_MODER_MODER_Values, BaseType, 3U> ; } ;