SHARE
TWEET

Untitled

a guest Jul 16th, 2019 57 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #ifndef __STM32F407xx_H_
  2. #define __STM32F407xx_H_
  3.  
  4. #include <stdint.h>
  5.  
  6. template <std::uint32_t... bitmask>
  7. inline constexpr std::uint32_t SetBits()
  8. {
  9.     return (bitmask | ...);
  10. }
  11.  
  12. #define __CM4_REV                     0x0001U
  13. #define __MPU_PRESENT                 1U
  14. #define __NVIC_PRIO_BITS              4U
  15. #define __Vendor_SysTickConfig        0U
  16. #define __FPU_PRESENT                 1U
  17.  
  18. namespace STM32_REGS
  19. {
  20.     enum class IRQn: std::int32_t
  21.     {
  22.         NonMaskableInt                 = -14,
  23.         MemoryManagement               = -12,
  24.         BusFault                       = -11,
  25.         UsageFault                     = -10,
  26.         SVCall                         = -5,
  27.         DebugMonitor                   = -4,
  28.         PendSV                         = -2,
  29.         SysTick                        = -1,
  30.         WWDG                           = 0,
  31.         PVD                            = 1,
  32.         TAMP_STAMP                     = 2,
  33.         RTC_WKUP                       = 3,
  34.         FLASH                          = 4,
  35.         RCC                            = 5,
  36.         EXTI0                          = 6,
  37.         EXTI1                          = 7,
  38.         EXTI2                          = 8,
  39.         EXTI3                          = 9,
  40.         EXTI4                          = 10,
  41.         DMA1_Stream0                   = 11,
  42.         DMA1_Stream1                   = 12,
  43.         DMA1_Stream2                   = 13,
  44.         DMA1_Stream3                   = 14,
  45.         DMA1_Stream4                   = 15,
  46.         DMA1_Stream5                   = 16,
  47.         DMA1_Stream6                   = 17,
  48.         ADC                            = 18,
  49.         CAN1_TX                        = 19,
  50.         CAN1_RX0                       = 20,
  51.         CAN1_RX1                       = 21,
  52.         CAN1_SCE                       = 22,
  53.         EXTI9_5                        = 23,
  54.         TIM1_BRK_TIM9                  = 24,
  55.         TIM1_UP_TIM10                  = 25,
  56.         TIM1_TRG_COM_TIM11             = 26,
  57.         TIM1_CC                        = 27,
  58.         TIM2                           = 28,
  59.         TIM3                           = 29,
  60.         TIM4                           = 30,
  61.         I2C1_EV                        = 31,
  62.         I2C1_ER                        = 32,
  63.         I2C2_EV                        = 33,
  64.         I2C2_ER                        = 34,
  65.         SPI1                           = 35,
  66.         SPI2                           = 36,
  67.         USART1                         = 37,
  68.         USART2                         = 38,
  69.         USART3                         = 39,
  70.         EXTI15_10                      = 40,
  71.         RTC_Alarm                      = 41,
  72.         OTG_FS_WKUP                    = 42,
  73.         TIM8_BRK_TIM12                 = 43,
  74.         TIM8_UP_TIM13                  = 44,
  75.         TIM8_TRG_COM_TIM14             = 45,
  76.         TIM8_CC                        = 46,
  77.         DMA1_Stream7                   = 47,
  78.         FSMC                           = 48,
  79.         SDIO                           = 49,
  80.         TIM5                           = 50,
  81.         SPI3                           = 51,
  82.         UART4                          = 52,
  83.         UART5                          = 53,
  84.         TIM6_DAC                       = 54,
  85.         TIM7                           = 55,
  86.         DMA2_Stream0                   = 56,
  87.         DMA2_Stream1                   = 57,
  88.         DMA2_Stream2                   = 58,
  89.         DMA2_Stream3                   = 59,
  90.         DMA2_Stream4                   = 60,
  91.         ETH                            = 61,
  92.         ETH_WKUP                       = 62,
  93.         CAN2_TX                        = 63,
  94.         CAN2_RX0                       = 64,
  95.         CAN2_RX1                       = 65,
  96.         CAN2_SCE                       = 66,
  97.         OTG_FS                         = 67,
  98.         DMA2_Stream5                   = 68,
  99.         DMA2_Stream6                   = 69,
  100.         DMA2_Stream7                   = 70,
  101.         USART6                         = 71,
  102.         I2C3_EV                        = 72,
  103.         I2C3_ER                        = 73,
  104.         OTG_HS_EP1_OUT                 = 74,
  105.         OTG_HS_EP1_IN                  = 75,
  106.         OTG_HS_WKUP                    = 76,
  107.         OTG_HS                         = 77,
  108.         DCMI                           = 78,
  109.         RNG                            = 80,
  110.         FPU                            = 81,
  111.     };
  112. }
  113.  
  114. //namespace ARM = STM32;
  115.  
  116. #ifdef __cplusplus
  117.   #define   __I     volatile             /*!< Defines 'read only' permissions */
  118. #else
  119.   #define   __I     volatile const       /*!< Defines 'read only' permissions */
  120. #endif
  121. #define     __O     volatile             /*!< Defines 'write only' permissions */
  122. #define     __IO    volatile             /*!< Defines 'read / write' permissions */
  123.  
  124. /* following defines should be used for structure members */
  125. #define     __IM     volatile const      /*! Defines 'read only' structure member permissions */
  126. #define     __OM     volatile            /*! Defines 'write only' structure member permissions */
  127. #define     __IOM    volatile            /*! Defines 'read / write' structure member permissions */
  128.  
  129. //#include "core_cm4.hpp"
  130. //#include "system_stm32f4xx.hpp"
  131. //#include "stdint.hpp"
  132.  
  133. //namespace CORTEX = CM4;
  134.  
  135. namespace STM32
  136. {
  137.     static constexpr std::uint32_t FLASH_BASE                     = 0x08000000U;
  138.     static constexpr std::uint32_t CCMDATARAM_BASE                = 0x10000000U;
  139.     static constexpr std::uint32_t SRAM1_BASE                     = 0x20000000U;
  140.     static constexpr std::uint32_t SRAM2_BASE                     = 0x2001C000U;
  141.     static constexpr std::uint32_t PERIPH_BASE                    = 0x40000000U;
  142.     static constexpr std::uint32_t BKPSRAM_BASE                   = 0x40024000U;
  143.     static constexpr std::uint32_t FSMC_R_BASE                    = 0xA0000000U;
  144.     static constexpr std::uint32_t SRAM1_BB_BASE                  = 0x22000000U;
  145.     static constexpr std::uint32_t SRAM2_BB_BASE                  = 0x22380000U;
  146.     static constexpr std::uint32_t PERIPH_BB_BASE                 = 0x42000000U;
  147.     static constexpr std::uint32_t BKPSRAM_BB_BASE                = 0x42480000U;
  148.     static constexpr std::uint32_t FLASH_END                      = 0x080FFFFFU;
  149.     static constexpr std::uint32_t FLASH_OTP_BASE                 = 0x1FFF7800U;
  150.     static constexpr std::uint32_t FLASH_OTP_END                  = 0x1FFF7A0FU;
  151.     static constexpr std::uint32_t CCMDATARAM_END                 = 0x1000FFFFU;
  152.     static constexpr std::uint32_t SRAM_BASE                      = SRAM1_BASE;
  153.     static constexpr std::uint32_t SRAM_BB_BASE                   = SRAM1_BB_BASE;
  154.     static constexpr std::uint32_t APB1PERIPH_BASE                = PERIPH_BASE;
  155.     static constexpr std::uint32_t APB2PERIPH_BASE                = (PERIPH_BASE + 0x00010000U);
  156.     static constexpr std::uint32_t AHB1PERIPH_BASE                = (PERIPH_BASE + 0x00020000U);
  157.     static constexpr std::uint32_t AHB2PERIPH_BASE                = (PERIPH_BASE + 0x10000000U);
  158.     static constexpr std::uint32_t TIM2_BASE                      = (APB1PERIPH_BASE + 0x0000U);
  159.     static constexpr std::uint32_t TIM3_BASE                      = (APB1PERIPH_BASE + 0x0400U);
  160.     static constexpr std::uint32_t TIM4_BASE                      = (APB1PERIPH_BASE + 0x0800U);
  161.     static constexpr std::uint32_t TIM5_BASE                      = (APB1PERIPH_BASE + 0x0C00U);
  162.     static constexpr std::uint32_t TIM6_BASE                      = (APB1PERIPH_BASE + 0x1000U);
  163.     static constexpr std::uint32_t TIM7_BASE                      = (APB1PERIPH_BASE + 0x1400U);
  164.     static constexpr std::uint32_t TIM12_BASE                     = (APB1PERIPH_BASE + 0x1800U);
  165.     static constexpr std::uint32_t TIM13_BASE                     = (APB1PERIPH_BASE + 0x1C00U);
  166.     static constexpr std::uint32_t TIM14_BASE                     = (APB1PERIPH_BASE + 0x2000U);
  167.     static constexpr std::uint32_t RTC_BASE                       = (APB1PERIPH_BASE + 0x2800U);
  168.     static constexpr std::uint32_t WWDG_BASE                      = (APB1PERIPH_BASE + 0x2C00U);
  169.     static constexpr std::uint32_t IWDG_BASE                      = (APB1PERIPH_BASE + 0x3000U);
  170.     static constexpr std::uint32_t I2S2ext_BASE                   = (APB1PERIPH_BASE + 0x3400U);
  171.     static constexpr std::uint32_t SPI2_BASE                      = (APB1PERIPH_BASE + 0x3800U);
  172.     static constexpr std::uint32_t SPI3_BASE                      = (APB1PERIPH_BASE + 0x3C00U);
  173.     static constexpr std::uint32_t I2S3ext_BASE                   = (APB1PERIPH_BASE + 0x4000U);
  174.     static constexpr std::uint32_t USART2_BASE                    = (APB1PERIPH_BASE + 0x4400U);
  175.     static constexpr std::uint32_t USART3_BASE                    = (APB1PERIPH_BASE + 0x4800U);
  176.     static constexpr std::uint32_t UART4_BASE                     = (APB1PERIPH_BASE + 0x4C00U);
  177.     static constexpr std::uint32_t UART5_BASE                     = (APB1PERIPH_BASE + 0x5000U);
  178.     static constexpr std::uint32_t I2C1_BASE                      = (APB1PERIPH_BASE + 0x5400U);
  179.     static constexpr std::uint32_t I2C2_BASE                      = (APB1PERIPH_BASE + 0x5800U);
  180.     static constexpr std::uint32_t I2C3_BASE                      = (APB1PERIPH_BASE + 0x5C00U);
  181.     static constexpr std::uint32_t CAN1_BASE                      = (APB1PERIPH_BASE + 0x6400U);
  182.     static constexpr std::uint32_t CAN2_BASE                      = (APB1PERIPH_BASE + 0x6800U);
  183.     static constexpr std::uint32_t PWR_BASE                       = (APB1PERIPH_BASE + 0x7000U);
  184.     static constexpr std::uint32_t DAC_BASE                       = (APB1PERIPH_BASE + 0x7400U);
  185.     static constexpr std::uint32_t TIM1_BASE                      = (APB2PERIPH_BASE + 0x0000U);
  186.     static constexpr std::uint32_t TIM8_BASE                      = (APB2PERIPH_BASE + 0x0400U);
  187.     static constexpr std::uint32_t USART1_BASE                    = (APB2PERIPH_BASE + 0x1000U);
  188.     static constexpr std::uint32_t USART6_BASE                    = (APB2PERIPH_BASE + 0x1400U);
  189.     static constexpr std::uint32_t ADC1_BASE                      = (APB2PERIPH_BASE + 0x2000U);
  190.     static constexpr std::uint32_t ADC2_BASE                      = (APB2PERIPH_BASE + 0x2100U);
  191.     static constexpr std::uint32_t ADC3_BASE                      = (APB2PERIPH_BASE + 0x2200U);
  192.     static constexpr std::uint32_t ADC123_COMMON_BASE             = (APB2PERIPH_BASE + 0x2300U);
  193.     static constexpr std::uint32_t ADC_BASE                       = ADC123_COMMON_BASE;
  194.     static constexpr std::uint32_t SDIO_BASE                      = (APB2PERIPH_BASE + 0x2C00U);
  195.     static constexpr std::uint32_t SPI1_BASE                      = (APB2PERIPH_BASE + 0x3000U);
  196.     static constexpr std::uint32_t SYSCFG_BASE                    = (APB2PERIPH_BASE + 0x3800U);
  197.     static constexpr std::uint32_t EXTI_BASE                      = (APB2PERIPH_BASE + 0x3C00U);
  198.     static constexpr std::uint32_t TIM9_BASE                      = (APB2PERIPH_BASE + 0x4000U);
  199.     static constexpr std::uint32_t TIM10_BASE                     = (APB2PERIPH_BASE + 0x4400U);
  200.     static constexpr std::uint32_t TIM11_BASE                     = (APB2PERIPH_BASE + 0x4800U);
  201.     static constexpr std::uint32_t GPIOA_BASE                     = (AHB1PERIPH_BASE + 0x0000U);
  202.     static constexpr std::uint32_t GPIOB_BASE                     = (AHB1PERIPH_BASE + 0x0400U);
  203.     static constexpr std::uint32_t GPIOC_BASE                     = (AHB1PERIPH_BASE + 0x0800U);
  204.     static constexpr std::uint32_t GPIOD_BASE                     = (AHB1PERIPH_BASE + 0x0C00U);
  205.     static constexpr std::uint32_t GPIOE_BASE                     = (AHB1PERIPH_BASE + 0x1000U);
  206.     static constexpr std::uint32_t GPIOF_BASE                     = (AHB1PERIPH_BASE + 0x1400U);
  207.     static constexpr std::uint32_t GPIOG_BASE                     = (AHB1PERIPH_BASE + 0x1800U);
  208.     static constexpr std::uint32_t GPIOH_BASE                     = (AHB1PERIPH_BASE + 0x1C00U);
  209.     static constexpr std::uint32_t GPIOI_BASE                     = (AHB1PERIPH_BASE + 0x2000U);
  210.     static constexpr std::uint32_t CRC_BASE                       = (AHB1PERIPH_BASE + 0x3000U);
  211.     static constexpr std::uint32_t RCC_BASE                       = (AHB1PERIPH_BASE + 0x3800U);
  212.     static constexpr std::uint32_t FLASH_R_BASE                   = (AHB1PERIPH_BASE + 0x3C00U);
  213.     static constexpr std::uint32_t DMA1_BASE                      = (AHB1PERIPH_BASE + 0x6000U);
  214.     static constexpr std::uint32_t DMA1_Stream0_BASE              = (DMA1_BASE + 0x010U);
  215.     static constexpr std::uint32_t DMA1_Stream1_BASE              = (DMA1_BASE + 0x028U);
  216.     static constexpr std::uint32_t DMA1_Stream2_BASE              = (DMA1_BASE + 0x040U);
  217.     static constexpr std::uint32_t DMA1_Stream3_BASE              = (DMA1_BASE + 0x058U);
  218.     static constexpr std::uint32_t DMA1_Stream4_BASE              = (DMA1_BASE + 0x070U);
  219.     static constexpr std::uint32_t DMA1_Stream5_BASE              = (DMA1_BASE + 0x088U);
  220.     static constexpr std::uint32_t DMA1_Stream6_BASE              = (DMA1_BASE + 0x0A0U);
  221.     static constexpr std::uint32_t DMA1_Stream7_BASE              = (DMA1_BASE + 0x0B8U);
  222.     static constexpr std::uint32_t DMA2_BASE                      = (AHB1PERIPH_BASE + 0x6400U);
  223.     static constexpr std::uint32_t DMA2_Stream0_BASE              = (DMA2_BASE + 0x010U);
  224.     static constexpr std::uint32_t DMA2_Stream1_BASE              = (DMA2_BASE + 0x028U);
  225.     static constexpr std::uint32_t DMA2_Stream2_BASE              = (DMA2_BASE + 0x040U);
  226.     static constexpr std::uint32_t DMA2_Stream3_BASE              = (DMA2_BASE + 0x058U);
  227.     static constexpr std::uint32_t DMA2_Stream4_BASE              = (DMA2_BASE + 0x070U);
  228.     static constexpr std::uint32_t DMA2_Stream5_BASE              = (DMA2_BASE + 0x088U);
  229.     static constexpr std::uint32_t DMA2_Stream6_BASE              = (DMA2_BASE + 0x0A0U);
  230.     static constexpr std::uint32_t DMA2_Stream7_BASE              = (DMA2_BASE + 0x0B8U);
  231.     static constexpr std::uint32_t ETH_BASE                       = (AHB1PERIPH_BASE + 0x8000U);
  232.     static constexpr std::uint32_t ETH_MAC_BASE                   = (ETH_BASE);
  233.     static constexpr std::uint32_t ETH_MMC_BASE                   = (ETH_BASE + 0x0100U);
  234.     static constexpr std::uint32_t ETH_PTP_BASE                   = (ETH_BASE + 0x0700U);
  235.     static constexpr std::uint32_t ETH_DMA_BASE                   = (ETH_BASE + 0x1000U);
  236.     static constexpr std::uint32_t DCMI_BASE                      = (AHB2PERIPH_BASE + 0x50000U);
  237.     static constexpr std::uint32_t RNG_BASE                       = (AHB2PERIPH_BASE + 0x60800U);
  238.     static constexpr std::uint32_t FSMC_Bank1_R_BASE              = (FSMC_R_BASE + 0x0000U);
  239.     static constexpr std::uint32_t FSMC_Bank1E_R_BASE             = (FSMC_R_BASE + 0x0104U);
  240.     static constexpr std::uint32_t FSMC_Bank2_3_R_BASE            = (FSMC_R_BASE + 0x0060U);
  241.     static constexpr std::uint32_t FSMC_Bank4_R_BASE              = (FSMC_R_BASE + 0x00A0U);
  242.     static constexpr std::uint32_t DBGMCU_BASE                    = 0xE0042000U;
  243.     static constexpr std::uint32_t USB_OTG_HS_PERIPH_BASE         = 0x40040000U;
  244.     static constexpr std::uint32_t USB_OTG_FS_PERIPH_BASE         = 0x50000000U;
  245.     static constexpr std::uint32_t USB_OTG_GLOBAL_BASE            = 0x000U;
  246.     static constexpr std::uint32_t USB_OTG_DEVICE_BASE            = 0x800U;
  247.     static constexpr std::uint32_t USB_OTG_IN_ENDPOINT_BASE       = 0x900U;
  248.     static constexpr std::uint32_t USB_OTG_OUT_ENDPOINT_BASE      = 0xB00U;
  249.     static constexpr std::uint32_t USB_OTG_EP_REG_SIZE            = 0x20U;
  250.     static constexpr std::uint32_t USB_OTG_HOST_BASE              = 0x400U;
  251.     static constexpr std::uint32_t USB_OTG_HOST_PORT_BASE         = 0x440U;
  252.     static constexpr std::uint32_t USB_OTG_HOST_CHANNEL_BASE      = 0x500U;
  253.     static constexpr std::uint32_t USB_OTG_HOST_CHANNEL_SIZE      = 0x20U;
  254.     static constexpr std::uint32_t USB_OTG_PCGCCTL_BASE           = 0xE00U;
  255.     static constexpr std::uint32_t USB_OTG_FIFO_BASE              = 0x1000U;
  256.     static constexpr std::uint32_t USB_OTG_FIFO_SIZE              = 0x1000U;
  257.     static constexpr std::uint32_t UID_BASE                       = 0x1FFF7A10U;
  258.     static constexpr std::uint32_t FLASHSIZE_BASE                 = 0x1FFF7A22U;
  259.     static constexpr std::uint32_t PACKAGE_BASE                   = 0x1FFF7BF0U;
  260. }
  261.  
  262. namespace STM32_REGS
  263. {
  264.     #define DAC_CHANNEL2_SUPPORT
  265.     #define RCC_PLLI2S_SUPPORT
  266.     #define RCC_AHB2_SUPPORT
  267.     #define RCC_AHB3_SUPPORT
  268.     #define RTC_TAMPER2_SUPPORT
  269.     #define RTC_AF2_SUPPORT
  270.     #define SPI_I2S_FULLDUPLEX_SUPPORT
  271.  
  272.     /* ADC DEFINITION */
  273.     class ADC
  274.     {
  275.     private:
  276.         struct ADC_t
  277.         {
  278.             __IO uint32_t                 SR;
  279.             __IO uint32_t                 CR1;
  280.             __IO uint32_t                 CR2;
  281.             __IO uint32_t                 SMPR1;
  282.             __IO uint32_t                 SMPR2;
  283.             __IO uint32_t                 JOFR1;
  284.             __IO uint32_t                 JOFR2;
  285.             __IO uint32_t                 JOFR3;
  286.             __IO uint32_t                 JOFR4;
  287.             __IO uint32_t                 HTR;
  288.             __IO uint32_t                 LTR;
  289.             __IO uint32_t                 SQR1;
  290.             __IO uint32_t                 SQR2;
  291.             __IO uint32_t                 SQR3;
  292.             __IO uint32_t                 JSQR;
  293.             __IO uint32_t                 JDR1;
  294.             __IO uint32_t                 JDR2;
  295.             __IO uint32_t                 JDR3;
  296.             __IO uint32_t                 JDR4;
  297.             __IO uint32_t                 DR;
  298.         };
  299.     public:
  300.         class SR
  301.         {
  302.         private:
  303.             union SR_t
  304.             {
  305.                 struct
  306.                 {
  307.                     uint32_t AWD            : 1;
  308.                     uint32_t EOC            : 1;
  309.                     uint32_t JEOC           : 1;
  310.                     uint32_t JSTRT          : 1;
  311.                     uint32_t STRT           : 1;
  312.                     uint32_t OVR            : 1;
  313.                     uint32_t reserved6      : 26;
  314.                 };
  315.                 uint32_t RAW;
  316.             };
  317.         public:
  318.             enum class EMasks: uint32_t
  319.             {
  320.                 AWD                    = (0x1U << 0),
  321.                 EOC                    = (0x1U << 1),
  322.                 JEOC                   = (0x1U << 2),
  323.                 JSTRT                  = (0x1U << 3),
  324.                 STRT                   = (0x1U << 4),
  325.                 OVR                    = (0x1U << 5),
  326.             };
  327.             static inline uint32_t get() { return reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SR; }
  328.             static inline void set(uint32_t value) { reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SR = value; }
  329.             template <EMasks ... flags>
  330.             static inline void set_flags()
  331.             {
  332.                 reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SR |= SetBits<(std::uint32_t)flags...>();
  333.             }
  334.             template <EMasks ... flags>
  335.             static inline void clear_flags()
  336.             {
  337.                 reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SR &= ~(SetBits<(std::uint32_t)flags...>());
  338.             }
  339.             template <EMasks ... flags>
  340.             static inline bool get_flags()
  341.             {
  342.                 return ((reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SR & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  343.             }
  344.         };
  345.         class CR1
  346.         {
  347.         private:
  348.             union CR1_t
  349.             {
  350.                 struct
  351.                 {
  352.                     uint32_t AWDCH          : 5;
  353.                     uint32_t EOCIE          : 1;
  354.                     uint32_t AWDIE          : 1;
  355.                     uint32_t JEOCIE         : 1;
  356.                     uint32_t SCAN           : 1;
  357.                     uint32_t AWDSGL         : 1;
  358.                     uint32_t JAUTO          : 1;
  359.                     uint32_t DISCEN         : 1;
  360.                     uint32_t JDISCEN        : 1;
  361.                     uint32_t DISCNUM        : 3;
  362.                     uint32_t reserved16     : 1;
  363.                     uint32_t reserved17     : 1;
  364.                     uint32_t reserved18     : 1;
  365.                     uint32_t reserved19     : 1;
  366.                     uint32_t reserved20     : 1;
  367.                     uint32_t reserved21     : 1;
  368.                     uint32_t JAWDEN         : 1;
  369.                     uint32_t AWDEN          : 1;
  370.                     uint32_t RES            : 2;
  371.                     uint32_t OVRIE          : 1;
  372.                     uint32_t reserved27     : 5;
  373.                 };
  374.                 uint32_t RAW;
  375.             };
  376.         public:
  377.             enum class EMasks: uint32_t
  378.             {
  379.                 AWDCH                  = (0x1FU << 0),
  380.                 EOCIE                  = (0x1U << 5),
  381.                 AWDIE                  = (0x1U << 6),
  382.                 JEOCIE                 = (0x1U << 7),
  383.                 SCAN                   = (0x1U << 8),
  384.                 AWDSGL                 = (0x1U << 9),
  385.                 JAUTO                  = (0x1U << 10),
  386.                 DISCEN                 = (0x1U << 11),
  387.                 JDISCEN                = (0x1U << 12),
  388.                 DISCNUM                = (0x7U << 13),
  389.                 JAWDEN                 = (0x1U << 22),
  390.                 AWDEN                  = (0x1U << 23),
  391.                 RES                    = (0x3U << 24),
  392.                 OVRIE                  = (0x1U << 26),
  393.             };
  394.             static inline uint32_t get() { return reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR1; }
  395.             static inline void set(uint32_t value) { reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR1 = value; }
  396.             template <EMasks ... flags>
  397.             static inline void set_flags()
  398.             {
  399.                 reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR1 |= SetBits<(std::uint32_t)flags...>();
  400.             }
  401.             template <EMasks ... flags>
  402.             static inline void clear_flags()
  403.             {
  404.                 reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR1 &= ~(SetBits<(std::uint32_t)flags...>());
  405.             }
  406.             template <EMasks ... flags>
  407.             static inline bool get_flags()
  408.             {
  409.                 return ((reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR1 & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  410.             }
  411.             static inline uint32_t get_AWDCH() { return reinterpret_cast<__IO CR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR1)->AWDCH; }
  412.             static inline void set_AWDCH(uint32_t value) { reinterpret_cast<__IO CR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR1)->AWDCH = value; }
  413.             static inline uint32_t get_DISCNUM() { return reinterpret_cast<__IO CR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR1)->DISCNUM; }
  414.             static inline void set_DISCNUM(uint32_t value) { reinterpret_cast<__IO CR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR1)->DISCNUM = value; }
  415.             static inline uint32_t get_RES() { return reinterpret_cast<__IO CR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR1)->RES; }
  416.             static inline void set_RES(uint32_t value) { reinterpret_cast<__IO CR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR1)->RES = value; }
  417.         };
  418.         class CR2
  419.         {
  420.         private:
  421.             union CR2_t
  422.             {
  423.                 struct
  424.                 {
  425.                     uint32_t ADON           : 1;
  426.                     uint32_t CONT           : 1;
  427.                     uint32_t reserved2      : 1;
  428.                     uint32_t reserved3      : 1;
  429.                     uint32_t reserved4      : 1;
  430.                     uint32_t reserved5      : 1;
  431.                     uint32_t reserved6      : 1;
  432.                     uint32_t reserved7      : 1;
  433.                     uint32_t DMA            : 1;
  434.                     uint32_t DDS            : 1;
  435.                     uint32_t EOCS           : 1;
  436.                     uint32_t ALIGN          : 1;
  437.                     uint32_t reserved12     : 1;
  438.                     uint32_t reserved13     : 1;
  439.                     uint32_t reserved14     : 1;
  440.                     uint32_t reserved15     : 1;
  441.                     uint32_t JEXTSEL        : 4;
  442.                     uint32_t JEXTEN         : 2;
  443.                     uint32_t JSWSTART       : 1;
  444.                     uint32_t reserved23     : 1;
  445.                     uint32_t EXTSEL         : 4;
  446.                     uint32_t EXTEN          : 2;
  447.                     uint32_t SWSTART        : 1;
  448.                     uint32_t reserved31     : 1;
  449.                 };
  450.                 uint32_t RAW;
  451.             };
  452.         public:
  453.             enum class EMasks: uint32_t
  454.             {
  455.                 ADON                   = (0x1U << 0),
  456.                 CONT                   = (0x1U << 1),
  457.                 DMA                    = (0x1U << 8),
  458.                 DDS                    = (0x1U << 9),
  459.                 EOCS                   = (0x1U << 10),
  460.                 ALIGN                  = (0x1U << 11),
  461.                 JEXTSEL                = (0xFU << 16),
  462.                 JEXTEN                 = (0x3U << 20),
  463.                 JSWSTART               = (0x1U << 22),
  464.                 EXTSEL                 = (0xFU << 24),
  465.                 EXTEN                  = (0x3U << 28),
  466.                 SWSTART                = (0x1U << 30),
  467.             };
  468.             static inline uint32_t get() { return reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR2; }
  469.             static inline void set(uint32_t value) { reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR2 = value; }
  470.             template <EMasks ... flags>
  471.             static inline void set_flags()
  472.             {
  473.                 reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR2 |= SetBits<(std::uint32_t)flags...>();
  474.             }
  475.             template <EMasks ... flags>
  476.             static inline void clear_flags()
  477.             {
  478.                 reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR2 &= ~(SetBits<(std::uint32_t)flags...>());
  479.             }
  480.             template <EMasks ... flags>
  481.             static inline bool get_flags()
  482.             {
  483.                 return ((reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR2 & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  484.             }
  485.             static inline uint32_t get_JEXTSEL() { return reinterpret_cast<__IO CR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR2)->JEXTSEL; }
  486.             static inline void set_JEXTSEL(uint32_t value) { reinterpret_cast<__IO CR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR2)->JEXTSEL = value; }
  487.             static inline uint32_t get_JEXTEN() { return reinterpret_cast<__IO CR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR2)->JEXTEN; }
  488.             static inline void set_JEXTEN(uint32_t value) { reinterpret_cast<__IO CR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR2)->JEXTEN = value; }
  489.             static inline uint32_t get_EXTSEL() { return reinterpret_cast<__IO CR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR2)->EXTSEL; }
  490.             static inline void set_EXTSEL(uint32_t value) { reinterpret_cast<__IO CR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR2)->EXTSEL = value; }
  491.             static inline uint32_t get_EXTEN() { return reinterpret_cast<__IO CR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR2)->EXTEN; }
  492.             static inline void set_EXTEN(uint32_t value) { reinterpret_cast<__IO CR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->CR2)->EXTEN = value; }
  493.         };
  494.         class SMPR1
  495.         {
  496.         private:
  497.             union SMPR1_t
  498.             {
  499.                 struct
  500.                 {
  501.                     uint32_t SMP10          : 3;
  502.                     uint32_t SMP11          : 3;
  503.                     uint32_t SMP12          : 3;
  504.                     uint32_t SMP13          : 3;
  505.                     uint32_t SMP14          : 3;
  506.                     uint32_t SMP15          : 3;
  507.                     uint32_t SMP16          : 3;
  508.                     uint32_t SMP17          : 3;
  509.                     uint32_t SMP18          : 3;
  510.                     uint32_t reserved27     : 5;
  511.                 };
  512.                 uint32_t RAW;
  513.             };
  514.         public:
  515.             enum class EMasks: uint32_t
  516.             {
  517.                 SMP10                  = (0x7U << 0),
  518.                 SMP11                  = (0x7U << 3),
  519.                 SMP12                  = (0x7U << 6),
  520.                 SMP13                  = (0x7U << 9),
  521.                 SMP14                  = (0x7U << 12),
  522.                 SMP15                  = (0x7U << 15),
  523.                 SMP16                  = (0x7U << 18),
  524.                 SMP17                  = (0x7U << 21),
  525.                 SMP18                  = (0x7U << 24),
  526.             };
  527.             static inline uint32_t get() { return reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR1; }
  528.             static inline void set(uint32_t value) { reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR1 = value; }
  529.             static inline uint32_t get_SMP10() { return reinterpret_cast<__IO SMPR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR1)->SMP10; }
  530.             static inline void set_SMP10(uint32_t value) { reinterpret_cast<__IO SMPR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR1)->SMP10 = value; }
  531.             static inline uint32_t get_SMP11() { return reinterpret_cast<__IO SMPR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR1)->SMP11; }
  532.             static inline void set_SMP11(uint32_t value) { reinterpret_cast<__IO SMPR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR1)->SMP11 = value; }
  533.             static inline uint32_t get_SMP12() { return reinterpret_cast<__IO SMPR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR1)->SMP12; }
  534.             static inline void set_SMP12(uint32_t value) { reinterpret_cast<__IO SMPR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR1)->SMP12 = value; }
  535.             static inline uint32_t get_SMP13() { return reinterpret_cast<__IO SMPR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR1)->SMP13; }
  536.             static inline void set_SMP13(uint32_t value) { reinterpret_cast<__IO SMPR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR1)->SMP13 = value; }
  537.             static inline uint32_t get_SMP14() { return reinterpret_cast<__IO SMPR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR1)->SMP14; }
  538.             static inline void set_SMP14(uint32_t value) { reinterpret_cast<__IO SMPR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR1)->SMP14 = value; }
  539.             static inline uint32_t get_SMP15() { return reinterpret_cast<__IO SMPR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR1)->SMP15; }
  540.             static inline void set_SMP15(uint32_t value) { reinterpret_cast<__IO SMPR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR1)->SMP15 = value; }
  541.             static inline uint32_t get_SMP16() { return reinterpret_cast<__IO SMPR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR1)->SMP16; }
  542.             static inline void set_SMP16(uint32_t value) { reinterpret_cast<__IO SMPR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR1)->SMP16 = value; }
  543.             static inline uint32_t get_SMP17() { return reinterpret_cast<__IO SMPR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR1)->SMP17; }
  544.             static inline void set_SMP17(uint32_t value) { reinterpret_cast<__IO SMPR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR1)->SMP17 = value; }
  545.             static inline uint32_t get_SMP18() { return reinterpret_cast<__IO SMPR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR1)->SMP18; }
  546.             static inline void set_SMP18(uint32_t value) { reinterpret_cast<__IO SMPR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR1)->SMP18 = value; }
  547.         };
  548.         class SMPR2
  549.         {
  550.         private:
  551.             union SMPR2_t
  552.             {
  553.                 struct
  554.                 {
  555.                     uint32_t SMP0           : 3;
  556.                     uint32_t SMP1           : 3;
  557.                     uint32_t SMP2           : 3;
  558.                     uint32_t SMP3           : 3;
  559.                     uint32_t SMP4           : 3;
  560.                     uint32_t SMP5           : 3;
  561.                     uint32_t SMP6           : 3;
  562.                     uint32_t SMP7           : 3;
  563.                     uint32_t SMP8           : 3;
  564.                     uint32_t SMP9           : 3;
  565.                     uint32_t reserved30     : 2;
  566.                 };
  567.                 uint32_t RAW;
  568.             };
  569.         public:
  570.             enum class EMasks: uint32_t
  571.             {
  572.                 SMP0                   = (0x7U << 0),
  573.                 SMP1                   = (0x7U << 3),
  574.                 SMP2                   = (0x7U << 6),
  575.                 SMP3                   = (0x7U << 9),
  576.                 SMP4                   = (0x7U << 12),
  577.                 SMP5                   = (0x7U << 15),
  578.                 SMP6                   = (0x7U << 18),
  579.                 SMP7                   = (0x7U << 21),
  580.                 SMP8                   = (0x7U << 24),
  581.                 SMP9                   = (0x7U << 27),
  582.             };
  583.             static inline uint32_t get() { return reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR2; }
  584.             static inline void set(uint32_t value) { reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR2 = value; }
  585.             static inline uint32_t get_SMP0() { return reinterpret_cast<__IO SMPR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR2)->SMP0; }
  586.             static inline void set_SMP0(uint32_t value) { reinterpret_cast<__IO SMPR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR2)->SMP0 = value; }
  587.             static inline uint32_t get_SMP1() { return reinterpret_cast<__IO SMPR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR2)->SMP1; }
  588.             static inline void set_SMP1(uint32_t value) { reinterpret_cast<__IO SMPR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR2)->SMP1 = value; }
  589.             static inline uint32_t get_SMP2() { return reinterpret_cast<__IO SMPR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR2)->SMP2; }
  590.             static inline void set_SMP2(uint32_t value) { reinterpret_cast<__IO SMPR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR2)->SMP2 = value; }
  591.             static inline uint32_t get_SMP3() { return reinterpret_cast<__IO SMPR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR2)->SMP3; }
  592.             static inline void set_SMP3(uint32_t value) { reinterpret_cast<__IO SMPR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR2)->SMP3 = value; }
  593.             static inline uint32_t get_SMP4() { return reinterpret_cast<__IO SMPR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR2)->SMP4; }
  594.             static inline void set_SMP4(uint32_t value) { reinterpret_cast<__IO SMPR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR2)->SMP4 = value; }
  595.             static inline uint32_t get_SMP5() { return reinterpret_cast<__IO SMPR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR2)->SMP5; }
  596.             static inline void set_SMP5(uint32_t value) { reinterpret_cast<__IO SMPR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR2)->SMP5 = value; }
  597.             static inline uint32_t get_SMP6() { return reinterpret_cast<__IO SMPR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR2)->SMP6; }
  598.             static inline void set_SMP6(uint32_t value) { reinterpret_cast<__IO SMPR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR2)->SMP6 = value; }
  599.             static inline uint32_t get_SMP7() { return reinterpret_cast<__IO SMPR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR2)->SMP7; }
  600.             static inline void set_SMP7(uint32_t value) { reinterpret_cast<__IO SMPR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR2)->SMP7 = value; }
  601.             static inline uint32_t get_SMP8() { return reinterpret_cast<__IO SMPR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR2)->SMP8; }
  602.             static inline void set_SMP8(uint32_t value) { reinterpret_cast<__IO SMPR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR2)->SMP8 = value; }
  603.             static inline uint32_t get_SMP9() { return reinterpret_cast<__IO SMPR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR2)->SMP9; }
  604.             static inline void set_SMP9(uint32_t value) { reinterpret_cast<__IO SMPR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SMPR2)->SMP9 = value; }
  605.         };
  606.         class JOFR1
  607.         {
  608.         private:
  609.             union JOFR1_t
  610.             {
  611.                 struct
  612.                 {
  613.                     uint32_t JOFFSET1       : 12;
  614.                     uint32_t reserved12     : 20;
  615.                 };
  616.                 uint32_t RAW;
  617.             };
  618.         public:
  619.             enum class EMasks: uint32_t
  620.             {
  621.                 JOFFSET1               = (0xFFFU << 0),
  622.             };
  623.             static inline uint32_t get() { return reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JOFR1; }
  624.             static inline void set(uint32_t value) { reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JOFR1 = value; }
  625.             static inline uint32_t get_JOFFSET1() { return reinterpret_cast<__IO JOFR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JOFR1)->JOFFSET1; }
  626.             static inline void set_JOFFSET1(uint32_t value) { reinterpret_cast<__IO JOFR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JOFR1)->JOFFSET1 = value; }
  627.         };
  628.         class JOFR2
  629.         {
  630.         private:
  631.             union JOFR2_t
  632.             {
  633.                 struct
  634.                 {
  635.                     uint32_t JOFFSET2       : 12;
  636.                     uint32_t reserved12     : 20;
  637.                 };
  638.                 uint32_t RAW;
  639.             };
  640.         public:
  641.             enum class EMasks: uint32_t
  642.             {
  643.                 JOFFSET2               = (0xFFFU << 0),
  644.             };
  645.             static inline uint32_t get() { return reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JOFR2; }
  646.             static inline void set(uint32_t value) { reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JOFR2 = value; }
  647.             static inline uint32_t get_JOFFSET2() { return reinterpret_cast<__IO JOFR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JOFR2)->JOFFSET2; }
  648.             static inline void set_JOFFSET2(uint32_t value) { reinterpret_cast<__IO JOFR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JOFR2)->JOFFSET2 = value; }
  649.         };
  650.         class JOFR3
  651.         {
  652.         private:
  653.             union JOFR3_t
  654.             {
  655.                 struct
  656.                 {
  657.                     uint32_t JOFFSET3       : 12;
  658.                     uint32_t reserved12     : 20;
  659.                 };
  660.                 uint32_t RAW;
  661.             };
  662.         public:
  663.             enum class EMasks: uint32_t
  664.             {
  665.                 JOFFSET3               = (0xFFFU << 0),
  666.             };
  667.             static inline uint32_t get() { return reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JOFR3; }
  668.             static inline void set(uint32_t value) { reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JOFR3 = value; }
  669.             static inline uint32_t get_JOFFSET3() { return reinterpret_cast<__IO JOFR3_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JOFR3)->JOFFSET3; }
  670.             static inline void set_JOFFSET3(uint32_t value) { reinterpret_cast<__IO JOFR3_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JOFR3)->JOFFSET3 = value; }
  671.         };
  672.         class JOFR4
  673.         {
  674.         private:
  675.             union JOFR4_t
  676.             {
  677.                 struct
  678.                 {
  679.                     uint32_t JOFFSET4       : 12;
  680.                     uint32_t reserved12     : 20;
  681.                 };
  682.                 uint32_t RAW;
  683.             };
  684.         public:
  685.             enum class EMasks: uint32_t
  686.             {
  687.                 JOFFSET4               = (0xFFFU << 0),
  688.             };
  689.             static inline uint32_t get() { return reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JOFR4; }
  690.             static inline void set(uint32_t value) { reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JOFR4 = value; }
  691.             static inline uint32_t get_JOFFSET4() { return reinterpret_cast<__IO JOFR4_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JOFR4)->JOFFSET4; }
  692.             static inline void set_JOFFSET4(uint32_t value) { reinterpret_cast<__IO JOFR4_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JOFR4)->JOFFSET4 = value; }
  693.         };
  694.         class HTR
  695.         {
  696.         private:
  697.             union HTR_t
  698.             {
  699.                 struct
  700.                 {
  701.                     uint32_t HT             : 12;
  702.                     uint32_t reserved12     : 20;
  703.                 };
  704.                 uint32_t RAW;
  705.             };
  706.         public:
  707.             enum class EMasks: uint32_t
  708.             {
  709.                 HT                     = (0xFFFU << 0),
  710.             };
  711.             static inline uint32_t get() { return reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->HTR; }
  712.             static inline void set(uint32_t value) { reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->HTR = value; }
  713.             static inline uint32_t get_HT() { return reinterpret_cast<__IO HTR_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->HTR)->HT; }
  714.             static inline void set_HT(uint32_t value) { reinterpret_cast<__IO HTR_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->HTR)->HT = value; }
  715.         };
  716.         class LTR
  717.         {
  718.         private:
  719.             union LTR_t
  720.             {
  721.                 struct
  722.                 {
  723.                     uint32_t LT             : 12;
  724.                     uint32_t reserved12     : 20;
  725.                 };
  726.                 uint32_t RAW;
  727.             };
  728.         public:
  729.             enum class EMasks: uint32_t
  730.             {
  731.                 LT                     = (0xFFFU << 0),
  732.             };
  733.             static inline uint32_t get() { return reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->LTR; }
  734.             static inline void set(uint32_t value) { reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->LTR = value; }
  735.             static inline uint32_t get_LT() { return reinterpret_cast<__IO LTR_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->LTR)->LT; }
  736.             static inline void set_LT(uint32_t value) { reinterpret_cast<__IO LTR_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->LTR)->LT = value; }
  737.         };
  738.         class SQR1
  739.         {
  740.         private:
  741.             union SQR1_t
  742.             {
  743.                 struct
  744.                 {
  745.                     uint32_t SQ13           : 5;
  746.                     uint32_t SQ14           : 5;
  747.                     uint32_t SQ15           : 5;
  748.                     uint32_t SQ16           : 5;
  749.                     uint32_t L              : 4;
  750.                     uint32_t reserved24     : 8;
  751.                 };
  752.                 uint32_t RAW;
  753.             };
  754.         public:
  755.             enum class EMasks: uint32_t
  756.             {
  757.                 SQ13                   = (0x1FU << 0),
  758.                 SQ14                   = (0x1FU << 5),
  759.                 SQ15                   = (0x1FU << 10),
  760.                 SQ16                   = (0x1FU << 15),
  761.                 L                      = (0xFU << 20),
  762.             };
  763.             static inline uint32_t get() { return reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR1; }
  764.             static inline void set(uint32_t value) { reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR1 = value; }
  765.             static inline uint32_t get_SQ13() { return reinterpret_cast<__IO SQR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR1)->SQ13; }
  766.             static inline void set_SQ13(uint32_t value) { reinterpret_cast<__IO SQR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR1)->SQ13 = value; }
  767.             static inline uint32_t get_SQ14() { return reinterpret_cast<__IO SQR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR1)->SQ14; }
  768.             static inline void set_SQ14(uint32_t value) { reinterpret_cast<__IO SQR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR1)->SQ14 = value; }
  769.             static inline uint32_t get_SQ15() { return reinterpret_cast<__IO SQR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR1)->SQ15; }
  770.             static inline void set_SQ15(uint32_t value) { reinterpret_cast<__IO SQR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR1)->SQ15 = value; }
  771.             static inline uint32_t get_SQ16() { return reinterpret_cast<__IO SQR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR1)->SQ16; }
  772.             static inline void set_SQ16(uint32_t value) { reinterpret_cast<__IO SQR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR1)->SQ16 = value; }
  773.             static inline uint32_t get_L() { return reinterpret_cast<__IO SQR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR1)->L; }
  774.             static inline void set_L(uint32_t value) { reinterpret_cast<__IO SQR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR1)->L = value; }
  775.         };
  776.         class SQR2
  777.         {
  778.         private:
  779.             union SQR2_t
  780.             {
  781.                 struct
  782.                 {
  783.                     uint32_t SQ7            : 5;
  784.                     uint32_t SQ8            : 5;
  785.                     uint32_t SQ9            : 5;
  786.                     uint32_t SQ10           : 5;
  787.                     uint32_t SQ11           : 5;
  788.                     uint32_t SQ12           : 5;
  789.                     uint32_t reserved30     : 2;
  790.                 };
  791.                 uint32_t RAW;
  792.             };
  793.         public:
  794.             enum class EMasks: uint32_t
  795.             {
  796.                 SQ7                    = (0x1FU << 0),
  797.                 SQ8                    = (0x1FU << 5),
  798.                 SQ9                    = (0x1FU << 10),
  799.                 SQ10                   = (0x1FU << 15),
  800.                 SQ11                   = (0x1FU << 20),
  801.                 SQ12                   = (0x1FU << 25),
  802.             };
  803.             static inline uint32_t get() { return reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR2; }
  804.             static inline void set(uint32_t value) { reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR2 = value; }
  805.             static inline uint32_t get_SQ7() { return reinterpret_cast<__IO SQR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR2)->SQ7; }
  806.             static inline void set_SQ7(uint32_t value) { reinterpret_cast<__IO SQR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR2)->SQ7 = value; }
  807.             static inline uint32_t get_SQ8() { return reinterpret_cast<__IO SQR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR2)->SQ8; }
  808.             static inline void set_SQ8(uint32_t value) { reinterpret_cast<__IO SQR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR2)->SQ8 = value; }
  809.             static inline uint32_t get_SQ9() { return reinterpret_cast<__IO SQR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR2)->SQ9; }
  810.             static inline void set_SQ9(uint32_t value) { reinterpret_cast<__IO SQR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR2)->SQ9 = value; }
  811.             static inline uint32_t get_SQ10() { return reinterpret_cast<__IO SQR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR2)->SQ10; }
  812.             static inline void set_SQ10(uint32_t value) { reinterpret_cast<__IO SQR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR2)->SQ10 = value; }
  813.             static inline uint32_t get_SQ11() { return reinterpret_cast<__IO SQR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR2)->SQ11; }
  814.             static inline void set_SQ11(uint32_t value) { reinterpret_cast<__IO SQR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR2)->SQ11 = value; }
  815.             static inline uint32_t get_SQ12() { return reinterpret_cast<__IO SQR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR2)->SQ12; }
  816.             static inline void set_SQ12(uint32_t value) { reinterpret_cast<__IO SQR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR2)->SQ12 = value; }
  817.         };
  818.         class SQR3
  819.         {
  820.         private:
  821.             union SQR3_t
  822.             {
  823.                 struct
  824.                 {
  825.                     uint32_t SQ1            : 5;
  826.                     uint32_t SQ2            : 5;
  827.                     uint32_t SQ3            : 5;
  828.                     uint32_t SQ4            : 5;
  829.                     uint32_t SQ5            : 5;
  830.                     uint32_t SQ6            : 5;
  831.                     uint32_t reserved30     : 2;
  832.                 };
  833.                 uint32_t RAW;
  834.             };
  835.         public:
  836.             enum class EMasks: uint32_t
  837.             {
  838.                 SQ1                    = (0x1FU << 0),
  839.                 SQ2                    = (0x1FU << 5),
  840.                 SQ3                    = (0x1FU << 10),
  841.                 SQ4                    = (0x1FU << 15),
  842.                 SQ5                    = (0x1FU << 20),
  843.                 SQ6                    = (0x1FU << 25),
  844.             };
  845.             static inline uint32_t get() { return reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR3; }
  846.             static inline void set(uint32_t value) { reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR3 = value; }
  847.             static inline uint32_t get_SQ1() { return reinterpret_cast<__IO SQR3_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR3)->SQ1; }
  848.             static inline void set_SQ1(uint32_t value) { reinterpret_cast<__IO SQR3_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR3)->SQ1 = value; }
  849.             static inline uint32_t get_SQ2() { return reinterpret_cast<__IO SQR3_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR3)->SQ2; }
  850.             static inline void set_SQ2(uint32_t value) { reinterpret_cast<__IO SQR3_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR3)->SQ2 = value; }
  851.             static inline uint32_t get_SQ3() { return reinterpret_cast<__IO SQR3_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR3)->SQ3; }
  852.             static inline void set_SQ3(uint32_t value) { reinterpret_cast<__IO SQR3_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR3)->SQ3 = value; }
  853.             static inline uint32_t get_SQ4() { return reinterpret_cast<__IO SQR3_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR3)->SQ4; }
  854.             static inline void set_SQ4(uint32_t value) { reinterpret_cast<__IO SQR3_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR3)->SQ4 = value; }
  855.             static inline uint32_t get_SQ5() { return reinterpret_cast<__IO SQR3_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR3)->SQ5; }
  856.             static inline void set_SQ5(uint32_t value) { reinterpret_cast<__IO SQR3_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR3)->SQ5 = value; }
  857.             static inline uint32_t get_SQ6() { return reinterpret_cast<__IO SQR3_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR3)->SQ6; }
  858.             static inline void set_SQ6(uint32_t value) { reinterpret_cast<__IO SQR3_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->SQR3)->SQ6 = value; }
  859.         };
  860.         class JSQR
  861.         {
  862.         private:
  863.             union JSQR_t
  864.             {
  865.                 struct
  866.                 {
  867.                     uint32_t JSQ1           : 5;
  868.                     uint32_t JSQ2           : 5;
  869.                     uint32_t JSQ3           : 5;
  870.                     uint32_t JSQ4           : 5;
  871.                     uint32_t JL             : 2;
  872.                     uint32_t reserved22     : 10;
  873.                 };
  874.                 uint32_t RAW;
  875.             };
  876.         public:
  877.             enum class EMasks: uint32_t
  878.             {
  879.                 JSQ1                   = (0x1FU << 0),
  880.                 JSQ2                   = (0x1FU << 5),
  881.                 JSQ3                   = (0x1FU << 10),
  882.                 JSQ4                   = (0x1FU << 15),
  883.                 JL                     = (0x3U << 20),
  884.             };
  885.             static inline uint32_t get() { return reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JSQR; }
  886.             static inline void set(uint32_t value) { reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JSQR = value; }
  887.             static inline uint32_t get_JSQ1() { return reinterpret_cast<__IO JSQR_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JSQR)->JSQ1; }
  888.             static inline void set_JSQ1(uint32_t value) { reinterpret_cast<__IO JSQR_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JSQR)->JSQ1 = value; }
  889.             static inline uint32_t get_JSQ2() { return reinterpret_cast<__IO JSQR_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JSQR)->JSQ2; }
  890.             static inline void set_JSQ2(uint32_t value) { reinterpret_cast<__IO JSQR_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JSQR)->JSQ2 = value; }
  891.             static inline uint32_t get_JSQ3() { return reinterpret_cast<__IO JSQR_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JSQR)->JSQ3; }
  892.             static inline void set_JSQ3(uint32_t value) { reinterpret_cast<__IO JSQR_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JSQR)->JSQ3 = value; }
  893.             static inline uint32_t get_JSQ4() { return reinterpret_cast<__IO JSQR_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JSQR)->JSQ4; }
  894.             static inline void set_JSQ4(uint32_t value) { reinterpret_cast<__IO JSQR_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JSQR)->JSQ4 = value; }
  895.             static inline uint32_t get_JL() { return reinterpret_cast<__IO JSQR_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JSQR)->JL; }
  896.             static inline void set_JL(uint32_t value) { reinterpret_cast<__IO JSQR_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JSQR)->JL = value; }
  897.         };
  898.         class JDR1
  899.         {
  900.         private:
  901.             union JDR1_t
  902.             {
  903.                 struct
  904.                 {
  905.                     uint32_t JDATA          : 16;
  906.                     uint32_t reserved16     : 16;
  907.                 };
  908.                 uint32_t RAW;
  909.             };
  910.         public:
  911.             enum class EMasks: uint32_t
  912.             {
  913.                 JDATA                  = (0xFFFFU << 0),
  914.             };
  915.             static inline uint32_t get() { return reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JDR1; }
  916.             static inline void set(uint32_t value) { reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JDR1 = value; }
  917.             static inline uint32_t get_JDATA() { return reinterpret_cast<__IO JDR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JDR1)->JDATA; }
  918.             static inline void set_JDATA(uint32_t value) { reinterpret_cast<__IO JDR1_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JDR1)->JDATA = value; }
  919.         };
  920.         class JDR2
  921.         {
  922.         private:
  923.             union JDR2_t
  924.             {
  925.                 struct
  926.                 {
  927.                     uint32_t JDATA          : 16;
  928.                     uint32_t reserved16     : 16;
  929.                 };
  930.                 uint32_t RAW;
  931.             };
  932.         public:
  933.             enum class EMasks: uint32_t
  934.             {
  935.                 JDATA                  = (0xFFFFU << 0),
  936.             };
  937.             static inline uint32_t get() { return reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JDR2; }
  938.             static inline void set(uint32_t value) { reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JDR2 = value; }
  939.             static inline uint32_t get_JDATA() { return reinterpret_cast<__IO JDR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JDR2)->JDATA; }
  940.             static inline void set_JDATA(uint32_t value) { reinterpret_cast<__IO JDR2_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JDR2)->JDATA = value; }
  941.         };
  942.         class JDR3
  943.         {
  944.         private:
  945.             union JDR3_t
  946.             {
  947.                 struct
  948.                 {
  949.                     uint32_t JDATA          : 16;
  950.                     uint32_t reserved16     : 16;
  951.                 };
  952.                 uint32_t RAW;
  953.             };
  954.         public:
  955.             enum class EMasks: uint32_t
  956.             {
  957.                 JDATA                  = (0xFFFFU << 0),
  958.             };
  959.             static inline uint32_t get() { return reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JDR3; }
  960.             static inline void set(uint32_t value) { reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JDR3 = value; }
  961.             static inline uint32_t get_JDATA() { return reinterpret_cast<__IO JDR3_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JDR3)->JDATA; }
  962.             static inline void set_JDATA(uint32_t value) { reinterpret_cast<__IO JDR3_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JDR3)->JDATA = value; }
  963.         };
  964.         class JDR4
  965.         {
  966.         private:
  967.             union JDR4_t
  968.             {
  969.                 struct
  970.                 {
  971.                     uint32_t JDATA          : 16;
  972.                     uint32_t reserved16     : 16;
  973.                 };
  974.                 uint32_t RAW;
  975.             };
  976.         public:
  977.             enum class EMasks: uint32_t
  978.             {
  979.                 JDATA                  = (0xFFFFU << 0),
  980.             };
  981.             static inline uint32_t get() { return reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JDR4; }
  982.             static inline void set(uint32_t value) { reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JDR4 = value; }
  983.             static inline uint32_t get_JDATA() { return reinterpret_cast<__IO JDR4_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JDR4)->JDATA; }
  984.             static inline void set_JDATA(uint32_t value) { reinterpret_cast<__IO JDR4_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->JDR4)->JDATA = value; }
  985.         };
  986.         class DR
  987.         {
  988.         private:
  989.             union DR_t
  990.             {
  991.                 struct
  992.                 {
  993.                     uint32_t DATA           : 16;
  994.                     uint32_t ADC2DATA       : 16;
  995.                 };
  996.                 uint32_t RAW;
  997.             };
  998.         public:
  999.             enum class EMasks: uint32_t
  1000.             {
  1001.                 DATA                   = (0xFFFFU << 0),
  1002.                 ADC2DATA               = (0xFFFFU << 16),
  1003.             };
  1004.             static inline uint32_t get() { return reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->DR; }
  1005.             static inline void set(uint32_t value) { reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->DR = value; }
  1006.             static inline uint32_t get_DATA() { return reinterpret_cast<__IO DR_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->DR)->DATA; }
  1007.             static inline void set_DATA(uint32_t value) { reinterpret_cast<__IO DR_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->DR)->DATA = value; }
  1008.             static inline uint32_t get_ADC2DATA() { return reinterpret_cast<__IO DR_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->DR)->ADC2DATA; }
  1009.             static inline void set_ADC2DATA(uint32_t value) { reinterpret_cast<__IO DR_t*>(&reinterpret_cast<ADC_t*>(STM32::ADC_BASE)->DR)->ADC2DATA = value; }
  1010.         };
  1011.     };
  1012.     /* ADC123_Common DEFINITION */
  1013.     template <uint32_t reg_base>
  1014.     class ADC123_Common
  1015.     {
  1016. #warning TODO: ADC123_Common
  1017.     };
  1018.     /* CAN_TxMailBox DEFINITION */
  1019.     template <uint32_t reg_base>
  1020.     class CAN_TxMailBox
  1021.     {
  1022. #warning TODO: CAN_TxMailBox
  1023.     };
  1024.     /* CAN_FIFOMailBox DEFINITION */
  1025.     template <uint32_t reg_base>
  1026.     class CAN_FIFOMailBox
  1027.     {
  1028. #warning TODO: CAN_FIFOMailBox
  1029.     };
  1030.     /* CAN_FilterRegister DEFINITION */
  1031.     template <uint32_t reg_base>
  1032.     class CAN_FilterRegister
  1033.     {
  1034. #warning TODO: CAN_FilterRegister
  1035.     };
  1036.     /* CAN DEFINITION */
  1037.     template <uint32_t reg_base>
  1038.     class CAN
  1039.     {
  1040. #warning TODO: CAN
  1041.     };
  1042.     /* CRC DEFINITION */
  1043.     class CRC
  1044.     {
  1045.     private:
  1046.         struct CRC_t
  1047.         {
  1048.             __IO uint32_t                 DR;
  1049.             __IO uint8_t                  IDR;
  1050.             uint8_t                       RESERVED0;
  1051.             uint16_t                      RESERVED1;
  1052.             __IO uint32_t                 CR;
  1053.         };
  1054.     public:
  1055.         class DR
  1056.         {
  1057.         private:
  1058.             union DR_t
  1059.             {
  1060.                 struct
  1061.                 {
  1062.                     uint32_t DR             : 32;
  1063.                 };
  1064.                 uint32_t RAW;
  1065.             };
  1066.         public:
  1067.             enum class EMasks: uint32_t
  1068.             {
  1069.                 DR                     = (0xFFFFFFFFU << 0),
  1070.             };
  1071.             static inline uint32_t get() { return reinterpret_cast<CRC_t*>(STM32::CRC_BASE)->DR; }
  1072.             static inline void set(uint32_t value) { reinterpret_cast<CRC_t*>(STM32::CRC_BASE)->DR = value; }
  1073.             static inline uint32_t get_DR() { return reinterpret_cast<__IO DR_t*>(&reinterpret_cast<CRC_t*>(STM32::CRC_BASE)->DR)->DR; }
  1074.             static inline void set_DR(uint32_t value) { reinterpret_cast<__IO DR_t*>(&reinterpret_cast<CRC_t*>(STM32::CRC_BASE)->DR)->DR = value; }
  1075.         };
  1076.         class IDR
  1077.         {
  1078.         public:
  1079.             enum class EMasks: uint32_t
  1080.             {
  1081.                 IDR                    = (0xFFU << 0),
  1082.             };
  1083.             static inline uint32_t get() { return reinterpret_cast<CRC_t*>(STM32::CRC_BASE)->IDR; }
  1084.             static inline void set(uint32_t value) { reinterpret_cast<CRC_t*>(STM32::CRC_BASE)->IDR = value; }
  1085.         };
  1086.         class CR
  1087.         {
  1088.         private:
  1089.             union CR_t
  1090.             {
  1091.                 struct
  1092.                 {
  1093.                     uint32_t RESET          : 1;
  1094.                     uint32_t reserved1      : 31;
  1095.                 };
  1096.                 uint32_t RAW;
  1097.             };
  1098.         public:
  1099.             enum class EMasks: uint32_t
  1100.             {
  1101.                 RESET                  = (0x1U << 0),
  1102.             };
  1103.             static inline uint32_t get() { return reinterpret_cast<CRC_t*>(STM32::CRC_BASE)->CR; }
  1104.             static inline void set(uint32_t value) { reinterpret_cast<CRC_t*>(STM32::CRC_BASE)->CR = value; }
  1105.             template <EMasks ... flags>
  1106.             static inline void set_flags()
  1107.             {
  1108.                 reinterpret_cast<CRC_t*>(STM32::CRC_BASE)->CR |= SetBits<(std::uint32_t)flags...>();
  1109.             }
  1110.             template <EMasks ... flags>
  1111.             static inline void clear_flags()
  1112.             {
  1113.                 reinterpret_cast<CRC_t*>(STM32::CRC_BASE)->CR &= ~(SetBits<(std::uint32_t)flags...>());
  1114.             }
  1115.             template <EMasks ... flags>
  1116.             static inline bool get_flags()
  1117.             {
  1118.                 return ((reinterpret_cast<CRC_t*>(STM32::CRC_BASE)->CR & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  1119.             }
  1120.         };
  1121.     };
  1122.     /* DAC DEFINITION */
  1123.     class DAC
  1124.     {
  1125.     private:
  1126.         struct DAC_t
  1127.         {
  1128.             __IO uint32_t                 CR;
  1129.             __IO uint32_t                 SWTRIGR;
  1130.             __IO uint32_t                 DHR12R1;
  1131.             __IO uint32_t                 DHR12L1;
  1132.             __IO uint32_t                 DHR8R1;
  1133.             __IO uint32_t                 DHR12R2;
  1134.             __IO uint32_t                 DHR12L2;
  1135.             __IO uint32_t                 DHR8R2;
  1136.             __IO uint32_t                 DHR12RD;
  1137.             __IO uint32_t                 DHR12LD;
  1138.             __IO uint32_t                 DHR8RD;
  1139.             __IO uint32_t                 DOR1;
  1140.             __IO uint32_t                 DOR2;
  1141.             __IO uint32_t                 SR;
  1142.         };
  1143.     public:
  1144.         class CR
  1145.         {
  1146.         private:
  1147.             union CR_t
  1148.             {
  1149.                 struct
  1150.                 {
  1151.                     uint32_t EN1            : 1;
  1152.                     uint32_t BOFF1          : 1;
  1153.                     uint32_t TEN1           : 1;
  1154.                     uint32_t TSEL1          : 3;
  1155.                     uint32_t WAVE1          : 2;
  1156.                     uint32_t MAMP1          : 4;
  1157.                     uint32_t DMAEN1         : 1;
  1158.                     uint32_t DMAUDRIE1      : 1;
  1159.                     uint32_t reserved14     : 1;
  1160.                     uint32_t reserved15     : 1;
  1161.                     uint32_t EN2            : 1;
  1162.                     uint32_t BOFF2          : 1;
  1163.                     uint32_t TEN2           : 1;
  1164.                     uint32_t TSEL2          : 3;
  1165.                     uint32_t WAVE2          : 2;
  1166.                     uint32_t MAMP2          : 4;
  1167.                     uint32_t DMAEN2         : 1;
  1168.                     uint32_t DMAUDRIE2      : 1;
  1169.                     uint32_t reserved30     : 2;
  1170.                 };
  1171.                 uint32_t RAW;
  1172.             };
  1173.         public:
  1174.             enum class EMasks: uint32_t
  1175.             {
  1176.                 EN1                    = (0x1U << 0),
  1177.                 BOFF1                  = (0x1U << 1),
  1178.                 TEN1                   = (0x1U << 2),
  1179.                 TSEL1                  = (0x7U << 3),
  1180.                 WAVE1                  = (0x3U << 6),
  1181.                 MAMP1                  = (0xFU << 8),
  1182.                 DMAEN1                 = (0x1U << 12),
  1183.                 DMAUDRIE1              = (0x1U << 13),
  1184.                 EN2                    = (0x1U << 16),
  1185.                 BOFF2                  = (0x1U << 17),
  1186.                 TEN2                   = (0x1U << 18),
  1187.                 TSEL2                  = (0x7U << 19),
  1188.                 WAVE2                  = (0x3U << 22),
  1189.                 MAMP2                  = (0xFU << 24),
  1190.                 DMAEN2                 = (0x1U << 28),
  1191.                 DMAUDRIE2              = (0x1U << 29),
  1192.             };
  1193.             static inline uint32_t get() { return reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->CR; }
  1194.             static inline void set(uint32_t value) { reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->CR = value; }
  1195.             template <EMasks ... flags>
  1196.             static inline void set_flags()
  1197.             {
  1198.                 reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->CR |= SetBits<(std::uint32_t)flags...>();
  1199.             }
  1200.             template <EMasks ... flags>
  1201.             static inline void clear_flags()
  1202.             {
  1203.                 reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->CR &= ~(SetBits<(std::uint32_t)flags...>());
  1204.             }
  1205.             template <EMasks ... flags>
  1206.             static inline bool get_flags()
  1207.             {
  1208.                 return ((reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->CR & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  1209.             }
  1210.             static inline uint32_t get_TSEL1() { return reinterpret_cast<__IO CR_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->CR)->TSEL1; }
  1211.             static inline void set_TSEL1(uint32_t value) { reinterpret_cast<__IO CR_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->CR)->TSEL1 = value; }
  1212.             static inline uint32_t get_WAVE1() { return reinterpret_cast<__IO CR_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->CR)->WAVE1; }
  1213.             static inline void set_WAVE1(uint32_t value) { reinterpret_cast<__IO CR_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->CR)->WAVE1 = value; }
  1214.             static inline uint32_t get_MAMP1() { return reinterpret_cast<__IO CR_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->CR)->MAMP1; }
  1215.             static inline void set_MAMP1(uint32_t value) { reinterpret_cast<__IO CR_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->CR)->MAMP1 = value; }
  1216.             static inline uint32_t get_TSEL2() { return reinterpret_cast<__IO CR_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->CR)->TSEL2; }
  1217.             static inline void set_TSEL2(uint32_t value) { reinterpret_cast<__IO CR_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->CR)->TSEL2 = value; }
  1218.             static inline uint32_t get_WAVE2() { return reinterpret_cast<__IO CR_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->CR)->WAVE2; }
  1219.             static inline void set_WAVE2(uint32_t value) { reinterpret_cast<__IO CR_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->CR)->WAVE2 = value; }
  1220.             static inline uint32_t get_MAMP2() { return reinterpret_cast<__IO CR_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->CR)->MAMP2; }
  1221.             static inline void set_MAMP2(uint32_t value) { reinterpret_cast<__IO CR_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->CR)->MAMP2 = value; }
  1222.         };
  1223.         class SWTRIGR
  1224.         {
  1225.         private:
  1226.             union SWTRIGR_t
  1227.             {
  1228.                 struct
  1229.                 {
  1230.                     uint32_t SWTRIG1        : 1;
  1231.                     uint32_t SWTRIG2        : 1;
  1232.                     uint32_t reserved2      : 30;
  1233.                 };
  1234.                 uint32_t RAW;
  1235.             };
  1236.         public:
  1237.             enum class EMasks: uint32_t
  1238.             {
  1239.                 SWTRIG1                = (0x1U << 0),
  1240.                 SWTRIG2                = (0x1U << 1),
  1241.             };
  1242.             static inline uint32_t get() { return reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->SWTRIGR; }
  1243.             static inline void set(uint32_t value) { reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->SWTRIGR = value; }
  1244.             template <EMasks ... flags>
  1245.             static inline void set_flags()
  1246.             {
  1247.                 reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->SWTRIGR |= SetBits<(std::uint32_t)flags...>();
  1248.             }
  1249.             template <EMasks ... flags>
  1250.             static inline void clear_flags()
  1251.             {
  1252.                 reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->SWTRIGR &= ~(SetBits<(std::uint32_t)flags...>());
  1253.             }
  1254.             template <EMasks ... flags>
  1255.             static inline bool get_flags()
  1256.             {
  1257.                 return ((reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->SWTRIGR & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  1258.             }
  1259.         };
  1260.         class DHR12R1
  1261.         {
  1262.         private:
  1263.             union DHR12R1_t
  1264.             {
  1265.                 struct
  1266.                 {
  1267.                     uint32_t DACC1DHR       : 12;
  1268.                     uint32_t reserved12     : 20;
  1269.                 };
  1270.                 uint32_t RAW;
  1271.             };
  1272.         public:
  1273.             enum class EMasks: uint32_t
  1274.             {
  1275.                 DACC1DHR               = (0xFFFU << 0),
  1276.             };
  1277.             static inline uint32_t get() { return reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12R1; }
  1278.             static inline void set(uint32_t value) { reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12R1 = value; }
  1279.             static inline uint32_t get_DACC1DHR() { return reinterpret_cast<__IO DHR12R1_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12R1)->DACC1DHR; }
  1280.             static inline void set_DACC1DHR(uint32_t value) { reinterpret_cast<__IO DHR12R1_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12R1)->DACC1DHR = value; }
  1281.         };
  1282.         class DHR12L1
  1283.         {
  1284.         private:
  1285.             union DHR12L1_t
  1286.             {
  1287.                 struct
  1288.                 {
  1289.                     uint32_t reserved0      : 1;
  1290.                     uint32_t reserved1      : 1;
  1291.                     uint32_t reserved2      : 1;
  1292.                     uint32_t reserved3      : 1;
  1293.                     uint32_t DACC1DHR       : 12;
  1294.                     uint32_t reserved16     : 16;
  1295.                 };
  1296.                 uint32_t RAW;
  1297.             };
  1298.         public:
  1299.             enum class EMasks: uint32_t
  1300.             {
  1301.                 DACC1DHR               = (0xFFFU << 4),
  1302.             };
  1303.             static inline uint32_t get() { return reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12L1; }
  1304.             static inline void set(uint32_t value) { reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12L1 = value; }
  1305.             static inline uint32_t get_DACC1DHR() { return reinterpret_cast<__IO DHR12L1_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12L1)->DACC1DHR; }
  1306.             static inline void set_DACC1DHR(uint32_t value) { reinterpret_cast<__IO DHR12L1_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12L1)->DACC1DHR = value; }
  1307.         };
  1308.         class DHR8R1
  1309.         {
  1310.         private:
  1311.             union DHR8R1_t
  1312.             {
  1313.                 struct
  1314.                 {
  1315.                     uint32_t DACC1DHR       : 8;
  1316.                     uint32_t reserved8      : 24;
  1317.                 };
  1318.                 uint32_t RAW;
  1319.             };
  1320.         public:
  1321.             enum class EMasks: uint32_t
  1322.             {
  1323.                 DACC1DHR               = (0xFFU << 0),
  1324.             };
  1325.             static inline uint32_t get() { return reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR8R1; }
  1326.             static inline void set(uint32_t value) { reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR8R1 = value; }
  1327.             static inline uint32_t get_DACC1DHR() { return reinterpret_cast<__IO DHR8R1_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR8R1)->DACC1DHR; }
  1328.             static inline void set_DACC1DHR(uint32_t value) { reinterpret_cast<__IO DHR8R1_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR8R1)->DACC1DHR = value; }
  1329.         };
  1330.         class DHR12R2
  1331.         {
  1332.         private:
  1333.             union DHR12R2_t
  1334.             {
  1335.                 struct
  1336.                 {
  1337.                     uint32_t DACC2DHR       : 12;
  1338.                     uint32_t reserved12     : 20;
  1339.                 };
  1340.                 uint32_t RAW;
  1341.             };
  1342.         public:
  1343.             enum class EMasks: uint32_t
  1344.             {
  1345.                 DACC2DHR               = (0xFFFU << 0),
  1346.             };
  1347.             static inline uint32_t get() { return reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12R2; }
  1348.             static inline void set(uint32_t value) { reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12R2 = value; }
  1349.             static inline uint32_t get_DACC2DHR() { return reinterpret_cast<__IO DHR12R2_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12R2)->DACC2DHR; }
  1350.             static inline void set_DACC2DHR(uint32_t value) { reinterpret_cast<__IO DHR12R2_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12R2)->DACC2DHR = value; }
  1351.         };
  1352.         class DHR12L2
  1353.         {
  1354.         private:
  1355.             union DHR12L2_t
  1356.             {
  1357.                 struct
  1358.                 {
  1359.                     uint32_t reserved0      : 1;
  1360.                     uint32_t reserved1      : 1;
  1361.                     uint32_t reserved2      : 1;
  1362.                     uint32_t reserved3      : 1;
  1363.                     uint32_t DACC2DHR       : 12;
  1364.                     uint32_t reserved16     : 16;
  1365.                 };
  1366.                 uint32_t RAW;
  1367.             };
  1368.         public:
  1369.             enum class EMasks: uint32_t
  1370.             {
  1371.                 DACC2DHR               = (0xFFFU << 4),
  1372.             };
  1373.             static inline uint32_t get() { return reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12L2; }
  1374.             static inline void set(uint32_t value) { reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12L2 = value; }
  1375.             static inline uint32_t get_DACC2DHR() { return reinterpret_cast<__IO DHR12L2_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12L2)->DACC2DHR; }
  1376.             static inline void set_DACC2DHR(uint32_t value) { reinterpret_cast<__IO DHR12L2_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12L2)->DACC2DHR = value; }
  1377.         };
  1378.         class DHR8R2
  1379.         {
  1380.         private:
  1381.             union DHR8R2_t
  1382.             {
  1383.                 struct
  1384.                 {
  1385.                     uint32_t DACC2DHR       : 8;
  1386.                     uint32_t reserved8      : 24;
  1387.                 };
  1388.                 uint32_t RAW;
  1389.             };
  1390.         public:
  1391.             enum class EMasks: uint32_t
  1392.             {
  1393.                 DACC2DHR               = (0xFFU << 0),
  1394.             };
  1395.             static inline uint32_t get() { return reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR8R2; }
  1396.             static inline void set(uint32_t value) { reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR8R2 = value; }
  1397.             static inline uint32_t get_DACC2DHR() { return reinterpret_cast<__IO DHR8R2_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR8R2)->DACC2DHR; }
  1398.             static inline void set_DACC2DHR(uint32_t value) { reinterpret_cast<__IO DHR8R2_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR8R2)->DACC2DHR = value; }
  1399.         };
  1400.         class DHR12RD
  1401.         {
  1402.         private:
  1403.             union DHR12RD_t
  1404.             {
  1405.                 struct
  1406.                 {
  1407.                     uint32_t DACC1DHR       : 12;
  1408.                     uint32_t reserved12     : 1;
  1409.                     uint32_t reserved13     : 1;
  1410.                     uint32_t reserved14     : 1;
  1411.                     uint32_t reserved15     : 1;
  1412.                     uint32_t DACC2DHR       : 12;
  1413.                     uint32_t reserved28     : 4;
  1414.                 };
  1415.                 uint32_t RAW;
  1416.             };
  1417.         public:
  1418.             enum class EMasks: uint32_t
  1419.             {
  1420.                 DACC1DHR               = (0xFFFU << 0),
  1421.                 DACC2DHR               = (0xFFFU << 16),
  1422.             };
  1423.             static inline uint32_t get() { return reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12RD; }
  1424.             static inline void set(uint32_t value) { reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12RD = value; }
  1425.             static inline uint32_t get_DACC1DHR() { return reinterpret_cast<__IO DHR12RD_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12RD)->DACC1DHR; }
  1426.             static inline void set_DACC1DHR(uint32_t value) { reinterpret_cast<__IO DHR12RD_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12RD)->DACC1DHR = value; }
  1427.             static inline uint32_t get_DACC2DHR() { return reinterpret_cast<__IO DHR12RD_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12RD)->DACC2DHR; }
  1428.             static inline void set_DACC2DHR(uint32_t value) { reinterpret_cast<__IO DHR12RD_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12RD)->DACC2DHR = value; }
  1429.         };
  1430.         class DHR12LD
  1431.         {
  1432.         private:
  1433.             union DHR12LD_t
  1434.             {
  1435.                 struct
  1436.                 {
  1437.                     uint32_t reserved0      : 1;
  1438.                     uint32_t reserved1      : 1;
  1439.                     uint32_t reserved2      : 1;
  1440.                     uint32_t reserved3      : 1;
  1441.                     uint32_t DACC1DHR       : 12;
  1442.                     uint32_t reserved16     : 1;
  1443.                     uint32_t reserved17     : 1;
  1444.                     uint32_t reserved18     : 1;
  1445.                     uint32_t reserved19     : 1;
  1446.                     uint32_t DACC2DHR       : 12;
  1447.                 };
  1448.                 uint32_t RAW;
  1449.             };
  1450.         public:
  1451.             enum class EMasks: uint32_t
  1452.             {
  1453.                 DACC1DHR               = (0xFFFU << 4),
  1454.                 DACC2DHR               = (0xFFFU << 20),
  1455.             };
  1456.             static inline uint32_t get() { return reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12LD; }
  1457.             static inline void set(uint32_t value) { reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12LD = value; }
  1458.             static inline uint32_t get_DACC1DHR() { return reinterpret_cast<__IO DHR12LD_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12LD)->DACC1DHR; }
  1459.             static inline void set_DACC1DHR(uint32_t value) { reinterpret_cast<__IO DHR12LD_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12LD)->DACC1DHR = value; }
  1460.             static inline uint32_t get_DACC2DHR() { return reinterpret_cast<__IO DHR12LD_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12LD)->DACC2DHR; }
  1461.             static inline void set_DACC2DHR(uint32_t value) { reinterpret_cast<__IO DHR12LD_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR12LD)->DACC2DHR = value; }
  1462.         };
  1463.         class DHR8RD
  1464.         {
  1465.         private:
  1466.             union DHR8RD_t
  1467.             {
  1468.                 struct
  1469.                 {
  1470.                     uint32_t DACC1DHR       : 8;
  1471.                     uint32_t DACC2DHR       : 8;
  1472.                     uint32_t reserved16     : 16;
  1473.                 };
  1474.                 uint32_t RAW;
  1475.             };
  1476.         public:
  1477.             enum class EMasks: uint32_t
  1478.             {
  1479.                 DACC1DHR               = (0xFFU << 0),
  1480.                 DACC2DHR               = (0xFFU << 8),
  1481.             };
  1482.             static inline uint32_t get() { return reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR8RD; }
  1483.             static inline void set(uint32_t value) { reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR8RD = value; }
  1484.             static inline uint32_t get_DACC1DHR() { return reinterpret_cast<__IO DHR8RD_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR8RD)->DACC1DHR; }
  1485.             static inline void set_DACC1DHR(uint32_t value) { reinterpret_cast<__IO DHR8RD_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR8RD)->DACC1DHR = value; }
  1486.             static inline uint32_t get_DACC2DHR() { return reinterpret_cast<__IO DHR8RD_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR8RD)->DACC2DHR; }
  1487.             static inline void set_DACC2DHR(uint32_t value) { reinterpret_cast<__IO DHR8RD_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DHR8RD)->DACC2DHR = value; }
  1488.         };
  1489.         class DOR1
  1490.         {
  1491.         private:
  1492.             union DOR1_t
  1493.             {
  1494.                 struct
  1495.                 {
  1496.                     uint32_t DACC1DOR       : 12;
  1497.                     uint32_t reserved12     : 20;
  1498.                 };
  1499.                 uint32_t RAW;
  1500.             };
  1501.         public:
  1502.             enum class EMasks: uint32_t
  1503.             {
  1504.                 DACC1DOR               = (0xFFFU << 0),
  1505.             };
  1506.             static inline uint32_t get() { return reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DOR1; }
  1507.             static inline void set(uint32_t value) { reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DOR1 = value; }
  1508.             static inline uint32_t get_DACC1DOR() { return reinterpret_cast<__IO DOR1_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DOR1)->DACC1DOR; }
  1509.             static inline void set_DACC1DOR(uint32_t value) { reinterpret_cast<__IO DOR1_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DOR1)->DACC1DOR = value; }
  1510.         };
  1511.         class DOR2
  1512.         {
  1513.         private:
  1514.             union DOR2_t
  1515.             {
  1516.                 struct
  1517.                 {
  1518.                     uint32_t DACC2DOR       : 12;
  1519.                     uint32_t reserved12     : 20;
  1520.                 };
  1521.                 uint32_t RAW;
  1522.             };
  1523.         public:
  1524.             enum class EMasks: uint32_t
  1525.             {
  1526.                 DACC2DOR               = (0xFFFU << 0),
  1527.             };
  1528.             static inline uint32_t get() { return reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DOR2; }
  1529.             static inline void set(uint32_t value) { reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DOR2 = value; }
  1530.             static inline uint32_t get_DACC2DOR() { return reinterpret_cast<__IO DOR2_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DOR2)->DACC2DOR; }
  1531.             static inline void set_DACC2DOR(uint32_t value) { reinterpret_cast<__IO DOR2_t*>(&reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->DOR2)->DACC2DOR = value; }
  1532.         };
  1533.         class SR
  1534.         {
  1535.         private:
  1536.             union SR_t
  1537.             {
  1538.                 struct
  1539.                 {
  1540.                     uint32_t reserved0      : 1;
  1541.                     uint32_t reserved1      : 1;
  1542.                     uint32_t reserved2      : 1;
  1543.                     uint32_t reserved3      : 1;
  1544.                     uint32_t reserved4      : 1;
  1545.                     uint32_t reserved5      : 1;
  1546.                     uint32_t reserved6      : 1;
  1547.                     uint32_t reserved7      : 1;
  1548.                     uint32_t reserved8      : 1;
  1549.                     uint32_t reserved9      : 1;
  1550.                     uint32_t reserved10     : 1;
  1551.                     uint32_t reserved11     : 1;
  1552.                     uint32_t reserved12     : 1;
  1553.                     uint32_t DMAUDR1        : 1;
  1554.                     uint32_t reserved14     : 1;
  1555.                     uint32_t reserved15     : 1;
  1556.                     uint32_t reserved16     : 1;
  1557.                     uint32_t reserved17     : 1;
  1558.                     uint32_t reserved18     : 1;
  1559.                     uint32_t reserved19     : 1;
  1560.                     uint32_t reserved20     : 1;
  1561.                     uint32_t reserved21     : 1;
  1562.                     uint32_t reserved22     : 1;
  1563.                     uint32_t reserved23     : 1;
  1564.                     uint32_t reserved24     : 1;
  1565.                     uint32_t reserved25     : 1;
  1566.                     uint32_t reserved26     : 1;
  1567.                     uint32_t reserved27     : 1;
  1568.                     uint32_t reserved28     : 1;
  1569.                     uint32_t DMAUDR2        : 1;
  1570.                     uint32_t reserved30     : 2;
  1571.                 };
  1572.                 uint32_t RAW;
  1573.             };
  1574.         public:
  1575.             enum class EMasks: uint32_t
  1576.             {
  1577.                 DMAUDR1                = (0x1U << 13),
  1578.                 DMAUDR2                = (0x1U << 29),
  1579.             };
  1580.             static inline uint32_t get() { return reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->SR; }
  1581.             static inline void set(uint32_t value) { reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->SR = value; }
  1582.             template <EMasks ... flags>
  1583.             static inline void set_flags()
  1584.             {
  1585.                 reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->SR |= SetBits<(std::uint32_t)flags...>();
  1586.             }
  1587.             template <EMasks ... flags>
  1588.             static inline void clear_flags()
  1589.             {
  1590.                 reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->SR &= ~(SetBits<(std::uint32_t)flags...>());
  1591.             }
  1592.             template <EMasks ... flags>
  1593.             static inline bool get_flags()
  1594.             {
  1595.                 return ((reinterpret_cast<DAC_t*>(STM32::DAC_BASE)->SR & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  1596.             }
  1597.         };
  1598.     };
  1599.     /* DBGMCU DEFINITION */
  1600.     class DBGMCU
  1601.     {
  1602.     private:
  1603.         struct DBGMCU_t
  1604.         {
  1605.             __IO uint32_t                 IDCODE;
  1606.             __IO uint32_t                 CR;
  1607.             __IO uint32_t                 APB1FZ;
  1608.             __IO uint32_t                 APB2FZ;
  1609.         };
  1610.     public:
  1611.         class IDCODE
  1612.         {
  1613.         private:
  1614.             union IDCODE_t
  1615.             {
  1616.                 struct
  1617.                 {
  1618.                     uint32_t DEV_ID         : 12;
  1619.                     uint32_t reserved12     : 1;
  1620.                     uint32_t reserved13     : 1;
  1621.                     uint32_t reserved14     : 1;
  1622.                     uint32_t reserved15     : 1;
  1623.                     uint32_t REV_ID         : 16;
  1624.                 };
  1625.                 uint32_t RAW;
  1626.             };
  1627.         public:
  1628.             enum class EMasks: uint32_t
  1629.             {
  1630.                 DEV_ID                 = (0xFFFU << 0),
  1631.                 REV_ID                 = (0xFFFFU << 16),
  1632.             };
  1633.             static inline uint32_t get() { return reinterpret_cast<DBGMCU_t*>(STM32::DBGMCU_BASE)->IDCODE; }
  1634.             static inline void set(uint32_t value) { reinterpret_cast<DBGMCU_t*>(STM32::DBGMCU_BASE)->IDCODE = value; }
  1635.             static inline uint32_t get_DEV_ID() { return reinterpret_cast<__IO IDCODE_t*>(&reinterpret_cast<DBGMCU_t*>(STM32::DBGMCU_BASE)->IDCODE)->DEV_ID; }
  1636.             static inline void set_DEV_ID(uint32_t value) { reinterpret_cast<__IO IDCODE_t*>(&reinterpret_cast<DBGMCU_t*>(STM32::DBGMCU_BASE)->IDCODE)->DEV_ID = value; }
  1637.             static inline uint32_t get_REV_ID() { return reinterpret_cast<__IO IDCODE_t*>(&reinterpret_cast<DBGMCU_t*>(STM32::DBGMCU_BASE)->IDCODE)->REV_ID; }
  1638.             static inline void set_REV_ID(uint32_t value) { reinterpret_cast<__IO IDCODE_t*>(&reinterpret_cast<DBGMCU_t*>(STM32::DBGMCU_BASE)->IDCODE)->REV_ID = value; }
  1639.         };
  1640.         class CR
  1641.         {
  1642.         private:
  1643.             union CR_t
  1644.             {
  1645.                 struct
  1646.                 {
  1647.                     uint32_t DBG_SLEEP      : 1;
  1648.                     uint32_t DBG_STOP       : 1;
  1649.                     uint32_t DBG_STANDBY    : 1;
  1650.                     uint32_t reserved3      : 1;
  1651.                     uint32_t reserved4      : 1;
  1652.                     uint32_t TRACE_IOEN     : 1;
  1653.                     uint32_t TRACE_MODE     : 2;
  1654.                     uint32_t reserved8      : 24;
  1655.                 };
  1656.                 uint32_t RAW;
  1657.             };
  1658.         public:
  1659.             enum class EMasks: uint32_t
  1660.             {
  1661.                 DBG_SLEEP              = (0x1U << 0),
  1662.                 DBG_STOP               = (0x1U << 1),
  1663.                 DBG_STANDBY            = (0x1U << 2),
  1664.                 TRACE_IOEN             = (0x1U << 5),
  1665.                 TRACE_MODE             = (0x3U << 6),
  1666.             };
  1667.             static inline uint32_t get() { return reinterpret_cast<DBGMCU_t*>(STM32::DBGMCU_BASE)->CR; }
  1668.             static inline void set(uint32_t value) { reinterpret_cast<DBGMCU_t*>(STM32::DBGMCU_BASE)->CR = value; }
  1669.             template <EMasks ... flags>
  1670.             static inline void set_flags()
  1671.             {
  1672.                 reinterpret_cast<DBGMCU_t*>(STM32::DBGMCU_BASE)->CR |= SetBits<(std::uint32_t)flags...>();
  1673.             }
  1674.             template <EMasks ... flags>
  1675.             static inline void clear_flags()
  1676.             {
  1677.                 reinterpret_cast<DBGMCU_t*>(STM32::DBGMCU_BASE)->CR &= ~(SetBits<(std::uint32_t)flags...>());
  1678.             }
  1679.             template <EMasks ... flags>
  1680.             static inline bool get_flags()
  1681.             {
  1682.                 return ((reinterpret_cast<DBGMCU_t*>(STM32::DBGMCU_BASE)->CR & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  1683.             }
  1684.             static inline uint32_t get_TRACE_MODE() { return reinterpret_cast<__IO CR_t*>(&reinterpret_cast<DBGMCU_t*>(STM32::DBGMCU_BASE)->CR)->TRACE_MODE; }
  1685.             static inline void set_TRACE_MODE(uint32_t value) { reinterpret_cast<__IO CR_t*>(&reinterpret_cast<DBGMCU_t*>(STM32::DBGMCU_BASE)->CR)->TRACE_MODE = value; }
  1686.         };
  1687.         class APB1FZ
  1688.         {
  1689.         private:
  1690.             union APB1FZ_t
  1691.             {
  1692.                 struct
  1693.                 {
  1694.                     uint32_t FZ_DBG_TIM2_STOP: 1;
  1695.                     uint32_t FZ_DBG_TIM3_STOP: 1;
  1696.                     uint32_t FZ_DBG_TIM4_STOP: 1;
  1697.                     uint32_t FZ_DBG_TIM5_STOP: 1;
  1698.                     uint32_t FZ_DBG_TIM6_STOP: 1;
  1699.                     uint32_t FZ_DBG_TIM7_STOP: 1;
  1700.                     uint32_t FZ_DBG_TIM12_STOP: 1;
  1701.                     uint32_t FZ_DBG_TIM13_STOP: 1;
  1702.                     uint32_t FZ_DBG_TIM14_STOP: 1;
  1703.                     uint32_t reserved9      : 1;
  1704.                     uint32_t FZ_DBG_RTC_STOP: 1;
  1705.                     uint32_t FZ_DBG_WWDG_STOP: 1;
  1706.                     uint32_t FZ_DBG_IWDG_STOP: 1;
  1707.                     uint32_t reserved13     : 1;
  1708.                     uint32_t reserved14     : 1;
  1709.                     uint32_t reserved15     : 1;
  1710.                     uint32_t reserved16     : 1;
  1711.                     uint32_t reserved17     : 1;
  1712.                     uint32_t reserved18     : 1;
  1713.                     uint32_t reserved19     : 1;
  1714.                     uint32_t reserved20     : 1;
  1715.                     uint32_t FZ_DBG_I2C1_SMBUS_TIMEOUT: 1;
  1716.                     uint32_t FZ_DBG_I2C2_SMBUS_TIMEOUT: 1;
  1717.                     uint32_t FZ_DBG_I2C3_SMBUS_TIMEOUT: 1;
  1718.                     uint32_t reserved24     : 1;
  1719.                     uint32_t FZ_DBG_CAN1_STOP: 1;
  1720.                     uint32_t FZ_DBG_CAN2_STOP: 1;
  1721.                     uint32_t reserved27     : 5;
  1722.                 };
  1723.                 uint32_t RAW;
  1724.             };
  1725.         public:
  1726.             enum class EMasks: uint32_t
  1727.             {
  1728.                 FZ_DBG_TIM2_STOP       = (0x1U << 0),
  1729.                 FZ_DBG_TIM3_STOP       = (0x1U << 1),
  1730.                 FZ_DBG_TIM4_STOP       = (0x1U << 2),
  1731.                 FZ_DBG_TIM5_STOP       = (0x1U << 3),
  1732.                 FZ_DBG_TIM6_STOP       = (0x1U << 4),
  1733.                 FZ_DBG_TIM7_STOP       = (0x1U << 5),
  1734.                 FZ_DBG_TIM12_STOP      = (0x1U << 6),
  1735.                 FZ_DBG_TIM13_STOP      = (0x1U << 7),
  1736.                 FZ_DBG_TIM14_STOP      = (0x1U << 8),
  1737.                 FZ_DBG_RTC_STOP        = (0x1U << 10),
  1738.                 FZ_DBG_WWDG_STOP       = (0x1U << 11),
  1739.                 FZ_DBG_IWDG_STOP       = (0x1U << 12),
  1740.                 FZ_DBG_I2C1_SMBUS_TIMEOUT = (0x1U << 21),
  1741.                 FZ_DBG_I2C2_SMBUS_TIMEOUT = (0x1U << 22),
  1742.                 FZ_DBG_I2C3_SMBUS_TIMEOUT = (0x1U << 23),
  1743.                 FZ_DBG_CAN1_STOP       = (0x1U << 25),
  1744.                 FZ_DBG_CAN2_STOP       = (0x1U << 26),
  1745.             };
  1746.             static inline uint32_t get() { return reinterpret_cast<DBGMCU_t*>(STM32::DBGMCU_BASE)->APB1FZ; }
  1747.             static inline void set(uint32_t value) { reinterpret_cast<DBGMCU_t*>(STM32::DBGMCU_BASE)->APB1FZ = value; }
  1748.             template <EMasks ... flags>
  1749.             static inline void set_flags()
  1750.             {
  1751.                 reinterpret_cast<DBGMCU_t*>(STM32::DBGMCU_BASE)->APB1FZ |= SetBits<(std::uint32_t)flags...>();
  1752.             }
  1753.             template <EMasks ... flags>
  1754.             static inline void clear_flags()
  1755.             {
  1756.                 reinterpret_cast<DBGMCU_t*>(STM32::DBGMCU_BASE)->APB1FZ &= ~(SetBits<(std::uint32_t)flags...>());
  1757.             }
  1758.             template <EMasks ... flags>
  1759.             static inline bool get_flags()
  1760.             {
  1761.                 return ((reinterpret_cast<DBGMCU_t*>(STM32::DBGMCU_BASE)->APB1FZ & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  1762.             }
  1763.         };
  1764.         class APB2FZ
  1765.         {
  1766.         private:
  1767.             union APB2FZ_t
  1768.             {
  1769.                 struct
  1770.                 {
  1771.                     uint32_t FZ_DBG_TIM1_STOP: 1;
  1772.                     uint32_t FZ_DBG_TIM8_STOP: 1;
  1773.                     uint32_t reserved2      : 1;
  1774.                     uint32_t reserved3      : 1;
  1775.                     uint32_t reserved4      : 1;
  1776.                     uint32_t reserved5      : 1;
  1777.                     uint32_t reserved6      : 1;
  1778.                     uint32_t reserved7      : 1;
  1779.                     uint32_t reserved8      : 1;
  1780.                     uint32_t reserved9      : 1;
  1781.                     uint32_t reserved10     : 1;
  1782.                     uint32_t reserved11     : 1;
  1783.                     uint32_t reserved12     : 1;
  1784.                     uint32_t reserved13     : 1;
  1785.                     uint32_t reserved14     : 1;
  1786.                     uint32_t reserved15     : 1;
  1787.                     uint32_t FZ_DBG_TIM9_STOP: 1;
  1788.                     uint32_t FZ_DBG_TIM10_STOP: 1;
  1789.                     uint32_t FZ_DBG_TIM11_STOP: 1;
  1790.                     uint32_t reserved19     : 13;
  1791.                 };
  1792.                 uint32_t RAW;
  1793.             };
  1794.         public:
  1795.             enum class EMasks: uint32_t
  1796.             {
  1797.                 FZ_DBG_TIM1_STOP       = (0x1U << 0),
  1798.                 FZ_DBG_TIM8_STOP       = (0x1U << 1),
  1799.                 FZ_DBG_TIM9_STOP       = (0x1U << 16),
  1800.                 FZ_DBG_TIM10_STOP      = (0x1U << 17),
  1801.                 FZ_DBG_TIM11_STOP      = (0x1U << 18),
  1802.             };
  1803.             static inline uint32_t get() { return reinterpret_cast<DBGMCU_t*>(STM32::DBGMCU_BASE)->APB2FZ; }
  1804.             static inline void set(uint32_t value) { reinterpret_cast<DBGMCU_t*>(STM32::DBGMCU_BASE)->APB2FZ = value; }
  1805.             template <EMasks ... flags>
  1806.             static inline void set_flags()
  1807.             {
  1808.                 reinterpret_cast<DBGMCU_t*>(STM32::DBGMCU_BASE)->APB2FZ |= SetBits<(std::uint32_t)flags...>();
  1809.             }
  1810.             template <EMasks ... flags>
  1811.             static inline void clear_flags()
  1812.             {
  1813.                 reinterpret_cast<DBGMCU_t*>(STM32::DBGMCU_BASE)->APB2FZ &= ~(SetBits<(std::uint32_t)flags...>());
  1814.             }
  1815.             template <EMasks ... flags>
  1816.             static inline bool get_flags()
  1817.             {
  1818.                 return ((reinterpret_cast<DBGMCU_t*>(STM32::DBGMCU_BASE)->APB2FZ & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  1819.             }
  1820.         };
  1821.     };
  1822.     /* DCMI DEFINITION */
  1823.     class DCMI
  1824.     {
  1825.     private:
  1826.         struct DCMI_t
  1827.         {
  1828.             __IO uint32_t                 CR;
  1829.             __IO uint32_t                 SR;
  1830.             __IO uint32_t                 RISR;
  1831.             __IO uint32_t                 IER;
  1832.             __IO uint32_t                 MISR;
  1833.             __IO uint32_t                 ICR;
  1834.             __IO uint32_t                 ESCR;
  1835.             __IO uint32_t                 ESUR;
  1836.             __IO uint32_t                 CWSTRTR;
  1837.             __IO uint32_t                 CWSIZER;
  1838.             __IO uint32_t                 DR;
  1839.         };
  1840.     public:
  1841.         class CR
  1842.         {
  1843.         private:
  1844.             union CR_t
  1845.             {
  1846.                 struct
  1847.                 {
  1848.                     uint32_t CAPTURE        : 1;
  1849.                     uint32_t CM             : 1;
  1850.                     uint32_t CROP           : 1;
  1851.                     uint32_t JPEG           : 1;
  1852.                     uint32_t ESS            : 1;
  1853.                     uint32_t PCKPOL         : 1;
  1854.                     uint32_t HSPOL          : 1;
  1855.                     uint32_t VSPOL          : 1;
  1856.                     uint32_t reserved8      : 1;
  1857.                     uint32_t reserved9      : 1;
  1858.                     uint32_t reserved10     : 1;
  1859.                     uint32_t reserved11     : 1;
  1860.                     uint32_t CRE            : 1;
  1861.                     uint32_t reserved13     : 1;
  1862.                     uint32_t ENABLE         : 1;
  1863.                     uint32_t reserved15     : 17;
  1864.                 };
  1865.                 uint32_t RAW;
  1866.             };
  1867.         public:
  1868.             enum class EMasks: uint32_t
  1869.             {
  1870.                 CAPTURE                = (0x1U << 0),
  1871.                 CM                     = (0x1U << 1),
  1872.                 CROP                   = (0x1U << 2),
  1873.                 JPEG                   = (0x1U << 3),
  1874.                 ESS                    = (0x1U << 4),
  1875.                 PCKPOL                 = (0x1U << 5),
  1876.                 HSPOL                  = (0x1U << 6),
  1877.                 VSPOL                  = (0x1U << 7),
  1878.                 CRE                    = (0x1U << 12),
  1879.                 ENABLE                 = (0x1U << 14),
  1880.             };
  1881.             static inline uint32_t get() { return reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->CR; }
  1882.             static inline void set(uint32_t value) { reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->CR = value; }
  1883.             template <EMasks ... flags>
  1884.             static inline void set_flags()
  1885.             {
  1886.                 reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->CR |= SetBits<(std::uint32_t)flags...>();
  1887.             }
  1888.             template <EMasks ... flags>
  1889.             static inline void clear_flags()
  1890.             {
  1891.                 reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->CR &= ~(SetBits<(std::uint32_t)flags...>());
  1892.             }
  1893.             template <EMasks ... flags>
  1894.             static inline bool get_flags()
  1895.             {
  1896.                 return ((reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->CR & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  1897.             }
  1898.         };
  1899.         class SR
  1900.         {
  1901.         private:
  1902.             union SR_t
  1903.             {
  1904.                 struct
  1905.                 {
  1906.                     uint32_t HSYNC          : 1;
  1907.                     uint32_t VSYNC          : 1;
  1908.                     uint32_t FNE            : 1;
  1909.                     uint32_t reserved3      : 29;
  1910.                 };
  1911.                 uint32_t RAW;
  1912.             };
  1913.         public:
  1914.             enum class EMasks: uint32_t
  1915.             {
  1916.                 HSYNC                  = (0x1U << 0),
  1917.                 VSYNC                  = (0x1U << 1),
  1918.                 FNE                    = (0x1U << 2),
  1919.             };
  1920.             static inline uint32_t get() { return reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->SR; }
  1921.             static inline void set(uint32_t value) { reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->SR = value; }
  1922.             template <EMasks ... flags>
  1923.             static inline void set_flags()
  1924.             {
  1925.                 reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->SR |= SetBits<(std::uint32_t)flags...>();
  1926.             }
  1927.             template <EMasks ... flags>
  1928.             static inline void clear_flags()
  1929.             {
  1930.                 reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->SR &= ~(SetBits<(std::uint32_t)flags...>());
  1931.             }
  1932.             template <EMasks ... flags>
  1933.             static inline bool get_flags()
  1934.             {
  1935.                 return ((reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->SR & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  1936.             }
  1937.         };
  1938.         class RISR
  1939.         {
  1940.         private:
  1941.             union RISR_t
  1942.             {
  1943.                 struct
  1944.                 {
  1945.                     uint32_t FRAME_RIS      : 1;
  1946.                     uint32_t OVR_RIS        : 1;
  1947.                     uint32_t ERR_RIS        : 1;
  1948.                     uint32_t VSYNC_RIS      : 1;
  1949.                     uint32_t LINE_RIS       : 1;
  1950.                     uint32_t reserved5      : 27;
  1951.                 };
  1952.                 uint32_t RAW;
  1953.             };
  1954.         public:
  1955.             enum class EMasks: uint32_t
  1956.             {
  1957.                 FRAME_RIS              = (0x1U << 0),
  1958.                 OVR_RIS                = (0x1U << 1),
  1959.                 ERR_RIS                = (0x1U << 2),
  1960.                 VSYNC_RIS              = (0x1U << 3),
  1961.                 LINE_RIS               = (0x1U << 4),
  1962.             };
  1963.             static inline uint32_t get() { return reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->RISR; }
  1964.             static inline void set(uint32_t value) { reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->RISR = value; }
  1965.             template <EMasks ... flags>
  1966.             static inline void set_flags()
  1967.             {
  1968.                 reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->RISR |= SetBits<(std::uint32_t)flags...>();
  1969.             }
  1970.             template <EMasks ... flags>
  1971.             static inline void clear_flags()
  1972.             {
  1973.                 reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->RISR &= ~(SetBits<(std::uint32_t)flags...>());
  1974.             }
  1975.             template <EMasks ... flags>
  1976.             static inline bool get_flags()
  1977.             {
  1978.                 return ((reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->RISR & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  1979.             }
  1980.         };
  1981.         class IER
  1982.         {
  1983.         private:
  1984.             union IER_t
  1985.             {
  1986.                 struct
  1987.                 {
  1988.                     uint32_t FRAME_IE       : 1;
  1989.                     uint32_t OVR_IE         : 1;
  1990.                     uint32_t ERR_IE         : 1;
  1991.                     uint32_t VSYNC_IE       : 1;
  1992.                     uint32_t LINE_IE        : 1;
  1993.                     uint32_t reserved5      : 27;
  1994.                 };
  1995.                 uint32_t RAW;
  1996.             };
  1997.         public:
  1998.             enum class EMasks: uint32_t
  1999.             {
  2000.                 FRAME_IE               = (0x1U << 0),
  2001.                 OVR_IE                 = (0x1U << 1),
  2002.                 ERR_IE                 = (0x1U << 2),
  2003.                 VSYNC_IE               = (0x1U << 3),
  2004.                 LINE_IE                = (0x1U << 4),
  2005.             };
  2006.             static inline uint32_t get() { return reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->IER; }
  2007.             static inline void set(uint32_t value) { reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->IER = value; }
  2008.             template <EMasks ... flags>
  2009.             static inline void set_flags()
  2010.             {
  2011.                 reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->IER |= SetBits<(std::uint32_t)flags...>();
  2012.             }
  2013.             template <EMasks ... flags>
  2014.             static inline void clear_flags()
  2015.             {
  2016.                 reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->IER &= ~(SetBits<(std::uint32_t)flags...>());
  2017.             }
  2018.             template <EMasks ... flags>
  2019.             static inline bool get_flags()
  2020.             {
  2021.                 return ((reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->IER & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  2022.             }
  2023.         };
  2024.         class MISR
  2025.         {
  2026.         private:
  2027.             union MISR_t
  2028.             {
  2029.                 struct
  2030.                 {
  2031.                     uint32_t FRAME_MIS      : 1;
  2032.                     uint32_t OVR_MIS        : 1;
  2033.                     uint32_t ERR_MIS        : 1;
  2034.                     uint32_t VSYNC_MIS      : 1;
  2035.                     uint32_t LINE_MIS       : 1;
  2036.                     uint32_t reserved5      : 27;
  2037.                 };
  2038.                 uint32_t RAW;
  2039.             };
  2040.         public:
  2041.             enum class EMasks: uint32_t
  2042.             {
  2043.                 FRAME_MIS              = (0x1U << 0),
  2044.                 OVR_MIS                = (0x1U << 1),
  2045.                 ERR_MIS                = (0x1U << 2),
  2046.                 VSYNC_MIS              = (0x1U << 3),
  2047.                 LINE_MIS               = (0x1U << 4),
  2048.             };
  2049.             static inline uint32_t get() { return reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->MISR; }
  2050.             static inline void set(uint32_t value) { reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->MISR = value; }
  2051.             template <EMasks ... flags>
  2052.             static inline void set_flags()
  2053.             {
  2054.                 reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->MISR |= SetBits<(std::uint32_t)flags...>();
  2055.             }
  2056.             template <EMasks ... flags>
  2057.             static inline void clear_flags()
  2058.             {
  2059.                 reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->MISR &= ~(SetBits<(std::uint32_t)flags...>());
  2060.             }
  2061.             template <EMasks ... flags>
  2062.             static inline bool get_flags()
  2063.             {
  2064.                 return ((reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->MISR & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  2065.             }
  2066.         };
  2067.         class ICR
  2068.         {
  2069.         private:
  2070.             union ICR_t
  2071.             {
  2072.                 struct
  2073.                 {
  2074.                     uint32_t FRAME_ISC      : 1;
  2075.                     uint32_t OVR_ISC        : 1;
  2076.                     uint32_t ERR_ISC        : 1;
  2077.                     uint32_t VSYNC_ISC      : 1;
  2078.                     uint32_t LINE_ISC       : 1;
  2079.                     uint32_t reserved5      : 27;
  2080.                 };
  2081.                 uint32_t RAW;
  2082.             };
  2083.         public:
  2084.             enum class EMasks: uint32_t
  2085.             {
  2086.                 FRAME_ISC              = (0x1U << 0),
  2087.                 OVR_ISC                = (0x1U << 1),
  2088.                 ERR_ISC                = (0x1U << 2),
  2089.                 VSYNC_ISC              = (0x1U << 3),
  2090.                 LINE_ISC               = (0x1U << 4),
  2091.             };
  2092.             static inline uint32_t get() { return reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ICR; }
  2093.             static inline void set(uint32_t value) { reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ICR = value; }
  2094.             template <EMasks ... flags>
  2095.             static inline void set_flags()
  2096.             {
  2097.                 reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ICR |= SetBits<(std::uint32_t)flags...>();
  2098.             }
  2099.             template <EMasks ... flags>
  2100.             static inline void clear_flags()
  2101.             {
  2102.                 reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ICR &= ~(SetBits<(std::uint32_t)flags...>());
  2103.             }
  2104.             template <EMasks ... flags>
  2105.             static inline bool get_flags()
  2106.             {
  2107.                 return ((reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ICR & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  2108.             }
  2109.         };
  2110.         class ESCR
  2111.         {
  2112.         private:
  2113.             union ESCR_t
  2114.             {
  2115.                 struct
  2116.                 {
  2117.                     uint32_t FSC            : 8;
  2118.                     uint32_t LSC            : 8;
  2119.                     uint32_t LEC            : 8;
  2120.                     uint32_t FEC            : 8;
  2121.                 };
  2122.                 uint32_t RAW;
  2123.             };
  2124.         public:
  2125.             enum class EMasks: uint32_t
  2126.             {
  2127.                 FSC                    = (0xFFU << 0),
  2128.                 LSC                    = (0xFFU << 8),
  2129.                 LEC                    = (0xFFU << 16),
  2130.                 FEC                    = (0xFFU << 24),
  2131.             };
  2132.             static inline uint32_t get() { return reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ESCR; }
  2133.             static inline void set(uint32_t value) { reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ESCR = value; }
  2134.             static inline uint32_t get_FSC() { return reinterpret_cast<__IO ESCR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ESCR)->FSC; }
  2135.             static inline void set_FSC(uint32_t value) { reinterpret_cast<__IO ESCR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ESCR)->FSC = value; }
  2136.             static inline uint32_t get_LSC() { return reinterpret_cast<__IO ESCR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ESCR)->LSC; }
  2137.             static inline void set_LSC(uint32_t value) { reinterpret_cast<__IO ESCR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ESCR)->LSC = value; }
  2138.             static inline uint32_t get_LEC() { return reinterpret_cast<__IO ESCR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ESCR)->LEC; }
  2139.             static inline void set_LEC(uint32_t value) { reinterpret_cast<__IO ESCR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ESCR)->LEC = value; }
  2140.             static inline uint32_t get_FEC() { return reinterpret_cast<__IO ESCR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ESCR)->FEC; }
  2141.             static inline void set_FEC(uint32_t value) { reinterpret_cast<__IO ESCR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ESCR)->FEC = value; }
  2142.         };
  2143.         class ESUR
  2144.         {
  2145.         private:
  2146.             union ESUR_t
  2147.             {
  2148.                 struct
  2149.                 {
  2150.                     uint32_t FSU            : 8;
  2151.                     uint32_t LSU            : 8;
  2152.                     uint32_t LEU            : 8;
  2153.                     uint32_t FEU            : 8;
  2154.                 };
  2155.                 uint32_t RAW;
  2156.             };
  2157.         public:
  2158.             enum class EMasks: uint32_t
  2159.             {
  2160.                 FSU                    = (0xFFU << 0),
  2161.                 LSU                    = (0xFFU << 8),
  2162.                 LEU                    = (0xFFU << 16),
  2163.                 FEU                    = (0xFFU << 24),
  2164.             };
  2165.             static inline uint32_t get() { return reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ESUR; }
  2166.             static inline void set(uint32_t value) { reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ESUR = value; }
  2167.             static inline uint32_t get_FSU() { return reinterpret_cast<__IO ESUR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ESUR)->FSU; }
  2168.             static inline void set_FSU(uint32_t value) { reinterpret_cast<__IO ESUR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ESUR)->FSU = value; }
  2169.             static inline uint32_t get_LSU() { return reinterpret_cast<__IO ESUR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ESUR)->LSU; }
  2170.             static inline void set_LSU(uint32_t value) { reinterpret_cast<__IO ESUR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ESUR)->LSU = value; }
  2171.             static inline uint32_t get_LEU() { return reinterpret_cast<__IO ESUR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ESUR)->LEU; }
  2172.             static inline void set_LEU(uint32_t value) { reinterpret_cast<__IO ESUR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ESUR)->LEU = value; }
  2173.             static inline uint32_t get_FEU() { return reinterpret_cast<__IO ESUR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ESUR)->FEU; }
  2174.             static inline void set_FEU(uint32_t value) { reinterpret_cast<__IO ESUR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->ESUR)->FEU = value; }
  2175.         };
  2176.         class CWSTRTR
  2177.         {
  2178.         private:
  2179.             union CWSTRTR_t
  2180.             {
  2181.                 struct
  2182.                 {
  2183.                     uint32_t HOFFCNT        : 14;
  2184.                     uint32_t reserved14     : 1;
  2185.                     uint32_t reserved15     : 1;
  2186.                     uint32_t VST            : 13;
  2187.                     uint32_t reserved29     : 3;
  2188.                 };
  2189.                 uint32_t RAW;
  2190.             };
  2191.         public:
  2192.             enum class EMasks: uint32_t
  2193.             {
  2194.                 HOFFCNT                = (0x3FFFU << 0),
  2195.                 VST                    = (0x1FFFU << 16),
  2196.             };
  2197.             static inline uint32_t get() { return reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->CWSTRTR; }
  2198.             static inline void set(uint32_t value) { reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->CWSTRTR = value; }
  2199.             static inline uint32_t get_HOFFCNT() { return reinterpret_cast<__IO CWSTRTR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->CWSTRTR)->HOFFCNT; }
  2200.             static inline void set_HOFFCNT(uint32_t value) { reinterpret_cast<__IO CWSTRTR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->CWSTRTR)->HOFFCNT = value; }
  2201.             static inline uint32_t get_VST() { return reinterpret_cast<__IO CWSTRTR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->CWSTRTR)->VST; }
  2202.             static inline void set_VST(uint32_t value) { reinterpret_cast<__IO CWSTRTR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->CWSTRTR)->VST = value; }
  2203.         };
  2204.         class CWSIZER
  2205.         {
  2206.         private:
  2207.             union CWSIZER_t
  2208.             {
  2209.                 struct
  2210.                 {
  2211.                     uint32_t CAPCNT         : 14;
  2212.                     uint32_t reserved14     : 1;
  2213.                     uint32_t reserved15     : 1;
  2214.                     uint32_t VLINE          : 14;
  2215.                     uint32_t reserved30     : 2;
  2216.                 };
  2217.                 uint32_t RAW;
  2218.             };
  2219.         public:
  2220.             enum class EMasks: uint32_t
  2221.             {
  2222.                 CAPCNT                 = (0x3FFFU << 0),
  2223.                 VLINE                  = (0x3FFFU << 16),
  2224.             };
  2225.             static inline uint32_t get() { return reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->CWSIZER; }
  2226.             static inline void set(uint32_t value) { reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->CWSIZER = value; }
  2227.             static inline uint32_t get_CAPCNT() { return reinterpret_cast<__IO CWSIZER_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->CWSIZER)->CAPCNT; }
  2228.             static inline void set_CAPCNT(uint32_t value) { reinterpret_cast<__IO CWSIZER_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->CWSIZER)->CAPCNT = value; }
  2229.             static inline uint32_t get_VLINE() { return reinterpret_cast<__IO CWSIZER_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->CWSIZER)->VLINE; }
  2230.             static inline void set_VLINE(uint32_t value) { reinterpret_cast<__IO CWSIZER_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->CWSIZER)->VLINE = value; }
  2231.         };
  2232.         class DR
  2233.         {
  2234.         private:
  2235.             union DR_t
  2236.             {
  2237.                 struct
  2238.                 {
  2239.                     uint32_t BYTE0          : 8;
  2240.                     uint32_t BYTE1          : 8;
  2241.                     uint32_t BYTE2          : 8;
  2242.                     uint32_t BYTE3          : 8;
  2243.                 };
  2244.                 uint32_t RAW;
  2245.             };
  2246.         public:
  2247.             enum class EMasks: uint32_t
  2248.             {
  2249.                 BYTE0                  = (0xFFU << 0),
  2250.                 BYTE1                  = (0xFFU << 8),
  2251.                 BYTE2                  = (0xFFU << 16),
  2252.                 BYTE3                  = (0xFFU << 24),
  2253.             };
  2254.             static inline uint32_t get() { return reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->DR; }
  2255.             static inline void set(uint32_t value) { reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->DR = value; }
  2256.             static inline uint32_t get_BYTE0() { return reinterpret_cast<__IO DR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->DR)->BYTE0; }
  2257.             static inline void set_BYTE0(uint32_t value) { reinterpret_cast<__IO DR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->DR)->BYTE0 = value; }
  2258.             static inline uint32_t get_BYTE1() { return reinterpret_cast<__IO DR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->DR)->BYTE1; }
  2259.             static inline void set_BYTE1(uint32_t value) { reinterpret_cast<__IO DR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->DR)->BYTE1 = value; }
  2260.             static inline uint32_t get_BYTE2() { return reinterpret_cast<__IO DR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->DR)->BYTE2; }
  2261.             static inline void set_BYTE2(uint32_t value) { reinterpret_cast<__IO DR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->DR)->BYTE2 = value; }
  2262.             static inline uint32_t get_BYTE3() { return reinterpret_cast<__IO DR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->DR)->BYTE3; }
  2263.             static inline void set_BYTE3(uint32_t value) { reinterpret_cast<__IO DR_t*>(&reinterpret_cast<DCMI_t*>(STM32::DCMI_BASE)->DR)->BYTE3 = value; }
  2264.         };
  2265.     };
  2266.     /* DMA_Stream DEFINITION */
  2267.     template <uint32_t reg_base>
  2268.     class DMA_Stream
  2269.     {
  2270. #warning TODO: DMA_Stream
  2271.     };
  2272.     /* DMA DEFINITION */
  2273.     template <uint32_t reg_base>
  2274.     class DMA
  2275.     {
  2276. #warning TODO: DMA
  2277.     };
  2278.     /* ETH DEFINITION */
  2279.     class ETH
  2280.     {
  2281.     private:
  2282.         struct ETH_t
  2283.         {
  2284.             __IO uint32_t                 MACCR;
  2285.             __IO uint32_t                 MACFFR;
  2286.             __IO uint32_t                 MACHTHR;
  2287.             __IO uint32_t                 MACHTLR;
  2288.             __IO uint32_t                 MACMIIAR;
  2289.             __IO uint32_t                 MACMIIDR;
  2290.             __IO uint32_t                 MACFCR;
  2291.             __IO uint32_t                 MACVLANTR;
  2292.             uint32_t                      RESERVED0[2];
  2293.             __IO uint32_t                 MACRWUFFR;
  2294.             __IO uint32_t                 MACPMTCSR;
  2295.             uint32_t                      RESERVED1;
  2296.             __IO uint32_t                 MACDBGR;
  2297.             __IO uint32_t                 MACSR;
  2298.             __IO uint32_t                 MACIMR;
  2299.             __IO uint32_t                 MACA0HR;
  2300.             __IO uint32_t                 MACA0LR;
  2301.             __IO uint32_t                 MACA1HR;
  2302.             __IO uint32_t                 MACA1LR;
  2303.             __IO uint32_t                 MACA2HR;
  2304.             __IO uint32_t                 MACA2LR;
  2305.             __IO uint32_t                 MACA3HR;
  2306.             __IO uint32_t                 MACA3LR;
  2307.             uint32_t                      RESERVED2[40];
  2308.             __IO uint32_t                 MMCCR;
  2309.             __IO uint32_t                 MMCRIR;
  2310.             __IO uint32_t                 MMCTIR;
  2311.             __IO uint32_t                 MMCRIMR;
  2312.             __IO uint32_t                 MMCTIMR;
  2313.             uint32_t                      RESERVED3[14];
  2314.             __IO uint32_t                 MMCTGFSCCR;
  2315.             __IO uint32_t                 MMCTGFMSCCR;
  2316.             uint32_t                      RESERVED4[5];
  2317.             __IO uint32_t                 MMCTGFCR;
  2318.             uint32_t                      RESERVED5[10];
  2319.             __IO uint32_t                 MMCRFCECR;
  2320.             __IO uint32_t                 MMCRFAECR;
  2321.             uint32_t                      RESERVED6[10];
  2322.             __IO uint32_t                 MMCRGUFCR;
  2323.             uint32_t                      RESERVED7[334];
  2324.             __IO uint32_t                 PTPTSCR;
  2325.             __IO uint32_t                 PTPSSIR;
  2326.             __IO uint32_t                 PTPTSHR;
  2327.             __IO uint32_t                 PTPTSLR;
  2328.             __IO uint32_t                 PTPTSHUR;
  2329.             __IO uint32_t                 PTPTSLUR;
  2330.             __IO uint32_t                 PTPTSAR;
  2331.             __IO uint32_t                 PTPTTHR;
  2332.             __IO uint32_t                 PTPTTLR;
  2333.             __IO uint32_t                 RESERVED8;
  2334.             __IO uint32_t                 PTPTSSR;
  2335.             uint32_t                      RESERVED9[565];
  2336.             __IO uint32_t                 DMABMR;
  2337.             __IO uint32_t                 DMATPDR;
  2338.             __IO uint32_t                 DMARPDR;
  2339.             __IO uint32_t                 DMARDLAR;
  2340.             __IO uint32_t                 DMATDLAR;
  2341.             __IO uint32_t                 DMASR;
  2342.             __IO uint32_t                 DMAOMR;
  2343.             __IO uint32_t                 DMAIER;
  2344.             __IO uint32_t                 DMAMFBOCR;
  2345.             __IO uint32_t                 DMARSWTR;
  2346.             uint32_t                      RESERVED10[8];
  2347.             __IO uint32_t                 DMACHTDR;
  2348.             __IO uint32_t                 DMACHRDR;
  2349.             __IO uint32_t                 DMACHTBAR;
  2350.             __IO uint32_t                 DMACHRBAR;
  2351.         };
  2352.     public:
  2353.         class MACCR
  2354.         {
  2355.         private:
  2356.             union MACCR_t
  2357.             {
  2358.                 struct
  2359.                 {
  2360.                     uint32_t reserved0      : 1;
  2361.                     uint32_t reserved1      : 1;
  2362.                     uint32_t reserved2      : 1;
  2363.                     uint32_t reserved3      : 1;
  2364.                     uint32_t reserved4      : 1;
  2365.                     uint32_t reserved5      : 1;
  2366.                     uint32_t reserved6      : 1;
  2367.                     uint32_t reserved7      : 1;
  2368.                     uint32_t reserved8      : 1;
  2369.                     uint32_t reserved9      : 1;
  2370.                     uint32_t reserved10     : 1;
  2371.                     uint32_t reserved11     : 1;
  2372.                     uint32_t reserved12     : 1;
  2373.                     uint32_t reserved13     : 1;
  2374.                     uint32_t reserved14     : 1;
  2375.                     uint32_t reserved15     : 1;
  2376.                     uint32_t reserved16     : 1;
  2377.                     uint32_t reserved17     : 1;
  2378.                     uint32_t reserved18     : 1;
  2379.                     uint32_t reserved19     : 1;
  2380.                     uint32_t reserved20     : 1;
  2381.                     uint32_t reserved21     : 1;
  2382.                     uint32_t reserved22     : 1;
  2383.                     uint32_t WD             : 1;
  2384.                     uint32_t JD             : 1;
  2385.                     uint32_t IFG            : 3;
  2386.                     uint32_t CSD            : 1;
  2387.                     uint32_t FES            : 1;
  2388.                     uint32_t ROD            : 1;
  2389.                     uint32_t LM             : 1;
  2390.                     uint32_t DM             : 1;
  2391.                     uint32_t IPCO           : 1;
  2392.                     uint32_t RD             : 1;
  2393.                     uint32_t APCS           : 1;
  2394.                     uint32_t BL             : 2;
  2395.                     uint32_t DC             : 1;
  2396.                     uint32_t TE             : 1;
  2397.                     uint32_t RE             : 1;
  2398.                 };
  2399.                 uint32_t RAW;
  2400.             };
  2401.         public:
  2402.             enum class EMasks: uint32_t
  2403.             {
  2404.                 WD                     = (0x1U << 23),
  2405.                 JD                     = (0x1U << 22),
  2406.                 IFG                    = (0x7U << 17),
  2407.                 CSD                    = (0x1U << 16),
  2408.                 FES                    = (0x1U << 14),
  2409.                 ROD                    = (0x1U << 13),
  2410.                 LM                     = (0x1U << 12),
  2411.                 DM                     = (0x1U << 11),
  2412.                 IPCO                   = (0x1U << 10),
  2413.                 RD                     = (0x1U << 9),
  2414.                 APCS                   = (0x1U << 7),
  2415.                 BL                     = (0x3U << 5),
  2416.                 DC                     = (0x1U << 4),
  2417.                 TE                     = (0x1U << 3),
  2418.                 RE                     = (0x1U << 2),
  2419.             };
  2420.             static inline uint32_t get() { return reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACCR; }
  2421.             static inline void set(uint32_t value) { reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACCR = value; }
  2422.             template <EMasks ... flags>
  2423.             static inline void set_flags()
  2424.             {
  2425.                 reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACCR |= SetBits<(std::uint32_t)flags...>();
  2426.             }
  2427.             template <EMasks ... flags>
  2428.             static inline void clear_flags()
  2429.             {
  2430.                 reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACCR &= ~(SetBits<(std::uint32_t)flags...>());
  2431.             }
  2432.             template <EMasks ... flags>
  2433.             static inline bool get_flags()
  2434.             {
  2435.                 return ((reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACCR & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  2436.             }
  2437.             static inline uint32_t get_IFG() { return reinterpret_cast<__IO MACCR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACCR)->IFG; }
  2438.             static inline void set_IFG(uint32_t value) { reinterpret_cast<__IO MACCR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACCR)->IFG = value; }
  2439.             static inline uint32_t get_BL() { return reinterpret_cast<__IO MACCR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACCR)->BL; }
  2440.             static inline void set_BL(uint32_t value) { reinterpret_cast<__IO MACCR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACCR)->BL = value; }
  2441.         };
  2442.         class MACFFR
  2443.         {
  2444.         private:
  2445.             union MACFFR_t
  2446.             {
  2447.                 struct
  2448.                 {
  2449.                     uint32_t reserved0      : 1;
  2450.                     uint32_t reserved1      : 1;
  2451.                     uint32_t reserved2      : 1;
  2452.                     uint32_t reserved3      : 1;
  2453.                     uint32_t reserved4      : 1;
  2454.                     uint32_t reserved5      : 1;
  2455.                     uint32_t reserved6      : 1;
  2456.                     uint32_t reserved7      : 1;
  2457.                     uint32_t reserved8      : 1;
  2458.                     uint32_t reserved9      : 1;
  2459.                     uint32_t reserved10     : 1;
  2460.                     uint32_t reserved11     : 1;
  2461.                     uint32_t reserved12     : 1;
  2462.                     uint32_t reserved13     : 1;
  2463.                     uint32_t reserved14     : 1;
  2464.                     uint32_t reserved15     : 1;
  2465.                     uint32_t reserved16     : 1;
  2466.                     uint32_t reserved17     : 1;
  2467.                     uint32_t reserved18     : 1;
  2468.                     uint32_t reserved19     : 1;
  2469.                     uint32_t reserved20     : 1;
  2470.                     uint32_t reserved21     : 1;
  2471.                     uint32_t reserved22     : 1;
  2472.                     uint32_t reserved23     : 1;
  2473.                     uint32_t reserved24     : 1;
  2474.                     uint32_t reserved25     : 1;
  2475.                     uint32_t reserved26     : 1;
  2476.                     uint32_t reserved27     : 1;
  2477.                     uint32_t reserved28     : 1;
  2478.                     uint32_t reserved29     : 1;
  2479.                     uint32_t reserved30     : 1;
  2480.                     uint32_t RA             : 1;
  2481.                     uint32_t HPF            : 1;
  2482.                     uint32_t SAF            : 1;
  2483.                     uint32_t SAIF           : 1;
  2484.                     uint32_t PCF            : 2;
  2485.                     uint32_t PCF_BlockAll   : 1;
  2486.                     uint32_t PCF_ForwardAll : 1;
  2487.                     uint32_t PCF_ForwardPassedAddrFilter: 2;
  2488.                     uint32_t BFD            : 1;
  2489.                     uint32_t PAM            : 1;
  2490.                     uint32_t DAIF           : 1;
  2491.                     uint32_t HM             : 1;
  2492.                     uint32_t HU             : 1;
  2493.                     uint32_t PM             : 1;
  2494.                 };
  2495.                 uint32_t RAW;
  2496.             };
  2497.         public:
  2498.             enum class EMasks: uint32_t
  2499.             {
  2500.                 RA                     = (0x1U << 31),
  2501.                 HPF                    = (0x1U << 10),
  2502.                 SAF                    = (0x1U << 9),
  2503.                 SAIF                   = (0x1U << 8),
  2504.                 PCF                    = (0x3U << 6),
  2505.                 PCF_BlockAll           = (0x1U << 6),
  2506.                 PCF_ForwardAll         = (0x1U << 7),
  2507.                 PCF_ForwardPassedAddrFilter = (0x3U << 6),
  2508.                 BFD                    = (0x1U << 5),
  2509.                 PAM                    = (0x1U << 4),
  2510.                 DAIF                   = (0x1U << 3),
  2511.                 HM                     = (0x1U << 2),
  2512.                 HU                     = (0x1U << 1),
  2513.                 PM                     = (0x1U << 0),
  2514.             };
  2515.             static inline uint32_t get() { return reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACFFR; }
  2516.             static inline void set(uint32_t value) { reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACFFR = value; }
  2517.             template <EMasks ... flags>
  2518.             static inline void set_flags()
  2519.             {
  2520.                 reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACFFR |= SetBits<(std::uint32_t)flags...>();
  2521.             }
  2522.             template <EMasks ... flags>
  2523.             static inline void clear_flags()
  2524.             {
  2525.                 reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACFFR &= ~(SetBits<(std::uint32_t)flags...>());
  2526.             }
  2527.             template <EMasks ... flags>
  2528.             static inline bool get_flags()
  2529.             {
  2530.                 return ((reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACFFR & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  2531.             }
  2532.             static inline uint32_t get_PCF() { return reinterpret_cast<__IO MACFFR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACFFR)->PCF; }
  2533.             static inline void set_PCF(uint32_t value) { reinterpret_cast<__IO MACFFR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACFFR)->PCF = value; }
  2534.             static inline uint32_t get_PCF_ForwardPassedAddrFilter() { return reinterpret_cast<__IO MACFFR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACFFR)->PCF_ForwardPassedAddrFilter; }
  2535.             static inline void set_PCF_ForwardPassedAddrFilter(uint32_t value) { reinterpret_cast<__IO MACFFR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACFFR)->PCF_ForwardPassedAddrFilter = value; }
  2536.         };
  2537.         class MACHTHR
  2538.         {
  2539.         private:
  2540.             union MACHTHR_t
  2541.             {
  2542.                 struct
  2543.                 {
  2544.                     uint32_t HTH            : 32;
  2545.                 };
  2546.                 uint32_t RAW;
  2547.             };
  2548.         public:
  2549.             enum class EMasks: uint32_t
  2550.             {
  2551.                 HTH                    = (0xFFFFFFFFU << 0),
  2552.             };
  2553.             static inline uint32_t get() { return reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACHTHR; }
  2554.             static inline void set(uint32_t value) { reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACHTHR = value; }
  2555.             static inline uint32_t get_HTH() { return reinterpret_cast<__IO MACHTHR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACHTHR)->HTH; }
  2556.             static inline void set_HTH(uint32_t value) { reinterpret_cast<__IO MACHTHR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACHTHR)->HTH = value; }
  2557.         };
  2558.         class MACHTLR
  2559.         {
  2560.         private:
  2561.             union MACHTLR_t
  2562.             {
  2563.                 struct
  2564.                 {
  2565.                     uint32_t HTL            : 32;
  2566.                 };
  2567.                 uint32_t RAW;
  2568.             };
  2569.         public:
  2570.             enum class EMasks: uint32_t
  2571.             {
  2572.                 HTL                    = (0xFFFFFFFFU << 0),
  2573.             };
  2574.             static inline uint32_t get() { return reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACHTLR; }
  2575.             static inline void set(uint32_t value) { reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACHTLR = value; }
  2576.             static inline uint32_t get_HTL() { return reinterpret_cast<__IO MACHTLR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACHTLR)->HTL; }
  2577.             static inline void set_HTL(uint32_t value) { reinterpret_cast<__IO MACHTLR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACHTLR)->HTL = value; }
  2578.         };
  2579.         class MACMIIAR
  2580.         {
  2581.         private:
  2582.             union MACMIIAR_t
  2583.             {
  2584.                 struct
  2585.                 {
  2586.                     uint32_t reserved0      : 1;
  2587.                     uint32_t reserved1      : 1;
  2588.                     uint32_t reserved2      : 1;
  2589.                     uint32_t reserved3      : 1;
  2590.                     uint32_t reserved4      : 1;
  2591.                     uint32_t reserved5      : 1;
  2592.                     uint32_t reserved6      : 1;
  2593.                     uint32_t reserved7      : 1;
  2594.                     uint32_t reserved8      : 1;
  2595.                     uint32_t reserved9      : 1;
  2596.                     uint32_t reserved10     : 1;
  2597.                     uint32_t PA             : 5;
  2598.                     uint32_t MR             : 5;
  2599.                     uint32_t CR             : 3;
  2600.                     uint32_t CR_Div62       : 1;
  2601.                     uint32_t CR_Div16       : 1;
  2602.                     uint32_t CR_Div26       : 2;
  2603.                     uint32_t CR_Div102      : 1;
  2604.                     uint32_t MW             : 1;
  2605.                     uint32_t MB             : 1;
  2606.                     uint32_t reserved31     : 1;
  2607.                 };
  2608.                 uint32_t RAW;
  2609.             };
  2610.         public:
  2611.             enum class EMasks: uint32_t
  2612.             {
  2613.                 PA                     = (0x1FU << 11),
  2614.                 MR                     = (0x1FU << 6),
  2615.                 CR                     = (0x7U << 2),
  2616.                 CR_Div62               = (0x1U << 2),
  2617.                 CR_Div16               = (0x1U << 3),
  2618.                 CR_Div26               = (0x3U << 2),
  2619.                 CR_Div102              = (0x1U << 4),
  2620.                 MW                     = (0x1U << 1),
  2621.                 MB                     = (0x1U << 0),
  2622.             };
  2623.             static inline uint32_t get() { return reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACMIIAR; }
  2624.             static inline void set(uint32_t value) { reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACMIIAR = value; }
  2625.             template <EMasks ... flags>
  2626.             static inline void set_flags()
  2627.             {
  2628.                 reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACMIIAR |= SetBits<(std::uint32_t)flags...>();
  2629.             }
  2630.             template <EMasks ... flags>
  2631.             static inline void clear_flags()
  2632.             {
  2633.                 reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACMIIAR &= ~(SetBits<(std::uint32_t)flags...>());
  2634.             }
  2635.             template <EMasks ... flags>
  2636.             static inline bool get_flags()
  2637.             {
  2638.                 return ((reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACMIIAR & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  2639.             }
  2640.             static inline uint32_t get_PA() { return reinterpret_cast<__IO MACMIIAR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACMIIAR)->PA; }
  2641.             static inline void set_PA(uint32_t value) { reinterpret_cast<__IO MACMIIAR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACMIIAR)->PA = value; }
  2642.             static inline uint32_t get_MR() { return reinterpret_cast<__IO MACMIIAR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACMIIAR)->MR; }
  2643.             static inline void set_MR(uint32_t value) { reinterpret_cast<__IO MACMIIAR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACMIIAR)->MR = value; }
  2644.             static inline uint32_t get_CR() { return reinterpret_cast<__IO MACMIIAR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACMIIAR)->CR; }
  2645.             static inline void set_CR(uint32_t value) { reinterpret_cast<__IO MACMIIAR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACMIIAR)->CR = value; }
  2646.             static inline uint32_t get_CR_Div26() { return reinterpret_cast<__IO MACMIIAR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACMIIAR)->CR_Div26; }
  2647.             static inline void set_CR_Div26(uint32_t value) { reinterpret_cast<__IO MACMIIAR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACMIIAR)->CR_Div26 = value; }
  2648.         };
  2649.         class MACMIIDR
  2650.         {
  2651.         private:
  2652.             union MACMIIDR_t
  2653.             {
  2654.                 struct
  2655.                 {
  2656.                     uint32_t MD             : 16;
  2657.                     uint32_t reserved16     : 16;
  2658.                 };
  2659.                 uint32_t RAW;
  2660.             };
  2661.         public:
  2662.             enum class EMasks: uint32_t
  2663.             {
  2664.                 MD                     = (0xFFFFU << 0),
  2665.             };
  2666.             static inline uint32_t get() { return reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACMIIDR; }
  2667.             static inline void set(uint32_t value) { reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACMIIDR = value; }
  2668.             static inline uint32_t get_MD() { return reinterpret_cast<__IO MACMIIDR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACMIIDR)->MD; }
  2669.             static inline void set_MD(uint32_t value) { reinterpret_cast<__IO MACMIIDR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACMIIDR)->MD = value; }
  2670.         };
  2671.         class MACFCR
  2672.         {
  2673.         private:
  2674.             union MACFCR_t
  2675.             {
  2676.                 struct
  2677.                 {
  2678.                     uint32_t reserved0      : 1;
  2679.                     uint32_t reserved1      : 1;
  2680.                     uint32_t reserved2      : 1;
  2681.                     uint32_t reserved3      : 1;
  2682.                     uint32_t reserved4      : 1;
  2683.                     uint32_t reserved5      : 1;
  2684.                     uint32_t reserved6      : 1;
  2685.                     uint32_t reserved7      : 1;
  2686.                     uint32_t reserved8      : 1;
  2687.                     uint32_t reserved9      : 1;
  2688.                     uint32_t reserved10     : 1;
  2689.                     uint32_t reserved11     : 1;
  2690.                     uint32_t reserved12     : 1;
  2691.                     uint32_t reserved13     : 1;
  2692.                     uint32_t reserved14     : 1;
  2693.                     uint32_t reserved15     : 1;
  2694.                     uint32_t PT             : 16;
  2695.                     uint32_t ZQPD           : 1;
  2696.                     uint32_t PLT            : 2;
  2697.                     uint32_t PLT_Minus28    : 1;
  2698.                     uint32_t PLT_Minus144   : 1;
  2699.                     uint32_t PLT_Minus256   : 2;
  2700.                     uint32_t UPFD           : 1;
  2701.                     uint32_t RFCE           : 1;
  2702.                     uint32_t TFCE           : 1;
  2703.                     uint32_t FCBBPA         : 1;
  2704.                 };
  2705.                 uint32_t RAW;
  2706.             };
  2707.         public:
  2708.             enum class EMasks: uint32_t
  2709.             {
  2710.                 PT                     = (0xFFFFU << 16),
  2711.                 ZQPD                   = (0x1U << 7),
  2712.                 PLT                    = (0x3U << 4),
  2713.                 PLT_Minus28            = (0x1U << 4),
  2714.                 PLT_Minus144           = (0x1U << 5),
  2715.                 PLT_Minus256           = (0x3U << 4),
  2716.                 UPFD                   = (0x1U << 3),
  2717.                 RFCE                   = (0x1U << 2),
  2718.                 TFCE                   = (0x1U << 1),
  2719.                 FCBBPA                 = (0x1U << 0),
  2720.             };
  2721.             static inline uint32_t get() { return reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACFCR; }
  2722.             static inline void set(uint32_t value) { reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACFCR = value; }
  2723.             template <EMasks ... flags>
  2724.             static inline void set_flags()
  2725.             {
  2726.                 reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACFCR |= SetBits<(std::uint32_t)flags...>();
  2727.             }
  2728.             template <EMasks ... flags>
  2729.             static inline void clear_flags()
  2730.             {
  2731.                 reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACFCR &= ~(SetBits<(std::uint32_t)flags...>());
  2732.             }
  2733.             template <EMasks ... flags>
  2734.             static inline bool get_flags()
  2735.             {
  2736.                 return ((reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACFCR & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  2737.             }
  2738.             static inline uint32_t get_PT() { return reinterpret_cast<__IO MACFCR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACFCR)->PT; }
  2739.             static inline void set_PT(uint32_t value) { reinterpret_cast<__IO MACFCR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACFCR)->PT = value; }
  2740.             static inline uint32_t get_PLT() { return reinterpret_cast<__IO MACFCR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACFCR)->PLT; }
  2741.             static inline void set_PLT(uint32_t value) { reinterpret_cast<__IO MACFCR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACFCR)->PLT = value; }
  2742.             static inline uint32_t get_PLT_Minus256() { return reinterpret_cast<__IO MACFCR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACFCR)->PLT_Minus256; }
  2743.             static inline void set_PLT_Minus256(uint32_t value) { reinterpret_cast<__IO MACFCR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACFCR)->PLT_Minus256 = value; }
  2744.         };
  2745.         class MACVLANTR
  2746.         {
  2747.         private:
  2748.             union MACVLANTR_t
  2749.             {
  2750.                 struct
  2751.                 {
  2752.                     uint32_t reserved0      : 1;
  2753.                     uint32_t reserved1      : 1;
  2754.                     uint32_t reserved2      : 1;
  2755.                     uint32_t reserved3      : 1;
  2756.                     uint32_t reserved4      : 1;
  2757.                     uint32_t reserved5      : 1;
  2758.                     uint32_t reserved6      : 1;
  2759.                     uint32_t reserved7      : 1;
  2760.                     uint32_t reserved8      : 1;
  2761.                     uint32_t reserved9      : 1;
  2762.                     uint32_t reserved10     : 1;
  2763.                     uint32_t reserved11     : 1;
  2764.                     uint32_t reserved12     : 1;
  2765.                     uint32_t reserved13     : 1;
  2766.                     uint32_t reserved14     : 1;
  2767.                     uint32_t reserved15     : 1;
  2768.                     uint32_t VLANTC         : 1;
  2769.                     uint32_t VLANTI         : 16;
  2770.                 };
  2771.                 uint32_t RAW;
  2772.             };
  2773.         public:
  2774.             enum class EMasks: uint32_t
  2775.             {
  2776.                 VLANTC                 = (0x1U << 16),
  2777.                 VLANTI                 = (0xFFFFU << 0),
  2778.             };
  2779.             static inline uint32_t get() { return reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACVLANTR; }
  2780.             static inline void set(uint32_t value) { reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACVLANTR = value; }
  2781.             template <EMasks ... flags>
  2782.             static inline void set_flags()
  2783.             {
  2784.                 reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACVLANTR |= SetBits<(std::uint32_t)flags...>();
  2785.             }
  2786.             template <EMasks ... flags>
  2787.             static inline void clear_flags()
  2788.             {
  2789.                 reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACVLANTR &= ~(SetBits<(std::uint32_t)flags...>());
  2790.             }
  2791.             template <EMasks ... flags>
  2792.             static inline bool get_flags()
  2793.             {
  2794.                 return ((reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACVLANTR & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  2795.             }
  2796.             static inline uint32_t get_VLANTI() { return reinterpret_cast<__IO MACVLANTR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACVLANTR)->VLANTI; }
  2797.             static inline void set_VLANTI(uint32_t value) { reinterpret_cast<__IO MACVLANTR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACVLANTR)->VLANTI = value; }
  2798.         };
  2799.         class MACRWUFFR
  2800.         {
  2801.         private:
  2802.             union MACRWUFFR_t
  2803.             {
  2804.                 struct
  2805.                 {
  2806.                     uint32_t D              : 32;
  2807.                 };
  2808.                 uint32_t RAW;
  2809.             };
  2810.         public:
  2811.             enum class EMasks: uint32_t
  2812.             {
  2813.                 D                      = (0xFFFFFFFFU << 0),
  2814.             };
  2815.             static inline uint32_t get() { return reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACRWUFFR; }
  2816.             static inline void set(uint32_t value) { reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACRWUFFR = value; }
  2817.             static inline uint32_t get_D() { return reinterpret_cast<__IO MACRWUFFR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACRWUFFR)->D; }
  2818.             static inline void set_D(uint32_t value) { reinterpret_cast<__IO MACRWUFFR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACRWUFFR)->D = value; }
  2819.         };
  2820.         class MACPMTCSR
  2821.         {
  2822.         private:
  2823.             union MACPMTCSR_t
  2824.             {
  2825.                 struct
  2826.                 {
  2827.                     uint32_t reserved0      : 1;
  2828.                     uint32_t reserved1      : 1;
  2829.                     uint32_t reserved2      : 1;
  2830.                     uint32_t reserved3      : 1;
  2831.                     uint32_t reserved4      : 1;
  2832.                     uint32_t reserved5      : 1;
  2833.                     uint32_t reserved6      : 1;
  2834.                     uint32_t reserved7      : 1;
  2835.                     uint32_t reserved8      : 1;
  2836.                     uint32_t reserved9      : 1;
  2837.                     uint32_t reserved10     : 1;
  2838.                     uint32_t reserved11     : 1;
  2839.                     uint32_t reserved12     : 1;
  2840.                     uint32_t reserved13     : 1;
  2841.                     uint32_t reserved14     : 1;
  2842.                     uint32_t reserved15     : 1;
  2843.                     uint32_t reserved16     : 1;
  2844.                     uint32_t reserved17     : 1;
  2845.                     uint32_t reserved18     : 1;
  2846.                     uint32_t reserved19     : 1;
  2847.                     uint32_t reserved20     : 1;
  2848.                     uint32_t reserved21     : 1;
  2849.                     uint32_t reserved22     : 1;
  2850.                     uint32_t reserved23     : 1;
  2851.                     uint32_t reserved24     : 1;
  2852.                     uint32_t reserved25     : 1;
  2853.                     uint32_t reserved26     : 1;
  2854.                     uint32_t reserved27     : 1;
  2855.                     uint32_t reserved28     : 1;
  2856.                     uint32_t reserved29     : 1;
  2857.                     uint32_t reserved30     : 1;
  2858.                     uint32_t WFFRPR         : 1;
  2859.                     uint32_t GU             : 1;
  2860.                     uint32_t WFR            : 1;
  2861.                     uint32_t MPR            : 1;
  2862.                     uint32_t WFE            : 1;
  2863.                     uint32_t MPE            : 1;
  2864.                     uint32_t PD             : 1;
  2865.                 };
  2866.                 uint32_t RAW;
  2867.             };
  2868.         public:
  2869.             enum class EMasks: uint32_t
  2870.             {
  2871.                 WFFRPR                 = (0x1U << 31),
  2872.                 GU                     = (0x1U << 9),
  2873.                 WFR                    = (0x1U << 6),
  2874.                 MPR                    = (0x1U << 5),
  2875.                 WFE                    = (0x1U << 2),
  2876.                 MPE                    = (0x1U << 1),
  2877.                 PD                     = (0x1U << 0),
  2878.             };
  2879.             static inline uint32_t get() { return reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACPMTCSR; }
  2880.             static inline void set(uint32_t value) { reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACPMTCSR = value; }
  2881.             template <EMasks ... flags>
  2882.             static inline void set_flags()
  2883.             {
  2884.                 reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACPMTCSR |= SetBits<(std::uint32_t)flags...>();
  2885.             }
  2886.             template <EMasks ... flags>
  2887.             static inline void clear_flags()
  2888.             {
  2889.                 reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACPMTCSR &= ~(SetBits<(std::uint32_t)flags...>());
  2890.             }
  2891.             template <EMasks ... flags>
  2892.             static inline bool get_flags()
  2893.             {
  2894.                 return ((reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACPMTCSR & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  2895.             }
  2896.         };
  2897.         class MACDBGR
  2898.         {
  2899.         private:
  2900.             union MACDBGR_t
  2901.             {
  2902.                 struct
  2903.                 {
  2904.                     uint32_t reserved0      : 1;
  2905.                     uint32_t reserved1      : 1;
  2906.                     uint32_t reserved2      : 1;
  2907.                     uint32_t reserved3      : 1;
  2908.                     uint32_t reserved4      : 1;
  2909.                     uint32_t reserved5      : 1;
  2910.                     uint32_t reserved6      : 1;
  2911.                     uint32_t reserved7      : 1;
  2912.                     uint32_t reserved8      : 1;
  2913.                     uint32_t reserved9      : 1;
  2914.                     uint32_t reserved10     : 1;
  2915.                     uint32_t reserved11     : 1;
  2916.                     uint32_t reserved12     : 1;
  2917.                     uint32_t reserved13     : 1;
  2918.                     uint32_t reserved14     : 1;
  2919.                     uint32_t reserved15     : 1;
  2920.                     uint32_t reserved16     : 1;
  2921.                     uint32_t reserved17     : 1;
  2922.                     uint32_t reserved18     : 1;
  2923.                     uint32_t reserved19     : 1;
  2924.                     uint32_t reserved20     : 1;
  2925.                     uint32_t reserved21     : 1;
  2926.                     uint32_t reserved22     : 1;
  2927.                     uint32_t reserved23     : 1;
  2928.                     uint32_t reserved24     : 1;
  2929.                     uint32_t TFF            : 1;
  2930.                     uint32_t TFNE           : 1;
  2931.                     uint32_t TFWA           : 1;
  2932.                     uint32_t TFRS           : 2;
  2933.                     uint32_t TFRS_WRITING   : 2;
  2934.                     uint32_t TFRS_WAITING   : 1;
  2935.                     uint32_t TFRS_READ      : 1;
  2936.                     uint32_t MTP            : 1;
  2937.                     uint32_t MTFCS          : 2;
  2938.                     uint32_t MTFCS_TRANSFERRING: 2;
  2939.                     uint32_t MTFCS_GENERATINGPCF: 1;
  2940.                     uint32_t MTFCS_WAITING  : 1;
  2941.                     uint32_t MMTEA          : 1;
  2942.                     uint32_t RFFL           : 2;
  2943.                     uint32_t RFFL_FULL      : 2;
  2944.                     uint32_t RFFL_ABOVEFCT  : 1;
  2945.                     uint32_t RFFL_BELOWFCT  : 1;
  2946.                     uint32_t RFRCS          : 2;
  2947.                     uint32_t RFRCS_FLUSHING : 2;
  2948.                     uint32_t RFRCS_STATUSREADING: 1;
  2949.                     uint32_t RFRCS_DATAREADING: 1;
  2950.                     uint32_t RFWRA          : 1;
  2951.                     uint32_t MSFRWCS        : 2;
  2952.                     uint32_t MMRPEA         : 1;
  2953.                 };
  2954.                 uint32_t RAW;
  2955.             };
  2956.         public:
  2957.             enum class EMasks: uint32_t
  2958.             {
  2959.                 TFF                    = (0x1U << 25),
  2960.                 TFNE                   = (0x1U << 24),
  2961.                 TFWA                   = (0x1U << 22),
  2962.                 TFRS                   = (0x3U << 20),
  2963.                 TFRS_WRITING           = (0x3U << 20),
  2964.                 TFRS_WAITING           = (0x1U << 21),
  2965.                 TFRS_READ              = (0x1U << 20),
  2966.                 MTP                    = (0x1U << 19),
  2967.                 MTFCS                  = (0x3U << 17),
  2968.                 MTFCS_TRANSFERRING     = (0x3U << 17),
  2969.                 MTFCS_GENERATINGPCF    = (0x1U << 18),
  2970.                 MTFCS_WAITING          = (0x1U << 17),
  2971.                 MMTEA                  = (0x1U << 16),
  2972.                 RFFL                   = (0x3U << 8),
  2973.                 RFFL_FULL              = (0x3U << 8),
  2974.                 RFFL_ABOVEFCT          = (0x1U << 9),
  2975.                 RFFL_BELOWFCT          = (0x1U << 8),
  2976.                 RFRCS                  = (0x3U << 5),
  2977.                 RFRCS_FLUSHING         = (0x3U << 5),
  2978.                 RFRCS_STATUSREADING    = (0x1U << 6),
  2979.                 RFRCS_DATAREADING      = (0x1U << 5),
  2980.                 RFWRA                  = (0x1U << 4),
  2981.                 MSFRWCS                = (0x3U << 1),
  2982.                 MMRPEA                 = (0x1U << 0),
  2983.             };
  2984.             static inline uint32_t get() { return reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACDBGR; }
  2985.             static inline void set(uint32_t value) { reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACDBGR = value; }
  2986.             template <EMasks ... flags>
  2987.             static inline void set_flags()
  2988.             {
  2989.                 reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACDBGR |= SetBits<(std::uint32_t)flags...>();
  2990.             }
  2991.             template <EMasks ... flags>
  2992.             static inline void clear_flags()
  2993.             {
  2994.                 reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACDBGR &= ~(SetBits<(std::uint32_t)flags...>());
  2995.             }
  2996.             template <EMasks ... flags>
  2997.             static inline bool get_flags()
  2998.             {
  2999.                 return ((reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACDBGR & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  3000.             }
  3001.             static inline uint32_t get_TFRS() { return reinterpret_cast<__IO MACDBGR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACDBGR)->TFRS; }
  3002.             static inline void set_TFRS(uint32_t value) { reinterpret_cast<__IO MACDBGR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACDBGR)->TFRS = value; }
  3003.             static inline uint32_t get_TFRS_WRITING() { return reinterpret_cast<__IO MACDBGR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACDBGR)->TFRS_WRITING; }
  3004.             static inline void set_TFRS_WRITING(uint32_t value) { reinterpret_cast<__IO MACDBGR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACDBGR)->TFRS_WRITING = value; }
  3005.             static inline uint32_t get_MTFCS() { return reinterpret_cast<__IO MACDBGR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACDBGR)->MTFCS; }
  3006.             static inline void set_MTFCS(uint32_t value) { reinterpret_cast<__IO MACDBGR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACDBGR)->MTFCS = value; }
  3007.             static inline uint32_t get_MTFCS_TRANSFERRING() { return reinterpret_cast<__IO MACDBGR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACDBGR)->MTFCS_TRANSFERRING; }
  3008.             static inline void set_MTFCS_TRANSFERRING(uint32_t value) { reinterpret_cast<__IO MACDBGR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACDBGR)->MTFCS_TRANSFERRING = value; }
  3009.             static inline uint32_t get_RFFL() { return reinterpret_cast<__IO MACDBGR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACDBGR)->RFFL; }
  3010.             static inline void set_RFFL(uint32_t value) { reinterpret_cast<__IO MACDBGR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACDBGR)->RFFL = value; }
  3011.             static inline uint32_t get_RFFL_FULL() { return reinterpret_cast<__IO MACDBGR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACDBGR)->RFFL_FULL; }
  3012.             static inline void set_RFFL_FULL(uint32_t value) { reinterpret_cast<__IO MACDBGR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACDBGR)->RFFL_FULL = value; }
  3013.             static inline uint32_t get_RFRCS() { return reinterpret_cast<__IO MACDBGR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACDBGR)->RFRCS; }
  3014.             static inline void set_RFRCS(uint32_t value) { reinterpret_cast<__IO MACDBGR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACDBGR)->RFRCS = value; }
  3015.             static inline uint32_t get_RFRCS_FLUSHING() { return reinterpret_cast<__IO MACDBGR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACDBGR)->RFRCS_FLUSHING; }
  3016.             static inline void set_RFRCS_FLUSHING(uint32_t value) { reinterpret_cast<__IO MACDBGR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACDBGR)->RFRCS_FLUSHING = value; }
  3017.             static inline uint32_t get_MSFRWCS() { return reinterpret_cast<__IO MACDBGR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACDBGR)->MSFRWCS; }
  3018.             static inline void set_MSFRWCS(uint32_t value) { reinterpret_cast<__IO MACDBGR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACDBGR)->MSFRWCS = value; }
  3019.         };
  3020.         class MACSR
  3021.         {
  3022.         private:
  3023.             union MACSR_t
  3024.             {
  3025.                 struct
  3026.                 {
  3027.                     uint32_t reserved0      : 1;
  3028.                     uint32_t reserved1      : 1;
  3029.                     uint32_t reserved2      : 1;
  3030.                     uint32_t reserved3      : 1;
  3031.                     uint32_t reserved4      : 1;
  3032.                     uint32_t reserved5      : 1;
  3033.                     uint32_t reserved6      : 1;
  3034.                     uint32_t reserved7      : 1;
  3035.                     uint32_t reserved8      : 1;
  3036.                     uint32_t TSTS           : 1;
  3037.                     uint32_t MMCTS          : 1;
  3038.                     uint32_t MMMCRS         : 1;
  3039.                     uint32_t MMCS           : 1;
  3040.                     uint32_t PMTS           : 1;
  3041.                     uint32_t reserved14     : 18;
  3042.                 };
  3043.                 uint32_t RAW;
  3044.             };
  3045.         public:
  3046.             enum class EMasks: uint32_t
  3047.             {
  3048.                 TSTS                   = (0x1U << 9),
  3049.                 MMCTS                  = (0x1U << 6),
  3050.                 MMMCRS                 = (0x1U << 5),
  3051.                 MMCS                   = (0x1U << 4),
  3052.                 PMTS                   = (0x1U << 3),
  3053.             };
  3054.             static inline uint32_t get() { return reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACSR; }
  3055.             static inline void set(uint32_t value) { reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACSR = value; }
  3056.             template <EMasks ... flags>
  3057.             static inline void set_flags()
  3058.             {
  3059.                 reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACSR |= SetBits<(std::uint32_t)flags...>();
  3060.             }
  3061.             template <EMasks ... flags>
  3062.             static inline void clear_flags()
  3063.             {
  3064.                 reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACSR &= ~(SetBits<(std::uint32_t)flags...>());
  3065.             }
  3066.             template <EMasks ... flags>
  3067.             static inline bool get_flags()
  3068.             {
  3069.                 return ((reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACSR & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  3070.             }
  3071.         };
  3072.         class MACIMR
  3073.         {
  3074.         private:
  3075.             union MACIMR_t
  3076.             {
  3077.                 struct
  3078.                 {
  3079.                     uint32_t reserved0      : 1;
  3080.                     uint32_t reserved1      : 1;
  3081.                     uint32_t reserved2      : 1;
  3082.                     uint32_t reserved3      : 1;
  3083.                     uint32_t reserved4      : 1;
  3084.                     uint32_t reserved5      : 1;
  3085.                     uint32_t reserved6      : 1;
  3086.                     uint32_t reserved7      : 1;
  3087.                     uint32_t reserved8      : 1;
  3088.                     uint32_t TSTIM          : 1;
  3089.                     uint32_t PMTIM          : 1;
  3090.                     uint32_t reserved11     : 21;
  3091.                 };
  3092.                 uint32_t RAW;
  3093.             };
  3094.         public:
  3095.             enum class EMasks: uint32_t
  3096.             {
  3097.                 TSTIM                  = (0x1U << 9),
  3098.                 PMTIM                  = (0x1U << 3),
  3099.             };
  3100.             static inline uint32_t get() { return reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACIMR; }
  3101.             static inline void set(uint32_t value) { reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACIMR = value; }
  3102.             template <EMasks ... flags>
  3103.             static inline void set_flags()
  3104.             {
  3105.                 reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACIMR |= SetBits<(std::uint32_t)flags...>();
  3106.             }
  3107.             template <EMasks ... flags>
  3108.             static inline void clear_flags()
  3109.             {
  3110.                 reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACIMR &= ~(SetBits<(std::uint32_t)flags...>());
  3111.             }
  3112.             template <EMasks ... flags>
  3113.             static inline bool get_flags()
  3114.             {
  3115.                 return ((reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACIMR & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  3116.             }
  3117.         };
  3118.         class MACA0HR
  3119.         {
  3120.         private:
  3121.             union MACA0HR_t
  3122.             {
  3123.                 struct
  3124.                 {
  3125.                     uint32_t MACA0H         : 16;
  3126.                     uint32_t reserved16     : 16;
  3127.                 };
  3128.                 uint32_t RAW;
  3129.             };
  3130.         public:
  3131.             enum class EMasks: uint32_t
  3132.             {
  3133.                 MACA0H                 = (0xFFFFU << 0),
  3134.             };
  3135.             static inline uint32_t get() { return reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA0HR; }
  3136.             static inline void set(uint32_t value) { reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA0HR = value; }
  3137.             static inline uint32_t get_MACA0H() { return reinterpret_cast<__IO MACA0HR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA0HR)->MACA0H; }
  3138.             static inline void set_MACA0H(uint32_t value) { reinterpret_cast<__IO MACA0HR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA0HR)->MACA0H = value; }
  3139.         };
  3140.         class MACA0LR
  3141.         {
  3142.         private:
  3143.             union MACA0LR_t
  3144.             {
  3145.                 struct
  3146.                 {
  3147.                     uint32_t MACA0L         : 32;
  3148.                 };
  3149.                 uint32_t RAW;
  3150.             };
  3151.         public:
  3152.             enum class EMasks: uint32_t
  3153.             {
  3154.                 MACA0L                 = (0xFFFFFFFFU << 0),
  3155.             };
  3156.             static inline uint32_t get() { return reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA0LR; }
  3157.             static inline void set(uint32_t value) { reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA0LR = value; }
  3158.             static inline uint32_t get_MACA0L() { return reinterpret_cast<__IO MACA0LR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA0LR)->MACA0L; }
  3159.             static inline void set_MACA0L(uint32_t value) { reinterpret_cast<__IO MACA0LR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA0LR)->MACA0L = value; }
  3160.         };
  3161.         class MACA1HR
  3162.         {
  3163.         private:
  3164.             union MACA1HR_t
  3165.             {
  3166.                 struct
  3167.                 {
  3168.                     uint32_t reserved0      : 1;
  3169.                     uint32_t reserved1      : 1;
  3170.                     uint32_t reserved2      : 1;
  3171.                     uint32_t reserved3      : 1;
  3172.                     uint32_t reserved4      : 1;
  3173.                     uint32_t reserved5      : 1;
  3174.                     uint32_t reserved6      : 1;
  3175.                     uint32_t reserved7      : 1;
  3176.                     uint32_t reserved8      : 1;
  3177.                     uint32_t reserved9      : 1;
  3178.                     uint32_t reserved10     : 1;
  3179.                     uint32_t reserved11     : 1;
  3180.                     uint32_t reserved12     : 1;
  3181.                     uint32_t reserved13     : 1;
  3182.                     uint32_t reserved14     : 1;
  3183.                     uint32_t reserved15     : 1;
  3184.                     uint32_t reserved16     : 1;
  3185.                     uint32_t reserved17     : 1;
  3186.                     uint32_t reserved18     : 1;
  3187.                     uint32_t reserved19     : 1;
  3188.                     uint32_t reserved20     : 1;
  3189.                     uint32_t reserved21     : 1;
  3190.                     uint32_t reserved22     : 1;
  3191.                     uint32_t reserved23     : 1;
  3192.                     uint32_t reserved24     : 1;
  3193.                     uint32_t reserved25     : 1;
  3194.                     uint32_t reserved26     : 1;
  3195.                     uint32_t reserved27     : 1;
  3196.                     uint32_t reserved28     : 1;
  3197.                     uint32_t reserved29     : 1;
  3198.                     uint32_t reserved30     : 1;
  3199.                     uint32_t AE             : 1;
  3200.                     uint32_t SA             : 1;
  3201.                     uint32_t MBC            : 6;
  3202.                     uint32_t MACA1H         : 16;
  3203.                 };
  3204.                 uint32_t RAW;
  3205.             };
  3206.         public:
  3207.             enum class EMasks: uint32_t
  3208.             {
  3209.                 AE                     = (0x1U << 31),
  3210.                 SA                     = (0x1U << 30),
  3211.                 MBC                    = (0x3FU << 24),
  3212.                 MACA1H                 = (0xFFFFU << 0),
  3213.             };
  3214.             static inline uint32_t get() { return reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA1HR; }
  3215.             static inline void set(uint32_t value) { reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA1HR = value; }
  3216.             template <EMasks ... flags>
  3217.             static inline void set_flags()
  3218.             {
  3219.                 reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA1HR |= SetBits<(std::uint32_t)flags...>();
  3220.             }
  3221.             template <EMasks ... flags>
  3222.             static inline void clear_flags()
  3223.             {
  3224.                 reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA1HR &= ~(SetBits<(std::uint32_t)flags...>());
  3225.             }
  3226.             template <EMasks ... flags>
  3227.             static inline bool get_flags()
  3228.             {
  3229.                 return ((reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA1HR & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  3230.             }
  3231.             static inline uint32_t get_MBC() { return reinterpret_cast<__IO MACA1HR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA1HR)->MBC; }
  3232.             static inline void set_MBC(uint32_t value) { reinterpret_cast<__IO MACA1HR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA1HR)->MBC = value; }
  3233.             static inline uint32_t get_MACA1H() { return reinterpret_cast<__IO MACA1HR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA1HR)->MACA1H; }
  3234.             static inline void set_MACA1H(uint32_t value) { reinterpret_cast<__IO MACA1HR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA1HR)->MACA1H = value; }
  3235.         };
  3236.         class MACA1LR
  3237.         {
  3238.         private:
  3239.             union MACA1LR_t
  3240.             {
  3241.                 struct
  3242.                 {
  3243.                     uint32_t MACA1L         : 32;
  3244.                 };
  3245.                 uint32_t RAW;
  3246.             };
  3247.         public:
  3248.             enum class EMasks: uint32_t
  3249.             {
  3250.                 MACA1L                 = (0xFFFFFFFFU << 0),
  3251.             };
  3252.             static inline uint32_t get() { return reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA1LR; }
  3253.             static inline void set(uint32_t value) { reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA1LR = value; }
  3254.             static inline uint32_t get_MACA1L() { return reinterpret_cast<__IO MACA1LR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA1LR)->MACA1L; }
  3255.             static inline void set_MACA1L(uint32_t value) { reinterpret_cast<__IO MACA1LR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA1LR)->MACA1L = value; }
  3256.         };
  3257.         class MACA2HR
  3258.         {
  3259.         private:
  3260.             union MACA2HR_t
  3261.             {
  3262.                 struct
  3263.                 {
  3264.                     uint32_t reserved0      : 1;
  3265.                     uint32_t reserved1      : 1;
  3266.                     uint32_t reserved2      : 1;
  3267.                     uint32_t reserved3      : 1;
  3268.                     uint32_t reserved4      : 1;
  3269.                     uint32_t reserved5      : 1;
  3270.                     uint32_t reserved6      : 1;
  3271.                     uint32_t reserved7      : 1;
  3272.                     uint32_t reserved8      : 1;
  3273.                     uint32_t reserved9      : 1;
  3274.                     uint32_t reserved10     : 1;
  3275.                     uint32_t reserved11     : 1;
  3276.                     uint32_t reserved12     : 1;
  3277.                     uint32_t reserved13     : 1;
  3278.                     uint32_t reserved14     : 1;
  3279.                     uint32_t reserved15     : 1;
  3280.                     uint32_t reserved16     : 1;
  3281.                     uint32_t reserved17     : 1;
  3282.                     uint32_t reserved18     : 1;
  3283.                     uint32_t reserved19     : 1;
  3284.                     uint32_t reserved20     : 1;
  3285.                     uint32_t reserved21     : 1;
  3286.                     uint32_t reserved22     : 1;
  3287.                     uint32_t reserved23     : 1;
  3288.                     uint32_t reserved24     : 1;
  3289.                     uint32_t reserved25     : 1;
  3290.                     uint32_t reserved26     : 1;
  3291.                     uint32_t reserved27     : 1;
  3292.                     uint32_t reserved28     : 1;
  3293.                     uint32_t reserved29     : 1;
  3294.                     uint32_t reserved30     : 1;
  3295.                     uint32_t AE             : 1;
  3296.                     uint32_t SA             : 1;
  3297.                     uint32_t MBC            : 6;
  3298.                     uint32_t MACA2H         : 16;
  3299.                 };
  3300.                 uint32_t RAW;
  3301.             };
  3302.         public:
  3303.             enum class EMasks: uint32_t
  3304.             {
  3305.                 AE                     = (0x1U << 31),
  3306.                 SA                     = (0x1U << 30),
  3307.                 MBC                    = (0x3FU << 24),
  3308.                 MACA2H                 = (0xFFFFU << 0),
  3309.             };
  3310.             static inline uint32_t get() { return reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA2HR; }
  3311.             static inline void set(uint32_t value) { reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA2HR = value; }
  3312.             template <EMasks ... flags>
  3313.             static inline void set_flags()
  3314.             {
  3315.                 reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA2HR |= SetBits<(std::uint32_t)flags...>();
  3316.             }
  3317.             template <EMasks ... flags>
  3318.             static inline void clear_flags()
  3319.             {
  3320.                 reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA2HR &= ~(SetBits<(std::uint32_t)flags...>());
  3321.             }
  3322.             template <EMasks ... flags>
  3323.             static inline bool get_flags()
  3324.             {
  3325.                 return ((reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA2HR & SetBits<(std::uint32_t)flags...>()) == SetBits<(std::uint32_t)flags...>());
  3326.             }
  3327.             static inline uint32_t get_MBC() { return reinterpret_cast<__IO MACA2HR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA2HR)->MBC; }
  3328.             static inline void set_MBC(uint32_t value) { reinterpret_cast<__IO MACA2HR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA2HR)->MBC = value; }
  3329.             static inline uint32_t get_MACA2H() { return reinterpret_cast<__IO MACA2HR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA2HR)->MACA2H; }
  3330.             static inline void set_MACA2H(uint32_t value) { reinterpret_cast<__IO MACA2HR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA2HR)->MACA2H = value; }
  3331.         };
  3332.         class MACA2LR
  3333.         {
  3334.         private:
  3335.             union MACA2LR_t
  3336.             {
  3337.                 struct
  3338.                 {
  3339.                     uint32_t MACA2L         : 32;
  3340.                 };
  3341.                 uint32_t RAW;
  3342.             };
  3343.         public:
  3344.             enum class EMasks: uint32_t
  3345.             {
  3346.                 MACA2L                 = (0xFFFFFFFFU << 0),
  3347.             };
  3348.             static inline uint32_t get() { return reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA2LR; }
  3349.             static inline void set(uint32_t value) { reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA2LR = value; }
  3350.             static inline uint32_t get_MACA2L() { return reinterpret_cast<__IO MACA2LR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA2LR)->MACA2L; }
  3351.             static inline void set_MACA2L(uint32_t value) { reinterpret_cast<__IO MACA2LR_t*>(&reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA2LR)->MACA2L = value; }
  3352.         };
  3353.         class MACA3HR
  3354.         {
  3355.         private:
  3356.             union MACA3HR_t
  3357.             {
  3358.                 struct
  3359.                 {
  3360.                     uint32_t reserved0      : 1;
  3361.                     uint32_t reserved1      : 1;
  3362.                     uint32_t reserved2      : 1;
  3363.                     uint32_t reserved3      : 1;
  3364.                     uint32_t reserved4      : 1;
  3365.                     uint32_t reserved5      : 1;
  3366.                     uint32_t reserved6      : 1;
  3367.                     uint32_t reserved7      : 1;
  3368.                     uint32_t reserved8      : 1;
  3369.                     uint32_t reserved9      : 1;
  3370.                     uint32_t reserved10     : 1;
  3371.                     uint32_t reserved11     : 1;
  3372.                     uint32_t reserved12     : 1;
  3373.                     uint32_t reserved13     : 1;
  3374.                     uint32_t reserved14     : 1;
  3375.                     uint32_t reserved15     : 1;
  3376.                     uint32_t reserved16     : 1;
  3377.                     uint32_t reserved17     : 1;
  3378.                     uint32_t reserved18     : 1;
  3379.                     uint32_t reserved19     : 1;
  3380.                     uint32_t reserved20     : 1;
  3381.                     uint32_t reserved21     : 1;
  3382.                     uint32_t reserved22     : 1;
  3383.                     uint32_t reserved23     : 1;
  3384.                     uint32_t reserved24     : 1;
  3385.                     uint32_t reserved25     : 1;
  3386.                     uint32_t reserved26     : 1;
  3387.                     uint32_t reserved27     : 1;
  3388.                     uint32_t reserved28     : 1;
  3389.                     uint32_t reserved29     : 1;
  3390.                     uint32_t reserved30     : 1;
  3391.                     uint32_t AE             : 1;
  3392.                     uint32_t SA             : 1;
  3393.                     uint32_t MBC            : 6;
  3394.                     uint32_t MACA3H         : 16;
  3395.                 };
  3396.                 uint32_t RAW;
  3397.             };
  3398.         public:
  3399.             enum class EMasks: uint32_t
  3400.             {
  3401.                 AE                     = (0x1U << 31),
  3402.                 SA                     = (0x1U << 30),
  3403.                 MBC                    = (0x3FU << 24),
  3404.                 MACA3H                 = (0xFFFFU << 0),
  3405.             };
  3406.             static inline uint32_t get() { return reinterpret_cast<ETH_t*>(STM32::ETH_BASE)->MACA3HR; }
  3407.             static inline void set(uint32_t value) { reinterpret_cast