From 6d33ec12204a65613ded8bfc7ac92055712a4338 Mon Sep 17 00:00:00 2001 From: Clyne Sullivan Date: Wed, 5 Feb 2025 15:52:50 -0500 Subject: add stm32 example --- example/Makefile | 7 + example/STM32U083xx_FLASH.ld | 187 ++ example/main.cpp | 32 + example/startup_stm32u083xx.s | 296 ++ example/stm32u083.hpp | 7431 +++++++++++++++++++++++++++++++++++++++++ 5 files changed, 7953 insertions(+) create mode 100644 example/Makefile create mode 100644 example/STM32U083xx_FLASH.ld create mode 100644 example/main.cpp create mode 100644 example/startup_stm32u083xx.s create mode 100644 example/stm32u083.hpp diff --git a/example/Makefile b/example/Makefile new file mode 100644 index 0000000..6b0d2fc --- /dev/null +++ b/example/Makefile @@ -0,0 +1,7 @@ +all: + arm-none-eabi-g++ -mcpu=cortex-m0plus -mthumb -std=c++20 -O1 -I .. \ + -fno-exceptions -fno-rtti -fdata-sections -ffunction-sections \ + main.cpp startup_stm32u083xx.s \ + -o main -T STM32U083xx_FLASH.ld -Wl,-gc-sections + arm-none-eabi-objcopy -Oihex main main.hex + diff --git a/example/STM32U083xx_FLASH.ld b/example/STM32U083xx_FLASH.ld new file mode 100644 index 0000000..e058cbf --- /dev/null +++ b/example/STM32U083xx_FLASH.ld @@ -0,0 +1,187 @@ +/* +****************************************************************************** +** +** @file : LinkerScript.ld +** +** @author : Auto-generated by STM32CubeIDE +** +** @brief : Linker script for STM32U083xx Device from STM32U0 series +** 256Kbytes FLASH +** 40Kbytes RAM +** +** Set heap size, stack size and stack location according +** to application requirements. +** +** Set memory bank area and size if external memory is used +** +** Target : STMicroelectronics STM32 +** +** Distribution: The file is distributed as is, without any warranty +** of any kind. +** +****************************************************************************** +** @attention +** +** Copyright (c) 2023 STMicroelectronics. +** All rights reserved. +** +** This software is licensed under terms that can be found in the LICENSE file +** in the root directory of this software component. +** If no LICENSE file comes with this software, it is provided AS-IS. +** +****************************************************************************** +*/ + +/* Entry Point */ +ENTRY(Reset_Handler) + +/* Highest address of the user mode stack */ +_estack = ORIGIN(RAM) + LENGTH(RAM); /* end of "RAM" Ram type memory */ + +_Min_Heap_Size = 0x0; /* required amount of heap */ +_Min_Stack_Size = 0x100; /* required amount of stack */ + +/* Memories definition */ +MEMORY +{ + RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 32K + FLASH (rx) : ORIGIN = 0x8000000, LENGTH = 256K +} + +/* Sections */ +SECTIONS +{ + /* The startup code into "FLASH" Rom type memory */ + .isr_vector : + { + . = ALIGN(4); + KEEP(*(.isr_vector)) /* Startup code */ + . = ALIGN(4); + } >FLASH + + /* The program code and other data into "FLASH" Rom type memory */ + .text : + { + . = ALIGN(4); + *(.text) /* .text sections (code) */ + *(.text*) /* .text* sections (code) */ + *(.glue_7) /* glue arm to thumb code */ + *(.glue_7t) /* glue thumb to arm code */ + *(.eh_frame) + + KEEP (*(.init)) + KEEP (*(.fini)) + + . = ALIGN(4); + _etext = .; /* define a global symbols at end of code */ + } >FLASH + + /* Constant data into "FLASH" Rom type memory */ + .rodata : + { + . = ALIGN(4); + *(.rodata) /* .rodata sections (constants, strings, etc.) */ + *(.rodata*) /* .rodata* sections (constants, strings, etc.) */ + . = ALIGN(4); + } >FLASH + + .ARM.extab (READONLY) : /* The READONLY keyword is only supported in GCC11 and later, remove it if using GCC10 or earlier. */ + { + . = ALIGN(4); + *(.ARM.extab* .gnu.linkonce.armextab.*) + . = ALIGN(4); + } >FLASH + + .ARM (READONLY) : /* The READONLY keyword is only supported in GCC11 and later, remove it if using GCC10 or earlier. */ + { + . = ALIGN(4); + __exidx_start = .; + *(.ARM.exidx*) + __exidx_end = .; + . = ALIGN(4); + } >FLASH + + .preinit_array (READONLY) : /* The READONLY keyword is only supported in GCC11 and later, remove it if using GCC10 or earlier. */ + { + . = ALIGN(4); + PROVIDE_HIDDEN (__preinit_array_start = .); + KEEP (*(.preinit_array*)) + PROVIDE_HIDDEN (__preinit_array_end = .); + . = ALIGN(4); + } >FLASH + + .init_array (READONLY) : /* The READONLY keyword is only supported in GCC11 and later, remove it if using GCC10 or earlier. */ + { + . = ALIGN(4); + PROVIDE_HIDDEN (__init_array_start = .); + KEEP (*(SORT(.init_array.*))) + KEEP (*(.init_array*)) + PROVIDE_HIDDEN (__init_array_end = .); + . = ALIGN(4); + } >FLASH + + .fini_array (READONLY) : /* The READONLY keyword is only supported in GCC11 and later, remove it if using GCC10 or earlier. */ + { + . = ALIGN(4); + PROVIDE_HIDDEN (__fini_array_start = .); + KEEP (*(SORT(.fini_array.*))) + KEEP (*(.fini_array*)) + PROVIDE_HIDDEN (__fini_array_end = .); + . = ALIGN(4); + } >FLASH + + /* Used by the startup to initialize data */ + _sidata = LOADADDR(.data); + + /* Initialized data sections into "RAM" Ram type memory */ + .data : + { + . = ALIGN(4); + _sdata = .; /* create a global symbol at data start */ + *(.data) /* .data sections */ + *(.data*) /* .data* sections */ + *(.RamFunc) /* .RamFunc sections */ + *(.RamFunc*) /* .RamFunc* sections */ + + . = ALIGN(4); + _edata = .; /* define a global symbol at data end */ + + } >RAM AT> FLASH + + /* Uninitialized data section into "RAM" Ram type memory */ + . = ALIGN(4); + .bss : + { + /* This is used by the startup in order to initialize the .bss section */ + _sbss = .; /* define a global symbol at bss start */ + __bss_start__ = _sbss; + *(.bss) + *(.bss*) + *(COMMON) + + . = ALIGN(4); + _ebss = .; /* define a global symbol at bss end */ + __bss_end__ = _ebss; + } >RAM + + /* User_heap_stack section, used to check that there is enough "RAM" Ram type memory left */ + ._user_heap_stack : + { + . = ALIGN(8); + PROVIDE ( end = . ); + PROVIDE ( _end = . ); + . = . + _Min_Heap_Size; + . = . + _Min_Stack_Size; + . = ALIGN(8); + } >RAM + + /* Remove information from the compiler libraries */ + /DISCARD/ : + { + libc.a ( * ) + libm.a ( * ) + libgcc.a ( * ) + } + + .ARM.attributes 0 : { *(.ARM.attributes) } +} diff --git a/example/main.cpp b/example/main.cpp new file mode 100644 index 0000000..9fc545e --- /dev/null +++ b/example/main.cpp @@ -0,0 +1,32 @@ +#include "stm32u083.hpp" + +int main() +{ + using namespace STM32U083; + using LD3 = GPIOC::ODR::OD13; + using LD4 = GPIOA::ODR::OD5; + using LD5 = GPIOB::ODR::OD2; + + RCC::ALL::set< + RCC::IOPENR::GPIOAEN, + RCC::IOPENR::GPIOBEN, + RCC::IOPENR::GPIOCEN, + RCC::APBENR1::USART2EN>(); + + GPIOC::MODER::MODE13::write<1>(); + GPIOA::MODER::MODE5::write<1>(); + GPIOB::MODER::MODE2::write<1>(); + + unsigned i = 0; + while (1) { + if (i & 1) LD3::set(); else LD3::clear(); + if (i & 2) LD4::set(); else LD4::clear(); + if (i & 4) LD5::set(); else LD5::clear(); + + for (int j = 0; j < 100000; j++) + asm("nop"); + + i++; + } +} + diff --git a/example/startup_stm32u083xx.s b/example/startup_stm32u083xx.s new file mode 100644 index 0000000..6190254 --- /dev/null +++ b/example/startup_stm32u083xx.s @@ -0,0 +1,296 @@ +/** + ****************************************************************************** + * @file startup_stm32u083xx.s + * @author Auto-generated by STM32CubeIDE + * @brief STM32U083xx device vector table for GCC toolchain. + * This module performs: + * - Set the initial SP + * - Set the initial PC == Reset_Handler, + * - Set the vector table entries with the exceptions ISR address + * - Branches to main in the C library (which eventually + * calls main()). + ****************************************************************************** + * @attention + * + * Copyright (c) 2023 STMicroelectronics. + * All rights reserved. + * + * This software is licensed under terms that can be found in the LICENSE file + * in the root directory of this software component. + * If no LICENSE file comes with this software, it is provided AS-IS. + * + ****************************************************************************** + */ + +.syntax unified +.cpu cortex-m0plus +.fpu softvfp +.thumb + +.global g_pfnVectors +.global Default_Handler + +/* start address for the initialization values of the .data section. +defined in linker script */ +.word _sidata +/* start address for the .data section. defined in linker script */ +.word _sdata +/* end address for the .data section. defined in linker script */ +.word _edata +/* start address for the .bss section. defined in linker script */ +.word _sbss +/* end address for the .bss section. defined in linker script */ +.word _ebss + +/** + * @brief This is the code that gets called when the processor first + * starts execution following a reset event. Only the absolutely + * necessary set is performed, after which the application + * supplied main() routine is called. + * @param None + * @retval : None +*/ + + .section .text.Reset_Handler + .weak Reset_Handler + .type Reset_Handler, %function +Reset_Handler: + ldr r0, =_estack + mov sp, r0 /* set stack pointer */ + +/* Copy the data segment initializers from flash to SRAM */ + ldr r0, =_sdata + ldr r1, =_edata + ldr r2, =_sidata + movs r3, #0 + b LoopCopyDataInit + +CopyDataInit: + ldr r4, [r2, r3] + str r4, [r0, r3] + adds r3, r3, #4 + +LoopCopyDataInit: + adds r4, r0, r3 + cmp r4, r1 + bcc CopyDataInit + +/* Zero fill the bss segment. */ + ldr r2, =_sbss + ldr r4, =_ebss + movs r3, #0 + b LoopFillZerobss + +FillZerobss: + str r3, [r2] + adds r2, r2, #4 + +LoopFillZerobss: + cmp r2, r4 + bcc FillZerobss + +/* Call static constructors */ + bl __libc_init_array +/* Call the application's entry point.*/ + bl main + +LoopForever: + b LoopForever + + .size Reset_Handler, .-Reset_Handler + +/** + * @brief This is the code that gets called when the processor receives an + * unexpected interrupt. This simply enters an infinite loop, preserving + * the system state for examination by a debugger. + * + * @param None + * @retval : None +*/ + .section .text.Default_Handler,"ax",%progbits +Default_Handler: +Infinite_Loop: + b Infinite_Loop + .size Default_Handler, .-Default_Handler + +/****************************************************************************** +* +* The STM32U083xx vector table. Note that the proper constructs +* must be placed on this to ensure that it ends up at physical address +* 0x0000.0000. +* +******************************************************************************/ + .section .isr_vector,"a",%progbits + .type g_pfnVectors, %object + +g_pfnVectors: + .word _estack + .word Reset_Handler + .word NMI_Handler + .word HardFault_Handler + .word 0 + .word 0 + .word 0 + .word 0 + .word 0 + .word 0 + .word 0 + .word SVC_Handler + .word 0 + .word 0 + .word PendSV_Handler + .word SysTick_Handler + .word WWDG_IWDG_IRQHandler /* Window watchdog interrupt */ + .word PVD_PVM_IRQHandler /* PVD/PVM1/PVM2/PVM3 interrupt (combined with EXTI lines 16 and 19 and 20 and 21) */ + .word RTC_TAMP_IRQHandler /* RTC and TAMP interrupts(combined EXTI lines 19 and 21) */ + .word FLASH_ECC_IRQHandler /* FLASH global interrupt */ + .word RCC_CRS_IRQHandler /* RCC and CRS global interrupt */ + .word EXTI0_1_IRQHandler /* EXTI lines 0 and 1 interrupt */ + .word EXTI2_3_IRQHandler /* EXTI lines 2 and 3 interrupt */ + .word EXTI4_15_IRQHandler /* EXTI lines 4 to 15 interrupt */ + .word USB_DRD_FS_IRQHandler /* USB global interrupt (combined with EXTI line 33) */ + .word DMA1_Channel1_IRQHandler /* DMA1 channel 1 interrupt */ + .word DMA1_Channel2_3_IRQHandler /* DMA1 channel 2 and 3 interrupts */ + .word DMA1_Ch4_7_DMA2_Ch1_5_DMAMUX_OVR_IRQHandler /* DMA1 channel 4, 5, 6, 7, DMAMUX overrun, DMA2 channel 1, 2, 3, 4, 5 interrupts */ + .word ADC_COMP1_2_IRQHandler /* ADC and COMP interrupts (ADC combined with EXTI lines 17 and 18) */ + .word TIM1_BRK_UP_TRG_COM_IRQHandler/* TIM1 break, update, trigger and commutation interrupts */ + .word TIM1_CC_IRQHandler /* TIM1 Capture Compare interrupt */ + .word TIM2_IRQHandler /* TIM2 global interrupt */ + .word TIM3_IRQHandler /* TIM3 global interrupt */ + .word TIM6_DAC_LPTIM1_IRQHandler /* TIM6, LPTIM1 and DAC global interrupt (combined with EXTI line 29) */ + .word TIM7_LPTIM2_IRQHandler /* TIM7 and LPTIM2 global interrupt (combined with EXTI line 30) */ + .word TIM15_LPTIM3_IRQHandler /* TIM15 and LPTIM3 global interrupt (combined with EXTI line 29) */ + .word TIM16_IRQHandler /* TIM16 global interrupt */ + .word TSC_IRQHandler /* TSC global interrupt */ + .word LCD_IRQHandler /* LCD global interrupt (combined with EXTI line 32) */ + .word I2C1_IRQHandler /* I2C1 global interrupt (combined with EXTI line 23) */ + .word I2C2_3_4_IRQHandler /* I2C2/3/4 global interrupt */ + .word SPI1_IRQHandler /* SPI1 global interrupt */ + .word SPI2_3_IRQHandler /* SPI2/3 global interrupt */ + .word USART1_IRQHandler /* USART1 global interrupt (combined with EXTI line 25) */ + .word USART2_LPUART2_IRQHandler /* USART2 and LPUART2 global interrupt (combined with EXTI lines 26 and 35) */ + .word USART3_LPUART1_IRQHandler /* USART3 and LPUART1 global interrupt (combined with EXTI lines 24 and 28) */ + .word USART4_LPUART3_IRQHandler /* USART4 and LPUART3 global interrupt (combined with EXTI lines 20 and 34) */ + .word RNG_CRYP_IRQHandler /* RNG and CRYPTO global interrupts */ + + .size g_pfnVectors, .-g_pfnVectors + +/******************************************************************************* +* +* Provide weak aliases for each Exception handler to the Default_Handler. +* As they are weak aliases, any function with the same name will override +* this definition. +* +*******************************************************************************/ + + .weak NMI_Handler + .thumb_set NMI_Handler,Default_Handler + + .weak HardFault_Handler + .thumb_set HardFault_Handler,Default_Handler + + .weak SVC_Handler + .thumb_set SVC_Handler,Default_Handler + + .weak PendSV_Handler + .thumb_set PendSV_Handler,Default_Handler + + .weak SysTick_Handler + .thumb_set SysTick_Handler,Default_Handler + + .weak WWDG_IWDG_IRQHandler + .thumb_set WWDG_IWDG_IRQHandler,Default_Handler + + .weak PVD_PVM_IRQHandler + .thumb_set PVD_PVM_IRQHandler,Default_Handler + + .weak RTC_TAMP_IRQHandler + .thumb_set RTC_TAMP_IRQHandler,Default_Handler + + .weak FLASH_ECC_IRQHandler + .thumb_set FLASH_ECC_IRQHandler,Default_Handler + + .weak RCC_CRS_IRQHandler + .thumb_set RCC_CRS_IRQHandler,Default_Handler + + .weak EXTI0_1_IRQHandler + .thumb_set EXTI0_1_IRQHandler,Default_Handler + + .weak EXTI2_3_IRQHandler + .thumb_set EXTI2_3_IRQHandler,Default_Handler + + .weak EXTI4_15_IRQHandler + .thumb_set EXTI4_15_IRQHandler,Default_Handler + + .weak USB_DRD_FS_IRQHandler + .thumb_set USB_DRD_FS_IRQHandler,Default_Handler + + .weak DMA1_Channel1_IRQHandler + .thumb_set DMA1_Channel1_IRQHandler,Default_Handler + + .weak DMA1_Channel2_3_IRQHandler + .thumb_set DMA1_Channel2_3_IRQHandler,Default_Handler + + .weak DMA1_Ch4_7_DMA2_Ch1_5_DMAMUX_OVR_IRQHandler + .thumb_set DMA1_Ch4_7_DMA2_Ch1_5_DMAMUX_OVR_IRQHandler,Default_Handler + + .weak ADC_COMP1_2_IRQHandler + .thumb_set ADC_COMP1_2_IRQHandler,Default_Handler + + .weak TIM1_BRK_UP_TRG_COM_IRQHandler + .thumb_set TIM1_BRK_UP_TRG_COM_IRQHandler,Default_Handler + + .weak TIM1_CC_IRQHandler + .thumb_set TIM1_CC_IRQHandler,Default_Handler + + .weak TIM2_IRQHandler + .thumb_set TIM2_IRQHandler,Default_Handler + + .weak TIM3_IRQHandler + .thumb_set TIM3_IRQHandler,Default_Handler + + .weak TIM6_DAC_LPTIM1_IRQHandler + .thumb_set TIM6_DAC_LPTIM1_IRQHandler,Default_Handler + + .weak TIM7_LPTIM2_IRQHandler + .thumb_set TIM7_LPTIM2_IRQHandler,Default_Handler + + .weak TIM15_LPTIM3_IRQHandler + .thumb_set TIM15_LPTIM3_IRQHandler,Default_Handler + + .weak TIM16_IRQHandler + .thumb_set TIM16_IRQHandler,Default_Handler + + .weak TSC_IRQHandler + .thumb_set TSC_IRQHandler,Default_Handler + + .weak LCD_IRQHandler + .thumb_set LCD_IRQHandler,Default_Handler + + .weak I2C1_IRQHandler + .thumb_set I2C1_IRQHandler,Default_Handler + + .weak I2C2_3_4_IRQHandler + .thumb_set I2C2_3_4_IRQHandler,Default_Handler + + .weak SPI1_IRQHandler + .thumb_set SPI1_IRQHandler,Default_Handler + + .weak SPI2_3_IRQHandler + .thumb_set SPI2_3_IRQHandler,Default_Handler + + .weak USART1_IRQHandler + .thumb_set USART1_IRQHandler,Default_Handler + + .weak USART2_LPUART2_IRQHandler + .thumb_set USART2_LPUART2_IRQHandler,Default_Handler + + .weak USART3_LPUART1_IRQHandler + .thumb_set USART3_LPUART1_IRQHandler,Default_Handler + + .weak USART4_LPUART3_IRQHandler + .thumb_set USART4_LPUART3_IRQHandler,Default_Handler + + .weak RNG_CRYP_IRQHandler + .thumb_set RNG_CRYP_IRQHandler,Default_Handler + diff --git a/example/stm32u083.hpp b/example/stm32u083.hpp new file mode 100644 index 0000000..bafd7d8 --- /dev/null +++ b/example/stm32u083.hpp @@ -0,0 +1,7431 @@ +#include "funreg.hpp" + +namespace STM32U083 { + using namespace fr; + namespace ADC { + struct ISR : public MemRegister { + using ADRDY = RegisterMask; + using EOSMP = RegisterMask; + using EOC = RegisterMask; + using EOS = RegisterMask; + using OVR = RegisterMask; + using AWD1 = RegisterMask; + using AWD2 = RegisterMask; + using AWD3 = RegisterMask; + using EOCAL = RegisterMask; + using CCRDY = RegisterMask; + }; + struct IER : public MemRegister { + using ADRDYIE = RegisterMask; + using EOSMPIE = RegisterMask; + using EOCIE = RegisterMask; + using EOSIE = RegisterMask; + using OVRIE = RegisterMask; + using AWD1IE = RegisterMask; + using AWD2IE = RegisterMask; + using AWD3IE = RegisterMask; + using EOCALIE = RegisterMask; + using CCRDYIE = RegisterMask; + }; + struct CR : public MemRegister { + using ADEN = RegisterMask; + using ADDIS = RegisterMask; + using ADSTART = RegisterMask; + using ADSTP = RegisterMask; + using ADVREGEN = RegisterMask; + using ADCAL = RegisterMask; + }; + struct CFGR1 : public MemRegister { + using DMAEN = RegisterMask; + using DMACFG = RegisterMask; + using SCANDIR = RegisterMask; + using RES = RegisterMask; + using ALIGN = RegisterMask; + using EXTSEL = RegisterMask; + using EXTEN = RegisterMask; + using OVRMOD = RegisterMask; + using CONT = RegisterMask; + using WAIT = RegisterMask; + using AUTOFF = RegisterMask; + using DISCEN = RegisterMask; + using CHSELRMOD = RegisterMask; + using AWD1SGL = RegisterMask; + using AWD1EN = RegisterMask; + using AWD1CH = RegisterMask; + }; + struct CFGR2 : public MemRegister { + using OVSE = RegisterMask; + using OVSR = RegisterMask; + using OVSS = RegisterMask; + using TOVS = RegisterMask; + using LFTRIG = RegisterMask; + using CKMODE = RegisterMask; + }; + struct SMPR : public MemRegister { + using SMP1 = RegisterMask; + using SMP2 = RegisterMask; + using SMPSEL0 = RegisterMask; + using SMPSEL1 = RegisterMask; + using SMPSEL2 = RegisterMask; + using SMPSEL3 = RegisterMask; + using SMPSEL4 = RegisterMask; + using SMPSEL5 = RegisterMask; + using SMPSEL6 = RegisterMask; + using SMPSEL7 = RegisterMask; + using SMPSEL8 = RegisterMask; + using SMPSEL9 = RegisterMask; + using SMPSEL10 = RegisterMask; + using SMPSEL11 = RegisterMask; + using SMPSEL12 = RegisterMask; + using SMPSEL13 = RegisterMask; + using SMPSEL14 = RegisterMask; + using SMPSEL15 = RegisterMask; + using SMPSEL16 = RegisterMask; + using SMPSEL17 = RegisterMask; + using SMPSEL18 = RegisterMask; + using SMPSEL19 = RegisterMask; + }; + struct AWD1TR : public MemRegister { + using LT1 = RegisterMask; + using HT1 = RegisterMask; + }; + struct AWD2TR : public MemRegister { + using LT2 = RegisterMask; + using HT2 = RegisterMask; + }; + struct CHSELR : public MemRegister { + using CHSEL0 = RegisterMask; + using CHSEL1 = RegisterMask; + using CHSEL2 = RegisterMask; + using CHSEL3 = RegisterMask; + using CHSEL4 = RegisterMask; + using CHSEL5 = RegisterMask; + using CHSEL6 = RegisterMask; + using CHSEL7 = RegisterMask; + using CHSEL8 = RegisterMask; + using CHSEL9 = RegisterMask; + using CHSEL10 = RegisterMask; + using CHSEL11 = RegisterMask; + using CHSEL12 = RegisterMask; + using CHSEL13 = RegisterMask; + using CHSEL14 = RegisterMask; + using CHSEL15 = RegisterMask; + using CHSEL16 = RegisterMask; + using CHSEL17 = RegisterMask; + using CHSEL18 = RegisterMask; + using CHSEL19 = RegisterMask; + }; + struct CHSELR_ALTERNATE : public MemRegister { + using SQ1 = RegisterMask; + using SQ2 = RegisterMask; + using SQ3 = RegisterMask; + using SQ4 = RegisterMask; + using SQ5 = RegisterMask; + using SQ6 = RegisterMask; + using SQ7 = RegisterMask; + using SQ8 = RegisterMask; + }; + struct AWD3TR : public MemRegister { + using LT3 = RegisterMask; + using HT3 = RegisterMask; + }; + struct DR : public MemRegister { + using DATA = RegisterMask; + }; + struct AWD2CR : public MemRegister { + using AWD2CH0 = RegisterMask; + using AWD2CH1 = RegisterMask; + using AWD2CH2 = RegisterMask; + using AWD2CH3 = RegisterMask; + using AWD2CH4 = RegisterMask; + using AWD2CH5 = RegisterMask; + using AWD2CH6 = RegisterMask; + using AWD2CH7 = RegisterMask; + using AWD2CH8 = RegisterMask; + using AWD2CH9 = RegisterMask; + using AWD2CH10 = RegisterMask; + using AWD2CH11 = RegisterMask; + using AWD2CH12 = RegisterMask; + using AWD2CH13 = RegisterMask; + using AWD2CH14 = RegisterMask; + using AWD2CH15 = RegisterMask; + using AWD2CH16 = RegisterMask; + using AWD2CH17 = RegisterMask; + using AWD2CH18 = RegisterMask; + using AWD2CH19 = RegisterMask; + }; + struct AWD3CR : public MemRegister { + using AWD3CH0 = RegisterMask; + using AWD3CH1 = RegisterMask; + using AWD3CH2 = RegisterMask; + using AWD3CH3 = RegisterMask; + using AWD3CH4 = RegisterMask; + using AWD3CH5 = RegisterMask; + using AWD3CH6 = RegisterMask; + using AWD3CH7 = RegisterMask; + using AWD3CH8 = RegisterMask; + using AWD3CH9 = RegisterMask; + using AWD3CH10 = RegisterMask; + using AWD3CH11 = RegisterMask; + using AWD3CH12 = RegisterMask; + using AWD3CH13 = RegisterMask; + using AWD3CH14 = RegisterMask; + using AWD3CH15 = RegisterMask; + using AWD3CH16 = RegisterMask; + using AWD3CH17 = RegisterMask; + using AWD3CH18 = RegisterMask; + using AWD3CH19 = RegisterMask; + }; + struct CALFACT : public MemRegister { + using val = RegisterMask; + }; + struct CCR : public MemRegister { + using PRESC = RegisterMask; + using VREFEN = RegisterMask; + using TSEN = RegisterMask; + using VBATEN = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace AES { + struct CR : public MemRegister { + using EN = RegisterMask; + using DATATYPE = RegisterMask; + using MODE = RegisterMask; + using CHMOD = RegisterMask; + using DMAINEN = RegisterMask; + using DMAOUTEN = RegisterMask; + using GCMPH = RegisterMask; + using CHMOD_1 = RegisterMask; + using KEYSIZE = RegisterMask; + using NPBLB = RegisterMask; + using IPRST = RegisterMask; + }; + struct SR : public MemRegister { + using RDERRF = RegisterMask; + using WRERRF = RegisterMask; + using BUSY = RegisterMask; + using KEYVALID = RegisterMask; + }; + struct DINR : public MemRegister { + using DIN = RegisterMask; + }; + struct DOUTR : public MemRegister { + using DOUT = RegisterMask; + }; + struct KEYR0 : public MemRegister { + using KEY = RegisterMask; + }; + struct KEYR1 : public MemRegister { + using KEY = RegisterMask; + }; + struct KEYR2 : public MemRegister { + using KEY = RegisterMask; + }; + struct KEYR3 : public MemRegister { + using KEY = RegisterMask; + }; + struct IVR0 : public MemRegister { + using IVI = RegisterMask; + }; + struct IVR1 : public MemRegister { + using IVI = RegisterMask; + }; + struct IVR2 : public MemRegister { + using IVI = RegisterMask; + }; + struct IVR3 : public MemRegister { + using IVI = RegisterMask; + }; + struct KEYR4 : public MemRegister { + using KEY = RegisterMask; + }; + struct KEYR5 : public MemRegister { + using KEY = RegisterMask; + }; + struct KEYR6 : public MemRegister { + using KEY = RegisterMask; + }; + struct KEYR7 : public MemRegister { + using KEY = RegisterMask; + }; + struct SUSPR0 : public MemRegister { + using SUSP = RegisterMask; + }; + struct SUSPR1 : public MemRegister { + using SUSP = RegisterMask; + }; + struct SUSPR2 : public MemRegister { + using SUSP = RegisterMask; + }; + struct SUSPR3 : public MemRegister { + using SUSP = RegisterMask; + }; + struct SUSPR4 : public MemRegister { + using SUSP = RegisterMask; + }; + struct SUSPR5 : public MemRegister { + using SUSP = RegisterMask; + }; + struct SUSPR6 : public MemRegister { + using SUSP = RegisterMask; + }; + struct SUSPR7 : public MemRegister { + using SUSP = RegisterMask; + }; + struct IER : public MemRegister { + using CCFIE = RegisterMask; + using RWEIE = RegisterMask; + using KEIE = RegisterMask; + }; + struct ISR : public MemRegister { + using CCF = RegisterMask; + using RWEIF = RegisterMask; + using KEIF = RegisterMask; + }; + struct ICR : public MemRegister { + using CCF = RegisterMask; + using RWEIF = RegisterMask; + using KEIF = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace COMP { + struct COMP1_CSR : public MemRegister { + using EN = RegisterMask; + using INMSEL = RegisterMask; + using INPSEL = RegisterMask; + using WINMODE = RegisterMask; + using WINOUT = RegisterMask; + using POLARITY = RegisterMask; + using HYST = RegisterMask; + using PWRMODE = RegisterMask; + using BLANKSEL = RegisterMask; + using VALUE = RegisterMask; + using LOCK = RegisterMask; + }; + struct COMP2_CSR : public MemRegister { + using EN = RegisterMask; + using INMSEL = RegisterMask; + using INPSEL = RegisterMask; + using WINMODE = RegisterMask; + using WINOUT = RegisterMask; + using POLARITY = RegisterMask; + using HYST = RegisterMask; + using PWRMODE = RegisterMask; + using BLANKSEL = RegisterMask; + using VALUE = RegisterMask; + using LOCK = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace CRC { + struct DR : public MemRegister { + using val = RegisterMask; + }; + struct IDR : public MemRegister { + using val = RegisterMask; + }; + struct CR : public MemRegister { + using RESET = RegisterMask; + using POLYSIZE = RegisterMask; + using REV_IN = RegisterMask; + using REV_OUT = RegisterMask; + using RTYPE_IN = RegisterMask; + using RTYPE_OUT = RegisterMask; + }; + struct INIT : public MemRegister { + using CRC_INIT = RegisterMask; + }; + struct POL : public MemRegister { + using val = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace CRS { + struct CR : public MemRegister { + using SYNCOKIE = RegisterMask; + using SYNCWARNIE = RegisterMask; + using ERRIE = RegisterMask; + using ESYNCIE = RegisterMask; + using CEN = RegisterMask; + using AUTOTRIMEN = RegisterMask; + using SWSYNC = RegisterMask; + using TRIM = RegisterMask; + }; + struct CFGR : public MemRegister { + using RELOAD = RegisterMask; + using FELIM = RegisterMask; + using SYNCDIV = RegisterMask; + using SYNCSRC = RegisterMask; + using SYNCPOL = RegisterMask; + }; + struct ISR : public MemRegister { + using SYNCOKF = RegisterMask; + using SYNCWARNF = RegisterMask; + using ERRF = RegisterMask; + using ESYNCF = RegisterMask; + using SYNCERR = RegisterMask; + using SYNCMISS = RegisterMask; + using TRIMOVF = RegisterMask; + using FEDIR = RegisterMask; + using FECAP = RegisterMask; + }; + struct ICR : public MemRegister { + using SYNCOKC = RegisterMask; + using SYNCWARNC = RegisterMask; + using ERRC = RegisterMask; + using ESYNCC = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace DAC { + struct CR : public MemRegister { + using EN1 = RegisterMask; + using TEN1 = RegisterMask; + using TSEL1 = RegisterMask; + using WAVE1 = RegisterMask; + using MAMP1 = RegisterMask; + using DMAEN1 = RegisterMask; + using DMAUDRIE1 = RegisterMask; + using CEN1 = RegisterMask; + }; + struct SWTRGR : public MemRegister { + using SWTRIG1 = RegisterMask; + }; + struct DHR12R1 : public MemRegister { + using DACC1DHR = RegisterMask; + }; + struct DHR12L1 : public MemRegister { + using DACC1DHR = RegisterMask; + }; + struct DHR8R1 : public MemRegister { + using DACC1DHR = RegisterMask; + }; + struct DOR1 : public MemRegister { + using DACC1DOR = RegisterMask; + }; + struct SR : public MemRegister { + using DMAUDR1 = RegisterMask; + using CAL_FLAG1 = RegisterMask; + using BWST1 = RegisterMask; + }; + struct CCR : public MemRegister { + using OTRIM1 = RegisterMask; + }; + struct MCR : public MemRegister { + using MODE1 = RegisterMask; + }; + struct SHSR1 : public MemRegister { + using TSAMPLE1 = RegisterMask; + }; + struct SHHR : public MemRegister { + using THOLD1 = RegisterMask; + }; + struct SHRR : public MemRegister { + using TREFRESH1 = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace DBGMCU { + struct IDCODE : public MemRegister { + using DEV_ID = RegisterMask; + using REV_ID = RegisterMask; + }; + struct CR : public MemRegister { + using DBG_STOP = RegisterMask; + using DBG_STANDBY = RegisterMask; + }; + struct APB1FZR : public MemRegister { + using DBG_TIM2_STOP = RegisterMask; + using DBG_TIM3_STOP = RegisterMask; + using DBG_TIM4_STOP = RegisterMask; + using DBG_TIM6_STOP = RegisterMask; + using DBG_TIM7_STOP = RegisterMask; + using DBG_RTC_STOP = RegisterMask; + using DBG_WWDG_STOP = RegisterMask; + using DBG_IWDG_STOP = RegisterMask; + using DBG_I2C3_STOP = RegisterMask; + using DBG_I2C1_STOP = RegisterMask; + using DBG_LPTIM2_STOP = RegisterMask; + using DBG_LPTIM1_STOP = RegisterMask; + }; + struct APB2FZR : public MemRegister { + using DBG_TIM1_STOP = RegisterMask; + using DBG_TIM14_STOP = RegisterMask; + using DBG_TIM15_STOP = RegisterMask; + using DBG_TIM16_STOP = RegisterMask; + using DBG_LPTIM3_STOP = RegisterMask; + }; + struct SR : public MemRegister { + using AP1_PRESENT = RegisterMask; + using AP0_PRESENT = RegisterMask; + using AP1_ENABLED = RegisterMask; + using AP0_ENABLED = RegisterMask; + }; + struct DBG_AUTH_HOST : public MemRegister { + using MESSAGE = RegisterMask; + }; + struct DBG_AUTH_DEVICE : public MemRegister { + using MESSAGE = RegisterMask; + }; + struct PIDR4 : public MemRegister { + using JEP106CON = RegisterMask; + using SIZE = RegisterMask; + }; + struct PIDR0 : public MemRegister { + using PARTNUM = RegisterMask; + }; + struct PIDR1 : public MemRegister { + using PARTNUM = RegisterMask; + using JEP106ID = RegisterMask; + }; + struct PIDR2 : public MemRegister { + using JEP106ID = RegisterMask; + using JEDEC = RegisterMask; + using REVISION = RegisterMask; + }; + struct PIDR3 : public MemRegister { + using CMOD = RegisterMask; + using REVAND = RegisterMask; + }; + struct CIDR0 : public MemRegister { + using PREAMBLE = RegisterMask; + }; + struct CIDR1 : public MemRegister { + using PREAMBLE = RegisterMask; + using CLASS = RegisterMask; + }; + struct CIDR2 : public MemRegister { + using PREAMBLE = RegisterMask; + }; + struct CIDR3 : public MemRegister { + using PREAMBLE = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace DMA1 { + struct ISR : public MemRegister { + using GIF1 = RegisterMask; + using TCIF1 = RegisterMask; + using HTIF1 = RegisterMask; + using TEIF1 = RegisterMask; + using GIF2 = RegisterMask; + using TCIF2 = RegisterMask; + using HTIF2 = RegisterMask; + using TEIF2 = RegisterMask; + using GIF3 = RegisterMask; + using TCIF3 = RegisterMask; + using HTIF3 = RegisterMask; + using TEIF3 = RegisterMask; + using GIF4 = RegisterMask; + using TCIF4 = RegisterMask; + using HTIF4 = RegisterMask; + using TEIF4 = RegisterMask; + using GIF5 = RegisterMask; + using TCIF5 = RegisterMask; + using HTIF5 = RegisterMask; + using TEIF5 = RegisterMask; + using GIF6 = RegisterMask; + using TCIF6 = RegisterMask; + using HTIF6 = RegisterMask; + using TEIF6 = RegisterMask; + using GIF7 = RegisterMask; + using TCIF7 = RegisterMask; + using HTIF7 = RegisterMask; + using TEIF7 = RegisterMask; + }; + struct IFCR : public MemRegister { + using CGIF1 = RegisterMask; + using CTCIF1 = RegisterMask; + using CHTIF1 = RegisterMask; + using CTEIF1 = RegisterMask; + using CGIF2 = RegisterMask; + using CTCIF2 = RegisterMask; + using CHTIF2 = RegisterMask; + using CTEIF2 = RegisterMask; + using CGIF3 = RegisterMask; + using CTCIF3 = RegisterMask; + using CHTIF3 = RegisterMask; + using CTEIF3 = RegisterMask; + using CGIF4 = RegisterMask; + using CTCIF4 = RegisterMask; + using CHTIF4 = RegisterMask; + using CTEIF4 = RegisterMask; + using CGIF5 = RegisterMask; + using CTCIF5 = RegisterMask; + using CHTIF5 = RegisterMask; + using CTEIF5 = RegisterMask; + using CGIF6 = RegisterMask; + using CTCIF6 = RegisterMask; + using CHTIF6 = RegisterMask; + using CTEIF6 = RegisterMask; + using CGIF7 = RegisterMask; + using CTCIF7 = RegisterMask; + using CHTIF7 = RegisterMask; + using CTEIF7 = RegisterMask; + }; + struct CCR1 : public MemRegister { + using EN = RegisterMask; + using TCIE = RegisterMask; + using HTIE = RegisterMask; + using TEIE = RegisterMask; + using DIR = RegisterMask; + using CIRC = RegisterMask; + using PINC = RegisterMask; + using MINC = RegisterMask; + using PSIZE = RegisterMask; + using MSIZE = RegisterMask; + using PL = RegisterMask; + using MEM2MEM = RegisterMask; + }; + struct CNDTR1 : public MemRegister { + using NDT = RegisterMask; + }; + struct CPAR1 : public MemRegister { + using PA = RegisterMask; + }; + struct CMAR1 : public MemRegister { + using MA = RegisterMask; + }; + struct CCR2 : public MemRegister { + using EN = RegisterMask; + using TCIE = RegisterMask; + using HTIE = RegisterMask; + using TEIE = RegisterMask; + using DIR = RegisterMask; + using CIRC = RegisterMask; + using PINC = RegisterMask; + using MINC = RegisterMask; + using PSIZE = RegisterMask; + using MSIZE = RegisterMask; + using PL = RegisterMask; + using MEM2MEM = RegisterMask; + }; + struct CNDTR2 : public MemRegister { + using NDT = RegisterMask; + }; + struct CPAR2 : public MemRegister { + using PA = RegisterMask; + }; + struct CMAR2 : public MemRegister { + using MA = RegisterMask; + }; + struct CCR3 : public MemRegister { + using EN = RegisterMask; + using TCIE = RegisterMask; + using HTIE = RegisterMask; + using TEIE = RegisterMask; + using DIR = RegisterMask; + using CIRC = RegisterMask; + using PINC = RegisterMask; + using MINC = RegisterMask; + using PSIZE = RegisterMask; + using MSIZE = RegisterMask; + using PL = RegisterMask; + using MEM2MEM = RegisterMask; + }; + struct CNDTR3 : public MemRegister { + using NDT = RegisterMask; + }; + struct CPAR3 : public MemRegister { + using PA = RegisterMask; + }; + struct CMAR3 : public MemRegister { + using MA = RegisterMask; + }; + struct CCR4 : public MemRegister { + using EN = RegisterMask; + using TCIE = RegisterMask; + using HTIE = RegisterMask; + using TEIE = RegisterMask; + using DIR = RegisterMask; + using CIRC = RegisterMask; + using PINC = RegisterMask; + using MINC = RegisterMask; + using PSIZE = RegisterMask; + using MSIZE = RegisterMask; + using PL = RegisterMask; + using MEM2MEM = RegisterMask; + }; + struct CNDTR4 : public MemRegister { + using NDT = RegisterMask; + }; + struct CPAR4 : public MemRegister { + using PA = RegisterMask; + }; + struct CMAR4 : public MemRegister { + using MA = RegisterMask; + }; + struct CCR5 : public MemRegister { + using EN = RegisterMask; + using TCIE = RegisterMask; + using HTIE = RegisterMask; + using TEIE = RegisterMask; + using DIR = RegisterMask; + using CIRC = RegisterMask; + using PINC = RegisterMask; + using MINC = RegisterMask; + using PSIZE = RegisterMask; + using MSIZE = RegisterMask; + using PL = RegisterMask; + using MEM2MEM = RegisterMask; + }; + struct CNDTR5 : public MemRegister { + using NDT = RegisterMask; + }; + struct CPAR5 : public MemRegister { + using PA = RegisterMask; + }; + struct CMAR5 : public MemRegister { + using MA = RegisterMask; + }; + struct CCR6 : public MemRegister { + using EN = RegisterMask; + using TCIE = RegisterMask; + using HTIE = RegisterMask; + using TEIE = RegisterMask; + using DIR = RegisterMask; + using CIRC = RegisterMask; + using PINC = RegisterMask; + using MINC = RegisterMask; + using PSIZE = RegisterMask; + using MSIZE = RegisterMask; + using PL = RegisterMask; + using MEM2MEM = RegisterMask; + }; + struct CNDTR6 : public MemRegister { + using NDT = RegisterMask; + }; + struct CPAR6 : public MemRegister { + using PA = RegisterMask; + }; + struct CMAR6 : public MemRegister { + using MA = RegisterMask; + }; + struct CCR7 : public MemRegister { + using EN = RegisterMask; + using TCIE = RegisterMask; + using HTIE = RegisterMask; + using TEIE = RegisterMask; + using DIR = RegisterMask; + using CIRC = RegisterMask; + using PINC = RegisterMask; + using MINC = RegisterMask; + using PSIZE = RegisterMask; + using MSIZE = RegisterMask; + using PL = RegisterMask; + using MEM2MEM = RegisterMask; + }; + struct CNDTR7 : public MemRegister { + using NDT = RegisterMask; + }; + struct CPAR7 : public MemRegister { + using PA = RegisterMask; + }; + struct CMAR7 : public MemRegister { + using MA = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace DMA2 { + struct ISR : public MemRegister { + using GIF1 = RegisterMask; + using TCIF1 = RegisterMask; + using HTIF1 = RegisterMask; + using TEIF1 = RegisterMask; + using GIF2 = RegisterMask; + using TCIF2 = RegisterMask; + using HTIF2 = RegisterMask; + using TEIF2 = RegisterMask; + using GIF3 = RegisterMask; + using TCIF3 = RegisterMask; + using HTIF3 = RegisterMask; + using TEIF3 = RegisterMask; + using GIF4 = RegisterMask; + using TCIF4 = RegisterMask; + using HTIF4 = RegisterMask; + using TEIF4 = RegisterMask; + using GIF5 = RegisterMask; + using TCIF5 = RegisterMask; + using HTIF5 = RegisterMask; + using TEIF5 = RegisterMask; + using GIF6 = RegisterMask; + using TCIF6 = RegisterMask; + using HTIF6 = RegisterMask; + using TEIF6 = RegisterMask; + using GIF7 = RegisterMask; + using TCIF7 = RegisterMask; + using HTIF7 = RegisterMask; + using TEIF7 = RegisterMask; + }; + struct IFCR : public MemRegister { + using CGIF1 = RegisterMask; + using CTCIF1 = RegisterMask; + using CHTIF1 = RegisterMask; + using CTEIF1 = RegisterMask; + using CGIF2 = RegisterMask; + using CTCIF2 = RegisterMask; + using CHTIF2 = RegisterMask; + using CTEIF2 = RegisterMask; + using CGIF3 = RegisterMask; + using CTCIF3 = RegisterMask; + using CHTIF3 = RegisterMask; + using CTEIF3 = RegisterMask; + using CGIF4 = RegisterMask; + using CTCIF4 = RegisterMask; + using CHTIF4 = RegisterMask; + using CTEIF4 = RegisterMask; + using CGIF5 = RegisterMask; + using CTCIF5 = RegisterMask; + using CHTIF5 = RegisterMask; + using CTEIF5 = RegisterMask; + using CGIF6 = RegisterMask; + using CTCIF6 = RegisterMask; + using CHTIF6 = RegisterMask; + using CTEIF6 = RegisterMask; + using CGIF7 = RegisterMask; + using CTCIF7 = RegisterMask; + using CHTIF7 = RegisterMask; + using CTEIF7 = RegisterMask; + }; + struct CCR1 : public MemRegister { + using EN = RegisterMask; + using TCIE = RegisterMask; + using HTIE = RegisterMask; + using TEIE = RegisterMask; + using DIR = RegisterMask; + using CIRC = RegisterMask; + using PINC = RegisterMask; + using MINC = RegisterMask; + using PSIZE = RegisterMask; + using MSIZE = RegisterMask; + using PL = RegisterMask; + using MEM2MEM = RegisterMask; + }; + struct CNDTR1 : public MemRegister { + using NDT = RegisterMask; + }; + struct CPAR1 : public MemRegister { + using PA = RegisterMask; + }; + struct CMAR1 : public MemRegister { + using MA = RegisterMask; + }; + struct CCR2 : public MemRegister { + using EN = RegisterMask; + using TCIE = RegisterMask; + using HTIE = RegisterMask; + using TEIE = RegisterMask; + using DIR = RegisterMask; + using CIRC = RegisterMask; + using PINC = RegisterMask; + using MINC = RegisterMask; + using PSIZE = RegisterMask; + using MSIZE = RegisterMask; + using PL = RegisterMask; + using MEM2MEM = RegisterMask; + }; + struct CNDTR2 : public MemRegister { + using NDT = RegisterMask; + }; + struct CPAR2 : public MemRegister { + using PA = RegisterMask; + }; + struct CMAR2 : public MemRegister { + using MA = RegisterMask; + }; + struct CCR3 : public MemRegister { + using EN = RegisterMask; + using TCIE = RegisterMask; + using HTIE = RegisterMask; + using TEIE = RegisterMask; + using DIR = RegisterMask; + using CIRC = RegisterMask; + using PINC = RegisterMask; + using MINC = RegisterMask; + using PSIZE = RegisterMask; + using MSIZE = RegisterMask; + using PL = RegisterMask; + using MEM2MEM = RegisterMask; + }; + struct CNDTR3 : public MemRegister { + using NDT = RegisterMask; + }; + struct CPAR3 : public MemRegister { + using PA = RegisterMask; + }; + struct CMAR3 : public MemRegister { + using MA = RegisterMask; + }; + struct CCR4 : public MemRegister { + using EN = RegisterMask; + using TCIE = RegisterMask; + using HTIE = RegisterMask; + using TEIE = RegisterMask; + using DIR = RegisterMask; + using CIRC = RegisterMask; + using PINC = RegisterMask; + using MINC = RegisterMask; + using PSIZE = RegisterMask; + using MSIZE = RegisterMask; + using PL = RegisterMask; + using MEM2MEM = RegisterMask; + }; + struct CNDTR4 : public MemRegister { + using NDT = RegisterMask; + }; + struct CPAR4 : public MemRegister { + using PA = RegisterMask; + }; + struct CMAR4 : public MemRegister { + using MA = RegisterMask; + }; + struct CCR5 : public MemRegister { + using EN = RegisterMask; + using TCIE = RegisterMask; + using HTIE = RegisterMask; + using TEIE = RegisterMask; + using DIR = RegisterMask; + using CIRC = RegisterMask; + using PINC = RegisterMask; + using MINC = RegisterMask; + using PSIZE = RegisterMask; + using MSIZE = RegisterMask; + using PL = RegisterMask; + using MEM2MEM = RegisterMask; + }; + struct CNDTR5 : public MemRegister { + using NDT = RegisterMask; + }; + struct CPAR5 : public MemRegister { + using PA = RegisterMask; + }; + struct CMAR5 : public MemRegister { + using MA = RegisterMask; + }; + struct CCR6 : public MemRegister { + using EN = RegisterMask; + using TCIE = RegisterMask; + using HTIE = RegisterMask; + using TEIE = RegisterMask; + using DIR = RegisterMask; + using CIRC = RegisterMask; + using PINC = RegisterMask; + using MINC = RegisterMask; + using PSIZE = RegisterMask; + using MSIZE = RegisterMask; + using PL = RegisterMask; + using MEM2MEM = RegisterMask; + }; + struct CNDTR6 : public MemRegister { + using NDT = RegisterMask; + }; + struct CPAR6 : public MemRegister { + using PA = RegisterMask; + }; + struct CMAR6 : public MemRegister { + using MA = RegisterMask; + }; + struct CCR7 : public MemRegister { + using EN = RegisterMask; + using TCIE = RegisterMask; + using HTIE = RegisterMask; + using TEIE = RegisterMask; + using DIR = RegisterMask; + using CIRC = RegisterMask; + using PINC = RegisterMask; + using MINC = RegisterMask; + using PSIZE = RegisterMask; + using MSIZE = RegisterMask; + using PL = RegisterMask; + using MEM2MEM = RegisterMask; + }; + struct CNDTR7 : public MemRegister { + using NDT = RegisterMask; + }; + struct CPAR7 : public MemRegister { + using PA = RegisterMask; + }; + struct CMAR7 : public MemRegister { + using MA = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace DMAMUX { + struct C0CR : public MemRegister { + using DMAREQ_ID = RegisterMask; + using SOIE = RegisterMask; + using EGE = RegisterMask; + using SE = RegisterMask; + using SPOL = RegisterMask; + using NBREQ = RegisterMask; + using SYNC_ID = RegisterMask; + }; + struct C1CR : public MemRegister { + using DMAREQ_ID = RegisterMask; + using SOIE = RegisterMask; + using EGE = RegisterMask; + using SE = RegisterMask; + using SPOL = RegisterMask; + using NBREQ = RegisterMask; + using SYNC_ID = RegisterMask; + }; + struct C2CR : public MemRegister { + using DMAREQ_ID = RegisterMask; + using SOIE = RegisterMask; + using EGE = RegisterMask; + using SE = RegisterMask; + using SPOL = RegisterMask; + using NBREQ = RegisterMask; + using SYNC_ID = RegisterMask; + }; + struct C3CR : public MemRegister { + using DMAREQ_ID = RegisterMask; + using SOIE = RegisterMask; + using EGE = RegisterMask; + using SE = RegisterMask; + using SPOL = RegisterMask; + using NBREQ = RegisterMask; + using SYNC_ID = RegisterMask; + }; + struct C4CR : public MemRegister { + using DMAREQ_ID = RegisterMask; + using SOIE = RegisterMask; + using EGE = RegisterMask; + using SE = RegisterMask; + using SPOL = RegisterMask; + using NBREQ = RegisterMask; + using SYNC_ID = RegisterMask; + }; + struct C5CR : public MemRegister { + using DMAREQ_ID = RegisterMask; + using SOIE = RegisterMask; + using EGE = RegisterMask; + using SE = RegisterMask; + using SPOL = RegisterMask; + using NBREQ = RegisterMask; + using SYNC_ID = RegisterMask; + }; + struct C6CR : public MemRegister { + using DMAREQ_ID = RegisterMask; + using SOIE = RegisterMask; + using EGE = RegisterMask; + using SE = RegisterMask; + using SPOL = RegisterMask; + using NBREQ = RegisterMask; + using SYNC_ID = RegisterMask; + }; + struct C7CR : public MemRegister { + using DMAREQ_ID = RegisterMask; + using SOIE = RegisterMask; + using EGE = RegisterMask; + using SE = RegisterMask; + using SPOL = RegisterMask; + using NBREQ = RegisterMask; + using SYNC_ID = RegisterMask; + }; + struct C8CR : public MemRegister { + using DMAREQ_ID = RegisterMask; + using SOIE = RegisterMask; + using EGE = RegisterMask; + using SE = RegisterMask; + using SPOL = RegisterMask; + using NBREQ = RegisterMask; + using SYNC_ID = RegisterMask; + }; + struct C9CR : public MemRegister { + using DMAREQ_ID = RegisterMask; + using SOIE = RegisterMask; + using EGE = RegisterMask; + using SE = RegisterMask; + using SPOL = RegisterMask; + using NBREQ = RegisterMask; + using SYNC_ID = RegisterMask; + }; + struct C10CR : public MemRegister { + using DMAREQ_ID = RegisterMask; + using SOIE = RegisterMask; + using EGE = RegisterMask; + using SE = RegisterMask; + using SPOL = RegisterMask; + using NBREQ = RegisterMask; + using SYNC_ID = RegisterMask; + }; + struct C11CR : public MemRegister { + using DMAREQ_ID = RegisterMask; + using SOIE = RegisterMask; + using EGE = RegisterMask; + using SE = RegisterMask; + using SPOL = RegisterMask; + using NBREQ = RegisterMask; + using SYNC_ID = RegisterMask; + }; + struct CSR : public MemRegister { + using SOF0 = RegisterMask; + using SOF1 = RegisterMask; + using SOF2 = RegisterMask; + using SOF3 = RegisterMask; + using SOF4 = RegisterMask; + using SOF5 = RegisterMask; + using SOF6 = RegisterMask; + using SOF7 = RegisterMask; + using SOF8 = RegisterMask; + using SOF9 = RegisterMask; + using SOF10 = RegisterMask; + using SOF11 = RegisterMask; + }; + struct CFR : public MemRegister { + using CSOF0 = RegisterMask; + using CSOF1 = RegisterMask; + using CSOF2 = RegisterMask; + using CSOF3 = RegisterMask; + using CSOF4 = RegisterMask; + using CSOF5 = RegisterMask; + using CSOF6 = RegisterMask; + using CSOF7 = RegisterMask; + using CSOF8 = RegisterMask; + using CSOF9 = RegisterMask; + using CSOF10 = RegisterMask; + using CSOF11 = RegisterMask; + }; + struct RG0CR : public MemRegister { + using SIG_ID = RegisterMask; + using OIE = RegisterMask; + using GE = RegisterMask; + using GPOL = RegisterMask; + using GNBREQ = RegisterMask; + }; + struct RG1CR : public MemRegister { + using SIG_ID = RegisterMask; + using OIE = RegisterMask; + using GE = RegisterMask; + using GPOL = RegisterMask; + using GNBREQ = RegisterMask; + }; + struct RG2CR : public MemRegister { + using SIG_ID = RegisterMask; + using OIE = RegisterMask; + using GE = RegisterMask; + using GPOL = RegisterMask; + using GNBREQ = RegisterMask; + }; + struct RG3CR : public MemRegister { + using SIG_ID = RegisterMask; + using OIE = RegisterMask; + using GE = RegisterMask; + using GPOL = RegisterMask; + using GNBREQ = RegisterMask; + }; + struct RGSR : public MemRegister { + using OF0 = RegisterMask; + using OF1 = RegisterMask; + using OF2 = RegisterMask; + using OF3 = RegisterMask; + }; + struct RGCFR : public MemRegister { + using COF0 = RegisterMask; + using COF1 = RegisterMask; + using COF2 = RegisterMask; + using COF3 = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace EXTI { + struct RTSR1 : public MemRegister { + using RT0 = RegisterMask; + using RT1 = RegisterMask; + using RT2 = RegisterMask; + using RT3 = RegisterMask; + using RT4 = RegisterMask; + using RT5 = RegisterMask; + using RT6 = RegisterMask; + using RT7 = RegisterMask; + using RT8 = RegisterMask; + using RT9 = RegisterMask; + using RT10 = RegisterMask; + using RT11 = RegisterMask; + using RT12 = RegisterMask; + using RT13 = RegisterMask; + using RT14 = RegisterMask; + using RT15 = RegisterMask; + using RT16 = RegisterMask; + using RT17 = RegisterMask; + using RT18 = RegisterMask; + using RT19 = RegisterMask; + using RT20 = RegisterMask; + using RT21 = RegisterMask; + }; + struct FTSR1 : public MemRegister { + using FT0 = RegisterMask; + using FT1 = RegisterMask; + using FT2 = RegisterMask; + using FT3 = RegisterMask; + using FT4 = RegisterMask; + using FT5 = RegisterMask; + using FT6 = RegisterMask; + using FT7 = RegisterMask; + using FT8 = RegisterMask; + using FT9 = RegisterMask; + using FT10 = RegisterMask; + using FT11 = RegisterMask; + using FT12 = RegisterMask; + using FT13 = RegisterMask; + using FT14 = RegisterMask; + using FT15 = RegisterMask; + using FT16 = RegisterMask; + using FT17 = RegisterMask; + using FT18 = RegisterMask; + using FT19 = RegisterMask; + using FT20 = RegisterMask; + using FT21 = RegisterMask; + }; + struct SWIER1 : public MemRegister { + using SWI0 = RegisterMask; + using SWI1 = RegisterMask; + using SWI2 = RegisterMask; + using SWI3 = RegisterMask; + using SWI4 = RegisterMask; + using SWI5 = RegisterMask; + using SWI6 = RegisterMask; + using SWI7 = RegisterMask; + using SWI8 = RegisterMask; + using SWI9 = RegisterMask; + using SWI10 = RegisterMask; + using SWI11 = RegisterMask; + using SWI12 = RegisterMask; + using SWI13 = RegisterMask; + using SWI14 = RegisterMask; + using SWI15 = RegisterMask; + using SWI16 = RegisterMask; + using SWI17 = RegisterMask; + using SWI18 = RegisterMask; + using SWI19 = RegisterMask; + using SWI20 = RegisterMask; + using SWI21 = RegisterMask; + }; + struct RPR1 : public MemRegister { + using RPIF0 = RegisterMask; + using RPIF1 = RegisterMask; + using RPIF2 = RegisterMask; + using RPIF3 = RegisterMask; + using RPIF4 = RegisterMask; + using RPIF5 = RegisterMask; + using RPIF6 = RegisterMask; + using RPIF7 = RegisterMask; + using RPIF8 = RegisterMask; + using RPIF9 = RegisterMask; + using RPIF10 = RegisterMask; + using RPIF11 = RegisterMask; + using RPIF12 = RegisterMask; + using RPIF13 = RegisterMask; + using RPIF14 = RegisterMask; + using RPIF15 = RegisterMask; + using RPIF16 = RegisterMask; + using RPIF17 = RegisterMask; + using RPIF18 = RegisterMask; + using RPIF19 = RegisterMask; + using RPIF20 = RegisterMask; + using RPIF21 = RegisterMask; + }; + struct FPR1 : public MemRegister { + using FPIF0 = RegisterMask; + using FPIF1 = RegisterMask; + using FPIF2 = RegisterMask; + using FPIF3 = RegisterMask; + using FPIF4 = RegisterMask; + using FPIF5 = RegisterMask; + using FPIF6 = RegisterMask; + using FPIF7 = RegisterMask; + using FPIF8 = RegisterMask; + using FPIF9 = RegisterMask; + using FPIF10 = RegisterMask; + using FPIF11 = RegisterMask; + using FPIF12 = RegisterMask; + using FPIF13 = RegisterMask; + using FPIF14 = RegisterMask; + using FPIF15 = RegisterMask; + using FPIF16 = RegisterMask; + using FPIF17 = RegisterMask; + using FPIF18 = RegisterMask; + using FPIF19 = RegisterMask; + using FPIF20 = RegisterMask; + using FPIF21 = RegisterMask; + }; + struct EXTICR1 : public MemRegister { + using EXTI0 = RegisterMask; + using EXTI1 = RegisterMask; + using EXTI2 = RegisterMask; + using EXTI3 = RegisterMask; + }; + struct EXTICR2 : public MemRegister { + using EXTI4 = RegisterMask; + using EXTI5 = RegisterMask; + using EXTI6 = RegisterMask; + using EXTI7 = RegisterMask; + }; + struct EXTICR3 : public MemRegister { + using EXTI8 = RegisterMask; + using EXTI9 = RegisterMask; + using EXTI10 = RegisterMask; + using EXTI11 = RegisterMask; + }; + struct EXTICR4 : public MemRegister { + using EXTI12 = RegisterMask; + using EXTI13 = RegisterMask; + using EXTI14 = RegisterMask; + using EXTI15 = RegisterMask; + }; + struct IMR1 : public MemRegister { + using IM0 = RegisterMask; + using IM1 = RegisterMask; + using IM2 = RegisterMask; + using IM3 = RegisterMask; + using IM4 = RegisterMask; + using IM5 = RegisterMask; + using IM6 = RegisterMask; + using IM7 = RegisterMask; + using IM8 = RegisterMask; + using IM9 = RegisterMask; + using IM10 = RegisterMask; + using IM11 = RegisterMask; + using IM12 = RegisterMask; + using IM13 = RegisterMask; + using IM14 = RegisterMask; + using IM15 = RegisterMask; + using IM16 = RegisterMask; + using IM17 = RegisterMask; + using IM18 = RegisterMask; + using IM19 = RegisterMask; + using IM20 = RegisterMask; + using IM21 = RegisterMask; + using IM22 = RegisterMask; + using IM23 = RegisterMask; + using IM24 = RegisterMask; + using IM25 = RegisterMask; + using IM26 = RegisterMask; + using IM27 = RegisterMask; + using IM28 = RegisterMask; + using IM29 = RegisterMask; + using IM30 = RegisterMask; + using IM31 = RegisterMask; + }; + struct EMR1 : public MemRegister { + using EM0 = RegisterMask; + using EM1 = RegisterMask; + using EM2 = RegisterMask; + using EM3 = RegisterMask; + using EM4 = RegisterMask; + using EM5 = RegisterMask; + using EM6 = RegisterMask; + using EM7 = RegisterMask; + using EM8 = RegisterMask; + using EM9 = RegisterMask; + using EM10 = RegisterMask; + using EM11 = RegisterMask; + using EM12 = RegisterMask; + using EM13 = RegisterMask; + using EM14 = RegisterMask; + using EM15 = RegisterMask; + using EM16 = RegisterMask; + using EM17 = RegisterMask; + using EM18 = RegisterMask; + using EM19 = RegisterMask; + using EM20 = RegisterMask; + using EM21 = RegisterMask; + using EM22 = RegisterMask; + using EM23 = RegisterMask; + using EM24 = RegisterMask; + using EM25 = RegisterMask; + using EM26 = RegisterMask; + using EM27 = RegisterMask; + using EM28 = RegisterMask; + using EM29 = RegisterMask; + using EM30 = RegisterMask; + using EM31 = RegisterMask; + }; + struct IMR2 : public MemRegister { + using IM32 = RegisterMask; + using IM33 = RegisterMask; + using IM34 = RegisterMask; + using IM35 = RegisterMask; + using IM36 = RegisterMask; + using IM37 = RegisterMask; + }; + struct EMR2 : public MemRegister { + using EM32 = RegisterMask; + using EM33 = RegisterMask; + using EM34 = RegisterMask; + using EM35 = RegisterMask; + using EM36 = RegisterMask; + using EM37 = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace FLASH { + struct ACR : public MemRegister { + using LATENCY = RegisterMask; + using PRFTEN = RegisterMask; + using ICEN = RegisterMask; + using ICRST = RegisterMask; + using EMPTY = RegisterMask; + using DBG_SWEN = RegisterMask; + }; + struct KEYR : public MemRegister { + using KEY = RegisterMask; + }; + struct OPTKEYR : public MemRegister { + using OPTKEY = RegisterMask; + }; + struct SR : public MemRegister { + using EOP = RegisterMask; + using OPERR = RegisterMask; + using PROGERR = RegisterMask; + using WRPERR = RegisterMask; + using PGAERR = RegisterMask; + using SIZERR = RegisterMask; + using PGSERR = RegisterMask; + using MISSERR = RegisterMask; + using FASTERR = RegisterMask; + using RDERR = RegisterMask; + using OPTVERR = RegisterMask; + using BSY1 = RegisterMask; + using CFGBSY = RegisterMask; + }; + struct CR : public MemRegister { + using PG = RegisterMask; + using PER = RegisterMask; + using MER1 = RegisterMask; + using PNB = RegisterMask; + using STRT = RegisterMask; + using OPTSTRT = RegisterMask; + using FSTPG = RegisterMask; + using EOPIE = RegisterMask; + using ERRIE = RegisterMask; + using RDERRIE = RegisterMask; + using OBL_LAUNCH = RegisterMask; + using SEC_PROT = RegisterMask; + using OPTLOCK = RegisterMask; + using LOCK = RegisterMask; + }; + struct ECCR : public MemRegister { + using ADDR_ECC = RegisterMask; + using SYSF_ECC = RegisterMask; + using ECCCIE = RegisterMask; + using ECCC = RegisterMask; + using ECCD = RegisterMask; + }; + struct OPTR : public MemRegister { + using RDP = RegisterMask; + using BORR_LEV = RegisterMask; + using NRST_STOP = RegisterMask; + using NRST_STDBY = RegisterMask; + using NRST_SHDW = RegisterMask; + using IWDG_SW = RegisterMask; + using IWDG_STOP = RegisterMask; + using IWDG_STDBY = RegisterMask; + using WWDG_SW = RegisterMask; + using BDRST = RegisterMask; + using RAM_PARITY_CHECK = RegisterMask; + using BKPSRAM_HW_ERASE_DISABLE = RegisterMask; + using NBOOT_SEL = RegisterMask; + using NBOOT1 = RegisterMask; + using NBOOT0 = RegisterMask; + using NRST_MODE = RegisterMask; + using IRHEN = RegisterMask; + }; + struct WRP1AR : public MemRegister { + using WRP1A_STRT = RegisterMask; + using WRP1A_END = RegisterMask; + }; + struct WRP1BR : public MemRegister { + using WRP1B_STRT = RegisterMask; + using WRP1B_END = RegisterMask; + }; + struct SECR : public MemRegister { + using HDP1_PEND = RegisterMask; + using BOOT_LOCK = RegisterMask; + using HDP1EN = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace GPIOA { + struct MODER : public MemRegister { + using MODE0 = RegisterMask; + using MODE1 = RegisterMask; + using MODE2 = RegisterMask; + using MODE3 = RegisterMask; + using MODE4 = RegisterMask; + using MODE5 = RegisterMask; + using MODE6 = RegisterMask; + using MODE7 = RegisterMask; + using MODE8 = RegisterMask; + using MODE9 = RegisterMask; + using MODE10 = RegisterMask; + using MODE11 = RegisterMask; + using MODE12 = RegisterMask; + using MODE13 = RegisterMask; + using MODE14 = RegisterMask; + using MODE15 = RegisterMask; + }; + struct OTYPER : public MemRegister { + using OT0 = RegisterMask; + using OT1 = RegisterMask; + using OT2 = RegisterMask; + using OT3 = RegisterMask; + using OT4 = RegisterMask; + using OT5 = RegisterMask; + using OT6 = RegisterMask; + using OT7 = RegisterMask; + using OT8 = RegisterMask; + using OT9 = RegisterMask; + using OT10 = RegisterMask; + using OT11 = RegisterMask; + using OT12 = RegisterMask; + using OT13 = RegisterMask; + using OT14 = RegisterMask; + using OT15 = RegisterMask; + }; + struct OSPEEDR : public MemRegister { + using OSPEED0 = RegisterMask; + using OSPEED1 = RegisterMask; + using OSPEED2 = RegisterMask; + using OSPEED3 = RegisterMask; + using OSPEED4 = RegisterMask; + using OSPEED5 = RegisterMask; + using OSPEED6 = RegisterMask; + using OSPEED7 = RegisterMask; + using OSPEED8 = RegisterMask; + using OSPEED9 = RegisterMask; + using OSPEED10 = RegisterMask; + using OSPEED11 = RegisterMask; + using OSPEED12 = RegisterMask; + using OSPEED13 = RegisterMask; + using OSPEED14 = RegisterMask; + using OSPEED15 = RegisterMask; + }; + struct PUPDR : public MemRegister { + using PUPD0 = RegisterMask; + using PUPD1 = RegisterMask; + using PUPD2 = RegisterMask; + using PUPD3 = RegisterMask; + using PUPD4 = RegisterMask; + using PUPD5 = RegisterMask; + using PUPD6 = RegisterMask; + using PUPD7 = RegisterMask; + using PUPD8 = RegisterMask; + using PUPD9 = RegisterMask; + using PUPD10 = RegisterMask; + using PUPD11 = RegisterMask; + using PUPD12 = RegisterMask; + using PUPD13 = RegisterMask; + using PUPD14 = RegisterMask; + using PUPD15 = RegisterMask; + }; + struct IDR : public MemRegister { + using ID0 = RegisterMask; + using ID1 = RegisterMask; + using ID2 = RegisterMask; + using ID3 = RegisterMask; + using ID4 = RegisterMask; + using ID5 = RegisterMask; + using ID6 = RegisterMask; + using ID7 = RegisterMask; + using ID8 = RegisterMask; + using ID9 = RegisterMask; + using ID10 = RegisterMask; + using ID11 = RegisterMask; + using ID12 = RegisterMask; + using ID13 = RegisterMask; + using ID14 = RegisterMask; + using ID15 = RegisterMask; + }; + struct ODR : public MemRegister { + using OD0 = RegisterMask; + using OD1 = RegisterMask; + using OD2 = RegisterMask; + using OD3 = RegisterMask; + using OD4 = RegisterMask; + using OD5 = RegisterMask; + using OD6 = RegisterMask; + using OD7 = RegisterMask; + using OD8 = RegisterMask; + using OD9 = RegisterMask; + using OD10 = RegisterMask; + using OD11 = RegisterMask; + using OD12 = RegisterMask; + using OD13 = RegisterMask; + using OD14 = RegisterMask; + using OD15 = RegisterMask; + }; + struct BSRR : public MemRegister { + using BS0 = RegisterMask; + using BS1 = RegisterMask; + using BS2 = RegisterMask; + using BS3 = RegisterMask; + using BS4 = RegisterMask; + using BS5 = RegisterMask; + using BS6 = RegisterMask; + using BS7 = RegisterMask; + using BS8 = RegisterMask; + using BS9 = RegisterMask; + using BS10 = RegisterMask; + using BS11 = RegisterMask; + using BS12 = RegisterMask; + using BS13 = RegisterMask; + using BS14 = RegisterMask; + using BS15 = RegisterMask; + using BR0 = RegisterMask; + using BR1 = RegisterMask; + using BR2 = RegisterMask; + using BR3 = RegisterMask; + using BR4 = RegisterMask; + using BR5 = RegisterMask; + using BR6 = RegisterMask; + using BR7 = RegisterMask; + using BR8 = RegisterMask; + using BR9 = RegisterMask; + using BR10 = RegisterMask; + using BR11 = RegisterMask; + using BR12 = RegisterMask; + using BR13 = RegisterMask; + using BR14 = RegisterMask; + using BR15 = RegisterMask; + }; + struct LCKR : public MemRegister { + using LCK0 = RegisterMask; + using LCK1 = RegisterMask; + using LCK2 = RegisterMask; + using LCK3 = RegisterMask; + using LCK4 = RegisterMask; + using LCK5 = RegisterMask; + using LCK6 = RegisterMask; + using LCK7 = RegisterMask; + using LCK8 = RegisterMask; + using LCK9 = RegisterMask; + using LCK10 = RegisterMask; + using LCK11 = RegisterMask; + using LCK12 = RegisterMask; + using LCK13 = RegisterMask; + using LCK14 = RegisterMask; + using LCK15 = RegisterMask; + using LCKK = RegisterMask; + }; + struct AFRL : public MemRegister { + using AFSEL0 = RegisterMask; + using AFSEL1 = RegisterMask; + using AFSEL2 = RegisterMask; + using AFSEL3 = RegisterMask; + using AFSEL4 = RegisterMask; + using AFSEL5 = RegisterMask; + using AFSEL6 = RegisterMask; + using AFSEL7 = RegisterMask; + }; + struct AFRH : public MemRegister { + using AFSEL8 = RegisterMask; + using AFSEL9 = RegisterMask; + using AFSEL10 = RegisterMask; + using AFSEL11 = RegisterMask; + using AFSEL12 = RegisterMask; + using AFSEL13 = RegisterMask; + using AFSEL14 = RegisterMask; + using AFSEL15 = RegisterMask; + }; + struct BRR : public MemRegister { + using BR0 = RegisterMask; + using BR1 = RegisterMask; + using BR2 = RegisterMask; + using BR3 = RegisterMask; + using BR4 = RegisterMask; + using BR5 = RegisterMask; + using BR6 = RegisterMask; + using BR7 = RegisterMask; + using BR8 = RegisterMask; + using BR9 = RegisterMask; + using BR10 = RegisterMask; + using BR11 = RegisterMask; + using BR12 = RegisterMask; + using BR13 = RegisterMask; + using BR14 = RegisterMask; + using BR15 = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace GPIOB { + struct MODER : public MemRegister { + using MODE0 = RegisterMask; + using MODE1 = RegisterMask; + using MODE2 = RegisterMask; + using MODE3 = RegisterMask; + using MODE4 = RegisterMask; + using MODE5 = RegisterMask; + using MODE6 = RegisterMask; + using MODE7 = RegisterMask; + using MODE8 = RegisterMask; + using MODE9 = RegisterMask; + using MODE10 = RegisterMask; + using MODE11 = RegisterMask; + using MODE12 = RegisterMask; + using MODE13 = RegisterMask; + using MODE14 = RegisterMask; + using MODE15 = RegisterMask; + }; + struct OTYPER : public MemRegister { + using OT0 = RegisterMask; + using OT1 = RegisterMask; + using OT2 = RegisterMask; + using OT3 = RegisterMask; + using OT4 = RegisterMask; + using OT5 = RegisterMask; + using OT6 = RegisterMask; + using OT7 = RegisterMask; + using OT8 = RegisterMask; + using OT9 = RegisterMask; + using OT10 = RegisterMask; + using OT11 = RegisterMask; + using OT12 = RegisterMask; + using OT13 = RegisterMask; + using OT14 = RegisterMask; + using OT15 = RegisterMask; + }; + struct OSPEEDR : public MemRegister { + using OSPEED0 = RegisterMask; + using OSPEED1 = RegisterMask; + using OSPEED2 = RegisterMask; + using OSPEED3 = RegisterMask; + using OSPEED4 = RegisterMask; + using OSPEED5 = RegisterMask; + using OSPEED6 = RegisterMask; + using OSPEED7 = RegisterMask; + using OSPEED8 = RegisterMask; + using OSPEED9 = RegisterMask; + using OSPEED10 = RegisterMask; + using OSPEED11 = RegisterMask; + using OSPEED12 = RegisterMask; + using OSPEED13 = RegisterMask; + using OSPEED14 = RegisterMask; + using OSPEED15 = RegisterMask; + }; + struct PUPDR : public MemRegister { + using PUPD0 = RegisterMask; + using PUPD1 = RegisterMask; + using PUPD2 = RegisterMask; + using PUPD3 = RegisterMask; + using PUPD4 = RegisterMask; + using PUPD5 = RegisterMask; + using PUPD6 = RegisterMask; + using PUPD7 = RegisterMask; + using PUPD8 = RegisterMask; + using PUPD9 = RegisterMask; + using PUPD10 = RegisterMask; + using PUPD11 = RegisterMask; + using PUPD12 = RegisterMask; + using PUPD13 = RegisterMask; + using PUPD14 = RegisterMask; + using PUPD15 = RegisterMask; + }; + struct IDR : public MemRegister { + using ID0 = RegisterMask; + using ID1 = RegisterMask; + using ID2 = RegisterMask; + using ID3 = RegisterMask; + using ID4 = RegisterMask; + using ID5 = RegisterMask; + using ID6 = RegisterMask; + using ID7 = RegisterMask; + using ID8 = RegisterMask; + using ID9 = RegisterMask; + using ID10 = RegisterMask; + using ID11 = RegisterMask; + using ID12 = RegisterMask; + using ID13 = RegisterMask; + using ID14 = RegisterMask; + using ID15 = RegisterMask; + }; + struct ODR : public MemRegister { + using OD0 = RegisterMask; + using OD1 = RegisterMask; + using OD2 = RegisterMask; + using OD3 = RegisterMask; + using OD4 = RegisterMask; + using OD5 = RegisterMask; + using OD6 = RegisterMask; + using OD7 = RegisterMask; + using OD8 = RegisterMask; + using OD9 = RegisterMask; + using OD10 = RegisterMask; + using OD11 = RegisterMask; + using OD12 = RegisterMask; + using OD13 = RegisterMask; + using OD14 = RegisterMask; + using OD15 = RegisterMask; + }; + struct BSRR : public MemRegister { + using BS0 = RegisterMask; + using BS1 = RegisterMask; + using BS2 = RegisterMask; + using BS3 = RegisterMask; + using BS4 = RegisterMask; + using BS5 = RegisterMask; + using BS6 = RegisterMask; + using BS7 = RegisterMask; + using BS8 = RegisterMask; + using BS9 = RegisterMask; + using BS10 = RegisterMask; + using BS11 = RegisterMask; + using BS12 = RegisterMask; + using BS13 = RegisterMask; + using BS14 = RegisterMask; + using BS15 = RegisterMask; + using BR0 = RegisterMask; + using BR1 = RegisterMask; + using BR2 = RegisterMask; + using BR3 = RegisterMask; + using BR4 = RegisterMask; + using BR5 = RegisterMask; + using BR6 = RegisterMask; + using BR7 = RegisterMask; + using BR8 = RegisterMask; + using BR9 = RegisterMask; + using BR10 = RegisterMask; + using BR11 = RegisterMask; + using BR12 = RegisterMask; + using BR13 = RegisterMask; + using BR14 = RegisterMask; + using BR15 = RegisterMask; + }; + struct LCKR : public MemRegister { + using LCK0 = RegisterMask; + using LCK1 = RegisterMask; + using LCK2 = RegisterMask; + using LCK3 = RegisterMask; + using LCK4 = RegisterMask; + using LCK5 = RegisterMask; + using LCK6 = RegisterMask; + using LCK7 = RegisterMask; + using LCK8 = RegisterMask; + using LCK9 = RegisterMask; + using LCK10 = RegisterMask; + using LCK11 = RegisterMask; + using LCK12 = RegisterMask; + using LCK13 = RegisterMask; + using LCK14 = RegisterMask; + using LCK15 = RegisterMask; + using LCKK = RegisterMask; + }; + struct AFRL : public MemRegister { + using AFSEL0 = RegisterMask; + using AFSEL1 = RegisterMask; + using AFSEL2 = RegisterMask; + using AFSEL3 = RegisterMask; + using AFSEL4 = RegisterMask; + using AFSEL5 = RegisterMask; + using AFSEL6 = RegisterMask; + using AFSEL7 = RegisterMask; + }; + struct AFRH : public MemRegister { + using AFSEL8 = RegisterMask; + using AFSEL9 = RegisterMask; + using AFSEL10 = RegisterMask; + using AFSEL11 = RegisterMask; + using AFSEL12 = RegisterMask; + using AFSEL13 = RegisterMask; + using AFSEL14 = RegisterMask; + using AFSEL15 = RegisterMask; + }; + struct BRR : public MemRegister { + using BR0 = RegisterMask; + using BR1 = RegisterMask; + using BR2 = RegisterMask; + using BR3 = RegisterMask; + using BR4 = RegisterMask; + using BR5 = RegisterMask; + using BR6 = RegisterMask; + using BR7 = RegisterMask; + using BR8 = RegisterMask; + using BR9 = RegisterMask; + using BR10 = RegisterMask; + using BR11 = RegisterMask; + using BR12 = RegisterMask; + using BR13 = RegisterMask; + using BR14 = RegisterMask; + using BR15 = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace GPIOC { + struct MODER : public MemRegister { + using MODE0 = RegisterMask; + using MODE1 = RegisterMask; + using MODE2 = RegisterMask; + using MODE3 = RegisterMask; + using MODE4 = RegisterMask; + using MODE5 = RegisterMask; + using MODE6 = RegisterMask; + using MODE7 = RegisterMask; + using MODE8 = RegisterMask; + using MODE9 = RegisterMask; + using MODE10 = RegisterMask; + using MODE11 = RegisterMask; + using MODE12 = RegisterMask; + using MODE13 = RegisterMask; + using MODE14 = RegisterMask; + using MODE15 = RegisterMask; + }; + struct OTYPER : public MemRegister { + using OT0 = RegisterMask; + using OT1 = RegisterMask; + using OT2 = RegisterMask; + using OT3 = RegisterMask; + using OT4 = RegisterMask; + using OT5 = RegisterMask; + using OT6 = RegisterMask; + using OT7 = RegisterMask; + using OT8 = RegisterMask; + using OT9 = RegisterMask; + using OT10 = RegisterMask; + using OT11 = RegisterMask; + using OT12 = RegisterMask; + using OT13 = RegisterMask; + using OT14 = RegisterMask; + using OT15 = RegisterMask; + }; + struct OSPEEDR : public MemRegister { + using OSPEED0 = RegisterMask; + using OSPEED1 = RegisterMask; + using OSPEED2 = RegisterMask; + using OSPEED3 = RegisterMask; + using OSPEED4 = RegisterMask; + using OSPEED5 = RegisterMask; + using OSPEED6 = RegisterMask; + using OSPEED7 = RegisterMask; + using OSPEED8 = RegisterMask; + using OSPEED9 = RegisterMask; + using OSPEED10 = RegisterMask; + using OSPEED11 = RegisterMask; + using OSPEED12 = RegisterMask; + using OSPEED13 = RegisterMask; + using OSPEED14 = RegisterMask; + using OSPEED15 = RegisterMask; + }; + struct PUPDR : public MemRegister { + using PUPD0 = RegisterMask; + using PUPD1 = RegisterMask; + using PUPD2 = RegisterMask; + using PUPD3 = RegisterMask; + using PUPD4 = RegisterMask; + using PUPD5 = RegisterMask; + using PUPD6 = RegisterMask; + using PUPD7 = RegisterMask; + using PUPD8 = RegisterMask; + using PUPD9 = RegisterMask; + using PUPD10 = RegisterMask; + using PUPD11 = RegisterMask; + using PUPD12 = RegisterMask; + using PUPD13 = RegisterMask; + using PUPD14 = RegisterMask; + using PUPD15 = RegisterMask; + }; + struct IDR : public MemRegister { + using ID0 = RegisterMask; + using ID1 = RegisterMask; + using ID2 = RegisterMask; + using ID3 = RegisterMask; + using ID4 = RegisterMask; + using ID5 = RegisterMask; + using ID6 = RegisterMask; + using ID7 = RegisterMask; + using ID8 = RegisterMask; + using ID9 = RegisterMask; + using ID10 = RegisterMask; + using ID11 = RegisterMask; + using ID12 = RegisterMask; + using ID13 = RegisterMask; + using ID14 = RegisterMask; + using ID15 = RegisterMask; + }; + struct ODR : public MemRegister { + using OD0 = RegisterMask; + using OD1 = RegisterMask; + using OD2 = RegisterMask; + using OD3 = RegisterMask; + using OD4 = RegisterMask; + using OD5 = RegisterMask; + using OD6 = RegisterMask; + using OD7 = RegisterMask; + using OD8 = RegisterMask; + using OD9 = RegisterMask; + using OD10 = RegisterMask; + using OD11 = RegisterMask; + using OD12 = RegisterMask; + using OD13 = RegisterMask; + using OD14 = RegisterMask; + using OD15 = RegisterMask; + }; + struct BSRR : public MemRegister { + using BS0 = RegisterMask; + using BS1 = RegisterMask; + using BS2 = RegisterMask; + using BS3 = RegisterMask; + using BS4 = RegisterMask; + using BS5 = RegisterMask; + using BS6 = RegisterMask; + using BS7 = RegisterMask; + using BS8 = RegisterMask; + using BS9 = RegisterMask; + using BS10 = RegisterMask; + using BS11 = RegisterMask; + using BS12 = RegisterMask; + using BS13 = RegisterMask; + using BS14 = RegisterMask; + using BS15 = RegisterMask; + using BR0 = RegisterMask; + using BR1 = RegisterMask; + using BR2 = RegisterMask; + using BR3 = RegisterMask; + using BR4 = RegisterMask; + using BR5 = RegisterMask; + using BR6 = RegisterMask; + using BR7 = RegisterMask; + using BR8 = RegisterMask; + using BR9 = RegisterMask; + using BR10 = RegisterMask; + using BR11 = RegisterMask; + using BR12 = RegisterMask; + using BR13 = RegisterMask; + using BR14 = RegisterMask; + using BR15 = RegisterMask; + }; + struct LCKR : public MemRegister { + using LCK0 = RegisterMask; + using LCK1 = RegisterMask; + using LCK2 = RegisterMask; + using LCK3 = RegisterMask; + using LCK4 = RegisterMask; + using LCK5 = RegisterMask; + using LCK6 = RegisterMask; + using LCK7 = RegisterMask; + using LCK8 = RegisterMask; + using LCK9 = RegisterMask; + using LCK10 = RegisterMask; + using LCK11 = RegisterMask; + using LCK12 = RegisterMask; + using LCK13 = RegisterMask; + using LCK14 = RegisterMask; + using LCK15 = RegisterMask; + using LCKK = RegisterMask; + }; + struct AFRL : public MemRegister { + using AFSEL0 = RegisterMask; + using AFSEL1 = RegisterMask; + using AFSEL2 = RegisterMask; + using AFSEL3 = RegisterMask; + using AFSEL4 = RegisterMask; + using AFSEL5 = RegisterMask; + using AFSEL6 = RegisterMask; + using AFSEL7 = RegisterMask; + }; + struct AFRH : public MemRegister { + using AFSEL8 = RegisterMask; + using AFSEL9 = RegisterMask; + using AFSEL10 = RegisterMask; + using AFSEL11 = RegisterMask; + using AFSEL12 = RegisterMask; + using AFSEL13 = RegisterMask; + using AFSEL14 = RegisterMask; + using AFSEL15 = RegisterMask; + }; + struct BRR : public MemRegister { + using BR0 = RegisterMask; + using BR1 = RegisterMask; + using BR2 = RegisterMask; + using BR3 = RegisterMask; + using BR4 = RegisterMask; + using BR5 = RegisterMask; + using BR6 = RegisterMask; + using BR7 = RegisterMask; + using BR8 = RegisterMask; + using BR9 = RegisterMask; + using BR10 = RegisterMask; + using BR11 = RegisterMask; + using BR12 = RegisterMask; + using BR13 = RegisterMask; + using BR14 = RegisterMask; + using BR15 = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace GPIOD { + struct MODER : public MemRegister { + using MODE0 = RegisterMask; + using MODE1 = RegisterMask; + using MODE2 = RegisterMask; + using MODE3 = RegisterMask; + using MODE4 = RegisterMask; + using MODE5 = RegisterMask; + using MODE6 = RegisterMask; + using MODE7 = RegisterMask; + using MODE8 = RegisterMask; + using MODE9 = RegisterMask; + using MODE10 = RegisterMask; + using MODE11 = RegisterMask; + using MODE12 = RegisterMask; + using MODE13 = RegisterMask; + using MODE14 = RegisterMask; + using MODE15 = RegisterMask; + }; + struct OTYPER : public MemRegister { + using OT0 = RegisterMask; + using OT1 = RegisterMask; + using OT2 = RegisterMask; + using OT3 = RegisterMask; + using OT4 = RegisterMask; + using OT5 = RegisterMask; + using OT6 = RegisterMask; + using OT7 = RegisterMask; + using OT8 = RegisterMask; + using OT9 = RegisterMask; + using OT10 = RegisterMask; + using OT11 = RegisterMask; + using OT12 = RegisterMask; + using OT13 = RegisterMask; + using OT14 = RegisterMask; + using OT15 = RegisterMask; + }; + struct OSPEEDR : public MemRegister { + using OSPEED0 = RegisterMask; + using OSPEED1 = RegisterMask; + using OSPEED2 = RegisterMask; + using OSPEED3 = RegisterMask; + using OSPEED4 = RegisterMask; + using OSPEED5 = RegisterMask; + using OSPEED6 = RegisterMask; + using OSPEED7 = RegisterMask; + using OSPEED8 = RegisterMask; + using OSPEED9 = RegisterMask; + using OSPEED10 = RegisterMask; + using OSPEED11 = RegisterMask; + using OSPEED12 = RegisterMask; + using OSPEED13 = RegisterMask; + using OSPEED14 = RegisterMask; + using OSPEED15 = RegisterMask; + }; + struct PUPDR : public MemRegister { + using PUPD0 = RegisterMask; + using PUPD1 = RegisterMask; + using PUPD2 = RegisterMask; + using PUPD3 = RegisterMask; + using PUPD4 = RegisterMask; + using PUPD5 = RegisterMask; + using PUPD6 = RegisterMask; + using PUPD7 = RegisterMask; + using PUPD8 = RegisterMask; + using PUPD9 = RegisterMask; + using PUPD10 = RegisterMask; + using PUPD11 = RegisterMask; + using PUPD12 = RegisterMask; + using PUPD13 = RegisterMask; + using PUPD14 = RegisterMask; + using PUPD15 = RegisterMask; + }; + struct IDR : public MemRegister { + using ID0 = RegisterMask; + using ID1 = RegisterMask; + using ID2 = RegisterMask; + using ID3 = RegisterMask; + using ID4 = RegisterMask; + using ID5 = RegisterMask; + using ID6 = RegisterMask; + using ID7 = RegisterMask; + using ID8 = RegisterMask; + using ID9 = RegisterMask; + using ID10 = RegisterMask; + using ID11 = RegisterMask; + using ID12 = RegisterMask; + using ID13 = RegisterMask; + using ID14 = RegisterMask; + using ID15 = RegisterMask; + }; + struct ODR : public MemRegister { + using OD0 = RegisterMask; + using OD1 = RegisterMask; + using OD2 = RegisterMask; + using OD3 = RegisterMask; + using OD4 = RegisterMask; + using OD5 = RegisterMask; + using OD6 = RegisterMask; + using OD7 = RegisterMask; + using OD8 = RegisterMask; + using OD9 = RegisterMask; + using OD10 = RegisterMask; + using OD11 = RegisterMask; + using OD12 = RegisterMask; + using OD13 = RegisterMask; + using OD14 = RegisterMask; + using OD15 = RegisterMask; + }; + struct BSRR : public MemRegister { + using BS0 = RegisterMask; + using BS1 = RegisterMask; + using BS2 = RegisterMask; + using BS3 = RegisterMask; + using BS4 = RegisterMask; + using BS5 = RegisterMask; + using BS6 = RegisterMask; + using BS7 = RegisterMask; + using BS8 = RegisterMask; + using BS9 = RegisterMask; + using BS10 = RegisterMask; + using BS11 = RegisterMask; + using BS12 = RegisterMask; + using BS13 = RegisterMask; + using BS14 = RegisterMask; + using BS15 = RegisterMask; + using BR0 = RegisterMask; + using BR1 = RegisterMask; + using BR2 = RegisterMask; + using BR3 = RegisterMask; + using BR4 = RegisterMask; + using BR5 = RegisterMask; + using BR6 = RegisterMask; + using BR7 = RegisterMask; + using BR8 = RegisterMask; + using BR9 = RegisterMask; + using BR10 = RegisterMask; + using BR11 = RegisterMask; + using BR12 = RegisterMask; + using BR13 = RegisterMask; + using BR14 = RegisterMask; + using BR15 = RegisterMask; + }; + struct LCKR : public MemRegister { + using LCK0 = RegisterMask; + using LCK1 = RegisterMask; + using LCK2 = RegisterMask; + using LCK3 = RegisterMask; + using LCK4 = RegisterMask; + using LCK5 = RegisterMask; + using LCK6 = RegisterMask; + using LCK7 = RegisterMask; + using LCK8 = RegisterMask; + using LCK9 = RegisterMask; + using LCK10 = RegisterMask; + using LCK11 = RegisterMask; + using LCK12 = RegisterMask; + using LCK13 = RegisterMask; + using LCK14 = RegisterMask; + using LCK15 = RegisterMask; + using LCKK = RegisterMask; + }; + struct AFRL : public MemRegister { + using AFSEL0 = RegisterMask; + using AFSEL1 = RegisterMask; + using AFSEL2 = RegisterMask; + using AFSEL3 = RegisterMask; + using AFSEL4 = RegisterMask; + using AFSEL5 = RegisterMask; + using AFSEL6 = RegisterMask; + using AFSEL7 = RegisterMask; + }; + struct AFRH : public MemRegister { + using AFSEL8 = RegisterMask; + using AFSEL9 = RegisterMask; + using AFSEL10 = RegisterMask; + using AFSEL11 = RegisterMask; + using AFSEL12 = RegisterMask; + using AFSEL13 = RegisterMask; + using AFSEL14 = RegisterMask; + using AFSEL15 = RegisterMask; + }; + struct BRR : public MemRegister { + using BR0 = RegisterMask; + using BR1 = RegisterMask; + using BR2 = RegisterMask; + using BR3 = RegisterMask; + using BR4 = RegisterMask; + using BR5 = RegisterMask; + using BR6 = RegisterMask; + using BR7 = RegisterMask; + using BR8 = RegisterMask; + using BR9 = RegisterMask; + using BR10 = RegisterMask; + using BR11 = RegisterMask; + using BR12 = RegisterMask; + using BR13 = RegisterMask; + using BR14 = RegisterMask; + using BR15 = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace GPIOE { + struct MODER : public MemRegister { + using MODE0 = RegisterMask; + using MODE1 = RegisterMask; + using MODE2 = RegisterMask; + using MODE3 = RegisterMask; + using MODE4 = RegisterMask; + using MODE5 = RegisterMask; + using MODE6 = RegisterMask; + using MODE7 = RegisterMask; + using MODE8 = RegisterMask; + using MODE9 = RegisterMask; + using MODE10 = RegisterMask; + using MODE11 = RegisterMask; + using MODE12 = RegisterMask; + using MODE13 = RegisterMask; + using MODE14 = RegisterMask; + using MODE15 = RegisterMask; + }; + struct OTYPER : public MemRegister { + using OT0 = RegisterMask; + using OT1 = RegisterMask; + using OT2 = RegisterMask; + using OT3 = RegisterMask; + using OT4 = RegisterMask; + using OT5 = RegisterMask; + using OT6 = RegisterMask; + using OT7 = RegisterMask; + using OT8 = RegisterMask; + using OT9 = RegisterMask; + using OT10 = RegisterMask; + using OT11 = RegisterMask; + using OT12 = RegisterMask; + using OT13 = RegisterMask; + using OT14 = RegisterMask; + using OT15 = RegisterMask; + }; + struct OSPEEDR : public MemRegister { + using OSPEED0 = RegisterMask; + using OSPEED1 = RegisterMask; + using OSPEED2 = RegisterMask; + using OSPEED3 = RegisterMask; + using OSPEED4 = RegisterMask; + using OSPEED5 = RegisterMask; + using OSPEED6 = RegisterMask; + using OSPEED7 = RegisterMask; + using OSPEED8 = RegisterMask; + using OSPEED9 = RegisterMask; + using OSPEED10 = RegisterMask; + using OSPEED11 = RegisterMask; + using OSPEED12 = RegisterMask; + using OSPEED13 = RegisterMask; + using OSPEED14 = RegisterMask; + using OSPEED15 = RegisterMask; + }; + struct PUPDR : public MemRegister { + using PUPD0 = RegisterMask; + using PUPD1 = RegisterMask; + using PUPD2 = RegisterMask; + using PUPD3 = RegisterMask; + using PUPD4 = RegisterMask; + using PUPD5 = RegisterMask; + using PUPD6 = RegisterMask; + using PUPD7 = RegisterMask; + using PUPD8 = RegisterMask; + using PUPD9 = RegisterMask; + using PUPD10 = RegisterMask; + using PUPD11 = RegisterMask; + using PUPD12 = RegisterMask; + using PUPD13 = RegisterMask; + using PUPD14 = RegisterMask; + using PUPD15 = RegisterMask; + }; + struct IDR : public MemRegister { + using ID0 = RegisterMask; + using ID1 = RegisterMask; + using ID2 = RegisterMask; + using ID3 = RegisterMask; + using ID4 = RegisterMask; + using ID5 = RegisterMask; + using ID6 = RegisterMask; + using ID7 = RegisterMask; + using ID8 = RegisterMask; + using ID9 = RegisterMask; + using ID10 = RegisterMask; + using ID11 = RegisterMask; + using ID12 = RegisterMask; + using ID13 = RegisterMask; + using ID14 = RegisterMask; + using ID15 = RegisterMask; + }; + struct ODR : public MemRegister { + using OD0 = RegisterMask; + using OD1 = RegisterMask; + using OD2 = RegisterMask; + using OD3 = RegisterMask; + using OD4 = RegisterMask; + using OD5 = RegisterMask; + using OD6 = RegisterMask; + using OD7 = RegisterMask; + using OD8 = RegisterMask; + using OD9 = RegisterMask; + using OD10 = RegisterMask; + using OD11 = RegisterMask; + using OD12 = RegisterMask; + using OD13 = RegisterMask; + using OD14 = RegisterMask; + using OD15 = RegisterMask; + }; + struct BSRR : public MemRegister { + using BS0 = RegisterMask; + using BS1 = RegisterMask; + using BS2 = RegisterMask; + using BS3 = RegisterMask; + using BS4 = RegisterMask; + using BS5 = RegisterMask; + using BS6 = RegisterMask; + using BS7 = RegisterMask; + using BS8 = RegisterMask; + using BS9 = RegisterMask; + using BS10 = RegisterMask; + using BS11 = RegisterMask; + using BS12 = RegisterMask; + using BS13 = RegisterMask; + using BS14 = RegisterMask; + using BS15 = RegisterMask; + using BR0 = RegisterMask; + using BR1 = RegisterMask; + using BR2 = RegisterMask; + using BR3 = RegisterMask; + using BR4 = RegisterMask; + using BR5 = RegisterMask; + using BR6 = RegisterMask; + using BR7 = RegisterMask; + using BR8 = RegisterMask; + using BR9 = RegisterMask; + using BR10 = RegisterMask; + using BR11 = RegisterMask; + using BR12 = RegisterMask; + using BR13 = RegisterMask; + using BR14 = RegisterMask; + using BR15 = RegisterMask; + }; + struct LCKR : public MemRegister { + using LCK0 = RegisterMask; + using LCK1 = RegisterMask; + using LCK2 = RegisterMask; + using LCK3 = RegisterMask; + using LCK4 = RegisterMask; + using LCK5 = RegisterMask; + using LCK6 = RegisterMask; + using LCK7 = RegisterMask; + using LCK8 = RegisterMask; + using LCK9 = RegisterMask; + using LCK10 = RegisterMask; + using LCK11 = RegisterMask; + using LCK12 = RegisterMask; + using LCK13 = RegisterMask; + using LCK14 = RegisterMask; + using LCK15 = RegisterMask; + using LCKK = RegisterMask; + }; + struct AFRL : public MemRegister { + using AFSEL0 = RegisterMask; + using AFSEL1 = RegisterMask; + using AFSEL2 = RegisterMask; + using AFSEL3 = RegisterMask; + using AFSEL4 = RegisterMask; + using AFSEL5 = RegisterMask; + using AFSEL6 = RegisterMask; + using AFSEL7 = RegisterMask; + }; + struct AFRH : public MemRegister { + using AFSEL8 = RegisterMask; + using AFSEL9 = RegisterMask; + using AFSEL10 = RegisterMask; + using AFSEL11 = RegisterMask; + using AFSEL12 = RegisterMask; + using AFSEL13 = RegisterMask; + using AFSEL14 = RegisterMask; + using AFSEL15 = RegisterMask; + }; + struct BRR : public MemRegister { + using BR0 = RegisterMask; + using BR1 = RegisterMask; + using BR2 = RegisterMask; + using BR3 = RegisterMask; + using BR4 = RegisterMask; + using BR5 = RegisterMask; + using BR6 = RegisterMask; + using BR7 = RegisterMask; + using BR8 = RegisterMask; + using BR9 = RegisterMask; + using BR10 = RegisterMask; + using BR11 = RegisterMask; + using BR12 = RegisterMask; + using BR13 = RegisterMask; + using BR14 = RegisterMask; + using BR15 = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace GPIOF { + struct MODER : public MemRegister { + using MODE0 = RegisterMask; + using MODE1 = RegisterMask; + using MODE2 = RegisterMask; + using MODE3 = RegisterMask; + using MODE4 = RegisterMask; + using MODE5 = RegisterMask; + using MODE6 = RegisterMask; + using MODE7 = RegisterMask; + using MODE8 = RegisterMask; + using MODE9 = RegisterMask; + using MODE10 = RegisterMask; + using MODE11 = RegisterMask; + using MODE12 = RegisterMask; + using MODE13 = RegisterMask; + using MODE14 = RegisterMask; + using MODE15 = RegisterMask; + }; + struct OTYPER : public MemRegister { + using OT0 = RegisterMask; + using OT1 = RegisterMask; + using OT2 = RegisterMask; + using OT3 = RegisterMask; + using OT4 = RegisterMask; + using OT5 = RegisterMask; + using OT6 = RegisterMask; + using OT7 = RegisterMask; + using OT8 = RegisterMask; + using OT9 = RegisterMask; + using OT10 = RegisterMask; + using OT11 = RegisterMask; + using OT12 = RegisterMask; + using OT13 = RegisterMask; + using OT14 = RegisterMask; + using OT15 = RegisterMask; + }; + struct OSPEEDR : public MemRegister { + using OSPEED0 = RegisterMask; + using OSPEED1 = RegisterMask; + using OSPEED2 = RegisterMask; + using OSPEED3 = RegisterMask; + using OSPEED4 = RegisterMask; + using OSPEED5 = RegisterMask; + using OSPEED6 = RegisterMask; + using OSPEED7 = RegisterMask; + using OSPEED8 = RegisterMask; + using OSPEED9 = RegisterMask; + using OSPEED10 = RegisterMask; + using OSPEED11 = RegisterMask; + using OSPEED12 = RegisterMask; + using OSPEED13 = RegisterMask; + using OSPEED14 = RegisterMask; + using OSPEED15 = RegisterMask; + }; + struct PUPDR : public MemRegister { + using PUPD0 = RegisterMask; + using PUPD1 = RegisterMask; + using PUPD2 = RegisterMask; + using PUPD3 = RegisterMask; + using PUPD4 = RegisterMask; + using PUPD5 = RegisterMask; + using PUPD6 = RegisterMask; + using PUPD7 = RegisterMask; + using PUPD8 = RegisterMask; + using PUPD9 = RegisterMask; + using PUPD10 = RegisterMask; + using PUPD11 = RegisterMask; + using PUPD12 = RegisterMask; + using PUPD13 = RegisterMask; + using PUPD14 = RegisterMask; + using PUPD15 = RegisterMask; + }; + struct IDR : public MemRegister { + using ID0 = RegisterMask; + using ID1 = RegisterMask; + using ID2 = RegisterMask; + using ID3 = RegisterMask; + using ID4 = RegisterMask; + using ID5 = RegisterMask; + using ID6 = RegisterMask; + using ID7 = RegisterMask; + using ID8 = RegisterMask; + using ID9 = RegisterMask; + using ID10 = RegisterMask; + using ID11 = RegisterMask; + using ID12 = RegisterMask; + using ID13 = RegisterMask; + using ID14 = RegisterMask; + using ID15 = RegisterMask; + }; + struct ODR : public MemRegister { + using OD0 = RegisterMask; + using OD1 = RegisterMask; + using OD2 = RegisterMask; + using OD3 = RegisterMask; + using OD4 = RegisterMask; + using OD5 = RegisterMask; + using OD6 = RegisterMask; + using OD7 = RegisterMask; + using OD8 = RegisterMask; + using OD9 = RegisterMask; + using OD10 = RegisterMask; + using OD11 = RegisterMask; + using OD12 = RegisterMask; + using OD13 = RegisterMask; + using OD14 = RegisterMask; + using OD15 = RegisterMask; + }; + struct BSRR : public MemRegister { + using BS0 = RegisterMask; + using BS1 = RegisterMask; + using BS2 = RegisterMask; + using BS3 = RegisterMask; + using BS4 = RegisterMask; + using BS5 = RegisterMask; + using BS6 = RegisterMask; + using BS7 = RegisterMask; + using BS8 = RegisterMask; + using BS9 = RegisterMask; + using BS10 = RegisterMask; + using BS11 = RegisterMask; + using BS12 = RegisterMask; + using BS13 = RegisterMask; + using BS14 = RegisterMask; + using BS15 = RegisterMask; + using BR0 = RegisterMask; + using BR1 = RegisterMask; + using BR2 = RegisterMask; + using BR3 = RegisterMask; + using BR4 = RegisterMask; + using BR5 = RegisterMask; + using BR6 = RegisterMask; + using BR7 = RegisterMask; + using BR8 = RegisterMask; + using BR9 = RegisterMask; + using BR10 = RegisterMask; + using BR11 = RegisterMask; + using BR12 = RegisterMask; + using BR13 = RegisterMask; + using BR14 = RegisterMask; + using BR15 = RegisterMask; + }; + struct LCKR : public MemRegister { + using LCK0 = RegisterMask; + using LCK1 = RegisterMask; + using LCK2 = RegisterMask; + using LCK3 = RegisterMask; + using LCK4 = RegisterMask; + using LCK5 = RegisterMask; + using LCK6 = RegisterMask; + using LCK7 = RegisterMask; + using LCK8 = RegisterMask; + using LCK9 = RegisterMask; + using LCK10 = RegisterMask; + using LCK11 = RegisterMask; + using LCK12 = RegisterMask; + using LCK13 = RegisterMask; + using LCK14 = RegisterMask; + using LCK15 = RegisterMask; + using LCKK = RegisterMask; + }; + struct AFRL : public MemRegister { + using AFSEL0 = RegisterMask; + using AFSEL1 = RegisterMask; + using AFSEL2 = RegisterMask; + using AFSEL3 = RegisterMask; + using AFSEL4 = RegisterMask; + using AFSEL5 = RegisterMask; + using AFSEL6 = RegisterMask; + using AFSEL7 = RegisterMask; + }; + struct AFRH : public MemRegister { + using AFSEL8 = RegisterMask; + using AFSEL9 = RegisterMask; + using AFSEL10 = RegisterMask; + using AFSEL11 = RegisterMask; + using AFSEL12 = RegisterMask; + using AFSEL13 = RegisterMask; + using AFSEL14 = RegisterMask; + using AFSEL15 = RegisterMask; + }; + struct BRR : public MemRegister { + using BR0 = RegisterMask; + using BR1 = RegisterMask; + using BR2 = RegisterMask; + using BR3 = RegisterMask; + using BR4 = RegisterMask; + using BR5 = RegisterMask; + using BR6 = RegisterMask; + using BR7 = RegisterMask; + using BR8 = RegisterMask; + using BR9 = RegisterMask; + using BR10 = RegisterMask; + using BR11 = RegisterMask; + using BR12 = RegisterMask; + using BR13 = RegisterMask; + using BR14 = RegisterMask; + using BR15 = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace I2C1 { + struct CR1 : public MemRegister { + using PE = RegisterMask; + using TXIE = RegisterMask; + using RXIE = RegisterMask; + using ADDRIE = RegisterMask; + using NACKIE = RegisterMask; + using STOPIE = RegisterMask; + using TCIE = RegisterMask; + using ERRIE = RegisterMask; + using DNF = RegisterMask; + using ANFOFF = RegisterMask; + using TXDMAEN = RegisterMask; + using RXDMAEN = RegisterMask; + using SBC = RegisterMask; + using NOSTRETCH = RegisterMask; + using WUPEN = RegisterMask; + using GCEN = RegisterMask; + using FMP = RegisterMask; + using ADDRACLR = RegisterMask; + using STOPFACLR = RegisterMask; + }; + struct CR2 : public MemRegister { + using SADD = RegisterMask; + using RD_WRN = RegisterMask; + using ADD10 = RegisterMask; + using HEAD10R = RegisterMask; + using START = RegisterMask; + using STOP = RegisterMask; + using NACK = RegisterMask; + using NBYTES = RegisterMask; + using RELOAD = RegisterMask; + using AUTOEND = RegisterMask; + }; + struct OAR1 : public MemRegister { + using OA1 = RegisterMask; + using OA1MODE = RegisterMask; + using OA1EN = RegisterMask; + }; + struct OAR2 : public MemRegister { + using OA2 = RegisterMask; + using OA2MSK = RegisterMask; + using OA2EN = RegisterMask; + }; + struct TIMINGR : public MemRegister { + using SCLL = RegisterMask; + using SCLH = RegisterMask; + using SDADEL = RegisterMask; + using SCLDEL = RegisterMask; + using PRESC = RegisterMask; + }; + struct TIMEOUTR : public MemRegister { + using TIMEOUTA = RegisterMask; + using TIDLE = RegisterMask; + using TIMOUTEN = RegisterMask; + using TIMEOUTB = RegisterMask; + using TEXTEN = RegisterMask; + }; + struct ISR : public MemRegister { + using TXE = RegisterMask; + using TXIS = RegisterMask; + using RXNE = RegisterMask; + using ADDR = RegisterMask; + using NACKF = RegisterMask; + using STOPF = RegisterMask; + using TC = RegisterMask; + using TCR = RegisterMask; + using BERR = RegisterMask; + using ARLO = RegisterMask; + using OVR = RegisterMask; + using BUSY = RegisterMask; + using DIR = RegisterMask; + using ADDCODE = RegisterMask; + }; + struct ICR : public MemRegister { + using ADDRCF = RegisterMask; + using NACKCF = RegisterMask; + using STOPCF = RegisterMask; + using BERRCF = RegisterMask; + using ARLOCF = RegisterMask; + using OVRCF = RegisterMask; + }; + struct PECR : public MemRegister { + using PEC = RegisterMask; + }; + struct RXDR : public MemRegister { + using RXDATA = RegisterMask; + }; + struct TXDR : public MemRegister { + using TXDATA = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace I2C2 { + struct CR1 : public MemRegister { + using PE = RegisterMask; + using TXIE = RegisterMask; + using RXIE = RegisterMask; + using ADDRIE = RegisterMask; + using NACKIE = RegisterMask; + using STOPIE = RegisterMask; + using TCIE = RegisterMask; + using ERRIE = RegisterMask; + using DNF = RegisterMask; + using ANFOFF = RegisterMask; + using TXDMAEN = RegisterMask; + using RXDMAEN = RegisterMask; + using SBC = RegisterMask; + using NOSTRETCH = RegisterMask; + using WUPEN = RegisterMask; + using GCEN = RegisterMask; + using FMP = RegisterMask; + using ADDRACLR = RegisterMask; + using STOPFACLR = RegisterMask; + }; + struct CR2 : public MemRegister { + using SADD = RegisterMask; + using RD_WRN = RegisterMask; + using ADD10 = RegisterMask; + using HEAD10R = RegisterMask; + using START = RegisterMask; + using STOP = RegisterMask; + using NACK = RegisterMask; + using NBYTES = RegisterMask; + using RELOAD = RegisterMask; + using AUTOEND = RegisterMask; + }; + struct OAR1 : public MemRegister { + using OA1 = RegisterMask; + using OA1MODE = RegisterMask; + using OA1EN = RegisterMask; + }; + struct OAR2 : public MemRegister { + using OA2 = RegisterMask; + using OA2MSK = RegisterMask; + using OA2EN = RegisterMask; + }; + struct TIMINGR : public MemRegister { + using SCLL = RegisterMask; + using SCLH = RegisterMask; + using SDADEL = RegisterMask; + using SCLDEL = RegisterMask; + using PRESC = RegisterMask; + }; + struct TIMEOUTR : public MemRegister { + using TIMEOUTA = RegisterMask; + using TIDLE = RegisterMask; + using TIMOUTEN = RegisterMask; + using TIMEOUTB = RegisterMask; + using TEXTEN = RegisterMask; + }; + struct ISR : public MemRegister { + using TXE = RegisterMask; + using TXIS = RegisterMask; + using RXNE = RegisterMask; + using ADDR = RegisterMask; + using NACKF = RegisterMask; + using STOPF = RegisterMask; + using TC = RegisterMask; + using TCR = RegisterMask; + using BERR = RegisterMask; + using ARLO = RegisterMask; + using OVR = RegisterMask; + using BUSY = RegisterMask; + using DIR = RegisterMask; + using ADDCODE = RegisterMask; + }; + struct ICR : public MemRegister { + using ADDRCF = RegisterMask; + using NACKCF = RegisterMask; + using STOPCF = RegisterMask; + using BERRCF = RegisterMask; + using ARLOCF = RegisterMask; + using OVRCF = RegisterMask; + }; + struct PECR : public MemRegister { + using PEC = RegisterMask; + }; + struct RXDR : public MemRegister { + using RXDATA = RegisterMask; + }; + struct TXDR : public MemRegister { + using TXDATA = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace I2C3 { + struct CR1 : public MemRegister { + using PE = RegisterMask; + using TXIE = RegisterMask; + using RXIE = RegisterMask; + using ADDRIE = RegisterMask; + using NACKIE = RegisterMask; + using STOPIE = RegisterMask; + using TCIE = RegisterMask; + using ERRIE = RegisterMask; + using DNF = RegisterMask; + using ANFOFF = RegisterMask; + using TXDMAEN = RegisterMask; + using RXDMAEN = RegisterMask; + using SBC = RegisterMask; + using NOSTRETCH = RegisterMask; + using WUPEN = RegisterMask; + using GCEN = RegisterMask; + using FMP = RegisterMask; + using ADDRACLR = RegisterMask; + using STOPFACLR = RegisterMask; + }; + struct CR2 : public MemRegister { + using SADD = RegisterMask; + using RD_WRN = RegisterMask; + using ADD10 = RegisterMask; + using HEAD10R = RegisterMask; + using START = RegisterMask; + using STOP = RegisterMask; + using NACK = RegisterMask; + using NBYTES = RegisterMask; + using RELOAD = RegisterMask; + using AUTOEND = RegisterMask; + }; + struct OAR1 : public MemRegister { + using OA1 = RegisterMask; + using OA1MODE = RegisterMask; + using OA1EN = RegisterMask; + }; + struct OAR2 : public MemRegister { + using OA2 = RegisterMask; + using OA2MSK = RegisterMask; + using OA2EN = RegisterMask; + }; + struct TIMINGR : public MemRegister { + using SCLL = RegisterMask; + using SCLH = RegisterMask; + using SDADEL = RegisterMask; + using SCLDEL = RegisterMask; + using PRESC = RegisterMask; + }; + struct TIMEOUTR : public MemRegister { + using TIMEOUTA = RegisterMask; + using TIDLE = RegisterMask; + using TIMOUTEN = RegisterMask; + using TIMEOUTB = RegisterMask; + using TEXTEN = RegisterMask; + }; + struct ISR : public MemRegister { + using TXE = RegisterMask; + using TXIS = RegisterMask; + using RXNE = RegisterMask; + using ADDR = RegisterMask; + using NACKF = RegisterMask; + using STOPF = RegisterMask; + using TC = RegisterMask; + using TCR = RegisterMask; + using BERR = RegisterMask; + using ARLO = RegisterMask; + using OVR = RegisterMask; + using BUSY = RegisterMask; + using DIR = RegisterMask; + using ADDCODE = RegisterMask; + }; + struct ICR : public MemRegister { + using ADDRCF = RegisterMask; + using NACKCF = RegisterMask; + using STOPCF = RegisterMask; + using BERRCF = RegisterMask; + using ARLOCF = RegisterMask; + using OVRCF = RegisterMask; + }; + struct PECR : public MemRegister { + using PEC = RegisterMask; + }; + struct RXDR : public MemRegister { + using RXDATA = RegisterMask; + }; + struct TXDR : public MemRegister { + using TXDATA = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace IWDG { + struct KR : public MemRegister { + using KEY = RegisterMask; + }; + struct PR : public MemRegister { + using val = RegisterMask; + }; + struct RLR : public MemRegister { + using RL = RegisterMask; + }; + struct SR : public MemRegister { + using PVU = RegisterMask; + using RVU = RegisterMask; + using WVU = RegisterMask; + using EWU = RegisterMask; + using ONF = RegisterMask; + using EWIF = RegisterMask; + }; + struct WINR : public MemRegister { + using WIN = RegisterMask; + }; + struct EWCR : public MemRegister { + using EWIT = RegisterMask; + using EWIC = RegisterMask; + using EWIE = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace LCD { + struct CR : public MemRegister { + using LCDEN = RegisterMask; + using VSEL = RegisterMask; + using DUTY = RegisterMask; + using BIAS = RegisterMask; + using MUX_SEG = RegisterMask; + using BUFEN = RegisterMask; + }; + struct FCR : public MemRegister { + using HD = RegisterMask; + using SOFIE = RegisterMask; + using UDDIE = RegisterMask; + using PON = RegisterMask; + using DEAD = RegisterMask; + using CC = RegisterMask; + using BLINKF = RegisterMask; + using BLINK = RegisterMask; + using DIV = RegisterMask; + using PS = RegisterMask; + }; + struct SR : public MemRegister { + using ENS = RegisterMask; + using SOF = RegisterMask; + using UDR = RegisterMask; + using UDD = RegisterMask; + using RDY = RegisterMask; + using FCRSF = RegisterMask; + }; + struct CLR : public MemRegister { + using SOFC = RegisterMask; + using UDDC = RegisterMask; + }; + struct RAM0 : public MemRegister { + using SEGMENT_DATA = RegisterMask; + }; + struct RAM1 : public MemRegister { + using SEGMENT_DATA = RegisterMask; + }; + struct RAM2 : public MemRegister { + using SEGMENT_DATA = RegisterMask; + }; + struct RAM3 : public MemRegister { + using SEGMENT_DATA = RegisterMask; + }; + struct RAM4 : public MemRegister { + using SEGMENT_DATA = RegisterMask; + }; + struct RAM5 : public MemRegister { + using SEGMENT_DATA = RegisterMask; + }; + struct RAM6 : public MemRegister { + using SEGMENT_DATA = RegisterMask; + }; + struct RAM7 : public MemRegister { + using SEGMENT_DATA = RegisterMask; + }; + struct RAM8 : public MemRegister { + using SEGMENT_DATA = RegisterMask; + }; + struct RAM9 : public MemRegister { + using SEGMENT_DATA = RegisterMask; + }; + struct RAM10 : public MemRegister { + using SEGMENT_DATA = RegisterMask; + }; + struct RAM11 : public MemRegister { + using SEGMENT_DATA = RegisterMask; + }; + struct RAM12 : public MemRegister { + using SEGMENT_DATA = RegisterMask; + }; + struct RAM13 : public MemRegister { + using SEGMENT_DATA = RegisterMask; + }; + struct RAM14 : public MemRegister { + using SEGMENT_DATA = RegisterMask; + }; + struct RAM15 : public MemRegister { + using SEGMENT_DATA = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace LPTIM1 { + struct LPTIM1_ISR_OUTPUT : public MemRegister { + using CC1IF = RegisterMask; + using ARRM = RegisterMask; + using EXTTRIG = RegisterMask; + using CMP1OK = RegisterMask; + using ARROK = RegisterMask; + using UP = RegisterMask; + using DOWN = RegisterMask; + using UE = RegisterMask; + using REPOK = RegisterMask; + using CC2IF = RegisterMask; + using CC3IF = RegisterMask; + using CC4IF = RegisterMask; + using CMP2OK = RegisterMask; + using CMP3OK = RegisterMask; + using CMP4OK = RegisterMask; + using DIEROK = RegisterMask; + }; + struct LPTIM1_ISR_INPUT : public MemRegister { + using CC1IF = RegisterMask; + using ARRM = RegisterMask; + using EXTTRIG = RegisterMask; + using ARROK = RegisterMask; + using UP = RegisterMask; + using DOWN = RegisterMask; + using UE = RegisterMask; + using REPOK = RegisterMask; + using CC2IF = RegisterMask; + using CC3IF = RegisterMask; + using CC4IF = RegisterMask; + using CC1OF = RegisterMask; + using CC2OF = RegisterMask; + using CC3OF = RegisterMask; + using CC4OF = RegisterMask; + using DIEROK = RegisterMask; + }; + struct LPTIM1_ICR_OUTPUT : public MemRegister { + using CC1CF = RegisterMask; + using ARRMCF = RegisterMask; + using EXTTRIGCF = RegisterMask; + using CMP1OKCF = RegisterMask; + using ARROKCF = RegisterMask; + using UPCF = RegisterMask; + using DOWNCF = RegisterMask; + using UECF = RegisterMask; + using REPOKCF = RegisterMask; + using CC2CF = RegisterMask; + using CC3CF = RegisterMask; + using CC4CF = RegisterMask; + using CMP2OKCF = RegisterMask; + using CMP3OKCF = RegisterMask; + using CMP4OKCF = RegisterMask; + using DIEROKCF = RegisterMask; + }; + struct LPTIM1_ICR_INPUT : public MemRegister { + using CC1CF = RegisterMask; + using ARRMCF = RegisterMask; + using EXTTRIGCF = RegisterMask; + using ARROKCF = RegisterMask; + using UPCF = RegisterMask; + using DOWNCF = RegisterMask; + using UECF = RegisterMask; + using REPOKCF = RegisterMask; + using CC2CF = RegisterMask; + using CC3CF = RegisterMask; + using CC4CF = RegisterMask; + using CC1OCF = RegisterMask; + using CC2OCF = RegisterMask; + using CC3OCF = RegisterMask; + using CC4OCF = RegisterMask; + using DIEROKCF = RegisterMask; + }; + struct LPTIM1_DIER_OUTPUT : public MemRegister { + using CC1IE = RegisterMask; + using ARRMIE = RegisterMask; + using EXTTRIGIE = RegisterMask; + using CMP1OKIE = RegisterMask; + using ARROKIE = RegisterMask; + using UPIE = RegisterMask; + using DOWNIE = RegisterMask; + using UEIE = RegisterMask; + using REPOKIE = RegisterMask; + using CC2IE = RegisterMask; + using CC3IE = RegisterMask; + using CC4IE = RegisterMask; + using CMP2OKIE = RegisterMask; + using CMP3OKIE = RegisterMask; + using CMP4OKIE = RegisterMask; + using UEDE = RegisterMask; + }; + struct LPTIM1_DIER_INPUT : public MemRegister { + using CC1IE = RegisterMask; + using ARRMIE = RegisterMask; + using EXTTRIGIE = RegisterMask; + using ARROKIE = RegisterMask; + using UPIE = RegisterMask; + using DOWNIE = RegisterMask; + using UEIE = RegisterMask; + using REPOKIE = RegisterMask; + using CC2IE = RegisterMask; + using CC3IE = RegisterMask; + using CC4IE = RegisterMask; + using CC1OIE = RegisterMask; + using CC2OIE = RegisterMask; + using CC3OIE = RegisterMask; + using CC4OIE = RegisterMask; + using CC1DE = RegisterMask; + using UEDE = RegisterMask; + using CC2DE = RegisterMask; + using CC3DE = RegisterMask; + using CC4DE = RegisterMask; + }; + struct LPTIM1_CFGR : public MemRegister { + using CKSEL = RegisterMask; + using CKPOL = RegisterMask; + using CKFLT = RegisterMask; + using TRGFLT = RegisterMask; + using PRESC = RegisterMask; + using TRIGSEL = RegisterMask; + using TRIGEN = RegisterMask; + using TIMOUT = RegisterMask; + using WAVE = RegisterMask; + using PRELOAD = RegisterMask; + using COUNTMODE = RegisterMask; + using ENC = RegisterMask; + }; + struct LPTIM1_CR : public MemRegister { + using ENABLE = RegisterMask; + using SNGSTRT = RegisterMask; + using CNTSTRT = RegisterMask; + using COUNTRST = RegisterMask; + using RSTARE = RegisterMask; + }; + struct LPTIM1_CCR1 : public MemRegister { + using CCR1 = RegisterMask; + }; + struct LPTIM1_ARR : public MemRegister { + using ARR = RegisterMask; + }; + struct LPTIM1_CNT : public MemRegister { + using CNT = RegisterMask; + }; + struct LPTIM1_CFGR2 : public MemRegister { + using IN1SEL = RegisterMask; + using IN2SEL = RegisterMask; + using IC1SEL = RegisterMask; + using IC2SEL = RegisterMask; + }; + struct LPTIM1_RCR : public MemRegister { + using REP = RegisterMask; + }; + struct LPTIM1_CCMR1 : public MemRegister { + using CC1SEL = RegisterMask; + using CC1E = RegisterMask; + using CC1P = RegisterMask; + using IC1PSC = RegisterMask; + using IC1F = RegisterMask; + using CC2SEL = RegisterMask; + using CC2E = RegisterMask; + using CC2P = RegisterMask; + using IC2PSC = RegisterMask; + using IC2F = RegisterMask; + }; + struct LPTIM1_CCMR2 : public MemRegister { + using CC3SEL = RegisterMask; + using CC3E = RegisterMask; + using CC3P = RegisterMask; + using IC3PSC = RegisterMask; + using IC3F = RegisterMask; + using CC4SEL = RegisterMask; + using CC4E = RegisterMask; + using CC4P = RegisterMask; + using IC4PSC = RegisterMask; + using IC4F = RegisterMask; + }; + struct LPTIM1_CCR2 : public MemRegister { + using CCR2 = RegisterMask; + }; + struct LPTIM1_CCR3 : public MemRegister { + using CCR3 = RegisterMask; + }; + struct LPTIM1_CCR4 : public MemRegister { + using CCR4 = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace LPTIM2 { + struct LPTIM2_ISR_OUTPUT : public MemRegister { + using CC1IF = RegisterMask; + using ARRM = RegisterMask; + using EXTTRIG = RegisterMask; + using CMP1OK = RegisterMask; + using ARROK = RegisterMask; + using UP = RegisterMask; + using DOWN = RegisterMask; + using UE = RegisterMask; + using REPOK = RegisterMask; + using CC2IF = RegisterMask; + using CC3IF = RegisterMask; + using CC4IF = RegisterMask; + using CMP2OK = RegisterMask; + using CMP3OK = RegisterMask; + using CMP4OK = RegisterMask; + using DIEROK = RegisterMask; + }; + struct LPTIM2_ISR_INPUT : public MemRegister { + using CC1IF = RegisterMask; + using ARRM = RegisterMask; + using EXTTRIG = RegisterMask; + using ARROK = RegisterMask; + using UP = RegisterMask; + using DOWN = RegisterMask; + using UE = RegisterMask; + using REPOK = RegisterMask; + using CC2IF = RegisterMask; + using CC3IF = RegisterMask; + using CC4IF = RegisterMask; + using CC1OF = RegisterMask; + using CC2OF = RegisterMask; + using CC3OF = RegisterMask; + using CC4OF = RegisterMask; + using DIEROK = RegisterMask; + }; + struct LPTIM2_ICR_OUTPUT : public MemRegister { + using CC1CF = RegisterMask; + using ARRMCF = RegisterMask; + using EXTTRIGCF = RegisterMask; + using CMP1OKCF = RegisterMask; + using ARROKCF = RegisterMask; + using UPCF = RegisterMask; + using DOWNCF = RegisterMask; + using UECF = RegisterMask; + using REPOKCF = RegisterMask; + using CC2CF = RegisterMask; + using CC3CF = RegisterMask; + using CC4CF = RegisterMask; + using CMP2OKCF = RegisterMask; + using CMP3OKCF = RegisterMask; + using CMP4OKCF = RegisterMask; + using DIEROKCF = RegisterMask; + }; + struct LPTIM2_ICR_INPUT : public MemRegister { + using CC1CF = RegisterMask; + using ARRMCF = RegisterMask; + using EXTTRIGCF = RegisterMask; + using ARROKCF = RegisterMask; + using UPCF = RegisterMask; + using DOWNCF = RegisterMask; + using UECF = RegisterMask; + using REPOKCF = RegisterMask; + using CC2CF = RegisterMask; + using CC3CF = RegisterMask; + using CC4CF = RegisterMask; + using CC1OCF = RegisterMask; + using CC2OCF = RegisterMask; + using CC3OCF = RegisterMask; + using CC4OCF = RegisterMask; + using DIEROKCF = RegisterMask; + }; + struct LPTIM2_DIER_OUTPUT : public MemRegister { + using CC1IE = RegisterMask; + using ARRMIE = RegisterMask; + using EXTTRIGIE = RegisterMask; + using CMP1OKIE = RegisterMask; + using ARROKIE = RegisterMask; + using UPIE = RegisterMask; + using DOWNIE = RegisterMask; + using UEIE = RegisterMask; + using REPOKIE = RegisterMask; + using CC2IE = RegisterMask; + using CC3IE = RegisterMask; + using CC4IE = RegisterMask; + using CMP2OKIE = RegisterMask; + using CMP3OKIE = RegisterMask; + using CMP4OKIE = RegisterMask; + using UEDE = RegisterMask; + }; + struct LPTIM2_DIER_INPUT : public MemRegister { + using CC1IE = RegisterMask; + using ARRMIE = RegisterMask; + using EXTTRIGIE = RegisterMask; + using ARROKIE = RegisterMask; + using UPIE = RegisterMask; + using DOWNIE = RegisterMask; + using UEIE = RegisterMask; + using REPOKIE = RegisterMask; + using CC2IE = RegisterMask; + using CC3IE = RegisterMask; + using CC4IE = RegisterMask; + using CC1OIE = RegisterMask; + using CC2OIE = RegisterMask; + using CC3OIE = RegisterMask; + using CC4OIE = RegisterMask; + using CC1DE = RegisterMask; + using UEDE = RegisterMask; + using CC2DE = RegisterMask; + using CC3DE = RegisterMask; + using CC4DE = RegisterMask; + }; + struct LPTIM2_CFGR : public MemRegister { + using CKSEL = RegisterMask; + using CKPOL = RegisterMask; + using CKFLT = RegisterMask; + using TRGFLT = RegisterMask; + using PRESC = RegisterMask; + using TRIGSEL = RegisterMask; + using TRIGEN = RegisterMask; + using TIMOUT = RegisterMask; + using WAVE = RegisterMask; + using PRELOAD = RegisterMask; + using COUNTMODE = RegisterMask; + using ENC = RegisterMask; + }; + struct LPTIM2_CR : public MemRegister { + using ENABLE = RegisterMask; + using SNGSTRT = RegisterMask; + using CNTSTRT = RegisterMask; + using COUNTRST = RegisterMask; + using RSTARE = RegisterMask; + }; + struct LPTIM2_CCR1 : public MemRegister { + using CCR1 = RegisterMask; + }; + struct LPTIM2_ARR : public MemRegister { + using ARR = RegisterMask; + }; + struct LPTIM2_CNT : public MemRegister { + using CNT = RegisterMask; + }; + struct LPTIM2_CFGR2 : public MemRegister { + using IN1SEL = RegisterMask; + using IN2SEL = RegisterMask; + using IC1SEL = RegisterMask; + using IC2SEL = RegisterMask; + }; + struct LPTIM2_RCR : public MemRegister { + using REP = RegisterMask; + }; + struct LPTIM2_CCMR1 : public MemRegister { + using CC1SEL = RegisterMask; + using CC1E = RegisterMask; + using CC1P = RegisterMask; + using IC1PSC = RegisterMask; + using IC1F = RegisterMask; + using CC2SEL = RegisterMask; + using CC2E = RegisterMask; + using CC2P = RegisterMask; + using IC2PSC = RegisterMask; + using IC2F = RegisterMask; + }; + struct LPTIM2_CCMR2 : public MemRegister { + using CC3SEL = RegisterMask; + using CC3E = RegisterMask; + using CC3P = RegisterMask; + using IC3PSC = RegisterMask; + using IC3F = RegisterMask; + using CC4SEL = RegisterMask; + using CC4E = RegisterMask; + using CC4P = RegisterMask; + using IC4PSC = RegisterMask; + using IC4F = RegisterMask; + }; + struct LPTIM2_CCR2 : public MemRegister { + using CCR2 = RegisterMask; + }; + struct LPTIM2_CCR3 : public MemRegister { + using CCR3 = RegisterMask; + }; + struct LPTIM2_CCR4 : public MemRegister { + using CCR4 = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace LPTIM3 { + struct LPTIM3_ISR_OUTPUT : public MemRegister { + using CC1IF = RegisterMask; + using ARRM = RegisterMask; + using EXTTRIG = RegisterMask; + using CMP1OK = RegisterMask; + using ARROK = RegisterMask; + using UP = RegisterMask; + using DOWN = RegisterMask; + using UE = RegisterMask; + using REPOK = RegisterMask; + using CC2IF = RegisterMask; + using CC3IF = RegisterMask; + using CC4IF = RegisterMask; + using CMP2OK = RegisterMask; + using CMP3OK = RegisterMask; + using CMP4OK = RegisterMask; + using DIEROK = RegisterMask; + }; + struct LPTIM3_ISR_INPUT : public MemRegister { + using CC1IF = RegisterMask; + using ARRM = RegisterMask; + using EXTTRIG = RegisterMask; + using ARROK = RegisterMask; + using UP = RegisterMask; + using DOWN = RegisterMask; + using UE = RegisterMask; + using REPOK = RegisterMask; + using CC2IF = RegisterMask; + using CC3IF = RegisterMask; + using CC4IF = RegisterMask; + using CC1OF = RegisterMask; + using CC2OF = RegisterMask; + using CC3OF = RegisterMask; + using CC4OF = RegisterMask; + using DIEROK = RegisterMask; + }; + struct LPTIM3_ICR_OUTPUT : public MemRegister { + using CC1CF = RegisterMask; + using ARRMCF = RegisterMask; + using EXTTRIGCF = RegisterMask; + using CMP1OKCF = RegisterMask; + using ARROKCF = RegisterMask; + using UPCF = RegisterMask; + using DOWNCF = RegisterMask; + using UECF = RegisterMask; + using REPOKCF = RegisterMask; + using CC2CF = RegisterMask; + using CC3CF = RegisterMask; + using CC4CF = RegisterMask; + using CMP2OKCF = RegisterMask; + using CMP3OKCF = RegisterMask; + using CMP4OKCF = RegisterMask; + using DIEROKCF = RegisterMask; + }; + struct LPTIM3_ICR_INPUT : public MemRegister { + using CC1CF = RegisterMask; + using ARRMCF = RegisterMask; + using EXTTRIGCF = RegisterMask; + using ARROKCF = RegisterMask; + using UPCF = RegisterMask; + using DOWNCF = RegisterMask; + using UECF = RegisterMask; + using REPOKCF = RegisterMask; + using CC2CF = RegisterMask; + using CC3CF = RegisterMask; + using CC4CF = RegisterMask; + using CC1OCF = RegisterMask; + using CC2OCF = RegisterMask; + using CC3OCF = RegisterMask; + using CC4OCF = RegisterMask; + using DIEROKCF = RegisterMask; + }; + struct LPTIM3_DIER_OUTPUT : public MemRegister { + using CC1IE = RegisterMask; + using ARRMIE = RegisterMask; + using EXTTRIGIE = RegisterMask; + using CMP1OKIE = RegisterMask; + using ARROKIE = RegisterMask; + using UPIE = RegisterMask; + using DOWNIE = RegisterMask; + using UEIE = RegisterMask; + using REPOKIE = RegisterMask; + using CC2IE = RegisterMask; + using CC3IE = RegisterMask; + using CC4IE = RegisterMask; + using CMP2OKIE = RegisterMask; + using CMP3OKIE = RegisterMask; + using CMP4OKIE = RegisterMask; + using UEDE = RegisterMask; + }; + struct LPTIM3_DIER_INPUT : public MemRegister { + using CC1IE = RegisterMask; + using ARRMIE = RegisterMask; + using EXTTRIGIE = RegisterMask; + using ARROKIE = RegisterMask; + using UPIE = RegisterMask; + using DOWNIE = RegisterMask; + using UEIE = RegisterMask; + using REPOKIE = RegisterMask; + using CC2IE = RegisterMask; + using CC3IE = RegisterMask; + using CC4IE = RegisterMask; + using CC1OIE = RegisterMask; + using CC2OIE = RegisterMask; + using CC3OIE = RegisterMask; + using CC4OIE = RegisterMask; + using CC1DE = RegisterMask; + using UEDE = RegisterMask; + using CC2DE = RegisterMask; + using CC3DE = RegisterMask; + using CC4DE = RegisterMask; + }; + struct LPTIM3_CFGR : public MemRegister { + using CKSEL = RegisterMask; + using CKPOL = RegisterMask; + using CKFLT = RegisterMask; + using TRGFLT = RegisterMask; + using PRESC = RegisterMask; + using TRIGSEL = RegisterMask; + using TRIGEN = RegisterMask; + using TIMOUT = RegisterMask; + using WAVE = RegisterMask; + using PRELOAD = RegisterMask; + using COUNTMODE = RegisterMask; + using ENC = RegisterMask; + }; + struct LPTIM3_CR : public MemRegister { + using ENABLE = RegisterMask; + using SNGSTRT = RegisterMask; + using CNTSTRT = RegisterMask; + using COUNTRST = RegisterMask; + using RSTARE = RegisterMask; + }; + struct LPTIM3_CCR1 : public MemRegister { + using CCR1 = RegisterMask; + }; + struct LPTIM3_ARR : public MemRegister { + using ARR = RegisterMask; + }; + struct LPTIM3_CNT : public MemRegister { + using CNT = RegisterMask; + }; + struct LPTIM3_CFGR2 : public MemRegister { + using IN1SEL = RegisterMask; + using IN2SEL = RegisterMask; + using IC1SEL = RegisterMask; + using IC2SEL = RegisterMask; + }; + struct LPTIM3_RCR : public MemRegister { + using REP = RegisterMask; + }; + struct LPTIM3_CCMR1 : public MemRegister { + using CC1SEL = RegisterMask; + using CC1E = RegisterMask; + using CC1P = RegisterMask; + using IC1PSC = RegisterMask; + using IC1F = RegisterMask; + using CC2SEL = RegisterMask; + using CC2E = RegisterMask; + using CC2P = RegisterMask; + using IC2PSC = RegisterMask; + using IC2F = RegisterMask; + }; + struct LPTIM3_CCMR2 : public MemRegister { + using CC3SEL = RegisterMask; + using CC3E = RegisterMask; + using CC3P = RegisterMask; + using IC3PSC = RegisterMask; + using IC3F = RegisterMask; + using CC4SEL = RegisterMask; + using CC4E = RegisterMask; + using CC4P = RegisterMask; + using IC4PSC = RegisterMask; + using IC4F = RegisterMask; + }; + struct LPTIM3_CCR2 : public MemRegister { + using CCR2 = RegisterMask; + }; + struct LPTIM3_CCR3 : public MemRegister { + using CCR3 = RegisterMask; + }; + struct LPTIM3_CCR4 : public MemRegister { + using CCR4 = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace LPUART1 { + struct CR1 : public MemRegister { + using UE = RegisterMask; + using UESM = RegisterMask; + using RE = RegisterMask; + using TE = RegisterMask; + using IDLEIE = RegisterMask; + using RXFNEIE = RegisterMask; + using TCIE = RegisterMask; + using TXFNFIE = RegisterMask; + using PEIE = RegisterMask; + using PS = RegisterMask; + using PCE = RegisterMask; + using WAKE = RegisterMask; + using M0 = RegisterMask; + using MME = RegisterMask; + using CMIE = RegisterMask; + using DEDT = RegisterMask; + using DEAT = RegisterMask; + using M1 = RegisterMask; + using FIFOEN = RegisterMask; + using TXFEIE = RegisterMask; + using RXFFIE = RegisterMask; + }; + struct CR1_ALTERNATE : public MemRegister { + using UE = RegisterMask; + using UESM = RegisterMask; + using RE = RegisterMask; + using TE = RegisterMask; + using IDLEIE = RegisterMask; + using RXNEIE = RegisterMask; + using TCIE = RegisterMask; + using TXEIE = RegisterMask; + using PEIE = RegisterMask; + using PS = RegisterMask; + using PCE = RegisterMask; + using WAKE = RegisterMask; + using M0 = RegisterMask; + using MME = RegisterMask; + using CMIE = RegisterMask; + using DEDT = RegisterMask; + using DEAT = RegisterMask; + using M1 = RegisterMask; + using FIFOEN = RegisterMask; + }; + struct CR2 : public MemRegister { + using ADDM7 = RegisterMask; + using STOP = RegisterMask; + using SWAP = RegisterMask; + using RXINV = RegisterMask; + using TXINV = RegisterMask; + using DATAINV = RegisterMask; + using MSBFIRST = RegisterMask; + using ADD = RegisterMask; + }; + struct CR3 : public MemRegister { + using EIE = RegisterMask; + using HDSEL = RegisterMask; + using DMAR = RegisterMask; + using DMAT = RegisterMask; + using RTSE = RegisterMask; + using CTSE = RegisterMask; + using CTSIE = RegisterMask; + using OVRDIS = RegisterMask; + using DDRE = RegisterMask; + using DEM = RegisterMask; + using DEP = RegisterMask; + using WUS0 = RegisterMask; + using WUS1 = RegisterMask; + using WUFIE = RegisterMask; + using TXFTIE = RegisterMask; + using RXFTCFG = RegisterMask; + using RXFTIE = RegisterMask; + using TXFTCFG = RegisterMask; + }; + struct BRR : public MemRegister { + using val = RegisterMask; + }; + struct RQR : public MemRegister { + using SBKRQ = RegisterMask; + using MMRQ = RegisterMask; + using RXFRQ = RegisterMask; + using TXFRQ = RegisterMask; + }; + struct ISR : public MemRegister { + using PE = RegisterMask; + using FE = RegisterMask; + using NE = RegisterMask; + using ORE = RegisterMask; + using IDLE = RegisterMask; + using RXFNE = RegisterMask; + using TC = RegisterMask; + using TXFNF = RegisterMask; + using CTSIF = RegisterMask; + using CTS = RegisterMask; + using BUSY = RegisterMask; + using CMF = RegisterMask; + using SBKF = RegisterMask; + using RWU = RegisterMask; + using WUF = RegisterMask; + using TEACK = RegisterMask; + using REACK = RegisterMask; + using TXFE = RegisterMask; + using RXFF = RegisterMask; + using RXFT = RegisterMask; + using TXFT = RegisterMask; + }; + struct ISR_ALTERNATE : public MemRegister { + using PE = RegisterMask; + using FE = RegisterMask; + using NE = RegisterMask; + using ORE = RegisterMask; + using IDLE = RegisterMask; + using RXNE = RegisterMask; + using TC = RegisterMask; + using TXE = RegisterMask; + using CTSIF = RegisterMask; + using CTS = RegisterMask; + using BUSY = RegisterMask; + using CMF = RegisterMask; + using SBKF = RegisterMask; + using RWU = RegisterMask; + using WUF = RegisterMask; + using TEACK = RegisterMask; + using REACK = RegisterMask; + }; + struct ICR : public MemRegister { + using PECF = RegisterMask; + using FECF = RegisterMask; + using NECF = RegisterMask; + using ORECF = RegisterMask; + using IDLECF = RegisterMask; + using TCCF = RegisterMask; + using CTSCF = RegisterMask; + using CMCF = RegisterMask; + using WUCF = RegisterMask; + }; + struct RDR : public MemRegister { + using val = RegisterMask; + }; + struct TDR : public MemRegister { + using val = RegisterMask; + }; + struct PRESC : public MemRegister { + using PRESCALER = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace LPUART2 { + struct CR1 : public MemRegister { + using UE = RegisterMask; + using UESM = RegisterMask; + using RE = RegisterMask; + using TE = RegisterMask; + using IDLEIE = RegisterMask; + using RXFNEIE = RegisterMask; + using TCIE = RegisterMask; + using TXFNFIE = RegisterMask; + using PEIE = RegisterMask; + using PS = RegisterMask; + using PCE = RegisterMask; + using WAKE = RegisterMask; + using M0 = RegisterMask; + using MME = RegisterMask; + using CMIE = RegisterMask; + using DEDT = RegisterMask; + using DEAT = RegisterMask; + using M1 = RegisterMask; + using FIFOEN = RegisterMask; + using TXFEIE = RegisterMask; + using RXFFIE = RegisterMask; + }; + struct CR1_ALTERNATE : public MemRegister { + using UE = RegisterMask; + using UESM = RegisterMask; + using RE = RegisterMask; + using TE = RegisterMask; + using IDLEIE = RegisterMask; + using RXNEIE = RegisterMask; + using TCIE = RegisterMask; + using TXEIE = RegisterMask; + using PEIE = RegisterMask; + using PS = RegisterMask; + using PCE = RegisterMask; + using WAKE = RegisterMask; + using M0 = RegisterMask; + using MME = RegisterMask; + using CMIE = RegisterMask; + using DEDT = RegisterMask; + using DEAT = RegisterMask; + using M1 = RegisterMask; + using FIFOEN = RegisterMask; + }; + struct CR2 : public MemRegister { + using ADDM7 = RegisterMask; + using STOP = RegisterMask; + using SWAP = RegisterMask; + using RXINV = RegisterMask; + using TXINV = RegisterMask; + using DATAINV = RegisterMask; + using MSBFIRST = RegisterMask; + using ADD = RegisterMask; + }; + struct CR3 : public MemRegister { + using EIE = RegisterMask; + using HDSEL = RegisterMask; + using DMAR = RegisterMask; + using DMAT = RegisterMask; + using RTSE = RegisterMask; + using CTSE = RegisterMask; + using CTSIE = RegisterMask; + using OVRDIS = RegisterMask; + using DDRE = RegisterMask; + using DEM = RegisterMask; + using DEP = RegisterMask; + using WUS0 = RegisterMask; + using WUS1 = RegisterMask; + using WUFIE = RegisterMask; + using TXFTIE = RegisterMask; + using RXFTCFG = RegisterMask; + using RXFTIE = RegisterMask; + using TXFTCFG = RegisterMask; + }; + struct BRR : public MemRegister { + using val = RegisterMask; + }; + struct RQR : public MemRegister { + using SBKRQ = RegisterMask; + using MMRQ = RegisterMask; + using RXFRQ = RegisterMask; + using TXFRQ = RegisterMask; + }; + struct ISR : public MemRegister { + using PE = RegisterMask; + using FE = RegisterMask; + using NE = RegisterMask; + using ORE = RegisterMask; + using IDLE = RegisterMask; + using RXFNE = RegisterMask; + using TC = RegisterMask; + using TXFNF = RegisterMask; + using CTSIF = RegisterMask; + using CTS = RegisterMask; + using BUSY = RegisterMask; + using CMF = RegisterMask; + using SBKF = RegisterMask; + using RWU = RegisterMask; + using WUF = RegisterMask; + using TEACK = RegisterMask; + using REACK = RegisterMask; + using TXFE = RegisterMask; + using RXFF = RegisterMask; + using RXFT = RegisterMask; + using TXFT = RegisterMask; + }; + struct ISR_ALTERNATE : public MemRegister { + using PE = RegisterMask; + using FE = RegisterMask; + using NE = RegisterMask; + using ORE = RegisterMask; + using IDLE = RegisterMask; + using RXNE = RegisterMask; + using TC = RegisterMask; + using TXE = RegisterMask; + using CTSIF = RegisterMask; + using CTS = RegisterMask; + using BUSY = RegisterMask; + using CMF = RegisterMask; + using SBKF = RegisterMask; + using RWU = RegisterMask; + using WUF = RegisterMask; + using TEACK = RegisterMask; + using REACK = RegisterMask; + }; + struct ICR : public MemRegister { + using PECF = RegisterMask; + using FECF = RegisterMask; + using NECF = RegisterMask; + using ORECF = RegisterMask; + using IDLECF = RegisterMask; + using TCCF = RegisterMask; + using CTSCF = RegisterMask; + using CMCF = RegisterMask; + using WUCF = RegisterMask; + }; + struct RDR : public MemRegister { + using val = RegisterMask; + }; + struct TDR : public MemRegister { + using val = RegisterMask; + }; + struct PRESC : public MemRegister { + using PRESCALER = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace LPUART3 { + struct CR1 : public MemRegister { + using UE = RegisterMask; + using UESM = RegisterMask; + using RE = RegisterMask; + using TE = RegisterMask; + using IDLEIE = RegisterMask; + using RXFNEIE = RegisterMask; + using TCIE = RegisterMask; + using TXFNFIE = RegisterMask; + using PEIE = RegisterMask; + using PS = RegisterMask; + using PCE = RegisterMask; + using WAKE = RegisterMask; + using M0 = RegisterMask; + using MME = RegisterMask; + using CMIE = RegisterMask; + using DEDT = RegisterMask; + using DEAT = RegisterMask; + using M1 = RegisterMask; + using FIFOEN = RegisterMask; + using TXFEIE = RegisterMask; + using RXFFIE = RegisterMask; + }; + struct CR1_ALTERNATE : public MemRegister { + using UE = RegisterMask; + using UESM = RegisterMask; + using RE = RegisterMask; + using TE = RegisterMask; + using IDLEIE = RegisterMask; + using RXNEIE = RegisterMask; + using TCIE = RegisterMask; + using TXEIE = RegisterMask; + using PEIE = RegisterMask; + using PS = RegisterMask; + using PCE = RegisterMask; + using WAKE = RegisterMask; + using M0 = RegisterMask; + using MME = RegisterMask; + using CMIE = RegisterMask; + using DEDT = RegisterMask; + using DEAT = RegisterMask; + using M1 = RegisterMask; + using FIFOEN = RegisterMask; + }; + struct CR2 : public MemRegister { + using ADDM7 = RegisterMask; + using STOP = RegisterMask; + using SWAP = RegisterMask; + using RXINV = RegisterMask; + using TXINV = RegisterMask; + using DATAINV = RegisterMask; + using MSBFIRST = RegisterMask; + using ADD = RegisterMask; + }; + struct CR3 : public MemRegister { + using EIE = RegisterMask; + using HDSEL = RegisterMask; + using DMAR = RegisterMask; + using DMAT = RegisterMask; + using RTSE = RegisterMask; + using CTSE = RegisterMask; + using CTSIE = RegisterMask; + using OVRDIS = RegisterMask; + using DDRE = RegisterMask; + using DEM = RegisterMask; + using DEP = RegisterMask; + using WUS0 = RegisterMask; + using WUS1 = RegisterMask; + using WUFIE = RegisterMask; + using TXFTIE = RegisterMask; + using RXFTCFG = RegisterMask; + using RXFTIE = RegisterMask; + using TXFTCFG = RegisterMask; + }; + struct BRR : public MemRegister { + using val = RegisterMask; + }; + struct RQR : public MemRegister { + using SBKRQ = RegisterMask; + using MMRQ = RegisterMask; + using RXFRQ = RegisterMask; + using TXFRQ = RegisterMask; + }; + struct ISR : public MemRegister { + using PE = RegisterMask; + using FE = RegisterMask; + using NE = RegisterMask; + using ORE = RegisterMask; + using IDLE = RegisterMask; + using RXFNE = RegisterMask; + using TC = RegisterMask; + using TXFNF = RegisterMask; + using CTSIF = RegisterMask; + using CTS = RegisterMask; + using BUSY = RegisterMask; + using CMF = RegisterMask; + using SBKF = RegisterMask; + using RWU = RegisterMask; + using WUF = RegisterMask; + using TEACK = RegisterMask; + using REACK = RegisterMask; + using TXFE = RegisterMask; + using RXFF = RegisterMask; + using RXFT = RegisterMask; + using TXFT = RegisterMask; + }; + struct ISR_ALTERNATE : public MemRegister { + using PE = RegisterMask; + using FE = RegisterMask; + using NE = RegisterMask; + using ORE = RegisterMask; + using IDLE = RegisterMask; + using RXNE = RegisterMask; + using TC = RegisterMask; + using TXE = RegisterMask; + using CTSIF = RegisterMask; + using CTS = RegisterMask; + using BUSY = RegisterMask; + using CMF = RegisterMask; + using SBKF = RegisterMask; + using RWU = RegisterMask; + using WUF = RegisterMask; + using TEACK = RegisterMask; + using REACK = RegisterMask; + }; + struct ICR : public MemRegister { + using PECF = RegisterMask; + using FECF = RegisterMask; + using NECF = RegisterMask; + using ORECF = RegisterMask; + using IDLECF = RegisterMask; + using TCCF = RegisterMask; + using CTSCF = RegisterMask; + using CMCF = RegisterMask; + using WUCF = RegisterMask; + }; + struct RDR : public MemRegister { + using val = RegisterMask; + }; + struct TDR : public MemRegister { + using val = RegisterMask; + }; + struct PRESC : public MemRegister { + using PRESCALER = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace OPAMP { + struct CSR : public MemRegister { + using OPAEN = RegisterMask; + using OPALPM = RegisterMask; + using OPAMODE = RegisterMask; + using PGA_GAIN = RegisterMask; + using VM_SEL = RegisterMask; + using VP_SEL = RegisterMask; + using CALON = RegisterMask; + using CALSEL = RegisterMask; + using USERTRIM = RegisterMask; + using CALOUT = RegisterMask; + using OPA_RANGE = RegisterMask; + }; + struct OTR : public MemRegister { + using TRIMOFFSETN = RegisterMask; + using TRIMOFFSETP = RegisterMask; + }; + struct LPOTR : public MemRegister { + using TRIMLPOFFSETN = RegisterMask; + using TRIMLPOFFSETP = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace PWR { + struct CR1 : public MemRegister { + using LPMS = RegisterMask; + using FPD_STOP = RegisterMask; + using FPD_LPRUN = RegisterMask; + using FPD_LPSLP = RegisterMask; + using DBP = RegisterMask; + using VOS = RegisterMask; + using LPR = RegisterMask; + }; + struct CR2 : public MemRegister { + using PVDE = RegisterMask; + using PLS = RegisterMask; + using PVME1 = RegisterMask; + using PVME3 = RegisterMask; + using PVME4 = RegisterMask; + using USV = RegisterMask; + }; + struct CR3 : public MemRegister { + using EWUP1 = RegisterMask; + using EWUP2 = RegisterMask; + using EWUP3 = RegisterMask; + using EWUP4 = RegisterMask; + using EWUP5 = RegisterMask; + using EWUP7 = RegisterMask; + using RRS = RegisterMask; + using ENULP = RegisterMask; + using APC = RegisterMask; + using EIWUL = RegisterMask; + }; + struct CR4 : public MemRegister { + using WP1 = RegisterMask; + using WP2 = RegisterMask; + using WP3 = RegisterMask; + using WP4 = RegisterMask; + using WP5 = RegisterMask; + using WP7 = RegisterMask; + using VBE = RegisterMask; + using VBRS = RegisterMask; + }; + struct SR1 : public MemRegister { + using WUF1 = RegisterMask; + using WUF2 = RegisterMask; + using WUF3 = RegisterMask; + using WUF4 = RegisterMask; + using WUF5 = RegisterMask; + using WUF7 = RegisterMask; + using SBF = RegisterMask; + using STOPF = RegisterMask; + using WUFI = RegisterMask; + }; + struct SR2 : public MemRegister { + using FLASH_RDY = RegisterMask; + using REGLPS = RegisterMask; + using REGLPF = RegisterMask; + using VOSF = RegisterMask; + using PVDO = RegisterMask; + using PVMO1 = RegisterMask; + using PVMO3 = RegisterMask; + using PVMO4 = RegisterMask; + }; + struct SCR : public MemRegister { + using CWUF1 = RegisterMask; + using CWUF2 = RegisterMask; + using CWUF3 = RegisterMask; + using CWUF4 = RegisterMask; + using CWUF5 = RegisterMask; + using CWUF7 = RegisterMask; + using CSBF = RegisterMask; + }; + struct PUCRA : public MemRegister { + using PU0 = RegisterMask; + using PU1 = RegisterMask; + using PU2 = RegisterMask; + using PU3 = RegisterMask; + using PU4 = RegisterMask; + using PU5 = RegisterMask; + using PU6 = RegisterMask; + using PU7 = RegisterMask; + using PU8 = RegisterMask; + using PU9 = RegisterMask; + using PU10 = RegisterMask; + using PU11 = RegisterMask; + using PU12 = RegisterMask; + using PU13 = RegisterMask; + using PU14 = RegisterMask; + using PU15 = RegisterMask; + }; + struct PDCRA : public MemRegister { + using PD0 = RegisterMask; + using PD1 = RegisterMask; + using PD2 = RegisterMask; + using PD3 = RegisterMask; + using PD4 = RegisterMask; + using PD5 = RegisterMask; + using PD6 = RegisterMask; + using PD7 = RegisterMask; + using PD8 = RegisterMask; + using PD9 = RegisterMask; + using PD10 = RegisterMask; + using PD11 = RegisterMask; + using PD12 = RegisterMask; + using PD13 = RegisterMask; + using PD14 = RegisterMask; + using PD15 = RegisterMask; + }; + struct PUCRB : public MemRegister { + using PU0 = RegisterMask; + using PU1 = RegisterMask; + using PU2 = RegisterMask; + using PU3 = RegisterMask; + using PU4 = RegisterMask; + using PU5 = RegisterMask; + using PU6 = RegisterMask; + using PU7 = RegisterMask; + using PU8 = RegisterMask; + using PU9 = RegisterMask; + using PU10 = RegisterMask; + using PU11 = RegisterMask; + using PU12 = RegisterMask; + using PU13 = RegisterMask; + using PU14 = RegisterMask; + using PU15 = RegisterMask; + }; + struct PDCRB : public MemRegister { + using PD0 = RegisterMask; + using PD1 = RegisterMask; + using PD2 = RegisterMask; + using PD3 = RegisterMask; + using PD4 = RegisterMask; + using PD5 = RegisterMask; + using PD6 = RegisterMask; + using PD7 = RegisterMask; + using PD8 = RegisterMask; + using PD9 = RegisterMask; + using PD10 = RegisterMask; + using PD11 = RegisterMask; + using PD12 = RegisterMask; + using PD13 = RegisterMask; + using PD14 = RegisterMask; + using PD15 = RegisterMask; + }; + struct PUCRC : public MemRegister { + using PU0 = RegisterMask; + using PU1 = RegisterMask; + using PU2 = RegisterMask; + using PU3 = RegisterMask; + using PU4 = RegisterMask; + using PU5 = RegisterMask; + using PU6 = RegisterMask; + using PU7 = RegisterMask; + using PU8 = RegisterMask; + using PU9 = RegisterMask; + using PU10 = RegisterMask; + using PU11 = RegisterMask; + using PU12 = RegisterMask; + using PU13 = RegisterMask; + using PU14 = RegisterMask; + using PU15 = RegisterMask; + }; + struct PDCRC : public MemRegister { + using PD0 = RegisterMask; + using PD1 = RegisterMask; + using PD2 = RegisterMask; + using PD3 = RegisterMask; + using PD4 = RegisterMask; + using PD5 = RegisterMask; + using PD6 = RegisterMask; + using PD7 = RegisterMask; + using PD8 = RegisterMask; + using PD9 = RegisterMask; + using PD10 = RegisterMask; + using PD11 = RegisterMask; + using PD12 = RegisterMask; + using PD13 = RegisterMask; + using PD14 = RegisterMask; + using PD15 = RegisterMask; + }; + struct PUCRD : public MemRegister { + using PU0 = RegisterMask; + using PU1 = RegisterMask; + using PU2 = RegisterMask; + using PU3 = RegisterMask; + using PU4 = RegisterMask; + using PU5 = RegisterMask; + using PU6 = RegisterMask; + using PU8 = RegisterMask; + using PU9 = RegisterMask; + using PU10 = RegisterMask; + using PU11 = RegisterMask; + using PU12 = RegisterMask; + using PU13 = RegisterMask; + }; + struct PDCRD : public MemRegister { + using PD0 = RegisterMask; + using PD1 = RegisterMask; + using PD2 = RegisterMask; + using PD3 = RegisterMask; + using PD4 = RegisterMask; + using PD5 = RegisterMask; + using PD6 = RegisterMask; + using PD8 = RegisterMask; + using PD9 = RegisterMask; + using PD10 = RegisterMask; + using PD11 = RegisterMask; + using PD12 = RegisterMask; + using PD13 = RegisterMask; + }; + struct PUCRE : public MemRegister { + using PU3 = RegisterMask; + using PU7 = RegisterMask; + using PU8 = RegisterMask; + using PU9 = RegisterMask; + }; + struct PDCRE : public MemRegister { + using PD3 = RegisterMask; + using PD7 = RegisterMask; + using PD8 = RegisterMask; + using PD9 = RegisterMask; + }; + struct PUCRF : public MemRegister { + using PU0 = RegisterMask; + using PU1 = RegisterMask; + using PU2 = RegisterMask; + using PU3 = RegisterMask; + }; + struct PDCRF : public MemRegister { + using PD0 = RegisterMask; + using PD1 = RegisterMask; + using PD2 = RegisterMask; + using PD3 = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace RCC { + struct CR : public MemRegister { + using MSION = RegisterMask; + using MSIRDY = RegisterMask; + using MSIPLLEN = RegisterMask; + using MSIRGSEL = RegisterMask; + using MSIRANGE = RegisterMask; + using HSION = RegisterMask; + using HSIKERON = RegisterMask; + using HSIRDY = RegisterMask; + using HSIASFS = RegisterMask; + using HSEON = RegisterMask; + using HSERDY = RegisterMask; + using HSEBYP = RegisterMask; + using CSSON = RegisterMask; + using PLLON = RegisterMask; + using PLLRDY = RegisterMask; + }; + struct ICSCR : public MemRegister { + using MSICAL = RegisterMask; + using MSITRIM = RegisterMask; + using HSICAL = RegisterMask; + using HSITRIM = RegisterMask; + }; + struct CFGR : public MemRegister { + using SW = RegisterMask; + using SWS = RegisterMask; + using HPRE = RegisterMask; + using PPRE = RegisterMask; + using STOPWUCK = RegisterMask; + using MCO2SEL = RegisterMask; + using MCO2PRE = RegisterMask; + using MCOSEL = RegisterMask; + using MCOPRE = RegisterMask; + }; + struct PLLCFGR : public MemRegister { + using PLLSRC = RegisterMask; + using PLLM = RegisterMask; + using PLLN = RegisterMask; + using PLLPEN = RegisterMask; + using PLLP = RegisterMask; + using PLLQEN = RegisterMask; + using PLLQ = RegisterMask; + using PLLREN = RegisterMask; + using PLLR = RegisterMask; + }; + struct CIER : public MemRegister { + using LSIRDYIE = RegisterMask; + using LSERDYIE = RegisterMask; + using MSIRDYIE = RegisterMask; + using HSIRDYIE = RegisterMask; + using HSERDYIE = RegisterMask; + using PLLRDYIE = RegisterMask; + using LSECSSIE = RegisterMask; + using HSI48RDYIE = RegisterMask; + }; + struct CIFR : public MemRegister { + using LSIRDYF = RegisterMask; + using LSERDYF = RegisterMask; + using MSIRDYF = RegisterMask; + using HSIRDYF = RegisterMask; + using HSERDYF = RegisterMask; + using PLLRDYF = RegisterMask; + using CSSF = RegisterMask; + using LSECSSF = RegisterMask; + using HSI48RDYF = RegisterMask; + }; + struct CICR : public MemRegister { + using LSIRDYC = RegisterMask; + using LSERDYC = RegisterMask; + using MSIRDYC = RegisterMask; + using HSIRDYC = RegisterMask; + using HSERDYC = RegisterMask; + using PLLRDYC = RegisterMask; + using CSSC = RegisterMask; + using LSECSSC = RegisterMask; + using HSI48RDYC = RegisterMask; + }; + struct AHBRSTR : public MemRegister { + using DMA1RST = RegisterMask; + using DMA2RST = RegisterMask; + using FLASHRST = RegisterMask; + using CRCRST = RegisterMask; + using AESRST = RegisterMask; + using RNGRST = RegisterMask; + using TSCRST = RegisterMask; + }; + struct IOPRSTR : public MemRegister { + using GPIOARST = RegisterMask; + using GPIOBRST = RegisterMask; + using GPIOCRST = RegisterMask; + using GPIODRST = RegisterMask; + using GPIOERST = RegisterMask; + using GPIOFRST = RegisterMask; + }; + struct APBRSTR1 : public MemRegister { + using TIM2RST = RegisterMask; + using TIM3RST = RegisterMask; + using TIM6RST = RegisterMask; + using TIM7RST = RegisterMask; + using LPUART2RST = RegisterMask; + using LCDRST = RegisterMask; + using LPUART3RST = RegisterMask; + using USBRST = RegisterMask; + using SPI2RST = RegisterMask; + using SPI3RST = RegisterMask; + using CRSRST = RegisterMask; + using USART2RST = RegisterMask; + using USART3RST = RegisterMask; + using USART4RST = RegisterMask; + using LPUART1RST = RegisterMask; + using I2C1RST = RegisterMask; + using I2C2RST = RegisterMask; + using I2C3RST = RegisterMask; + using OPAMPRST = RegisterMask; + using I2C4RST = RegisterMask; + using LPTIM3RST = RegisterMask; + using PWRRST = RegisterMask; + using DAC1RST = RegisterMask; + using LPTIM2RST = RegisterMask; + using LPTIM1RST = RegisterMask; + }; + struct APBRSTR2 : public MemRegister { + using SYSCFGRST = RegisterMask; + using TIM1RST = RegisterMask; + using SPI1RST = RegisterMask; + using USART1RST = RegisterMask; + using TIM15RST = RegisterMask; + using TIM16RST = RegisterMask; + using ADCRST = RegisterMask; + }; + struct AHBENR : public MemRegister { + using DMA1EN = RegisterMask; + using DMA2EN = RegisterMask; + using FLASHEN = RegisterMask; + using CRCEN = RegisterMask; + using AESEN = RegisterMask; + using RNGEN = RegisterMask; + using TSCEN = RegisterMask; + }; + struct IOPENR : public MemRegister { + using GPIOAEN = RegisterMask; + using GPIOBEN = RegisterMask; + using GPIOCEN = RegisterMask; + using GPIODEN = RegisterMask; + using GPIOEEN = RegisterMask; + using GPIOFEN = RegisterMask; + }; + struct DBGCFGR : public MemRegister { + using DBGEN = RegisterMask; + using DBGRST = RegisterMask; + }; + struct APBENR1 : public MemRegister { + using TIM2EN = RegisterMask; + using TIM3EN = RegisterMask; + using TIM6EN = RegisterMask; + using TIM7EN = RegisterMask; + using LPUART2EN = RegisterMask; + using LCDEN = RegisterMask; + using RTCAPBEN = RegisterMask; + using WWDGEN = RegisterMask; + using LPUART3EN = RegisterMask; + using USBEN = RegisterMask; + using SPI2EN = RegisterMask; + using SPI3EN = RegisterMask; + using CRSEN = RegisterMask; + using USART2EN = RegisterMask; + using USART3EN = RegisterMask; + using USART4EN = RegisterMask; + using LPUART1EN = RegisterMask; + using I2C1EN = RegisterMask; + using I2C2EN = RegisterMask; + using I2C3EN = RegisterMask; + using OPAMPEN = RegisterMask; + using I2C4EN = RegisterMask; + using LPTIM3EN = RegisterMask; + using PWREN = RegisterMask; + using DAC1EN = RegisterMask; + using LPTIM2EN = RegisterMask; + using LPTIM1EN = RegisterMask; + }; + struct APBENR2 : public MemRegister { + using SYSCFGEN = RegisterMask; + using TIM1EN = RegisterMask; + using SPI1EN = RegisterMask; + using USART1EN = RegisterMask; + using TIM15EN = RegisterMask; + using TIM16EN = RegisterMask; + using ADCEN = RegisterMask; + }; + struct AHBSMENR : public MemRegister { + using DMA1SMEN = RegisterMask; + using DMA2SMEN = RegisterMask; + using FLASHSMEN = RegisterMask; + using SRAMSMEN = RegisterMask; + using CRCSMEN = RegisterMask; + using AESSMEN = RegisterMask; + using RNGSMEN = RegisterMask; + using TSCSMEN = RegisterMask; + }; + struct IOPSMENR : public MemRegister { + using GPIOASMEN = RegisterMask; + using GPIOBSMEN = RegisterMask; + using GPIOCSMEN = RegisterMask; + using GPIODSMEN = RegisterMask; + using GPIOESMEN = RegisterMask; + using GPIOFSMEN = RegisterMask; + }; + struct APBSMENR1 : public MemRegister { + using TIM2SMEN = RegisterMask; + using TIM3SMEN = RegisterMask; + using TIM6SMEN = RegisterMask; + using TIM7SMEN = RegisterMask; + using LPUART2SMEN = RegisterMask; + using LCDSMEN = RegisterMask; + using RTCAPBSMEN = RegisterMask; + using WWDGSMEN = RegisterMask; + using LPUART3SMEN = RegisterMask; + using USBSMEN = RegisterMask; + using SPI2SMEN = RegisterMask; + using SPI3SMEN = RegisterMask; + using CRSSMEN = RegisterMask; + using USART2SMEN = RegisterMask; + using USART3SMEN = RegisterMask; + using USART4SMEN = RegisterMask; + using LPUART1SMEN = RegisterMask; + using I2C1SMEN = RegisterMask; + using I2C2SMEN = RegisterMask; + using I2C3SMEN = RegisterMask; + using OPAMPSMEN = RegisterMask; + using I2C4SMEN = RegisterMask; + using LPTIM3SMEN = RegisterMask; + using PWRSMEN = RegisterMask; + using DAC1SMEN = RegisterMask; + using LPTIM2SMEN = RegisterMask; + using LPTIM1SMEN = RegisterMask; + }; + struct APBSMENR2 : public MemRegister { + using SYSCFGSMEN = RegisterMask; + using TIM1SMEN = RegisterMask; + using SPI1SMEN = RegisterMask; + using USART1SMEN = RegisterMask; + using TIM15SMEN = RegisterMask; + using TIM16SMEN = RegisterMask; + using ADCSMEN = RegisterMask; + }; + struct CCIPR : public MemRegister { + using USART1SEL = RegisterMask; + using USART2SEL = RegisterMask; + using LPUART3SEL = RegisterMask; + using LPUART2SEL = RegisterMask; + using LPUART1SEL = RegisterMask; + using I2C1SEL = RegisterMask; + using I2C3SEL = RegisterMask; + using LPTIM1SEL = RegisterMask; + using LPTIM2SEL = RegisterMask; + using LPTIM3SEL = RegisterMask; + using TIM1SEL = RegisterMask; + using TIM15SEL = RegisterMask; + using CLK48SEL = RegisterMask; + using ADCSEL = RegisterMask; + }; + struct BDCR : public MemRegister { + using LSEON = RegisterMask; + using LSERDY = RegisterMask; + using LSEBYP = RegisterMask; + using LSEDRV = RegisterMask; + using LSECSSON = RegisterMask; + using LSECSSD = RegisterMask; + using LSESYSEN = RegisterMask; + using RTCSEL = RegisterMask; + using LSESYSRDY = RegisterMask; + using RTCEN = RegisterMask; + using BDRST = RegisterMask; + using LSCOEN = RegisterMask; + using LSCOSEL = RegisterMask; + }; + struct CSR : public MemRegister { + using LSION = RegisterMask; + using LSIRDY = RegisterMask; + using LSIPREDIV = RegisterMask; + using MSISRANGE = RegisterMask; + using RMVF = RegisterMask; + using OBLRSTF = RegisterMask; + using PINRSTF = RegisterMask; + using PWRRSTF = RegisterMask; + using SFTRSTF = RegisterMask; + using IWDGRSTF = RegisterMask; + using WWDGRSTF = RegisterMask; + using LPWRRSTF = RegisterMask; + }; + struct CRRCR : public MemRegister { + using HSI48ON = RegisterMask; + using HSI48RDY = RegisterMask; + using HSI48CAL = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace RNG { + struct CR : public MemRegister { + using RNGEN = RegisterMask; + using IE = RegisterMask; + using CED = RegisterMask; + using ARDIS = RegisterMask; + using RNG_CONFIG3 = RegisterMask; + using NISTC = RegisterMask; + using RNG_CONFIG2 = RegisterMask; + using CLKDIV = RegisterMask; + using RNG_CONFIG1 = RegisterMask; + using CONDRST = RegisterMask; + using CONFIGLOCK = RegisterMask; + }; + struct SR : public MemRegister { + using DRDY = RegisterMask; + using CECS = RegisterMask; + using SECS = RegisterMask; + using CEIS = RegisterMask; + using SEIS = RegisterMask; + }; + struct DR : public MemRegister { + using RNDATA = RegisterMask; + }; + struct HTCR : public MemRegister { + using HTCFG = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace RTC { + struct TR : public MemRegister { + using SU = RegisterMask; + using ST = RegisterMask; + using MNU = RegisterMask; + using MNT = RegisterMask; + using HU = RegisterMask; + using HT = RegisterMask; + using PM = RegisterMask; + }; + struct DR : public MemRegister { + using DU = RegisterMask; + using DT = RegisterMask; + using MU = RegisterMask; + using MT = RegisterMask; + using WDU = RegisterMask; + using YU = RegisterMask; + using YT = RegisterMask; + }; + struct SSR : public MemRegister { + using SS = RegisterMask; + }; + struct ICSR : public MemRegister { + using WUTWF = RegisterMask; + using SHPF = RegisterMask; + using INITS = RegisterMask; + using RSF = RegisterMask; + using INITF = RegisterMask; + using INIT = RegisterMask; + using BIN = RegisterMask; + using BCDU = RegisterMask; + using RECALPF = RegisterMask; + }; + struct PRER : public MemRegister { + using PREDIV_S = RegisterMask; + using PREDIV_A = RegisterMask; + }; + struct WUTR : public MemRegister { + using WUT = RegisterMask; + using WUTOCLR = RegisterMask; + }; + struct CR : public MemRegister { + using WUCKSEL = RegisterMask; + using TSEDGE = RegisterMask; + using REFCKON = RegisterMask; + using BYPSHAD = RegisterMask; + using FMT = RegisterMask; + using SSRUIE = RegisterMask; + using ALRAE = RegisterMask; + using ALRBE = RegisterMask; + using WUTE = RegisterMask; + using TSE = RegisterMask; + using ALRAIE = RegisterMask; + using ALRBIE = RegisterMask; + using WUTIE = RegisterMask; + using TSIE = RegisterMask; + using ADD1H = RegisterMask; + using SUB1H = RegisterMask; + using BKP = RegisterMask; + using COSEL = RegisterMask; + using POL = RegisterMask; + using OSEL = RegisterMask; + using COE = RegisterMask; + using ITSE = RegisterMask; + using TAMPTS = RegisterMask; + using TAMPOE = RegisterMask; + using ALRAFCLR = RegisterMask; + using ALRBFCLR = RegisterMask; + using TAMPALRM_PU = RegisterMask; + using TAMPALRM_TYPE = RegisterMask; + using OUT2EN = RegisterMask; + }; + struct WPR : public MemRegister { + using KEY = RegisterMask; + }; + struct CALR : public MemRegister { + using CALM = RegisterMask; + using LPCAL = RegisterMask; + using CALW16 = RegisterMask; + using CALW8 = RegisterMask; + using CALP = RegisterMask; + }; + struct SHIFTR : public MemRegister { + using SUBFS = RegisterMask; + using ADD1S = RegisterMask; + }; + struct TSTR : public MemRegister { + using SU = RegisterMask; + using ST = RegisterMask; + using MNU = RegisterMask; + using MNT = RegisterMask; + using HU = RegisterMask; + using HT = RegisterMask; + using PM = RegisterMask; + }; + struct TSDR : public MemRegister { + using DU = RegisterMask; + using DT = RegisterMask; + using MU = RegisterMask; + using MT = RegisterMask; + using WDU = RegisterMask; + }; + struct TSSSR : public MemRegister { + using SS = RegisterMask; + }; + struct ALRMAR : public MemRegister { + using SU = RegisterMask; + using ST = RegisterMask; + using MSK1 = RegisterMask; + using MNU = RegisterMask; + using MNT = RegisterMask; + using MSK2 = RegisterMask; + using HU = RegisterMask; + using HT = RegisterMask; + using PM = RegisterMask; + using MSK3 = RegisterMask; + using DU = RegisterMask; + using DT = RegisterMask; + using WDSEL = RegisterMask; + using MSK4 = RegisterMask; + }; + struct ALRMASSR : public MemRegister { + using SS = RegisterMask; + using MASKSS = RegisterMask; + using SSCLR = RegisterMask; + }; + struct ALRMBR : public MemRegister { + using SU = RegisterMask; + using ST = RegisterMask; + using MSK1 = RegisterMask; + using MNU = RegisterMask; + using MNT = RegisterMask; + using MSK2 = RegisterMask; + using HU = RegisterMask; + using HT = RegisterMask; + using PM = RegisterMask; + using MSK3 = RegisterMask; + using DU = RegisterMask; + using DT = RegisterMask; + using WDSEL = RegisterMask; + using MSK4 = RegisterMask; + }; + struct ALRMBSSR : public MemRegister { + using SS = RegisterMask; + using MASKSS = RegisterMask; + using SSCLR = RegisterMask; + }; + struct SR : public MemRegister { + using ALRAF = RegisterMask; + using ALRBF = RegisterMask; + using WUTF = RegisterMask; + using TSF = RegisterMask; + using TSOVF = RegisterMask; + using ITSF = RegisterMask; + using SSRUF = RegisterMask; + }; + struct MISR : public MemRegister { + using ALRAMF = RegisterMask; + using ALRBMF = RegisterMask; + using WUTMF = RegisterMask; + using TSMF = RegisterMask; + using TSOVMF = RegisterMask; + using ITSMF = RegisterMask; + using SSRUMF = RegisterMask; + }; + struct SCR : public MemRegister { + using CALRAF = RegisterMask; + using CALRBF = RegisterMask; + using CWUTF = RegisterMask; + using CTSF = RegisterMask; + using CTSOVF = RegisterMask; + using CITSF = RegisterMask; + using CSSRUF = RegisterMask; + }; + struct ALRABINR : public MemRegister { + using SS = RegisterMask; + }; + struct ALRBBINR : public MemRegister { + using SS = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace SPI1 { + struct CR1 : public MemRegister { + using CPHA = RegisterMask; + using CPOL = RegisterMask; + using MSTR = RegisterMask; + using BR = RegisterMask; + using SPE = RegisterMask; + using LSBFIRST = RegisterMask; + using SSI = RegisterMask; + using SSM = RegisterMask; + using RXONLY = RegisterMask; + using CRCL = RegisterMask; + using CRCNEXT = RegisterMask; + using CRCEN = RegisterMask; + using BIDIOE = RegisterMask; + using BIDIMODE = RegisterMask; + }; + struct CR2 : public MemRegister { + using RXDMAEN = RegisterMask; + using TXDMAEN = RegisterMask; + using SSOE = RegisterMask; + using NSSP = RegisterMask; + using FRF = RegisterMask; + using ERRIE = RegisterMask; + using RXNEIE = RegisterMask; + using TXEIE = RegisterMask; + using DS = RegisterMask; + using FRXTH = RegisterMask; + using LDMA_RX = RegisterMask; + using LDMA_TX = RegisterMask; + }; + struct SR : public MemRegister { + using RXNE = RegisterMask; + using TXE = RegisterMask; + using CRCERR = RegisterMask; + using MODF = RegisterMask; + using OVR = RegisterMask; + using BSY = RegisterMask; + using FRE = RegisterMask; + using FRLVL = RegisterMask; + using FTLVL = RegisterMask; + }; + struct DR : public MemRegister { + using val = RegisterMask; + }; + struct CRCPR : public MemRegister { + using CRCPOLY = RegisterMask; + }; + struct RXCRCR : public MemRegister { + using RXCRC = RegisterMask; + }; + struct TXCRCR : public MemRegister { + using TXCRC = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace SPI2 { + struct CR1 : public MemRegister { + using CPHA = RegisterMask; + using CPOL = RegisterMask; + using MSTR = RegisterMask; + using BR = RegisterMask; + using SPE = RegisterMask; + using LSBFIRST = RegisterMask; + using SSI = RegisterMask; + using SSM = RegisterMask; + using RXONLY = RegisterMask; + using CRCL = RegisterMask; + using CRCNEXT = RegisterMask; + using CRCEN = RegisterMask; + using BIDIOE = RegisterMask; + using BIDIMODE = RegisterMask; + }; + struct CR2 : public MemRegister { + using RXDMAEN = RegisterMask; + using TXDMAEN = RegisterMask; + using SSOE = RegisterMask; + using NSSP = RegisterMask; + using FRF = RegisterMask; + using ERRIE = RegisterMask; + using RXNEIE = RegisterMask; + using TXEIE = RegisterMask; + using DS = RegisterMask; + using FRXTH = RegisterMask; + using LDMA_RX = RegisterMask; + using LDMA_TX = RegisterMask; + }; + struct SR : public MemRegister { + using RXNE = RegisterMask; + using TXE = RegisterMask; + using CRCERR = RegisterMask; + using MODF = RegisterMask; + using OVR = RegisterMask; + using BSY = RegisterMask; + using FRE = RegisterMask; + using FRLVL = RegisterMask; + using FTLVL = RegisterMask; + }; + struct DR : public MemRegister { + using val = RegisterMask; + }; + struct CRCPR : public MemRegister { + using CRCPOLY = RegisterMask; + }; + struct RXCRCR : public MemRegister { + using RXCRC = RegisterMask; + }; + struct TXCRCR : public MemRegister { + using TXCRC = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace SPI3 { + struct CR1 : public MemRegister { + using CPHA = RegisterMask; + using CPOL = RegisterMask; + using MSTR = RegisterMask; + using BR = RegisterMask; + using SPE = RegisterMask; + using LSBFIRST = RegisterMask; + using SSI = RegisterMask; + using SSM = RegisterMask; + using RXONLY = RegisterMask; + using CRCL = RegisterMask; + using CRCNEXT = RegisterMask; + using CRCEN = RegisterMask; + using BIDIOE = RegisterMask; + using BIDIMODE = RegisterMask; + }; + struct CR2 : public MemRegister { + using RXDMAEN = RegisterMask; + using TXDMAEN = RegisterMask; + using SSOE = RegisterMask; + using NSSP = RegisterMask; + using FRF = RegisterMask; + using ERRIE = RegisterMask; + using RXNEIE = RegisterMask; + using TXEIE = RegisterMask; + using DS = RegisterMask; + using FRXTH = RegisterMask; + using LDMA_RX = RegisterMask; + using LDMA_TX = RegisterMask; + }; + struct SR : public MemRegister { + using RXNE = RegisterMask; + using TXE = RegisterMask; + using CRCERR = RegisterMask; + using MODF = RegisterMask; + using OVR = RegisterMask; + using BSY = RegisterMask; + using FRE = RegisterMask; + using FRLVL = RegisterMask; + using FTLVL = RegisterMask; + }; + struct DR : public MemRegister { + using val = RegisterMask; + }; + struct CRCPR : public MemRegister { + using CRCPOLY = RegisterMask; + }; + struct RXCRCR : public MemRegister { + using RXCRC = RegisterMask; + }; + struct TXCRCR : public MemRegister { + using TXCRC = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace SYSCFG { + struct CFGR1 : public MemRegister { + using MEM_MODE = RegisterMask; + using PA11_RMP = RegisterMask; + using PA12_RMP = RegisterMask; + using IR_POL = RegisterMask; + using IR_MOD = RegisterMask; + using BOOSTEN = RegisterMask; + using I2C_PB6_FMP = RegisterMask; + using I2C_PB7_FMP = RegisterMask; + using I2C_PB8_FMP = RegisterMask; + using I2C_PB9_FMP = RegisterMask; + using I2C_PA9_FMP = RegisterMask; + using I2C_PA10_FMP = RegisterMask; + using I2C3_FMP = RegisterMask; + }; + struct CFGR2 : public MemRegister { + using CCL = RegisterMask; + using SPL = RegisterMask; + using PVDL = RegisterMask; + using ECCL = RegisterMask; + using BKPL = RegisterMask; + using BKPF = RegisterMask; + using SPF = RegisterMask; + }; + struct SCSR : public MemRegister { + using SRAM2ER = RegisterMask; + using SRAM2BSY = RegisterMask; + }; + struct SKR : public MemRegister { + using KEY = RegisterMask; + }; + struct TSCCR : public MemRegister { + using G2_IO1 = RegisterMask; + using G2_IO3 = RegisterMask; + using G4_IO3 = RegisterMask; + using G6_IO1 = RegisterMask; + using G7_IO1 = RegisterMask; + using TSC_IOCTRL = RegisterMask; + }; + struct ITLINE0 : public MemRegister { + using WWDG = RegisterMask; + }; + struct ITLINE1 : public MemRegister { + using PVDOUT = RegisterMask; + using PVMOUT1 = RegisterMask; + using PVMOUT3 = RegisterMask; + using PVMOUT4 = RegisterMask; + }; + struct ITLINE2 : public MemRegister { + using TAMP = RegisterMask; + using RTC = RegisterMask; + }; + struct ITLINE3 : public MemRegister { + using FLASH_ITF = RegisterMask; + using FLASH_ECC = RegisterMask; + }; + struct ITLINE4 : public MemRegister { + using RCC = RegisterMask; + using CRS = RegisterMask; + }; + struct ITLINE5 : public MemRegister { + using EXTI0 = RegisterMask; + using EXTI1 = RegisterMask; + }; + struct ITLINE6 : public MemRegister { + using EXTI2 = RegisterMask; + using EXTI3 = RegisterMask; + }; + struct ITLINE7 : public MemRegister { + using EXTI4 = RegisterMask; + using EXTI5 = RegisterMask; + using EXTI6 = RegisterMask; + using EXTI7 = RegisterMask; + using EXTI8 = RegisterMask; + using EXTI9 = RegisterMask; + using EXTI10 = RegisterMask; + using EXTI11 = RegisterMask; + using EXTI12 = RegisterMask; + using EXTI13 = RegisterMask; + using EXTI14 = RegisterMask; + using EXTI15 = RegisterMask; + }; + struct ITLINE8 : public MemRegister { + using USB = RegisterMask; + }; + struct ITLINE9 : public MemRegister { + using DMA1_CH1 = RegisterMask; + }; + struct ITLINE10 : public MemRegister { + using DMA1_CH2 = RegisterMask; + using DMA1_CH3 = RegisterMask; + }; + struct ITLINE11 : public MemRegister { + using DMAMUX = RegisterMask; + using DMA1_CH4 = RegisterMask; + using DMA1_CH5 = RegisterMask; + using DMA1_CH6 = RegisterMask; + using DMA1_CH7 = RegisterMask; + using DMA2_CH1 = RegisterMask; + using DMA2_CH2 = RegisterMask; + using DMA2_CH3 = RegisterMask; + using DMA2_CH4 = RegisterMask; + using DMA2_CH5 = RegisterMask; + }; + struct ITLINE12 : public MemRegister { + using ADC = RegisterMask; + using COMP1 = RegisterMask; + using COMP2 = RegisterMask; + }; + struct ITLINE13 : public MemRegister { + using TIM1_CCU = RegisterMask; + using TIM1_TRG = RegisterMask; + using TIM1_UPD = RegisterMask; + using TIM1_BRK = RegisterMask; + }; + struct ITLINE14 : public MemRegister { + using TIM1_CC1 = RegisterMask; + using TIM1_CC2 = RegisterMask; + using TIM1_CC3 = RegisterMask; + using TIM1_CC4 = RegisterMask; + }; + struct ITLINE15 : public MemRegister { + using TIM2 = RegisterMask; + }; + struct ITLINE16 : public MemRegister { + using TIM3 = RegisterMask; + }; + struct ITLINE17 : public MemRegister { + using TIM6 = RegisterMask; + using DAC = RegisterMask; + using LPTIM1 = RegisterMask; + }; + struct ITLINE18 : public MemRegister { + using TIM7 = RegisterMask; + using LPTIM2 = RegisterMask; + }; + struct ITLINE19 : public MemRegister { + using TIM15 = RegisterMask; + using LPTIM3 = RegisterMask; + }; + struct ITLINE20 : public MemRegister { + using TIM16 = RegisterMask; + }; + struct ITLINE21 : public MemRegister { + using TSC_MCE = RegisterMask; + using TSC_EOA = RegisterMask; + }; + struct ITLINE22 : public MemRegister { + using LCD = RegisterMask; + }; + struct ITLINE23 : public MemRegister { + using I2C1 = RegisterMask; + }; + struct ITLINE24 : public MemRegister { + using I2C2 = RegisterMask; + using I2C4 = RegisterMask; + using I2C3 = RegisterMask; + }; + struct ITLINE25 : public MemRegister { + using SPI1 = RegisterMask; + }; + struct ITLINE26 : public MemRegister { + using SPI2 = RegisterMask; + using SPI3 = RegisterMask; + }; + struct ITLINE27 : public MemRegister { + using USART1 = RegisterMask; + }; + struct ITLINE28 : public MemRegister { + using USART2 = RegisterMask; + using LPUART2 = RegisterMask; + }; + struct ITLINE29 : public MemRegister { + using USART3 = RegisterMask; + using LPUART1 = RegisterMask; + }; + struct ITLINE30 : public MemRegister { + using USART4 = RegisterMask; + using LPUART3 = RegisterMask; + }; + struct ITLINE31 : public MemRegister { + using RNG = RegisterMask; + using AES = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace TAMP { + struct CR1 : public MemRegister { + using TAMP1E = RegisterMask; + using TAMP2E = RegisterMask; + using TAMP3E = RegisterMask; + using TAMP4E = RegisterMask; + using TAMP5E = RegisterMask; + using ITAMP3E = RegisterMask; + using ITAMP4E = RegisterMask; + using ITAMP5E = RegisterMask; + using ITAMP6E = RegisterMask; + }; + struct CR2 : public MemRegister { + using TAMP1POM = RegisterMask; + using TAMP2POM = RegisterMask; + using TAMP3POM = RegisterMask; + using TAMP4POM = RegisterMask; + using TAMP5POM = RegisterMask; + using TAMP1MSK = RegisterMask; + using TAMP2MSK = RegisterMask; + using TAMP3MSK = RegisterMask; + using BKBLOCK = RegisterMask; + using BKERASE = RegisterMask; + using TAMP1TRG = RegisterMask; + using TAMP2TRG = RegisterMask; + using TAMP3TRG = RegisterMask; + using TAMP4TRG = RegisterMask; + using TAMP5TRG = RegisterMask; + }; + struct CR3 : public MemRegister { + using ITAMP3POM = RegisterMask; + using ITAMP4POM = RegisterMask; + using ITAMP5POM = RegisterMask; + using ITAMP6POM = RegisterMask; + }; + struct FLTCR : public MemRegister { + using TAMPFREQ = RegisterMask; + using TAMPFLT = RegisterMask; + using TAMPPRCH = RegisterMask; + using TAMPPUDIS = RegisterMask; + }; + struct IER : public MemRegister { + using TAMP1IE = RegisterMask; + using TAMP2IE = RegisterMask; + using TAMP3IE = RegisterMask; + using TAMP4IE = RegisterMask; + using TAMP5IE = RegisterMask; + using ITAMP3IE = RegisterMask; + using ITAMP4IE = RegisterMask; + using ITAMP5IE = RegisterMask; + using ITAMP6IE = RegisterMask; + }; + struct SR : public MemRegister { + using TAMP1F = RegisterMask; + using TAMP2F = RegisterMask; + using TAMP3F = RegisterMask; + using TAMP4F = RegisterMask; + using TAMP5F = RegisterMask; + using ITAMP3F = RegisterMask; + using ITAMP4F = RegisterMask; + using ITAMP5F = RegisterMask; + using ITAMP6F = RegisterMask; + }; + struct MISR : public MemRegister { + using TAMP1MF = RegisterMask; + using TAMP2MF = RegisterMask; + using TAMP3MF = RegisterMask; + using TAMP4MF = RegisterMask; + using TAMP5MF = RegisterMask; + using ITAMP3MF = RegisterMask; + using ITAMP4MF = RegisterMask; + using ITAMP5MF = RegisterMask; + using ITAMP6MF = RegisterMask; + }; + struct SCR : public MemRegister { + using CTAMP1F = RegisterMask; + using CTAMP2F = RegisterMask; + using CTAMP3F = RegisterMask; + using CTAMP4F = RegisterMask; + using CTAMP5F = RegisterMask; + using CITAMP3F = RegisterMask; + using CITAMP4F = RegisterMask; + using CITAMP5F = RegisterMask; + using CITAMP6F = RegisterMask; + }; + struct BKP0R : public MemRegister { + using BKP = RegisterMask; + }; + struct BKP1R : public MemRegister { + using BKP = RegisterMask; + }; + struct BKP2R : public MemRegister { + using BKP = RegisterMask; + }; + struct BKP3R : public MemRegister { + using BKP = RegisterMask; + }; + struct BKP4R : public MemRegister { + using BKP = RegisterMask; + }; + struct BKP5R : public MemRegister { + using BKP = RegisterMask; + }; + struct BKP6R : public MemRegister { + using BKP = RegisterMask; + }; + struct BKP7R : public MemRegister { + using BKP = RegisterMask; + }; + struct BKP8R : public MemRegister { + using BKP = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace TIM1 { + struct TIM1_CR1 : public MemRegister { + using CEN = RegisterMask; + using UDIS = RegisterMask; + using URS = RegisterMask; + using OPM = RegisterMask; + using DIR = RegisterMask; + using CMS = RegisterMask; + using ARPE = RegisterMask; + using CKD = RegisterMask; + using UIFREMAP = RegisterMask; + }; + struct TIM1_CR2 : public MemRegister { + using CCPC = RegisterMask; + using CCUS = RegisterMask; + using CCDS = RegisterMask; + using MMS = RegisterMask; + using TI1S = RegisterMask; + using OIS1 = RegisterMask; + using OIS1N = RegisterMask; + using OIS2 = RegisterMask; + using OIS2N = RegisterMask; + using OIS3 = RegisterMask; + using OIS3N = RegisterMask; + using OIS4 = RegisterMask; + using OIS5 = RegisterMask; + using OIS6 = RegisterMask; + using MMS2 = RegisterMask; + }; + struct TIM1_SMCR : public MemRegister { + using SMS = RegisterMask; + using OCCS = RegisterMask; + using TS = RegisterMask; + using MSM = RegisterMask; + using ETF = RegisterMask; + using ETPS = RegisterMask; + using ECE = RegisterMask; + using ETP = RegisterMask; + using SMS_1 = RegisterMask; + using TS_1 = RegisterMask; + }; + struct TIM1_DIER : public MemRegister { + using UIE = RegisterMask; + using CC1IE = RegisterMask; + using CC2IE = RegisterMask; + using CC3IE = RegisterMask; + using CC4IE = RegisterMask; + using COMIE = RegisterMask; + using TIE = RegisterMask; + using BIE = RegisterMask; + using UDE = RegisterMask; + using CC1DE = RegisterMask; + using CC2DE = RegisterMask; + using CC3DE = RegisterMask; + using CC4DE = RegisterMask; + using COMDE = RegisterMask; + using TDE = RegisterMask; + }; + struct TIM1_SR : public MemRegister { + using UIF = RegisterMask; + using CC1IF = RegisterMask; + using CC2IF = RegisterMask; + using CC3IF = RegisterMask; + using CC4IF = RegisterMask; + using COMIF = RegisterMask; + using TIF = RegisterMask; + using BIF = RegisterMask; + using B2IF = RegisterMask; + using CC1OF = RegisterMask; + using CC2OF = RegisterMask; + using CC3OF = RegisterMask; + using CC4OF = RegisterMask; + using SBIF = RegisterMask; + using CC5IF = RegisterMask; + using CC6IF = RegisterMask; + }; + struct TIM1_EGR : public MemRegister { + using UG = RegisterMask; + using CC1G = RegisterMask; + using CC2G = RegisterMask; + using CC3G = RegisterMask; + using CC4G = RegisterMask; + using COMG = RegisterMask; + using TG = RegisterMask; + using BG = RegisterMask; + using B2G = RegisterMask; + }; + struct TIM1_CCMR1_INPUT : public MemRegister { + using CC1S = RegisterMask; + using IC1PSC = RegisterMask; + using IC1F = RegisterMask; + using CC2S = RegisterMask; + using IC2PSC = RegisterMask; + using IC2F = RegisterMask; + }; + struct TIM1_CCMR1_OUTPUT : public MemRegister { + using CC1S = RegisterMask; + using OC1FE = RegisterMask; + using OC1PE = RegisterMask; + using OC1M = RegisterMask; + using OC1CE = RegisterMask; + using CC2S = RegisterMask; + using OC2FE = RegisterMask; + using OC2PE = RegisterMask; + using OC2M = RegisterMask; + using OC2CE = RegisterMask; + using OC1M_1 = RegisterMask; + using OC2M_1 = RegisterMask; + }; + struct TIM1_CCMR2_INPUT : public MemRegister { + using CC3S = RegisterMask; + using IC3PSC = RegisterMask; + using IC3F = RegisterMask; + using CC4S = RegisterMask; + using IC4PSC = RegisterMask; + using IC4F = RegisterMask; + }; + struct TIM1_CCMR2_OUTPUT : public MemRegister { + using CC3S = RegisterMask; + using OC3FE = RegisterMask; + using OC3PE = RegisterMask; + using OC3M = RegisterMask; + using OC3CE = RegisterMask; + using CC4S = RegisterMask; + using OC4FE = RegisterMask; + using OC4PE = RegisterMask; + using OC4M = RegisterMask; + using OC4CE = RegisterMask; + using OC3M_1 = RegisterMask; + using OC4M_1 = RegisterMask; + }; + struct TIM1_CCER : public MemRegister { + using CC1E = RegisterMask; + using CC1P = RegisterMask; + using CC1NE = RegisterMask; + using CC1NP = RegisterMask; + using CC2E = RegisterMask; + using CC2P = RegisterMask; + using CC2NE = RegisterMask; + using CC2NP = RegisterMask; + using CC3E = RegisterMask; + using CC3P = RegisterMask; + using CC3NE = RegisterMask; + using CC3NP = RegisterMask; + using CC4E = RegisterMask; + using CC4P = RegisterMask; + using CC4NP = RegisterMask; + using CC5E = RegisterMask; + using CC5P = RegisterMask; + using CC6E = RegisterMask; + using CC6P = RegisterMask; + }; + struct TIM1_CNT : public MemRegister { + using CNT = RegisterMask; + using UIFCPY = RegisterMask; + }; + struct TIM1_PSC : public MemRegister { + using PSC = RegisterMask; + }; + struct TIM1_ARR : public MemRegister { + using ARR = RegisterMask; + }; + struct TIM1_RCR : public MemRegister { + using REP = RegisterMask; + }; + struct TIM1_CCR1 : public MemRegister { + using CCR1 = RegisterMask; + }; + struct TIM1_CCR2 : public MemRegister { + using CCR2 = RegisterMask; + }; + struct TIM1_CCR3 : public MemRegister { + using CCR3 = RegisterMask; + }; + struct TIM1_CCR4 : public MemRegister { + using CCR4 = RegisterMask; + }; + struct TIM1_BDTR : public MemRegister { + using DTG = RegisterMask; + using LOCK = RegisterMask; + using OSSI = RegisterMask; + using OSSR = RegisterMask; + using BKE = RegisterMask; + using BKP = RegisterMask; + using AOE = RegisterMask; + using MOE = RegisterMask; + using BKF = RegisterMask; + using BK2F = RegisterMask; + using BK2E = RegisterMask; + using BK2P = RegisterMask; + using BKDSRM = RegisterMask; + using BK2DSRM = RegisterMask; + using BKBID = RegisterMask; + using BK2BID = RegisterMask; + }; + struct TIM1_DCR : public MemRegister { + using DBA = RegisterMask; + using DBL = RegisterMask; + }; + struct TIM1_DMAR : public MemRegister { + using DMAB = RegisterMask; + }; + struct TIM1_OR1 : public MemRegister { + using OCREF_CLR = RegisterMask; + }; + struct TIM1_CCMR3 : public MemRegister { + using OC5FE = RegisterMask; + using OC5PE = RegisterMask; + using OC5M = RegisterMask; + using OC5CE = RegisterMask; + using OC6FE = RegisterMask; + using OC6PE = RegisterMask; + using OC6M = RegisterMask; + using OC6CE = RegisterMask; + using OC5M_1 = RegisterMask; + using OC6M_1 = RegisterMask; + }; + struct TIM1_CCR5 : public MemRegister { + using CCR5 = RegisterMask; + using GC5C1 = RegisterMask; + using GC5C2 = RegisterMask; + using GC5C3 = RegisterMask; + }; + struct TIM1_CCR6 : public MemRegister { + using CCR6 = RegisterMask; + }; + struct TIM1_AF1 : public MemRegister { + using BKINE = RegisterMask; + using BKCMP1E = RegisterMask; + using BKCMP2E = RegisterMask; + using BKINP = RegisterMask; + using BKCMP1P = RegisterMask; + using BKCMP2P = RegisterMask; + using ETRSEL = RegisterMask; + }; + struct TIM1_AF2 : public MemRegister { + using BK2INE = RegisterMask; + using BK2CMP1E = RegisterMask; + using BK2CMP2E = RegisterMask; + using BK2INP = RegisterMask; + using BK2CMP1P = RegisterMask; + using BK2CMP2P = RegisterMask; + }; + struct TIM1_TISEL : public MemRegister { + using TI1SEL = RegisterMask; + using TI2SEL = RegisterMask; + using TI3SEL = RegisterMask; + using TI4SEL = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace TIM15 { + struct TIM15_CR1 : public MemRegister { + using CEN = RegisterMask; + using UDIS = RegisterMask; + using URS = RegisterMask; + using OPM = RegisterMask; + using ARPE = RegisterMask; + using CKD = RegisterMask; + using UIFREMAP = RegisterMask; + }; + struct TIM15_CR2 : public MemRegister { + using CCPC = RegisterMask; + using CCUS = RegisterMask; + using CCDS = RegisterMask; + using MMS = RegisterMask; + using TI1S = RegisterMask; + using OIS1 = RegisterMask; + using OIS1N = RegisterMask; + using OIS2 = RegisterMask; + }; + struct TIM15_SMCR : public MemRegister { + using SMS = RegisterMask; + using TS = RegisterMask; + using MSM = RegisterMask; + using SMS_1 = RegisterMask; + using TS_1 = RegisterMask; + }; + struct TIM15_DIER : public MemRegister { + using UIE = RegisterMask; + using CC1IE = RegisterMask; + using CC2IE = RegisterMask; + using COMIE = RegisterMask; + using TIE = RegisterMask; + using BIE = RegisterMask; + using UDE = RegisterMask; + using CC1DE = RegisterMask; + using COMDE = RegisterMask; + using TDE = RegisterMask; + }; + struct TIM15_SR : public MemRegister { + using UIF = RegisterMask; + using CC1IF = RegisterMask; + using CC2IF = RegisterMask; + using COMIF = RegisterMask; + using TIF = RegisterMask; + using BIF = RegisterMask; + using CC1OF = RegisterMask; + using CC2OF = RegisterMask; + }; + struct TIM15_EGR : public MemRegister { + using UG = RegisterMask; + using CC1G = RegisterMask; + using CC2G = RegisterMask; + using COMG = RegisterMask; + using TG = RegisterMask; + using BG = RegisterMask; + }; + struct TIM15_CCMR1 : public MemRegister { + using CC1S = RegisterMask; + using IC1PSC = RegisterMask; + using IC1F = RegisterMask; + using CC2S = RegisterMask; + using IC2PSC = RegisterMask; + using IC2F = RegisterMask; + }; + struct TIM15_CCMR1_ALTERNATE1 : public MemRegister { + using CC1S = RegisterMask; + using OC1FE = RegisterMask; + using OC1PE = RegisterMask; + using OC1M = RegisterMask; + using CC2S = RegisterMask; + using OC2FE = RegisterMask; + using OC2PE = RegisterMask; + using OC2M = RegisterMask; + using OC1M_1 = RegisterMask; + using OC2M_1 = RegisterMask; + }; + struct TIM15_CCER : public MemRegister { + using CC1E = RegisterMask; + using CC1P = RegisterMask; + using CC1NE = RegisterMask; + using CC1NP = RegisterMask; + using CC2E = RegisterMask; + using CC2P = RegisterMask; + using CC2NP = RegisterMask; + }; + struct TIM15_CNT : public MemRegister { + using CNT = RegisterMask; + using UIFCPY = RegisterMask; + }; + struct TIM15_PSC : public MemRegister { + using PSC = RegisterMask; + }; + struct TIM15_ARR : public MemRegister { + using ARR = RegisterMask; + }; + struct TIM15_RCR : public MemRegister { + using REP = RegisterMask; + }; + struct TIM15_CCR1 : public MemRegister { + using CCR1 = RegisterMask; + }; + struct TIM15_CCR2 : public MemRegister { + using CCR2 = RegisterMask; + }; + struct TIM15_BDTR : public MemRegister { + using DTG = RegisterMask; + using LOCK = RegisterMask; + using OSSI = RegisterMask; + using OSSR = RegisterMask; + using BKE = RegisterMask; + using BKP = RegisterMask; + using AOE = RegisterMask; + using MOE = RegisterMask; + using BKF = RegisterMask; + using BKDSRM = RegisterMask; + using BKBID = RegisterMask; + }; + struct TIM15_DCR : public MemRegister { + using DBA = RegisterMask; + using DBL = RegisterMask; + }; + struct TIM15_DMAR : public MemRegister { + using DMAB = RegisterMask; + }; + struct TIM15_AF1 : public MemRegister { + using BKINE = RegisterMask; + using BKCMP1E = RegisterMask; + using BKCMP2E = RegisterMask; + using BKINP = RegisterMask; + using BKCMP1P = RegisterMask; + using BKCMP2P = RegisterMask; + }; + struct TIM15_TISEL : public MemRegister { + using TI1SEL = RegisterMask; + using TI2SEL = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace TIM16 { + struct TIM16_CR1 : public MemRegister { + using CEN = RegisterMask; + using UDIS = RegisterMask; + using URS = RegisterMask; + using OPM = RegisterMask; + using ARPE = RegisterMask; + using CKD = RegisterMask; + using UIFREMAP = RegisterMask; + }; + struct TIM16_CR2 : public MemRegister { + using CCPC = RegisterMask; + using CCUS = RegisterMask; + using CCDS = RegisterMask; + using OIS1 = RegisterMask; + using OIS1N = RegisterMask; + }; + struct TIM16_DIER : public MemRegister { + using UIE = RegisterMask; + using CC1IE = RegisterMask; + using COMIE = RegisterMask; + using BIE = RegisterMask; + using UDE = RegisterMask; + using CC1DE = RegisterMask; + }; + struct TIM16_SR : public MemRegister { + using UIF = RegisterMask; + using CC1IF = RegisterMask; + using COMIF = RegisterMask; + using BIF = RegisterMask; + using CC1OF = RegisterMask; + }; + struct TIM16_EGR : public MemRegister { + using UG = RegisterMask; + using CC1G = RegisterMask; + using COMG = RegisterMask; + using BG = RegisterMask; + }; + struct TIM16_CCMR1 : public MemRegister { + using CC1S = RegisterMask; + using IC1PSC = RegisterMask; + using IC1F = RegisterMask; + }; + struct TIM16_CCMR1_ALTERNATE1 : public MemRegister { + using CC1S = RegisterMask; + using OC1FE = RegisterMask; + using OC1PE = RegisterMask; + using OC1M = RegisterMask; + using OC1M_1 = RegisterMask; + }; + struct TIM16_CCER : public MemRegister { + using CC1E = RegisterMask; + using CC1P = RegisterMask; + using CC1NE = RegisterMask; + using CC1NP = RegisterMask; + }; + struct TIM16_CNT : public MemRegister { + using CNT = RegisterMask; + using UIFCPY = RegisterMask; + }; + struct TIM16_PSC : public MemRegister { + using PSC = RegisterMask; + }; + struct TIM16_ARR : public MemRegister { + using ARR = RegisterMask; + }; + struct TIM16_RCR : public MemRegister { + using REP = RegisterMask; + }; + struct TIM16_CCR1 : public MemRegister { + using CCR1 = RegisterMask; + }; + struct TIM16_BDTR : public MemRegister { + using DTG = RegisterMask; + using LOCK = RegisterMask; + using OSSI = RegisterMask; + using OSSR = RegisterMask; + using BKE = RegisterMask; + using BKP = RegisterMask; + using AOE = RegisterMask; + using MOE = RegisterMask; + using BKF = RegisterMask; + using BKDSRM = RegisterMask; + using BKBID = RegisterMask; + }; + struct TIM16_DCR : public MemRegister { + using DBA = RegisterMask; + using DBL = RegisterMask; + }; + struct TIM16_DMAR : public MemRegister { + using DMAB = RegisterMask; + }; + struct TIM16_AF1 : public MemRegister { + using BKINE = RegisterMask; + using BKCMP1E = RegisterMask; + using BKCMP2E = RegisterMask; + using BKINP = RegisterMask; + using BKCMP1P = RegisterMask; + using BKCMP2P = RegisterMask; + }; + struct TIM16_TISEL : public MemRegister { + using TI1SEL = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace TIM2 { + struct TIM2_CR1 : public MemRegister { + using CEN = RegisterMask; + using UDIS = RegisterMask; + using URS = RegisterMask; + using OPM = RegisterMask; + using DIR = RegisterMask; + using CMS = RegisterMask; + using ARPE = RegisterMask; + using CKD = RegisterMask; + using UIFREMAP = RegisterMask; + }; + struct TIM2_CR2 : public MemRegister { + using CCDS = RegisterMask; + using MMS = RegisterMask; + using TI1S = RegisterMask; + }; + struct TIM2_SMCR : public MemRegister { + using SMS = RegisterMask; + using OCCS = RegisterMask; + using TS = RegisterMask; + using MSM = RegisterMask; + using ETF = RegisterMask; + using ETPS = RegisterMask; + using ECE = RegisterMask; + using ETP = RegisterMask; + using SMS_1 = RegisterMask; + using TS_1 = RegisterMask; + }; + struct TIM2_DIER : public MemRegister { + using UIE = RegisterMask; + using CC1IE = RegisterMask; + using CC2IE = RegisterMask; + using CC3IE = RegisterMask; + using CC4IE = RegisterMask; + using TIE = RegisterMask; + using UDE = RegisterMask; + using CC1DE = RegisterMask; + using CC2DE = RegisterMask; + using CC3DE = RegisterMask; + using CC4DE = RegisterMask; + using TDE = RegisterMask; + }; + struct TIM2_SR : public MemRegister { + using UIF = RegisterMask; + using CC1IF = RegisterMask; + using CC2IF = RegisterMask; + using CC3IF = RegisterMask; + using CC4IF = RegisterMask; + using TIF = RegisterMask; + using CC1OF = RegisterMask; + using CC2OF = RegisterMask; + using CC3OF = RegisterMask; + using CC4OF = RegisterMask; + }; + struct TIM2_EGR : public MemRegister { + using UG = RegisterMask; + using CC1G = RegisterMask; + using CC2G = RegisterMask; + using CC3G = RegisterMask; + using CC4G = RegisterMask; + using TG = RegisterMask; + }; + struct TIM2_CCMR1 : public MemRegister { + using CC1S = RegisterMask; + using IC1PSC = RegisterMask; + using IC1F = RegisterMask; + using CC2S = RegisterMask; + using IC2PSC = RegisterMask; + using IC2F = RegisterMask; + }; + struct TIM2_CCMR1_ALTERNATE1 : public MemRegister { + using CC1S = RegisterMask; + using OC1FE = RegisterMask; + using OC1PE = RegisterMask; + using OC1M = RegisterMask; + using OC1CE = RegisterMask; + using CC2S = RegisterMask; + using OC2FE = RegisterMask; + using OC2PE = RegisterMask; + using OC2M = RegisterMask; + using OC2CE = RegisterMask; + using OC1M_1 = RegisterMask; + using OC2M_1 = RegisterMask; + }; + struct TIM2_CCMR2 : public MemRegister { + using CC3S = RegisterMask; + using IC3PSC = RegisterMask; + using IC3F = RegisterMask; + using CC4S = RegisterMask; + using IC4PSC = RegisterMask; + using IC4F = RegisterMask; + }; + struct TIM2_CCMR2_ALTERNATE1 : public MemRegister { + using CC3S = RegisterMask; + using OC3FE = RegisterMask; + using OC3PE = RegisterMask; + using OC3M = RegisterMask; + using OC3CE = RegisterMask; + using CC4S = RegisterMask; + using OC4FE = RegisterMask; + using OC4PE = RegisterMask; + using OC4M = RegisterMask; + using OC4CE = RegisterMask; + using OC3M_1 = RegisterMask; + using OC4M_1 = RegisterMask; + }; + struct TIM2_CCER : public MemRegister { + using CC1E = RegisterMask; + using CC1P = RegisterMask; + using CC1NP = RegisterMask; + using CC2E = RegisterMask; + using CC2P = RegisterMask; + using CC2NP = RegisterMask; + using CC3E = RegisterMask; + using CC3P = RegisterMask; + using CC3NP = RegisterMask; + using CC4E = RegisterMask; + using CC4P = RegisterMask; + using CC4NP = RegisterMask; + }; + struct TIM2_CNT : public MemRegister { + using CNT = RegisterMask; + }; + struct TIM2_CNT_ALTERNATE1 : public MemRegister { + using CNT = RegisterMask; + using UIFCPY = RegisterMask; + }; + struct TIM2_PSC : public MemRegister { + using PSC = RegisterMask; + }; + struct TIM2_ARR : public MemRegister { + using ARR = RegisterMask; + }; + struct TIM2_CCR1 : public MemRegister { + using CCR1 = RegisterMask; + }; + struct TIM2_CCR2 : public MemRegister { + using CCR2 = RegisterMask; + }; + struct TIM2_CCR3 : public MemRegister { + using CCR3 = RegisterMask; + }; + struct TIM2_CCR4 : public MemRegister { + using CCR4 = RegisterMask; + }; + struct TIM2_DCR : public MemRegister { + using DBA = RegisterMask; + using DBL = RegisterMask; + }; + struct TIM2_DMAR : public MemRegister { + using DMAB = RegisterMask; + }; + struct TIM2_OR1 : public MemRegister { + using OCREF_CLR = RegisterMask; + }; + struct TIM2_AF1 : public MemRegister { + using ETRSEL = RegisterMask; + }; + struct TIM2_TISEL : public MemRegister { + using TI1SEL = RegisterMask; + using TI2SEL = RegisterMask; + using TI3SEL = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace TIM3 { + struct TIM3_CR1 : public MemRegister { + using CEN = RegisterMask; + using UDIS = RegisterMask; + using URS = RegisterMask; + using OPM = RegisterMask; + using DIR = RegisterMask; + using CMS = RegisterMask; + using ARPE = RegisterMask; + using CKD = RegisterMask; + using UIFREMAP = RegisterMask; + }; + struct TIM3_CR2 : public MemRegister { + using CCDS = RegisterMask; + using MMS = RegisterMask; + using TI1S = RegisterMask; + }; + struct TIM3_SMCR : public MemRegister { + using SMS = RegisterMask; + using OCCS = RegisterMask; + using TS = RegisterMask; + using MSM = RegisterMask; + using ETF = RegisterMask; + using ETPS = RegisterMask; + using ECE = RegisterMask; + using ETP = RegisterMask; + using SMS_1 = RegisterMask; + using TS_1 = RegisterMask; + }; + struct TIM3_DIER : public MemRegister { + using UIE = RegisterMask; + using CC1IE = RegisterMask; + using CC2IE = RegisterMask; + using CC3IE = RegisterMask; + using CC4IE = RegisterMask; + using TIE = RegisterMask; + using UDE = RegisterMask; + using CC1DE = RegisterMask; + using CC2DE = RegisterMask; + using CC3DE = RegisterMask; + using CC4DE = RegisterMask; + using TDE = RegisterMask; + }; + struct TIM3_SR : public MemRegister { + using UIF = RegisterMask; + using CC1IF = RegisterMask; + using CC2IF = RegisterMask; + using CC3IF = RegisterMask; + using CC4IF = RegisterMask; + using TIF = RegisterMask; + using CC1OF = RegisterMask; + using CC2OF = RegisterMask; + using CC3OF = RegisterMask; + using CC4OF = RegisterMask; + }; + struct TIM3_EGR : public MemRegister { + using UG = RegisterMask; + using CC1G = RegisterMask; + using CC2G = RegisterMask; + using CC3G = RegisterMask; + using CC4G = RegisterMask; + using TG = RegisterMask; + }; + struct TIM3_CCMR1 : public MemRegister { + using CC1S = RegisterMask; + using IC1PSC = RegisterMask; + using IC1F = RegisterMask; + using CC2S = RegisterMask; + using IC2PSC = RegisterMask; + using IC2F = RegisterMask; + }; + struct TIM3_CCMR1_ALTERNATE1 : public MemRegister { + using CC1S = RegisterMask; + using OC1FE = RegisterMask; + using OC1PE = RegisterMask; + using OC1M = RegisterMask; + using OC1CE = RegisterMask; + using CC2S = RegisterMask; + using OC2FE = RegisterMask; + using OC2PE = RegisterMask; + using OC2M = RegisterMask; + using OC2CE = RegisterMask; + using OC1M_1 = RegisterMask; + using OC2M_1 = RegisterMask; + }; + struct TIM3_CCMR2 : public MemRegister { + using CC3S = RegisterMask; + using IC3PSC = RegisterMask; + using IC3F = RegisterMask; + using CC4S = RegisterMask; + using IC4PSC = RegisterMask; + using IC4F = RegisterMask; + }; + struct TIM3_CCMR2_ALTERNATE1 : public MemRegister { + using CC3S = RegisterMask; + using OC3FE = RegisterMask; + using OC3PE = RegisterMask; + using OC3M = RegisterMask; + using OC3CE = RegisterMask; + using CC4S = RegisterMask; + using OC4FE = RegisterMask; + using OC4PE = RegisterMask; + using OC4M = RegisterMask; + using OC4CE = RegisterMask; + using OC3M_1 = RegisterMask; + using OC4M_1 = RegisterMask; + }; + struct TIM3_CCER : public MemRegister { + using CC1E = RegisterMask; + using CC1P = RegisterMask; + using CC1NP = RegisterMask; + using CC2E = RegisterMask; + using CC2P = RegisterMask; + using CC2NP = RegisterMask; + using CC3E = RegisterMask; + using CC3P = RegisterMask; + using CC3NP = RegisterMask; + using CC4E = RegisterMask; + using CC4P = RegisterMask; + using CC4NP = RegisterMask; + }; + struct TIM3_CNT : public MemRegister { + using CNT = RegisterMask; + }; + struct TIM3_CNT_ALTERNATE1 : public MemRegister { + using CNT = RegisterMask; + using UIFCPY = RegisterMask; + }; + struct TIM3_PSC : public MemRegister { + using PSC = RegisterMask; + }; + struct TIM3_ARR : public MemRegister { + using ARR = RegisterMask; + }; + struct TIM3_CCR1 : public MemRegister { + using CCR1 = RegisterMask; + }; + struct TIM3_CCR2 : public MemRegister { + using CCR2 = RegisterMask; + }; + struct TIM3_CCR3 : public MemRegister { + using CCR3 = RegisterMask; + }; + struct TIM3_CCR4 : public MemRegister { + using CCR4 = RegisterMask; + }; + struct TIM3_DCR : public MemRegister { + using DBA = RegisterMask; + using DBL = RegisterMask; + }; + struct TIM3_DMAR : public MemRegister { + using DMAB = RegisterMask; + }; + struct TIM3_OR1 : public MemRegister { + using OCREF_CLR = RegisterMask; + }; + struct TIM3_AF1 : public MemRegister { + using ETRSEL = RegisterMask; + }; + struct TIM3_TISEL : public MemRegister { + using TI1SEL = RegisterMask; + using TI2SEL = RegisterMask; + using TI3SEL = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace TIM6 { + struct TIM6_CR1 : public MemRegister { + using CEN = RegisterMask; + using UDIS = RegisterMask; + using URS = RegisterMask; + using OPM = RegisterMask; + using ARPE = RegisterMask; + using UIFREMAP = RegisterMask; + }; + struct TIM6_CR2 : public MemRegister { + using MMS = RegisterMask; + }; + struct TIM6_DIER : public MemRegister { + using UIE = RegisterMask; + using UDE = RegisterMask; + }; + struct TIM6_SR : public MemRegister { + using UIF = RegisterMask; + }; + struct TIM6_EGR : public MemRegister { + using UG = RegisterMask; + }; + struct TIM6_CNT : public MemRegister { + using CNT = RegisterMask; + using UIFCPY = RegisterMask; + }; + struct TIM6_PSC : public MemRegister { + using PSC = RegisterMask; + }; + struct TIM6_ARR : public MemRegister { + using ARR = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace TIM7 { + struct TIM7_CR1 : public MemRegister { + using CEN = RegisterMask; + using UDIS = RegisterMask; + using URS = RegisterMask; + using OPM = RegisterMask; + using ARPE = RegisterMask; + using UIFREMAP = RegisterMask; + }; + struct TIM7_CR2 : public MemRegister { + using MMS = RegisterMask; + }; + struct TIM7_DIER : public MemRegister { + using UIE = RegisterMask; + using UDE = RegisterMask; + }; + struct TIM7_SR : public MemRegister { + using UIF = RegisterMask; + }; + struct TIM7_EGR : public MemRegister { + using UG = RegisterMask; + }; + struct TIM7_CNT : public MemRegister { + using CNT = RegisterMask; + using UIFCPY = RegisterMask; + }; + struct TIM7_PSC : public MemRegister { + using PSC = RegisterMask; + }; + struct TIM7_ARR : public MemRegister { + using ARR = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace TSC { + struct CR : public MemRegister { + using TSCE = RegisterMask; + using START = RegisterMask; + using AM = RegisterMask; + using SYNCPOL = RegisterMask; + using IODEF = RegisterMask; + using MCV = RegisterMask; + using PGPSC = RegisterMask; + using SSPSC = RegisterMask; + using SSE = RegisterMask; + using SSD = RegisterMask; + using CTPL = RegisterMask; + using CTPH = RegisterMask; + }; + struct IER : public MemRegister { + using EOAIE = RegisterMask; + using MCEIE = RegisterMask; + }; + struct ICR : public MemRegister { + using EOAIC = RegisterMask; + using MCEIC = RegisterMask; + }; + struct ISR : public MemRegister { + using EOAF = RegisterMask; + using MCEF = RegisterMask; + }; + struct IOHCR : public MemRegister { + using G1_IO1 = RegisterMask; + using G1_IO2 = RegisterMask; + using G1_IO3 = RegisterMask; + using G1_IO4 = RegisterMask; + using G2_IO1 = RegisterMask; + using G2_IO2 = RegisterMask; + using G2_IO3 = RegisterMask; + using G2_IO4 = RegisterMask; + using G3_IO1 = RegisterMask; + using G3_IO2 = RegisterMask; + using G3_IO3 = RegisterMask; + using G3_IO4 = RegisterMask; + using G4_IO1 = RegisterMask; + using G4_IO2 = RegisterMask; + using G4_IO3 = RegisterMask; + using G4_IO4 = RegisterMask; + using G5_IO1 = RegisterMask; + using G5_IO2 = RegisterMask; + using G5_IO3 = RegisterMask; + using G5_IO4 = RegisterMask; + using G6_IO1 = RegisterMask; + using G6_IO2 = RegisterMask; + using G6_IO3 = RegisterMask; + using G6_IO4 = RegisterMask; + using G7_IO1 = RegisterMask; + using G7_IO2 = RegisterMask; + using G7_IO3 = RegisterMask; + using G7_IO4 = RegisterMask; + }; + struct IOASCR : public MemRegister { + using G1_IO1 = RegisterMask; + using G1_IO2 = RegisterMask; + using G1_IO3 = RegisterMask; + using G1_IO4 = RegisterMask; + using G2_IO1 = RegisterMask; + using G2_IO2 = RegisterMask; + using G2_IO3 = RegisterMask; + using G2_IO4 = RegisterMask; + using G3_IO1 = RegisterMask; + using G3_IO2 = RegisterMask; + using G3_IO3 = RegisterMask; + using G3_IO4 = RegisterMask; + using G4_IO1 = RegisterMask; + using G4_IO2 = RegisterMask; + using G4_IO3 = RegisterMask; + using G4_IO4 = RegisterMask; + using G5_IO1 = RegisterMask; + using G5_IO2 = RegisterMask; + using G5_IO3 = RegisterMask; + using G5_IO4 = RegisterMask; + using G6_IO1 = RegisterMask; + using G6_IO2 = RegisterMask; + using G6_IO3 = RegisterMask; + using G6_IO4 = RegisterMask; + using G7_IO1 = RegisterMask; + using G7_IO2 = RegisterMask; + using G7_IO3 = RegisterMask; + using G7_IO4 = RegisterMask; + }; + struct IOSCR : public MemRegister { + using G1_IO1 = RegisterMask; + using G1_IO2 = RegisterMask; + using G1_IO3 = RegisterMask; + using G1_IO4 = RegisterMask; + using G2_IO1 = RegisterMask; + using G2_IO2 = RegisterMask; + using G2_IO3 = RegisterMask; + using G2_IO4 = RegisterMask; + using G3_IO1 = RegisterMask; + using G3_IO2 = RegisterMask; + using G3_IO3 = RegisterMask; + using G3_IO4 = RegisterMask; + using G4_IO1 = RegisterMask; + using G4_IO2 = RegisterMask; + using G4_IO3 = RegisterMask; + using G4_IO4 = RegisterMask; + using G5_IO1 = RegisterMask; + using G5_IO2 = RegisterMask; + using G5_IO3 = RegisterMask; + using G5_IO4 = RegisterMask; + using G6_IO1 = RegisterMask; + using G6_IO2 = RegisterMask; + using G6_IO3 = RegisterMask; + using G6_IO4 = RegisterMask; + using G7_IO1 = RegisterMask; + using G7_IO2 = RegisterMask; + using G7_IO3 = RegisterMask; + using G7_IO4 = RegisterMask; + }; + struct IOCCR : public MemRegister { + using G1_IO1 = RegisterMask; + using G1_IO2 = RegisterMask; + using G1_IO3 = RegisterMask; + using G1_IO4 = RegisterMask; + using G2_IO1 = RegisterMask; + using G2_IO2 = RegisterMask; + using G2_IO3 = RegisterMask; + using G2_IO4 = RegisterMask; + using G3_IO1 = RegisterMask; + using G3_IO2 = RegisterMask; + using G3_IO3 = RegisterMask; + using G3_IO4 = RegisterMask; + using G4_IO1 = RegisterMask; + using G4_IO2 = RegisterMask; + using G4_IO3 = RegisterMask; + using G4_IO4 = RegisterMask; + using G5_IO1 = RegisterMask; + using G5_IO2 = RegisterMask; + using G5_IO3 = RegisterMask; + using G5_IO4 = RegisterMask; + using G6_IO1 = RegisterMask; + using G6_IO2 = RegisterMask; + using G6_IO3 = RegisterMask; + using G6_IO4 = RegisterMask; + using G7_IO1 = RegisterMask; + using G7_IO2 = RegisterMask; + using G7_IO3 = RegisterMask; + using G7_IO4 = RegisterMask; + }; + struct IOGCSR : public MemRegister { + using G1E = RegisterMask; + using G2E = RegisterMask; + using G3E = RegisterMask; + using G4E = RegisterMask; + using G5E = RegisterMask; + using G6E = RegisterMask; + using G7E = RegisterMask; + using G1S = RegisterMask; + using G2S = RegisterMask; + using G3S = RegisterMask; + using G4S = RegisterMask; + using G5S = RegisterMask; + using G6S = RegisterMask; + using G7S = RegisterMask; + }; + struct IOG1CR : public MemRegister { + using CNT = RegisterMask; + }; + struct IOG2CR : public MemRegister { + using CNT = RegisterMask; + }; + struct IOG3CR : public MemRegister { + using CNT = RegisterMask; + }; + struct IOG4CR : public MemRegister { + using CNT = RegisterMask; + }; + struct IOG5CR : public MemRegister { + using CNT = RegisterMask; + }; + struct IOG6CR : public MemRegister { + using CNT = RegisterMask; + }; + struct IOG7CR : public MemRegister { + using CNT = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace USART1 { + struct CR1 : public MemRegister { + using UE = RegisterMask; + using UESM = RegisterMask; + using RE = RegisterMask; + using TE = RegisterMask; + using IDLEIE = RegisterMask; + using RXFNEIE = RegisterMask; + using TCIE = RegisterMask; + using TXFNFIE = RegisterMask; + using PEIE = RegisterMask; + using PS = RegisterMask; + using PCE = RegisterMask; + using WAKE = RegisterMask; + using M0 = RegisterMask; + using MME = RegisterMask; + using CMIE = RegisterMask; + using OVER8 = RegisterMask; + using DEDT = RegisterMask; + using DEAT = RegisterMask; + using RTOIE = RegisterMask; + using EOBIE = RegisterMask; + using M1 = RegisterMask; + using FIFOEN = RegisterMask; + using TXFEIE = RegisterMask; + using RXFFIE = RegisterMask; + }; + struct CR1_ALTERNATE : public MemRegister { + using UE = RegisterMask; + using UESM = RegisterMask; + using RE = RegisterMask; + using TE = RegisterMask; + using IDLEIE = RegisterMask; + using RXNEIE = RegisterMask; + using TCIE = RegisterMask; + using TXEIE = RegisterMask; + using PEIE = RegisterMask; + using PS = RegisterMask; + using PCE = RegisterMask; + using WAKE = RegisterMask; + using M0 = RegisterMask; + using MME = RegisterMask; + using CMIE = RegisterMask; + using OVER8 = RegisterMask; + using DEDT = RegisterMask; + using DEAT = RegisterMask; + using RTOIE = RegisterMask; + using EOBIE = RegisterMask; + using M1 = RegisterMask; + using FIFOEN = RegisterMask; + }; + struct CR2 : public MemRegister { + using SLVEN = RegisterMask; + using DIS_NSS = RegisterMask; + using ADDM7 = RegisterMask; + using LBDL = RegisterMask; + using LBDIE = RegisterMask; + using LBCL = RegisterMask; + using CPHA = RegisterMask; + using CPOL = RegisterMask; + using CLKEN = RegisterMask; + using STOP = RegisterMask; + using LINEN = RegisterMask; + using SWAP = RegisterMask; + using RXINV = RegisterMask; + using TXINV = RegisterMask; + using DATAINV = RegisterMask; + using MSBFIRST = RegisterMask; + using ABREN = RegisterMask; + using ABRMOD = RegisterMask; + using RTOEN = RegisterMask; + using ADD = RegisterMask; + }; + struct CR3 : public MemRegister { + using EIE = RegisterMask; + using IREN = RegisterMask; + using IRLP = RegisterMask; + using HDSEL = RegisterMask; + using NACK = RegisterMask; + using SCEN = RegisterMask; + using DMAR = RegisterMask; + using DMAT = RegisterMask; + using RTSE = RegisterMask; + using CTSE = RegisterMask; + using CTSIE = RegisterMask; + using ONEBIT = RegisterMask; + using OVRDIS = RegisterMask; + using DDRE = RegisterMask; + using DEM = RegisterMask; + using DEP = RegisterMask; + using SCARCNT = RegisterMask; + using WUS0 = RegisterMask; + using WUS1 = RegisterMask; + using WUFIE = RegisterMask; + using TXFTIE = RegisterMask; + using TCBGTIE = RegisterMask; + using RXFTCFG = RegisterMask; + using RXFTIE = RegisterMask; + using TXFTCFG = RegisterMask; + }; + struct BRR : public MemRegister { + using val = RegisterMask; + }; + struct GTPR : public MemRegister { + using PSC = RegisterMask; + using GT = RegisterMask; + }; + struct RTOR : public MemRegister { + using RTO = RegisterMask; + using BLEN = RegisterMask; + }; + struct RQR : public MemRegister { + using ABRRQ = RegisterMask; + using SBKRQ = RegisterMask; + using MMRQ = RegisterMask; + using RXFRQ = RegisterMask; + using TXFRQ = RegisterMask; + }; + struct ISR : public MemRegister { + using PE = RegisterMask; + using FE = RegisterMask; + using NE = RegisterMask; + using ORE = RegisterMask; + using IDLE = RegisterMask; + using RXFNE = RegisterMask; + using TC = RegisterMask; + using TXFNF = RegisterMask; + using LBDF = RegisterMask; + using CTSIF = RegisterMask; + using CTS = RegisterMask; + using RTOF = RegisterMask; + using EOBF = RegisterMask; + using UDR = RegisterMask; + using ABRE = RegisterMask; + using ABRF = RegisterMask; + using BUSY = RegisterMask; + using CMF = RegisterMask; + using SBKF = RegisterMask; + using RWU = RegisterMask; + using WUF = RegisterMask; + using TEACK = RegisterMask; + using REACK = RegisterMask; + using TXFE = RegisterMask; + using RXFF = RegisterMask; + using TCBGT = RegisterMask; + using RXFT = RegisterMask; + using TXFT = RegisterMask; + }; + struct ISR_ALTERNATE : public MemRegister { + using PE = RegisterMask; + using FE = RegisterMask; + using NE = RegisterMask; + using ORE = RegisterMask; + using IDLE = RegisterMask; + using RXNE = RegisterMask; + using TC = RegisterMask; + using TXE = RegisterMask; + using LBDF = RegisterMask; + using CTSIF = RegisterMask; + using CTS = RegisterMask; + using RTOF = RegisterMask; + using EOBF = RegisterMask; + using UDR = RegisterMask; + using ABRE = RegisterMask; + using ABRF = RegisterMask; + using BUSY = RegisterMask; + using CMF = RegisterMask; + using SBKF = RegisterMask; + using RWU = RegisterMask; + using WUF = RegisterMask; + using TEACK = RegisterMask; + using REACK = RegisterMask; + using TCBGT = RegisterMask; + }; + struct ICR : public MemRegister { + using PECF = RegisterMask; + using FECF = RegisterMask; + using NECF = RegisterMask; + using ORECF = RegisterMask; + using IDLECF = RegisterMask; + using TXFECF = RegisterMask; + using TCCF = RegisterMask; + using TCBGTCF = RegisterMask; + using LBDCF = RegisterMask; + using CTSCF = RegisterMask; + using RTOCF = RegisterMask; + using EOBCF = RegisterMask; + using UDRCF = RegisterMask; + using CMCF = RegisterMask; + using WUCF = RegisterMask; + }; + struct RDR : public MemRegister { + using val = RegisterMask; + }; + struct TDR : public MemRegister { + using val = RegisterMask; + }; + struct PRESC : public MemRegister { + using PRESCALER = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace USART2 { + struct CR1 : public MemRegister { + using UE = RegisterMask; + using UESM = RegisterMask; + using RE = RegisterMask; + using TE = RegisterMask; + using IDLEIE = RegisterMask; + using RXFNEIE = RegisterMask; + using TCIE = RegisterMask; + using TXFNFIE = RegisterMask; + using PEIE = RegisterMask; + using PS = RegisterMask; + using PCE = RegisterMask; + using WAKE = RegisterMask; + using M0 = RegisterMask; + using MME = RegisterMask; + using CMIE = RegisterMask; + using OVER8 = RegisterMask; + using DEDT = RegisterMask; + using DEAT = RegisterMask; + using RTOIE = RegisterMask; + using EOBIE = RegisterMask; + using M1 = RegisterMask; + using FIFOEN = RegisterMask; + using TXFEIE = RegisterMask; + using RXFFIE = RegisterMask; + }; + struct CR1_ALTERNATE : public MemRegister { + using UE = RegisterMask; + using UESM = RegisterMask; + using RE = RegisterMask; + using TE = RegisterMask; + using IDLEIE = RegisterMask; + using RXNEIE = RegisterMask; + using TCIE = RegisterMask; + using TXEIE = RegisterMask; + using PEIE = RegisterMask; + using PS = RegisterMask; + using PCE = RegisterMask; + using WAKE = RegisterMask; + using M0 = RegisterMask; + using MME = RegisterMask; + using CMIE = RegisterMask; + using OVER8 = RegisterMask; + using DEDT = RegisterMask; + using DEAT = RegisterMask; + using RTOIE = RegisterMask; + using EOBIE = RegisterMask; + using M1 = RegisterMask; + using FIFOEN = RegisterMask; + }; + struct CR2 : public MemRegister { + using SLVEN = RegisterMask; + using DIS_NSS = RegisterMask; + using ADDM7 = RegisterMask; + using LBDL = RegisterMask; + using LBDIE = RegisterMask; + using LBCL = RegisterMask; + using CPHA = RegisterMask; + using CPOL = RegisterMask; + using CLKEN = RegisterMask; + using STOP = RegisterMask; + using LINEN = RegisterMask; + using SWAP = RegisterMask; + using RXINV = RegisterMask; + using TXINV = RegisterMask; + using DATAINV = RegisterMask; + using MSBFIRST = RegisterMask; + using ABREN = RegisterMask; + using ABRMOD = RegisterMask; + using RTOEN = RegisterMask; + using ADD = RegisterMask; + }; + struct CR3 : public MemRegister { + using EIE = RegisterMask; + using IREN = RegisterMask; + using IRLP = RegisterMask; + using HDSEL = RegisterMask; + using NACK = RegisterMask; + using SCEN = RegisterMask; + using DMAR = RegisterMask; + using DMAT = RegisterMask; + using RTSE = RegisterMask; + using CTSE = RegisterMask; + using CTSIE = RegisterMask; + using ONEBIT = RegisterMask; + using OVRDIS = RegisterMask; + using DDRE = RegisterMask; + using DEM = RegisterMask; + using DEP = RegisterMask; + using SCARCNT = RegisterMask; + using WUS0 = RegisterMask; + using WUS1 = RegisterMask; + using WUFIE = RegisterMask; + using TXFTIE = RegisterMask; + using TCBGTIE = RegisterMask; + using RXFTCFG = RegisterMask; + using RXFTIE = RegisterMask; + using TXFTCFG = RegisterMask; + }; + struct BRR : public MemRegister { + using val = RegisterMask; + }; + struct GTPR : public MemRegister { + using PSC = RegisterMask; + using GT = RegisterMask; + }; + struct RTOR : public MemRegister { + using RTO = RegisterMask; + using BLEN = RegisterMask; + }; + struct RQR : public MemRegister { + using ABRRQ = RegisterMask; + using SBKRQ = RegisterMask; + using MMRQ = RegisterMask; + using RXFRQ = RegisterMask; + using TXFRQ = RegisterMask; + }; + struct ISR : public MemRegister { + using PE = RegisterMask; + using FE = RegisterMask; + using NE = RegisterMask; + using ORE = RegisterMask; + using IDLE = RegisterMask; + using RXFNE = RegisterMask; + using TC = RegisterMask; + using TXFNF = RegisterMask; + using LBDF = RegisterMask; + using CTSIF = RegisterMask; + using CTS = RegisterMask; + using RTOF = RegisterMask; + using EOBF = RegisterMask; + using UDR = RegisterMask; + using ABRE = RegisterMask; + using ABRF = RegisterMask; + using BUSY = RegisterMask; + using CMF = RegisterMask; + using SBKF = RegisterMask; + using RWU = RegisterMask; + using WUF = RegisterMask; + using TEACK = RegisterMask; + using REACK = RegisterMask; + using TXFE = RegisterMask; + using RXFF = RegisterMask; + using TCBGT = RegisterMask; + using RXFT = RegisterMask; + using TXFT = RegisterMask; + }; + struct ISR_ALTERNATE : public MemRegister { + using PE = RegisterMask; + using FE = RegisterMask; + using NE = RegisterMask; + using ORE = RegisterMask; + using IDLE = RegisterMask; + using RXNE = RegisterMask; + using TC = RegisterMask; + using TXE = RegisterMask; + using LBDF = RegisterMask; + using CTSIF = RegisterMask; + using CTS = RegisterMask; + using RTOF = RegisterMask; + using EOBF = RegisterMask; + using UDR = RegisterMask; + using ABRE = RegisterMask; + using ABRF = RegisterMask; + using BUSY = RegisterMask; + using CMF = RegisterMask; + using SBKF = RegisterMask; + using RWU = RegisterMask; + using WUF = RegisterMask; + using TEACK = RegisterMask; + using REACK = RegisterMask; + using TCBGT = RegisterMask; + }; + struct ICR : public MemRegister { + using PECF = RegisterMask; + using FECF = RegisterMask; + using NECF = RegisterMask; + using ORECF = RegisterMask; + using IDLECF = RegisterMask; + using TXFECF = RegisterMask; + using TCCF = RegisterMask; + using TCBGTCF = RegisterMask; + using LBDCF = RegisterMask; + using CTSCF = RegisterMask; + using RTOCF = RegisterMask; + using EOBCF = RegisterMask; + using UDRCF = RegisterMask; + using CMCF = RegisterMask; + using WUCF = RegisterMask; + }; + struct RDR : public MemRegister { + using val = RegisterMask; + }; + struct TDR : public MemRegister { + using val = RegisterMask; + }; + struct PRESC : public MemRegister { + using PRESCALER = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace USART3 { + struct CR1 : public MemRegister { + using UE = RegisterMask; + using UESM = RegisterMask; + using RE = RegisterMask; + using TE = RegisterMask; + using IDLEIE = RegisterMask; + using RXFNEIE = RegisterMask; + using TCIE = RegisterMask; + using TXFNFIE = RegisterMask; + using PEIE = RegisterMask; + using PS = RegisterMask; + using PCE = RegisterMask; + using WAKE = RegisterMask; + using M0 = RegisterMask; + using MME = RegisterMask; + using CMIE = RegisterMask; + using OVER8 = RegisterMask; + using DEDT = RegisterMask; + using DEAT = RegisterMask; + using RTOIE = RegisterMask; + using EOBIE = RegisterMask; + using M1 = RegisterMask; + using FIFOEN = RegisterMask; + using TXFEIE = RegisterMask; + using RXFFIE = RegisterMask; + }; + struct CR1_ALTERNATE : public MemRegister { + using UE = RegisterMask; + using UESM = RegisterMask; + using RE = RegisterMask; + using TE = RegisterMask; + using IDLEIE = RegisterMask; + using RXNEIE = RegisterMask; + using TCIE = RegisterMask; + using TXEIE = RegisterMask; + using PEIE = RegisterMask; + using PS = RegisterMask; + using PCE = RegisterMask; + using WAKE = RegisterMask; + using M0 = RegisterMask; + using MME = RegisterMask; + using CMIE = RegisterMask; + using OVER8 = RegisterMask; + using DEDT = RegisterMask; + using DEAT = RegisterMask; + using RTOIE = RegisterMask; + using EOBIE = RegisterMask; + using M1 = RegisterMask; + using FIFOEN = RegisterMask; + }; + struct CR2 : public MemRegister { + using SLVEN = RegisterMask; + using DIS_NSS = RegisterMask; + using ADDM7 = RegisterMask; + using LBDL = RegisterMask; + using LBDIE = RegisterMask; + using LBCL = RegisterMask; + using CPHA = RegisterMask; + using CPOL = RegisterMask; + using CLKEN = RegisterMask; + using STOP = RegisterMask; + using LINEN = RegisterMask; + using SWAP = RegisterMask; + using RXINV = RegisterMask; + using TXINV = RegisterMask; + using DATAINV = RegisterMask; + using MSBFIRST = RegisterMask; + using ABREN = RegisterMask; + using ABRMOD = RegisterMask; + using RTOEN = RegisterMask; + using ADD = RegisterMask; + }; + struct CR3 : public MemRegister { + using EIE = RegisterMask; + using IREN = RegisterMask; + using IRLP = RegisterMask; + using HDSEL = RegisterMask; + using NACK = RegisterMask; + using SCEN = RegisterMask; + using DMAR = RegisterMask; + using DMAT = RegisterMask; + using RTSE = RegisterMask; + using CTSE = RegisterMask; + using CTSIE = RegisterMask; + using ONEBIT = RegisterMask; + using OVRDIS = RegisterMask; + using DDRE = RegisterMask; + using DEM = RegisterMask; + using DEP = RegisterMask; + using SCARCNT = RegisterMask; + using WUS0 = RegisterMask; + using WUS1 = RegisterMask; + using WUFIE = RegisterMask; + using TXFTIE = RegisterMask; + using TCBGTIE = RegisterMask; + using RXFTCFG = RegisterMask; + using RXFTIE = RegisterMask; + using TXFTCFG = RegisterMask; + }; + struct BRR : public MemRegister { + using val = RegisterMask; + }; + struct GTPR : public MemRegister { + using PSC = RegisterMask; + using GT = RegisterMask; + }; + struct RTOR : public MemRegister { + using RTO = RegisterMask; + using BLEN = RegisterMask; + }; + struct RQR : public MemRegister { + using ABRRQ = RegisterMask; + using SBKRQ = RegisterMask; + using MMRQ = RegisterMask; + using RXFRQ = RegisterMask; + using TXFRQ = RegisterMask; + }; + struct ISR : public MemRegister { + using PE = RegisterMask; + using FE = RegisterMask; + using NE = RegisterMask; + using ORE = RegisterMask; + using IDLE = RegisterMask; + using RXFNE = RegisterMask; + using TC = RegisterMask; + using TXFNF = RegisterMask; + using LBDF = RegisterMask; + using CTSIF = RegisterMask; + using CTS = RegisterMask; + using RTOF = RegisterMask; + using EOBF = RegisterMask; + using UDR = RegisterMask; + using ABRE = RegisterMask; + using ABRF = RegisterMask; + using BUSY = RegisterMask; + using CMF = RegisterMask; + using SBKF = RegisterMask; + using RWU = RegisterMask; + using WUF = RegisterMask; + using TEACK = RegisterMask; + using REACK = RegisterMask; + using TXFE = RegisterMask; + using RXFF = RegisterMask; + using TCBGT = RegisterMask; + using RXFT = RegisterMask; + using TXFT = RegisterMask; + }; + struct ISR_ALTERNATE : public MemRegister { + using PE = RegisterMask; + using FE = RegisterMask; + using NE = RegisterMask; + using ORE = RegisterMask; + using IDLE = RegisterMask; + using RXNE = RegisterMask; + using TC = RegisterMask; + using TXE = RegisterMask; + using LBDF = RegisterMask; + using CTSIF = RegisterMask; + using CTS = RegisterMask; + using RTOF = RegisterMask; + using EOBF = RegisterMask; + using UDR = RegisterMask; + using ABRE = RegisterMask; + using ABRF = RegisterMask; + using BUSY = RegisterMask; + using CMF = RegisterMask; + using SBKF = RegisterMask; + using RWU = RegisterMask; + using WUF = RegisterMask; + using TEACK = RegisterMask; + using REACK = RegisterMask; + using TCBGT = RegisterMask; + }; + struct ICR : public MemRegister { + using PECF = RegisterMask; + using FECF = RegisterMask; + using NECF = RegisterMask; + using ORECF = RegisterMask; + using IDLECF = RegisterMask; + using TXFECF = RegisterMask; + using TCCF = RegisterMask; + using TCBGTCF = RegisterMask; + using LBDCF = RegisterMask; + using CTSCF = RegisterMask; + using RTOCF = RegisterMask; + using EOBCF = RegisterMask; + using UDRCF = RegisterMask; + using CMCF = RegisterMask; + using WUCF = RegisterMask; + }; + struct RDR : public MemRegister { + using val = RegisterMask; + }; + struct TDR : public MemRegister { + using val = RegisterMask; + }; + struct PRESC : public MemRegister { + using PRESCALER = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace USART4 { + struct CR1 : public MemRegister { + using UE = RegisterMask; + using UESM = RegisterMask; + using RE = RegisterMask; + using TE = RegisterMask; + using IDLEIE = RegisterMask; + using RXFNEIE = RegisterMask; + using TCIE = RegisterMask; + using TXFNFIE = RegisterMask; + using PEIE = RegisterMask; + using PS = RegisterMask; + using PCE = RegisterMask; + using WAKE = RegisterMask; + using M0 = RegisterMask; + using MME = RegisterMask; + using CMIE = RegisterMask; + using OVER8 = RegisterMask; + using DEDT = RegisterMask; + using DEAT = RegisterMask; + using RTOIE = RegisterMask; + using EOBIE = RegisterMask; + using M1 = RegisterMask; + using FIFOEN = RegisterMask; + using TXFEIE = RegisterMask; + using RXFFIE = RegisterMask; + }; + struct CR1_ALTERNATE : public MemRegister { + using UE = RegisterMask; + using UESM = RegisterMask; + using RE = RegisterMask; + using TE = RegisterMask; + using IDLEIE = RegisterMask; + using RXNEIE = RegisterMask; + using TCIE = RegisterMask; + using TXEIE = RegisterMask; + using PEIE = RegisterMask; + using PS = RegisterMask; + using PCE = RegisterMask; + using WAKE = RegisterMask; + using M0 = RegisterMask; + using MME = RegisterMask; + using CMIE = RegisterMask; + using OVER8 = RegisterMask; + using DEDT = RegisterMask; + using DEAT = RegisterMask; + using RTOIE = RegisterMask; + using EOBIE = RegisterMask; + using M1 = RegisterMask; + using FIFOEN = RegisterMask; + }; + struct CR2 : public MemRegister { + using SLVEN = RegisterMask; + using DIS_NSS = RegisterMask; + using ADDM7 = RegisterMask; + using LBDL = RegisterMask; + using LBDIE = RegisterMask; + using LBCL = RegisterMask; + using CPHA = RegisterMask; + using CPOL = RegisterMask; + using CLKEN = RegisterMask; + using STOP = RegisterMask; + using LINEN = RegisterMask; + using SWAP = RegisterMask; + using RXINV = RegisterMask; + using TXINV = RegisterMask; + using DATAINV = RegisterMask; + using MSBFIRST = RegisterMask; + using ABREN = RegisterMask; + using ABRMOD = RegisterMask; + using RTOEN = RegisterMask; + using ADD = RegisterMask; + }; + struct CR3 : public MemRegister { + using EIE = RegisterMask; + using IREN = RegisterMask; + using IRLP = RegisterMask; + using HDSEL = RegisterMask; + using NACK = RegisterMask; + using SCEN = RegisterMask; + using DMAR = RegisterMask; + using DMAT = RegisterMask; + using RTSE = RegisterMask; + using CTSE = RegisterMask; + using CTSIE = RegisterMask; + using ONEBIT = RegisterMask; + using OVRDIS = RegisterMask; + using DDRE = RegisterMask; + using DEM = RegisterMask; + using DEP = RegisterMask; + using SCARCNT = RegisterMask; + using WUS0 = RegisterMask; + using WUS1 = RegisterMask; + using WUFIE = RegisterMask; + using TXFTIE = RegisterMask; + using TCBGTIE = RegisterMask; + using RXFTCFG = RegisterMask; + using RXFTIE = RegisterMask; + using TXFTCFG = RegisterMask; + }; + struct BRR : public MemRegister { + using val = RegisterMask; + }; + struct GTPR : public MemRegister { + using PSC = RegisterMask; + using GT = RegisterMask; + }; + struct RTOR : public MemRegister { + using RTO = RegisterMask; + using BLEN = RegisterMask; + }; + struct RQR : public MemRegister { + using ABRRQ = RegisterMask; + using SBKRQ = RegisterMask; + using MMRQ = RegisterMask; + using RXFRQ = RegisterMask; + using TXFRQ = RegisterMask; + }; + struct ISR : public MemRegister { + using PE = RegisterMask; + using FE = RegisterMask; + using NE = RegisterMask; + using ORE = RegisterMask; + using IDLE = RegisterMask; + using RXFNE = RegisterMask; + using TC = RegisterMask; + using TXFNF = RegisterMask; + using LBDF = RegisterMask; + using CTSIF = RegisterMask; + using CTS = RegisterMask; + using RTOF = RegisterMask; + using EOBF = RegisterMask; + using UDR = RegisterMask; + using ABRE = RegisterMask; + using ABRF = RegisterMask; + using BUSY = RegisterMask; + using CMF = RegisterMask; + using SBKF = RegisterMask; + using RWU = RegisterMask; + using WUF = RegisterMask; + using TEACK = RegisterMask; + using REACK = RegisterMask; + using TXFE = RegisterMask; + using RXFF = RegisterMask; + using TCBGT = RegisterMask; + using RXFT = RegisterMask; + using TXFT = RegisterMask; + }; + struct ISR_ALTERNATE : public MemRegister { + using PE = RegisterMask; + using FE = RegisterMask; + using NE = RegisterMask; + using ORE = RegisterMask; + using IDLE = RegisterMask; + using RXNE = RegisterMask; + using TC = RegisterMask; + using TXE = RegisterMask; + using LBDF = RegisterMask; + using CTSIF = RegisterMask; + using CTS = RegisterMask; + using RTOF = RegisterMask; + using EOBF = RegisterMask; + using UDR = RegisterMask; + using ABRE = RegisterMask; + using ABRF = RegisterMask; + using BUSY = RegisterMask; + using CMF = RegisterMask; + using SBKF = RegisterMask; + using RWU = RegisterMask; + using WUF = RegisterMask; + using TEACK = RegisterMask; + using REACK = RegisterMask; + using TCBGT = RegisterMask; + }; + struct ICR : public MemRegister { + using PECF = RegisterMask; + using FECF = RegisterMask; + using NECF = RegisterMask; + using ORECF = RegisterMask; + using IDLECF = RegisterMask; + using TXFECF = RegisterMask; + using TCCF = RegisterMask; + using TCBGTCF = RegisterMask; + using LBDCF = RegisterMask; + using CTSCF = RegisterMask; + using RTOCF = RegisterMask; + using EOBCF = RegisterMask; + using UDRCF = RegisterMask; + using CMCF = RegisterMask; + using WUCF = RegisterMask; + }; + struct RDR : public MemRegister { + using val = RegisterMask; + }; + struct TDR : public MemRegister { + using val = RegisterMask; + }; + struct PRESC : public MemRegister { + using PRESCALER = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace USB { + struct CHEP0R : public MemRegister { + using EA = RegisterMask; + using STATTX = RegisterMask; + using DTOGTX = RegisterMask; + using VTTX = RegisterMask; + using EPKIND = RegisterMask; + using UTYPE = RegisterMask; + using SETUP = RegisterMask; + using STATRX = RegisterMask; + using DTOGRX = RegisterMask; + using VTRX = RegisterMask; + using DEVADDR = RegisterMask; + using NAK = RegisterMask; + using LS_EP = RegisterMask; + using ERR_TX = RegisterMask; + using ERR_RX = RegisterMask; + using THREE_ERR_TX = RegisterMask; + using THREE_ERR_RX = RegisterMask; + }; + struct CHEP1R : public MemRegister { + using EA = RegisterMask; + using STATTX = RegisterMask; + using DTOGTX = RegisterMask; + using VTTX = RegisterMask; + using EPKIND = RegisterMask; + using UTYPE = RegisterMask; + using SETUP = RegisterMask; + using STATRX = RegisterMask; + using DTOGRX = RegisterMask; + using VTRX = RegisterMask; + using DEVADDR = RegisterMask; + using NAK = RegisterMask; + using LS_EP = RegisterMask; + using ERR_TX = RegisterMask; + using ERR_RX = RegisterMask; + using THREE_ERR_TX = RegisterMask; + using THREE_ERR_RX = RegisterMask; + }; + struct CHEP2R : public MemRegister { + using EA = RegisterMask; + using STATTX = RegisterMask; + using DTOGTX = RegisterMask; + using VTTX = RegisterMask; + using EPKIND = RegisterMask; + using UTYPE = RegisterMask; + using SETUP = RegisterMask; + using STATRX = RegisterMask; + using DTOGRX = RegisterMask; + using VTRX = RegisterMask; + using DEVADDR = RegisterMask; + using NAK = RegisterMask; + using LS_EP = RegisterMask; + using ERR_TX = RegisterMask; + using ERR_RX = RegisterMask; + using THREE_ERR_TX = RegisterMask; + using THREE_ERR_RX = RegisterMask; + }; + struct CHEP3R : public MemRegister { + using EA = RegisterMask; + using STATTX = RegisterMask; + using DTOGTX = RegisterMask; + using VTTX = RegisterMask; + using EPKIND = RegisterMask; + using UTYPE = RegisterMask; + using SETUP = RegisterMask; + using STATRX = RegisterMask; + using DTOGRX = RegisterMask; + using VTRX = RegisterMask; + using DEVADDR = RegisterMask; + using NAK = RegisterMask; + using LS_EP = RegisterMask; + using ERR_TX = RegisterMask; + using ERR_RX = RegisterMask; + using THREE_ERR_TX = RegisterMask; + using THREE_ERR_RX = RegisterMask; + }; + struct CHEP4R : public MemRegister { + using EA = RegisterMask; + using STATTX = RegisterMask; + using DTOGTX = RegisterMask; + using VTTX = RegisterMask; + using EPKIND = RegisterMask; + using UTYPE = RegisterMask; + using SETUP = RegisterMask; + using STATRX = RegisterMask; + using DTOGRX = RegisterMask; + using VTRX = RegisterMask; + using DEVADDR = RegisterMask; + using NAK = RegisterMask; + using LS_EP = RegisterMask; + using ERR_TX = RegisterMask; + using ERR_RX = RegisterMask; + using THREE_ERR_TX = RegisterMask; + using THREE_ERR_RX = RegisterMask; + }; + struct CHEP5R : public MemRegister { + using EA = RegisterMask; + using STATTX = RegisterMask; + using DTOGTX = RegisterMask; + using VTTX = RegisterMask; + using EPKIND = RegisterMask; + using UTYPE = RegisterMask; + using SETUP = RegisterMask; + using STATRX = RegisterMask; + using DTOGRX = RegisterMask; + using VTRX = RegisterMask; + using DEVADDR = RegisterMask; + using NAK = RegisterMask; + using LS_EP = RegisterMask; + using ERR_TX = RegisterMask; + using ERR_RX = RegisterMask; + using THREE_ERR_TX = RegisterMask; + using THREE_ERR_RX = RegisterMask; + }; + struct CHEP6R : public MemRegister { + using EA = RegisterMask; + using STATTX = RegisterMask; + using DTOGTX = RegisterMask; + using VTTX = RegisterMask; + using EPKIND = RegisterMask; + using UTYPE = RegisterMask; + using SETUP = RegisterMask; + using STATRX = RegisterMask; + using DTOGRX = RegisterMask; + using VTRX = RegisterMask; + using DEVADDR = RegisterMask; + using NAK = RegisterMask; + using LS_EP = RegisterMask; + using ERR_TX = RegisterMask; + using ERR_RX = RegisterMask; + using THREE_ERR_TX = RegisterMask; + using THREE_ERR_RX = RegisterMask; + }; + struct CHEP7R : public MemRegister { + using EA = RegisterMask; + using STATTX = RegisterMask; + using DTOGTX = RegisterMask; + using VTTX = RegisterMask; + using EPKIND = RegisterMask; + using UTYPE = RegisterMask; + using SETUP = RegisterMask; + using STATRX = RegisterMask; + using DTOGRX = RegisterMask; + using VTRX = RegisterMask; + using DEVADDR = RegisterMask; + using NAK = RegisterMask; + using LS_EP = RegisterMask; + using ERR_TX = RegisterMask; + using ERR_RX = RegisterMask; + using THREE_ERR_TX = RegisterMask; + using THREE_ERR_RX = RegisterMask; + }; + struct CNTR : public MemRegister { + using USBRST = RegisterMask; + using PDWN = RegisterMask; + using SUSPRDY = RegisterMask; + using SUSPEN = RegisterMask; + using L2RES = RegisterMask; + using L1RES = RegisterMask; + using L1REQM = RegisterMask; + using ESOFM = RegisterMask; + using SOFM = RegisterMask; + using RST_DCONM = RegisterMask; + using SUSPM = RegisterMask; + using WKUPM = RegisterMask; + using ERRM = RegisterMask; + using PMAOVRM = RegisterMask; + using CTRM = RegisterMask; + using THR512M = RegisterMask; + using DDISCM = RegisterMask; + using HOST = RegisterMask; + }; + struct ISTR : public MemRegister { + using IDN = RegisterMask; + using DIR = RegisterMask; + using L1REQ = RegisterMask; + using ESOF = RegisterMask; + using SOF = RegisterMask; + using RST_DCON = RegisterMask; + using SUSP = RegisterMask; + using WKUP = RegisterMask; + using ERR = RegisterMask; + using PMAOVR = RegisterMask; + using CTR = RegisterMask; + using THR512 = RegisterMask; + using DDISC = RegisterMask; + using DCON_STAT = RegisterMask; + using LS_DCON = RegisterMask; + }; + struct FNR : public MemRegister { + using FN = RegisterMask; + using LSOF = RegisterMask; + using LCK = RegisterMask; + using RXDM = RegisterMask; + using RXDP = RegisterMask; + }; + struct DADDR : public MemRegister { + using ADD = RegisterMask; + using EF = RegisterMask; + }; + struct LPMCSR : public MemRegister { + using LPMEN = RegisterMask; + using LPMACK = RegisterMask; + using REMWAKE = RegisterMask; + using BESL = RegisterMask; + }; + struct BCDR : public MemRegister { + using BCDEN = RegisterMask; + using DCDEN = RegisterMask; + using PDEN = RegisterMask; + using SDEN = RegisterMask; + using DCDET = RegisterMask; + using PDET = RegisterMask; + using SDET = RegisterMask; + using PS2DET = RegisterMask; + using DPPU_DPD = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace VREFBUF { + struct CSR : public MemRegister { + using ENVR = RegisterMask; + using HIZ = RegisterMask; + using VRS = RegisterMask; + using VRR = RegisterMask; + }; + struct CCR : public MemRegister { + using TRIM = RegisterMask; + }; + using ALL = RegisterGroup; + } + namespace WWDG { + struct CR : public MemRegister { + using T = RegisterMask; + using WDGA = RegisterMask; + }; + struct CFR : public MemRegister { + using W = RegisterMask; + using EWI = RegisterMask; + using WDGTB = RegisterMask; + }; + struct SR : public MemRegister { + using EWIF = RegisterMask; + }; + using ALL = RegisterGroup; + } +} -- cgit v1.2.3