From 5aa8a44d745ac8709061be6ddc82345bfa5ea4c9 Mon Sep 17 00:00:00 2001 From: Frank Voorburg Date: Tue, 15 Nov 2016 16:08:42 +0000 Subject: [PATCH] Refs #125 - Added ST Nucleo-F091RC demo bootloader and user program. git-svn-id: https://svn.code.sf.net/p/openblt/code/trunk@183 5dc33758-31d5-4daf-9ae8-b24bf3d40d73 --- .../Boot/bin/openblt_stm32f091.elf | Bin 0 -> 609652 bytes .../Boot/bin/openblt_stm32f091.map | 4954 +++ .../Boot/bin/openblt_stm32f091.srec | 510 + .../Boot/blt_conf.h | 175 + .../Boot/boot.dox | 7 + .../Boot/cfg/STM32F091x.svd | 31643 ++++++++++++++++ .../Boot/hooks.c | 295 + .../Boot/ide/stm32f091.depend | 567 + .../Boot/ide/stm32f091.ebp | 410 + .../Boot/ide/stm32f091.elay | 94 + .../Boot/led.c | 100 + .../Boot/led.h | 40 + .../Boot/lib/SPL/Release_Notes.html | 390 + .../Boot/lib/SPL/inc/stm32f0xx_adc.h | 450 + .../Boot/lib/SPL/inc/stm32f0xx_can.h | 643 + .../Boot/lib/SPL/inc/stm32f0xx_cec.h | 300 + .../Boot/lib/SPL/inc/stm32f0xx_comp.h | 245 + .../Boot/lib/SPL/inc/stm32f0xx_crc.h | 122 + .../Boot/lib/SPL/inc/stm32f0xx_crs.h | 183 + .../Boot/lib/SPL/inc/stm32f0xx_dac.h | 312 + .../Boot/lib/SPL/inc/stm32f0xx_dbgmcu.h | 107 + .../Boot/lib/SPL/inc/stm32f0xx_dma.h | 804 + .../Boot/lib/SPL/inc/stm32f0xx_exti.h | 216 + .../Boot/lib/SPL/inc/stm32f0xx_flash.h | 435 + .../Boot/lib/SPL/inc/stm32f0xx_gpio.h | 358 + .../Boot/lib/SPL/inc/stm32f0xx_i2c.h | 478 + .../Boot/lib/SPL/inc/stm32f0xx_iwdg.h | 140 + .../Boot/lib/SPL/inc/stm32f0xx_misc.h | 143 + .../Boot/lib/SPL/inc/stm32f0xx_pwr.h | 197 + .../Boot/lib/SPL/inc/stm32f0xx_rcc.h | 624 + .../Boot/lib/SPL/inc/stm32f0xx_rtc.h | 807 + .../Boot/lib/SPL/inc/stm32f0xx_spi.h | 588 + .../Boot/lib/SPL/inc/stm32f0xx_syscfg.h | 459 + .../Boot/lib/SPL/inc/stm32f0xx_tim.h | 1186 + .../Boot/lib/SPL/inc/stm32f0xx_usart.h | 604 + .../Boot/lib/SPL/inc/stm32f0xx_wwdg.h | 109 + .../Boot/lib/SPL/src/stm32f0xx_adc.c | 1240 + .../Boot/lib/SPL/src/stm32f0xx_can.c | 1631 + .../Boot/lib/SPL/src/stm32f0xx_cec.c | 607 + .../Boot/lib/SPL/src/stm32f0xx_comp.c | 408 + .../Boot/lib/SPL/src/stm32f0xx_crc.c | 361 + .../Boot/lib/SPL/src/stm32f0xx_crs.c | 466 + .../Boot/lib/SPL/src/stm32f0xx_dac.c | 692 + .../Boot/lib/SPL/src/stm32f0xx_dbgmcu.c | 218 + .../Boot/lib/SPL/src/stm32f0xx_dma.c | 891 + .../Boot/lib/SPL/src/stm32f0xx_exti.c | 314 + .../Boot/lib/SPL/src/stm32f0xx_flash.c | 1256 + .../Boot/lib/SPL/src/stm32f0xx_gpio.c | 542 + .../Boot/lib/SPL/src/stm32f0xx_i2c.c | 1585 + .../Boot/lib/SPL/src/stm32f0xx_iwdg.c | 293 + .../Boot/lib/SPL/src/stm32f0xx_misc.c | 167 + .../Boot/lib/SPL/src/stm32f0xx_pwr.c | 566 + .../Boot/lib/SPL/src/stm32f0xx_rcc.c | 1781 + .../Boot/lib/SPL/src/stm32f0xx_rtc.c | 2518 ++ .../Boot/lib/SPL/src/stm32f0xx_spi.c | 1334 + .../Boot/lib/SPL/src/stm32f0xx_syscfg.c | 420 + .../Boot/lib/SPL/src/stm32f0xx_tim.c | 3349 ++ .../Boot/lib/SPL/src/stm32f0xx_usart.c | 2168 ++ .../Boot/lib/SPL/src/stm32f0xx_wwdg.c | 303 + .../Boot/lib/cmsis/arm_common_tables.h | 93 + .../Boot/lib/cmsis/arm_const_structs.h | 85 + .../Boot/lib/cmsis/arm_math.h | 7306 ++++ .../Boot/lib/cmsis/core_cm0.h | 682 + .../Boot/lib/cmsis/core_cmFunc.h | 636 + .../Boot/lib/cmsis/core_cmInstr.h | 688 + .../Boot/lib/stm32f0xx.h | 5707 +++ .../Boot/lib/stm32f0xx_conf.h | 83 + .../Boot/lib/system_stm32f0xx.c | 331 + .../Boot/lib/system_stm32f0xx.h | 104 + .../Boot/main.c | 130 + .../Prog/bin/demoprog_stm32f091.elf | Bin 0 -> 489656 bytes .../Prog/bin/demoprog_stm32f091.map | 3957 ++ .../Prog/bin/demoprog_stm32f091.srec | 266 + .../Prog/boot.c | 397 + .../Prog/boot.h | 40 + .../Prog/cfg/STM32F091x.svd | 31643 ++++++++++++++++ .../Prog/cfg/stm32f091rc_flash.ld | 186 + .../Prog/header.h | 42 + .../Prog/ide/stm32f091.depend | 788 + .../Prog/ide/stm32f091.ebp | 307 + .../Prog/ide/stm32f091.elay | 19 + .../Prog/led.c | 103 + .../Prog/led.h | 39 + .../Prog/lib/SPL/Release_Notes.html | 390 + .../Prog/lib/SPL/inc/stm32f0xx_adc.h | 450 + .../Prog/lib/SPL/inc/stm32f0xx_can.h | 643 + .../Prog/lib/SPL/inc/stm32f0xx_cec.h | 300 + .../Prog/lib/SPL/inc/stm32f0xx_comp.h | 245 + .../Prog/lib/SPL/inc/stm32f0xx_crc.h | 122 + .../Prog/lib/SPL/inc/stm32f0xx_crs.h | 183 + .../Prog/lib/SPL/inc/stm32f0xx_dac.h | 312 + .../Prog/lib/SPL/inc/stm32f0xx_dbgmcu.h | 107 + .../Prog/lib/SPL/inc/stm32f0xx_dma.h | 804 + .../Prog/lib/SPL/inc/stm32f0xx_exti.h | 216 + .../Prog/lib/SPL/inc/stm32f0xx_flash.h | 435 + .../Prog/lib/SPL/inc/stm32f0xx_gpio.h | 358 + .../Prog/lib/SPL/inc/stm32f0xx_i2c.h | 478 + .../Prog/lib/SPL/inc/stm32f0xx_iwdg.h | 140 + .../Prog/lib/SPL/inc/stm32f0xx_misc.h | 143 + .../Prog/lib/SPL/inc/stm32f0xx_pwr.h | 197 + .../Prog/lib/SPL/inc/stm32f0xx_rcc.h | 624 + .../Prog/lib/SPL/inc/stm32f0xx_rtc.h | 807 + .../Prog/lib/SPL/inc/stm32f0xx_spi.h | 588 + .../Prog/lib/SPL/inc/stm32f0xx_syscfg.h | 459 + .../Prog/lib/SPL/inc/stm32f0xx_tim.h | 1186 + .../Prog/lib/SPL/inc/stm32f0xx_usart.h | 604 + .../Prog/lib/SPL/inc/stm32f0xx_wwdg.h | 109 + .../Prog/lib/SPL/src/stm32f0xx_adc.c | 1240 + .../Prog/lib/SPL/src/stm32f0xx_can.c | 1631 + .../Prog/lib/SPL/src/stm32f0xx_cec.c | 607 + .../Prog/lib/SPL/src/stm32f0xx_comp.c | 408 + .../Prog/lib/SPL/src/stm32f0xx_crc.c | 361 + .../Prog/lib/SPL/src/stm32f0xx_crs.c | 466 + .../Prog/lib/SPL/src/stm32f0xx_dac.c | 692 + .../Prog/lib/SPL/src/stm32f0xx_dbgmcu.c | 218 + .../Prog/lib/SPL/src/stm32f0xx_dma.c | 891 + .../Prog/lib/SPL/src/stm32f0xx_exti.c | 314 + .../Prog/lib/SPL/src/stm32f0xx_flash.c | 1256 + .../Prog/lib/SPL/src/stm32f0xx_gpio.c | 542 + .../Prog/lib/SPL/src/stm32f0xx_i2c.c | 1585 + .../Prog/lib/SPL/src/stm32f0xx_iwdg.c | 293 + .../Prog/lib/SPL/src/stm32f0xx_misc.c | 167 + .../Prog/lib/SPL/src/stm32f0xx_pwr.c | 566 + .../Prog/lib/SPL/src/stm32f0xx_rcc.c | 1781 + .../Prog/lib/SPL/src/stm32f0xx_rtc.c | 2518 ++ .../Prog/lib/SPL/src/stm32f0xx_spi.c | 1334 + .../Prog/lib/SPL/src/stm32f0xx_syscfg.c | 420 + .../Prog/lib/SPL/src/stm32f0xx_tim.c | 3349 ++ .../Prog/lib/SPL/src/stm32f0xx_usart.c | 2168 ++ .../Prog/lib/SPL/src/stm32f0xx_wwdg.c | 303 + .../Prog/lib/cmsis/arm_common_tables.h | 93 + .../Prog/lib/cmsis/arm_const_structs.h | 85 + .../Prog/lib/cmsis/arm_math.h | 7306 ++++ .../Prog/lib/cmsis/core_cm0.h | 682 + .../Prog/lib/cmsis/core_cmFunc.h | 636 + .../Prog/lib/cmsis/core_cmInstr.h | 688 + .../Prog/lib/stm32f0xx.h | 5707 +++ .../Prog/lib/stm32f0xx_conf.h | 83 + .../Prog/lib/system_stm32f0xx.c | 331 + .../Prog/lib/system_stm32f0xx.h | 104 + .../Prog/main.c | 81 + .../Prog/prog.dox | 5 + .../Prog/startup_stm32f0xx.S | 252 + .../Prog/timer.c | 106 + .../Prog/timer.h | 40 + .../ARMCM0_STM32F0_Nucleo_F091RC_GCC/demo.dox | 8 + .../Boot/bin/openblt_stm32f303.elf | Bin 823712 -> 823552 bytes .../Boot/bin/openblt_stm32f303.map | 50 +- .../Boot/ide/stm32f303.ebp | 8 +- .../Prog/ide/stm32f303.ebp | 5 +- Target/Source/ARMCM0_STM32F0/can.c | 243 + 151 files changed, 174927 insertions(+), 33 deletions(-) create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/bin/openblt_stm32f091.elf create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/bin/openblt_stm32f091.map create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/bin/openblt_stm32f091.srec create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/blt_conf.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/boot.dox create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/cfg/STM32F091x.svd create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/hooks.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/ide/stm32f091.depend create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/ide/stm32f091.ebp create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/ide/stm32f091.elay create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/led.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/led.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/Release_Notes.html create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_adc.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_can.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_cec.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_comp.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_crc.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_crs.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_dac.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_dbgmcu.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_dma.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_exti.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_flash.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_gpio.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_i2c.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_iwdg.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_misc.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_pwr.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_rcc.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_rtc.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_spi.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_syscfg.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_tim.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_usart.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_wwdg.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_adc.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_can.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_cec.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_comp.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_crc.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_crs.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_dac.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_dbgmcu.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_dma.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_exti.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_flash.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_gpio.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_i2c.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_iwdg.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_misc.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_pwr.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_rcc.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_rtc.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_spi.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_syscfg.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_tim.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_usart.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_wwdg.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/arm_common_tables.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/arm_const_structs.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/arm_math.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/core_cm0.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/core_cmFunc.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/core_cmInstr.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/stm32f0xx.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/stm32f0xx_conf.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/system_stm32f0xx.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/system_stm32f0xx.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/main.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/bin/demoprog_stm32f091.elf create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/bin/demoprog_stm32f091.map create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/bin/demoprog_stm32f091.srec create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/boot.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/boot.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/cfg/STM32F091x.svd create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/cfg/stm32f091rc_flash.ld create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/header.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/ide/stm32f091.depend create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/ide/stm32f091.ebp create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/ide/stm32f091.elay create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/led.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/led.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/Release_Notes.html create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_adc.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_can.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_cec.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_comp.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_crc.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_crs.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_dac.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_dbgmcu.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_dma.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_exti.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_flash.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_gpio.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_i2c.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_iwdg.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_misc.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_pwr.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_rcc.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_rtc.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_spi.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_syscfg.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_tim.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_usart.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_wwdg.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_adc.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_can.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_cec.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_comp.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_crc.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_crs.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_dac.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_dbgmcu.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_dma.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_exti.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_flash.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_gpio.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_i2c.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_iwdg.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_misc.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_pwr.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_rcc.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_rtc.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_spi.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_syscfg.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_tim.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_usart.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_wwdg.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/arm_common_tables.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/arm_const_structs.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/arm_math.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/core_cm0.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/core_cmFunc.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/core_cmInstr.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/stm32f0xx.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/stm32f0xx_conf.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/system_stm32f0xx.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/system_stm32f0xx.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/main.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/prog.dox create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/startup_stm32f0xx.S create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/timer.c create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/timer.h create mode 100644 Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/demo.dox create mode 100644 Target/Source/ARMCM0_STM32F0/can.c diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/bin/openblt_stm32f091.elf b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/bin/openblt_stm32f091.elf new file mode 100644 index 0000000000000000000000000000000000000000..c097bcea0d34acfe4db8bda5794a0a0c1406bd4b GIT binary patch literal 609652 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

-=d< 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.DY#kI?m+_7y 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 literal 0 HcmV?d00001 diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/bin/openblt_stm32f091.map b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/bin/openblt_stm32f091.map new file mode 100644 index 00000000..8493336e --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/bin/openblt_stm32f091.map @@ -0,0 +1,4954 @@ +Archive member included to satisfy reference by file (symbol) + +c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_udivsi3.o) + ..\obj\lib\spl\src\stm32f0xx_rcc.o (__aeabi_uidiv) +c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_dvmd_tls.o) + c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_udivsi3.o) (__aeabi_idiv0) +c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-exit.o) + c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m/crt0.o (exit) +c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-impure.o) + c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-exit.o) (_global_impure_ptr) +c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-init.o) + c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m/crt0.o (__libc_init_array) +c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-memset.o) + c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m/crt0.o (memset) +c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libnosys_s.a(_exit.o) + c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-exit.o) (_exit) + +Discarded input sections + + .text 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crti.o + .data 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crti.o + .bss 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crti.o + .data 0x00000000 0x4 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o + .data 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m/crt0.o + .bss 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m/crt0.o + .ARM.extab 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m/crt0.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\hooks.o + .text 0x00000000 0x0 ..\obj\hooks.o + .data 0x00000000 0x0 ..\obj\hooks.o + .bss 0x00000000 0x0 ..\obj\hooks.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .text 0x00000000 0x0 ..\obj\led.o + .data 0x00000000 0x0 ..\obj\led.o + .bss 0x00000000 0x0 ..\obj\led.o + .debug_macro 0x00000000 0x832 ..\obj\led.o + .debug_macro 0x00000000 0x1c ..\obj\led.o + .debug_macro 0x00000000 0x1c ..\obj\led.o + .debug_macro 0x00000000 0x22 ..\obj\led.o + .debug_macro 0x00000000 0x93 ..\obj\led.o + .debug_macro 0x00000000 0x3e ..\obj\led.o + .debug_macro 0x00000000 0x1c ..\obj\led.o + .debug_macro 0x00000000 0x9f ..\obj\led.o + .debug_macro 0x00000000 0x40 ..\obj\led.o + .debug_macro 0x00000000 0x81 ..\obj\led.o + .debug_macro 0x00000000 0x3a ..\obj\led.o + .debug_macro 0x00000000 0x22 ..\obj\led.o + .debug_macro 0x00000000 0x87 ..\obj\led.o + .debug_macro 0x00000000 0x44 ..\obj\led.o + .debug_macro 0x00000000 0xfd ..\obj\led.o + .debug_macro 0x00000000 0x5e ..\obj\led.o + .debug_macro 0x00000000 0x1df ..\obj\led.o + .debug_macro 0x00000000 0x1f ..\obj\led.o + .debug_macro 0x00000000 0x242 ..\obj\led.o + .debug_macro 0x00000000 0x632a ..\obj\led.o + .debug_macro 0x00000000 0x2eb ..\obj\led.o + .debug_macro 0x00000000 0x3cf ..\obj\led.o + .debug_macro 0x00000000 0x191 ..\obj\led.o + .debug_macro 0x00000000 0xef ..\obj\led.o + .debug_macro 0x00000000 0x46 ..\obj\led.o + .debug_macro 0x00000000 0xd9 ..\obj\led.o + .debug_macro 0x00000000 0x184 ..\obj\led.o + .debug_macro 0x00000000 0x7c ..\obj\led.o + .debug_macro 0x00000000 0x85b ..\obj\led.o + .debug_macro 0x00000000 0xd5 ..\obj\led.o + .debug_macro 0x00000000 0x2b7 ..\obj\led.o + .debug_macro 0x00000000 0x185 ..\obj\led.o + .debug_macro 0x00000000 0x2a0 ..\obj\led.o + .debug_macro 0x00000000 0x70 ..\obj\led.o + .debug_macro 0x00000000 0xdf ..\obj\led.o + .debug_macro 0x00000000 0x561 ..\obj\led.o + .debug_macro 0x00000000 0x4c5 ..\obj\led.o + .debug_macro 0x00000000 0x396 ..\obj\led.o + .debug_macro 0x00000000 0x471 ..\obj\led.o + .debug_macro 0x00000000 0x750 ..\obj\led.o + .debug_macro 0x00000000 0x356 ..\obj\led.o + .debug_macro 0x00000000 0x34 ..\obj\led.o + .debug_macro 0x00000000 0x3a ..\obj\led.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_adc.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_adc.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_DeInit + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_Init + 0x00000000 0x2c ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_StructInit + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_Cmd 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_ClockModeConfig + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_JitterCmd + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_AutoPowerOffCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_WaitModeCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_AnalogWatchdogCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_AnalogWatchdogThresholdsConfig + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_AnalogWatchdogSingleChannelConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_AnalogWatchdogSingleChannelCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_TempSensorCmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_VrefintCmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_VbatCmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_ChannelConfig + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_ContinuousModeCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_DiscModeCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_OverrunModeCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_GetCalibrationFactor + 0x00000000 0x38 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_StopOfConversion + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_StartOfConversion + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_GetConversionValue + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_DMACmd + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_DMARequestModeConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_ITConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_GetFlagStatus + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_ClearFlag + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_GetITStatus + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_ClearITPendingBit + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_info 0x00000000 0x906 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_abbrev 0x00000000 0x1b0 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_loc 0x00000000 0x41e ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_aranges + 0x00000000 0x108 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_ranges 0x00000000 0xf8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x19f ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x3c9 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_line 0x00000000 0x6b0 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_str 0x00000000 0x4a54e ..\obj\lib\spl\src\stm32f0xx_adc.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_frame 0x00000000 0x204 ..\obj\lib\spl\src\stm32f0xx_adc.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_can.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_can.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_SlaveStartBank + 0x00000000 0x30 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_DBGFreeze + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_TTComModeCmd + 0x00000000 0x58 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_CancelTransmit + 0x00000000 0x30 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_FIFORelease + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_OperatingModeRequest + 0x00000000 0xac ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_Sleep + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_WakeUp + 0x00000000 0x30 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_GetLastErrorCode + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_GetReceiveErrorCounter + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_GetLSBTransmitErrorCounter + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_ITConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_GetFlagStatus + 0x00000000 0x6c ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_ClearFlag + 0x00000000 0x30 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_GetITStatus + 0x00000000 0xfc ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_ClearITPendingBit + 0x00000000 0xb0 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x3c9 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_cec.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_cec.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_DeInit + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_Init + 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_StructInit + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_Cmd 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_ListenModeCmd + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_OwnAddressConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_OwnAddressClear + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_SendData + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_ReceiveData + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_StartOfMessage + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_EndOfMessage + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_ITConfig + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_GetFlagStatus + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_ClearFlag + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_GetITStatus + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_ClearITPendingBit + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_info 0x00000000 0x47f ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_abbrev 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_loc 0x00000000 0x1ac ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_aranges + 0x00000000 0x98 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_ranges 0x00000000 0x88 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x19f ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x18b ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_line 0x00000000 0x579 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_str 0x00000000 0x4a343 ..\obj\lib\spl\src\stm32f0xx_cec.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_frame 0x00000000 0x120 ..\obj\lib\spl\src\stm32f0xx_cec.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_comp.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_comp.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_comp.o + .text.COMP_DeInit + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_comp.o + .text.COMP_Init + 0x00000000 0x30 ..\obj\lib\spl\src\stm32f0xx_comp.o + .text.COMP_StructInit + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_comp.o + .text.COMP_Cmd + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_comp.o + .text.COMP_SwitchCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_comp.o + .text.COMP_GetOutputLevel + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_comp.o + .text.COMP_WindowCmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_comp.o + .text.COMP_LockConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_info 0x00000000 0x27c ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_abbrev 0x00000000 0x181 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_loc 0x00000000 0xd0 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_aranges + 0x00000000 0x58 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_ranges 0x00000000 0x48 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x199 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0xe9 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_line 0x00000000 0x4d9 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_str 0x00000000 0x4a1e1 ..\obj\lib\spl\src\stm32f0xx_comp.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_frame 0x00000000 0x9c ..\obj\lib\spl\src\stm32f0xx_comp.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_crc.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_crc.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_DeInit + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_ResetDR + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_PolynomialSizeSelect + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_ReverseInputDataSelect + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_ReverseOutputDataCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_SetInitRegister + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_SetPolynomial + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_CalcCRC + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_CalcCRC16bits + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_CalcCRC8bits + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_CalcBlockCRC + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_GetCRC + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_SetIDRegister + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_GetIDRegister + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_info 0x00000000 0x379 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_abbrev 0x00000000 0x192 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_loc 0x00000000 0x154 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_aranges + 0x00000000 0x88 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_ranges 0x00000000 0x78 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x193 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x40 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_line 0x00000000 0x551 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_str 0x00000000 0x4a26a ..\obj\lib\spl\src\stm32f0xx_crc.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_frame 0x00000000 0xf0 ..\obj\lib\spl\src\stm32f0xx_crc.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_crs.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_crs.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_DeInit + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_AdjustHSI48CalibrationValue + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_FrequencyErrorCounterCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_AutomaticCalibrationCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_SoftwareSynchronizationGenerate + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_FrequencyErrorCounterReload + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_FrequencyErrorLimitConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_SynchronizationPrescalerConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_SynchronizationSourceConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_SynchronizationPolarityConfig + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_GetReloadValue + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_GetHSI48CalibrationValue + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_GetFrequencyErrorValue + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_GetFrequencyErrorDirection + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_ITConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_GetFlagStatus + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_ClearFlag + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_GetITStatus + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_ClearITPendingBit + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_info 0x00000000 0x401 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_abbrev 0x00000000 0x18d ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_loc 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_aranges + 0x00000000 0xb0 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_ranges 0x00000000 0xa0 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x199 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0xd3 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_line 0x00000000 0x59f ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_str 0x00000000 0x4a37b ..\obj\lib\spl\src\stm32f0xx_crs.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_frame 0x00000000 0x148 ..\obj\lib\spl\src\stm32f0xx_crs.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_dac.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_dac.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_DeInit + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_Init + 0x00000000 0x2c ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_StructInit + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_Cmd 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_SoftwareTriggerCmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_DualSoftwareTriggerCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_WaveGenerationCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_SetChannel1Data + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_SetChannel2Data + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_SetDualChannelData + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_GetDataOutputValue + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_DMACmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_ITConfig + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_GetFlagStatus + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_ClearFlag + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_GetITStatus + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_ClearITPendingBit + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_info 0x00000000 0x673 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_abbrev 0x00000000 0x1bc ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_loc 0x00000000 0x521 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_aranges + 0x00000000 0xa0 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_ranges 0x00000000 0x90 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x1c1 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x17e ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_line 0x00000000 0x5a0 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_str 0x00000000 0x4a475 ..\obj\lib\spl\src\stm32f0xx_dac.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_frame 0x00000000 0x140 ..\obj\lib\spl\src\stm32f0xx_dac.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .text.DBGMCU_GetREVID + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .text.DBGMCU_GetDEVID + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .text.DBGMCU_Config + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .text.DBGMCU_APB1PeriphConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .text.DBGMCU_APB2PeriphConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_info 0x00000000 0x1bd ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_abbrev 0x00000000 0xfb ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_loc 0x00000000 0xae ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_aranges + 0x00000000 0x40 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_ranges 0x00000000 0x30 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x199 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x76 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_line 0x00000000 0x49b ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_str 0x00000000 0x4a16b ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_frame 0x00000000 0x60 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_dma.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_dma.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_DeInit + 0x00000000 0x138 ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_Init + 0x00000000 0x3c ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_StructInit + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_Cmd 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_RemapConfig + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_SetCurrDataCounter + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_GetCurrDataCounter + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_ITConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_GetFlagStatus + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_ClearFlag + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_GetITStatus + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_ClearITPendingBit + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_info 0x00000000 0x4ba ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_abbrev 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_loc 0x00000000 0x1d2 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_aranges + 0x00000000 0x78 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_ranges 0x00000000 0x68 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x1e7 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x855 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_line 0x00000000 0x555 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_str 0x00000000 0x4a7d7 ..\obj\lib\spl\src\stm32f0xx_dma.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_frame 0x00000000 0xe4 ..\obj\lib\spl\src\stm32f0xx_dma.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_exti.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_exti.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_exti.o + .text.EXTI_DeInit + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_exti.o + .text.EXTI_Init + 0x00000000 0x78 ..\obj\lib\spl\src\stm32f0xx_exti.o + .text.EXTI_StructInit + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_exti.o + .text.EXTI_GenerateSWInterrupt + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_exti.o + .text.EXTI_GetFlagStatus + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_exti.o + .text.EXTI_ClearFlag + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_exti.o + .text.EXTI_GetITStatus + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_exti.o + .text.EXTI_ClearITPendingBit + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_info 0x00000000 0x327 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_abbrev 0x00000000 0x1b9 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_loc 0x00000000 0x149 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_aranges + 0x00000000 0x58 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_ranges 0x00000000 0x48 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x199 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0xcf ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_line 0x00000000 0x4de ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_str 0x00000000 0x4a270 ..\obj\lib\spl\src\stm32f0xx_exti.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_frame 0x00000000 0x98 ..\obj\lib\spl\src\stm32f0xx_exti.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_flash.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_flash.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_SetLatency + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_PrefetchBufferCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_GetPrefetchBufferStatus + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_Unlock + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_Lock + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_Launch + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_GetUser + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_GetWRP + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_GetRDP + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_ITConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_GetFlagStatus + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_EraseAllPages + 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_ProgramHalfWord + 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_Erase + 0x00000000 0x80 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_EnableWRP + 0x00000000 0x94 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_RDPConfig + 0x00000000 0x78 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_UserConfig + 0x00000000 0x50 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_BOOTConfig + 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_BOOT0Config + 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_BOOT0SWConfig + 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_VDDAConfig + 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_SRAMParityConfig + 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_WriteUser + 0x00000000 0x40 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_ProgramData + 0x00000000 0x3c ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .text.GPIO_DeInit + 0x00000000 0xc0 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .text.GPIO_StructInit + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .text.GPIO_PinLockConfig + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .text.GPIO_ReadInputData + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .text.GPIO_ReadOutputDataBit + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_gpio.o + .text.GPIO_ReadOutputData + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .text.GPIO_WriteBit + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_gpio.o + .text.GPIO_Write + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_DeInit + 0x00000000 0x38 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_Init + 0x00000000 0x64 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_StructInit + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_Cmd 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_SoftwareResetCmd + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_ITConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_StretchClockCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_StopModeCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_DualAddressCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_OwnAddress2Config + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_GeneralCallCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_SlaveByteControlCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_SlaveAddressConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_10BitAddressingModeCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_AutoEndCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_ReloadCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_NumberOfBytesConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_MasterRequestConfig + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_GenerateSTART + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_GenerateSTOP + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_10BitAddressHeaderCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_AcknowledgeConfig + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_GetAddressMatched + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_GetTransferDirection + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_TransferHandling + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_SMBusAlertCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_ClockTimeoutCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_ExtendedClockTimeoutCmd + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_IdleClockTimeoutCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_TimeoutAConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_TimeoutBConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_CalculatePEC + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_PECRequestCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_GetPEC + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_ReadRegister + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_SendData + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_ReceiveData + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_DMACmd + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_GetFlagStatus + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_ClearFlag + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_GetITStatus + 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_ClearITPendingBit + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_info 0x00000000 0xc19 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_abbrev 0x00000000 0x1ad ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_loc 0x00000000 0x621 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_aranges + 0x00000000 0x168 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_ranges 0x00000000 0x158 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x1b1 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x29a ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_line 0x00000000 0x7a8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_str 0x00000000 0x4a62c ..\obj\lib\spl\src\stm32f0xx_i2c.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_frame 0x00000000 0x2e0 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .text.IWDG_WriteAccessCmd + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .text.IWDG_SetPrescaler + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .text.IWDG_SetReload + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .text.IWDG_ReloadCounter + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .text.IWDG_SetWindowValue + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .text.IWDG_Enable + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .text.IWDG_GetFlagStatus + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_info 0x00000000 0x21d ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_abbrev 0x00000000 0x113 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_loc 0x00000000 0x62 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_aranges + 0x00000000 0x50 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_ranges 0x00000000 0x40 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x19f ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x6a ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_line 0x00000000 0x4ba ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_str 0x00000000 0x4a1d5 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_frame 0x00000000 0x80 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_misc.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_misc.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_misc.o + .text.NVIC_Init + 0x00000000 0x5c ..\obj\lib\spl\src\stm32f0xx_misc.o + .text.NVIC_SystemLPConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_misc.o + .text.SysTick_CLKSourceConfig + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_info 0x00000000 0x375 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_abbrev 0x00000000 0x159 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_loc 0x00000000 0x7f ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_aranges + 0x00000000 0x30 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_ranges 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x193 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_line 0x00000000 0x479 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_str 0x00000000 0x4a215 ..\obj\lib\spl\src\stm32f0xx_misc.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_frame 0x00000000 0x4c ..\obj\lib\spl\src\stm32f0xx_misc.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .text.PWR_DeInit + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .text.PWR_BackupAccessCmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .text.PWR_PVDLevelConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .text.PWR_PVDCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .text.PWR_WakeUpPinCmd + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_pwr.o + .text.PWR_EnterSleepMode + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .text.PWR_EnterSTOPMode + 0x00000000 0x50 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .text.PWR_EnterSTANDBYMode + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .text.PWR_GetFlagStatus + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .text.PWR_ClearFlag + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_info 0x00000000 0x44a ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_abbrev 0x00000000 0x1b0 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_loc 0x00000000 0x1ad ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_aranges + 0x00000000 0x68 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_ranges 0x00000000 0x58 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x19f ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_line 0x00000000 0x534 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_str 0x00000000 0x4a29c ..\obj\lib\spl\src\stm32f0xx_pwr.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_frame 0x00000000 0xc0 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_DeInit + 0x00000000 0x60 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_HSEConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_AdjustHSICalibrationValue + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_HSICmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_AdjustHSI14CalibrationValue + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_HSI14Cmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_HSI14ADCRequestCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_LSEConfig + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_LSEDriveConfig + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_LSICmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_PLLConfig + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_PLLCmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_HSI48Cmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_PREDIV1Config + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_ClockSecuritySystemCmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_MCOConfig + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_SYSCLKConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_GetSYSCLKSource + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_HCLKConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_PCLKConfig + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_ADCCLKConfig + 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_CECCLKConfig + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_I2CCLKConfig + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_USARTCLKConfig + 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_USBCLKConfig + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_RTCCLKConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_RTCCLKCmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_BackupResetCmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_AHBPeriphResetCmd + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_APB2PeriphResetCmd + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_ITConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_GetFlagStatus + 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_WaitForHSEStartUp + 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_ClearFlag + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_GetITStatus + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_ClearITPendingBit + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_ByteToBcd2 + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_Bcd2ToByte + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_StructInit + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_WriteProtectionCmd + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_EnterInitMode + 0x00000000 0x48 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_ExitInitMode + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_Init + 0x00000000 0x4c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_WaitForSynchro + 0x00000000 0x58 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_DeInit + 0x00000000 0x5c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_RefClockCmd + 0x00000000 0x48 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_BypassShadowCmd + 0x00000000 0x30 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_SetTime + 0x00000000 0xa8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_TimeStructInit + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_GetTime + 0x00000000 0x4c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_GetSubSecond + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_SetDate + 0x00000000 0x9c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_DateStructInit + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_GetDate + 0x00000000 0x48 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_SetAlarm + 0x00000000 0x98 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_AlarmStructInit + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_GetAlarm + 0x00000000 0x74 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_AlarmCmd + 0x00000000 0x60 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_AlarmSubSecondConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_GetAlarmSubSecond + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_WakeUpClockConfig + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_SetWakeUpCounter + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_GetWakeUpCounter + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_WakeUpCmd + 0x00000000 0x68 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_DayLightSavingConfig + 0x00000000 0x2c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_GetStoreOperation + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_OutputConfig + 0x00000000 0x2c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_CalibOutputCmd + 0x00000000 0x38 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_CalibOutputConfig + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_SmoothCalibConfig + 0x00000000 0x54 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_TimeStampCmd + 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_GetTimeStamp + 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_GetTimeStampSubSecond + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_TamperTriggerConfig + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_TamperCmd + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_TamperFilterConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_TamperSamplingFreqConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_TamperPinsPrechargeDuration + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_TimeStampOnTamperDetectionCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_TamperPullUpCmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_WriteBackupRegister + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_ReadBackupRegister + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_OutputTypeConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_SynchroShiftConfig + 0x00000000 0x60 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_ITConfig + 0x00000000 0x48 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_GetFlagStatus + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_ClearFlag + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_GetITStatus + 0x00000000 0x38 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_ClearITPendingBit + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_info 0x00000000 0x1107 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_abbrev 0x00000000 0x1e2 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_loc 0x00000000 0xfa6 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_aranges + 0x00000000 0x1c0 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_ranges 0x00000000 0x1b0 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x1d3 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x4bf ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_line 0x00000000 0x9e6 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_str 0x00000000 0x4ab68 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_frame 0x00000000 0x458 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_spi.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_spi.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_I2S_DeInit + 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_StructInit + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_Init + 0x00000000 0x54 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.I2S_StructInit + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.I2S_Init + 0x00000000 0xb4 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_Cmd 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_TIModeCmd + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.I2S_Cmd 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_DataSizeConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_RxFIFOThresholdConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_BiDirectionalLineConfig + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_NSSInternalSoftwareConfig + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_SSOutputCmd + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_NSSPulseModeCmd + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_SendData8 + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_I2S_SendData16 + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_ReceiveData8 + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_I2S_ReceiveData16 + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_CRCLengthConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_CalculateCRC + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_TransmitCRC + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_GetCRC + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_GetCRCPolynomial + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_I2S_DMACmd + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_LastDMATransferCmd + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_I2S_ITConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_GetTransmissionFIFOStatus + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_GetReceptionFIFOStatus + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_I2S_GetFlagStatus + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_I2S_ClearFlag + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_I2S_GetITStatus + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_info 0x00000000 0xb5e ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_abbrev 0x00000000 0x1d6 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_loc 0x00000000 0x737 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_aranges + 0x00000000 0x110 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_ranges 0x00000000 0x100 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x1ab ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x390 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_line 0x00000000 0x6d9 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_str 0x00000000 0x4a722 ..\obj\lib\spl\src\stm32f0xx_spi.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_frame 0x00000000 0x228 ..\obj\lib\spl\src\stm32f0xx_spi.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .text.SYSCFG_DeInit + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .text.SYSCFG_DMAChannelRemapConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .text.SYSCFG_I2CFastModePlusConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .text.SYSCFG_IRDAEnvSelection + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .text.SYSCFG_EXTILineConfig + 0x00000000 0x2c ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .text.SYSCFG_GetPendingIT + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .text.SYSCFG_BreakConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .text.SYSCFG_GetFlagStatus + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .text.SYSCFG_ClearFlag + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_tim.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_tim.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TI1_Config + 0x00000000 0x2c ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TI2_Config + 0x00000000 0x38 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_DeInit + 0x00000000 0x110 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_TimeBaseInit + 0x00000000 0xa4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_TimeBaseStructInit + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_PrescalerConfig + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_CounterModeConfig + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SetCounter + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SetAutoreload + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_GetCounter + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_GetPrescaler + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_UpdateDisableConfig + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_UpdateRequestConfig + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ARRPreloadConfig + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SelectOnePulseMode + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SetClockDivision + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_Cmd 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_BDTRConfig + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_BDTRStructInit + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_CtrlPWMOutputs + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC1Init + 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC2Init + 0x00000000 0xa0 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC3Init + 0x00000000 0x84 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC4Init + 0x00000000 0x64 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OCStructInit + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SelectOCxM + 0x00000000 0x4c ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SetCompare1 + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SetCompare2 + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SetCompare3 + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SetCompare4 + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ForcedOC1Config + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ForcedOC2Config + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ForcedOC3Config + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ForcedOC4Config + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_CCPreloadControl + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC1PreloadConfig + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC2PreloadConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC3PreloadConfig + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC4PreloadConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC1FastConfig + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC2FastConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC3FastConfig + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC4FastConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ClearOC1Ref + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ClearOC2Ref + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ClearOC3Ref + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ClearOC4Ref + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC1PolarityConfig + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC1NPolarityConfig + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC2PolarityConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC2NPolarityConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC3PolarityConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC3NPolarityConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC4PolarityConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SelectOCREFClear + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_CCxCmd + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_CCxNCmd + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SelectCOM + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ICStructInit + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_GetCapture1 + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_GetCapture2 + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_GetCapture3 + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_GetCapture4 + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SetIC1Prescaler + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SetIC2Prescaler + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_PWMIConfig + 0x00000000 0x68 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SetIC3Prescaler + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SetIC4Prescaler + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ICInit + 0x00000000 0xd0 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ITConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_GenerateEvent + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_GetFlagStatus + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ClearFlag + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_GetITStatus + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ClearITPendingBit + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_DMAConfig + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_DMACmd + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SelectCCDMA + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_InternalClockConfig + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ITRxExternalClockConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_TIxExternalClockConfig + 0x00000000 0x30 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SelectInputTrigger + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SelectOutputTrigger + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SelectSlaveMode + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SelectMasterSlaveMode + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ETRConfig + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ETRClockMode1Config + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ETRClockMode2Config + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_EncoderInterfaceConfig + 0x00000000 0x30 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SelectHallSensor + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_RemapConfig + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_info 0x00000000 0x20de ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_abbrev 0x00000000 0x262 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_loc 0x00000000 0x1c4f ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_aranges + 0x00000000 0x2f0 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_ranges 0x00000000 0x2e0 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x1af ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x74a ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_line 0x00000000 0xc70 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_str 0x00000000 0x4adac ..\obj\lib\spl\src\stm32f0xx_tim.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_frame 0x00000000 0x68c ..\obj\lib\spl\src\stm32f0xx_tim.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_usart.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_usart.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_DeInit + 0x00000000 0xf8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_StructInit + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_ClockInit + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_ClockStructInit + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_DirectionModeCmd + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_OverSampling8Cmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_OneBitMethodCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_MSBFirstCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_DataInvCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_InvPinCmd + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_SWAPPinCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_ReceiverTimeOutCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_SetReceiverTimeOut + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_SetPrescaler + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_STOPModeCmd + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_StopModeWakeUpSourceConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_AutoBaudRateCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_AutoBaudRateConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_SetAddress + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_MuteModeCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_MuteModeWakeUpConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_AddressDetectionConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_LINBreakDetectLengthConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_LINCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_HalfDuplexCmd + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_SetGuardTime + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_SmartCardCmd + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_SmartCardNACKCmd + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_SetAutoRetryCount + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_SetBlockLength + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_IrDAConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_IrDACmd + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_DECmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_DEPolarityConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_SetDEAssertionTime + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_SetDEDeassertionTime + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_DMACmd + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_DMAReceptionErrorConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_ITConfig + 0x00000000 0x38 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_RequestCmd + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_ClearFlag + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_GetITStatus + 0x00000000 0x40 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_ClearITPendingBit + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .text.WWDG_DeInit + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .text.WWDG_SetPrescaler + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .text.WWDG_SetWindowValue + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .text.WWDG_EnableIT + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .text.WWDG_SetCounter + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .text.WWDG_Enable + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .text.WWDG_GetFlagStatus + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .text.WWDG_ClearFlag + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_info 0x00000000 0x288 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_abbrev 0x00000000 0x162 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_loc 0x00000000 0xd1 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_aranges + 0x00000000 0x58 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_ranges 0x00000000 0x48 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x1a5 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x2e ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_line 0x00000000 0x4d0 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_str 0x00000000 0x4a205 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_frame 0x00000000 0x9c ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .text 0x00000000 0x0 ..\obj\lib\system_stm32f0xx.o + .data 0x00000000 0x0 ..\obj\lib\system_stm32f0xx.o + .bss 0x00000000 0x0 ..\obj\lib\system_stm32f0xx.o + .text.SystemCoreClockUpdate + 0x00000000 0x90 ..\obj\lib\system_stm32f0xx.o + .data.AHBPrescTable + 0x00000000 0x10 ..\obj\lib\system_stm32f0xx.o + .data.SystemCoreClock + 0x00000000 0x4 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x832 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x81 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x3a ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x22 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x87 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x44 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0xfd ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x5e ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x1df ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x1f ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x242 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x632a ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x191 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0xef ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x46 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x184 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x7c ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x85b ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x185 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x70 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0xdf ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x561 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x396 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x471 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x750 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x356 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x34 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x3a ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .text 0x00000000 0x0 ..\obj\main.o + .data 0x00000000 0x0 ..\obj\main.o + .bss 0x00000000 0x0 ..\obj\main.o + .debug_macro 0x00000000 0x832 ..\obj\main.o + .debug_macro 0x00000000 0x1c ..\obj\main.o + .debug_macro 0x00000000 0x1c ..\obj\main.o + .debug_macro 0x00000000 0x22 ..\obj\main.o + .debug_macro 0x00000000 0x93 ..\obj\main.o + .debug_macro 0x00000000 0x3e ..\obj\main.o + .debug_macro 0x00000000 0x1c ..\obj\main.o + .debug_macro 0x00000000 0x9f ..\obj\main.o + .debug_macro 0x00000000 0x40 ..\obj\main.o + .debug_macro 0x00000000 0x81 ..\obj\main.o + .debug_macro 0x00000000 0x3a ..\obj\main.o + .debug_macro 0x00000000 0x22 ..\obj\main.o + .debug_macro 0x00000000 0x87 ..\obj\main.o + .debug_macro 0x00000000 0x44 ..\obj\main.o + .debug_macro 0x00000000 0xfd ..\obj\main.o + .debug_macro 0x00000000 0x5e ..\obj\main.o + .debug_macro 0x00000000 0x1df ..\obj\main.o + .debug_macro 0x00000000 0x1f ..\obj\main.o + .debug_macro 0x00000000 0x242 ..\obj\main.o + .debug_macro 0x00000000 0x632a ..\obj\main.o + .debug_macro 0x00000000 0x2eb ..\obj\main.o + .debug_macro 0x00000000 0x3cf ..\obj\main.o + .debug_macro 0x00000000 0x191 ..\obj\main.o + .debug_macro 0x00000000 0xef ..\obj\main.o + .debug_macro 0x00000000 0x46 ..\obj\main.o + .debug_macro 0x00000000 0xd9 ..\obj\main.o + .debug_macro 0x00000000 0x184 ..\obj\main.o + .debug_macro 0x00000000 0x7c ..\obj\main.o + .debug_macro 0x00000000 0x85b ..\obj\main.o + .debug_macro 0x00000000 0xd5 ..\obj\main.o + .debug_macro 0x00000000 0x2b7 ..\obj\main.o + .debug_macro 0x00000000 0x185 ..\obj\main.o + .debug_macro 0x00000000 0x2a0 ..\obj\main.o + .debug_macro 0x00000000 0x70 ..\obj\main.o + .debug_macro 0x00000000 0xdf ..\obj\main.o + .debug_macro 0x00000000 0x561 ..\obj\main.o + .debug_macro 0x00000000 0x4c5 ..\obj\main.o + .debug_macro 0x00000000 0x396 ..\obj\main.o + .debug_macro 0x00000000 0x471 ..\obj\main.o + .debug_macro 0x00000000 0x750 ..\obj\main.o + .debug_macro 0x00000000 0x356 ..\obj\main.o + .debug_macro 0x00000000 0x34 ..\obj\main.o + .debug_macro 0x00000000 0x3a ..\obj\main.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .text 0x00000000 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .data 0x00000000 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .bss 0x00000000 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x832 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x22 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x93 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x3e ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x9f ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x40 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x81 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x3a ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x22 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x87 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x44 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0xfd ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x5e ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x1df ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x1f ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x242 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x632a ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x2eb ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x3cf ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x191 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0xef ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x46 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0xd9 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x184 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x7c ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x85b ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0xd5 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x2b7 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x185 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x2a0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x70 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0xdf ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x561 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x4c5 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x396 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x471 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x750 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x356 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x34 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x00000000 0x3a ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .text 0x00000000 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .data 0x00000000 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .bss 0x00000000 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .text.CpuReset + 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x832 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x22 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x93 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x3e ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x9f ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x40 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x81 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x3a ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x22 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x87 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x44 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0xfd ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x5e ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x1df ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x1f ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x242 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x632a ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x2eb ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x3cf ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x191 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0xef ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x46 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0xd9 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x184 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x7c ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x85b ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0xd5 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x2b7 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x185 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x2a0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x70 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0xdf ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x561 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x4c5 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x396 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x471 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x750 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x356 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x34 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x00000000 0x3a ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .text 0x00000000 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .data 0x00000000 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .bss 0x00000000 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x832 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x22 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x93 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x3e ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x9f ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x40 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x81 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x3a ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x22 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x87 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x44 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0xfd ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x5e ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x1df ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x1f ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x242 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x632a ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x2eb ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x3cf ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x191 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0xef ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x46 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0xd9 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x184 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x7c ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x85b ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0xd5 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x2b7 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x185 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x2a0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x70 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0xdf ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x561 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x4c5 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x396 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x471 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x750 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x356 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x34 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x00000000 0x3a ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .text 0x00000000 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .data 0x00000000 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .bss 0x00000000 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .debug_macro 0x00000000 0x832 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .debug_macro 0x00000000 0x22 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .debug_macro 0x00000000 0x93 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .debug_macro 0x00000000 0x3e ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .debug_macro 0x00000000 0x9f ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .debug_macro 0x00000000 0x40 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .data 0x00000000 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cstart.o + .bss 0x00000000 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cstart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .text 0x00000000 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .data 0x00000000 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .bss 0x00000000 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .debug_macro 0x00000000 0x832 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .debug_macro 0x00000000 0x22 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .debug_macro 0x00000000 0x93 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .debug_macro 0x00000000 0x3e ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .debug_macro 0x00000000 0x9f ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .debug_macro 0x00000000 0x40 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .text 0x00000000 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .data 0x00000000 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .bss 0x00000000 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x832 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x22 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x93 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x3e ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x9f ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x40 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x81 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x3a ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x22 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x87 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x44 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0xfd ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x5e ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x1df ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x1f ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x242 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x632a ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x2eb ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x3cf ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x191 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0xef ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x46 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0xd9 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x184 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x7c ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x85b ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0xd5 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x2b7 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x185 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x2a0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x70 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0xdf ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x561 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x4c5 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x396 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x471 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x750 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x356 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x34 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x00000000 0x3a ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .text 0x00000000 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .data 0x00000000 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .bss 0x00000000 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x832 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x22 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x93 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x3e ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x9f ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x40 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x81 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x3a ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x22 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x87 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x44 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0xfd ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x5e ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x1df ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x1f ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x242 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x632a ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x2eb ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x3cf ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x191 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0xef ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x46 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0xd9 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x184 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x7c ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x85b ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0xd5 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x2b7 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x185 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x2a0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x70 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0xdf ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x561 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x4c5 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x396 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x471 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x750 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x356 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x34 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x00000000 0x3a ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\assert.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\assert.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\assert.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\assert.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\assert.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\assert.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\assert.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\assert.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\assert.o + .text 0x00000000 0x0 ..\obj\~#\~#\~#\source\assert.o + .data 0x00000000 0x0 ..\obj\~#\~#\~#\source\assert.o + .bss 0x00000000 0x0 ..\obj\~#\~#\~#\source\assert.o + .debug_macro 0x00000000 0x832 ..\obj\~#\~#\~#\source\assert.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\assert.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\assert.o + .debug_macro 0x00000000 0x22 ..\obj\~#\~#\~#\source\assert.o + .debug_macro 0x00000000 0x93 ..\obj\~#\~#\~#\source\assert.o + .debug_macro 0x00000000 0x3e ..\obj\~#\~#\~#\source\assert.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\assert.o + .debug_macro 0x00000000 0x9f ..\obj\~#\~#\~#\source\assert.o + .debug_macro 0x00000000 0x40 ..\obj\~#\~#\~#\source\assert.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\backdoor.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\backdoor.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\backdoor.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\backdoor.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\backdoor.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\backdoor.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\backdoor.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\backdoor.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\backdoor.o + .text 0x00000000 0x0 ..\obj\~#\~#\~#\source\backdoor.o + .data 0x00000000 0x0 ..\obj\~#\~#\~#\source\backdoor.o + .bss 0x00000000 0x0 ..\obj\~#\~#\~#\source\backdoor.o + .debug_macro 0x00000000 0x832 ..\obj\~#\~#\~#\source\backdoor.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\backdoor.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\backdoor.o + .debug_macro 0x00000000 0x22 ..\obj\~#\~#\~#\source\backdoor.o + .debug_macro 0x00000000 0x93 ..\obj\~#\~#\~#\source\backdoor.o + .debug_macro 0x00000000 0x3e ..\obj\~#\~#\~#\source\backdoor.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\backdoor.o + .debug_macro 0x00000000 0x9f ..\obj\~#\~#\~#\source\backdoor.o + .debug_macro 0x00000000 0x40 ..\obj\~#\~#\~#\source\backdoor.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\boot.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\boot.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\boot.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\boot.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\boot.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\boot.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\boot.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\boot.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\boot.o + .text 0x00000000 0x0 ..\obj\~#\~#\~#\source\boot.o + .data 0x00000000 0x0 ..\obj\~#\~#\~#\source\boot.o + .bss 0x00000000 0x0 ..\obj\~#\~#\~#\source\boot.o + .debug_macro 0x00000000 0x832 ..\obj\~#\~#\~#\source\boot.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\boot.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\boot.o + .debug_macro 0x00000000 0x22 ..\obj\~#\~#\~#\source\boot.o + .debug_macro 0x00000000 0x93 ..\obj\~#\~#\~#\source\boot.o + .debug_macro 0x00000000 0x3e ..\obj\~#\~#\~#\source\boot.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\boot.o + .debug_macro 0x00000000 0x9f ..\obj\~#\~#\~#\source\boot.o + .debug_macro 0x00000000 0x40 ..\obj\~#\~#\~#\source\boot.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\com.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\com.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\com.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\com.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\com.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\com.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\com.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\com.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\com.o + .text 0x00000000 0x0 ..\obj\~#\~#\~#\source\com.o + .data 0x00000000 0x0 ..\obj\~#\~#\~#\source\com.o + .bss 0x00000000 0x0 ..\obj\~#\~#\~#\source\com.o + .debug_macro 0x00000000 0x832 ..\obj\~#\~#\~#\source\com.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\com.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\com.o + .debug_macro 0x00000000 0x22 ..\obj\~#\~#\~#\source\com.o + .debug_macro 0x00000000 0x93 ..\obj\~#\~#\~#\source\com.o + .debug_macro 0x00000000 0x3e ..\obj\~#\~#\~#\source\com.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\com.o + .debug_macro 0x00000000 0x9f ..\obj\~#\~#\~#\source\com.o + .debug_macro 0x00000000 0x40 ..\obj\~#\~#\~#\source\com.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\cop.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\cop.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\cop.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\cop.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\cop.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\cop.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\cop.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\cop.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\cop.o + .text 0x00000000 0x0 ..\obj\~#\~#\~#\source\cop.o + .data 0x00000000 0x0 ..\obj\~#\~#\~#\source\cop.o + .bss 0x00000000 0x0 ..\obj\~#\~#\~#\source\cop.o + .debug_macro 0x00000000 0x832 ..\obj\~#\~#\~#\source\cop.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\cop.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\cop.o + .debug_macro 0x00000000 0x22 ..\obj\~#\~#\~#\source\cop.o + .debug_macro 0x00000000 0x93 ..\obj\~#\~#\~#\source\cop.o + .debug_macro 0x00000000 0x3e ..\obj\~#\~#\~#\source\cop.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\cop.o + .debug_macro 0x00000000 0x9f ..\obj\~#\~#\~#\source\cop.o + .debug_macro 0x00000000 0x40 ..\obj\~#\~#\~#\source\cop.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\file.o + .text 0x00000000 0x0 ..\obj\~#\~#\~#\source\file.o + .data 0x00000000 0x0 ..\obj\~#\~#\~#\source\file.o + .bss 0x00000000 0x0 ..\obj\~#\~#\~#\source\file.o + .debug_info 0x00000000 0x7d ..\obj\~#\~#\~#\source\file.o + .debug_abbrev 0x00000000 0x29 ..\obj\~#\~#\~#\source\file.o + .debug_aranges + 0x00000000 0x18 ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x169 ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x832 ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x22 ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x93 ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x3e ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x9f ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x40 ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x22 ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x4c ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x8d ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x35 ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x9c ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x174 ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x4a ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x52 ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x1f ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x43 ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x20 ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x187 ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x30d ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x10 ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0x35 ..\obj\~#\~#\~#\source\file.o + .debug_macro 0x00000000 0xac ..\obj\~#\~#\~#\source\file.o + .debug_line 0x00000000 0x303 ..\obj\~#\~#\~#\source\file.o + .debug_str 0x00000000 0x5ea9 ..\obj\~#\~#\~#\source\file.o + .comment 0x00000000 0x6f ..\obj\~#\~#\~#\source\file.o + .ARM.attributes + 0x00000000 0x31 ..\obj\~#\~#\~#\source\file.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\net.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\net.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\net.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\net.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\net.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\net.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\net.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\net.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\net.o + .text 0x00000000 0x0 ..\obj\~#\~#\~#\source\net.o + .data 0x00000000 0x0 ..\obj\~#\~#\~#\source\net.o + .bss 0x00000000 0x0 ..\obj\~#\~#\~#\source\net.o + .debug_info 0x00000000 0x5a ..\obj\~#\~#\~#\source\net.o + .debug_abbrev 0x00000000 0x29 ..\obj\~#\~#\~#\source\net.o + .debug_aranges + 0x00000000 0x18 ..\obj\~#\~#\~#\source\net.o + .debug_macro 0x00000000 0x91 ..\obj\~#\~#\~#\source\net.o + .debug_macro 0x00000000 0x832 ..\obj\~#\~#\~#\source\net.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\net.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\net.o + .debug_macro 0x00000000 0x22 ..\obj\~#\~#\~#\source\net.o + .debug_macro 0x00000000 0x93 ..\obj\~#\~#\~#\source\net.o + .debug_macro 0x00000000 0x3e ..\obj\~#\~#\~#\source\net.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\net.o + .debug_macro 0x00000000 0x9f ..\obj\~#\~#\~#\source\net.o + .debug_macro 0x00000000 0x40 ..\obj\~#\~#\~#\source\net.o + .debug_line 0x00000000 0xf7 ..\obj\~#\~#\~#\source\net.o + .debug_str 0x00000000 0x2d0f ..\obj\~#\~#\~#\source\net.o + .comment 0x00000000 0x6f ..\obj\~#\~#\~#\source\net.o + .ARM.attributes + 0x00000000 0x31 ..\obj\~#\~#\~#\source\net.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\xcp.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\xcp.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\xcp.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\xcp.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\xcp.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\xcp.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\xcp.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\xcp.o + .group 0x00000000 0x8 ..\obj\~#\~#\~#\source\xcp.o + .text 0x00000000 0x0 ..\obj\~#\~#\~#\source\xcp.o + .data 0x00000000 0x0 ..\obj\~#\~#\~#\source\xcp.o + .bss 0x00000000 0x0 ..\obj\~#\~#\~#\source\xcp.o + .debug_macro 0x00000000 0x832 ..\obj\~#\~#\~#\source\xcp.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\xcp.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\xcp.o + .debug_macro 0x00000000 0x22 ..\obj\~#\~#\~#\source\xcp.o + .debug_macro 0x00000000 0x93 ..\obj\~#\~#\~#\source\xcp.o + .debug_macro 0x00000000 0x3e ..\obj\~#\~#\~#\source\xcp.o + .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\xcp.o + .debug_macro 0x00000000 0x9f ..\obj\~#\~#\~#\source\xcp.o + .debug_macro 0x00000000 0x40 ..\obj\~#\~#\~#\source\xcp.o + .data 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_udivsi3.o) + .bss 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_udivsi3.o) + .data 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_dvmd_tls.o) + .bss 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_dvmd_tls.o) + .text 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-exit.o) + .data 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-exit.o) + .bss 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-exit.o) + .text 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-impure.o) + .data 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-impure.o) + .bss 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-impure.o) + .data._impure_ptr + 0x00000000 0x4 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-impure.o) + .text 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-init.o) + .data 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-init.o) + .bss 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-init.o) + .text 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-memset.o) + .data 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-memset.o) + .bss 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-memset.o) + .text 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libnosys_s.a(_exit.o) + .data 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libnosys_s.a(_exit.o) + .bss 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libnosys_s.a(_exit.o) + .text 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtend.o + .data 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtend.o + .bss 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtend.o + .jcr 0x00000000 0x4 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtend.o + .text 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtn.o + .data 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtn.o + .bss 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtn.o + +Memory Configuration + +Name Origin Length Attributes +ROM 0x08000000 0x00002000 xr +RAM 0x200000c0 0x00000f40 xrw +*default* 0x00000000 0xffffffff + +Linker script and memory map + +LOAD c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crti.o +LOAD c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o +LOAD c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m/crt0.o + 0x00000000 __HEAP_SIZE = 0x0 + 0x00000100 __STACK_SIZE = 0x100 + +.text 0x08000000 0x1f30 + *(.isr_vector) + .isr_vector 0x08000000 0xc0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cstart.o + 0x08000000 __isr_vector + *(.text*) + .text 0x080000c0 0x60 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o + .text 0x08000120 0x78 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m/crt0.o + 0x08000120 _start + 0x08000120 _mainCRTStartup + .text.CpuUserProgramStartHook + 0x08000198 0x1c ..\obj\hooks.o + 0x08000198 CpuUserProgramStartHook + .text.CopInitHook + 0x080001b4 0xc ..\obj\hooks.o + 0x080001b4 CopInitHook + .text.CopServiceHook + 0x080001c0 0x8 ..\obj\hooks.o + 0x080001c0 CopServiceHook + .text.LedBlinkInit + 0x080001c8 0xc ..\obj\led.o + 0x080001c8 LedBlinkInit + .text.LedBlinkTask + 0x080001d4 0x54 ..\obj\led.o + 0x080001d4 LedBlinkTask + .text.LedBlinkExit + 0x08000228 0x10 ..\obj\led.o + 0x08000228 LedBlinkExit + .text.CAN_DeInit + 0x08000238 0x18 ..\obj\lib\spl\src\stm32f0xx_can.o + 0x08000238 CAN_DeInit + .text.CAN_Init + 0x08000250 0x10c ..\obj\lib\spl\src\stm32f0xx_can.o + 0x08000250 CAN_Init + .text.CAN_FilterInit + 0x0800035c 0xfc ..\obj\lib\spl\src\stm32f0xx_can.o + 0x0800035c CAN_FilterInit + .text.CAN_StructInit + 0x08000458 0x20 ..\obj\lib\spl\src\stm32f0xx_can.o + 0x08000458 CAN_StructInit + .text.CAN_Transmit + 0x08000478 0xd8 ..\obj\lib\spl\src\stm32f0xx_can.o + 0x08000478 CAN_Transmit + .text.CAN_TransmitStatus + 0x08000550 0x5c ..\obj\lib\spl\src\stm32f0xx_can.o + 0x08000550 CAN_TransmitStatus + .text.CAN_Receive + 0x080005ac 0x9c ..\obj\lib\spl\src\stm32f0xx_can.o + 0x080005ac CAN_Receive + .text.CAN_MessagePending + 0x08000648 0x1c ..\obj\lib\spl\src\stm32f0xx_can.o + 0x08000648 CAN_MessagePending + .text.FLASH_Unlock + 0x08000664 0x20 ..\obj\lib\spl\src\stm32f0xx_flash.o + 0x08000664 FLASH_Unlock + .text.FLASH_Lock + 0x08000684 0x10 ..\obj\lib\spl\src\stm32f0xx_flash.o + 0x08000684 FLASH_Lock + .text.FLASH_ClearFlag + 0x08000694 0xc ..\obj\lib\spl\src\stm32f0xx_flash.o + 0x08000694 FLASH_ClearFlag + .text.FLASH_GetStatus + 0x080006a0 0x28 ..\obj\lib\spl\src\stm32f0xx_flash.o + 0x080006a0 FLASH_GetStatus + .text.FLASH_WaitForLastOperation + 0x080006c8 0x2c ..\obj\lib\spl\src\stm32f0xx_flash.o + 0x080006c8 FLASH_WaitForLastOperation + .text.FLASH_ErasePage + 0x080006f4 0x38 ..\obj\lib\spl\src\stm32f0xx_flash.o + 0x080006f4 FLASH_ErasePage + .text.FLASH_ProgramWord + 0x0800072c 0x64 ..\obj\lib\spl\src\stm32f0xx_flash.o + 0x0800072c FLASH_ProgramWord + .text.GPIO_Init + 0x08000790 0xa4 ..\obj\lib\spl\src\stm32f0xx_gpio.o + 0x08000790 GPIO_Init + .text.GPIO_ReadInputDataBit + 0x08000834 0xc ..\obj\lib\spl\src\stm32f0xx_gpio.o + 0x08000834 GPIO_ReadInputDataBit + .text.GPIO_SetBits + 0x08000840 0x4 ..\obj\lib\spl\src\stm32f0xx_gpio.o + 0x08000840 GPIO_SetBits + .text.GPIO_ResetBits + 0x08000844 0x4 ..\obj\lib\spl\src\stm32f0xx_gpio.o + 0x08000844 GPIO_ResetBits + .text.GPIO_PinAFConfig + 0x08000848 0x24 ..\obj\lib\spl\src\stm32f0xx_gpio.o + 0x08000848 GPIO_PinAFConfig + .text.RCC_GetClocksFreq + 0x0800086c 0x1e8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + 0x0800086c RCC_GetClocksFreq + .text.RCC_AHBPeriphClockCmd + 0x08000a54 0x1c ..\obj\lib\spl\src\stm32f0xx_rcc.o + 0x08000a54 RCC_AHBPeriphClockCmd + .text.RCC_APB2PeriphClockCmd + 0x08000a70 0x1c ..\obj\lib\spl\src\stm32f0xx_rcc.o + 0x08000a70 RCC_APB2PeriphClockCmd + .text.RCC_APB1PeriphClockCmd + 0x08000a8c 0x1c ..\obj\lib\spl\src\stm32f0xx_rcc.o + 0x08000a8c RCC_APB1PeriphClockCmd + .text.RCC_APB1PeriphResetCmd + 0x08000aa8 0x1c ..\obj\lib\spl\src\stm32f0xx_rcc.o + 0x08000aa8 RCC_APB1PeriphResetCmd + .text.SYSCFG_MemoryRemapConfig + 0x08000ac4 0x14 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + 0x08000ac4 SYSCFG_MemoryRemapConfig + .text.USART_Init + 0x08000ad8 0xdc ..\obj\lib\spl\src\stm32f0xx_usart.o + 0x08000ad8 USART_Init + .text.USART_Cmd + 0x08000bb4 0x18 ..\obj\lib\spl\src\stm32f0xx_usart.o + 0x08000bb4 USART_Cmd + .text.USART_SendData + 0x08000bcc 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + 0x08000bcc USART_SendData + .text.USART_ReceiveData + 0x08000bd4 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + 0x08000bd4 USART_ReceiveData + .text.USART_OverrunDetectionConfig + 0x08000bdc 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + 0x08000bdc USART_OverrunDetectionConfig + .text.USART_GetFlagStatus + 0x08000bf0 0x10 ..\obj\lib\spl\src\stm32f0xx_usart.o + 0x08000bf0 USART_GetFlagStatus + .text.SystemInit + 0x08000c00 0xbc ..\obj\lib\system_stm32f0xx.o + 0x08000c00 SystemInit + .text.main 0x08000cbc 0xf4 ..\obj\main.o + 0x08000cbc main + .text.CanInit 0x08000db0 0xe0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + 0x08000db0 CanInit + .text.CanTransmitPacket + 0x08000e90 0x54 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + 0x08000e90 CanTransmitPacket + .text.CanReceivePacket + 0x08000ee4 0x60 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + 0x08000ee4 CanReceivePacket + .text.CpuInit 0x08000f44 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + 0x08000f44 CpuInit + .text.CpuMemCopy + 0x08000f4c 0x24 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + 0x08000f4c CpuMemCopy + .text.CpuStartUserProgram + 0x08000f70 0x48 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + 0x08000f70 CpuStartUserProgram + .text.FlashGetSector + 0x08000fb8 0x3c ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .text.FlashWriteBlock + 0x08000ff4 0x84 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .text.FlashSwitchBlock + 0x08001078 0x54 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .text.FlashAddToBlock + 0x080010cc 0x98 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .text.FlashInit + 0x08001164 0x18 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + 0x08001164 FlashInit + .text.FlashWrite + 0x0800117c 0x5c ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + 0x0800117c FlashWrite + .text.FlashErase + 0x080011d8 0x110 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + 0x080011d8 FlashErase + .text.FlashWriteChecksum + 0x080012e8 0x50 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + 0x080012e8 FlashWriteChecksum + .text.FlashVerifyChecksum + 0x08001338 0x58 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + 0x08001338 FlashVerifyChecksum + .text.FlashDone + 0x08001390 0x34 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + 0x08001390 FlashDone + .text.FlashGetUserProgBaseAddress + 0x080013c4 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + 0x080013c4 FlashGetUserProgBaseAddress + .text.CpuIrqDisable + 0x080013cc 0x4 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + 0x080013cc CpuIrqDisable + .text.CpuIrqEnable + 0x080013d0 0x4 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + 0x080013d0 CpuIrqEnable + .text 0x080013d4 0xa8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cstart.o + 0x080013d4 Reset_Handler + 0x08001426 NMI_Handler + 0x08001428 HardFault_Handler + 0x0800142a SVC_Handler + 0x0800142c PendSV_Handler + 0x0800142e SysTick_Handler + 0x08001430 Default_Handler + 0x08001432 WWDG_IRQHandler + 0x08001434 PVD_IRQHandler + 0x08001436 RTC_IRQHandler + 0x08001438 FLASH_IRQHandler + 0x0800143a RCC_IRQHandler + 0x0800143c EXTI0_1_IRQHandler + 0x0800143e EXTI2_3_IRQHandler + 0x08001440 EXTI4_15_IRQHandler + 0x08001442 TS_IRQHandler + 0x08001444 DMA1_Channel1_IRQHandler + 0x08001446 DMA1_Channel2_3_IRQHandler + 0x08001448 DMA1_Channel4_5_IRQHandler + 0x0800144a ADC1_COMP_IRQHandler + 0x0800144c TIM1_BRK_UP_TRG_COM_IRQHandler + 0x0800144e TIM1_CC_IRQHandler + 0x08001450 TIM2_IRQHandler + 0x08001452 TIM3_IRQHandler + 0x08001454 TIM6_DAC_IRQHandler + 0x08001456 TIM7_IRQHandler + 0x08001458 TIM14_IRQHandler + 0x0800145a TIM15_IRQHandler + 0x0800145c TIM16_IRQHandler + 0x0800145e TIM17_IRQHandler + 0x08001460 I2C1_IRQHandler + 0x08001462 I2C2_IRQHandler + 0x08001464 SPI1_IRQHandler + 0x08001466 SPI2_IRQHandler + 0x08001468 USART1_IRQHandler + 0x0800146a USART2_IRQHandler + 0x0800146c USART3_4_IRQHandler + 0x0800146e CEC_IRQHandler + 0x08001470 USB_IRQHandler + .text.NvmInit 0x0800147c 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + 0x0800147c NvmInit + .text.NvmWrite + 0x08001484 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + 0x08001484 NvmWrite + .text.NvmErase + 0x0800148c 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + 0x0800148c NvmErase + .text.NvmVerifyChecksum + 0x08001494 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + 0x08001494 NvmVerifyChecksum + .text.NvmGetUserProgBaseAddress + 0x0800149c 0x8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + 0x0800149c NvmGetUserProgBaseAddress + .text.NvmDone 0x080014a4 0x10 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + 0x080014a4 NvmDone + .text.TimerInit + 0x080014b4 0x24 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + 0x080014b4 TimerInit + .text.TimerReset + 0x080014d8 0xc ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + 0x080014d8 TimerReset + .text.TimerUpdate + 0x080014e4 0x1c ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + 0x080014e4 TimerUpdate + .text.TimerGet + 0x08001500 0x10 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + 0x08001500 TimerGet + .text.UartTransmitByte + 0x08001510 0x34 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .text.UartReceiveByte + 0x08001544 0x24 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .text.UartInit + 0x08001568 0x3c ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + 0x08001568 UartInit + .text.UartTransmitPacket + 0x080015a4 0x58 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + 0x080015a4 UartTransmitPacket + .text.UartReceivePacket + 0x080015fc 0xa0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + 0x080015fc UartReceivePacket + .text.AssertFailure + 0x0800169c 0x8 ..\obj\~#\~#\~#\source\assert.o + 0x0800169c AssertFailure + .text.BackDoorCheck + 0x080016a4 0x38 ..\obj\~#\~#\~#\source\backdoor.o + 0x080016a4 BackDoorCheck + .text.BackDoorInit + 0x080016dc 0x20 ..\obj\~#\~#\~#\source\backdoor.o + 0x080016dc BackDoorInit + .text.BootInit + 0x080016fc 0x1c ..\obj\~#\~#\~#\source\boot.o + 0x080016fc BootInit + .text.BootTask + 0x08001718 0x14 ..\obj\~#\~#\~#\source\boot.o + 0x08001718 BootTask + .text.ComInit 0x0800172c 0x20 ..\obj\~#\~#\~#\source\com.o + 0x0800172c ComInit + .text.ComTask 0x0800174c 0x38 ..\obj\~#\~#\~#\source\com.o + 0x0800174c ComTask + .text.ComFree 0x08001784 0x4 ..\obj\~#\~#\~#\source\com.o + 0x08001784 ComFree + .text.ComTransmitPacket + 0x08001788 0x30 ..\obj\~#\~#\~#\source\com.o + 0x08001788 ComTransmitPacket + .text.ComGetActiveInterfaceMaxRxLen + 0x080017b8 0x24 ..\obj\~#\~#\~#\source\com.o + 0x080017b8 ComGetActiveInterfaceMaxRxLen + .text.ComGetActiveInterfaceMaxTxLen + 0x080017dc 0x24 ..\obj\~#\~#\~#\source\com.o + 0x080017dc ComGetActiveInterfaceMaxTxLen + .text.ComIsConnected + 0x08001800 0x8 ..\obj\~#\~#\~#\source\com.o + 0x08001800 ComIsConnected + .text.CopInit 0x08001808 0x8 ..\obj\~#\~#\~#\source\cop.o + 0x08001808 CopInit + .text.CopService + 0x08001810 0x8 ..\obj\~#\~#\~#\source\cop.o + 0x08001810 CopService + .text.XcpSetCtoError + 0x08001818 0x14 ..\obj\~#\~#\~#\source\xcp.o + .text.XcpInit 0x0800182c 0x1c ..\obj\~#\~#\~#\source\xcp.o + 0x0800182c XcpInit + .text.XcpIsConnected + 0x08001848 0x10 ..\obj\~#\~#\~#\source\xcp.o + 0x08001848 XcpIsConnected + .text.XcpPacketTransmitted + 0x08001858 0x10 ..\obj\~#\~#\~#\source\xcp.o + 0x08001858 XcpPacketTransmitted + .text.XcpPacketReceived + 0x08001868 0x2c4 ..\obj\~#\~#\~#\source\xcp.o + 0x08001868 XcpPacketReceived + .text 0x08001b2c 0x114 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_udivsi3.o) + 0x08001b2c __aeabi_uidiv + 0x08001b2c __udivsi3 + 0x08001c38 __aeabi_uidivmod + .text 0x08001c40 0x4 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_dvmd_tls.o) + 0x08001c40 __aeabi_idiv0 + 0x08001c40 __aeabi_ldiv0 + .text.exit 0x08001c44 0x2c c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-exit.o) + 0x08001c44 exit + .text.__libc_init_array + 0x08001c70 0x4c c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-init.o) + 0x08001c70 __libc_init_array + .text.memset 0x08001cbc 0x10 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-memset.o) + 0x08001cbc memset + .text._exit 0x08001ccc 0x2 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libnosys_s.a(_exit.o) + 0x08001ccc _exit + *(.init) + *fill* 0x08001cce 0x2 + .init 0x08001cd0 0x4 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crti.o + 0x08001cd0 _init + .init 0x08001cd4 0x8 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtn.o + *(.fini) + .fini 0x08001cdc 0x4 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crti.o + 0x08001cdc _fini + .fini 0x08001ce0 0x8 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtn.o + *crtbegin.o(.ctors) + *crtbegin?.o(.ctors) + *(EXCLUDE_FILE(*crtend.o *crtend?.o) .ctors) + *(SORT(.ctors.*)) + *(.ctors) + *crtbegin.o(.dtors) + *crtbegin?.o(.dtors) + *(EXCLUDE_FILE(*crtend.o *crtend?.o) .dtors) + *(SORT(.dtors.*)) + *(.dtors) + *(.rodata*) + .rodata.str1.4 + 0x08001ce8 0x28 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .rodata.canTiming + 0x08001d10 0x24 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .rodata.flashLayout + 0x08001d34 0xe4 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .rodata.str1.4 + 0x08001e18 0x2c ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + 0x29 (size before relaxing) + .rodata.XcpPacketReceived + 0x08001e44 0xd8 ..\obj\~#\~#\~#\source\xcp.o + .rodata.xcpStationId + 0x08001f1c 0x8 ..\obj\~#\~#\~#\source\xcp.o + .rodata.str1.1 + 0x08001f24 0x2 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-impure.o) + *fill* 0x08001f26 0x2 + .rodata._global_impure_ptr + 0x08001f28 0x4 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-impure.o) + 0x08001f28 _global_impure_ptr + *(.eh_frame*) + .eh_frame 0x08001f2c 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o + .eh_frame 0x08001f2c 0x4 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtend.o + +.glue_7 0x08001f30 0x0 + .glue_7 0x08001f30 0x0 linker stubs + +.glue_7t 0x08001f30 0x0 + .glue_7t 0x08001f30 0x0 linker stubs + +.vfp11_veneer 0x08001f30 0x0 + .vfp11_veneer 0x08001f30 0x0 linker stubs + +.v4_bx 0x08001f30 0x0 + .v4_bx 0x08001f30 0x0 linker stubs + +.iplt 0x08001f30 0x0 + .iplt 0x08001f30 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o + +.ARM.extab + *(.ARM.extab* .gnu.linkonce.armextab.*) + 0x08001f30 __exidx_start = . + +.ARM.exidx 0x08001f30 0x8 + *(.ARM.exidx* .gnu.linkonce.armexidx.*) + .ARM.exidx 0x08001f30 0x8 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m/crt0.o + 0x08001f38 __exidx_end = . + 0x08001f38 __etext = . + +.rel.dyn 0x08001f38 0x0 + .rel.iplt 0x08001f38 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o + +.data 0x200000c0 0x7c load address 0x08001f38 + 0x200000c0 __data_start__ = . + *(vtable) + *(.data*) + .data.APBAHBPrescTable + 0x200000c0 0x10 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .data.comActiveInterface + 0x200000d0 0x1 ..\obj\~#\~#\~#\source\com.o + *fill* 0x200000d1 0x3 + .data.impure_data + 0x200000d4 0x60 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-impure.o) + 0x20000134 . = ALIGN (0x4) + 0x20000134 PROVIDE (__preinit_array_start, .) + *(.preinit_array) + 0x20000134 PROVIDE (__preinit_array_end, .) + 0x20000134 . = ALIGN (0x4) + 0x20000134 PROVIDE (__init_array_start, .) + *(SORT(.init_array.*)) + *(.init_array) + .init_array 0x20000134 0x4 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o + 0x20000138 PROVIDE (__init_array_end, .) + 0x20000138 . = ALIGN (0x4) + [!provide] PROVIDE (__fini_array_start, .) + *(SORT(.fini_array.*)) + *(.fini_array) + .fini_array 0x20000138 0x4 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o + [!provide] PROVIDE (__fini_array_end, .) + 0x2000013c . = ALIGN (0x4) + 0x2000013c __data_end__ = . + +.jcr 0x2000013c 0x0 load address 0x08001fb4 + .jcr 0x2000013c 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o + +.igot.plt 0x2000013c 0x0 load address 0x08001fb4 + .igot.plt 0x2000013c 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o + +.bss 0x2000013c 0x50c load address 0x08001fb4 + 0x2000013c __bss_start__ = . + *(.bss*) + .bss 0x2000013c 0x1c c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o + .bss.nextBlinkEvent.6556 + 0x20000158 0x4 ..\obj\led.o + .bss.ledBlinkIntervalMs + 0x2000015c 0x2 ..\obj\led.o + .bss.ledOn.6555 + 0x2000015e 0x1 ..\obj\led.o + *fill* 0x2000015f 0x1 + .bss.bootBlockInfo + 0x20000160 0x204 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .bss.blockInfo + 0x20000364 0x204 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .bss.millisecond_counter + 0x20000568 0x4 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .bss.xcpCtoRxLength.6565 + 0x2000056c 0x1 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + *fill* 0x2000056d 0x3 + .bss.xcpCtoRxStartTime.6567 + 0x20000570 0x4 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .bss.xcpCtoReqPacket.6564 + 0x20000574 0x41 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .bss.xcpCtoRxInProgress.6566 + 0x200005b5 0x1 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .bss.backdoorOpen + 0x200005b6 0x1 ..\obj\~#\~#\~#\source\backdoor.o + *fill* 0x200005b7 0x1 + .bss.backdoorOpenTime + 0x200005b8 0x4 ..\obj\~#\~#\~#\source\backdoor.o + .bss.xcpCtoReqPacket.4275 + 0x200005bc 0x40 ..\obj\~#\~#\~#\source\com.o + .bss.xcpInfo 0x200005fc 0x4c ..\obj\~#\~#\~#\source\xcp.o + *(COMMON) + 0x20000648 __bss_end__ = . + +.heap 0x20000648 0x0 + 0x20000648 __end__ = . + 0x20000648 end = __end__ + *(.heap*) + .heap 0x20000648 0x0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cstart.o + 0x20000648 __HeapLimit = . + +.stack_dummy 0x20000648 0x100 + *(.stack) + .stack 0x20000648 0x100 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cstart.o + 0x20001000 __StackTop = (ORIGIN (RAM) + LENGTH (RAM)) + 0x20000f00 __StackLimit = (__StackTop - SIZEOF (.stack_dummy)) + 0x20001000 PROVIDE (__stack, __StackTop) + 0x00000001 ASSERT ((__StackLimit >= __HeapLimit), region RAM overflowed with stack) +LOAD ..\obj\hooks.o +LOAD ..\obj\led.o +LOAD ..\obj\lib\spl\src\stm32f0xx_adc.o +LOAD ..\obj\lib\spl\src\stm32f0xx_can.o +LOAD ..\obj\lib\spl\src\stm32f0xx_cec.o +LOAD ..\obj\lib\spl\src\stm32f0xx_comp.o +LOAD ..\obj\lib\spl\src\stm32f0xx_crc.o +LOAD ..\obj\lib\spl\src\stm32f0xx_crs.o +LOAD ..\obj\lib\spl\src\stm32f0xx_dac.o +LOAD ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o +LOAD ..\obj\lib\spl\src\stm32f0xx_dma.o +LOAD ..\obj\lib\spl\src\stm32f0xx_exti.o +LOAD ..\obj\lib\spl\src\stm32f0xx_flash.o +LOAD ..\obj\lib\spl\src\stm32f0xx_gpio.o +LOAD ..\obj\lib\spl\src\stm32f0xx_i2c.o +LOAD ..\obj\lib\spl\src\stm32f0xx_iwdg.o +LOAD ..\obj\lib\spl\src\stm32f0xx_misc.o +LOAD ..\obj\lib\spl\src\stm32f0xx_pwr.o +LOAD ..\obj\lib\spl\src\stm32f0xx_rcc.o +LOAD ..\obj\lib\spl\src\stm32f0xx_rtc.o +LOAD ..\obj\lib\spl\src\stm32f0xx_spi.o +LOAD ..\obj\lib\spl\src\stm32f0xx_syscfg.o +LOAD ..\obj\lib\spl\src\stm32f0xx_tim.o +LOAD ..\obj\lib\spl\src\stm32f0xx_usart.o +LOAD ..\obj\lib\spl\src\stm32f0xx_wwdg.o +LOAD ..\obj\lib\system_stm32f0xx.o +LOAD ..\obj\main.o +LOAD ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o +LOAD ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o +LOAD ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o +LOAD ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o +LOAD ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cstart.o +LOAD ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o +LOAD ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o +LOAD ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o +LOAD ..\obj\~#\~#\~#\source\assert.o +LOAD ..\obj\~#\~#\~#\source\backdoor.o +LOAD ..\obj\~#\~#\~#\source\boot.o +LOAD ..\obj\~#\~#\~#\source\com.o +LOAD ..\obj\~#\~#\~#\source\cop.o +LOAD ..\obj\~#\~#\~#\source\file.o +LOAD ..\obj\~#\~#\~#\source\net.o +LOAD ..\obj\~#\~#\~#\source\xcp.o +START GROUP +LOAD c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a +LOAD c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a +LOAD c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libc_n.a +END GROUP +START GROUP +LOAD c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a +LOAD c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libc_n.a +LOAD c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libnosys_s.a +END GROUP +LOAD c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtend.o +LOAD c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtn.o +OUTPUT(..\bin\openblt_stm32f091.elf elf32-littlearm) + +.ARM.attributes + 0x00000000 0x28 + .ARM.attributes + 0x00000000 0x1e c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crti.o + .ARM.attributes + 0x0000001e 0x2c c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o + .ARM.attributes + 0x0000004a 0x1b c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m/crt0.o + .ARM.attributes + 0x00000065 0x31 ..\obj\hooks.o + .ARM.attributes + 0x00000096 0x31 ..\obj\led.o + .ARM.attributes + 0x000000c7 0x31 ..\obj\lib\spl\src\stm32f0xx_can.o + .ARM.attributes + 0x000000f8 0x31 ..\obj\lib\spl\src\stm32f0xx_flash.o + .ARM.attributes + 0x00000129 0x31 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .ARM.attributes + 0x0000015a 0x31 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .ARM.attributes + 0x0000018b 0x31 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .ARM.attributes + 0x000001bc 0x31 ..\obj\lib\spl\src\stm32f0xx_usart.o + .ARM.attributes + 0x000001ed 0x31 ..\obj\lib\system_stm32f0xx.o + .ARM.attributes + 0x0000021e 0x31 ..\obj\main.o + .ARM.attributes + 0x0000024f 0x31 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .ARM.attributes + 0x00000280 0x31 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .ARM.attributes + 0x000002b1 0x31 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .ARM.attributes + 0x000002e2 0x31 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .ARM.attributes + 0x00000313 0x1b ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cstart.o + .ARM.attributes + 0x0000032e 0x31 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .ARM.attributes + 0x0000035f 0x31 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .ARM.attributes + 0x00000390 0x31 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .ARM.attributes + 0x000003c1 0x31 ..\obj\~#\~#\~#\source\assert.o + .ARM.attributes + 0x000003f2 0x31 ..\obj\~#\~#\~#\source\backdoor.o + .ARM.attributes + 0x00000423 0x31 ..\obj\~#\~#\~#\source\boot.o + .ARM.attributes + 0x00000454 0x31 ..\obj\~#\~#\~#\source\com.o + .ARM.attributes + 0x00000485 0x31 ..\obj\~#\~#\~#\source\cop.o + .ARM.attributes + 0x000004b6 0x31 ..\obj\~#\~#\~#\source\xcp.o + .ARM.attributes + 0x000004e7 0x1e c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_udivsi3.o) + .ARM.attributes + 0x00000505 0x1e c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_dvmd_tls.o) + .ARM.attributes + 0x00000523 0x2c c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-exit.o) + .ARM.attributes + 0x0000054f 0x2c c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-impure.o) + .ARM.attributes + 0x0000057b 0x2c c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-init.o) + .ARM.attributes + 0x000005a7 0x2c c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-memset.o) + .ARM.attributes + 0x000005d3 0x2c c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libnosys_s.a(_exit.o) + .ARM.attributes + 0x000005ff 0x2c c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtend.o + .ARM.attributes + 0x0000062b 0x1e c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtn.o + +.comment 0x00000000 0x6e + .comment 0x00000000 0x6e ..\obj\hooks.o + 0x6f (size before relaxing) + .comment 0x0000006e 0x6f ..\obj\led.o + .comment 0x0000006e 0x6f ..\obj\lib\spl\src\stm32f0xx_can.o + .comment 0x0000006e 0x6f ..\obj\lib\spl\src\stm32f0xx_flash.o + .comment 0x0000006e 0x6f ..\obj\lib\spl\src\stm32f0xx_gpio.o + .comment 0x0000006e 0x6f ..\obj\lib\spl\src\stm32f0xx_rcc.o + .comment 0x0000006e 0x6f ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .comment 0x0000006e 0x6f ..\obj\lib\spl\src\stm32f0xx_usart.o + .comment 0x0000006e 0x6f ..\obj\lib\system_stm32f0xx.o + .comment 0x0000006e 0x6f ..\obj\main.o + .comment 0x0000006e 0x6f ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .comment 0x0000006e 0x6f ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .comment 0x0000006e 0x6f ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .comment 0x0000006e 0x6f ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .comment 0x0000006e 0x6f ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .comment 0x0000006e 0x6f ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .comment 0x0000006e 0x6f ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .comment 0x0000006e 0x6f ..\obj\~#\~#\~#\source\assert.o + .comment 0x0000006e 0x6f ..\obj\~#\~#\~#\source\backdoor.o + .comment 0x0000006e 0x6f ..\obj\~#\~#\~#\source\boot.o + .comment 0x0000006e 0x6f ..\obj\~#\~#\~#\source\com.o + .comment 0x0000006e 0x6f ..\obj\~#\~#\~#\source\cop.o + .comment 0x0000006e 0x6f ..\obj\~#\~#\~#\source\xcp.o + +.debug_info 0x00000000 0x7892 + .debug_info 0x00000000 0x268 ..\obj\hooks.o + .debug_info 0x00000268 0x2ba ..\obj\led.o + .debug_info 0x00000522 0xc2d ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_info 0x0000114f 0xb48 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_info 0x00001c97 0x72a ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_info 0x000023c1 0xaa4 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_info 0x00002e65 0x354 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_info 0x000031b9 0x1016 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_info 0x000041cf 0x2c1 ..\obj\lib\system_stm32f0xx.o + .debug_info 0x00004490 0x513 ..\obj\main.o + .debug_info 0x000049a3 0x99a ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_info 0x0000533d 0x2d1 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_info 0x0000560e 0x93f ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_info 0x00005f4d 0x84 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .debug_info 0x00005fd1 0xa6 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cstart.o + .debug_info 0x00006077 0x228 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .debug_info 0x0000629f 0x174 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_info 0x00006413 0x5a7 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_info 0x000069ba 0xc6 ..\obj\~#\~#\~#\source\assert.o + .debug_info 0x00006a80 0x114 ..\obj\~#\~#\~#\source\backdoor.o + .debug_info 0x00006b94 0x156 ..\obj\~#\~#\~#\source\boot.o + .debug_info 0x00006cea 0x2fe ..\obj\~#\~#\~#\source\com.o + .debug_info 0x00006fe8 0xb6 ..\obj\~#\~#\~#\source\cop.o + .debug_info 0x0000709e 0x7f4 ..\obj\~#\~#\~#\source\xcp.o + +.debug_abbrev 0x00000000 0x1f78 + .debug_abbrev 0x00000000 0x11d ..\obj\hooks.o + .debug_abbrev 0x0000011d 0x114 ..\obj\led.o + .debug_abbrev 0x00000231 0x266 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_abbrev 0x00000497 0x211 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_abbrev 0x000006a8 0x1d4 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_abbrev 0x0000087c 0x235 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_abbrev 0x00000ab1 0x177 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_abbrev 0x00000c28 0x1b8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_abbrev 0x00000de0 0x113 ..\obj\lib\system_stm32f0xx.o + .debug_abbrev 0x00000ef3 0x17f ..\obj\main.o + .debug_abbrev 0x00001072 0x262 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_abbrev 0x000012d4 0x10a ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_abbrev 0x000013de 0x27a ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_abbrev 0x00001658 0x45 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .debug_abbrev 0x0000169d 0x14 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cstart.o + .debug_abbrev 0x000016b1 0xca ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .debug_abbrev 0x0000177b 0x118 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_abbrev 0x00001893 0x1ae ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_abbrev 0x00001a41 0x8b ..\obj\~#\~#\~#\source\assert.o + .debug_abbrev 0x00001acc 0x7f ..\obj\~#\~#\~#\source\backdoor.o + .debug_abbrev 0x00001b4b 0x63 ..\obj\~#\~#\~#\source\boot.o + .debug_abbrev 0x00001bae 0x153 ..\obj\~#\~#\~#\source\com.o + .debug_abbrev 0x00001d01 0x63 ..\obj\~#\~#\~#\source\cop.o + .debug_abbrev 0x00001d64 0x214 ..\obj\~#\~#\~#\source\xcp.o + +.debug_aranges 0x00000000 0x980 + .debug_aranges + 0x00000000 0x30 ..\obj\hooks.o + .debug_aranges + 0x00000030 0x30 ..\obj\led.o + .debug_aranges + 0x00000060 0xd8 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_aranges + 0x00000138 0x110 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_aranges + 0x00000248 0x80 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_aranges + 0x000002c8 0x160 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_aranges + 0x00000428 0x68 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_aranges + 0x00000490 0x1a0 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_aranges + 0x00000630 0x28 ..\obj\lib\system_stm32f0xx.o + .debug_aranges + 0x00000658 0x20 ..\obj\main.o + .debug_aranges + 0x00000678 0x30 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_aranges + 0x000006a8 0x38 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_aranges + 0x000006e0 0x70 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_aranges + 0x00000750 0x28 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .debug_aranges + 0x00000778 0x20 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cstart.o + .debug_aranges + 0x00000798 0x48 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .debug_aranges + 0x000007e0 0x38 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_aranges + 0x00000818 0x40 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_aranges + 0x00000858 0x20 ..\obj\~#\~#\~#\source\assert.o + .debug_aranges + 0x00000878 0x28 ..\obj\~#\~#\~#\source\backdoor.o + .debug_aranges + 0x000008a0 0x28 ..\obj\~#\~#\~#\source\boot.o + .debug_aranges + 0x000008c8 0x50 ..\obj\~#\~#\~#\source\com.o + .debug_aranges + 0x00000918 0x28 ..\obj\~#\~#\~#\source\cop.o + .debug_aranges + 0x00000940 0x40 ..\obj\~#\~#\~#\source\xcp.o + +.debug_ranges 0x00000000 0x898 + .debug_ranges 0x00000000 0x20 ..\obj\hooks.o + .debug_ranges 0x00000020 0x20 ..\obj\led.o + .debug_ranges 0x00000040 0x138 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_ranges 0x00000178 0x100 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_ranges 0x00000278 0x70 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_ranges 0x000002e8 0x150 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_ranges 0x00000438 0x58 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_ranges 0x00000490 0x190 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_ranges 0x00000620 0x18 ..\obj\lib\system_stm32f0xx.o + .debug_ranges 0x00000638 0x10 ..\obj\main.o + .debug_ranges 0x00000648 0x38 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_ranges 0x00000680 0x28 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_ranges 0x000006a8 0x80 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_ranges 0x00000728 0x18 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .debug_ranges 0x00000740 0x38 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .debug_ranges 0x00000778 0x28 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_ranges 0x000007a0 0x30 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_ranges 0x000007d0 0x10 ..\obj\~#\~#\~#\source\assert.o + .debug_ranges 0x000007e0 0x18 ..\obj\~#\~#\~#\source\backdoor.o + .debug_ranges 0x000007f8 0x18 ..\obj\~#\~#\~#\source\boot.o + .debug_ranges 0x00000810 0x40 ..\obj\~#\~#\~#\source\com.o + .debug_ranges 0x00000850 0x18 ..\obj\~#\~#\~#\source\cop.o + .debug_ranges 0x00000868 0x30 ..\obj\~#\~#\~#\source\xcp.o + +.debug_macro 0x00000000 0xe2a1 + .debug_macro 0x00000000 0x213 ..\obj\hooks.o + .debug_macro 0x00000213 0x832 ..\obj\hooks.o + .debug_macro 0x00000a45 0x1c ..\obj\hooks.o + .debug_macro 0x00000a61 0x1c ..\obj\hooks.o + .debug_macro 0x00000a7d 0x22 ..\obj\hooks.o + .debug_macro 0x00000a9f 0x93 ..\obj\hooks.o + .debug_macro 0x00000b32 0x3e ..\obj\hooks.o + .debug_macro 0x00000b70 0x1c ..\obj\hooks.o + .debug_macro 0x00000b8c 0x9f ..\obj\hooks.o + .debug_macro 0x00000c2b 0x40 ..\obj\hooks.o + .debug_macro 0x00000c6b 0x81 ..\obj\hooks.o + .debug_macro 0x00000cec 0x3a ..\obj\hooks.o + .debug_macro 0x00000d26 0x22 ..\obj\hooks.o + .debug_macro 0x00000d48 0x87 ..\obj\hooks.o + .debug_macro 0x00000dcf 0x44 ..\obj\hooks.o + .debug_macro 0x00000e13 0xfd ..\obj\hooks.o + .debug_macro 0x00000f10 0x5e ..\obj\hooks.o + .debug_macro 0x00000f6e 0x1df ..\obj\hooks.o + .debug_macro 0x0000114d 0x1f ..\obj\hooks.o + .debug_macro 0x0000116c 0x242 ..\obj\hooks.o + .debug_macro 0x000013ae 0x632a ..\obj\hooks.o + .debug_macro 0x000076d8 0x2eb ..\obj\hooks.o + .debug_macro 0x000079c3 0x3cf ..\obj\hooks.o + .debug_macro 0x00007d92 0x191 ..\obj\hooks.o + .debug_macro 0x00007f23 0xef ..\obj\hooks.o + .debug_macro 0x00008012 0x46 ..\obj\hooks.o + .debug_macro 0x00008058 0xd9 ..\obj\hooks.o + .debug_macro 0x00008131 0x184 ..\obj\hooks.o + .debug_macro 0x000082b5 0x7c ..\obj\hooks.o + .debug_macro 0x00008331 0x85b ..\obj\hooks.o + .debug_macro 0x00008b8c 0xd5 ..\obj\hooks.o + .debug_macro 0x00008c61 0x2b7 ..\obj\hooks.o + .debug_macro 0x00008f18 0x185 ..\obj\hooks.o + .debug_macro 0x0000909d 0x2a0 ..\obj\hooks.o + .debug_macro 0x0000933d 0x70 ..\obj\hooks.o + .debug_macro 0x000093ad 0xdf ..\obj\hooks.o + .debug_macro 0x0000948c 0x561 ..\obj\hooks.o + .debug_macro 0x000099ed 0x4c5 ..\obj\hooks.o + .debug_macro 0x00009eb2 0x396 ..\obj\hooks.o + .debug_macro 0x0000a248 0x471 ..\obj\hooks.o + .debug_macro 0x0000a6b9 0x750 ..\obj\hooks.o + .debug_macro 0x0000ae09 0x356 ..\obj\hooks.o + .debug_macro 0x0000b15f 0x34 ..\obj\hooks.o + .debug_macro 0x0000b193 0x3a ..\obj\hooks.o + .debug_macro 0x0000b1cd 0x213 ..\obj\led.o + .debug_macro 0x0000b3e0 0x1e7 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x0000b5c7 0x193 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x0000b75a 0x2b1 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x0000ba0b 0x193 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x0000bb9e 0x17f ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x0000bd1d 0x1b1 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x0000bece 0x55b ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x0000c429 0x193 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x0000c5bc 0x46b ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x0000ca27 0x1ab ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x0000cbd2 0x350 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x0000cf22 0x189 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x0000d0ab 0x209 ..\obj\main.o + .debug_macro 0x0000d2b4 0x209 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_macro 0x0000d4bd 0x221 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_macro 0x0000d6de 0x233 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_macro 0x0000d911 0x91 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .debug_macro 0x0000d9a2 0x9b ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .debug_macro 0x0000da3d 0x209 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_macro 0x0000dc46 0x215 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_macro 0x0000de5b 0x91 ..\obj\~#\~#\~#\source\assert.o + .debug_macro 0x0000deec 0x97 ..\obj\~#\~#\~#\source\backdoor.o + .debug_macro 0x0000df83 0x91 ..\obj\~#\~#\~#\source\boot.o + .debug_macro 0x0000e014 0xa5 ..\obj\~#\~#\~#\source\com.o + .debug_macro 0x0000e0b9 0x91 ..\obj\~#\~#\~#\source\cop.o + .debug_macro 0x0000e14a 0x157 ..\obj\~#\~#\~#\source\xcp.o + +.debug_line 0x00000000 0x658e + .debug_line 0x00000000 0x53a ..\obj\hooks.o + .debug_line 0x0000053a 0x539 ..\obj\led.o + .debug_line 0x00000a73 0x7a4 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_line 0x00001217 0x73a ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_line 0x00001951 0x563 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_line 0x00001eb4 0x7e4 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_line 0x00002698 0x501 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_line 0x00002b99 0x84f ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_line 0x000033e8 0x486 ..\obj\lib\system_stm32f0xx.o + .debug_line 0x0000386e 0x52f ..\obj\main.o + .debug_line 0x00003d9d 0x58e ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_line 0x0000432b 0x544 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_line 0x0000486f 0x69a ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_line 0x00004f09 0x144 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .debug_line 0x0000504d 0xb4 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cstart.o + .debug_line 0x00005101 0x176 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .debug_line 0x00005277 0x543 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_line 0x000057ba 0x5a1 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_line 0x00005d5b 0x10e ..\obj\~#\~#\~#\source\assert.o + .debug_line 0x00005e69 0x12c ..\obj\~#\~#\~#\source\backdoor.o + .debug_line 0x00005f95 0x123 ..\obj\~#\~#\~#\source\boot.o + .debug_line 0x000060b8 0x1b7 ..\obj\~#\~#\~#\source\com.o + .debug_line 0x0000626f 0x119 ..\obj\~#\~#\~#\source\cop.o + .debug_line 0x00006388 0x206 ..\obj\~#\~#\~#\source\xcp.o + +.debug_str 0x00000000 0x4d69a + .debug_str 0x00000000 0x4a90f ..\obj\hooks.o + 0x4aa85 (size before relaxing) + .debug_str 0x0004a90f 0x78 ..\obj\led.o + 0x4aa97 (size before relaxing) + .debug_str 0x0004a987 0x749 ..\obj\lib\spl\src\stm32f0xx_can.o + 0x4a843 (size before relaxing) + .debug_str 0x0004b0d0 0x392 ..\obj\lib\spl\src\stm32f0xx_flash.o + 0x4a4ed (size before relaxing) + .debug_str 0x0004b462 0x23d ..\obj\lib\spl\src\stm32f0xx_gpio.o + 0x4a3c1 (size before relaxing) + .debug_str 0x0004b69f 0x63d ..\obj\lib\spl\src\stm32f0xx_rcc.o + 0x4a77c (size before relaxing) + .debug_str 0x0004bcdc 0x1c1 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + 0x4a297 (size before relaxing) + .debug_str 0x0004be9d 0x7f3 ..\obj\lib\spl\src\stm32f0xx_usart.o + 0x4aa13 (size before relaxing) + .debug_str 0x0004c690 0x57 ..\obj\lib\system_stm32f0xx.o + 0x4a17b (size before relaxing) + .debug_str 0x0004c6e7 0x34 ..\obj\main.o + 0x4abda (size before relaxing) + .debug_str 0x0004c71b 0x13e ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + 0x4aeb2 (size before relaxing) + .debug_str 0x0004c859 0x1e4 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + 0x4abf2 (size before relaxing) + .debug_str 0x0004ca3d 0x32a ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + 0x4adb4 (size before relaxing) + .debug_str 0x0004cd67 0x31 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + 0x2d42 (size before relaxing) + .debug_str 0x0004cd98 0x4a ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + 0x2e13 (size before relaxing) + .debug_str 0x0004cde2 0x6c ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + 0x4aa0a (size before relaxing) + .debug_str 0x0004ce4e 0x115 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + 0x4ac3e (size before relaxing) + .debug_str 0x0004cf63 0x2a ..\obj\~#\~#\~#\source\assert.o + 0x2d49 (size before relaxing) + .debug_str 0x0004cf8d 0x86 ..\obj\~#\~#\~#\source\backdoor.o + 0x2dad (size before relaxing) + .debug_str 0x0004d013 0x32 ..\obj\~#\~#\~#\source\boot.o + 0x2d86 (size before relaxing) + .debug_str 0x0004d045 0x10a ..\obj\~#\~#\~#\source\com.o + 0x2eca (size before relaxing) + .debug_str 0x0004d14f 0x19 ..\obj\~#\~#\~#\source\cop.o + 0x2d3d (size before relaxing) + .debug_str 0x0004d168 0x532 ..\obj\~#\~#\~#\source\xcp.o + 0x3333 (size before relaxing) + +.debug_frame 0x00000000 0x13f0 + .debug_frame 0x00000000 0x58 ..\obj\hooks.o + .debug_frame 0x00000058 0x50 ..\obj\led.o + .debug_frame 0x000000a8 0x1dc ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_frame 0x00000284 0x2a0 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_frame 0x00000524 0x108 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_frame 0x0000062c 0x2c0 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_frame 0x000008ec 0xb8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_frame 0x000009a4 0x354 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_frame 0x00000cf8 0x38 ..\obj\lib\system_stm32f0xx.o + .debug_frame 0x00000d30 0x38 ..\obj\main.o + .debug_frame 0x00000d68 0x74 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_frame 0x00000ddc 0x74 ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_frame 0x00000e50 0x138 ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_frame 0x00000f88 0x30 ..\obj\~#\~#\~#\source\armcm0_stm32f0\gcc\cpu_comp.o + .debug_frame 0x00000fb8 0xa0 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .debug_frame 0x00001058 0x58 ..\obj\~#\~#\~#\source\armcm0_stm32f0\timer.o + .debug_frame 0x000010b0 0x94 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_frame 0x00001144 0x28 ..\obj\~#\~#\~#\source\assert.o + .debug_frame 0x0000116c 0x40 ..\obj\~#\~#\~#\source\backdoor.o + .debug_frame 0x000011ac 0x40 ..\obj\~#\~#\~#\source\boot.o + .debug_frame 0x000011ec 0xa4 ..\obj\~#\~#\~#\source\com.o + .debug_frame 0x00001290 0x40 ..\obj\~#\~#\~#\source\cop.o + .debug_frame 0x000012d0 0x6c ..\obj\~#\~#\~#\source\xcp.o + .debug_frame 0x0000133c 0x20 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_udivsi3.o) + .debug_frame 0x0000135c 0x28 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-exit.o) + .debug_frame 0x00001384 0x2c c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-init.o) + .debug_frame 0x000013b0 0x20 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-memset.o) + .debug_frame 0x000013d0 0x20 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libnosys_s.a(_exit.o) + +.debug_loc 0x00000000 0x3af5 + .debug_loc 0x00000000 0x930 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_loc 0x00000930 0x8c2 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_loc 0x000011f2 0x2a4 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_loc 0x00001496 0xa2c ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_loc 0x00001ec2 0x20a ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_loc 0x000020cc 0x97b ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_loc 0x00002a47 0x113 ..\obj\lib\system_stm32f0xx.o + .debug_loc 0x00002b5a 0x1d8 ..\obj\~#\~#\~#\source\armcm0_stm32f0\can.o + .debug_loc 0x00002d32 0xbe ..\obj\~#\~#\~#\source\armcm0_stm32f0\cpu.o + .debug_loc 0x00002df0 0x6ad ..\obj\~#\~#\~#\source\armcm0_stm32f0\flash.o + .debug_loc 0x0000349d 0xa5 ..\obj\~#\~#\~#\source\armcm0_stm32f0\nvm.o + .debug_loc 0x00003542 0x130 ..\obj\~#\~#\~#\source\armcm0_stm32f0\uart.o + .debug_loc 0x00003672 0x42 ..\obj\~#\~#\~#\source\assert.o + .debug_loc 0x000036b4 0x8b ..\obj\~#\~#\~#\source\com.o + .debug_loc 0x0000373f 0x3b6 ..\obj\~#\~#\~#\source\xcp.o diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/bin/openblt_stm32f091.srec b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/bin/openblt_stm32f091.srec new file mode 100644 index 00000000..84ff128b --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/bin/openblt_stm32f091.srec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diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/blt_conf.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/blt_conf.h new file mode 100644 index 00000000..f33456e6 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/blt_conf.h @@ -0,0 +1,175 @@ +/************************************************************************************//** +* \file Demo\ARMCM0_STM32F0_Nucleo_F091RC_GCC\Boot\blt_conf.h +* \brief Bootloader configuration header file. +* \ingroup Boot_ARMCM0_STM32F0_Nucleo_F091RC_GCC +* \internal +*---------------------------------------------------------------------------------------- +* C O P Y R I G H T +*---------------------------------------------------------------------------------------- +* Copyright (c) 2016 by Feaser http://www.feaser.com All rights reserved +* +*---------------------------------------------------------------------------------------- +* L I C E N S E +*---------------------------------------------------------------------------------------- +* This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +* modify it under the terms of the GNU General Public License as published by the Free +* Software Foundation, either version 3 of the License, or (at your option) any later +* version. +* +* OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +* PURPOSE. See the GNU General Public License for more details. +* +* You have received a copy of the GNU General Public License along with OpenBLT. It +* should be located in ".\Doc\license.html". If not, contact Feaser to obtain a copy. +* +* \endinternal +****************************************************************************************/ +#ifndef BLT_CONF_H +#define BLT_CONF_H + +/**************************************************************************************** +* C P U D R I V E R C O N F I G U R A T I O N +****************************************************************************************/ +/* To properly initialize the baudrate clocks of the communication interface, typically + * the speed of the crystal oscillator and/or the speed at which the system runs is + * needed. Set these through configurables BOOT_CPU_XTAL_SPEED_KHZ and + * BOOT_CPU_SYSTEM_SPEED_KHZ, respectively. To enable data exchange with the host that is + * not dependent on the targets architecture, the byte ordering needs to be known. + * Setting BOOT_CPU_BYTE_ORDER_MOTOROLA to 1 selects big endian mode and 0 selects + * little endian mode. + * + * Set BOOT_CPU_USER_PROGRAM_START_HOOK to 1 if you would like a hook function to be + * called the moment the user program is about to be started. This could be used to + * de-initialize application specific parts, for example to stop blinking an LED, etc. + */ +/** \brief Frequency of the external crystal oscillator. */ +#define BOOT_CPU_XTAL_SPEED_KHZ (8000) +/** \brief Desired system speed. */ +#define BOOT_CPU_SYSTEM_SPEED_KHZ (48000) +/** \brief Motorola or Intel style byte ordering. */ +#define BOOT_CPU_BYTE_ORDER_MOTOROLA (0) +/** \brief Enable/disable hook function call right before user program start. */ +#define BOOT_CPU_USER_PROGRAM_START_HOOK (1) + + +/**************************************************************************************** +* C O M M U N I C A T I O N I N T E R F A C E C O N F I G U R A T I O N +****************************************************************************************/ +/* The CAN communication interface is selected by setting the BOOT_COM_CAN_ENABLE + * configurable to 1. Configurable BOOT_COM_CAN_BAUDRATE selects the communication speed + * in bits/second. Two CAN messages are reserved for communication with the host. The + * message identifier for sending data from the target to the host is configured with + * BOOT_COM_CAN_TXMSG_ID. The one for receiving data from the host is configured with + * BOOT_COM_CAN_RXMSG_ID. The maximum amount of data bytes in a message for data + * transmission and reception is set through BOOT_COM_CAN_TX_MAX_DATA and + * BOOT_COM_CAN_RX_MAX_DATA, respectively. It is common for a microcontroller to have more + * than 1 CAN controller on board. The zero-based BOOT_COM_CAN_CHANNEL_INDEX selects the + * CAN controller channel. + * + */ +/** \brief Enable/disable CAN transport layer. */ +#define BOOT_COM_CAN_ENABLE (1) +/** \brief Configure the desired CAN baudrate. */ +#define BOOT_COM_CAN_BAUDRATE (500000) +/** \brief Configure CAN message ID target->host. */ +#define BOOT_COM_CAN_TX_MSG_ID (0x7E1) +/** \brief Configure number of bytes in the target->host CAN message. */ +#define BOOT_COM_CAN_TX_MAX_DATA (8) +/** \brief Configure CAN message ID host->target. */ +#define BOOT_COM_CAN_RX_MSG_ID (0x667) +/** \brief Configure number of bytes in the host->target CAN message. */ +#define BOOT_COM_CAN_RX_MAX_DATA (8) +/** \brief Select the desired CAN peripheral as a zero based index. */ +#define BOOT_COM_CAN_CHANNEL_INDEX (0) + +/* The UART communication interface is selected by setting the BOOT_COM_UART_ENABLE + * configurable to 1. Configurable BOOT_COM_UART_BAUDRATE selects the communication speed + * in bits/second. The maximum amount of data bytes in a message for data transmission + * and reception is set through BOOT_COM_UART_TX_MAX_DATA and BOOT_COM_UART_RX_MAX_DATA, + * respectively. It is common for a microcontroller to have more than 1 UART interface + * on board. The zero-based BOOT_COM_UART_CHANNEL_INDEX selects the UART interface. + * + */ +/** \brief Enable/disable UART transport layer. */ +#define BOOT_COM_UART_ENABLE (1) +/** \brief Configure the desired communication speed. */ +#define BOOT_COM_UART_BAUDRATE (57600) +/** \brief Configure number of bytes in the target->host data packet. */ +#define BOOT_COM_UART_TX_MAX_DATA (64) +/** \brief Configure number of bytes in the host->target data packet. */ +#define BOOT_COM_UART_RX_MAX_DATA (64) +/** \brief Select the desired UART peripheral as a zero based index. */ +#define BOOT_COM_UART_CHANNEL_INDEX (1) + + +/**************************************************************************************** +* B A C K D O O R E N T R Y C O N F I G U R A T I O N +****************************************************************************************/ +/* It is possible to implement an application specific method to force the bootloader to + * stay active after a reset. Such a backdoor entry into the bootloader is desired in + * situations where the user program does not run properly and therefore cannot + * reactivate the bootloader. By enabling these hook functions, the application can + * implement the backdoor, which overrides the default backdoor entry that is programmed + * into the bootloader. When desired for security purposes, these hook functions can + * also be implemented in a way that disables the backdoor entry altogether. + */ +/** \brief Enable/disable the backdoor override hook functions. */ +#define BOOT_BACKDOOR_HOOKS_ENABLE (0) + + +/**************************************************************************************** +* N O N - V O L A T I L E M E M O R Y D R I V E R C O N F I G U R A T I O N +****************************************************************************************/ +/* The NVM driver typically supports erase and program operations of the internal memory + * present on the microcontroller. Through these hook functions the NVM driver can be + * extended to support additional memory types such as external flash memory and serial + * eeproms. The size of the internal memory in kilobytes is specified with configurable + * BOOT_NVM_SIZE_KB. If desired the internal checksum writing and verification method can + * be overridden with a application specific method by enabling configuration switch + * BOOT_NVM_CHECKSUM_HOOKS_ENABLE. + */ +/** \brief Enable/disable the NVM hook function for supporting additional memory devices. */ +#define BOOT_NVM_HOOKS_ENABLE (0) +/** \brief Configure the size of the default memory device (typically flash EEPROM). */ +#define BOOT_NVM_SIZE_KB (256) +/** \brief Enable/disable hooks functions to override the user program checksum handling. */ +#define BOOT_NVM_CHECKSUM_HOOKS_ENABLE (0) + + +/**************************************************************************************** +* W A T C H D O G D R I V E R C O N F I G U R A T I O N +****************************************************************************************/ +/* The COP driver cannot be configured internally in the bootloader, because its use + * and configuration is application specific. The bootloader does need to service the + * watchdog in case it is used. When the application requires the use of a watchdog, + * set BOOT_COP_HOOKS_ENABLE to be able to initialize and service the watchdog through + * hook functions. + */ +/** \brief Enable/disable the hook functions for controlling the watchdog. */ +#define BOOT_COP_HOOKS_ENABLE (1) + + +/**************************************************************************************** +* S E E D / K E Y S E C U R I T Y C O N F I G U R A T I O N +****************************************************************************************/ +/* A security mechanism can be enabled in the bootloader's XCP module by setting configu- + * rable BOOT_XCP_SEED_KEY_ENABLE to 1. Before any memory erase or programming + * operations can be performed, access to this resource need to be unlocked. + * In the Microboot settings on tab "XCP Protection" you need to specify a DLL that + * implements the unlocking algorithm. The demo programs are configured for the (simple) + * algorithm in "FeaserKey.dll". The source code for this DLL is available so it can be + * customized to your needs. + * During the unlock sequence, Microboot requests a seed from the bootloader, which is in + * the format of a byte array. Using this seed the unlock algorithm in the DLL computes + * a key, which is also a byte array, and sends this back to the bootloader. The + * bootloader then verifies this key to determine if programming and erase operations are + * permitted. + * After enabling this feature the hook functions XcpGetSeedHook() and XcpVerifyKeyHook() + * are called by the bootloader to obtain the seed and to verify the key, respectively. + */ +#define BOOT_XCP_SEED_KEY_ENABLE (0) + + +#endif /* BLT_CONF_H */ +/*********************************** end of blt_conf.h *********************************/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/boot.dox b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/boot.dox new file mode 100644 index 00000000..73f3761f --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/boot.dox @@ -0,0 +1,7 @@ +/** +\defgroup Boot_ARMCM0_STM32F0_Nucleo_F091RC_GCC Bootloader +\brief Bootloader. +\ingroup ARMCM0_STM32F0_Nucleo_F091RC_GCC +*/ + + diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/cfg/STM32F091x.svd b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/cfg/STM32F091x.svd new file mode 100644 index 00000000..2b84ea3d --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/cfg/STM32F091x.svd @@ -0,0 +1,31643 @@ + + + STM32F091x + 1.0 + STM32F091x + + + 8 + + 32 + + 0x20 + 0x0 + 0xFFFFFFFF + + + CRC + cyclic redundancy check calculation + unit + CRC + 0x40023000 + + 0x0 + 0x400 + registers + + + + DR + DR + Data register + 0x0 + 0x20 + read-write + 0xFFFFFFFF + + + DR + Data register bits + 0 + 32 + + + + + IDR + IDR + Independent data register + 0x4 + 0x20 + read-write + 0x00000000 + + + IDR + General-purpose 8-bit data register + bits + 0 + 8 + + + + + CR + CR + Control register + 0x8 + 0x20 + read-write + 0x00000000 + + + RESET + reset bit + 0 + 1 + + + REV_IN + Reverse input data + 5 + 2 + + + REV_OUT + Reverse output data + 7 + 1 + + + + + INIT + INIT + Initial CRC value + 0xC + 0x20 + read-write + 0xFFFFFFFF + + + INIT + Programmable initial CRC + value + 0 + 32 + + + + + + + GPIOF + General-purpose I/Os + GPIO + 0x48001400 + + 0x0 + 0x400 + registers + + + + MODER + MODER + GPIO port mode register + 0x0 + 0x20 + read-write + 0x00000000 + + + MODER15 + Port x configuration bits (y = + 0..15) + 30 + 2 + + + MODER14 + Port x configuration bits (y = + 0..15) + 28 + 2 + + + MODER13 + Port x configuration bits (y = + 0..15) + 26 + 2 + + + MODER12 + Port x configuration bits (y = + 0..15) + 24 + 2 + + + MODER11 + Port x configuration bits (y = + 0..15) + 22 + 2 + + + MODER10 + Port x configuration bits (y = + 0..15) + 20 + 2 + + + MODER9 + Port x configuration bits (y = + 0..15) + 18 + 2 + + + MODER8 + Port x configuration bits (y = + 0..15) + 16 + 2 + + + MODER7 + Port x configuration bits (y = + 0..15) + 14 + 2 + + + MODER6 + Port x configuration bits (y = + 0..15) + 12 + 2 + + + MODER5 + Port x configuration bits (y = + 0..15) + 10 + 2 + + + MODER4 + Port x configuration bits (y = + 0..15) + 8 + 2 + + + MODER3 + Port x configuration bits (y = + 0..15) + 6 + 2 + + + MODER2 + Port x configuration bits (y = + 0..15) + 4 + 2 + + + MODER1 + Port x configuration bits (y = + 0..15) + 2 + 2 + + + MODER0 + Port x configuration bits (y = + 0..15) + 0 + 2 + + + + + OTYPER + OTYPER + GPIO port output type register + 0x4 + 0x20 + read-write + 0x00000000 + + + OT15 + Port x configuration bit + 15 + 15 + 1 + + + OT14 + Port x configuration bit + 14 + 14 + 1 + + + OT13 + Port x configuration bit + 13 + 13 + 1 + + + OT12 + Port x configuration bit + 12 + 12 + 1 + + + OT11 + Port x configuration bit + 11 + 11 + 1 + + + OT10 + Port x configuration bit + 10 + 10 + 1 + + + OT9 + Port x configuration bit 9 + 9 + 1 + + + OT8 + Port x configuration bit 8 + 8 + 1 + + + OT7 + Port x configuration bit 7 + 7 + 1 + + + OT6 + Port x configuration bit 6 + 6 + 1 + + + OT5 + Port x configuration bit 5 + 5 + 1 + + + OT4 + Port x configuration bit 4 + 4 + 1 + + + OT3 + Port x configuration bit 3 + 3 + 1 + + + OT2 + Port x configuration bit 2 + 2 + 1 + + + OT1 + Port x configuration bit 1 + 1 + 1 + + + OT0 + Port x configuration bit 0 + 0 + 1 + + + + + OSPEEDR + OSPEEDR + GPIO port output speed + register + 0x8 + 0x20 + read-write + 0x00000000 + + + OSPEEDR15 + Port x configuration bits (y = + 0..15) + 30 + 2 + + + OSPEEDR14 + Port x configuration bits (y = + 0..15) + 28 + 2 + + + OSPEEDR13 + Port x configuration bits (y = + 0..15) + 26 + 2 + + + OSPEEDR12 + Port x configuration bits (y = + 0..15) + 24 + 2 + + + OSPEEDR11 + Port x configuration bits (y = + 0..15) + 22 + 2 + + + OSPEEDR10 + Port x configuration bits (y = + 0..15) + 20 + 2 + + + OSPEEDR9 + Port x configuration bits (y = + 0..15) + 18 + 2 + + + OSPEEDR8 + Port x configuration bits (y = + 0..15) + 16 + 2 + + + OSPEEDR7 + Port x configuration bits (y = + 0..15) + 14 + 2 + + + OSPEEDR6 + Port x configuration bits (y = + 0..15) + 12 + 2 + + + OSPEEDR5 + Port x configuration bits (y = + 0..15) + 10 + 2 + + + OSPEEDR4 + Port x configuration bits (y = + 0..15) + 8 + 2 + + + OSPEEDR3 + Port x configuration bits (y = + 0..15) + 6 + 2 + + + OSPEEDR2 + Port x configuration bits (y = + 0..15) + 4 + 2 + + + OSPEEDR1 + Port x configuration bits (y = + 0..15) + 2 + 2 + + + OSPEEDR0 + Port x configuration bits (y = + 0..15) + 0 + 2 + + + + + PUPDR + PUPDR + GPIO port pull-up/pull-down + register + 0xC + 0x20 + read-write + 0x00000000 + + + PUPDR15 + Port x configuration bits (y = + 0..15) + 30 + 2 + + + PUPDR14 + Port x configuration bits (y = + 0..15) + 28 + 2 + + + PUPDR13 + Port x configuration bits (y = + 0..15) + 26 + 2 + + + PUPDR12 + Port x configuration bits (y = + 0..15) + 24 + 2 + + + PUPDR11 + Port x configuration bits (y = + 0..15) + 22 + 2 + + + PUPDR10 + Port x configuration bits (y = + 0..15) + 20 + 2 + + + PUPDR9 + Port x configuration bits (y = + 0..15) + 18 + 2 + + + PUPDR8 + Port x configuration bits (y = + 0..15) + 16 + 2 + + + PUPDR7 + Port x configuration bits (y = + 0..15) + 14 + 2 + + + PUPDR6 + Port x configuration bits (y = + 0..15) + 12 + 2 + + + PUPDR5 + Port x configuration bits (y = + 0..15) + 10 + 2 + + + PUPDR4 + Port x configuration bits (y = + 0..15) + 8 + 2 + + + PUPDR3 + Port x configuration bits (y = + 0..15) + 6 + 2 + + + PUPDR2 + Port x configuration bits (y = + 0..15) + 4 + 2 + + + PUPDR1 + Port x configuration bits (y = + 0..15) + 2 + 2 + + + PUPDR0 + Port x configuration bits (y = + 0..15) + 0 + 2 + + + + + IDR + IDR + GPIO port input data register + 0x10 + 0x20 + read-only + 0x00000000 + + + IDR15 + Port input data (y = + 0..15) + 15 + 1 + + + IDR14 + Port input data (y = + 0..15) + 14 + 1 + + + IDR13 + Port input data (y = + 0..15) + 13 + 1 + + + IDR12 + Port input data (y = + 0..15) + 12 + 1 + + + IDR11 + Port input data (y = + 0..15) + 11 + 1 + + + IDR10 + Port input data (y = + 0..15) + 10 + 1 + + + IDR9 + Port input data (y = + 0..15) + 9 + 1 + + + IDR8 + Port input data (y = + 0..15) + 8 + 1 + + + IDR7 + Port input data (y = + 0..15) + 7 + 1 + + + IDR6 + Port input data (y = + 0..15) + 6 + 1 + + + IDR5 + Port input data (y = + 0..15) + 5 + 1 + + + IDR4 + Port input data (y = + 0..15) + 4 + 1 + + + IDR3 + Port input data (y = + 0..15) + 3 + 1 + + + IDR2 + Port input data (y = + 0..15) + 2 + 1 + + + IDR1 + Port input data (y = + 0..15) + 1 + 1 + + + IDR0 + Port input data (y = + 0..15) + 0 + 1 + + + + + ODR + ODR + GPIO port output data register + 0x14 + 0x20 + read-write + 0x00000000 + + + ODR15 + Port output data (y = + 0..15) + 15 + 1 + + + ODR14 + Port output data (y = + 0..15) + 14 + 1 + + + ODR13 + Port output data (y = + 0..15) + 13 + 1 + + + ODR12 + Port output data (y = + 0..15) + 12 + 1 + + + ODR11 + Port output data (y = + 0..15) + 11 + 1 + + + ODR10 + Port output data (y = + 0..15) + 10 + 1 + + + ODR9 + Port output data (y = + 0..15) + 9 + 1 + + + ODR8 + Port output data (y = + 0..15) + 8 + 1 + + + ODR7 + Port output data (y = + 0..15) + 7 + 1 + + + ODR6 + Port output data (y = + 0..15) + 6 + 1 + + + ODR5 + Port output data (y = + 0..15) + 5 + 1 + + + ODR4 + Port output data (y = + 0..15) + 4 + 1 + + + ODR3 + Port output data (y = + 0..15) + 3 + 1 + + + ODR2 + Port output data (y = + 0..15) + 2 + 1 + + + ODR1 + Port output data (y = + 0..15) + 1 + 1 + + + ODR0 + Port output data (y = + 0..15) + 0 + 1 + + + + + BSRR + BSRR + GPIO port bit set/reset + register + 0x18 + 0x20 + write-only + 0x00000000 + + + BR15 + Port x reset bit y (y = + 0..15) + 31 + 1 + + + BR14 + Port x reset bit y (y = + 0..15) + 30 + 1 + + + BR13 + Port x reset bit y (y = + 0..15) + 29 + 1 + + + BR12 + Port x reset bit y (y = + 0..15) + 28 + 1 + + + BR11 + Port x reset bit y (y = + 0..15) + 27 + 1 + + + BR10 + Port x reset bit y (y = + 0..15) + 26 + 1 + + + BR9 + Port x reset bit y (y = + 0..15) + 25 + 1 + + + BR8 + Port x reset bit y (y = + 0..15) + 24 + 1 + + + BR7 + Port x reset bit y (y = + 0..15) + 23 + 1 + + + BR6 + Port x reset bit y (y = + 0..15) + 22 + 1 + + + BR5 + Port x reset bit y (y = + 0..15) + 21 + 1 + + + BR4 + Port x reset bit y (y = + 0..15) + 20 + 1 + + + BR3 + Port x reset bit y (y = + 0..15) + 19 + 1 + + + BR2 + Port x reset bit y (y = + 0..15) + 18 + 1 + + + BR1 + Port x reset bit y (y = + 0..15) + 17 + 1 + + + BR0 + Port x set bit y (y= + 0..15) + 16 + 1 + + + BS15 + Port x set bit y (y= + 0..15) + 15 + 1 + + + BS14 + Port x set bit y (y= + 0..15) + 14 + 1 + + + BS13 + Port x set bit y (y= + 0..15) + 13 + 1 + + + BS12 + Port x set bit y (y= + 0..15) + 12 + 1 + + + BS11 + Port x set bit y (y= + 0..15) + 11 + 1 + + + BS10 + Port x set bit y (y= + 0..15) + 10 + 1 + + + BS9 + Port x set bit y (y= + 0..15) + 9 + 1 + + + BS8 + Port x set bit y (y= + 0..15) + 8 + 1 + + + BS7 + Port x set bit y (y= + 0..15) + 7 + 1 + + + BS6 + Port x set bit y (y= + 0..15) + 6 + 1 + + + BS5 + Port x set bit y (y= + 0..15) + 5 + 1 + + + BS4 + Port x set bit y (y= + 0..15) + 4 + 1 + + + BS3 + Port x set bit y (y= + 0..15) + 3 + 1 + + + BS2 + Port x set bit y (y= + 0..15) + 2 + 1 + + + BS1 + Port x set bit y (y= + 0..15) + 1 + 1 + + + BS0 + Port x set bit y (y= + 0..15) + 0 + 1 + + + + + LCKR + LCKR + GPIO port configuration lock + register + 0x1C + 0x20 + read-write + 0x00000000 + + + LCKK + Port x lock bit y + 16 + 1 + + + LCK15 + Port x lock bit y (y= + 0..15) + 15 + 1 + + + LCK14 + Port x lock bit y (y= + 0..15) + 14 + 1 + + + LCK13 + Port x lock bit y (y= + 0..15) + 13 + 1 + + + LCK12 + Port x lock bit y (y= + 0..15) + 12 + 1 + + + LCK11 + Port x lock bit y (y= + 0..15) + 11 + 1 + + + LCK10 + Port x lock bit y (y= + 0..15) + 10 + 1 + + + LCK9 + Port x lock bit y (y= + 0..15) + 9 + 1 + + + LCK8 + Port x lock bit y (y= + 0..15) + 8 + 1 + + + LCK7 + Port x lock bit y (y= + 0..15) + 7 + 1 + + + LCK6 + Port x lock bit y (y= + 0..15) + 6 + 1 + + + LCK5 + Port x lock bit y (y= + 0..15) + 5 + 1 + + + LCK4 + Port x lock bit y (y= + 0..15) + 4 + 1 + + + LCK3 + Port x lock bit y (y= + 0..15) + 3 + 1 + + + LCK2 + Port x lock bit y (y= + 0..15) + 2 + 1 + + + LCK1 + Port x lock bit y (y= + 0..15) + 1 + 1 + + + LCK0 + Port x lock bit y (y= + 0..15) + 0 + 1 + + + + + AFRL + AFRL + GPIO alternate function low + register + 0x20 + 0x20 + read-write + 0x00000000 + + + AFRL7 + Alternate function selection for port x + bit y (y = 0..7) + 28 + 4 + + + AFRL6 + Alternate function selection for port x + bit y (y = 0..7) + 24 + 4 + + + AFRL5 + Alternate function selection for port x + bit y (y = 0..7) + 20 + 4 + + + AFRL4 + Alternate function selection for port x + bit y (y = 0..7) + 16 + 4 + + + AFRL3 + Alternate function selection for port x + bit y (y = 0..7) + 12 + 4 + + + AFRL2 + Alternate function selection for port x + bit y (y = 0..7) + 8 + 4 + + + AFRL1 + Alternate function selection for port x + bit y (y = 0..7) + 4 + 4 + + + AFRL0 + Alternate function selection for port x + bit y (y = 0..7) + 0 + 4 + + + + + AFRH + AFRH + GPIO alternate function high + register + 0x24 + 0x20 + read-write + 0x00000000 + + + AFRH15 + Alternate function selection for port x + bit y (y = 8..15) + 28 + 4 + + + AFRH14 + Alternate function selection for port x + bit y (y = 8..15) + 24 + 4 + + + AFRH13 + Alternate function selection for port x + bit y (y = 8..15) + 20 + 4 + + + AFRH12 + Alternate function selection for port x + bit y (y = 8..15) + 16 + 4 + + + AFRH11 + Alternate function selection for port x + bit y (y = 8..15) + 12 + 4 + + + AFRH10 + Alternate function selection for port x + bit y (y = 8..15) + 8 + 4 + + + AFRH9 + Alternate function selection for port x + bit y (y = 8..15) + 4 + 4 + + + AFRH8 + Alternate function selection for port x + bit y (y = 8..15) + 0 + 4 + + + + + BRR + BRR + Port bit reset register + 0x28 + 0x20 + write-only + 0x00000000 + + + BR0 + Port x Reset bit y + 0 + 1 + + + BR1 + Port x Reset bit y + 1 + 1 + + + BR2 + Port x Reset bit y + 2 + 1 + + + BR3 + Port x Reset bit y + 3 + 1 + + + BR4 + Port x Reset bit y + 4 + 1 + + + BR5 + Port x Reset bit y + 5 + 1 + + + BR6 + Port x Reset bit y + 6 + 1 + + + BR7 + Port x Reset bit y + 7 + 1 + + + BR8 + Port x Reset bit y + 8 + 1 + + + BR9 + Port x Reset bit y + 9 + 1 + + + BR10 + Port x Reset bit y + 10 + 1 + + + BR11 + Port x Reset bit y + 11 + 1 + + + BR12 + Port x Reset bit y + 12 + 1 + + + BR13 + Port x Reset bit y + 13 + 1 + + + BR14 + Port x Reset bit y + 14 + 1 + + + BR15 + Port x Reset bit y + 15 + 1 + + + + + + + GPIOD + 0x48000C00 + + + GPIOC + 0x48000800 + + + GPIOB + 0x48000400 + + + GPIOE + 0x48001000 + + + GPIOA + General-purpose I/Os + GPIO + 0x48000000 + + 0x0 + 0x400 + registers + + + + MODER + MODER + GPIO port mode register + 0x0 + 0x20 + read-write + 0x28000000 + + + MODER15 + Port x configuration bits (y = + 0..15) + 30 + 2 + + + MODER14 + Port x configuration bits (y = + 0..15) + 28 + 2 + + + MODER13 + Port x configuration bits (y = + 0..15) + 26 + 2 + + + MODER12 + Port x configuration bits (y = + 0..15) + 24 + 2 + + + MODER11 + Port x configuration bits (y = + 0..15) + 22 + 2 + + + MODER10 + Port x configuration bits (y = + 0..15) + 20 + 2 + + + MODER9 + Port x configuration bits (y = + 0..15) + 18 + 2 + + + MODER8 + Port x configuration bits (y = + 0..15) + 16 + 2 + + + MODER7 + Port x configuration bits (y = + 0..15) + 14 + 2 + + + MODER6 + Port x configuration bits (y = + 0..15) + 12 + 2 + + + MODER5 + Port x configuration bits (y = + 0..15) + 10 + 2 + + + MODER4 + Port x configuration bits (y = + 0..15) + 8 + 2 + + + MODER3 + Port x configuration bits (y = + 0..15) + 6 + 2 + + + MODER2 + Port x configuration bits (y = + 0..15) + 4 + 2 + + + MODER1 + Port x configuration bits (y = + 0..15) + 2 + 2 + + + MODER0 + Port x configuration bits (y = + 0..15) + 0 + 2 + + + + + OTYPER + OTYPER + GPIO port output type register + 0x4 + 0x20 + read-write + 0x00000000 + + + OT15 + Port x configuration bits (y = + 0..15) + 15 + 1 + + + OT14 + Port x configuration bits (y = + 0..15) + 14 + 1 + + + OT13 + Port x configuration bits (y = + 0..15) + 13 + 1 + + + OT12 + Port x configuration bits (y = + 0..15) + 12 + 1 + + + OT11 + Port x configuration bits (y = + 0..15) + 11 + 1 + + + OT10 + Port x configuration bits (y = + 0..15) + 10 + 1 + + + OT9 + Port x configuration bits (y = + 0..15) + 9 + 1 + + + OT8 + Port x configuration bits (y = + 0..15) + 8 + 1 + + + OT7 + Port x configuration bits (y = + 0..15) + 7 + 1 + + + OT6 + Port x configuration bits (y = + 0..15) + 6 + 1 + + + OT5 + Port x configuration bits (y = + 0..15) + 5 + 1 + + + OT4 + Port x configuration bits (y = + 0..15) + 4 + 1 + + + OT3 + Port x configuration bits (y = + 0..15) + 3 + 1 + + + OT2 + Port x configuration bits (y = + 0..15) + 2 + 1 + + + OT1 + Port x configuration bits (y = + 0..15) + 1 + 1 + + + OT0 + Port x configuration bits (y = + 0..15) + 0 + 1 + + + + + OSPEEDR + OSPEEDR + GPIO port output speed + register + 0x8 + 0x20 + read-write + 0x00000000 + + + OSPEEDR15 + Port x configuration bits (y = + 0..15) + 30 + 2 + + + OSPEEDR14 + Port x configuration bits (y = + 0..15) + 28 + 2 + + + OSPEEDR13 + Port x configuration bits (y = + 0..15) + 26 + 2 + + + OSPEEDR12 + Port x configuration bits (y = + 0..15) + 24 + 2 + + + OSPEEDR11 + Port x configuration bits (y = + 0..15) + 22 + 2 + + + OSPEEDR10 + Port x configuration bits (y = + 0..15) + 20 + 2 + + + OSPEEDR9 + Port x configuration bits (y = + 0..15) + 18 + 2 + + + OSPEEDR8 + Port x configuration bits (y = + 0..15) + 16 + 2 + + + OSPEEDR7 + Port x configuration bits (y = + 0..15) + 14 + 2 + + + OSPEEDR6 + Port x configuration bits (y = + 0..15) + 12 + 2 + + + OSPEEDR5 + Port x configuration bits (y = + 0..15) + 10 + 2 + + + OSPEEDR4 + Port x configuration bits (y = + 0..15) + 8 + 2 + + + OSPEEDR3 + Port x configuration bits (y = + 0..15) + 6 + 2 + + + OSPEEDR2 + Port x configuration bits (y = + 0..15) + 4 + 2 + + + OSPEEDR1 + Port x configuration bits (y = + 0..15) + 2 + 2 + + + OSPEEDR0 + Port x configuration bits (y = + 0..15) + 0 + 2 + + + + + PUPDR + PUPDR + GPIO port pull-up/pull-down + register + 0xC + 0x20 + read-write + 0x24000000 + + + PUPDR15 + Port x configuration bits (y = + 0..15) + 30 + 2 + + + PUPDR14 + Port x configuration bits (y = + 0..15) + 28 + 2 + + + PUPDR13 + Port x configuration bits (y = + 0..15) + 26 + 2 + + + PUPDR12 + Port x configuration bits (y = + 0..15) + 24 + 2 + + + PUPDR11 + Port x configuration bits (y = + 0..15) + 22 + 2 + + + PUPDR10 + Port x configuration bits (y = + 0..15) + 20 + 2 + + + PUPDR9 + Port x configuration bits (y = + 0..15) + 18 + 2 + + + PUPDR8 + Port x configuration bits (y = + 0..15) + 16 + 2 + + + PUPDR7 + Port x configuration bits (y = + 0..15) + 14 + 2 + + + PUPDR6 + Port x configuration bits (y = + 0..15) + 12 + 2 + + + PUPDR5 + Port x configuration bits (y = + 0..15) + 10 + 2 + + + PUPDR4 + Port x configuration bits (y = + 0..15) + 8 + 2 + + + PUPDR3 + Port x configuration bits (y = + 0..15) + 6 + 2 + + + PUPDR2 + Port x configuration bits (y = + 0..15) + 4 + 2 + + + PUPDR1 + Port x configuration bits (y = + 0..15) + 2 + 2 + + + PUPDR0 + Port x configuration bits (y = + 0..15) + 0 + 2 + + + + + IDR + IDR + GPIO port input data register + 0x10 + 0x20 + read-only + 0x00000000 + + + IDR15 + Port input data (y = + 0..15) + 15 + 1 + + + IDR14 + Port input data (y = + 0..15) + 14 + 1 + + + IDR13 + Port input data (y = + 0..15) + 13 + 1 + + + IDR12 + Port input data (y = + 0..15) + 12 + 1 + + + IDR11 + Port input data (y = + 0..15) + 11 + 1 + + + IDR10 + Port input data (y = + 0..15) + 10 + 1 + + + IDR9 + Port input data (y = + 0..15) + 9 + 1 + + + IDR8 + Port input data (y = + 0..15) + 8 + 1 + + + IDR7 + Port input data (y = + 0..15) + 7 + 1 + + + IDR6 + Port input data (y = + 0..15) + 6 + 1 + + + IDR5 + Port input data (y = + 0..15) + 5 + 1 + + + IDR4 + Port input data (y = + 0..15) + 4 + 1 + + + IDR3 + Port input data (y = + 0..15) + 3 + 1 + + + IDR2 + Port input data (y = + 0..15) + 2 + 1 + + + IDR1 + Port input data (y = + 0..15) + 1 + 1 + + + IDR0 + Port input data (y = + 0..15) + 0 + 1 + + + + + ODR + ODR + GPIO port output data register + 0x14 + 0x20 + read-write + 0x00000000 + + + ODR15 + Port output data (y = + 0..15) + 15 + 1 + + + ODR14 + Port output data (y = + 0..15) + 14 + 1 + + + ODR13 + Port output data (y = + 0..15) + 13 + 1 + + + ODR12 + Port output data (y = + 0..15) + 12 + 1 + + + ODR11 + Port output data (y = + 0..15) + 11 + 1 + + + ODR10 + Port output data (y = + 0..15) + 10 + 1 + + + ODR9 + Port output data (y = + 0..15) + 9 + 1 + + + ODR8 + Port output data (y = + 0..15) + 8 + 1 + + + ODR7 + Port output data (y = + 0..15) + 7 + 1 + + + ODR6 + Port output data (y = + 0..15) + 6 + 1 + + + ODR5 + Port output data (y = + 0..15) + 5 + 1 + + + ODR4 + Port output data (y = + 0..15) + 4 + 1 + + + ODR3 + Port output data (y = + 0..15) + 3 + 1 + + + ODR2 + Port output data (y = + 0..15) + 2 + 1 + + + ODR1 + Port output data (y = + 0..15) + 1 + 1 + + + ODR0 + Port output data (y = + 0..15) + 0 + 1 + + + + + BSRR + BSRR + GPIO port bit set/reset + register + 0x18 + 0x20 + write-only + 0x00000000 + + + BR15 + Port x reset bit y (y = + 0..15) + 31 + 1 + + + BR14 + Port x reset bit y (y = + 0..15) + 30 + 1 + + + BR13 + Port x reset bit y (y = + 0..15) + 29 + 1 + + + BR12 + Port x reset bit y (y = + 0..15) + 28 + 1 + + + BR11 + Port x reset bit y (y = + 0..15) + 27 + 1 + + + BR10 + Port x reset bit y (y = + 0..15) + 26 + 1 + + + BR9 + Port x reset bit y (y = + 0..15) + 25 + 1 + + + BR8 + Port x reset bit y (y = + 0..15) + 24 + 1 + + + BR7 + Port x reset bit y (y = + 0..15) + 23 + 1 + + + BR6 + Port x reset bit y (y = + 0..15) + 22 + 1 + + + BR5 + Port x reset bit y (y = + 0..15) + 21 + 1 + + + BR4 + Port x reset bit y (y = + 0..15) + 20 + 1 + + + BR3 + Port x reset bit y (y = + 0..15) + 19 + 1 + + + BR2 + Port x reset bit y (y = + 0..15) + 18 + 1 + + + BR1 + Port x reset bit y (y = + 0..15) + 17 + 1 + + + BR0 + Port x set bit y (y= + 0..15) + 16 + 1 + + + BS15 + Port x set bit y (y= + 0..15) + 15 + 1 + + + BS14 + Port x set bit y (y= + 0..15) + 14 + 1 + + + BS13 + Port x set bit y (y= + 0..15) + 13 + 1 + + + BS12 + Port x set bit y (y= + 0..15) + 12 + 1 + + + BS11 + Port x set bit y (y= + 0..15) + 11 + 1 + + + BS10 + Port x set bit y (y= + 0..15) + 10 + 1 + + + BS9 + Port x set bit y (y= + 0..15) + 9 + 1 + + + BS8 + Port x set bit y (y= + 0..15) + 8 + 1 + + + BS7 + Port x set bit y (y= + 0..15) + 7 + 1 + + + BS6 + Port x set bit y (y= + 0..15) + 6 + 1 + + + BS5 + Port x set bit y (y= + 0..15) + 5 + 1 + + + BS4 + Port x set bit y (y= + 0..15) + 4 + 1 + + + BS3 + Port x set bit y (y= + 0..15) + 3 + 1 + + + BS2 + Port x set bit y (y= + 0..15) + 2 + 1 + + + BS1 + Port x set bit y (y= + 0..15) + 1 + 1 + + + BS0 + Port x set bit y (y= + 0..15) + 0 + 1 + + + + + LCKR + LCKR + GPIO port configuration lock + register + 0x1C + 0x20 + read-write + 0x00000000 + + + LCKK + Port x lock bit y (y= + 0..15) + 16 + 1 + + + LCK15 + Port x lock bit y (y= + 0..15) + 15 + 1 + + + LCK14 + Port x lock bit y (y= + 0..15) + 14 + 1 + + + LCK13 + Port x lock bit y (y= + 0..15) + 13 + 1 + + + LCK12 + Port x lock bit y (y= + 0..15) + 12 + 1 + + + LCK11 + Port x lock bit y (y= + 0..15) + 11 + 1 + + + LCK10 + Port x lock bit y (y= + 0..15) + 10 + 1 + + + LCK9 + Port x lock bit y (y= + 0..15) + 9 + 1 + + + LCK8 + Port x lock bit y (y= + 0..15) + 8 + 1 + + + LCK7 + Port x lock bit y (y= + 0..15) + 7 + 1 + + + LCK6 + Port x lock bit y (y= + 0..15) + 6 + 1 + + + LCK5 + Port x lock bit y (y= + 0..15) + 5 + 1 + + + LCK4 + Port x lock bit y (y= + 0..15) + 4 + 1 + + + LCK3 + Port x lock bit y (y= + 0..15) + 3 + 1 + + + LCK2 + Port x lock bit y (y= + 0..15) + 2 + 1 + + + LCK1 + Port x lock bit y (y= + 0..15) + 1 + 1 + + + LCK0 + Port x lock bit y (y= + 0..15) + 0 + 1 + + + + + AFRL + AFRL + GPIO alternate function low + register + 0x20 + 0x20 + read-write + 0x00000000 + + + AFRL7 + Alternate function selection for port x + bit y (y = 0..7) + 28 + 4 + + + AFRL6 + Alternate function selection for port x + bit y (y = 0..7) + 24 + 4 + + + AFRL5 + Alternate function selection for port x + bit y (y = 0..7) + 20 + 4 + + + AFRL4 + Alternate function selection for port x + bit y (y = 0..7) + 16 + 4 + + + AFRL3 + Alternate function selection for port x + bit y (y = 0..7) + 12 + 4 + + + AFRL2 + Alternate function selection for port x + bit y (y = 0..7) + 8 + 4 + + + AFRL1 + Alternate function selection for port x + bit y (y = 0..7) + 4 + 4 + + + AFRL0 + Alternate function selection for port x + bit y (y = 0..7) + 0 + 4 + + + + + AFRH + AFRH + GPIO alternate function high + register + 0x24 + 0x20 + read-write + 0x00000000 + + + AFRH15 + Alternate function selection for port x + bit y (y = 8..15) + 28 + 4 + + + AFRH14 + Alternate function selection for port x + bit y (y = 8..15) + 24 + 4 + + + AFRH13 + Alternate function selection for port x + bit y (y = 8..15) + 20 + 4 + + + AFRH12 + Alternate function selection for port x + bit y (y = 8..15) + 16 + 4 + + + AFRH11 + Alternate function selection for port x + bit y (y = 8..15) + 12 + 4 + + + AFRH10 + Alternate function selection for port x + bit y (y = 8..15) + 8 + 4 + + + AFRH9 + Alternate function selection for port x + bit y (y = 8..15) + 4 + 4 + + + AFRH8 + Alternate function selection for port x + bit y (y = 8..15) + 0 + 4 + + + + + BRR + BRR + Port bit reset register + 0x28 + 0x20 + write-only + 0x00000000 + + + BR0 + Port x Reset bit y + 0 + 1 + + + BR1 + Port x Reset bit y + 1 + 1 + + + BR2 + Port x Reset bit y + 2 + 1 + + + BR3 + Port x Reset bit y + 3 + 1 + + + BR4 + Port x Reset bit y + 4 + 1 + + + BR5 + Port x Reset bit y + 5 + 1 + + + BR6 + Port x Reset bit y + 6 + 1 + + + BR7 + Port x Reset bit y + 7 + 1 + + + BR8 + Port x Reset bit y + 8 + 1 + + + BR9 + Port x Reset bit y + 9 + 1 + + + BR10 + Port x Reset bit y + 10 + 1 + + + BR11 + Port x Reset bit y + 11 + 1 + + + BR12 + Port x Reset bit y + 12 + 1 + + + BR13 + Port x Reset bit y + 13 + 1 + + + BR14 + Port x Reset bit y + 14 + 1 + + + BR15 + Port x Reset bit y + 15 + 1 + + + + + + + SPI1 + Serial peripheral interface + SPI + 0x40013000 + + 0x0 + 0x400 + registers + + + SPI1 + SPI1_global_interrupt + 25 + + + + CR1 + CR1 + control register 1 + 0x0 + 0x20 + read-write + 0x0000 + + + BIDIMODE + Bidirectional data mode + enable + 15 + 1 + + + BIDIOE + Output enable in bidirectional + mode + 14 + 1 + + + CRCEN + Hardware CRC calculation + enable + 13 + 1 + + + CRCNEXT + CRC transfer next + 12 + 1 + + + DFF + Data frame format + 11 + 1 + + + RXONLY + Receive only + 10 + 1 + + + SSM + Software slave management + 9 + 1 + + + SSI + Internal slave select + 8 + 1 + + + LSBFIRST + Frame format + 7 + 1 + + + SPE + SPI enable + 6 + 1 + + + BR + Baud rate control + 3 + 3 + + + MSTR + Master selection + 2 + 1 + + + CPOL + Clock polarity + 1 + 1 + + + CPHA + Clock phase + 0 + 1 + + + + + CR2 + CR2 + control register 2 + 0x4 + 0x20 + read-write + 0x0000 + + + RXDMAEN + Rx buffer DMA enable + 0 + 1 + + + TXDMAEN + Tx buffer DMA enable + 1 + 1 + + + SSOE + SS output enable + 2 + 1 + + + NSSP + NSS pulse management + 3 + 1 + + + FRF + Frame format + 4 + 1 + + + ERRIE + Error interrupt enable + 5 + 1 + + + RXNEIE + RX buffer not empty interrupt + enable + 6 + 1 + + + TXEIE + Tx buffer empty interrupt + enable + 7 + 1 + + + DS + Data size + 8 + 4 + + + FRXTH + FIFO reception threshold + 12 + 1 + + + LDMA_RX + Last DMA transfer for + reception + 13 + 1 + + + LDMA_TX + Last DMA transfer for + transmission + 14 + 1 + + + + + SR + SR + status register + 0x8 + 0x20 + 0x0002 + + + RXNE + Receive buffer not empty + 0 + 1 + read-only + + + TXE + Transmit buffer empty + 1 + 1 + read-only + + + CHSIDE + Channel side + 2 + 1 + read-only + + + UDR + Underrun flag + 3 + 1 + read-only + + + CRCERR + CRC error flag + 4 + 1 + read-write + + + MODF + Mode fault + 5 + 1 + read-only + + + OVR + Overrun flag + 6 + 1 + read-only + + + BSY + Busy flag + 7 + 1 + read-only + + + TIFRFE + TI frame format error + 8 + 1 + read-only + + + FRLVL + FIFO reception level + 9 + 2 + read-only + + + FTLVL + FIFO transmission level + 11 + 2 + read-only + + + + + DR + DR + data register + 0xC + 0x20 + read-write + 0x0000 + + + DR + Data register + 0 + 16 + + + + + CRCPR + CRCPR + CRC polynomial register + 0x10 + 0x20 + read-write + 0x0007 + + + CRCPOLY + CRC polynomial register + 0 + 16 + + + + + RXCRCR + RXCRCR + RX CRC register + 0x14 + 0x20 + read-only + 0x0000 + + + RxCRC + Rx CRC register + 0 + 16 + + + + + TXCRCR + TXCRCR + TX CRC register + 0x18 + 0x20 + read-only + 0x0000 + + + TxCRC + Tx CRC register + 0 + 16 + + + + + I2SCFGR + I2SCFGR + I2S configuration register + 0x1C + 0x20 + read-write + 0x0000 + + + I2SMOD + I2S mode selection + 11 + 1 + + + I2SE + I2S Enable + 10 + 1 + + + I2SCFG + I2S configuration mode + 8 + 2 + + + PCMSYNC + PCM frame synchronization + 7 + 1 + + + I2SSTD + I2S standard selection + 4 + 2 + + + CKPOL + Steady state clock + polarity + 3 + 1 + + + DATLEN + Data length to be + transferred + 1 + 2 + + + CHLEN + Channel length (number of bits per audio + channel) + 0 + 1 + + + + + I2SPR + I2SPR + I2S prescaler register + 0x20 + 0x20 + read-write + 0x00000010 + + + MCKOE + Master clock output enable + 9 + 1 + + + ODD + Odd factor for the + prescaler + 8 + 1 + + + I2SDIV + I2S Linear prescaler + 0 + 8 + + + + + + + SPI2 + 0x40003800 + + SPI2 + SPI2 global interrupt + 26 + + + + DAC + Digital-to-analog converter + DAC + 0x40007400 + + 0x0 + 0x400 + registers + + + TIM6_DAC + TIM6 global interrupt and DAC underrun + interrupt + 17 + + + + CR + CR + control register + 0x0 + 0x20 + read-write + 0x00000000 + + + EN1 + DAC channel1 enable + 0 + 1 + + + BOFF1 + DAC channel1 output buffer + disable + 1 + 1 + + + TEN1 + DAC channel1 trigger + enable + 2 + 1 + + + TSEL10 + DAC channel1 trigger + selection + 3 + 1 + + + TSEL11 + DAC channel1 trigger + selection + 4 + 1 + + + TSEL12 + DAC channel1 trigger + selection + 5 + 1 + + + DMAEN1 + DAC channel1 DMA enable + 12 + 1 + + + DMAUDRIE1 + DAC channel1 DMA Underrun Interrupt + enable + 13 + 1 + + + + + SWTRIGR + SWTRIGR + software trigger register + 0x4 + 0x20 + write-only + 0x00000000 + + + SWTRIG1 + DAC channel1 software + trigger + 0 + 1 + + + + + DHR12R1 + DHR12R1 + channel1 12-bit right-aligned data holding + register + 0x8 + 0x20 + read-write + 0x00000000 + + + DACC1DHR + DAC channel1 12-bit right-aligned + data + 0 + 12 + + + + + DHR12L1 + DHR12L1 + channel1 12-bit left aligned data holding + register + 0xC + 0x20 + read-write + 0x00000000 + + + DACC1DHR + DAC channel1 12-bit left-aligned + data + 4 + 12 + + + + + DHR8R1 + DHR8R1 + channel1 8-bit right aligned data holding + register + 0x10 + 0x20 + read-write + 0x00000000 + + + DACC1DHR + DAC channel1 8-bit right-aligned + data + 0 + 8 + + + + + DOR1 + DOR1 + channel1 data output register + 0x2C + 0x20 + read-only + 0x00000000 + + + DACC1DOR + DAC channel1 data output + 0 + 12 + + + + + SR + SR + status register + 0x34 + 0x20 + read-write + 0x00000000 + + + DMAUDR2 + DAC channel2 DMA underrun + flag + 29 + 1 + + + DMAUDR1 + DAC channel1 DMA underrun + flag + 13 + 1 + + + + + + + PWR + Power control + PWR + 0x40007000 + + 0x0 + 0x400 + registers + + + + CR + CR + power control register + 0x0 + 0x20 + read-write + 0x00000000 + + + FPDS + Flash power down in Stop + mode + 9 + 1 + + + DBP + Disable backup domain write + protection + 8 + 1 + + + PLS + PVD level selection + 5 + 3 + + + PVDE + Power voltage detector + enable + 4 + 1 + + + CSBF + Clear standby flag + 3 + 1 + + + CWUF + Clear wakeup flag + 2 + 1 + + + PDDS + Power down deepsleep + 1 + 1 + + + LPDS + Low-power deep sleep + 0 + 1 + + + + + CSR + CSR + power control/status register + 0x4 + 0x20 + 0x00000000 + + + BRE + Backup regulator enable + 9 + 1 + read-write + + + EWUP + Enable WKUP pin + 8 + 1 + read-write + + + BRR + Backup regulator ready + 3 + 1 + read-only + + + PVDO + PVD output + 2 + 1 + read-only + + + SBF + Standby flag + 1 + 1 + read-only + + + WUF + Wakeup flag + 0 + 1 + read-only + + + + + + + I2C1 + Inter-integrated circuit + I2C + 0x40005400 + + 0x0 + 0x400 + registers + + + I2C1 + I2C1 global interrupt + 23 + + + + CR1 + CR1 + Control register 1 + 0x0 + 0x20 + 0x00000000 + + + PE + Peripheral enable + 0 + 1 + read-write + + + TXIE + TX Interrupt enable + 1 + 1 + read-write + + + RXIE + RX Interrupt enable + 2 + 1 + read-write + + + ADDRIE + Address match interrupt enable (slave + only) + 3 + 1 + read-write + + + NACKIE + Not acknowledge received interrupt + enable + 4 + 1 + read-write + + + STOPIE + STOP detection Interrupt + enable + 5 + 1 + read-write + + + TCIE + Transfer Complete interrupt + enable + 6 + 1 + read-write + + + ERRIE + Error interrupts enable + 7 + 1 + read-write + + + DNF + Digital noise filter + 8 + 4 + read-write + + + ANFOFF + Analog noise filter OFF + 12 + 1 + read-write + + + SWRST + Software reset + 13 + 1 + write-only + + + TXDMAEN + DMA transmission requests + enable + 14 + 1 + read-write + + + RXDMAEN + DMA reception requests + enable + 15 + 1 + read-write + + + SBC + Slave byte control + 16 + 1 + read-write + + + NOSTRETCH + Clock stretching disable + 17 + 1 + read-write + + + WUPEN + Wakeup from STOP enable + 18 + 1 + read-write + + + GCEN + General call enable + 19 + 1 + read-write + + + SMBHEN + SMBus Host address enable + 20 + 1 + read-write + + + SMBDEN + SMBus Device Default address + enable + 21 + 1 + read-write + + + ALERTEN + SMBUS alert enable + 22 + 1 + read-write + + + PECEN + PEC enable + 23 + 1 + read-write + + + + + CR2 + CR2 + Control register 2 + 0x4 + 0x20 + read-write + 0x00000000 + + + PECBYTE + Packet error checking byte + 26 + 1 + + + AUTOEND + Automatic end mode (master + mode) + 25 + 1 + + + RELOAD + NBYTES reload mode + 24 + 1 + + + NBYTES + Number of bytes + 16 + 8 + + + NACK + NACK generation (slave + mode) + 15 + 1 + + + STOP + Stop generation (master + mode) + 14 + 1 + + + START + Start generation + 13 + 1 + + + HEAD10R + 10-bit address header only read + direction (master receiver mode) + 12 + 1 + + + ADD10 + 10-bit addressing mode (master + mode) + 11 + 1 + + + RD_WRN + Transfer direction (master + mode) + 10 + 1 + + + SADD8 + Slave address bit 9:8 (master + mode) + 8 + 2 + + + SADD1 + Slave address bit 7:1 (master + mode) + 1 + 7 + + + SADD0 + Slave address bit 0 (master + mode) + 0 + 1 + + + + + OAR1 + OAR1 + Own address register 1 + 0x8 + 0x20 + read-write + 0x00000000 + + + OA1_0 + Interface address + 0 + 1 + + + OA1_1 + Interface address + 1 + 7 + + + OA1_8 + Interface address + 8 + 2 + + + OA1MODE + Own Address 1 10-bit mode + 10 + 1 + + + OA1EN + Own Address 1 enable + 15 + 1 + + + + + OAR2 + OAR2 + Own address register 2 + 0xC + 0x20 + read-write + 0x00000000 + + + OA2 + Interface address + 1 + 7 + + + OA2MSK + Own Address 2 masks + 8 + 3 + + + OA2EN + Own Address 2 enable + 15 + 1 + + + + + TIMINGR + TIMINGR + Timing register + 0x10 + 0x20 + read-write + 0x00000000 + + + SCLL + SCL low period (master + mode) + 0 + 8 + + + SCLH + SCL high period (master + mode) + 8 + 8 + + + SDADEL + Data hold time + 16 + 4 + + + SCLDEL + Data setup time + 20 + 4 + + + PRESC + Timing prescaler + 28 + 4 + + + + + TIMEOUTR + TIMEOUTR + Status register 1 + 0x14 + 0x20 + read-write + 0x00000000 + + + TIMEOUTA + Bus timeout A + 0 + 12 + + + TIDLE + Idle clock timeout + detection + 12 + 1 + + + TIMOUTEN + Clock timeout enable + 15 + 1 + + + TIMEOUTB + Bus timeout B + 16 + 12 + + + TEXTEN + Extended clock timeout + enable + 31 + 1 + + + + + ISR + ISR + Interrupt and Status register + 0x18 + 0x20 + 0x00000001 + + + ADDCODE + Address match code (Slave + mode) + 17 + 7 + read-only + + + DIR + Transfer direction (Slave + mode) + 16 + 1 + read-only + + + BUSY + Bus busy + 15 + 1 + read-only + + + ALERT + SMBus alert + 13 + 1 + read-only + + + TIMEOUT + Timeout or t_low detection + flag + 12 + 1 + read-only + + + PECERR + PEC Error in reception + 11 + 1 + read-only + + + OVR + Overrun/Underrun (slave + mode) + 10 + 1 + read-only + + + ARLO + Arbitration lost + 9 + 1 + read-only + + + BERR + Bus error + 8 + 1 + read-only + + + TCR + Transfer Complete Reload + 7 + 1 + read-only + + + TC + Transfer Complete (master + mode) + 6 + 1 + read-only + + + STOPF + Stop detection flag + 5 + 1 + read-only + + + NACKF + Not acknowledge received + flag + 4 + 1 + read-only + + + ADDR + Address matched (slave + mode) + 3 + 1 + read-only + + + RXNE + Receive data register not empty + (receivers) + 2 + 1 + read-only + + + TXIS + Transmit interrupt status + (transmitters) + 1 + 1 + read-write + + + TXE + Transmit data register empty + (transmitters) + 0 + 1 + read-write + + + + + ICR + ICR + Interrupt clear register + 0x1C + 0x20 + write-only + 0x00000000 + + + ALERTCF + Alert flag clear + 13 + 1 + + + TIMOUTCF + Timeout detection flag + clear + 12 + 1 + + + PECCF + PEC Error flag clear + 11 + 1 + + + OVRCF + Overrun/Underrun flag + clear + 10 + 1 + + + ARLOCF + Arbitration lost flag + clear + 9 + 1 + + + BERRCF + Bus error flag clear + 8 + 1 + + + STOPCF + Stop detection flag clear + 5 + 1 + + + NACKCF + Not Acknowledge flag clear + 4 + 1 + + + ADDRCF + Address Matched flag clear + 3 + 1 + + + + + PECR + PECR + PEC register + 0x20 + 0x20 + read-only + 0x00000000 + + + PEC + Packet error checking + register + 0 + 8 + + + + + RXDR + RXDR + Receive data register + 0x24 + 0x20 + read-only + 0x00000000 + + + RXDATA + 8-bit receive data + 0 + 8 + + + + + TXDR + TXDR + Transmit data register + 0x28 + 0x20 + read-write + 0x00000000 + + + TXDATA + 8-bit transmit data + 0 + 8 + + + + + + + I2C2 + 0x40005800 + + I2C2 + I2C2 global interrupt + 24 + + + + IWDG + Independent watchdog + IWDG + 0x40003000 + + 0x0 + 0x400 + registers + + + + KR + KR + Key register + 0x0 + 0x20 + write-only + 0x00000000 + + + KEY + Key value + 0 + 16 + + + + + PR + PR + Prescaler register + 0x4 + 0x20 + read-write + 0x00000000 + + + PR + Prescaler divider + 0 + 3 + + + + + RLR + RLR + Reload register + 0x8 + 0x20 + read-write + 0x00000FFF + + + RL + Watchdog counter reload + value + 0 + 12 + + + + + SR + SR + Status register + 0xC + 0x20 + read-only + 0x00000000 + + + PVU + Watchdog prescaler value + update + 0 + 1 + + + RVU + Watchdog counter reload value + update + 1 + 1 + + + WVU + Watchdog counter window value + update + 2 + 1 + + + + + WINR + WINR + Window register + 0x10 + 0x20 + read-write + 0x00000FFF + + + WIN + Watchdog counter window + value + 0 + 12 + + + + + + + WWDG + Window watchdog + WWDG + 0x40002C00 + + 0x0 + 0x400 + registers + + + WWDG + Window Watchdog interrupt + 0 + + + + CR + CR + Control register + 0x0 + 0x20 + read-write + 0x0000007F + + + WDGA + Activation bit + 7 + 1 + + + T + 7-bit counter + 0 + 7 + + + + + CFR + CFR + Configuration register + 0x4 + 0x20 + read-write + 0x0000007F + + + EWI + Early wakeup interrupt + 9 + 1 + + + WDGTB + Timer base + 7 + 2 + + + W + 7-bit window value + 0 + 7 + + + + + SR + SR + Status register + 0x8 + 0x20 + read-write + 0x00000000 + + + EWIF + Early wakeup interrupt + flag + 0 + 1 + + + + + + + TIM1 + Advanced-timers + TIM + 0x40012C00 + + 0x0 + 0x400 + registers + + + TIM1_BRK_UP_TRG_COM + TIM1 break, update, trigger and commutation + interrupt + 13 + + + TIM1_CC + TIM1 Capture Compare interrupt + 14 + + + + CR1 + CR1 + control register 1 + 0x0 + 0x20 + read-write + 0x0000 + + + CKD + Clock division + 8 + 2 + + + ARPE + Auto-reload preload enable + 7 + 1 + + + CMS + Center-aligned mode + selection + 5 + 2 + + + DIR + Direction + 4 + 1 + + + OPM + One-pulse mode + 3 + 1 + + + URS + Update request source + 2 + 1 + + + UDIS + Update disable + 1 + 1 + + + CEN + Counter enable + 0 + 1 + + + + + CR2 + CR2 + control register 2 + 0x4 + 0x20 + read-write + 0x0000 + + + OIS4 + Output Idle state 4 + 14 + 1 + + + OIS3N + Output Idle state 3 + 13 + 1 + + + OIS3 + Output Idle state 3 + 12 + 1 + + + OIS2N + Output Idle state 2 + 11 + 1 + + + OIS2 + Output Idle state 2 + 10 + 1 + + + OIS1N + Output Idle state 1 + 9 + 1 + + + OIS1 + Output Idle state 1 + 8 + 1 + + + TI1S + TI1 selection + 7 + 1 + + + MMS + Master mode selection + 4 + 3 + + + CCDS + Capture/compare DMA + selection + 3 + 1 + + + CCUS + Capture/compare control update + selection + 2 + 1 + + + CCPC + Capture/compare preloaded + control + 0 + 1 + + + + + SMCR + SMCR + slave mode control register + 0x8 + 0x20 + read-write + 0x0000 + + + ETP + External trigger polarity + 15 + 1 + + + ECE + External clock enable + 14 + 1 + + + ETPS + External trigger prescaler + 12 + 2 + + + ETF + External trigger filter + 8 + 4 + + + MSM + Master/Slave mode + 7 + 1 + + + TS + Trigger selection + 4 + 3 + + + SMS + Slave mode selection + 0 + 3 + + + + + DIER + DIER + DMA/Interrupt enable register + 0xC + 0x20 + read-write + 0x0000 + + + TDE + Trigger DMA request enable + 14 + 1 + + + COMDE + Reserved + 13 + 1 + + + CC4DE + Capture/Compare 4 DMA request + enable + 12 + 1 + + + CC3DE + Capture/Compare 3 DMA request + enable + 11 + 1 + + + CC2DE + Capture/Compare 2 DMA request + enable + 10 + 1 + + + CC1DE + Capture/Compare 1 DMA request + enable + 9 + 1 + + + UDE + Update DMA request enable + 8 + 1 + + + BIE + Break interrupt enable + 7 + 1 + + + TIE + Trigger interrupt enable + 6 + 1 + + + COMIE + COM interrupt enable + 5 + 1 + + + CC4IE + Capture/Compare 4 interrupt + enable + 4 + 1 + + + CC3IE + Capture/Compare 3 interrupt + enable + 3 + 1 + + + CC2IE + Capture/Compare 2 interrupt + enable + 2 + 1 + + + CC1IE + Capture/Compare 1 interrupt + enable + 1 + 1 + + + UIE + Update interrupt enable + 0 + 1 + + + + + SR + SR + status register + 0x10 + 0x20 + read-write + 0x0000 + + + CC4OF + Capture/Compare 4 overcapture + flag + 12 + 1 + + + CC3OF + Capture/Compare 3 overcapture + flag + 11 + 1 + + + CC2OF + Capture/compare 2 overcapture + flag + 10 + 1 + + + CC1OF + Capture/Compare 1 overcapture + flag + 9 + 1 + + + BIF + Break interrupt flag + 7 + 1 + + + TIF + Trigger interrupt flag + 6 + 1 + + + COMIF + COM interrupt flag + 5 + 1 + + + CC4IF + Capture/Compare 4 interrupt + flag + 4 + 1 + + + CC3IF + Capture/Compare 3 interrupt + flag + 3 + 1 + + + CC2IF + Capture/Compare 2 interrupt + flag + 2 + 1 + + + CC1IF + Capture/compare 1 interrupt + flag + 1 + 1 + + + UIF + Update interrupt flag + 0 + 1 + + + + + EGR + EGR + event generation register + 0x14 + 0x20 + write-only + 0x0000 + + + BG + Break generation + 7 + 1 + + + TG + Trigger generation + 6 + 1 + + + COMG + Capture/Compare control update + generation + 5 + 1 + + + CC4G + Capture/compare 4 + generation + 4 + 1 + + + CC3G + Capture/compare 3 + generation + 3 + 1 + + + CC2G + Capture/compare 2 + generation + 2 + 1 + + + CC1G + Capture/compare 1 + generation + 1 + 1 + + + UG + Update generation + 0 + 1 + + + + + CCMR1_Output + CCMR1_Output + capture/compare mode register (output + mode) + 0x18 + 0x20 + read-write + 0x00000000 + + + OC2CE + Output Compare 2 clear + enable + 15 + 1 + + + OC2M + Output Compare 2 mode + 12 + 3 + + + OC2PE + Output Compare 2 preload + enable + 11 + 1 + + + OC2FE + Output Compare 2 fast + enable + 10 + 1 + + + CC2S + Capture/Compare 2 + selection + 8 + 2 + + + OC1CE + Output Compare 1 clear + enable + 7 + 1 + + + OC1M + Output Compare 1 mode + 4 + 3 + + + OC1PE + Output Compare 1 preload + enable + 3 + 1 + + + OC1FE + Output Compare 1 fast + enable + 2 + 1 + + + CC1S + Capture/Compare 1 + selection + 0 + 2 + + + + + CCMR1_Input + CCMR1_Input + capture/compare mode register 1 (input + mode) + CCMR1_Output + 0x18 + 0x20 + read-write + 0x00000000 + + + IC2F + Input capture 2 filter + 12 + 4 + + + IC2PCS + Input capture 2 prescaler + 10 + 2 + + + CC2S + Capture/Compare 2 + selection + 8 + 2 + + + IC1F + Input capture 1 filter + 4 + 4 + + + IC1PCS + Input capture 1 prescaler + 2 + 2 + + + CC1S + Capture/Compare 1 + selection + 0 + 2 + + + + + CCMR2_Output + CCMR2_Output + capture/compare mode register (output + mode) + 0x1C + 0x20 + read-write + 0x00000000 + + + OC4CE + Output compare 4 clear + enable + 15 + 1 + + + OC4M + Output compare 4 mode + 12 + 3 + + + OC4PE + Output compare 4 preload + enable + 11 + 1 + + + OC4FE + Output compare 4 fast + enable + 10 + 1 + + + CC4S + Capture/Compare 4 + selection + 8 + 2 + + + OC3CE + Output compare 3 clear + enable + 7 + 1 + + + OC3M + Output compare 3 mode + 4 + 3 + + + OC3PE + Output compare 3 preload + enable + 3 + 1 + + + OC3FE + Output compare 3 fast + enable + 2 + 1 + + + CC3S + Capture/Compare 3 + selection + 0 + 2 + + + + + CCMR2_Input + CCMR2_Input + capture/compare mode register 2 (input + mode) + CCMR2_Output + 0x1C + 0x20 + read-write + 0x00000000 + + + IC4F + Input capture 4 filter + 12 + 4 + + + IC4PSC + Input capture 4 prescaler + 10 + 2 + + + CC4S + Capture/Compare 4 + selection + 8 + 2 + + + IC3F + Input capture 3 filter + 4 + 4 + + + IC3PSC + Input capture 3 prescaler + 2 + 2 + + + CC3S + Capture/compare 3 + selection + 0 + 2 + + + + + CCER + CCER + capture/compare enable + register + 0x20 + 0x20 + read-write + 0x0000 + + + CC4P + Capture/Compare 3 output + Polarity + 13 + 1 + + + CC4E + Capture/Compare 4 output + enable + 12 + 1 + + + CC3NP + Capture/Compare 3 output + Polarity + 11 + 1 + + + CC3NE + Capture/Compare 3 complementary output + enable + 10 + 1 + + + CC3P + Capture/Compare 3 output + Polarity + 9 + 1 + + + CC3E + Capture/Compare 3 output + enable + 8 + 1 + + + CC2NP + Capture/Compare 2 output + Polarity + 7 + 1 + + + CC2NE + Capture/Compare 2 complementary output + enable + 6 + 1 + + + CC2P + Capture/Compare 2 output + Polarity + 5 + 1 + + + CC2E + Capture/Compare 2 output + enable + 4 + 1 + + + CC1NP + Capture/Compare 1 output + Polarity + 3 + 1 + + + CC1NE + Capture/Compare 1 complementary output + enable + 2 + 1 + + + CC1P + Capture/Compare 1 output + Polarity + 1 + 1 + + + CC1E + Capture/Compare 1 output + enable + 0 + 1 + + + + + CNT + CNT + counter + 0x24 + 0x20 + read-write + 0x00000000 + + + CNT + counter value + 0 + 16 + + + + + PSC + PSC + prescaler + 0x28 + 0x20 + read-write + 0x0000 + + + PSC + Prescaler value + 0 + 16 + + + + + ARR + ARR + auto-reload register + 0x2C + 0x20 + read-write + 0x00000000 + + + ARR + Auto-reload value + 0 + 16 + + + + + RCR + RCR + repetition counter register + 0x30 + 0x20 + read-write + 0x0000 + + + REP + Repetition counter value + 0 + 8 + + + + + CCR1 + CCR1 + capture/compare register 1 + 0x34 + 0x20 + read-write + 0x00000000 + + + CCR1 + Capture/Compare 1 value + 0 + 16 + + + + + CCR2 + CCR2 + capture/compare register 2 + 0x38 + 0x20 + read-write + 0x00000000 + + + CCR2 + Capture/Compare 2 value + 0 + 16 + + + + + CCR3 + CCR3 + capture/compare register 3 + 0x3C + 0x20 + read-write + 0x00000000 + + + CCR3 + Capture/Compare 3 value + 0 + 16 + + + + + CCR4 + CCR4 + capture/compare register 4 + 0x40 + 0x20 + read-write + 0x00000000 + + + CCR4 + Capture/Compare 3 value + 0 + 16 + + + + + BDTR + BDTR + break and dead-time register + 0x44 + 0x20 + read-write + 0x0000 + + + MOE + Main output enable + 15 + 1 + + + AOE + Automatic output enable + 14 + 1 + + + BKP + Break polarity + 13 + 1 + + + BKE + Break enable + 12 + 1 + + + OSSR + Off-state selection for Run + mode + 11 + 1 + + + OSSI + Off-state selection for Idle + mode + 10 + 1 + + + LOCK + Lock configuration + 8 + 2 + + + DTG + Dead-time generator setup + 0 + 8 + + + + + DCR + DCR + DMA control register + 0x48 + 0x20 + read-write + 0x0000 + + + DBL + DMA burst length + 8 + 5 + + + DBA + DMA base address + 0 + 5 + + + + + DMAR + DMAR + DMA address for full transfer + 0x4C + 0x20 + read-write + 0x0000 + + + DMAB + DMA register for burst + accesses + 0 + 16 + + + + + + + TIM2 + General-purpose-timers + TIM + 0x40000000 + + 0x0 + 0x400 + registers + + + TIM2 + TIM2 global interrupt + 15 + + + + CR1 + CR1 + control register 1 + 0x0 + 0x20 + read-write + 0x0000 + + + CKD + Clock division + 8 + 2 + + + ARPE + Auto-reload preload enable + 7 + 1 + + + CMS + Center-aligned mode + selection + 5 + 2 + + + DIR + Direction + 4 + 1 + + + OPM + One-pulse mode + 3 + 1 + + + URS + Update request source + 2 + 1 + + + UDIS + Update disable + 1 + 1 + + + CEN + Counter enable + 0 + 1 + + + + + CR2 + CR2 + control register 2 + 0x4 + 0x20 + read-write + 0x0000 + + + TI1S + TI1 selection + 7 + 1 + + + MMS + Master mode selection + 4 + 3 + + + CCDS + Capture/compare DMA + selection + 3 + 1 + + + + + SMCR + SMCR + slave mode control register + 0x8 + 0x20 + read-write + 0x0000 + + + ETP + External trigger polarity + 15 + 1 + + + ECE + External clock enable + 14 + 1 + + + ETPS + External trigger prescaler + 12 + 2 + + + ETF + External trigger filter + 8 + 4 + + + MSM + Master/Slave mode + 7 + 1 + + + TS + Trigger selection + 4 + 3 + + + SMS + Slave mode selection + 0 + 3 + + + + + DIER + DIER + DMA/Interrupt enable register + 0xC + 0x20 + read-write + 0x0000 + + + TDE + Trigger DMA request enable + 14 + 1 + + + COMDE + Reserved + 13 + 1 + + + CC4DE + Capture/Compare 4 DMA request + enable + 12 + 1 + + + CC3DE + Capture/Compare 3 DMA request + enable + 11 + 1 + + + CC2DE + Capture/Compare 2 DMA request + enable + 10 + 1 + + + CC1DE + Capture/Compare 1 DMA request + enable + 9 + 1 + + + UDE + Update DMA request enable + 8 + 1 + + + TIE + Trigger interrupt enable + 6 + 1 + + + CC4IE + Capture/Compare 4 interrupt + enable + 4 + 1 + + + CC3IE + Capture/Compare 3 interrupt + enable + 3 + 1 + + + CC2IE + Capture/Compare 2 interrupt + enable + 2 + 1 + + + CC1IE + Capture/Compare 1 interrupt + enable + 1 + 1 + + + UIE + Update interrupt enable + 0 + 1 + + + + + SR + SR + status register + 0x10 + 0x20 + read-write + 0x0000 + + + CC4OF + Capture/Compare 4 overcapture + flag + 12 + 1 + + + CC3OF + Capture/Compare 3 overcapture + flag + 11 + 1 + + + CC2OF + Capture/compare 2 overcapture + flag + 10 + 1 + + + CC1OF + Capture/Compare 1 overcapture + flag + 9 + 1 + + + TIF + Trigger interrupt flag + 6 + 1 + + + CC4IF + Capture/Compare 4 interrupt + flag + 4 + 1 + + + CC3IF + Capture/Compare 3 interrupt + flag + 3 + 1 + + + CC2IF + Capture/Compare 2 interrupt + flag + 2 + 1 + + + CC1IF + Capture/compare 1 interrupt + flag + 1 + 1 + + + UIF + Update interrupt flag + 0 + 1 + + + + + EGR + EGR + event generation register + 0x14 + 0x20 + write-only + 0x0000 + + + TG + Trigger generation + 6 + 1 + + + CC4G + Capture/compare 4 + generation + 4 + 1 + + + CC3G + Capture/compare 3 + generation + 3 + 1 + + + CC2G + Capture/compare 2 + generation + 2 + 1 + + + CC1G + Capture/compare 1 + generation + 1 + 1 + + + UG + Update generation + 0 + 1 + + + + + CCMR1_Output + CCMR1_Output + capture/compare mode register 1 (output + mode) + 0x18 + 0x20 + read-write + 0x00000000 + + + OC2CE + Output compare 2 clear + enable + 15 + 1 + + + OC2M + Output compare 2 mode + 12 + 3 + + + OC2PE + Output compare 2 preload + enable + 11 + 1 + + + OC2FE + Output compare 2 fast + enable + 10 + 1 + + + CC2S + Capture/Compare 2 + selection + 8 + 2 + + + OC1CE + Output compare 1 clear + enable + 7 + 1 + + + OC1M + Output compare 1 mode + 4 + 3 + + + OC1PE + Output compare 1 preload + enable + 3 + 1 + + + OC1FE + Output compare 1 fast + enable + 2 + 1 + + + CC1S + Capture/Compare 1 + selection + 0 + 2 + + + + + CCMR1_Input + CCMR1_Input + capture/compare mode register 1 (input + mode) + CCMR1_Output + 0x18 + 0x20 + read-write + 0x00000000 + + + IC2F + Input capture 2 filter + 12 + 4 + + + IC2PSC + Input capture 2 prescaler + 10 + 2 + + + CC2S + Capture/compare 2 + selection + 8 + 2 + + + IC1F + Input capture 1 filter + 4 + 4 + + + IC1PSC + Input capture 1 prescaler + 2 + 2 + + + CC1S + Capture/Compare 1 + selection + 0 + 2 + + + + + CCMR2_Output + CCMR2_Output + capture/compare mode register 2 (output + mode) + 0x1C + 0x20 + read-write + 0x00000000 + + + OC4CE + Output compare 4 clear + enable + 15 + 1 + + + OC4M + Output compare 4 mode + 12 + 3 + + + OC4PE + Output compare 4 preload + enable + 11 + 1 + + + OC4FE + Output compare 4 fast + enable + 10 + 1 + + + CC4S + Capture/Compare 4 + selection + 8 + 2 + + + OC3CE + Output compare 3 clear + enable + 7 + 1 + + + OC3M + Output compare 3 mode + 4 + 3 + + + OC3PE + Output compare 3 preload + enable + 3 + 1 + + + OC3FE + Output compare 3 fast + enable + 2 + 1 + + + CC3S + Capture/Compare 3 + selection + 0 + 2 + + + + + CCMR2_Input + CCMR2_Input + capture/compare mode register 2 (input + mode) + CCMR2_Output + 0x1C + 0x20 + read-write + 0x00000000 + + + IC4F + Input capture 4 filter + 12 + 4 + + + IC4PSC + Input capture 4 prescaler + 10 + 2 + + + CC4S + Capture/Compare 4 + selection + 8 + 2 + + + IC3F + Input capture 3 filter + 4 + 4 + + + IC3PSC + Input capture 3 prescaler + 2 + 2 + + + CC3S + Capture/Compare 3 + selection + 0 + 2 + + + + + CCER + CCER + capture/compare enable + register + 0x20 + 0x20 + read-write + 0x0000 + + + CC4NP + Capture/Compare 4 output + Polarity + 15 + 1 + + + CC4P + Capture/Compare 3 output + Polarity + 13 + 1 + + + CC4E + Capture/Compare 4 output + enable + 12 + 1 + + + CC3NP + Capture/Compare 3 output + Polarity + 11 + 1 + + + CC3P + Capture/Compare 3 output + Polarity + 9 + 1 + + + CC3E + Capture/Compare 3 output + enable + 8 + 1 + + + CC2NP + Capture/Compare 2 output + Polarity + 7 + 1 + + + CC2P + Capture/Compare 2 output + Polarity + 5 + 1 + + + CC2E + Capture/Compare 2 output + enable + 4 + 1 + + + CC1NP + Capture/Compare 1 output + Polarity + 3 + 1 + + + CC1P + Capture/Compare 1 output + Polarity + 1 + 1 + + + CC1E + Capture/Compare 1 output + enable + 0 + 1 + + + + + CNT + CNT + counter + 0x24 + 0x20 + read-write + 0x00000000 + + + CNT_H + High counter value (TIM2 + only) + 16 + 16 + + + CNT_L + Low counter value + 0 + 16 + + + + + PSC + PSC + prescaler + 0x28 + 0x20 + read-write + 0x0000 + + + PSC + Prescaler value + 0 + 16 + + + + + ARR + ARR + auto-reload register + 0x2C + 0x20 + read-write + 0x00000000 + + + ARR_H + High Auto-reload value (TIM2 + only) + 16 + 16 + + + ARR_L + Low Auto-reload value + 0 + 16 + + + + + CCR1 + CCR1 + capture/compare register 1 + 0x34 + 0x20 + read-write + 0x00000000 + + + CCR1_H + High Capture/Compare 1 value (TIM2 + only) + 16 + 16 + + + CCR1_L + Low Capture/Compare 1 + value + 0 + 16 + + + + + CCR2 + CCR2 + capture/compare register 2 + 0x38 + 0x20 + read-write + 0x00000000 + + + CCR2_H + High Capture/Compare 2 value (TIM2 + only) + 16 + 16 + + + CCR2_L + Low Capture/Compare 2 + value + 0 + 16 + + + + + CCR3 + CCR3 + capture/compare register 3 + 0x3C + 0x20 + read-write + 0x00000000 + + + CCR3_H + High Capture/Compare value (TIM2 + only) + 16 + 16 + + + CCR3_L + Low Capture/Compare value + 0 + 16 + + + + + CCR4 + CCR4 + capture/compare register 4 + 0x40 + 0x20 + read-write + 0x00000000 + + + CCR4_H + High Capture/Compare value (TIM2 + only) + 16 + 16 + + + CCR4_L + Low Capture/Compare value + 0 + 16 + + + + + DCR + DCR + DMA control register + 0x48 + 0x20 + read-write + 0x0000 + + + DBL + DMA burst length + 8 + 5 + + + DBA + DMA base address + 0 + 5 + + + + + DMAR + DMAR + DMA address for full transfer + 0x4C + 0x20 + read-write + 0x0000 + + + DMAR + DMA register for burst + accesses + 0 + 16 + + + + + + + TIM3 + 0x40000400 + + TIM3 + TIM3 global interrupt + 16 + + + + TIM14 + General-purpose-timers + TIM + 0x40002000 + + 0x0 + 0x400 + registers + + + TIM14 + TIM14 global interrupt + 19 + + + + CR1 + CR1 + control register 1 + 0x0 + 0x20 + read-write + 0x0000 + + + CKD + Clock division + 8 + 2 + + + ARPE + Auto-reload preload enable + 7 + 1 + + + URS + Update request source + 2 + 1 + + + UDIS + Update disable + 1 + 1 + + + CEN + Counter enable + 0 + 1 + + + + + DIER + DIER + DMA/Interrupt enable register + 0xC + 0x20 + read-write + 0x0000 + + + CC1IE + Capture/Compare 1 interrupt + enable + 1 + 1 + + + UIE + Update interrupt enable + 0 + 1 + + + + + SR + SR + status register + 0x10 + 0x20 + read-write + 0x0000 + + + CC1OF + Capture/Compare 1 overcapture + flag + 9 + 1 + + + CC1IF + Capture/compare 1 interrupt + flag + 1 + 1 + + + UIF + Update interrupt flag + 0 + 1 + + + + + EGR + EGR + event generation register + 0x14 + 0x20 + write-only + 0x0000 + + + CC1G + Capture/compare 1 + generation + 1 + 1 + + + UG + Update generation + 0 + 1 + + + + + CCMR1_Output + CCMR1_Output + capture/compare mode register (output + mode) + 0x18 + 0x20 + read-write + 0x00000000 + + + CC1S + Capture/Compare 1 + selection + 0 + 2 + + + OC1FE + Output compare 1 fast + enable + 2 + 1 + + + OC1PE + Output Compare 1 preload + enable + 3 + 1 + + + OC1M + Output Compare 1 mode + 4 + 3 + + + + + CCMR1_Input + CCMR1_Input + capture/compare mode register (input + mode) + CCMR1_Output + 0x18 + 0x20 + read-write + 0x00000000 + + + IC1F + Input capture 1 filter + 4 + 4 + + + IC1PSC + Input capture 1 prescaler + 2 + 2 + + + CC1S + Capture/Compare 1 + selection + 0 + 2 + + + + + CCER + CCER + capture/compare enable + register + 0x20 + 0x20 + read-write + 0x0000 + + + CC1NP + Capture/Compare 1 output + Polarity + 3 + 1 + + + CC1P + Capture/Compare 1 output + Polarity + 1 + 1 + + + CC1E + Capture/Compare 1 output + enable + 0 + 1 + + + + + CNT + CNT + counter + 0x24 + 0x20 + read-write + 0x00000000 + + + CNT + counter value + 0 + 16 + + + + + PSC + PSC + prescaler + 0x28 + 0x20 + read-write + 0x0000 + + + PSC + Prescaler value + 0 + 16 + + + + + ARR + ARR + auto-reload register + 0x2C + 0x20 + read-write + 0x00000000 + + + ARR + Auto-reload value + 0 + 16 + + + + + CCR1 + CCR1 + capture/compare register 1 + 0x34 + 0x20 + read-write + 0x00000000 + + + CCR1 + Capture/Compare 1 value + 0 + 16 + + + + + OR + OR + option register + 0x50 + 0x20 + read-write + 0x00000000 + + + RMP + Timer input 1 remap + 0 + 2 + + + + + + + TIM6 + Basic-timers + TIM + 0x40001000 + + 0x0 + 0x400 + registers + + + TIM6_DAC + TIM6 global interrupt and DAC underrun + interrupt + 17 + + + + CR1 + CR1 + control register 1 + 0x0 + 0x20 + read-write + 0x0000 + + + ARPE + Auto-reload preload enable + 7 + 1 + + + OPM + One-pulse mode + 3 + 1 + + + URS + Update request source + 2 + 1 + + + UDIS + Update disable + 1 + 1 + + + CEN + Counter enable + 0 + 1 + + + + + CR2 + CR2 + control register 2 + 0x4 + 0x20 + read-write + 0x0000 + + + MMS + Master mode selection + 4 + 3 + + + + + DIER + DIER + DMA/Interrupt enable register + 0xC + 0x20 + read-write + 0x0000 + + + UDE + Update DMA request enable + 8 + 1 + + + UIE + Update interrupt enable + 0 + 1 + + + + + SR + SR + status register + 0x10 + 0x20 + read-write + 0x0000 + + + UIF + Update interrupt flag + 0 + 1 + + + + + EGR + EGR + event generation register + 0x14 + 0x20 + write-only + 0x0000 + + + UG + Update generation + 0 + 1 + + + + + CNT + CNT + counter + 0x24 + 0x20 + read-write + 0x00000000 + + + CNT + Low counter value + 0 + 16 + + + + + PSC + PSC + prescaler + 0x28 + 0x20 + read-write + 0x0000 + + + PSC + Prescaler value + 0 + 16 + + + + + ARR + ARR + auto-reload register + 0x2C + 0x20 + read-write + 0x00000000 + + + ARR + Low Auto-reload value + 0 + 16 + + + + + + + TIM7 + 0x40001400 + + TIM7 + TIM7 global interrupt + 18 + + + + EXTI + External interrupt/event + controller + EXTI + 0x40010400 + + 0x0 + 0x400 + registers + + + PVD + PVD and VDDIO2 supply comparator + interrupt + 1 + + + EXTI0_1 + EXTI Line[1:0] interrupts + 5 + + + EXTI2_3 + EXTI Line[3:2] interrupts + 6 + + + EXTI4_15 + EXTI Line15 and EXTI4 interrupts + 7 + + + + IMR + IMR + Interrupt mask register + (EXTI_IMR) + 0x0 + 0x20 + read-write + 0x0F940000 + + + MR0 + Interrupt Mask on line 0 + 0 + 1 + + + MR1 + Interrupt Mask on line 1 + 1 + 1 + + + MR2 + Interrupt Mask on line 2 + 2 + 1 + + + MR3 + Interrupt Mask on line 3 + 3 + 1 + + + MR4 + Interrupt Mask on line 4 + 4 + 1 + + + MR5 + Interrupt Mask on line 5 + 5 + 1 + + + MR6 + Interrupt Mask on line 6 + 6 + 1 + + + MR7 + Interrupt Mask on line 7 + 7 + 1 + + + MR8 + Interrupt Mask on line 8 + 8 + 1 + + + MR9 + Interrupt Mask on line 9 + 9 + 1 + + + MR10 + Interrupt Mask on line 10 + 10 + 1 + + + MR11 + Interrupt Mask on line 11 + 11 + 1 + + + MR12 + Interrupt Mask on line 12 + 12 + 1 + + + MR13 + Interrupt Mask on line 13 + 13 + 1 + + + MR14 + Interrupt Mask on line 14 + 14 + 1 + + + MR15 + Interrupt Mask on line 15 + 15 + 1 + + + MR16 + Interrupt Mask on line 16 + 16 + 1 + + + MR17 + Interrupt Mask on line 17 + 17 + 1 + + + MR18 + Interrupt Mask on line 18 + 18 + 1 + + + MR19 + Interrupt Mask on line 19 + 19 + 1 + + + MR20 + Interrupt Mask on line 20 + 20 + 1 + + + MR21 + Interrupt Mask on line 21 + 21 + 1 + + + MR22 + Interrupt Mask on line 22 + 22 + 1 + + + MR23 + Interrupt Mask on line 23 + 23 + 1 + + + MR24 + Interrupt Mask on line 24 + 24 + 1 + + + MR25 + Interrupt Mask on line 25 + 25 + 1 + + + MR26 + Interrupt Mask on line 26 + 26 + 1 + + + MR27 + Interrupt Mask on line 27 + 27 + 1 + + + + + EMR + EMR + Event mask register (EXTI_EMR) + 0x4 + 0x20 + read-write + 0x00000000 + + + MR0 + Event Mask on line 0 + 0 + 1 + + + MR1 + Event Mask on line 1 + 1 + 1 + + + MR2 + Event Mask on line 2 + 2 + 1 + + + MR3 + Event Mask on line 3 + 3 + 1 + + + MR4 + Event Mask on line 4 + 4 + 1 + + + MR5 + Event Mask on line 5 + 5 + 1 + + + MR6 + Event Mask on line 6 + 6 + 1 + + + MR7 + Event Mask on line 7 + 7 + 1 + + + MR8 + Event Mask on line 8 + 8 + 1 + + + MR9 + Event Mask on line 9 + 9 + 1 + + + MR10 + Event Mask on line 10 + 10 + 1 + + + MR11 + Event Mask on line 11 + 11 + 1 + + + MR12 + Event Mask on line 12 + 12 + 1 + + + MR13 + Event Mask on line 13 + 13 + 1 + + + MR14 + Event Mask on line 14 + 14 + 1 + + + MR15 + Event Mask on line 15 + 15 + 1 + + + MR16 + Event Mask on line 16 + 16 + 1 + + + MR17 + Event Mask on line 17 + 17 + 1 + + + MR18 + Event Mask on line 18 + 18 + 1 + + + MR19 + Event Mask on line 19 + 19 + 1 + + + MR20 + Event Mask on line 20 + 20 + 1 + + + MR21 + Event Mask on line 21 + 21 + 1 + + + MR22 + Event Mask on line 22 + 22 + 1 + + + MR23 + Event Mask on line 23 + 23 + 1 + + + MR24 + Event Mask on line 24 + 24 + 1 + + + MR25 + Event Mask on line 25 + 25 + 1 + + + MR26 + Event Mask on line 26 + 26 + 1 + + + MR27 + Event Mask on line 27 + 27 + 1 + + + + + RTSR + RTSR + Rising Trigger selection register + (EXTI_RTSR) + 0x8 + 0x20 + read-write + 0x00000000 + + + TR0 + Rising trigger event configuration of + line 0 + 0 + 1 + + + TR1 + Rising trigger event configuration of + line 1 + 1 + 1 + + + TR2 + Rising trigger event configuration of + line 2 + 2 + 1 + + + TR3 + Rising trigger event configuration of + line 3 + 3 + 1 + + + TR4 + Rising trigger event configuration of + line 4 + 4 + 1 + + + TR5 + Rising trigger event configuration of + line 5 + 5 + 1 + + + TR6 + Rising trigger event configuration of + line 6 + 6 + 1 + + + TR7 + Rising trigger event configuration of + line 7 + 7 + 1 + + + TR8 + Rising trigger event configuration of + line 8 + 8 + 1 + + + TR9 + Rising trigger event configuration of + line 9 + 9 + 1 + + + TR10 + Rising trigger event configuration of + line 10 + 10 + 1 + + + TR11 + Rising trigger event configuration of + line 11 + 11 + 1 + + + TR12 + Rising trigger event configuration of + line 12 + 12 + 1 + + + TR13 + Rising trigger event configuration of + line 13 + 13 + 1 + + + TR14 + Rising trigger event configuration of + line 14 + 14 + 1 + + + TR15 + Rising trigger event configuration of + line 15 + 15 + 1 + + + TR16 + Rising trigger event configuration of + line 16 + 16 + 1 + + + TR17 + Rising trigger event configuration of + line 17 + 17 + 1 + + + TR19 + Rising trigger event configuration of + line 19 + 19 + 1 + + + + + FTSR + FTSR + Falling Trigger selection register + (EXTI_FTSR) + 0xC + 0x20 + read-write + 0x00000000 + + + TR0 + Falling trigger event configuration of + line 0 + 0 + 1 + + + TR1 + Falling trigger event configuration of + line 1 + 1 + 1 + + + TR2 + Falling trigger event configuration of + line 2 + 2 + 1 + + + TR3 + Falling trigger event configuration of + line 3 + 3 + 1 + + + TR4 + Falling trigger event configuration of + line 4 + 4 + 1 + + + TR5 + Falling trigger event configuration of + line 5 + 5 + 1 + + + TR6 + Falling trigger event configuration of + line 6 + 6 + 1 + + + TR7 + Falling trigger event configuration of + line 7 + 7 + 1 + + + TR8 + Falling trigger event configuration of + line 8 + 8 + 1 + + + TR9 + Falling trigger event configuration of + line 9 + 9 + 1 + + + TR10 + Falling trigger event configuration of + line 10 + 10 + 1 + + + TR11 + Falling trigger event configuration of + line 11 + 11 + 1 + + + TR12 + Falling trigger event configuration of + line 12 + 12 + 1 + + + TR13 + Falling trigger event configuration of + line 13 + 13 + 1 + + + TR14 + Falling trigger event configuration of + line 14 + 14 + 1 + + + TR15 + Falling trigger event configuration of + line 15 + 15 + 1 + + + TR16 + Falling trigger event configuration of + line 16 + 16 + 1 + + + TR17 + Falling trigger event configuration of + line 17 + 17 + 1 + + + TR19 + Falling trigger event configuration of + line 19 + 19 + 1 + + + + + SWIER + SWIER + Software interrupt event register + (EXTI_SWIER) + 0x10 + 0x20 + read-write + 0x00000000 + + + SWIER0 + Software Interrupt on line + 0 + 0 + 1 + + + SWIER1 + Software Interrupt on line + 1 + 1 + 1 + + + SWIER2 + Software Interrupt on line + 2 + 2 + 1 + + + SWIER3 + Software Interrupt on line + 3 + 3 + 1 + + + SWIER4 + Software Interrupt on line + 4 + 4 + 1 + + + SWIER5 + Software Interrupt on line + 5 + 5 + 1 + + + SWIER6 + Software Interrupt on line + 6 + 6 + 1 + + + SWIER7 + Software Interrupt on line + 7 + 7 + 1 + + + SWIER8 + Software Interrupt on line + 8 + 8 + 1 + + + SWIER9 + Software Interrupt on line + 9 + 9 + 1 + + + SWIER10 + Software Interrupt on line + 10 + 10 + 1 + + + SWIER11 + Software Interrupt on line + 11 + 11 + 1 + + + SWIER12 + Software Interrupt on line + 12 + 12 + 1 + + + SWIER13 + Software Interrupt on line + 13 + 13 + 1 + + + SWIER14 + Software Interrupt on line + 14 + 14 + 1 + + + SWIER15 + Software Interrupt on line + 15 + 15 + 1 + + + SWIER16 + Software Interrupt on line + 16 + 16 + 1 + + + SWIER17 + Software Interrupt on line + 17 + 17 + 1 + + + SWIER19 + Software Interrupt on line + 19 + 19 + 1 + + + + + PR + PR + Pending register (EXTI_PR) + 0x14 + 0x20 + read-write + 0x00000000 + + + PR0 + Pending bit 0 + 0 + 1 + + + PR1 + Pending bit 1 + 1 + 1 + + + PR2 + Pending bit 2 + 2 + 1 + + + PR3 + Pending bit 3 + 3 + 1 + + + PR4 + Pending bit 4 + 4 + 1 + + + PR5 + Pending bit 5 + 5 + 1 + + + PR6 + Pending bit 6 + 6 + 1 + + + PR7 + Pending bit 7 + 7 + 1 + + + PR8 + Pending bit 8 + 8 + 1 + + + PR9 + Pending bit 9 + 9 + 1 + + + PR10 + Pending bit 10 + 10 + 1 + + + PR11 + Pending bit 11 + 11 + 1 + + + PR12 + Pending bit 12 + 12 + 1 + + + PR13 + Pending bit 13 + 13 + 1 + + + PR14 + Pending bit 14 + 14 + 1 + + + PR15 + Pending bit 15 + 15 + 1 + + + PR16 + Pending bit 16 + 16 + 1 + + + PR17 + Pending bit 17 + 17 + 1 + + + PR19 + Pending bit 19 + 19 + 1 + + + + + + + NVIC + Nested Vectored Interrupt + Controller + NVIC + 0xE000E100 + + 0x0 + 0x33D + registers + + + + ISER + ISER + Interrupt Set Enable Register + 0x0 + 0x20 + read-write + 0x00000000 + + + SETENA + SETENA + 0 + 32 + + + + + ICER + ICER + Interrupt Clear Enable + Register + 0x80 + 0x20 + read-write + 0x00000000 + + + CLRENA + CLRENA + 0 + 32 + + + + + ISPR + ISPR + Interrupt Set-Pending Register + 0x100 + 0x20 + read-write + 0x00000000 + + + SETPEND + SETPEND + 0 + 32 + + + + + ICPR + ICPR + Interrupt Clear-Pending + Register + 0x180 + 0x20 + read-write + 0x00000000 + + + CLRPEND + CLRPEND + 0 + 32 + + + + + IPR0 + IPR0 + Interrupt Priority Register 0 + 0x300 + 0x20 + read-write + 0x00000000 + + + PRI_00 + PRI_00 + 6 + 2 + + + PRI_01 + PRI_01 + 14 + 2 + + + PRI_02 + PRI_02 + 22 + 2 + + + PRI_03 + PRI_03 + 30 + 2 + + + + + IPR1 + IPR1 + Interrupt Priority Register 1 + 0x304 + 0x20 + read-write + 0x00000000 + + + PRI_40 + PRI_40 + 6 + 2 + + + PRI_41 + PRI_41 + 14 + 2 + + + PRI_42 + PRI_42 + 22 + 2 + + + PRI_43 + PRI_43 + 30 + 2 + + + + + IPR2 + IPR2 + Interrupt Priority Register 2 + 0x308 + 0x20 + read-write + 0x00000000 + + + PRI_80 + PRI_80 + 6 + 2 + + + PRI_81 + PRI_81 + 14 + 2 + + + PRI_82 + PRI_82 + 22 + 2 + + + PRI_83 + PRI_83 + 30 + 2 + + + + + IPR3 + IPR3 + Interrupt Priority Register 3 + 0x30C + 0x20 + read-write + 0x00000000 + + + PRI_120 + PRI_120 + 6 + 2 + + + PRI_121 + PRI_121 + 14 + 2 + + + PRI_122 + PRI_122 + 22 + 2 + + + PRI_123 + PRI_123 + 30 + 2 + + + + + IPR4 + IPR4 + Interrupt Priority Register 4 + 0x310 + 0x20 + read-write + 0x00000000 + + + PRI_160 + PRI_160 + 6 + 2 + + + PRI_161 + PRI_161 + 14 + 2 + + + PRI_162 + PRI_162 + 22 + 2 + + + PRI_163 + PRI_163 + 30 + 2 + + + + + IPR5 + IPR5 + Interrupt Priority Register 5 + 0x314 + 0x20 + read-write + 0x00000000 + + + PRI_200 + PRI_200 + 6 + 2 + + + PRI_201 + PRI_201 + 14 + 2 + + + PRI_202 + PRI_202 + 22 + 2 + + + PRI_203 + PRI_203 + 30 + 2 + + + + + IPR6 + IPR6 + Interrupt Priority Register 6 + 0x318 + 0x20 + read-write + 0x00000000 + + + PRI_240 + PRI_240 + 6 + 2 + + + PRI_241 + PRI_241 + 14 + 2 + + + PRI_242 + PRI_242 + 22 + 2 + + + PRI_243 + PRI_243 + 30 + 2 + + + + + IPR7 + IPR7 + Interrupt Priority Register 7 + 0x31C + 0x20 + read-write + 0x00000000 + + + PRI_280 + PRI_280 + 6 + 2 + + + PRI_281 + PRI_281 + 14 + 2 + + + PRI_282 + PRI_282 + 22 + 2 + + + PRI_283 + PRI_283 + 30 + 2 + + + + + + + DMA + DMA controller + DMA + 0x40020000 + + 0x0 + 0x400 + registers + + + DMA_CH1 + DMA channel 1 interrupt + 9 + + + DMA_CH2_3 + DMA channel 2 and 3 interrupts + 10 + + + DMA_CH4_5_6_7 + DMA channel 4, 5, 6 and 7 + interrupts + 11 + + + + ISR + ISR + DMA interrupt status register + (DMA_ISR) + 0x0 + 0x20 + read-only + 0x00000000 + + + GIF1 + Channel 1 Global interrupt + flag + 0 + 1 + + + TCIF1 + Channel 1 Transfer Complete + flag + 1 + 1 + + + HTIF1 + Channel 1 Half Transfer Complete + flag + 2 + 1 + + + TEIF1 + Channel 1 Transfer Error + flag + 3 + 1 + + + GIF2 + Channel 2 Global interrupt + flag + 4 + 1 + + + TCIF2 + Channel 2 Transfer Complete + flag + 5 + 1 + + + HTIF2 + Channel 2 Half Transfer Complete + flag + 6 + 1 + + + TEIF2 + Channel 2 Transfer Error + flag + 7 + 1 + + + GIF3 + Channel 3 Global interrupt + flag + 8 + 1 + + + TCIF3 + Channel 3 Transfer Complete + flag + 9 + 1 + + + HTIF3 + Channel 3 Half Transfer Complete + flag + 10 + 1 + + + TEIF3 + Channel 3 Transfer Error + flag + 11 + 1 + + + GIF4 + Channel 4 Global interrupt + flag + 12 + 1 + + + TCIF4 + Channel 4 Transfer Complete + flag + 13 + 1 + + + HTIF4 + Channel 4 Half Transfer Complete + flag + 14 + 1 + + + TEIF4 + Channel 4 Transfer Error + flag + 15 + 1 + + + GIF5 + Channel 5 Global interrupt + flag + 16 + 1 + + + TCIF5 + Channel 5 Transfer Complete + flag + 17 + 1 + + + HTIF5 + Channel 5 Half Transfer Complete + flag + 18 + 1 + + + TEIF5 + Channel 5 Transfer Error + flag + 19 + 1 + + + GIF6 + Channel 6 Global interrupt + flag + 20 + 1 + + + TCIF6 + Channel 6 Transfer Complete + flag + 21 + 1 + + + HTIF6 + Channel 6 Half Transfer Complete + flag + 22 + 1 + + + TEIF6 + Channel 6 Transfer Error + flag + 23 + 1 + + + GIF7 + Channel 7 Global interrupt + flag + 24 + 1 + + + TCIF7 + Channel 7 Transfer Complete + flag + 25 + 1 + + + HTIF7 + Channel 7 Half Transfer Complete + flag + 26 + 1 + + + TEIF7 + Channel 7 Transfer Error + flag + 27 + 1 + + + + + IFCR + IFCR + DMA interrupt flag clear register + (DMA_IFCR) + 0x4 + 0x20 + write-only + 0x00000000 + + + CGIF1 + Channel 1 Global interrupt + clear + 0 + 1 + + + CTCIF1 + Channel 1 Transfer Complete + clear + 1 + 1 + + + CHTIF1 + Channel 1 Half Transfer + clear + 2 + 1 + + + CTEIF1 + Channel 1 Transfer Error + clear + 3 + 1 + + + CGIF2 + Channel 2 Global interrupt + clear + 4 + 1 + + + CTCIF2 + Channel 2 Transfer Complete + clear + 5 + 1 + + + CHTIF2 + Channel 2 Half Transfer + clear + 6 + 1 + + + CTEIF2 + Channel 2 Transfer Error + clear + 7 + 1 + + + CGIF3 + Channel 3 Global interrupt + clear + 8 + 1 + + + CTCIF3 + Channel 3 Transfer Complete + clear + 9 + 1 + + + CHTIF3 + Channel 3 Half Transfer + clear + 10 + 1 + + + CTEIF3 + Channel 3 Transfer Error + clear + 11 + 1 + + + CGIF4 + Channel 4 Global interrupt + clear + 12 + 1 + + + CTCIF4 + Channel 4 Transfer Complete + clear + 13 + 1 + + + CHTIF4 + Channel 4 Half Transfer + clear + 14 + 1 + + + CTEIF4 + Channel 4 Transfer Error + clear + 15 + 1 + + + CGIF5 + Channel 5 Global interrupt + clear + 16 + 1 + + + CTCIF5 + Channel 5 Transfer Complete + clear + 17 + 1 + + + CHTIF5 + Channel 5 Half Transfer + clear + 18 + 1 + + + CTEIF5 + Channel 5 Transfer Error + clear + 19 + 1 + + + CGIF6 + Channel 6 Global interrupt + clear + 20 + 1 + + + CTCIF6 + Channel 6 Transfer Complete + clear + 21 + 1 + + + CHTIF6 + Channel 6 Half Transfer + clear + 22 + 1 + + + CTEIF6 + Channel 6 Transfer Error + clear + 23 + 1 + + + CGIF7 + Channel 7 Global interrupt + clear + 24 + 1 + + + CTCIF7 + Channel 7 Transfer Complete + clear + 25 + 1 + + + CHTIF7 + Channel 7 Half Transfer + clear + 26 + 1 + + + CTEIF7 + Channel 7 Transfer Error + clear + 27 + 1 + + + + + CCR1 + CCR1 + DMA channel configuration register + (DMA_CCR) + 0x8 + 0x20 + read-write + 0x00000000 + + + EN + Channel enable + 0 + 1 + + + TCIE + Transfer complete interrupt + enable + 1 + 1 + + + HTIE + Half Transfer interrupt + enable + 2 + 1 + + + TEIE + Transfer error interrupt + enable + 3 + 1 + + + DIR + Data transfer direction + 4 + 1 + + + CIRC + Circular mode + 5 + 1 + + + PINC + Peripheral increment mode + 6 + 1 + + + MINC + Memory increment mode + 7 + 1 + + + PSIZE + Peripheral size + 8 + 2 + + + MSIZE + Memory size + 10 + 2 + + + PL + Channel Priority level + 12 + 2 + + + MEM2MEM + Memory to memory mode + 14 + 1 + + + + + CNDTR1 + CNDTR1 + DMA channel 1 number of data + register + 0xC + 0x20 + read-write + 0x00000000 + + + NDT + Number of data to transfer + 0 + 16 + + + + + CPAR1 + CPAR1 + DMA channel 1 peripheral address + register + 0x10 + 0x20 + read-write + 0x00000000 + + + PA + Peripheral address + 0 + 32 + + + + + CMAR1 + CMAR1 + DMA channel 1 memory address + register + 0x14 + 0x20 + read-write + 0x00000000 + + + MA + Memory address + 0 + 32 + + + + + CCR2 + CCR2 + DMA channel configuration register + (DMA_CCR) + 0x1C + 0x20 + read-write + 0x00000000 + + + EN + Channel enable + 0 + 1 + + + TCIE + Transfer complete interrupt + enable + 1 + 1 + + + HTIE + Half Transfer interrupt + enable + 2 + 1 + + + TEIE + Transfer error interrupt + enable + 3 + 1 + + + DIR + Data transfer direction + 4 + 1 + + + CIRC + Circular mode + 5 + 1 + + + PINC + Peripheral increment mode + 6 + 1 + + + MINC + Memory increment mode + 7 + 1 + + + PSIZE + Peripheral size + 8 + 2 + + + MSIZE + Memory size + 10 + 2 + + + PL + Channel Priority level + 12 + 2 + + + MEM2MEM + Memory to memory mode + 14 + 1 + + + + + CNDTR2 + CNDTR2 + DMA channel 2 number of data + register + 0x20 + 0x20 + read-write + 0x00000000 + + + NDT + Number of data to transfer + 0 + 16 + + + + + CPAR2 + CPAR2 + DMA channel 2 peripheral address + register + 0x24 + 0x20 + read-write + 0x00000000 + + + PA + Peripheral address + 0 + 32 + + + + + CMAR2 + CMAR2 + DMA channel 2 memory address + register + 0x28 + 0x20 + read-write + 0x00000000 + + + MA + Memory address + 0 + 32 + + + + + CCR3 + CCR3 + DMA channel configuration register + (DMA_CCR) + 0x30 + 0x20 + read-write + 0x00000000 + + + EN + Channel enable + 0 + 1 + + + TCIE + Transfer complete interrupt + enable + 1 + 1 + + + HTIE + Half Transfer interrupt + enable + 2 + 1 + + + TEIE + Transfer error interrupt + enable + 3 + 1 + + + DIR + Data transfer direction + 4 + 1 + + + CIRC + Circular mode + 5 + 1 + + + PINC + Peripheral increment mode + 6 + 1 + + + MINC + Memory increment mode + 7 + 1 + + + PSIZE + Peripheral size + 8 + 2 + + + MSIZE + Memory size + 10 + 2 + + + PL + Channel Priority level + 12 + 2 + + + MEM2MEM + Memory to memory mode + 14 + 1 + + + + + CNDTR3 + CNDTR3 + DMA channel 3 number of data + register + 0x34 + 0x20 + read-write + 0x00000000 + + + NDT + Number of data to transfer + 0 + 16 + + + + + CPAR3 + CPAR3 + DMA channel 3 peripheral address + register + 0x38 + 0x20 + read-write + 0x00000000 + + + PA + Peripheral address + 0 + 32 + + + + + CMAR3 + CMAR3 + DMA channel 3 memory address + register + 0x3C + 0x20 + read-write + 0x00000000 + + + MA + Memory address + 0 + 32 + + + + + CCR4 + CCR4 + DMA channel configuration register + (DMA_CCR) + 0x44 + 0x20 + read-write + 0x00000000 + + + EN + Channel enable + 0 + 1 + + + TCIE + Transfer complete interrupt + enable + 1 + 1 + + + HTIE + Half Transfer interrupt + enable + 2 + 1 + + + TEIE + Transfer error interrupt + enable + 3 + 1 + + + DIR + Data transfer direction + 4 + 1 + + + CIRC + Circular mode + 5 + 1 + + + PINC + Peripheral increment mode + 6 + 1 + + + MINC + Memory increment mode + 7 + 1 + + + PSIZE + Peripheral size + 8 + 2 + + + MSIZE + Memory size + 10 + 2 + + + PL + Channel Priority level + 12 + 2 + + + MEM2MEM + Memory to memory mode + 14 + 1 + + + + + CNDTR4 + CNDTR4 + DMA channel 4 number of data + register + 0x48 + 0x20 + read-write + 0x00000000 + + + NDT + Number of data to transfer + 0 + 16 + + + + + CPAR4 + CPAR4 + DMA channel 4 peripheral address + register + 0x4C + 0x20 + read-write + 0x00000000 + + + PA + Peripheral address + 0 + 32 + + + + + CMAR4 + CMAR4 + DMA channel 4 memory address + register + 0x50 + 0x20 + read-write + 0x00000000 + + + MA + Memory address + 0 + 32 + + + + + CCR5 + CCR5 + DMA channel configuration register + (DMA_CCR) + 0x58 + 0x20 + read-write + 0x00000000 + + + EN + Channel enable + 0 + 1 + + + TCIE + Transfer complete interrupt + enable + 1 + 1 + + + HTIE + Half Transfer interrupt + enable + 2 + 1 + + + TEIE + Transfer error interrupt + enable + 3 + 1 + + + DIR + Data transfer direction + 4 + 1 + + + CIRC + Circular mode + 5 + 1 + + + PINC + Peripheral increment mode + 6 + 1 + + + MINC + Memory increment mode + 7 + 1 + + + PSIZE + Peripheral size + 8 + 2 + + + MSIZE + Memory size + 10 + 2 + + + PL + Channel Priority level + 12 + 2 + + + MEM2MEM + Memory to memory mode + 14 + 1 + + + + + CNDTR5 + CNDTR5 + DMA channel 5 number of data + register + 0x5C + 0x20 + read-write + 0x00000000 + + + NDT + Number of data to transfer + 0 + 16 + + + + + CPAR5 + CPAR5 + DMA channel 5 peripheral address + register + 0x60 + 0x20 + read-write + 0x00000000 + + + PA + Peripheral address + 0 + 32 + + + + + CMAR5 + CMAR5 + DMA channel 5 memory address + register + 0x64 + 0x20 + read-write + 0x00000000 + + + MA + Memory address + 0 + 32 + + + + + CCR6 + CCR6 + DMA channel configuration register + (DMA_CCR) + 0x6C + 0x20 + read-write + 0x00000000 + + + EN + Channel enable + 0 + 1 + + + TCIE + Transfer complete interrupt + enable + 1 + 1 + + + HTIE + Half Transfer interrupt + enable + 2 + 1 + + + TEIE + Transfer error interrupt + enable + 3 + 1 + + + DIR + Data transfer direction + 4 + 1 + + + CIRC + Circular mode + 5 + 1 + + + PINC + Peripheral increment mode + 6 + 1 + + + MINC + Memory increment mode + 7 + 1 + + + PSIZE + Peripheral size + 8 + 2 + + + MSIZE + Memory size + 10 + 2 + + + PL + Channel Priority level + 12 + 2 + + + MEM2MEM + Memory to memory mode + 14 + 1 + + + + + CNDTR6 + CNDTR6 + DMA channel 6 number of data + register + 0x70 + 0x20 + read-write + 0x00000000 + + + NDT + Number of data to transfer + 0 + 16 + + + + + CPAR6 + CPAR6 + DMA channel 6 peripheral address + register + 0x74 + 0x20 + read-write + 0x00000000 + + + PA + Peripheral address + 0 + 32 + + + + + CMAR6 + CMAR6 + DMA channel 6 memory address + register + 0x78 + 0x20 + read-write + 0x00000000 + + + MA + Memory address + 0 + 32 + + + + + CCR7 + CCR7 + DMA channel configuration register + (DMA_CCR) + 0x80 + 0x20 + read-write + 0x00000000 + + + EN + Channel enable + 0 + 1 + + + TCIE + Transfer complete interrupt + enable + 1 + 1 + + + HTIE + Half Transfer interrupt + enable + 2 + 1 + + + TEIE + Transfer error interrupt + enable + 3 + 1 + + + DIR + Data transfer direction + 4 + 1 + + + CIRC + Circular mode + 5 + 1 + + + PINC + Peripheral increment mode + 6 + 1 + + + MINC + Memory increment mode + 7 + 1 + + + PSIZE + Peripheral size + 8 + 2 + + + MSIZE + Memory size + 10 + 2 + + + PL + Channel Priority level + 12 + 2 + + + MEM2MEM + Memory to memory mode + 14 + 1 + + + + + CNDTR7 + CNDTR7 + DMA channel 7 number of data + register + 0x84 + 0x20 + read-write + 0x00000000 + + + NDT + Number of data to transfer + 0 + 16 + + + + + CPAR7 + CPAR7 + DMA channel 7 peripheral address + register + 0x88 + 0x20 + read-write + 0x00000000 + + + PA + Peripheral address + 0 + 32 + + + + + CMAR7 + CMAR7 + DMA channel 7 memory address + register + 0x8C + 0x20 + read-write + 0x00000000 + + + MA + Memory address + 0 + 32 + + + + + + + RCC + Reset and clock control + RCC + 0x40021000 + + 0x0 + 0x400 + registers + + + RCC_CRS + RCC and CRS global interrupts + 4 + + + + CR + CR + Clock control register + 0x0 + 0x20 + 0x00000083 + + + HSION + Internal High Speed clock + enable + 0 + 1 + read-write + + + HSIRDY + Internal High Speed clock ready + flag + 1 + 1 + read-only + + + HSITRIM + Internal High Speed clock + trimming + 3 + 5 + read-write + + + HSICAL + Internal High Speed clock + Calibration + 8 + 8 + read-only + + + HSEON + External High Speed clock + enable + 16 + 1 + read-write + + + HSERDY + External High Speed clock ready + flag + 17 + 1 + read-only + + + HSEBYP + External High Speed clock + Bypass + 18 + 1 + read-write + + + CSSON + Clock Security System + enable + 19 + 1 + read-write + + + PLLON + PLL enable + 24 + 1 + read-write + + + PLLRDY + PLL clock ready flag + 25 + 1 + read-only + + + + + CFGR + CFGR + Clock configuration register + (RCC_CFGR) + 0x4 + 0x20 + 0x00000000 + + + SW + System clock Switch + 0 + 2 + read-write + + + SWS + System Clock Switch Status + 2 + 2 + read-only + + + HPRE + AHB prescaler + 4 + 4 + read-write + + + PPRE + APB Low speed prescaler + (APB1) + 8 + 3 + read-write + + + ADCPRE + ADC prescaler + 14 + 1 + read-write + + + PLLSRC + PLL input clock source + 15 + 2 + read-write + + + PLLXTPRE + HSE divider for PLL entry + 17 + 1 + read-write + + + PLLMUL + PLL Multiplication Factor + 18 + 4 + read-write + + + MCO + Microcontroller clock + output + 24 + 3 + read-write + + + MCOPRE + Microcontroller Clock Output + Prescaler + 28 + 3 + read-write + + + PLLNODIV + PLL clock not divided for + MCO + 31 + 1 + read-write + + + + + CIR + CIR + Clock interrupt register + (RCC_CIR) + 0x8 + 0x20 + 0x00000000 + + + LSIRDYF + LSI Ready Interrupt flag + 0 + 1 + read-only + + + LSERDYF + LSE Ready Interrupt flag + 1 + 1 + read-only + + + HSIRDYF + HSI Ready Interrupt flag + 2 + 1 + read-only + + + HSERDYF + HSE Ready Interrupt flag + 3 + 1 + read-only + + + PLLRDYF + PLL Ready Interrupt flag + 4 + 1 + read-only + + + HSI14RDYF + HSI14 ready interrupt flag + 5 + 1 + read-only + + + HSI48RDYF + HSI48 ready interrupt flag + 6 + 1 + read-only + + + CSSF + Clock Security System Interrupt + flag + 7 + 1 + read-only + + + LSIRDYIE + LSI Ready Interrupt Enable + 8 + 1 + read-write + + + LSERDYIE + LSE Ready Interrupt Enable + 9 + 1 + read-write + + + HSIRDYIE + HSI Ready Interrupt Enable + 10 + 1 + read-write + + + HSERDYIE + HSE Ready Interrupt Enable + 11 + 1 + read-write + + + PLLRDYIE + PLL Ready Interrupt Enable + 12 + 1 + read-write + + + HSI14RDYE + HSI14 ready interrupt + enable + 13 + 1 + read-write + + + HSI48RDYIE + HSI48 ready interrupt + enable + 14 + 1 + read-write + + + LSIRDYC + LSI Ready Interrupt Clear + 16 + 1 + write-only + + + LSERDYC + LSE Ready Interrupt Clear + 17 + 1 + write-only + + + HSIRDYC + HSI Ready Interrupt Clear + 18 + 1 + write-only + + + HSERDYC + HSE Ready Interrupt Clear + 19 + 1 + write-only + + + PLLRDYC + PLL Ready Interrupt Clear + 20 + 1 + write-only + + + HSI14RDYC + HSI 14 MHz Ready Interrupt + Clear + 21 + 1 + write-only + + + HSI48RDYC + HSI48 Ready Interrupt + Clear + 22 + 1 + write-only + + + CSSC + Clock security system interrupt + clear + 23 + 1 + write-only + + + + + APB2RSTR + APB2RSTR + APB2 peripheral reset register + (RCC_APB2RSTR) + 0xC + 0x20 + read-write + 0x00000000 + + + SYSCFGRST + SYSCFG and COMP reset + 0 + 1 + + + ADCRST + ADC interface reset + 9 + 1 + + + TIM1RST + TIM1 timer reset + 11 + 1 + + + SPI1RST + SPI 1 reset + 12 + 1 + + + USART1RST + USART1 reset + 14 + 1 + + + TIM15RST + TIM15 timer reset + 16 + 1 + + + TIM16RST + TIM16 timer reset + 17 + 1 + + + TIM17RST + TIM17 timer reset + 18 + 1 + + + DBGMCURST + Debug MCU reset + 22 + 1 + + + + + APB1RSTR + APB1RSTR + APB1 peripheral reset register + (RCC_APB1RSTR) + 0x10 + 0x20 + read-write + 0x00000000 + + + TIM2RST + Timer 2 reset + 0 + 1 + + + TIM3RST + Timer 3 reset + 1 + 1 + + + TIM6RST + Timer 6 reset + 4 + 1 + + + TIM7RST + TIM7 timer reset + 5 + 1 + + + TIM14RST + Timer 14 reset + 8 + 1 + + + WWDGRST + Window watchdog reset + 11 + 1 + + + SPI2RST + SPI2 reset + 14 + 1 + + + USART2RST + USART 2 reset + 17 + 1 + + + USART3RST + USART3 reset + 18 + 1 + + + USART4RST + USART4 reset + 19 + 1 + + + I2C1RST + I2C1 reset + 21 + 1 + + + I2C2RST + I2C2 reset + 22 + 1 + + + USBRST + USB interface reset + 23 + 1 + + + CANRST + CAN interface reset + 25 + 1 + + + CRSRST + Clock Recovery System interface + reset + 27 + 1 + + + PWRRST + Power interface reset + 28 + 1 + + + DACRST + DAC interface reset + 29 + 1 + + + CECRST + HDMI CEC reset + 30 + 1 + + + + + AHBENR + AHBENR + AHB Peripheral Clock enable register + (RCC_AHBENR) + 0x14 + 0x20 + read-write + 0x00000014 + + + DMAEN + DMA1 clock enable + 0 + 1 + + + SRAMEN + SRAM interface clock + enable + 2 + 1 + + + FLITFEN + FLITF clock enable + 4 + 1 + + + CRCEN + CRC clock enable + 6 + 1 + + + IOPAEN + I/O port A clock enable + 17 + 1 + + + IOPBEN + I/O port B clock enable + 18 + 1 + + + IOPCEN + I/O port C clock enable + 19 + 1 + + + IOPDEN + I/O port D clock enable + 20 + 1 + + + IOPFEN + I/O port F clock enable + 22 + 1 + + + TSCEN + Touch sensing controller clock + enable + 24 + 1 + + + + + APB2ENR + APB2ENR + APB2 peripheral clock enable register + (RCC_APB2ENR) + 0x18 + 0x20 + read-write + 0x00000000 + + + SYSCFGEN + SYSCFG clock enable + 0 + 1 + + + ADCEN + ADC 1 interface clock + enable + 9 + 1 + + + TIM1EN + TIM1 Timer clock enable + 11 + 1 + + + SPI1EN + SPI 1 clock enable + 12 + 1 + + + USART1EN + USART1 clock enable + 14 + 1 + + + TIM15EN + TIM15 timer clock enable + 16 + 1 + + + TIM16EN + TIM16 timer clock enable + 17 + 1 + + + TIM17EN + TIM17 timer clock enable + 18 + 1 + + + DBGMCUEN + MCU debug module clock + enable + 22 + 1 + + + + + APB1ENR + APB1ENR + APB1 peripheral clock enable register + (RCC_APB1ENR) + 0x1C + 0x20 + read-write + 0x00000000 + + + TIM2EN + Timer 2 clock enable + 0 + 1 + + + TIM3EN + Timer 3 clock enable + 1 + 1 + + + TIM6EN + Timer 6 clock enable + 4 + 1 + + + TIM7EN + TIM7 timer clock enable + 5 + 1 + + + TIM14EN + Timer 14 clock enable + 8 + 1 + + + WWDGEN + Window watchdog clock + enable + 11 + 1 + + + SPI2EN + SPI 2 clock enable + 14 + 1 + + + USART2EN + USART 2 clock enable + 17 + 1 + + + USART3EN + USART3 clock enable + 18 + 1 + + + USART4EN + USART4 clock enable + 19 + 1 + + + I2C1EN + I2C 1 clock enable + 21 + 1 + + + I2C2EN + I2C 2 clock enable + 22 + 1 + + + USBRST + USB interface clock enable + 23 + 1 + + + CANEN + CAN interface clock enable + 25 + 1 + + + CRSEN + Clock Recovery System interface clock + enable + 27 + 1 + + + PWREN + Power interface clock + enable + 28 + 1 + + + DACEN + DAC interface clock enable + 29 + 1 + + + CECEN + HDMI CEC interface clock + enable + 30 + 1 + + + + + BDCR + BDCR + Backup domain control register + (RCC_BDCR) + 0x20 + 0x20 + 0x00000000 + + + LSEON + External Low Speed oscillator + enable + 0 + 1 + read-write + + + LSERDY + External Low Speed oscillator + ready + 1 + 1 + read-only + + + LSEBYP + External Low Speed oscillator + bypass + 2 + 1 + read-write + + + LSEDRV + LSE oscillator drive + capability + 3 + 2 + read-write + + + RTCSEL + RTC clock source selection + 8 + 2 + read-write + + + RTCEN + RTC clock enable + 15 + 1 + read-write + + + BDRST + Backup domain software + reset + 16 + 1 + read-write + + + + + CSR + CSR + Control/status register + (RCC_CSR) + 0x24 + 0x20 + 0x0C000000 + + + LSION + Internal low speed oscillator + enable + 0 + 1 + read-write + + + LSIRDY + Internal low speed oscillator + ready + 1 + 1 + read-only + + + RMVF + Remove reset flag + 24 + 1 + read-write + + + OBLRSTF + Option byte loader reset + flag + 25 + 1 + read-write + + + PINRSTF + PIN reset flag + 26 + 1 + read-write + + + PORRSTF + POR/PDR reset flag + 27 + 1 + read-write + + + SFTRSTF + Software reset flag + 28 + 1 + read-write + + + IWDGRSTF + Independent watchdog reset + flag + 29 + 1 + read-write + + + WWDGRSTF + Window watchdog reset flag + 30 + 1 + read-write + + + LPWRRSTF + Low-power reset flag + 31 + 1 + read-write + + + + + AHBRSTR + AHBRSTR + AHB peripheral reset register + 0x28 + 0x20 + read-write + 0x00000000 + + + IOPARST + I/O port A reset + 17 + 1 + + + IOPBRST + I/O port B reset + 18 + 1 + + + IOPCRST + I/O port C reset + 19 + 1 + + + IOPDRST + I/O port D reset + 20 + 1 + + + IOPFRST + I/O port F reset + 22 + 1 + + + TSCRST + Touch sensing controller + reset + 24 + 1 + + + + + CFGR2 + CFGR2 + Clock configuration register 2 + 0x2C + 0x20 + read-write + 0x00000000 + + + PREDIV + PREDIV division factor + 0 + 4 + + + + + CFGR3 + CFGR3 + Clock configuration register 3 + 0x30 + 0x20 + read-write + 0x00000000 + + + USART1SW + USART1 clock source + selection + 0 + 2 + + + I2C1SW + I2C1 clock source + selection + 4 + 1 + + + CECSW + HDMI CEC clock source + selection + 6 + 1 + + + USBSW + USB clock source selection + 7 + 1 + + + ADCSW + ADC clock source selection + 8 + 1 + + + USART2SW + USART2 clock source + selection + 16 + 2 + + + + + CR2 + CR2 + Clock control register 2 + 0x34 + 0x20 + 0x00000080 + + + HSI14ON + HSI14 clock enable + 0 + 1 + read-write + + + HSI14RDY + HR14 clock ready flag + 1 + 1 + read-only + + + HSI14DIS + HSI14 clock request from ADC + disable + 2 + 1 + read-write + + + HSI14TRIM + HSI14 clock trimming + 3 + 5 + read-write + + + HSI14CAL + HSI14 clock calibration + 8 + 8 + read-only + + + HSI48ON + HSI48 clock enable + 16 + 1 + read-write + + + HSI48RDY + HSI48 clock ready flag + 17 + 1 + read-only + + + HSI48CAL + HSI48 factory clock + calibration + 24 + 1 + read-only + + + + + + + SYSCFG + System configuration controller + SYSCFG + 0x40010000 + + 0x0 + 0x400 + registers + + + + CFGR1 + CFGR1 + configuration register 1 + 0x0 + 0x20 + read-write + 0x00000000 + + + MEM_MODE + Memory mapping selection + bits + 0 + 2 + + + ADC_DMA_RMP + ADC DMA remapping bit + 8 + 1 + + + USART1_TX_DMA_RMP + USART1_TX DMA remapping + bit + 9 + 1 + + + USART1_RX_DMA_RMP + USART1_RX DMA request remapping + bit + 10 + 1 + + + TIM16_DMA_RMP + TIM16 DMA request remapping + bit + 11 + 1 + + + TIM17_DMA_RMP + TIM17 DMA request remapping + bit + 12 + 1 + + + I2C_PB6_FM + Fast Mode Plus (FM plus) driving + capability activation bits. + 16 + 1 + + + I2C_PB7_FM + Fast Mode Plus (FM+) driving capability + activation bits. + 17 + 1 + + + I2C_PB8_FM + Fast Mode Plus (FM+) driving capability + activation bits. + 18 + 1 + + + I2C_PB9_FM + Fast Mode Plus (FM+) driving capability + activation bits. + 19 + 1 + + + I2C1_FM_plus + FM+ driving capability activation for + I2C1 + 20 + 1 + + + I2C2_FM_plus + FM+ driving capability activation for + I2C2 + 21 + 1 + + + SPI2_DMA_RMP + SPI2 DMA request remapping + bit + 24 + 1 + + + USART2_DMA_RMP + USART2 DMA request remapping + bit + 25 + 1 + + + USART3_DMA_RMP + USART3 DMA request remapping + bit + 26 + 1 + + + I2C1_DMA_RMP + I2C1 DMA request remapping + bit + 27 + 1 + + + TIM1_DMA_RMP + TIM1 DMA request remapping + bit + 28 + 1 + + + TIM2_DMA_RMP + TIM2 DMA request remapping + bit + 29 + 1 + + + TIM3_DMA_RMP + TIM3 DMA request remapping + bit + 30 + 1 + + + + + EXTICR1 + EXTICR1 + external interrupt configuration register + 1 + 0x8 + 0x20 + read-write + 0x0000 + + + EXTI3 + EXTI 3 configuration bits + 12 + 4 + + + EXTI2 + EXTI 2 configuration bits + 8 + 4 + + + EXTI1 + EXTI 1 configuration bits + 4 + 4 + + + EXTI0 + EXTI 0 configuration bits + 0 + 4 + + + + + EXTICR2 + EXTICR2 + external interrupt configuration register + 2 + 0xC + 0x20 + read-write + 0x0000 + + + EXTI7 + EXTI 7 configuration bits + 12 + 4 + + + EXTI6 + EXTI 6 configuration bits + 8 + 4 + + + EXTI5 + EXTI 5 configuration bits + 4 + 4 + + + EXTI4 + EXTI 4 configuration bits + 0 + 4 + + + + + EXTICR3 + EXTICR3 + external interrupt configuration register + 3 + 0x10 + 0x20 + read-write + 0x0000 + + + EXTI11 + EXTI 11 configuration bits + 12 + 4 + + + EXTI10 + EXTI 10 configuration bits + 8 + 4 + + + EXTI9 + EXTI 9 configuration bits + 4 + 4 + + + EXTI8 + EXTI 8 configuration bits + 0 + 4 + + + + + EXTICR4 + EXTICR4 + external interrupt configuration register + 4 + 0x14 + 0x20 + read-write + 0x0000 + + + EXTI15 + EXTI 15 configuration bits + 12 + 4 + + + EXTI14 + EXTI 14 configuration bits + 8 + 4 + + + EXTI13 + EXTI 13 configuration bits + 4 + 4 + + + EXTI12 + EXTI 12 configuration bits + 0 + 4 + + + + + CFGR2 + CFGR2 + configuration register 2 + 0x18 + 0x20 + read-write + 0x0000 + + + SRAM_PEF + SRAM parity flag + 8 + 1 + + + PVD_LOCK + PVD lock enable bit + 2 + 1 + + + SRAM_PARITY_LOCK + SRAM parity lock bit + 1 + 1 + + + LOCUP_LOCK + Cortex-M0 LOCKUP bit enable + bit + 0 + 1 + + + + + + + ADC + Analog-to-digital converter + ADC + 0x40012400 + + 0x0 + 0x400 + registers + + + ADC_COMP + ADC and comparator interrupts + 12 + + + + ISR + ISR + interrupt and status register + 0x0 + 0x20 + read-write + 0x00000000 + + + AWD + Analog watchdog flag + 7 + 1 + + + OVR + ADC overrun + 4 + 1 + + + EOS + End of sequence flag + 3 + 1 + + + EOC + End of conversion flag + 2 + 1 + + + EOSMP + End of sampling flag + 1 + 1 + + + ADRDY + ADC ready + 0 + 1 + + + + + IER + IER + interrupt enable register + 0x4 + 0x20 + read-write + 0x00000000 + + + AWDIE + Analog watchdog interrupt + enable + 7 + 1 + + + OVRIE + Overrun interrupt enable + 4 + 1 + + + EOSIE + End of conversion sequence interrupt + enable + 3 + 1 + + + EOCIE + End of conversion interrupt + enable + 2 + 1 + + + EOSMPIE + End of sampling flag interrupt + enable + 1 + 1 + + + ADRDYIE + ADC ready interrupt enable + 0 + 1 + + + + + CR + CR + control register + 0x8 + 0x20 + read-write + 0x00000000 + + + ADCAL + ADC calibration + 31 + 1 + + + ADSTP + ADC stop conversion + command + 4 + 1 + + + ADSTART + ADC start conversion + command + 2 + 1 + + + ADDIS + ADC disable command + 1 + 1 + + + ADEN + ADC enable command + 0 + 1 + + + + + CFGR1 + CFGR1 + configuration register 1 + 0xC + 0x20 + read-write + 0x00000000 + + + AWDCH + Analog watchdog channel + selection + 26 + 5 + + + AWDEN + Analog watchdog enable + 23 + 1 + + + AWDSGL + Enable the watchdog on a single channel + or on all channels + 22 + 1 + + + DISCEN + Discontinuous mode + 16 + 1 + + + AUTOFF + Auto-off mode + 15 + 1 + + + AUTDLY + Auto-delayed conversion + mode + 14 + 1 + + + CONT + Single / continuous conversion + mode + 13 + 1 + + + OVRMOD + Overrun management mode + 12 + 1 + + + EXTEN + External trigger enable and polarity + selection + 10 + 2 + + + EXTSEL + External trigger selection + 6 + 3 + + + ALIGN + Data alignment + 5 + 1 + + + RES + Data resolution + 3 + 2 + + + SCANDIR + Scan sequence direction + 2 + 1 + + + DMACFG + Direct memery access + configuration + 1 + 1 + + + DMAEN + Direct memory access + enable + 0 + 1 + + + + + CFGR2 + CFGR2 + configuration register 2 + 0x10 + 0x20 + read-write + 0x00008000 + + + JITOFF_D4 + JITOFF_D4 + 31 + 1 + + + JITOFF_D2 + JITOFF_D2 + 30 + 1 + + + + + SMPR + SMPR + sampling time register + 0x14 + 0x20 + read-write + 0x00000000 + + + SMPR + Sampling time selection + 0 + 3 + + + + + TR + TR + watchdog threshold register + 0x20 + 0x20 + read-write + 0x00000FFF + + + HT + Analog watchdog higher + threshold + 16 + 12 + + + LT + Analog watchdog lower + threshold + 0 + 12 + + + + + CHSELR + CHSELR + channel selection register + 0x28 + 0x20 + read-write + 0x00000000 + + + CHSEL18 + Channel-x selection + 18 + 1 + + + CHSEL17 + Channel-x selection + 17 + 1 + + + CHSEL16 + Channel-x selection + 16 + 1 + + + CHSEL15 + Channel-x selection + 15 + 1 + + + CHSEL14 + Channel-x selection + 14 + 1 + + + CHSEL13 + Channel-x selection + 13 + 1 + + + CHSEL12 + Channel-x selection + 12 + 1 + + + CHSEL11 + Channel-x selection + 11 + 1 + + + CHSEL10 + Channel-x selection + 10 + 1 + + + CHSEL9 + Channel-x selection + 9 + 1 + + + CHSEL8 + Channel-x selection + 8 + 1 + + + CHSEL7 + Channel-x selection + 7 + 1 + + + CHSEL6 + Channel-x selection + 6 + 1 + + + CHSEL5 + Channel-x selection + 5 + 1 + + + CHSEL4 + Channel-x selection + 4 + 1 + + + CHSEL3 + Channel-x selection + 3 + 1 + + + CHSEL2 + Channel-x selection + 2 + 1 + + + CHSEL1 + Channel-x selection + 1 + 1 + + + CHSEL0 + Channel-x selection + 0 + 1 + + + + + DR + DR + data register + 0x40 + 0x20 + read-only + 0x00000000 + + + DATA + Converted data + 0 + 16 + + + + + CCR + CCR + common configuration register + 0x308 + 0x20 + read-write + 0x00000000 + + + VBATEN + VBAT enable + 24 + 1 + + + TSEN + Temperature sensor enable + 23 + 1 + + + VREFEN + Temperature sensor and VREFINT + enable + 22 + 1 + + + + + + + USART1 + Universal synchronous asynchronous receiver + transmitter + USART + 0x40013800 + + 0x0 + 0x400 + registers + + + USART1 + USART1 global interrupt + 27 + + + + CR1 + CR1 + Control register 1 + 0x0 + 0x20 + read-write + 0x0000 + + + UE + USART enable + 0 + 1 + + + UESM + USART enable in Stop mode + 1 + 1 + + + RE + Receiver enable + 2 + 1 + + + TE + Transmitter enable + 3 + 1 + + + IDLEIE + IDLE interrupt enable + 4 + 1 + + + RXNEIE + RXNE interrupt enable + 5 + 1 + + + TCIE + Transmission complete interrupt + enable + 6 + 1 + + + TXEIE + interrupt enable + 7 + 1 + + + PEIE + PE interrupt enable + 8 + 1 + + + PS + Parity selection + 9 + 1 + + + PCE + Parity control enable + 10 + 1 + + + WAKE + Receiver wakeup method + 11 + 1 + + + M + Word length + 12 + 1 + + + MME + Mute mode enable + 13 + 1 + + + CMIE + Character match interrupt + enable + 14 + 1 + + + OVER8 + Oversampling mode + 15 + 1 + + + DEDT + Driver Enable deassertion + time + 16 + 5 + + + DEAT + Driver Enable assertion + time + 21 + 5 + + + RTOIE + Receiver timeout interrupt + enable + 26 + 1 + + + EOBIE + End of Block interrupt + enable + 27 + 1 + + + M1 + Word length + 28 + 1 + + + + + CR2 + CR2 + Control register 2 + 0x4 + 0x20 + read-write + 0x0000 + + + ADD4 + Address of the USART node + 28 + 4 + + + ADD0 + Address of the USART node + 24 + 4 + + + RTOEN + Receiver timeout enable + 23 + 1 + + + ABRMOD + Auto baud rate mode + 21 + 2 + + + ABREN + Auto baud rate enable + 20 + 1 + + + MSBFIRST + Most significant bit first + 19 + 1 + + + DATAINV + Binary data inversion + 18 + 1 + + + TXINV + TX pin active level + inversion + 17 + 1 + + + RXINV + RX pin active level + inversion + 16 + 1 + + + SWAP + Swap TX/RX pins + 15 + 1 + + + LINEN + LIN mode enable + 14 + 1 + + + STOP + STOP bits + 12 + 2 + + + CLKEN + Clock enable + 11 + 1 + + + CPOL + Clock polarity + 10 + 1 + + + CPHA + Clock phase + 9 + 1 + + + LBCL + Last bit clock pulse + 8 + 1 + + + LBDIE + LIN break detection interrupt + enable + 6 + 1 + + + LBDL + LIN break detection length + 5 + 1 + + + ADDM7 + 7-bit Address Detection/4-bit Address + Detection + 4 + 1 + + + + + CR3 + CR3 + Control register 3 + 0x8 + 0x20 + read-write + 0x0000 + + + WUFIE + Wakeup from Stop mode interrupt + enable + 22 + 1 + + + WUS + Wakeup from Stop mode interrupt flag + selection + 20 + 2 + + + SCARCNT + Smartcard auto-retry count + 17 + 3 + + + DEP + Driver enable polarity + selection + 15 + 1 + + + DEM + Driver enable mode + 14 + 1 + + + DDRE + DMA Disable on Reception + Error + 13 + 1 + + + OVRDIS + Overrun Disable + 12 + 1 + + + ONEBIT + One sample bit method + enable + 11 + 1 + + + CTSIE + CTS interrupt enable + 10 + 1 + + + CTSE + CTS enable + 9 + 1 + + + RTSE + RTS enable + 8 + 1 + + + DMAT + DMA enable transmitter + 7 + 1 + + + DMAR + DMA enable receiver + 6 + 1 + + + SCEN + Smartcard mode enable + 5 + 1 + + + NACK + Smartcard NACK enable + 4 + 1 + + + HDSEL + Half-duplex selection + 3 + 1 + + + IRLP + IrDA low-power + 2 + 1 + + + IREN + IrDA mode enable + 1 + 1 + + + EIE + Error interrupt enable + 0 + 1 + + + + + BRR + BRR + Baud rate register + 0xC + 0x20 + read-write + 0x0000 + + + DIV_Mantissa + mantissa of USARTDIV + 4 + 12 + + + DIV_Fraction + fraction of USARTDIV + 0 + 4 + + + + + GTPR + GTPR + Guard time and prescaler + register + 0x10 + 0x20 + read-write + 0x0000 + + + GT + Guard time value + 8 + 8 + + + PSC + Prescaler value + 0 + 8 + + + + + RTOR + RTOR + Receiver timeout register + 0x14 + 0x20 + read-write + 0x0000 + + + BLEN + Block Length + 24 + 8 + + + RTO + Receiver timeout value + 0 + 24 + + + + + RQR + RQR + Request register + 0x18 + 0x20 + read-write + 0x0000 + + + TXFRQ + Transmit data flush + request + 4 + 1 + + + RXFRQ + Receive data flush request + 3 + 1 + + + MMRQ + Mute mode request + 2 + 1 + + + SBKRQ + Send break request + 1 + 1 + + + ABRRQ + Auto baud rate request + 0 + 1 + + + + + ISR + ISR + Interrupt & status + register + 0x1C + 0x20 + read-only + 0x00C0 + + + REACK + Receive enable acknowledge + flag + 22 + 1 + + + TEACK + Transmit enable acknowledge + flag + 21 + 1 + + + WUF + Wakeup from Stop mode flag + 20 + 1 + + + RWU + Receiver wakeup from Mute + mode + 19 + 1 + + + SBKF + Send break flag + 18 + 1 + + + CMF + character match flag + 17 + 1 + + + BUSY + Busy flag + 16 + 1 + + + ABRF + Auto baud rate flag + 15 + 1 + + + ABRE + Auto baud rate error + 14 + 1 + + + EOBF + End of block flag + 12 + 1 + + + RTOF + Receiver timeout + 11 + 1 + + + CTS + CTS flag + 10 + 1 + + + CTSIF + CTS interrupt flag + 9 + 1 + + + LBDF + LIN break detection flag + 8 + 1 + + + TXE + Transmit data register + empty + 7 + 1 + + + TC + Transmission complete + 6 + 1 + + + RXNE + Read data register not + empty + 5 + 1 + + + IDLE + Idle line detected + 4 + 1 + + + ORE + Overrun error + 3 + 1 + + + NF + Noise detected flag + 2 + 1 + + + FE + Framing error + 1 + 1 + + + PE + Parity error + 0 + 1 + + + + + ICR + ICR + Interrupt flag clear register + 0x20 + 0x20 + read-write + 0x0000 + + + WUCF + Wakeup from Stop mode clear + flag + 20 + 1 + + + CMCF + Character match clear flag + 17 + 1 + + + EOBCF + End of timeout clear flag + 12 + 1 + + + RTOCF + Receiver timeout clear + flag + 11 + 1 + + + CTSCF + CTS clear flag + 9 + 1 + + + LBDCF + LIN break detection clear + flag + 8 + 1 + + + TCCF + Transmission complete clear + flag + 6 + 1 + + + IDLECF + Idle line detected clear + flag + 4 + 1 + + + ORECF + Overrun error clear flag + 3 + 1 + + + NCF + Noise detected clear flag + 2 + 1 + + + FECF + Framing error clear flag + 1 + 1 + + + PECF + Parity error clear flag + 0 + 1 + + + + + RDR + RDR + Receive data register + 0x24 + 0x20 + read-only + 0x0000 + + + RDR + Receive data value + 0 + 9 + + + + + TDR + TDR + Transmit data register + 0x28 + 0x20 + read-write + 0x0000 + + + TDR + Transmit data value + 0 + 9 + + + + + + + USART2 + 0x40004400 + + USART2 + USART2 global interrupt + 28 + + + + USART3 + 0x40004800 + + USART3_4 + USART3 and USART4 global + interrupt + 29 + + + + USART4 + 0x40004C00 + + USART3_4 + USART3 and USART4 global + interrupt + 29 + + + + USART6 + 0x40011400 + + USART1 + USART1 global interrupt + 27 + + + + USART7 + 0x40011800 + + USART1 + USART1 global interrupt + 27 + + + + USART8 + 0x40011C00 + + USART1 + USART1 global interrupt + 27 + + + + COMP + Comparator + COMP + 0x4001001C + + 0x0 + 0x400 + registers + + + ADC_COMP + ADC and comparator interrupts + 12 + + + + CSR + CSR + control and status register + 0x0 + 0x20 + 0x00000000 + + + COMP1EN + Comparator 1 enable + 0 + 1 + read-write + + + COMP1_INP_DAC + COMP1_INP_DAC + 1 + 1 + read-write + + + COMP1MODE + Comparator 1 mode + 2 + 2 + read-write + + + COMP1INSEL + Comparator 1 inverting input + selection + 4 + 3 + read-write + + + COMP1OUTSEL + Comparator 1 output + selection + 8 + 3 + read-write + + + COMP1POL + Comparator 1 output + polarity + 11 + 1 + read-write + + + COMP1HYST + Comparator 1 hysteresis + 12 + 2 + read-write + + + COMP1OUT + Comparator 1 output + 14 + 1 + read-only + + + COMP1LOCK + Comparator 1 lock + 15 + 1 + read-write + + + COMP2EN + Comparator 2 enable + 16 + 1 + read-write + + + COMP2MODE + Comparator 2 mode + 18 + 2 + read-write + + + COMP2INSEL + Comparator 2 inverting input + selection + 20 + 3 + read-write + + + WNDWEN + Window mode enable + 23 + 1 + read-write + + + COMP2OUTSEL + Comparator 2 output + selection + 24 + 3 + read-write + + + COMP2POL + Comparator 2 output + polarity + 27 + 1 + read-write + + + COMP2HYST + Comparator 2 hysteresis + 28 + 2 + read-write + + + COMP2OUT + Comparator 2 output + 30 + 1 + read-only + + + COMP2LOCK + Comparator 2 lock + 31 + 1 + read-write + + + + + + + RTC + Real-time clock + RTC + 0x40002800 + + 0x0 + 0x400 + registers + + + RTC + RTC interrupts + 2 + + + + TR + TR + time register + 0x0 + 0x20 + read-write + 0x00000000 + + + PM + AM/PM notation + 22 + 1 + + + HT + Hour tens in BCD format + 20 + 2 + + + HU + Hour units in BCD format + 16 + 4 + + + MNT + Minute tens in BCD format + 12 + 3 + + + MNU + Minute units in BCD format + 8 + 4 + + + ST + Second tens in BCD format + 4 + 3 + + + SU + Second units in BCD format + 0 + 4 + + + + + DR + DR + date register + 0x4 + 0x20 + read-write + 0x00002101 + + + YT + Year tens in BCD format + 20 + 4 + + + YU + Year units in BCD format + 16 + 4 + + + WDU + Week day units + 13 + 3 + + + MT + Month tens in BCD format + 12 + 1 + + + MU + Month units in BCD format + 8 + 4 + + + DT + Date tens in BCD format + 4 + 2 + + + DU + Date units in BCD format + 0 + 4 + + + + + CR + CR + control register + 0x8 + 0x20 + 0x00000000 + + + TSEDGE + Time-stamp event active + edge + 3 + 1 + read-write + + + REFCKON + RTC_REFIN reference clock detection + enable (50 or 60 Hz) + 4 + 1 + read-write + + + BYPSHAD + Bypass the shadow + registers + 5 + 1 + read-write + + + FMT + Hour format + 6 + 1 + read-write + + + ALRAE + Alarm A enable + 8 + 1 + read-write + + + TSE + timestamp enable + 11 + 1 + read-write + + + ALRAIE + Alarm A interrupt enable + 12 + 1 + read-write + + + TSIE + Time-stamp interrupt + enable + 15 + 1 + read-write + + + ADD1H + Add 1 hour (summer time + change) + 16 + 1 + write-only + + + SUB1H + Subtract 1 hour (winter time + change) + 17 + 1 + write-only + + + BKP + Backup + 18 + 1 + read-write + + + COSEL + Calibration output + selection + 19 + 1 + read-write + + + POL + Output polarity + 20 + 1 + read-write + + + OSEL + Output selection + 21 + 2 + read-write + + + COE + Calibration output enable + 23 + 1 + read-write + + + + + ISR + ISR + initialization and status + register + 0xC + 0x20 + 0x00000007 + + + ALRAWF + Alarm A write flag + 0 + 1 + read-only + + + SHPF + Shift operation pending + 3 + 1 + read-write + + + INITS + Initialization status flag + 4 + 1 + read-only + + + RSF + Registers synchronization + flag + 5 + 1 + read-write + + + INITF + Initialization flag + 6 + 1 + read-only + + + INIT + Initialization mode + 7 + 1 + read-write + + + ALRAF + Alarm A flag + 8 + 1 + read-write + + + TSF + Time-stamp flag + 11 + 1 + read-write + + + TSOVF + Time-stamp overflow flag + 12 + 1 + read-write + + + TAMP1F + RTC_TAMP1 detection flag + 13 + 1 + read-write + + + TAMP2F + RTC_TAMP2 detection flag + 14 + 1 + read-write + + + RECALPF + Recalibration pending Flag + 16 + 1 + read-only + + + + + PRER + PRER + prescaler register + 0x10 + 0x20 + read-write + 0x007F00FF + + + PREDIV_A + Asynchronous prescaler + factor + 16 + 7 + + + PREDIV_S + Synchronous prescaler + factor + 0 + 15 + + + + + ALRMAR + ALRMAR + alarm A register + 0x1C + 0x20 + read-write + 0x00000000 + + + MSK4 + Alarm A date mask + 31 + 1 + + + WDSEL + Week day selection + 30 + 1 + + + DT + Date tens in BCD format. + 28 + 2 + + + DU + Date units or day in BCD + format. + 24 + 4 + + + MSK3 + Alarm A hours mask + 23 + 1 + + + PM + AM/PM notation + 22 + 1 + + + HT + Hour tens in BCD format. + 20 + 2 + + + HU + Hour units in BCD format. + 16 + 4 + + + MSK2 + Alarm A minutes mask + 15 + 1 + + + MNT + Minute tens in BCD format. + 12 + 3 + + + MNU + Minute units in BCD + format. + 8 + 4 + + + MSK1 + Alarm A seconds mask + 7 + 1 + + + ST + Second tens in BCD format. + 4 + 3 + + + SU + Second units in BCD + format. + 0 + 4 + + + + + WPR + WPR + write protection register + 0x24 + 0x20 + write-only + 0x00000000 + + + KEY + Write protection key + 0 + 8 + + + + + SSR + SSR + sub second register + 0x28 + 0x20 + read-only + 0x00000000 + + + SS + Sub second value + 0 + 16 + + + + + SHIFTR + SHIFTR + shift control register + 0x2C + 0x20 + write-only + 0x00000000 + + + ADD1S + Reserved + 31 + 1 + + + SUBFS + Subtract a fraction of a + second + 0 + 15 + + + + + TSTR + TSTR + timestamp time register + 0x30 + 0x20 + read-only + 0x00000000 + + + PM + AM/PM notation + 22 + 1 + + + HT + Hour tens in BCD format. + 20 + 2 + + + HU + Hour units in BCD format. + 16 + 4 + + + MNT + Minute tens in BCD format. + 12 + 3 + + + MNU + Minute units in BCD + format. + 8 + 4 + + + ST + Second tens in BCD format. + 4 + 3 + + + SU + Second units in BCD + format. + 0 + 4 + + + + + TSDR + TSDR + timestamp date register + 0x34 + 0x20 + read-only + 0x00000000 + + + WDU + Week day units + 13 + 3 + + + MT + Month tens in BCD format + 12 + 1 + + + MU + Month units in BCD format + 8 + 4 + + + DT + Date tens in BCD format + 4 + 2 + + + DU + Date units in BCD format + 0 + 4 + + + + + TSSSR + TSSSR + time-stamp sub second register + 0x38 + 0x20 + read-only + 0x00000000 + + + SS + Sub second value + 0 + 16 + + + + + CALR + CALR + calibration register + 0x3C + 0x20 + read-write + 0x00000000 + + + CALP + Use an 8-second calibration cycle + period + 15 + 1 + + + CALW8 + Use a 16-second calibration cycle + period + 14 + 1 + + + CALW16 + Reserved + 13 + 1 + + + CALM + Calibration minus + 0 + 9 + + + + + TAFCR + TAFCR + tamper and alternate function configuration + register + 0x40 + 0x20 + read-write + 0x00000000 + + + PC15MODE + PC15 mode + 23 + 1 + + + PC15VALUE + PC15 value + 22 + 1 + + + PC14MODE + PC14 mode + 21 + 1 + + + PC14VALUE + PC14 value + 20 + 1 + + + PC13MODE + PC13 mode + 19 + 1 + + + PC13VALUE + RTC_ALARM output type/PC13 + value + 18 + 1 + + + TAMP_PUDIS + RTC_TAMPx pull-up disable + 15 + 1 + + + TAMP_PRCH + RTC_TAMPx precharge + duration + 13 + 2 + + + TAMPFLT + RTC_TAMPx filter count + 11 + 2 + + + TAMPFREQ + Tamper sampling frequency + 8 + 3 + + + TAMPTS + Activate timestamp on tamper detection + event + 7 + 1 + + + TAMP2_TRG + Active level for RTC_TAMP2 + input + 4 + 1 + + + TAMP2E + RTC_TAMP2 input detection + enable + 3 + 1 + + + TAMPIE + Tamper interrupt enable + 2 + 1 + + + TAMP1TRG + Active level for RTC_TAMP1 + input + 1 + 1 + + + TAMP1E + RTC_TAMP1 input detection + enable + 0 + 1 + + + + + ALRMASSR + ALRMASSR + alarm A sub second register + 0x44 + 0x20 + read-write + 0x00000000 + + + MASKSS + Mask the most-significant bits starting + at this bit + 24 + 4 + + + SS + Sub seconds value + 0 + 15 + + + + + BKP0R + BKP0R + backup register + 0x50 + 0x20 + read-write + 0x00000000 + + + BKP + BKP + 0 + 32 + + + + + BKP1R + BKP1R + backup register + 0x54 + 0x20 + read-write + 0x00000000 + + + BKP + BKP + 0 + 32 + + + + + BKP2R + BKP2R + backup register + 0x58 + 0x20 + read-write + 0x00000000 + + + BKP + BKP + 0 + 32 + + + + + BKP3R + BKP3R + backup register + 0x5C + 0x20 + read-write + 0x00000000 + + + BKP + BKP + 0 + 32 + + + + + BKP4R + BKP4R + backup register + 0x60 + 0x20 + read-write + 0x00000000 + + + BKP + BKP + 0 + 32 + + + + + + + TIM15 + General-purpose-timers + TIM + 0x40014000 + + 0x0 + 0x400 + registers + + + TIM15 + TIM15 global interrupt + 20 + + + + CR1 + CR1 + control register 1 + 0x0 + 0x20 + read-write + 0x0000 + + + CKD + Clock division + 8 + 2 + + + ARPE + Auto-reload preload enable + 7 + 1 + + + OPM + One-pulse mode + 3 + 1 + + + URS + Update request source + 2 + 1 + + + UDIS + Update disable + 1 + 1 + + + CEN + Counter enable + 0 + 1 + + + + + CR2 + CR2 + control register 2 + 0x4 + 0x20 + read-write + 0x0000 + + + OIS2 + Output Idle state 2 + 10 + 1 + + + OIS1N + Output Idle state 1 + 9 + 1 + + + OIS1 + Output Idle state 1 + 8 + 1 + + + MMS + Master mode selection + 4 + 3 + + + CCDS + Capture/compare DMA + selection + 3 + 1 + + + CCUS + Capture/compare control update + selection + 2 + 1 + + + CCPC + Capture/compare preloaded + control + 0 + 1 + + + + + SMCR + SMCR + slave mode control register + 0x8 + 0x20 + read-write + 0x0000 + + + MSM + Master/Slave mode + 7 + 1 + + + TS + Trigger selection + 4 + 3 + + + SMS + Slave mode selection + 0 + 3 + + + + + DIER + DIER + DMA/Interrupt enable register + 0xC + 0x20 + read-write + 0x0000 + + + TDE + Trigger DMA request enable + 14 + 1 + + + CC2DE + Capture/Compare 2 DMA request + enable + 10 + 1 + + + CC1DE + Capture/Compare 1 DMA request + enable + 9 + 1 + + + UDE + Update DMA request enable + 8 + 1 + + + BIE + Break interrupt enable + 7 + 1 + + + TIE + Trigger interrupt enable + 6 + 1 + + + COMIE + COM interrupt enable + 5 + 1 + + + CC2IE + Capture/Compare 2 interrupt + enable + 2 + 1 + + + CC1IE + Capture/Compare 1 interrupt + enable + 1 + 1 + + + UIE + Update interrupt enable + 0 + 1 + + + + + SR + SR + status register + 0x10 + 0x20 + read-write + 0x0000 + + + CC2OF + Capture/compare 2 overcapture + flag + 10 + 1 + + + CC1OF + Capture/Compare 1 overcapture + flag + 9 + 1 + + + BIF + Break interrupt flag + 7 + 1 + + + TIF + Trigger interrupt flag + 6 + 1 + + + COMIF + COM interrupt flag + 5 + 1 + + + CC2IF + Capture/Compare 2 interrupt + flag + 2 + 1 + + + CC1IF + Capture/compare 1 interrupt + flag + 1 + 1 + + + UIF + Update interrupt flag + 0 + 1 + + + + + EGR + EGR + event generation register + 0x14 + 0x20 + write-only + 0x0000 + + + BG + Break generation + 7 + 1 + + + TG + Trigger generation + 6 + 1 + + + COMG + Capture/Compare control update + generation + 5 + 1 + + + CC2G + Capture/compare 2 + generation + 2 + 1 + + + CC1G + Capture/compare 1 + generation + 1 + 1 + + + UG + Update generation + 0 + 1 + + + + + CCMR1_Output + CCMR1_Output + capture/compare mode register (output + mode) + 0x18 + 0x20 + read-write + 0x00000000 + + + OC2M + Output Compare 2 mode + 12 + 3 + + + OC2PE + Output Compare 2 preload + enable + 11 + 1 + + + OC2FE + Output Compare 2 fast + enable + 10 + 1 + + + CC2S + Capture/Compare 2 + selection + 8 + 2 + + + OC1M + Output Compare 1 mode + 4 + 3 + + + OC1PE + Output Compare 1 preload + enable + 3 + 1 + + + OC1FE + Output Compare 1 fast + enable + 2 + 1 + + + CC1S + Capture/Compare 1 + selection + 0 + 2 + + + + + CCMR1_Input + CCMR1_Input + capture/compare mode register 1 (input + mode) + CCMR1_Output + 0x18 + 0x20 + read-write + 0x00000000 + + + IC2F + Input capture 2 filter + 12 + 4 + + + IC2PSC + Input capture 2 prescaler + 10 + 2 + + + CC2S + Capture/Compare 2 + selection + 8 + 2 + + + IC1F + Input capture 1 filter + 4 + 4 + + + IC1PSC + Input capture 1 prescaler + 2 + 2 + + + CC1S + Capture/Compare 1 + selection + 0 + 2 + + + + + CCER + CCER + capture/compare enable + register + 0x20 + 0x20 + read-write + 0x0000 + + + CC2NP + Capture/Compare 2 output + Polarity + 7 + 1 + + + CC2P + Capture/Compare 2 output + Polarity + 5 + 1 + + + CC2E + Capture/Compare 2 output + enable + 4 + 1 + + + CC1NP + Capture/Compare 1 output + Polarity + 3 + 1 + + + CC1NE + Capture/Compare 1 complementary output + enable + 2 + 1 + + + CC1P + Capture/Compare 1 output + Polarity + 1 + 1 + + + CC1E + Capture/Compare 1 output + enable + 0 + 1 + + + + + CNT + CNT + counter + 0x24 + 0x20 + read-write + 0x00000000 + + + CNT + counter value + 0 + 16 + + + + + PSC + PSC + prescaler + 0x28 + 0x20 + read-write + 0x0000 + + + PSC + Prescaler value + 0 + 16 + + + + + ARR + ARR + auto-reload register + 0x2C + 0x20 + read-write + 0x00000000 + + + ARR + Auto-reload value + 0 + 16 + + + + + RCR + RCR + repetition counter register + 0x30 + 0x20 + read-write + 0x0000 + + + REP + Repetition counter value + 0 + 8 + + + + + CCR1 + CCR1 + capture/compare register 1 + 0x34 + 0x20 + read-write + 0x00000000 + + + CCR1 + Capture/Compare 1 value + 0 + 16 + + + + + CCR2 + CCR2 + capture/compare register 2 + 0x38 + 0x20 + read-write + 0x00000000 + + + CCR2 + Capture/Compare 2 value + 0 + 16 + + + + + BDTR + BDTR + break and dead-time register + 0x44 + 0x20 + read-write + 0x0000 + + + MOE + Main output enable + 15 + 1 + + + AOE + Automatic output enable + 14 + 1 + + + BKP + Break polarity + 13 + 1 + + + BKE + Break enable + 12 + 1 + + + OSSR + Off-state selection for Run + mode + 11 + 1 + + + OSSI + Off-state selection for Idle + mode + 10 + 1 + + + LOCK + Lock configuration + 8 + 2 + + + DTG + Dead-time generator setup + 0 + 8 + + + + + DCR + DCR + DMA control register + 0x48 + 0x20 + read-write + 0x0000 + + + DBL + DMA burst length + 8 + 5 + + + DBA + DMA base address + 0 + 5 + + + + + DMAR + DMAR + DMA address for full transfer + 0x4C + 0x20 + read-write + 0x0000 + + + DMAB + DMA register for burst + accesses + 0 + 16 + + + + + + + TIM16 + General-purpose-timers + TIM + 0x40014400 + + 0x0 + 0x400 + registers + + + TIM16 + TIM16 global interrupt + 21 + + + + CR1 + CR1 + control register 1 + 0x0 + 0x20 + read-write + 0x0000 + + + CKD + Clock division + 8 + 2 + + + ARPE + Auto-reload preload enable + 7 + 1 + + + OPM + One-pulse mode + 3 + 1 + + + URS + Update request source + 2 + 1 + + + UDIS + Update disable + 1 + 1 + + + CEN + Counter enable + 0 + 1 + + + + + CR2 + CR2 + control register 2 + 0x4 + 0x20 + read-write + 0x0000 + + + OIS1N + Output Idle state 1 + 9 + 1 + + + OIS1 + Output Idle state 1 + 8 + 1 + + + CCDS + Capture/compare DMA + selection + 3 + 1 + + + CCUS + Capture/compare control update + selection + 2 + 1 + + + CCPC + Capture/compare preloaded + control + 0 + 1 + + + + + DIER + DIER + DMA/Interrupt enable register + 0xC + 0x20 + read-write + 0x0000 + + + TDE + Trigger DMA request enable + 14 + 1 + + + CC1DE + Capture/Compare 1 DMA request + enable + 9 + 1 + + + UDE + Update DMA request enable + 8 + 1 + + + BIE + Break interrupt enable + 7 + 1 + + + TIE + Trigger interrupt enable + 6 + 1 + + + COMIE + COM interrupt enable + 5 + 1 + + + CC1IE + Capture/Compare 1 interrupt + enable + 1 + 1 + + + UIE + Update interrupt enable + 0 + 1 + + + + + SR + SR + status register + 0x10 + 0x20 + read-write + 0x0000 + + + CC1OF + Capture/Compare 1 overcapture + flag + 9 + 1 + + + BIF + Break interrupt flag + 7 + 1 + + + TIF + Trigger interrupt flag + 6 + 1 + + + COMIF + COM interrupt flag + 5 + 1 + + + CC1IF + Capture/compare 1 interrupt + flag + 1 + 1 + + + UIF + Update interrupt flag + 0 + 1 + + + + + EGR + EGR + event generation register + 0x14 + 0x20 + write-only + 0x0000 + + + BG + Break generation + 7 + 1 + + + TG + Trigger generation + 6 + 1 + + + COMG + Capture/Compare control update + generation + 5 + 1 + + + CC1G + Capture/compare 1 + generation + 1 + 1 + + + UG + Update generation + 0 + 1 + + + + + CCMR1_Output + CCMR1_Output + capture/compare mode register (output + mode) + 0x18 + 0x20 + read-write + 0x00000000 + + + OC1M + Output Compare 1 mode + 4 + 3 + + + OC1PE + Output Compare 1 preload + enable + 3 + 1 + + + OC1FE + Output Compare 1 fast + enable + 2 + 1 + + + CC1S + Capture/Compare 1 + selection + 0 + 2 + + + + + CCMR1_Input + CCMR1_Input + capture/compare mode register 1 (input + mode) + CCMR1_Output + 0x18 + 0x20 + read-write + 0x00000000 + + + IC1F + Input capture 1 filter + 4 + 4 + + + IC1PSC + Input capture 1 prescaler + 2 + 2 + + + CC1S + Capture/Compare 1 + selection + 0 + 2 + + + + + CCER + CCER + capture/compare enable + register + 0x20 + 0x20 + read-write + 0x0000 + + + CC1NP + Capture/Compare 1 output + Polarity + 3 + 1 + + + CC1NE + Capture/Compare 1 complementary output + enable + 2 + 1 + + + CC1P + Capture/Compare 1 output + Polarity + 1 + 1 + + + CC1E + Capture/Compare 1 output + enable + 0 + 1 + + + + + CNT + CNT + counter + 0x24 + 0x20 + read-write + 0x00000000 + + + CNT + counter value + 0 + 16 + + + + + PSC + PSC + prescaler + 0x28 + 0x20 + read-write + 0x0000 + + + PSC + Prescaler value + 0 + 16 + + + + + ARR + ARR + auto-reload register + 0x2C + 0x20 + read-write + 0x00000000 + + + ARR + Auto-reload value + 0 + 16 + + + + + RCR + RCR + repetition counter register + 0x30 + 0x20 + read-write + 0x0000 + + + REP + Repetition counter value + 0 + 8 + + + + + CCR1 + CCR1 + capture/compare register 1 + 0x34 + 0x20 + read-write + 0x00000000 + + + CCR1 + Capture/Compare 1 value + 0 + 16 + + + + + BDTR + BDTR + break and dead-time register + 0x44 + 0x20 + read-write + 0x0000 + + + MOE + Main output enable + 15 + 1 + + + AOE + Automatic output enable + 14 + 1 + + + BKP + Break polarity + 13 + 1 + + + BKE + Break enable + 12 + 1 + + + OSSR + Off-state selection for Run + mode + 11 + 1 + + + OSSI + Off-state selection for Idle + mode + 10 + 1 + + + LOCK + Lock configuration + 8 + 2 + + + DTG + Dead-time generator setup + 0 + 8 + + + + + DCR + DCR + DMA control register + 0x48 + 0x20 + read-write + 0x0000 + + + DBL + DMA burst length + 8 + 5 + + + DBA + DMA base address + 0 + 5 + + + + + DMAR + DMAR + DMA address for full transfer + 0x4C + 0x20 + read-write + 0x0000 + + + DMAB + DMA register for burst + accesses + 0 + 16 + + + + + + + TIM17 + 0x40014800 + + TIM17 + TIM17 global interrupt + 22 + + + + TSC + Touch sensing controller + TSC + 0x40024000 + + 0x0 + 0x400 + registers + + + TSC + Touch sensing interrupt + 8 + + + + CR + CR + control register + 0x0 + 0x20 + read-write + 0x00000000 + + + CTPH + Charge transfer pulse high + 28 + 4 + + + CTPL + Charge transfer pulse low + 24 + 4 + + + SSD + Spread spectrum deviation + 17 + 7 + + + SSE + Spread spectrum enable + 16 + 1 + + + SSPSC + Spread spectrum prescaler + 15 + 1 + + + PGPSC + pulse generator prescaler + 12 + 3 + + + MCV + Max count value + 5 + 3 + + + IODEF + I/O Default mode + 4 + 1 + + + SYNCPOL + Synchronization pin + polarity + 3 + 1 + + + AM + Acquisition mode + 2 + 1 + + + START + Start a new acquisition + 1 + 1 + + + TSCE + Touch sensing controller + enable + 0 + 1 + + + + + IER + IER + interrupt enable register + 0x4 + 0x20 + read-write + 0x00000000 + + + MCEIE + Max count error interrupt + enable + 1 + 1 + + + EOAIE + End of acquisition interrupt + enable + 0 + 1 + + + + + ICR + ICR + interrupt clear register + 0x8 + 0x20 + read-write + 0x00000000 + + + MCEIC + Max count error interrupt + clear + 1 + 1 + + + EOAIC + End of acquisition interrupt + clear + 0 + 1 + + + + + ISR + ISR + interrupt status register + 0xC + 0x20 + read-write + 0x00000000 + + + MCEF + Max count error flag + 1 + 1 + + + EOAF + End of acquisition flag + 0 + 1 + + + + + IOHCR + IOHCR + I/O hysteresis control + register + 0x10 + 0x20 + read-write + 0xFFFFFFFF + + + G6_IO4 + G6_IO4 Schmitt trigger hysteresis + mode + 23 + 1 + + + G6_IO3 + G6_IO3 Schmitt trigger hysteresis + mode + 22 + 1 + + + G6_IO2 + G6_IO2 Schmitt trigger hysteresis + mode + 21 + 1 + + + G6_IO1 + G6_IO1 Schmitt trigger hysteresis + mode + 20 + 1 + + + G5_IO4 + G5_IO4 Schmitt trigger hysteresis + mode + 19 + 1 + + + G5_IO3 + G5_IO3 Schmitt trigger hysteresis + mode + 18 + 1 + + + G5_IO2 + G5_IO2 Schmitt trigger hysteresis + mode + 17 + 1 + + + G5_IO1 + G5_IO1 Schmitt trigger hysteresis + mode + 16 + 1 + + + G4_IO4 + G4_IO4 Schmitt trigger hysteresis + mode + 15 + 1 + + + G4_IO3 + G4_IO3 Schmitt trigger hysteresis + mode + 14 + 1 + + + G4_IO2 + G4_IO2 Schmitt trigger hysteresis + mode + 13 + 1 + + + G4_IO1 + G4_IO1 Schmitt trigger hysteresis + mode + 12 + 1 + + + G3_IO4 + G3_IO4 Schmitt trigger hysteresis + mode + 11 + 1 + + + G3_IO3 + G3_IO3 Schmitt trigger hysteresis + mode + 10 + 1 + + + G3_IO2 + G3_IO2 Schmitt trigger hysteresis + mode + 9 + 1 + + + G3_IO1 + G3_IO1 Schmitt trigger hysteresis + mode + 8 + 1 + + + G2_IO4 + G2_IO4 Schmitt trigger hysteresis + mode + 7 + 1 + + + G2_IO3 + G2_IO3 Schmitt trigger hysteresis + mode + 6 + 1 + + + G2_IO2 + G2_IO2 Schmitt trigger hysteresis + mode + 5 + 1 + + + G2_IO1 + G2_IO1 Schmitt trigger hysteresis + mode + 4 + 1 + + + G1_IO4 + G1_IO4 Schmitt trigger hysteresis + mode + 3 + 1 + + + G1_IO3 + G1_IO3 Schmitt trigger hysteresis + mode + 2 + 1 + + + G1_IO2 + G1_IO2 Schmitt trigger hysteresis + mode + 1 + 1 + + + G1_IO1 + G1_IO1 Schmitt trigger hysteresis + mode + 0 + 1 + + + + + IOASCR + IOASCR + I/O analog switch control + register + 0x18 + 0x20 + read-write + 0x00000000 + + + G6_IO4 + G6_IO4 analog switch + enable + 23 + 1 + + + G6_IO3 + G6_IO3 analog switch + enable + 22 + 1 + + + G6_IO2 + G6_IO2 analog switch + enable + 21 + 1 + + + G6_IO1 + G6_IO1 analog switch + enable + 20 + 1 + + + G5_IO4 + G5_IO4 analog switch + enable + 19 + 1 + + + G5_IO3 + G5_IO3 analog switch + enable + 18 + 1 + + + G5_IO2 + G5_IO2 analog switch + enable + 17 + 1 + + + G5_IO1 + G5_IO1 analog switch + enable + 16 + 1 + + + G4_IO4 + G4_IO4 analog switch + enable + 15 + 1 + + + G4_IO3 + G4_IO3 analog switch + enable + 14 + 1 + + + G4_IO2 + G4_IO2 analog switch + enable + 13 + 1 + + + G4_IO1 + G4_IO1 analog switch + enable + 12 + 1 + + + G3_IO4 + G3_IO4 analog switch + enable + 11 + 1 + + + G3_IO3 + G3_IO3 analog switch + enable + 10 + 1 + + + G3_IO2 + G3_IO2 analog switch + enable + 9 + 1 + + + G3_IO1 + G3_IO1 analog switch + enable + 8 + 1 + + + G2_IO4 + G2_IO4 analog switch + enable + 7 + 1 + + + G2_IO3 + G2_IO3 analog switch + enable + 6 + 1 + + + G2_IO2 + G2_IO2 analog switch + enable + 5 + 1 + + + G2_IO1 + G2_IO1 analog switch + enable + 4 + 1 + + + G1_IO4 + G1_IO4 analog switch + enable + 3 + 1 + + + G1_IO3 + G1_IO3 analog switch + enable + 2 + 1 + + + G1_IO2 + G1_IO2 analog switch + enable + 1 + 1 + + + G1_IO1 + G1_IO1 analog switch + enable + 0 + 1 + + + + + IOSCR + IOSCR + I/O sampling control register + 0x20 + 0x20 + read-write + 0x00000000 + + + G6_IO4 + G6_IO4 sampling mode + 23 + 1 + + + G6_IO3 + G6_IO3 sampling mode + 22 + 1 + + + G6_IO2 + G6_IO2 sampling mode + 21 + 1 + + + G6_IO1 + G6_IO1 sampling mode + 20 + 1 + + + G5_IO4 + G5_IO4 sampling mode + 19 + 1 + + + G5_IO3 + G5_IO3 sampling mode + 18 + 1 + + + G5_IO2 + G5_IO2 sampling mode + 17 + 1 + + + G5_IO1 + G5_IO1 sampling mode + 16 + 1 + + + G4_IO4 + G4_IO4 sampling mode + 15 + 1 + + + G4_IO3 + G4_IO3 sampling mode + 14 + 1 + + + G4_IO2 + G4_IO2 sampling mode + 13 + 1 + + + G4_IO1 + G4_IO1 sampling mode + 12 + 1 + + + G3_IO4 + G3_IO4 sampling mode + 11 + 1 + + + G3_IO3 + G3_IO3 sampling mode + 10 + 1 + + + G3_IO2 + G3_IO2 sampling mode + 9 + 1 + + + G3_IO1 + G3_IO1 sampling mode + 8 + 1 + + + G2_IO4 + G2_IO4 sampling mode + 7 + 1 + + + G2_IO3 + G2_IO3 sampling mode + 6 + 1 + + + G2_IO2 + G2_IO2 sampling mode + 5 + 1 + + + G2_IO1 + G2_IO1 sampling mode + 4 + 1 + + + G1_IO4 + G1_IO4 sampling mode + 3 + 1 + + + G1_IO3 + G1_IO3 sampling mode + 2 + 1 + + + G1_IO2 + G1_IO2 sampling mode + 1 + 1 + + + G1_IO1 + G1_IO1 sampling mode + 0 + 1 + + + + + IOCCR + IOCCR + I/O channel control register + 0x28 + 0x20 + read-write + 0x00000000 + + + G6_IO4 + G6_IO4 channel mode + 23 + 1 + + + G6_IO3 + G6_IO3 channel mode + 22 + 1 + + + G6_IO2 + G6_IO2 channel mode + 21 + 1 + + + G6_IO1 + G6_IO1 channel mode + 20 + 1 + + + G5_IO4 + G5_IO4 channel mode + 19 + 1 + + + G5_IO3 + G5_IO3 channel mode + 18 + 1 + + + G5_IO2 + G5_IO2 channel mode + 17 + 1 + + + G5_IO1 + G5_IO1 channel mode + 16 + 1 + + + G4_IO4 + G4_IO4 channel mode + 15 + 1 + + + G4_IO3 + G4_IO3 channel mode + 14 + 1 + + + G4_IO2 + G4_IO2 channel mode + 13 + 1 + + + G4_IO1 + G4_IO1 channel mode + 12 + 1 + + + G3_IO4 + G3_IO4 channel mode + 11 + 1 + + + G3_IO3 + G3_IO3 channel mode + 10 + 1 + + + G3_IO2 + G3_IO2 channel mode + 9 + 1 + + + G3_IO1 + G3_IO1 channel mode + 8 + 1 + + + G2_IO4 + G2_IO4 channel mode + 7 + 1 + + + G2_IO3 + G2_IO3 channel mode + 6 + 1 + + + G2_IO2 + G2_IO2 channel mode + 5 + 1 + + + G2_IO1 + G2_IO1 channel mode + 4 + 1 + + + G1_IO4 + G1_IO4 channel mode + 3 + 1 + + + G1_IO3 + G1_IO3 channel mode + 2 + 1 + + + G1_IO2 + G1_IO2 channel mode + 1 + 1 + + + G1_IO1 + G1_IO1 channel mode + 0 + 1 + + + + + IOGCSR + IOGCSR + I/O group control status + register + 0x30 + 0x20 + 0x00000000 + + + G8S + Analog I/O group x status + 23 + 1 + read-write + + + G7S + Analog I/O group x status + 22 + 1 + read-write + + + G6S + Analog I/O group x status + 21 + 1 + read-only + + + G5S + Analog I/O group x status + 20 + 1 + read-only + + + G4S + Analog I/O group x status + 19 + 1 + read-only + + + G3S + Analog I/O group x status + 18 + 1 + read-only + + + G2S + Analog I/O group x status + 17 + 1 + read-only + + + G1S + Analog I/O group x status + 16 + 1 + read-only + + + G8E + Analog I/O group x enable + 7 + 1 + read-write + + + G7E + Analog I/O group x enable + 6 + 1 + read-write + + + G6E + Analog I/O group x enable + 5 + 1 + read-write + + + G5E + Analog I/O group x enable + 4 + 1 + read-write + + + G4E + Analog I/O group x enable + 3 + 1 + read-write + + + G3E + Analog I/O group x enable + 2 + 1 + read-write + + + G2E + Analog I/O group x enable + 1 + 1 + read-write + + + G1E + Analog I/O group x enable + 0 + 1 + read-write + + + + + IOG1CR + IOG1CR + I/O group x counter register + 0x34 + 0x20 + read-only + 0x00000000 + + + CNT + Counter value + 0 + 14 + + + + + IOG2CR + IOG2CR + I/O group x counter register + 0x38 + 0x20 + read-only + 0x00000000 + + + CNT + Counter value + 0 + 14 + + + + + IOG3CR + IOG3CR + I/O group x counter register + 0x3C + 0x20 + read-only + 0x00000000 + + + CNT + Counter value + 0 + 14 + + + + + IOG4CR + IOG4CR + I/O group x counter register + 0x40 + 0x20 + read-only + 0x00000000 + + + CNT + Counter value + 0 + 14 + + + + + IOG5CR + IOG5CR + I/O group x counter register + 0x44 + 0x20 + read-only + 0x00000000 + + + CNT + Counter value + 0 + 14 + + + + + IOG6CR + IOG6CR + I/O group x counter register + 0x48 + 0x20 + read-only + 0x00000000 + + + CNT + Counter value + 0 + 14 + + + + + + + CEC + HDMI-CEC controller + CEC + 0x40007800 + + 0x0 + 0x400 + registers + + + CEC_CAN + CEC and CAN global interrupt + 30 + + + + CR + CR + control register + 0x0 + 0x20 + read-write + 0x00000000 + + + TXEOM + Tx End Of Message + 2 + 1 + + + TXSOM + Tx start of message + 1 + 1 + + + CECEN + CEC Enable + 0 + 1 + + + + + CFGR + CFGR + configuration register + 0x4 + 0x20 + read-write + 0x00000000 + + + LBPEGEN + Generate Error-Bit on Long Bit Period + Error + 11 + 1 + + + BREGEN + Generate error-bit on bit rising + error + 10 + 1 + + + BRESTP + Rx-stop on bit rising + error + 9 + 1 + + + RXTOL + Rx-Tolerance + 8 + 1 + + + SFT + Signal Free Time + 5 + 3 + + + LSTN + Listen mode + 4 + 1 + + + OAR + Own Address + 0 + 4 + + + + + TXDR + TXDR + Tx data register + 0x8 + 0x20 + write-only + 0x00000000 + + + TXD + Tx Data register + 0 + 8 + + + + + RXDR + RXDR + Rx Data Register + 0xC + 0x20 + read-only + 0x00000000 + + + RXDR + CEC Rx Data Register + 0 + 8 + + + + + ISR + ISR + Interrupt and Status Register + 0x10 + 0x20 + read-write + 0x00000000 + + + TXACKE + Tx-Missing acknowledge + error + 12 + 1 + + + TXERR + Tx-Error + 11 + 1 + + + TXUDR + Tx-Buffer Underrun + 10 + 1 + + + TXEND + End of Transmission + 9 + 1 + + + TXBR + Tx-Byte Request + 8 + 1 + + + ARBLST + Arbitration Lost + 7 + 1 + + + RXACKE + Rx-Missing Acknowledge + 6 + 1 + + + LBPE + Rx-Long Bit Period Error + 5 + 1 + + + SBPE + Rx-Short Bit period error + 4 + 1 + + + BRE + Rx-Bit rising error + 3 + 1 + + + RXOVR + Rx-Overrun + 2 + 1 + + + RXEND + End Of Reception + 1 + 1 + + + RXBR + Rx-Byte Received + 0 + 1 + + + + + IER + IER + interrupt enable register + 0x14 + 0x20 + read-write + 0x00000000 + + + TXACKIE + Tx-Missing Acknowledge Error Interrupt + Enable + 12 + 1 + + + TXERRIE + Tx-Error Interrupt Enable + 11 + 1 + + + TXUDRIE + Tx-Underrun interrupt + enable + 10 + 1 + + + TXENDIE + Tx-End of message interrupt + enable + 9 + 1 + + + TXBRIE + Tx-Byte Request Interrupt + Enable + 8 + 1 + + + ARBLSTIE + Arbitration Lost Interrupt + Enable + 7 + 1 + + + RXACKIE + Rx-Missing Acknowledge Error Interrupt + Enable + 6 + 1 + + + LBPEIE + Long Bit Period Error Interrupt + Enable + 5 + 1 + + + SBPEIE + Short Bit Period Error Interrupt + Enable + 4 + 1 + + + BREIE + Bit Rising Error Interrupt + Enable + 3 + 1 + + + RXOVRIE + Rx-Buffer Overrun Interrupt + Enable + 2 + 1 + + + RXENDIE + End Of Reception Interrupt + Enable + 1 + 1 + + + RXBRIE + Rx-Byte Received Interrupt + Enable + 0 + 1 + + + + + + + Flash + Flash + Flash + 0x40022000 + + 0x0 + 0x400 + registers + + + FLASH + Flash global interrupt + 3 + + + + ACR + ACR + Flash access control register + 0x0 + 0x20 + 0x00000030 + + + LATENCY + LATENCY + 0 + 3 + read-write + + + PRFTBE + PRFTBE + 4 + 1 + read-write + + + PRFTBS + PRFTBS + 5 + 1 + read-only + + + + + KEYR + KEYR + Flash key register + 0x4 + 0x20 + write-only + 0x00000000 + + + FKEYR + Flash Key + 0 + 32 + + + + + OPTKEYR + OPTKEYR + Flash option key register + 0x8 + 0x20 + write-only + 0x00000000 + + + OPTKEYR + Option byte key + 0 + 32 + + + + + SR + SR + Flash status register + 0xC + 0x20 + 0x00000000 + + + EOP + End of operation + 5 + 1 + read-write + + + WRPRT + Write protection error + 4 + 1 + read-write + + + PGERR + Programming error + 2 + 1 + read-write + + + BSY + Busy + 0 + 1 + read-only + + + + + CR + CR + Flash control register + 0x10 + 0x20 + read-write + 0x00000080 + + + FORCE_OPTLOAD + Force option byte loading + 13 + 1 + + + EOPIE + End of operation interrupt + enable + 12 + 1 + + + ERRIE + Error interrupt enable + 10 + 1 + + + OPTWRE + Option bytes write enable + 9 + 1 + + + LOCK + Lock + 7 + 1 + + + STRT + Start + 6 + 1 + + + OPTER + Option byte erase + 5 + 1 + + + OPTPG + Option byte programming + 4 + 1 + + + MER + Mass erase + 2 + 1 + + + PER + Page erase + 1 + 1 + + + PG + Programming + 0 + 1 + + + + + AR + AR + Flash address register + 0x14 + 0x20 + write-only + 0x00000000 + + + FAR + Flash address + 0 + 32 + + + + + OBR + OBR + Option byte register + 0x1C + 0x20 + read-only + 0x03FFFFF2 + + + Data1 + Data1 + 24 + 8 + + + Data0 + Data0 + 16 + 8 + + + VDDA_MONITOR + VDDA_MONITOR + 13 + 1 + + + BOOT1 + BOOT1 + 12 + 1 + + + nRST_STDBY + nRST_STDBY + 10 + 1 + + + nRST_STOP + nRST_STOP + 9 + 1 + + + WDG_SW + WDG_SW + 8 + 1 + + + LEVEL2_PROT + Level 2 protection status + 2 + 1 + + + LEVEL1_PROT + Level 1 protection status + 1 + 1 + + + OPTERR + Option byte error + 0 + 1 + + + + + WRPR + WRPR + Write protection register + 0x20 + 0x20 + read-only + 0xFFFFFFFF + + + WRP + Write protect + 0 + 32 + + + + + + + DBGMCU + Debug support + DBGMCU + 0x40015800 + + 0x0 + 0x400 + registers + + + + IDCODE + IDCODE + MCU Device ID Code Register + 0x0 + 0x20 + read-only + 0x0 + + + DEV_ID + Device Identifier + 0 + 12 + + + DIV_ID + Division Identifier + 12 + 4 + + + REV_ID + Revision Identifier + 16 + 16 + + + + + CR + CR + Debug MCU Configuration + Register + 0x4 + 0x20 + read-write + 0x0 + + + DBG_STOP + Debug Stop Mode + 1 + 1 + + + DBG_STANDBY + Debug Standby Mode + 2 + 1 + + + + + APBLFZ + APBLFZ + APB Low Freeze Register + 0x8 + 0x20 + read-write + 0x0 + + + DBG_TIMER2_STOP + Debug Timer 2 stopped when Core is + halted + 0 + 1 + + + DBG_TIMER3_STOP + Debug Timer 3 stopped when Core is + halted + 1 + 1 + + + DBG_TIMER6_STOP + Debug Timer 6 stopped when Core is + halted + 4 + 1 + + + DBG_TIMER14_STOP + Debug Timer 14 stopped when Core is + halted + 8 + 1 + + + DBG_RTC_STOP + Debug RTC stopped when Core is + halted + 10 + 1 + + + DBG_WWDG_STOP + Debug Window Wachdog stopped when Core + is halted + 11 + 1 + + + DBG_IWDG_STOP + Debug Independent Wachdog stopped when + Core is halted + 12 + 1 + + + I2C1_SMBUS_TIMEOUT + SMBUS timeout mode stopped when Core is + halted + 21 + 1 + + + + + APBHFZ + APBHFZ + APB High Freeze Register + 0xC + 0x20 + read-write + 0x0 + + + DBG_TIMER1_STOP + Debug Timer 1 stopped when Core is + halted + 11 + 1 + + + DBG_TIMER15_STO + Debug Timer 15 stopped when Core is + halted + 16 + 1 + + + DBG_TIMER16_STO + Debug Timer 16 stopped when Core is + halted + 17 + 1 + + + DBG_TIMER17_STO + Debug Timer 17 stopped when Core is + halted + 18 + 1 + + + + + + + USB + Universal serial bus full-speed device + interface + USB + 0x40005C00 + + 0x0 + 0x400 + registers + + + USB + USB global interrupt + 31 + + + + EP0R + EP0R + endpoint 0 register + 0x0 + 0x20 + read-write + 0x00000000 + + + EA + Endpoint address + 0 + 4 + + + STAT_TX + Status bits, for transmission + transfers + 4 + 2 + + + DTOG_TX + Data Toggle, for transmission + transfers + 6 + 1 + + + CTR_TX + Correct Transfer for + transmission + 7 + 1 + + + EP_KIND + Endpoint kind + 8 + 1 + + + EP_TYPE + Endpoint type + 9 + 2 + + + SETUP + Setup transaction + completed + 11 + 1 + + + STAT_RX + Status bits, for reception + transfers + 12 + 2 + + + DTOG_RX + Data Toggle, for reception + transfers + 14 + 1 + + + CTR_RX + Correct transfer for + reception + 15 + 1 + + + + + EP1R + EP1R + endpoint 1 register + 0x4 + 0x20 + read-write + 0x00000000 + + + EA + Endpoint address + 0 + 4 + + + STAT_TX + Status bits, for transmission + transfers + 4 + 2 + + + DTOG_TX + Data Toggle, for transmission + transfers + 6 + 1 + + + CTR_TX + Correct Transfer for + transmission + 7 + 1 + + + EP_KIND + Endpoint kind + 8 + 1 + + + EP_TYPE + Endpoint type + 9 + 2 + + + SETUP + Setup transaction + completed + 11 + 1 + + + STAT_RX + Status bits, for reception + transfers + 12 + 2 + + + DTOG_RX + Data Toggle, for reception + transfers + 14 + 1 + + + CTR_RX + Correct transfer for + reception + 15 + 1 + + + + + EP2R + EP2R + endpoint 2 register + 0x8 + 0x20 + read-write + 0x00000000 + + + EA + Endpoint address + 0 + 4 + + + STAT_TX + Status bits, for transmission + transfers + 4 + 2 + + + DTOG_TX + Data Toggle, for transmission + transfers + 6 + 1 + + + CTR_TX + Correct Transfer for + transmission + 7 + 1 + + + EP_KIND + Endpoint kind + 8 + 1 + + + EP_TYPE + Endpoint type + 9 + 2 + + + SETUP + Setup transaction + completed + 11 + 1 + + + STAT_RX + Status bits, for reception + transfers + 12 + 2 + + + DTOG_RX + Data Toggle, for reception + transfers + 14 + 1 + + + CTR_RX + Correct transfer for + reception + 15 + 1 + + + + + EP3R + EP3R + endpoint 3 register + 0xC + 0x20 + read-write + 0x00000000 + + + EA + Endpoint address + 0 + 4 + + + STAT_TX + Status bits, for transmission + transfers + 4 + 2 + + + DTOG_TX + Data Toggle, for transmission + transfers + 6 + 1 + + + CTR_TX + Correct Transfer for + transmission + 7 + 1 + + + EP_KIND + Endpoint kind + 8 + 1 + + + EP_TYPE + Endpoint type + 9 + 2 + + + SETUP + Setup transaction + completed + 11 + 1 + + + STAT_RX + Status bits, for reception + transfers + 12 + 2 + + + DTOG_RX + Data Toggle, for reception + transfers + 14 + 1 + + + CTR_RX + Correct transfer for + reception + 15 + 1 + + + + + EP4R + EP4R + endpoint 4 register + 0x10 + 0x20 + read-write + 0x00000000 + + + EA + Endpoint address + 0 + 4 + + + STAT_TX + Status bits, for transmission + transfers + 4 + 2 + + + DTOG_TX + Data Toggle, for transmission + transfers + 6 + 1 + + + CTR_TX + Correct Transfer for + transmission + 7 + 1 + + + EP_KIND + Endpoint kind + 8 + 1 + + + EP_TYPE + Endpoint type + 9 + 2 + + + SETUP + Setup transaction + completed + 11 + 1 + + + STAT_RX + Status bits, for reception + transfers + 12 + 2 + + + DTOG_RX + Data Toggle, for reception + transfers + 14 + 1 + + + CTR_RX + Correct transfer for + reception + 15 + 1 + + + + + EP5R + EP5R + endpoint 5 register + 0x14 + 0x20 + read-write + 0x00000000 + + + EA + Endpoint address + 0 + 4 + + + STAT_TX + Status bits, for transmission + transfers + 4 + 2 + + + DTOG_TX + Data Toggle, for transmission + transfers + 6 + 1 + + + CTR_TX + Correct Transfer for + transmission + 7 + 1 + + + EP_KIND + Endpoint kind + 8 + 1 + + + EP_TYPE + Endpoint type + 9 + 2 + + + SETUP + Setup transaction + completed + 11 + 1 + + + STAT_RX + Status bits, for reception + transfers + 12 + 2 + + + DTOG_RX + Data Toggle, for reception + transfers + 14 + 1 + + + CTR_RX + Correct transfer for + reception + 15 + 1 + + + + + EP6R + EP6R + endpoint 6 register + 0x18 + 0x20 + read-write + 0x00000000 + + + EA + Endpoint address + 0 + 4 + + + STAT_TX + Status bits, for transmission + transfers + 4 + 2 + + + DTOG_TX + Data Toggle, for transmission + transfers + 6 + 1 + + + CTR_TX + Correct Transfer for + transmission + 7 + 1 + + + EP_KIND + Endpoint kind + 8 + 1 + + + EP_TYPE + Endpoint type + 9 + 2 + + + SETUP + Setup transaction + completed + 11 + 1 + + + STAT_RX + Status bits, for reception + transfers + 12 + 2 + + + DTOG_RX + Data Toggle, for reception + transfers + 14 + 1 + + + CTR_RX + Correct transfer for + reception + 15 + 1 + + + + + EP7R + EP7R + endpoint 7 register + 0x1C + 0x20 + read-write + 0x00000000 + + + EA + Endpoint address + 0 + 4 + + + STAT_TX + Status bits, for transmission + transfers + 4 + 2 + + + DTOG_TX + Data Toggle, for transmission + transfers + 6 + 1 + + + CTR_TX + Correct Transfer for + transmission + 7 + 1 + + + EP_KIND + Endpoint kind + 8 + 1 + + + EP_TYPE + Endpoint type + 9 + 2 + + + SETUP + Setup transaction + completed + 11 + 1 + + + STAT_RX + Status bits, for reception + transfers + 12 + 2 + + + DTOG_RX + Data Toggle, for reception + transfers + 14 + 1 + + + CTR_RX + Correct transfer for + reception + 15 + 1 + + + + + CNTR + CNTR + control register + 0x40 + 0x20 + read-write + 0x00000003 + + + FRES + Force USB Reset + 0 + 1 + + + PDWN + Power down + 1 + 1 + + + LPMODE + Low-power mode + 2 + 1 + + + FSUSP + Force suspend + 3 + 1 + + + RESUME + Resume request + 4 + 1 + + + L1RESUME + LPM L1 Resume request + 5 + 1 + + + L1REQM + LPM L1 state request interrupt + mask + 7 + 1 + + + ESOFM + Expected start of frame interrupt + mask + 8 + 1 + + + SOFM + Start of frame interrupt + mask + 9 + 1 + + + RESETM + USB reset interrupt mask + 10 + 1 + + + SUSPM + Suspend mode interrupt + mask + 11 + 1 + + + WKUPM + Wakeup interrupt mask + 12 + 1 + + + ERRM + Error interrupt mask + 13 + 1 + + + PMAOVRM + Packet memory area over / underrun + interrupt mask + 14 + 1 + + + CTRM + Correct transfer interrupt + mask + 15 + 1 + + + + + ISTR + ISTR + interrupt status register + 0x44 + 0x20 + 0x00000000 + + + EP_ID + Endpoint Identifier + 0 + 4 + read-only + + + DIR + Direction of transaction + 4 + 1 + read-only + + + L1REQ + LPM L1 state request + 7 + 1 + read-write + + + ESOF + Expected start frame + 8 + 1 + read-write + + + SOF + start of frame + 9 + 1 + read-write + + + RESET + reset request + 10 + 1 + read-write + + + SUSP + Suspend mode request + 11 + 1 + read-write + + + WKUP + Wakeup + 12 + 1 + read-write + + + ERR + Error + 13 + 1 + read-write + + + PMAOVR + Packet memory area over / + underrun + 14 + 1 + read-write + + + CTR + Correct transfer + 15 + 1 + read-only + + + + + FNR + FNR + frame number register + 0x48 + 0x20 + read-only + 0x0000 + + + FN + Frame number + 0 + 11 + + + LSOF + Lost SOF + 11 + 2 + + + LCK + Locked + 13 + 1 + + + RXDM + Receive data - line status + 14 + 1 + + + RXDP + Receive data + line status + 15 + 1 + + + + + DADDR + DADDR + device address + 0x4C + 0x20 + read-write + 0x0000 + + + ADD + Device address + 0 + 7 + + + EF + Enable function + 7 + 1 + + + + + BTABLE + BTABLE + Buffer table address + 0x50 + 0x20 + read-write + 0x0000 + + + BTABLE + Buffer table + 3 + 13 + + + + + LPMCSR + LPMCSR + LPM control and status + register + 0x54 + 0x20 + 0x0000 + + + LPMEN + LPM support enable + 0 + 1 + read-write + + + LPMACK + LPM Token acknowledge + enable + 1 + 1 + read-write + + + REMWAKE + bRemoteWake value + 3 + 1 + read-only + + + BESL + BESL value + 4 + 4 + read-only + + + + + BCDR + BCDR + Battery charging detector + 0x58 + 0x20 + 0x0000 + + + BCDEN + Battery charging detector (BCD) + enable + 0 + 1 + read-write + + + DCDEN + Data contact detection (DCD) mode + enable + 1 + 1 + read-write + + + PDEN + Primary detection (PD) mode + enable + 2 + 1 + read-write + + + SDEN + Secondary detection (SD) mode + enable + 3 + 1 + read-write + + + DCDET + Data contact detection (DCD) + status + 4 + 1 + read-only + + + PDET + Primary detection (PD) + status + 5 + 1 + read-only + + + SDET + Secondary detection (SD) + status + 6 + 1 + read-only + + + PS2DET + DM pull-up detection + status + 7 + 1 + read-only + + + DPPU + DP pull-up control + 15 + 1 + read-write + + + + + + + CRS + Clock recovery system + CRS + 0x40006C00 + + 0x0 + 0x400 + registers + + + RCC_CRS + RCC and CRS global interrupts + 4 + + + + CR + CR + control register + 0x0 + 0x20 + read-write + 0x00002000 + + + TRIM + HSI48 oscillator smooth + trimming + 8 + 6 + + + SWSYNC + Generate software SYNC + event + 7 + 1 + + + AUTOTRIMEN + Automatic trimming enable + 6 + 1 + + + CEN + Frequency error counter + enable + 5 + 1 + + + ESYNCIE + Expected SYNC interrupt + enable + 3 + 1 + + + ERRIE + Synchronization or trimming error + interrupt enable + 2 + 1 + + + SYNCWARNIE + SYNC warning interrupt + enable + 1 + 1 + + + SYNCOKIE + SYNC event OK interrupt + enable + 0 + 1 + + + + + CFGR + CFGR + configuration register + 0x4 + 0x20 + read-write + 0x2022BB7F + + + SYNCPOL + SYNC polarity selection + 31 + 1 + + + SYNCSRC + SYNC signal source + selection + 28 + 2 + + + SYNCDIV + SYNC divider + 24 + 3 + + + FELIM + Frequency error limit + 16 + 8 + + + RELOAD + Counter reload value + 0 + 16 + + + + + ISR + ISR + interrupt and status register + 0x8 + 0x20 + read-only + 0x00000000 + + + FECAP + Frequency error capture + 16 + 16 + + + FEDIR + Frequency error direction + 15 + 1 + + + TRIMOVF + Trimming overflow or + underflow + 10 + 1 + + + SYNCMISS + SYNC missed + 9 + 1 + + + SYNCERR + SYNC error + 8 + 1 + + + ESYNCF + Expected SYNC flag + 3 + 1 + + + ERRF + Error flag + 2 + 1 + + + SYNCWARNF + SYNC warning flag + 1 + 1 + + + SYNCOKF + SYNC event OK flag + 0 + 1 + + + + + ICR + ICR + interrupt flag clear register + 0xC + 0x20 + read-write + 0x00000000 + + + ESYNCC + Expected SYNC clear flag + 3 + 1 + + + ERRC + Error clear flag + 2 + 1 + + + SYNCWARNC + SYNC warning clear flag + 1 + 1 + + + SYNCOKC + SYNC event OK clear flag + 0 + 1 + + + + + + + CAN + Controller area network + CAN + 0x40006400 + + 0x0 + 0x400 + registers + + + CEC_CAN + CEC and CAN global interrupt + 30 + + + + CAN_MCR + CAN_MCR + CAN_MCR + 0x0 + 0x20 + read-write + 0x00000000 + + + DBF + DBF + 16 + 1 + + + RESET + RESET + 15 + 1 + + + TTCM + TTCM + 7 + 1 + + + ABOM + ABOM + 6 + 1 + + + AWUM + AWUM + 5 + 1 + + + NART + NART + 4 + 1 + + + RFLM + RFLM + 3 + 1 + + + TXFP + TXFP + 2 + 1 + + + SLEEP + SLEEP + 1 + 1 + + + INRQ + INRQ + 0 + 1 + + + + + CAN_MSR + CAN_MSR + CAN_MSR + 0x4 + 0x20 + 0x00000000 + + + RX + RX + 11 + 1 + read-only + + + SAMP + SAMP + 10 + 1 + read-only + + + RXM + RXM + 9 + 1 + read-only + + + TXM + TXM + 8 + 1 + read-only + + + SLAKI + SLAKI + 4 + 1 + read-write + + + WKUI + WKUI + 3 + 1 + read-write + + + ERRI + ERRI + 2 + 1 + read-write + + + SLAK + SLAK + 1 + 1 + read-only + + + INAK + INAK + 0 + 1 + read-only + + + + + CAN_TSR + CAN_TSR + CAN_TSR + 0x8 + 0x20 + 0x00000000 + + + LOW2 + Lowest priority flag for mailbox + 2 + 31 + 1 + read-only + + + LOW1 + Lowest priority flag for mailbox + 1 + 30 + 1 + read-only + + + LOW0 + Lowest priority flag for mailbox + 0 + 29 + 1 + read-only + + + TME2 + Lowest priority flag for mailbox + 2 + 28 + 1 + read-only + + + TME1 + Lowest priority flag for mailbox + 1 + 27 + 1 + read-only + + + TME0 + Lowest priority flag for mailbox + 0 + 26 + 1 + read-only + + + CODE + CODE + 24 + 2 + read-only + + + ABRQ2 + ABRQ2 + 23 + 1 + read-write + + + TERR2 + TERR2 + 19 + 1 + read-write + + + ALST2 + ALST2 + 18 + 1 + read-write + + + TXOK2 + TXOK2 + 17 + 1 + read-write + + + RQCP2 + RQCP2 + 16 + 1 + read-write + + + ABRQ1 + ABRQ1 + 15 + 1 + read-write + + + TERR1 + TERR1 + 11 + 1 + read-write + + + ALST1 + ALST1 + 10 + 1 + read-write + + + TXOK1 + TXOK1 + 9 + 1 + read-write + + + RQCP1 + RQCP1 + 8 + 1 + read-write + + + ABRQ0 + ABRQ0 + 7 + 1 + read-write + + + TERR0 + TERR0 + 3 + 1 + read-write + + + ALST0 + ALST0 + 2 + 1 + read-write + + + TXOK0 + TXOK0 + 1 + 1 + read-write + + + RQCP0 + RQCP0 + 0 + 1 + read-write + + + + + CAN_RF0R + CAN_RF0R + CAN_RF0R + 0xC + 0x20 + 0x00000000 + + + RFOM0 + RFOM0 + 5 + 1 + read-write + + + FOVR0 + FOVR0 + 4 + 1 + read-write + + + FULL0 + FULL0 + 3 + 1 + read-write + + + FMP0 + FMP0 + 0 + 2 + read-only + + + + + CAN_RF1R + CAN_RF1R + CAN_RF1R + 0x10 + 0x20 + 0x00000000 + + + RFOM1 + RFOM1 + 5 + 1 + read-write + + + FOVR1 + FOVR1 + 4 + 1 + read-write + + + FULL1 + FULL1 + 3 + 1 + read-write + + + FMP1 + FMP1 + 0 + 2 + read-only + + + + + CAN_IER + CAN_IER + CAN_IER + 0x14 + 0x20 + read-write + 0x00000000 + + + SLKIE + SLKIE + 17 + 1 + + + WKUIE + WKUIE + 16 + 1 + + + ERRIE + ERRIE + 15 + 1 + + + LECIE + LECIE + 11 + 1 + + + BOFIE + BOFIE + 10 + 1 + + + EPVIE + EPVIE + 9 + 1 + + + EWGIE + EWGIE + 8 + 1 + + + FOVIE1 + FOVIE1 + 6 + 1 + + + FFIE1 + FFIE1 + 5 + 1 + + + FMPIE1 + FMPIE1 + 4 + 1 + + + FOVIE0 + FOVIE0 + 3 + 1 + + + FFIE0 + FFIE0 + 2 + 1 + + + FMPIE0 + FMPIE0 + 1 + 1 + + + TMEIE + TMEIE + 0 + 1 + + + + + CAN_ESR + CAN_ESR + CAN_ESR + 0x18 + 0x20 + 0x00000000 + + + REC + REC + 24 + 8 + read-only + + + TEC + TEC + 16 + 8 + read-only + + + LEC + LEC + 4 + 3 + read-write + + + BOFF + BOFF + 2 + 1 + read-only + + + EPVF + EPVF + 1 + 1 + read-only + + + EWGF + EWGF + 0 + 1 + read-only + + + + + CAN_BTR + CAN_BTR + CAN_BTR + 0x1C + 0x20 + read-write + 0x00000000 + + + SILM + SILM + 31 + 1 + + + LBKM + LBKM + 30 + 1 + + + SJW + SJW + 24 + 2 + + + TS2 + TS2 + 20 + 3 + + + TS1 + TS1 + 16 + 4 + + + BRP + BRP + 0 + 10 + + + + + CAN_TI0R + CAN_TI0R + CAN_TI0R + 0x180 + 0x20 + read-write + 0x00000000 + + + STID + STID + 21 + 11 + + + EXID + EXID + 3 + 18 + + + IDE + IDE + 2 + 1 + + + RTR + RTR + 1 + 1 + + + TXRQ + TXRQ + 0 + 1 + + + + + CAN_TDT0R + CAN_TDT0R + CAN_TDT0R + 0x184 + 0x20 + read-write + 0x00000000 + + + TIME + TIME + 16 + 16 + + + TGT + TGT + 8 + 1 + + + DLC + DLC + 0 + 4 + + + + + CAN_TDL0R + CAN_TDL0R + CAN_TDL0R + 0x188 + 0x20 + read-write + 0x00000000 + + + DATA3 + DATA3 + 24 + 8 + + + DATA2 + DATA2 + 16 + 8 + + + DATA1 + DATA1 + 8 + 8 + + + DATA0 + DATA0 + 0 + 8 + + + + + CAN_TDH0R + CAN_TDH0R + CAN_TDH0R + 0x18C + 0x20 + read-write + 0x00000000 + + + DATA7 + DATA7 + 24 + 8 + + + DATA6 + DATA6 + 16 + 8 + + + DATA5 + DATA5 + 8 + 8 + + + DATA4 + DATA4 + 0 + 8 + + + + + CAN_TI1R + CAN_TI1R + CAN_TI1R + 0x190 + 0x20 + read-write + 0x00000000 + + + STID + STID + 21 + 11 + + + EXID + EXID + 3 + 18 + + + IDE + IDE + 2 + 1 + + + RTR + RTR + 1 + 1 + + + TXRQ + TXRQ + 0 + 1 + + + + + CAN_TDT1R + CAN_TDT1R + CAN_TDT1R + 0x194 + 0x20 + read-write + 0x00000000 + + + TIME + TIME + 16 + 16 + + + TGT + TGT + 8 + 1 + + + DLC + DLC + 0 + 4 + + + + + CAN_TDL1R + CAN_TDL1R + CAN_TDL1R + 0x198 + 0x20 + read-write + 0x00000000 + + + DATA3 + DATA3 + 24 + 8 + + + DATA2 + DATA2 + 16 + 8 + + + DATA1 + DATA1 + 8 + 8 + + + DATA0 + DATA0 + 0 + 8 + + + + + CAN_TDH1R + CAN_TDH1R + CAN_TDH1R + 0x19C + 0x20 + read-write + 0x00000000 + + + DATA7 + DATA7 + 24 + 8 + + + DATA6 + DATA6 + 16 + 8 + + + DATA5 + DATA5 + 8 + 8 + + + DATA4 + DATA4 + 0 + 8 + + + + + CAN_TI2R + CAN_TI2R + CAN_TI2R + 0x1A0 + 0x20 + read-write + 0x00000000 + + + STID + STID + 21 + 11 + + + EXID + EXID + 3 + 18 + + + IDE + IDE + 2 + 1 + + + RTR + RTR + 1 + 1 + + + TXRQ + TXRQ + 0 + 1 + + + + + CAN_TDT2R + CAN_TDT2R + CAN_TDT2R + 0x1A4 + 0x20 + read-write + 0x00000000 + + + TIME + TIME + 16 + 16 + + + TGT + TGT + 8 + 1 + + + DLC + DLC + 0 + 4 + + + + + CAN_TDL2R + CAN_TDL2R + CAN_TDL2R + 0x1A8 + 0x20 + read-write + 0x00000000 + + + DATA3 + DATA3 + 24 + 8 + + + DATA2 + DATA2 + 16 + 8 + + + DATA1 + DATA1 + 8 + 8 + + + DATA0 + DATA0 + 0 + 8 + + + + + CAN_TDH2R + CAN_TDH2R + CAN_TDH2R + 0x1AC + 0x20 + read-write + 0x00000000 + + + DATA7 + DATA7 + 24 + 8 + + + DATA6 + DATA6 + 16 + 8 + + + DATA5 + DATA5 + 8 + 8 + + + DATA4 + DATA4 + 0 + 8 + + + + + CAN_RI0R + CAN_RI0R + CAN_RI0R + 0x1B0 + 0x20 + read-only + 0x00000000 + + + STID + STID + 21 + 11 + + + EXID + EXID + 3 + 18 + + + IDE + IDE + 2 + 1 + + + RTR + RTR + 1 + 1 + + + + + CAN_RDT0R + CAN_RDT0R + CAN_RDT0R + 0x1B4 + 0x20 + read-only + 0x00000000 + + + TIME + TIME + 16 + 16 + + + FMI + FMI + 8 + 8 + + + DLC + DLC + 0 + 4 + + + + + CAN_RDL0R + CAN_RDL0R + CAN_RDL0R + 0x1B8 + 0x20 + read-only + 0x00000000 + + + DATA3 + DATA3 + 24 + 8 + + + DATA2 + DATA2 + 16 + 8 + + + DATA1 + DATA1 + 8 + 8 + + + DATA0 + DATA0 + 0 + 8 + + + + + CAN_RDH0R + CAN_RDH0R + CAN_RDH0R + 0x1BC + 0x20 + read-only + 0x00000000 + + + DATA7 + DATA7 + 24 + 8 + + + DATA6 + DATA6 + 16 + 8 + + + DATA5 + DATA5 + 8 + 8 + + + DATA4 + DATA4 + 0 + 8 + + + + + CAN_RI1R + CAN_RI1R + CAN_RI1R + 0x1C0 + 0x20 + read-only + 0x00000000 + + + STID + STID + 21 + 11 + + + EXID + EXID + 3 + 18 + + + IDE + IDE + 2 + 1 + + + RTR + RTR + 1 + 1 + + + + + CAN_RDT1R + CAN_RDT1R + CAN_RDT1R + 0x1C4 + 0x20 + read-only + 0x00000000 + + + TIME + TIME + 16 + 16 + + + FMI + FMI + 8 + 8 + + + DLC + DLC + 0 + 4 + + + + + CAN_RDL1R + CAN_RDL1R + CAN_RDL1R + 0x1C8 + 0x20 + read-only + 0x00000000 + + + DATA3 + DATA3 + 24 + 8 + + + DATA2 + DATA2 + 16 + 8 + + + DATA1 + DATA1 + 8 + 8 + + + DATA0 + DATA0 + 0 + 8 + + + + + CAN_RDH1R + CAN_RDH1R + CAN_RDH1R + 0x1CC + 0x20 + read-only + 0x00000000 + + + DATA7 + DATA7 + 24 + 8 + + + DATA6 + DATA6 + 16 + 8 + + + DATA5 + DATA5 + 8 + 8 + + + DATA4 + DATA4 + 0 + 8 + + + + + CAN_FMR + CAN_FMR + CAN_FMR + 0x200 + 0x20 + read-write + 0x00000000 + + + CAN2SB + CAN2SB + 8 + 6 + + + FINIT + FINIT + 0 + 1 + + + + + CAN_FM1R + CAN_FM1R + CAN_FM1R + 0x204 + 0x20 + read-write + 0x00000000 + + + FBM0 + Filter mode + 0 + 1 + + + FBM1 + Filter mode + 1 + 1 + + + FBM2 + Filter mode + 2 + 1 + + + FBM3 + Filter mode + 3 + 1 + + + FBM4 + Filter mode + 4 + 1 + + + FBM5 + Filter mode + 5 + 1 + + + FBM6 + Filter mode + 6 + 1 + + + FBM7 + Filter mode + 7 + 1 + + + FBM8 + Filter mode + 8 + 1 + + + FBM9 + Filter mode + 9 + 1 + + + FBM10 + Filter mode + 10 + 1 + + + FBM11 + Filter mode + 11 + 1 + + + FBM12 + Filter mode + 12 + 1 + + + FBM13 + Filter mode + 13 + 1 + + + FBM14 + Filter mode + 14 + 1 + + + FBM15 + Filter mode + 15 + 1 + + + FBM16 + Filter mode + 16 + 1 + + + FBM17 + Filter mode + 17 + 1 + + + FBM18 + Filter mode + 18 + 1 + + + FBM19 + Filter mode + 19 + 1 + + + FBM20 + Filter mode + 20 + 1 + + + FBM21 + Filter mode + 21 + 1 + + + FBM22 + Filter mode + 22 + 1 + + + FBM23 + Filter mode + 23 + 1 + + + FBM24 + Filter mode + 24 + 1 + + + FBM25 + Filter mode + 25 + 1 + + + FBM26 + Filter mode + 26 + 1 + + + FBM27 + Filter mode + 27 + 1 + + + + + CAN_FS1R + CAN_FS1R + CAN_FS1R + 0x20C + 0x20 + read-write + 0x00000000 + + + FSC0 + Filter scale configuration + 0 + 1 + + + FSC1 + Filter scale configuration + 1 + 1 + + + FSC2 + Filter scale configuration + 2 + 1 + + + FSC3 + Filter scale configuration + 3 + 1 + + + FSC4 + Filter scale configuration + 4 + 1 + + + FSC5 + Filter scale configuration + 5 + 1 + + + FSC6 + Filter scale configuration + 6 + 1 + + + FSC7 + Filter scale configuration + 7 + 1 + + + FSC8 + Filter scale configuration + 8 + 1 + + + FSC9 + Filter scale configuration + 9 + 1 + + + FSC10 + Filter scale configuration + 10 + 1 + + + FSC11 + Filter scale configuration + 11 + 1 + + + FSC12 + Filter scale configuration + 12 + 1 + + + FSC13 + Filter scale configuration + 13 + 1 + + + FSC14 + Filter scale configuration + 14 + 1 + + + FSC15 + Filter scale configuration + 15 + 1 + + + FSC16 + Filter scale configuration + 16 + 1 + + + FSC17 + Filter scale configuration + 17 + 1 + + + FSC18 + Filter scale configuration + 18 + 1 + + + FSC19 + Filter scale configuration + 19 + 1 + + + FSC20 + Filter scale configuration + 20 + 1 + + + FSC21 + Filter scale configuration + 21 + 1 + + + FSC22 + Filter scale configuration + 22 + 1 + + + FSC23 + Filter scale configuration + 23 + 1 + + + FSC24 + Filter scale configuration + 24 + 1 + + + FSC25 + Filter scale configuration + 25 + 1 + + + FSC26 + Filter scale configuration + 26 + 1 + + + FSC27 + Filter scale configuration + 27 + 1 + + + + + CAN_FFA1R + CAN_FFA1R + CAN_FFA1R + 0x214 + 0x20 + read-write + 0x00000000 + + + FFA0 + Filter FIFO assignment for filter + 0 + 0 + 1 + + + FFA1 + Filter FIFO assignment for filter + 1 + 1 + 1 + + + FFA2 + Filter FIFO assignment for filter + 2 + 2 + 1 + + + FFA3 + Filter FIFO assignment for filter + 3 + 3 + 1 + + + FFA4 + Filter FIFO assignment for filter + 4 + 4 + 1 + + + FFA5 + Filter FIFO assignment for filter + 5 + 5 + 1 + + + FFA6 + Filter FIFO assignment for filter + 6 + 6 + 1 + + + FFA7 + Filter FIFO assignment for filter + 7 + 7 + 1 + + + FFA8 + Filter FIFO assignment for filter + 8 + 8 + 1 + + + FFA9 + Filter FIFO assignment for filter + 9 + 9 + 1 + + + FFA10 + Filter FIFO assignment for filter + 10 + 10 + 1 + + + FFA11 + Filter FIFO assignment for filter + 11 + 11 + 1 + + + FFA12 + Filter FIFO assignment for filter + 12 + 12 + 1 + + + FFA13 + Filter FIFO assignment for filter + 13 + 13 + 1 + + + FFA14 + Filter FIFO assignment for filter + 14 + 14 + 1 + + + FFA15 + Filter FIFO assignment for filter + 15 + 15 + 1 + + + FFA16 + Filter FIFO assignment for filter + 16 + 16 + 1 + + + FFA17 + Filter FIFO assignment for filter + 17 + 17 + 1 + + + FFA18 + Filter FIFO assignment for filter + 18 + 18 + 1 + + + FFA19 + Filter FIFO assignment for filter + 19 + 19 + 1 + + + FFA20 + Filter FIFO assignment for filter + 20 + 20 + 1 + + + FFA21 + Filter FIFO assignment for filter + 21 + 21 + 1 + + + FFA22 + Filter FIFO assignment for filter + 22 + 22 + 1 + + + FFA23 + Filter FIFO assignment for filter + 23 + 23 + 1 + + + FFA24 + Filter FIFO assignment for filter + 24 + 24 + 1 + + + FFA25 + Filter FIFO assignment for filter + 25 + 25 + 1 + + + FFA26 + Filter FIFO assignment for filter + 26 + 26 + 1 + + + FFA27 + Filter FIFO assignment for filter + 27 + 27 + 1 + + + + + CAN_FA1R + CAN_FA1R + CAN_FA1R + 0x21C + 0x20 + read-write + 0x00000000 + + + FACT0 + Filter active + 0 + 1 + + + FACT1 + Filter active + 1 + 1 + + + FACT2 + Filter active + 2 + 1 + + + FACT3 + Filter active + 3 + 1 + + + FACT4 + Filter active + 4 + 1 + + + FACT5 + Filter active + 5 + 1 + + + FACT6 + Filter active + 6 + 1 + + + FACT7 + Filter active + 7 + 1 + + + FACT8 + Filter active + 8 + 1 + + + FACT9 + Filter active + 9 + 1 + + + FACT10 + Filter active + 10 + 1 + + + FACT11 + Filter active + 11 + 1 + + + FACT12 + Filter active + 12 + 1 + + + FACT13 + Filter active + 13 + 1 + + + FACT14 + Filter active + 14 + 1 + + + FACT15 + Filter active + 15 + 1 + + + FACT16 + Filter active + 16 + 1 + + + FACT17 + Filter active + 17 + 1 + + + FACT18 + Filter active + 18 + 1 + + + FACT19 + Filter active + 19 + 1 + + + FACT20 + Filter active + 20 + 1 + + + FACT21 + Filter active + 21 + 1 + + + FACT22 + Filter active + 22 + 1 + + + FACT23 + Filter active + 23 + 1 + + + FACT24 + Filter active + 24 + 1 + + + FACT25 + Filter active + 25 + 1 + + + FACT26 + Filter active + 26 + 1 + + + FACT27 + Filter active + 27 + 1 + + + + + F0R1 + F0R1 + Filter bank 0 register 1 + 0x240 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F0R2 + F0R2 + Filter bank 0 register 2 + 0x244 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F1R1 + F1R1 + Filter bank 1 register 1 + 0x248 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F1R2 + F1R2 + Filter bank 1 register 2 + 0x24C + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F2R1 + F2R1 + Filter bank 2 register 1 + 0x250 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F2R2 + F2R2 + Filter bank 2 register 2 + 0x254 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F3R1 + F3R1 + Filter bank 3 register 1 + 0x258 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F3R2 + F3R2 + Filter bank 3 register 2 + 0x25C + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F4R1 + F4R1 + Filter bank 4 register 1 + 0x260 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F4R2 + F4R2 + Filter bank 4 register 2 + 0x264 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F5R1 + F5R1 + Filter bank 5 register 1 + 0x268 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F5R2 + F5R2 + Filter bank 5 register 2 + 0x26C + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F6R1 + F6R1 + Filter bank 6 register 1 + 0x270 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F6R2 + F6R2 + Filter bank 6 register 2 + 0x274 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F7R1 + F7R1 + Filter bank 7 register 1 + 0x278 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F7R2 + F7R2 + Filter bank 7 register 2 + 0x27C + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F8R1 + F8R1 + Filter bank 8 register 1 + 0x280 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F8R2 + F8R2 + Filter bank 8 register 2 + 0x284 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F9R1 + F9R1 + Filter bank 9 register 1 + 0x288 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F9R2 + F9R2 + Filter bank 9 register 2 + 0x28C + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F10R1 + F10R1 + Filter bank 10 register 1 + 0x290 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F10R2 + F10R2 + Filter bank 10 register 2 + 0x294 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F11R1 + F11R1 + Filter bank 11 register 1 + 0x298 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F11R2 + F11R2 + Filter bank 11 register 2 + 0x29C + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F12R1 + F12R1 + Filter bank 4 register 1 + 0x2A0 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F12R2 + F12R2 + Filter bank 12 register 2 + 0x2A4 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F13R1 + F13R1 + Filter bank 13 register 1 + 0x2A8 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F13R2 + F13R2 + Filter bank 13 register 2 + 0x2AC + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F14R1 + F14R1 + Filter bank 14 register 1 + 0x2B0 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F14R2 + F14R2 + Filter bank 14 register 2 + 0x2B4 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F15R1 + F15R1 + Filter bank 15 register 1 + 0x2B8 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F15R2 + F15R2 + Filter bank 15 register 2 + 0x2BC + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F16R1 + F16R1 + Filter bank 16 register 1 + 0x2C0 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F16R2 + F16R2 + Filter bank 16 register 2 + 0x2C4 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F17R1 + F17R1 + Filter bank 17 register 1 + 0x2C8 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F17R2 + F17R2 + Filter bank 17 register 2 + 0x2CC + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F18R1 + F18R1 + Filter bank 18 register 1 + 0x2D0 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F18R2 + F18R2 + Filter bank 18 register 2 + 0x2D4 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F19R1 + F19R1 + Filter bank 19 register 1 + 0x2D8 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F19R2 + F19R2 + Filter bank 19 register 2 + 0x2DC + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F20R1 + F20R1 + Filter bank 20 register 1 + 0x2E0 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F20R2 + F20R2 + Filter bank 20 register 2 + 0x2E4 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F21R1 + F21R1 + Filter bank 21 register 1 + 0x2E8 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F21R2 + F21R2 + Filter bank 21 register 2 + 0x2EC + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F22R1 + F22R1 + Filter bank 22 register 1 + 0x2F0 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F22R2 + F22R2 + Filter bank 22 register 2 + 0x2F4 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F23R1 + F23R1 + Filter bank 23 register 1 + 0x2F8 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F23R2 + F23R2 + Filter bank 23 register 2 + 0x2FC + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F24R1 + F24R1 + Filter bank 24 register 1 + 0x300 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F24R2 + F24R2 + Filter bank 24 register 2 + 0x304 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F25R1 + F25R1 + Filter bank 25 register 1 + 0x308 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F25R2 + F25R2 + Filter bank 25 register 2 + 0x30C + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F26R1 + F26R1 + Filter bank 26 register 1 + 0x310 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F26R2 + F26R2 + Filter bank 26 register 2 + 0x314 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F27R1 + F27R1 + Filter bank 27 register 1 + 0x318 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F27R2 + F27R2 + Filter bank 27 register 2 + 0x31C + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + + + diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/hooks.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/hooks.c new file mode 100644 index 00000000..f373a42a --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/hooks.c @@ -0,0 +1,295 @@ +/************************************************************************************//** +* \file Demo\ARMCM0_STM32F0_Nucleo_F091RC_GCC\Boot\hooks.c +* \brief Bootloader callback source file. +* \ingroup Boot_ARMCM0_STM32F0_Nucleo_F091RC_GCC +* \internal +*---------------------------------------------------------------------------------------- +* C O P Y R I G H T +*---------------------------------------------------------------------------------------- +* Copyright (c) 2016 by Feaser http://www.feaser.com All rights reserved +* +*---------------------------------------------------------------------------------------- +* L I C E N S E +*---------------------------------------------------------------------------------------- +* This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +* modify it under the terms of the GNU General Public License as published by the Free +* Software Foundation, either version 3 of the License, or (at your option) any later +* version. +* +* OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +* PURPOSE. See the GNU General Public License for more details. +* +* You have received a copy of the GNU General Public License along with OpenBLT. It +* should be located in ".\Doc\license.html". If not, contact Feaser to obtain a copy. +* +* \endinternal +****************************************************************************************/ + +/**************************************************************************************** +* Include files +****************************************************************************************/ +#include "boot.h" /* bootloader generic header */ +#include "led.h" /* LED driver header */ +#include "stm32f0xx.h" /* STM32 registers and drivers */ + + +/**************************************************************************************** +* B A C K D O O R E N T R Y H O O K F U N C T I O N S +****************************************************************************************/ + +#if (BOOT_BACKDOOR_HOOKS_ENABLE > 0) +/************************************************************************************//** +** \brief Initializes the backdoor entry option. +** \return none. +** +****************************************************************************************/ +void BackDoorInitHook(void) +{ +} /*** end of BackDoorInitHook ***/ + + +/************************************************************************************//** +** \brief Checks if a backdoor entry is requested. +** \return BLT_TRUE if the backdoor entry is requested, BLT_FALSE otherwise. +** +****************************************************************************************/ +blt_bool BackDoorEntryHook(void) +{ + /* default implementation always activates the bootloader after a reset */ + return BLT_TRUE; +} /*** end of BackDoorEntryHook ***/ +#endif /* BOOT_BACKDOOR_HOOKS_ENABLE > 0 */ + + +/**************************************************************************************** +* C P U D R I V E R H O O K F U N C T I O N S +****************************************************************************************/ + +#if (BOOT_CPU_USER_PROGRAM_START_HOOK > 0) +/************************************************************************************//** +** \brief Callback that gets called when the bootloader is about to exit and +** hand over control to the user program. This is the last moment that +** some final checking can be performed and if necessary prevent the +** bootloader from activiting the user program. +** \return BLT_TRUE if it is okay to start the user program, BLT_FALSE to keep +** keep the bootloader active. +** +****************************************************************************************/ +blt_bool CpuUserProgramStartHook(void) +{ + /* clean up the LED driver */ + LedBlinkExit(); + + /* additional and optional backdoor entry through the pushbutton on the board. to + * force the bootloader to stay active after reset, keep it pressed during reset. + */ + if (GPIO_ReadInputDataBit(GPIOC, GPIO_Pin_13) == Bit_RESET) + { + /* pushbutton pressed, so do not start the user program and keep the + * bootloader active instead. + */ + return BLT_FALSE; + } + /* okay to start the user program.*/ + return BLT_TRUE; +} /*** end of CpuUserProgramStartHook ***/ +#endif /* BOOT_CPU_USER_PROGRAM_START_HOOK > 0 */ + + +/**************************************************************************************** +* W A T C H D O G D R I V E R H O O K F U N C T I O N S +****************************************************************************************/ + +#if (BOOT_COP_HOOKS_ENABLE > 0) +/************************************************************************************//** +** \brief Callback that gets called at the end of the internal COP driver +** initialization routine. It can be used to configure and enable the +** watchdog. +** \return none. +** +****************************************************************************************/ +void CopInitHook(void) +{ + /* this function is called upon initialization. might as well use it to initialize + * the LED driver. It is kind of a visual watchdog anyways. + */ + LedBlinkInit(100); +} /*** end of CopInitHook ***/ + + +/************************************************************************************//** +** \brief Callback that gets called at the end of the internal COP driver +** service routine. This gets called upon initialization and during +** potential long lasting loops and routine. It can be used to service +** the watchdog to prevent a watchdog reset. +** \return none. +** +****************************************************************************************/ +void CopServiceHook(void) +{ + /* run the LED blink task. this is a better place to do it than in the main() program + * loop. certain operations such as flash erase can take a long time, which would cause + * a blink interval to be skipped. this function is also called during such operations, + * so no blink intervals will be skipped when calling the LED blink task here. + */ + LedBlinkTask(); +} /*** end of CopServiceHook ***/ +#endif /* BOOT_COP_HOOKS_ENABLE > 0 */ + + +/**************************************************************************************** +* N O N - V O L A T I L E M E M O R Y D R I V E R H O O K F U N C T I O N S +****************************************************************************************/ + +#if (BOOT_NVM_HOOKS_ENABLE > 0) +/************************************************************************************//** +** \brief Callback that gets called at the start of the internal NVM driver +** initialization routine. +** \return none. +** +****************************************************************************************/ +void NvmInitHook(void) +{ +} /*** end of NvmInitHook ***/ + + +/************************************************************************************//** +** \brief Callback that gets called at the start of the NVM driver write +** routine. It allows additional memory to be operated on. If the address +** is not within the range of the additional memory, then +** BLT_NVM_NOT_IN_RANGE must be returned to indicate that the data hasn't +** been written yet. +** \param addr Start address. +** \param len Length in bytes. +** \param data Pointer to the data buffer. +** \return BLT_NVM_OKAY if successful, BLT_NVM_NOT_IN_RANGE if the address is +** not within the supported memory range, or BLT_NVM_ERROR is the write +** operation failed. +** +****************************************************************************************/ +blt_int8u NvmWriteHook(blt_addr addr, blt_int32u len, blt_int8u *data) +{ + return BLT_NVM_NOT_IN_RANGE; +} /*** end of NvmWriteHook ***/ + + +/************************************************************************************//** +** \brief Callback that gets called at the start of the NVM driver erase +** routine. It allows additional memory to be operated on. If the address +** is not within the range of the additional memory, then +** BLT_NVM_NOT_IN_RANGE must be returned to indicate that the memory +** hasn't been erased yet. +** \param addr Start address. +** \param len Length in bytes. +** \return BLT_NVM_OKAY if successful, BLT_NVM_NOT_IN_RANGE if the address is +** not within the supported memory range, or BLT_NVM_ERROR is the erase +** operation failed. +** +****************************************************************************************/ +blt_int8u NvmEraseHook(blt_addr addr, blt_int32u len) +{ + return BLT_NVM_NOT_IN_RANGE; +} /*** end of NvmEraseHook ***/ + + +/************************************************************************************//** +** \brief Callback that gets called at the end of the NVM programming session. +** \return BLT_TRUE is successful, BLT_FALSE otherwise. +** +****************************************************************************************/ +blt_bool NvmDoneHook(void) +{ + return BLT_TRUE; +} /*** end of NvmDoneHook ***/ +#endif /* BOOT_NVM_HOOKS_ENABLE > 0 */ + + +#if (BOOT_NVM_CHECKSUM_HOOKS_ENABLE > 0) +/************************************************************************************//** +** \brief Verifies the checksum, which indicates that a valid user program is +** present and can be started. +** \return BLT_TRUE if successful, BLT_FALSE otherwise. +** +****************************************************************************************/ +blt_bool NvmVerifyChecksumHook(void) +{ + return BLT_TRUE; +} /*** end of NvmVerifyChecksum ***/ + + +/************************************************************************************//** +** \brief Writes a checksum of the user program to non-volatile memory. This is +** performed once the entire user program has been programmed. Through +** the checksum, the bootloader can check if a valid user programming is +** present and can be started. +** \return BLT_TRUE if successful, BLT_FALSE otherwise. +** +****************************************************************************************/ +blt_bool NvmWriteChecksumHook(void) +{ + return BLT_TRUE; +} +#endif /* BOOT_NVM_CHECKSUM_HOOKS_ENABLE > 0 */ + + +/**************************************************************************************** +* S E E D / K E Y S E C U R I T Y H O O K F U N C T I O N S +****************************************************************************************/ + +#if (BOOT_XCP_SEED_KEY_ENABLE > 0) +/************************************************************************************//** +** \brief Provides a seed to the XCP master that will be used for the key +** generation when the master attempts to unlock the specified resource. +** Called by the GET_SEED command. +** \param resource Resource that the seed if requested for (XCP_RES_XXX). +** \param seed Pointer to byte buffer wher the seed will be stored. +** \return Length of the seed in bytes. +** +****************************************************************************************/ +blt_int8u XcpGetSeedHook(blt_int8u resource, blt_int8u *seed) +{ + /* request seed for unlocking ProGraMming resource */ + if ((resource & XCP_RES_PGM) != 0) + { + seed[0] = 0x55; + } + + /* return seed length */ + return 1; +} /*** end of XcpGetSeedHook ***/ + + +/************************************************************************************//** +** \brief Called by the UNLOCK command and checks if the key to unlock the +** specified resource was correct. If so, then the resource protection +** will be removed. +** \param resource resource to unlock (XCP_RES_XXX). +** \param key pointer to the byte buffer holding the key. +** \param len length of the key in bytes. +** \return 1 if the key was correct, 0 otherwise. +** +****************************************************************************************/ +blt_int8u XcpVerifyKeyHook(blt_int8u resource, blt_int8u *key, blt_int8u len) +{ + /* suppress compiler warning for unused parameter */ + len = len; + + /* the example key algorithm in "FeaserKey.dll" works as follows: + * - PGM will be unlocked if key = seed - 1 + */ + + /* check key for unlocking ProGraMming resource */ + if ((resource == XCP_RES_PGM) && (key[0] == (0x55-1))) + { + /* correct key received for unlocking PGM resource */ + return 1; + } + + /* still here so key incorrect */ + return 0; +} /*** end of XcpVerifyKeyHook ***/ +#endif /* BOOT_XCP_SEED_KEY_ENABLE > 0 */ + + +/*********************************** end of hooks.c ************************************/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/ide/stm32f091.depend b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/ide/stm32f091.depend new file mode 100644 index 00000000..b1b7947d --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/ide/stm32f091.depend @@ -0,0 +1,567 @@ +# depslib dependency file v1.0 +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_adc.c + "stm32f0xx_adc.h" + "stm32f0xx_rcc.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_adc.h + "stm32f0xx.h" + +1417710862 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\stm32f0xx.h + "core_cm0.h" + "system_stm32f0xx.h" + + "stm32f0xx_conf.h" + +1417516674 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\cmsis\core_cm0.h + + + + +1417516674 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\cmsis\core_cminstr.h + + + +1417516674 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\cmsis\core_cmfunc.h + + + +1417714462 c:\users\voorburg\desktop\stm32f091_emblocks_os\src\hw\system_stm32f0xx.h + +1417516578 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\stm32f0xx_conf.h + "stm32f0xx_adc.h" + "stm32f0xx_can.h" + "stm32f0xx_cec.h" + "stm32f0xx_comp.h" + "stm32f0xx_crc.h" + "stm32f0xx_crs.h" + "stm32f0xx_dac.h" + "stm32f0xx_dbgmcu.h" + "stm32f0xx_dma.h" + "stm32f0xx_exti.h" + "stm32f0xx_flash.h" + "stm32f0xx_gpio.h" + "stm32f0xx_i2c.h" + "stm32f0xx_iwdg.h" + "stm32f0xx_pwr.h" + "stm32f0xx_rcc.h" + "stm32f0xx_rtc.h" + "stm32f0xx_spi.h" + "stm32f0xx_syscfg.h" + "stm32f0xx_tim.h" + "stm32f0xx_usart.h" + "stm32f0xx_wwdg.h" + "stm32f0xx_misc.h" + +1417710865 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_can.h + "stm32f0xx.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_cec.h + "stm32f0xx.h" + +1417710865 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_comp.h + "stm32f0xx.h" + +1417710865 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_crc.h + "stm32f0xx.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_crs.h + "stm32f0xx.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_dac.h + "stm32f0xx.h" + +1417710865 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_dbgmcu.h + "stm32f0xx.h" + +1417710865 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_dma.h + "stm32f0xx.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_exti.h + "stm32f0xx.h" + +1417710865 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_flash.h + "stm32f0xx.h" + +1417710865 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_gpio.h + "stm32f0xx.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_i2c.h + "stm32f0xx.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_iwdg.h + "stm32f0xx.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_pwr.h + "stm32f0xx.h" + +1417710865 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_rcc.h + "stm32f0xx.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_rtc.h + "stm32f0xx.h" + +1417710865 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_spi.h + "stm32f0xx.h" + +1417710865 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_syscfg.h + "stm32f0xx.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_tim.h + "stm32f0xx.h" + +1417710865 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_usart.h + "stm32f0xx.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_wwdg.h + "stm32f0xx.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_misc.h + "stm32f0xx.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_can.c + "stm32f0xx_can.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_cec.c + "stm32f0xx_cec.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_comp.c + "stm32f0xx_comp.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_crc.c + "stm32f0xx_crc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_crs.c + "stm32f0xx_crs.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_dac.c + "stm32f0xx_dac.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_dbgmcu.c + "stm32f0xx_dbgmcu.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_dma.c + "stm32f0xx_dma.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_exti.c + "stm32f0xx_exti.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_flash.c + "stm32f0xx_flash.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_gpio.c + "stm32f0xx_gpio.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_i2c.c + "stm32f0xx_i2c.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_iwdg.c + "stm32f0xx_iwdg.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_misc.c + "stm32f0xx_misc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_pwr.c + "stm32f0xx_pwr.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_rcc.c + "stm32f0xx_rcc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_rtc.c + "stm32f0xx_rtc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_spi.c + "stm32f0xx_spi.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_syscfg.c + "stm32f0xx_syscfg.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_tim.c + "stm32f0xx_tim.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_usart.c + "stm32f0xx_usart.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_wwdg.c + "stm32f0xx_wwdg.h" + "stm32f0xx_rcc.h" + +1479203609 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\src\app\app.c + "header.h" + +1461835068 c:\users\voorburg\desktop\stm32f091_emblocks_os\src\header.h + + + "os.h" + "hw.h" + "app.h" + +1452182352 c:\users\voorburg\desktop\stm32f091_emblocks_os\src\os\os.h + +1461835274 c:\users\voorburg\desktop\stm32f091_emblocks_os\src\hw\hw.h + "stm32f0xx_conf.h" + "led.h" + +1452182499 c:\users\voorburg\desktop\stm32f091_emblocks_os\src\hw\led.h + +1452182185 c:\users\voorburg\desktop\stm32f091_emblocks_os\src\app\app.h + "assert.h" + +1452181838 c:\users\voorburg\desktop\stm32f091_emblocks_os\src\app\assert.h + +1452181962 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\src\app\assert.c + "header.h" + +1461835384 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\src\hw\hw.c + "header.h" + +1471419376 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\src\hw\startup_stm32f0xx.s + +1471422675 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\src\hw\system_stm32f0xx.c + "stm32f0xx.h" + +1452182352 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\src\os\os.c + "os.h" + +1471421727 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\src\hw\led.c + "header.h" + +1417710862 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\system_stm32f0xx.h + +1471419075 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\system_stm32f0xx.c + "stm32f0xx.h" + +1479209122 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\hooks.c + "boot.h" + "led.h" + "stm32f0xx.h" + +1477216154 c:\work\software\openblt\target\source\boot.h + "types.h" + "assert.h" + "blt_conf.h" + "plausibility.h" + "cpu.h" + "cop.h" + "nvm.h" + "timer.h" + "backdoor.h" + "file.h" + "com.h" + +1477294386 c:\work\software\openblt\target\source\armcm0_stm32f0\types.h + +1469431761 c:\work\software\openblt\target\source\assert.h + +1479210119 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\blt_conf.h + +1469431761 c:\work\software\openblt\target\source\plausibility.h + +1476728168 c:\work\software\openblt\target\source\cpu.h + +1469431761 c:\work\software\openblt\target\source\cop.h + +1469431761 c:\work\software\openblt\target\source\nvm.h + +1469431761 c:\work\software\openblt\target\source\timer.h + +1469431761 c:\work\software\openblt\target\source\backdoor.h + +1469431761 c:\work\software\openblt\target\source\file.h + "ff.h" + +1469431761 c:\work\software\openblt\target\source\com.h + "xcp.h" + +1476783465 c:\work\software\openblt\target\source\xcp.h + +1479203921 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\led.h + +1417710862 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\stm32f0xx.h + "core_cm0.h" + "system_stm32f0xx.h" + + "stm32f0xx_conf.h" + +1417516674 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\cmsis\core_cm0.h + + + + +1417516674 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\cmsis\core_cminstr.h + + + +1417516674 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\cmsis\core_cmfunc.h + + + +1417710862 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\system_stm32f0xx.h + +1417516578 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\stm32f0xx_conf.h + "stm32f0xx_adc.h" + "stm32f0xx_can.h" + "stm32f0xx_cec.h" + "stm32f0xx_comp.h" + "stm32f0xx_crc.h" + "stm32f0xx_crs.h" + "stm32f0xx_dac.h" + "stm32f0xx_dbgmcu.h" + "stm32f0xx_dma.h" + "stm32f0xx_exti.h" + "stm32f0xx_flash.h" + "stm32f0xx_gpio.h" + "stm32f0xx_i2c.h" + "stm32f0xx_iwdg.h" + "stm32f0xx_pwr.h" + "stm32f0xx_rcc.h" + "stm32f0xx_rtc.h" + "stm32f0xx_spi.h" + "stm32f0xx_syscfg.h" + "stm32f0xx_tim.h" + "stm32f0xx_usart.h" + "stm32f0xx_wwdg.h" + "stm32f0xx_misc.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_adc.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_can.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_cec.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_comp.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_crc.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_crs.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_dac.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_dbgmcu.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_dma.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_exti.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_flash.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_gpio.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_i2c.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_iwdg.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_pwr.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_rcc.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_rtc.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_spi.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_syscfg.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_tim.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_usart.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_wwdg.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_misc.h + "stm32f0xx.h" + +1479225073 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\led.c + "boot.h" + "led.h" + "stm32f0xx.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_adc.c + "stm32f0xx_adc.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_can.c + "stm32f0xx_can.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_cec.c + "stm32f0xx_cec.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_comp.c + "stm32f0xx_comp.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_crc.c + "stm32f0xx_crc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_crs.c + "stm32f0xx_crs.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_dac.c + "stm32f0xx_dac.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_dbgmcu.c + "stm32f0xx_dbgmcu.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_dma.c + "stm32f0xx_dma.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_exti.c + "stm32f0xx_exti.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_flash.c + "stm32f0xx_flash.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_gpio.c + "stm32f0xx_gpio.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_i2c.c + "stm32f0xx_i2c.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_iwdg.c + "stm32f0xx_iwdg.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_misc.c + "stm32f0xx_misc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_pwr.c + "stm32f0xx_pwr.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_rcc.c + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_rtc.c + "stm32f0xx_rtc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_spi.c + "stm32f0xx_spi.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_syscfg.c + "stm32f0xx_syscfg.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_tim.c + "stm32f0xx_tim.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_usart.c + "stm32f0xx_usart.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_wwdg.c + "stm32f0xx_wwdg.h" + "stm32f0xx_rcc.h" + +1471419075 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\system_stm32f0xx.c + "stm32f0xx.h" + +1479225127 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\main.c + "boot.h" + "stm32f0xx.h" + +1477294428 source:c:\work\software\openblt\target\source\armcm0_stm32f0\cpu.c + "boot.h" + "stm32f0xx.h" + +1477294420 source:c:\work\software\openblt\target\source\armcm0_stm32f0\flash.c + "boot.h" + "stm32f0xx.h" + "flash_layout.c" + +1477294453 source:c:\work\software\openblt\target\source\armcm0_stm32f0\gcc\cpu_comp.c + "boot.h" + +1476741290 source:c:\work\software\openblt\target\source\armcm0_stm32f0\gcc\cstart.s + +1477294404 source:c:\work\software\openblt\target\source\armcm0_stm32f0\nvm.c + "boot.h" + "flash.h" + +1477294413 c:\work\software\openblt\target\source\armcm0_stm32f0\flash.h + +1477294395 source:c:\work\software\openblt\target\source\armcm0_stm32f0\timer.c + "boot.h" + "stm32f0xx.h" + +1479207236 source:c:\work\software\openblt\target\source\armcm0_stm32f0\uart.c + "boot.h" + "stm32f0xx.h" + +1477295250 source:c:\work\software\openblt\target\source\assert.c + "boot.h" + +1469431756 source:c:\work\software\openblt\target\source\backdoor.c + "boot.h" + +1476728156 source:c:\work\software\openblt\target\source\boot.c + "boot.h" + +1469431756 source:c:\work\software\openblt\target\source\com.c + "boot.h" + "can.h" + "uart.h" + "usb.h" + "net.h" + +1469431761 c:\work\software\openblt\target\source\can.h + +1469431761 c:\work\software\openblt\target\source\uart.h + +1469431761 c:\work\software\openblt\target\source\usb.h + +1469431761 c:\work\software\openblt\target\source\net.h + +1469431756 source:c:\work\software\openblt\target\source\cop.c + "boot.h" + +1469281006 source:c:\work\software\openblt\target\source\file.c + "boot.h" + + + +1469431757 source:c:\work\software\openblt\target\source\net.c + "boot.h" + "netdev.h" + "uip.h" + "uip_arp.h" + +1476783463 source:c:\work\software\openblt\target\source\xcp.c + "boot.h" + +1479224789 source:c:\work\software\openblt\target\source\armcm0_stm32f0\can.c + "boot.h" + "stm32f0xx.h" + diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/ide/stm32f091.ebp b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/ide/stm32f091.ebp new file mode 100644 index 00000000..92d14c3f --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/ide/stm32f091.ebp @@ -0,0 +1,410 @@ + + + + + + + diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/ide/stm32f091.elay b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/ide/stm32f091.elay new file mode 100644 index 00000000..bd626080 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/ide/stm32f091.elay @@ -0,0 +1,94 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/led.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/led.c new file mode 100644 index 00000000..b9ee8cc2 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/led.c @@ -0,0 +1,100 @@ +/************************************************************************************//** +* \file Demo\ARMCM0_STM32F0_Nucleo_F091RC_GCC\Boot\led.c +* \brief LED driver source file. +* \ingroup Boot_ARMCM0_STM32F0_Nucleo_F091RC_GCC +* \internal +*---------------------------------------------------------------------------------------- +* C O P Y R I G H T +*---------------------------------------------------------------------------------------- +* Copyright (c) 2016 by Feaser http://www.feaser.com All rights reserved +* +*---------------------------------------------------------------------------------------- +* L I C E N S E +*---------------------------------------------------------------------------------------- +* This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +* modify it under the terms of the GNU General Public License as published by the Free +* Software Foundation, either version 3 of the License, or (at your option) any later +* version. +* +* OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +* PURPOSE. See the GNU General Public License for more details. +* +* You have received a copy of the GNU General Public License along with OpenBLT. It +* should be located in ".\Doc\license.html". If not, contact Feaser to obtain a copy. +* +* \endinternal +****************************************************************************************/ + +/**************************************************************************************** +* Include files +****************************************************************************************/ +#include "boot.h" /* bootloader generic header */ +#include "led.h" /* module header */ +#include "stm32f0xx.h" /* STM32 registers and drivers */ + + +/**************************************************************************************** +* Local data declarations +****************************************************************************************/ +/** \brief Holds the desired LED blink interval time. */ +static blt_int16u ledBlinkIntervalMs; + + +/************************************************************************************//** +** \brief Initializes the LED blink driver. +** \param interval_ms Specifies the desired LED blink interval time in milliseconds. +** \return none. +** +****************************************************************************************/ +void LedBlinkInit(blt_int16u interval_ms) +{ + /* store the interval time between LED toggles */ + ledBlinkIntervalMs = interval_ms; +} /*** end of LedBlinkInit ***/ + + +/************************************************************************************//** +** \brief Task function for blinking the LED as a fixed timer interval. +** \return none. +** +****************************************************************************************/ +void LedBlinkTask(void) +{ + static blt_bool ledOn = BLT_FALSE; + static blt_int32u nextBlinkEvent = 0; + + /* check for blink event */ + if (TimerGet() >= nextBlinkEvent) + { + /* toggle the LED state */ + if (ledOn == BLT_FALSE) + { + ledOn = BLT_TRUE; + GPIO_SetBits(GPIOA, GPIO_Pin_5); + } + else + { + ledOn = BLT_FALSE; + GPIO_ResetBits(GPIOA, GPIO_Pin_5); + } + /* schedule the next blink event */ + nextBlinkEvent = TimerGet() + ledBlinkIntervalMs; + } +} /*** end of LedBlinkTask ***/ + + +/************************************************************************************//** +** \brief Cleans up the LED blink driver. This is intended to be used upon program +** exit. +** \return none. +** +****************************************************************************************/ +void LedBlinkExit(void) +{ + /* turn the LED off */ + GPIO_ResetBits(GPIOA, GPIO_Pin_5); +} /*** end of LedBlinkExit ***/ + + +/*********************************** end of led.c **************************************/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/led.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/led.h new file mode 100644 index 00000000..653debde --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/led.h @@ -0,0 +1,40 @@ +/************************************************************************************//** +* \file Demo\ARMCM0_STM32F0_Nucleo_F091RC_GCC\Boot\led.h +* \brief LED driver header file. +* \ingroup Boot_ARMCM0_STM32F0_Nucleo_F091RC_GCC +* \internal +*---------------------------------------------------------------------------------------- +* C O P Y R I G H T +*---------------------------------------------------------------------------------------- +* Copyright (c) 2016 by Feaser http://www.feaser.com All rights reserved +* +*---------------------------------------------------------------------------------------- +* L I C E N S E +*---------------------------------------------------------------------------------------- +* This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +* modify it under the terms of the GNU General Public License as published by the Free +* Software Foundation, either version 3 of the License, or (at your option) any later +* version. +* +* OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +* PURPOSE. See the GNU General Public License for more details. +* +* You have received a copy of the GNU General Public License along with OpenBLT. It +* should be located in ".\Doc\license.html". If not, contact Feaser to obtain a copy. +* +* \endinternal +****************************************************************************************/ +#ifndef LED_H +#define LED_H + +/**************************************************************************************** +* Function prototypes +****************************************************************************************/ +void LedBlinkInit(blt_int16u interval_ms); +void LedBlinkTask(void); +void LedBlinkExit(void); + + +#endif /* LED_H */ +/*********************************** end of led.h **************************************/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/Release_Notes.html b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/Release_Notes.html new file mode 100644 index 00000000..e3f0d1de --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/Release_Notes.html @@ -0,0 +1,390 @@ + + + + + + + + + + +Release Notes for STM32F0xx Standard Peripherals Library Drivers + + + + + + +

+


+

+
+ + + + + + +
+ + + + + + +
+ +

Release +Notes for STM32F0xx Standard Peripherals Drivers
+

+

Copyright +© 2014 STMicroelectronics

+

+
+ + + + + + + +
+

Update history

V1.5.0 / 05-December-2015

Main +Changes

+
  • Add support of the STM32F070xB, STM32F070x6 and STM32F030xC  devices.
  • stm32f0xx_flash.c/.h: update for STM32F070xB, STM32F070x6 and STM32F030xC devices

V1.4.0 / 24-July-2014

Main +Changes

+
  • Add support of the STM32F091 devices.
  • stm32f0xx_dma.c/.h: update for STM32F091 devices
    • Add the support of the DMA2 channels.
    • Add new function "void DMA_RemapConfig(DMA_TypeDef* DMAy, uint32_t DMAx_CHy_RemapRequest);"
  • stm32f0xx_flash.c/.h: update for STM32F091 devices
    • Add definition for new option bytes on the STM32F091 devices.
  • stm32f0xx_gpio.c/.h: update for STM32F091 devices
    • Update the GPIO_AF definition comments with the new supported alternate functions
  • stm32f0xx_rcc.c/.h: update for STM32F091 devices
    • Add USART3CLK_Frequency fields in the RCC_ClocksTypeDef structure.
      +
    • Add definition for USART3 clock sources
    • Add USART4, USART5, USART6, USART7 and USART8 clock and reset configuration.
    • Add DMA2 clock configuration.
  • stm32f0xx_syscfg.c/.h: update for STM32F091 devices
    • Add new function "void SYSCFG_IRDAEnvSelection(uint32_t SYSCFG_IRDAEnv);"
    • Add new function "uint32_t SYSCFG_GetPendingIT(uint32_t ITSourceLine);"
  • stm32f0xx_usart.c/.h:  update for STM32F091 devices
    • Add support of the USART3,USART4, USART5, USART6, USART7 and USART8.
  • stm32f0xx_pwr.c 
    • Fix +PWR_EnterSTANDBYMode() to not clear Wakeup flag (WUF), this flag need +to be cleared at application level before to call this function 
    • PWR_EnterSleepMode(): +update usage of __WFE() in low power entry function. If there is a +pending event, calling __WFE() instruction, the CortexM0 core will not +enter to sleep mode. The solution is to make the call below: the first +__WFE() is always ignored and clears the event if one was already +pending, the second is always applied

      __SEV()
      __WFE()
      __WFE()

V1.3.0 / 16-January-2014

Main +Changes

+
  • Add support of the STM32042 and STM32F072 devices.
  • Update to support the new STM32F0xx family devices names.
    • STM32F0XX_MD  replaced by STM32F051
    • STM32F0XX_LD  replaced by STM32F031
    • STM32F030x8 and STM32F030x6 replaced by STM32F030
  • Add Clock Recovery System(CRS) driver.
  • Add CAN driver.
  • Update RCC driver to manage the High Speed Internal RC48MHz oscillator.
  • stm32f0xx_adc.c/.h: update for STM32F042 and STM32F072 devices
    • Add note to no more use the ADC_JitterOff definition as obsolete and maintained for legacy purpose. They are replaced by ADC_ClockMode definition.
    • Add new ADC_ClockMode definition for proper ADC clock configuration.
    • Update ADC_FLAG_ADSTP definition.
    • Update ADC_FLAG_ADCAL definition.
    • Add ADC_ClockModeConfig() function for proper ADC clock configuration.
    • Add note to no more use the ADC_JitterCmd() function as obsolete.
  • stm32f0xx_comp.c/.h: update for STM32F042 and STM32F072 devices
    • Add define for the COMP_InvertingInput_DAC2.
  • stm32f0xx_crc.c/.h: update for STM32F042 and STM32F072 devices
    • Add definition for the CRC Polynomial Size.
    • Add CRC_SetPolynomial(), CRC_CalcCRC16bits(), CRC_PolynomialSizeSelect(), CRC_CalcCRC16bits(), CRC_CalcCRC8bits() functions for the polynomial configuration management.
  • stm32f0xx_dac.c/.h: update for STM32F042 and STM32F072 devices
    • Add DAC_WaveGeneration and DAC_LFSRUnmask_TriangleAmplitude fields in the DAC_InitTypeDef structure. 
    • Add DAC_WaveGeneration definitions.
    • Add DAC_lfsrunmask_triangleamplitude definitions.
    • Add definition for DAC_Channel_2.
    • Add DAC_DualSoftwareTriggerCmd(), DAC_WaveGenerationCmd(), DAC_SetChannel2Data(), DAC_SetDualChannelData() for wave generation and dual channel management.
  • stm32f0xx_dbgmcu.c/.h: update for STM32F042 and STM32F072 devices
    • Add define for DBGMCU_TIM7_STOP.
    • Add define for DBGMCU_CAN1_STOP.
  • stm32f0xx_dma.c/.h: update for STM32F042 and STM32F072 devices
    • Add the support of the DMA channel 6 and DMA Channel 7
  • stm32f0xx_exti.c/.h: update for STM32F042 and STM32F072 devices
    • Add defines for EXTI Lines 18, 20, 26 and 31.
  • stm32f0xx_flash.c/.h: update for STM32F042 and STM32F072 devices
    • Add definition for option bytes on the STM32F072 devices.
    • Update IS_FLASH_CLEAR_FLAG macro definition.
    • Add definition of the BOOT0 and BOOT0_SW option bytes.
    • Add FLASH_OB_BOOT0Config() and FLASH_OB_BOOT0SWConfig() function for the BOOT0 Option bytes configuration.
  • stm32f0xx_gpio.c/.h: update for STM32F042 and STM32F072 devices
    • Add the support of the PortE.
    • Update the GPIO_AF definition comments with the new supported alternate functions
  • stm32f0xx_pwr.c/.h: update for STM32F042 and STM32F072 devices
    • Add definition for Wake up pins 3, 4, 5, 6, 7 and 8.
    • Update PWR_EnterSTOPMode() function to support of the SLEEPONEXIT entry mode.
  • stm32f0xx_rcc.c/.h: update for STM32F042 and STM32F072 devices
    • Replace references to STM32F0XX_MD device definition by STM32F051.
    • Add USART2CLK_Frequency and  USBCLK_Frequency fields in the RCC_ClocksTypeDef structure.
      +
    • Add definition of HSE, HSI48 and HSI clocks as new PLL clock sources.
    • Add definition of HSI48 clock as system clock source.
    • Add definition for USB clock sources.
    • Add definition for USART2 clock sources
    • Add definition for HSI48 and PLL clock as MCO sources
    • Add RCC_HSI48Cmd() and RCC_GetHSI48CalibrationValue() functions for the HSI48 clock source management.
    • Add RCC_USBCLKConfig() function for USB clock management.
    • Add note to no more use the RCC_ADCCLKConfig() as obsolete, however maintained for legacy purpose. Proper ADC clock configuration is managed by new function ADC_ClockModeConfig() available within the ADC driver.
  • stm32f0xx_rtc.c/.h: update for STM32F042 and STM32F072 devices
    • Add definition of the Tamper 3.
    • Add definiton for the Wake up counter in the RTC output selection
    • Add RTC_WakeUpClockConfig(), RTC_SetWakeUpCounter(), RTC_GetWakeUpCounter(), RTC_WakeUpCmd() functions for the wakeup counter configuration.
  • stm32f0xx_syscfg.c/.h: update for STM32F042 and STM32F072 devices
    • Add definition for EXTI_PortSourceGPIOE.
    • Add DMA remap definition for TIM3, TIM2, TIM1, I2C1, USART3, USART2, SPI2.
    • Add new DMA remap possibility definition for TIM17 and TIM16.
    • Add definition for SYSCFG_I2CFastModePlus_I2C2.
  • stm32f0xx_tim.c/.h: update for STM32F042 and STM32F072 devices
    • Add support of the TIM7.
  • stm32f0xx_usart.c/.h: update for STM32F042 and STM32F072 devices
    • Add support of the USART3 and USART4.

V1.2.1 / 22-November-2013
+

+

Main +Changes

+ +
  • Update the support of STM32F030 devices by removing the references to STM32F030x8 and STM32F030x6 devices and replacing them in by STM32F030 in the SYSCFG and GPIO drivers 
    +

V1.2.0 / 01-Agust-2013
+

+

Main +Changes

+ +
  • Add support of STM32F030x8 and STM32F030x6 devices (STM32F030 devices are  microcontrollers where the Flash memory ranges between 16 and 32 Kbytes)
    +

V1.1.1 / 31-July-2013
+

+ + +

Main +Changes

+ + + +
  • stm32f0xx_tim.c
    • TIM_OC2Init(): add configuration of OC2 output idle state for TIM15
      +
+ +

V1.1.0 / 10-May-2013
+

+

Main +Changes

+ +
  • Add support of STM32F0xx Low-density devices (STM32F0XX_LD devices, STM32F050xx and STM32F060xx microcontrollers where the Flash memory ranges between 16 and 32 Kbytes) and miscellaneous update
    +
  • stm32f0xx_rcc.c/.h: update for STM32F0XX_LD devices
    • Add new function RCC_MCOConfig(uint8_t RCC_MCOSource, +uint32_t RCC_MCOPrescaler)
      +
    • RCC_DeInit(): update to reset new bits added in RCC_CFGR register
  • stm32f0xx_syscfg.c/.h: update for STM32F0XX_LD devices
    • Add defines for "I2C fast mode plus" new AF mapping: SYSCFG_I2CFastModePlus_PA9, SYSCFG_I2CFastModePlus_PA10 and SYSCFG_I2CFastModePlus_I2C1
      +
  • stm32f0xx_gpio.h: update for STM32F0XX_LD devices
    • GPIO_PinAFConfig(): in the function header add reference to I2C1's new AF4 remapping
      +
  • stm32f0xx_flash.h
    • Swap the value of these defines OB_VDDA_ANALOG_ON and OB_VDDA_ANALOG_OFF
  • stm32f0xx_misc.c
    • NVIC_Init(): remove reference to NVIC_PriorityGroupConfig() function (not available)
      +
  • stm32f0xx_gpio.h
    • Update GPIOSpeed_TypeDef members naming to be in line w/ the Reference Manual
      +
  • stm32f0xx_exti.c
    +
    • EXTI_GetITStatus() updated to remove test on IMR register to avoid corner case limitation
+

V1.0.2 / 13-July-2012

Main +Changes

+
  • stm32f0xx_i2c.c/.h
    • I2C_SoftwareResetCmd(): update function coding to be in line with I2C software reset procedure recommended in STM32F0xx lasted documentation. As consequence NewState parameter was removed.
  • stm32f0xx_flash.c/.h
    • Rename FLASH_ProgramOptionByteData() to FLASH_OB_ProgramData()
    • Add some legacy defines for compatibility with STM32F10x Flash driver
  • stm32f0xx_rtc.c
    • RTC_DeInit(): remove unused variable “wutcounter”
  • stm32f0xx_spi.c 
    • File header's comment: add details how to configure the FIFO threshold 

V1.0.1 / 20-April-2012

Main +Changes

+
  • All drivers, function's header: update comments and Doxygen tags formatting
  • stm32f0xx_pwr.c
    • PWR_PVDLevelConfig() +function: remove value of the voltage threshold corresponding to each +PVD detection level, user should refer to the electrical +characteristics of the STM32F0xx device datasheet to have the correct +value
  • stm32f0xx_usart.c/.h
    • USART_Init() function: update baudrate computation to be in line with the formula described in the Reference Manual (RM0091)
    • USART_AutoBaudRateNewRequest() function removed
  • stm32f0xx_i2c.c
    • I2C_GetITStatus() function: add test to check if the interrupt source is enabled or not

V1.0.0 / 23-March-2012

Main +Changes

+
  • First official release for STM32F0xx devices
  • All source files: license disclaimer text update and add link to the License file on ST Internet
  • stm32f0xx_comp.h
    •  Correct values of COMP_Mode parameter
  • stm32f0xx_rcc.c/.h
    • Add new reset flag V18PWRRSTF in the RCC CSR register
    • Add new MCO clock sources (LSI and LSE) and change value of RCC_MCOSource_HSI14 
  • stm32f0xx_flash.c/.h
    • Add new function FLASH_OB_SRAMParityConfig() to manage the SRAM parity enable option bit
    • Flash and OB keys moved to stm32f0xx.h file
  • stm32f0xx_tim.c/.h
    • Add additional input for TIM14 clock  (HSE divided by 32 and MCO) 
    • Miscellaneous enhancement
  • stm32f0xx_adc.c/.h
    • Miscellaneous update to be in line with bits naming in the Reference Manual (update done also in stm32f0xx.h file)
  • stm32f0xx_i2c.c/.h
    • Miscellaneous enhancement
+ +

V1.0.0RC1 / 27-January-2012

+

Main +Changes

+ + + + + +
    +
  • Official version (V1.0.0) Release Candidate 1
    • + +
+
    + +

    License

    Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); You may not use this package except in compliance with the License. You may obtain a copy of the License at:


    Unless +required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT +WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See +the License for the specific language governing permissions and +limitations under the License.
    +
    +

    For + complete documentation on STM32 + Microcontrollers visit www.st.com/STM32

    +
    +

    +
    +
    +

     

    +
    + \ No newline at end of file diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_adc.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_adc.h new file mode 100644 index 00000000..900803a5 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_adc.h @@ -0,0 +1,450 @@ +/** + ****************************************************************************** + * @file stm32f0xx_adc.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the ADC firmware + * library + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_ADC_H +#define __STM32F0XX_ADC_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup ADC + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief ADC Init structure definition + */ + +typedef struct +{ + uint32_t ADC_Resolution; /*!< Selects the resolution of the conversion. + This parameter can be a value of @ref ADC_Resolution */ + + FunctionalState ADC_ContinuousConvMode; /*!< Specifies whether the conversion is performed in + Continuous or Single mode. + This parameter can be set to ENABLE or DISABLE. */ + + uint32_t ADC_ExternalTrigConvEdge; /*!< Selects the external trigger Edge and enables the + trigger of a regular group. This parameter can be a value + of @ref ADC_external_trigger_edge_conversion */ + + uint32_t ADC_ExternalTrigConv; /*!< Defines the external trigger used to start the analog + to digital conversion of regular channels. This parameter + can be a value of @ref ADC_external_trigger_sources_for_channels_conversion */ + + uint32_t ADC_DataAlign; /*!< Specifies whether the ADC data alignment is left or right. + This parameter can be a value of @ref ADC_data_align */ + + uint32_t ADC_ScanDirection; /*!< Specifies in which direction the channels will be scanned + in the sequence. + This parameter can be a value of @ref ADC_Scan_Direction */ +}ADC_InitTypeDef; + + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup ADC_Exported_Constants + * @{ + */ +#define IS_ADC_ALL_PERIPH(PERIPH) ((PERIPH) == ADC1) + +/** @defgroup ADC_JitterOff + * @{ + */ +/* These defines are obsolete and maintained for legacy purpose only. They are replaced by the ADC_ClockMode */ +#define ADC_JitterOff_PCLKDiv2 ADC_CFGR2_JITOFFDIV2 +#define ADC_JitterOff_PCLKDiv4 ADC_CFGR2_JITOFFDIV4 + +#define IS_ADC_JITTEROFF(JITTEROFF) (((JITTEROFF) & 0x3FFFFFFF) == (uint32_t)RESET) + +/** + * @} + */ + +/** @defgroup ADC_ClockMode + * @{ + */ +#define ADC_ClockMode_AsynClk ((uint32_t)0x00000000) /*!< ADC Asynchronous clock mode */ +#define ADC_ClockMode_SynClkDiv2 ADC_CFGR2_CKMODE_0 /*!< Synchronous clock mode divided by 2 */ +#define ADC_ClockMode_SynClkDiv4 ADC_CFGR2_CKMODE_1 /*!< Synchronous clock mode divided by 4 */ +#define IS_ADC_CLOCKMODE(CLOCK) (((CLOCK) == ADC_ClockMode_AsynClk) ||\ + ((CLOCK) == ADC_ClockMode_SynClkDiv2) ||\ + ((CLOCK) == ADC_ClockMode_SynClkDiv4)) + +/** + * @} + */ + +/** @defgroup ADC_Resolution + * @{ + */ +#define ADC_Resolution_12b ((uint32_t)0x00000000) +#define ADC_Resolution_10b ADC_CFGR1_RES_0 +#define ADC_Resolution_8b ADC_CFGR1_RES_1 +#define ADC_Resolution_6b ADC_CFGR1_RES + +#define IS_ADC_RESOLUTION(RESOLUTION) (((RESOLUTION) == ADC_Resolution_12b) || \ + ((RESOLUTION) == ADC_Resolution_10b) || \ + ((RESOLUTION) == ADC_Resolution_8b) || \ + ((RESOLUTION) == ADC_Resolution_6b)) + +/** + * @} + */ + +/** @defgroup ADC_external_trigger_edge_conversion + * @{ + */ +#define ADC_ExternalTrigConvEdge_None ((uint32_t)0x00000000) +#define ADC_ExternalTrigConvEdge_Rising ADC_CFGR1_EXTEN_0 +#define ADC_ExternalTrigConvEdge_Falling ADC_CFGR1_EXTEN_1 +#define ADC_ExternalTrigConvEdge_RisingFalling ADC_CFGR1_EXTEN + +#define IS_ADC_EXT_TRIG_EDGE(EDGE) (((EDGE) == ADC_ExternalTrigConvEdge_None) || \ + ((EDGE) == ADC_ExternalTrigConvEdge_Rising) || \ + ((EDGE) == ADC_ExternalTrigConvEdge_Falling) || \ + ((EDGE) == ADC_ExternalTrigConvEdge_RisingFalling)) +/** + * @} + */ + +/** @defgroup ADC_external_trigger_sources_for_channels_conversion + * @{ + */ + +/* TIM1 */ +#define ADC_ExternalTrigConv_T1_TRGO ((uint32_t)0x00000000) +#define ADC_ExternalTrigConv_T1_CC4 ADC_CFGR1_EXTSEL_0 + +/* TIM2 */ +#define ADC_ExternalTrigConv_T2_TRGO ADC_CFGR1_EXTSEL_1 + +/* TIM3 */ +#define ADC_ExternalTrigConv_T3_TRGO ((uint32_t)(ADC_CFGR1_EXTSEL_0 | ADC_CFGR1_EXTSEL_1)) + +/* TIM15 */ +#define ADC_ExternalTrigConv_T15_TRGO ADC_CFGR1_EXTSEL_2 + +#define IS_ADC_EXTERNAL_TRIG_CONV(CONV) (((CONV) == ADC_ExternalTrigConv_T1_TRGO) || \ + ((CONV) == ADC_ExternalTrigConv_T1_CC4) || \ + ((CONV) == ADC_ExternalTrigConv_T2_TRGO) || \ + ((CONV) == ADC_ExternalTrigConv_T3_TRGO) || \ + ((CONV) == ADC_ExternalTrigConv_T15_TRGO)) +/** + * @} + */ + +/** @defgroup ADC_data_align + * @{ + */ + +#define ADC_DataAlign_Right ((uint32_t)0x00000000) +#define ADC_DataAlign_Left ADC_CFGR1_ALIGN + +#define IS_ADC_DATA_ALIGN(ALIGN) (((ALIGN) == ADC_DataAlign_Right) || \ + ((ALIGN) == ADC_DataAlign_Left)) +/** + * @} + */ + +/** @defgroup ADC_Scan_Direction + * @{ + */ + +#define ADC_ScanDirection_Upward ((uint32_t)0x00000000) +#define ADC_ScanDirection_Backward ADC_CFGR1_SCANDIR + +#define IS_ADC_SCAN_DIRECTION(DIRECTION) (((DIRECTION) == ADC_ScanDirection_Upward) || \ + ((DIRECTION) == ADC_ScanDirection_Backward)) +/** + * @} + */ + +/** @defgroup ADC_DMA_Mode + * @{ + */ + +#define ADC_DMAMode_OneShot ((uint32_t)0x00000000) +#define ADC_DMAMode_Circular ADC_CFGR1_DMACFG + +#define IS_ADC_DMA_MODE(MODE) (((MODE) == ADC_DMAMode_OneShot) || \ + ((MODE) == ADC_DMAMode_Circular)) +/** + * @} + */ + +/** @defgroup ADC_analog_watchdog_selection + * @{ + */ + +#define ADC_AnalogWatchdog_Channel_0 ((uint32_t)0x00000000) +#define ADC_AnalogWatchdog_Channel_1 ((uint32_t)0x04000000) +#define ADC_AnalogWatchdog_Channel_2 ((uint32_t)0x08000000) +#define ADC_AnalogWatchdog_Channel_3 ((uint32_t)0x0C000000) +#define ADC_AnalogWatchdog_Channel_4 ((uint32_t)0x10000000) +#define ADC_AnalogWatchdog_Channel_5 ((uint32_t)0x14000000) +#define ADC_AnalogWatchdog_Channel_6 ((uint32_t)0x18000000) +#define ADC_AnalogWatchdog_Channel_7 ((uint32_t)0x1C000000) +#define ADC_AnalogWatchdog_Channel_8 ((uint32_t)0x20000000) +#define ADC_AnalogWatchdog_Channel_9 ((uint32_t)0x24000000) +#define ADC_AnalogWatchdog_Channel_10 ((uint32_t)0x28000000) /*!< Not available for STM32F031 devices */ +#define ADC_AnalogWatchdog_Channel_11 ((uint32_t)0x2C000000) /*!< Not available for STM32F031 devices */ +#define ADC_AnalogWatchdog_Channel_12 ((uint32_t)0x30000000) /*!< Not available for STM32F031 devices */ +#define ADC_AnalogWatchdog_Channel_13 ((uint32_t)0x34000000) /*!< Not available for STM32F031 devices */ +#define ADC_AnalogWatchdog_Channel_14 ((uint32_t)0x38000000) /*!< Not available for STM32F031 devices */ +#define ADC_AnalogWatchdog_Channel_15 ((uint32_t)0x3C000000) /*!< Not available for STM32F031 devices */ +#define ADC_AnalogWatchdog_Channel_16 ((uint32_t)0x40000000) +#define ADC_AnalogWatchdog_Channel_17 ((uint32_t)0x44000000) +#define ADC_AnalogWatchdog_Channel_18 ((uint32_t)0x48000000) + + +#define IS_ADC_ANALOG_WATCHDOG_CHANNEL(CHANNEL) (((CHANNEL) == ADC_AnalogWatchdog_Channel_0) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_1) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_2) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_3) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_4) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_5) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_6) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_7) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_8) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_9) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_10) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_11) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_12) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_13) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_14) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_15) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_16) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_17) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_18)) +/** + * @} + */ + +/** @defgroup ADC_sampling_times + * @{ + */ + +#define ADC_SampleTime_1_5Cycles ((uint32_t)0x00000000) +#define ADC_SampleTime_7_5Cycles ((uint32_t)0x00000001) +#define ADC_SampleTime_13_5Cycles ((uint32_t)0x00000002) +#define ADC_SampleTime_28_5Cycles ((uint32_t)0x00000003) +#define ADC_SampleTime_41_5Cycles ((uint32_t)0x00000004) +#define ADC_SampleTime_55_5Cycles ((uint32_t)0x00000005) +#define ADC_SampleTime_71_5Cycles ((uint32_t)0x00000006) +#define ADC_SampleTime_239_5Cycles ((uint32_t)0x00000007) + +#define IS_ADC_SAMPLE_TIME(TIME) (((TIME) == ADC_SampleTime_1_5Cycles) || \ + ((TIME) == ADC_SampleTime_7_5Cycles) || \ + ((TIME) == ADC_SampleTime_13_5Cycles) || \ + ((TIME) == ADC_SampleTime_28_5Cycles) || \ + ((TIME) == ADC_SampleTime_41_5Cycles) || \ + ((TIME) == ADC_SampleTime_55_5Cycles) || \ + ((TIME) == ADC_SampleTime_71_5Cycles) || \ + ((TIME) == ADC_SampleTime_239_5Cycles)) +/** + * @} + */ + +/** @defgroup ADC_thresholds + * @{ + */ + +#define IS_ADC_THRESHOLD(THRESHOLD) ((THRESHOLD) <= 0xFFF) + +/** + * @} + */ + +/** @defgroup ADC_channels + * @{ + */ + +#define ADC_Channel_0 ADC_CHSELR_CHSEL0 +#define ADC_Channel_1 ADC_CHSELR_CHSEL1 +#define ADC_Channel_2 ADC_CHSELR_CHSEL2 +#define ADC_Channel_3 ADC_CHSELR_CHSEL3 +#define ADC_Channel_4 ADC_CHSELR_CHSEL4 +#define ADC_Channel_5 ADC_CHSELR_CHSEL5 +#define ADC_Channel_6 ADC_CHSELR_CHSEL6 +#define ADC_Channel_7 ADC_CHSELR_CHSEL7 +#define ADC_Channel_8 ADC_CHSELR_CHSEL8 +#define ADC_Channel_9 ADC_CHSELR_CHSEL9 +#define ADC_Channel_10 ADC_CHSELR_CHSEL10 /*!< Not available for STM32F031 devices */ +#define ADC_Channel_11 ADC_CHSELR_CHSEL11 /*!< Not available for STM32F031 devices */ +#define ADC_Channel_12 ADC_CHSELR_CHSEL12 /*!< Not available for STM32F031 devices */ +#define ADC_Channel_13 ADC_CHSELR_CHSEL13 /*!< Not available for STM32F031 devices */ +#define ADC_Channel_14 ADC_CHSELR_CHSEL14 /*!< Not available for STM32F031 devices */ +#define ADC_Channel_15 ADC_CHSELR_CHSEL15 /*!< Not available for STM32F031 devices */ +#define ADC_Channel_16 ADC_CHSELR_CHSEL16 +#define ADC_Channel_17 ADC_CHSELR_CHSEL17 +#define ADC_Channel_18 ADC_CHSELR_CHSEL18 /*!< Not available for STM32F030 devices */ + +#define ADC_Channel_TempSensor ((uint32_t)ADC_Channel_16) +#define ADC_Channel_Vrefint ((uint32_t)ADC_Channel_17) +#define ADC_Channel_Vbat ((uint32_t)ADC_Channel_18) /*!< Not available for STM32F030 devices */ + +#define IS_ADC_CHANNEL(CHANNEL) (((CHANNEL) != (uint32_t)RESET) && (((CHANNEL) & 0xFFF80000) == (uint32_t)RESET)) + +/** + * @} + */ + +/** @defgroup ADC_interrupts_definition + * @{ + */ + +#define ADC_IT_ADRDY ADC_IER_ADRDYIE +#define ADC_IT_EOSMP ADC_IER_EOSMPIE +#define ADC_IT_EOC ADC_IER_EOCIE +#define ADC_IT_EOSEQ ADC_IER_EOSEQIE +#define ADC_IT_OVR ADC_IER_OVRIE +#define ADC_IT_AWD ADC_IER_AWDIE + +#define IS_ADC_CONFIG_IT(IT) (((IT) != (uint32_t)RESET) && (((IT) & 0xFFFFFF60) == (uint32_t)RESET)) + +#define IS_ADC_GET_IT(IT) (((IT) == ADC_IT_ADRDY) || ((IT) == ADC_IT_EOSMP) || \ + ((IT) == ADC_IT_EOC) || ((IT) == ADC_IT_EOSEQ) || \ + ((IT) == ADC_IT_OVR) || ((IT) == ADC_IT_AWD)) + +#define IS_ADC_CLEAR_IT(IT) (((IT) != (uint32_t)RESET) && (((IT) & 0xFFFFFF60) == (uint32_t)RESET)) + +/** + * @} + */ + +/** @defgroup ADC_flags_definition + * @{ + */ + +#define ADC_FLAG_ADRDY ADC_ISR_ADRDY +#define ADC_FLAG_EOSMP ADC_ISR_EOSMP +#define ADC_FLAG_EOC ADC_ISR_EOC +#define ADC_FLAG_EOSEQ ADC_ISR_EOSEQ +#define ADC_FLAG_OVR ADC_ISR_OVR +#define ADC_FLAG_AWD ADC_ISR_AWD + +#define ADC_FLAG_ADEN ((uint32_t)0x01000001) +#define ADC_FLAG_ADDIS ((uint32_t)0x01000002) +#define ADC_FLAG_ADSTART ((uint32_t)0x01000004) +#define ADC_FLAG_ADSTP ((uint32_t)0x01000010) +#define ADC_FLAG_ADCAL ((uint32_t)0x81000000) + +#define IS_ADC_CLEAR_FLAG(FLAG) (((FLAG) != (uint32_t)RESET) && (((FLAG) & 0xFFFFFF60) == (uint32_t)RESET)) + +#define IS_ADC_GET_FLAG(FLAG) (((FLAG) == ADC_FLAG_ADRDY) || ((FLAG) == ADC_FLAG_EOSMP) || \ + ((FLAG) == ADC_FLAG_EOC) || ((FLAG) == ADC_FLAG_EOSEQ) || \ + ((FLAG) == ADC_FLAG_AWD) || ((FLAG) == ADC_FLAG_OVR) || \ + ((FLAG) == ADC_FLAG_ADEN) || ((FLAG) == ADC_FLAG_ADDIS) || \ + ((FLAG) == ADC_FLAG_ADSTART) || ((FLAG) == ADC_FLAG_ADSTP) || \ + ((FLAG) == ADC_FLAG_ADCAL)) +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Function used to set the ADC configuration to the default reset state *****/ +void ADC_DeInit(ADC_TypeDef* ADCx); + +/* Initialization and Configuration functions *********************************/ +void ADC_Init(ADC_TypeDef* ADCx, ADC_InitTypeDef* ADC_InitStruct); +void ADC_StructInit(ADC_InitTypeDef* ADC_InitStruct); +void ADC_ClockModeConfig(ADC_TypeDef* ADCx, uint32_t ADC_ClockMode); +void ADC_Cmd(ADC_TypeDef* ADCx, FunctionalState NewState); +/* This Function is obsolete and maintained for legacy purpose only. + ADC_ClockModeConfig() function should be used instead */ +void ADC_JitterCmd(ADC_TypeDef* ADCx, uint32_t ADC_JitterOff, FunctionalState NewState); + +/* Power saving functions *****************************************************/ +void ADC_AutoPowerOffCmd(ADC_TypeDef* ADCx, FunctionalState NewState); +void ADC_WaitModeCmd(ADC_TypeDef* ADCx, FunctionalState NewState); + +/* Analog Watchdog configuration functions ************************************/ +void ADC_AnalogWatchdogCmd(ADC_TypeDef* ADCx, FunctionalState NewState); +void ADC_AnalogWatchdogThresholdsConfig(ADC_TypeDef* ADCx, uint16_t HighThreshold,uint16_t LowThreshold); +void ADC_AnalogWatchdogSingleChannelConfig(ADC_TypeDef* ADCx, uint32_t ADC_AnalogWatchdog_Channel); +void ADC_AnalogWatchdogSingleChannelCmd(ADC_TypeDef* ADCx, FunctionalState NewState); + +/* Temperature Sensor , Vrefint and Vbat management function ******************/ +void ADC_TempSensorCmd(FunctionalState NewState); +void ADC_VrefintCmd(FunctionalState NewState); +void ADC_VbatCmd(FunctionalState NewState); /*!< Not applicable for STM32F030 devices */ + +/* Channels Configuration functions *******************************************/ +void ADC_ChannelConfig(ADC_TypeDef* ADCx, uint32_t ADC_Channel, uint32_t ADC_SampleTime); +void ADC_ContinuousModeCmd(ADC_TypeDef* ADCx, FunctionalState NewState); +void ADC_DiscModeCmd(ADC_TypeDef* ADCx, FunctionalState NewState); +void ADC_OverrunModeCmd(ADC_TypeDef* ADCx, FunctionalState NewState); +uint32_t ADC_GetCalibrationFactor(ADC_TypeDef* ADCx); +void ADC_StopOfConversion(ADC_TypeDef* ADCx); +void ADC_StartOfConversion(ADC_TypeDef* ADCx); +uint16_t ADC_GetConversionValue(ADC_TypeDef* ADCx); + +/* Regular Channels DMA Configuration functions *******************************/ +void ADC_DMACmd(ADC_TypeDef* ADCx, FunctionalState NewState); +void ADC_DMARequestModeConfig(ADC_TypeDef* ADCx, uint32_t ADC_DMARequestMode); + +/* Interrupts and flags management functions **********************************/ +void ADC_ITConfig(ADC_TypeDef* ADCx, uint32_t ADC_IT, FunctionalState NewState); +FlagStatus ADC_GetFlagStatus(ADC_TypeDef* ADCx, uint32_t ADC_FLAG); +void ADC_ClearFlag(ADC_TypeDef* ADCx, uint32_t ADC_FLAG); +ITStatus ADC_GetITStatus(ADC_TypeDef* ADCx, uint32_t ADC_IT); +void ADC_ClearITPendingBit(ADC_TypeDef* ADCx, uint32_t ADC_IT); + +#ifdef __cplusplus +} +#endif + +#endif /*__STM32F0XX_ADC_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_can.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_can.h new file mode 100644 index 00000000..d8a178ea --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_can.h @@ -0,0 +1,643 @@ +/** + ****************************************************************************** + * @file stm32f0xx_can.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the CAN firmware + * library, applicable only for STM32F072 devices. + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0xx_CAN_H +#define __STM32F0xx_CAN_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup CAN + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +#define IS_CAN_ALL_PERIPH(PERIPH) (((PERIPH) == CAN)) + +/** + * @brief CAN init structure definition + */ +typedef struct +{ + uint16_t CAN_Prescaler; /*!< Specifies the length of a time quantum. + It ranges from 1 to 1024. */ + + uint8_t CAN_Mode; /*!< Specifies the CAN operating mode. + This parameter can be a value of @ref CAN_operating_mode */ + + uint8_t CAN_SJW; /*!< Specifies the maximum number of time quanta + the CAN hardware is allowed to lengthen or + shorten a bit to perform resynchronization. + This parameter can be a value of @ref CAN_synchronisation_jump_width */ + + uint8_t CAN_BS1; /*!< Specifies the number of time quanta in Bit + Segment 1. This parameter can be a value of + @ref CAN_time_quantum_in_bit_segment_1 */ + + uint8_t CAN_BS2; /*!< Specifies the number of time quanta in Bit Segment 2. + This parameter can be a value of @ref CAN_time_quantum_in_bit_segment_2 */ + + FunctionalState CAN_TTCM; /*!< Enable or disable the time triggered communication mode. + This parameter can be set either to ENABLE or DISABLE. */ + + FunctionalState CAN_ABOM; /*!< Enable or disable the automatic bus-off management. + This parameter can be set either to ENABLE or DISABLE. */ + + FunctionalState CAN_AWUM; /*!< Enable or disable the automatic wake-up mode. + This parameter can be set either to ENABLE or DISABLE. */ + + FunctionalState CAN_NART; /*!< Enable or disable the non-automatic retransmission mode. + This parameter can be set either to ENABLE or DISABLE. */ + + FunctionalState CAN_RFLM; /*!< Enable or disable the Receive FIFO Locked mode. + This parameter can be set either to ENABLE or DISABLE. */ + + FunctionalState CAN_TXFP; /*!< Enable or disable the transmit FIFO priority. + This parameter can be set either to ENABLE or DISABLE. */ +} CAN_InitTypeDef; + +/** + * @brief CAN filter init structure definition + */ +typedef struct +{ + uint16_t CAN_FilterIdHigh; /*!< Specifies the filter identification number (MSBs for a 32-bit + configuration, first one for a 16-bit configuration). + This parameter can be a value between 0x0000 and 0xFFFF */ + + uint16_t CAN_FilterIdLow; /*!< Specifies the filter identification number (LSBs for a 32-bit + configuration, second one for a 16-bit configuration). + This parameter can be a value between 0x0000 and 0xFFFF */ + + uint16_t CAN_FilterMaskIdHigh; /*!< Specifies the filter mask number or identification number, + according to the mode (MSBs for a 32-bit configuration, + first one for a 16-bit configuration). + This parameter can be a value between 0x0000 and 0xFFFF */ + + uint16_t CAN_FilterMaskIdLow; /*!< Specifies the filter mask number or identification number, + according to the mode (LSBs for a 32-bit configuration, + second one for a 16-bit configuration). + This parameter can be a value between 0x0000 and 0xFFFF */ + + uint16_t CAN_FilterFIFOAssignment; /*!< Specifies the FIFO (0 or 1) which will be assigned to the filter. + This parameter can be a value of @ref CAN_filter_FIFO */ + + uint8_t CAN_FilterNumber; /*!< Specifies the filter which will be initialized. It ranges from 0 to 13. */ + + uint8_t CAN_FilterMode; /*!< Specifies the filter mode to be initialized. + This parameter can be a value of @ref CAN_filter_mode */ + + uint8_t CAN_FilterScale; /*!< Specifies the filter scale. + This parameter can be a value of @ref CAN_filter_scale */ + + FunctionalState CAN_FilterActivation; /*!< Enable or disable the filter. + This parameter can be set either to ENABLE or DISABLE. */ +} CAN_FilterInitTypeDef; + +/** + * @brief CAN Tx message structure definition + */ +typedef struct +{ + uint32_t StdId; /*!< Specifies the standard identifier. + This parameter can be a value between 0 to 0x7FF. */ + + uint32_t ExtId; /*!< Specifies the extended identifier. + This parameter can be a value between 0 to 0x1FFFFFFF. */ + + uint8_t IDE; /*!< Specifies the type of identifier for the message that + will be transmitted. This parameter can be a value + of @ref CAN_identifier_type */ + + uint8_t RTR; /*!< Specifies the type of frame for the message that will + be transmitted. This parameter can be a value of + @ref CAN_remote_transmission_request */ + + uint8_t DLC; /*!< Specifies the length of the frame that will be + transmitted. This parameter can be a value between + 0 to 8 */ + + uint8_t Data[8]; /*!< Contains the data to be transmitted. It ranges from 0 + to 0xFF. */ +} CanTxMsg; + +/** + * @brief CAN Rx message structure definition + */ +typedef struct +{ + uint32_t StdId; /*!< Specifies the standard identifier. + This parameter can be a value between 0 to 0x7FF. */ + + uint32_t ExtId; /*!< Specifies the extended identifier. + This parameter can be a value between 0 to 0x1FFFFFFF. */ + + uint8_t IDE; /*!< Specifies the type of identifier for the message that + will be received. This parameter can be a value of + @ref CAN_identifier_type */ + + uint8_t RTR; /*!< Specifies the type of frame for the received message. + This parameter can be a value of + @ref CAN_remote_transmission_request */ + + uint8_t DLC; /*!< Specifies the length of the frame that will be received. + This parameter can be a value between 0 to 8 */ + + uint8_t Data[8]; /*!< Contains the data to be received. It ranges from 0 to + 0xFF. */ + + uint8_t FMI; /*!< Specifies the index of the filter the message stored in + the mailbox passes through. This parameter can be a + value between 0 to 0xFF */ +} CanRxMsg; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup CAN_Exported_Constants + * @{ + */ + +/** @defgroup CAN_InitStatus + * @{ + */ + +#define CAN_InitStatus_Failed ((uint8_t)0x00) /*!< CAN initialization failed */ +#define CAN_InitStatus_Success ((uint8_t)0x01) /*!< CAN initialization OK */ + + +/* Legacy defines */ +#define CANINITFAILED CAN_InitStatus_Failed +#define CANINITOK CAN_InitStatus_Success +/** + * @} + */ + +/** @defgroup CAN_operating_mode + * @{ + */ + +#define CAN_Mode_Normal ((uint8_t)0x00) /*!< normal mode */ +#define CAN_Mode_LoopBack ((uint8_t)0x01) /*!< loopback mode */ +#define CAN_Mode_Silent ((uint8_t)0x02) /*!< silent mode */ +#define CAN_Mode_Silent_LoopBack ((uint8_t)0x03) /*!< loopback combined with silent mode */ + +#define IS_CAN_MODE(MODE) (((MODE) == CAN_Mode_Normal) || \ + ((MODE) == CAN_Mode_LoopBack)|| \ + ((MODE) == CAN_Mode_Silent) || \ + ((MODE) == CAN_Mode_Silent_LoopBack)) +/** + * @} + */ + + + /** + * @defgroup CAN_operating_mode + * @{ + */ +#define CAN_OperatingMode_Initialization ((uint8_t)0x00) /*!< Initialization mode */ +#define CAN_OperatingMode_Normal ((uint8_t)0x01) /*!< Normal mode */ +#define CAN_OperatingMode_Sleep ((uint8_t)0x02) /*!< sleep mode */ + + +#define IS_CAN_OPERATING_MODE(MODE) (((MODE) == CAN_OperatingMode_Initialization) ||\ + ((MODE) == CAN_OperatingMode_Normal)|| \ + ((MODE) == CAN_OperatingMode_Sleep)) +/** + * @} + */ + +/** + * @defgroup CAN_operating_mode_status + * @{ + */ + +#define CAN_ModeStatus_Failed ((uint8_t)0x00) /*!< CAN entering the specific mode failed */ +#define CAN_ModeStatus_Success ((uint8_t)!CAN_ModeStatus_Failed) /*!< CAN entering the specific mode Succeed */ +/** + * @} + */ + +/** @defgroup CAN_synchronisation_jump_width + * @{ + */ +#define CAN_SJW_1tq ((uint8_t)0x00) /*!< 1 time quantum */ +#define CAN_SJW_2tq ((uint8_t)0x01) /*!< 2 time quantum */ +#define CAN_SJW_3tq ((uint8_t)0x02) /*!< 3 time quantum */ +#define CAN_SJW_4tq ((uint8_t)0x03) /*!< 4 time quantum */ + +#define IS_CAN_SJW(SJW) (((SJW) == CAN_SJW_1tq) || ((SJW) == CAN_SJW_2tq)|| \ + ((SJW) == CAN_SJW_3tq) || ((SJW) == CAN_SJW_4tq)) +/** + * @} + */ + +/** @defgroup CAN_time_quantum_in_bit_segment_1 + * @{ + */ +#define CAN_BS1_1tq ((uint8_t)0x00) /*!< 1 time quantum */ +#define CAN_BS1_2tq ((uint8_t)0x01) /*!< 2 time quantum */ +#define CAN_BS1_3tq ((uint8_t)0x02) /*!< 3 time quantum */ +#define CAN_BS1_4tq ((uint8_t)0x03) /*!< 4 time quantum */ +#define CAN_BS1_5tq ((uint8_t)0x04) /*!< 5 time quantum */ +#define CAN_BS1_6tq ((uint8_t)0x05) /*!< 6 time quantum */ +#define CAN_BS1_7tq ((uint8_t)0x06) /*!< 7 time quantum */ +#define CAN_BS1_8tq ((uint8_t)0x07) /*!< 8 time quantum */ +#define CAN_BS1_9tq ((uint8_t)0x08) /*!< 9 time quantum */ +#define CAN_BS1_10tq ((uint8_t)0x09) /*!< 10 time quantum */ +#define CAN_BS1_11tq ((uint8_t)0x0A) /*!< 11 time quantum */ +#define CAN_BS1_12tq ((uint8_t)0x0B) /*!< 12 time quantum */ +#define CAN_BS1_13tq ((uint8_t)0x0C) /*!< 13 time quantum */ +#define CAN_BS1_14tq ((uint8_t)0x0D) /*!< 14 time quantum */ +#define CAN_BS1_15tq ((uint8_t)0x0E) /*!< 15 time quantum */ +#define CAN_BS1_16tq ((uint8_t)0x0F) /*!< 16 time quantum */ + +#define IS_CAN_BS1(BS1) ((BS1) <= CAN_BS1_16tq) +/** + * @} + */ + +/** @defgroup CAN_time_quantum_in_bit_segment_2 + * @{ + */ +#define CAN_BS2_1tq ((uint8_t)0x00) /*!< 1 time quantum */ +#define CAN_BS2_2tq ((uint8_t)0x01) /*!< 2 time quantum */ +#define CAN_BS2_3tq ((uint8_t)0x02) /*!< 3 time quantum */ +#define CAN_BS2_4tq ((uint8_t)0x03) /*!< 4 time quantum */ +#define CAN_BS2_5tq ((uint8_t)0x04) /*!< 5 time quantum */ +#define CAN_BS2_6tq ((uint8_t)0x05) /*!< 6 time quantum */ +#define CAN_BS2_7tq ((uint8_t)0x06) /*!< 7 time quantum */ +#define CAN_BS2_8tq ((uint8_t)0x07) /*!< 8 time quantum */ + +#define IS_CAN_BS2(BS2) ((BS2) <= CAN_BS2_8tq) +/** + * @} + */ + +/** @defgroup CAN_clock_prescaler + * @{ + */ +#define IS_CAN_PRESCALER(PRESCALER) (((PRESCALER) >= 1) && ((PRESCALER) <= 1024)) +/** + * @} + */ + +/** @defgroup CAN_filter_number + * @{ + */ +#define IS_CAN_FILTER_NUMBER(NUMBER) ((NUMBER) <= 27) +/** + * @} + */ + +/** @defgroup CAN_filter_mode + * @{ + */ +#define CAN_FilterMode_IdMask ((uint8_t)0x00) /*!< identifier/mask mode */ +#define CAN_FilterMode_IdList ((uint8_t)0x01) /*!< identifier list mode */ + +#define IS_CAN_FILTER_MODE(MODE) (((MODE) == CAN_FilterMode_IdMask) || \ + ((MODE) == CAN_FilterMode_IdList)) +/** + * @} + */ + +/** @defgroup CAN_filter_scale + * @{ + */ +#define CAN_FilterScale_16bit ((uint8_t)0x00) /*!< Two 16-bit filters */ +#define CAN_FilterScale_32bit ((uint8_t)0x01) /*!< One 32-bit filter */ + +#define IS_CAN_FILTER_SCALE(SCALE) (((SCALE) == CAN_FilterScale_16bit) || \ + ((SCALE) == CAN_FilterScale_32bit)) +/** + * @} + */ + +/** @defgroup CAN_filter_FIFO + * @{ + */ +#define CAN_Filter_FIFO0 ((uint8_t)0x00) /*!< Filter FIFO 0 assignment for filter x */ +#define CAN_Filter_FIFO1 ((uint8_t)0x01) /*!< Filter FIFO 1 assignment for filter x */ +#define IS_CAN_FILTER_FIFO(FIFO) (((FIFO) == CAN_FilterFIFO0) || \ + ((FIFO) == CAN_FilterFIFO1)) + +/* Legacy defines */ +#define CAN_FilterFIFO0 CAN_Filter_FIFO0 +#define CAN_FilterFIFO1 CAN_Filter_FIFO1 +/** + * @} + */ + +/** @defgroup CAN_Start_bank_filter_for_slave_CAN + * @{ + */ +#define IS_CAN_BANKNUMBER(BANKNUMBER) (((BANKNUMBER) >= 1) && ((BANKNUMBER) <= 27)) +/** + * @} + */ + +/** @defgroup CAN_Tx + * @{ + */ +#define IS_CAN_TRANSMITMAILBOX(TRANSMITMAILBOX) ((TRANSMITMAILBOX) <= ((uint8_t)0x02)) +#define IS_CAN_STDID(STDID) ((STDID) <= ((uint32_t)0x7FF)) +#define IS_CAN_EXTID(EXTID) ((EXTID) <= ((uint32_t)0x1FFFFFFF)) +#define IS_CAN_DLC(DLC) ((DLC) <= ((uint8_t)0x08)) +/** + * @} + */ + +/** @defgroup CAN_identifier_type + * @{ + */ +#define CAN_Id_Standard ((uint32_t)0x00000000) /*!< Standard Id */ +#define CAN_Id_Extended ((uint32_t)0x00000004) /*!< Extended Id */ +#define IS_CAN_IDTYPE(IDTYPE) (((IDTYPE) == CAN_Id_Standard) || \ + ((IDTYPE) == CAN_Id_Extended)) + +/* Legacy defines */ +#define CAN_ID_STD CAN_Id_Standard +#define CAN_ID_EXT CAN_Id_Extended +/** + * @} + */ + +/** @defgroup CAN_remote_transmission_request + * @{ + */ +#define CAN_RTR_Data ((uint32_t)0x00000000) /*!< Data frame */ +#define CAN_RTR_Remote ((uint32_t)0x00000002) /*!< Remote frame */ +#define IS_CAN_RTR(RTR) (((RTR) == CAN_RTR_Data) || ((RTR) == CAN_RTR_Remote)) + +/* Legacy defines */ +#define CAN_RTR_DATA CAN_RTR_Data +#define CAN_RTR_REMOTE CAN_RTR_Remote +/** + * @} + */ + +/** @defgroup CAN_transmit_constants + * @{ + */ +#define CAN_TxStatus_Failed ((uint8_t)0x00)/*!< CAN transmission failed */ +#define CAN_TxStatus_Ok ((uint8_t)0x01) /*!< CAN transmission succeeded */ +#define CAN_TxStatus_Pending ((uint8_t)0x02) /*!< CAN transmission pending */ +#define CAN_TxStatus_NoMailBox ((uint8_t)0x04) /*!< CAN cell did not provide + an empty mailbox */ +/* Legacy defines */ +#define CANTXFAILED CAN_TxStatus_Failed +#define CANTXOK CAN_TxStatus_Ok +#define CANTXPENDING CAN_TxStatus_Pending +#define CAN_NO_MB CAN_TxStatus_NoMailBox +/** + * @} + */ + +/** @defgroup CAN_receive_FIFO_number_constants + * @{ + */ +#define CAN_FIFO0 ((uint8_t)0x00) /*!< CAN FIFO 0 used to receive */ +#define CAN_FIFO1 ((uint8_t)0x01) /*!< CAN FIFO 1 used to receive */ + +#define IS_CAN_FIFO(FIFO) (((FIFO) == CAN_FIFO0) || ((FIFO) == CAN_FIFO1)) +/** + * @} + */ + +/** @defgroup CAN_sleep_constants + * @{ + */ +#define CAN_Sleep_Failed ((uint8_t)0x00) /*!< CAN did not enter the sleep mode */ +#define CAN_Sleep_Ok ((uint8_t)0x01) /*!< CAN entered the sleep mode */ + +/* Legacy defines */ +#define CANSLEEPFAILED CAN_Sleep_Failed +#define CANSLEEPOK CAN_Sleep_Ok +/** + * @} + */ + +/** @defgroup CAN_wake_up_constants + * @{ + */ +#define CAN_WakeUp_Failed ((uint8_t)0x00) /*!< CAN did not leave the sleep mode */ +#define CAN_WakeUp_Ok ((uint8_t)0x01) /*!< CAN leaved the sleep mode */ + +/* Legacy defines */ +#define CANWAKEUPFAILED CAN_WakeUp_Failed +#define CANWAKEUPOK CAN_WakeUp_Ok +/** + * @} + */ + +/** + * @defgroup CAN_Error_Code_constants + * @{ + */ +#define CAN_ErrorCode_NoErr ((uint8_t)0x00) /*!< No Error */ +#define CAN_ErrorCode_StuffErr ((uint8_t)0x10) /*!< Stuff Error */ +#define CAN_ErrorCode_FormErr ((uint8_t)0x20) /*!< Form Error */ +#define CAN_ErrorCode_ACKErr ((uint8_t)0x30) /*!< Acknowledgment Error */ +#define CAN_ErrorCode_BitRecessiveErr ((uint8_t)0x40) /*!< Bit Recessive Error */ +#define CAN_ErrorCode_BitDominantErr ((uint8_t)0x50) /*!< Bit Dominant Error */ +#define CAN_ErrorCode_CRCErr ((uint8_t)0x60) /*!< CRC Error */ +#define CAN_ErrorCode_SoftwareSetErr ((uint8_t)0x70) /*!< Software Set Error */ +/** + * @} + */ + +/** @defgroup CAN_flags + * @{ + */ +/* If the flag is 0x3XXXXXXX, it means that it can be used with CAN_GetFlagStatus() + and CAN_ClearFlag() functions. */ +/* If the flag is 0x1XXXXXXX, it means that it can only be used with + CAN_GetFlagStatus() function. */ + +/* Transmit Flags */ +#define CAN_FLAG_RQCP0 ((uint32_t)0x38000001) /*!< Request MailBox0 Flag */ +#define CAN_FLAG_RQCP1 ((uint32_t)0x38000100) /*!< Request MailBox1 Flag */ +#define CAN_FLAG_RQCP2 ((uint32_t)0x38010000) /*!< Request MailBox2 Flag */ + +/* Receive Flags */ +#define CAN_FLAG_FMP0 ((uint32_t)0x12000003) /*!< FIFO 0 Message Pending Flag */ +#define CAN_FLAG_FF0 ((uint32_t)0x32000008) /*!< FIFO 0 Full Flag */ +#define CAN_FLAG_FOV0 ((uint32_t)0x32000010) /*!< FIFO 0 Overrun Flag */ +#define CAN_FLAG_FMP1 ((uint32_t)0x14000003) /*!< FIFO 1 Message Pending Flag */ +#define CAN_FLAG_FF1 ((uint32_t)0x34000008) /*!< FIFO 1 Full Flag */ +#define CAN_FLAG_FOV1 ((uint32_t)0x34000010) /*!< FIFO 1 Overrun Flag */ + +/* Operating Mode Flags */ +#define CAN_FLAG_WKU ((uint32_t)0x31000008) /*!< Wake up Flag */ +#define CAN_FLAG_SLAK ((uint32_t)0x31000012) /*!< Sleep acknowledge Flag */ +/* @note When SLAK interrupt is disabled (SLKIE=0), no polling on SLAKI is possible. + In this case the SLAK bit can be polled.*/ + +/* Error Flags */ +#define CAN_FLAG_EWG ((uint32_t)0x10F00001) /*!< Error Warning Flag */ +#define CAN_FLAG_EPV ((uint32_t)0x10F00002) /*!< Error Passive Flag */ +#define CAN_FLAG_BOF ((uint32_t)0x10F00004) /*!< Bus-Off Flag */ +#define CAN_FLAG_LEC ((uint32_t)0x30F00070) /*!< Last error code Flag */ + +#define IS_CAN_GET_FLAG(FLAG) (((FLAG) == CAN_FLAG_LEC) || ((FLAG) == CAN_FLAG_BOF) || \ + ((FLAG) == CAN_FLAG_EPV) || ((FLAG) == CAN_FLAG_EWG) || \ + ((FLAG) == CAN_FLAG_WKU) || ((FLAG) == CAN_FLAG_FOV0) || \ + ((FLAG) == CAN_FLAG_FF0) || ((FLAG) == CAN_FLAG_FMP0) || \ + ((FLAG) == CAN_FLAG_FOV1) || ((FLAG) == CAN_FLAG_FF1) || \ + ((FLAG) == CAN_FLAG_FMP1) || ((FLAG) == CAN_FLAG_RQCP2) || \ + ((FLAG) == CAN_FLAG_RQCP1)|| ((FLAG) == CAN_FLAG_RQCP0) || \ + ((FLAG) == CAN_FLAG_SLAK )) + +#define IS_CAN_CLEAR_FLAG(FLAG)(((FLAG) == CAN_FLAG_LEC) || ((FLAG) == CAN_FLAG_RQCP2) || \ + ((FLAG) == CAN_FLAG_RQCP1) || ((FLAG) == CAN_FLAG_RQCP0) || \ + ((FLAG) == CAN_FLAG_FF0) || ((FLAG) == CAN_FLAG_FOV0) ||\ + ((FLAG) == CAN_FLAG_FF1) || ((FLAG) == CAN_FLAG_FOV1) || \ + ((FLAG) == CAN_FLAG_WKU) || ((FLAG) == CAN_FLAG_SLAK)) +/** + * @} + */ + + +/** @defgroup CAN_interrupts + * @{ + */ +#define CAN_IT_TME ((uint32_t)0x00000001) /*!< Transmit mailbox empty Interrupt*/ + +/* Receive Interrupts */ +#define CAN_IT_FMP0 ((uint32_t)0x00000002) /*!< FIFO 0 message pending Interrupt*/ +#define CAN_IT_FF0 ((uint32_t)0x00000004) /*!< FIFO 0 full Interrupt*/ +#define CAN_IT_FOV0 ((uint32_t)0x00000008) /*!< FIFO 0 overrun Interrupt*/ +#define CAN_IT_FMP1 ((uint32_t)0x00000010) /*!< FIFO 1 message pending Interrupt*/ +#define CAN_IT_FF1 ((uint32_t)0x00000020) /*!< FIFO 1 full Interrupt*/ +#define CAN_IT_FOV1 ((uint32_t)0x00000040) /*!< FIFO 1 overrun Interrupt*/ + +/* Operating Mode Interrupts */ +#define CAN_IT_WKU ((uint32_t)0x00010000) /*!< Wake-up Interrupt*/ +#define CAN_IT_SLK ((uint32_t)0x00020000) /*!< Sleep acknowledge Interrupt*/ + +/* Error Interrupts */ +#define CAN_IT_EWG ((uint32_t)0x00000100) /*!< Error warning Interrupt*/ +#define CAN_IT_EPV ((uint32_t)0x00000200) /*!< Error passive Interrupt*/ +#define CAN_IT_BOF ((uint32_t)0x00000400) /*!< Bus-off Interrupt*/ +#define CAN_IT_LEC ((uint32_t)0x00000800) /*!< Last error code Interrupt*/ +#define CAN_IT_ERR ((uint32_t)0x00008000) /*!< Error Interrupt*/ + +/* Flags named as Interrupts : kept only for FW compatibility */ +#define CAN_IT_RQCP0 CAN_IT_TME +#define CAN_IT_RQCP1 CAN_IT_TME +#define CAN_IT_RQCP2 CAN_IT_TME + + +#define IS_CAN_IT(IT) (((IT) == CAN_IT_TME) || ((IT) == CAN_IT_FMP0) ||\ + ((IT) == CAN_IT_FF0) || ((IT) == CAN_IT_FOV0) ||\ + ((IT) == CAN_IT_FMP1) || ((IT) == CAN_IT_FF1) ||\ + ((IT) == CAN_IT_FOV1) || ((IT) == CAN_IT_EWG) ||\ + ((IT) == CAN_IT_EPV) || ((IT) == CAN_IT_BOF) ||\ + ((IT) == CAN_IT_LEC) || ((IT) == CAN_IT_ERR) ||\ + ((IT) == CAN_IT_WKU) || ((IT) == CAN_IT_SLK)) + +#define IS_CAN_CLEAR_IT(IT) (((IT) == CAN_IT_TME) || ((IT) == CAN_IT_FF0) ||\ + ((IT) == CAN_IT_FOV0)|| ((IT) == CAN_IT_FF1) ||\ + ((IT) == CAN_IT_FOV1)|| ((IT) == CAN_IT_EWG) ||\ + ((IT) == CAN_IT_EPV) || ((IT) == CAN_IT_BOF) ||\ + ((IT) == CAN_IT_LEC) || ((IT) == CAN_IT_ERR) ||\ + ((IT) == CAN_IT_WKU) || ((IT) == CAN_IT_SLK)) +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions --------------------------------------------------------*/ + +/* Function used to set the CAN configuration to the default reset state *****/ +void CAN_DeInit(CAN_TypeDef* CANx); + +/* Initialization and Configuration functions *********************************/ +uint8_t CAN_Init(CAN_TypeDef* CANx, CAN_InitTypeDef* CAN_InitStruct); +void CAN_FilterInit(CAN_FilterInitTypeDef* CAN_FilterInitStruct); +void CAN_StructInit(CAN_InitTypeDef* CAN_InitStruct); +void CAN_SlaveStartBank(uint8_t CAN_BankNumber); +void CAN_DBGFreeze(CAN_TypeDef* CANx, FunctionalState NewState); +void CAN_TTComModeCmd(CAN_TypeDef* CANx, FunctionalState NewState); + +/* CAN Frames Transmission functions ******************************************/ +uint8_t CAN_Transmit(CAN_TypeDef* CANx, CanTxMsg* TxMessage); +uint8_t CAN_TransmitStatus(CAN_TypeDef* CANx, uint8_t TransmitMailbox); +void CAN_CancelTransmit(CAN_TypeDef* CANx, uint8_t Mailbox); + +/* CAN Frames Reception functions *********************************************/ +void CAN_Receive(CAN_TypeDef* CANx, uint8_t FIFONumber, CanRxMsg* RxMessage); +void CAN_FIFORelease(CAN_TypeDef* CANx, uint8_t FIFONumber); +uint8_t CAN_MessagePending(CAN_TypeDef* CANx, uint8_t FIFONumber); + +/* Operation modes functions **************************************************/ +uint8_t CAN_OperatingModeRequest(CAN_TypeDef* CANx, uint8_t CAN_OperatingMode); +uint8_t CAN_Sleep(CAN_TypeDef* CANx); +uint8_t CAN_WakeUp(CAN_TypeDef* CANx); + +/* CAN Bus Error management functions *****************************************/ +uint8_t CAN_GetLastErrorCode(CAN_TypeDef* CANx); +uint8_t CAN_GetReceiveErrorCounter(CAN_TypeDef* CANx); +uint8_t CAN_GetLSBTransmitErrorCounter(CAN_TypeDef* CANx); + +/* Interrupts and flags management functions **********************************/ +void CAN_ITConfig(CAN_TypeDef* CANx, uint32_t CAN_IT, FunctionalState NewState); +FlagStatus CAN_GetFlagStatus(CAN_TypeDef* CANx, uint32_t CAN_FLAG); +void CAN_ClearFlag(CAN_TypeDef* CANx, uint32_t CAN_FLAG); +ITStatus CAN_GetITStatus(CAN_TypeDef* CANx, uint32_t CAN_IT); +void CAN_ClearITPendingBit(CAN_TypeDef* CANx, uint32_t CAN_IT); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0xx_CAN_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_cec.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_cec.h new file mode 100644 index 00000000..ca1244e2 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_cec.h @@ -0,0 +1,300 @@ +/** + ****************************************************************************** + * @file stm32f0xx_cec.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the CEC firmware + * library, applicable only for STM32F051, STM32F042 and STM32F072 devices. + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_CEC_H +#define __STM32F0XX_CEC_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup CEC + * @{ + */ +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief CEC Init structure definition + */ +typedef struct +{ + uint32_t CEC_SignalFreeTime; /*!< Specifies the CEC Signal Free Time configuration. + This parameter can be a value of @ref CEC_Signal_Free_Time */ + uint32_t CEC_RxTolerance; /*!< Specifies the CEC Reception Tolerance. + This parameter can be a value of @ref CEC_RxTolerance */ + uint32_t CEC_StopReception; /*!< Specifies the CEC Stop Reception. + This parameter can be a value of @ref CEC_Stop_Reception */ + uint32_t CEC_BitRisingError; /*!< Specifies the CEC Bit Rising Error generation. + This parameter can be a value of @ref CEC_Bit_Rising_Error_Generation */ + uint32_t CEC_LongBitPeriodError; /*!< Specifies the CEC Long Bit Error generation. + This parameter can be a value of @ref CEC_Long_Bit_Error_Generation */ + uint32_t CEC_BRDNoGen; /*!< Specifies the CEC Broadcast Error generation. + This parameter can be a value of @ref CEC_BDR_No_Gen */ + uint32_t CEC_SFTOption; /*!< Specifies the CEC Signal Free Time option. + This parameter can be a value of @ref CEC_SFT_Option */ + +}CEC_InitTypeDef; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup CEC_Exported_Constants + * @{ + */ + +/** @defgroup CEC_Signal_Free_Time + * @{ + */ +#define CEC_SignalFreeTime_Standard ((uint32_t)0x00000000) /*!< CEC Signal Free Time Standard */ +#define CEC_SignalFreeTime_1T ((uint32_t)0x00000001) /*!< CEC 1.5 nominal data bit periods */ +#define CEC_SignalFreeTime_2T ((uint32_t)0x00000002) /*!< CEC 2.5 nominal data bit periods */ +#define CEC_SignalFreeTime_3T ((uint32_t)0x00000003) /*!< CEC 3.5 nominal data bit periods */ +#define CEC_SignalFreeTime_4T ((uint32_t)0x00000004) /*!< CEC 4.5 nominal data bit periods */ +#define CEC_SignalFreeTime_5T ((uint32_t)0x00000005) /*!< CEC 5.5 nominal data bit periods */ +#define CEC_SignalFreeTime_6T ((uint32_t)0x00000006) /*!< CEC 6.5 nominal data bit periods */ +#define CEC_SignalFreeTime_7T ((uint32_t)0x00000007) /*!< CEC 7.5 nominal data bit periods */ + +#define IS_CEC_SIGNAL_FREE_TIME(TIME) (((TIME) == CEC_SignalFreeTime_Standard) || \ + ((TIME) == CEC_SignalFreeTime_1T)|| \ + ((TIME) == CEC_SignalFreeTime_2T)|| \ + ((TIME) == CEC_SignalFreeTime_3T)|| \ + ((TIME) == CEC_SignalFreeTime_4T)|| \ + ((TIME) == CEC_SignalFreeTime_5T)|| \ + ((TIME) == CEC_SignalFreeTime_6T)|| \ + ((TIME) == CEC_SignalFreeTime_7T)) +/** + * @} + */ + +/** @defgroup CEC_RxTolerance + * @{ + */ +#define CEC_RxTolerance_Standard ((uint32_t)0x00000000) /*!< Standard Tolerance Margin */ +#define CEC_RxTolerance_Extended CEC_CFGR_RXTOL /*!< Extended Tolerance Margin */ + +#define IS_CEC_RX_TOLERANCE(TOLERANCE) (((TOLERANCE) == CEC_RxTolerance_Standard) || \ + ((TOLERANCE) == CEC_RxTolerance_Extended)) +/** + * @} + */ + +/** @defgroup CEC_Stop_Reception + * @{ + */ +#define CEC_StopReception_Off ((uint32_t)0x00000000) /*!< No RX Stop on bit Rising Error (BRE) */ +#define CEC_StopReception_On CEC_CFGR_BRESTP /*!< RX Stop on bit Rising Error (BRE) */ + +#define IS_CEC_STOP_RECEPTION(RECEPTION) (((RECEPTION) == CEC_StopReception_On) || \ + ((RECEPTION) == CEC_StopReception_Off)) +/** + * @} + */ + +/** @defgroup CEC_Bit_Rising_Error_Generation + * @{ + */ +#define CEC_BitRisingError_Off ((uint32_t)0x00000000) /*!< Bit Rising Error generation turned Off */ +#define CEC_BitRisingError_On CEC_CFGR_BREGEN /*!< Bit Rising Error generation turned On */ + +#define IS_CEC_BIT_RISING_ERROR(ERROR) (((ERROR) == CEC_BitRisingError_Off) || \ + ((ERROR) == CEC_BitRisingError_On)) +/** + * @} + */ + +/** @defgroup CEC_Long_Bit_Error_Generation + * @{ + */ +#define CEC_LongBitPeriodError_Off ((uint32_t)0x00000000) /*!< Long Bit Period Error generation turned Off */ +#define CEC_LongBitPeriodError_On CEC_CFGR_LREGEN /*!< Long Bit Period Error generation turned On */ + +#define IS_CEC_LONG_BIT_PERIOD_ERROR(ERROR) (((ERROR) == CEC_LongBitPeriodError_Off) || \ + ((ERROR) == CEC_LongBitPeriodError_On)) +/** + * @} + */ + +/** @defgroup CEC_BDR_No_Gen + * @{ + */ + +#define CEC_BRDNoGen_Off ((uint32_t)0x00000000) /*!< Broadcast Bit Rising Error generation turned Off */ +#define CEC_BRDNoGen_On CEC_CFGR_BRDNOGEN /*!< Broadcast Bit Rising Error generation turned On */ + +#define IS_CEC_BDR_NO_GEN_ERROR(ERROR) (((ERROR) == CEC_BRDNoGen_Off) || \ + ((ERROR) == CEC_BRDNoGen_On)) +/** + * @} + */ + +/** @defgroup CEC_SFT_Option + * @{ + */ +#define CEC_SFTOption_Off ((uint32_t)0x00000000) /*!< SFT option turned Off */ +#define CEC_SFTOption_On CEC_CFGR_SFTOPT /*!< SFT option turned On */ + +#define IS_CEC_SFT_OPTION(OPTION) (((OPTION) == CEC_SFTOption_Off) || \ + ((OPTION) == CEC_SFTOption_On)) +/** + * @} + */ + +/** @defgroup CEC_Own_Address + * @{ + */ +#define IS_CEC_ADDRESS(ADDRESS) ((ADDRESS) < 0x10) + +/** + * @} + */ + +/** @defgroup CEC_Interrupt_Configuration_definition + * @{ + */ +#define CEC_IT_TXACKE CEC_IER_TXACKEIE +#define CEC_IT_TXERR CEC_IER_TXERRIE +#define CEC_IT_TXUDR CEC_IER_TXUDRIE +#define CEC_IT_TXEND CEC_IER_TXENDIE +#define CEC_IT_TXBR CEC_IER_TXBRIE +#define CEC_IT_ARBLST CEC_IER_ARBLSTIE +#define CEC_IT_RXACKE CEC_IER_RXACKEIE +#define CEC_IT_LBPE CEC_IER_LBPEIE +#define CEC_IT_SBPE CEC_IER_SBPEIE +#define CEC_IT_BRE CEC_IER_BREIEIE +#define CEC_IT_RXOVR CEC_IER_RXOVRIE +#define CEC_IT_RXEND CEC_IER_RXENDIE +#define CEC_IT_RXBR CEC_IER_RXBRIE + +#define IS_CEC_IT(IT) ((((IT) & (uint32_t)0xFFFFE000) == 0x00) && ((IT) != 0x00)) + +#define IS_CEC_GET_IT(IT) (((IT) == CEC_IT_TXACKE) || \ + ((IT) == CEC_IT_TXERR)|| \ + ((IT) == CEC_IT_TXUDR)|| \ + ((IT) == CEC_IT_TXEND)|| \ + ((IT) == CEC_IT_TXBR)|| \ + ((IT) == CEC_IT_ARBLST)|| \ + ((IT) == CEC_IT_RXACKE)|| \ + ((IT) == CEC_IT_LBPE)|| \ + ((IT) == CEC_IT_SBPE)|| \ + ((IT) == CEC_IT_BRE)|| \ + ((IT) == CEC_IT_RXOVR)|| \ + ((IT) == CEC_IT_RXEND)|| \ + ((IT) == CEC_IT_RXBR)) +/** + * @} + */ + +/** @defgroup CEC_ISR_register_flags_definition + * @{ + */ +#define CEC_FLAG_TXACKE CEC_ISR_TXACKE +#define CEC_FLAG_TXERR CEC_ISR_TXERR +#define CEC_FLAG_TXUDR CEC_ISR_TXUDR +#define CEC_FLAG_TXEND CEC_ISR_TXEND +#define CEC_FLAG_TXBR CEC_ISR_TXBR +#define CEC_FLAG_ARBLST CEC_ISR_ARBLST +#define CEC_FLAG_RXACKE CEC_ISR_RXACKE +#define CEC_FLAG_LBPE CEC_ISR_LBPE +#define CEC_FLAG_SBPE CEC_ISR_SBPE +#define CEC_FLAG_BRE CEC_ISR_BRE +#define CEC_FLAG_RXOVR CEC_ISR_RXOVR +#define CEC_FLAG_RXEND CEC_ISR_RXEND +#define CEC_FLAG_RXBR CEC_ISR_RXBR + +#define IS_CEC_CLEAR_FLAG(FLAG) ((((FLAG) & (uint32_t)0xFFFFE000) == 0x00) && ((FLAG) != 0x00)) + +#define IS_CEC_GET_FLAG(FLAG) (((FLAG) == CEC_FLAG_TXACKE) || \ + ((FLAG) == CEC_FLAG_TXERR)|| \ + ((FLAG) == CEC_FLAG_TXUDR)|| \ + ((FLAG) == CEC_FLAG_TXEND)|| \ + ((FLAG) == CEC_FLAG_TXBR)|| \ + ((FLAG) == CEC_FLAG_ARBLST)|| \ + ((FLAG) == CEC_FLAG_RXACKE)|| \ + ((FLAG) == CEC_FLAG_LBPE)|| \ + ((FLAG) == CEC_FLAG_SBPE)|| \ + ((FLAG) == CEC_FLAG_BRE)|| \ + ((FLAG) == CEC_FLAG_RXOVR)|| \ + ((FLAG) == CEC_FLAG_RXEND)|| \ + ((FLAG) == CEC_FLAG_RXBR)) +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Function used to set the CEC configuration to the default reset state *****/ +void CEC_DeInit(void); + +/* CEC_Initialization and Configuration functions *****************************/ +void CEC_Init(CEC_InitTypeDef* CEC_InitStruct); +void CEC_StructInit(CEC_InitTypeDef* CEC_InitStruct); +void CEC_Cmd(FunctionalState NewState); +void CEC_ListenModeCmd(FunctionalState NewState); +void CEC_OwnAddressConfig(uint8_t CEC_OwnAddress); +void CEC_OwnAddressClear(void); + +/* CEC_Data transfers functions ***********************************************/ +void CEC_SendData(uint8_t Data); +uint8_t CEC_ReceiveData(void); +void CEC_StartOfMessage(void); +void CEC_EndOfMessage(void); + +/* CEC_Interrupts and flags management functions ******************************/ +void CEC_ITConfig(uint16_t CEC_IT, FunctionalState NewState); +FlagStatus CEC_GetFlagStatus(uint16_t CEC_FLAG); +void CEC_ClearFlag(uint32_t CEC_FLAG); +ITStatus CEC_GetITStatus(uint16_t CEC_IT); +void CEC_ClearITPendingBit(uint16_t CEC_IT); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_CEC_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_comp.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_comp.h new file mode 100644 index 00000000..12d1493b --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_comp.h @@ -0,0 +1,245 @@ +/** + ****************************************************************************** + * @file stm32f0xx_comp.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the COMP firmware + * library, applicable only for STM32F051 and STM32F072 devices. + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_COMP_H +#define __STM32F0XX_COMP_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup COMP + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief COMP Init structure definition + */ + +typedef struct +{ + + uint32_t COMP_InvertingInput; /*!< Selects the inverting input of the comparator. + This parameter can be a value of @ref COMP_InvertingInput */ + + uint32_t COMP_Output; /*!< Selects the output redirection of the comparator. + This parameter can be a value of @ref COMP_Output */ + + uint32_t COMP_OutputPol; /*!< Selects the output polarity of the comparator. + This parameter can be a value of @ref COMP_OutputPolarity */ + + uint32_t COMP_Hysteresis; /*!< Selects the hysteresis voltage of the comparator. + This parameter can be a value of @ref COMP_Hysteresis */ + + uint32_t COMP_Mode; /*!< Selects the operating mode of the comparator + and allows to adjust the speed/consumption. + This parameter can be a value of @ref COMP_Mode */ + +}COMP_InitTypeDef; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup COMP_Exported_Constants + * @{ + */ + +/** @defgroup COMP_Selection + * @{ + */ + +#define COMP_Selection_COMP1 ((uint32_t)0x00000000) /*!< COMP1 Selection */ +#define COMP_Selection_COMP2 ((uint32_t)0x00000010) /*!< COMP2 Selection */ + +#define IS_COMP_ALL_PERIPH(PERIPH) (((PERIPH) == COMP_Selection_COMP1) || \ + ((PERIPH) == COMP_Selection_COMP2)) + +/** + * @} + */ + +/** @defgroup COMP_InvertingInput + * @{ + */ + +#define COMP_InvertingInput_1_4VREFINT ((uint32_t)0x00000000) /*!< 1/4 VREFINT connected to comparator inverting input */ +#define COMP_InvertingInput_1_2VREFINT COMP_CSR_COMP1INSEL_0 /*!< 1/2 VREFINT connected to comparator inverting input */ +#define COMP_InvertingInput_3_4VREFINT COMP_CSR_COMP1INSEL_1 /*!< 3/4 VREFINT connected to comparator inverting input */ +#define COMP_InvertingInput_VREFINT ((uint32_t)0x00000030) /*!< VREFINT connected to comparator inverting input */ +#define COMP_InvertingInput_DAC1 COMP_CSR_COMP1INSEL_2 /*!< DAC1_OUT (PA4) connected to comparator inverting input */ +#define COMP_InvertingInput_DAC2 ((uint32_t)0x00000050) /*!< DAC2_OUT (PA5) connected to comparator inverting input, applicable only for STM32F072 devices */ +#define COMP_InvertingInput_IO ((uint32_t)0x00000060) /*!< I/O (PA0 for COMP1 and PA2 for COMP2) connected to comparator inverting input */ + +#define IS_COMP_INVERTING_INPUT(INPUT) (((INPUT) == COMP_InvertingInput_1_4VREFINT) || \ + ((INPUT) == COMP_InvertingInput_1_2VREFINT) || \ + ((INPUT) == COMP_InvertingInput_3_4VREFINT) || \ + ((INPUT) == COMP_InvertingInput_VREFINT) || \ + ((INPUT) == COMP_InvertingInput_DAC1) || \ + ((INPUT) == COMP_InvertingInput_DAC2) || \ + ((INPUT) == COMP_InvertingInput_1_4VREFINT) || \ + ((INPUT) == COMP_InvertingInput_IO)) +/** + * @} + */ + +/** @defgroup COMP_Output + * @{ + */ + +#define COMP_Output_None ((uint32_t)0x00000000) /*!< COMP output isn't connected to other peripherals */ +#define COMP_Output_TIM1BKIN COMP_CSR_COMP1OUTSEL_0 /*!< COMP output connected to TIM1 Break Input (BKIN) */ +#define COMP_Output_TIM1IC1 COMP_CSR_COMP1OUTSEL_1 /*!< COMP output connected to TIM1 Input Capture 1 */ +#define COMP_Output_TIM1OCREFCLR ((uint32_t)0x00000300) /*!< COMP output connected to TIM1 OCREF Clear */ +#define COMP_Output_TIM2IC4 COMP_CSR_COMP1OUTSEL_2 /*!< COMP output connected to TIM2 Input Capture 4 */ +#define COMP_Output_TIM2OCREFCLR ((uint32_t)0x00000500) /*!< COMP output connected to TIM2 OCREF Clear */ +#define COMP_Output_TIM3IC1 ((uint32_t)0x00000600) /*!< COMP output connected to TIM3 Input Capture 1 */ +#define COMP_Output_TIM3OCREFCLR COMP_CSR_COMP1OUTSEL /*!< COMP output connected to TIM3 OCREF Clear */ + + +#define IS_COMP_OUTPUT(OUTPUT) (((OUTPUT) == COMP_Output_None) || \ + ((OUTPUT) == COMP_Output_TIM1BKIN) || \ + ((OUTPUT) == COMP_Output_TIM1IC1) || \ + ((OUTPUT) == COMP_Output_TIM1OCREFCLR) || \ + ((OUTPUT) == COMP_Output_TIM2IC4) || \ + ((OUTPUT) == COMP_Output_TIM2OCREFCLR) || \ + ((OUTPUT) == COMP_Output_TIM3IC1) || \ + ((OUTPUT) == COMP_Output_TIM3OCREFCLR)) +/** + * @} + */ + +/** @defgroup COMP_OutputPolarity + * @{ + */ +#define COMP_OutputPol_NonInverted ((uint32_t)0x00000000) /*!< COMP output on GPIO isn't inverted */ +#define COMP_OutputPol_Inverted COMP_CSR_COMP1POL /*!< COMP output on GPIO is inverted */ + +#define IS_COMP_OUTPUT_POL(POL) (((POL) == COMP_OutputPol_NonInverted) || \ + ((POL) == COMP_OutputPol_Inverted)) + +/** + * @} + */ + +/** @defgroup COMP_Hysteresis + * @{ + */ +/* Please refer to the electrical characteristics in the device datasheet for + the hysteresis level */ +#define COMP_Hysteresis_No 0x00000000 /*!< No hysteresis */ +#define COMP_Hysteresis_Low COMP_CSR_COMP1HYST_0 /*!< Hysteresis level low */ +#define COMP_Hysteresis_Medium COMP_CSR_COMP1HYST_1 /*!< Hysteresis level medium */ +#define COMP_Hysteresis_High COMP_CSR_COMP1HYST /*!< Hysteresis level high */ + +#define IS_COMP_HYSTERESIS(HYSTERESIS) (((HYSTERESIS) == COMP_Hysteresis_No) || \ + ((HYSTERESIS) == COMP_Hysteresis_Low) || \ + ((HYSTERESIS) == COMP_Hysteresis_Medium) || \ + ((HYSTERESIS) == COMP_Hysteresis_High)) +/** + * @} + */ + +/** @defgroup COMP_Mode + * @{ + */ +/* Please refer to the electrical characteristics in the device datasheet for + the power consumption values */ +#define COMP_Mode_HighSpeed 0x00000000 /*!< High Speed */ +#define COMP_Mode_MediumSpeed COMP_CSR_COMP1MODE_0 /*!< Medium Speed */ +#define COMP_Mode_LowPower COMP_CSR_COMP1MODE_1 /*!< Low power mode */ +#define COMP_Mode_UltraLowPower COMP_CSR_COMP1MODE /*!< Ultra-low power mode */ + +#define IS_COMP_MODE(MODE) (((MODE) == COMP_Mode_UltraLowPower) || \ + ((MODE) == COMP_Mode_LowPower) || \ + ((MODE) == COMP_Mode_MediumSpeed) || \ + ((MODE) == COMP_Mode_HighSpeed)) +/** + * @} + */ + +/** @defgroup COMP_OutputLevel + * @{ + */ +/* When output polarity is not inverted, comparator output is high when + the non-inverting input is at a higher voltage than the inverting input */ +#define COMP_OutputLevel_High COMP_CSR_COMP1OUT +/* When output polarity is not inverted, comparator output is low when + the non-inverting input is at a lower voltage than the inverting input*/ +#define COMP_OutputLevel_Low ((uint32_t)0x00000000) + +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Function used to set the COMP configuration to the default reset state ****/ +void COMP_DeInit(void); + +/* Initialization and Configuration functions *********************************/ +void COMP_Init(uint32_t COMP_Selection, COMP_InitTypeDef* COMP_InitStruct); +void COMP_StructInit(COMP_InitTypeDef* COMP_InitStruct); +void COMP_Cmd(uint32_t COMP_Selection, FunctionalState NewState); +void COMP_SwitchCmd(FunctionalState NewState); +uint32_t COMP_GetOutputLevel(uint32_t COMP_Selection); + +/* Window mode control function ***********************************************/ +void COMP_WindowCmd(FunctionalState NewState); + +/* COMP configuration locking function ****************************************/ +void COMP_LockConfig(uint32_t COMP_Selection); + +#ifdef __cplusplus +} +#endif + +#endif /*__STM32F0XX_COMP_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_crc.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_crc.h new file mode 100644 index 00000000..e639df63 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_crc.h @@ -0,0 +1,122 @@ +/** + ****************************************************************************** + * @file stm32f0xx_crc.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the CRC firmware + * library. + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_CRC_H +#define __STM32F0XX_CRC_H + +#ifdef __cplusplus + extern "C" { +#endif + +/*!< Includes ----------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup CRC + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup CRC_ReverseInputData + * @{ + */ +#define CRC_ReverseInputData_No ((uint32_t)0x00000000) /*!< No reverse operation of Input Data */ +#define CRC_ReverseInputData_8bits CRC_CR_REV_IN_0 /*!< Reverse operation of Input Data on 8 bits */ +#define CRC_ReverseInputData_16bits CRC_CR_REV_IN_1 /*!< Reverse operation of Input Data on 16 bits */ +#define CRC_ReverseInputData_32bits CRC_CR_REV_IN /*!< Reverse operation of Input Data on 32 bits */ + +#define IS_CRC_REVERSE_INPUT_DATA(DATA) (((DATA) == CRC_ReverseInputData_No) || \ + ((DATA) == CRC_ReverseInputData_8bits) || \ + ((DATA) == CRC_ReverseInputData_16bits) || \ + ((DATA) == CRC_ReverseInputData_32bits)) + +/** + * @} + */ + +/** @defgroup CRC_PolynomialSize + * @brief Only applicable for STM32F042 and STM32F072 devices + * @{ + */ +#define CRC_PolSize_7 CRC_CR_POLSIZE /*!< 7-bit polynomial for CRC calculation */ +#define CRC_PolSize_8 CRC_CR_POLSIZE_1 /*!< 8-bit polynomial for CRC calculation */ +#define CRC_PolSize_16 CRC_CR_POLSIZE_0 /*!< 16-bit polynomial for CRC calculation */ +#define CRC_PolSize_32 ((uint32_t)0x00000000)/*!< 32-bit polynomial for CRC calculation */ + +#define IS_CRC_POL_SIZE(SIZE) (((SIZE) == CRC_PolSize_7) || \ + ((SIZE) == CRC_PolSize_8) || \ + ((SIZE) == CRC_PolSize_16) || \ + ((SIZE) == CRC_PolSize_32)) + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ +/* Configuration of the CRC computation unit **********************************/ +void CRC_DeInit(void); +void CRC_ResetDR(void); +void CRC_PolynomialSizeSelect(uint32_t CRC_PolSize); /*!< Only applicable for STM32F042 and STM32F072 devices */ +void CRC_ReverseInputDataSelect(uint32_t CRC_ReverseInputData); +void CRC_ReverseOutputDataCmd(FunctionalState NewState); +void CRC_SetInitRegister(uint32_t CRC_InitValue); +void CRC_SetPolynomial(uint32_t CRC_Pol); /*!< Only applicable for STM32F042 and STM32F072 devices */ + +/* CRC computation ************************************************************/ +uint32_t CRC_CalcCRC(uint32_t CRC_Data); +uint32_t CRC_CalcCRC16bits(uint16_t CRC_Data); /*!< Only applicable for STM32F042 and STM32F072 devices */ +uint32_t CRC_CalcCRC8bits(uint8_t CRC_Data); /*!< Only applicable for STM32F042 and STM32F072 devices */ +uint32_t CRC_CalcBlockCRC(uint32_t pBuffer[], uint32_t BufferLength); +uint32_t CRC_GetCRC(void); + +/* Independent register (IDR) access (write/read) *****************************/ +void CRC_SetIDRegister(uint8_t CRC_IDValue); +uint8_t CRC_GetIDRegister(void); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_CRC_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_crs.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_crs.h new file mode 100644 index 00000000..ed63e981 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_crs.h @@ -0,0 +1,183 @@ +/** + ****************************************************************************** + * @file stm32f0xx_crs.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the CRS firmware + * library, applicable only for STM32F042 and STM32F072 devices. + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_CRS_H +#define __STM32F0XX_CRS_H + +#ifdef __cplusplus + extern "C" { +#endif + +/*!< Includes ----------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup CRS + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup CRS_Interrupt_Sources + * @{ + */ +#define CRS_IT_SYNCOK CRS_ISR_SYNCOKF /*!< SYNC event OK */ +#define CRS_IT_SYNCWARN CRS_ISR_SYNCWARNF /*!< SYNC warning */ +#define CRS_IT_ERR CRS_ISR_ERRF /*!< error */ +#define CRS_IT_ESYNC CRS_ISR_ESYNCF /*!< Expected SYNC */ +#define CRS_IT_TRIMOVF CRS_ISR_TRIMOVF /*!< Trimming overflow or underflow */ +#define CRS_IT_SYNCERR CRS_ISR_SYNCERR /*!< SYNC error */ +#define CRS_IT_SYNCMISS CRS_ISR_SYNCMISS /*!< SYNC missed*/ + +#define IS_CRS_IT(IT) (((IT) == CRS_IT_SYNCOK) || ((IT) == CRS_IT_SYNCWARN) || \ + ((IT) == CRS_IT_ERR) || ((IT) == CRS_IT_ESYNC)) + +#define IS_CRS_GET_IT(IT) (((IT) == CRS_IT_SYNCOK) || ((IT) == CRS_IT_SYNCWARN) || \ + ((IT) == CRS_IT_ERR) || ((IT) == CRS_IT_ESYNC) || \ + ((IT) == CRS_IT_TRIMOVF) || ((IT) == CRS_IT_SYNCERR) || \ + ((IT) == CRS_IT_SYNCMISS)) + +#define IS_CRS_CLEAR_IT(IT) ((IT) != 0x00) + +/** + * @} + */ + +/** @defgroup CRS_Flags + * @{ + */ +#define CRS_FLAG_SYNCOK CRS_ISR_SYNCOKF /*!< SYNC event OK */ +#define CRS_FLAG_SYNCWARN CRS_ISR_SYNCWARNF /*!< SYNC warning */ +#define CRS_FLAG_ERR CRS_ISR_ERRF /*!< error */ +#define CRS_FLAG_ESYNC CRS_ISR_ESYNCF /*!< Expected SYNC */ +#define CRS_FLAG_TRIMOVF CRS_ISR_TRIMOVF /*!< Trimming overflow or underflow */ +#define CRS_FLAG_SYNCERR CRS_ISR_SYNCERR /*!< SYNC error */ +#define CRS_FLAG_SYNCMISS CRS_ISR_SYNCMISS /*!< SYNC missed*/ + +#define IS_CRS_FLAG(FLAG) (((FLAG) == CRS_FLAG_SYNCOK) || ((FLAG) == CRS_FLAG_SYNCWARN) || \ + ((FLAG) == CRS_FLAG_ERR) || ((FLAG) == CRS_FLAG_ESYNC) || \ + ((FLAG) == CRS_FLAG_TRIMOVF) || ((FLAG) == CRS_FLAG_SYNCERR) || \ + ((FLAG) == CRS_FLAG_SYNCMISS)) + +/** + * @} + */ + +/** @defgroup CRS_Synchro_Source + * @{ + */ +#define CRS_SYNCSource_GPIO ((uint32_t)0x00) /*!< Synchro Signal soucre GPIO */ +#define CRS_SYNCSource_LSE CRS_CFGR_SYNCSRC_0 /*!< Synchro Signal source LSE */ +#define CRS_SYNCSource_USB CRS_CFGR_SYNCSRC_1 /*!< Synchro Signal source USB SOF */ + +#define IS_CRS_SYNC_SOURCE(SOURCE) (((SOURCE) == CRS_SYNCSource_GPIO) || \ + ((SOURCE) == CRS_SYNCSource_LSE) ||\ + ((SOURCE) == CRS_SYNCSource_USB)) +/** + * @} + */ + +/** @defgroup CRS_SynchroDivider + * @{ + */ +#define CRS_SYNC_Div1 ((uint32_t)0x00) /*!< Synchro Signal not divided */ +#define CRS_SYNC_Div2 CRS_CFGR_SYNCDIV_0 /*!< Synchro Signal divided by 2 */ +#define CRS_SYNC_Div4 CRS_CFGR_SYNCDIV_1 /*!< Synchro Signal divided by 4 */ +#define CRS_SYNC_Div8 (CRS_CFGR_SYNCDIV_1 | CRS_CFGR_SYNCDIV_0) /*!< Synchro Signal divided by 8 */ +#define CRS_SYNC_Div16 CRS_CFGR_SYNCDIV_2 /*!< Synchro Signal divided by 16 */ +#define CRS_SYNC_Div32 (CRS_CFGR_SYNCDIV_2 | CRS_CFGR_SYNCDIV_0) /*!< Synchro Signal divided by 32 */ +#define CRS_SYNC_Div64 (CRS_CFGR_SYNCDIV_2 | CRS_CFGR_SYNCDIV_1) /*!< Synchro Signal divided by 64 */ +#define CRS_SYNC_Div128 CRS_CFGR_SYNCDIV /*!< Synchro Signal divided by 128 */ + +#define IS_CRS_SYNC_DIV(DIV) (((DIV) == CRS_SYNC_Div1) || ((DIV) == CRS_SYNC_Div2) ||\ + ((DIV) == CRS_SYNC_Div4) || ((DIV) == CRS_SYNC_Div8) || \ + ((DIV) == CRS_SYNC_Div16) || ((DIV) == CRS_SYNC_Div32) || \ + ((DIV) == CRS_SYNC_Div64) || ((DIV) == CRS_SYNC_Div128)) +/** + * @} + */ + +/** @defgroup CRS_SynchroPolarity + * @{ + */ +#define CRS_SYNCPolarity_Rising ((uint32_t)0x00) /*!< Synchro Active on rising edge */ +#define CRS_SYNCPolarity_Falling CRS_CFGR_SYNCPOL /*!< Synchro Active on falling edge */ + +#define IS_CRS_SYNC_POLARITY(POLARITY) (((POLARITY) == CRS_SYNCPolarity_Rising) || \ + ((POLARITY) == CRS_SYNCPolarity_Falling)) +/** + * @} + */ + + + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ +/* Configuration of the CRS **********************************/ +void CRS_DeInit(void); +void CRS_AdjustHSI48CalibrationValue(uint8_t CRS_HSI48CalibrationValue); +void CRS_FrequencyErrorCounterCmd(FunctionalState NewState); +void CRS_AutomaticCalibrationCmd(FunctionalState NewState); +void CRS_SoftwareSynchronizationGenerate(void); +void CRS_FrequencyErrorCounterReload(uint32_t CRS_ReloadValue); +void CRS_FrequencyErrorLimitConfig(uint8_t CRS_ErrorLimitValue); +void CRS_SynchronizationPrescalerConfig(uint32_t CRS_Prescaler); +void CRS_SynchronizationSourceConfig(uint32_t CRS_Source); +void CRS_SynchronizationPolarityConfig(uint32_t CRS_Polarity); +uint32_t CRS_GetReloadValue(void); +uint32_t CRS_GetHSI48CalibrationValue(void); +uint32_t CRS_GetFrequencyErrorValue(void); +uint32_t CRS_GetFrequencyErrorDirection(void); + +/* Interrupts and flags management functions **********************************/ +void CRS_ITConfig(uint32_t CRS_IT, FunctionalState NewState); +FlagStatus CRS_GetFlagStatus(uint32_t CRS_FLAG); +void CRS_ClearFlag(uint32_t CRS_FLAG); +ITStatus CRS_GetITStatus(uint32_t CRS_IT); +void CRS_ClearITPendingBit(uint32_t CRS_IT); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_CRS_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_dac.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_dac.h new file mode 100644 index 00000000..75896b45 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_dac.h @@ -0,0 +1,312 @@ +/** + ****************************************************************************** + * @file stm32f0xx_dac.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the DAC firmware + * library, applicable only for STM32F051 and STM32F072 devices. + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_DAC_H +#define __STM32F0XX_DAC_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup DAC + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief DAC Init structure definition + */ + +typedef struct +{ + uint32_t DAC_Trigger; /*!< Specifies the external trigger for the selected DAC channel. + This parameter can be a value of @ref DAC_trigger_selection */ + + uint32_t DAC_WaveGeneration; /*!< Specifies whether DAC channel noise waves or triangle waves + are generated, or whether no wave is generated. + This parameter can be a value of @ref DAC_wave_generation + This parameter is only applicable for STM32F072 devices */ + + uint32_t DAC_LFSRUnmask_TriangleAmplitude; /*!< Specifies the LFSR mask for noise wave generation or + the maximum amplitude triangle generation for the DAC channel. + This parameter can be a value of @ref DAC_lfsrunmask_triangleamplitude + This parameter is only applicable for STM32F072 devices */ + + uint32_t DAC_OutputBuffer; /*!< Specifies whether the DAC channel output buffer is enabled or disabled. + This parameter can be a value of @ref DAC_output_buffer */ +}DAC_InitTypeDef; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup DAC_Exported_Constants + * @{ + */ + +/** @defgroup DAC_Trigger + * @{ + */ + +#define DAC_Trigger_None ((uint32_t)0x00000000) /*!< Conversion is automatic once the DAC1_DHRxxxx register + has been loaded, and not by external trigger */ +#define DAC_Trigger_T6_TRGO ((uint32_t)0x00000004) /*!< TIM6 TRGO selected as external conversion trigger for DAC channel1 */ +#define DAC_Trigger_T3_TRGO ((uint32_t)0x0000000C) /*!< TIM3 TRGO selected as external conversion trigger for DAC channel1 */ +#define DAC_Trigger_T7_TRGO ((uint32_t)0x00000014) /*!< TIM7 TRGO selected as external conversion trigger for DAC channel1, + applicable only for STM32F072 devices */ +#define DAC_Trigger_T15_TRGO ((uint32_t)0x0000001C) /*!< TIM15 TRGO selected as external conversion trigger for DAC channel1 */ +#define DAC_Trigger_T2_TRGO ((uint32_t)0x00000024) /*!< TIM2 TRGO selected as external conversion trigger for DAC channel1 */ +#define DAC_Trigger_Ext_IT9 ((uint32_t)0x00000034) /*!< EXTI Line9 event selected as external conversion trigger for DAC channels */ +#define DAC_Trigger_Software ((uint32_t)0x0000003C) /*!< Conversion started by software trigger for DAC channels */ + +#define IS_DAC_TRIGGER(TRIGGER) (((TRIGGER) == DAC_Trigger_None) || \ + ((TRIGGER) == DAC_Trigger_T6_TRGO) || \ + ((TRIGGER) == DAC_Trigger_T7_TRGO) || \ + ((TRIGGER) == DAC_Trigger_T3_TRGO) || \ + ((TRIGGER) == DAC_Trigger_T15_TRGO) || \ + ((TRIGGER) == DAC_Trigger_T2_TRGO) || \ + ((TRIGGER) == DAC_Trigger_Ext_IT9) || \ + ((TRIGGER) == DAC_Trigger_Software)) + +/** + * @} + */ + +/** @defgroup DAC_wave_generation + * @brief This parameters are only applicable for STM32F072 devices. + * @{ + */ + +#define DAC_WaveGeneration_None ((uint32_t)0x00000000) +#define DAC_WaveGeneration_Noise ((uint32_t)0x00000040) +#define DAC_WaveGeneration_Triangle ((uint32_t)0x00000080) +#define IS_DAC_GENERATE_WAVE(WAVE) (((WAVE) == DAC_WaveGeneration_None) || \ + ((WAVE) == DAC_WaveGeneration_Noise) || \ + ((WAVE) == DAC_WaveGeneration_Triangle)) +/** + * @} + */ + +/** @defgroup DAC_lfsrunmask_triangleamplitude + * @brief These parameters are only applicable for STM32F072 devices. + * @{ + */ + +#define DAC_LFSRUnmask_Bit0 ((uint32_t)0x00000000) /*!< Unmask DAC channel LFSR bit0 for noise wave generation */ +#define DAC_LFSRUnmask_Bits1_0 ((uint32_t)0x00000100) /*!< Unmask DAC channel LFSR bit[1:0] for noise wave generation */ +#define DAC_LFSRUnmask_Bits2_0 ((uint32_t)0x00000200) /*!< Unmask DAC channel LFSR bit[2:0] for noise wave generation */ +#define DAC_LFSRUnmask_Bits3_0 ((uint32_t)0x00000300) /*!< Unmask DAC channel LFSR bit[3:0] for noise wave generation */ +#define DAC_LFSRUnmask_Bits4_0 ((uint32_t)0x00000400) /*!< Unmask DAC channel LFSR bit[4:0] for noise wave generation */ +#define DAC_LFSRUnmask_Bits5_0 ((uint32_t)0x00000500) /*!< Unmask DAC channel LFSR bit[5:0] for noise wave generation */ +#define DAC_LFSRUnmask_Bits6_0 ((uint32_t)0x00000600) /*!< Unmask DAC channel LFSR bit[6:0] for noise wave generation */ +#define DAC_LFSRUnmask_Bits7_0 ((uint32_t)0x00000700) /*!< Unmask DAC channel LFSR bit[7:0] for noise wave generation */ +#define DAC_LFSRUnmask_Bits8_0 ((uint32_t)0x00000800) /*!< Unmask DAC channel LFSR bit[8:0] for noise wave generation */ +#define DAC_LFSRUnmask_Bits9_0 ((uint32_t)0x00000900) /*!< Unmask DAC channel LFSR bit[9:0] for noise wave generation */ +#define DAC_LFSRUnmask_Bits10_0 ((uint32_t)0x00000A00) /*!< Unmask DAC channel LFSR bit[10:0] for noise wave generation */ +#define DAC_LFSRUnmask_Bits11_0 ((uint32_t)0x00000B00) /*!< Unmask DAC channel LFSR bit[11:0] for noise wave generation */ +#define DAC_TriangleAmplitude_1 ((uint32_t)0x00000000) /*!< Select max triangle amplitude of 1 */ +#define DAC_TriangleAmplitude_3 ((uint32_t)0x00000100) /*!< Select max triangle amplitude of 3 */ +#define DAC_TriangleAmplitude_7 ((uint32_t)0x00000200) /*!< Select max triangle amplitude of 7 */ +#define DAC_TriangleAmplitude_15 ((uint32_t)0x00000300) /*!< Select max triangle amplitude of 15 */ +#define DAC_TriangleAmplitude_31 ((uint32_t)0x00000400) /*!< Select max triangle amplitude of 31 */ +#define DAC_TriangleAmplitude_63 ((uint32_t)0x00000500) /*!< Select max triangle amplitude of 63 */ +#define DAC_TriangleAmplitude_127 ((uint32_t)0x00000600) /*!< Select max triangle amplitude of 127 */ +#define DAC_TriangleAmplitude_255 ((uint32_t)0x00000700) /*!< Select max triangle amplitude of 255 */ +#define DAC_TriangleAmplitude_511 ((uint32_t)0x00000800) /*!< Select max triangle amplitude of 511 */ +#define DAC_TriangleAmplitude_1023 ((uint32_t)0x00000900) /*!< Select max triangle amplitude of 1023 */ +#define DAC_TriangleAmplitude_2047 ((uint32_t)0x00000A00) /*!< Select max triangle amplitude of 2047 */ +#define DAC_TriangleAmplitude_4095 ((uint32_t)0x00000B00) /*!< Select max triangle amplitude of 4095 */ + +#define IS_DAC_LFSR_UNMASK_TRIANGLE_AMPLITUDE(VALUE) (((VALUE) == DAC_LFSRUnmask_Bit0) || \ + ((VALUE) == DAC_LFSRUnmask_Bits1_0) || \ + ((VALUE) == DAC_LFSRUnmask_Bits2_0) || \ + ((VALUE) == DAC_LFSRUnmask_Bits3_0) || \ + ((VALUE) == DAC_LFSRUnmask_Bits4_0) || \ + ((VALUE) == DAC_LFSRUnmask_Bits5_0) || \ + ((VALUE) == DAC_LFSRUnmask_Bits6_0) || \ + ((VALUE) == DAC_LFSRUnmask_Bits7_0) || \ + ((VALUE) == DAC_LFSRUnmask_Bits8_0) || \ + ((VALUE) == DAC_LFSRUnmask_Bits9_0) || \ + ((VALUE) == DAC_LFSRUnmask_Bits10_0) || \ + ((VALUE) == DAC_LFSRUnmask_Bits11_0) || \ + ((VALUE) == DAC_TriangleAmplitude_1) || \ + ((VALUE) == DAC_TriangleAmplitude_3) || \ + ((VALUE) == DAC_TriangleAmplitude_7) || \ + ((VALUE) == DAC_TriangleAmplitude_15) || \ + ((VALUE) == DAC_TriangleAmplitude_31) || \ + ((VALUE) == DAC_TriangleAmplitude_63) || \ + ((VALUE) == DAC_TriangleAmplitude_127) || \ + ((VALUE) == DAC_TriangleAmplitude_255) || \ + ((VALUE) == DAC_TriangleAmplitude_511) || \ + ((VALUE) == DAC_TriangleAmplitude_1023) || \ + ((VALUE) == DAC_TriangleAmplitude_2047) || \ + ((VALUE) == DAC_TriangleAmplitude_4095)) +/** + * @} + */ + +/** @defgroup DAC_OutputBuffer + * @{ + */ + +#define DAC_OutputBuffer_Enable ((uint32_t)0x00000000) +#define DAC_OutputBuffer_Disable DAC_CR_BOFF1 +#define IS_DAC_OUTPUT_BUFFER_STATE(STATE) (((STATE) == DAC_OutputBuffer_Enable) || \ + ((STATE) == DAC_OutputBuffer_Disable)) +/** + * @} + */ + +/** @defgroup DAC_Channel_selection + * @{ + */ + +#define DAC_Channel_1 ((uint32_t)0x00000000) +#define DAC_Channel_2 ((uint32_t)0x00000010) /*!< Only applicable for STM32F072 devices */ +#define IS_DAC_CHANNEL(CHANNEL) (((CHANNEL) == DAC_Channel_1) || \ + ((CHANNEL) == DAC_Channel_2)) + +/** + * @} + */ + +/** @defgroup DAC_data_alignment + * @{ + */ + +#define DAC_Align_12b_R ((uint32_t)0x00000000) +#define DAC_Align_12b_L ((uint32_t)0x00000004) +#define DAC_Align_8b_R ((uint32_t)0x00000008) +#define IS_DAC_ALIGN(ALIGN) (((ALIGN) == DAC_Align_12b_R) || \ + ((ALIGN) == DAC_Align_12b_L) || \ + ((ALIGN) == DAC_Align_8b_R)) +/** + * @} + */ + +/** @defgroup DAC_wave_generation + * @brief These parameters are only applicable for STM32F072 devices. + * @{ + */ + +#define DAC_Wave_Noise ((uint32_t)0x00000040) +#define DAC_Wave_Triangle ((uint32_t)0x00000080) +#define IS_DAC_WAVE(WAVE) (((WAVE) == DAC_Wave_Noise) || \ + ((WAVE) == DAC_Wave_Triangle)) +/** + * @} + */ + +/** @defgroup DAC_data + * @{ + */ + +#define IS_DAC_DATA(DATA) ((DATA) <= 0xFFF0) + +/** + * @} + */ + +/** @defgroup DAC_interrupts_definition + * @{ + */ + +#define DAC_IT_DMAUDR DAC_SR_DMAUDR1 +#define IS_DAC_IT(IT) (((IT) == DAC_IT_DMAUDR)) + +/** + * @} + */ + + +/** @defgroup DAC_flags_definition + * @{ + */ + +#define DAC_FLAG_DMAUDR DAC_SR_DMAUDR1 + +#define IS_DAC_FLAG(FLAG) (((FLAG) == DAC_FLAG_DMAUDR)) + +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Function used to set the DAC configuration to the default reset state *****/ +void DAC_DeInit(void); + +/* DAC channels configuration: trigger, output buffer, data format functions */ +void DAC_Init(uint32_t DAC_Channel, DAC_InitTypeDef* DAC_InitStruct); +void DAC_StructInit(DAC_InitTypeDef* DAC_InitStruct); +void DAC_Cmd(uint32_t DAC_Channel, FunctionalState NewState); +void DAC_SoftwareTriggerCmd(uint32_t DAC_Channel, FunctionalState NewState); +void DAC_DualSoftwareTriggerCmd(FunctionalState NewState); /*!< Only applicable for STM32F072 devices */ +void DAC_WaveGenerationCmd(uint32_t DAC_Channel, uint32_t DAC_Wave, FunctionalState NewState); /*!< Only applicable for STM32F072 devices */ +void DAC_SetChannel1Data(uint32_t DAC_Align, uint16_t Data); +void DAC_SetChannel2Data(uint32_t DAC_Align, uint16_t Data); /*!< Only applicable for STM32F072 devices */ +void DAC_SetDualChannelData(uint32_t DAC_Align, uint16_t Data2, uint16_t Data1); /*!< Only applicable for STM32F072 devices */ +uint16_t DAC_GetDataOutputValue(uint32_t DAC_Channel); + +/* DMA management functions ***************************************************/ +void DAC_DMACmd(uint32_t DAC_Channel, FunctionalState NewState); + +/* Interrupts and flags management functions **********************************/ +void DAC_ITConfig(uint32_t DAC_Channel, uint32_t DAC_IT, FunctionalState NewState); +FlagStatus DAC_GetFlagStatus(uint32_t DAC_Channel, uint32_t DAC_FLAG); +void DAC_ClearFlag(uint32_t DAC_Channel, uint32_t DAC_FLAG); +ITStatus DAC_GetITStatus(uint32_t DAC_Channel, uint32_t DAC_IT); +void DAC_ClearITPendingBit(uint32_t DAC_Channel, uint32_t DAC_IT); + +#ifdef __cplusplus +} +#endif + +#endif /*__STM32F0XX_DAC_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_dbgmcu.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_dbgmcu.h new file mode 100644 index 00000000..4ee2916f --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_dbgmcu.h @@ -0,0 +1,107 @@ +/** + ****************************************************************************** + * @file stm32f0xx_dbgmcu.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the DBGMCU firmware + * library. + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_DBGMCU_H +#define __STM32F0XX_DBGMCU_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup DBGMCU + * @{ + */ +/* Exported types ------------------------------------------------------------*/ +/* Exported constants --------------------------------------------------------*/ + + +/** @defgroup DBGMCU_Exported_Constants + * @{ + */ + +#define DBGMCU_STOP DBGMCU_CR_DBG_STOP +#define DBGMCU_STANDBY DBGMCU_CR_DBG_STANDBY +#define IS_DBGMCU_PERIPH(PERIPH) ((((PERIPH) & 0xFFFFFFF9) == 0x00) && ((PERIPH) != 0x00)) + +#define DBGMCU_TIM2_STOP DBGMCU_APB1_FZ_DBG_TIM2_STOP /*!< Not applicable for STM32F030 devices */ +#define DBGMCU_TIM3_STOP DBGMCU_APB1_FZ_DBG_TIM3_STOP +#define DBGMCU_TIM6_STOP DBGMCU_APB1_FZ_DBG_TIM6_STOP +#define DBGMCU_TIM7_STOP DBGMCU_APB1_FZ_DBG_TIM7_STOP /*!< Only applicable for STM32F072 devices */ +#define DBGMCU_TIM14_STOP DBGMCU_APB1_FZ_DBG_TIM14_STOP +#define DBGMCU_RTC_STOP DBGMCU_APB1_FZ_DBG_RTC_STOP +#define DBGMCU_WWDG_STOP DBGMCU_APB1_FZ_DBG_WWDG_STOP +#define DBGMCU_IWDG_STOP DBGMCU_APB1_FZ_DBG_IWDG_STOP +#define DBGMCU_I2C1_SMBUS_TIMEOUT DBGMCU_APB1_FZ_DBG_I2C1_SMBUS_TIMEOUT +#define DBGMCU_CAN1_STOP DBGMCU_APB1_FZ_DBG_CAN1_STOP /*!< Only applicable for STM32F042 and STM32F072 devices */ +#define IS_DBGMCU_APB1PERIPH(PERIPH) ((((PERIPH) & 0xFDDFE2CC) == 0x00) && ((PERIPH) != 0x00)) + +#define DBGMCU_TIM1_STOP DBGMCU_APB2_FZ_DBG_TIM1_STOP +#define DBGMCU_TIM15_STOP DBGMCU_APB2_FZ_DBG_TIM15_STOP +#define DBGMCU_TIM16_STOP DBGMCU_APB2_FZ_DBG_TIM16_STOP +#define DBGMCU_TIM17_STOP DBGMCU_APB2_FZ_DBG_TIM17_STOP +#define IS_DBGMCU_APB2PERIPH(PERIPH) ((((PERIPH) & 0xFFF8F7FF) == 0x00) && ((PERIPH) != 0x00)) + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Device and Revision ID management functions ********************************/ +uint32_t DBGMCU_GetREVID(void); +uint32_t DBGMCU_GetDEVID(void); + +/* Peripherals Configuration functions ****************************************/ +void DBGMCU_Config(uint32_t DBGMCU_Periph, FunctionalState NewState); +void DBGMCU_APB1PeriphConfig(uint32_t DBGMCU_Periph, FunctionalState NewState); +void DBGMCU_APB2PeriphConfig(uint32_t DBGMCU_Periph, FunctionalState NewState); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_DBGMCU_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_dma.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_dma.h new file mode 100644 index 00000000..2c6492c7 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_dma.h @@ -0,0 +1,804 @@ +/** + ****************************************************************************** + * @file stm32f0xx_dma.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the DMA firmware + * library. + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_DMA_H +#define __STM32F0XX_DMA_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup DMA + * @{ + */ +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief DMA Init structures definition + */ +typedef struct +{ + uint32_t DMA_PeripheralBaseAddr; /*!< Specifies the peripheral base address for DMAy Channelx. */ + + uint32_t DMA_MemoryBaseAddr; /*!< Specifies the memory base address for DMAy Channelx. */ + + uint32_t DMA_DIR; /*!< Specifies if the peripheral is the source or destination. + This parameter can be a value of @ref DMA_data_transfer_direction */ + + uint32_t DMA_BufferSize; /*!< Specifies the buffer size, in data unit, of the specified Channel. + The data unit is equal to the configuration set in DMA_PeripheralDataSize + or DMA_MemoryDataSize members depending in the transfer direction */ + + uint32_t DMA_PeripheralInc; /*!< Specifies whether the Peripheral address register is incremented or not. + This parameter can be a value of @ref DMA_peripheral_incremented_mode */ + + uint32_t DMA_MemoryInc; /*!< Specifies whether the memory address register is incremented or not. + This parameter can be a value of @ref DMA_memory_incremented_mode */ + + uint32_t DMA_PeripheralDataSize; /*!< Specifies the Peripheral data width. + This parameter can be a value of @ref DMA_peripheral_data_size */ + + uint32_t DMA_MemoryDataSize; /*!< Specifies the Memory data width. + This parameter can be a value of @ref DMA_memory_data_size */ + + uint32_t DMA_Mode; /*!< Specifies the operation mode of the DMAy Channelx. + This parameter can be a value of @ref DMA_circular_normal_mode + @note: The circular buffer mode cannot be used if the memory-to-memory + data transfer is configured on the selected Channel */ + + uint32_t DMA_Priority; /*!< Specifies the software priority for the DMAy Channelx. + This parameter can be a value of @ref DMA_priority_level */ + + uint32_t DMA_M2M; /*!< Specifies if the DMAy Channelx will be used in memory-to-memory transfer. + This parameter can be a value of @ref DMA_memory_to_memory */ +}DMA_InitTypeDef; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup DMA_Exported_Constants + * @{ + */ + +#define IS_DMA_ALL_PERIPH(PERIPH) (((PERIPH) == DMA1_Channel1) || \ + ((PERIPH) == DMA1_Channel2) || \ + ((PERIPH) == DMA1_Channel3) || \ + ((PERIPH) == DMA1_Channel4) || \ + ((PERIPH) == DMA1_Channel5) || \ + ((PERIPH) == DMA1_Channel6) || \ + ((PERIPH) == DMA1_Channel7) || \ + ((PERIPH) == DMA2_Channel1) || \ + ((PERIPH) == DMA2_Channel2) || \ + ((PERIPH) == DMA2_Channel3) || \ + ((PERIPH) == DMA2_Channel4) || \ + ((PERIPH) == DMA2_Channel5)) + +/** @defgroup DMA_data_transfer_direction + * @{ + */ + +#define DMA_DIR_PeripheralSRC ((uint32_t)0x00000000) +#define DMA_DIR_PeripheralDST DMA_CCR_DIR + +#define IS_DMA_DIR(DIR) (((DIR) == DMA_DIR_PeripheralSRC) || \ + ((DIR) == DMA_DIR_PeripheralDST)) +/** + * @} + */ + +/** @defgroup DMA_peripheral_incremented_mode + * @{ + */ + +#define DMA_PeripheralInc_Disable ((uint32_t)0x00000000) +#define DMA_PeripheralInc_Enable DMA_CCR_PINC + +#define IS_DMA_PERIPHERAL_INC_STATE(STATE) (((STATE) == DMA_PeripheralInc_Disable) || \ + ((STATE) == DMA_PeripheralInc_Enable)) +/** + * @} + */ + +/** @defgroup DMA_memory_incremented_mode + * @{ + */ + +#define DMA_MemoryInc_Disable ((uint32_t)0x00000000) +#define DMA_MemoryInc_Enable DMA_CCR_MINC + +#define IS_DMA_MEMORY_INC_STATE(STATE) (((STATE) == DMA_MemoryInc_Disable) || \ + ((STATE) == DMA_MemoryInc_Enable)) +/** + * @} + */ + +/** @defgroup DMA_peripheral_data_size + * @{ + */ + +#define DMA_PeripheralDataSize_Byte ((uint32_t)0x00000000) +#define DMA_PeripheralDataSize_HalfWord DMA_CCR_PSIZE_0 +#define DMA_PeripheralDataSize_Word DMA_CCR_PSIZE_1 + +#define IS_DMA_PERIPHERAL_DATA_SIZE(SIZE) (((SIZE) == DMA_PeripheralDataSize_Byte) || \ + ((SIZE) == DMA_PeripheralDataSize_HalfWord) || \ + ((SIZE) == DMA_PeripheralDataSize_Word)) +/** + * @} + */ + +/** @defgroup DMA_memory_data_size + * @{ + */ + +#define DMA_MemoryDataSize_Byte ((uint32_t)0x00000000) +#define DMA_MemoryDataSize_HalfWord DMA_CCR_MSIZE_0 +#define DMA_MemoryDataSize_Word DMA_CCR_MSIZE_1 + +#define IS_DMA_MEMORY_DATA_SIZE(SIZE) (((SIZE) == DMA_MemoryDataSize_Byte) || \ + ((SIZE) == DMA_MemoryDataSize_HalfWord) || \ + ((SIZE) == DMA_MemoryDataSize_Word)) +/** + * @} + */ + +/** @defgroup DMA_circular_normal_mode + * @{ + */ + +#define DMA_Mode_Normal ((uint32_t)0x00000000) +#define DMA_Mode_Circular DMA_CCR_CIRC + +#define IS_DMA_MODE(MODE) (((MODE) == DMA_Mode_Normal) || ((MODE) == DMA_Mode_Circular)) +/** + * @} + */ + +/** @defgroup DMA_priority_level + * @{ + */ + +#define DMA_Priority_VeryHigh DMA_CCR_PL +#define DMA_Priority_High DMA_CCR_PL_1 +#define DMA_Priority_Medium DMA_CCR_PL_0 +#define DMA_Priority_Low ((uint32_t)0x00000000) + +#define IS_DMA_PRIORITY(PRIORITY) (((PRIORITY) == DMA_Priority_VeryHigh) || \ + ((PRIORITY) == DMA_Priority_High) || \ + ((PRIORITY) == DMA_Priority_Medium) || \ + ((PRIORITY) == DMA_Priority_Low)) +/** + * @} + */ + +/** @defgroup DMA_memory_to_memory + * @{ + */ + +#define DMA_M2M_Disable ((uint32_t)0x00000000) +#define DMA_M2M_Enable DMA_CCR_MEM2MEM + +#define IS_DMA_M2M_STATE(STATE) (((STATE) == DMA_M2M_Disable) || ((STATE) == DMA_M2M_Enable)) + +/** + * @} + */ + +/** @defgroup DMA_Remap_Config + * @{ + */ +#define DMAx_CHANNEL1_RMP 0x00000000 +#define DMAx_CHANNEL2_RMP 0x10000000 +#define DMAx_CHANNEL3_RMP 0x20000000 +#define DMAx_CHANNEL4_RMP 0x30000000 +#define DMAx_CHANNEL5_RMP 0x40000000 +#define DMAx_CHANNEL6_RMP 0x50000000 +#define DMAx_CHANNEL7_RMP 0x60000000 + + +#define IS_DMA_ALL_LIST(LIST) (((LIST) == DMA1) || \ + ((LIST) == DMA2)) + +/****************** DMA1 remap bit field definition********************/ +/* DMA1 - Channel 1 */ +#define DMA1_CH1_DEFAULT (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_DEFAULT) /*!< Default remap position for DMA1 */ +#define DMA1_CH1_ADC (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_CH1_ADC) /*!< Remap ADC on DMA1 Channel 1*/ +#define DMA1_CH1_TIM17_CH1 (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_CH1_TIM17_CH1) /*!< Remap TIM17 channel 1 on DMA1 channel 1 */ +#define DMA1_CH1_TIM17_UP (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_CH1_TIM17_UP) /*!< Remap TIM17 up on DMA1 channel 1 */ +#define DMA1_CH1_USART1_RX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_CH1_USART1_RX) /*!< Remap USART1 Rx on DMA1 channel 1 */ +#define DMA1_CH1_USART2_RX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_CH1_USART2_RX) /*!< Remap USART2 Rx on DMA1 channel 1 */ +#define DMA1_CH1_USART3_RX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_CH1_USART3_RX) /*!< Remap USART3 Rx on DMA1 channel 1 */ +#define DMA1_CH1_USART4_RX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_CH1_USART4_RX) /*!< Remap USART4 Rx on DMA1 channel 1 */ +#define DMA1_CH1_USART5_RX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_CH1_USART5_RX) /*!< Remap USART5 Rx on DMA1 channel 1 */ +#define DMA1_CH1_USART6_RX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_CH1_USART6_RX) /*!< Remap USART6 Rx on DMA1 channel 1 */ +#define DMA1_CH1_USART7_RX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_CH1_USART7_RX) /*!< Remap USART7 Rx on DMA1 channel 1 */ +#define DMA1_CH1_USART8_RX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_CH1_USART8_RX) /*!< Remap USART8 Rx on DMA1 channel 1 */ +/* DMA1 - Channel 2 */ +#define DMA1_CH2_DEFAULT (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_DEFAULT) /*!< Default remap position for DMA1 */ +#define DMA1_CH2_ADC (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_ADC) /*!< Remap ADC on DMA1 channel 2 */ +#define DMA1_CH2_I2C1_TX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_I2C1_TX) /*!< Remap I2C1 Tx on DMA1 channel 2 */ +#define DMA1_CH2_SPI1_RX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_SPI_1RX) /*!< Remap SPI1 Rx on DMA1 channel 2 */ +#define DMA1_CH2_TIM1_CH1 (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_TIM1_CH1) /*!< Remap TIM1 channel 1 on DMA1 channel 2 */ +#define DMA1_CH2_TIM17_CH1 (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_TIM17_CH1) /*!< Remap TIM17 channel 1 on DMA1 channel 2 */ +#define DMA1_CH2_TIM17_UP (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_TIM17_UP) /*!< Remap TIM17 up on DMA1 channel 2 */ +#define DMA1_CH2_USART1_TX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_USART1_TX) /*!< Remap USART1 Tx on DMA1 channel 2 */ +#define DMA1_CH2_USART2_TX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_USART2_TX) /*!< Remap USART2 Tx on DMA1 channel 2 */ +#define DMA1_CH2_USART3_TX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_USART3_TX) /*!< Remap USART3 Tx on DMA1 channel 2 */ +#define DMA1_CH2_USART4_TX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_USART4_TX) /*!< Remap USART4 Tx on DMA1 channel 2 */ +#define DMA1_CH2_USART5_TX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_USART5_TX) /*!< Remap USART5 Tx on DMA1 channel 2 */ +#define DMA1_CH2_USART6_TX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_USART6_TX) /*!< Remap USART6 Tx on DMA1 channel 2 */ +#define DMA1_CH2_USART7_TX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_USART7_TX) /*!< Remap USART7 Tx on DMA1 channel 2 */ +#define DMA1_CH2_USART8_TX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_USART8_TX) /*!< Remap USART8 Tx on DMA1 channel 2 */ +/* DMA1 - Channel 3 */ +#define DMA1_CH3_DEFAULT (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_DEFAULT) /*!< Default remap position for DMAx */ +#define DMA1_CH3_TIM6_UP (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_TIM6_UP) /*!< Remap TIM6 up on DMA1 channel 3 */ +#define DMA1_CH3_DAC_CH1 (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_DAC_CH1) /*!< Remap DAC Channel 1on DMA1 channel 3 */ +#define DMA1_CH3_I2C1_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_I2C1_RX) /*!< Remap I2C1 Rx on DMA1 channel 3 */ +#define DMA1_CH3_SPI1_TX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_SPI1_TX) /*!< Remap SPI1 Tx on DMA1 channel 3 */ +#define DMA1_CH3_TIM1_CH2 (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_TIM1_CH2) /*!< Remap TIM1 channel 2 on DMA1 channel 3 */ +#define DMA1_CH3_TIM2_CH2 (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_TIM2_CH2) /*!< Remap TIM2 channel 2 on DMA1 channel 3 */ +#define DMA1_CH3_TIM16_CH1 (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_TIM16_CH1) /*!< Remap TIM16 channel 1 on DMA1 channel 3 */ +#define DMA1_CH3_TIM16_UP (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_TIM16_UP) /*!< Remap TIM16 up on DMA1 channel 3 */ +#define DMA1_CH3_USART1_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_USART1_RX) /*!< Remap USART1 Rx on DMA1 channel 3 */ +#define DMA1_CH3_USART2_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_USART2_RX) /*!< Remap USART2 Rx on DMA1 channel 3 */ +#define DMA1_CH3_USART3_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_USART3_RX) /*!< Remap USART3 Rx on DMA1 channel 3 */ +#define DMA1_CH3_USART4_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_USART4_RX) /*!< Remap USART4 Rx on DMA1 channel 3 */ +#define DMA1_CH3_USART5_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_USART5_RX) /*!< Remap USART5 Rx on DMA1 channel 3 */ +#define DMA1_CH3_USART6_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_USART6_RX) /*!< Remap USART6 Rx on DMA1 channel 3 */ +#define DMA1_CH3_USART7_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_USART7_RX) /*!< Remap USART7 Rx on DMA1 channel 3 */ +#define DMA1_CH3_USART8_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_USART8_RX) /*!< Remap USART8 Rx on DMA1 channel 3 */ +/* DMA1 - Channel 4 */ +#define DMA1_CH4_DEFAULT (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_DEFAULT) /*!< Default remap position for DMA1 */ +#define DMA1_CH4_TIM7_UP (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_TIM7_UP) /*!< Remap TIM7 up on DMA1 channel 4 */ +#define DMA1_CH4_DAC_CH2 (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_DAC_CH2) /*!< Remap DAC Channel 2 on DMA1 channel 4 */ +#define DMA1_CH4_I2C2_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_I2C2_TX) /*!< Remap I2C2 Tx on DMA1 channel 4 */ +#define DMA1_CH4_SPI2_RX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_SPI2_RX) /*!< Remap SPI2 Rx on DMA1 channel 4 */ +#define DMA1_CH4_TIM2_CH4 (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_TIM2_CH4) /*!< Remap TIM2 channel 4 on DMA1 channel 4 */ +#define DMA1_CH4_TIM3_CH1 (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_TIM3_CH1) /*!< Remap TIM3 channel 1 on DMA1 channel 4 */ +#define DMA1_CH4_TIM3_TRIG (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_TIM3_TRIG) /*!< Remap TIM3 Trig on DMA1 channel 4 */ +#define DMA1_CH4_TIM16_CH1 (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_TIM16_CH1) /*!< Remap TIM16 channel 1 on DMA1 channel 4 */ +#define DMA1_CH4_TIM16_UP (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_TIM16_UP) /*!< Remap TIM16 up on DMA1 channel 4 */ +#define DMA1_CH4_USART1_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_USART1_TX) /*!< Remap USART1 Tx on DMA1 channel 4 */ +#define DMA1_CH4_USART2_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_USART2_TX) /*!< Remap USART2 Tx on DMA1 channel 4 */ +#define DMA1_CH4_USART3_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_USART3_TX) /*!< Remap USART3 Tx on DMA1 channel 4 */ +#define DMA1_CH4_USART4_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_USART4_TX) /*!< Remap USART4 Tx on DMA1 channel 4 */ +#define DMA1_CH4_USART5_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_USART5_TX) /*!< Remap USART5 Tx on DMA1 channel 4 */ +#define DMA1_CH4_USART6_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_USART6_TX) /*!< Remap USART6 Tx on DMA1 channel 4 */ +#define DMA1_CH4_USART7_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_USART7_TX) /*!< Remap USART7 Tx on DMA1 channel 4 */ +#define DMA1_CH4_USART8_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_USART8_TX) /*!< Remap USART8 Tx on DMA1 channel 4 */ +/* DMA1 - Channel 5 */ +#define DMA1_CH5_DEFAULT (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_DEFAULT) /*!< Default remap position for DMA1 */ +#define DMA1_CH5_I2C2_RX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_CH5_I2C2_RX) /*!< Remap I2C2 Rx on DMA1 channel 5 */ +#define DMA1_CH5_SPI2_TX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_CH5_SPI2_TX) /*!< Remap SPI1 Tx on DMA1 channel 5 */ +#define DMA1_CH5_TIM1_CH3 (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_CH5_TIM1_CH3) /*!< Remap TIM1 channel 3 on DMA1 channel 5 */ +#define DMA1_CH5_USART1_RX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_CH5_USART1_RX) /*!< Remap USART1 Rx on DMA1 channel 5 */ +#define DMA1_CH5_USART2_RX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_CH5_USART2_RX) /*!< Remap USART2 Rx on DMA1 channel 5 */ +#define DMA1_CH5_USART3_RX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_CH5_USART3_RX) /*!< Remap USART3 Rx on DMA1 channel 5 */ +#define DMA1_CH5_USART4_RX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_CH5_USART4_RX) /*!< Remap USART4 Rx on DMA1 channel 5 */ +#define DMA1_CH5_USART5_RX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_CH5_USART5_RX) /*!< Remap USART5 Rx on DMA1 channel 5 */ +#define DMA1_CH5_USART6_RX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_CH5_USART6_RX) /*!< Remap USART6 Rx on DMA1 channel 5 */ +#define DMA1_CH5_USART7_RX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_CH5_USART7_RX) /*!< Remap USART7 Rx on DMA1 channel 5 */ +#define DMA1_CH5_USART8_RX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_CH5_USART8_RX) /*!< Remap USART8 Rx on DMA1 channel 5 */ +/* DMA1 - Channel 6 */ +#define DMA1_CH6_DEFAULT (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_DEFAULT) /*!< Default remap position for DMA1 */ +#define DMA1_CH6_I2C1_TX (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_I2C1_TX) /*!< Remap I2C1 Tx on DMA1 channel 6 */ +#define DMA1_CH6_SPI2_RX (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_SPI2_RX) /*!< Remap SPI2 Rx on DMA1 channel 6 */ +#define DMA1_CH6_TIM1_CH1 (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_TIM1_CH1) /*!< Remap TIM1 channel 1 on DMA1 channel 6 */ +#define DMA1_CH6_TIM1_CH2 (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_TIM1_CH2) /*!< Remap TIM1 channel 2 on DMA1 channel 6 */ +#define DMA1_CH6_TIM1_CH3 (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_TIM1_CH3) /*!< Remap TIM1 channel 3 on DMA1 channel 6 */ +#define DMA1_CH6_TIM3_CH1 (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_TIM3_CH1) /*!< Remap TIM3 channel 1 on DMA1 channel 6 */ +#define DMA1_CH6_TIM3_TRIG (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_TIM3_TRIG) /*!< Remap TIM3 Trig on DMA1 channel 6 */ +#define DMA1_CH6_TIM16_CH1 (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_TIM16_CH1) /*!< Remap TIM16 channel 1 on DMA1 channel 6 */ +#define DMA1_CH6_TIM16_UP (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_TIM16_UP) /*!< Remap TIM16 up on DMA1 channel 6 */ +#define DMA1_CH6_USART1_RX (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_USART1_RX) /*!< Remap USART1 Rx on DMA1 channel 6 */ +#define DMA1_CH6_USART2_RX (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_USART2_RX) /*!< Remap USART2 Rx on DMA1 channel 6 */ +#define DMA1_CH6_USART3_RX (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_USART3_RX) /*!< Remap USART3 Rx on DMA1 channel 6 */ +#define DMA1_CH6_USART4_RX (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_USART4_RX) /*!< Remap USART4 Rx on DMA1 channel 6 */ +#define DMA1_CH6_USART5_RX (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_USART5_RX) /*!< Remap USART5 Rx on DMA1 channel 6 */ +#define DMA1_CH6_USART6_RX (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_USART6_RX) /*!< Remap USART6 Rx on DMA1 channel 6 */ +#define DMA1_CH6_USART7_RX (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_USART7_RX) /*!< Remap USART7 Rx on DMA1 channel 6 */ +#define DMA1_CH6_USART8_RX (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_USART8_RX) /*!< Remap USART8 Rx on DMA1 channel 6 */ +/* DMA1 - Channel 7 */ +#define DMA1_CH7_DEFAULT (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_DEFAULT) /*!< Default remap position for DMA1 */ +#define DMA1_CH7_I2C1_RX (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_I2C1_RX) /*!< Remap I2C1 Rx on DMA1 channel 7 */ +#define DMA1_CH7_SPI2_TX (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_SPI2_TX) /*!< Remap SPI2 Tx on DMA1 channel 7 */ +#define DMA1_CH7_TIM2_CH2 (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_TIM2_CH2) /*!< Remap TIM2 channel 2 on DMA1 channel 7 */ +#define DMA1_CH7_TIM2_CH4 (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_TIM2_CH4) /*!< Remap TIM2 channel 4 on DMA1 channel 7 */ +#define DMA1_CH7_TIM17_CH1 (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_TIM17_CH1) /*!< Remap TIM17 channel 1 on DMA1 channel 7 */ +#define DMA1_CH7_TIM17_UP (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_TIM17_UP) /*!< Remap TIM17 up on DMA1 channel 7 */ +#define DMA1_CH7_USART1_TX (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_USART1_TX) /*!< Remap USART1 Tx on DMA1 channel 7 */ +#define DMA1_CH7_USART2_TX (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_USART2_TX) /*!< Remap USART2 Tx on DMA1 channel 7 */ +#define DMA1_CH7_USART3_TX (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_USART3_TX) /*!< Remap USART3 Tx on DMA1 channel 7 */ +#define DMA1_CH7_USART4_TX (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_USART4_TX) /*!< Remap USART4 Tx on DMA1 channel 7 */ +#define DMA1_CH7_USART5_TX (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_USART5_TX) /*!< Remap USART5 Tx on DMA1 channel 7 */ +#define DMA1_CH7_USART6_TX (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_USART6_TX) /*!< Remap USART6 Tx on DMA1 channel 7 */ +#define DMA1_CH7_USART7_TX (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_USART7_TX) /*!< Remap USART7 Tx on DMA1 channel 7 */ +#define DMA1_CH7_USART8_TX (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_USART8_TX) /*!< Remap USART8 Tx on DMA1 channel 7 */ + +#define IS_DMA1_REMAP(REMAP) ((REMAP == DMA1_CH1_DEFAULT) ||\ + (REMAP == DMA1_CH1_ADC) ||\ + (REMAP == DMA1_CH1_TIM17_CH1) ||\ + (REMAP == DMA1_CH1_TIM17_UP) ||\ + (REMAP == DMA1_CH1_USART1_RX) ||\ + (REMAP == DMA1_CH1_USART2_RX) ||\ + (REMAP == DMA1_CH1_USART3_RX) ||\ + (REMAP == DMA1_CH1_USART4_RX) ||\ + (REMAP == DMA1_CH1_USART5_RX) ||\ + (REMAP == DMA1_CH1_USART6_RX) ||\ + (REMAP == DMA1_CH1_USART7_RX) ||\ + (REMAP == DMA1_CH1_USART8_RX) ||\ + (REMAP == DMA1_CH2_DEFAULT) ||\ + (REMAP == DMA1_CH2_ADC) ||\ + (REMAP == DMA1_CH2_I2C1_TX) ||\ + (REMAP == DMA1_CH2_SPI1_RX) ||\ + (REMAP == DMA1_CH2_TIM1_CH1) ||\ + (REMAP == DMA1_CH2_I2C1_TX) ||\ + (REMAP == DMA1_CH2_TIM17_CH1) ||\ + (REMAP == DMA1_CH2_TIM17_UP) ||\ + (REMAP == DMA1_CH2_USART1_TX) ||\ + (REMAP == DMA1_CH2_USART2_TX) ||\ + (REMAP == DMA1_CH2_USART3_TX) ||\ + (REMAP == DMA1_CH2_USART4_TX) ||\ + (REMAP == DMA1_CH2_USART5_TX) ||\ + (REMAP == DMA1_CH2_USART6_TX) ||\ + (REMAP == DMA1_CH2_USART7_TX) ||\ + (REMAP == DMA1_CH2_USART8_TX) ||\ + (REMAP == DMA1_CH3_DEFAULT) ||\ + (REMAP == DMA1_CH3_TIM6_UP) ||\ + (REMAP == DMA1_CH3_DAC_CH1) ||\ + (REMAP == DMA1_CH3_I2C1_RX) ||\ + (REMAP == DMA1_CH3_SPI1_TX) ||\ + (REMAP == DMA1_CH3_TIM1_CH2) ||\ + (REMAP == DMA1_CH3_TIM2_CH2) ||\ + (REMAP == DMA1_CH3_TIM16_CH1) ||\ + (REMAP == DMA1_CH3_TIM16_UP) ||\ + (REMAP == DMA1_CH3_USART1_RX) ||\ + (REMAP == DMA1_CH3_USART2_RX) ||\ + (REMAP == DMA1_CH3_USART3_RX) ||\ + (REMAP == DMA1_CH3_USART4_RX) ||\ + (REMAP == DMA1_CH3_USART5_RX) ||\ + (REMAP == DMA1_CH3_USART6_RX) ||\ + (REMAP == DMA1_CH3_USART7_RX) ||\ + (REMAP == DMA1_CH3_USART8_RX) ||\ + (REMAP == DMA1_CH4_DEFAULT) ||\ + (REMAP == DMA1_CH4_TIM7_UP) ||\ + (REMAP == DMA1_CH4_DAC_CH2) ||\ + (REMAP == DMA1_CH4_I2C2_TX) ||\ + (REMAP == DMA1_CH4_SPI2_RX) ||\ + (REMAP == DMA1_CH4_TIM2_CH4) ||\ + (REMAP == DMA1_CH4_TIM3_CH1) ||\ + (REMAP == DMA1_CH4_TIM3_TRIG) ||\ + (REMAP == DMA1_CH4_TIM16_CH1) ||\ + (REMAP == DMA1_CH4_TIM16_UP) ||\ + (REMAP == DMA1_CH4_USART1_TX) ||\ + (REMAP == DMA1_CH4_USART2_TX) ||\ + (REMAP == DMA1_CH4_USART3_TX) ||\ + (REMAP == DMA1_CH4_USART4_TX) ||\ + (REMAP == DMA1_CH4_USART5_TX) ||\ + (REMAP == DMA1_CH4_USART6_TX) ||\ + (REMAP == DMA1_CH4_USART7_TX) ||\ + (REMAP == DMA1_CH4_USART8_TX) ||\ + (REMAP == DMA1_CH5_DEFAULT) ||\ + (REMAP == DMA1_CH5_I2C2_RX) ||\ + (REMAP == DMA1_CH5_SPI2_TX) ||\ + (REMAP == DMA1_CH5_TIM1_CH3) ||\ + (REMAP == DMA1_CH5_USART1_RX) ||\ + (REMAP == DMA1_CH5_USART2_RX) ||\ + (REMAP == DMA1_CH5_USART3_RX) ||\ + (REMAP == DMA1_CH5_USART4_RX) ||\ + (REMAP == DMA1_CH5_USART5_RX) ||\ + (REMAP == DMA1_CH5_USART6_RX) ||\ + (REMAP == DMA1_CH5_USART7_RX) ||\ + (REMAP == DMA1_CH5_USART8_RX) ||\ + (REMAP == DMA1_CH6_DEFAULT) ||\ + (REMAP == DMA1_CH6_I2C1_TX) ||\ + (REMAP == DMA1_CH6_SPI2_RX) ||\ + (REMAP == DMA1_CH6_TIM1_CH1) ||\ + (REMAP == DMA1_CH6_TIM1_CH2) ||\ + (REMAP == DMA1_CH6_TIM1_CH3) ||\ + (REMAP == DMA1_CH6_TIM3_CH1) ||\ + (REMAP == DMA1_CH6_TIM3_TRIG) ||\ + (REMAP == DMA1_CH6_TIM16_CH1) ||\ + (REMAP == DMA1_CH6_TIM16_UP) ||\ + (REMAP == DMA1_CH6_USART1_RX) ||\ + (REMAP == DMA1_CH6_USART2_RX) ||\ + (REMAP == DMA1_CH6_USART3_RX) ||\ + (REMAP == DMA1_CH6_USART4_RX) ||\ + (REMAP == DMA1_CH6_USART5_RX) ||\ + (REMAP == DMA1_CH6_USART6_RX) ||\ + (REMAP == DMA1_CH6_USART7_RX) ||\ + (REMAP == DMA1_CH6_USART8_RX) ||\ + (REMAP == DMA1_CH7_DEFAULT) ||\ + (REMAP == DMA1_CH7_I2C1_RX) ||\ + (REMAP == DMA1_CH7_SPI2_TX) ||\ + (REMAP == DMA1_CH7_TIM2_CH2) ||\ + (REMAP == DMA1_CH7_TIM2_CH4) ||\ + (REMAP == DMA1_CH7_TIM17_CH1) ||\ + (REMAP == DMA1_CH7_TIM17_UP) ||\ + (REMAP == DMA1_CH7_USART1_TX) ||\ + (REMAP == DMA1_CH7_USART2_TX) ||\ + (REMAP == DMA1_CH7_USART3_TX) ||\ + (REMAP == DMA1_CH7_USART4_TX) ||\ + (REMAP == DMA1_CH7_USART5_TX) ||\ + (REMAP == DMA1_CH7_USART6_TX) ||\ + (REMAP == DMA1_CH7_USART7_TX) ||\ + (REMAP == DMA1_CH7_USART8_TX)) + +/****************** DMA2 remap bit field definition********************/ +/* DMA2 - Channel 1 */ +#define DMA2_CH1_DEFAULT (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR2_DEFAULT) /*!< Default remap position for DMA2 */ +#define DMA2_CH1_I2C2_TX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR2_CH1_I2C2_TX) /*!< Remap I2C2 TX on DMA2 channel 1 */ +#define DMA2_CH1_USART1_TX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR2_CH1_USART1_TX) /*!< Remap USART1 Tx on DMA2 channel 1 */ +#define DMA2_CH1_USART2_TX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR2_CH1_USART2_TX) /*!< Remap USART2 Tx on DMA2 channel 1 */ +#define DMA2_CH1_USART3_TX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR2_CH1_USART3_TX) /*!< Remap USART3 Tx on DMA2 channel 1 */ +#define DMA2_CH1_USART4_TX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR2_CH1_USART4_TX) /*!< Remap USART4 Tx on DMA2 channel 1 */ +#define DMA2_CH1_USART5_TX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR2_CH1_USART5_TX) /*!< Remap USART5 Tx on DMA2 channel 1 */ +#define DMA2_CH1_USART6_TX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR2_CH1_USART6_TX) /*!< Remap USART6 Tx on DMA2 channel 1 */ +#define DMA2_CH1_USART7_TX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR2_CH1_USART7_TX) /*!< Remap USART7 Tx on DMA2 channel 1 */ +#define DMA2_CH1_USART8_TX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR2_CH1_USART8_TX) /*!< Remap USART8 Tx on DMA2 channel 1 */ +/* DMA2 - Channel 2 */ +#define DMA2_CH2_DEFAULT (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR2_DEFAULT) /*!< Default remap position for DMA2 */ +#define DMA2_CH2_I2C2_RX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR2_CH2_I2C2_RX) /*!< Remap I2C2 Rx on DMA2 channel 2 */ +#define DMA2_CH2_USART1_RX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR2_CH2_USART1_RX) /*!< Remap USART1 Rx on DMA2 channel 2 */ +#define DMA2_CH2_USART2_RX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR2_CH2_USART2_RX) /*!< Remap USART2 Rx on DMA2 channel 2 */ +#define DMA2_CH2_USART3_RX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR2_CH2_USART3_RX) /*!< Remap USART3 Rx on DMA2 channel 2 */ +#define DMA2_CH2_USART4_RX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR2_CH2_USART4_RX) /*!< Remap USART4 Rx on DMA2 channel 2 */ +#define DMA2_CH2_USART5_RX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR2_CH2_USART5_RX) /*!< Remap USART5 Rx on DMA2 channel 2 */ +#define DMA2_CH2_USART6_RX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR2_CH2_USART6_RX) /*!< Remap USART6 Rx on DMA2 channel 2 */ +#define DMA2_CH2_USART7_RX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR2_CH2_USART7_RX) /*!< Remap USART7 Rx on DMA2 channel 2 */ +#define DMA2_CH2_USART8_RX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR2_CH2_USART8_RX) /*!< Remap USART8 Rx on DMA2 channel 2 */ +/* DMA2 - Channel 3 */ +#define DMA2_CH3_DEFAULT (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_DEFAULT) /*!< Default remap position for DMA2 */ +#define DMA2_CH3_TIM6_UP (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_CH3_TIM6_UP) /*!< Remap TIM6 up on DMA2 channel 3 */ +#define DMA2_CH3_DAC_CH1 (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_CH3_DAC_CH1) /*!< Remap DAC channel 1 on DMA2 channel 3 */ +#define DMA2_CH3_SPI1_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_CH3_SPI1_RX) /*!< Remap SPI1 Rx on DMA2 channel 3 */ +#define DMA2_CH3_USART1_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_CH3_USART1_RX) /*!< Remap USART1 Rx on DMA2 channel 3 */ +#define DMA2_CH3_USART2_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_CH3_USART2_RX) /*!< Remap USART2 Rx on DMA2 channel 3 */ +#define DMA2_CH3_USART3_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_CH3_USART3_RX) /*!< Remap USART3 Rx on DMA2 channel 3 */ +#define DMA2_CH3_USART4_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_CH3_USART4_RX) /*!< Remap USART4 Rx on DMA2 channel 3 */ +#define DMA2_CH3_USART5_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_CH3_USART5_RX) /*!< Remap USART5 Rx on DMA2 channel 3 */ +#define DMA2_CH3_USART6_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_CH3_USART6_RX) /*!< Remap USART6 Rx on DMA2 channel 3 */ +#define DMA2_CH3_USART7_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_CH3_USART7_RX) /*!< Remap USART7 Rx on DMA2 channel 3 */ +#define DMA2_CH3_USART8_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_CH3_USART8_RX) /*!< Remap USART8 Rx on DMA2 channel 3 */ +/* DMA2 - Channel 4 */ +#define DMA2_CH4_DEFAULT (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_DEFAULT) /*!< Default remap position for DMA2 */ +#define DMA2_CH4_TIM7_UP (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_CH4_TIM7_UP) /*!< Remap TIM7 up on DMA2 channel 4 */ +#define DMA2_CH4_DAC_CH2 (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_CH4_DAC_CH2) /*!< Remap DAC channel 2 on DMA2 channel 4 */ +#define DMA2_CH4_SPI1_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_CH4_SPI1_TX) /*!< Remap SPI1 Tx on DMA2 channel 4 */ +#define DMA2_CH4_USART1_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_CH4_USART1_TX) /*!< Remap USART1 Tx on DMA2 channel 4 */ +#define DMA2_CH4_USART2_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_CH4_USART2_TX) /*!< Remap USART2 Tx on DMA2 channel 4 */ +#define DMA2_CH4_USART3_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_CH4_USART3_TX) /*!< Remap USART3 Tx on DMA2 channel 4 */ +#define DMA2_CH4_USART4_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_CH4_USART4_TX) /*!< Remap USART4 Tx on DMA2 channel 4 */ +#define DMA2_CH4_USART5_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_CH4_USART5_TX) /*!< Remap USART5 Tx on DMA2 channel 4 */ +#define DMA2_CH4_USART6_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_CH4_USART6_TX) /*!< Remap USART6 Tx on DMA2 channel 4 */ +#define DMA2_CH4_USART7_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_CH4_USART7_TX) /*!< Remap USART7 Tx on DMA2 channel 4 */ +#define DMA2_CH4_USART8_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_CH4_USART8_TX) /*!< Remap USART8 Tx on DMA2 channel 4 */ +/* DMA2 - Channel 5 */ +#define DMA2_CH5_DEFAULT (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR2_DEFAULT) /*!< Default remap position for DMA2 */ +#define DMA2_CH5_ADC (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR2_CH5_ADC) /*!< Remap ADC on DMA2 channel 5 */ +#define DMA2_CH5_USART1_TX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR2_CH5_USART1_TX) /*!< Remap USART1 Tx on DMA2 channel 5 */ +#define DMA2_CH5_USART2_TX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR2_CH5_USART2_TX) /*!< Remap USART2 Tx on DMA2 channel 5 */ +#define DMA2_CH5_USART3_TX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR2_CH5_USART3_TX) /*!< Remap USART3 Tx on DMA2 channel 5 */ +#define DMA2_CH5_USART4_TX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR2_CH5_USART4_TX) /*!< Remap USART4 Tx on DMA2 channel 5 */ +#define DMA2_CH5_USART5_TX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR2_CH5_USART5_TX) /*!< Remap USART5 Tx on DMA2 channel 5 */ +#define DMA2_CH5_USART6_TX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR2_CH5_USART6_TX) /*!< Remap USART6 Tx on DMA2 channel 5 */ +#define DMA2_CH5_USART7_TX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR2_CH5_USART7_TX) /*!< Remap USART7 Tx on DMA2 channel 5 */ +#define DMA2_CH5_USART8_TX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR2_CH5_USART8_TX) /*!< Remap USART8 Tx on DMA2 channel 5 */ + +#define IS_DMA2_REMAP(REMAP) ((REMAP == DMA2_CH1_DEFAULT) ||\ + (REMAP == DMA2_CH1_I2C2_TX) ||\ + (REMAP == DMA2_CH1_USART1_TX) ||\ + (REMAP == DMA2_CH1_USART2_TX) ||\ + (REMAP == DMA2_CH1_USART3_TX) ||\ + (REMAP == DMA2_CH1_USART4_TX) ||\ + (REMAP == DMA2_CH1_USART5_TX) ||\ + (REMAP == DMA2_CH1_USART6_TX) ||\ + (REMAP == DMA2_CH1_USART7_TX) ||\ + (REMAP == DMA2_CH1_USART8_TX) ||\ + (REMAP == DMA2_CH2_DEFAULT) ||\ + (REMAP == DMA2_CH2_I2C2_RX) ||\ + (REMAP == DMA2_CH2_USART1_RX) ||\ + (REMAP == DMA2_CH2_USART2_RX) ||\ + (REMAP == DMA2_CH2_USART3_RX) ||\ + (REMAP == DMA2_CH2_USART4_RX) ||\ + (REMAP == DMA2_CH2_USART5_RX) ||\ + (REMAP == DMA2_CH2_USART6_RX) ||\ + (REMAP == DMA2_CH2_USART7_RX) ||\ + (REMAP == DMA2_CH2_USART8_RX) ||\ + (REMAP == DMA2_CH3_DEFAULT) ||\ + (REMAP == DMA2_CH3_TIM6_UP) ||\ + (REMAP == DMA2_CH3_DAC_CH1) ||\ + (REMAP == DMA2_CH3_SPI1_RX) ||\ + (REMAP == DMA2_CH3_USART1_RX) ||\ + (REMAP == DMA2_CH3_USART2_RX) ||\ + (REMAP == DMA2_CH3_USART3_RX) ||\ + (REMAP == DMA2_CH3_USART4_RX) ||\ + (REMAP == DMA2_CH3_USART5_RX) ||\ + (REMAP == DMA2_CH3_USART6_RX) ||\ + (REMAP == DMA2_CH3_USART7_RX) ||\ + (REMAP == DMA2_CH3_USART8_RX) ||\ + (REMAP == DMA2_CH4_DEFAULT) ||\ + (REMAP == DMA2_CH4_TIM7_UP) ||\ + (REMAP == DMA2_CH4_DAC_CH2) ||\ + (REMAP == DMA2_CH4_SPI1_TX) ||\ + (REMAP == DMA2_CH4_USART1_TX) ||\ + (REMAP == DMA2_CH4_USART2_TX) ||\ + (REMAP == DMA2_CH4_USART3_TX) ||\ + (REMAP == DMA2_CH4_USART4_TX) ||\ + (REMAP == DMA2_CH4_USART5_TX) ||\ + (REMAP == DMA2_CH4_USART6_TX) ||\ + (REMAP == DMA2_CH4_USART7_TX) ||\ + (REMAP == DMA2_CH4_USART8_TX) ||\ + (REMAP == DMA2_CH5_DEFAULT) ||\ + (REMAP == DMA2_CH5_ADC) ||\ + (REMAP == DMA2_CH5_USART1_TX) ||\ + (REMAP == DMA2_CH5_USART2_TX) ||\ + (REMAP == DMA2_CH5_USART3_TX) ||\ + (REMAP == DMA2_CH5_USART4_TX) ||\ + (REMAP == DMA2_CH5_USART5_TX) ||\ + (REMAP == DMA2_CH5_USART6_TX) ||\ + (REMAP == DMA2_CH5_USART7_TX) ||\ + (REMAP == DMA2_CH5_USART8_TX )) + +/** + * @} + */ + +/** @defgroup DMA_interrupts_definition + * @{ + */ + +#define DMA_IT_TC DMA_CCR_TCIE +#define DMA_IT_HT DMA_CCR_HTIE +#define DMA_IT_TE DMA_CCR_TEIE + +#define IS_DMA_CONFIG_IT(IT) ((((IT) & 0xFFFFFFF1) == 0x00) && ((IT) != 0x00)) + +#define DMA1_IT_GL1 DMA_ISR_GIF1 +#define DMA1_IT_TC1 DMA_ISR_TCIF1 +#define DMA1_IT_HT1 DMA_ISR_HTIF1 +#define DMA1_IT_TE1 DMA_ISR_TEIF1 +#define DMA1_IT_GL2 DMA_ISR_GIF2 +#define DMA1_IT_TC2 DMA_ISR_TCIF2 +#define DMA1_IT_HT2 DMA_ISR_HTIF2 +#define DMA1_IT_TE2 DMA_ISR_TEIF2 +#define DMA1_IT_GL3 DMA_ISR_GIF3 +#define DMA1_IT_TC3 DMA_ISR_TCIF3 +#define DMA1_IT_HT3 DMA_ISR_HTIF3 +#define DMA1_IT_TE3 DMA_ISR_TEIF3 +#define DMA1_IT_GL4 DMA_ISR_GIF4 +#define DMA1_IT_TC4 DMA_ISR_TCIF4 +#define DMA1_IT_HT4 DMA_ISR_HTIF4 +#define DMA1_IT_TE4 DMA_ISR_TEIF4 +#define DMA1_IT_GL5 DMA_ISR_GIF5 +#define DMA1_IT_TC5 DMA_ISR_TCIF5 +#define DMA1_IT_HT5 DMA_ISR_HTIF5 +#define DMA1_IT_TE5 DMA_ISR_TEIF5 +#define DMA1_IT_GL6 DMA_ISR_GIF6 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_IT_TC6 DMA_ISR_TCIF6 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_IT_HT6 DMA_ISR_HTIF6 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_IT_TE6 DMA_ISR_TEIF6 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_IT_GL7 DMA_ISR_GIF7 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_IT_TC7 DMA_ISR_TCIF7 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_IT_HT7 DMA_ISR_HTIF7 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_IT_TE7 DMA_ISR_TEIF7 /*!< Only applicable for STM32F072 and STM32F091 devices */ + +#define DMA2_IT_GL1 ((uint32_t)0x10000001) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_TC1 ((uint32_t)0x10000002) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_HT1 ((uint32_t)0x10000004) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_TE1 ((uint32_t)0x10000008) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_GL2 ((uint32_t)0x10000010) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_TC2 ((uint32_t)0x10000020) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_HT2 ((uint32_t)0x10000040) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_TE2 ((uint32_t)0x10000080) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_GL3 ((uint32_t)0x10000100) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_TC3 ((uint32_t)0x10000200) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_HT3 ((uint32_t)0x10000400) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_TE3 ((uint32_t)0x10000800) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_GL4 ((uint32_t)0x10001000) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_TC4 ((uint32_t)0x10002000) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_HT4 ((uint32_t)0x10004000) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_TE4 ((uint32_t)0x10008000) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_GL5 ((uint32_t)0x10010000) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_TC5 ((uint32_t)0x10020000) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_HT5 ((uint32_t)0x10040000) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_TE5 ((uint32_t)0x10080000) /*!< Only applicable for STM32F091 devices */ + +#define IS_DMA_CLEAR_IT(IT) (((((IT) & 0xF0000000) == 0x00) || (((IT) & 0xEFF00000) == 0x00)) && ((IT) != 0x00)) + +#define IS_DMA_GET_IT(IT) (((IT) == DMA1_IT_GL1) || ((IT) == DMA1_IT_TC1) || \ + ((IT) == DMA1_IT_HT1) || ((IT) == DMA1_IT_TE1) || \ + ((IT) == DMA1_IT_GL2) || ((IT) == DMA1_IT_TC2) || \ + ((IT) == DMA1_IT_HT2) || ((IT) == DMA1_IT_TE2) || \ + ((IT) == DMA1_IT_GL3) || ((IT) == DMA1_IT_TC3) || \ + ((IT) == DMA1_IT_HT3) || ((IT) == DMA1_IT_TE3) || \ + ((IT) == DMA1_IT_GL4) || ((IT) == DMA1_IT_TC4) || \ + ((IT) == DMA1_IT_HT4) || ((IT) == DMA1_IT_TE4) || \ + ((IT) == DMA1_IT_GL5) || ((IT) == DMA1_IT_TC5) || \ + ((IT) == DMA1_IT_HT5) || ((IT) == DMA1_IT_TE5) || \ + ((IT) == DMA1_IT_GL6) || ((IT) == DMA1_IT_TC6) || \ + ((IT) == DMA1_IT_HT6) || ((IT) == DMA1_IT_TE6) || \ + ((IT) == DMA1_IT_GL7) || ((IT) == DMA1_IT_TC7) || \ + ((IT) == DMA1_IT_HT7) || ((IT) == DMA1_IT_TE7) || \ + ((IT) == DMA2_IT_GL1) || ((IT) == DMA2_IT_TC1) || \ + ((IT) == DMA2_IT_HT1) || ((IT) == DMA2_IT_TE1) || \ + ((IT) == DMA2_IT_GL2) || ((IT) == DMA2_IT_TC2) || \ + ((IT) == DMA2_IT_HT2) || ((IT) == DMA2_IT_TE2) || \ + ((IT) == DMA2_IT_GL3) || ((IT) == DMA2_IT_TC3) || \ + ((IT) == DMA2_IT_HT3) || ((IT) == DMA2_IT_TE3) || \ + ((IT) == DMA2_IT_GL4) || ((IT) == DMA2_IT_TC4) || \ + ((IT) == DMA2_IT_HT4) || ((IT) == DMA2_IT_TE4) || \ + ((IT) == DMA2_IT_GL5) || ((IT) == DMA2_IT_TC5) || \ + ((IT) == DMA2_IT_HT5) || ((IT) == DMA2_IT_TE5)) + +/** + * @} + */ + +/** @defgroup DMA_flags_definition + * @{ + */ +#define DMA1_FLAG_GL1 DMA_ISR_GIF1 +#define DMA1_FLAG_TC1 DMA_ISR_TCIF1 +#define DMA1_FLAG_HT1 DMA_ISR_HTIF1 +#define DMA1_FLAG_TE1 DMA_ISR_TEIF1 +#define DMA1_FLAG_GL2 DMA_ISR_GIF2 +#define DMA1_FLAG_TC2 DMA_ISR_TCIF2 +#define DMA1_FLAG_HT2 DMA_ISR_HTIF2 +#define DMA1_FLAG_TE2 DMA_ISR_TEIF2 +#define DMA1_FLAG_GL3 DMA_ISR_GIF3 +#define DMA1_FLAG_TC3 DMA_ISR_TCIF3 +#define DMA1_FLAG_HT3 DMA_ISR_HTIF3 +#define DMA1_FLAG_TE3 DMA_ISR_TEIF3 +#define DMA1_FLAG_GL4 DMA_ISR_GIF4 +#define DMA1_FLAG_TC4 DMA_ISR_TCIF4 +#define DMA1_FLAG_HT4 DMA_ISR_HTIF4 +#define DMA1_FLAG_TE4 DMA_ISR_TEIF4 +#define DMA1_FLAG_GL5 DMA_ISR_GIF5 +#define DMA1_FLAG_TC5 DMA_ISR_TCIF5 +#define DMA1_FLAG_HT5 DMA_ISR_HTIF5 +#define DMA1_FLAG_TE5 DMA_ISR_TEIF5 +#define DMA1_FLAG_GL6 DMA_ISR_GIF6 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_FLAG_TC6 DMA_ISR_TCIF6 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_FLAG_HT6 DMA_ISR_HTIF6 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_FLAG_TE6 DMA_ISR_TEIF6 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_FLAG_GL7 DMA_ISR_GIF7 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_FLAG_TC7 DMA_ISR_TCIF7 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_FLAG_HT7 DMA_ISR_HTIF7 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_FLAG_TE7 DMA_ISR_TEIF7 /*!< Only applicable for STM32F072 and STM32F091 devices */ + +#define DMA2_FLAG_GL1 ((uint32_t)0x10000001) +#define DMA2_FLAG_TC1 ((uint32_t)0x10000002) +#define DMA2_FLAG_HT1 ((uint32_t)0x10000004) +#define DMA2_FLAG_TE1 ((uint32_t)0x10000008) +#define DMA2_FLAG_GL2 ((uint32_t)0x10000010) +#define DMA2_FLAG_TC2 ((uint32_t)0x10000020) +#define DMA2_FLAG_HT2 ((uint32_t)0x10000040) +#define DMA2_FLAG_TE2 ((uint32_t)0x10000080) +#define DMA2_FLAG_GL3 ((uint32_t)0x10000100) +#define DMA2_FLAG_TC3 ((uint32_t)0x10000200) +#define DMA2_FLAG_HT3 ((uint32_t)0x10000400) +#define DMA2_FLAG_TE3 ((uint32_t)0x10000800) +#define DMA2_FLAG_GL4 ((uint32_t)0x10001000) +#define DMA2_FLAG_TC4 ((uint32_t)0x10002000) +#define DMA2_FLAG_HT4 ((uint32_t)0x10004000) +#define DMA2_FLAG_TE4 ((uint32_t)0x10008000) +#define DMA2_FLAG_GL5 ((uint32_t)0x10010000) +#define DMA2_FLAG_TC5 ((uint32_t)0x10020000) +#define DMA2_FLAG_HT5 ((uint32_t)0x10040000) +#define DMA2_FLAG_TE5 ((uint32_t)0x10080000) + +#define IS_DMA_CLEAR_FLAG(FLAG) (((((FLAG) & 0xF0000000) == 0x00) || (((FLAG) & 0xEFF00000) == 0x00)) && ((FLAG) != 0x00)) + +#define IS_DMA_GET_FLAG(FLAG) (((FLAG) == DMA1_FLAG_GL1) || ((FLAG) == DMA1_FLAG_TC1) || \ + ((FLAG) == DMA1_FLAG_HT1) || ((FLAG) == DMA1_FLAG_TE1) || \ + ((FLAG) == DMA1_FLAG_GL2) || ((FLAG) == DMA1_FLAG_TC2) || \ + ((FLAG) == DMA1_FLAG_HT2) || ((FLAG) == DMA1_FLAG_TE2) || \ + ((FLAG) == DMA1_FLAG_GL3) || ((FLAG) == DMA1_FLAG_TC3) || \ + ((FLAG) == DMA1_FLAG_HT3) || ((FLAG) == DMA1_FLAG_TE3) || \ + ((FLAG) == DMA1_FLAG_GL4) || ((FLAG) == DMA1_FLAG_TC4) || \ + ((FLAG) == DMA1_FLAG_HT4) || ((FLAG) == DMA1_FLAG_TE4) || \ + ((FLAG) == DMA1_FLAG_GL5) || ((FLAG) == DMA1_FLAG_TC5) || \ + ((FLAG) == DMA1_FLAG_HT5) || ((FLAG) == DMA1_FLAG_TE5) || \ + ((FLAG) == DMA1_FLAG_GL6) || ((FLAG) == DMA1_FLAG_TC6) || \ + ((FLAG) == DMA1_FLAG_HT6) || ((FLAG) == DMA1_FLAG_TE6) || \ + ((FLAG) == DMA1_FLAG_GL7) || ((FLAG) == DMA1_FLAG_TC7) || \ + ((FLAG) == DMA1_FLAG_HT7) || ((FLAG) == DMA1_FLAG_TE7) || \ + ((FLAG) == DMA2_FLAG_GL1) || ((FLAG) == DMA2_FLAG_TC1) || \ + ((FLAG) == DMA2_FLAG_HT1) || ((FLAG) == DMA2_FLAG_TE1) || \ + ((FLAG) == DMA2_FLAG_GL2) || ((FLAG) == DMA2_FLAG_TC2) || \ + ((FLAG) == DMA2_FLAG_HT2) || ((FLAG) == DMA2_FLAG_TE2) || \ + ((FLAG) == DMA2_FLAG_GL3) || ((FLAG) == DMA2_FLAG_TC3) || \ + ((FLAG) == DMA2_FLAG_HT3) || ((FLAG) == DMA2_FLAG_TE3) || \ + ((FLAG) == DMA2_FLAG_GL4) || ((FLAG) == DMA2_FLAG_TC4) || \ + ((FLAG) == DMA2_FLAG_HT4) || ((FLAG) == DMA2_FLAG_TE4) || \ + ((FLAG) == DMA2_FLAG_GL5) || ((FLAG) == DMA2_FLAG_TC5) || \ + ((FLAG) == DMA2_FLAG_HT5) || ((FLAG) == DMA2_FLAG_TE5)) +/** + * @} + */ + +/** @defgroup DMA_Buffer_Size + * @{ + */ + +#define IS_DMA_BUFFER_SIZE(SIZE) (((SIZE) >= 0x1) && ((SIZE) < 0x10000)) + +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Function used to set the DMA configuration to the default reset state ******/ +void DMA_DeInit(DMA_Channel_TypeDef* DMAy_Channelx); + +/* Initialization and Configuration functions *********************************/ +void DMA_Init(DMA_Channel_TypeDef* DMAy_Channelx, DMA_InitTypeDef* DMA_InitStruct); +void DMA_StructInit(DMA_InitTypeDef* DMA_InitStruct); +void DMA_Cmd(DMA_Channel_TypeDef* DMAy_Channelx, FunctionalState NewState); +void DMA_RemapConfig(DMA_TypeDef* DMAy, uint32_t DMAx_CHy_RemapRequest); + +/* Data Counter functions******************************************************/ +void DMA_SetCurrDataCounter(DMA_Channel_TypeDef* DMAy_Channelx, uint16_t DataNumber); +uint16_t DMA_GetCurrDataCounter(DMA_Channel_TypeDef* DMAy_Channelx); + +/* Interrupts and flags management functions **********************************/ +void DMA_ITConfig(DMA_Channel_TypeDef* DMAy_Channelx, uint32_t DMA_IT, FunctionalState NewState); +FlagStatus DMA_GetFlagStatus(uint32_t DMAy_FLAG); +void DMA_ClearFlag(uint32_t DMAy_FLAG); +ITStatus DMA_GetITStatus(uint32_t DMAy_IT); +void DMA_ClearITPendingBit(uint32_t DMAy_IT); + +#ifdef __cplusplus +} +#endif + +#endif /*__STM32F0XX_DMA_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_exti.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_exti.h new file mode 100644 index 00000000..4db573ce --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_exti.h @@ -0,0 +1,216 @@ +/** + ****************************************************************************** + * @file stm32f0xx_exti.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the EXTI + * firmware library + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_EXTI_H +#define __STM32F0XX_EXTI_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup EXTI + * @{ + */ +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief EXTI mode enumeration + */ + +typedef enum +{ + EXTI_Mode_Interrupt = 0x00, + EXTI_Mode_Event = 0x04 +}EXTIMode_TypeDef; + +#define IS_EXTI_MODE(MODE) (((MODE) == EXTI_Mode_Interrupt) || ((MODE) == EXTI_Mode_Event)) + +/** + * @brief EXTI Trigger enumeration + */ + +typedef enum +{ + EXTI_Trigger_Rising = 0x08, + EXTI_Trigger_Falling = 0x0C, + EXTI_Trigger_Rising_Falling = 0x10 +}EXTITrigger_TypeDef; + +#define IS_EXTI_TRIGGER(TRIGGER) (((TRIGGER) == EXTI_Trigger_Rising) || \ + ((TRIGGER) == EXTI_Trigger_Falling) || \ + ((TRIGGER) == EXTI_Trigger_Rising_Falling)) +/** + * @brief EXTI Init Structure definition + */ + +typedef struct +{ + uint32_t EXTI_Line; /*!< Specifies the EXTI lines to be enabled or disabled. + This parameter can be any combination of @ref EXTI_Lines */ + + EXTIMode_TypeDef EXTI_Mode; /*!< Specifies the mode for the EXTI lines. + This parameter can be a value of @ref EXTIMode_TypeDef */ + + EXTITrigger_TypeDef EXTI_Trigger; /*!< Specifies the trigger signal active edge for the EXTI lines. + This parameter can be a value of @ref EXTIMode_TypeDef */ + + FunctionalState EXTI_LineCmd; /*!< Specifies the new state of the selected EXTI lines. + This parameter can be set either to ENABLE or DISABLE */ +}EXTI_InitTypeDef; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup EXTI_Exported_Constants + * @{ + */ +/** @defgroup EXTI_Lines + * @{ + */ + +#define EXTI_Line0 ((uint32_t)0x00000001) /*!< External interrupt line 0 */ +#define EXTI_Line1 ((uint32_t)0x00000002) /*!< External interrupt line 1 */ +#define EXTI_Line2 ((uint32_t)0x00000004) /*!< External interrupt line 2 */ +#define EXTI_Line3 ((uint32_t)0x00000008) /*!< External interrupt line 3 */ +#define EXTI_Line4 ((uint32_t)0x00000010) /*!< External interrupt line 4 */ +#define EXTI_Line5 ((uint32_t)0x00000020) /*!< External interrupt line 5 */ +#define EXTI_Line6 ((uint32_t)0x00000040) /*!< External interrupt line 6 */ +#define EXTI_Line7 ((uint32_t)0x00000080) /*!< External interrupt line 7 */ +#define EXTI_Line8 ((uint32_t)0x00000100) /*!< External interrupt line 8 */ +#define EXTI_Line9 ((uint32_t)0x00000200) /*!< External interrupt line 9 */ +#define EXTI_Line10 ((uint32_t)0x00000400) /*!< External interrupt line 10 */ +#define EXTI_Line11 ((uint32_t)0x00000800) /*!< External interrupt line 11 */ +#define EXTI_Line12 ((uint32_t)0x00001000) /*!< External interrupt line 12 */ +#define EXTI_Line13 ((uint32_t)0x00002000) /*!< External interrupt line 13 */ +#define EXTI_Line14 ((uint32_t)0x00004000) /*!< External interrupt line 14 */ +#define EXTI_Line15 ((uint32_t)0x00008000) /*!< External interrupt line 15 */ +#define EXTI_Line16 ((uint32_t)0x00010000) /*!< External interrupt line 16 + Connected to the PVD Output, + not applicable for STM32F030 devices */ +#define EXTI_Line17 ((uint32_t)0x00020000) /*!< Internal interrupt line 17 + Connected to the RTC Alarm + event */ +#define EXTI_Line18 ((uint32_t)0x00040000) /*!< Internal interrupt line 18 + Connected to the USB + event, only applicable for + STM32F072 devices */ +#define EXTI_Line19 ((uint32_t)0x00080000) /*!< Internal interrupt line 19 + Connected to the RTC Tamper + and Time Stamp events */ +#define EXTI_Line20 ((uint32_t)0x00100000) /*!< Internal interrupt line 20 + Connected to the RTC wakeup + event, only applicable for + STM32F072 devices */ +#define EXTI_Line21 ((uint32_t)0x00200000) /*!< Internal interrupt line 21 + Connected to the Comparator 1 + event, only applicable for STM32F051 + ans STM32F072 devices */ +#define EXTI_Line22 ((uint32_t)0x00400000) /*!< Internal interrupt line 22 + Connected to the Comparator 2 + event, only applicable for STM32F051 + and STM32F072 devices */ +#define EXTI_Line23 ((uint32_t)0x00800000) /*!< Internal interrupt line 23 + Connected to the I2C1 wakeup + event, not applicable for STM32F030 devices */ +#define EXTI_Line25 ((uint32_t)0x02000000) /*!< Internal interrupt line 25 + Connected to the USART1 wakeup + event, not applicable for STM32F030 devices */ +#define EXTI_Line26 ((uint32_t)0x04000000) /*!< Internal interrupt line 26 + Connected to the USART2 wakeup + event, applicable only for + STM32F072 devices */ +#define EXTI_Line27 ((uint32_t)0x08000000) /*!< Internal interrupt line 27 + Connected to the CEC wakeup + event, applicable only for STM32F051 + and STM32F072 devices */ +#define EXTI_Line31 ((uint32_t)0x80000000) /*!< Internal interrupt line 31 + Connected to the VDD USB monitor + event, applicable only for + STM32F072 devices */ +#define IS_EXTI_LINE(LINE) ((((LINE) & (uint32_t)0x71000000) == 0x00) && ((LINE) != (uint16_t)0x00)) + +#define IS_GET_EXTI_LINE(LINE) (((LINE) == EXTI_Line0) || ((LINE) == EXTI_Line1) || \ + ((LINE) == EXTI_Line2) || ((LINE) == EXTI_Line3) || \ + ((LINE) == EXTI_Line4) || ((LINE) == EXTI_Line5) || \ + ((LINE) == EXTI_Line6) || ((LINE) == EXTI_Line7) || \ + ((LINE) == EXTI_Line8) || ((LINE) == EXTI_Line9) || \ + ((LINE) == EXTI_Line10) || ((LINE) == EXTI_Line11) || \ + ((LINE) == EXTI_Line12) || ((LINE) == EXTI_Line13) || \ + ((LINE) == EXTI_Line14) || ((LINE) == EXTI_Line15) || \ + ((LINE) == EXTI_Line16) || ((LINE) == EXTI_Line17) || \ + ((LINE) == EXTI_Line18) || ((LINE) == EXTI_Line19) || \ + ((LINE) == EXTI_Line20) || ((LINE) == EXTI_Line21) || \ + ((LINE) == EXTI_Line22) || ((LINE) == EXTI_Line23) || \ + ((LINE) == EXTI_Line25) || ((LINE) == EXTI_Line26) || \ + ((LINE) == EXTI_Line27) || ((LINE) == EXTI_Line31)) + +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ +/* Function used to set the EXTI configuration to the default reset state *****/ +void EXTI_DeInit(void); + +/* Initialization and Configuration functions *********************************/ +void EXTI_Init(EXTI_InitTypeDef* EXTI_InitStruct); +void EXTI_StructInit(EXTI_InitTypeDef* EXTI_InitStruct); +void EXTI_GenerateSWInterrupt(uint32_t EXTI_Line); + +/* Interrupts and flags management functions **********************************/ +FlagStatus EXTI_GetFlagStatus(uint32_t EXTI_Line); +void EXTI_ClearFlag(uint32_t EXTI_Line); +ITStatus EXTI_GetITStatus(uint32_t EXTI_Line); +void EXTI_ClearITPendingBit(uint32_t EXTI_Line); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_EXTI_H */ +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_flash.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_flash.h new file mode 100644 index 00000000..f647684a --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_flash.h @@ -0,0 +1,435 @@ +/** + ****************************************************************************** + * @file stm32f0xx_flash.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the FLASH + * firmware library. + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_FLASH_H +#define __STM32F0XX_FLASH_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup FLASH + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief FLASH Status + */ +typedef enum +{ + FLASH_BUSY = 1, + FLASH_ERROR_WRP, + FLASH_ERROR_PROGRAM, + FLASH_COMPLETE, + FLASH_TIMEOUT +}FLASH_Status; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup FLASH_Exported_Constants + * @{ + */ + +/** @defgroup FLASH_Latency + * @{ + */ +#define FLASH_Latency_0 ((uint32_t)0x00000000) /*!< FLASH Zero Latency cycle */ +#define FLASH_Latency_1 FLASH_ACR_LATENCY /*!< FLASH One Latency cycle */ + +#define IS_FLASH_LATENCY(LATENCY) (((LATENCY) == FLASH_Latency_0) || \ + ((LATENCY) == FLASH_Latency_1)) +/** + * @} + */ + +/** @defgroup FLASH_Interrupts + * @{ + */ + +#define FLASH_IT_EOP FLASH_CR_EOPIE /*!< End of programming interrupt source */ +#define FLASH_IT_ERR FLASH_CR_ERRIE /*!< Error interrupt source */ +#define IS_FLASH_IT(IT) ((((IT) & (uint32_t)0xFFFFEBFF) == 0x00000000) && (((IT) != 0x00000000))) +/** + * @} + */ + +/** @defgroup FLASH_Address + * @{ + */ +#if defined(STM32F042) || defined(STM32F031) || defined(STM32F070x6) /*32K devices */ + #define IS_FLASH_PROGRAM_ADDRESS(ADDRESS) (((ADDRESS) >= 0x08000000) && ((ADDRESS) <= 0x08007FFF)) +#elif defined(STM32F030) || defined(STM32F051) /*64K devices */ + #define IS_FLASH_PROGRAM_ADDRESS(ADDRESS) (((ADDRESS) >= 0x08000000) && ((ADDRESS) <= 0x0800FFFF)) +#elif defined(STM32F072) || defined(STM32F070xB) /*128K devices */ + #define IS_FLASH_PROGRAM_ADDRESS(ADDRESS) (((ADDRESS) >= 0x08000000) && ((ADDRESS) <= 0x0801FFFF)) +#else /* STM32F091 || STM32F030 || STM32F030xC */ /*256K Flash devices */ + #define IS_FLASH_PROGRAM_ADDRESS(ADDRESS) (((ADDRESS) >= 0x08000000) && ((ADDRESS) <= 0x0800FFFF)) +#endif /* STM32F042 || STM32F031 || STM32F070x6 */ +/** + * @} + */ + +/** @defgroup FLASH_OB_DATA_ADDRESS + * @{ + */ +#define IS_OB_DATA_ADDRESS(ADDRESS) (((ADDRESS) == 0x1FFFF804) || ((ADDRESS) == 0x1FFFF806)) + +/** + * @} + */ + +/** @defgroup FLASH_Option_Bytes_Write_Protection + * @{ + */ + +#if !defined (STM32F072) && !defined (STM32F070xB) && !defined (STM32F091) && !defined (STM32F030) && !defined (STM32F030xC) /* 32K and 64K Flash devices */ +#define OB_WRP_Pages0to3 ((uint32_t)0x00000001) /* Write protection of page 0 to 3 */ +#define OB_WRP_Pages4to7 ((uint32_t)0x00000002) /* Write protection of page 4 to 7 */ +#define OB_WRP_Pages8to11 ((uint32_t)0x00000004) /* Write protection of page 8 to 11 */ +#define OB_WRP_Pages12to15 ((uint32_t)0x00000008) /* Write protection of page 12 to 15 */ +#define OB_WRP_Pages16to19 ((uint32_t)0x00000010) /* Write protection of page 16 to 19 */ +#define OB_WRP_Pages20to23 ((uint32_t)0x00000020) /* Write protection of page 20 to 23 */ +#define OB_WRP_Pages24to27 ((uint32_t)0x00000040) /* Write protection of page 24 to 27 */ +#define OB_WRP_Pages28to31 ((uint32_t)0x00000080) /* Write protection of page 28 to 31 */ +#define OB_WRP_Pages32to35 ((uint32_t)0x00000100) /* Write protection of page 32 to 35 */ +#define OB_WRP_Pages36to39 ((uint32_t)0x00000200) /* Write protection of page 36 to 39 */ +#define OB_WRP_Pages40to43 ((uint32_t)0x00000400) /* Write protection of page 40 to 43 */ +#define OB_WRP_Pages44to47 ((uint32_t)0x00000800) /* Write protection of page 44 to 47 */ +#define OB_WRP_Pages48to51 ((uint32_t)0x00001000) /* Write protection of page 48 to 51 */ +#define OB_WRP_Pages52to55 ((uint32_t)0x00002000) /* Write protection of page 52 to 55 */ +#define OB_WRP_Pages56to59 ((uint32_t)0x00004000) /* Write protection of page 56 to 59 */ +#define OB_WRP_Pages60to63 ((uint32_t)0x00008000) /* Write protection of page 60 to 63 */ + +#define OB_WRP_AllPages ((uint32_t)0x0000FFFF) /*!< Write protection of all Sectors */ + +#define IS_OB_WRP(PAGE) (((PAGE) != 0x0000000)) + +#else /* 128K and 256K Flash devices */ + +#define OB_WRP_Pages0to1 ((uint32_t)0x00000001) /* Write protection of page 0 to 1 */ +#define OB_WRP_Pages2to3 ((uint32_t)0x00000002) /* Write protection of page 2 to 3 */ +#define OB_WRP_Pages4to5 ((uint32_t)0x00000004) /* Write protection of page 4 to 5 */ +#define OB_WRP_Pages6to7 ((uint32_t)0x00000008) /* Write protection of page 6 to 7 */ +#define OB_WRP_Pages8to9 ((uint32_t)0x00000010) /* Write protection of page 8 to 9 */ +#define OB_WRP_Pages10to11 ((uint32_t)0x00000020) /* Write protection of page 10 to 11 */ +#define OB_WRP_Pages12to13 ((uint32_t)0x00000040) /* Write protection of page 12 to 13 */ +#define OB_WRP_Pages14to15 ((uint32_t)0x00000080) /* Write protection of page 14 to 15 */ +#define OB_WRP_Pages16to17 ((uint32_t)0x00000100) /* Write protection of page 16 to 17 */ +#define OB_WRP_Pages18to19 ((uint32_t)0x00000200) /* Write protection of page 18 to 19 */ +#define OB_WRP_Pages20to21 ((uint32_t)0x00000400) /* Write protection of page 20 to 21 */ +#define OB_WRP_Pages22to23 ((uint32_t)0x00000800) /* Write protection of page 22 to 23 */ +#define OB_WRP_Pages24to25 ((uint32_t)0x00001000) /* Write protection of page 24 to 25 */ +#define OB_WRP_Pages26to27 ((uint32_t)0x00002000) /* Write protection of page 26 to 27 */ +#define OB_WRP_Pages28to29 ((uint32_t)0x00004000) /* Write protection of page 28 to 29 */ +#define OB_WRP_Pages30to31 ((uint32_t)0x00008000) /* Write protection of page 30 to 31 */ +#define OB_WRP_Pages32to33 ((uint32_t)0x00010000) /* Write protection of page 32 to 33 */ +#define OB_WRP_Pages34to35 ((uint32_t)0x00020000) /* Write protection of page 34 to 35 */ +#define OB_WRP_Pages36to37 ((uint32_t)0x00040000) /* Write protection of page 36 to 37 */ +#define OB_WRP_Pages38to39 ((uint32_t)0x00080000) /* Write protection of page 38 to 39 */ +#define OB_WRP_Pages40to41 ((uint32_t)0x00100000) /* Write protection of page 40 to 41 */ +#define OB_WRP_Pages42to43 ((uint32_t)0x00200000) /* Write protection of page 42 to 43 */ +#define OB_WRP_Pages44to45 ((uint32_t)0x00400000) /* Write protection of page 44 to 45 */ +#define OB_WRP_Pages46to47 ((uint32_t)0x00800000) /* Write protection of page 46 to 47 */ +#define OB_WRP_Pages48to49 ((uint32_t)0x01000000) /* Write protection of page 48 to 49 */ +#define OB_WRP_Pages50to51 ((uint32_t)0x02000000) /* Write protection of page 50 to 51 */ +#define OB_WRP_Pages52to53 ((uint32_t)0x04000000) /* Write protection of page 52 to 53 */ +#define OB_WRP_Pages54to55 ((uint32_t)0x08000000) /* Write protection of page 54 to 55 */ +#define OB_WRP_Pages56to57 ((uint32_t)0x10000000) /* Write protection of page 56 to 57 */ +#define OB_WRP_Pages58to59 ((uint32_t)0x20000000) /* Write protection of page 58 to 59 */ +#define OB_WRP_Pages60to61 ((uint32_t)0x40000000) /* Write protection of page 60 to 61 */ + +#if defined(STM32F091) || defined(STM32F030xC) /* 256K Flash devices */ +#define OB_WRP_Pages62to127 ((uint32_t)0x80000000) /* Write protection of page 62 to 127 */ +#else /* 128K Flash devices */ +#define OB_WRP_Pages62to63 ((uint32_t)0x80000000) /* Write protection of page 62 to 63 */ +#endif /* STM32F091 || STM32F030xC */ +#define OB_WRP_AllPages ((uint32_t)0xFFFFFFFF) /*!< Write protection of all Sectors */ +#define IS_OB_WRP(PAGE) (((PAGE) != 0x0000000)) + +#endif /* STM32F072 || STM32F070xB || STM32F091 || STM32F030 || STM32F030xC */ +/** + * @} + */ + +/** @defgroup FLASH_Option_Bytes_Read_Protection + * @{ + */ + +/** + * @brief FLASH_Read Protection Level + */ +#define OB_RDP_Level_0 ((uint8_t)0xAA) +#define OB_RDP_Level_1 ((uint8_t)0xBB) +/*#define OB_RDP_Level_2 ((uint8_t)0xCC)*/ /* Warning: When enabling read protection level 2 + it's no more possible to go back to level 1 or 0 */ + +#define IS_OB_RDP(LEVEL) (((LEVEL) == OB_RDP_Level_0)||\ + ((LEVEL) == OB_RDP_Level_1))/*||\ + ((LEVEL) == OB_RDP_Level_2))*/ +/** + * @} + */ + +/** @defgroup FLASH_Option_Bytes_IWatchdog + * @{ + */ + +#define OB_IWDG_SW ((uint8_t)0x01) /*!< Software IWDG selected */ +#define OB_IWDG_HW ((uint8_t)0x00) /*!< Hardware IWDG selected */ +#define IS_OB_IWDG_SOURCE(SOURCE) (((SOURCE) == OB_IWDG_SW) || ((SOURCE) == OB_IWDG_HW)) + +/** + * @} + */ + +/** @defgroup FLASH_Option_Bytes_nRST_STOP + * @{ + */ + +#define OB_STOP_NoRST ((uint8_t)0x02) /*!< No reset generated when entering in STOP */ +#define OB_STOP_RST ((uint8_t)0x00) /*!< Reset generated when entering in STOP */ +#define IS_OB_STOP_SOURCE(SOURCE) (((SOURCE) == OB_STOP_NoRST) || ((SOURCE) == OB_STOP_RST)) + +/** + * @} + */ + +/** @defgroup FLASH_Option_Bytes_nRST_STDBY + * @{ + */ + +#define OB_STDBY_NoRST ((uint8_t)0x04) /*!< No reset generated when entering in STANDBY */ +#define OB_STDBY_RST ((uint8_t)0x00) /*!< Reset generated when entering in STANDBY */ +#define IS_OB_STDBY_SOURCE(SOURCE) (((SOURCE) == OB_STDBY_NoRST) || ((SOURCE) == OB_STDBY_RST)) + +/** + * @} + */ + +/** @defgroup FLASH_Option_Bytes_BOOT1 + * @{ + */ + +#define OB_BOOT1_RESET ((uint8_t)0x00) /*!< BOOT1 Reset */ +#define OB_BOOT1_SET ((uint8_t)0x10) /*!< BOOT1 Set */ +#define IS_OB_BOOT1(BOOT1) (((BOOT1) == OB_BOOT1_RESET) || ((BOOT1) == OB_BOOT1_SET)) + +/** + * @} + */ + +/** @defgroup FLASH_Option_Bytes_BOOT0 + * @{ + */ + +#define OB_BOOT0_RESET ((uint8_t)0x00) /*!< BOOT0 Reset */ +#define OB_BOOT0_SET ((uint8_t)0x08) /*!< BOOT0 Set */ +#define IS_OB_BOOT0(BOOT0) (((BOOT0) == OB_BOOT0_RESET) || ((BOOT0) == OB_BOOT0_SET)) + +/** + * @} + */ + +/** @defgroup FLASH_Option_Bytes_BOOT0SW + * @{ + */ + +#define OB_BOOT0_SW ((uint8_t)0x00) /*!< BOOT0 pin disabled */ +#define OB_BOOT0_HW ((uint8_t)0x80) /*!< BOOT0 pin bonded with GPIO */ +#define IS_OB_BOOT0SW(BOOT0) (((BOOT0) == OB_BOOT0_SW) || ((BOOT0) == OB_BOOT0_HW)) + +/** + * @} + */ + +/** @defgroup FLASH_Option_Bytes_VDDA_Analog_Monitoring + * @{ + */ + +#define OB_VDDA_ANALOG_ON ((uint8_t)0x20) /*!< Analog monitoring on VDDA Power source ON */ +#define OB_VDDA_ANALOG_OFF ((uint8_t)0x00) /*!< Analog monitoring on VDDA Power source OFF */ + +#define IS_OB_VDDA_ANALOG(ANALOG) (((ANALOG) == OB_VDDA_ANALOG_ON) || ((ANALOG) == OB_VDDA_ANALOG_OFF)) + +/** + * @} + */ + +/** @defgroup FLASH_Option_Bytes_SRAM_Parity_Enable + * @{ + */ + +#define OB_SRAM_PARITY_SET ((uint8_t)0x00) /*!< SRAM parity enable Set */ +#define OB_SRAM_PARITY_RESET ((uint8_t)0x40) /*!< SRAM parity enable reset */ + +#define IS_OB_SRAM_PARITY(PARITY) (((PARITY) == OB_SRAM_PARITY_SET) || ((PARITY) == OB_SRAM_PARITY_RESET)) + +/** + * @} + */ + +/** @defgroup FLASH_Flags + * @{ + */ + +#define FLASH_FLAG_BSY FLASH_SR_BSY /*!< FLASH Busy flag */ +#define FLASH_FLAG_PGERR FLASH_SR_PGERR /*!< FLASH Programming error flag */ +#define FLASH_FLAG_WRPERR FLASH_SR_WRPERR /*!< FLASH Write protected error flag */ +#define FLASH_FLAG_EOP FLASH_SR_EOP /*!< FLASH End of Programming flag */ + +#define IS_FLASH_CLEAR_FLAG(FLAG) ((((FLAG) & (uint32_t)0xFFFFFFCB) == 0x00000000) && ((FLAG) != 0x00000000)) + +#define IS_FLASH_GET_FLAG(FLAG) (((FLAG) == FLASH_FLAG_BSY) || ((FLAG) == FLASH_FLAG_PGERR) || \ + ((FLAG) == FLASH_FLAG_WRPERR) || ((FLAG) == FLASH_FLAG_EOP)) +/** + * @} + */ + +/** @defgroup FLASH_Timeout_definition + * @{ + */ +#define FLASH_ER_PRG_TIMEOUT ((uint32_t)0x000B0000) + +/** + * @} + */ + +/** @defgroup FLASH_Legacy + * @{ + */ +#define FLASH_WRProt_Pages0to3 OB_WRP_Pages0to3 +#define FLASH_WRProt_Pages4to7 OB_WRP_Pages4to7 +#define FLASH_WRProt_Pages8to11 OB_WRP_Pages8to11 +#define FLASH_WRProt_Pages12to15 OB_WRP_Pages12to15 +#define FLASH_WRProt_Pages16to19 OB_WRP_Pages16to19 +#define FLASH_WRProt_Pages20to23 OB_WRP_Pages20to23 +#define FLASH_WRProt_Pages24to27 OB_WRP_Pages24to27 +#define FLASH_WRProt_Pages28to31 OB_WRP_Pages28to31 +#define FLASH_WRProt_Pages32to35 OB_WRP_Pages32to35 +#define FLASH_WRProt_Pages36to39 OB_WRP_Pages36to39 +#define FLASH_WRProt_Pages40to43 OB_WRP_Pages40to21 +#define FLASH_WRProt_Pages44to47 OB_WRP_Pages44to23 +#define FLASH_WRProt_Pages48to51 OB_WRP_Pages48to51 +#define FLASH_WRProt_Pages52to55 OB_WRP_Pages52to55 +#define FLASH_WRProt_Pages56to59 OB_WRP_Pages56to59 +#define FLASH_WRProt_Pages60to63 OB_WRP_Pages60to63 + + +#define FLASH_WRProt_AllPages OB_WRP_AllPages +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/** + * @brief FLASH memory functions that can be executed from FLASH. + */ +/* FLASH Interface configuration functions ************************************/ +void FLASH_SetLatency(uint32_t FLASH_Latency); +void FLASH_PrefetchBufferCmd(FunctionalState NewState); +FlagStatus FLASH_GetPrefetchBufferStatus(void); + +/* FLASH Memory Programming functions *****************************************/ +void FLASH_Unlock(void); +void FLASH_Lock(void); +FLASH_Status FLASH_ErasePage(uint32_t Page_Address); +FLASH_Status FLASH_EraseAllPages(void); +FLASH_Status FLASH_ProgramWord(uint32_t Address, uint32_t Data); +FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data); + +/* FLASH Option Bytes Programming functions *****************************************/ +void FLASH_OB_Unlock(void); +void FLASH_OB_Lock(void); +void FLASH_OB_Launch(void); +FLASH_Status FLASH_OB_Erase(void); +FLASH_Status FLASH_OB_EnableWRP(uint32_t OB_WRP); +FLASH_Status FLASH_OB_RDPConfig(uint8_t OB_RDP); +FLASH_Status FLASH_OB_UserConfig(uint8_t OB_IWDG, uint8_t OB_STOP, uint8_t OB_STDBY); +FLASH_Status FLASH_OB_BOOTConfig(uint8_t OB_BOOT1); +FLASH_Status FLASH_OB_BOOT0Config(uint8_t OB_BOOT0); +FLASH_Status FLASH_OB_BOOT0SWConfig(uint8_t OB_BOOT0SW); +FLASH_Status FLASH_OB_VDDAConfig(uint8_t OB_VDDA_ANALOG); +FLASH_Status FLASH_OB_SRAMParityConfig(uint8_t OB_SRAM_Parity); +FLASH_Status FLASH_OB_WriteUser(uint8_t OB_USER); +FLASH_Status FLASH_OB_ProgramData(uint32_t Address, uint8_t Data); +uint8_t FLASH_OB_GetUser(void); +uint32_t FLASH_OB_GetWRP(void); +FlagStatus FLASH_OB_GetRDP(void); + +/* FLASH Interrupts and flags management functions **********************************/ +void FLASH_ITConfig(uint32_t FLASH_IT, FunctionalState NewState); +FlagStatus FLASH_GetFlagStatus(uint32_t FLASH_FLAG); +void FLASH_ClearFlag(uint32_t FLASH_FLAG); +FLASH_Status FLASH_GetStatus(void); +FLASH_Status FLASH_WaitForLastOperation(uint32_t Timeout); + +/** @defgroup FLASH_Legacy + * @{ + */ +#define FLASH_EraseOptionBytes FLASH_OB_Erase +#define FLASH_EnableWriteProtection FLASH_OB_EnableWRP +#define FLASH_UserOptionByteConfig FLASH_OB_UserConfig +#define FLASH_ProgramOptionByteData FLASH_OB_ProgramData +#define FLASH_GetUserOptionByte FLASH_OB_GetUser +#define FLASH_GetWriteProtectionOptionByte FLASH_OB_GetWRP + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_FLASH_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_gpio.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_gpio.h new file mode 100644 index 00000000..8a2aa9be --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_gpio.h @@ -0,0 +1,358 @@ +/** + ****************************************************************************** + * @file stm32f0xx_gpio.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the GPIO + * firmware library. + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_GPIO_H +#define __STM32F0XX_GPIO_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup GPIO + * @{ + */ +/* Exported types ------------------------------------------------------------*/ + +#define IS_GPIO_ALL_PERIPH(PERIPH) (((PERIPH) == GPIOA) || \ + ((PERIPH) == GPIOB) || \ + ((PERIPH) == GPIOC) || \ + ((PERIPH) == GPIOD) || \ + ((PERIPH) == GPIOE) || \ + ((PERIPH) == GPIOF)) + +#define IS_GPIO_LIST_PERIPH(PERIPH) (((PERIPH) == GPIOA) || \ + ((PERIPH) == GPIOB)) + +/** @defgroup Configuration_Mode_enumeration + * @{ + */ +typedef enum +{ + GPIO_Mode_IN = 0x00, /*!< GPIO Input Mode */ + GPIO_Mode_OUT = 0x01, /*!< GPIO Output Mode */ + GPIO_Mode_AF = 0x02, /*!< GPIO Alternate function Mode */ + GPIO_Mode_AN = 0x03 /*!< GPIO Analog In/Out Mode */ +}GPIOMode_TypeDef; + +#define IS_GPIO_MODE(MODE) (((MODE) == GPIO_Mode_IN)|| ((MODE) == GPIO_Mode_OUT) || \ + ((MODE) == GPIO_Mode_AF)|| ((MODE) == GPIO_Mode_AN)) +/** + * @} + */ + +/** @defgroup Output_type_enumeration + * @{ + */ +typedef enum +{ + GPIO_OType_PP = 0x00, + GPIO_OType_OD = 0x01 +}GPIOOType_TypeDef; + +#define IS_GPIO_OTYPE(OTYPE) (((OTYPE) == GPIO_OType_PP) || ((OTYPE) == GPIO_OType_OD)) + +/** + * @} + */ + +/** @defgroup Output_Maximum_frequency_enumeration + * @{ + */ +typedef enum +{ + GPIO_Speed_Level_1 = 0x00, /*!< I/O output speed: Low 2 MHz */ + GPIO_Speed_Level_2 = 0x01, /*!< I/O output speed: Medium 10 MHz */ + GPIO_Speed_Level_3 = 0x03 /*!< I/O output speed: High 50 MHz */ +}GPIOSpeed_TypeDef; + +#define IS_GPIO_SPEED(SPEED) (((SPEED) == GPIO_Speed_Level_1) || ((SPEED) == GPIO_Speed_Level_2) || \ + ((SPEED) == GPIO_Speed_Level_3)) +/** + * @} + */ + +/** @defgroup Configuration_Pull-Up_Pull-Down_enumeration + * @{ + */ +typedef enum +{ + GPIO_PuPd_NOPULL = 0x00, + GPIO_PuPd_UP = 0x01, + GPIO_PuPd_DOWN = 0x02 +}GPIOPuPd_TypeDef; + +#define IS_GPIO_PUPD(PUPD) (((PUPD) == GPIO_PuPd_NOPULL) || ((PUPD) == GPIO_PuPd_UP) || \ + ((PUPD) == GPIO_PuPd_DOWN)) +/** + * @} + */ + +/** @defgroup Bit_SET_and_Bit_RESET_enumeration + * @{ + */ +typedef enum +{ + Bit_RESET = 0, + Bit_SET +}BitAction; + +#define IS_GPIO_BIT_ACTION(ACTION) (((ACTION) == Bit_RESET) || ((ACTION) == Bit_SET)) +/** + * @} + */ + +/** + * @brief GPIO Init structure definition + */ +typedef struct +{ + uint32_t GPIO_Pin; /*!< Specifies the GPIO pins to be configured. + This parameter can be any value of @ref GPIO_pins_define */ + + GPIOMode_TypeDef GPIO_Mode; /*!< Specifies the operating mode for the selected pins. + This parameter can be a value of @ref GPIOMode_TypeDef */ + + GPIOSpeed_TypeDef GPIO_Speed; /*!< Specifies the speed for the selected pins. + This parameter can be a value of @ref GPIOSpeed_TypeDef */ + + GPIOOType_TypeDef GPIO_OType; /*!< Specifies the operating output type for the selected pins. + This parameter can be a value of @ref GPIOOType_TypeDef */ + + GPIOPuPd_TypeDef GPIO_PuPd; /*!< Specifies the operating Pull-up/Pull down for the selected pins. + This parameter can be a value of @ref GPIOPuPd_TypeDef */ +}GPIO_InitTypeDef; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup GPIO_Exported_Constants + * @{ + */ + +/** @defgroup GPIO_pins_define + * @{ + */ +#define GPIO_Pin_0 ((uint16_t)0x0001) /*!< Pin 0 selected */ +#define GPIO_Pin_1 ((uint16_t)0x0002) /*!< Pin 1 selected */ +#define GPIO_Pin_2 ((uint16_t)0x0004) /*!< Pin 2 selected */ +#define GPIO_Pin_3 ((uint16_t)0x0008) /*!< Pin 3 selected */ +#define GPIO_Pin_4 ((uint16_t)0x0010) /*!< Pin 4 selected */ +#define GPIO_Pin_5 ((uint16_t)0x0020) /*!< Pin 5 selected */ +#define GPIO_Pin_6 ((uint16_t)0x0040) /*!< Pin 6 selected */ +#define GPIO_Pin_7 ((uint16_t)0x0080) /*!< Pin 7 selected */ +#define GPIO_Pin_8 ((uint16_t)0x0100) /*!< Pin 8 selected */ +#define GPIO_Pin_9 ((uint16_t)0x0200) /*!< Pin 9 selected */ +#define GPIO_Pin_10 ((uint16_t)0x0400) /*!< Pin 10 selected */ +#define GPIO_Pin_11 ((uint16_t)0x0800) /*!< Pin 11 selected */ +#define GPIO_Pin_12 ((uint16_t)0x1000) /*!< Pin 12 selected */ +#define GPIO_Pin_13 ((uint16_t)0x2000) /*!< Pin 13 selected */ +#define GPIO_Pin_14 ((uint16_t)0x4000) /*!< Pin 14 selected */ +#define GPIO_Pin_15 ((uint16_t)0x8000) /*!< Pin 15 selected */ +#define GPIO_Pin_All ((uint16_t)0xFFFF) /*!< All pins selected */ + +#define IS_GPIO_PIN(PIN) ((PIN) != (uint16_t)0x00) + +#define IS_GET_GPIO_PIN(PIN) (((PIN) == GPIO_Pin_0) || \ + ((PIN) == GPIO_Pin_1) || \ + ((PIN) == GPIO_Pin_2) || \ + ((PIN) == GPIO_Pin_3) || \ + ((PIN) == GPIO_Pin_4) || \ + ((PIN) == GPIO_Pin_5) || \ + ((PIN) == GPIO_Pin_6) || \ + ((PIN) == GPIO_Pin_7) || \ + ((PIN) == GPIO_Pin_8) || \ + ((PIN) == GPIO_Pin_9) || \ + ((PIN) == GPIO_Pin_10) || \ + ((PIN) == GPIO_Pin_11) || \ + ((PIN) == GPIO_Pin_12) || \ + ((PIN) == GPIO_Pin_13) || \ + ((PIN) == GPIO_Pin_14) || \ + ((PIN) == GPIO_Pin_15)) + +/** + * @} + */ + +/** @defgroup GPIO_Pin_sources + * @{ + */ +#define GPIO_PinSource0 ((uint8_t)0x00) +#define GPIO_PinSource1 ((uint8_t)0x01) +#define GPIO_PinSource2 ((uint8_t)0x02) +#define GPIO_PinSource3 ((uint8_t)0x03) +#define GPIO_PinSource4 ((uint8_t)0x04) +#define GPIO_PinSource5 ((uint8_t)0x05) +#define GPIO_PinSource6 ((uint8_t)0x06) +#define GPIO_PinSource7 ((uint8_t)0x07) +#define GPIO_PinSource8 ((uint8_t)0x08) +#define GPIO_PinSource9 ((uint8_t)0x09) +#define GPIO_PinSource10 ((uint8_t)0x0A) +#define GPIO_PinSource11 ((uint8_t)0x0B) +#define GPIO_PinSource12 ((uint8_t)0x0C) +#define GPIO_PinSource13 ((uint8_t)0x0D) +#define GPIO_PinSource14 ((uint8_t)0x0E) +#define GPIO_PinSource15 ((uint8_t)0x0F) + +#define IS_GPIO_PIN_SOURCE(PINSOURCE) (((PINSOURCE) == GPIO_PinSource0) || \ + ((PINSOURCE) == GPIO_PinSource1) || \ + ((PINSOURCE) == GPIO_PinSource2) || \ + ((PINSOURCE) == GPIO_PinSource3) || \ + ((PINSOURCE) == GPIO_PinSource4) || \ + ((PINSOURCE) == GPIO_PinSource5) || \ + ((PINSOURCE) == GPIO_PinSource6) || \ + ((PINSOURCE) == GPIO_PinSource7) || \ + ((PINSOURCE) == GPIO_PinSource8) || \ + ((PINSOURCE) == GPIO_PinSource9) || \ + ((PINSOURCE) == GPIO_PinSource10) || \ + ((PINSOURCE) == GPIO_PinSource11) || \ + ((PINSOURCE) == GPIO_PinSource12) || \ + ((PINSOURCE) == GPIO_PinSource13) || \ + ((PINSOURCE) == GPIO_PinSource14) || \ + ((PINSOURCE) == GPIO_PinSource15)) +/** + * @} + */ + +/** @defgroup GPIO_Alternate_function_selection_define + * @{ + */ + +/** + * @brief AF 0 selection + */ +#define GPIO_AF_0 ((uint8_t)0x00) /* WKUP, EVENTOUT, TIM15, SPI1, TIM17, + MCO, SWDAT, SWCLK, TIM14, BOOT, + USART1, CEC, IR_OUT, SPI2, TS, TIM3, + USART4, CAN, TIM3, USART2, USART3, + CRS, TIM16, TIM1 */ +/** + * @brief AF 1 selection + */ +#define GPIO_AF_1 ((uint8_t)0x01) /* USART2, CEC, TIM3, USART1, IR, + EVENTOUT, I2C1, I2C2, TIM15, SPI2, + USART3, TS, SPI1 */ +/** + * @brief AF 2 selection + */ +#define GPIO_AF_2 ((uint8_t)0x02) /* TIM2, TIM1, EVENTOUT, TIM16, TIM17, + USB */ +/** + * @brief AF 3 selection + */ +#define GPIO_AF_3 ((uint8_t)0x03) /* TS, I2C1, TIM15, EVENTOUT */ + +/** + * @brief AF 4 selection + */ +#define GPIO_AF_4 ((uint8_t)0x04) /* TIM14, USART4, USART3, CRS, CAN, + I2C1 */ + +/** + * @brief AF 5 selection + */ +#define GPIO_AF_5 ((uint8_t)0x05) /* TIM16, TIM17, TIM15, SPI2, I2C2, + MCO, I2C1, USB */ + +/** + * @brief AF 6 selection + */ +#define GPIO_AF_6 ((uint8_t)0x06) /* EVENTOUT */ +/** + * @brief AF 7 selection + */ +#define GPIO_AF_7 ((uint8_t)0x07) /* COMP1 OUT and COMP2 OUT */ + +#define IS_GPIO_AF(AF) (((AF) == GPIO_AF_0) || ((AF) == GPIO_AF_1) || \ + ((AF) == GPIO_AF_2) || ((AF) == GPIO_AF_3) || \ + ((AF) == GPIO_AF_4) || ((AF) == GPIO_AF_5) || \ + ((AF) == GPIO_AF_6) || ((AF) == GPIO_AF_7)) + +/** + * @} + */ + +/** @defgroup GPIO_Speed_Legacy + * @{ + */ + +#define GPIO_Speed_2MHz GPIO_Speed_Level_1 /*!< I/O output speed: Low 2 MHz */ +#define GPIO_Speed_10MHz GPIO_Speed_Level_2 /*!< I/O output speed: Medium 10 MHz */ +#define GPIO_Speed_50MHz GPIO_Speed_Level_3 /*!< I/O output speed: High 50 MHz */ + +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ +/* Function used to set the GPIO configuration to the default reset state *****/ +void GPIO_DeInit(GPIO_TypeDef* GPIOx); + +/* Initialization and Configuration functions *********************************/ +void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct); +void GPIO_StructInit(GPIO_InitTypeDef* GPIO_InitStruct); +void GPIO_PinLockConfig(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin); + +/* GPIO Read and Write functions **********************************************/ +uint8_t GPIO_ReadInputDataBit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin); +uint16_t GPIO_ReadInputData(GPIO_TypeDef* GPIOx); +uint8_t GPIO_ReadOutputDataBit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin); +uint16_t GPIO_ReadOutputData(GPIO_TypeDef* GPIOx); +void GPIO_SetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin); +void GPIO_ResetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin); +void GPIO_WriteBit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, BitAction BitVal); +void GPIO_Write(GPIO_TypeDef* GPIOx, uint16_t PortVal); + +/* GPIO Alternate functions configuration functions ***************************/ +void GPIO_PinAFConfig(GPIO_TypeDef* GPIOx, uint16_t GPIO_PinSource, uint8_t GPIO_AF); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_GPIO_H */ +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_i2c.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_i2c.h new file mode 100644 index 00000000..12247991 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_i2c.h @@ -0,0 +1,478 @@ +/** + ****************************************************************************** + * @file stm32f0xx_i2c.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the I2C firmware + * library + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_I2C_H +#define __STM32F0XX_I2C_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup I2C + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief I2C Init structure definition + */ + +typedef struct +{ + uint32_t I2C_Timing; /*!< Specifies the I2C_TIMINGR_register value. + This parameter must be set by referring to I2C_Timing_Config_Tool*/ + + uint32_t I2C_AnalogFilter; /*!< Enables or disables analog noise filter. + This parameter can be a value of @ref I2C_Analog_Filter*/ + + uint32_t I2C_DigitalFilter; /*!< Configures the digital noise filter. + This parameter can be a number between 0x00 and 0x0F*/ + + uint32_t I2C_Mode; /*!< Specifies the I2C mode. + This parameter can be a value of @ref I2C_mode*/ + + uint32_t I2C_OwnAddress1; /*!< Specifies the device own address 1. + This parameter can be a 7-bit or 10-bit address*/ + + uint32_t I2C_Ack; /*!< Enables or disables the acknowledgement. + This parameter can be a value of @ref I2C_acknowledgement*/ + + uint32_t I2C_AcknowledgedAddress; /*!< Specifies if 7-bit or 10-bit address is acknowledged. + This parameter can be a value of @ref I2C_acknowledged_address*/ +}I2C_InitTypeDef; + +/* Exported constants --------------------------------------------------------*/ + + +/** @defgroup I2C_Exported_Constants + * @{ + */ + +#define IS_I2C_ALL_PERIPH(PERIPH) (((PERIPH) == I2C1) || \ + ((PERIPH) == I2C2)) + +#define IS_I2C_1_PERIPH(PERIPH) ((PERIPH) == I2C1) + +/** @defgroup I2C_Analog_Filter + * @{ + */ + +#define I2C_AnalogFilter_Enable ((uint32_t)0x00000000) +#define I2C_AnalogFilter_Disable I2C_CR1_ANFOFF + +#define IS_I2C_ANALOG_FILTER(FILTER) (((FILTER) == I2C_AnalogFilter_Enable) || \ + ((FILTER) == I2C_AnalogFilter_Disable)) +/** + * @} + */ + +/** @defgroup I2C_Digital_Filter + * @{ + */ + +#define IS_I2C_DIGITAL_FILTER(FILTER) ((FILTER) <= 0x0000000F) +/** + * @} + */ + +/** @defgroup I2C_mode + * @{ + */ + +#define I2C_Mode_I2C ((uint32_t)0x00000000) +#define I2C_Mode_SMBusDevice I2C_CR1_SMBDEN +#define I2C_Mode_SMBusHost I2C_CR1_SMBHEN + +#define IS_I2C_MODE(MODE) (((MODE) == I2C_Mode_I2C) || \ + ((MODE) == I2C_Mode_SMBusDevice) || \ + ((MODE) == I2C_Mode_SMBusHost)) +/** + * @} + */ + +/** @defgroup I2C_acknowledgement + * @{ + */ + +#define I2C_Ack_Enable ((uint32_t)0x00000000) +#define I2C_Ack_Disable I2C_CR2_NACK + +#define IS_I2C_ACK(ACK) (((ACK) == I2C_Ack_Enable) || \ + ((ACK) == I2C_Ack_Disable)) +/** + * @} + */ + +/** @defgroup I2C_acknowledged_address + * @{ + */ + +#define I2C_AcknowledgedAddress_7bit ((uint32_t)0x00000000) +#define I2C_AcknowledgedAddress_10bit I2C_OAR1_OA1MODE + +#define IS_I2C_ACKNOWLEDGE_ADDRESS(ADDRESS) (((ADDRESS) == I2C_AcknowledgedAddress_7bit) || \ + ((ADDRESS) == I2C_AcknowledgedAddress_10bit)) +/** + * @} + */ + +/** @defgroup I2C_own_address1 + * @{ + */ + +#define IS_I2C_OWN_ADDRESS1(ADDRESS1) ((ADDRESS1) <= (uint32_t)0x000003FF) +/** + * @} + */ + +/** @defgroup I2C_transfer_direction + * @{ + */ + +#define I2C_Direction_Transmitter ((uint16_t)0x0000) +#define I2C_Direction_Receiver ((uint16_t)0x0400) + +#define IS_I2C_DIRECTION(DIRECTION) (((DIRECTION) == I2C_Direction_Transmitter) || \ + ((DIRECTION) == I2C_Direction_Receiver)) +/** + * @} + */ + +/** @defgroup I2C_DMA_transfer_requests + * @{ + */ + +#define I2C_DMAReq_Tx I2C_CR1_TXDMAEN +#define I2C_DMAReq_Rx I2C_CR1_RXDMAEN + +#define IS_I2C_DMA_REQ(REQ) ((((REQ) & (uint32_t)0xFFFF3FFF) == 0x00) && ((REQ) != 0x00)) +/** + * @} + */ + +/** @defgroup I2C_slave_address + * @{ + */ + +#define IS_I2C_SLAVE_ADDRESS(ADDRESS) ((ADDRESS) <= (uint16_t)0x03FF) +/** + * @} + */ + + +/** @defgroup I2C_own_address2 + * @{ + */ + +#define IS_I2C_OWN_ADDRESS2(ADDRESS2) ((ADDRESS2) <= (uint16_t)0x00FF) + +/** + * @} + */ + +/** @defgroup I2C_own_address2_mask + * @{ + */ + +#define I2C_OA2_NoMask ((uint8_t)0x00) +#define I2C_OA2_Mask01 ((uint8_t)0x01) +#define I2C_OA2_Mask02 ((uint8_t)0x02) +#define I2C_OA2_Mask03 ((uint8_t)0x03) +#define I2C_OA2_Mask04 ((uint8_t)0x04) +#define I2C_OA2_Mask05 ((uint8_t)0x05) +#define I2C_OA2_Mask06 ((uint8_t)0x06) +#define I2C_OA2_Mask07 ((uint8_t)0x07) + +#define IS_I2C_OWN_ADDRESS2_MASK(MASK) (((MASK) == I2C_OA2_NoMask) || \ + ((MASK) == I2C_OA2_Mask01) || \ + ((MASK) == I2C_OA2_Mask02) || \ + ((MASK) == I2C_OA2_Mask03) || \ + ((MASK) == I2C_OA2_Mask04) || \ + ((MASK) == I2C_OA2_Mask05) || \ + ((MASK) == I2C_OA2_Mask06) || \ + ((MASK) == I2C_OA2_Mask07)) + +/** + * @} + */ + +/** @defgroup I2C_timeout + * @{ + */ + +#define IS_I2C_TIMEOUT(TIMEOUT) ((TIMEOUT) <= (uint16_t)0x0FFF) + +/** + * @} + */ + +/** @defgroup I2C_registers + * @{ + */ + +#define I2C_Register_CR1 ((uint8_t)0x00) +#define I2C_Register_CR2 ((uint8_t)0x04) +#define I2C_Register_OAR1 ((uint8_t)0x08) +#define I2C_Register_OAR2 ((uint8_t)0x0C) +#define I2C_Register_TIMINGR ((uint8_t)0x10) +#define I2C_Register_TIMEOUTR ((uint8_t)0x14) +#define I2C_Register_ISR ((uint8_t)0x18) +#define I2C_Register_ICR ((uint8_t)0x1C) +#define I2C_Register_PECR ((uint8_t)0x20) +#define I2C_Register_RXDR ((uint8_t)0x24) +#define I2C_Register_TXDR ((uint8_t)0x28) + +#define IS_I2C_REGISTER(REGISTER) (((REGISTER) == I2C_Register_CR1) || \ + ((REGISTER) == I2C_Register_CR2) || \ + ((REGISTER) == I2C_Register_OAR1) || \ + ((REGISTER) == I2C_Register_OAR2) || \ + ((REGISTER) == I2C_Register_TIMINGR) || \ + ((REGISTER) == I2C_Register_TIMEOUTR) || \ + ((REGISTER) == I2C_Register_ISR) || \ + ((REGISTER) == I2C_Register_ICR) || \ + ((REGISTER) == I2C_Register_PECR) || \ + ((REGISTER) == I2C_Register_RXDR) || \ + ((REGISTER) == I2C_Register_TXDR)) +/** + * @} + */ + +/** @defgroup I2C_interrupts_definition + * @{ + */ + +#define I2C_IT_ERRI I2C_CR1_ERRIE +#define I2C_IT_TCI I2C_CR1_TCIE +#define I2C_IT_STOPI I2C_CR1_STOPIE +#define I2C_IT_NACKI I2C_CR1_NACKIE +#define I2C_IT_ADDRI I2C_CR1_ADDRIE +#define I2C_IT_RXI I2C_CR1_RXIE +#define I2C_IT_TXI I2C_CR1_TXIE + +#define IS_I2C_CONFIG_IT(IT) ((((IT) & (uint32_t)0xFFFFFF01) == 0x00) && ((IT) != 0x00)) + +/** + * @} + */ + +/** @defgroup I2C_flags_definition + * @{ + */ + +#define I2C_FLAG_TXE I2C_ISR_TXE +#define I2C_FLAG_TXIS I2C_ISR_TXIS +#define I2C_FLAG_RXNE I2C_ISR_RXNE +#define I2C_FLAG_ADDR I2C_ISR_ADDR +#define I2C_FLAG_NACKF I2C_ISR_NACKF +#define I2C_FLAG_STOPF I2C_ISR_STOPF +#define I2C_FLAG_TC I2C_ISR_TC +#define I2C_FLAG_TCR I2C_ISR_TCR +#define I2C_FLAG_BERR I2C_ISR_BERR +#define I2C_FLAG_ARLO I2C_ISR_ARLO +#define I2C_FLAG_OVR I2C_ISR_OVR +#define I2C_FLAG_PECERR I2C_ISR_PECERR +#define I2C_FLAG_TIMEOUT I2C_ISR_TIMEOUT +#define I2C_FLAG_ALERT I2C_ISR_ALERT +#define I2C_FLAG_BUSY I2C_ISR_BUSY + +#define IS_I2C_CLEAR_FLAG(FLAG) ((((FLAG) & (uint32_t)0xFFFF4000) == 0x00) && ((FLAG) != 0x00)) + +#define IS_I2C_GET_FLAG(FLAG) (((FLAG) == I2C_FLAG_TXE) || ((FLAG) == I2C_FLAG_TXIS) || \ + ((FLAG) == I2C_FLAG_RXNE) || ((FLAG) == I2C_FLAG_ADDR) || \ + ((FLAG) == I2C_FLAG_NACKF) || ((FLAG) == I2C_FLAG_STOPF) || \ + ((FLAG) == I2C_FLAG_TC) || ((FLAG) == I2C_FLAG_TCR) || \ + ((FLAG) == I2C_FLAG_BERR) || ((FLAG) == I2C_FLAG_ARLO) || \ + ((FLAG) == I2C_FLAG_OVR) || ((FLAG) == I2C_FLAG_PECERR) || \ + ((FLAG) == I2C_FLAG_TIMEOUT) || ((FLAG) == I2C_FLAG_ALERT) || \ + ((FLAG) == I2C_FLAG_BUSY)) + +/** + * @} + */ + + +/** @defgroup I2C_interrupts_definition + * @{ + */ + +#define I2C_IT_TXIS I2C_ISR_TXIS +#define I2C_IT_RXNE I2C_ISR_RXNE +#define I2C_IT_ADDR I2C_ISR_ADDR +#define I2C_IT_NACKF I2C_ISR_NACKF +#define I2C_IT_STOPF I2C_ISR_STOPF +#define I2C_IT_TC I2C_ISR_TC +#define I2C_IT_TCR I2C_ISR_TCR +#define I2C_IT_BERR I2C_ISR_BERR +#define I2C_IT_ARLO I2C_ISR_ARLO +#define I2C_IT_OVR I2C_ISR_OVR +#define I2C_IT_PECERR I2C_ISR_PECERR +#define I2C_IT_TIMEOUT I2C_ISR_TIMEOUT +#define I2C_IT_ALERT I2C_ISR_ALERT + +#define IS_I2C_CLEAR_IT(IT) ((((IT) & (uint32_t)0xFFFFC001) == 0x00) && ((IT) != 0x00)) + +#define IS_I2C_GET_IT(IT) (((IT) == I2C_IT_TXIS) || ((IT) == I2C_IT_RXNE) || \ + ((IT) == I2C_IT_ADDR) || ((IT) == I2C_IT_NACKF) || \ + ((IT) == I2C_IT_STOPF) || ((IT) == I2C_IT_TC) || \ + ((IT) == I2C_IT_TCR) || ((IT) == I2C_IT_BERR) || \ + ((IT) == I2C_IT_ARLO) || ((IT) == I2C_IT_OVR) || \ + ((IT) == I2C_IT_PECERR) || ((IT) == I2C_IT_TIMEOUT) || \ + ((IT) == I2C_IT_ALERT)) + + +/** + * @} + */ + +/** @defgroup I2C_ReloadEndMode_definition + * @{ + */ + +#define I2C_Reload_Mode I2C_CR2_RELOAD +#define I2C_AutoEnd_Mode I2C_CR2_AUTOEND +#define I2C_SoftEnd_Mode ((uint32_t)0x00000000) + + +#define IS_RELOAD_END_MODE(MODE) (((MODE) == I2C_Reload_Mode) || \ + ((MODE) == I2C_AutoEnd_Mode) || \ + ((MODE) == I2C_SoftEnd_Mode)) + + +/** + * @} + */ + +/** @defgroup I2C_StartStopMode_definition + * @{ + */ + +#define I2C_No_StartStop ((uint32_t)0x00000000) +#define I2C_Generate_Stop I2C_CR2_STOP +#define I2C_Generate_Start_Read (uint32_t)(I2C_CR2_START | I2C_CR2_RD_WRN) +#define I2C_Generate_Start_Write I2C_CR2_START + + +#define IS_START_STOP_MODE(MODE) (((MODE) == I2C_Generate_Stop) || \ + ((MODE) == I2C_Generate_Start_Read) || \ + ((MODE) == I2C_Generate_Start_Write) || \ + ((MODE) == I2C_No_StartStop)) + + +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + + +/* Initialization and Configuration functions *********************************/ +void I2C_DeInit(I2C_TypeDef* I2Cx); +void I2C_Init(I2C_TypeDef* I2Cx, I2C_InitTypeDef* I2C_InitStruct); +void I2C_StructInit(I2C_InitTypeDef* I2C_InitStruct); +void I2C_Cmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_SoftwareResetCmd(I2C_TypeDef* I2Cx); +void I2C_ITConfig(I2C_TypeDef* I2Cx, uint32_t I2C_IT, FunctionalState NewState); +void I2C_StretchClockCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_StopModeCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); /*!< not applicable for STM32F030 devices */ +void I2C_DualAddressCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_OwnAddress2Config(I2C_TypeDef* I2Cx, uint16_t Address, uint8_t Mask); +void I2C_GeneralCallCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_SlaveByteControlCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_SlaveAddressConfig(I2C_TypeDef* I2Cx, uint16_t Address); +void I2C_10BitAddressingModeCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); + +/* Communications handling functions ******************************************/ +void I2C_AutoEndCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_ReloadCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_NumberOfBytesConfig(I2C_TypeDef* I2Cx, uint8_t Number_Bytes); +void I2C_MasterRequestConfig(I2C_TypeDef* I2Cx, uint16_t I2C_Direction); +void I2C_GenerateSTART(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_GenerateSTOP(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_10BitAddressHeaderCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_AcknowledgeConfig(I2C_TypeDef* I2Cx, FunctionalState NewState); +uint8_t I2C_GetAddressMatched(I2C_TypeDef* I2Cx); +uint16_t I2C_GetTransferDirection(I2C_TypeDef* I2Cx); +void I2C_TransferHandling(I2C_TypeDef* I2Cx, uint16_t Address, uint8_t Number_Bytes, uint32_t ReloadEndMode, uint32_t StartStopMode); + +/* SMBUS management functions ************************************************/ +void I2C_SMBusAlertCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_ClockTimeoutCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_ExtendedClockTimeoutCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_IdleClockTimeoutCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_TimeoutAConfig(I2C_TypeDef* I2Cx, uint16_t Timeout); +void I2C_TimeoutBConfig(I2C_TypeDef* I2Cx, uint16_t Timeout); +void I2C_CalculatePEC(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_PECRequestCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +uint8_t I2C_GetPEC(I2C_TypeDef* I2Cx); + +/* I2C registers management functions *****************************************/ +uint32_t I2C_ReadRegister(I2C_TypeDef* I2Cx, uint8_t I2C_Register); + +/* Data transfers management functions ****************************************/ +void I2C_SendData(I2C_TypeDef* I2Cx, uint8_t Data); +uint8_t I2C_ReceiveData(I2C_TypeDef* I2Cx); + +/* DMA transfers management functions *****************************************/ +void I2C_DMACmd(I2C_TypeDef* I2Cx, uint32_t I2C_DMAReq, FunctionalState NewState); + +/* Interrupts and flags management functions **********************************/ +FlagStatus I2C_GetFlagStatus(I2C_TypeDef* I2Cx, uint32_t I2C_FLAG); +void I2C_ClearFlag(I2C_TypeDef* I2Cx, uint32_t I2C_FLAG); +ITStatus I2C_GetITStatus(I2C_TypeDef* I2Cx, uint32_t I2C_IT); +void I2C_ClearITPendingBit(I2C_TypeDef* I2Cx, uint32_t I2C_IT); + + +#ifdef __cplusplus +} +#endif + +#endif /*__STM32F0XX_I2C_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_iwdg.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_iwdg.h new file mode 100644 index 00000000..e65c8ded --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_iwdg.h @@ -0,0 +1,140 @@ +/** + ****************************************************************************** + * @file stm32f0xx_iwdg.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the IWDG + * firmware library. + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_IWDG_H +#define __STM32F0XX_IWDG_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup IWDG + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup IWDG_Exported_Constants + * @{ + */ + +/** @defgroup IWDG_WriteAccess + * @{ + */ + +#define IWDG_WriteAccess_Enable ((uint16_t)0x5555) +#define IWDG_WriteAccess_Disable ((uint16_t)0x0000) +#define IS_IWDG_WRITE_ACCESS(ACCESS) (((ACCESS) == IWDG_WriteAccess_Enable) || \ + ((ACCESS) == IWDG_WriteAccess_Disable)) +/** + * @} + */ + +/** @defgroup IWDG_prescaler + * @{ + */ + +#define IWDG_Prescaler_4 ((uint8_t)0x00) +#define IWDG_Prescaler_8 ((uint8_t)0x01) +#define IWDG_Prescaler_16 ((uint8_t)0x02) +#define IWDG_Prescaler_32 ((uint8_t)0x03) +#define IWDG_Prescaler_64 ((uint8_t)0x04) +#define IWDG_Prescaler_128 ((uint8_t)0x05) +#define IWDG_Prescaler_256 ((uint8_t)0x06) +#define IS_IWDG_PRESCALER(PRESCALER) (((PRESCALER) == IWDG_Prescaler_4) || \ + ((PRESCALER) == IWDG_Prescaler_8) || \ + ((PRESCALER) == IWDG_Prescaler_16) || \ + ((PRESCALER) == IWDG_Prescaler_32) || \ + ((PRESCALER) == IWDG_Prescaler_64) || \ + ((PRESCALER) == IWDG_Prescaler_128)|| \ + ((PRESCALER) == IWDG_Prescaler_256)) +/** + * @} + */ + +/** @defgroup IWDG_Flag + * @{ + */ + +#define IWDG_FLAG_PVU IWDG_SR_PVU +#define IWDG_FLAG_RVU IWDG_SR_RVU +#define IWDG_FLAG_WVU IWDG_SR_WVU +#define IS_IWDG_FLAG(FLAG) (((FLAG) == IWDG_FLAG_PVU) || ((FLAG) == IWDG_FLAG_RVU) || \ + ((FLAG) == IWDG_FLAG_WVU)) + +#define IS_IWDG_RELOAD(RELOAD) ((RELOAD) <= 0xFFF) + +#define IS_IWDG_WINDOW_VALUE(VALUE) ((VALUE) <= 0xFFF) +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Prescaler and Counter configuration functions ******************************/ +void IWDG_WriteAccessCmd(uint16_t IWDG_WriteAccess); +void IWDG_SetPrescaler(uint8_t IWDG_Prescaler); +void IWDG_SetReload(uint16_t Reload); +void IWDG_ReloadCounter(void); +void IWDG_SetWindowValue(uint16_t WindowValue); + +/* IWDG activation function ***************************************************/ +void IWDG_Enable(void); + +/* Flag management function ***************************************************/ +FlagStatus IWDG_GetFlagStatus(uint16_t IWDG_FLAG); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_IWDG_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_misc.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_misc.h new file mode 100644 index 00000000..750dc287 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_misc.h @@ -0,0 +1,143 @@ +/** + ****************************************************************************** + * @file stm32f0xx_misc.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the miscellaneous + * firmware library functions (add-on to CMSIS functions). + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_MISC_H +#define __STM32F0XX_MISC_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup MISC + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief NVIC Init Structure definition + */ + +typedef struct +{ + uint8_t NVIC_IRQChannel; /*!< Specifies the IRQ channel to be enabled or disabled. + This parameter can be a value of @ref IRQn_Type + (For the complete STM32 Devices IRQ Channels list, + please refer to stm32f0xx.h file) */ + + uint8_t NVIC_IRQChannelPriority; /*!< Specifies the priority level for the IRQ channel specified + in NVIC_IRQChannel. This parameter can be a value + between 0 and 3. */ + + FunctionalState NVIC_IRQChannelCmd; /*!< Specifies whether the IRQ channel defined in NVIC_IRQChannel + will be enabled or disabled. + This parameter can be set either to ENABLE or DISABLE */ +} NVIC_InitTypeDef; + +/** + * +@verbatim + +@endverbatim +*/ + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup MISC_Exported_Constants + * @{ + */ + +/** @defgroup MISC_System_Low_Power + * @{ + */ + +#define NVIC_LP_SEVONPEND ((uint8_t)0x10) +#define NVIC_LP_SLEEPDEEP ((uint8_t)0x04) +#define NVIC_LP_SLEEPONEXIT ((uint8_t)0x02) +#define IS_NVIC_LP(LP) (((LP) == NVIC_LP_SEVONPEND) || \ + ((LP) == NVIC_LP_SLEEPDEEP) || \ + ((LP) == NVIC_LP_SLEEPONEXIT)) +/** + * @} + */ + +/** @defgroup MISC_Preemption_Priority_Group + * @{ + */ +#define IS_NVIC_PRIORITY(PRIORITY) ((PRIORITY) < 0x04) + +/** + * @} + */ + +/** @defgroup MISC_SysTick_clock_source + * @{ + */ + +#define SysTick_CLKSource_HCLK_Div8 ((uint32_t)0xFFFFFFFB) +#define SysTick_CLKSource_HCLK ((uint32_t)0x00000004) +#define IS_SYSTICK_CLK_SOURCE(SOURCE) (((SOURCE) == SysTick_CLKSource_HCLK) || \ + ((SOURCE) == SysTick_CLKSource_HCLK_Div8)) +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +void NVIC_Init(NVIC_InitTypeDef* NVIC_InitStruct); +void NVIC_SystemLPConfig(uint8_t LowPowerMode, FunctionalState NewState); +void SysTick_CLKSourceConfig(uint32_t SysTick_CLKSource); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_MISC_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_pwr.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_pwr.h new file mode 100644 index 00000000..7044b678 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_pwr.h @@ -0,0 +1,197 @@ +/** + ****************************************************************************** + * @file stm32f0xx_pwr.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the PWR firmware + * library. + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_PWR_H +#define __STM32F0XX_PWR_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup PWR + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup PWR_Exported_Constants + * @{ + */ + +/** @defgroup PWR_PVD_detection_level + * @brief This parameters are only applicable for STM32F051 and STM32F072 devices + * @{ + */ + +#define PWR_PVDLevel_0 PWR_CR_PLS_LEV0 +#define PWR_PVDLevel_1 PWR_CR_PLS_LEV1 +#define PWR_PVDLevel_2 PWR_CR_PLS_LEV2 +#define PWR_PVDLevel_3 PWR_CR_PLS_LEV3 +#define PWR_PVDLevel_4 PWR_CR_PLS_LEV4 +#define PWR_PVDLevel_5 PWR_CR_PLS_LEV5 +#define PWR_PVDLevel_6 PWR_CR_PLS_LEV6 +#define PWR_PVDLevel_7 PWR_CR_PLS_LEV7 + +#define IS_PWR_PVD_LEVEL(LEVEL) (((LEVEL) == PWR_PVDLevel_0) || ((LEVEL) == PWR_PVDLevel_1)|| \ + ((LEVEL) == PWR_PVDLevel_2) || ((LEVEL) == PWR_PVDLevel_3)|| \ + ((LEVEL) == PWR_PVDLevel_4) || ((LEVEL) == PWR_PVDLevel_5)|| \ + ((LEVEL) == PWR_PVDLevel_6) || ((LEVEL) == PWR_PVDLevel_7)) +/** + * @} + */ + +/** @defgroup PWR_WakeUp_Pins + * @{ + */ + +#define PWR_WakeUpPin_1 PWR_CSR_EWUP1 +#define PWR_WakeUpPin_2 PWR_CSR_EWUP2 +#define PWR_WakeUpPin_3 PWR_CSR_EWUP3 /*!< only applicable for STM32F072 devices */ +#define PWR_WakeUpPin_4 PWR_CSR_EWUP4 /*!< only applicable for STM32F072 devices */ +#define PWR_WakeUpPin_5 PWR_CSR_EWUP5 /*!< only applicable for STM32F072 devices */ +#define PWR_WakeUpPin_6 PWR_CSR_EWUP6 /*!< only applicable for STM32F072 devices */ +#define PWR_WakeUpPin_7 PWR_CSR_EWUP7 /*!< only applicable for STM32F072 devices */ +#define PWR_WakeUpPin_8 PWR_CSR_EWUP8 /*!< only applicable for STM32F072 devices */ +#define IS_PWR_WAKEUP_PIN(PIN) (((PIN) == PWR_WakeUpPin_1) || ((PIN) == PWR_WakeUpPin_2) || \ + ((PIN) == PWR_WakeUpPin_3) || ((PIN) == PWR_WakeUpPin_4) || \ + ((PIN) == PWR_WakeUpPin_5) || ((PIN) == PWR_WakeUpPin_6) || \ + ((PIN) == PWR_WakeUpPin_7) || ((PIN) == PWR_WakeUpPin_8)) +/** + * @} + */ + + +/** @defgroup PWR_Regulator_state_is_Sleep_STOP_mode + * @{ + */ + +#define PWR_Regulator_ON ((uint32_t)0x00000000) +#define PWR_Regulator_LowPower PWR_CR_LPSDSR +#define IS_PWR_REGULATOR(REGULATOR) (((REGULATOR) == PWR_Regulator_ON) || \ + ((REGULATOR) == PWR_Regulator_LowPower)) +/** + * @} + */ + +/** @defgroup PWR_SLEEP_mode_entry + * @{ + */ + +#define PWR_SLEEPEntry_WFI ((uint8_t)0x01) +#define PWR_SLEEPEntry_WFE ((uint8_t)0x02) +#define IS_PWR_SLEEP_ENTRY(ENTRY) (((ENTRY) == PWR_SLEEPEntry_WFI) || ((ENTRY) == PWR_SLEEPEntry_WFE)) + +/** + * @} + */ + +/** @defgroup PWR_STOP_mode_entry + * @{ + */ + +#define PWR_STOPEntry_WFI ((uint8_t)0x01) +#define PWR_STOPEntry_WFE ((uint8_t)0x02) +#define PWR_STOPEntry_SLEEPONEXIT ((uint8_t)0x03) +#define IS_PWR_STOP_ENTRY(ENTRY) (((ENTRY) == PWR_STOPEntry_WFI) || ((ENTRY) == PWR_STOPEntry_WFE) ||\ + ((ENTRY) == PWR_STOPEntry_SLEEPONEXIT)) + +/** + * @} + */ + +/** @defgroup PWR_Flag + * @{ + */ + +#define PWR_FLAG_WU PWR_CSR_WUF +#define PWR_FLAG_SB PWR_CSR_SBF +#define PWR_FLAG_PVDO PWR_CSR_PVDO /*!< Not applicable for STM32F030 devices */ +#define PWR_FLAG_VREFINTRDY PWR_CSR_VREFINTRDYF + +#define IS_PWR_GET_FLAG(FLAG) (((FLAG) == PWR_FLAG_WU) || ((FLAG) == PWR_FLAG_SB) || \ + ((FLAG) == PWR_FLAG_PVDO) || ((FLAG) == PWR_FLAG_VREFINTRDY)) + +#define IS_PWR_CLEAR_FLAG(FLAG) (((FLAG) == PWR_FLAG_WU) || ((FLAG) == PWR_FLAG_SB)) +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Function used to set the PWR configuration to the default reset state ******/ +void PWR_DeInit(void); + +/* Backup Domain Access function **********************************************/ +void PWR_BackupAccessCmd(FunctionalState NewState); + +/* PVD configuration functions ************************************************/ +void PWR_PVDLevelConfig(uint32_t PWR_PVDLevel); /*!< only applicable for STM32F051 and STM32F072 devices */ +void PWR_PVDCmd(FunctionalState NewState); /*!< only applicable for STM32F051 and STM32F072 devices */ + +/* WakeUp pins configuration functions ****************************************/ +void PWR_WakeUpPinCmd(uint32_t PWR_WakeUpPin, FunctionalState NewState); + +/* Low Power modes configuration functions ************************************/ +void PWR_EnterSleepMode(uint8_t PWR_SLEEPEntry); +void PWR_EnterSTOPMode(uint32_t PWR_Regulator, uint8_t PWR_STOPEntry); +void PWR_EnterSTANDBYMode(void); + +/* Flags management functions *************************************************/ +FlagStatus PWR_GetFlagStatus(uint32_t PWR_FLAG); +void PWR_ClearFlag(uint32_t PWR_FLAG); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_PWR_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_rcc.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_rcc.h new file mode 100644 index 00000000..cf3c10a3 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_rcc.h @@ -0,0 +1,624 @@ +/** + ****************************************************************************** + * @file stm32f0xx_rcc.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the RCC + * firmware library. + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_RCC_H +#define __STM32F0XX_RCC_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup RCC + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +typedef struct +{ + uint32_t SYSCLK_Frequency; + uint32_t HCLK_Frequency; + uint32_t PCLK_Frequency; + uint32_t ADCCLK_Frequency; + uint32_t CECCLK_Frequency; + uint32_t I2C1CLK_Frequency; + uint32_t USART1CLK_Frequency; + uint32_t USART2CLK_Frequency; /*!< Only applicable for STM32F072 and STM32F091 devices */ + uint32_t USART3CLK_Frequency; /*!< Only applicable for STM32F091 devices */ + uint32_t USBCLK_Frequency; /*!< Only applicable for STM32F072 devices */ +}RCC_ClocksTypeDef; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup RCC_Exported_Constants + * @{ + */ + +/** @defgroup RCC_HSE_configuration + * @{ + */ + +#define RCC_HSE_OFF ((uint8_t)0x00) +#define RCC_HSE_ON ((uint8_t)0x01) +#define RCC_HSE_Bypass ((uint8_t)0x05) +#define IS_RCC_HSE(HSE) (((HSE) == RCC_HSE_OFF) || ((HSE) == RCC_HSE_ON) || \ + ((HSE) == RCC_HSE_Bypass)) + +/** + * @} + */ + +/** @defgroup RCC_PLL_Clock_Source + * @{ + */ + +#define RCC_PLLSource_HSI_Div2 RCC_CFGR_PLLSRC_HSI_Div2 +#define RCC_PLLSource_PREDIV1 RCC_CFGR_PLLSRC_HSE_PREDIV /* Old HSEPREDIV1 bit definition, maintained for legacy purpose */ +#define RCC_PLLSource_HSE RCC_CFGR_PLLSRC_HSE_PREDIV /*!< Only applicable for STM32F072 devices */ +#define RCC_PLLSource_HSI48 RCC_CFGR_PLLSRC_HSI48_PREDIV /*!< Only applicable for STM32F072 devices */ +#define RCC_PLLSource_HSI RCC_CFGR_PLLSRC_HSI_PREDIV /*!< Only applicable for STM32F072 devices */ + +#define IS_RCC_PLL_SOURCE(SOURCE) (((SOURCE) == RCC_PLLSource_HSI_Div2) || \ + ((SOURCE) == RCC_PLLSource_HSI48) || \ + ((SOURCE) == RCC_PLLSource_HSI) || \ + ((SOURCE) == RCC_PLLSource_HSE) || \ + ((SOURCE) == RCC_PLLSource_PREDIV1)) +/** + * @} + */ + +/** @defgroup RCC_PLL_Multiplication_Factor + * @{ + */ + +#define RCC_PLLMul_2 RCC_CFGR_PLLMULL2 +#define RCC_PLLMul_3 RCC_CFGR_PLLMULL3 +#define RCC_PLLMul_4 RCC_CFGR_PLLMULL4 +#define RCC_PLLMul_5 RCC_CFGR_PLLMULL5 +#define RCC_PLLMul_6 RCC_CFGR_PLLMULL6 +#define RCC_PLLMul_7 RCC_CFGR_PLLMULL7 +#define RCC_PLLMul_8 RCC_CFGR_PLLMULL8 +#define RCC_PLLMul_9 RCC_CFGR_PLLMULL9 +#define RCC_PLLMul_10 RCC_CFGR_PLLMULL10 +#define RCC_PLLMul_11 RCC_CFGR_PLLMULL11 +#define RCC_PLLMul_12 RCC_CFGR_PLLMULL12 +#define RCC_PLLMul_13 RCC_CFGR_PLLMULL13 +#define RCC_PLLMul_14 RCC_CFGR_PLLMULL14 +#define RCC_PLLMul_15 RCC_CFGR_PLLMULL15 +#define RCC_PLLMul_16 RCC_CFGR_PLLMULL16 +#define IS_RCC_PLL_MUL(MUL) (((MUL) == RCC_PLLMul_2) || ((MUL) == RCC_PLLMul_3) || \ + ((MUL) == RCC_PLLMul_4) || ((MUL) == RCC_PLLMul_5) || \ + ((MUL) == RCC_PLLMul_6) || ((MUL) == RCC_PLLMul_7) || \ + ((MUL) == RCC_PLLMul_8) || ((MUL) == RCC_PLLMul_9) || \ + ((MUL) == RCC_PLLMul_10) || ((MUL) == RCC_PLLMul_11) || \ + ((MUL) == RCC_PLLMul_12) || ((MUL) == RCC_PLLMul_13) || \ + ((MUL) == RCC_PLLMul_14) || ((MUL) == RCC_PLLMul_15) || \ + ((MUL) == RCC_PLLMul_16)) +/** + * @} + */ + +/** @defgroup RCC_PREDIV1_division_factor + * @{ + */ +#define RCC_PREDIV1_Div1 RCC_CFGR2_PREDIV1_DIV1 +#define RCC_PREDIV1_Div2 RCC_CFGR2_PREDIV1_DIV2 +#define RCC_PREDIV1_Div3 RCC_CFGR2_PREDIV1_DIV3 +#define RCC_PREDIV1_Div4 RCC_CFGR2_PREDIV1_DIV4 +#define RCC_PREDIV1_Div5 RCC_CFGR2_PREDIV1_DIV5 +#define RCC_PREDIV1_Div6 RCC_CFGR2_PREDIV1_DIV6 +#define RCC_PREDIV1_Div7 RCC_CFGR2_PREDIV1_DIV7 +#define RCC_PREDIV1_Div8 RCC_CFGR2_PREDIV1_DIV8 +#define RCC_PREDIV1_Div9 RCC_CFGR2_PREDIV1_DIV9 +#define RCC_PREDIV1_Div10 RCC_CFGR2_PREDIV1_DIV10 +#define RCC_PREDIV1_Div11 RCC_CFGR2_PREDIV1_DIV11 +#define RCC_PREDIV1_Div12 RCC_CFGR2_PREDIV1_DIV12 +#define RCC_PREDIV1_Div13 RCC_CFGR2_PREDIV1_DIV13 +#define RCC_PREDIV1_Div14 RCC_CFGR2_PREDIV1_DIV14 +#define RCC_PREDIV1_Div15 RCC_CFGR2_PREDIV1_DIV15 +#define RCC_PREDIV1_Div16 RCC_CFGR2_PREDIV1_DIV16 + +#define IS_RCC_PREDIV1(PREDIV1) (((PREDIV1) == RCC_PREDIV1_Div1) || ((PREDIV1) == RCC_PREDIV1_Div2) || \ + ((PREDIV1) == RCC_PREDIV1_Div3) || ((PREDIV1) == RCC_PREDIV1_Div4) || \ + ((PREDIV1) == RCC_PREDIV1_Div5) || ((PREDIV1) == RCC_PREDIV1_Div6) || \ + ((PREDIV1) == RCC_PREDIV1_Div7) || ((PREDIV1) == RCC_PREDIV1_Div8) || \ + ((PREDIV1) == RCC_PREDIV1_Div9) || ((PREDIV1) == RCC_PREDIV1_Div10) || \ + ((PREDIV1) == RCC_PREDIV1_Div11) || ((PREDIV1) == RCC_PREDIV1_Div12) || \ + ((PREDIV1) == RCC_PREDIV1_Div13) || ((PREDIV1) == RCC_PREDIV1_Div14) || \ + ((PREDIV1) == RCC_PREDIV1_Div15) || ((PREDIV1) == RCC_PREDIV1_Div16)) +/** + * @} + */ + +/** @defgroup RCC_System_Clock_Source + * @{ + */ + +#define RCC_SYSCLKSource_HSI RCC_CFGR_SW_HSI +#define RCC_SYSCLKSource_HSE RCC_CFGR_SW_HSE +#define RCC_SYSCLKSource_PLLCLK RCC_CFGR_SW_PLL +#define RCC_SYSCLKSource_HSI48 RCC_CFGR_SW_HSI48 /*!< Only applicable for STM32F072 devices */ + +#define IS_RCC_SYSCLK_SOURCE(SOURCE) (((SOURCE) == RCC_SYSCLKSource_HSI) || \ + ((SOURCE) == RCC_SYSCLKSource_HSE) || \ + ((SOURCE) == RCC_SYSCLKSource_HSI48) || \ + ((SOURCE) == RCC_SYSCLKSource_PLLCLK)) +/** + * @} + */ + +/** @defgroup RCC_AHB_Clock_Source + * @{ + */ + +#define RCC_SYSCLK_Div1 RCC_CFGR_HPRE_DIV1 +#define RCC_SYSCLK_Div2 RCC_CFGR_HPRE_DIV2 +#define RCC_SYSCLK_Div4 RCC_CFGR_HPRE_DIV4 +#define RCC_SYSCLK_Div8 RCC_CFGR_HPRE_DIV8 +#define RCC_SYSCLK_Div16 RCC_CFGR_HPRE_DIV16 +#define RCC_SYSCLK_Div64 RCC_CFGR_HPRE_DIV64 +#define RCC_SYSCLK_Div128 RCC_CFGR_HPRE_DIV128 +#define RCC_SYSCLK_Div256 RCC_CFGR_HPRE_DIV256 +#define RCC_SYSCLK_Div512 RCC_CFGR_HPRE_DIV512 +#define IS_RCC_HCLK(HCLK) (((HCLK) == RCC_SYSCLK_Div1) || ((HCLK) == RCC_SYSCLK_Div2) || \ + ((HCLK) == RCC_SYSCLK_Div4) || ((HCLK) == RCC_SYSCLK_Div8) || \ + ((HCLK) == RCC_SYSCLK_Div16) || ((HCLK) == RCC_SYSCLK_Div64) || \ + ((HCLK) == RCC_SYSCLK_Div128) || ((HCLK) == RCC_SYSCLK_Div256) || \ + ((HCLK) == RCC_SYSCLK_Div512)) +/** + * @} + */ + +/** @defgroup RCC_APB_Clock_Source + * @{ + */ + +#define RCC_HCLK_Div1 RCC_CFGR_PPRE_DIV1 +#define RCC_HCLK_Div2 RCC_CFGR_PPRE_DIV2 +#define RCC_HCLK_Div4 RCC_CFGR_PPRE_DIV4 +#define RCC_HCLK_Div8 RCC_CFGR_PPRE_DIV8 +#define RCC_HCLK_Div16 RCC_CFGR_PPRE_DIV16 +#define IS_RCC_PCLK(PCLK) (((PCLK) == RCC_HCLK_Div1) || ((PCLK) == RCC_HCLK_Div2) || \ + ((PCLK) == RCC_HCLK_Div4) || ((PCLK) == RCC_HCLK_Div8) || \ + ((PCLK) == RCC_HCLK_Div16)) +/** + * @} + */ + +/** @defgroup RCC_ADC_clock_source + * @{ + */ +/* These defines are obsolete and kept for legacy purpose only. +Proper ADC clock selection is done within ADC driver by mean of the ADC_ClockModeConfig() function */ +#define RCC_ADCCLK_HSI14 ((uint32_t)0x00000000) +#define RCC_ADCCLK_PCLK_Div2 ((uint32_t)0x01000000) +#define RCC_ADCCLK_PCLK_Div4 ((uint32_t)0x01004000) + +#define IS_RCC_ADCCLK(ADCCLK) (((ADCCLK) == RCC_ADCCLK_HSI14) || ((ADCCLK) == RCC_ADCCLK_PCLK_Div2) || \ + ((ADCCLK) == RCC_ADCCLK_PCLK_Div4)) + +/** + * @} + */ + +/** @defgroup RCC_CEC_clock_source + * @{ + */ + +#define RCC_CECCLK_HSI_Div244 ((uint32_t)0x00000000) +#define RCC_CECCLK_LSE RCC_CFGR3_CECSW + +#define IS_RCC_CECCLK(CECCLK) (((CECCLK) == RCC_CECCLK_HSI_Div244) || ((CECCLK) == RCC_CECCLK_LSE)) + +/** + * @} + */ + +/** @defgroup RCC_I2C_clock_source + * @{ + */ + +#define RCC_I2C1CLK_HSI ((uint32_t)0x00000000) +#define RCC_I2C1CLK_SYSCLK RCC_CFGR3_I2C1SW + +#define IS_RCC_I2CCLK(I2CCLK) (((I2CCLK) == RCC_I2C1CLK_HSI) || ((I2CCLK) == RCC_I2C1CLK_SYSCLK)) + +/** + * @} + */ + +/** @defgroup RCC_USB_clock_source + * @brief Applicable only for STM32F072 devices + * @{ + */ + +#define RCC_USBCLK_HSI48 ((uint32_t)0x00000000) +#define RCC_USBCLK_PLLCLK RCC_CFGR3_USBSW + +#define IS_RCC_USBCLK(USBCLK) (((USBCLK) == RCC_USBCLK_HSI48) || ((USBCLK) == RCC_USBCLK_PLLCLK)) + +/** + * @} + */ + +/** @defgroup RCC_USART_clock_source + * @{ + */ + +#define RCC_USART1CLK_PCLK ((uint32_t)0x10000000) +#define RCC_USART1CLK_SYSCLK ((uint32_t)0x10000001) +#define RCC_USART1CLK_LSE ((uint32_t)0x10000002) +#define RCC_USART1CLK_HSI ((uint32_t)0x10000003) + +#define RCC_USART2CLK_PCLK ((uint32_t)0x20000000) /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define RCC_USART2CLK_SYSCLK ((uint32_t)0x20010000) /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define RCC_USART2CLK_LSE ((uint32_t)0x20020000) /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define RCC_USART2CLK_HSI ((uint32_t)0x20030000) /*!< Only applicable for STM32F072 and STM32F091 devices */ + +#define RCC_USART3CLK_PCLK ((uint32_t)0x30000000) /*!< Only applicable for STM32F091 devices */ +#define RCC_USART3CLK_SYSCLK ((uint32_t)0x30040000) /*!< Only applicable for STM32F091 devices */ +#define RCC_USART3CLK_LSE ((uint32_t)0x30080000) /*!< Only applicable for STM32F091 devices */ +#define RCC_USART3CLK_HSI ((uint32_t)0x300C0000) /*!< Only applicable for STM32F091 devices */ + + +#define IS_RCC_USARTCLK(USARTCLK) (((USARTCLK) == RCC_USART1CLK_PCLK) || \ + ((USARTCLK) == RCC_USART1CLK_SYSCLK) || \ + ((USARTCLK) == RCC_USART1CLK_LSE) || \ + ((USARTCLK) == RCC_USART1CLK_HSI) || \ + ((USARTCLK) == RCC_USART2CLK_PCLK) || \ + ((USARTCLK) == RCC_USART2CLK_SYSCLK) || \ + ((USARTCLK) == RCC_USART2CLK_LSE) || \ + ((USARTCLK) == RCC_USART2CLK_HSI)|| \ + ((USARTCLK) == RCC_USART3CLK_PCLK) || \ + ((USARTCLK) == RCC_USART3CLK_SYSCLK) || \ + ((USARTCLK) == RCC_USART3CLK_LSE) || \ + ((USARTCLK) == RCC_USART3CLK_HSI)) + +/** + * @} + */ + +/** @defgroup RCC_Interrupt_Source + * @{ + */ + +#define RCC_IT_LSIRDY ((uint8_t)0x01) +#define RCC_IT_LSERDY ((uint8_t)0x02) +#define RCC_IT_HSIRDY ((uint8_t)0x04) +#define RCC_IT_HSERDY ((uint8_t)0x08) +#define RCC_IT_PLLRDY ((uint8_t)0x10) +#define RCC_IT_HSI14RDY ((uint8_t)0x20) +#define RCC_IT_HSI48RDY ((uint8_t)0x40) /*!< Only applicable for STM32F072 devices */ +#define RCC_IT_CSS ((uint8_t)0x80) + +#define IS_RCC_IT(IT) ((((IT) & (uint8_t)0x80) == 0x00) && ((IT) != 0x00)) + +#define IS_RCC_GET_IT(IT) (((IT) == RCC_IT_LSIRDY) || ((IT) == RCC_IT_LSERDY) || \ + ((IT) == RCC_IT_HSIRDY) || ((IT) == RCC_IT_HSERDY) || \ + ((IT) == RCC_IT_PLLRDY) || ((IT) == RCC_IT_HSI14RDY) || \ + ((IT) == RCC_IT_CSS) || ((IT) == RCC_IT_HSI48RDY)) + +#define IS_RCC_CLEAR_IT(IT) ((IT) != 0x00) + +/** + * @} + */ + +/** @defgroup RCC_LSE_Configuration + * @{ + */ + +#define RCC_LSE_OFF ((uint32_t)0x00000000) +#define RCC_LSE_ON RCC_BDCR_LSEON +#define RCC_LSE_Bypass ((uint32_t)(RCC_BDCR_LSEON | RCC_BDCR_LSEBYP)) +#define IS_RCC_LSE(LSE) (((LSE) == RCC_LSE_OFF) || ((LSE) == RCC_LSE_ON) || \ + ((LSE) == RCC_LSE_Bypass)) +/** + * @} + */ + +/** @defgroup RCC_RTC_Clock_Source + * @{ + */ + +#define RCC_RTCCLKSource_LSE RCC_BDCR_RTCSEL_LSE +#define RCC_RTCCLKSource_LSI RCC_BDCR_RTCSEL_LSI +#define RCC_RTCCLKSource_HSE_Div32 RCC_BDCR_RTCSEL_HSE + +#define IS_RCC_RTCCLK_SOURCE(SOURCE) (((SOURCE) == RCC_RTCCLKSource_LSE) || \ + ((SOURCE) == RCC_RTCCLKSource_LSI) || \ + ((SOURCE) == RCC_RTCCLKSource_HSE_Div32)) +/** + * @} + */ + +/** @defgroup RCC_LSE_Drive_Configuration + * @{ + */ + +#define RCC_LSEDrive_Low ((uint32_t)0x00000000) +#define RCC_LSEDrive_MediumLow RCC_BDCR_LSEDRV_0 +#define RCC_LSEDrive_MediumHigh RCC_BDCR_LSEDRV_1 +#define RCC_LSEDrive_High RCC_BDCR_LSEDRV +#define IS_RCC_LSE_DRIVE(DRIVE) (((DRIVE) == RCC_LSEDrive_Low) || ((DRIVE) == RCC_LSEDrive_MediumLow) || \ + ((DRIVE) == RCC_LSEDrive_MediumHigh) || ((DRIVE) == RCC_LSEDrive_High)) +/** + * @} + */ + +/** @defgroup RCC_AHB_Peripherals + * @{ + */ + +#define RCC_AHBPeriph_GPIOA RCC_AHBENR_GPIOAEN +#define RCC_AHBPeriph_GPIOB RCC_AHBENR_GPIOBEN +#define RCC_AHBPeriph_GPIOC RCC_AHBENR_GPIOCEN +#define RCC_AHBPeriph_GPIOD RCC_AHBENR_GPIODEN +#define RCC_AHBPeriph_GPIOE RCC_AHBENR_GPIOEEN /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define RCC_AHBPeriph_GPIOF RCC_AHBENR_GPIOFEN +#define RCC_AHBPeriph_TS RCC_AHBENR_TSEN +#define RCC_AHBPeriph_CRC RCC_AHBENR_CRCEN +#define RCC_AHBPeriph_FLITF RCC_AHBENR_FLITFEN +#define RCC_AHBPeriph_SRAM RCC_AHBENR_SRAMEN +#define RCC_AHBPeriph_DMA1 RCC_AHBENR_DMA1EN +#define RCC_AHBPeriph_DMA2 RCC_AHBENR_DMA2EN + +#define IS_RCC_AHB_PERIPH(PERIPH) ((((PERIPH) & 0xFE81FFA8) == 0x00) && ((PERIPH) != 0x00)) +#define IS_RCC_AHB_RST_PERIPH(PERIPH) ((((PERIPH) & 0xFE81FFA8) == 0x00) && ((PERIPH) != 0x00)) + +/** + * @} + */ + +/** @defgroup RCC_APB2_Peripherals + * @{ + */ + +#define RCC_APB2Periph_SYSCFG RCC_APB2ENR_SYSCFGEN +#define RCC_APB2Periph_USART6 RCC_APB2ENR_USART6EN +#define RCC_APB2Periph_USART7 RCC_APB2ENR_USART7EN +#define RCC_APB2Periph_USART8 RCC_APB2ENR_USART8EN +#define RCC_APB2Periph_ADC1 RCC_APB2ENR_ADC1EN +#define RCC_APB2Periph_TIM1 RCC_APB2ENR_TIM1EN +#define RCC_APB2Periph_SPI1 RCC_APB2ENR_SPI1EN +#define RCC_APB2Periph_USART1 RCC_APB2ENR_USART1EN +#define RCC_APB2Periph_TIM15 RCC_APB2ENR_TIM15EN +#define RCC_APB2Periph_TIM16 RCC_APB2ENR_TIM16EN +#define RCC_APB2Periph_TIM17 RCC_APB2ENR_TIM17EN +#define RCC_APB2Periph_DBGMCU RCC_APB2ENR_DBGMCUEN + +#define IS_RCC_APB2_PERIPH(PERIPH) ((((PERIPH) & 0xFFB8A51E) == 0x00) && ((PERIPH) != 0x00)) + +/** + * @} + */ + +/** @defgroup RCC_APB1_Peripherals + * @{ + */ + +#define RCC_APB1Periph_TIM2 RCC_APB1ENR_TIM2EN /*!< Only applicable for STM32F051, STM32F072 and STM32F091 devices */ +#define RCC_APB1Periph_TIM3 RCC_APB1ENR_TIM3EN +#define RCC_APB1Periph_TIM6 RCC_APB1ENR_TIM6EN +#define RCC_APB1Periph_TIM7 RCC_APB1ENR_TIM7EN /*!< Only applicable for STM32F072 devices */ +#define RCC_APB1Periph_TIM14 RCC_APB1ENR_TIM14EN +#define RCC_APB1Periph_WWDG RCC_APB1ENR_WWDGEN +#define RCC_APB1Periph_SPI2 RCC_APB1ENR_SPI2EN +#define RCC_APB1Periph_USART2 RCC_APB1ENR_USART2EN +#define RCC_APB1Periph_USART3 RCC_APB1ENR_USART3EN /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define RCC_APB1Periph_USART4 RCC_APB1ENR_USART4EN /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define RCC_APB1Periph_USART5 RCC_APB1ENR_USART5EN /*!< Only applicable for STM32F091 devices */ +#define RCC_APB1Periph_I2C1 RCC_APB1ENR_I2C1EN +#define RCC_APB1Periph_I2C2 RCC_APB1ENR_I2C2EN +#define RCC_APB1Periph_USB RCC_APB1ENR_USBEN /*!< Only applicable for STM32F072 and STM32F042 devices */ +#define RCC_APB1Periph_CAN RCC_APB1ENR_CANEN /*!< Only applicable for STM32F072, STM32F042 and STM32F091 devices */ +#define RCC_APB1Periph_CRS RCC_APB1ENR_CRSEN /*!< Only applicable for STM32F072, STM32F042 and STM32F091 devices */ +#define RCC_APB1Periph_PWR RCC_APB1ENR_PWREN +#define RCC_APB1Periph_DAC RCC_APB1ENR_DACEN /*!< Only applicable for STM32F051, STM32F072 and STM32F091 devices */ +#define RCC_APB1Periph_CEC RCC_APB1ENR_CECEN /*!< Only applicable for STM32F051, STM32F042, STM32F072 and STM32F091 devices */ + +#define IS_RCC_APB1_PERIPH(PERIPH) ((((PERIPH) & 0x8581B6CC) == 0x00) && ((PERIPH) != 0x00)) +/** + * @} + */ + +/** @defgroup RCC_MCO_Clock_Source + * @{ + */ + +#define RCC_MCOSource_NoClock ((uint8_t)0x00) +#define RCC_MCOSource_HSI14 ((uint8_t)0x01) +#define RCC_MCOSource_LSI ((uint8_t)0x02) +#define RCC_MCOSource_LSE ((uint8_t)0x03) +#define RCC_MCOSource_SYSCLK ((uint8_t)0x04) +#define RCC_MCOSource_HSI ((uint8_t)0x05) +#define RCC_MCOSource_HSE ((uint8_t)0x06) +#define RCC_MCOSource_PLLCLK_Div2 ((uint8_t)0x07) +#define RCC_MCOSource_HSI48 ((uint8_t)0x08) /*!< Only applicable for STM32F072 devices */ +#define RCC_MCOSource_PLLCLK ((uint8_t)0x87) + +#define IS_RCC_MCO_SOURCE(SOURCE) (((SOURCE) == RCC_MCOSource_NoClock) || ((SOURCE) == RCC_MCOSource_HSI14) || \ + ((SOURCE) == RCC_MCOSource_SYSCLK) || ((SOURCE) == RCC_MCOSource_HSI) || \ + ((SOURCE) == RCC_MCOSource_HSE) || ((SOURCE) == RCC_MCOSource_PLLCLK_Div2)|| \ + ((SOURCE) == RCC_MCOSource_LSI) || ((SOURCE) == RCC_MCOSource_HSI48) || \ + ((SOURCE) == RCC_MCOSource_PLLCLK) || ((SOURCE) == RCC_MCOSource_LSE)) +/** + * @} + */ + +/** @defgroup RCC_MCOPrescaler + * @{ + */ +#if !defined (STM32F051) +#define RCC_MCOPrescaler_1 RCC_CFGR_MCO_PRE_1 +#define RCC_MCOPrescaler_2 RCC_CFGR_MCO_PRE_2 +#define RCC_MCOPrescaler_4 RCC_CFGR_MCO_PRE_4 +#define RCC_MCOPrescaler_8 RCC_CFGR_MCO_PRE_8 +#define RCC_MCOPrescaler_16 RCC_CFGR_MCO_PRE_16 +#define RCC_MCOPrescaler_32 RCC_CFGR_MCO_PRE_32 +#define RCC_MCOPrescaler_64 RCC_CFGR_MCO_PRE_64 +#define RCC_MCOPrescaler_128 RCC_CFGR_MCO_PRE_128 + +#define IS_RCC_MCO_PRESCALER(PRESCALER) (((PRESCALER) == RCC_MCOPrescaler_1) || \ + ((PRESCALER) == RCC_MCOPrescaler_2) || \ + ((PRESCALER) == RCC_MCOPrescaler_4) || \ + ((PRESCALER) == RCC_MCOPrescaler_8) || \ + ((PRESCALER) == RCC_MCOPrescaler_16) || \ + ((PRESCALER) == RCC_MCOPrescaler_32) || \ + ((PRESCALER) == RCC_MCOPrescaler_64) || \ + ((PRESCALER) == RCC_MCOPrescaler_128)) +#endif /* STM32F051 */ +/** + * @} + */ + +/** @defgroup RCC_Flag + * @{ + */ +#define RCC_FLAG_HSIRDY ((uint8_t)0x01) +#define RCC_FLAG_HSERDY ((uint8_t)0x11) +#define RCC_FLAG_PLLRDY ((uint8_t)0x19) +#define RCC_FLAG_LSERDY ((uint8_t)0x21) +#define RCC_FLAG_LSIRDY ((uint8_t)0x41) +#define RCC_FLAG_V18PWRRSTF ((uint8_t)0x57) +#define RCC_FLAG_OBLRST ((uint8_t)0x59) +#define RCC_FLAG_PINRST ((uint8_t)0x5A) +#define RCC_FLAG_PORRST ((uint8_t)0x5B) +#define RCC_FLAG_SFTRST ((uint8_t)0x5C) +#define RCC_FLAG_IWDGRST ((uint8_t)0x5D) +#define RCC_FLAG_WWDGRST ((uint8_t)0x5E) +#define RCC_FLAG_LPWRRST ((uint8_t)0x5F) +#define RCC_FLAG_HSI14RDY ((uint8_t)0x61) +#define RCC_FLAG_HSI48RDY ((uint8_t)0x71) /*!< Only applicable for STM32F072 devices */ + +#define IS_RCC_FLAG(FLAG) (((FLAG) == RCC_FLAG_HSIRDY) || ((FLAG) == RCC_FLAG_HSERDY) || \ + ((FLAG) == RCC_FLAG_PLLRDY) || ((FLAG) == RCC_FLAG_LSERDY) || \ + ((FLAG) == RCC_FLAG_LSIRDY) || ((FLAG) == RCC_FLAG_OBLRST) || \ + ((FLAG) == RCC_FLAG_PINRST) || ((FLAG) == RCC_FLAG_PORRST) || \ + ((FLAG) == RCC_FLAG_SFTRST) || ((FLAG) == RCC_FLAG_IWDGRST) || \ + ((FLAG) == RCC_FLAG_WWDGRST) || ((FLAG) == RCC_FLAG_LPWRRST) || \ + ((FLAG) == RCC_FLAG_HSI14RDY)|| ((FLAG) == RCC_FLAG_HSI48RDY)|| \ + ((FLAG) == RCC_FLAG_V18PWRRSTF)) + +#define IS_RCC_HSI_CALIBRATION_VALUE(VALUE) ((VALUE) <= 0x1F) +#define IS_RCC_HSI14_CALIBRATION_VALUE(VALUE) ((VALUE) <= 0x1F) + +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Function used to set the RCC clock configuration to the default reset state */ +void RCC_DeInit(void); + +/* Internal/external clocks, PLL, CSS and MCO configuration functions *********/ +void RCC_HSEConfig(uint8_t RCC_HSE); +ErrorStatus RCC_WaitForHSEStartUp(void); +void RCC_AdjustHSICalibrationValue(uint8_t HSICalibrationValue); +void RCC_HSICmd(FunctionalState NewState); +void RCC_AdjustHSI14CalibrationValue(uint8_t HSI14CalibrationValue); +void RCC_HSI14Cmd(FunctionalState NewState); +void RCC_HSI14ADCRequestCmd(FunctionalState NewState); +void RCC_LSEConfig(uint32_t RCC_LSE); +void RCC_LSEDriveConfig(uint32_t RCC_LSEDrive); +void RCC_LSICmd(FunctionalState NewState); +void RCC_PLLConfig(uint32_t RCC_PLLSource, uint32_t RCC_PLLMul); +void RCC_PLLCmd(FunctionalState NewState); +void RCC_HSI48Cmd(FunctionalState NewState); /*!< Only applicable for STM32F072 devices */ +uint32_t RCC_GetHSI48CalibrationValue(void); /*!< Only applicable for STM32F072 devices */ +void RCC_PREDIV1Config(uint32_t RCC_PREDIV1_Div); +void RCC_ClockSecuritySystemCmd(FunctionalState NewState); +#ifdef STM32F051 +void RCC_MCOConfig(uint8_t RCC_MCOSource); +#else +void RCC_MCOConfig(uint8_t RCC_MCOSource,uint32_t RCC_MCOPrescaler); +#endif /* STM32F051 */ + +/* System, AHB and APB busses clocks configuration functions ******************/ +void RCC_SYSCLKConfig(uint32_t RCC_SYSCLKSource); +uint8_t RCC_GetSYSCLKSource(void); +void RCC_HCLKConfig(uint32_t RCC_SYSCLK); +void RCC_PCLKConfig(uint32_t RCC_HCLK); +void RCC_ADCCLKConfig(uint32_t RCC_ADCCLK); /* This function is obsolete. + For proper ADC clock selection, refer to + ADC_ClockModeConfig() in the ADC driver */ +void RCC_CECCLKConfig(uint32_t RCC_CECCLK); +void RCC_I2CCLKConfig(uint32_t RCC_I2CCLK); +void RCC_USARTCLKConfig(uint32_t RCC_USARTCLK); +void RCC_USBCLKConfig(uint32_t RCC_USBCLK); /*!< Only applicable for STM32F042 and STM32F072 devices */ +void RCC_GetClocksFreq(RCC_ClocksTypeDef* RCC_Clocks); + +/* Peripheral clocks configuration functions **********************************/ +void RCC_RTCCLKConfig(uint32_t RCC_RTCCLKSource); +void RCC_RTCCLKCmd(FunctionalState NewState); +void RCC_BackupResetCmd(FunctionalState NewState); + +void RCC_AHBPeriphClockCmd(uint32_t RCC_AHBPeriph, FunctionalState NewState); +void RCC_APB2PeriphClockCmd(uint32_t RCC_APB2Periph, FunctionalState NewState); +void RCC_APB1PeriphClockCmd(uint32_t RCC_APB1Periph, FunctionalState NewState); + +void RCC_AHBPeriphResetCmd(uint32_t RCC_AHBPeriph, FunctionalState NewState); +void RCC_APB2PeriphResetCmd(uint32_t RCC_APB2Periph, FunctionalState NewState); +void RCC_APB1PeriphResetCmd(uint32_t RCC_APB1Periph, FunctionalState NewState); + +/* Interrupts and flags management functions **********************************/ +void RCC_ITConfig(uint8_t RCC_IT, FunctionalState NewState); +FlagStatus RCC_GetFlagStatus(uint8_t RCC_FLAG); +void RCC_ClearFlag(void); +ITStatus RCC_GetITStatus(uint8_t RCC_IT); +void RCC_ClearITPendingBit(uint8_t RCC_IT); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_RCC_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_rtc.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_rtc.h new file mode 100644 index 00000000..83d2b258 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_rtc.h @@ -0,0 +1,807 @@ +/** + ****************************************************************************** + * @file stm32f0xx_rtc.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the RTC firmware + * library. + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_RTC_H +#define __STM32F0XX_RTC_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup RTC + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief RTC Init structures definition + */ +typedef struct +{ + uint32_t RTC_HourFormat; /*!< Specifies the RTC Hour Format. + This parameter can be a value of @ref RTC_Hour_Formats */ + + uint32_t RTC_AsynchPrediv; /*!< Specifies the RTC Asynchronous Predivider value. + This parameter must be set to a value lower than 0x7F */ + + uint32_t RTC_SynchPrediv; /*!< Specifies the RTC Synchronous Predivider value. + This parameter must be set to a value lower than 0x1FFF */ +}RTC_InitTypeDef; + +/** + * @brief RTC Time structure definition + */ +typedef struct +{ + uint8_t RTC_Hours; /*!< Specifies the RTC Time Hour. + This parameter must be set to a value in the 0-12 range + if the RTC_HourFormat_12 is selected or 0-23 range if + the RTC_HourFormat_24 is selected. */ + + uint8_t RTC_Minutes; /*!< Specifies the RTC Time Minutes. + This parameter must be set to a value in the 0-59 range. */ + + uint8_t RTC_Seconds; /*!< Specifies the RTC Time Seconds. + This parameter must be set to a value in the 0-59 range. */ + + uint8_t RTC_H12; /*!< Specifies the RTC AM/PM Time. + This parameter can be a value of @ref RTC_AM_PM_Definitions */ +}RTC_TimeTypeDef; + +/** + * @brief RTC Date structure definition + */ +typedef struct +{ + uint8_t RTC_WeekDay; /*!< Specifies the RTC Date WeekDay. + This parameter can be a value of @ref RTC_WeekDay_Definitions */ + + uint8_t RTC_Month; /*!< Specifies the RTC Date Month. + This parameter can be a value of @ref RTC_Month_Date_Definitions */ + + uint8_t RTC_Date; /*!< Specifies the RTC Date. + This parameter must be set to a value in the 1-31 range. */ + + uint8_t RTC_Year; /*!< Specifies the RTC Date Year. + This parameter must be set to a value in the 0-99 range. */ +}RTC_DateTypeDef; + +/** + * @brief RTC Alarm structure definition + */ +typedef struct +{ + RTC_TimeTypeDef RTC_AlarmTime; /*!< Specifies the RTC Alarm Time members. */ + + uint32_t RTC_AlarmMask; /*!< Specifies the RTC Alarm Masks. + This parameter can be a value of @ref RTC_AlarmMask_Definitions */ + + uint32_t RTC_AlarmDateWeekDaySel; /*!< Specifies the RTC Alarm is on Date or WeekDay. + This parameter can be a value of @ref RTC_AlarmDateWeekDay_Definitions */ + + uint8_t RTC_AlarmDateWeekDay; /*!< Specifies the RTC Alarm Date/WeekDay. + This parameter must be set to a value in the 1-31 range + if the Alarm Date is selected. + This parameter can be a value of @ref RTC_WeekDay_Definitions + if the Alarm WeekDay is selected. */ +}RTC_AlarmTypeDef; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup RTC_Exported_Constants + * @{ + */ + + +/** @defgroup RTC_Hour_Formats + * @{ + */ +#define RTC_HourFormat_24 ((uint32_t)0x00000000) +#define RTC_HourFormat_12 ((uint32_t)0x00000040) +#define IS_RTC_HOUR_FORMAT(FORMAT) (((FORMAT) == RTC_HourFormat_12) || \ + ((FORMAT) == RTC_HourFormat_24)) +/** + * @} + */ + +/** @defgroup RTC_Asynchronous_Predivider + * @{ + */ +#define IS_RTC_ASYNCH_PREDIV(PREDIV) ((PREDIV) <= 0x7F) + +/** + * @} + */ + + +/** @defgroup RTC_Synchronous_Predivider + * @{ + */ +#define IS_RTC_SYNCH_PREDIV(PREDIV) ((PREDIV) <= 0x7FFF) + +/** + * @} + */ + +/** @defgroup RTC_Time_Definitions + * @{ + */ +#define IS_RTC_HOUR12(HOUR) (((HOUR) > 0) && ((HOUR) <= 12)) +#define IS_RTC_HOUR24(HOUR) ((HOUR) <= 23) +#define IS_RTC_MINUTES(MINUTES) ((MINUTES) <= 59) +#define IS_RTC_SECONDS(SECONDS) ((SECONDS) <= 59) + +/** + * @} + */ + +/** @defgroup RTC_AM_PM_Definitions + * @{ + */ +#define RTC_H12_AM ((uint8_t)0x00) +#define RTC_H12_PM ((uint8_t)0x40) +#define IS_RTC_H12(PM) (((PM) == RTC_H12_AM) || ((PM) == RTC_H12_PM)) + +/** + * @} + */ + +/** @defgroup RTC_Year_Date_Definitions + * @{ + */ +#define IS_RTC_YEAR(YEAR) ((YEAR) <= 99) + +/** + * @} + */ + +/** @defgroup RTC_Month_Date_Definitions + * @{ + */ +#define RTC_Month_January ((uint8_t)0x01) +#define RTC_Month_February ((uint8_t)0x02) +#define RTC_Month_March ((uint8_t)0x03) +#define RTC_Month_April ((uint8_t)0x04) +#define RTC_Month_May ((uint8_t)0x05) +#define RTC_Month_June ((uint8_t)0x06) +#define RTC_Month_July ((uint8_t)0x07) +#define RTC_Month_August ((uint8_t)0x08) +#define RTC_Month_September ((uint8_t)0x09) +#define RTC_Month_October ((uint8_t)0x10) +#define RTC_Month_November ((uint8_t)0x11) +#define RTC_Month_December ((uint8_t)0x12) +#define IS_RTC_MONTH(MONTH) (((MONTH) >= 1) && ((MONTH) <= 12)) +#define IS_RTC_DATE(DATE) (((DATE) >= 1) && ((DATE) <= 31)) + +/** + * @} + */ + +/** @defgroup RTC_WeekDay_Definitions + * @{ + */ + +#define RTC_Weekday_Monday ((uint8_t)0x01) +#define RTC_Weekday_Tuesday ((uint8_t)0x02) +#define RTC_Weekday_Wednesday ((uint8_t)0x03) +#define RTC_Weekday_Thursday ((uint8_t)0x04) +#define RTC_Weekday_Friday ((uint8_t)0x05) +#define RTC_Weekday_Saturday ((uint8_t)0x6) +#define RTC_Weekday_Sunday ((uint8_t)0x07) +#define IS_RTC_WEEKDAY(WEEKDAY) (((WEEKDAY) == RTC_Weekday_Monday) || \ + ((WEEKDAY) == RTC_Weekday_Tuesday) || \ + ((WEEKDAY) == RTC_Weekday_Wednesday) || \ + ((WEEKDAY) == RTC_Weekday_Thursday) || \ + ((WEEKDAY) == RTC_Weekday_Friday) || \ + ((WEEKDAY) == RTC_Weekday_Saturday) || \ + ((WEEKDAY) == RTC_Weekday_Sunday)) +/** + * @} + */ + + +/** @defgroup RTC_Alarm_Definitions + * @{ + */ +#define IS_RTC_ALARM_DATE_WEEKDAY_DATE(DATE) (((DATE) > 0) && ((DATE) <= 31)) +#define IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(WEEKDAY) (((WEEKDAY) == RTC_Weekday_Monday) || \ + ((WEEKDAY) == RTC_Weekday_Tuesday) || \ + ((WEEKDAY) == RTC_Weekday_Wednesday) || \ + ((WEEKDAY) == RTC_Weekday_Thursday) || \ + ((WEEKDAY) == RTC_Weekday_Friday) || \ + ((WEEKDAY) == RTC_Weekday_Saturday) || \ + ((WEEKDAY) == RTC_Weekday_Sunday)) + +/** + * @} + */ + + +/** @defgroup RTC_AlarmDateWeekDay_Definitions + * @{ + */ +#define RTC_AlarmDateWeekDaySel_Date ((uint32_t)0x00000000) +#define RTC_AlarmDateWeekDaySel_WeekDay ((uint32_t)0x40000000) + +#define IS_RTC_ALARM_DATE_WEEKDAY_SEL(SEL) (((SEL) == RTC_AlarmDateWeekDaySel_Date) || \ + ((SEL) == RTC_AlarmDateWeekDaySel_WeekDay)) + +/** + * @} + */ + + +/** @defgroup RTC_AlarmMask_Definitions + * @{ + */ +#define RTC_AlarmMask_None ((uint32_t)0x00000000) +#define RTC_AlarmMask_DateWeekDay ((uint32_t)0x80000000) +#define RTC_AlarmMask_Hours ((uint32_t)0x00800000) +#define RTC_AlarmMask_Minutes ((uint32_t)0x00008000) +#define RTC_AlarmMask_Seconds ((uint32_t)0x00000080) +#define RTC_AlarmMask_All ((uint32_t)0x80808080) +#define IS_RTC_ALARM_MASK(MASK) (((MASK) & 0x7F7F7F7F) == (uint32_t)RESET) + +/** + * @} + */ + +/** @defgroup RTC_Alarms_Definitions + * @{ + */ +#define RTC_Alarm_A ((uint32_t)0x00000100) +#define IS_RTC_ALARM(ALARM) ((ALARM) == RTC_Alarm_A) +#define IS_RTC_CMD_ALARM(ALARM) (((ALARM) & (RTC_Alarm_A)) != (uint32_t)RESET) + +/** + * @} + */ + +/** @defgroup RTC_Alarm_Sub_Seconds_Masks Definitions. + * @{ + */ +#define RTC_AlarmSubSecondMask_All ((uint8_t)0x00) /*!< All Alarm SS fields are masked. + There is no comparison on sub seconds + for Alarm */ +#define RTC_AlarmSubSecondMask_SS14_1 ((uint8_t)0x01) /*!< SS[14:1] are don't care in Alarm + comparison. Only SS[0] is compared. */ +#define RTC_AlarmSubSecondMask_SS14_2 ((uint8_t)0x02) /*!< SS[14:2] are don't care in Alarm + comparison. Only SS[1:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14_3 ((uint8_t)0x03) /*!< SS[14:3] are don't care in Alarm + comparison. Only SS[2:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14_4 ((uint8_t)0x04) /*!< SS[14:4] are don't care in Alarm + comparison. Only SS[3:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14_5 ((uint8_t)0x05) /*!< SS[14:5] are don't care in Alarm + comparison. Only SS[4:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14_6 ((uint8_t)0x06) /*!< SS[14:6] are don't care in Alarm + comparison. Only SS[5:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14_7 ((uint8_t)0x07) /*!< SS[14:7] are don't care in Alarm + comparison. Only SS[6:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14_8 ((uint8_t)0x08) /*!< SS[14:8] are don't care in Alarm + comparison. Only SS[7:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14_9 ((uint8_t)0x09) /*!< SS[14:9] are don't care in Alarm + comparison. Only SS[8:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14_10 ((uint8_t)0x0A) /*!< SS[14:10] are don't care in Alarm + comparison. Only SS[9:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14_11 ((uint8_t)0x0B) /*!< SS[14:11] are don't care in Alarm + comparison. Only SS[10:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14_12 ((uint8_t)0x0C) /*!< SS[14:12] are don't care in Alarm + comparison.Only SS[11:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14_13 ((uint8_t)0x0D) /*!< SS[14:13] are don't care in Alarm + comparison. Only SS[12:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14 ((uint8_t)0x0E) /*!< SS[14] is don't care in Alarm + comparison.Only SS[13:0] are compared */ +#define RTC_AlarmSubSecondMask_None ((uint8_t)0x0F) /*!< SS[14:0] are compared and must match + to activate alarm. */ +#define IS_RTC_ALARM_SUB_SECOND_MASK(MASK) (((MASK) == RTC_AlarmSubSecondMask_All) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_1) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_2) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_3) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_4) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_5) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_6) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_7) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_8) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_9) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_10) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_11) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_12) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_13) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14) || \ + ((MASK) == RTC_AlarmSubSecondMask_None)) +/** + * @} + */ + +/** @defgroup RTC_Alarm_Sub_Seconds_Value + * @{ + */ + +#define IS_RTC_ALARM_SUB_SECOND_VALUE(VALUE) ((VALUE) <= 0x00007FFF) + +/** + * @} + */ + +/** @defgroup RTC_Wakeup_Timer_Definitions + * @brief These parameters are only available for STM32F072 devices + * @{ + */ +#define RTC_WakeUpClock_RTCCLK_Div16 ((uint32_t)0x00000000) +#define RTC_WakeUpClock_RTCCLK_Div8 ((uint32_t)0x00000001) +#define RTC_WakeUpClock_RTCCLK_Div4 ((uint32_t)0x00000002) +#define RTC_WakeUpClock_RTCCLK_Div2 ((uint32_t)0x00000003) +#define RTC_WakeUpClock_CK_SPRE_16bits ((uint32_t)0x00000004) +#define RTC_WakeUpClock_CK_SPRE_17bits ((uint32_t)0x00000006) +#define IS_RTC_WAKEUP_CLOCK(CLOCK) (((CLOCK) == RTC_WakeUpClock_RTCCLK_Div16) || \ + ((CLOCK) == RTC_WakeUpClock_RTCCLK_Div8) || \ + ((CLOCK) == RTC_WakeUpClock_RTCCLK_Div4) || \ + ((CLOCK) == RTC_WakeUpClock_RTCCLK_Div2) || \ + ((CLOCK) == RTC_WakeUpClock_CK_SPRE_16bits) || \ + ((CLOCK) == RTC_WakeUpClock_CK_SPRE_17bits)) +#define IS_RTC_WAKEUP_COUNTER(COUNTER) ((COUNTER) <= 0xFFFF) +/** + * @} + */ + +/** @defgroup RTC_Time_Stamp_Edges_definitions + * @{ + */ +#define RTC_TimeStampEdge_Rising ((uint32_t)0x00000000) +#define RTC_TimeStampEdge_Falling ((uint32_t)0x00000008) +#define IS_RTC_TIMESTAMP_EDGE(EDGE) (((EDGE) == RTC_TimeStampEdge_Rising) || \ + ((EDGE) == RTC_TimeStampEdge_Falling)) +/** + * @} + */ + +/** @defgroup RTC_Output_selection_Definitions + * @{ + */ +#define RTC_Output_Disable ((uint32_t)0x00000000) +#define RTC_Output_AlarmA ((uint32_t)0x00200000) +#define RTC_Output_WakeUp ((uint32_t)0x00600000) /*!< available only for STM32F072 devices */ + +#define IS_RTC_OUTPUT(OUTPUT) (((OUTPUT) == RTC_Output_Disable) || \ + ((OUTPUT) == RTC_Output_AlarmA) || \ + ((OUTPUT) == RTC_Output_WakeUp)) + +/** + * @} + */ + +/** @defgroup RTC_Output_Polarity_Definitions + * @{ + */ +#define RTC_OutputPolarity_High ((uint32_t)0x00000000) +#define RTC_OutputPolarity_Low ((uint32_t)0x00100000) +#define IS_RTC_OUTPUT_POL(POL) (((POL) == RTC_OutputPolarity_High) || \ + ((POL) == RTC_OutputPolarity_Low)) +/** + * @} + */ + + +/** @defgroup RTC_Calib_Output_selection_Definitions + * @{ + */ +#define RTC_CalibOutput_512Hz ((uint32_t)0x00000000) +#define RTC_CalibOutput_1Hz ((uint32_t)0x00080000) +#define IS_RTC_CALIB_OUTPUT(OUTPUT) (((OUTPUT) == RTC_CalibOutput_512Hz) || \ + ((OUTPUT) == RTC_CalibOutput_1Hz)) +/** + * @} + */ + +/** @defgroup RTC_Smooth_calib_period_Definitions + * @{ + */ +#define RTC_SmoothCalibPeriod_32sec ((uint32_t)0x00000000) /*!< if RTCCLK = 32768 Hz, Smooth calibation + period is 32s, else 2exp20 RTCCLK seconds */ +#define RTC_SmoothCalibPeriod_16sec ((uint32_t)0x00002000) /*!< if RTCCLK = 32768 Hz, Smooth calibation + period is 16s, else 2exp19 RTCCLK seconds */ +#define RTC_SmoothCalibPeriod_8sec ((uint32_t)0x00004000) /*!< if RTCCLK = 32768 Hz, Smooth calibation + period is 8s, else 2exp18 RTCCLK seconds */ +#define IS_RTC_SMOOTH_CALIB_PERIOD(PERIOD) (((PERIOD) == RTC_SmoothCalibPeriod_32sec) || \ + ((PERIOD) == RTC_SmoothCalibPeriod_16sec) || \ + ((PERIOD) == RTC_SmoothCalibPeriod_8sec)) + +/** + * @} + */ + +/** @defgroup RTC_Smooth_calib_Plus_pulses_Definitions + * @{ + */ +#define RTC_SmoothCalibPlusPulses_Set ((uint32_t)0x00008000) /*!< The number of RTCCLK pulses added + during a X -second window = Y - CALM[8:0]. + with Y = 512, 256, 128 when X = 32, 16, 8 */ +#define RTC_SmoothCalibPlusPulses_Reset ((uint32_t)0x00000000) /*!< The number of RTCCLK pulses subbstited + during a 32-second window = CALM[8:0]. */ +#define IS_RTC_SMOOTH_CALIB_PLUS(PLUS) (((PLUS) == RTC_SmoothCalibPlusPulses_Set) || \ + ((PLUS) == RTC_SmoothCalibPlusPulses_Reset)) + +/** + * @} + */ + +/** @defgroup RTC_Smooth_calib_Minus_pulses_Definitions + * @{ + */ +#define IS_RTC_SMOOTH_CALIB_MINUS(VALUE) ((VALUE) <= 0x000001FF) + +/** + * @} + */ + +/** @defgroup RTC_DayLightSaving_Definitions + * @{ + */ +#define RTC_DayLightSaving_SUB1H ((uint32_t)0x00020000) +#define RTC_DayLightSaving_ADD1H ((uint32_t)0x00010000) +#define IS_RTC_DAYLIGHT_SAVING(SAVING) (((SAVING) == RTC_DayLightSaving_SUB1H) || \ + ((SAVING) == RTC_DayLightSaving_ADD1H)) + +#define RTC_StoreOperation_Reset ((uint32_t)0x00000000) +#define RTC_StoreOperation_Set ((uint32_t)0x00040000) +#define IS_RTC_STORE_OPERATION(OPERATION) (((OPERATION) == RTC_StoreOperation_Reset) || \ + ((OPERATION) == RTC_StoreOperation_Set)) +/** + * @} + */ + +/** @defgroup RTC_Tamper_Trigger_Definitions + * @{ + */ +#define RTC_TamperTrigger_RisingEdge ((uint32_t)0x00000000) +#define RTC_TamperTrigger_FallingEdge ((uint32_t)0x00000001) +#define RTC_TamperTrigger_LowLevel ((uint32_t)0x00000000) +#define RTC_TamperTrigger_HighLevel ((uint32_t)0x00000001) +#define IS_RTC_TAMPER_TRIGGER(TRIGGER) (((TRIGGER) == RTC_TamperTrigger_RisingEdge) || \ + ((TRIGGER) == RTC_TamperTrigger_FallingEdge) || \ + ((TRIGGER) == RTC_TamperTrigger_LowLevel) || \ + ((TRIGGER) == RTC_TamperTrigger_HighLevel)) + +/** + * @} + */ + +/** @defgroup RTC_Tamper_Filter_Definitions + * @{ + */ +#define RTC_TamperFilter_Disable ((uint32_t)0x00000000) /*!< Tamper filter is disabled */ + +#define RTC_TamperFilter_2Sample ((uint32_t)0x00000800) /*!< Tamper is activated after 2 + consecutive samples at the active level */ +#define RTC_TamperFilter_4Sample ((uint32_t)0x00001000) /*!< Tamper is activated after 4 + consecutive samples at the active level */ +#define RTC_TamperFilter_8Sample ((uint32_t)0x00001800) /*!< Tamper is activated after 8 + consecutive samples at the active leve. */ +#define IS_RTC_TAMPER_FILTER(FILTER) (((FILTER) == RTC_TamperFilter_Disable) || \ + ((FILTER) == RTC_TamperFilter_2Sample) || \ + ((FILTER) == RTC_TamperFilter_4Sample) || \ + ((FILTER) == RTC_TamperFilter_8Sample)) +/** + * @} + */ + +/** @defgroup RTC_Tamper_Sampling_Frequencies_Definitions + * @{ + */ +#define RTC_TamperSamplingFreq_RTCCLK_Div32768 ((uint32_t)0x00000000) /*!< Each of the tamper inputs are sampled + with a frequency = RTCCLK / 32768 */ +#define RTC_TamperSamplingFreq_RTCCLK_Div16384 ((uint32_t)0x00000100) /*!< Each of the tamper inputs are sampled + with a frequency = RTCCLK / 16384 */ +#define RTC_TamperSamplingFreq_RTCCLK_Div8192 ((uint32_t)0x00000200) /*!< Each of the tamper inputs are sampled + with a frequency = RTCCLK / 8192 */ +#define RTC_TamperSamplingFreq_RTCCLK_Div4096 ((uint32_t)0x00000300) /*!< Each of the tamper inputs are sampled + with a frequency = RTCCLK / 4096 */ +#define RTC_TamperSamplingFreq_RTCCLK_Div2048 ((uint32_t)0x00000400) /*!< Each of the tamper inputs are sampled + with a frequency = RTCCLK / 2048 */ +#define RTC_TamperSamplingFreq_RTCCLK_Div1024 ((uint32_t)0x00000500) /*!< Each of the tamper inputs are sampled + with a frequency = RTCCLK / 1024 */ +#define RTC_TamperSamplingFreq_RTCCLK_Div512 ((uint32_t)0x00000600) /*!< Each of the tamper inputs are sampled + with a frequency = RTCCLK / 512 */ +#define RTC_TamperSamplingFreq_RTCCLK_Div256 ((uint32_t)0x00000700) /*!< Each of the tamper inputs are sampled + with a frequency = RTCCLK / 256 */ +#define IS_RTC_TAMPER_SAMPLING_FREQ(FREQ) (((FREQ) ==RTC_TamperSamplingFreq_RTCCLK_Div32768) || \ + ((FREQ) ==RTC_TamperSamplingFreq_RTCCLK_Div16384) || \ + ((FREQ) ==RTC_TamperSamplingFreq_RTCCLK_Div8192) || \ + ((FREQ) ==RTC_TamperSamplingFreq_RTCCLK_Div4096) || \ + ((FREQ) ==RTC_TamperSamplingFreq_RTCCLK_Div2048) || \ + ((FREQ) ==RTC_TamperSamplingFreq_RTCCLK_Div1024) || \ + ((FREQ) ==RTC_TamperSamplingFreq_RTCCLK_Div512) || \ + ((FREQ) ==RTC_TamperSamplingFreq_RTCCLK_Div256)) + +/** + * @} + */ + + /** @defgroup RTC_Tamper_Pin_Precharge_Duration_Definitions + * @{ + */ +#define RTC_TamperPrechargeDuration_1RTCCLK ((uint32_t)0x00000000) /*!< Tamper pins are pre-charged before + sampling during 1 RTCCLK cycle */ +#define RTC_TamperPrechargeDuration_2RTCCLK ((uint32_t)0x00002000) /*!< Tamper pins are pre-charged before + sampling during 2 RTCCLK cycles */ +#define RTC_TamperPrechargeDuration_4RTCCLK ((uint32_t)0x00004000) /*!< Tamper pins are pre-charged before + sampling during 4 RTCCLK cycles */ +#define RTC_TamperPrechargeDuration_8RTCCLK ((uint32_t)0x00006000) /*!< Tamper pins are pre-charged before + sampling during 8 RTCCLK cycles */ + +#define IS_RTC_TAMPER_PRECHARGE_DURATION(DURATION) (((DURATION) == RTC_TamperPrechargeDuration_1RTCCLK) || \ + ((DURATION) == RTC_TamperPrechargeDuration_2RTCCLK) || \ + ((DURATION) == RTC_TamperPrechargeDuration_4RTCCLK) || \ + ((DURATION) == RTC_TamperPrechargeDuration_8RTCCLK)) +/** + * @} + */ + +/** @defgroup RTC_Tamper_Pins_Definitions + * @{ + */ +#define RTC_Tamper_1 RTC_TAFCR_TAMP1E /*!< Tamper detection enable for + input tamper 1 */ +#define RTC_Tamper_2 RTC_TAFCR_TAMP2E /*!< Tamper detection enable for + input tamper 2 */ +#define RTC_Tamper_3 RTC_TAFCR_TAMP3E /*!< Tamper detection enable for + input tamper 3, available only + for STM32F072 devices */ +#define IS_RTC_TAMPER(TAMPER) ((((TAMPER) & (uint32_t)0xFFFFFFD6) == 0x00) && ((TAMPER) != (uint32_t)RESET)) + +/** + * @} + */ + +/** @defgroup RTC_Output_Type_ALARM_OUT + * @{ + */ +#define RTC_OutputType_OpenDrain ((uint32_t)0x00000000) +#define RTC_OutputType_PushPull ((uint32_t)0x00040000) +#define IS_RTC_OUTPUT_TYPE(TYPE) (((TYPE) == RTC_OutputType_OpenDrain) || \ + ((TYPE) == RTC_OutputType_PushPull)) + +/** + * @} + */ + +/** @defgroup RTC_Add_1_Second_Parameter_Definitions + * @{ + */ +#define RTC_ShiftAdd1S_Reset ((uint32_t)0x00000000) +#define RTC_ShiftAdd1S_Set ((uint32_t)0x80000000) +#define IS_RTC_SHIFT_ADD1S(SEL) (((SEL) == RTC_ShiftAdd1S_Reset) || \ + ((SEL) == RTC_ShiftAdd1S_Set)) +/** + * @} + */ + +/** @defgroup RTC_Substract_Fraction_Of_Second_Value + * @{ + */ +#define IS_RTC_SHIFT_SUBFS(FS) ((FS) <= 0x00007FFF) + +/** + * @} + */ + +/** @defgroup RTC_Backup_Registers_Definitions + * @{ + */ + +#define RTC_BKP_DR0 ((uint32_t)0x00000000) +#define RTC_BKP_DR1 ((uint32_t)0x00000001) +#define RTC_BKP_DR2 ((uint32_t)0x00000002) +#define RTC_BKP_DR3 ((uint32_t)0x00000003) +#define RTC_BKP_DR4 ((uint32_t)0x00000004) +#define IS_RTC_BKP(BKP) (((BKP) == RTC_BKP_DR0) || \ + ((BKP) == RTC_BKP_DR1) || \ + ((BKP) == RTC_BKP_DR2) || \ + ((BKP) == RTC_BKP_DR3) || \ + ((BKP) == RTC_BKP_DR4)) +/** + * @} + */ + +/** @defgroup RTC_Input_parameter_format_definitions + * @{ + */ +#define RTC_Format_BIN ((uint32_t)0x000000000) +#define RTC_Format_BCD ((uint32_t)0x000000001) +#define IS_RTC_FORMAT(FORMAT) (((FORMAT) == RTC_Format_BIN) || ((FORMAT) == RTC_Format_BCD)) + +/** + * @} + */ + +/** @defgroup RTC_Flags_Definitions + * @{ + */ +#define RTC_FLAG_RECALPF RTC_ISR_RECALPF +#define RTC_FLAG_TAMP3F RTC_ISR_TAMP3F /*!< Only available for STM32F072 devices */ +#define RTC_FLAG_TAMP2F RTC_ISR_TAMP2F +#define RTC_FLAG_TAMP1F RTC_ISR_TAMP1F +#define RTC_FLAG_TSOVF RTC_ISR_TSOVF +#define RTC_FLAG_TSF RTC_ISR_TSF +#define RTC_FLAG_WUTF RTC_ISR_WUTF /*!< Only available for STM32F072 devices */ +#define RTC_FLAG_ALRAF RTC_ISR_ALRAF +#define RTC_FLAG_INITF RTC_ISR_INITF +#define RTC_FLAG_RSF RTC_ISR_RSF +#define RTC_FLAG_INITS RTC_ISR_INITS +#define RTC_FLAG_SHPF RTC_ISR_SHPF +#define RTC_FLAG_WUTWF RTC_ISR_WUTWF /*!< Only available for STM32F072 devices */ +#define RTC_FLAG_ALRAWF RTC_ISR_ALRAWF + +#define IS_RTC_GET_FLAG(FLAG) (((FLAG) == RTC_FLAG_TSOVF) || ((FLAG) == RTC_FLAG_TSF) || \ + ((FLAG) == RTC_FLAG_WUTF) || ((FLAG) == RTC_FLAG_ALRAWF) || \ + ((FLAG) == RTC_FLAG_ALRAF) || ((FLAG) == RTC_FLAG_INITF) || \ + ((FLAG) == RTC_FLAG_RSF) || ((FLAG) == RTC_FLAG_WUTWF) || \ + ((FLAG) == RTC_FLAG_TAMP1F) || ((FLAG) == RTC_FLAG_TAMP2F) || \ + ((FLAG) == RTC_FLAG_TAMP3F) || ((FLAG) == RTC_FLAG_RECALPF) || \ + ((FLAG) == RTC_FLAG_SHPF)) +#define IS_RTC_CLEAR_FLAG(FLAG) (((FLAG) != (uint32_t)RESET) && (((FLAG) & 0xFFFF02DF) == (uint32_t)RESET)) + +/** + * @} + */ + +/** @defgroup RTC_Interrupts_Definitions + * @{ + */ +#define RTC_IT_TS ((uint32_t)0x00008000) +#define RTC_IT_WUT ((uint32_t)0x00004000) /* Available only for STM32F072 devices */ +#define RTC_IT_ALRA ((uint32_t)0x00001000) +#define RTC_IT_TAMP ((uint32_t)0x00000004) /* Used only to Enable the Tamper Interrupt */ +#define RTC_IT_TAMP1 ((uint32_t)0x00020000) +#define RTC_IT_TAMP2 ((uint32_t)0x00040000) +#define RTC_IT_TAMP3 ((uint32_t)0x00080000) /* Available only for STM32F072 devices */ + +#define IS_RTC_CONFIG_IT(IT) (((IT) != (uint32_t)RESET) && (((IT) & 0xFFFF2FFB) == (uint32_t)RESET)) +#define IS_RTC_GET_IT(IT) (((IT) == RTC_IT_TS) || ((IT) == RTC_IT_ALRA) || \ + ((IT) == RTC_IT_TAMP1) || ((IT) == RTC_IT_WUT) || \ + ((IT) == RTC_IT_TAMP2) || ((IT) == RTC_IT_TAMP3)) + +#define IS_RTC_CLEAR_IT(IT) (((IT) != (uint32_t)RESET) && (((IT) & 0xFFF12FFF) == (uint32_t)RESET)) + +/** + * @} + */ + +/** + * @} + */ + + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ +/* Function used to set the RTC configuration to the default reset state *****/ +ErrorStatus RTC_DeInit(void); + + +/* Initialization and Configuration functions *********************************/ +ErrorStatus RTC_Init(RTC_InitTypeDef* RTC_InitStruct); +void RTC_StructInit(RTC_InitTypeDef* RTC_InitStruct); +void RTC_WriteProtectionCmd(FunctionalState NewState); +ErrorStatus RTC_EnterInitMode(void); +void RTC_ExitInitMode(void); +ErrorStatus RTC_WaitForSynchro(void); +ErrorStatus RTC_RefClockCmd(FunctionalState NewState); +void RTC_BypassShadowCmd(FunctionalState NewState); + +/* Time and Date configuration functions **************************************/ +ErrorStatus RTC_SetTime(uint32_t RTC_Format, RTC_TimeTypeDef* RTC_TimeStruct); +void RTC_TimeStructInit(RTC_TimeTypeDef* RTC_TimeStruct); +void RTC_GetTime(uint32_t RTC_Format, RTC_TimeTypeDef* RTC_TimeStruct); +uint32_t RTC_GetSubSecond(void); +ErrorStatus RTC_SetDate(uint32_t RTC_Format, RTC_DateTypeDef* RTC_DateStruct); +void RTC_DateStructInit(RTC_DateTypeDef* RTC_DateStruct); +void RTC_GetDate(uint32_t RTC_Format, RTC_DateTypeDef* RTC_DateStruct); + +/* Alarms (Alarm A) configuration functions **********************************/ +void RTC_SetAlarm(uint32_t RTC_Format, uint32_t RTC_Alarm, RTC_AlarmTypeDef* RTC_AlarmStruct); +void RTC_AlarmStructInit(RTC_AlarmTypeDef* RTC_AlarmStruct); +void RTC_GetAlarm(uint32_t RTC_Format, uint32_t RTC_Alarm, RTC_AlarmTypeDef* RTC_AlarmStruct); +ErrorStatus RTC_AlarmCmd(uint32_t RTC_Alarm, FunctionalState NewState); +void RTC_AlarmSubSecondConfig(uint32_t RTC_Alarm, uint32_t RTC_AlarmSubSecondValue, uint8_t RTC_AlarmSubSecondMask); +uint32_t RTC_GetAlarmSubSecond(uint32_t RTC_Alarm); + +/* WakeUp Timer configuration functions ***************************************/ +void RTC_WakeUpClockConfig(uint32_t RTC_WakeUpClock); /*!< available only for STM32F072 devices */ +void RTC_SetWakeUpCounter(uint32_t RTC_WakeUpCounter); /*!< available only for STM32F072 devices */ +uint32_t RTC_GetWakeUpCounter(void); /*!< available only for STM32F072 devices */ +ErrorStatus RTC_WakeUpCmd(FunctionalState NewState); /*!< available only for STM32F072 devices */ + +/* Daylight Saving configuration functions ************************************/ +void RTC_DayLightSavingConfig(uint32_t RTC_DayLightSaving, uint32_t RTC_StoreOperation); +uint32_t RTC_GetStoreOperation(void); + +/* Output pin Configuration function ******************************************/ +void RTC_OutputConfig(uint32_t RTC_Output, uint32_t RTC_OutputPolarity); + +/* Digital Calibration configuration functions ********************************/ +void RTC_CalibOutputCmd(FunctionalState NewState); +void RTC_CalibOutputConfig(uint32_t RTC_CalibOutput); +ErrorStatus RTC_SmoothCalibConfig(uint32_t RTC_SmoothCalibPeriod, + uint32_t RTC_SmoothCalibPlusPulses, + uint32_t RTC_SmouthCalibMinusPulsesValue); + +/* TimeStamp configuration functions ******************************************/ +void RTC_TimeStampCmd(uint32_t RTC_TimeStampEdge, FunctionalState NewState); +void RTC_GetTimeStamp(uint32_t RTC_Format, RTC_TimeTypeDef* RTC_StampTimeStruct, RTC_DateTypeDef* RTC_StampDateStruct); +uint32_t RTC_GetTimeStampSubSecond(void); + +/* Tampers configuration functions ********************************************/ +void RTC_TamperTriggerConfig(uint32_t RTC_Tamper, uint32_t RTC_TamperTrigger); +void RTC_TamperCmd(uint32_t RTC_Tamper, FunctionalState NewState); +void RTC_TamperFilterConfig(uint32_t RTC_TamperFilter); +void RTC_TamperSamplingFreqConfig(uint32_t RTC_TamperSamplingFreq); +void RTC_TamperPinsPrechargeDuration(uint32_t RTC_TamperPrechargeDuration); +void RTC_TimeStampOnTamperDetectionCmd(FunctionalState NewState); +void RTC_TamperPullUpCmd(FunctionalState NewState); + +/* Backup Data Registers configuration functions ******************************/ +void RTC_WriteBackupRegister(uint32_t RTC_BKP_DR, uint32_t Data); +uint32_t RTC_ReadBackupRegister(uint32_t RTC_BKP_DR); + +/* Output Type Config configuration functions *********************************/ +void RTC_OutputTypeConfig(uint32_t RTC_OutputType); + +/* RTC_Shift_control_synchonisation_functions *********************************/ +ErrorStatus RTC_SynchroShiftConfig(uint32_t RTC_ShiftAdd1S, uint32_t RTC_ShiftSubFS); + +/* Interrupts and flags management functions **********************************/ +void RTC_ITConfig(uint32_t RTC_IT, FunctionalState NewState); +FlagStatus RTC_GetFlagStatus(uint32_t RTC_FLAG); +void RTC_ClearFlag(uint32_t RTC_FLAG); +ITStatus RTC_GetITStatus(uint32_t RTC_IT); +void RTC_ClearITPendingBit(uint32_t RTC_IT); + +#ifdef __cplusplus +} +#endif + +#endif /*__STM32F0XX_RTC_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_spi.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_spi.h new file mode 100644 index 00000000..711d908c --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_spi.h @@ -0,0 +1,588 @@ +/** + ****************************************************************************** + * @file stm32f0xx_spi.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the SPI + * firmware library. + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_SPI_H +#define __STM32F0XX_SPI_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup SPI + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief SPI Init structure definition + */ + +typedef struct +{ + uint16_t SPI_Direction; /*!< Specifies the SPI unidirectional or bidirectional data mode. + This parameter can be a value of @ref SPI_data_direction */ + + uint16_t SPI_Mode; /*!< Specifies the SPI mode (Master/Slave). + This parameter can be a value of @ref SPI_mode */ + + uint16_t SPI_DataSize; /*!< Specifies the SPI data size. + This parameter can be a value of @ref SPI_data_size */ + + uint16_t SPI_CPOL; /*!< Specifies the serial clock steady state. + This parameter can be a value of @ref SPI_Clock_Polarity */ + + uint16_t SPI_CPHA; /*!< Specifies the clock active edge for the bit capture. + This parameter can be a value of @ref SPI_Clock_Phase */ + + uint16_t SPI_NSS; /*!< Specifies whether the NSS signal is managed by + hardware (NSS pin) or by software using the SSI bit. + This parameter can be a value of @ref SPI_Slave_Select_management */ + + uint16_t SPI_BaudRatePrescaler; /*!< Specifies the Baud Rate prescaler value which will be + used to configure the transmit and receive SCK clock. + This parameter can be a value of @ref SPI_BaudRate_Prescaler + @note The communication clock is derived from the master + clock. The slave clock does not need to be set. */ + + uint16_t SPI_FirstBit; /*!< Specifies whether data transfers start from MSB or LSB bit. + This parameter can be a value of @ref SPI_MSB_LSB_transmission */ + + uint16_t SPI_CRCPolynomial; /*!< Specifies the polynomial used for the CRC calculation. */ +}SPI_InitTypeDef; + + +/** + * @brief I2S Init structure definition + * @note These parameters are not available for STM32F030 devices. + */ + +typedef struct +{ + uint16_t I2S_Mode; /*!< Specifies the I2S operating mode. + This parameter can be a value of @ref SPI_I2S_Mode */ + + uint16_t I2S_Standard; /*!< Specifies the standard used for the I2S communication. + This parameter can be a value of @ref SPI_I2S_Standard */ + + uint16_t I2S_DataFormat; /*!< Specifies the data format for the I2S communication. + This parameter can be a value of @ref SPI_I2S_Data_Format */ + + uint16_t I2S_MCLKOutput; /*!< Specifies whether the I2S MCLK output is enabled or not. + This parameter can be a value of @ref SPI_I2S_MCLK_Output */ + + uint32_t I2S_AudioFreq; /*!< Specifies the frequency selected for the I2S communication. + This parameter can be a value of @ref SPI_I2S_Audio_Frequency */ + + uint16_t I2S_CPOL; /*!< Specifies the idle state of the I2S clock. + This parameter can be a value of @ref SPI_I2S_Clock_Polarity */ +}I2S_InitTypeDef; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup SPI_Exported_Constants + * @{ + */ + +#define IS_SPI_ALL_PERIPH(PERIPH) (((PERIPH) == SPI1) || \ + ((PERIPH) == SPI2)) + +#define IS_SPI_1_PERIPH(PERIPH) (((PERIPH) == SPI1)) + +/** @defgroup SPI_data_direction + * @{ + */ + +#define SPI_Direction_2Lines_FullDuplex ((uint16_t)0x0000) +#define SPI_Direction_2Lines_RxOnly ((uint16_t)0x0400) +#define SPI_Direction_1Line_Rx ((uint16_t)0x8000) +#define SPI_Direction_1Line_Tx ((uint16_t)0xC000) +#define IS_SPI_DIRECTION_MODE(MODE) (((MODE) == SPI_Direction_2Lines_FullDuplex) || \ + ((MODE) == SPI_Direction_2Lines_RxOnly) || \ + ((MODE) == SPI_Direction_1Line_Rx) || \ + ((MODE) == SPI_Direction_1Line_Tx)) +/** + * @} + */ + +/** @defgroup SPI_mode + * @{ + */ + +#define SPI_Mode_Master ((uint16_t)0x0104) +#define SPI_Mode_Slave ((uint16_t)0x0000) +#define IS_SPI_MODE(MODE) (((MODE) == SPI_Mode_Master) || \ + ((MODE) == SPI_Mode_Slave)) +/** + * @} + */ + +/** @defgroup SPI_data_size + * @{ + */ + +#define SPI_DataSize_4b ((uint16_t)0x0300) +#define SPI_DataSize_5b ((uint16_t)0x0400) +#define SPI_DataSize_6b ((uint16_t)0x0500) +#define SPI_DataSize_7b ((uint16_t)0x0600) +#define SPI_DataSize_8b ((uint16_t)0x0700) +#define SPI_DataSize_9b ((uint16_t)0x0800) +#define SPI_DataSize_10b ((uint16_t)0x0900) +#define SPI_DataSize_11b ((uint16_t)0x0A00) +#define SPI_DataSize_12b ((uint16_t)0x0B00) +#define SPI_DataSize_13b ((uint16_t)0x0C00) +#define SPI_DataSize_14b ((uint16_t)0x0D00) +#define SPI_DataSize_15b ((uint16_t)0x0E00) +#define SPI_DataSize_16b ((uint16_t)0x0F00) +#define IS_SPI_DATA_SIZE(SIZE) (((SIZE) == SPI_DataSize_4b) || \ + ((SIZE) == SPI_DataSize_5b) || \ + ((SIZE) == SPI_DataSize_6b) || \ + ((SIZE) == SPI_DataSize_7b) || \ + ((SIZE) == SPI_DataSize_8b) || \ + ((SIZE) == SPI_DataSize_9b) || \ + ((SIZE) == SPI_DataSize_10b) || \ + ((SIZE) == SPI_DataSize_11b) || \ + ((SIZE) == SPI_DataSize_12b) || \ + ((SIZE) == SPI_DataSize_13b) || \ + ((SIZE) == SPI_DataSize_14b) || \ + ((SIZE) == SPI_DataSize_15b) || \ + ((SIZE) == SPI_DataSize_16b)) +/** + * @} + */ + +/** @defgroup SPI_CRC_length + * @{ + */ + +#define SPI_CRCLength_8b ((uint16_t)0x0000) +#define SPI_CRCLength_16b SPI_CR1_CRCL +#define IS_SPI_CRC_LENGTH(LENGTH) (((LENGTH) == SPI_CRCLength_8b) || \ + ((LENGTH) == SPI_CRCLength_16b)) +/** + * @} + */ + +/** @defgroup SPI_Clock_Polarity + * @{ + */ + +#define SPI_CPOL_Low ((uint16_t)0x0000) +#define SPI_CPOL_High SPI_CR1_CPOL +#define IS_SPI_CPOL(CPOL) (((CPOL) == SPI_CPOL_Low) || \ + ((CPOL) == SPI_CPOL_High)) +/** + * @} + */ + +/** @defgroup SPI_Clock_Phase + * @{ + */ + +#define SPI_CPHA_1Edge ((uint16_t)0x0000) +#define SPI_CPHA_2Edge SPI_CR1_CPHA +#define IS_SPI_CPHA(CPHA) (((CPHA) == SPI_CPHA_1Edge) || \ + ((CPHA) == SPI_CPHA_2Edge)) +/** + * @} + */ + +/** @defgroup SPI_Slave_Select_management + * @{ + */ + +#define SPI_NSS_Soft SPI_CR1_SSM +#define SPI_NSS_Hard ((uint16_t)0x0000) +#define IS_SPI_NSS(NSS) (((NSS) == SPI_NSS_Soft) || \ + ((NSS) == SPI_NSS_Hard)) +/** + * @} + */ + +/** @defgroup SPI_BaudRate_Prescaler + * @{ + */ + +#define SPI_BaudRatePrescaler_2 ((uint16_t)0x0000) +#define SPI_BaudRatePrescaler_4 ((uint16_t)0x0008) +#define SPI_BaudRatePrescaler_8 ((uint16_t)0x0010) +#define SPI_BaudRatePrescaler_16 ((uint16_t)0x0018) +#define SPI_BaudRatePrescaler_32 ((uint16_t)0x0020) +#define SPI_BaudRatePrescaler_64 ((uint16_t)0x0028) +#define SPI_BaudRatePrescaler_128 ((uint16_t)0x0030) +#define SPI_BaudRatePrescaler_256 ((uint16_t)0x0038) +#define IS_SPI_BAUDRATE_PRESCALER(PRESCALER) (((PRESCALER) == SPI_BaudRatePrescaler_2) || \ + ((PRESCALER) == SPI_BaudRatePrescaler_4) || \ + ((PRESCALER) == SPI_BaudRatePrescaler_8) || \ + ((PRESCALER) == SPI_BaudRatePrescaler_16) || \ + ((PRESCALER) == SPI_BaudRatePrescaler_32) || \ + ((PRESCALER) == SPI_BaudRatePrescaler_64) || \ + ((PRESCALER) == SPI_BaudRatePrescaler_128) || \ + ((PRESCALER) == SPI_BaudRatePrescaler_256)) +/** + * @} + */ + +/** @defgroup SPI_MSB_LSB_transmission + * @{ + */ + +#define SPI_FirstBit_MSB ((uint16_t)0x0000) +#define SPI_FirstBit_LSB SPI_CR1_LSBFIRST +#define IS_SPI_FIRST_BIT(BIT) (((BIT) == SPI_FirstBit_MSB) || \ + ((BIT) == SPI_FirstBit_LSB)) +/** + * @} + */ + +/** @defgroup SPI_I2S_Mode + * @{ + */ + +#define I2S_Mode_SlaveTx ((uint16_t)0x0000) +#define I2S_Mode_SlaveRx ((uint16_t)0x0100) +#define I2S_Mode_MasterTx ((uint16_t)0x0200) +#define I2S_Mode_MasterRx ((uint16_t)0x0300) +#define IS_I2S_MODE(MODE) (((MODE) == I2S_Mode_SlaveTx) || \ + ((MODE) == I2S_Mode_SlaveRx) || \ + ((MODE) == I2S_Mode_MasterTx)|| \ + ((MODE) == I2S_Mode_MasterRx)) +/** + * @} + */ + +/** @defgroup SPI_I2S_Standard + * @{ + */ + +#define I2S_Standard_Phillips ((uint16_t)0x0000) +#define I2S_Standard_MSB ((uint16_t)0x0010) +#define I2S_Standard_LSB ((uint16_t)0x0020) +#define I2S_Standard_PCMShort ((uint16_t)0x0030) +#define I2S_Standard_PCMLong ((uint16_t)0x00B0) +#define IS_I2S_STANDARD(STANDARD) (((STANDARD) == I2S_Standard_Phillips) || \ + ((STANDARD) == I2S_Standard_MSB) || \ + ((STANDARD) == I2S_Standard_LSB) || \ + ((STANDARD) == I2S_Standard_PCMShort) || \ + ((STANDARD) == I2S_Standard_PCMLong)) +/** + * @} + */ + +/** @defgroup SPI_I2S_Data_Format + * @{ + */ + +#define I2S_DataFormat_16b ((uint16_t)0x0000) +#define I2S_DataFormat_16bextended ((uint16_t)0x0001) +#define I2S_DataFormat_24b ((uint16_t)0x0003) +#define I2S_DataFormat_32b ((uint16_t)0x0005) +#define IS_I2S_DATA_FORMAT(FORMAT) (((FORMAT) == I2S_DataFormat_16b) || \ + ((FORMAT) == I2S_DataFormat_16bextended) || \ + ((FORMAT) == I2S_DataFormat_24b) || \ + ((FORMAT) == I2S_DataFormat_32b)) +/** + * @} + */ + +/** @defgroup SPI_I2S_MCLK_Output + * @{ + */ + +#define I2S_MCLKOutput_Enable SPI_I2SPR_MCKOE +#define I2S_MCLKOutput_Disable ((uint16_t)0x0000) +#define IS_I2S_MCLK_OUTPUT(OUTPUT) (((OUTPUT) == I2S_MCLKOutput_Enable) || \ + ((OUTPUT) == I2S_MCLKOutput_Disable)) +/** + * @} + */ + +/** @defgroup SPI_I2S_Audio_Frequency + * @{ + */ + +#define I2S_AudioFreq_192k ((uint32_t)192000) +#define I2S_AudioFreq_96k ((uint32_t)96000) +#define I2S_AudioFreq_48k ((uint32_t)48000) +#define I2S_AudioFreq_44k ((uint32_t)44100) +#define I2S_AudioFreq_32k ((uint32_t)32000) +#define I2S_AudioFreq_22k ((uint32_t)22050) +#define I2S_AudioFreq_16k ((uint32_t)16000) +#define I2S_AudioFreq_11k ((uint32_t)11025) +#define I2S_AudioFreq_8k ((uint32_t)8000) +#define I2S_AudioFreq_Default ((uint32_t)2) + +#define IS_I2S_AUDIO_FREQ(FREQ) ((((FREQ) >= I2S_AudioFreq_8k) && \ + ((FREQ) <= I2S_AudioFreq_192k)) || \ + ((FREQ) == I2S_AudioFreq_Default)) +/** + * @} + */ + +/** @defgroup SPI_I2S_Clock_Polarity + * @{ + */ + +#define I2S_CPOL_Low ((uint16_t)0x0000) +#define I2S_CPOL_High SPI_I2SCFGR_CKPOL +#define IS_I2S_CPOL(CPOL) (((CPOL) == I2S_CPOL_Low) || \ + ((CPOL) == I2S_CPOL_High)) +/** + * @} + */ + +/** @defgroup SPI_FIFO_reception_threshold + * @{ + */ + +#define SPI_RxFIFOThreshold_HF ((uint16_t)0x0000) +#define SPI_RxFIFOThreshold_QF SPI_CR2_FRXTH +#define IS_SPI_RX_FIFO_THRESHOLD(THRESHOLD) (((THRESHOLD) == SPI_RxFIFOThreshold_HF) || \ + ((THRESHOLD) == SPI_RxFIFOThreshold_QF)) +/** + * @} + */ + +/** @defgroup SPI_I2S_DMA_transfer_requests + * @{ + */ + +#define SPI_I2S_DMAReq_Tx SPI_CR2_TXDMAEN +#define SPI_I2S_DMAReq_Rx SPI_CR2_RXDMAEN +#define IS_SPI_I2S_DMA_REQ(REQ) ((((REQ) & (uint16_t)0xFFFC) == 0x00) && ((REQ) != 0x00)) +/** + * @} + */ + +/** @defgroup SPI_last_DMA_transfers + * @{ + */ + +#define SPI_LastDMATransfer_TxEvenRxEven ((uint16_t)0x0000) +#define SPI_LastDMATransfer_TxOddRxEven ((uint16_t)0x4000) +#define SPI_LastDMATransfer_TxEvenRxOdd ((uint16_t)0x2000) +#define SPI_LastDMATransfer_TxOddRxOdd ((uint16_t)0x6000) +#define IS_SPI_LAST_DMA_TRANSFER(TRANSFER) (((TRANSFER) == SPI_LastDMATransfer_TxEvenRxEven) || \ + ((TRANSFER) == SPI_LastDMATransfer_TxOddRxEven) || \ + ((TRANSFER) == SPI_LastDMATransfer_TxEvenRxOdd) || \ + ((TRANSFER) == SPI_LastDMATransfer_TxOddRxOdd)) +/** + * @} + */ +/** @defgroup SPI_NSS_internal_software_management + * @{ + */ + +#define SPI_NSSInternalSoft_Set SPI_CR1_SSI +#define SPI_NSSInternalSoft_Reset ((uint16_t)0xFEFF) +#define IS_SPI_NSS_INTERNAL(INTERNAL) (((INTERNAL) == SPI_NSSInternalSoft_Set) || \ + ((INTERNAL) == SPI_NSSInternalSoft_Reset)) +/** + * @} + */ + +/** @defgroup SPI_CRC_Transmit_Receive + * @{ + */ + +#define SPI_CRC_Tx ((uint8_t)0x00) +#define SPI_CRC_Rx ((uint8_t)0x01) +#define IS_SPI_CRC(CRC) (((CRC) == SPI_CRC_Tx) || ((CRC) == SPI_CRC_Rx)) +/** + * @} + */ + +/** @defgroup SPI_direction_transmit_receive + * @{ + */ + +#define SPI_Direction_Rx ((uint16_t)0xBFFF) +#define SPI_Direction_Tx ((uint16_t)0x4000) +#define IS_SPI_DIRECTION(DIRECTION) (((DIRECTION) == SPI_Direction_Rx) || \ + ((DIRECTION) == SPI_Direction_Tx)) +/** + * @} + */ + +/** @defgroup SPI_I2S_interrupts_definition + * @{ + */ + +#define SPI_I2S_IT_TXE ((uint8_t)0x71) +#define SPI_I2S_IT_RXNE ((uint8_t)0x60) +#define SPI_I2S_IT_ERR ((uint8_t)0x50) + +#define IS_SPI_I2S_CONFIG_IT(IT) (((IT) == SPI_I2S_IT_TXE) || \ + ((IT) == SPI_I2S_IT_RXNE) || \ + ((IT) == SPI_I2S_IT_ERR)) + +#define I2S_IT_UDR ((uint8_t)0x53) +#define SPI_IT_MODF ((uint8_t)0x55) +#define SPI_I2S_IT_OVR ((uint8_t)0x56) +#define SPI_I2S_IT_FRE ((uint8_t)0x58) + +#define IS_SPI_I2S_GET_IT(IT) (((IT) == SPI_I2S_IT_RXNE) || ((IT) == SPI_I2S_IT_TXE) || \ + ((IT) == SPI_I2S_IT_OVR) || ((IT) == SPI_IT_MODF) || \ + ((IT) == SPI_I2S_IT_FRE)|| ((IT) == I2S_IT_UDR)) +/** + * @} + */ + + +/** @defgroup SPI_transmission_fifo_status_level + * @{ + */ + +#define SPI_TransmissionFIFOStatus_Empty ((uint16_t)0x0000) +#define SPI_TransmissionFIFOStatus_1QuarterFull ((uint16_t)0x0800) +#define SPI_TransmissionFIFOStatus_HalfFull ((uint16_t)0x1000) +#define SPI_TransmissionFIFOStatus_Full ((uint16_t)0x1800) + +/** + * @} + */ + +/** @defgroup SPI_reception_fifo_status_level + * @{ + */ +#define SPI_ReceptionFIFOStatus_Empty ((uint16_t)0x0000) +#define SPI_ReceptionFIFOStatus_1QuarterFull ((uint16_t)0x0200) +#define SPI_ReceptionFIFOStatus_HalfFull ((uint16_t)0x0400) +#define SPI_ReceptionFIFOStatus_Full ((uint16_t)0x0600) + +/** + * @} + */ + + +/** @defgroup SPI_I2S_flags_definition + * @{ + */ + +#define SPI_I2S_FLAG_RXNE SPI_SR_RXNE +#define SPI_I2S_FLAG_TXE SPI_SR_TXE +#define I2S_FLAG_CHSIDE SPI_SR_CHSIDE +#define I2S_FLAG_UDR SPI_SR_UDR +#define SPI_FLAG_CRCERR SPI_SR_CRCERR +#define SPI_FLAG_MODF SPI_SR_MODF +#define SPI_I2S_FLAG_OVR SPI_SR_OVR +#define SPI_I2S_FLAG_BSY SPI_SR_BSY +#define SPI_I2S_FLAG_FRE SPI_SR_FRE + + + +#define IS_SPI_CLEAR_FLAG(FLAG) (((FLAG) == SPI_FLAG_CRCERR)) +#define IS_SPI_I2S_GET_FLAG(FLAG) (((FLAG) == SPI_I2S_FLAG_BSY) || ((FLAG) == SPI_I2S_FLAG_OVR) || \ + ((FLAG) == SPI_FLAG_MODF) || ((FLAG) == SPI_FLAG_CRCERR) || \ + ((FLAG) == SPI_I2S_FLAG_TXE) || ((FLAG) == SPI_I2S_FLAG_RXNE)|| \ + ((FLAG) == SPI_I2S_FLAG_FRE)|| ((FLAG) == I2S_FLAG_CHSIDE)|| \ + ((FLAG) == I2S_FLAG_UDR)) +/** + * @} + */ + +/** @defgroup SPI_CRC_polynomial + * @{ + */ + +#define IS_SPI_CRC_POLYNOMIAL(POLYNOMIAL) ((POLYNOMIAL) >= 0x1) +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Initialization and Configuration functions *********************************/ +void SPI_I2S_DeInit(SPI_TypeDef* SPIx); +void SPI_Init(SPI_TypeDef* SPIx, SPI_InitTypeDef* SPI_InitStruct); +void I2S_Init(SPI_TypeDef* SPIx, I2S_InitTypeDef* I2S_InitStruct); /*!< Not applicable for STM32F030 devices */ +void SPI_StructInit(SPI_InitTypeDef* SPI_InitStruct); +void I2S_StructInit(I2S_InitTypeDef* I2S_InitStruct); /*!< Not applicable for STM32F030 devices */ +void SPI_TIModeCmd(SPI_TypeDef* SPIx, FunctionalState NewState); +void SPI_NSSPulseModeCmd(SPI_TypeDef* SPIx, FunctionalState NewState); +void SPI_Cmd(SPI_TypeDef* SPIx, FunctionalState NewState); +void I2S_Cmd(SPI_TypeDef* SPIx, FunctionalState NewState); /*!< Not applicable for STM32F030 devices */ +void SPI_DataSizeConfig(SPI_TypeDef* SPIx, uint16_t SPI_DataSize); +void SPI_RxFIFOThresholdConfig(SPI_TypeDef* SPIx, uint16_t SPI_RxFIFOThreshold); +void SPI_BiDirectionalLineConfig(SPI_TypeDef* SPIx, uint16_t SPI_Direction); +void SPI_NSSInternalSoftwareConfig(SPI_TypeDef* SPIx, uint16_t SPI_NSSInternalSoft); +void SPI_SSOutputCmd(SPI_TypeDef* SPIx, FunctionalState NewState); + +/* Data transfers functions ***************************************************/ +void SPI_SendData8(SPI_TypeDef* SPIx, uint8_t Data); +void SPI_I2S_SendData16(SPI_TypeDef* SPIx, uint16_t Data); +uint8_t SPI_ReceiveData8(SPI_TypeDef* SPIx); +uint16_t SPI_I2S_ReceiveData16(SPI_TypeDef* SPIx); + +/* Hardware CRC Calculation functions *****************************************/ +void SPI_CRCLengthConfig(SPI_TypeDef* SPIx, uint16_t SPI_CRCLength); +void SPI_CalculateCRC(SPI_TypeDef* SPIx, FunctionalState NewState); +void SPI_TransmitCRC(SPI_TypeDef* SPIx); +uint16_t SPI_GetCRC(SPI_TypeDef* SPIx, uint8_t SPI_CRC); +uint16_t SPI_GetCRCPolynomial(SPI_TypeDef* SPIx); + +/* DMA transfers management functions *****************************************/ +void SPI_I2S_DMACmd(SPI_TypeDef* SPIx, uint16_t SPI_I2S_DMAReq, FunctionalState NewState); +void SPI_LastDMATransferCmd(SPI_TypeDef* SPIx, uint16_t SPI_LastDMATransfer); + +/* Interrupts and flags management functions **********************************/ +void SPI_I2S_ITConfig(SPI_TypeDef* SPIx, uint8_t SPI_I2S_IT, FunctionalState NewState); +uint16_t SPI_GetTransmissionFIFOStatus(SPI_TypeDef* SPIx); +uint16_t SPI_GetReceptionFIFOStatus(SPI_TypeDef* SPIx); +FlagStatus SPI_I2S_GetFlagStatus(SPI_TypeDef* SPIx, uint16_t SPI_I2S_FLAG); +void SPI_I2S_ClearFlag(SPI_TypeDef* SPIx, uint16_t SPI_I2S_FLAG); +ITStatus SPI_I2S_GetITStatus(SPI_TypeDef* SPIx, uint8_t SPI_I2S_IT); + +#ifdef __cplusplus +} +#endif + +#endif /*__STM32F0XX_SPI_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_syscfg.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_syscfg.h new file mode 100644 index 00000000..86560377 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_syscfg.h @@ -0,0 +1,459 @@ +/** + ****************************************************************************** + * @file stm32f0xx_syscfg.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the SYSCFG firmware + * library. + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/*!< Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_SYSCFG_H +#define __STM32F0XX_SYSCFG_H + +#ifdef __cplusplus + extern "C" { +#endif + +/*!< Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup SYSCFG + * @{ + */ +/* Exported types ------------------------------------------------------------*/ +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup SYSCFG_Exported_Constants + * @{ + */ + +/** @defgroup SYSCFG_EXTI_Port_Sources + * @{ + */ +#define EXTI_PortSourceGPIOA ((uint8_t)0x00) +#define EXTI_PortSourceGPIOB ((uint8_t)0x01) +#define EXTI_PortSourceGPIOC ((uint8_t)0x02) +#define EXTI_PortSourceGPIOD ((uint8_t)0x03) /*!< not available for STM32F031 devices */ +#define EXTI_PortSourceGPIOE ((uint8_t)0x04) /*!< only available for STM32F072 devices */ +#define EXTI_PortSourceGPIOF ((uint8_t)0x05) + +#define IS_EXTI_PORT_SOURCE(PORTSOURCE) (((PORTSOURCE) == EXTI_PortSourceGPIOA) || \ + ((PORTSOURCE) == EXTI_PortSourceGPIOB) || \ + ((PORTSOURCE) == EXTI_PortSourceGPIOC) || \ + ((PORTSOURCE) == EXTI_PortSourceGPIOD) || \ + ((PORTSOURCE) == EXTI_PortSourceGPIOE) || \ + ((PORTSOURCE) == EXTI_PortSourceGPIOF)) +/** + * @} + */ + +/** @defgroup SYSCFG_EXTI_Pin_sources + * @{ + */ +#define EXTI_PinSource0 ((uint8_t)0x00) +#define EXTI_PinSource1 ((uint8_t)0x01) +#define EXTI_PinSource2 ((uint8_t)0x02) +#define EXTI_PinSource3 ((uint8_t)0x03) +#define EXTI_PinSource4 ((uint8_t)0x04) +#define EXTI_PinSource5 ((uint8_t)0x05) +#define EXTI_PinSource6 ((uint8_t)0x06) +#define EXTI_PinSource7 ((uint8_t)0x07) +#define EXTI_PinSource8 ((uint8_t)0x08) +#define EXTI_PinSource9 ((uint8_t)0x09) +#define EXTI_PinSource10 ((uint8_t)0x0A) +#define EXTI_PinSource11 ((uint8_t)0x0B) +#define EXTI_PinSource12 ((uint8_t)0x0C) +#define EXTI_PinSource13 ((uint8_t)0x0D) +#define EXTI_PinSource14 ((uint8_t)0x0E) +#define EXTI_PinSource15 ((uint8_t)0x0F) + +#define IS_EXTI_PIN_SOURCE(PINSOURCE) (((PINSOURCE) == EXTI_PinSource0) || \ + ((PINSOURCE) == EXTI_PinSource1) || \ + ((PINSOURCE) == EXTI_PinSource2) || \ + ((PINSOURCE) == EXTI_PinSource3) || \ + ((PINSOURCE) == EXTI_PinSource4) || \ + ((PINSOURCE) == EXTI_PinSource5) || \ + ((PINSOURCE) == EXTI_PinSource6) || \ + ((PINSOURCE) == EXTI_PinSource7) || \ + ((PINSOURCE) == EXTI_PinSource8) || \ + ((PINSOURCE) == EXTI_PinSource9) || \ + ((PINSOURCE) == EXTI_PinSource10) || \ + ((PINSOURCE) == EXTI_PinSource11) || \ + ((PINSOURCE) == EXTI_PinSource12) || \ + ((PINSOURCE) == EXTI_PinSource13) || \ + ((PINSOURCE) == EXTI_PinSource14) || \ + ((PINSOURCE) == EXTI_PinSource15)) +/** + * @} + */ + +/** @defgroup SYSCFG_Memory_Remap_Config + * @{ + */ +#define SYSCFG_MemoryRemap_Flash ((uint8_t)0x00) +#define SYSCFG_MemoryRemap_SystemMemory ((uint8_t)0x01) +#define SYSCFG_MemoryRemap_SRAM ((uint8_t)0x03) + + +#define IS_SYSCFG_MEMORY_REMAP(REMAP) (((REMAP) == SYSCFG_MemoryRemap_Flash) || \ + ((REMAP) == SYSCFG_MemoryRemap_SystemMemory) || \ + ((REMAP) == SYSCFG_MemoryRemap_SRAM)) + +/** + * @} + */ + +/** @defgroup SYSCFG_DMA_Remap_Config + * @{ + */ +#define SYSCFG_DMARemap_TIM3 SYSCFG_CFGR1_TIM3_DMA_RMP /* Remap TIM3 DMA requests from channel4 to channel6, + available only for STM32F072 devices */ +#define SYSCFG_DMARemap_TIM2 SYSCFG_CFGR1_TIM2_DMA_RMP /* Remap TIM2 DMA requests from channel3/4 to channel7, + available only for STM32F072 devices */ +#define SYSCFG_DMARemap_TIM1 SYSCFG_CFGR1_TIM1_DMA_RMP /* Remap TIM1 DMA requests from channel2/3/4 to channel6, + available only for STM32F072 devices */ +#define SYSCFG_DMARemap_I2C1 SYSCFG_CFGR1_I2C1_DMA_RMP /* Remap I2C1 DMA requests from channel3/2 to channel7/6, + available only for STM32F072 devices */ +#define SYSCFG_DMARemap_USART3 SYSCFG_CFGR1_USART3_DMA_RMP /* Remap USART3 DMA requests from channel6/7 to channel3/2, + available only for STM32F072 devices */ +#define SYSCFG_DMARemap_USART2 SYSCFG_CFGR1_USART2_DMA_RMP /* Remap USART2 DMA requests from channel4/5 to channel6/7, + available only for STM32F072 devices */ +#define SYSCFG_DMARemap_SPI2 SYSCFG_CFGR1_SPI2_DMA_RMP /* Remap SPI2 DMA requests from channel4/5 to channel6/7, + available only for STM32F072 devices */ +#define SYSCFG_DMARemap_TIM17_2 SYSCFG_CFGR1_TIM17_DMA_RMP2 /* Remap TIM17 DMA requests from channel1/2 to channel7, + available only for STM32F072 devices */ +#define SYSCFG_DMARemap_TIM16_2 SYSCFG_CFGR1_TIM16_DMA_RMP2 /* Remap TIM16 DMA requests from channel3/4 to channel6, + available only for STM32F072 devices */ +#define SYSCFG_DMARemap_TIM17 SYSCFG_CFGR1_TIM17_DMA_RMP /* Remap TIM17 DMA requests from channel1 to channel2 */ +#define SYSCFG_DMARemap_TIM16 SYSCFG_CFGR1_TIM16_DMA_RMP /* Remap TIM16 DMA requests from channel3 to channel4 */ +#define SYSCFG_DMARemap_USART1Rx SYSCFG_CFGR1_USART1RX_DMA_RMP /* Remap USART1 Rx DMA requests from channel3 to channel5 */ +#define SYSCFG_DMARemap_USART1Tx SYSCFG_CFGR1_USART1TX_DMA_RMP /* Remap USART1 Tx DMA requests from channel2 to channel4 */ +#define SYSCFG_DMARemap_ADC1 SYSCFG_CFGR1_ADC_DMA_RMP /* Remap ADC1 DMA requests from channel1 to channel2 */ + +#define IS_SYSCFG_DMA_REMAP(REMAP) (((REMAP) == SYSCFG_DMARemap_TIM17) || \ + ((REMAP) == SYSCFG_DMARemap_TIM16) || \ + ((REMAP) == SYSCFG_DMARemap_USART1Rx) || \ + ((REMAP) == SYSCFG_DMARemap_USART1Tx) || \ + ((REMAP) == SYSCFG_CFGR1_TIM3_DMA_RMP) || \ + ((REMAP) == SYSCFG_CFGR1_TIM2_DMA_RMP) || \ + ((REMAP) == SYSCFG_CFGR1_TIM1_DMA_RMP) || \ + ((REMAP) == SYSCFG_CFGR1_I2C1_DMA_RMP) || \ + ((REMAP) == SYSCFG_CFGR1_USART3_DMA_RMP) || \ + ((REMAP) == SYSCFG_CFGR1_USART2_DMA_RMP) || \ + ((REMAP) == SYSCFG_CFGR1_SPI2_DMA_RMP) || \ + ((REMAP) == SYSCFG_CFGR1_TIM17_DMA_RMP2) || \ + ((REMAP) == SYSCFG_CFGR1_TIM16_DMA_RMP2) || \ + ((REMAP) == SYSCFG_DMARemap_ADC1)) + +/** + * @} + */ + +/** @defgroup SYSCFG_I2C_FastModePlus_Config + * @{ + */ +#define SYSCFG_I2CFastModePlus_PB6 SYSCFG_CFGR1_I2C_FMP_PB6 /* Enable Fast Mode Plus on PB6 */ +#define SYSCFG_I2CFastModePlus_PB7 SYSCFG_CFGR1_I2C_FMP_PB7 /* Enable Fast Mode Plus on PB7 */ +#define SYSCFG_I2CFastModePlus_PB8 SYSCFG_CFGR1_I2C_FMP_PB8 /* Enable Fast Mode Plus on PB8 */ +#define SYSCFG_I2CFastModePlus_PB9 SYSCFG_CFGR1_I2C_FMP_PB9 /* Enable Fast Mode Plus on PB9 */ +#define SYSCFG_I2CFastModePlus_I2C1 SYSCFG_CFGR1_I2C_FMP_I2C1 /* Enable Fast Mode Plus on PB10, PB11, PF6 and PF7(only for STM32F0031 and STM32F030 devices) */ +#define SYSCFG_I2CFastModePlus_I2C2 SYSCFG_CFGR1_I2C_FMP_I2C2 /* Enable Fast Mode Plus on I2C2 pins, available only for STM32F072 devices */ +#define SYSCFG_I2CFastModePlus_PA9 SYSCFG_CFGR1_I2C_FMP_PA9 /* Enable Fast Mode Plus on PA9 (only for STM32F031 and STM32F030 devices) */ +#define SYSCFG_I2CFastModePlus_PA10 SYSCFG_CFGR1_I2C_FMP_PA10/* Enable Fast Mode Plus on PA10(only for STM32F031 and STM32F030 devices) */ + +#define IS_SYSCFG_I2C_FMP(PIN) (((PIN) == SYSCFG_I2CFastModePlus_PB6) || \ + ((PIN) == SYSCFG_I2CFastModePlus_PB7) || \ + ((PIN) == SYSCFG_I2CFastModePlus_PB8) || \ + ((PIN) == SYSCFG_I2CFastModePlus_PB9) || \ + ((PIN) == SYSCFG_I2CFastModePlus_I2C1) || \ + ((PIN) == SYSCFG_I2CFastModePlus_I2C2) || \ + ((PIN) == SYSCFG_I2CFastModePlus_PA9) || \ + ((PIN) == SYSCFG_I2CFastModePlus_PA10)) + + +/** + * @} + */ + +/** @defgroup SYSCFG_Lock_Config + * @{ + */ +#define SYSCFG_Break_PVD SYSCFG_CFGR2_PVD_LOCK /*!< Connects the PVD event to the Break Input of TIM1, not available for STM32F030 devices */ +#define SYSCFG_Break_SRAMParity SYSCFG_CFGR2_SRAM_PARITY_LOCK /*!< Connects the SRAM_PARITY error signal to the Break Input of TIM1 */ +#define SYSCFG_Break_Lockup SYSCFG_CFGR2_LOCKUP_LOCK /*!< Connects Lockup output of CortexM0 to the break input of TIM1 */ + +#define IS_SYSCFG_LOCK_CONFIG(CONFIG) (((CONFIG) == SYSCFG_Break_PVD) || \ + ((CONFIG) == SYSCFG_Break_SRAMParity) || \ + ((CONFIG) == SYSCFG_Break_Lockup)) + +/** + * @} + */ + +/** @defgroup SYSCFG_flags_definition + * @{ + */ + +#define SYSCFG_FLAG_PE SYSCFG_CFGR2_SRAM_PE + +#define IS_SYSCFG_FLAG(FLAG) (((FLAG) == SYSCFG_FLAG_PE)) + +/** + * @} + */ + +/** @defgroup SYSCFG_ISR_WRAPPER + * @{ + */ +#define SYSCFG_ITLINE0 ((uint32_t) 0x00000000) +#define SYSCFG_ITLINE1 ((uint32_t) 0x00000001) +#define SYSCFG_ITLINE2 ((uint32_t) 0x00000002) +#define SYSCFG_ITLINE3 ((uint32_t) 0x00000003) +#define SYSCFG_ITLINE4 ((uint32_t) 0x00000004) +#define SYSCFG_ITLINE5 ((uint32_t) 0x00000005) +#define SYSCFG_ITLINE6 ((uint32_t) 0x00000006) +#define SYSCFG_ITLINE7 ((uint32_t) 0x00000007) +#define SYSCFG_ITLINE8 ((uint32_t) 0x00000008) +#define SYSCFG_ITLINE9 ((uint32_t) 0x00000009) +#define SYSCFG_ITLINE10 ((uint32_t) 0x0000000A) +#define SYSCFG_ITLINE11 ((uint32_t) 0x0000000B) +#define SYSCFG_ITLINE12 ((uint32_t) 0x0000000C) +#define SYSCFG_ITLINE13 ((uint32_t) 0x0000000D) +#define SYSCFG_ITLINE14 ((uint32_t) 0x0000000E) +#define SYSCFG_ITLINE15 ((uint32_t) 0x0000000F) +#define SYSCFG_ITLINE16 ((uint32_t) 0x00000010) +#define SYSCFG_ITLINE17 ((uint32_t) 0x00000011) +#define SYSCFG_ITLINE18 ((uint32_t) 0x00000012) +#define SYSCFG_ITLINE19 ((uint32_t) 0x00000013) +#define SYSCFG_ITLINE20 ((uint32_t) 0x00000014) +#define SYSCFG_ITLINE21 ((uint32_t) 0x00000015) +#define SYSCFG_ITLINE22 ((uint32_t) 0x00000016) +#define SYSCFG_ITLINE23 ((uint32_t) 0x00000017) +#define SYSCFG_ITLINE24 ((uint32_t) 0x00000018) +#define SYSCFG_ITLINE25 ((uint32_t) 0x00000019) +#define SYSCFG_ITLINE26 ((uint32_t) 0x0000001A) +#define SYSCFG_ITLINE27 ((uint32_t) 0x0000001B) +#define SYSCFG_ITLINE28 ((uint32_t) 0x0000001C) +#define SYSCFG_ITLINE29 ((uint32_t) 0x0000001D) +#define SYSCFG_ITLINE30 ((uint32_t) 0x0000001E) +#define SYSCFG_ITLINE31 ((uint32_t) 0x0000001F) + +#define ITLINE_EWDG ((uint32_t) ((SYSCFG_ITLINE0 << 0x18) | SYSCFG_ITLINE0_SR_EWDG)) /* EWDG Interrupt */ +#define ITLINE_PVDOUT ((uint32_t) ((SYSCFG_ITLINE1 << 0x18) | SYSCFG_ITLINE1_SR_PVDOUT)) /* Power voltage detection Interrupt */ +#define ITLINE_VDDIO2 ((uint32_t) ((SYSCFG_ITLINE1 << 0x18) | SYSCFG_ITLINE1_SR_VDDIO2)) /* VDDIO2 Interrupt */ +#define ITLINE_RTC_WAKEUP ((uint32_t) ((SYSCFG_ITLINE2 << 0x18) | SYSCFG_ITLINE2_SR_RTC_WAKEUP)) /* RTC WAKEUP -> exti[20] Interrupt */ +#define ITLINE_RTC_TSTAMP ((uint32_t) ((SYSCFG_ITLINE2 << 0x18) | SYSCFG_ITLINE2_SR_RTC_TSTAMP)) /* RTC Time Stamp -> exti[19] interrupt */ +#define ITLINE_RTC_ALRA ((uint32_t) ((SYSCFG_ITLINE2 << 0x18) | SYSCFG_ITLINE2_SR_RTC_ALRA)) /* RTC Alarm -> exti[17] interrupt */ +#define ITLINE_FLASH_ITF ((uint32_t) ((SYSCFG_ITLINE3 << 0x18) | SYSCFG_ITLINE3_SR_FLASH_ITF)) /* Flash ITF Interrupt */ +#define ITLINE_CRS ((uint32_t) ((SYSCFG_ITLINE4 << 0x18) | SYSCFG_ITLINE4_SR_CRS)) /* CRS Interrupt */ +#define ITLINE_CLK_CTRL ((uint32_t) ((SYSCFG_ITLINE4 << 0x18) | SYSCFG_ITLINE4_SR_CLK_CTRL)) /* CLK Control Interrupt */ +#define ITLINE_EXTI0 ((uint32_t) ((SYSCFG_ITLINE5 << 0x18) | SYSCFG_ITLINE5_SR_EXTI0)) /* External Interrupt 0 */ +#define ITLINE_EXTI1 ((uint32_t) ((SYSCFG_ITLINE5 << 0x18) | SYSCFG_ITLINE5_SR_EXTI1)) /* External Interrupt 1 */ +#define ITLINE_EXTI2 ((uint32_t) ((SYSCFG_ITLINE6 << 0x18) | SYSCFG_ITLINE6_SR_EXTI2)) /* External Interrupt 2 */ +#define ITLINE_EXTI3 ((uint32_t) ((SYSCFG_ITLINE6 << 0x18) | SYSCFG_ITLINE6_SR_EXTI3)) /* External Interrupt 3 */ +#define ITLINE_EXTI4 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI4)) /* EXTI4 Interrupt */ +#define ITLINE_EXTI5 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI5)) /* EXTI5 Interrupt */ +#define ITLINE_EXTI6 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI6)) /* EXTI6 Interrupt */ +#define ITLINE_EXTI7 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI7)) /* EXTI7 Interrupt */ +#define ITLINE_EXTI8 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI8)) /* EXTI8 Interrupt */ +#define ITLINE_EXTI9 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI9)) /* EXTI9 Interrupt */ +#define ITLINE_EXTI10 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI10)) /* EXTI10 Interrupt */ +#define ITLINE_EXTI11 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI11)) /* EXTI11 Interrupt */ +#define ITLINE_EXTI12 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI12)) /* EXTI12 Interrupt */ +#define ITLINE_EXTI13 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI13)) /* EXTI13 Interrupt */ +#define ITLINE_EXTI14 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI14)) /* EXTI14 Interrupt */ +#define ITLINE_EXTI15 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI15)) /* EXTI15 Interrupt */ +#define ITLINE_TSC_EOA ((uint32_t) ((SYSCFG_ITLINE8 << 0x18) | SYSCFG_ITLINE8_SR_TSC_EOA)) /* Touch control EOA Interrupt */ +#define ITLINE_TSC_MCE ((uint32_t) ((SYSCFG_ITLINE8 << 0x18) | SYSCFG_ITLINE8_SR_TSC_MCE)) /* Touch control MCE Interrupt */ +#define ITLINE_DMA1_CH1 ((uint32_t) ((SYSCFG_ITLINE9 << 0x18) | SYSCFG_ITLINE9_SR_DMA1_CH1)) /* DMA1 Channel 1 Interrupt */ +#define ITLINE_DMA1_CH2 ((uint32_t) ((SYSCFG_ITLINE10 << 0x18) | SYSCFG_ITLINE10_SR_DMA1_CH2)) /* DMA1 Channel 2 Interrupt */ +#define ITLINE_DMA1_CH3 ((uint32_t) ((SYSCFG_ITLINE10 << 0x18) | SYSCFG_ITLINE10_SR_DMA1_CH3)) /* DMA1 Channel 3 Interrupt */ +#define ITLINE_DMA2_CH1 ((uint32_t) ((SYSCFG_ITLINE10 << 0x18) | SYSCFG_ITLINE10_SR_DMA2_CH1)) /* DMA2 Channel 1 Interrupt */ +#define ITLINE_DMA2_CH2 ((uint32_t) ((SYSCFG_ITLINE10 << 0x18) | SYSCFG_ITLINE10_SR_DMA2_CH2)) /* DMA2 Channel 2 Interrupt */ +#define ITLINE_DMA1_CH4 ((uint32_t) ((SYSCFG_ITLINE11 << 0x18) | SYSCFG_ITLINE11_SR_DMA1_CH4)) /* DMA1 Channel 4 Interrupt */ +#define ITLINE_DMA1_CH5 ((uint32_t) ((SYSCFG_ITLINE11 << 0x18) | SYSCFG_ITLINE11_SR_DMA1_CH5)) /* DMA1 Channel 5 Interrupt */ +#define ITLINE_DMA1_CH6 ((uint32_t) ((SYSCFG_ITLINE11 << 0x18) | SYSCFG_ITLINE11_SR_DMA1_CH6)) /* DMA1 Channel 6 Interrupt */ +#define ITLINE_DMA1_CH7 ((uint32_t) ((SYSCFG_ITLINE11 << 0x18) | SYSCFG_ITLINE11_SR_DMA1_CH7)) /* DMA1 Channel 7 Interrupt */ +#define ITLINE_DMA2_CH3 ((uint32_t) ((SYSCFG_ITLINE11 << 0x18) | SYSCFG_ITLINE11_SR_DMA2_CH3)) /* DMA2 Channel 3 Interrupt */ +#define ITLINE_DMA2_CH4 ((uint32_t) ((SYSCFG_ITLINE11 << 0x18) | SYSCFG_ITLINE11_SR_DMA2_CH4)) /* DMA2 Channel 4 Interrupt */ +#define ITLINE_DMA2_CH5 ((uint32_t) ((SYSCFG_ITLINE11 << 0x18) | SYSCFG_ITLINE11_SR_DMA2_CH5)) /* DMA2 Channel 5 Interrupt */ +#define ITLINE_ADC ((uint32_t) ((SYSCFG_ITLINE12 << 0x18) | SYSCFG_ITLINE12_SR_ADC)) /* ADC Interrupt */ +#define ITLINE_COMP1 ((uint32_t) ((SYSCFG_ITLINE12 << 0x18) | SYSCFG_ITLINE12_SR_COMP1)) /* COMP1 Interrupt -> exti[21] */ +#define ITLINE_COMP2 ((uint32_t) ((SYSCFG_ITLINE12 << 0x18) | SYSCFG_ITLINE12_SR_COMP2)) /* COMP2 Interrupt -> exti[21] */ +#define ITLINE_TIM1_BRK ((uint32_t) ((SYSCFG_ITLINE13 << 0x18) | SYSCFG_ITLINE13_SR_TIM1_BRK)) /* TIM1 BRK Interrupt */ +#define ITLINE_TIM1_UPD ((uint32_t) ((SYSCFG_ITLINE13 << 0x18) | SYSCFG_ITLINE13_SR_TIM1_UPD)) /* TIM1 UPD Interrupt */ +#define ITLINE_TIM1_TRG ((uint32_t) ((SYSCFG_ITLINE13 << 0x18) | SYSCFG_ITLINE13_SR_TIM1_TRG)) /* TIM1 TRG Interrupt */ +#define ITLINE_TIM1_CCU ((uint32_t) ((SYSCFG_ITLINE13 << 0x18) | SYSCFG_ITLINE13_SR_TIM1_CCU)) /* TIM1 CCU Interrupt */ +#define ITLINE_TIM1_CC ((uint32_t) ((SYSCFG_ITLINE14 << 0x18) | SYSCFG_ITLINE14_SR_TIM1_CC)) /* TIM1 CC Interrupt */ +#define ITLINE_TIM2 ((uint32_t) ((SYSCFG_ITLINE15 << 0x18) | SYSCFG_ITLINE15_SR_TIM2_GLB)) /* TIM2 Interrupt */ +#define ITLINE_TIM3 ((uint32_t) ((SYSCFG_ITLINE16 << 0x18) | SYSCFG_ITLINE16_SR_TIM3_GLB)) /* TIM3 Interrupt */ +#define ITLINE_DAC ((uint32_t) ((SYSCFG_ITLINE17 << 0x18) | SYSCFG_ITLINE17_SR_DAC)) /* DAC Interrupt */ +#define ITLINE_TIM6 ((uint32_t) ((SYSCFG_ITLINE17 << 0x18) | SYSCFG_ITLINE17_SR_TIM6_GLB)) /* TIM6 Interrupt */ +#define ITLINE_TIM7 ((uint32_t) ((SYSCFG_ITLINE18 << 0x18) | SYSCFG_ITLINE18_SR_TIM7_GLB)) /* TIM7 Interrupt */ +#define ITLINE_TIM14 ((uint32_t) ((SYSCFG_ITLINE19 << 0x18) | SYSCFG_ITLINE19_SR_TIM14_GLB)) /* TIM14 Interrupt */ +#define ITLINE_TIM15 ((uint32_t) ((SYSCFG_ITLINE20 << 0x18) | SYSCFG_ITLINE20_SR_TIM15_GLB)) /* TIM15 Interrupt */ +#define ITLINE_TIM16 ((uint32_t) ((SYSCFG_ITLINE21 << 0x18) | SYSCFG_ITLINE21_SR_TIM16_GLB)) /* TIM16 Interrupt */ +#define ITLINE_TIM17 ((uint32_t) ((SYSCFG_ITLINE22 << 0x18) | SYSCFG_ITLINE22_SR_TIM17_GLB)) /* TIM17 Interrupt */ +#define ITLINE_I2C1 ((uint32_t) ((SYSCFG_ITLINE23 << 0x18) | SYSCFG_ITLINE23_SR_I2C1_GLB)) /* I2C1 Interrupt -> exti[23] */ +#define ITLINE_I2C2 ((uint32_t) ((SYSCFG_ITLINE24 << 0x18) | SYSCFG_ITLINE24_SR_I2C2_GLB)) /* I2C2 Interrupt */ +#define ITLINE_SPI1 ((uint32_t) ((SYSCFG_ITLINE25 << 0x18) | SYSCFG_ITLINE25_SR_SPI1)) /* I2C1 Interrupt -> exti[23] */ +#define ITLINE_SPI2 ((uint32_t) ((SYSCFG_ITLINE26 << 0x18) | SYSCFG_ITLINE26_SR_SPI2)) /* SPI1 Interrupt */ +#define ITLINE_USART1 ((uint32_t) ((SYSCFG_ITLINE27 << 0x18) | SYSCFG_ITLINE27_SR_USART1_GLB)) /*!< USART1 GLB Interrupt -> exti[25] */ +#define ITLINE_USART2 ((uint32_t) ((SYSCFG_ITLINE28 << 0x18) | SYSCFG_ITLINE28_SR_USART2_GLB)) /*!< USART2 GLB Interrupt -> exti[26] */ +#define ITLINE_USART3 ((uint32_t) ((SYSCFG_ITLINE29 << 0x18) | SYSCFG_ITLINE29_SR_USART3_GLB)) /* USART3 Interrupt */ +#define ITLINE_USART4 ((uint32_t) ((SYSCFG_ITLINE29 << 0x18) | SYSCFG_ITLINE29_SR_USART4_GLB)) /* USART4 Interrupt */ +#define ITLINE_USART5 ((uint32_t) ((SYSCFG_ITLINE29 << 0x18) | SYSCFG_ITLINE29_SR_USART5_GLB)) /* USART5 Interrupt */ +#define ITLINE_USART6 ((uint32_t) ((SYSCFG_ITLINE29 << 0x18) | SYSCFG_ITLINE29_SR_USART6_GLB)) /* USART6 Interrupt */ +#define ITLINE_USART7 ((uint32_t) ((SYSCFG_ITLINE29 << 0x18) | SYSCFG_ITLINE29_SR_USART7_GLB)) /* USART7 Interrupt */ +#define ITLINE_USART8 ((uint32_t) ((SYSCFG_ITLINE29 << 0x18) | SYSCFG_ITLINE29_SR_USART8_GLB)) /* USART8 Interrupt */ +#define ITLINE_CAN ((uint32_t) ((SYSCFG_ITLINE30 << 0x18) | SYSCFG_ITLINE30_SR_CAN)) /* CAN Interrupt */ +#define ITLINE_CEC ((uint32_t) ((SYSCFG_ITLINE30 << 0x18) | SYSCFG_ITLINE30_SR_CEC)) /* CEC Interrupt -> exti[27] */ + +#define IS_SYSCFG_ITLINE(LINE) (((LINE) == ITLINE_EWDG) || \ + ((LINE) == ITLINE_PVDOUT) || \ + ((LINE) == ITLINE_VDDIO2) || \ + ((LINE) == ITLINE_RTC_WAKEUP) || \ + ((LINE) == ITLINE_RTC_TSTAMP) || \ + ((LINE) == ITLINE_RTC_ALRA) || \ + ((LINE) == ITLINE_FLASH_ITF) || \ + ((LINE) == ITLINE_CRS) || \ + ((LINE) == ITLINE_CLK_CTRL) || \ + ((LINE) == ITLINE_EXTI0) || \ + ((LINE) == ITLINE_EXTI1) || \ + ((LINE) == ITLINE_EXTI2) || \ + ((LINE) == ITLINE_EXTI3) || \ + ((LINE) == ITLINE_EXTI4) || \ + ((LINE) == ITLINE_EXTI5) || \ + ((LINE) == ITLINE_EXTI6) || \ + ((LINE) == ITLINE_EXTI7) || \ + ((LINE) == ITLINE_EXTI8) || \ + ((LINE) == ITLINE_EXTI9) || \ + ((LINE) == ITLINE_EXTI10) || \ + ((LINE) == ITLINE_EXTI11) || \ + ((LINE) == ITLINE_EXTI12) || \ + ((LINE) == ITLINE_EXTI13) || \ + ((LINE) == ITLINE_EXTI14) || \ + ((LINE) == ITLINE_EXTI15) || \ + ((LINE) == ITLINE_TSC_EOA) || \ + ((LINE) == ITLINE_TSC_MCE) || \ + ((LINE) == ITLINE_DMA1_CH1) || \ + ((LINE) == ITLINE_DMA1_CH2) || \ + ((LINE) == ITLINE_DMA1_CH3) || \ + ((LINE) == ITLINE_DMA1_CH4) || \ + ((LINE) == ITLINE_DMA1_CH5) || \ + ((LINE) == ITLINE_DMA1_CH6) || \ + ((LINE) == ITLINE_DMA1_CH7) || \ + ((LINE) == ITLINE_DMA2_CH1) || \ + ((LINE) == ITLINE_DMA2_CH2) || \ + ((LINE) == ITLINE_DMA2_CH3) || \ + ((LINE) == ITLINE_DMA2_CH4) || \ + ((LINE) == ITLINE_DMA2_CH5) || \ + ((LINE) == ITLINE_ADC) || \ + ((LINE) == ITLINE_COMP1) || \ + ((LINE) == ITLINE_COMP2) || \ + ((LINE) == ITLINE_TIM1_BRK) || \ + ((LINE) == ITLINE_TIM1_UPD) || \ + ((LINE) == ITLINE_TIM1_TRG) || \ + ((LINE) == ITLINE_TIM1_CCU) || \ + ((LINE) == ITLINE_TIM1_CC) || \ + ((LINE) == ITLINE_TIM2) || \ + ((LINE) == ITLINE_TIM3) || \ + ((LINE) == ITLINE_DAC) || \ + ((LINE) == ITLINE_TIM6) || \ + ((LINE) == ITLINE_TIM7) || \ + ((LINE) == ITLINE_TIM14) || \ + ((LINE) == ITLINE_TIM15) || \ + ((LINE) == ITLINE_TIM16) || \ + ((LINE) == ITLINE_TIM17) || \ + ((LINE) == ITLINE_I2C1) || \ + ((LINE) == ITLINE_I2C2) || \ + ((LINE) == ITLINE_SPI1) || \ + ((LINE) == ITLINE_SPI2) || \ + ((LINE) == ITLINE_USART1) || \ + ((LINE) == ITLINE_USART2) || \ + ((LINE) == ITLINE_USART3) || \ + ((LINE) == ITLINE_USART4) || \ + ((LINE) == ITLINE_USART5) || \ + ((LINE) == ITLINE_USART6) || \ + ((LINE) == ITLINE_USART7) || \ + ((LINE) == ITLINE_USART8) || \ + ((LINE) == ITLINE_CAN) || \ + ((LINE) == ITLINE_CEC)) + +/** + * @} + */ +/** @defgroup IRDA_ENV_SEL + * @{ + */ +#define SYSCFG_IRDA_ENV_SEL_TIM16 (SYSCFG_CFGR1_IRDA_ENV_SEL_0&SYSCFG_CFGR1_IRDA_ENV_SEL_1) /* Timer16 is selected as IRDA Modulation envelope source */ +#define SYSCFG_IRDA_ENV_SEL_USART1 (SYSCFG_CFGR1_IRDA_ENV_SEL_0) /* USART1 is selected as IRDA Modulation envelope source.*/ +#define SYSCFG_IRDA_ENV_SEL_USART4 (SYSCFG_CFGR1_IRDA_ENV_SEL_1) /* USART4 is selected as IRDA Modulation envelope source.*/ + +#define IS_SYSCFG_IRDA_ENV(ENV) (((ENV) == SYSCFG_IRDA_ENV_SEL_TIM16) || \ + ((ENV) == SYSCFG_IRDA_ENV_SEL_USART1) || \ + ((ENV) == SYSCFG_IRDA_ENV_SEL_USART4)) +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Function used to set the SYSCFG configuration to the default reset state **/ +void SYSCFG_DeInit(void); + +/* SYSCFG configuration functions *********************************************/ +void SYSCFG_MemoryRemapConfig(uint32_t SYSCFG_MemoryRemap); +void SYSCFG_DMAChannelRemapConfig(uint32_t SYSCFG_DMARemap, FunctionalState NewState); +void SYSCFG_I2CFastModePlusConfig(uint32_t SYSCFG_I2CFastModePlus, FunctionalState NewState); +void SYSCFG_IRDAEnvSelection(uint32_t SYSCFG_IRDAEnv); +void SYSCFG_EXTILineConfig(uint8_t EXTI_PortSourceGPIOx, uint8_t EXTI_PinSourcex); +uint32_t SYSCFG_GetPendingIT(uint32_t ITSourceLine); +void SYSCFG_BreakConfig(uint32_t SYSCFG_Break); +FlagStatus SYSCFG_GetFlagStatus(uint32_t SYSCFG_Flag); +void SYSCFG_ClearFlag(uint32_t SYSCFG_Flag); + +#ifdef __cplusplus +} +#endif + +#endif /*__STM32F0XX_SYSCFG_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_tim.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_tim.h new file mode 100644 index 00000000..7a4c8b99 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_tim.h @@ -0,0 +1,1186 @@ +/** + ****************************************************************************** + * @file stm32f0xx_tim.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the TIM + * firmware library. + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_TIM_H +#define __STM32F0XX_TIM_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup TIM + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief TIM Time Base Init structure definition + * @note This sturcture is used with all TIMx. + */ + +typedef struct +{ + uint16_t TIM_Prescaler; /*!< Specifies the prescaler value used to divide the TIM clock. + This parameter can be a number between 0x0000 and 0xFFFF */ + + uint16_t TIM_CounterMode; /*!< Specifies the counter mode. + This parameter can be a value of @ref TIM_Counter_Mode */ + + uint32_t TIM_Period; /*!< Specifies the period value to be loaded into the active + Auto-Reload Register at the next update event. + This parameter must be a number between 0x0000 and 0xFFFF. */ + + uint16_t TIM_ClockDivision; /*!< Specifies the clock division. + This parameter can be a value of @ref TIM_Clock_Division_CKD */ + + uint8_t TIM_RepetitionCounter; /*!< Specifies the repetition counter value. Each time the RCR downcounter + reaches zero, an update event is generated and counting restarts + from the RCR value (N). + This means in PWM mode that (N+1) corresponds to: + - the number of PWM periods in edge-aligned mode + - the number of half PWM period in center-aligned mode + This parameter must be a number between 0x00 and 0xFF. + @note This parameter is valid only for TIM1. */ +} TIM_TimeBaseInitTypeDef; + +/** + * @brief TIM Output Compare Init structure definition + */ + +typedef struct +{ + uint16_t TIM_OCMode; /*!< Specifies the TIM mode. + This parameter can be a value of @ref TIM_Output_Compare_and_PWM_modes */ + + uint16_t TIM_OutputState; /*!< Specifies the TIM Output Compare state. + This parameter can be a value of @ref TIM_Output_Compare_state */ + + uint16_t TIM_OutputNState; /*!< Specifies the TIM complementary Output Compare state. + This parameter can be a value of @ref TIM_Output_Compare_N_state + @note This parameter is valid only for TIM1. */ + + uint32_t TIM_Pulse; /*!< Specifies the pulse value to be loaded into the Capture Compare Register. + This parameter can be a number between 0x0000 and 0xFFFF ( or 0xFFFFFFFF + for TIM2) */ + + uint16_t TIM_OCPolarity; /*!< Specifies the output polarity. + This parameter can be a value of @ref TIM_Output_Compare_Polarity */ + + uint16_t TIM_OCNPolarity; /*!< Specifies the complementary output polarity. + This parameter can be a value of @ref TIM_Output_Compare_N_Polarity + @note This parameter is valid only for TIM1. */ + + uint16_t TIM_OCIdleState; /*!< Specifies the TIM Output Compare pin state during Idle state. + This parameter can be a value of @ref TIM_Output_Compare_Idle_State + @note This parameter is valid only for TIM1. */ + + uint16_t TIM_OCNIdleState; /*!< Specifies the TIM Output Compare pin state during Idle state. + This parameter can be a value of @ref TIM_Output_Compare_N_Idle_State + @note This parameter is valid only for TIM1. */ +} TIM_OCInitTypeDef; + +/** + * @brief TIM Input Capture Init structure definition + */ + +typedef struct +{ + + uint16_t TIM_Channel; /*!< Specifies the TIM channel. + This parameter can be a value of @ref TIM_Channel */ + + uint16_t TIM_ICPolarity; /*!< Specifies the active edge of the input signal. + This parameter can be a value of @ref TIM_Input_Capture_Polarity */ + + uint16_t TIM_ICSelection; /*!< Specifies the input. + This parameter can be a value of @ref TIM_Input_Capture_Selection */ + + uint16_t TIM_ICPrescaler; /*!< Specifies the Input Capture Prescaler. + This parameter can be a value of @ref TIM_Input_Capture_Prescaler */ + + uint16_t TIM_ICFilter; /*!< Specifies the input capture filter. + This parameter can be a number between 0x0 and 0xF */ +} TIM_ICInitTypeDef; + +/** + * @brief TIM_BDTR structure definition + * @note This sturcture is used only with TIM1. + */ + +typedef struct +{ + + uint16_t TIM_OSSRState; /*!< Specifies the Off-State selection used in Run mode. + This parameter can be a value of @ref TIM_OSSR_Off_State_Selection_for_Run_mode_state */ + + uint16_t TIM_OSSIState; /*!< Specifies the Off-State used in Idle state. + This parameter can be a value of @ref TIM_OSSI_Off_State_Selection_for_Idle_mode_state */ + + uint16_t TIM_LOCKLevel; /*!< Specifies the LOCK level parameters. + This parameter can be a value of @ref TIM_Lock_level */ + + uint16_t TIM_DeadTime; /*!< Specifies the delay time between the switching-off and the + switching-on of the outputs. + This parameter can be a number between 0x00 and 0xFF */ + + uint16_t TIM_Break; /*!< Specifies whether the TIM Break input is enabled or not. + This parameter can be a value of @ref TIM_Break_Input_enable_disable */ + + uint16_t TIM_BreakPolarity; /*!< Specifies the TIM Break Input pin polarity. + This parameter can be a value of @ref TIM_Break_Polarity */ + + uint16_t TIM_AutomaticOutput; /*!< Specifies whether the TIM Automatic Output feature is enabled or not. + This parameter can be a value of @ref TIM_AOE_Bit_Set_Reset */ +} TIM_BDTRInitTypeDef; + +/** + * @brief TIM Input Capture Init structure definition + */ + +/* Exported constants --------------------------------------------------------*/ + + +/** @defgroup TIM_Exported_constants + * @{ + */ + +#define IS_TIM_ALL_PERIPH(PERIPH) (((PERIPH) == TIM1) || \ + ((PERIPH) == TIM2) || \ + ((PERIPH) == TIM3) || \ + ((PERIPH) == TIM6) || \ + ((PERIPH) == TIM7) || \ + ((PERIPH) == TIM14)|| \ + ((PERIPH) == TIM15)|| \ + ((PERIPH) == TIM16)|| \ + ((PERIPH) == TIM17)) + +/* LIST1: TIM 1 */ +#define IS_TIM_LIST1_PERIPH(PERIPH) ((PERIPH) == TIM1) + +/* LIST2: TIM 1, 15, 16 and 17 */ +#define IS_TIM_LIST2_PERIPH(PERIPH) (((PERIPH) == TIM1) || \ + ((PERIPH) == TIM15)|| \ + ((PERIPH) == TIM16)|| \ + ((PERIPH) == TIM17)) + +/* LIST3: TIM 1, 2 and 3 */ +#define IS_TIM_LIST3_PERIPH(PERIPH) (((PERIPH) == TIM1) || \ + ((PERIPH) == TIM2) || \ + ((PERIPH) == TIM3)) + +/* LIST4: TIM 1, 2, 3, 14, 15, 16 and 17 */ +#define IS_TIM_LIST4_PERIPH(PERIPH) (((PERIPH) == TIM1) || \ + ((PERIPH) == TIM2) || \ + ((PERIPH) == TIM3) || \ + ((PERIPH) == TIM14) || \ + ((PERIPH) == TIM15)|| \ + ((PERIPH) == TIM16)|| \ + ((PERIPH) == TIM17)) + +/* LIST5: TIM 1, 2, 3, 15, 16 and 17 */ +#define IS_TIM_LIST5_PERIPH(PERIPH) (((PERIPH) == TIM1) || \ + ((PERIPH) == TIM2) || \ + ((PERIPH) == TIM3) || \ + ((PERIPH) == TIM15)|| \ + ((PERIPH) == TIM16)|| \ + ((PERIPH) == TIM17)) + +/* LIST6: TIM 1, 2, 3 and 15 */ +#define IS_TIM_LIST6_PERIPH(PERIPH) (((PERIPH) == TIM1) || \ + ((PERIPH) == TIM2) || \ + ((PERIPH) == TIM3) || \ + ((PERIPH) == TIM15)) + +/* LIST7: TIM 1, 2, 3, 6, 7 and 14 */ +#define IS_TIM_LIST7_PERIPH(PERIPH) (((PERIPH) == TIM1) || \ + ((PERIPH) == TIM2) || \ + ((PERIPH) == TIM3) || \ + ((PERIPH) == TIM6) || \ + ((PERIPH) == TIM7) || \ + ((PERIPH) == TIM14)) + +/* LIST8: TIM 1, 2, 3 and 14 */ +#define IS_TIM_LIST8_PERIPH(PERIPH) (((PERIPH) == TIM1) || \ + ((PERIPH) == TIM2) || \ + ((PERIPH) == TIM3) || \ + ((PERIPH) == TIM14)) + +/* LIST9: TIM 1, 2, 3, 6, 7 and 15 */ +#define IS_TIM_LIST9_PERIPH(PERIPH) (((PERIPH) == TIM1) || \ + ((PERIPH) == TIM2) || \ + ((PERIPH) == TIM3) || \ + ((PERIPH) == TIM6) || \ + ((PERIPH) == TIM7) || \ + ((PERIPH) == TIM15)) + +/* LIST10: TIM 1, 2, 3, 6, 7, 15, 16 and 17 */ +#define IS_TIM_LIST10_PERIPH(PERIPH) (((PERIPH) == TIM1) || \ + ((PERIPH) == TIM2) || \ + ((PERIPH) == TIM3) || \ + ((PERIPH) == TIM6) || \ + ((PERIPH) == TIM7) || \ + ((PERIPH) == TIM15)|| \ + ((PERIPH) == TIM16)|| \ + ((PERIPH) == TIM17)) + +/* LIST1: TIM 11 */ +#define IS_TIM_LIST11_PERIPH(PERIPH) ((PERIPH) == TIM14) + + +/** + * @} + */ + +/** @defgroup TIM_Output_Compare_and_PWM_modes + * @{ + */ + +#define TIM_OCMode_Timing ((uint16_t)0x0000) +#define TIM_OCMode_Active ((uint16_t)0x0010) +#define TIM_OCMode_Inactive ((uint16_t)0x0020) +#define TIM_OCMode_Toggle ((uint16_t)0x0030) +#define TIM_OCMode_PWM1 ((uint16_t)0x0060) +#define TIM_OCMode_PWM2 ((uint16_t)0x0070) +#define IS_TIM_OC_MODE(MODE) (((MODE) == TIM_OCMode_Timing) || \ + ((MODE) == TIM_OCMode_Active) || \ + ((MODE) == TIM_OCMode_Inactive) || \ + ((MODE) == TIM_OCMode_Toggle)|| \ + ((MODE) == TIM_OCMode_PWM1) || \ + ((MODE) == TIM_OCMode_PWM2)) +#define IS_TIM_OCM(MODE) (((MODE) == TIM_OCMode_Timing) || \ + ((MODE) == TIM_OCMode_Active) || \ + ((MODE) == TIM_OCMode_Inactive) || \ + ((MODE) == TIM_OCMode_Toggle)|| \ + ((MODE) == TIM_OCMode_PWM1) || \ + ((MODE) == TIM_OCMode_PWM2) || \ + ((MODE) == TIM_ForcedAction_Active) || \ + ((MODE) == TIM_ForcedAction_InActive)) +/** + * @} + */ + +/** @defgroup TIM_One_Pulse_Mode + * @{ + */ + +#define TIM_OPMode_Single ((uint16_t)0x0008) +#define TIM_OPMode_Repetitive ((uint16_t)0x0000) +#define IS_TIM_OPM_MODE(MODE) (((MODE) == TIM_OPMode_Single) || \ + ((MODE) == TIM_OPMode_Repetitive)) +/** + * @} + */ + +/** @defgroup TIM_Channel + * @{ + */ + +#define TIM_Channel_1 ((uint16_t)0x0000) +#define TIM_Channel_2 ((uint16_t)0x0004) +#define TIM_Channel_3 ((uint16_t)0x0008) +#define TIM_Channel_4 ((uint16_t)0x000C) + +#define IS_TIM_CHANNEL(CHANNEL) (((CHANNEL) == TIM_Channel_1) || \ + ((CHANNEL) == TIM_Channel_2) || \ + ((CHANNEL) == TIM_Channel_3) || \ + ((CHANNEL) == TIM_Channel_4)) +#define IS_TIM_COMPLEMENTARY_CHANNEL(CHANNEL) (((CHANNEL) == TIM_Channel_1) || \ + ((CHANNEL) == TIM_Channel_2) || \ + ((CHANNEL) == TIM_Channel_3)) +#define IS_TIM_PWMI_CHANNEL(CHANNEL) (((CHANNEL) == TIM_Channel_1) || \ + ((CHANNEL) == TIM_Channel_2)) + +/** + * @} + */ + +/** @defgroup TIM_Clock_Division_CKD + * @{ + */ + +#define TIM_CKD_DIV1 ((uint16_t)0x0000) +#define TIM_CKD_DIV2 ((uint16_t)0x0100) +#define TIM_CKD_DIV4 ((uint16_t)0x0200) +#define IS_TIM_CKD_DIV(DIV) (((DIV) == TIM_CKD_DIV1) || \ + ((DIV) == TIM_CKD_DIV2) || \ + ((DIV) == TIM_CKD_DIV4)) +/** + * @} + */ + +/** @defgroup TIM_Counter_Mode + * @{ + */ + +#define TIM_CounterMode_Up ((uint16_t)0x0000) +#define TIM_CounterMode_Down ((uint16_t)0x0010) +#define TIM_CounterMode_CenterAligned1 ((uint16_t)0x0020) +#define TIM_CounterMode_CenterAligned2 ((uint16_t)0x0040) +#define TIM_CounterMode_CenterAligned3 ((uint16_t)0x0060) +#define IS_TIM_COUNTER_MODE(MODE) (((MODE) == TIM_CounterMode_Up) || \ + ((MODE) == TIM_CounterMode_Down) || \ + ((MODE) == TIM_CounterMode_CenterAligned1) || \ + ((MODE) == TIM_CounterMode_CenterAligned2) || \ + ((MODE) == TIM_CounterMode_CenterAligned3)) +/** + * @} + */ + +/** @defgroup TIM_Output_Compare_Polarity + * @{ + */ + +#define TIM_OCPolarity_High ((uint16_t)0x0000) +#define TIM_OCPolarity_Low ((uint16_t)0x0002) +#define IS_TIM_OC_POLARITY(POLARITY) (((POLARITY) == TIM_OCPolarity_High) || \ + ((POLARITY) == TIM_OCPolarity_Low)) +/** + * @} + */ + +/** @defgroup TIM_Output_Compare_N_Polarity + * @{ + */ + +#define TIM_OCNPolarity_High ((uint16_t)0x0000) +#define TIM_OCNPolarity_Low ((uint16_t)0x0008) +#define IS_TIM_OCN_POLARITY(POLARITY) (((POLARITY) == TIM_OCNPolarity_High) || \ + ((POLARITY) == TIM_OCNPolarity_Low)) +/** + * @} + */ + +/** @defgroup TIM_Output_Compare_state + * @{ + */ + +#define TIM_OutputState_Disable ((uint16_t)0x0000) +#define TIM_OutputState_Enable ((uint16_t)0x0001) +#define IS_TIM_OUTPUT_STATE(STATE) (((STATE) == TIM_OutputState_Disable) || \ + ((STATE) == TIM_OutputState_Enable)) +/** + * @} + */ + +/** @defgroup TIM_Output_Compare_N_state + * @{ + */ + +#define TIM_OutputNState_Disable ((uint16_t)0x0000) +#define TIM_OutputNState_Enable ((uint16_t)0x0004) +#define IS_TIM_OUTPUTN_STATE(STATE) (((STATE) == TIM_OutputNState_Disable) || \ + ((STATE) == TIM_OutputNState_Enable)) +/** + * @} + */ + +/** @defgroup TIM_Capture_Compare_state + * @{ + */ + +#define TIM_CCx_Enable ((uint16_t)0x0001) +#define TIM_CCx_Disable ((uint16_t)0x0000) +#define IS_TIM_CCX(CCX) (((CCX) == TIM_CCx_Enable) || \ + ((CCX) == TIM_CCx_Disable)) +/** + * @} + */ + +/** @defgroup TIM_Capture_Compare_N_state + * @{ + */ + +#define TIM_CCxN_Enable ((uint16_t)0x0004) +#define TIM_CCxN_Disable ((uint16_t)0x0000) +#define IS_TIM_CCXN(CCXN) (((CCXN) == TIM_CCxN_Enable) || \ + ((CCXN) == TIM_CCxN_Disable)) +/** + * @} + */ + +/** @defgroup TIM_Break_Input_enable_disable + * @{ + */ + +#define TIM_Break_Enable ((uint16_t)0x1000) +#define TIM_Break_Disable ((uint16_t)0x0000) +#define IS_TIM_BREAK_STATE(STATE) (((STATE) == TIM_Break_Enable) || \ + ((STATE) == TIM_Break_Disable)) +/** + * @} + */ + +/** @defgroup TIM_Break_Polarity + * @{ + */ + +#define TIM_BreakPolarity_Low ((uint16_t)0x0000) +#define TIM_BreakPolarity_High ((uint16_t)0x2000) +#define IS_TIM_BREAK_POLARITY(POLARITY) (((POLARITY) == TIM_BreakPolarity_Low) || \ + ((POLARITY) == TIM_BreakPolarity_High)) +/** + * @} + */ + +/** @defgroup TIM_AOE_Bit_Set_Reset + * @{ + */ + +#define TIM_AutomaticOutput_Enable ((uint16_t)0x4000) +#define TIM_AutomaticOutput_Disable ((uint16_t)0x0000) +#define IS_TIM_AUTOMATIC_OUTPUT_STATE(STATE) (((STATE) == TIM_AutomaticOutput_Enable) || \ + ((STATE) == TIM_AutomaticOutput_Disable)) +/** + * @} + */ + +/** @defgroup TIM_Lock_level + * @{ + */ + +#define TIM_LOCKLevel_OFF ((uint16_t)0x0000) +#define TIM_LOCKLevel_1 ((uint16_t)0x0100) +#define TIM_LOCKLevel_2 ((uint16_t)0x0200) +#define TIM_LOCKLevel_3 ((uint16_t)0x0300) +#define IS_TIM_LOCK_LEVEL(LEVEL) (((LEVEL) == TIM_LOCKLevel_OFF) || \ + ((LEVEL) == TIM_LOCKLevel_1) || \ + ((LEVEL) == TIM_LOCKLevel_2) || \ + ((LEVEL) == TIM_LOCKLevel_3)) +/** + * @} + */ + +/** @defgroup TIM_OSSI_Off_State_Selection_for_Idle_mode_state + * @{ + */ + +#define TIM_OSSIState_Enable ((uint16_t)0x0400) +#define TIM_OSSIState_Disable ((uint16_t)0x0000) +#define IS_TIM_OSSI_STATE(STATE) (((STATE) == TIM_OSSIState_Enable) || \ + ((STATE) == TIM_OSSIState_Disable)) +/** + * @} + */ + +/** @defgroup TIM_OSSR_Off_State_Selection_for_Run_mode_state + * @{ + */ + +#define TIM_OSSRState_Enable ((uint16_t)0x0800) +#define TIM_OSSRState_Disable ((uint16_t)0x0000) +#define IS_TIM_OSSR_STATE(STATE) (((STATE) == TIM_OSSRState_Enable) || \ + ((STATE) == TIM_OSSRState_Disable)) +/** + * @} + */ + +/** @defgroup TIM_Output_Compare_Idle_State + * @{ + */ + +#define TIM_OCIdleState_Set ((uint16_t)0x0100) +#define TIM_OCIdleState_Reset ((uint16_t)0x0000) +#define IS_TIM_OCIDLE_STATE(STATE) (((STATE) == TIM_OCIdleState_Set) || \ + ((STATE) == TIM_OCIdleState_Reset)) +/** + * @} + */ + +/** @defgroup TIM_Output_Compare_N_Idle_State + * @{ + */ + +#define TIM_OCNIdleState_Set ((uint16_t)0x0200) +#define TIM_OCNIdleState_Reset ((uint16_t)0x0000) +#define IS_TIM_OCNIDLE_STATE(STATE) (((STATE) == TIM_OCNIdleState_Set) || \ + ((STATE) == TIM_OCNIdleState_Reset)) +/** + * @} + */ + +/** @defgroup TIM_Input_Capture_Polarity + * @{ + */ + +#define TIM_ICPolarity_Rising ((uint16_t)0x0000) +#define TIM_ICPolarity_Falling ((uint16_t)0x0002) +#define TIM_ICPolarity_BothEdge ((uint16_t)0x000A) +#define IS_TIM_IC_POLARITY(POLARITY) (((POLARITY) == TIM_ICPolarity_Rising) || \ + ((POLARITY) == TIM_ICPolarity_Falling)|| \ + ((POLARITY) == TIM_ICPolarity_BothEdge)) +/** + * @} + */ + +/** @defgroup TIM_Input_Capture_Selection + * @{ + */ + +#define TIM_ICSelection_DirectTI ((uint16_t)0x0001) /*!< TIM Input 1, 2, 3 or 4 is selected to be + connected to IC1, IC2, IC3 or IC4, respectively */ +#define TIM_ICSelection_IndirectTI ((uint16_t)0x0002) /*!< TIM Input 1, 2, 3 or 4 is selected to be + connected to IC2, IC1, IC4 or IC3, respectively. */ +#define TIM_ICSelection_TRC ((uint16_t)0x0003) /*!< TIM Input 1, 2, 3 or 4 is selected to be connected to TRC. */ +#define IS_TIM_IC_SELECTION(SELECTION) (((SELECTION) == TIM_ICSelection_DirectTI) || \ + ((SELECTION) == TIM_ICSelection_IndirectTI) || \ + ((SELECTION) == TIM_ICSelection_TRC)) +/** + * @} + */ + +/** @defgroup TIM_Input_Capture_Prescaler + * @{ + */ + +#define TIM_ICPSC_DIV1 ((uint16_t)0x0000) /*!< Capture performed each time an edge is detected on the capture input. */ +#define TIM_ICPSC_DIV2 ((uint16_t)0x0004) /*!< Capture performed once every 2 events. */ +#define TIM_ICPSC_DIV4 ((uint16_t)0x0008) /*!< Capture performed once every 4 events. */ +#define TIM_ICPSC_DIV8 ((uint16_t)0x000C) /*!< Capture performed once every 8 events. */ +#define IS_TIM_IC_PRESCALER(PRESCALER) (((PRESCALER) == TIM_ICPSC_DIV1) || \ + ((PRESCALER) == TIM_ICPSC_DIV2) || \ + ((PRESCALER) == TIM_ICPSC_DIV4) || \ + ((PRESCALER) == TIM_ICPSC_DIV8)) +/** + * @} + */ + +/** @defgroup TIM_interrupt_sources + * @{ + */ + +#define TIM_IT_Update ((uint16_t)0x0001) +#define TIM_IT_CC1 ((uint16_t)0x0002) +#define TIM_IT_CC2 ((uint16_t)0x0004) +#define TIM_IT_CC3 ((uint16_t)0x0008) +#define TIM_IT_CC4 ((uint16_t)0x0010) +#define TIM_IT_COM ((uint16_t)0x0020) +#define TIM_IT_Trigger ((uint16_t)0x0040) +#define TIM_IT_Break ((uint16_t)0x0080) +#define IS_TIM_IT(IT) ((((IT) & (uint16_t)0xFF00) == 0x0000) && ((IT) != 0x0000)) + +#define IS_TIM_GET_IT(IT) (((IT) == TIM_IT_Update) || \ + ((IT) == TIM_IT_CC1) || \ + ((IT) == TIM_IT_CC2) || \ + ((IT) == TIM_IT_CC3) || \ + ((IT) == TIM_IT_CC4) || \ + ((IT) == TIM_IT_COM) || \ + ((IT) == TIM_IT_Trigger) || \ + ((IT) == TIM_IT_Break)) +/** + * @} + */ + +/** @defgroup TIM_DMA_Base_address + * @{ + */ + +#define TIM_DMABase_CR1 ((uint16_t)0x0000) +#define TIM_DMABase_CR2 ((uint16_t)0x0001) +#define TIM_DMABase_SMCR ((uint16_t)0x0002) +#define TIM_DMABase_DIER ((uint16_t)0x0003) +#define TIM_DMABase_SR ((uint16_t)0x0004) +#define TIM_DMABase_EGR ((uint16_t)0x0005) +#define TIM_DMABase_CCMR1 ((uint16_t)0x0006) +#define TIM_DMABase_CCMR2 ((uint16_t)0x0007) +#define TIM_DMABase_CCER ((uint16_t)0x0008) +#define TIM_DMABase_CNT ((uint16_t)0x0009) +#define TIM_DMABase_PSC ((uint16_t)0x000A) +#define TIM_DMABase_ARR ((uint16_t)0x000B) +#define TIM_DMABase_RCR ((uint16_t)0x000C) +#define TIM_DMABase_CCR1 ((uint16_t)0x000D) +#define TIM_DMABase_CCR2 ((uint16_t)0x000E) +#define TIM_DMABase_CCR3 ((uint16_t)0x000F) +#define TIM_DMABase_CCR4 ((uint16_t)0x0010) +#define TIM_DMABase_BDTR ((uint16_t)0x0011) +#define TIM_DMABase_DCR ((uint16_t)0x0012) +#define TIM_DMABase_OR ((uint16_t)0x0013) +#define IS_TIM_DMA_BASE(BASE) (((BASE) == TIM_DMABase_CR1) || \ + ((BASE) == TIM_DMABase_CR2) || \ + ((BASE) == TIM_DMABase_SMCR) || \ + ((BASE) == TIM_DMABase_DIER) || \ + ((BASE) == TIM_DMABase_SR) || \ + ((BASE) == TIM_DMABase_EGR) || \ + ((BASE) == TIM_DMABase_CCMR1) || \ + ((BASE) == TIM_DMABase_CCMR2) || \ + ((BASE) == TIM_DMABase_CCER) || \ + ((BASE) == TIM_DMABase_CNT) || \ + ((BASE) == TIM_DMABase_PSC) || \ + ((BASE) == TIM_DMABase_ARR) || \ + ((BASE) == TIM_DMABase_RCR) || \ + ((BASE) == TIM_DMABase_CCR1) || \ + ((BASE) == TIM_DMABase_CCR2) || \ + ((BASE) == TIM_DMABase_CCR3) || \ + ((BASE) == TIM_DMABase_CCR4) || \ + ((BASE) == TIM_DMABase_BDTR) || \ + ((BASE) == TIM_DMABase_DCR) || \ + ((BASE) == TIM_DMABase_OR)) +/** + * @} + */ + + +/** @defgroup TIM_DMA_Burst_Length + * @{ + */ + +#define TIM_DMABurstLength_1Transfer ((uint16_t)0x0000) +#define TIM_DMABurstLength_2Transfers ((uint16_t)0x0100) +#define TIM_DMABurstLength_3Transfers ((uint16_t)0x0200) +#define TIM_DMABurstLength_4Transfers ((uint16_t)0x0300) +#define TIM_DMABurstLength_5Transfers ((uint16_t)0x0400) +#define TIM_DMABurstLength_6Transfers ((uint16_t)0x0500) +#define TIM_DMABurstLength_7Transfers ((uint16_t)0x0600) +#define TIM_DMABurstLength_8Transfers ((uint16_t)0x0700) +#define TIM_DMABurstLength_9Transfers ((uint16_t)0x0800) +#define TIM_DMABurstLength_10Transfers ((uint16_t)0x0900) +#define TIM_DMABurstLength_11Transfers ((uint16_t)0x0A00) +#define TIM_DMABurstLength_12Transfers ((uint16_t)0x0B00) +#define TIM_DMABurstLength_13Transfers ((uint16_t)0x0C00) +#define TIM_DMABurstLength_14Transfers ((uint16_t)0x0D00) +#define TIM_DMABurstLength_15Transfers ((uint16_t)0x0E00) +#define TIM_DMABurstLength_16Transfers ((uint16_t)0x0F00) +#define TIM_DMABurstLength_17Transfers ((uint16_t)0x1000) +#define TIM_DMABurstLength_18Transfers ((uint16_t)0x1100) +#define IS_TIM_DMA_LENGTH(LENGTH) (((LENGTH) == TIM_DMABurstLength_1Transfer) || \ + ((LENGTH) == TIM_DMABurstLength_2Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_3Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_4Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_5Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_6Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_7Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_8Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_9Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_10Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_11Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_12Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_13Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_14Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_15Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_16Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_17Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_18Transfers)) +/** + * @} + */ + +/** @defgroup TIM_DMA_sources + * @{ + */ + +#define TIM_DMA_Update ((uint16_t)0x0100) +#define TIM_DMA_CC1 ((uint16_t)0x0200) +#define TIM_DMA_CC2 ((uint16_t)0x0400) +#define TIM_DMA_CC3 ((uint16_t)0x0800) +#define TIM_DMA_CC4 ((uint16_t)0x1000) +#define TIM_DMA_COM ((uint16_t)0x2000) +#define TIM_DMA_Trigger ((uint16_t)0x4000) +#define IS_TIM_DMA_SOURCE(SOURCE) ((((SOURCE) & (uint16_t)0x80FF) == 0x0000) && ((SOURCE) != 0x0000)) + +/** + * @} + */ + +/** @defgroup TIM_External_Trigger_Prescaler + * @{ + */ + +#define TIM_ExtTRGPSC_OFF ((uint16_t)0x0000) +#define TIM_ExtTRGPSC_DIV2 ((uint16_t)0x1000) +#define TIM_ExtTRGPSC_DIV4 ((uint16_t)0x2000) +#define TIM_ExtTRGPSC_DIV8 ((uint16_t)0x3000) +#define IS_TIM_EXT_PRESCALER(PRESCALER) (((PRESCALER) == TIM_ExtTRGPSC_OFF) || \ + ((PRESCALER) == TIM_ExtTRGPSC_DIV2) || \ + ((PRESCALER) == TIM_ExtTRGPSC_DIV4) || \ + ((PRESCALER) == TIM_ExtTRGPSC_DIV8)) +/** + * @} + */ + +/** @defgroup TIM_Internal_Trigger_Selection + * @{ + */ + +#define TIM_TS_ITR0 ((uint16_t)0x0000) +#define TIM_TS_ITR1 ((uint16_t)0x0010) +#define TIM_TS_ITR2 ((uint16_t)0x0020) +#define TIM_TS_ITR3 ((uint16_t)0x0030) +#define TIM_TS_TI1F_ED ((uint16_t)0x0040) +#define TIM_TS_TI1FP1 ((uint16_t)0x0050) +#define TIM_TS_TI2FP2 ((uint16_t)0x0060) +#define TIM_TS_ETRF ((uint16_t)0x0070) +#define IS_TIM_TRIGGER_SELECTION(SELECTION) (((SELECTION) == TIM_TS_ITR0) || \ + ((SELECTION) == TIM_TS_ITR1) || \ + ((SELECTION) == TIM_TS_ITR2) || \ + ((SELECTION) == TIM_TS_ITR3) || \ + ((SELECTION) == TIM_TS_TI1F_ED) || \ + ((SELECTION) == TIM_TS_TI1FP1) || \ + ((SELECTION) == TIM_TS_TI2FP2) || \ + ((SELECTION) == TIM_TS_ETRF)) +#define IS_TIM_INTERNAL_TRIGGER_SELECTION(SELECTION) (((SELECTION) == TIM_TS_ITR0) || \ + ((SELECTION) == TIM_TS_ITR1) || \ + ((SELECTION) == TIM_TS_ITR2) || \ + ((SELECTION) == TIM_TS_ITR3)) +/** + * @} + */ + +/** @defgroup TIM_TIx_External_Clock_Source + * @{ + */ + +#define TIM_TIxExternalCLK1Source_TI1 ((uint16_t)0x0050) +#define TIM_TIxExternalCLK1Source_TI2 ((uint16_t)0x0060) +#define TIM_TIxExternalCLK1Source_TI1ED ((uint16_t)0x0040) + +/** + * @} + */ + +/** @defgroup TIM_External_Trigger_Polarity + * @{ + */ +#define TIM_ExtTRGPolarity_Inverted ((uint16_t)0x8000) +#define TIM_ExtTRGPolarity_NonInverted ((uint16_t)0x0000) +#define IS_TIM_EXT_POLARITY(POLARITY) (((POLARITY) == TIM_ExtTRGPolarity_Inverted) || \ + ((POLARITY) == TIM_ExtTRGPolarity_NonInverted)) +/** + * @} + */ + +/** @defgroup TIM_Prescaler_Reload_Mode + * @{ + */ + +#define TIM_PSCReloadMode_Update ((uint16_t)0x0000) +#define TIM_PSCReloadMode_Immediate ((uint16_t)0x0001) +#define IS_TIM_PRESCALER_RELOAD(RELOAD) (((RELOAD) == TIM_PSCReloadMode_Update) || \ + ((RELOAD) == TIM_PSCReloadMode_Immediate)) +/** + * @} + */ + +/** @defgroup TIM_Forced_Action + * @{ + */ + +#define TIM_ForcedAction_Active ((uint16_t)0x0050) +#define TIM_ForcedAction_InActive ((uint16_t)0x0040) +#define IS_TIM_FORCED_ACTION(ACTION) (((ACTION) == TIM_ForcedAction_Active) || \ + ((ACTION) == TIM_ForcedAction_InActive)) +/** + * @} + */ + +/** @defgroup TIM_Encoder_Mode + * @{ + */ + +#define TIM_EncoderMode_TI1 ((uint16_t)0x0001) +#define TIM_EncoderMode_TI2 ((uint16_t)0x0002) +#define TIM_EncoderMode_TI12 ((uint16_t)0x0003) +#define IS_TIM_ENCODER_MODE(MODE) (((MODE) == TIM_EncoderMode_TI1) || \ + ((MODE) == TIM_EncoderMode_TI2) || \ + ((MODE) == TIM_EncoderMode_TI12)) +/** + * @} + */ + + +/** @defgroup TIM_Event_Source + * @{ + */ + +#define TIM_EventSource_Update ((uint16_t)0x0001) +#define TIM_EventSource_CC1 ((uint16_t)0x0002) +#define TIM_EventSource_CC2 ((uint16_t)0x0004) +#define TIM_EventSource_CC3 ((uint16_t)0x0008) +#define TIM_EventSource_CC4 ((uint16_t)0x0010) +#define TIM_EventSource_COM ((uint16_t)0x0020) +#define TIM_EventSource_Trigger ((uint16_t)0x0040) +#define TIM_EventSource_Break ((uint16_t)0x0080) +#define IS_TIM_EVENT_SOURCE(SOURCE) ((((SOURCE) & (uint16_t)0xFF00) == 0x0000) && ((SOURCE) != 0x0000)) + +/** + * @} + */ + +/** @defgroup TIM_Update_Source + * @{ + */ + +#define TIM_UpdateSource_Global ((uint16_t)0x0000) /*!< Source of update is the counter overflow/underflow + or the setting of UG bit, or an update generation + through the slave mode controller. */ +#define TIM_UpdateSource_Regular ((uint16_t)0x0001) /*!< Source of update is counter overflow/underflow. */ +#define IS_TIM_UPDATE_SOURCE(SOURCE) (((SOURCE) == TIM_UpdateSource_Global) || \ + ((SOURCE) == TIM_UpdateSource_Regular)) +/** + * @} + */ + +/** @defgroup TIM_Output_Compare_Preload_State + * @{ + */ + +#define TIM_OCPreload_Enable ((uint16_t)0x0008) +#define TIM_OCPreload_Disable ((uint16_t)0x0000) +#define IS_TIM_OCPRELOAD_STATE(STATE) (((STATE) == TIM_OCPreload_Enable) || \ + ((STATE) == TIM_OCPreload_Disable)) +/** + * @} + */ + +/** @defgroup TIM_Output_Compare_Fast_State + * @{ + */ + +#define TIM_OCFast_Enable ((uint16_t)0x0004) +#define TIM_OCFast_Disable ((uint16_t)0x0000) +#define IS_TIM_OCFAST_STATE(STATE) (((STATE) == TIM_OCFast_Enable) || \ + ((STATE) == TIM_OCFast_Disable)) + +/** + * @} + */ + +/** @defgroup TIM_Output_Compare_Clear_State + * @{ + */ + +#define TIM_OCClear_Enable ((uint16_t)0x0080) +#define TIM_OCClear_Disable ((uint16_t)0x0000) +#define IS_TIM_OCCLEAR_STATE(STATE) (((STATE) == TIM_OCClear_Enable) || \ + ((STATE) == TIM_OCClear_Disable)) +/** + * @} + */ + +/** @defgroup TIM_Trigger_Output_Source + * @{ + */ + +#define TIM_TRGOSource_Reset ((uint16_t)0x0000) +#define TIM_TRGOSource_Enable ((uint16_t)0x0010) +#define TIM_TRGOSource_Update ((uint16_t)0x0020) +#define TIM_TRGOSource_OC1 ((uint16_t)0x0030) +#define TIM_TRGOSource_OC1Ref ((uint16_t)0x0040) +#define TIM_TRGOSource_OC2Ref ((uint16_t)0x0050) +#define TIM_TRGOSource_OC3Ref ((uint16_t)0x0060) +#define TIM_TRGOSource_OC4Ref ((uint16_t)0x0070) +#define IS_TIM_TRGO_SOURCE(SOURCE) (((SOURCE) == TIM_TRGOSource_Reset) || \ + ((SOURCE) == TIM_TRGOSource_Enable) || \ + ((SOURCE) == TIM_TRGOSource_Update) || \ + ((SOURCE) == TIM_TRGOSource_OC1) || \ + ((SOURCE) == TIM_TRGOSource_OC1Ref) || \ + ((SOURCE) == TIM_TRGOSource_OC2Ref) || \ + ((SOURCE) == TIM_TRGOSource_OC3Ref) || \ + ((SOURCE) == TIM_TRGOSource_OC4Ref)) +/** + * @} + */ + +/** @defgroup TIM_Slave_Mode + * @{ + */ + +#define TIM_SlaveMode_Reset ((uint16_t)0x0004) +#define TIM_SlaveMode_Gated ((uint16_t)0x0005) +#define TIM_SlaveMode_Trigger ((uint16_t)0x0006) +#define TIM_SlaveMode_External1 ((uint16_t)0x0007) +#define IS_TIM_SLAVE_MODE(MODE) (((MODE) == TIM_SlaveMode_Reset) || \ + ((MODE) == TIM_SlaveMode_Gated) || \ + ((MODE) == TIM_SlaveMode_Trigger) || \ + ((MODE) == TIM_SlaveMode_External1)) +/** + * @} + */ + +/** @defgroup TIM_Master_Slave_Mode + * @{ + */ + +#define TIM_MasterSlaveMode_Enable ((uint16_t)0x0080) +#define TIM_MasterSlaveMode_Disable ((uint16_t)0x0000) +#define IS_TIM_MSM_STATE(STATE) (((STATE) == TIM_MasterSlaveMode_Enable) || \ + ((STATE) == TIM_MasterSlaveMode_Disable)) +/** + * @} + */ + +/** @defgroup TIM_Flags + * @{ + */ + +#define TIM_FLAG_Update ((uint16_t)0x0001) +#define TIM_FLAG_CC1 ((uint16_t)0x0002) +#define TIM_FLAG_CC2 ((uint16_t)0x0004) +#define TIM_FLAG_CC3 ((uint16_t)0x0008) +#define TIM_FLAG_CC4 ((uint16_t)0x0010) +#define TIM_FLAG_COM ((uint16_t)0x0020) +#define TIM_FLAG_Trigger ((uint16_t)0x0040) +#define TIM_FLAG_Break ((uint16_t)0x0080) +#define TIM_FLAG_CC1OF ((uint16_t)0x0200) +#define TIM_FLAG_CC2OF ((uint16_t)0x0400) +#define TIM_FLAG_CC3OF ((uint16_t)0x0800) +#define TIM_FLAG_CC4OF ((uint16_t)0x1000) +#define IS_TIM_GET_FLAG(FLAG) (((FLAG) == TIM_FLAG_Update) || \ + ((FLAG) == TIM_FLAG_CC1) || \ + ((FLAG) == TIM_FLAG_CC2) || \ + ((FLAG) == TIM_FLAG_CC3) || \ + ((FLAG) == TIM_FLAG_CC4) || \ + ((FLAG) == TIM_FLAG_COM) || \ + ((FLAG) == TIM_FLAG_Trigger) || \ + ((FLAG) == TIM_FLAG_Break) || \ + ((FLAG) == TIM_FLAG_CC1OF) || \ + ((FLAG) == TIM_FLAG_CC2OF) || \ + ((FLAG) == TIM_FLAG_CC3OF) || \ + ((FLAG) == TIM_FLAG_CC4OF)) + + +#define IS_TIM_CLEAR_FLAG(TIM_FLAG) ((((TIM_FLAG) & (uint16_t)0xE100) == 0x0000) && ((TIM_FLAG) != 0x0000)) +/** + * @} + */ + + +/** @defgroup TIM_Input_Capture_Filer_Value + * @{ + */ + +#define IS_TIM_IC_FILTER(ICFILTER) ((ICFILTER) <= 0xF) +/** + * @} + */ + +/** @defgroup TIM_External_Trigger_Filter + * @{ + */ + +#define IS_TIM_EXT_FILTER(EXTFILTER) ((EXTFILTER) <= 0xF) +/** + * @} + */ + +/** @defgroup TIM_OCReferenceClear + * @{ + */ +#define TIM_OCReferenceClear_ETRF ((uint16_t)0x0008) +#define TIM_OCReferenceClear_OCREFCLR ((uint16_t)0x0000) +#define TIM_OCREFERENCECECLEAR_SOURCE(SOURCE) (((SOURCE) == TIM_OCReferenceClear_ETRF) || \ + ((SOURCE) == TIM_OCReferenceClear_OCREFCLR)) + +/** + * @} + */ +/** @defgroup TIM_Remap + * @{ + */ +#define TIM14_GPIO ((uint16_t)0x0000) +#define TIM14_RTC_CLK ((uint16_t)0x0001) +#define TIM14_HSEDiv32 ((uint16_t)0x0002) +#define TIM14_MCO ((uint16_t)0x0003) + +#define IS_TIM_REMAP(TIM_REMAP) (((TIM_REMAP) == TIM14_GPIO)|| \ + ((TIM_REMAP) == TIM14_RTC_CLK) || \ + ((TIM_REMAP) == TIM14_HSEDiv32) || \ + ((TIM_REMAP) == TIM14_MCO)) +/** + * @} + */ + +/** @defgroup TIM_Legacy + * @{ + */ + +#define TIM_DMABurstLength_1Byte TIM_DMABurstLength_1Transfer +#define TIM_DMABurstLength_2Bytes TIM_DMABurstLength_2Transfers +#define TIM_DMABurstLength_3Bytes TIM_DMABurstLength_3Transfers +#define TIM_DMABurstLength_4Bytes TIM_DMABurstLength_4Transfers +#define TIM_DMABurstLength_5Bytes TIM_DMABurstLength_5Transfers +#define TIM_DMABurstLength_6Bytes TIM_DMABurstLength_6Transfers +#define TIM_DMABurstLength_7Bytes TIM_DMABurstLength_7Transfers +#define TIM_DMABurstLength_8Bytes TIM_DMABurstLength_8Transfers +#define TIM_DMABurstLength_9Bytes TIM_DMABurstLength_9Transfers +#define TIM_DMABurstLength_10Bytes TIM_DMABurstLength_10Transfers +#define TIM_DMABurstLength_11Bytes TIM_DMABurstLength_11Transfers +#define TIM_DMABurstLength_12Bytes TIM_DMABurstLength_12Transfers +#define TIM_DMABurstLength_13Bytes TIM_DMABurstLength_13Transfers +#define TIM_DMABurstLength_14Bytes TIM_DMABurstLength_14Transfers +#define TIM_DMABurstLength_15Bytes TIM_DMABurstLength_15Transfers +#define TIM_DMABurstLength_16Bytes TIM_DMABurstLength_16Transfers +#define TIM_DMABurstLength_17Bytes TIM_DMABurstLength_17Transfers +#define TIM_DMABurstLength_18Bytes TIM_DMABurstLength_18Transfers +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* TimeBase management ********************************************************/ +void TIM_DeInit(TIM_TypeDef* TIMx); +void TIM_TimeBaseInit(TIM_TypeDef* TIMx, TIM_TimeBaseInitTypeDef* TIM_TimeBaseInitStruct); +void TIM_TimeBaseStructInit(TIM_TimeBaseInitTypeDef* TIM_TimeBaseInitStruct); +void TIM_PrescalerConfig(TIM_TypeDef* TIMx, uint16_t Prescaler, uint16_t TIM_PSCReloadMode); +void TIM_CounterModeConfig(TIM_TypeDef* TIMx, uint16_t TIM_CounterMode); +void TIM_SetCounter(TIM_TypeDef* TIMx, uint32_t Counter); +void TIM_SetAutoreload(TIM_TypeDef* TIMx, uint32_t Autoreload); +uint32_t TIM_GetCounter(TIM_TypeDef* TIMx); +uint16_t TIM_GetPrescaler(TIM_TypeDef* TIMx); +void TIM_UpdateDisableConfig(TIM_TypeDef* TIMx, FunctionalState NewState); +void TIM_UpdateRequestConfig(TIM_TypeDef* TIMx, uint16_t TIM_UpdateSource); +void TIM_ARRPreloadConfig(TIM_TypeDef* TIMx, FunctionalState NewState); +void TIM_SelectOnePulseMode(TIM_TypeDef* TIMx, uint16_t TIM_OPMode); +void TIM_SetClockDivision(TIM_TypeDef* TIMx, uint16_t TIM_CKD); +void TIM_Cmd(TIM_TypeDef* TIMx, FunctionalState NewState); + +/* Advanced-control timers (TIM1) specific features*******************/ +void TIM_BDTRConfig(TIM_TypeDef* TIMx, TIM_BDTRInitTypeDef *TIM_BDTRInitStruct); +void TIM_BDTRStructInit(TIM_BDTRInitTypeDef* TIM_BDTRInitStruct); +void TIM_CtrlPWMOutputs(TIM_TypeDef* TIMx, FunctionalState NewState); + +/* Output Compare management **************************************************/ +void TIM_OC1Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct); +void TIM_OC2Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct); +void TIM_OC3Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct); +void TIM_OC4Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct); +void TIM_OCStructInit(TIM_OCInitTypeDef* TIM_OCInitStruct); +void TIM_SelectOCxM(TIM_TypeDef* TIMx, uint16_t TIM_Channel, uint16_t TIM_OCMode); +void TIM_SetCompare1(TIM_TypeDef* TIMx, uint32_t Compare1); +void TIM_SetCompare2(TIM_TypeDef* TIMx, uint32_t Compare2); +void TIM_SetCompare3(TIM_TypeDef* TIMx, uint32_t Compare3); +void TIM_SetCompare4(TIM_TypeDef* TIMx, uint32_t Compare4); +void TIM_ForcedOC1Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction); +void TIM_ForcedOC2Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction); +void TIM_ForcedOC3Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction); +void TIM_ForcedOC4Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction); +void TIM_CCPreloadControl(TIM_TypeDef* TIMx, FunctionalState NewState); +void TIM_OC1PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload); +void TIM_OC2PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload); +void TIM_OC3PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload); +void TIM_OC4PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload); +void TIM_OC1FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast); +void TIM_OC2FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast); +void TIM_OC3FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast); +void TIM_OC4FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast); +void TIM_ClearOC1Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear); +void TIM_ClearOC2Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear); +void TIM_ClearOC3Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear); +void TIM_ClearOC4Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear); +void TIM_OC1PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity); +void TIM_OC1NPolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCNPolarity); +void TIM_OC2PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity); +void TIM_OC2NPolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCNPolarity); +void TIM_OC3PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity); +void TIM_OC3NPolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCNPolarity); +void TIM_OC4PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity); +void TIM_SelectOCREFClear(TIM_TypeDef* TIMx, uint16_t TIM_OCReferenceClear); +void TIM_CCxCmd(TIM_TypeDef* TIMx, uint16_t TIM_Channel, uint16_t TIM_CCx); +void TIM_CCxNCmd(TIM_TypeDef* TIMx, uint16_t TIM_Channel, uint16_t TIM_CCxN); +void TIM_SelectCOM(TIM_TypeDef* TIMx, FunctionalState NewState); + +/* Input Capture management ***************************************************/ +void TIM_ICInit(TIM_TypeDef* TIMx, TIM_ICInitTypeDef* TIM_ICInitStruct); +void TIM_ICStructInit(TIM_ICInitTypeDef* TIM_ICInitStruct); +void TIM_PWMIConfig(TIM_TypeDef* TIMx, TIM_ICInitTypeDef* TIM_ICInitStruct); +uint32_t TIM_GetCapture1(TIM_TypeDef* TIMx); +uint32_t TIM_GetCapture2(TIM_TypeDef* TIMx); +uint32_t TIM_GetCapture3(TIM_TypeDef* TIMx); +uint32_t TIM_GetCapture4(TIM_TypeDef* TIMx); +void TIM_SetIC1Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC); +void TIM_SetIC2Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC); +void TIM_SetIC3Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC); +void TIM_SetIC4Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC); + +/* Interrupts, DMA and flags management ***************************************/ +void TIM_ITConfig(TIM_TypeDef* TIMx, uint16_t TIM_IT, FunctionalState NewState); +void TIM_GenerateEvent(TIM_TypeDef* TIMx, uint16_t TIM_EventSource); +FlagStatus TIM_GetFlagStatus(TIM_TypeDef* TIMx, uint16_t TIM_FLAG); +void TIM_ClearFlag(TIM_TypeDef* TIMx, uint16_t TIM_FLAG); +ITStatus TIM_GetITStatus(TIM_TypeDef* TIMx, uint16_t TIM_IT); +void TIM_ClearITPendingBit(TIM_TypeDef* TIMx, uint16_t TIM_IT); +void TIM_DMAConfig(TIM_TypeDef* TIMx, uint16_t TIM_DMABase, uint16_t TIM_DMABurstLength); +void TIM_DMACmd(TIM_TypeDef* TIMx, uint16_t TIM_DMASource, FunctionalState NewState); +void TIM_SelectCCDMA(TIM_TypeDef* TIMx, FunctionalState NewState); + +/* Clocks management **********************************************************/ +void TIM_InternalClockConfig(TIM_TypeDef* TIMx); +void TIM_ITRxExternalClockConfig(TIM_TypeDef* TIMx, uint16_t TIM_InputTriggerSource); +void TIM_TIxExternalClockConfig(TIM_TypeDef* TIMx, uint16_t TIM_TIxExternalCLKSource, + uint16_t TIM_ICPolarity, uint16_t ICFilter); +void TIM_ETRClockMode1Config(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, uint16_t TIM_ExtTRGPolarity, + uint16_t ExtTRGFilter); +void TIM_ETRClockMode2Config(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, + uint16_t TIM_ExtTRGPolarity, uint16_t ExtTRGFilter); + + +/* Synchronization management *************************************************/ +void TIM_SelectInputTrigger(TIM_TypeDef* TIMx, uint16_t TIM_InputTriggerSource); +void TIM_SelectOutputTrigger(TIM_TypeDef* TIMx, uint16_t TIM_TRGOSource); +void TIM_SelectSlaveMode(TIM_TypeDef* TIMx, uint16_t TIM_SlaveMode); +void TIM_SelectMasterSlaveMode(TIM_TypeDef* TIMx, uint16_t TIM_MasterSlaveMode); +void TIM_ETRConfig(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, uint16_t TIM_ExtTRGPolarity, + uint16_t ExtTRGFilter); + +/* Specific interface management **********************************************/ +void TIM_EncoderInterfaceConfig(TIM_TypeDef* TIMx, uint16_t TIM_EncoderMode, + uint16_t TIM_IC1Polarity, uint16_t TIM_IC2Polarity); +void TIM_SelectHallSensor(TIM_TypeDef* TIMx, FunctionalState NewState); + +/* Specific remapping management **********************************************/ +void TIM_RemapConfig(TIM_TypeDef* TIMx, uint16_t TIM_Remap); + + +#ifdef __cplusplus +} +#endif + +#endif /*__STM32F0XX_TIM_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_usart.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_usart.h new file mode 100644 index 00000000..85ff3c6f --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_usart.h @@ -0,0 +1,604 @@ +/** + ****************************************************************************** + * @file stm32f0xx_usart.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the USART + * firmware library. + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_USART_H +#define __STM32F0XX_USART_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup USART + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + + + +/** + * @brief USART Init Structure definition + */ + +typedef struct +{ + uint32_t USART_BaudRate; /*!< This member configures the USART communication baud rate. + The baud rate is computed using the following formula: + - IntegerDivider = ((PCLKx) / (16 * (USART_InitStruct->USART_BaudRate))) + - FractionalDivider = ((IntegerDivider - ((uint32_t) IntegerDivider)) * 16) + 0.5 */ + + uint32_t USART_WordLength; /*!< Specifies the number of data bits transmitted or received in a frame. + This parameter can be a value of @ref USART_Word_Length */ + + uint32_t USART_StopBits; /*!< Specifies the number of stop bits transmitted. + This parameter can be a value of @ref USART_Stop_Bits */ + + uint32_t USART_Parity; /*!< Specifies the parity mode. + This parameter can be a value of @ref USART_Parity + @note When parity is enabled, the computed parity is inserted + at the MSB position of the transmitted data (9th bit when + the word length is set to 9 data bits; 8th bit when the + word length is set to 8 data bits). */ + + uint32_t USART_Mode; /*!< Specifies wether the Receive or Transmit mode is enabled or disabled. + This parameter can be a value of @ref USART_Mode */ + + uint32_t USART_HardwareFlowControl; /*!< Specifies wether the hardware flow control mode is enabled + or disabled. + This parameter can be a value of @ref USART_Hardware_Flow_Control*/ +} USART_InitTypeDef; + +/** + * @brief USART Clock Init Structure definition + */ + +typedef struct +{ + uint32_t USART_Clock; /*!< Specifies whether the USART clock is enabled or disabled. + This parameter can be a value of @ref USART_Clock */ + + uint32_t USART_CPOL; /*!< Specifies the steady state of the serial clock. + This parameter can be a value of @ref USART_Clock_Polarity */ + + uint32_t USART_CPHA; /*!< Specifies the clock transition on which the bit capture is made. + This parameter can be a value of @ref USART_Clock_Phase */ + + uint32_t USART_LastBit; /*!< Specifies whether the clock pulse corresponding to the last transmitted + data bit (MSB) has to be output on the SCLK pin in synchronous mode. + This parameter can be a value of @ref USART_Last_Bit */ +} USART_ClockInitTypeDef; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup USART_Exported_Constants + * @{ + */ + +#define IS_USART_ALL_PERIPH(PERIPH) (((PERIPH) == USART1) || \ + ((PERIPH) == USART2) || \ + ((PERIPH) == USART3) || \ + ((PERIPH) == USART4) || \ + ((PERIPH) == USART5) || \ + ((PERIPH) == USART6) || \ + ((PERIPH) == USART7) || \ + ((PERIPH) == USART8)) + +#define IS_USART_123_PERIPH(PERIPH) (((PERIPH) == USART1) || \ + ((PERIPH) == USART2) || \ + ((PERIPH) == USART3)) + +/** @defgroup USART_Word_Length + * @{ + */ + +#define USART_WordLength_8b ((uint32_t)0x00000000) +#define USART_WordLength_9b USART_CR1_M /* should be ((uint32_t)0x00001000) */ +#define USART_WordLength_7b ((uint32_t)0x10001000) /*!< only available for STM32F072 and STM32F030 devices */ +#define IS_USART_WORD_LENGTH(LENGTH) (((LENGTH) == USART_WordLength_8b) || \ + ((LENGTH) == USART_WordLength_9b) || \ + ((LENGTH) == USART_WordLength_7b)) +/** + * @} + */ + +/** @defgroup USART_Stop_Bits + * @{ + */ + +#define USART_StopBits_1 ((uint32_t)0x00000000) +#define USART_StopBits_2 USART_CR2_STOP_1 +#define USART_StopBits_1_5 (USART_CR2_STOP_0 | USART_CR2_STOP_1) +#define IS_USART_STOPBITS(STOPBITS) (((STOPBITS) == USART_StopBits_1) || \ + ((STOPBITS) == USART_StopBits_2) || \ + ((STOPBITS) == USART_StopBits_1_5)) +/** + * @} + */ + +/** @defgroup USART_Parity + * @{ + */ + +#define USART_Parity_No ((uint32_t)0x00000000) +#define USART_Parity_Even USART_CR1_PCE +#define USART_Parity_Odd (USART_CR1_PCE | USART_CR1_PS) +#define IS_USART_PARITY(PARITY) (((PARITY) == USART_Parity_No) || \ + ((PARITY) == USART_Parity_Even) || \ + ((PARITY) == USART_Parity_Odd)) +/** + * @} + */ + +/** @defgroup USART_Mode + * @{ + */ + +#define USART_Mode_Rx USART_CR1_RE +#define USART_Mode_Tx USART_CR1_TE +#define IS_USART_MODE(MODE) ((((MODE) & (uint32_t)0xFFFFFFF3) == 0x00) && \ + ((MODE) != (uint32_t)0x00)) +/** + * @} + */ + +/** @defgroup USART_Hardware_Flow_Control + * @{ + */ + +#define USART_HardwareFlowControl_None ((uint32_t)0x00000000) +#define USART_HardwareFlowControl_RTS USART_CR3_RTSE +#define USART_HardwareFlowControl_CTS USART_CR3_CTSE +#define USART_HardwareFlowControl_RTS_CTS (USART_CR3_RTSE | USART_CR3_CTSE) +#define IS_USART_HARDWARE_FLOW_CONTROL(CONTROL)\ + (((CONTROL) == USART_HardwareFlowControl_None) || \ + ((CONTROL) == USART_HardwareFlowControl_RTS) || \ + ((CONTROL) == USART_HardwareFlowControl_CTS) || \ + ((CONTROL) == USART_HardwareFlowControl_RTS_CTS)) +/** + * @} + */ + +/** @defgroup USART_Clock + * @{ + */ + +#define USART_Clock_Disable ((uint32_t)0x00000000) +#define USART_Clock_Enable USART_CR2_CLKEN +#define IS_USART_CLOCK(CLOCK) (((CLOCK) == USART_Clock_Disable) || \ + ((CLOCK) == USART_Clock_Enable)) +/** + * @} + */ + +/** @defgroup USART_Clock_Polarity + * @{ + */ + +#define USART_CPOL_Low ((uint32_t)0x00000000) +#define USART_CPOL_High USART_CR2_CPOL +#define IS_USART_CPOL(CPOL) (((CPOL) == USART_CPOL_Low) || ((CPOL) == USART_CPOL_High)) + +/** + * @} + */ + +/** @defgroup USART_Clock_Phase + * @{ + */ + +#define USART_CPHA_1Edge ((uint32_t)0x00000000) +#define USART_CPHA_2Edge USART_CR2_CPHA +#define IS_USART_CPHA(CPHA) (((CPHA) == USART_CPHA_1Edge) || ((CPHA) == USART_CPHA_2Edge)) + +/** + * @} + */ + +/** @defgroup USART_Last_Bit + * @{ + */ + +#define USART_LastBit_Disable ((uint32_t)0x00000000) +#define USART_LastBit_Enable USART_CR2_LBCL +#define IS_USART_LASTBIT(LASTBIT) (((LASTBIT) == USART_LastBit_Disable) || \ + ((LASTBIT) == USART_LastBit_Enable)) +/** + * @} + */ + +/** @defgroup USART_DMA_Requests + * @{ + */ + +#define USART_DMAReq_Tx USART_CR3_DMAT +#define USART_DMAReq_Rx USART_CR3_DMAR +#define IS_USART_DMAREQ(DMAREQ) ((((DMAREQ) & (uint32_t)0xFFFFFF3F) == 0x00) && \ + ((DMAREQ) != (uint32_t)0x00)) + +/** + * @} + */ + +/** @defgroup USART_DMA_Recception_Error + * @{ + */ + +#define USART_DMAOnError_Enable ((uint32_t)0x00000000) +#define USART_DMAOnError_Disable USART_CR3_DDRE +#define IS_USART_DMAONERROR(DMAERROR) (((DMAERROR) == USART_DMAOnError_Disable)|| \ + ((DMAERROR) == USART_DMAOnError_Enable)) +/** + * @} + */ + +/** @defgroup USART_MuteMode_WakeUp_methods + * @{ + */ + +#define USART_WakeUp_IdleLine ((uint32_t)0x00000000) +#define USART_WakeUp_AddressMark USART_CR1_WAKE +#define IS_USART_MUTEMODE_WAKEUP(WAKEUP) (((WAKEUP) == USART_WakeUp_IdleLine) || \ + ((WAKEUP) == USART_WakeUp_AddressMark)) +/** + * @} + */ + +/** @defgroup USART_Address_Detection + * @{ + */ + +#define USART_AddressLength_4b ((uint32_t)0x00000000) +#define USART_AddressLength_7b USART_CR2_ADDM7 +#define IS_USART_ADDRESS_DETECTION(ADDRESS) (((ADDRESS) == USART_AddressLength_4b) || \ + ((ADDRESS) == USART_AddressLength_7b)) +/** + * @} + */ + +/** @defgroup USART_StopMode_WakeUp_methods + * @note These parameters are only available for STM32F051 and STM32F072 devices + * @{ + */ + +#define USART_WakeUpSource_AddressMatch ((uint32_t)0x00000000) +#define USART_WakeUpSource_StartBit USART_CR3_WUS_1 +#define USART_WakeUpSource_RXNE (USART_CR3_WUS_0 | USART_CR3_WUS_1) +#define IS_USART_STOPMODE_WAKEUPSOURCE(SOURCE) (((SOURCE) == USART_WakeUpSource_AddressMatch) || \ + ((SOURCE) == USART_WakeUpSource_StartBit) || \ + ((SOURCE) == USART_WakeUpSource_RXNE)) +/** + * @} + */ + +/** @defgroup USART_LIN_Break_Detection_Length + * @{ + */ + +#define USART_LINBreakDetectLength_10b ((uint32_t)0x00000000) +#define USART_LINBreakDetectLength_11b USART_CR2_LBDL +#define IS_USART_LIN_BREAK_DETECT_LENGTH(LENGTH) \ + (((LENGTH) == USART_LINBreakDetectLength_10b) || \ + ((LENGTH) == USART_LINBreakDetectLength_11b)) +/** + * @} + */ + +/** @defgroup USART_IrDA_Low_Power + * @{ + */ + +#define USART_IrDAMode_LowPower USART_CR3_IRLP +#define USART_IrDAMode_Normal ((uint32_t)0x00000000) +#define IS_USART_IRDA_MODE(MODE) (((MODE) == USART_IrDAMode_LowPower) || \ + ((MODE) == USART_IrDAMode_Normal)) +/** + * @} + */ + +/** @defgroup USART_DE_Polarity + * @{ + */ + +#define USART_DEPolarity_High ((uint32_t)0x00000000) +#define USART_DEPolarity_Low USART_CR3_DEP +#define IS_USART_DE_POLARITY(POLARITY) (((POLARITY) == USART_DEPolarity_Low) || \ + ((POLARITY) == USART_DEPolarity_High)) +/** + * @} + */ + +/** @defgroup USART_Inversion_Pins + * @{ + */ + +#define USART_InvPin_Tx USART_CR2_TXINV +#define USART_InvPin_Rx USART_CR2_RXINV +#define IS_USART_INVERSTION_PIN(PIN) ((((PIN) & (uint32_t)0xFFFCFFFF) == 0x00) && \ + ((PIN) != (uint32_t)0x00)) + +/** + * @} + */ + +/** @defgroup USART_AutoBaudRate_Mode + * @{ + */ + +#define USART_AutoBaudRate_StartBit ((uint32_t)0x00000000) +#define USART_AutoBaudRate_FallingEdge USART_CR2_ABRMODE_0 +#define IS_USART_AUTOBAUDRATE_MODE(MODE) (((MODE) == USART_AutoBaudRate_StartBit) || \ + ((MODE) == USART_AutoBaudRate_FallingEdge)) +/** + * @} + */ + +/** @defgroup USART_OVR_DETECTION + * @{ + */ + +#define USART_OVRDetection_Enable ((uint32_t)0x00000000) +#define USART_OVRDetection_Disable USART_CR3_OVRDIS +#define IS_USART_OVRDETECTION(OVR) (((OVR) == USART_OVRDetection_Enable)|| \ + ((OVR) == USART_OVRDetection_Disable)) +/** + * @} + */ +/** @defgroup USART_Request + * @{ + */ + +#define USART_Request_ABRRQ USART_RQR_ABRRQ +#define USART_Request_SBKRQ USART_RQR_SBKRQ +#define USART_Request_MMRQ USART_RQR_MMRQ +#define USART_Request_RXFRQ USART_RQR_RXFRQ +#define USART_Request_TXFRQ USART_RQR_TXFRQ + +#define IS_USART_REQUEST(REQUEST) (((REQUEST) == USART_Request_TXFRQ) || \ + ((REQUEST) == USART_Request_RXFRQ) || \ + ((REQUEST) == USART_Request_MMRQ) || \ + ((REQUEST) == USART_Request_SBKRQ) || \ + ((REQUEST) == USART_Request_ABRRQ)) +/** + * @} + */ + +/** @defgroup USART_Flags + * @{ + */ +#define USART_FLAG_REACK USART_ISR_REACK +#define USART_FLAG_TEACK USART_ISR_TEACK +#define USART_FLAG_WU USART_ISR_WUF /*!< Not available for STM32F030 devices */ +#define USART_FLAG_RWU USART_ISR_RWU /*!< Not available for STM32F030 devices */ +#define USART_FLAG_SBK USART_ISR_SBKF +#define USART_FLAG_CM USART_ISR_CMF +#define USART_FLAG_BUSY USART_ISR_BUSY +#define USART_FLAG_ABRF USART_ISR_ABRF +#define USART_FLAG_ABRE USART_ISR_ABRE +#define USART_FLAG_EOB USART_ISR_EOBF /*!< Not available for STM32F030 devices */ +#define USART_FLAG_RTO USART_ISR_RTOF +#define USART_FLAG_nCTSS USART_ISR_CTS +#define USART_FLAG_CTS USART_ISR_CTSIF +#define USART_FLAG_LBD USART_ISR_LBD /*!< Not available for STM32F030 devices */ +#define USART_FLAG_TXE USART_ISR_TXE +#define USART_FLAG_TC USART_ISR_TC +#define USART_FLAG_RXNE USART_ISR_RXNE +#define USART_FLAG_IDLE USART_ISR_IDLE +#define USART_FLAG_ORE USART_ISR_ORE +#define USART_FLAG_NE USART_ISR_NE +#define USART_FLAG_FE USART_ISR_FE +#define USART_FLAG_PE USART_ISR_PE +#define IS_USART_FLAG(FLAG) (((FLAG) == USART_FLAG_PE) || ((FLAG) == USART_FLAG_TXE) || \ + ((FLAG) == USART_FLAG_TC) || ((FLAG) == USART_FLAG_RXNE) || \ + ((FLAG) == USART_FLAG_IDLE) || ((FLAG) == USART_FLAG_LBD) || \ + ((FLAG) == USART_FLAG_CTS) || ((FLAG) == USART_FLAG_ORE) || \ + ((FLAG) == USART_FLAG_NE) || ((FLAG) == USART_FLAG_FE) || \ + ((FLAG) == USART_FLAG_nCTSS) || ((FLAG) == USART_FLAG_RTO) || \ + ((FLAG) == USART_FLAG_EOB) || ((FLAG) == USART_FLAG_ABRE) || \ + ((FLAG) == USART_FLAG_ABRF) || ((FLAG) == USART_FLAG_BUSY) || \ + ((FLAG) == USART_FLAG_CM) || ((FLAG) == USART_FLAG_SBK) || \ + ((FLAG) == USART_FLAG_RWU) || ((FLAG) == USART_FLAG_WU) || \ + ((FLAG) == USART_FLAG_TEACK)|| ((FLAG) == USART_FLAG_REACK)) + +#define IS_USART_CLEAR_FLAG(FLAG) (((FLAG) == USART_FLAG_WU) || ((FLAG) == USART_FLAG_TC) || \ + ((FLAG) == USART_FLAG_IDLE) || ((FLAG) == USART_FLAG_ORE) || \ + ((FLAG) == USART_FLAG_NE) || ((FLAG) == USART_FLAG_FE) || \ + ((FLAG) == USART_FLAG_LBD) || ((FLAG) == USART_FLAG_CTS) || \ + ((FLAG) == USART_FLAG_RTO) || ((FLAG) == USART_FLAG_EOB) || \ + ((FLAG) == USART_FLAG_CM) || ((FLAG) == USART_FLAG_PE)) +/** + * @} + */ + +/** @defgroup USART_Interrupt_definition + * @brief USART Interrupt definition + * USART_IT possible values + * Elements values convention: 0xZZZZYYXX + * XX: Position of the corresponding Interrupt + * YY: Register index + * ZZZZ: Flag position + * @{ + */ + +#define USART_IT_WU ((uint32_t)0x00140316) /*!< Not available for STM32F030 devices */ +#define USART_IT_CM ((uint32_t)0x0011010E) +#define USART_IT_EOB ((uint32_t)0x000C011B) /*!< Not available for STM32F030 devices */ +#define USART_IT_RTO ((uint32_t)0x000B011A) +#define USART_IT_PE ((uint32_t)0x00000108) +#define USART_IT_TXE ((uint32_t)0x00070107) +#define USART_IT_TC ((uint32_t)0x00060106) +#define USART_IT_RXNE ((uint32_t)0x00050105) +#define USART_IT_IDLE ((uint32_t)0x00040104) +#define USART_IT_LBD ((uint32_t)0x00080206) /*!< Not available for STM32F030 devices */ +#define USART_IT_CTS ((uint32_t)0x0009030A) +#define USART_IT_ERR ((uint32_t)0x00000300) +#define USART_IT_ORE ((uint32_t)0x00030300) +#define USART_IT_NE ((uint32_t)0x00020300) +#define USART_IT_FE ((uint32_t)0x00010300) + +#define IS_USART_CONFIG_IT(IT) (((IT) == USART_IT_PE) || ((IT) == USART_IT_TXE) || \ + ((IT) == USART_IT_TC) || ((IT) == USART_IT_RXNE) || \ + ((IT) == USART_IT_IDLE) || ((IT) == USART_IT_LBD) || \ + ((IT) == USART_IT_CTS) || ((IT) == USART_IT_ERR) || \ + ((IT) == USART_IT_RTO) || ((IT) == USART_IT_EOB) || \ + ((IT) == USART_IT_CM) || ((IT) == USART_IT_WU)) + +#define IS_USART_GET_IT(IT) (((IT) == USART_IT_PE) || ((IT) == USART_IT_TXE) || \ + ((IT) == USART_IT_TC) || ((IT) == USART_IT_RXNE) || \ + ((IT) == USART_IT_IDLE) || ((IT) == USART_IT_LBD) || \ + ((IT) == USART_IT_CTS) || ((IT) == USART_IT_ORE) || \ + ((IT) == USART_IT_NE) || ((IT) == USART_IT_FE) || \ + ((IT) == USART_IT_RTO) || ((IT) == USART_IT_EOB) || \ + ((IT) == USART_IT_CM) || ((IT) == USART_IT_WU)) + +#define IS_USART_CLEAR_IT(IT) (((IT) == USART_IT_TC) || ((IT) == USART_IT_PE) || \ + ((IT) == USART_IT_FE) || ((IT) == USART_IT_NE) || \ + ((IT) == USART_IT_ORE) || ((IT) == USART_IT_IDLE) || \ + ((IT) == USART_IT_LBD) || ((IT) == USART_IT_CTS) || \ + ((IT) == USART_IT_RTO) || ((IT) == USART_IT_EOB) || \ + ((IT) == USART_IT_CM) || ((IT) == USART_IT_WU)) +/** + * @} + */ + +/** @defgroup USART_Global_definition + * @{ + */ + +#define IS_USART_BAUDRATE(BAUDRATE) (((BAUDRATE) > 0) && ((BAUDRATE) < 0x005B8D81)) +#define IS_USART_DE_ASSERTION_DEASSERTION_TIME(TIME) ((TIME) <= 0x1F) +#define IS_USART_AUTO_RETRY_COUNTER(COUNTER) ((COUNTER) <= 0x7) +#define IS_USART_TIMEOUT(TIMEOUT) ((TIMEOUT) <= 0x00FFFFFF) +#define IS_USART_DATA(DATA) ((DATA) <= 0x1FF) + +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Initialization and Configuration functions *********************************/ +void USART_DeInit(USART_TypeDef* USARTx); +void USART_Init(USART_TypeDef* USARTx, USART_InitTypeDef* USART_InitStruct); +void USART_StructInit(USART_InitTypeDef* USART_InitStruct); +void USART_ClockInit(USART_TypeDef* USARTx, USART_ClockInitTypeDef* USART_ClockInitStruct); +void USART_ClockStructInit(USART_ClockInitTypeDef* USART_ClockInitStruct); +void USART_Cmd(USART_TypeDef* USARTx, FunctionalState NewState); +void USART_DirectionModeCmd(USART_TypeDef* USARTx, uint32_t USART_DirectionMode, FunctionalState NewState); +void USART_SetPrescaler(USART_TypeDef* USARTx, uint8_t USART_Prescaler); /* Not available for STM32F030 devices */ +void USART_OverSampling8Cmd(USART_TypeDef* USARTx, FunctionalState NewState); +void USART_OneBitMethodCmd(USART_TypeDef* USARTx, FunctionalState NewState); +void USART_MSBFirstCmd(USART_TypeDef* USARTx, FunctionalState NewState); +void USART_DataInvCmd(USART_TypeDef* USARTx, FunctionalState NewState); +void USART_InvPinCmd(USART_TypeDef* USARTx, uint32_t USART_InvPin, FunctionalState NewState); +void USART_SWAPPinCmd(USART_TypeDef* USARTx, FunctionalState NewState); +void USART_ReceiverTimeOutCmd(USART_TypeDef* USARTx, FunctionalState NewState); +void USART_SetReceiverTimeOut(USART_TypeDef* USARTx, uint32_t USART_ReceiverTimeOut); + +/* STOP Mode functions ********************************************************/ +void USART_STOPModeCmd(USART_TypeDef* USARTx, FunctionalState NewState); +void USART_StopModeWakeUpSourceConfig(USART_TypeDef* USARTx, uint32_t USART_WakeUpSource); /* Not available for STM32F030 devices */ + +/* AutoBaudRate functions *****************************************************/ +void USART_AutoBaudRateCmd(USART_TypeDef* USARTx, FunctionalState NewState); +void USART_AutoBaudRateConfig(USART_TypeDef* USARTx, uint32_t USART_AutoBaudRate); + +/* Data transfers functions ***************************************************/ +void USART_SendData(USART_TypeDef* USARTx, uint16_t Data); +uint16_t USART_ReceiveData(USART_TypeDef* USARTx); + +/* Multi-Processor Communication functions ************************************/ +void USART_SetAddress(USART_TypeDef* USARTx, uint8_t USART_Address); +void USART_MuteModeWakeUpConfig(USART_TypeDef* USARTx, uint32_t USART_WakeUp); +void USART_MuteModeCmd(USART_TypeDef* USARTx, FunctionalState NewState); +void USART_AddressDetectionConfig(USART_TypeDef* USARTx, uint32_t USART_AddressLength); + +/* LIN mode functions *********************************************************/ +void USART_LINBreakDetectLengthConfig(USART_TypeDef* USARTx, uint32_t USART_LINBreakDetectLength); /* Not available for STM32F030 devices */ +void USART_LINCmd(USART_TypeDef* USARTx, FunctionalState NewState); /* Not available for STM32F030 devices */ + +/* Half-duplex mode function **************************************************/ +void USART_HalfDuplexCmd(USART_TypeDef* USARTx, FunctionalState NewState); + +/* Smartcard mode functions ***************************************************/ +void USART_SmartCardCmd(USART_TypeDef* USARTx, FunctionalState NewState); /* Not available for STM32F030 devices */ +void USART_SmartCardNACKCmd(USART_TypeDef* USARTx, FunctionalState NewState); /* Not available for STM32F030 devices */ +void USART_SetGuardTime(USART_TypeDef* USARTx, uint8_t USART_GuardTime); /* Not available for STM32F030 devices */ +void USART_SetAutoRetryCount(USART_TypeDef* USARTx, uint8_t USART_AutoCount); /* Not available for STM32F030 devices */ +void USART_SetBlockLength(USART_TypeDef* USARTx, uint8_t USART_BlockLength); /* Not available for STM32F030 devices */ + +/* IrDA mode functions ********************************************************/ +void USART_IrDAConfig(USART_TypeDef* USARTx, uint32_t USART_IrDAMode); /* Not available for STM32F030 devices */ +void USART_IrDACmd(USART_TypeDef* USARTx, FunctionalState NewState); /* Not available for STM32F030 devices */ + +/* RS485 mode functions *******************************************************/ +void USART_DECmd(USART_TypeDef* USARTx, FunctionalState NewState); +void USART_DEPolarityConfig(USART_TypeDef* USARTx, uint32_t USART_DEPolarity); +void USART_SetDEAssertionTime(USART_TypeDef* USARTx, uint32_t USART_DEAssertionTime); +void USART_SetDEDeassertionTime(USART_TypeDef* USARTx, uint32_t USART_DEDeassertionTime); + +/* DMA transfers management functions *****************************************/ +void USART_DMACmd(USART_TypeDef* USARTx, uint32_t USART_DMAReq, FunctionalState NewState); +void USART_DMAReceptionErrorConfig(USART_TypeDef* USARTx, uint32_t USART_DMAOnError); + +/* Interrupts and flags management functions **********************************/ +void USART_ITConfig(USART_TypeDef* USARTx, uint32_t USART_IT, FunctionalState NewState); +void USART_RequestCmd(USART_TypeDef* USARTx, uint32_t USART_Request, FunctionalState NewState); +void USART_OverrunDetectionConfig(USART_TypeDef* USARTx, uint32_t USART_OVRDetection); +FlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, uint32_t USART_FLAG); +void USART_ClearFlag(USART_TypeDef* USARTx, uint32_t USART_FLAG); +ITStatus USART_GetITStatus(USART_TypeDef* USARTx, uint32_t USART_IT); +void USART_ClearITPendingBit(USART_TypeDef* USARTx, uint32_t USART_IT); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_USART_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_wwdg.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_wwdg.h new file mode 100644 index 00000000..435fcb27 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/inc/stm32f0xx_wwdg.h @@ -0,0 +1,109 @@ +/** + ****************************************************************************** + * @file stm32f0xx_wwdg.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the WWDG + * firmware library. + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_WWDG_H +#define __STM32F0XX_WWDG_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup WWDG + * @{ + */ +/* Exported types ------------------------------------------------------------*/ +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup WWDG_Exported_Constants + * @{ + */ + +/** @defgroup WWDG_Prescaler + * @{ + */ + +#define WWDG_Prescaler_1 ((uint32_t)0x00000000) +#define WWDG_Prescaler_2 ((uint32_t)0x00000080) +#define WWDG_Prescaler_4 ((uint32_t)0x00000100) +#define WWDG_Prescaler_8 ((uint32_t)0x00000180) +#define IS_WWDG_PRESCALER(PRESCALER) (((PRESCALER) == WWDG_Prescaler_1) || \ + ((PRESCALER) == WWDG_Prescaler_2) || \ + ((PRESCALER) == WWDG_Prescaler_4) || \ + ((PRESCALER) == WWDG_Prescaler_8)) +#define IS_WWDG_WINDOW_VALUE(VALUE) ((VALUE) <= 0x7F) +#define IS_WWDG_COUNTER(COUNTER) (((COUNTER) >= 0x40) && ((COUNTER) <= 0x7F)) + +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ +/* Function used to set the WWDG configuration to the default reset state ****/ +void WWDG_DeInit(void); + +/* Prescaler, Refresh window and Counter configuration functions **************/ +void WWDG_SetPrescaler(uint32_t WWDG_Prescaler); +void WWDG_SetWindowValue(uint8_t WindowValue); +void WWDG_EnableIT(void); +void WWDG_SetCounter(uint8_t Counter); + +/* WWDG activation functions **************************************************/ +void WWDG_Enable(uint8_t Counter); + +/* Interrupts and flags management functions **********************************/ +FlagStatus WWDG_GetFlagStatus(void); +void WWDG_ClearFlag(void); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_WWDG_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_adc.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_adc.c new file mode 100644 index 00000000..e0f13358 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_adc.c @@ -0,0 +1,1240 @@ +/** + ****************************************************************************** + * @file stm32f0xx_adc.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Analog to Digital Convertor (ADC) peripheral: + * + Initialization and Configuration + * + Power saving + * + Analog Watchdog configuration + * + Temperature Sensor, Vrefint (Internal Reference Voltage) and + * Vbat (Voltage battery) management + * + ADC Channels Configuration + * + ADC Channels DMA Configuration + * + Interrupts and flags management + * + * @verbatim +================================================================================ + ##### How to use this driver ##### +================================================================================ + [..] + (#) Enable the ADC interface clock using + RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE); + (#) ADC pins configuration + (++) Enable the clock for the ADC GPIOs using the following function: + RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOx, ENABLE); + (++) Configure these ADC pins in analog mode using GPIO_Init(); + (#) Configure the ADC conversion resolution, data alignment, external + trigger and edge, scan direction and Enable/Disable the continuous mode + using the ADC_Init() function. + (#) Activate the ADC peripheral using ADC_Cmd() function. + + *** ADC channels group configuration *** + ============================================ + [..] + (+) To configure the ADC channels features, use ADC_Init() and + ADC_ChannelConfig() functions. + (+) To activate the continuous mode, use the ADC_ContinuousModeCmd() + function. + (+) To activate the Discontinuous mode, use the ADC_DiscModeCmd() functions. + (+) To activate the overrun mode, use the ADC_OverrunModeCmd() functions. + (+) To activate the calibration mode, use the ADC_GetCalibrationFactor() functions. + (+) To read the ADC converted values, use the ADC_GetConversionValue() + function. + + *** DMA for ADC channels features configuration *** + ============================================================= + [..] + (+) To enable the DMA mode for ADC channels group, use the ADC_DMACmd() function. + (+) To configure the DMA transfer request, use ADC_DMARequestModeConfig() function. + + * @endverbatim + * + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_adc.h" +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup ADC + * @brief ADC driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* ADC CFGR mask */ +#define CFGR1_CLEAR_MASK ((uint32_t)0xFFFFD203) + +/* Calibration time out */ +#define CALIBRATION_TIMEOUT ((uint32_t)0x0000F000) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup ADC_Private_Functions + * @{ + */ + +/** @defgroup ADC_Group1 Initialization and Configuration functions + * @brief Initialization and Configuration functions + * +@verbatim + =============================================================================== + ##### Initialization and Configuration functions ##### + =============================================================================== + [..] This section provides functions allowing to: + (+) Initialize and configure the ADC Prescaler + (+) ADC Conversion Resolution (12bit..6bit) + (+) ADC Continuous Conversion Mode (Continuous or Single conversion) + (+) External trigger Edge and source + (+) Converted data alignment (left or right) + (+) The direction in which the channels will be scanned in the sequence + (+) Enable or disable the ADC peripheral + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes ADC1 peripheral registers to their default reset values. + * @param ADCx: where x can be 1 to select the ADC peripheral. + * @retval None + */ +void ADC_DeInit(ADC_TypeDef* ADCx) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + + if(ADCx == ADC1) + { + /* Enable ADC1 reset state */ + RCC_APB2PeriphResetCmd(RCC_APB2Periph_ADC1, ENABLE); + + /* Release ADC1 from reset state */ + RCC_APB2PeriphResetCmd(RCC_APB2Periph_ADC1, DISABLE); + } +} + +/** + * @brief Initializes the ADCx peripheral according to the specified parameters + * in the ADC_InitStruct. + * @note This function is used to configure the global features of the ADC ( + * Resolution, Data Alignment, continuous mode activation, External + * trigger source and edge, Sequence Scan Direction). + * @param ADCx: where x can be 1 to select the ADC peripheral. + * @param ADC_InitStruct: pointer to an ADC_InitTypeDef structure that contains + * the configuration information for the specified ADC peripheral. + * @retval None + */ +void ADC_Init(ADC_TypeDef* ADCx, ADC_InitTypeDef* ADC_InitStruct) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_ADC_RESOLUTION(ADC_InitStruct->ADC_Resolution)); + assert_param(IS_FUNCTIONAL_STATE(ADC_InitStruct->ADC_ContinuousConvMode)); + assert_param(IS_ADC_EXT_TRIG_EDGE(ADC_InitStruct->ADC_ExternalTrigConvEdge)); + assert_param(IS_ADC_EXTERNAL_TRIG_CONV(ADC_InitStruct->ADC_ExternalTrigConv)); + assert_param(IS_ADC_DATA_ALIGN(ADC_InitStruct->ADC_DataAlign)); + assert_param(IS_ADC_SCAN_DIRECTION(ADC_InitStruct->ADC_ScanDirection)); + + /* Get the ADCx CFGR value */ + tmpreg = ADCx->CFGR1; + + /* Clear SCANDIR, RES[1:0], ALIGN, EXTSEL[2:0], EXTEN[1:0] and CONT bits */ + tmpreg &= CFGR1_CLEAR_MASK; + + /*---------------------------- ADCx CFGR Configuration ---------------------*/ + + /* Set RES[1:0] bits according to ADC_Resolution value */ + /* Set CONT bit according to ADC_ContinuousConvMode value */ + /* Set EXTEN[1:0] bits according to ADC_ExternalTrigConvEdge value */ + /* Set EXTSEL[2:0] bits according to ADC_ExternalTrigConv value */ + /* Set ALIGN bit according to ADC_DataAlign value */ + /* Set SCANDIR bit according to ADC_ScanDirection value */ + + tmpreg |= (uint32_t)(ADC_InitStruct->ADC_Resolution | ((uint32_t)(ADC_InitStruct->ADC_ContinuousConvMode) << 13) | + ADC_InitStruct->ADC_ExternalTrigConvEdge | ADC_InitStruct->ADC_ExternalTrigConv | + ADC_InitStruct->ADC_DataAlign | ADC_InitStruct->ADC_ScanDirection); + + /* Write to ADCx CFGR */ + ADCx->CFGR1 = tmpreg; +} + +/** + * @brief Fills each ADC_InitStruct member with its default value. + * @note This function is used to initialize the global features of the ADC ( + * Resolution, Data Alignment, continuous mode activation, External + * trigger source and edge, Sequence Scan Direction). + * @param ADC_InitStruct: pointer to an ADC_InitTypeDef structure which will + * be initialized. + * @retval None + */ +void ADC_StructInit(ADC_InitTypeDef* ADC_InitStruct) +{ + /* Reset ADC init structure parameters values */ + /* Initialize the ADC_Resolution member */ + ADC_InitStruct->ADC_Resolution = ADC_Resolution_12b; + + /* Initialize the ADC_ContinuousConvMode member */ + ADC_InitStruct->ADC_ContinuousConvMode = DISABLE; + + /* Initialize the ADC_ExternalTrigConvEdge member */ + ADC_InitStruct->ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_None; + + /* Initialize the ADC_ExternalTrigConv member */ + ADC_InitStruct->ADC_ExternalTrigConv = ADC_ExternalTrigConv_T1_TRGO; + + /* Initialize the ADC_DataAlign member */ + ADC_InitStruct->ADC_DataAlign = ADC_DataAlign_Right; + + /* Initialize the ADC_ScanDirection member */ + ADC_InitStruct->ADC_ScanDirection = ADC_ScanDirection_Upward; +} + +/** + * @brief Enables or disables the specified ADC peripheral. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param NewState: new state of the ADCx peripheral. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_Cmd(ADC_TypeDef* ADCx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Set the ADEN bit to Enable the ADC peripheral */ + ADCx->CR |= (uint32_t)ADC_CR_ADEN; + } + else + { + /* Set the ADDIS to Disable the ADC peripheral */ + ADCx->CR |= (uint32_t)ADC_CR_ADDIS; + } +} + +/** + * @brief Configure the ADC to either be clocked by the asynchronous clock(which is + * independent, the dedicated 14MHz clock) or the synchronous clock derived from + * the APB clock of the ADC bus interface divided by 2 or 4 + * @note This function can be called only when ADC is disabled. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param ADC_ClockMode: This parameter can be : + * @arg ADC_ClockMode_AsynClk: ADC clocked by the dedicated 14MHz clock + * @arg ADC_ClockMode_SynClkDiv2: ADC clocked by PCLK/2 + * @arg ADC_ClockMode_SynClkDiv4: ADC clocked by PCLK/4 + * @retval None + */ +void ADC_ClockModeConfig(ADC_TypeDef* ADCx, uint32_t ADC_ClockMode) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_ADC_CLOCKMODE(ADC_ClockMode)); + + /* Configure the ADC Clock mode according to ADC_ClockMode */ + ADCx->CFGR2 = (uint32_t)ADC_ClockMode; + +} + +/** + * @brief Enables or disables the jitter when the ADC is clocked by PCLK div2 + * or div4 + * @note This function is obsolete and maintained for legacy purpose only. ADC_ClockModeConfig() + * function should be used instead. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param ADC_JitterOff: This parameter can be : + * @arg ADC_JitterOff_PCLKDiv2: Remove jitter when ADC is clocked by PLCK divided by 2 + * @arg ADC_JitterOff_PCLKDiv4: Remove jitter when ADC is clocked by PLCK divided by 4 + * @param NewState: new state of the ADCx jitter. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_JitterCmd(ADC_TypeDef* ADCx, uint32_t ADC_JitterOff, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_ADC_JITTEROFF(ADC_JitterOff)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Disable Jitter */ + ADCx->CFGR2 |= (uint32_t)ADC_JitterOff; + } + else + { + /* Enable Jitter */ + ADCx->CFGR2 &= (uint32_t)(~ADC_JitterOff); + } +} + +/** + * @} + */ + +/** @defgroup ADC_Group2 Power saving functions + * @brief Power saving functions + * +@verbatim + =============================================================================== + ##### Power saving functions ##### + =============================================================================== + [..] This section provides functions allowing to reduce power consumption. + [..] The two function must be combined to get the maximal benefits: + When the ADC frequency is higher than the CPU one, it is recommended to + (#) Enable the Auto Delayed Conversion mode : + ==> using ADC_WaitModeCmd(ADC_TypeDef* ADCx, FunctionalState NewState); + (#) Enable the power off in Delay phases : + ==> using ADC_AutoPowerOffCmd(ADC_TypeDef* ADCx, FunctionalState NewState); + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the ADC Power Off. + * @note ADC power-on and power-off can be managed by hardware to cut the + * consumption when the ADC is not converting. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @note The ADC can be powered down: + * - During the Auto delay phase: The ADC is powered on again at the end + * of the delay (until the previous data is read from the ADC data register). + * - During the ADC is waiting for a trigger event: The ADC is powered up + * at the next trigger event (when the conversion is started). + * @param NewState: new state of the ADCx power Off. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_AutoPowerOffCmd(ADC_TypeDef* ADCx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the ADC Automatic Power-Off */ + ADCx->CFGR1 |= ADC_CFGR1_AUTOFF; + } + else + { + /* Disable the ADC Automatic Power-Off */ + ADCx->CFGR1 &= (uint32_t)~ADC_CFGR1_AUTOFF; + } +} + +/** + * @brief Enables or disables the Wait conversion mode. + * @note When the CPU clock is not fast enough to manage the data rate, a + * Hardware delay can be introduced between ADC conversions to reduce + * this data rate. + * @note The Hardware delay is inserted after each conversions and until the + * previous data is read from the ADC data register + * @note This is a way to automatically adapt the speed of the ADC to the speed + * of the system which will read the data. + * @note Any hardware triggers wich occur while a conversion is on going or + * while the automatic Delay is applied are ignored + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param NewState: new state of the ADCx Auto-Delay. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_WaitModeCmd(ADC_TypeDef* ADCx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the ADC Automatic Delayed conversion */ + ADCx->CFGR1 |= ADC_CFGR1_WAIT; + } + else + { + /* Disable the ADC Automatic Delayed conversion */ + ADCx->CFGR1 &= (uint32_t)~ADC_CFGR1_WAIT; + } +} + +/** + * @} + */ + +/** @defgroup ADC_Group3 Analog Watchdog configuration functions + * @brief Analog Watchdog configuration functions + * +@verbatim + =============================================================================== + ##### Analog Watchdog configuration functions ##### + =============================================================================== + [..] This section provides functions allowing to configure the Analog Watchdog + (AWD) feature in the ADC. + [..] A typical configuration Analog Watchdog is done following these steps : + (#) the ADC guarded channel(s) is (are) selected using the + ADC_AnalogWatchdogSingleChannelConfig() function. + (#) The Analog watchdog lower and higher threshold are configured using the + ADC_AnalogWatchdogThresholdsConfig() function. + (#) The Analog watchdog is enabled and configured to enable the check, on one + or more channels, using the ADC_AnalogWatchdogCmd() function. + (#) Enable the analog watchdog on the selected channel using + ADC_AnalogWatchdogSingleChannelCmd() function + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the analog watchdog + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param NewState: new state of the ADCx Analog Watchdog. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_AnalogWatchdogCmd(ADC_TypeDef* ADCx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the ADC Analog Watchdog */ + ADCx->CFGR1 |= ADC_CFGR1_AWDEN; + } + else + { + /* Disable the ADC Analog Watchdog */ + ADCx->CFGR1 &= (uint32_t)~ADC_CFGR1_AWDEN; + } +} + +/** + * @brief Configures the high and low thresholds of the analog watchdog. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param HighThreshold: the ADC analog watchdog High threshold value. + * This parameter must be a 12bit value. + * @param LowThreshold: the ADC analog watchdog Low threshold value. + * This parameter must be a 12bit value. + * @retval None + */ +void ADC_AnalogWatchdogThresholdsConfig(ADC_TypeDef* ADCx, uint16_t HighThreshold, + uint16_t LowThreshold) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_ADC_THRESHOLD(HighThreshold)); + assert_param(IS_ADC_THRESHOLD(LowThreshold)); + + /* Set the ADCx high and low threshold */ + ADCx->TR = LowThreshold | ((uint32_t)HighThreshold << 16); + +} + +/** + * @brief Configures the analog watchdog guarded single channel + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param ADC_AnalogWatchdog_Channel: the ADC channel to configure for the analog watchdog. + * This parameter can be one of the following values: + * @arg ADC_AnalogWatchdog_Channel_0: ADC Channel0 selected + * @arg ADC_AnalogWatchdog_Channel_1: ADC Channel1 selected + * @arg ADC_AnalogWatchdog_Channel_2: ADC Channel2 selected + * @arg ADC_AnalogWatchdog_Channel_3: ADC Channel3 selected + * @arg ADC_AnalogWatchdog_Channel_4: ADC Channel4 selected + * @arg ADC_AnalogWatchdog_Channel_5: ADC Channel5 selected + * @arg ADC_AnalogWatchdog_Channel_6: ADC Channel6 selected + * @arg ADC_AnalogWatchdog_Channel_7: ADC Channel7 selected + * @arg ADC_AnalogWatchdog_Channel_8: ADC Channel8 selected + * @arg ADC_AnalogWatchdog_Channel_9: ADC Channel9 selected + * @arg ADC_AnalogWatchdog_Channel_10: ADC Channel10 selected, not available for STM32F031 devices + * @arg ADC_AnalogWatchdog_Channel_11: ADC Channel11 selected, not available for STM32F031 devices + * @arg ADC_AnalogWatchdog_Channel_12: ADC Channel12 selected, not available for STM32F031 devices + * @arg ADC_AnalogWatchdog_Channel_13: ADC Channel13 selected, not available for STM32F031 devices + * @arg ADC_AnalogWatchdog_Channel_14: ADC Channel14 selected, not available for STM32F031 devices + * @arg ADC_AnalogWatchdog_Channel_15: ADC Channel15 selected, not available for STM32F031 devices + * @arg ADC_AnalogWatchdog_Channel_16: ADC Channel16 selected + * @arg ADC_AnalogWatchdog_Channel_17: ADC Channel17 selected + * @arg ADC_AnalogWatchdog_Channel_18: ADC Channel18 selected, not available for STM32F030 devices + * @note The channel selected on the AWDCH must be also set into the CHSELR + * register + * @retval None + */ +void ADC_AnalogWatchdogSingleChannelConfig(ADC_TypeDef* ADCx, uint32_t ADC_AnalogWatchdog_Channel) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_ADC_ANALOG_WATCHDOG_CHANNEL(ADC_AnalogWatchdog_Channel)); + + /* Get the old register value */ + tmpreg = ADCx->CFGR1; + + /* Clear the Analog watchdog channel select bits */ + tmpreg &= ~ADC_CFGR1_AWDCH; + + /* Set the Analog watchdog channel */ + tmpreg |= ADC_AnalogWatchdog_Channel; + + /* Store the new register value */ + ADCx->CFGR1 = tmpreg; +} + +/** + * @brief Enables or disables the ADC Analog Watchdog Single Channel. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param NewState: new state of the ADCx ADC Analog Watchdog Single Channel. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_AnalogWatchdogSingleChannelCmd(ADC_TypeDef* ADCx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the ADC Analog Watchdog Single Channel */ + ADCx->CFGR1 |= ADC_CFGR1_AWDSGL; + } + else + { + /* Disable the ADC Analog Watchdog Single Channel */ + ADCx->CFGR1 &= (uint32_t)~ADC_CFGR1_AWDSGL; + } +} + +/** + * @} + */ + +/** @defgroup ADC_Group4 Temperature Sensor, Vrefint and Vbat management functions + * @brief Temperature Sensor, Vrefint and Vbat management functions + * +@verbatim + =============================================================================== + ##### Temperature Sensor, Vrefint and Vbat management function ##### + =============================================================================== + [..] This section provides a function allowing to enable/disable the internal + connections between the ADC and the Temperature Sensor, the Vrefint and + Vbat source. + + [..] A typical configuration to get the Temperature sensor, Vrefint and Vbat channels + voltages is done following these steps : + (#) Enable the internal connection of Temperature sensor, Vrefint or Vbat sources + with the ADC channels using ADC_TempSensorCmd(), ADC_VrefintCmd() or ADC_VbatCmd() + functions. + (#) select the ADC_Channel_16(Temperature sensor), ADC_Channel_17(Vrefint) + or ADC_Channel_18(Voltage battery) using ADC_ChannelConfig() function + (#) Get the voltage values, using ADC_GetConversionValue() function + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the temperature sensor channel. + * @param NewState: new state of the temperature sensor input channel. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_TempSensorCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the temperature sensor channel*/ + ADC->CCR |= (uint32_t)ADC_CCR_TSEN; + } + else + { + /* Disable the temperature sensor channel*/ + ADC->CCR &= (uint32_t)(~ADC_CCR_TSEN); + } +} + +/** + * @brief Enables or disables the Vrefint channel. + * @param NewState: new state of the Vref input channel. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_VrefintCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the Vrefint channel*/ + ADC->CCR |= (uint32_t)ADC_CCR_VREFEN; + } + else + { + /* Disable the Vrefint channel*/ + ADC->CCR &= (uint32_t)(~ADC_CCR_VREFEN); + } +} + +/** + * @brief Enables or disables the Vbat channel. + * @note This feature is not applicable for STM32F030 devices. + * @param NewState: new state of the Vbat input channel. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_VbatCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the Vbat channel*/ + ADC->CCR |= (uint32_t)ADC_CCR_VBATEN; + } + else + { + /* Disable the Vbat channel*/ + ADC->CCR &= (uint32_t)(~ADC_CCR_VBATEN); + } +} + +/** + * @} + */ + +/** @defgroup ADC_Group5 Channels Configuration functions + * @brief Channels Configuration functions + * +@verbatim + =============================================================================== + ##### Channels Configuration functions ##### + =============================================================================== + [..] This section provides functions allowing to manage the ADC channels, + it is composed of 3 sub sections : + (#) Configuration and management functions for ADC channels: This subsection + provides functions allowing to configure the ADC channels : + (++) Select the ADC channels + (++) Activate ADC Calibration + (++) Activate the Overrun Mode. + (++) Activate the Discontinuous Mode + (++) Activate the Continuous Mode. + (++) Configure the sampling time for each channel + (++) Select the conversion Trigger and Edge for ADC channels + (++) Select the scan direction. + -@@- Please Note that the following features for ADC channels are configurated + using the ADC_Init() function : + (+@@) Activate the Continuous Mode (can be also activated by ADC_OverrunModeCmd(). + (+@@) Select the conversion Trigger and Edge for ADC channels + (+@@) Select the scan direction. + (#) Control the ADC peripheral : This subsection permits to command the ADC: + (++) Stop or discard an on-going conversion (ADSTP command) + (++) Start the ADC conversion . + (#) Get the conversion data: This subsection provides an important function in + the ADC peripheral since it returns the converted data of the current + ADC channel. When the Conversion value is read, the EOC Flag is + automatically cleared. + +@endverbatim + * @{ + */ + +/** + * @brief Configures for the selected ADC and its sampling time. + * @param ADCx: where x can be 1 to select the ADC peripheral. + * @param ADC_Channel: the ADC channel to configure. + * This parameter can be any combination of the following values: + * @arg ADC_Channel_0: ADC Channel0 selected + * @arg ADC_Channel_1: ADC Channel1 selected + * @arg ADC_Channel_2: ADC Channel2 selected + * @arg ADC_Channel_3: ADC Channel3 selected + * @arg ADC_Channel_4: ADC Channel4 selected + * @arg ADC_Channel_5: ADC Channel5 selected + * @arg ADC_Channel_6: ADC Channel6 selected + * @arg ADC_Channel_7: ADC Channel7 selected + * @arg ADC_Channel_8: ADC Channel8 selected + * @arg ADC_Channel_9: ADC Channel9 selected + * @arg ADC_Channel_10: ADC Channel10 selected, not available for STM32F031 devices + * @arg ADC_Channel_11: ADC Channel11 selected, not available for STM32F031 devices + * @arg ADC_Channel_12: ADC Channel12 selected, not available for STM32F031 devices + * @arg ADC_Channel_13: ADC Channel13 selected, not available for STM32F031 devices + * @arg ADC_Channel_14: ADC Channel14 selected, not available for STM32F031 devices + * @arg ADC_Channel_15: ADC Channel15 selected, not available for STM32F031 devices + * @arg ADC_Channel_16: ADC Channel16 selected + * @arg ADC_Channel_17: ADC Channel17 selected + * @arg ADC_Channel_18: ADC Channel18 selected, not available for STM32F030 devices + * @param ADC_SampleTime: The sample time value to be set for the selected channel. + * This parameter can be one of the following values: + * @arg ADC_SampleTime_1_5Cycles: Sample time equal to 1.5 cycles + * @arg ADC_SampleTime_7_5Cycles: Sample time equal to 7.5 cycles + * @arg ADC_SampleTime_13_5Cycles: Sample time equal to 13.5 cycles + * @arg ADC_SampleTime_28_5Cycles: Sample time equal to 28.5 cycles + * @arg ADC_SampleTime_41_5Cycles: Sample time equal to 41.5 cycles + * @arg ADC_SampleTime_55_5Cycles: Sample time equal to 55.5 cycles + * @arg ADC_SampleTime_71_5Cycles: Sample time equal to 71.5 cycles + * @arg ADC_SampleTime_239_5Cycles: Sample time equal to 239.5 cycles + * @retval None + */ +void ADC_ChannelConfig(ADC_TypeDef* ADCx, uint32_t ADC_Channel, uint32_t ADC_SampleTime) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_ADC_CHANNEL(ADC_Channel)); + assert_param(IS_ADC_SAMPLE_TIME(ADC_SampleTime)); + + /* Configure the ADC Channel */ + ADCx->CHSELR |= (uint32_t)ADC_Channel; + + /* Clear the Sampling time Selection bits */ + tmpreg &= ~ADC_SMPR1_SMPR; + + /* Set the ADC Sampling Time register */ + tmpreg |= (uint32_t)ADC_SampleTime; + + /* Configure the ADC Sample time register */ + ADCx->SMPR = tmpreg ; +} + +/** + * @brief Enable the Continuous mode for the selected ADCx channels. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param NewState: new state of the Continuous mode. + * This parameter can be: ENABLE or DISABLE. + * @note It is not possible to have both discontinuous mode and continuous mode + * enabled. In this case (If DISCEN and CONT are Set), the ADC behaves + * as if continuous mode was disabled + * @retval None + */ +void ADC_ContinuousModeCmd(ADC_TypeDef* ADCx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the Continuous mode*/ + ADCx->CFGR1 |= (uint32_t)ADC_CFGR1_CONT; + } + else + { + /* Disable the Continuous mode */ + ADCx->CFGR1 &= (uint32_t)(~ADC_CFGR1_CONT); + } +} + +/** + * @brief Enable the discontinuous mode for the selected ADC channels. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param NewState: new state of the discontinuous mode. + * This parameter can be: ENABLE or DISABLE. + * @note It is not possible to have both discontinuous mode and continuous mode + * enabled. In this case (If DISCEN and CONT are Set), the ADC behaves + * as if continuous mode was disabled + * @retval None + */ +void ADC_DiscModeCmd(ADC_TypeDef* ADCx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the Discontinuous mode */ + ADCx->CFGR1 |= (uint32_t)ADC_CFGR1_DISCEN; + } + else + { + /* Disable the Discontinuous mode */ + ADCx->CFGR1 &= (uint32_t)(~ADC_CFGR1_DISCEN); + } +} + +/** + * @brief Enable the Overrun mode for the selected ADC channels. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param NewState: new state of the Overrun mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_OverrunModeCmd(ADC_TypeDef* ADCx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the Overrun mode */ + ADCx->CFGR1 |= (uint32_t)ADC_CFGR1_OVRMOD; + } + else + { + /* Disable the Overrun mode */ + ADCx->CFGR1 &= (uint32_t)(~ADC_CFGR1_OVRMOD); + } +} + +/** + * @brief Active the Calibration operation for the selected ADC. + * @note The Calibration can be initiated only when ADC is still in the + * reset configuration (ADEN must be equal to 0). + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @retval ADC Calibration factor + */ +uint32_t ADC_GetCalibrationFactor(ADC_TypeDef* ADCx) +{ + uint32_t tmpreg = 0, calibrationcounter = 0, calibrationstatus = 0; + + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + + /* Set the ADC calibartion */ + ADCx->CR |= (uint32_t)ADC_CR_ADCAL; + + /* Wait until no ADC calibration is completed */ + do + { + calibrationstatus = ADCx->CR & ADC_CR_ADCAL; + calibrationcounter++; + } while((calibrationcounter != CALIBRATION_TIMEOUT) && (calibrationstatus != 0x00)); + + if((uint32_t)(ADCx->CR & ADC_CR_ADCAL) == RESET) + { + /*Get the calibration factor from the ADC data register */ + tmpreg = ADCx->DR; + } + else + { + /* Error factor */ + tmpreg = 0x00000000; + } + return tmpreg; +} + +/** + * @brief Stop the on going conversions for the selected ADC. + * @note When ADSTP is set, any on going conversion is aborted, and the ADC + * data register is not updated with current conversion. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @retval None + */ +void ADC_StopOfConversion(ADC_TypeDef* ADCx) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + + ADCx->CR |= (uint32_t)ADC_CR_ADSTP; +} + +/** + * @brief Start Conversion for the selected ADC channels. + * @note In continuous mode, ADSTART is not cleared by hardware with the + * assertion of EOSEQ because the sequence is automatic relaunched + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @retval None + */ +void ADC_StartOfConversion(ADC_TypeDef* ADCx) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + + ADCx->CR |= (uint32_t)ADC_CR_ADSTART; +} + +/** + * @brief Returns the last ADCx conversion result data for ADC channel. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @retval The Data conversion value. + */ +uint16_t ADC_GetConversionValue(ADC_TypeDef* ADCx) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + + /* Return the selected ADC conversion value */ + return (uint16_t) ADCx->DR; +} + +/** + * @} + */ + +/** @defgroup ADC_Group6 DMA Configuration functions + * @brief Regular Channels DMA Configuration functions + * +@verbatim + =============================================================================== + ##### DMA Configuration functions ##### + =============================================================================== + [..] This section provides functions allowing to configure the DMA for ADC hannels. + Since converted channel values are stored into a unique data register, + it is useful to use DMA for conversion of more than one channel. This + avoids the loss of the data already stored in the ADC Data register. + When the DMA mode is enabled (using the ADC_DMACmd() function), after each + conversion of a channel, a DMA request is generated. + + [..] Depending on the "DMA disable selection" configuration (using the + ADC_DMARequestModeConfig() function), at the end of the last DMA + transfer, two possibilities are allowed: + (+) No new DMA request is issued to the DMA controller (One Shot Mode) + (+) Requests can continue to be generated (Circular Mode). + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified ADC DMA request. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param NewState: new state of the selected ADC DMA transfer. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_DMACmd(ADC_TypeDef* ADCx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected ADC DMA request */ + ADCx->CFGR1 |= (uint32_t)ADC_CFGR1_DMAEN; + } + else + { + /* Disable the selected ADC DMA request */ + ADCx->CFGR1 &= (uint32_t)(~ADC_CFGR1_DMAEN); + } +} + +/** + * @brief Enables or disables the ADC DMA request after last transfer (Single-ADC mode) + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param ADC_DMARequestMode: the ADC channel to configure. + * This parameter can be one of the following values: + * @arg ADC_DMAMode_OneShot: DMA One Shot Mode + * @arg ADC_DMAMode_Circular: DMA Circular Mode + * @retval None + */ +void ADC_DMARequestModeConfig(ADC_TypeDef* ADCx, uint32_t ADC_DMARequestMode) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + + ADCx->CFGR1 &= (uint32_t)~ADC_CFGR1_DMACFG; + ADCx->CFGR1 |= (uint32_t)ADC_DMARequestMode; +} + +/** + * @} + */ + +/** @defgroup ADC_Group7 Interrupts and flags management functions + * @brief Interrupts and flags management functions. + * +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== + [..] This section provides functions allowing to configure the ADC Interrupts + and get the status and clear flags and Interrupts pending bits. + + [..] The ADC provide 6 Interrupts sources and 11 Flags which can be divided into + 3 groups: + + *** Flags for ADC status *** + ====================================================== + [..] + (+)Flags : + (##) ADC_FLAG_ADRDY : This flag is set after the ADC has been enabled (bit ADEN=1) + and when the ADC reaches a state where it is ready to accept conversion requests + (##) ADC_FLAG_ADEN : This flag is set by software to enable the ADC. + The ADC will be effectively ready to operate once the ADRDY flag has been set. + (##) ADC_FLAG_ADDIS : This flag is cleared once the ADC is effectively + disabled. + (##) ADC_FLAG_ADSTART : This flag is cleared after the execution of + ADC_StopOfConversion() function, at the same time as the ADSTP bit is + cleared by hardware + (##) ADC_FLAG_ADSTP : This flag is cleared by hardware when the conversion + is effectively discarded and the ADC is ready to accept a new start conversion + (##) ADC_FLAG_ADCAL : This flag is set once the calibration is complete. + + (+)Interrupts + (##) ADC_IT_ADRDY : specifies the interrupt source for ADC ready event. + + *** Flags and Interrupts for ADC channel conversion *** + ===================================================== + [..] + (+)Flags : + (##) ADC_FLAG_EOC : This flag is set by hardware at the end of each conversion + of a channel when a new data result is available in the data register + (##) ADC_FLAG_EOSEQ : This bit is set by hardware at the end of the conversion + of a sequence of channels selected by ADC_ChannelConfig() function. + (##) ADC_FLAG_EOSMP : This bit is set by hardware at the end of the sampling phase. + (##) ADC_FLAG_OVR : This flag is set by hardware when an overrun occurs, + meaning that a new conversion has complete while the EOC flag was already set. + + (+)Interrupts : + (##) ADC_IT_EOC : specifies the interrupt source for end of conversion event. + (##) ADC_IT_EOSEQ : specifies the interrupt source for end of sequence event. + (##) ADC_IT_EOSMP : specifies the interrupt source for end of sampling event. + (##) ADC_IT_OVR : specifies the interrupt source for Overrun detection + event. + + *** Flags and Interrupts for the Analog Watchdog *** + ================================================ + [..] + (+)Flags : + (##) ADC_FLAG_AWD: This flag is set by hardware when the converted + voltage crosses the values programmed thrsholds + + (+)Interrupts : + (##) ADC_IT_AWD : specifies the interrupt source for Analog watchdog + event. + + [..] The user should identify which mode will be used in his application to + manage the ADC controller events: Polling mode or Interrupt mode. + + [..] In the Polling Mode it is advised to use the following functions: + (+) ADC_GetFlagStatus() : to check if flags events occur. + (+) ADC_ClearFlag() : to clear the flags events. + + [..] In the Interrupt Mode it is advised to use the following functions: + (+) ADC_ITConfig() : to enable or disable the interrupt source. + (+) ADC_GetITStatus() : to check if Interrupt occurs. + (+) ADC_ClearITPendingBit() : to clear the Interrupt pending Bit + (corresponding Flag). + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified ADC interrupts. + * @param ADCx: where x can be 1 to select the ADC peripheral. + * @param ADC_IT: specifies the ADC interrupt sources to be enabled or disabled. + * This parameter can be one of the following values: + * @arg ADC_IT_ADRDY: ADC ready interrupt + * @arg ADC_IT_EOSMP: End of sampling interrupt + * @arg ADC_IT_EOC: End of conversion interrupt + * @arg ADC_IT_EOSEQ: End of sequence of conversion interrupt + * @arg ADC_IT_OVR: overrun interrupt + * @arg ADC_IT_AWD: Analog watchdog interrupt + * @param NewState: new state of the specified ADC interrupts. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_ITConfig(ADC_TypeDef* ADCx, uint32_t ADC_IT, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + assert_param(IS_ADC_CONFIG_IT(ADC_IT)); + + if (NewState != DISABLE) + { + /* Enable the selected ADC interrupts */ + ADCx->IER |= ADC_IT; + } + else + { + /* Disable the selected ADC interrupts */ + ADCx->IER &= (~(uint32_t)ADC_IT); + } +} + +/** + * @brief Checks whether the specified ADC flag is set or not. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param ADC_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg ADC_FLAG_AWD: Analog watchdog flag + * @arg ADC_FLAG_OVR: Overrun flag + * @arg ADC_FLAG_EOSEQ: End of Sequence flag + * @arg ADC_FLAG_EOC: End of conversion flag + * @arg ADC_FLAG_EOSMP: End of sampling flag + * @arg ADC_FLAG_ADRDY: ADC Ready flag + * @arg ADC_FLAG_ADEN: ADC enable flag + * @arg ADC_FLAG_ADDIS: ADC disable flag + * @arg ADC_FLAG_ADSTART: ADC start flag + * @arg ADC_FLAG_ADSTP: ADC stop flag + * @arg ADC_FLAG_ADCAL: ADC Calibration flag + * @retval The new state of ADC_FLAG (SET or RESET). + */ +FlagStatus ADC_GetFlagStatus(ADC_TypeDef* ADCx, uint32_t ADC_FLAG) +{ + FlagStatus bitstatus = RESET; + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_ADC_GET_FLAG(ADC_FLAG)); + + if((uint32_t)(ADC_FLAG & 0x01000000)) + { + tmpreg = ADCx->CR & 0xFEFFFFFF; + } + else + { + tmpreg = ADCx->ISR; + } + + /* Check the status of the specified ADC flag */ + if ((tmpreg & ADC_FLAG) != (uint32_t)RESET) + { + /* ADC_FLAG is set */ + bitstatus = SET; + } + else + { + /* ADC_FLAG is reset */ + bitstatus = RESET; + } + /* Return the ADC_FLAG status */ + return bitstatus; +} + +/** + * @brief Clears the ADCx's pending flags. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param ADC_FLAG: specifies the flag to clear. + * This parameter can be any combination of the following values: + * @arg ADC_FLAG_AWD: Analog watchdog flag + * @arg ADC_FLAG_EOC: End of conversion flag + * @arg ADC_FLAG_ADRDY: ADC Ready flag + * @arg ADC_FLAG_EOSMP: End of sampling flag + * @arg ADC_FLAG_EOSEQ: End of Sequence flag + * @arg ADC_FLAG_OVR: Overrun flag + * @retval None + */ +void ADC_ClearFlag(ADC_TypeDef* ADCx, uint32_t ADC_FLAG) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_ADC_CLEAR_FLAG(ADC_FLAG)); + + /* Clear the selected ADC flags */ + ADCx->ISR = (uint32_t)ADC_FLAG; +} + +/** + * @brief Checks whether the specified ADC interrupt has occurred or not. + * @param ADCx: where x can be 1 to select the ADC1 peripheral + * @param ADC_IT: specifies the ADC interrupt source to check. + * This parameter can be one of the following values: + * @arg ADC_IT_ADRDY: ADC ready interrupt + * @arg ADC_IT_EOSMP: End of sampling interrupt + * @arg ADC_IT_EOC: End of conversion interrupt + * @arg ADC_IT_EOSEQ: End of sequence of conversion interrupt + * @arg ADC_IT_OVR: overrun interrupt + * @arg ADC_IT_AWD: Analog watchdog interrupt + * @retval The new state of ADC_IT (SET or RESET). + */ +ITStatus ADC_GetITStatus(ADC_TypeDef* ADCx, uint32_t ADC_IT) +{ + ITStatus bitstatus = RESET; + uint32_t enablestatus = 0; + + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_ADC_GET_IT(ADC_IT)); + + /* Get the ADC_IT enable bit status */ + enablestatus = (uint32_t)(ADCx->IER & ADC_IT); + + /* Check the status of the specified ADC interrupt */ + if (((uint32_t)(ADCx->ISR & ADC_IT) != (uint32_t)RESET) && (enablestatus != (uint32_t)RESET)) + { + /* ADC_IT is set */ + bitstatus = SET; + } + else + { + /* ADC_IT is reset */ + bitstatus = RESET; + } + /* Return the ADC_IT status */ + return bitstatus; +} + +/** + * @brief Clears the ADCx's interrupt pending bits. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param ADC_IT: specifies the ADC interrupt pending bit to clear. + * This parameter can be one of the following values: + * @arg ADC_IT_ADRDY: ADC ready interrupt + * @arg ADC_IT_EOSMP: End of sampling interrupt + * @arg ADC_IT_EOC: End of conversion interrupt + * @arg ADC_IT_EOSEQ: End of sequence of conversion interrupt + * @arg ADC_IT_OVR: overrun interrupt + * @arg ADC_IT_AWD: Analog watchdog interrupt + * @retval None + */ +void ADC_ClearITPendingBit(ADC_TypeDef* ADCx, uint32_t ADC_IT) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_ADC_CLEAR_IT(ADC_IT)); + + /* Clear the selected ADC interrupt pending bits */ + ADCx->ISR = (uint32_t)ADC_IT; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_can.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_can.c new file mode 100644 index 00000000..c051ab49 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_can.c @@ -0,0 +1,1631 @@ +/** + ****************************************************************************** + * @file stm32f0xx_can.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Controller area network (CAN) peripheral and + * applicable only for STM32F072 devices : + * + Initialization and Configuration + * + CAN Frames Transmission + * + CAN Frames Reception + * + Operation modes switch + * + Error management + * + Interrupts and flags + * + @verbatim + + =============================================================================== + ##### How to use this driver ##### + =============================================================================== + [..] + (#) Enable the CAN controller interface clock using + RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN, ENABLE); + (#) CAN pins configuration: + (++) Enable the clock for the CAN GPIOs using the following function: + RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOx, ENABLE); + (++) Connect the involved CAN pins to AF0 using the following function + GPIO_PinAFConfig(GPIOx, GPIO_PinSourcex, GPIO_AF_CANx); + (++) Configure these CAN pins in alternate function mode by calling + the function GPIO_Init(); + (#) Initialise and configure the CAN using CAN_Init() and + CAN_FilterInit() functions. + (#) Transmit the desired CAN frame using CAN_Transmit() function. + (#) Check the transmission of a CAN frame using CAN_TransmitStatus() function. + (#) Cancel the transmission of a CAN frame using CAN_CancelTransmit() function. + (#) Receive a CAN frame using CAN_Recieve() function. + (#) Release the receive FIFOs using CAN_FIFORelease() function. + (#) Return the number of pending received frames using CAN_MessagePending() function. + (#) To control CAN events you can use one of the following two methods: + (++) Check on CAN flags using the CAN_GetFlagStatus() function. + (++) Use CAN interrupts through the function CAN_ITConfig() at initialization + phase and CAN_GetITStatus() function into interrupt routines to check + if the event has occurred or not. + After checking on a flag you should clear it using CAN_ClearFlag() + function. And after checking on an interrupt event you should clear it + using CAN_ClearITPendingBit() function. + + @endverbatim + * + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_can.h" +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup CAN + * @brief CAN driver modules + * @{ + */ +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ + +/* CAN Master Control Register bits */ +#define MCR_DBF ((uint32_t)0x00010000) /* software master reset */ + +/* CAN Mailbox Transmit Request */ +#define TMIDxR_TXRQ ((uint32_t)0x00000001) /* Transmit mailbox request */ + +/* CAN Filter Master Register bits */ +#define FMR_FINIT ((uint32_t)0x00000001) /* Filter init mode */ + +/* Time out for INAK bit */ +#define INAK_TIMEOUT ((uint32_t)0x00FFFFFF) +/* Time out for SLAK bit */ +#define SLAK_TIMEOUT ((uint32_t)0x00FFFFFF) + +/* Flags in TSR register */ +#define CAN_FLAGS_TSR ((uint32_t)0x08000000) +/* Flags in RF1R register */ +#define CAN_FLAGS_RF1R ((uint32_t)0x04000000) +/* Flags in RF0R register */ +#define CAN_FLAGS_RF0R ((uint32_t)0x02000000) +/* Flags in MSR register */ +#define CAN_FLAGS_MSR ((uint32_t)0x01000000) +/* Flags in ESR register */ +#define CAN_FLAGS_ESR ((uint32_t)0x00F00000) + +/* Mailboxes definition */ +#define CAN_TXMAILBOX_0 ((uint8_t)0x00) +#define CAN_TXMAILBOX_1 ((uint8_t)0x01) +#define CAN_TXMAILBOX_2 ((uint8_t)0x02) + +#define CAN_MODE_MASK ((uint32_t) 0x00000003) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ +static ITStatus CheckITStatus(uint32_t CAN_Reg, uint32_t It_Bit); + +/** @defgroup CAN_Private_Functions + * @{ + */ + +/** @defgroup CAN_Group1 Initialization and Configuration functions + * @brief Initialization and Configuration functions + * +@verbatim + =============================================================================== + ##### Initialization and Configuration functions ##### + =============================================================================== + [..] This section provides functions allowing to: + (+) Initialize the CAN peripherals : Prescaler, operating mode, the maximum + number of time quanta to perform resynchronization, the number of time + quanta in Bit Segment 1 and 2 and many other modes. + (+) Configure the CAN reception filter. + (+) Select the start bank filter for slave CAN. + (+) Enable or disable the Debug Freeze mode for CAN. + (+) Enable or disable the CAN Time Trigger Operation communication mode. + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the CAN peripheral registers to their default reset values. + * @param CANx: where x can be 1 to select the CAN peripheral. + * @retval None. + */ +void CAN_DeInit(CAN_TypeDef* CANx) +{ + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + + /* Enable CAN reset state */ + RCC_APB1PeriphResetCmd(RCC_APB1Periph_CAN, ENABLE); + /* Release CAN from reset state */ + RCC_APB1PeriphResetCmd(RCC_APB1Periph_CAN, DISABLE); +} + +/** + * @brief Initializes the CAN peripheral according to the specified + * parameters in the CAN_InitStruct. + * @param CANx: where x can be 1 to select the CAN peripheral. + * @param CAN_InitStruct: pointer to a CAN_InitTypeDef structure that contains + * the configuration information for the CAN peripheral. + * @retval Constant indicates initialization succeed which will be + * CAN_InitStatus_Failed or CAN_InitStatus_Success. + */ +uint8_t CAN_Init(CAN_TypeDef* CANx, CAN_InitTypeDef* CAN_InitStruct) +{ + uint8_t InitStatus = CAN_InitStatus_Failed; + uint32_t wait_ack = 0x00000000; + + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_TTCM)); + assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_ABOM)); + assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_AWUM)); + assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_NART)); + assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_RFLM)); + assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_TXFP)); + assert_param(IS_CAN_MODE(CAN_InitStruct->CAN_Mode)); + assert_param(IS_CAN_SJW(CAN_InitStruct->CAN_SJW)); + assert_param(IS_CAN_BS1(CAN_InitStruct->CAN_BS1)); + assert_param(IS_CAN_BS2(CAN_InitStruct->CAN_BS2)); + assert_param(IS_CAN_PRESCALER(CAN_InitStruct->CAN_Prescaler)); + + /* Exit from sleep mode */ + CANx->MCR &= (~(uint32_t)CAN_MCR_SLEEP); + + /* Request initialisation */ + CANx->MCR |= CAN_MCR_INRQ ; + + /* Wait the acknowledge */ + while (((CANx->MSR & CAN_MSR_INAK) != CAN_MSR_INAK) && (wait_ack != INAK_TIMEOUT)) + { + wait_ack++; + } + + /* Check acknowledge */ + if ((CANx->MSR & CAN_MSR_INAK) != CAN_MSR_INAK) + { + InitStatus = CAN_InitStatus_Failed; + } + else + { + /* Set the time triggered communication mode */ + if (CAN_InitStruct->CAN_TTCM == ENABLE) + { + CANx->MCR |= CAN_MCR_TTCM; + } + else + { + CANx->MCR &= ~(uint32_t)CAN_MCR_TTCM; + } + + /* Set the automatic bus-off management */ + if (CAN_InitStruct->CAN_ABOM == ENABLE) + { + CANx->MCR |= CAN_MCR_ABOM; + } + else + { + CANx->MCR &= ~(uint32_t)CAN_MCR_ABOM; + } + + /* Set the automatic wake-up mode */ + if (CAN_InitStruct->CAN_AWUM == ENABLE) + { + CANx->MCR |= CAN_MCR_AWUM; + } + else + { + CANx->MCR &= ~(uint32_t)CAN_MCR_AWUM; + } + + /* Set the no automatic retransmission */ + if (CAN_InitStruct->CAN_NART == ENABLE) + { + CANx->MCR |= CAN_MCR_NART; + } + else + { + CANx->MCR &= ~(uint32_t)CAN_MCR_NART; + } + + /* Set the receive FIFO locked mode */ + if (CAN_InitStruct->CAN_RFLM == ENABLE) + { + CANx->MCR |= CAN_MCR_RFLM; + } + else + { + CANx->MCR &= ~(uint32_t)CAN_MCR_RFLM; + } + + /* Set the transmit FIFO priority */ + if (CAN_InitStruct->CAN_TXFP == ENABLE) + { + CANx->MCR |= CAN_MCR_TXFP; + } + else + { + CANx->MCR &= ~(uint32_t)CAN_MCR_TXFP; + } + + /* Set the bit timing register */ + CANx->BTR = (uint32_t)((uint32_t)CAN_InitStruct->CAN_Mode << 30) | \ + ((uint32_t)CAN_InitStruct->CAN_SJW << 24) | \ + ((uint32_t)CAN_InitStruct->CAN_BS1 << 16) | \ + ((uint32_t)CAN_InitStruct->CAN_BS2 << 20) | \ + ((uint32_t)CAN_InitStruct->CAN_Prescaler - 1); + + /* Request leave initialisation */ + CANx->MCR &= ~(uint32_t)CAN_MCR_INRQ; + + /* Wait the acknowledge */ + wait_ack = 0; + + while (((CANx->MSR & CAN_MSR_INAK) == (uint16_t)CAN_MSR_INAK) && (wait_ack != INAK_TIMEOUT)) + { + wait_ack++; + } + + /* ...and check acknowledged */ + if ((CANx->MSR & CAN_MSR_INAK) == CAN_MSR_INAK) + { + InitStatus = CAN_InitStatus_Failed; + } + else + { + InitStatus = CAN_InitStatus_Success ; + } + } + + /* At this step, return the status of initialization */ + return InitStatus; +} + +/** + * @brief Configures the CAN reception filter according to the specified + * parameters in the CAN_FilterInitStruct. + * @param CAN_FilterInitStruct: pointer to a CAN_FilterInitTypeDef structure that + * contains the configuration information. + * @retval None + */ +void CAN_FilterInit(CAN_FilterInitTypeDef* CAN_FilterInitStruct) +{ + uint32_t filter_number_bit_pos = 0; + /* Check the parameters */ + assert_param(IS_CAN_FILTER_NUMBER(CAN_FilterInitStruct->CAN_FilterNumber)); + assert_param(IS_CAN_FILTER_MODE(CAN_FilterInitStruct->CAN_FilterMode)); + assert_param(IS_CAN_FILTER_SCALE(CAN_FilterInitStruct->CAN_FilterScale)); + assert_param(IS_CAN_FILTER_FIFO(CAN_FilterInitStruct->CAN_FilterFIFOAssignment)); + assert_param(IS_FUNCTIONAL_STATE(CAN_FilterInitStruct->CAN_FilterActivation)); + + filter_number_bit_pos = ((uint32_t)1) << CAN_FilterInitStruct->CAN_FilterNumber; + + /* Initialisation mode for the filter */ + CAN->FMR |= FMR_FINIT; + + /* Filter Deactivation */ + CAN->FA1R &= ~(uint32_t)filter_number_bit_pos; + + /* Filter Scale */ + if (CAN_FilterInitStruct->CAN_FilterScale == CAN_FilterScale_16bit) + { + /* 16-bit scale for the filter */ + CAN->FS1R &= ~(uint32_t)filter_number_bit_pos; + + /* First 16-bit identifier and First 16-bit mask */ + /* Or First 16-bit identifier and Second 16-bit identifier */ + CAN->sFilterRegister[CAN_FilterInitStruct->CAN_FilterNumber].FR1 = + ((0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterMaskIdLow) << 16) | + (0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterIdLow); + + /* Second 16-bit identifier and Second 16-bit mask */ + /* Or Third 16-bit identifier and Fourth 16-bit identifier */ + CAN->sFilterRegister[CAN_FilterInitStruct->CAN_FilterNumber].FR2 = + ((0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterMaskIdHigh) << 16) | + (0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterIdHigh); + } + + if (CAN_FilterInitStruct->CAN_FilterScale == CAN_FilterScale_32bit) + { + /* 32-bit scale for the filter */ + CAN->FS1R |= filter_number_bit_pos; + /* 32-bit identifier or First 32-bit identifier */ + CAN->sFilterRegister[CAN_FilterInitStruct->CAN_FilterNumber].FR1 = + ((0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterIdHigh) << 16) | + (0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterIdLow); + /* 32-bit mask or Second 32-bit identifier */ + CAN->sFilterRegister[CAN_FilterInitStruct->CAN_FilterNumber].FR2 = + ((0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterMaskIdHigh) << 16) | + (0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterMaskIdLow); + } + + /* Filter Mode */ + if (CAN_FilterInitStruct->CAN_FilterMode == CAN_FilterMode_IdMask) + { + /*Id/Mask mode for the filter*/ + CAN->FM1R &= ~(uint32_t)filter_number_bit_pos; + } + else /* CAN_FilterInitStruct->CAN_FilterMode == CAN_FilterMode_IdList */ + { + /*Identifier list mode for the filter*/ + CAN->FM1R |= (uint32_t)filter_number_bit_pos; + } + + /* Filter FIFO assignment */ + if (CAN_FilterInitStruct->CAN_FilterFIFOAssignment == CAN_Filter_FIFO0) + { + /* FIFO 0 assignation for the filter */ + CAN->FFA1R &= ~(uint32_t)filter_number_bit_pos; + } + + if (CAN_FilterInitStruct->CAN_FilterFIFOAssignment == CAN_Filter_FIFO1) + { + /* FIFO 1 assignation for the filter */ + CAN->FFA1R |= (uint32_t)filter_number_bit_pos; + } + + /* Filter activation */ + if (CAN_FilterInitStruct->CAN_FilterActivation == ENABLE) + { + CAN->FA1R |= filter_number_bit_pos; + } + + /* Leave the initialisation mode for the filter */ + CAN->FMR &= ~FMR_FINIT; +} + +/** + * @brief Fills each CAN_InitStruct member with its default value. + * @param CAN_InitStruct: pointer to a CAN_InitTypeDef structure which ill be initialized. + * @retval None + */ +void CAN_StructInit(CAN_InitTypeDef* CAN_InitStruct) +{ + /* Reset CAN init structure parameters values */ + + /* Initialize the time triggered communication mode */ + CAN_InitStruct->CAN_TTCM = DISABLE; + + /* Initialize the automatic bus-off management */ + CAN_InitStruct->CAN_ABOM = DISABLE; + + /* Initialize the automatic wake-up mode */ + CAN_InitStruct->CAN_AWUM = DISABLE; + + /* Initialize the no automatic retransmission */ + CAN_InitStruct->CAN_NART = DISABLE; + + /* Initialize the receive FIFO locked mode */ + CAN_InitStruct->CAN_RFLM = DISABLE; + + /* Initialize the transmit FIFO priority */ + CAN_InitStruct->CAN_TXFP = DISABLE; + + /* Initialize the CAN_Mode member */ + CAN_InitStruct->CAN_Mode = CAN_Mode_Normal; + + /* Initialize the CAN_SJW member */ + CAN_InitStruct->CAN_SJW = CAN_SJW_1tq; + + /* Initialize the CAN_BS1 member */ + CAN_InitStruct->CAN_BS1 = CAN_BS1_4tq; + + /* Initialize the CAN_BS2 member */ + CAN_InitStruct->CAN_BS2 = CAN_BS2_3tq; + + /* Initialize the CAN_Prescaler member */ + CAN_InitStruct->CAN_Prescaler = 1; +} + +/** + * @brief Select the start bank filter for slave CAN. + * @param CAN_BankNumber: Select the start slave bank filter from 1..27. + * @retval None + */ +void CAN_SlaveStartBank(uint8_t CAN_BankNumber) +{ + /* Check the parameters */ + assert_param(IS_CAN_BANKNUMBER(CAN_BankNumber)); + + /* Enter Initialisation mode for the filter */ + CAN->FMR |= FMR_FINIT; + + /* Select the start slave bank */ + CAN->FMR &= (uint32_t)0xFFFFC0F1 ; + CAN->FMR |= (uint32_t)(CAN_BankNumber)<<8; + + /* Leave Initialisation mode for the filter */ + CAN->FMR &= ~FMR_FINIT; +} + +/** + * @brief Enables or disables the DBG Freeze for CAN. + * @param CANx: where x can be 1 or 2 to to select the CAN peripheral. + * @param NewState: new state of the CAN peripheral. + * This parameter can be: ENABLE (CAN reception/transmission is frozen + * during debug. Reception FIFOs can still be accessed/controlled normally) + * or DISABLE (CAN is working during debug). + * @retval None + */ +void CAN_DBGFreeze(CAN_TypeDef* CANx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable Debug Freeze */ + CANx->MCR |= MCR_DBF; + } + else + { + /* Disable Debug Freeze */ + CANx->MCR &= ~MCR_DBF; + } +} + +/** + * @brief Enables or disables the CAN Time TriggerOperation communication mode. + * @note DLC must be programmed as 8 in order Time Stamp (2 bytes) to be + * sent over the CAN bus. + * @param CANx: where x can be 1 or 2 to to select the CAN peripheral. + * @param NewState: Mode new state. This parameter can be: ENABLE or DISABLE. + * When enabled, Time stamp (TIME[15:0]) value is sent in the last two + * data bytes of the 8-byte message: TIME[7:0] in data byte 6 and TIME[15:8] + * in data byte 7. + * @retval None + */ +void CAN_TTComModeCmd(CAN_TypeDef* CANx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + if (NewState != DISABLE) + { + /* Enable the TTCM mode */ + CANx->MCR |= CAN_MCR_TTCM; + + /* Set TGT bits */ + CANx->sTxMailBox[0].TDTR |= ((uint32_t)CAN_TDT0R_TGT); + CANx->sTxMailBox[1].TDTR |= ((uint32_t)CAN_TDT1R_TGT); + CANx->sTxMailBox[2].TDTR |= ((uint32_t)CAN_TDT2R_TGT); + } + else + { + /* Disable the TTCM mode */ + CANx->MCR &= (uint32_t)(~(uint32_t)CAN_MCR_TTCM); + + /* Reset TGT bits */ + CANx->sTxMailBox[0].TDTR &= ((uint32_t)~CAN_TDT0R_TGT); + CANx->sTxMailBox[1].TDTR &= ((uint32_t)~CAN_TDT1R_TGT); + CANx->sTxMailBox[2].TDTR &= ((uint32_t)~CAN_TDT2R_TGT); + } +} +/** + * @} + */ + + +/** @defgroup CAN_Group2 CAN Frames Transmission functions + * @brief CAN Frames Transmission functions + * +@verbatim + =============================================================================== + ##### CAN Frames Transmission functions ##### + =============================================================================== + [..] This section provides functions allowing to + (+) Initiate and transmit a CAN frame message (if there is an empty mailbox). + (+) Check the transmission status of a CAN Frame. + (+) Cancel a transmit request. + +@endverbatim + * @{ + */ + +/** + * @brief Initiates and transmits a CAN frame message. + * @param CANx: where x can be 1 or 2 to to select the CAN peripheral. + * @param TxMessage: pointer to a structure which contains CAN Id, CAN DLC and CAN data. + * @retval The number of the mailbox that is used for transmission or + * CAN_TxStatus_NoMailBox if there is no empty mailbox. + */ +uint8_t CAN_Transmit(CAN_TypeDef* CANx, CanTxMsg* TxMessage) +{ + uint8_t transmit_mailbox = 0; + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_IDTYPE(TxMessage->IDE)); + assert_param(IS_CAN_RTR(TxMessage->RTR)); + assert_param(IS_CAN_DLC(TxMessage->DLC)); + + /* Select one empty transmit mailbox */ + if ((CANx->TSR&CAN_TSR_TME0) == CAN_TSR_TME0) + { + transmit_mailbox = 0; + } + else if ((CANx->TSR&CAN_TSR_TME1) == CAN_TSR_TME1) + { + transmit_mailbox = 1; + } + else if ((CANx->TSR&CAN_TSR_TME2) == CAN_TSR_TME2) + { + transmit_mailbox = 2; + } + else + { + transmit_mailbox = CAN_TxStatus_NoMailBox; + } + + if (transmit_mailbox != CAN_TxStatus_NoMailBox) + { + /* Set up the Id */ + CANx->sTxMailBox[transmit_mailbox].TIR &= TMIDxR_TXRQ; + if (TxMessage->IDE == CAN_Id_Standard) + { + assert_param(IS_CAN_STDID(TxMessage->StdId)); + CANx->sTxMailBox[transmit_mailbox].TIR |= ((TxMessage->StdId << 21) | \ + TxMessage->RTR); + } + else + { + assert_param(IS_CAN_EXTID(TxMessage->ExtId)); + CANx->sTxMailBox[transmit_mailbox].TIR |= ((TxMessage->ExtId << 3) | \ + TxMessage->IDE | \ + TxMessage->RTR); + } + + /* Set up the DLC */ + TxMessage->DLC &= (uint8_t)0x0000000F; + CANx->sTxMailBox[transmit_mailbox].TDTR &= (uint32_t)0xFFFFFFF0; + CANx->sTxMailBox[transmit_mailbox].TDTR |= TxMessage->DLC; + + /* Set up the data field */ + CANx->sTxMailBox[transmit_mailbox].TDLR = (((uint32_t)TxMessage->Data[3] << 24) | + ((uint32_t)TxMessage->Data[2] << 16) | + ((uint32_t)TxMessage->Data[1] << 8) | + ((uint32_t)TxMessage->Data[0])); + CANx->sTxMailBox[transmit_mailbox].TDHR = (((uint32_t)TxMessage->Data[7] << 24) | + ((uint32_t)TxMessage->Data[6] << 16) | + ((uint32_t)TxMessage->Data[5] << 8) | + ((uint32_t)TxMessage->Data[4])); + /* Request transmission */ + CANx->sTxMailBox[transmit_mailbox].TIR |= TMIDxR_TXRQ; + } + return transmit_mailbox; +} + +/** + * @brief Checks the transmission status of a CAN Frame. + * @param CANx: where x can be 1 to select the CAN peripheral. + * @param TransmitMailbox: the number of the mailbox that is used for transmission. + * @retval CAN_TxStatus_Ok if the CAN driver transmits the message, + * CAN_TxStatus_Failed in an other case. + */ +uint8_t CAN_TransmitStatus(CAN_TypeDef* CANx, uint8_t TransmitMailbox) +{ + uint32_t state = 0; + + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_TRANSMITMAILBOX(TransmitMailbox)); + + switch (TransmitMailbox) + { + case (CAN_TXMAILBOX_0): + state = CANx->TSR & (CAN_TSR_RQCP0 | CAN_TSR_TXOK0 | CAN_TSR_TME0); + break; + case (CAN_TXMAILBOX_1): + state = CANx->TSR & (CAN_TSR_RQCP1 | CAN_TSR_TXOK1 | CAN_TSR_TME1); + break; + case (CAN_TXMAILBOX_2): + state = CANx->TSR & (CAN_TSR_RQCP2 | CAN_TSR_TXOK2 | CAN_TSR_TME2); + break; + default: + state = CAN_TxStatus_Failed; + break; + } + switch (state) + { + /* transmit pending */ + case (0x0): state = CAN_TxStatus_Pending; + break; + /* transmit failed */ + case (CAN_TSR_RQCP0 | CAN_TSR_TME0): state = CAN_TxStatus_Failed; + break; + case (CAN_TSR_RQCP1 | CAN_TSR_TME1): state = CAN_TxStatus_Failed; + break; + case (CAN_TSR_RQCP2 | CAN_TSR_TME2): state = CAN_TxStatus_Failed; + break; + /* transmit succeeded */ + case (CAN_TSR_RQCP0 | CAN_TSR_TXOK0 | CAN_TSR_TME0):state = CAN_TxStatus_Ok; + break; + case (CAN_TSR_RQCP1 | CAN_TSR_TXOK1 | CAN_TSR_TME1):state = CAN_TxStatus_Ok; + break; + case (CAN_TSR_RQCP2 | CAN_TSR_TXOK2 | CAN_TSR_TME2):state = CAN_TxStatus_Ok; + break; + default: state = CAN_TxStatus_Failed; + break; + } + return (uint8_t) state; +} + +/** + * @brief Cancels a transmit request. + * @param CANx: where x can be 1 to select the CAN peripheral. + * @param Mailbox: Mailbox number. + * @retval None + */ +void CAN_CancelTransmit(CAN_TypeDef* CANx, uint8_t Mailbox) +{ + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_TRANSMITMAILBOX(Mailbox)); + /* abort transmission */ + switch (Mailbox) + { + case (CAN_TXMAILBOX_0): CANx->TSR |= CAN_TSR_ABRQ0; + break; + case (CAN_TXMAILBOX_1): CANx->TSR |= CAN_TSR_ABRQ1; + break; + case (CAN_TXMAILBOX_2): CANx->TSR |= CAN_TSR_ABRQ2; + break; + default: + break; + } +} +/** + * @} + */ + + +/** @defgroup CAN_Group3 CAN Frames Reception functions + * @brief CAN Frames Reception functions + * +@verbatim + =============================================================================== + ##### CAN Frames Reception functions ##### + =============================================================================== + [..] This section provides functions allowing to + (+) Receive a correct CAN frame. + (+) Release a specified receive FIFO (2 FIFOs are available). + (+) Return the number of the pending received CAN frames. + +@endverbatim + * @{ + */ + +/** + * @brief Receives a correct CAN frame. + * @param CANx: where x can be 1 to select the CAN peripheral. + * @param FIFONumber: Receive FIFO number, CAN_FIFO0 or CAN_FIFO1. + * @param RxMessage: pointer to a structure receive frame which contains CAN Id, + * CAN DLC, CAN data and FMI number. + * @retval None + */ +void CAN_Receive(CAN_TypeDef* CANx, uint8_t FIFONumber, CanRxMsg* RxMessage) +{ + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_FIFO(FIFONumber)); + /* Get the Id */ + RxMessage->IDE = (uint8_t)0x04 & CANx->sFIFOMailBox[FIFONumber].RIR; + if (RxMessage->IDE == CAN_Id_Standard) + { + RxMessage->StdId = (uint32_t)0x000007FF & (CANx->sFIFOMailBox[FIFONumber].RIR >> 21); + } + else + { + RxMessage->ExtId = (uint32_t)0x1FFFFFFF & (CANx->sFIFOMailBox[FIFONumber].RIR >> 3); + } + + RxMessage->RTR = (uint8_t)0x02 & CANx->sFIFOMailBox[FIFONumber].RIR; + /* Get the DLC */ + RxMessage->DLC = (uint8_t)0x0F & CANx->sFIFOMailBox[FIFONumber].RDTR; + /* Get the FMI */ + RxMessage->FMI = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDTR >> 8); + /* Get the data field */ + RxMessage->Data[0] = (uint8_t)0xFF & CANx->sFIFOMailBox[FIFONumber].RDLR; + RxMessage->Data[1] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDLR >> 8); + RxMessage->Data[2] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDLR >> 16); + RxMessage->Data[3] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDLR >> 24); + RxMessage->Data[4] = (uint8_t)0xFF & CANx->sFIFOMailBox[FIFONumber].RDHR; + RxMessage->Data[5] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDHR >> 8); + RxMessage->Data[6] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDHR >> 16); + RxMessage->Data[7] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDHR >> 24); + /* Release the FIFO */ + /* Release FIFO0 */ + if (FIFONumber == CAN_FIFO0) + { + CANx->RF0R |= CAN_RF0R_RFOM0; + } + /* Release FIFO1 */ + else /* FIFONumber == CAN_FIFO1 */ + { + CANx->RF1R |= CAN_RF1R_RFOM1; + } +} + +/** + * @brief Releases the specified receive FIFO. + * @param CANx: where x can be 1 to select the CAN peripheral. + * @param FIFONumber: FIFO to release, CAN_FIFO0 or CAN_FIFO1. + * @retval None + */ +void CAN_FIFORelease(CAN_TypeDef* CANx, uint8_t FIFONumber) +{ + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_FIFO(FIFONumber)); + /* Release FIFO0 */ + if (FIFONumber == CAN_FIFO0) + { + CANx->RF0R |= CAN_RF0R_RFOM0; + } + /* Release FIFO1 */ + else /* FIFONumber == CAN_FIFO1 */ + { + CANx->RF1R |= CAN_RF1R_RFOM1; + } +} + +/** + * @brief Returns the number of pending received messages. + * @param CANx: where x can be 1 to select the CAN peripheral. + * @param FIFONumber: Receive FIFO number, CAN_FIFO0 or CAN_FIFO1. + * @retval NbMessage : which is the number of pending message. + */ +uint8_t CAN_MessagePending(CAN_TypeDef* CANx, uint8_t FIFONumber) +{ + uint8_t message_pending=0; + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_FIFO(FIFONumber)); + if (FIFONumber == CAN_FIFO0) + { + message_pending = (uint8_t)(CANx->RF0R&(uint32_t)0x03); + } + else if (FIFONumber == CAN_FIFO1) + { + message_pending = (uint8_t)(CANx->RF1R&(uint32_t)0x03); + } + else + { + message_pending = 0; + } + return message_pending; +} +/** + * @} + */ + + +/** @defgroup CAN_Group4 CAN Operation modes functions + * @brief CAN Operation modes functions + * +@verbatim + =============================================================================== + ##### CAN Operation modes functions ##### + =============================================================================== + [..] This section provides functions allowing to select the CAN Operation modes: + (+) sleep mode. + (+) normal mode. + (+) initialization mode. + +@endverbatim + * @{ + */ + + +/** + * @brief Selects the CAN Operation mode. + * @param CAN_OperatingMode: CAN Operating Mode. + * This parameter can be one of @ref CAN_OperatingMode_TypeDef enumeration. + * @retval status of the requested mode which can be: + * - CAN_ModeStatus_Failed: CAN failed entering the specific mode + * - CAN_ModeStatus_Success: CAN Succeed entering the specific mode + */ +uint8_t CAN_OperatingModeRequest(CAN_TypeDef* CANx, uint8_t CAN_OperatingMode) +{ + uint8_t status = CAN_ModeStatus_Failed; + + /* Timeout for INAK or also for SLAK bits*/ + uint32_t timeout = INAK_TIMEOUT; + + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_OPERATING_MODE(CAN_OperatingMode)); + + if (CAN_OperatingMode == CAN_OperatingMode_Initialization) + { + /* Request initialisation */ + CANx->MCR = (uint32_t)((CANx->MCR & (uint32_t)(~(uint32_t)CAN_MCR_SLEEP)) | CAN_MCR_INRQ); + + /* Wait the acknowledge */ + while (((CANx->MSR & CAN_MODE_MASK) != CAN_MSR_INAK) && (timeout != 0)) + { + timeout--; + } + if ((CANx->MSR & CAN_MODE_MASK) != CAN_MSR_INAK) + { + status = CAN_ModeStatus_Failed; + } + else + { + status = CAN_ModeStatus_Success; + } + } + else if (CAN_OperatingMode == CAN_OperatingMode_Normal) + { + /* Request leave initialisation and sleep mode and enter Normal mode */ + CANx->MCR &= (uint32_t)(~(CAN_MCR_SLEEP|CAN_MCR_INRQ)); + + /* Wait the acknowledge */ + while (((CANx->MSR & CAN_MODE_MASK) != 0) && (timeout!=0)) + { + timeout--; + } + if ((CANx->MSR & CAN_MODE_MASK) != 0) + { + status = CAN_ModeStatus_Failed; + } + else + { + status = CAN_ModeStatus_Success; + } + } + else if (CAN_OperatingMode == CAN_OperatingMode_Sleep) + { + /* Request Sleep mode */ + CANx->MCR = (uint32_t)((CANx->MCR & (uint32_t)(~(uint32_t)CAN_MCR_INRQ)) | CAN_MCR_SLEEP); + + /* Wait the acknowledge */ + while (((CANx->MSR & CAN_MODE_MASK) != CAN_MSR_SLAK) && (timeout!=0)) + { + timeout--; + } + if ((CANx->MSR & CAN_MODE_MASK) != CAN_MSR_SLAK) + { + status = CAN_ModeStatus_Failed; + } + else + { + status = CAN_ModeStatus_Success; + } + } + else + { + status = CAN_ModeStatus_Failed; + } + + return (uint8_t) status; +} + +/** + * @brief Enters the Sleep (low power) mode. + * @param CANx: where x can be 1 to select the CAN peripheral. + * @retval CAN_Sleep_Ok if sleep entered, CAN_Sleep_Failed otherwise. + */ +uint8_t CAN_Sleep(CAN_TypeDef* CANx) +{ + uint8_t sleepstatus = CAN_Sleep_Failed; + + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + + /* Request Sleep mode */ + CANx->MCR = (((CANx->MCR) & (uint32_t)(~(uint32_t)CAN_MCR_INRQ)) | CAN_MCR_SLEEP); + + /* Sleep mode status */ + if ((CANx->MSR & (CAN_MSR_SLAK|CAN_MSR_INAK)) == CAN_MSR_SLAK) + { + /* Sleep mode not entered */ + sleepstatus = CAN_Sleep_Ok; + } + /* return sleep mode status */ + return (uint8_t)sleepstatus; +} + +/** + * @brief Wakes up the CAN peripheral from sleep mode . + * @param CANx: where x can be 1 to select the CAN peripheral. + * @retval CAN_WakeUp_Ok if sleep mode left, CAN_WakeUp_Failed otherwise. + */ +uint8_t CAN_WakeUp(CAN_TypeDef* CANx) +{ + uint32_t wait_slak = SLAK_TIMEOUT; + uint8_t wakeupstatus = CAN_WakeUp_Failed; + + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + + /* Wake up request */ + CANx->MCR &= ~(uint32_t)CAN_MCR_SLEEP; + + /* Sleep mode status */ + while(((CANx->MSR & CAN_MSR_SLAK) == CAN_MSR_SLAK)&&(wait_slak!=0x00)) + { + wait_slak--; + } + if((CANx->MSR & CAN_MSR_SLAK) != CAN_MSR_SLAK) + { + /* wake up done : Sleep mode exited */ + wakeupstatus = CAN_WakeUp_Ok; + } + /* return wakeup status */ + return (uint8_t)wakeupstatus; +} +/** + * @} + */ + + +/** @defgroup CAN_Group5 CAN Bus Error management functions + * @brief CAN Bus Error management functions + * +@verbatim + =============================================================================== + ##### CAN Bus Error management functions ##### + =============================================================================== + [..] This section provides functions allowing to + (+) Return the CANx's last error code (LEC). + (+) Return the CANx Receive Error Counter (REC). + (+) Return the LSB of the 9-bit CANx Transmit Error Counter(TEC). + [..] + (@) If TEC is greater than 255, The CAN is in bus-off state. + (@) If REC or TEC are greater than 96, an Error warning flag occurs. + (@) If REC or TEC are greater than 127, an Error Passive Flag occurs. + +@endverbatim + * @{ + */ + +/** + * @brief Returns the CANx's last error code (LEC). + * @param CANx: where x can be 1 to select the CAN peripheral. + * @retval Error code: + * - CAN_ERRORCODE_NoErr: No Error + * - CAN_ERRORCODE_StuffErr: Stuff Error + * - CAN_ERRORCODE_FormErr: Form Error + * - CAN_ERRORCODE_ACKErr : Acknowledgment Error + * - CAN_ERRORCODE_BitRecessiveErr: Bit Recessive Error + * - CAN_ERRORCODE_BitDominantErr: Bit Dominant Error + * - CAN_ERRORCODE_CRCErr: CRC Error + * - CAN_ERRORCODE_SoftwareSetErr: Software Set Error + */ +uint8_t CAN_GetLastErrorCode(CAN_TypeDef* CANx) +{ + uint8_t errorcode=0; + + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + + /* Get the error code*/ + errorcode = (((uint8_t)CANx->ESR) & (uint8_t)CAN_ESR_LEC); + + /* Return the error code*/ + return errorcode; +} + +/** + * @brief Returns the CANx Receive Error Counter (REC). + * @note In case of an error during reception, this counter is incremented + * by 1 or by 8 depending on the error condition as defined by the CAN + * standard. After every successful reception, the counter is + * decremented by 1 or reset to 120 if its value was higher than 128. + * When the counter value exceeds 127, the CAN controller enters the + * error passive state. + * @param CANx: where x can be 1 or 2 to to select the CAN peripheral. + * @retval CAN Receive Error Counter. + */ +uint8_t CAN_GetReceiveErrorCounter(CAN_TypeDef* CANx) +{ + uint8_t counter=0; + + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + + /* Get the Receive Error Counter*/ + counter = (uint8_t)((CANx->ESR & CAN_ESR_REC)>> 24); + + /* Return the Receive Error Counter*/ + return counter; +} + + +/** + * @brief Returns the LSB of the 9-bit CANx Transmit Error Counter(TEC). + * @param CANx: where x can be 1 or 2 to to select the CAN peripheral. + * @retval LSB of the 9-bit CAN Transmit Error Counter. + */ +uint8_t CAN_GetLSBTransmitErrorCounter(CAN_TypeDef* CANx) +{ + uint8_t counter=0; + + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + + /* Get the LSB of the 9-bit CANx Transmit Error Counter(TEC) */ + counter = (uint8_t)((CANx->ESR & CAN_ESR_TEC)>> 16); + + /* Return the LSB of the 9-bit CANx Transmit Error Counter(TEC) */ + return counter; +} +/** + * @} + */ + +/** @defgroup CAN_Group6 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== + [..] This section provides functions allowing to configure the CAN Interrupts + and to get the status and clear flags and Interrupts pending bits. + [..] The CAN provides 14 Interrupts sources and 15 Flags: + + *** Flags *** + ============= + [..] The 15 flags can be divided on 4 groups: + (+) Transmit Flags: + (++) CAN_FLAG_RQCP0. + (++) CAN_FLAG_RQCP1. + (++) CAN_FLAG_RQCP2: Request completed MailBoxes 0, 1 and 2 Flags + Set when when the last request (transmit or abort) has + been performed. + (+) Receive Flags: + (++) CAN_FLAG_FMP0. + (++) CAN_FLAG_FMP1: FIFO 0 and 1 Message Pending Flags; + Set to signal that messages are pending in the receive FIFO. + These Flags are cleared only by hardware. + (++) CAN_FLAG_FF0. + (++) CAN_FLAG_FF1: FIFO 0 and 1 Full Flags; + Set when three messages are stored in the selected FIFO. + (++) CAN_FLAG_FOV0. + (++) CAN_FLAG_FOV1: FIFO 0 and 1 Overrun Flags; + Set when a new message has been received and passed the filter + while the FIFO was full. + (+) Operating Mode Flags: + (++) CAN_FLAG_WKU: Wake up Flag; + Set to signal that a SOF bit has been detected while the CAN + hardware was in Sleep mode. + (++) CAN_FLAG_SLAK: Sleep acknowledge Flag; + Set to signal that the CAN has entered Sleep Mode. + (+) Error Flags: + (++) CAN_FLAG_EWG: Error Warning Flag; + Set when the warning limit has been reached (Receive Error Counter + or Transmit Error Counter greater than 96). + This Flag is cleared only by hardware. + (++) CAN_FLAG_EPV: Error Passive Flag; + Set when the Error Passive limit has been reached (Receive Error + Counter or Transmit Error Counter greater than 127). + This Flag is cleared only by hardware. + (++) CAN_FLAG_BOF: Bus-Off Flag; + Set when CAN enters the bus-off state. The bus-off state is + entered on TEC overflow, greater than 255. + This Flag is cleared only by hardware. + (++) CAN_FLAG_LEC: Last error code Flag; + Set If a message has been transferred (reception or transmission) + with error, and the error code is hold. + + *** Interrupts *** + ================== + [..] The 14 interrupts can be divided on 4 groups: + (+) Transmit interrupt: + (++) CAN_IT_TME: Transmit mailbox empty Interrupt; + If enabled, this interrupt source is pending when no transmit + request are pending for Tx mailboxes. + (+) Receive Interrupts: + (++) CAN_IT_FMP0. + (++) CAN_IT_FMP1: FIFO 0 and FIFO1 message pending Interrupts; + If enabled, these interrupt sources are pending when messages + are pending in the receive FIFO. + The corresponding interrupt pending bits are cleared only by hardware. + (++) CAN_IT_FF0. + (++) CAN_IT_FF1: FIFO 0 and FIFO1 full Interrupts; + If enabled, these interrupt sources are pending when three messages + are stored in the selected FIFO. + (++) CAN_IT_FOV0. + (++) CAN_IT_FOV1: FIFO 0 and FIFO1 overrun Interrupts; + If enabled, these interrupt sources are pending when a new message + has been received and passed the filter while the FIFO was full. + (+) Operating Mode Interrupts: + (++) CAN_IT_WKU: Wake-up Interrupt; + If enabled, this interrupt source is pending when a SOF bit has + been detected while the CAN hardware was in Sleep mode. + (++) CAN_IT_SLK: Sleep acknowledge Interrupt: + If enabled, this interrupt source is pending when the CAN has + entered Sleep Mode. + (+) Error Interrupts: + (++) CAN_IT_EWG: Error warning Interrupt; + If enabled, this interrupt source is pending when the warning limit + has been reached (Receive Error Counter or Transmit Error Counter=96). + (++) CAN_IT_EPV: Error passive Interrupt; + If enabled, this interrupt source is pending when the Error Passive + limit has been reached (Receive Error Counter or Transmit Error Counter>127). + (++) CAN_IT_BOF: Bus-off Interrupt; + If enabled, this interrupt source is pending when CAN enters + the bus-off state. The bus-off state is entered on TEC overflow, + greater than 255. + This Flag is cleared only by hardware. + (++) CAN_IT_LEC: Last error code Interrupt; + If enabled, this interrupt source is pending when a message has + been transferred (reception or transmission) with error and the + error code is hold. + (++) CAN_IT_ERR: Error Interrupt; + If enabled, this interrupt source is pending when an error condition + is pending. + [..] Managing the CAN controller events: + The user should identify which mode will be used in his application to manage + the CAN controller events: Polling mode or Interrupt mode. + (+) In the Polling Mode it is advised to use the following functions: + (++) CAN_GetFlagStatus() : to check if flags events occur. + (++) CAN_ClearFlag() : to clear the flags events. + (+) In the Interrupt Mode it is advised to use the following functions: + (++) CAN_ITConfig() : to enable or disable the interrupt source. + (++) CAN_GetITStatus() : to check if Interrupt occurs. + (++) CAN_ClearITPendingBit() : to clear the Interrupt pending Bit + (corresponding Flag). + This function has no impact on CAN_IT_FMP0 and CAN_IT_FMP1 Interrupts + pending bits since there are cleared only by hardware. + +@endverbatim + * @{ + */ +/** + * @brief Enables or disables the specified CANx interrupts. + * @param CANx: where x can be 1 or 2 to to select the CAN peripheral. + * @param CAN_IT: specifies the CAN interrupt sources to be enabled or disabled. + * This parameter can be: + * @arg CAN_IT_TME: Transmit mailbox empty Interrupt + * @arg CAN_IT_FMP0: FIFO 0 message pending Interrupt + * @arg CAN_IT_FF0: FIFO 0 full Interrupt + * @arg CAN_IT_FOV0: FIFO 0 overrun Interrupt + * @arg CAN_IT_FMP1: FIFO 1 message pending Interrupt + * @arg CAN_IT_FF1: FIFO 1 full Interrupt + * @arg CAN_IT_FOV1: FIFO 1 overrun Interrupt + * @arg CAN_IT_WKU: Wake-up Interrupt + * @arg CAN_IT_SLK: Sleep acknowledge Interrupt + * @arg CAN_IT_EWG: Error warning Interrupt + * @arg CAN_IT_EPV: Error passive Interrupt + * @arg CAN_IT_BOF: Bus-off Interrupt + * @arg CAN_IT_LEC: Last error code Interrupt + * @arg CAN_IT_ERR: Error Interrupt + * @param NewState: new state of the CAN interrupts. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void CAN_ITConfig(CAN_TypeDef* CANx, uint32_t CAN_IT, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_IT(CAN_IT)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected CANx interrupt */ + CANx->IER |= CAN_IT; + } + else + { + /* Disable the selected CANx interrupt */ + CANx->IER &= ~CAN_IT; + } +} +/** + * @brief Checks whether the specified CAN flag is set or not. + * @param CANx: where x can be 1 or 2 to to select the CAN peripheral. + * @param CAN_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg CAN_FLAG_RQCP0: Request MailBox0 Flag + * @arg CAN_FLAG_RQCP1: Request MailBox1 Flag + * @arg CAN_FLAG_RQCP2: Request MailBox2 Flag + * @arg CAN_FLAG_FMP0: FIFO 0 Message Pending Flag + * @arg CAN_FLAG_FF0: FIFO 0 Full Flag + * @arg CAN_FLAG_FOV0: FIFO 0 Overrun Flag + * @arg CAN_FLAG_FMP1: FIFO 1 Message Pending Flag + * @arg CAN_FLAG_FF1: FIFO 1 Full Flag + * @arg CAN_FLAG_FOV1: FIFO 1 Overrun Flag + * @arg CAN_FLAG_WKU: Wake up Flag + * @arg CAN_FLAG_SLAK: Sleep acknowledge Flag + * @arg CAN_FLAG_EWG: Error Warning Flag + * @arg CAN_FLAG_EPV: Error Passive Flag + * @arg CAN_FLAG_BOF: Bus-Off Flag + * @arg CAN_FLAG_LEC: Last error code Flag + * @retval The new state of CAN_FLAG (SET or RESET). + */ +FlagStatus CAN_GetFlagStatus(CAN_TypeDef* CANx, uint32_t CAN_FLAG) +{ + FlagStatus bitstatus = RESET; + + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_GET_FLAG(CAN_FLAG)); + + + if((CAN_FLAG & CAN_FLAGS_ESR) != (uint32_t)RESET) + { + /* Check the status of the specified CAN flag */ + if ((CANx->ESR & (CAN_FLAG & 0x000FFFFF)) != (uint32_t)RESET) + { + /* CAN_FLAG is set */ + bitstatus = SET; + } + else + { + /* CAN_FLAG is reset */ + bitstatus = RESET; + } + } + else if((CAN_FLAG & CAN_FLAGS_MSR) != (uint32_t)RESET) + { + /* Check the status of the specified CAN flag */ + if ((CANx->MSR & (CAN_FLAG & 0x000FFFFF)) != (uint32_t)RESET) + { + /* CAN_FLAG is set */ + bitstatus = SET; + } + else + { + /* CAN_FLAG is reset */ + bitstatus = RESET; + } + } + else if((CAN_FLAG & CAN_FLAGS_TSR) != (uint32_t)RESET) + { + /* Check the status of the specified CAN flag */ + if ((CANx->TSR & (CAN_FLAG & 0x000FFFFF)) != (uint32_t)RESET) + { + /* CAN_FLAG is set */ + bitstatus = SET; + } + else + { + /* CAN_FLAG is reset */ + bitstatus = RESET; + } + } + else if((CAN_FLAG & CAN_FLAGS_RF0R) != (uint32_t)RESET) + { + /* Check the status of the specified CAN flag */ + if ((CANx->RF0R & (CAN_FLAG & 0x000FFFFF)) != (uint32_t)RESET) + { + /* CAN_FLAG is set */ + bitstatus = SET; + } + else + { + /* CAN_FLAG is reset */ + bitstatus = RESET; + } + } + else /* If(CAN_FLAG & CAN_FLAGS_RF1R != (uint32_t)RESET) */ + { + /* Check the status of the specified CAN flag */ + if ((uint32_t)(CANx->RF1R & (CAN_FLAG & 0x000FFFFF)) != (uint32_t)RESET) + { + /* CAN_FLAG is set */ + bitstatus = SET; + } + else + { + /* CAN_FLAG is reset */ + bitstatus = RESET; + } + } + /* Return the CAN_FLAG status */ + return bitstatus; +} + +/** + * @brief Clears the CAN's pending flags. + * @param CANx: where x can be 1 or 2 to to select the CAN peripheral. + * @param CAN_FLAG: specifies the flag to clear. + * This parameter can be one of the following values: + * @arg CAN_FLAG_RQCP0: Request MailBox0 Flag + * @arg CAN_FLAG_RQCP1: Request MailBox1 Flag + * @arg CAN_FLAG_RQCP2: Request MailBox2 Flag + * @arg CAN_FLAG_FF0: FIFO 0 Full Flag + * @arg CAN_FLAG_FOV0: FIFO 0 Overrun Flag + * @arg CAN_FLAG_FF1: FIFO 1 Full Flag + * @arg CAN_FLAG_FOV1: FIFO 1 Overrun Flag + * @arg CAN_FLAG_WKU: Wake up Flag + * @arg CAN_FLAG_SLAK: Sleep acknowledge Flag + * @arg CAN_FLAG_LEC: Last error code Flag + * @retval None + */ +void CAN_ClearFlag(CAN_TypeDef* CANx, uint32_t CAN_FLAG) +{ + uint32_t flagtmp=0; + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_CLEAR_FLAG(CAN_FLAG)); + + if (CAN_FLAG == CAN_FLAG_LEC) /* ESR register */ + { + /* Clear the selected CAN flags */ + CANx->ESR = (uint32_t)RESET; + } + else /* MSR or TSR or RF0R or RF1R */ + { + flagtmp = CAN_FLAG & 0x000FFFFF; + + if ((CAN_FLAG & CAN_FLAGS_RF0R)!=(uint32_t)RESET) + { + /* Receive Flags */ + CANx->RF0R = (uint32_t)(flagtmp); + } + else if ((CAN_FLAG & CAN_FLAGS_RF1R)!=(uint32_t)RESET) + { + /* Receive Flags */ + CANx->RF1R = (uint32_t)(flagtmp); + } + else if ((CAN_FLAG & CAN_FLAGS_TSR)!=(uint32_t)RESET) + { + /* Transmit Flags */ + CANx->TSR = (uint32_t)(flagtmp); + } + else /* If((CAN_FLAG & CAN_FLAGS_MSR)!=(uint32_t)RESET) */ + { + /* Operating mode Flags */ + CANx->MSR = (uint32_t)(flagtmp); + } + } +} + +/** + * @brief Checks whether the specified CANx interrupt has occurred or not. + * @param CANx: where x can be 1 or 2 to to select the CAN peripheral. + * @param CAN_IT: specifies the CAN interrupt source to check. + * This parameter can be one of the following values: + * @arg CAN_IT_TME: Transmit mailbox empty Interrupt + * @arg CAN_IT_FMP0: FIFO 0 message pending Interrupt + * @arg CAN_IT_FF0: FIFO 0 full Interrupt + * @arg CAN_IT_FOV0: FIFO 0 overrun Interrupt + * @arg CAN_IT_FMP1: FIFO 1 message pending Interrupt + * @arg CAN_IT_FF1: FIFO 1 full Interrupt + * @arg CAN_IT_FOV1: FIFO 1 overrun Interrupt + * @arg CAN_IT_WKU: Wake-up Interrupt + * @arg CAN_IT_SLK: Sleep acknowledge Interrupt + * @arg CAN_IT_EWG: Error warning Interrupt + * @arg CAN_IT_EPV: Error passive Interrupt + * @arg CAN_IT_BOF: Bus-off Interrupt + * @arg CAN_IT_LEC: Last error code Interrupt + * @arg CAN_IT_ERR: Error Interrupt + * @retval The current state of CAN_IT (SET or RESET). + */ +ITStatus CAN_GetITStatus(CAN_TypeDef* CANx, uint32_t CAN_IT) +{ + ITStatus itstatus = RESET; + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_IT(CAN_IT)); + + /* check the interrupt enable bit */ + if((CANx->IER & CAN_IT) != RESET) + { + /* in case the Interrupt is enabled, .... */ + switch (CAN_IT) + { + case CAN_IT_TME: + /* Check CAN_TSR_RQCPx bits */ + itstatus = CheckITStatus(CANx->TSR, CAN_TSR_RQCP0|CAN_TSR_RQCP1|CAN_TSR_RQCP2); + break; + case CAN_IT_FMP0: + /* Check CAN_RF0R_FMP0 bit */ + itstatus = CheckITStatus(CANx->RF0R, CAN_RF0R_FMP0); + break; + case CAN_IT_FF0: + /* Check CAN_RF0R_FULL0 bit */ + itstatus = CheckITStatus(CANx->RF0R, CAN_RF0R_FULL0); + break; + case CAN_IT_FOV0: + /* Check CAN_RF0R_FOVR0 bit */ + itstatus = CheckITStatus(CANx->RF0R, CAN_RF0R_FOVR0); + break; + case CAN_IT_FMP1: + /* Check CAN_RF1R_FMP1 bit */ + itstatus = CheckITStatus(CANx->RF1R, CAN_RF1R_FMP1); + break; + case CAN_IT_FF1: + /* Check CAN_RF1R_FULL1 bit */ + itstatus = CheckITStatus(CANx->RF1R, CAN_RF1R_FULL1); + break; + case CAN_IT_FOV1: + /* Check CAN_RF1R_FOVR1 bit */ + itstatus = CheckITStatus(CANx->RF1R, CAN_RF1R_FOVR1); + break; + case CAN_IT_WKU: + /* Check CAN_MSR_WKUI bit */ + itstatus = CheckITStatus(CANx->MSR, CAN_MSR_WKUI); + break; + case CAN_IT_SLK: + /* Check CAN_MSR_SLAKI bit */ + itstatus = CheckITStatus(CANx->MSR, CAN_MSR_SLAKI); + break; + case CAN_IT_EWG: + /* Check CAN_ESR_EWGF bit */ + itstatus = CheckITStatus(CANx->ESR, CAN_ESR_EWGF); + break; + case CAN_IT_EPV: + /* Check CAN_ESR_EPVF bit */ + itstatus = CheckITStatus(CANx->ESR, CAN_ESR_EPVF); + break; + case CAN_IT_BOF: + /* Check CAN_ESR_BOFF bit */ + itstatus = CheckITStatus(CANx->ESR, CAN_ESR_BOFF); + break; + case CAN_IT_LEC: + /* Check CAN_ESR_LEC bit */ + itstatus = CheckITStatus(CANx->ESR, CAN_ESR_LEC); + break; + case CAN_IT_ERR: + /* Check CAN_MSR_ERRI bit */ + itstatus = CheckITStatus(CANx->MSR, CAN_MSR_ERRI); + break; + default: + /* in case of error, return RESET */ + itstatus = RESET; + break; + } + } + else + { + /* in case the Interrupt is not enabled, return RESET */ + itstatus = RESET; + } + + /* Return the CAN_IT status */ + return itstatus; +} + +/** + * @brief Clears the CANx's interrupt pending bits. + * @param CANx: where x can be 1 or 2 to to select the CAN peripheral. + * @param CAN_IT: specifies the interrupt pending bit to clear. + * This parameter can be one of the following values: + * @arg CAN_IT_TME: Transmit mailbox empty Interrupt + * @arg CAN_IT_FF0: FIFO 0 full Interrupt + * @arg CAN_IT_FOV0: FIFO 0 overrun Interrupt + * @arg CAN_IT_FF1: FIFO 1 full Interrupt + * @arg CAN_IT_FOV1: FIFO 1 overrun Interrupt + * @arg CAN_IT_WKU: Wake-up Interrupt + * @arg CAN_IT_SLK: Sleep acknowledge Interrupt + * @arg CAN_IT_EWG: Error warning Interrupt + * @arg CAN_IT_EPV: Error passive Interrupt + * @arg CAN_IT_BOF: Bus-off Interrupt + * @arg CAN_IT_LEC: Last error code Interrupt + * @arg CAN_IT_ERR: Error Interrupt + * @retval None + */ +void CAN_ClearITPendingBit(CAN_TypeDef* CANx, uint32_t CAN_IT) +{ + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_CLEAR_IT(CAN_IT)); + + switch (CAN_IT) + { + case CAN_IT_TME: + /* Clear CAN_TSR_RQCPx (rc_w1)*/ + CANx->TSR = CAN_TSR_RQCP0|CAN_TSR_RQCP1|CAN_TSR_RQCP2; + break; + case CAN_IT_FF0: + /* Clear CAN_RF0R_FULL0 (rc_w1)*/ + CANx->RF0R = CAN_RF0R_FULL0; + break; + case CAN_IT_FOV0: + /* Clear CAN_RF0R_FOVR0 (rc_w1)*/ + CANx->RF0R = CAN_RF0R_FOVR0; + break; + case CAN_IT_FF1: + /* Clear CAN_RF1R_FULL1 (rc_w1)*/ + CANx->RF1R = CAN_RF1R_FULL1; + break; + case CAN_IT_FOV1: + /* Clear CAN_RF1R_FOVR1 (rc_w1)*/ + CANx->RF1R = CAN_RF1R_FOVR1; + break; + case CAN_IT_WKU: + /* Clear CAN_MSR_WKUI (rc_w1)*/ + CANx->MSR = CAN_MSR_WKUI; + break; + case CAN_IT_SLK: + /* Clear CAN_MSR_SLAKI (rc_w1)*/ + CANx->MSR = CAN_MSR_SLAKI; + break; + case CAN_IT_EWG: + /* Clear CAN_MSR_ERRI (rc_w1) */ + CANx->MSR = CAN_MSR_ERRI; + /* @note the corresponding Flag is cleared by hardware depending on the CAN Bus status*/ + break; + case CAN_IT_EPV: + /* Clear CAN_MSR_ERRI (rc_w1) */ + CANx->MSR = CAN_MSR_ERRI; + /* @note the corresponding Flag is cleared by hardware depending on the CAN Bus status*/ + break; + case CAN_IT_BOF: + /* Clear CAN_MSR_ERRI (rc_w1) */ + CANx->MSR = CAN_MSR_ERRI; + /* @note the corresponding Flag is cleared by hardware depending on the CAN Bus status*/ + break; + case CAN_IT_LEC: + /* Clear LEC bits */ + CANx->ESR = RESET; + /* Clear CAN_MSR_ERRI (rc_w1) */ + CANx->MSR = CAN_MSR_ERRI; + break; + case CAN_IT_ERR: + /*Clear LEC bits */ + CANx->ESR = RESET; + /* Clear CAN_MSR_ERRI (rc_w1) */ + CANx->MSR = CAN_MSR_ERRI; + /* @note BOFF, EPVF and EWGF Flags are cleared by hardware depending on the CAN Bus status*/ + break; + default: + break; + } +} + /** + * @} + */ + +/** + * @brief Checks whether the CAN interrupt has occurred or not. + * @param CAN_Reg: specifies the CAN interrupt register to check. + * @param It_Bit: specifies the interrupt source bit to check. + * @retval The new state of the CAN Interrupt (SET or RESET). + */ +static ITStatus CheckITStatus(uint32_t CAN_Reg, uint32_t It_Bit) +{ + ITStatus pendingbitstatus = RESET; + + if ((CAN_Reg & It_Bit) != (uint32_t)RESET) + { + /* CAN_IT is set */ + pendingbitstatus = SET; + } + else + { + /* CAN_IT is reset */ + pendingbitstatus = RESET; + } + return pendingbitstatus; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_cec.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_cec.c new file mode 100644 index 00000000..f49e8b9d --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_cec.c @@ -0,0 +1,607 @@ +/** + ****************************************************************************** + * @file stm32f0xx_cec.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Consumer Electronics Control (CEC) peripheral + * applicable only on STM32F051, STM32F042 and STM32F072 devices: + * + Initialization and Configuration + * + Data transfers functions + * + Interrupts and flags management + * + * @verbatim + ============================================================================== + ##### CEC features ##### + ============================================================================== + [..] This device provides some features: + (#) Supports HDMI-CEC specification 1.4. + (#) Supports two source clocks(HSI/244 or LSE). + (#) Works in stop mode(without APB clock, but with CEC clock 32KHz). + It can genarate an interrupt in the CEC clock domain that the CPU + wakes up from the low power mode. + (#) Configurable Signal Free Time before of transmission start. The + number of nominal data bit periods waited before transmission can be + ruled by Hardware or Software. + (#) Configurable Peripheral Address (multi-addressing configuration). + (#) Supports listen mode.The CEC Messages addressed to different destination + can be received without interfering with CEC bus when Listen mode option is enabled. + (#) Configurable Rx-Tolerance(Standard and Extended tolerance margin). + (#) Error detection with configurable error bit generation. + (#) Arbitration lost error in the case of two CEC devices starting at the same time. + + ##### How to use this driver ##### + ============================================================================== + [..] This driver provides functions to configure and program the CEC device, + follow steps below: + (#) The source clock can be configured using: + (++) RCC_CECCLKConfig(RCC_CECCLK_HSI_Div244) for HSI(Default) + (++) RCC_CECCLKConfig(RCC_CECCLK_LSE) for LSE. + (#) Enable CEC peripheral clock using RCC_APBPeriphClockCmd(RCC_APBPeriph_CEC, ENABLE). + (#) Peripherals alternate function. + (++) Connect the pin to the desired peripherals' Alternate Function (AF) using + GPIO_PinAFConfig() function. + (++) Configure the desired pin in alternate function by: + GPIO_InitStruct->GPIO_Mode = GPIO_Mode_AF. + (++) Select the type open-drain and output speed via GPIO_OType + and GPIO_Speed members. + (++) Call GPIO_Init() function. + (#) Configure the Signal Free Time, Rx Tolerance, Stop reception generation + and Bit error generation using the CEC_Init() function. + The function CEC_Init() must be called when the CEC peripheral is disabled. + (#) Configure the CEC own address by calling the fuction CEC_OwnAddressConfig(). + (#) Optionally, you can configure the Listen mode using the function CEC_ListenModeCmd(). + (#) Enable the NVIC and the corresponding interrupt using the function + CEC_ITConfig() if you need to use interrupt mode. + CEC_ITConfig() must be called before enabling the CEC peripheral. + (#) Enable the CEC using the CEC_Cmd() function. + (#) Charge the first data byte in the TXDR register using CEC_SendDataByte(). + (#) Enable the transmission of the Byte of a CEC message using CEC_StartOfMessage() + (#) Transmit single data through the CEC peripheral using CEC_SendDataByte() + and Receive the last transmitted byte using CEC_ReceiveDataByte(). + (#) Enable the CEC_EndOfMessage() in order to indicate the last byte of the message. + [..] + (@) If the listen mode is enabled, Stop reception generation and Bit error generation + must be in reset state. + (@) If the CEC message consists of only 1 byte, the function CEC_EndOfMessage() + must be called before CEC_StartOfMessage(). + + @endverbatim + * + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_cec.h" +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup CEC + * @brief CEC driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +#define BROADCAST_ADDRESS ((uint32_t)0x0000F) +#define CFGR_CLEAR_MASK ((uint32_t)0x7000FE00) /* CFGR register Mask */ + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup CEC_Private_Functions + * @{ + */ + +/** @defgroup CEC_Group1 Initialization and Configuration functions + * @brief Initialization and Configuration functions + * +@verbatim + =============================================================================== + ##### Initialization and Configuration functions ##### + =============================================================================== + [..] This section provides functions allowing to initialize: + (+) CEC own addresses + (+) CEC Signal Free Time + (+) CEC Rx Tolerance + (+) CEC Stop Reception + (+) CEC Bit Rising Error + (+) CEC Long Bit Period Error + [..] This section provides also a function to configure the CEC peripheral in Listen Mode. + Messages addressed to different destination can be received when Listen mode is + enabled without interfering with CEC bus. +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the CEC peripheral registers to their default reset values. + * @param None + * @retval None + */ +void CEC_DeInit(void) +{ + RCC_APB1PeriphResetCmd(RCC_APB1Periph_CEC, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_CEC, DISABLE); +} + +/** + * @brief Initializes the CEC peripheral according to the specified parameters + * in the CEC_InitStruct. + * @note The CEC parameters must be configured before enabling the CEC peripheral. + * @param CEC_InitStruct: pointer to an CEC_InitTypeDef structure that contains + * the configuration information for the specified CEC peripheral. + * @retval None + */ +void CEC_Init(CEC_InitTypeDef* CEC_InitStruct) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_CEC_SIGNAL_FREE_TIME(CEC_InitStruct->CEC_SignalFreeTime)); + assert_param(IS_CEC_RX_TOLERANCE(CEC_InitStruct->CEC_RxTolerance)); + assert_param(IS_CEC_STOP_RECEPTION(CEC_InitStruct->CEC_StopReception)); + assert_param(IS_CEC_BIT_RISING_ERROR(CEC_InitStruct->CEC_BitRisingError)); + assert_param(IS_CEC_LONG_BIT_PERIOD_ERROR(CEC_InitStruct->CEC_LongBitPeriodError)); + assert_param(IS_CEC_BDR_NO_GEN_ERROR(CEC_InitStruct->CEC_BRDNoGen)); + assert_param(IS_CEC_SFT_OPTION(CEC_InitStruct->CEC_SFTOption)); + + /* Get the CEC CFGR value */ + tmpreg = CEC->CFGR; + + /* Clear CFGR bits */ + tmpreg &= CFGR_CLEAR_MASK; + + /* Configure the CEC peripheral */ + tmpreg |= (CEC_InitStruct->CEC_SignalFreeTime | CEC_InitStruct->CEC_RxTolerance | + CEC_InitStruct->CEC_StopReception | CEC_InitStruct->CEC_BitRisingError | + CEC_InitStruct->CEC_LongBitPeriodError| CEC_InitStruct->CEC_BRDNoGen | + CEC_InitStruct->CEC_SFTOption); + + /* Write to CEC CFGR register */ + CEC->CFGR = tmpreg; +} + +/** + * @brief Fills each CEC_InitStruct member with its default value. + * @param CEC_InitStruct: pointer to a CEC_InitTypeDef structure which will + * be initialized. + * @retval None + */ +void CEC_StructInit(CEC_InitTypeDef* CEC_InitStruct) +{ + CEC_InitStruct->CEC_SignalFreeTime = CEC_SignalFreeTime_Standard; + CEC_InitStruct->CEC_RxTolerance = CEC_RxTolerance_Standard; + CEC_InitStruct->CEC_StopReception = CEC_StopReception_Off; + CEC_InitStruct->CEC_BitRisingError = CEC_BitRisingError_Off; + CEC_InitStruct->CEC_LongBitPeriodError = CEC_LongBitPeriodError_Off; + CEC_InitStruct->CEC_BRDNoGen = CEC_BRDNoGen_Off; + CEC_InitStruct->CEC_SFTOption = CEC_SFTOption_Off; +} + +/** + * @brief Enables or disables the CEC peripheral. + * @param NewState: new state of the CEC peripheral. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void CEC_Cmd(FunctionalState NewState) +{ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the CEC peripheral */ + CEC->CR |= CEC_CR_CECEN; + } + else + { + /* Disable the CEC peripheral */ + CEC->CR &= ~CEC_CR_CECEN; + } +} + +/** + * @brief Enables or disables the CEC Listen Mode. + * @param NewState: new state of the Listen Mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void CEC_ListenModeCmd(FunctionalState NewState) +{ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the Listen Mode */ + CEC->CFGR |= CEC_CFGR_LSTN; + } + else + { + /* Disable the Listen Mode */ + CEC->CFGR &= ~CEC_CFGR_LSTN; + } +} + +/** + * @brief Defines the Own Address of the CEC device. + * @param CEC_OwnAddress: The CEC own address. + * @retval None + */ +void CEC_OwnAddressConfig(uint8_t CEC_OwnAddress) +{ + uint32_t tmp =0x00; + /* Check the parameters */ + assert_param(IS_CEC_ADDRESS(CEC_OwnAddress)); + tmp = 1 <<(CEC_OwnAddress + 16); + /* Set the CEC own address */ + CEC->CFGR |= tmp; +} + +/** + * @brief Clears the Own Address of the CEC device. + * @param CEC_OwnAddress: The CEC own address. + * @retval None + */ +void CEC_OwnAddressClear(void) +{ + /* Set the CEC own address */ + CEC->CFGR = 0x0; +} + +/** + * @} + */ + +/** @defgroup CEC_Group2 Data transfers functions + * @brief Data transfers functions + * +@verbatim + =============================================================================== + ##### Data transfers functions ##### + =============================================================================== + [..] This section provides functions allowing the CEC data transfers.The read + access of the CEC_RXDR register can be done using the CEC_ReceiveData()function + and returns the Rx buffered value. Whereas a write access to the CEC_TXDR can be + done using CEC_SendData() function. +@endverbatim + * @{ + */ + +/** + * @brief Transmits single data through the CEC peripheral. + * @param Data: the data to transmit. + * @retval None + */ +void CEC_SendData(uint8_t Data) +{ + /* Transmit Data */ + CEC->TXDR = Data; +} + +/** + * @brief Returns the most recent received data by the CEC peripheral. + * @param None + * @retval The received data. + */ +uint8_t CEC_ReceiveData(void) +{ + /* Receive Data */ + return (uint8_t)(CEC->RXDR); +} + +/** + * @brief Starts a new message. + * @param None + * @retval None + */ +void CEC_StartOfMessage(void) +{ + /* Starts of new message */ + CEC->CR |= CEC_CR_TXSOM; +} + +/** + * @brief Transmits message with an EOM bit. + * @param None + * @retval None + */ +void CEC_EndOfMessage(void) +{ + /* The data byte will be transmitted with an EOM bit */ + CEC->CR |= CEC_CR_TXEOM; +} + +/** + * @} + */ + +/** @defgroup CEC_Group3 Interrupts and flags management functions + * @brief Interrupts and flags management functions +* +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== + [..] This section provides functions allowing to configure the CEC Interrupts + sources and check or clear the flags or pending bits status. + [..] The user should identify which mode will be used in his application to manage + the communication: Polling mode or Interrupt mode. + + [..] In polling mode, the CEC can be managed by the following flags: + (+) CEC_FLAG_TXACKE : to indicate a missing acknowledge in transmission mode. + (+) CEC_FLAG_TXERR : to indicate an error occurs during transmission mode. + The initiator detects low impedance in the CEC line. + (+) CEC_FLAG_TXUDR : to indicate if an underrun error occurs in transmission mode. + The transmission is enabled while the software has not yet + loaded any value into the TXDR register. + (+) CEC_FLAG_TXEND : to indicate the end of successful transmission. + (+) CEC_FLAG_TXBR : to indicate the next transmission data has to be written to TXDR. + (+) CEC_FLAG_ARBLST : to indicate arbitration lost in the case of two CEC devices + starting at the same time. + (+) CEC_FLAG_RXACKE : to indicate a missing acknowledge in receive mode. + (+) CEC_FLAG_LBPE : to indicate a long bit period error generated during receive mode. + (+) CEC_FLAG_SBPE : to indicate a short bit period error generated during receive mode. + (+) CEC_FLAG_BRE : to indicate a bit rising error generated during receive mode. + (+) CEC_FLAG_RXOVR : to indicate if an overrun error occur while receiving a CEC message. + A byte is not yet received while a new byte is stored in the RXDR register. + (+) CEC_FLAG_RXEND : to indicate the end Of reception + (+) CEC_FLAG_RXBR : to indicate a new byte has been received from the CEC line and + stored into the RXDR buffer. + [..] + (@)In this Mode, it is advised to use the following functions: + FlagStatus CEC_GetFlagStatus(uint16_t CEC_FLAG); + void CEC_ClearFlag(uint16_t CEC_FLAG); + + [..] In Interrupt mode, the CEC can be managed by the following interrupt sources: + (+) CEC_IT_TXACKE : to indicate a TX Missing acknowledge + (+) CEC_IT_TXACKE : to indicate a missing acknowledge in transmission mode. + (+) CEC_IT_TXERR : to indicate an error occurs during transmission mode. + The initiator detects low impedance in the CEC line. + (+) CEC_IT_TXUDR : to indicate if an underrun error occurs in transmission mode. + The transmission is enabled while the software has not yet + loaded any value into the TXDR register. + (+) CEC_IT_TXEND : to indicate the end of successful transmission. + (+) CEC_IT_TXBR : to indicate the next transmission data has to be written to TXDR register. + (+) CEC_IT_ARBLST : to indicate arbitration lost in the case of two CEC devices + starting at the same time. + (+) CEC_IT_RXACKE : to indicate a missing acknowledge in receive mode. + (+) CEC_IT_LBPE : to indicate a long bit period error generated during receive mode. + (+) CEC_IT_SBPE : to indicate a short bit period error generated during receive mode. + (+) CEC_IT_BRE : to indicate a bit rising error generated during receive mode. + (+) CEC_IT_RXOVR : to indicate if an overrun error occur while receiving a CEC message. + A byte is not yet received while a new byte is stored in the RXDR register. + (+) CEC_IT_RXEND : to indicate the end Of reception + (+) CEC_IT_RXBR : to indicate a new byte has been received from the CEC line and + stored into the RXDR buffer. + [..] + (@)In this Mode it is advised to use the following functions: + void CEC_ITConfig( uint16_t CEC_IT, FunctionalState NewState); + ITStatus CEC_GetITStatus(uint16_t CEC_IT); + void CEC_ClearITPendingBit(uint16_t CEC_IT); + + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the selected CEC interrupts. + * @param CEC_IT: specifies the CEC interrupt source to be enabled. + * This parameter can be any combination of the following values: + * @arg CEC_IT_TXACKE: Tx Missing acknowledge Error + * @arg CEC_IT_TXERR: Tx Error. + * @arg CEC_IT_TXUDR: Tx-Buffer Underrun. + * @arg CEC_IT_TXEND: End of Transmission (successful transmission of the last byte). + * @arg CEC_IT_TXBR: Tx-Byte Request. + * @arg CEC_IT_ARBLST: Arbitration Lost + * @arg CEC_IT_RXACKE: Rx-Missing Acknowledge + * @arg CEC_IT_LBPE: Rx Long period Error + * @arg CEC_IT_SBPE: Rx Short period Error + * @arg CEC_IT_BRE: Rx Bit Rising Error + * @arg CEC_IT_RXOVR: Rx Overrun. + * @arg CEC_IT_RXEND: End Of Reception + * @arg CEC_IT_RXBR: Rx-Byte Received + * @param NewState: new state of the selected CEC interrupts. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void CEC_ITConfig(uint16_t CEC_IT, FunctionalState NewState) +{ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + assert_param(IS_CEC_IT(CEC_IT)); + + if (NewState != DISABLE) + { + /* Enable the selected CEC interrupt */ + CEC->IER |= CEC_IT; + } + else + { + CEC_IT =~CEC_IT; + /* Disable the selected CEC interrupt */ + CEC->IER &= CEC_IT; + } +} + +/** + * @brief Gets the CEC flag status. + * @param CEC_FLAG: specifies the CEC flag to check. + * This parameter can be one of the following values: + * @arg CEC_FLAG_TXACKE: Tx Missing acknowledge Error + * @arg CEC_FLAG_TXERR: Tx Error. + * @arg CEC_FLAG_TXUDR: Tx-Buffer Underrun. + * @arg CEC_FLAG_TXEND: End of transmission (successful transmission of the last byte). + * @arg CEC_FLAG_TXBR: Tx-Byte Request. + * @arg CEC_FLAG_ARBLST: Arbitration Lost + * @arg CEC_FLAG_RXACKE: Rx-Missing Acknowledge + * @arg CEC_FLAG_LBPE: Rx Long period Error + * @arg CEC_FLAG_SBPE: Rx Short period Error + * @arg CEC_FLAG_BRE: Rx Bit Rissing Error + * @arg CEC_FLAG_RXOVR: Rx Overrun. + * @arg CEC_FLAG_RXEND: End Of Reception. + * @arg CEC_FLAG_RXBR: Rx-Byte Received. + * @retval The new state of CEC_FLAG (SET or RESET) + */ +FlagStatus CEC_GetFlagStatus(uint16_t CEC_FLAG) +{ + FlagStatus bitstatus = RESET; + + assert_param(IS_CEC_GET_FLAG(CEC_FLAG)); + + /* Check the status of the specified CEC flag */ + if ((CEC->ISR & CEC_FLAG) != (uint16_t)RESET) + { + /* CEC flag is set */ + bitstatus = SET; + } + else + { + /* CEC flag is reset */ + bitstatus = RESET; + } + + /* Return the CEC flag status */ + return bitstatus; +} + +/** + * @brief Clears the CEC's pending flags. + * @param CEC_FLAG: specifies the flag to clear. + * This parameter can be any combination of the following values: + * @arg CEC_FLAG_TXACKE: Tx Missing acknowledge Error + * @arg CEC_FLAG_TXERR: Tx Error + * @arg CEC_FLAG_TXUDR: Tx-Buffer Underrun + * @arg CEC_FLAG_TXEND: End of transmission (successful transmission of the last byte). + * @arg CEC_FLAG_TXBR: Tx-Byte Request + * @arg CEC_FLAG_ARBLST: Arbitration Lost + * @arg CEC_FLAG_RXACKE: Rx Missing Acknowledge + * @arg CEC_FLAG_LBPE: Rx Long period Error + * @arg CEC_FLAG_SBPE: Rx Short period Error + * @arg CEC_FLAG_BRE: Rx Bit Rising Error + * @arg CEC_FLAG_RXOVR: Rx Overrun + * @arg CEC_FLAG_RXEND: End Of Reception + * @arg CEC_FLAG_RXBR: Rx-Byte Received + * @retval None + */ +void CEC_ClearFlag(uint32_t CEC_FLAG) +{ + assert_param(IS_CEC_CLEAR_FLAG(CEC_FLAG)); + + /* Clear the selected CEC flag */ + CEC->ISR = CEC_FLAG; +} + +/** + * @brief Checks whether the specified CEC interrupt has occurred or not. + * @param CEC_IT: specifies the CEC interrupt source to check. + * This parameter can be one of the following values: + * @arg CEC_IT_TXACKE: Tx Missing acknowledge Error + * @arg CEC_IT_TXERR: Tx Error. + * @arg CEC_IT_TXUDR: Tx-Buffer Underrun. + * @arg CEC_IT_TXEND: End of transmission (successful transmission of the last byte). + * @arg CEC_IT_TXBR: Tx-Byte Request. + * @arg CEC_IT_ARBLST: Arbitration Lost. + * @arg CEC_IT_RXACKE: Rx-Missing Acknowledge. + * @arg CEC_IT_LBPE: Rx Long period Error. + * @arg CEC_IT_SBPE: Rx Short period Error. + * @arg CEC_IT_BRE: Rx Bit Rising Error. + * @arg CEC_IT_RXOVR: Rx Overrun. + * @arg CEC_IT_RXEND: End Of Reception. + * @arg CEC_IT_RXBR: Rx-Byte Received + * @retval The new state of CEC_IT (SET or RESET). + */ +ITStatus CEC_GetITStatus(uint16_t CEC_IT) +{ + ITStatus bitstatus = RESET; + uint32_t enablestatus = 0; + + /* Check the parameters */ + assert_param(IS_CEC_GET_IT(CEC_IT)); + + /* Get the CEC IT enable bit status */ + enablestatus = (CEC->IER & CEC_IT); + + /* Check the status of the specified CEC interrupt */ + if (((CEC->ISR & CEC_IT) != (uint32_t)RESET) && enablestatus) + { + /* CEC interrupt is set */ + bitstatus = SET; + } + else + { + /* CEC interrupt is reset */ + bitstatus = RESET; + } + + /* Return the CEC interrupt status */ + return bitstatus; +} + +/** + * @brief Clears the CEC's interrupt pending bits. + * @param CEC_IT: specifies the CEC interrupt pending bit to clear. + * This parameter can be any combination of the following values: + * @arg CEC_IT_TXACKE: Tx Missing acknowledge Error + * @arg CEC_IT_TXERR: Tx Error + * @arg CEC_IT_TXUDR: Tx-Buffer Underrun + * @arg CEC_IT_TXEND: End of Transmission + * @arg CEC_IT_TXBR: Tx-Byte Request + * @arg CEC_IT_ARBLST: Arbitration Lost + * @arg CEC_IT_RXACKE: Rx-Missing Acknowledge + * @arg CEC_IT_LBPE: Rx Long period Error + * @arg CEC_IT_SBPE: Rx Short period Error + * @arg CEC_IT_BRE: Rx Bit Rising Error + * @arg CEC_IT_RXOVR: Rx Overrun + * @arg CEC_IT_RXEND: End Of Reception + * @arg CEC_IT_RXBR: Rx-Byte Received + * @retval None + */ +void CEC_ClearITPendingBit(uint16_t CEC_IT) +{ + assert_param(IS_CEC_IT(CEC_IT)); + + /* Clear the selected CEC interrupt pending bits */ + CEC->ISR = CEC_IT; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_comp.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_comp.c new file mode 100644 index 00000000..be7249e3 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_comp.c @@ -0,0 +1,408 @@ +/** + ****************************************************************************** + * @file stm32f0xx_comp.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the comparators (COMP1 and COMP2) peripheral + * applicable only on STM32F051 and STM32F072 devices: + * + Comparators configuration + * + Window mode control + * + * @verbatim + * + =============================================================================== + ##### How to use this driver ##### + =============================================================================== + [..] + + The device integrates two analog comparators COMP1 and COMP2: + (+) The non inverting input is set to PA1 for COMP1 and to PA3 + for COMP2. + + (+) The inverting input can be selected among: DAC1_OUT, DAC2_OUT + 1/4 VREFINT, 1/2 VERFINT, 3/4 VREFINT, VREFINT, + I/O (PA0 for COMP1 and PA2 for COMP2) + + (+) The COMP output is internally is available using COMP_GetOutputLevel() + and can be set on GPIO pins: PA0, PA6, PA11 for COMP1 + and PA2, PA7, PA12 for COMP2 + + (+) The COMP output can be redirected to embedded timers (TIM1, TIM2 + and TIM3) + + (+) The two comparators COMP1 and COMP2 can be combined in window + mode and only COMP1 non inverting (PA1) can be used as non- + inverting input. + + (+) The two comparators COMP1 and COMP2 have interrupt capability + with wake-up from Sleep and Stop modes (through the EXTI controller). + COMP1 and COMP2 outputs are internally connected to EXTI Line 21 + and EXTI Line 22 respectively. + + + ##### How to configure the comparator ##### + =============================================================================== + [..] + This driver provides functions to configure and program the Comparators + of all STM32F0xx devices. + + [..] To use the comparator, perform the following steps: + + (#) Enable the SYSCFG APB clock to get write access to comparator + register using RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE); + + (#) Configure the comparator input in analog mode using GPIO_Init() + + (#) Configure the comparator output in alternate function mode + using GPIO_Init() and use GPIO_PinAFConfig() function to map the + comparator output to the GPIO pin + + (#) Configure the comparator using COMP_Init() function: + (++) Select the inverting input + (++) Select the output polarity + (++) Select the output redirection + (++) Select the hysteresis level + (++) Select the power mode + + (#) Enable the comparator using COMP_Cmd() function + + (#) If required enable the COMP interrupt by configuring and enabling + EXTI line in Interrupt mode and selecting the desired sensitivity + level using EXTI_Init() function. After that enable the comparator + interrupt vector using NVIC_Init() function. + + @endverbatim + * + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_comp.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup COMP + * @brief COMP driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* CSR register Mask */ +#define COMP_CSR_CLEAR_MASK ((uint32_t)0x00003FFE) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup COMP_Private_Functions + * @{ + */ + +/** @defgroup COMP_Group1 Initialization and Configuration functions + * @brief Initialization and Configuration functions + * +@verbatim + =============================================================================== + ##### Initialization and Configuration functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes COMP peripheral registers to their default reset values. + * @note Deinitialization can't be performed if the COMP configuration is locked. + * To unlock the configuration, perform a system reset. + * @param None + * @retval None + */ +void COMP_DeInit(void) +{ + COMP->CSR = ((uint32_t)0x00000000); /*!< Set COMP_CSR register to reset value */ +} + +/** + * @brief Initializes the COMP peripheral according to the specified parameters + * in COMP_InitStruct + * @note If the selected comparator is locked, initialization can't be performed. + * To unlock the configuration, perform a system reset. + * @note By default, PA1 is selected as COMP1 non inverting input. + * To use PA4 as COMP1 non inverting input call COMP_SwitchCmd() after COMP_Init() + * @param COMP_Selection: the selected comparator. + * This parameter can be one of the following values: + * @arg COMP_Selection_COMP1: COMP1 selected + * @arg COMP_Selection_COMP2: COMP2 selected + * @param COMP_InitStruct: pointer to an COMP_InitTypeDef structure that contains + * the configuration information for the specified COMP peripheral. + * @retval None + */ +void COMP_Init(uint32_t COMP_Selection, COMP_InitTypeDef* COMP_InitStruct) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_COMP_ALL_PERIPH(COMP_Selection)); + assert_param(IS_COMP_INVERTING_INPUT(COMP_InitStruct->COMP_InvertingInput)); + assert_param(IS_COMP_OUTPUT(COMP_InitStruct->COMP_Output)); + assert_param(IS_COMP_OUTPUT_POL(COMP_InitStruct->COMP_OutputPol)); + assert_param(IS_COMP_HYSTERESIS(COMP_InitStruct->COMP_Hysteresis)); + assert_param(IS_COMP_MODE(COMP_InitStruct->COMP_Mode)); + + /*!< Get the COMP_CSR register value */ + tmpreg = COMP->CSR; + + /*!< Clear the COMP1SW1, COMPx_IN_SEL, COMPx_OUT_TIM_SEL, COMPx_POL, COMPx_HYST and COMPx_PWR_MODE bits */ + tmpreg &= (uint32_t) ~(COMP_CSR_CLEAR_MASK<COMP_InvertingInput value */ + /*!< Set COMPxOUTSEL bits according to COMP_InitStruct->COMP_Output value */ + /*!< Set COMPxPOL bit according to COMP_InitStruct->COMP_OutputPol value */ + /*!< Set COMPxHYST bits according to COMP_InitStruct->COMP_Hysteresis value */ + /*!< Set COMPxMODE bits according to COMP_InitStruct->COMP_Mode value */ + tmpreg |= (uint32_t)((COMP_InitStruct->COMP_InvertingInput | COMP_InitStruct->COMP_Output | + COMP_InitStruct->COMP_OutputPol | COMP_InitStruct->COMP_Hysteresis | + COMP_InitStruct->COMP_Mode)<CSR = tmpreg; +} + +/** + * @brief Fills each COMP_InitStruct member with its default value. + * @param COMP_InitStruct: pointer to an COMP_InitTypeDef structure which will + * be initialized. + * @retval None + */ +void COMP_StructInit(COMP_InitTypeDef* COMP_InitStruct) +{ + COMP_InitStruct->COMP_InvertingInput = COMP_InvertingInput_1_4VREFINT; + COMP_InitStruct->COMP_Output = COMP_Output_None; + COMP_InitStruct->COMP_OutputPol = COMP_OutputPol_NonInverted; + COMP_InitStruct->COMP_Hysteresis = COMP_Hysteresis_No; + COMP_InitStruct->COMP_Mode = COMP_Mode_UltraLowPower; +} + +/** + * @brief Enable or disable the COMP peripheral. + * @note If the selected comparator is locked, enable/disable can't be performed. + * To unlock the configuration, perform a system reset. + * @param COMP_Selection: the selected comparator. + * This parameter can be one of the following values: + * @arg COMP_Selection_COMP1: COMP1 selected + * @arg COMP_Selection_COMP2: COMP2 selected + * @param NewState: new state of the COMP peripheral. + * This parameter can be: ENABLE or DISABLE. + * @note When enabled, the comparator compares the non inverting input with + * the inverting input and the comparison result is available on comparator output. + * @note When disabled, the comparator doesn't perform comparison and the + * output level is low. + * @retval None + */ +void COMP_Cmd(uint32_t COMP_Selection, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_COMP_ALL_PERIPH(COMP_Selection)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected COMP peripheral */ + COMP->CSR |= (uint32_t) (1<CSR &= (uint32_t)(~((uint32_t)1<CSR |= (uint32_t) (COMP_CSR_COMP1SW1); + } + else + { + /* Open SW1 switch */ + COMP->CSR &= (uint32_t)(~COMP_CSR_COMP1SW1); + } +} + +/** + * @brief Return the output level (high or low) of the selected comparator. + * @note The output level depends on the selected polarity. + * @note If the polarity is not inverted: + * - Comparator output is low when the non-inverting input is at a lower + * voltage than the inverting input + * - Comparator output is high when the non-inverting input is at a higher + * voltage than the inverting input + * @note If the polarity is inverted: + * - Comparator output is high when the non-inverting input is at a lower + * voltage than the inverting input + * - Comparator output is low when the non-inverting input is at a higher + * voltage than the inverting input + * @param COMP_Selection: the selected comparator. + * This parameter can be one of the following values: + * @arg COMP_Selection_COMP1: COMP1 selected + * @arg COMP_Selection_COMP2: COMP2 selected + * @retval Returns the selected comparator output level: low or high. + * + */ +uint32_t COMP_GetOutputLevel(uint32_t COMP_Selection) +{ + uint32_t compout = 0x0; + + /* Check the parameters */ + assert_param(IS_COMP_ALL_PERIPH(COMP_Selection)); + + /* Check if selected comparator output is high */ + if ((COMP->CSR & (COMP_CSR_COMP1OUT<CSR |= (uint32_t) COMP_CSR_WNDWEN; + } + else + { + /* Disable the window mode */ + COMP->CSR &= (uint32_t)(~COMP_CSR_WNDWEN); + } +} + +/** + * @} + */ + +/** @defgroup COMP_Group3 COMP configuration locking function + * @brief COMP1 and COMP2 configuration locking function + * COMP1 and COMP2 configuration can be locked each separately. + * Unlocking is performed by system reset. + * +@verbatim + =============================================================================== + ##### Configuration Lock function ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Lock the selected comparator (COMP1/COMP2) configuration. + * @note Locking the configuration means that all control bits are read-only. + * To unlock the comparator configuration, perform a system reset. + * @param COMP_Selection: selects the comparator to be locked + * This parameter can be a value of the following values: + * @arg COMP_Selection_COMP1: COMP1 configuration is locked. + * @arg COMP_Selection_COMP2: COMP2 configuration is locked. + * @retval None + */ +void COMP_LockConfig(uint32_t COMP_Selection) +{ + /* Check the parameter */ + assert_param(IS_COMP_ALL_PERIPH(COMP_Selection)); + + /* Set the lock bit corresponding to selected comparator */ + COMP->CSR |= (uint32_t) (COMP_CSR_COMP1LOCK<
    © COPYRIGHT 2014 STMicroelectronics
    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_crc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup CRC + * @brief CRC driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup CRC_Private_Functions + * @{ + */ + +/** @defgroup CRC_Group1 Configuration of the CRC computation unit functions + * @brief Configuration of the CRC computation unit functions + * +@verbatim + =============================================================================== + ##### CRC configuration functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes CRC peripheral registers to their default reset values. + * @param None + * @retval None + */ +void CRC_DeInit(void) +{ + /* Set DR register to reset value */ + CRC->DR = 0xFFFFFFFF; + + /* Set the POL register to the reset value: 0x04C11DB7 */ + CRC->POL = 0x04C11DB7; + + /* Reset IDR register */ + CRC->IDR = 0x00; + + /* Set INIT register to reset value */ + CRC->INIT = 0xFFFFFFFF; + + /* Reset the CRC calculation unit */ + CRC->CR = CRC_CR_RESET; +} + +/** + * @brief Resets the CRC calculation unit and sets INIT register content in DR register. + * @param None + * @retval None + */ +void CRC_ResetDR(void) +{ + /* Reset CRC generator */ + CRC->CR |= CRC_CR_RESET; +} + +/** + * @brief Selects the polynomial size. This function is only applicable for + * STM32F072 devices. + * @param CRC_PolSize: Specifies the polynomial size. + * This parameter can be: + * @arg CRC_PolSize_7: 7-bit polynomial for CRC calculation + * @arg CRC_PolSize_8: 8-bit polynomial for CRC calculation + * @arg CRC_PolSize_16: 16-bit polynomial for CRC calculation + * @arg CRC_PolSize_32: 32-bit polynomial for CRC calculation + * @retval None + */ +void CRC_PolynomialSizeSelect(uint32_t CRC_PolSize) +{ + uint32_t tmpcr = 0; + + /* Check the parameter */ + assert_param(IS_CRC_POL_SIZE(CRC_PolSize)); + + /* Get CR register value */ + tmpcr = CRC->CR; + + /* Reset POL_SIZE bits */ + tmpcr &= (uint32_t)~((uint32_t)CRC_CR_POLSIZE); + /* Set the polynomial size */ + tmpcr |= (uint32_t)CRC_PolSize; + + /* Write to CR register */ + CRC->CR = (uint32_t)tmpcr; +} + +/** + * @brief Selects the reverse operation to be performed on input data. + * @param CRC_ReverseInputData: Specifies the reverse operation on input data. + * This parameter can be: + * @arg CRC_ReverseInputData_No: No reverse operation is performed + * @arg CRC_ReverseInputData_8bits: reverse operation performed on 8 bits + * @arg CRC_ReverseInputData_16bits: reverse operation performed on 16 bits + * @arg CRC_ReverseInputData_32bits: reverse operation performed on 32 bits + * @retval None + */ +void CRC_ReverseInputDataSelect(uint32_t CRC_ReverseInputData) +{ + uint32_t tmpcr = 0; + + /* Check the parameter */ + assert_param(IS_CRC_REVERSE_INPUT_DATA(CRC_ReverseInputData)); + + /* Get CR register value */ + tmpcr = CRC->CR; + + /* Reset REV_IN bits */ + tmpcr &= (uint32_t)~((uint32_t)CRC_CR_REV_IN); + /* Set the reverse operation */ + tmpcr |= (uint32_t)CRC_ReverseInputData; + + /* Write to CR register */ + CRC->CR = (uint32_t)tmpcr; +} + +/** + * @brief Enables or disable the reverse operation on output data. + * The reverse operation on output data is performed on 32-bit. + * @param NewState: new state of the reverse operation on output data. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void CRC_ReverseOutputDataCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable reverse operation on output data */ + CRC->CR |= CRC_CR_REV_OUT; + } + else + { + /* Disable reverse operation on output data */ + CRC->CR &= (uint32_t)~((uint32_t)CRC_CR_REV_OUT); + } +} + +/** + * @brief Initializes the INIT register. + * @note After resetting CRC calculation unit, CRC_InitValue is stored in DR register + * @param CRC_InitValue: Programmable initial CRC value + * @retval None + */ +void CRC_SetInitRegister(uint32_t CRC_InitValue) +{ + CRC->INIT = CRC_InitValue; +} + +/** + * @brief Initializes the polynomail coefficients. This function is only + * applicable for STM32F072 devices. + * @param CRC_Pol: Polynomial to be used for CRC calculation. + * @retval None + */ +void CRC_SetPolynomial(uint32_t CRC_Pol) +{ + CRC->POL = CRC_Pol; +} + +/** + * @} + */ + +/** @defgroup CRC_Group2 CRC computation of one/many 32-bit data functions + * @brief CRC computation of one/many 32-bit data functions + * +@verbatim + =============================================================================== + ##### CRC computation functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Computes the 32-bit CRC of a given data word(32-bit). + * @param CRC_Data: data word(32-bit) to compute its CRC + * @retval 32-bit CRC + */ +uint32_t CRC_CalcCRC(uint32_t CRC_Data) +{ + CRC->DR = CRC_Data; + + return (CRC->DR); +} + +/** + * @brief Computes the 16-bit CRC of a given 16-bit data. This function is only + * applicable for STM32F072 devices. + * @param CRC_Data: data half-word(16-bit) to compute its CRC + * @retval 16-bit CRC + */ +uint32_t CRC_CalcCRC16bits(uint16_t CRC_Data) +{ + *(uint16_t*)(CRC_BASE) = (uint16_t) CRC_Data; + + return (CRC->DR); +} + +/** + * @brief Computes the 8-bit CRC of a given 8-bit data. This function is only + * applicable for STM32F072 devices. + * @param CRC_Data: 8-bit data to compute its CRC + * @retval 8-bit CRC + */ +uint32_t CRC_CalcCRC8bits(uint8_t CRC_Data) +{ + *(uint8_t*)(CRC_BASE) = (uint8_t) CRC_Data; + + return (CRC->DR); +} + +/** + * @brief Computes the 32-bit CRC of a given buffer of data word(32-bit). + * @param pBuffer: pointer to the buffer containing the data to be computed + * @param BufferLength: length of the buffer to be computed + * @retval 32-bit CRC + */ +uint32_t CRC_CalcBlockCRC(uint32_t pBuffer[], uint32_t BufferLength) +{ + uint32_t index = 0; + + for(index = 0; index < BufferLength; index++) + { + CRC->DR = pBuffer[index]; + } + return (CRC->DR); +} + +/** + * @brief Returns the current CRC value. + * @param None + * @retval 32-bit CRC + */ +uint32_t CRC_GetCRC(void) +{ + return (CRC->DR); +} + +/** + * @} + */ + +/** @defgroup CRC_Group3 CRC Independent Register (IDR) access functions + * @brief CRC Independent Register (IDR) access (write/read) functions + * +@verbatim + =============================================================================== + ##### CRC Independent Register (IDR) access functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Stores an 8-bit data in the Independent Data(ID) register. + * @param CRC_IDValue: 8-bit value to be stored in the ID register + * @retval None + */ +void CRC_SetIDRegister(uint8_t CRC_IDValue) +{ + CRC->IDR = CRC_IDValue; +} + +/** + * @brief Returns the 8-bit data stored in the Independent Data(ID) register + * @param None + * @retval 8-bit value of the ID register + */ +uint8_t CRC_GetIDRegister(void) +{ + return (CRC->IDR); +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_crs.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_crs.c new file mode 100644 index 00000000..3bc10903 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_crs.c @@ -0,0 +1,466 @@ +/** + ****************************************************************************** + * @file stm32f0xx_crs.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of CRS peripheral applicable only on STM32F042 and + * STM32F072 devices: + * + Configuration of the CRS peripheral + * + Interrupts and flags management + * + * + * @verbatim + =============================================================================== + ##### How to use this driver ##### + =============================================================================== + [..] + + (+) Enable CRS AHB clock using RCC_APB1eriphClockCmd(RCC_APB1Periph_CRS, ENABLE) + function + + + @endverbatim + * + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_crs.h" +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup CRS + * @brief CRS driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* CRS Flag Mask */ +#define FLAG_MASK ((uint32_t)0x700) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup CRS_Private_Functions + * @{ + */ + +/** @defgroup CRS_Group1 Configuration of the CRS functions + * @brief Configuration of the CRS functions + * +@verbatim + =============================================================================== + ##### CRS configuration functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes CRS peripheral registers to their default reset values. + * @param None + * @retval None + */ +void CRS_DeInit(void) +{ + RCC_APB1PeriphResetCmd(RCC_APB1Periph_CRS, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_CRS, DISABLE); +} + +/** + * @brief Adjusts the Internal High Speed 48 oscillator (HSI 48) calibration value. + * @note The calibration is used to compensate for the variations in voltage + * and temperature that influence the frequency of the internal HSI48 RC. + * @note This function can be called only when the AUTOTRIMEN bit is reset. + * @param CRS_HSI48CalibrationValue: + * @retval None + */ +void CRS_AdjustHSI48CalibrationValue(uint8_t CRS_HSI48CalibrationValue) +{ + /* Clear TRIM[5:0] bits */ + CRS->CR &= ~CRS_CR_TRIM; + + /* Set the TRIM[5:0] bits according to CRS_HSI48CalibrationValue value */ + CRS->CR |= (uint32_t)((uint32_t)CRS_HSI48CalibrationValue << 8); + +} + +/** + * @brief Enables or disables the oscillator clock for frequency error counter. + * @note when the CEN bit is set the CRS_CFGR register becomes write-protected. + * @param NewState: new state of the frequency error counter. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void CRS_FrequencyErrorCounterCmd(FunctionalState NewState) +{ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + CRS->CR |= CRS_CR_CEN; + } + else + { + CRS->CR &= ~CRS_CR_CEN; + } +} + +/** + * @brief Enables or disables the automatic hardware adjustement of TRIM bits. + * @note When the AUTOTRIMEN bit is set the CRS_CFGR register becomes write-protected. + * @param NewState: new state of the automatic trimming. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void CRS_AutomaticCalibrationCmd(FunctionalState NewState) +{ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + CRS->CR |= CRS_CR_AUTOTRIMEN; + } +else + { + CRS->CR &= ~CRS_CR_AUTOTRIMEN; + } +} + +/** + * @brief Generate the software synchronization event + * @param None + * @retval None + */ +void CRS_SoftwareSynchronizationGenerate(void) +{ + CRS->CR |= CRS_CR_SWSYNC; +} + +/** + * @brief Adjusts the Internal High Speed 48 oscillator (HSI 48) calibration value. + * @note The calibration is used to compensate for the variations in voltage + * and temperature that influence the frequency of the internal HSI48 RC. + * @note This function can be called only when the CEN bit is reset. + * @param CRS_ReloadValue: specifies the HSI calibration trimming value. + * This parameter must be a number between 0 and . + * @retval None + */ +void CRS_FrequencyErrorCounterReload(uint32_t CRS_ReloadValue) +{ + + /* Clear RELOAD[15:0] bits */ + CRS->CFGR &= ~CRS_CFGR_RELOAD; + + /* Set the RELOAD[15:0] bits according to CRS_ReloadValue value */ + CRS->CFGR |= (uint32_t)CRS_ReloadValue; + +} + +/** + * @brief + * @note This function can be called only when the CEN bit is reset. + * @param CRS_ErrorLimitValue: specifies the HSI calibration trimming value. + * This parameter must be a number between 0 and . + * @retval None + */ +void CRS_FrequencyErrorLimitConfig(uint8_t CRS_ErrorLimitValue) +{ + /* Clear FELIM[7:0] bits */ + CRS->CFGR &= ~CRS_CFGR_FELIM; + + /* Set the FELIM[7:0] bits according to CRS_ErrorLimitValue value */ + CRS->CFGR |= (uint32_t)CRS_ErrorLimitValue; +} + +/** + * @brief + * @note This function can be called only when the CEN bit is reset. + * @param CRS_Prescaler: specifies the HSI calibration trimming value. + * This parameter can be one of the following values: + * @arg CRS_SYNC_Div1: + * @arg CRS_SYNC_Div2: + * @arg CRS_SYNC_Div4: + * @arg CRS_SYNC_Div8: + * @arg CRS_SYNC_Div16: + * @arg CRS_SYNC_Div32: + * @arg CRS_SYNC_Div64: + * @arg CRS_SYNC_Div128: + * @retval None + */ +void CRS_SynchronizationPrescalerConfig(uint32_t CRS_Prescaler) +{ + /* Check the parameters */ + assert_param(IS_CRS_SYNC_DIV(CRS_Prescaler)); + + /* Clear SYNCDIV[2:0] bits */ + CRS->CFGR &= ~CRS_CFGR_SYNCDIV; + + /* Set the CRS_CFGR_SYNCDIV[2:0] bits according to CRS_Prescaler value */ + CRS->CFGR |= CRS_Prescaler; +} + +/** + * @brief + * @note This function can be called only when the CEN bit is reset. + * @param CRS_Source: . + * This parameter can be one of the following values: + * @arg CRS_SYNCSource_GPIO: + * @arg CRS_SYNCSource_LSE: + * @arg CRS_SYNCSource_USB: + * @retval None + */ +void CRS_SynchronizationSourceConfig(uint32_t CRS_Source) +{ + /* Check the parameters */ + assert_param(IS_CRS_SYNC_SOURCE(CRS_Source)); + + /* Clear SYNCSRC[1:0] bits */ + CRS->CFGR &= ~CRS_CFGR_SYNCSRC; + + /* Set the SYNCSRC[1:0] bits according to CRS_Source value */ + CRS->CFGR |= CRS_Source; +} + +/** + * @brief + * @note This function can be called only when the CEN bit is reset. + * @param CRS_Polarity: . + * This parameter can be one of the following values: + * @arg CRS_SYNCPolarity_Rising: + * @arg CRS_SYNCPolarity_Falling: + * @retval None + */ +void CRS_SynchronizationPolarityConfig(uint32_t CRS_Polarity) +{ + /* Check the parameters */ + assert_param(IS_CRS_SYNC_POLARITY(CRS_Polarity)); + + /* Clear SYNCSPOL bit */ + CRS->CFGR &= ~CRS_CFGR_SYNCPOL; + + /* Set the SYNCSPOL bits according to CRS_Polarity value */ + CRS->CFGR |= CRS_Polarity; +} + +/** + * @brief Returns the Relaod value. + * @param None + * @retval The reload value + */ +uint32_t CRS_GetReloadValue(void) +{ + return ((uint32_t)(CRS->CFGR & CRS_CFGR_RELOAD)); +} + +/** + * @brief Returns the HSI48 Calibration value. + * @param None + * @retval The reload value + */ +uint32_t CRS_GetHSI48CalibrationValue(void) +{ + return (((uint32_t)(CRS->CR & CRS_CR_TRIM)) >> 8); +} + +/** + * @brief Returns the frequency error capture. + * @param None + * @retval The frequency error capture value + */ +uint32_t CRS_GetFrequencyErrorValue(void) +{ + return ((uint32_t)(CRS->ISR & CRS_ISR_FECAP)); +} + +/** + * @brief Returns the frequency error direction. + * @param None + * @retval The frequency error direction. The returned value can be one + * of the following values: + * - 0x00: Up counting + * - 0x8000: Down counting + */ +uint32_t CRS_GetFrequencyErrorDirection(void) +{ + return ((uint32_t)(CRS->ISR & CRS_ISR_FEDIR)); +} + +/** @defgroup CRS_Group2 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== +@endverbatim + * @{ + */ +/** + * @brief Enables or disables the specified CRS interrupts. + * @param CRS_IT: specifies the RCC interrupt sources to be enabled or disabled. + * This parameter can be any combination of the following values: + * @arg CRS_IT_SYNCOK: + * @arg CRS_IT_SYNCWARN: + * @arg CRS_IT_ERR: + * @arg CRS_IT_ESYNC: + * @param NewState: new state of the specified CRS interrupts. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void CRS_ITConfig(uint32_t CRS_IT, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_CRS_IT(CRS_IT)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + CRS->CR |= CRS_IT; + } + else + { + CRS->CR &= ~CRS_IT; + } +} + +/** + * @brief Checks whether the specified CRS flag is set or not. + * @param CRS_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg CRS_FLAG_SYNCOK: + * @arg CRS_FLAG_SYNCWARN: + * @arg CRS_FLAG_ERR: + * @arg CRS_FLAG_ESYNC: + * @arg CRS_FLAG_TRIMOVF: + * @arg CRS_FLAG_SYNCERR: + * @arg CRS_FLAG_SYNCMISS: + * @retval The new state of CRS_FLAG (SET or RESET). + */ +FlagStatus CRS_GetFlagStatus(uint32_t CRS_FLAG) +{ + /* Check the parameters */ + assert_param(IS_CRS_FLAG(CRS_FLAG)); + + return ((FlagStatus)(CRS->ISR & CRS_FLAG)); +} + +/** + * @brief Clears the CRS specified FLAG. + * @param CRS_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg CRS_FLAG_SYNCOK: + * @arg CRS_FLAG_SYNCWARN: + * @arg CRS_FLAG_ERR: + * @arg CRS_FLAG_ESYNC: + * @arg CRS_FLAG_TRIMOVF: + * @arg CRS_FLAG_SYNCERR: + * @arg CRS_FLAG_SYNCMISS: + * @retval None + */ +void CRS_ClearFlag(uint32_t CRS_FLAG) +{ + /* Check the parameters */ + assert_param(IS_CRS_FLAG(CRS_FLAG)); + + if ((CRS_FLAG & FLAG_MASK)!= 0) + { + CRS->ICR |= CRS_ICR_ERRC; + } + else + { + CRS->ICR |= CRS_FLAG; + } +} + +/** + * @brief Checks whether the specified CRS IT pending bit is set or not. + * @param CRS_IT: specifies the IT pending bit to check. + * This parameter can be one of the following values: + * @arg CRS_IT_SYNCOK: + * @arg CRS_IT_SYNCWARN: + * @arg CRS_IT_ERR: + * @arg CRS_IT_ESYNC: + * @arg CRS_IT_TRIMOVF: + * @arg CRS_IT_SYNCERR: + * @arg CRS_IT_SYNCMISS: + * @retval The new state of CRS_IT (SET or RESET). + */ +ITStatus CRS_GetITStatus(uint32_t CRS_IT) +{ + /* Check the parameters */ + assert_param(IS_CRS_GET_IT(CRS_IT)); + + return ((ITStatus)(CRS->ISR & CRS_IT)); +} + +/** + * @brief Clears the CRS specified IT pending bi. + * @param CRS_FLAG: specifies the IT pending bi to clear. + * This parameter can be one of the following values: + * @arg CRS_IT_SYNCOK: + * @arg CRS_IT_SYNCWARN: + * @arg CRS_IT_ERR: + * @arg CRS_IT_ESYNC: + * @arg CRS_IT_TRIMOVF: + * @arg CRS_IT_SYNCERR: + * @arg CRS_IT_SYNCMISS: + * @retval None + */ +void CRS_ClearITPendingBit(uint32_t CRS_IT) +{ + /* Check the parameters */ + assert_param(IS_CRS_CLEAR_IT(CRS_IT)); + + if ((CRS_IT & FLAG_MASK)!= 0) + { + CRS->ICR |= CRS_ICR_ERRC; + } + else + { + CRS->ICR |= CRS_IT; + } +} +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_dac.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_dac.c new file mode 100644 index 00000000..00527e65 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_dac.c @@ -0,0 +1,692 @@ +/** + ****************************************************************************** + * @file stm32f0xx_dac.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Digital-to-Analog Converter (DAC) peripheral + * applicable only on STM32F051 and STM32F072 devices: + * + DAC channel configuration: trigger, output buffer, data format + * + DMA management + * + Interrupts and flags management + * + * @verbatim + * + =============================================================================== + ##### DAC Peripheral features ##### + =============================================================================== + [..] The device integrates two 12-bit Digital Analog Converters refered as + DAC channel1 with DAC_OUT1 (PA4) and DAC_OUT2 (PA5) as outputs. + + [..] Digital to Analog conversion can be non-triggered using DAC_Trigger_None + and DAC_OUTx is available once writing to DHRx register using + DAC_SetChannel1Data() or DAC_SetChannel2Data() + + [..] Digital to Analog conversion can be triggered by: + (#) External event: EXTI Line 9 (any GPIOx_Pin9) using DAC_Trigger_Ext_IT9. + The used pin (GPIOx_Pin9) must be configured in input mode. + + (#) Timers TRGO: TIM2, TIM3,TIM7, TIM6 and TIM15 + (DAC_Trigger_T2_TRGO, DAC_Trigger_T3_TRGO...) + The timer TRGO event should be selected using TIM_SelectOutputTrigger() + + (#) Software using DAC_Trigger_Software + + [..] Each DAC integrates an output buffer that can be used to + reduce the output impedance, and to drive external loads directly + without having to add an external operational amplifier. + To enable the output buffer use + DAC_InitStructure.DAC_OutputBuffer = DAC_OutputBuffer_Enable; + + [..] Refer to the device datasheet for more details about output impedance + value with and without output buffer. + + [..] DAC wave generation feature + Both DAC channels can be used to generate + 1- Noise wave using DAC_WaveGeneration_Noise + 2- Triangle wave using DAC_WaveGeneration_Triangle + + [..] The DAC data format can be: + (#) 8-bit right alignment using DAC_Align_8b_R + (#) 12-bit left alignment using DAC_Align_12b_L + (#) 12-bit right alignment using DAC_Align_12b_R + + [..] The analog output voltage on each DAC channel pin is determined + by the following equation: DAC_OUTx = VREF+ * DOR / 4095 + with DOR is the Data Output Register + VEF+ is the input voltage reference (refer to the device datasheet) + e.g. To set DAC_OUT1 to 0.7V, use + DAC_SetChannel1Data(DAC_Align_12b_R, 868); + Assuming that VREF+ = 3.3, DAC_OUT1 = (3.3 * 868) / 4095 = 0.7V + + [..] A DMA1 request can be generated when an external trigger (but not + a software trigger) occurs if DMA1 requests are enabled using + DAC_DMACmd() + DMA1 requests are mapped as following: + (+) DAC channel1 is mapped on DMA1 channel3 which must be already + configured + (+) DAC channel2 is mapped on DMA1 channel4 which must be already + configured + + ##### How to use this driver ##### + =============================================================================== + [..] + (+) Enable DAC APB1 clock to get write access to DAC registers + using RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC, ENABLE) + + (+) Configure DAC_OUTx (DAC_OUT1: PA4, DAC_OUT2: PA5) in analog mode + using GPIO_Init() function + + (+) Configure the DAC channel using DAC_Init() + + (+) Enable the DAC channel using DAC_Cmd() + + @endverbatim + * + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_dac.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup DAC + * @brief DAC driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* CR register Mask */ +#define CR_CLEAR_MASK ((uint32_t)0x00000FFE) /* check the value of the mask */ + +/* DAC Dual Channels SWTRIG masks */ +#define DUAL_SWTRIG_SET ((uint32_t)0x00000003) /*!< Only applicable for STM32F072 devices */ +#define DUAL_SWTRIG_RESET ((uint32_t)0xFFFFFFFC) /*!< Only applicable for STM32F072 devices */ + +/* DHR registers offsets */ +#define DHR12R1_OFFSET ((uint32_t)0x00000008) +#define DHR12R2_OFFSET ((uint32_t)0x00000014) /*!< Only applicable for STM32F072 devices */ +#define DHR12RD_OFFSET ((uint32_t)0x00000020) /*!< Only applicable for STM32F072 devices */ + +/* DOR register offset */ +#define DOR_OFFSET ((uint32_t)0x0000002C) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup DAC_Private_Functions + * @{ + */ + +/** @defgroup DAC_Group1 DAC channels configuration + * @brief DAC channels configuration: trigger, output buffer, data format + * +@verbatim + =============================================================================== + ##### DAC channels configuration: trigger, output buffer, data format ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the DAC peripheral registers to their default reset values. + * @param None + * @retval None + */ +void DAC_DeInit(void) +{ + /* Enable DAC reset state */ + RCC_APB1PeriphResetCmd(RCC_APB1Periph_DAC, ENABLE); + /* Release DAC from reset state */ + RCC_APB1PeriphResetCmd(RCC_APB1Periph_DAC, DISABLE); +} + +/** + * @brief Initializes the DAC peripheral according to the specified parameters + * in the DAC_InitStruct. + * @param DAC_Channel: the selected DAC channel. + * This parameter can be: + * @arg DAC_Channel_1: DAC Channel1 selected + * @arg DAC_Channel_2: DAC Channel2 selected, applicable only for STM32F072 devices + * @param DAC_InitStruct: pointer to a DAC_InitTypeDef structure that contains + * the configuration information for the specified DAC channel. + * @retval None + */ +void DAC_Init(uint32_t DAC_Channel, DAC_InitTypeDef* DAC_InitStruct) +{ + uint32_t tmpreg1 = 0, tmpreg2 = 0; + + /* Check the DAC parameters */ + assert_param(IS_DAC_TRIGGER(DAC_InitStruct->DAC_Trigger)); + assert_param(IS_DAC_GENERATE_WAVE(DAC_InitStruct->DAC_WaveGeneration)); + assert_param(IS_DAC_LFSR_UNMASK_TRIANGLE_AMPLITUDE(DAC_InitStruct->DAC_LFSRUnmask_TriangleAmplitude)); + assert_param(IS_DAC_OUTPUT_BUFFER_STATE(DAC_InitStruct->DAC_OutputBuffer)); + +/*---------------------------- DAC CR Configuration --------------------------*/ + /* Get the DAC CR value */ + tmpreg1 = DAC->CR; + /* Clear BOFFx, TENx, TSELx, WAVEx and MAMPx bits */ + tmpreg1 &= ~(CR_CLEAR_MASK << DAC_Channel); + /* Configure for the selected DAC channel: buffer output, trigger, + wave generation, mask/amplitude for wave generation */ + /* Set TSELx and TENx bits according to DAC_Trigger value */ + /* Set WAVEx bits according to DAC_WaveGeneration value */ + /* Set MAMPx bits according to DAC_LFSRUnmask_TriangleAmplitude value */ + /* Set BOFFx bit according to DAC_OutputBuffer value */ + tmpreg2 = (DAC_InitStruct->DAC_Trigger | DAC_InitStruct->DAC_WaveGeneration | + DAC_InitStruct->DAC_LFSRUnmask_TriangleAmplitude | \ + DAC_InitStruct->DAC_OutputBuffer); + /* Calculate CR register value depending on DAC_Channel */ + tmpreg1 |= tmpreg2 << DAC_Channel; + /* Write to DAC CR */ + DAC->CR = tmpreg1; +} + +/** + * @brief Fills each DAC_InitStruct member with its default value. + * @param DAC_InitStruct: pointer to a DAC_InitTypeDef structure which will + * be initialized. + * @retval None + */ +void DAC_StructInit(DAC_InitTypeDef* DAC_InitStruct) +{ +/*--------------- Reset DAC init structure parameters values -----------------*/ + /* Initialize the DAC_Trigger member */ + DAC_InitStruct->DAC_Trigger = DAC_Trigger_None; + + /* Initialize the DAC_WaveGeneration member */ + DAC_InitStruct->DAC_WaveGeneration = DAC_WaveGeneration_None; + + /* Initialize the DAC_LFSRUnmask_TriangleAmplitude member */ + DAC_InitStruct->DAC_LFSRUnmask_TriangleAmplitude = DAC_LFSRUnmask_Bit0; + + /* Initialize the DAC_OutputBuffer member */ + DAC_InitStruct->DAC_OutputBuffer = DAC_OutputBuffer_Enable; +} + +/** + * @brief Enables or disables the specified DAC channel. + * @param DAC_Channel: The selected DAC channel. + * This parameter can be one of the following values: + * @arg DAC_Channel_1: DAC Channel1 selected + * @arg DAC_Channel_2: DAC Channel2 selected, applicable only for STM32F072 devices + * @param NewState: new state of the DAC channel. + * This parameter can be: ENABLE or DISABLE. + * @note When the DAC channel is enabled the trigger source can no more be modified. + * @retval None + */ +void DAC_Cmd(uint32_t DAC_Channel, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_DAC_CHANNEL(DAC_Channel)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected DAC channel */ + DAC->CR |= (DAC_CR_EN1 << DAC_Channel); + } + else + { + /* Disable the selected DAC channel */ + DAC->CR &= (~(DAC_CR_EN1 << DAC_Channel)); + } +} + +/** + * @brief Enables or disables the selected DAC channel software trigger. + * @param DAC_Channel: The selected DAC channel. + * This parameter can be one of the following values: + * @arg DAC_Channel_1: DAC Channel1 selected + * @arg DAC_Channel_2: DAC Channel2 selected, applicable only for STM32F072 devices + * @param NewState: new state of the selected DAC channel software trigger. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void DAC_SoftwareTriggerCmd(uint32_t DAC_Channel, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_DAC_CHANNEL(DAC_Channel)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable software trigger for the selected DAC channel */ + DAC->SWTRIGR |= (uint32_t)DAC_SWTRIGR_SWTRIG1 << (DAC_Channel >> 4); + } + else + { + /* Disable software trigger for the selected DAC channel */ + DAC->SWTRIGR &= ~((uint32_t)DAC_SWTRIGR_SWTRIG1 << (DAC_Channel >> 4)); + } +} + +/** + * @brief Enables or disables simultaneously the two DAC channels software triggers. + * This function is applicable only for STM32F072 devices. + * @param NewState: new state of the DAC channels software triggers. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void DAC_DualSoftwareTriggerCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable software trigger for both DAC channels */ + DAC->SWTRIGR |= DUAL_SWTRIG_SET; + } + else + { + /* Disable software trigger for both DAC channels */ + DAC->SWTRIGR &= DUAL_SWTRIG_RESET; + } +} + +/** + * @brief Enables or disables the selected DAC channel wave generation. + * This function is applicable only for STM32F072 devices. + * @param DAC_Channel: The selected DAC channel. + * This parameter can be: + * @arg DAC_Channel_1: DAC Channel1 selected + * @arg DAC_Channel_2: DAC Channel2 selected + * @param DAC_Wave: specifies the wave type to enable or disable. + * This parameter can be: + * @arg DAC_Wave_Noise: noise wave generation + * @arg DAC_Wave_Triangle: triangle wave generation + * @param NewState: new state of the selected DAC channel wave generation. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void DAC_WaveGenerationCmd(uint32_t DAC_Channel, uint32_t DAC_Wave, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_DAC_CHANNEL(DAC_Channel)); + assert_param(IS_DAC_WAVE(DAC_Wave)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected wave generation for the selected DAC channel */ + DAC->CR |= DAC_Wave << DAC_Channel; + } + else + { + /* Disable the selected wave generation for the selected DAC channel */ + DAC->CR &= ~(DAC_Wave << DAC_Channel); + } +} + +/** + * @brief Set the specified data holding register value for DAC channel1. + * @param DAC_Align: Specifies the data alignment for DAC channel1. + * This parameter can be one of the following values: + * @arg DAC_Align_8b_R: 8bit right data alignment selected + * @arg DAC_Align_12b_L: 12bit left data alignment selected + * @arg DAC_Align_12b_R: 12bit right data alignment selected + * @param Data: Data to be loaded in the selected data holding register. + * @retval None + */ +void DAC_SetChannel1Data(uint32_t DAC_Align, uint16_t Data) +{ + __IO uint32_t tmp = 0; + + /* Check the parameters */ + assert_param(IS_DAC_ALIGN(DAC_Align)); + assert_param(IS_DAC_DATA(Data)); + + tmp = (uint32_t)DAC_BASE; + tmp += DHR12R1_OFFSET + DAC_Align; + + /* Set the DAC channel1 selected data holding register */ + *(__IO uint32_t *) tmp = Data; +} + +/** + * @brief Sets the specified data holding register value for DAC channel2. + * This function is applicable only for STM32F072 devices. + * @param DAC_Align: Specifies the data alignment for DAC channel2. + * This parameter can be: + * @arg DAC_Align_8b_R: 8bit right data alignment selected + * @arg DAC_Align_12b_L: 12bit left data alignment selected + * @arg DAC_Align_12b_R: 12bit right data alignment selected + * @param Data: Data to be loaded in the selected data holding register. + * @retval None + */ +void DAC_SetChannel2Data(uint32_t DAC_Align, uint16_t Data) +{ + __IO uint32_t tmp = 0; + + /* Check the parameters */ + assert_param(IS_DAC_ALIGN(DAC_Align)); + assert_param(IS_DAC_DATA(Data)); + + tmp = (uint32_t)DAC_BASE; + tmp += DHR12R2_OFFSET + DAC_Align; + + /* Set the DAC channel2 selected data holding register */ + *(__IO uint32_t *)tmp = Data; +} + +/** + * @brief Sets the specified data holding register value for dual channel DAC. + * This function is applicable only for STM32F072 devices. + * @param DAC_Align: Specifies the data alignment for dual channel DAC. + * This parameter can be: + * @arg DAC_Align_8b_R: 8bit right data alignment selected + * @arg DAC_Align_12b_L: 12bit left data alignment selected + * @arg DAC_Align_12b_R: 12bit right data alignment selected + * @param Data2: Data for DAC Channel2 to be loaded in the selected data holding register. + * @param Data1: Data for DAC Channel1 to be loaded in the selected data holding register. + * @note In dual mode, a unique register access is required to write in both + * DAC channels at the same time. + * @retval None + */ +void DAC_SetDualChannelData(uint32_t DAC_Align, uint16_t Data2, uint16_t Data1) +{ + uint32_t data = 0, tmp = 0; + + /* Check the parameters */ + assert_param(IS_DAC_ALIGN(DAC_Align)); + assert_param(IS_DAC_DATA(Data1)); + assert_param(IS_DAC_DATA(Data2)); + + /* Calculate and set dual DAC data holding register value */ + if (DAC_Align == DAC_Align_8b_R) + { + data = ((uint32_t)Data2 << 8) | Data1; + } + else + { + data = ((uint32_t)Data2 << 16) | Data1; + } + + tmp = (uint32_t)DAC_BASE; + tmp += DHR12RD_OFFSET + DAC_Align; + + /* Set the dual DAC selected data holding register */ + *(__IO uint32_t *)tmp = data; +} + +/** + * @brief Returns the last data output value of the selected DAC channel. + * @param DAC_Channel: The selected DAC channel. + * This parameter can be one of the following values: + * @arg DAC_Channel_1: DAC Channel1 selected + * @arg DAC_Channel_2: DAC Channel2 selected, applicable only for STM32F072 devices + * @retval The selected DAC channel data output value. + */ +uint16_t DAC_GetDataOutputValue(uint32_t DAC_Channel) +{ + __IO uint32_t tmp = 0; + + /* Check the parameters */ + assert_param(IS_DAC_CHANNEL(DAC_Channel)); + + tmp = (uint32_t) DAC_BASE ; + tmp += DOR_OFFSET + ((uint32_t)DAC_Channel >> 2); + + /* Returns the DAC channel data output register value */ + return (uint16_t) (*(__IO uint32_t*) tmp); +} + +/** + * @} + */ + +/** @defgroup DAC_Group2 DMA management functions + * @brief DMA management functions + * +@verbatim + =============================================================================== + ##### DMA management functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified DAC channel DMA request. + * When enabled DMA1 is generated when an external trigger (EXTI Line9, + * TIM2, TIM3, TIM6 or TIM15 but not a software trigger) occurs + * @param DAC_Channel: the selected DAC channel. + * This parameter can be one of the following values: + * @arg DAC_Channel_1: DAC Channel1 selected + * @arg DAC_Channel_2: DAC Channel2 selected, applicable only for STM32F072 devices + * @param NewState: new state of the selected DAC channel DMA request. + * This parameter can be: ENABLE or DISABLE. + * @note The DAC channel1 is mapped on DMA1 channel3 which must be already configured. + * @note The DAC channel2 is mapped on DMA1 channel4 which must be already configured. + * @retval None + */ +void DAC_DMACmd(uint32_t DAC_Channel, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_DAC_CHANNEL(DAC_Channel)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected DAC channel DMA request */ + DAC->CR |= (DAC_CR_DMAEN1 << DAC_Channel); + } + else + { + /* Disable the selected DAC channel DMA request */ + DAC->CR &= (~(DAC_CR_DMAEN1 << DAC_Channel)); + } +} + +/** + * @} + */ + +/** @defgroup DAC_Group3 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified DAC interrupts. + * @param DAC_Channel: The selected DAC channel. + * This parameter can be: + * @arg DAC_Channel_1: DAC Channel1 selected + * @arg DAC_Channel_2: DAC Channel2 selected, applicable only for STM32F072 devices + * @param DAC_IT: specifies the DAC interrupt sources to be enabled or disabled. + * This parameter can be the following values: + * @arg DAC_IT_DMAUDR: DMA underrun interrupt mask + * @note The DMA underrun occurs when a second external trigger arrives before the + * acknowledgement for the first external trigger is received (first request). + * @param NewState: new state of the specified DAC interrupts. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void DAC_ITConfig(uint32_t DAC_Channel, uint32_t DAC_IT, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_DAC_CHANNEL(DAC_Channel)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + assert_param(IS_DAC_IT(DAC_IT)); + + if (NewState != DISABLE) + { + /* Enable the selected DAC interrupts */ + DAC->CR |= (DAC_IT << DAC_Channel); + } + else + { + /* Disable the selected DAC interrupts */ + DAC->CR &= (~(uint32_t)(DAC_IT << DAC_Channel)); + } +} + +/** + * @brief Checks whether the specified DAC flag is set or not. + * @param DAC_Channel: The selected DAC channel. + * This parameter can be one of the following values: + * @arg DAC_Channel_1: DAC Channel1 selected + * @arg DAC_Channel_2: DAC Channel2 selected, applicable only for STM32F072 devices + * @param DAC_FLAG: specifies the flag to check. + * This parameter can be only of the following value: + * @arg DAC_FLAG_DMAUDR: DMA underrun flag + * @note The DMA underrun occurs when a second external trigger arrives before the + * acknowledgement for the first external trigger is received (first request). + * @retval The new state of DAC_FLAG (SET or RESET). + */ +FlagStatus DAC_GetFlagStatus(uint32_t DAC_Channel, uint32_t DAC_FLAG) +{ + FlagStatus bitstatus = RESET; + /* Check the parameters */ + assert_param(IS_DAC_CHANNEL(DAC_Channel)); + assert_param(IS_DAC_FLAG(DAC_FLAG)); + + /* Check the status of the specified DAC flag */ + if ((DAC->SR & (DAC_FLAG << DAC_Channel)) != (uint8_t)RESET) + { + /* DAC_FLAG is set */ + bitstatus = SET; + } + else + { + /* DAC_FLAG is reset */ + bitstatus = RESET; + } + /* Return the DAC_FLAG status */ + return bitstatus; +} + +/** + * @brief Clears the DAC channel's pending flags. + * @param DAC_Channel: The selected DAC channel. + * This parameter can be one of the following values: + * @arg DAC_Channel_1: DAC Channel1 selected + * @arg DAC_Channel_2: DAC Channel2 selected, applicable only for STM32F072 devices + * @param DAC_FLAG: specifies the flag to clear. + * This parameter can be of the following value: + * @arg DAC_FLAG_DMAUDR: DMA underrun flag + * @retval None + */ +void DAC_ClearFlag(uint32_t DAC_Channel, uint32_t DAC_FLAG) +{ + /* Check the parameters */ + assert_param(IS_DAC_CHANNEL(DAC_Channel)); + assert_param(IS_DAC_FLAG(DAC_FLAG)); + + /* Clear the selected DAC flags */ + DAC->SR = (DAC_FLAG << DAC_Channel); +} + +/** + * @brief Checks whether the specified DAC interrupt has occurred or not. + * @param DAC_Channel: The selected DAC channel. + * This parameter can be one of the following values: + * @arg DAC_Channel_1: DAC Channel1 selected + * @arg DAC_Channel_2: DAC Channel2 selected, applicable only for STM32F072 devices + * @param DAC_IT: specifies the DAC interrupt source to check. + * This parameter can be the following values: + * @arg DAC_IT_DMAUDR: DMA underrun interrupt mask + * @note The DMA underrun occurs when a second external trigger arrives before the + * acknowledgement for the first external trigger is received (first request). + * @retval The new state of DAC_IT (SET or RESET). + */ +ITStatus DAC_GetITStatus(uint32_t DAC_Channel, uint32_t DAC_IT) +{ + ITStatus bitstatus = RESET; + uint32_t enablestatus = 0; + + /* Check the parameters */ + assert_param(IS_DAC_CHANNEL(DAC_Channel)); + assert_param(IS_DAC_IT(DAC_IT)); + + /* Get the DAC_IT enable bit status */ + enablestatus = (DAC->CR & (DAC_IT << DAC_Channel)) ; + + /* Check the status of the specified DAC interrupt */ + if (((DAC->SR & (DAC_IT << DAC_Channel)) != (uint32_t)RESET) && enablestatus) + { + /* DAC_IT is set */ + bitstatus = SET; + } + else + { + /* DAC_IT is reset */ + bitstatus = RESET; + } + /* Return the DAC_IT status */ + return bitstatus; +} + +/** + * @brief Clears the DAC channel's interrupt pending bits. + * @param DAC_Channel: The selected DAC channel. + * This parameter can be one of the following values: + * @arg DAC_Channel_1: DAC Channel1 selected + * @arg DAC_Channel_2: DAC Channel2 selected, applicable only for STM32F072 devices + * @param DAC_IT: specifies the DAC interrupt pending bit to clear. + * This parameter can be the following values: + * @arg DAC_IT_DMAUDR: DMA underrun interrupt mask + * @retval None + */ +void DAC_ClearITPendingBit(uint32_t DAC_Channel, uint32_t DAC_IT) +{ + /* Check the parameters */ + assert_param(IS_DAC_CHANNEL(DAC_Channel)); + assert_param(IS_DAC_IT(DAC_IT)); + + /* Clear the selected DAC interrupt pending bits */ + DAC->SR = (DAC_IT << DAC_Channel); +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_dbgmcu.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_dbgmcu.c new file mode 100644 index 00000000..bb456da5 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_dbgmcu.c @@ -0,0 +1,218 @@ +/** + ****************************************************************************** + * @file stm32f0xx_dbgmcu.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Debug MCU (DBGMCU) peripheral: + * + Device and Revision ID management + * + Peripherals Configuration + * @verbatim + * @endverbatim + * + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_dbgmcu.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup DBGMCU + * @brief DBGMCU driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +#define IDCODE_DEVID_MASK ((uint32_t)0x00000FFF) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup DBGMCU_Private_Functions + * @{ + */ + + +/** @defgroup DBGMCU_Group1 Device and Revision ID management functions + * @brief Device and Revision ID management functions + * +@verbatim + ============================================================================== + ##### Device and Revision ID management functions ##### + ============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Returns the device revision identifier. + * @param None + * @retval Device revision identifier + */ +uint32_t DBGMCU_GetREVID(void) +{ + return(DBGMCU->IDCODE >> 16); +} + +/** + * @brief Returns the device identifier. + * @param None + * @retval Device identifier + */ +uint32_t DBGMCU_GetDEVID(void) +{ + return(DBGMCU->IDCODE & IDCODE_DEVID_MASK); +} + +/** + * @} + */ + +/** @defgroup DBGMCU_Group2 Peripherals Configuration functions + * @brief Peripherals Configuration + * +@verbatim + ============================================================================== + ##### Peripherals Configuration functions ##### + ============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Configures low power mode behavior when the MCU is in Debug mode. + * @param DBGMCU_Periph: specifies the low power mode. + * This parameter can be any combination of the following values: + * @arg DBGMCU_STOP: Keep debugger connection during STOP mode + * @arg DBGMCU_STANDBY: Keep debugger connection during STANDBY mode + * @param NewState: new state of the specified low power mode in Debug mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void DBGMCU_Config(uint32_t DBGMCU_Periph, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_DBGMCU_PERIPH(DBGMCU_Periph)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + DBGMCU->CR |= DBGMCU_Periph; + } + else + { + DBGMCU->CR &= ~DBGMCU_Periph; + } +} + + +/** + * @brief Configures APB1 peripheral behavior when the MCU is in Debug mode. + * @param DBGMCU_Periph: specifies the APB1 peripheral. + * This parameter can be any combination of the following values: + * @arg DBGMCU_TIM2_STOP: TIM2 counter stopped when Core is halted, + * not applicable for STM32F030 devices + * @arg DBGMCU_TIM3_STOP: TIM3 counter stopped when Core is halted + * @arg DBGMCU_TIM6_STOP: TIM6 counter stopped when Core is halted + * @arg DBGMCU_TIM7_STOP: TIM7 counter stopped when Core is halted, + * applicable only for STM32F072 devices + * @arg DBGMCU_TIM14_STOP: TIM14 counter stopped when Core is halted + * @arg DBGMCU_RTC_STOP: RTC Calendar and Wakeup counter stopped + * when Core is halted. + * @arg DBGMCU_WWDG_STOP: Debug WWDG stopped when Core is halted + * @arg DBGMCU_IWDG_STOP: Debug IWDG stopped when Core is halted + * @arg DBGMCU_I2C1_SMBUS_TIMEOUT: I2C1 SMBUS timeout mode stopped + * when Core is halted + * @arg DBGMCU_CAN1_STOP: Debug CAN1 stopped when Core is halted, + * applicable only for STM32F042 and STM32F072 devices + * @param NewState: new state of the specified APB1 peripheral in Debug mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void DBGMCU_APB1PeriphConfig(uint32_t DBGMCU_Periph, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_DBGMCU_APB1PERIPH(DBGMCU_Periph)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + DBGMCU->APB1FZ |= DBGMCU_Periph; + } + else + { + DBGMCU->APB1FZ &= ~DBGMCU_Periph; + } +} + +/** + * @brief Configures APB2 peripheral behavior when the MCU is in Debug mode. + * @param DBGMCU_Periph: specifies the APB2 peripheral. + * This parameter can be any combination of the following values: + * @arg DBGMCU_TIM1_STOP: TIM1 counter stopped when Core is halted + * @arg DBGMCU_TIM15_STOP: TIM15 counter stopped when Core is halted + * @arg DBGMCU_TIM16_STOP: TIM16 counter stopped when Core is halted + * @arg DBGMCU_TIM17_STOP: TIM17 counter stopped when Core is halted + * @param NewState: new state of the specified APB2 peripheral in Debug mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void DBGMCU_APB2PeriphConfig(uint32_t DBGMCU_Periph, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_DBGMCU_APB2PERIPH(DBGMCU_Periph)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + DBGMCU->APB2FZ |= DBGMCU_Periph; + } + else + { + DBGMCU->APB2FZ &= ~DBGMCU_Periph; + } +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_dma.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_dma.c new file mode 100644 index 00000000..a6696f2c --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_dma.c @@ -0,0 +1,891 @@ +/** + ****************************************************************************** + * @file stm32f0xx_dma.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Direct Memory Access controller (DMA): + * + Initialization and Configuration + * + Data Counter + * + Interrupts and flags management + * + * @verbatim + ============================================================================== + ##### How to use this driver ##### + ============================================================================== + [..] + (#) Enable The DMA controller clock using + RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE) function for DMA1. + (#) Enable and configure the peripheral to be connected to the DMA channel + (except for internal SRAM / FLASH memories: no initialization is necessary). + (#) For a given Channel, program the Source and Destination addresses, + the transfer Direction, the Buffer Size, the Peripheral and Memory + Incrementation mode and Data Size, the Circular or Normal mode, + the channel transfer Priority and the Memory-to-Memory transfer + mode (if needed) using the DMA_Init() function. + (#) Enable the NVIC and the corresponding interrupt(s) using the function + DMA_ITConfig() if you need to use DMA interrupts. + (#) Enable the DMA channel using the DMA_Cmd() function. + (#) Activate the needed channel Request using PPP_DMACmd() function for + any PPP peripheral except internal SRAM and FLASH (ie. SPI, USART ...) + The function allowing this operation is provided in each PPP peripheral + driver (ie. SPI_DMACmd for SPI peripheral). + (#) Optionally, you can configure the number of data to be transferred + when the channel is disabled (ie. after each Transfer Complete event + or when a Transfer Error occurs) using the function DMA_SetCurrDataCounter(). + And you can get the number of remaining data to be transferred using + the function DMA_GetCurrDataCounter() at run time (when the DMA channel is + enabled and running). + (#) To control DMA events you can use one of the following two methods: + (##) Check on DMA channel flags using the function DMA_GetFlagStatus(). + (##) Use DMA interrupts through the function DMA_ITConfig() at initialization + phase and DMA_GetITStatus() function into interrupt routines in + communication phase. + After checking on a flag you should clear it using DMA_ClearFlag() + function. And after checking on an interrupt event you should + clear it using DMA_ClearITPendingBit() function. + @endverbatim + * + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_dma.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup DMA + * @brief DMA driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +#define CCR_CLEAR_MASK ((uint32_t)0xFFFF800F) /* DMA Channel config registers Masks */ +#define FLAG_Mask ((uint32_t)0x10000000) /* DMA2 FLAG mask */ + +/* DMA1 Channelx interrupt pending bit masks */ +#define DMA1_CHANNEL1_IT_MASK ((uint32_t)(DMA_ISR_GIF1 | DMA_ISR_TCIF1 | DMA_ISR_HTIF1 | DMA_ISR_TEIF1)) +#define DMA1_CHANNEL2_IT_MASK ((uint32_t)(DMA_ISR_GIF2 | DMA_ISR_TCIF2 | DMA_ISR_HTIF2 | DMA_ISR_TEIF2)) +#define DMA1_CHANNEL3_IT_MASK ((uint32_t)(DMA_ISR_GIF3 | DMA_ISR_TCIF3 | DMA_ISR_HTIF3 | DMA_ISR_TEIF3)) +#define DMA1_CHANNEL4_IT_MASK ((uint32_t)(DMA_ISR_GIF4 | DMA_ISR_TCIF4 | DMA_ISR_HTIF4 | DMA_ISR_TEIF4)) +#define DMA1_CHANNEL5_IT_MASK ((uint32_t)(DMA_ISR_GIF5 | DMA_ISR_TCIF5 | DMA_ISR_HTIF5 | DMA_ISR_TEIF5)) +#define DMA1_CHANNEL6_IT_MASK ((uint32_t)(DMA_ISR_GIF6 | DMA_ISR_TCIF6 | DMA_ISR_HTIF6 | DMA_ISR_TEIF6)) /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_CHANNEL7_IT_MASK ((uint32_t)(DMA_ISR_GIF7 | DMA_ISR_TCIF7 | DMA_ISR_HTIF7 | DMA_ISR_TEIF7)) /*!< Only applicable for STM32F072 and STM32F091 devices */ + +/* DMA2 Channelx interrupt pending bit masks: Only applicable for STM32F091 devices */ +#define DMA2_CHANNEL1_IT_MASK ((uint32_t)(DMA_ISR_GIF1 | DMA_ISR_TCIF1 | DMA_ISR_HTIF1 | DMA_ISR_TEIF1)) +#define DMA2_CHANNEL2_IT_MASK ((uint32_t)(DMA_ISR_GIF2 | DMA_ISR_TCIF2 | DMA_ISR_HTIF2 | DMA_ISR_TEIF2)) +#define DMA2_CHANNEL3_IT_MASK ((uint32_t)(DMA_ISR_GIF3 | DMA_ISR_TCIF3 | DMA_ISR_HTIF3 | DMA_ISR_TEIF3)) +#define DMA2_CHANNEL4_IT_MASK ((uint32_t)(DMA_ISR_GIF4 | DMA_ISR_TCIF4 | DMA_ISR_HTIF4 | DMA_ISR_TEIF4)) +#define DMA2_CHANNEL5_IT_MASK ((uint32_t)(DMA_ISR_GIF5 | DMA_ISR_TCIF5 | DMA_ISR_HTIF5 | DMA_ISR_TEIF5)) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup DMA_Private_Functions + * @{ + */ + +/** @defgroup DMA_Group1 Initialization and Configuration functions + * @brief Initialization and Configuration functions + * +@verbatim + =============================================================================== + ##### Initialization and Configuration functions ##### + =============================================================================== + [..] This subsection provides functions allowing to initialize the DMA channel + source and destination addresses, incrementation and data sizes, transfer + direction, buffer size, circular/normal mode selection, memory-to-memory + mode selection and channel priority value. + [..] The DMA_Init() function follows the DMA configuration procedures as described + in reference manual (RM0091). +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the DMAy Channelx registers to their default reset + * values. + * @param DMAy_Channelx: where y can be 1 to select the DMA and + * x can be 1 to 7 for DMA1 to select the DMA Channel. + * @note Channel 6 and 7 are available only for STM32F072 devices. + * @retval None + */ +void DMA_DeInit(DMA_Channel_TypeDef* DMAy_Channelx) +{ + /* Check the parameters */ + assert_param(IS_DMA_ALL_PERIPH(DMAy_Channelx)); + + /* Disable the selected DMAy Channelx */ + DMAy_Channelx->CCR &= (uint16_t)(~DMA_CCR_EN); + + /* Reset DMAy Channelx control register */ + DMAy_Channelx->CCR = 0; + + /* Reset DMAy Channelx remaining bytes register */ + DMAy_Channelx->CNDTR = 0; + + /* Reset DMAy Channelx peripheral address register */ + DMAy_Channelx->CPAR = 0; + + /* Reset DMAy Channelx memory address register */ + DMAy_Channelx->CMAR = 0; + + if (DMAy_Channelx == DMA1_Channel1) + { + /* Reset interrupt pending bits for DMA1 Channel1 */ + DMA1->IFCR |= DMA1_CHANNEL1_IT_MASK; + } + else if (DMAy_Channelx == DMA1_Channel2) + { + /* Reset interrupt pending bits for DMA1 Channel2 */ + DMA1->IFCR |= DMA1_CHANNEL2_IT_MASK; + } + else if (DMAy_Channelx == DMA1_Channel3) + { + /* Reset interrupt pending bits for DMA1 Channel3 */ + DMA1->IFCR |= DMA1_CHANNEL3_IT_MASK; + } + else if (DMAy_Channelx == DMA1_Channel4) + { + /* Reset interrupt pending bits for DMA1 Channel4 */ + DMA1->IFCR |= DMA1_CHANNEL4_IT_MASK; + } + else if (DMAy_Channelx == DMA1_Channel5) + { + /* Reset interrupt pending bits for DMA1 Channel5 */ + DMA1->IFCR |= DMA1_CHANNEL5_IT_MASK; + } + else if (DMAy_Channelx == DMA1_Channel6) + { + /* Reset interrupt pending bits for DMA1 Channel6 */ + DMA1->IFCR |= DMA1_CHANNEL6_IT_MASK; + } + else if (DMAy_Channelx == DMA1_Channel7) + { + /* Reset interrupt pending bits for DMA1 Channel7 */ + DMA1->IFCR |= DMA1_CHANNEL7_IT_MASK; + } + else if (DMAy_Channelx == DMA2_Channel1) + { + /* Reset interrupt pending bits for DMA2 Channel1 */ + DMA2->IFCR |= DMA2_CHANNEL1_IT_MASK; + } + else if (DMAy_Channelx == DMA2_Channel2) + { + /* Reset interrupt pending bits for DMA2 Channel2 */ + DMA2->IFCR |= DMA2_CHANNEL2_IT_MASK; + } + else if (DMAy_Channelx == DMA2_Channel3) + { + /* Reset interrupt pending bits for DMA2 Channel3 */ + DMA2->IFCR |= DMA2_CHANNEL3_IT_MASK; + } + else if (DMAy_Channelx == DMA2_Channel4) + { + /* Reset interrupt pending bits for DMA2 Channel4 */ + DMA2->IFCR |= DMA2_CHANNEL4_IT_MASK; + } + else + { + if (DMAy_Channelx == DMA2_Channel5) + { + /* Reset interrupt pending bits for DMA2 Channel5 */ + DMA2->IFCR |= DMA2_CHANNEL5_IT_MASK; + } + } +} + +/** + * @brief Initializes the DMAy Channelx according to the specified parameters + * in the DMA_InitStruct. + * @param DMAy_Channelx: where y can be 1 to select the DMA and x can be 1 to 7 + * for DMA1 to select the DMA Channel and 1 to 5 for DMA2 to select the DMA Channel. + * @note DMA1 Channel 6 and 7 are available only for STM32F072 and STM32F091 devices. + * @note DMA2 Channel 1 to 5 are available only for STM32F091 devices. + * @param DMA_InitStruct: pointer to a DMA_InitTypeDef structure that contains + * the configuration information for the specified DMA Channel. + * @retval None + */ +void DMA_Init(DMA_Channel_TypeDef* DMAy_Channelx, DMA_InitTypeDef* DMA_InitStruct) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_DMA_ALL_PERIPH(DMAy_Channelx)); + assert_param(IS_DMA_DIR(DMA_InitStruct->DMA_DIR)); + assert_param(IS_DMA_BUFFER_SIZE(DMA_InitStruct->DMA_BufferSize)); + assert_param(IS_DMA_PERIPHERAL_INC_STATE(DMA_InitStruct->DMA_PeripheralInc)); + assert_param(IS_DMA_MEMORY_INC_STATE(DMA_InitStruct->DMA_MemoryInc)); + assert_param(IS_DMA_PERIPHERAL_DATA_SIZE(DMA_InitStruct->DMA_PeripheralDataSize)); + assert_param(IS_DMA_MEMORY_DATA_SIZE(DMA_InitStruct->DMA_MemoryDataSize)); + assert_param(IS_DMA_MODE(DMA_InitStruct->DMA_Mode)); + assert_param(IS_DMA_PRIORITY(DMA_InitStruct->DMA_Priority)); + assert_param(IS_DMA_M2M_STATE(DMA_InitStruct->DMA_M2M)); + +/*--------------------------- DMAy Channelx CCR Configuration ----------------*/ + /* Get the DMAy_Channelx CCR value */ + tmpreg = DMAy_Channelx->CCR; + + /* Clear MEM2MEM, PL, MSIZE, PSIZE, MINC, PINC, CIRC and DIR bits */ + tmpreg &= CCR_CLEAR_MASK; + + /* Configure DMAy Channelx: data transfer, data size, priority level and mode */ + /* Set DIR bit according to DMA_DIR value */ + /* Set CIRC bit according to DMA_Mode value */ + /* Set PINC bit according to DMA_PeripheralInc value */ + /* Set MINC bit according to DMA_MemoryInc value */ + /* Set PSIZE bits according to DMA_PeripheralDataSize value */ + /* Set MSIZE bits according to DMA_MemoryDataSize value */ + /* Set PL bits according to DMA_Priority value */ + /* Set the MEM2MEM bit according to DMA_M2M value */ + tmpreg |= DMA_InitStruct->DMA_DIR | DMA_InitStruct->DMA_Mode | + DMA_InitStruct->DMA_PeripheralInc | DMA_InitStruct->DMA_MemoryInc | + DMA_InitStruct->DMA_PeripheralDataSize | DMA_InitStruct->DMA_MemoryDataSize | + DMA_InitStruct->DMA_Priority | DMA_InitStruct->DMA_M2M; + + /* Write to DMAy Channelx CCR */ + DMAy_Channelx->CCR = tmpreg; + +/*--------------------------- DMAy Channelx CNDTR Configuration --------------*/ + /* Write to DMAy Channelx CNDTR */ + DMAy_Channelx->CNDTR = DMA_InitStruct->DMA_BufferSize; + +/*--------------------------- DMAy Channelx CPAR Configuration ---------------*/ + /* Write to DMAy Channelx CPAR */ + DMAy_Channelx->CPAR = DMA_InitStruct->DMA_PeripheralBaseAddr; + +/*--------------------------- DMAy Channelx CMAR Configuration ---------------*/ + /* Write to DMAy Channelx CMAR */ + DMAy_Channelx->CMAR = DMA_InitStruct->DMA_MemoryBaseAddr; +} + +/** + * @brief Fills each DMA_InitStruct member with its default value. + * @param DMA_InitStruct: pointer to a DMA_InitTypeDef structure which will + * be initialized. + * @retval None + */ +void DMA_StructInit(DMA_InitTypeDef* DMA_InitStruct) +{ +/*-------------- Reset DMA init structure parameters values ------------------*/ + /* Initialize the DMA_PeripheralBaseAddr member */ + DMA_InitStruct->DMA_PeripheralBaseAddr = 0; + /* Initialize the DMA_MemoryBaseAddr member */ + DMA_InitStruct->DMA_MemoryBaseAddr = 0; + /* Initialize the DMA_DIR member */ + DMA_InitStruct->DMA_DIR = DMA_DIR_PeripheralSRC; + /* Initialize the DMA_BufferSize member */ + DMA_InitStruct->DMA_BufferSize = 0; + /* Initialize the DMA_PeripheralInc member */ + DMA_InitStruct->DMA_PeripheralInc = DMA_PeripheralInc_Disable; + /* Initialize the DMA_MemoryInc member */ + DMA_InitStruct->DMA_MemoryInc = DMA_MemoryInc_Disable; + /* Initialize the DMA_PeripheralDataSize member */ + DMA_InitStruct->DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; + /* Initialize the DMA_MemoryDataSize member */ + DMA_InitStruct->DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; + /* Initialize the DMA_Mode member */ + DMA_InitStruct->DMA_Mode = DMA_Mode_Normal; + /* Initialize the DMA_Priority member */ + DMA_InitStruct->DMA_Priority = DMA_Priority_Low; + /* Initialize the DMA_M2M member */ + DMA_InitStruct->DMA_M2M = DMA_M2M_Disable; +} + +/** + * @brief Enables or disables the specified DMAy Channelx. + * @param DMAy_Channelx: where y can be 1 to select the DMA and x can be 1 to 7 + * for DMA1 to select the DMA Channel and 1 to 5 for DMA2 to select the DMA Channel. + * @note DMA1 Channel 6 and 7 are available only for STM32F072 and STM32F091 devices. + * @note DMA2 Channel 1 to 5 are available only for STM32F091 devices. + * @param NewState: new state of the DMAy Channelx. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void DMA_Cmd(DMA_Channel_TypeDef* DMAy_Channelx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_DMA_ALL_PERIPH(DMAy_Channelx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected DMAy Channelx */ + DMAy_Channelx->CCR |= DMA_CCR_EN; + } + else + { + /* Disable the selected DMAy Channelx */ + DMAy_Channelx->CCR &= (uint16_t)(~DMA_CCR_EN); + } +} + +/** + * @brief Configure the DMAx channels remapping. + * @param DMAy: where x can be 1 or 2 to select the DMA peripheral. + * @param DMAy_CHx_RemapRequest: where y can be 1 or 2 to select the DMA and x can be 1 to 7 + * for DMA1 to select the DMA1 Channel and can be 1 to 5 for DMA2 to select the DMA2 Channel. + * @note This function is available only for STM32F091 devices. + * @retval None + */ +void DMA_RemapConfig(DMA_TypeDef* DMAy, uint32_t DMAx_CHy_RemapRequest) +{ + assert_param(IS_DMA_ALL_LIST(DMAy)); + + if (DMAy == DMA1) + { + assert_param(IS_DMA1_REMAP(DMAx_CHy_RemapRequest)); + } + else + { + assert_param(IS_DMA2_REMAP(DMAx_CHy_RemapRequest)); + } + + DMAy->RMPCR &= ~((uint32_t)0x0F << (uint32_t)((DMAx_CHy_RemapRequest >> 28) * 4)); + DMAy->RMPCR |= (uint32_t)(DMAx_CHy_RemapRequest & 0x0FFFFFFF); +} + +/** + * @} + */ + +/** @defgroup DMA_Group2 Data Counter functions + * @brief Data Counter functions + * +@verbatim + =============================================================================== + ##### Data Counter functions ##### + =============================================================================== + [..] This subsection provides function allowing to configure and read the buffer + size (number of data to be transferred).The DMA data counter can be written + only when the DMA channel is disabled (ie. after transfer complete event). + [..] The following function can be used to write the Channel data counter value: + (+) void DMA_SetCurrDataCounter(DMA_Channel_TypeDef* DMAy_Channelx, uint16_t + DataNumber). + -@- It is advised to use this function rather than DMA_Init() in situations + where only the Data buffer needs to be reloaded. + [..] The DMA data counter can be read to indicate the number of remaining transfers + for the relative DMA channel. This counter is decremented at the end of each + data transfer and when the transfer is complete: + (+) If Normal mode is selected: the counter is set to 0. + (+) If Circular mode is selected: the counter is reloaded with the initial + value(configured before enabling the DMA channel). + [..] The following function can be used to read the Channel data counter value: + (+) uint16_t DMA_GetCurrDataCounter(DMA_Channel_TypeDef* DMAy_Channelx). + +@endverbatim + * @{ + */ + +/** + * @brief Sets the number of data units in the current DMAy Channelx transfer. + * @param DMAy_Channelx: where y can be 1 to select the DMA and x can be 1 to 7 + * for DMA1 to select the DMA Channel and 1 to 5 for DMA2 to select the DMA Channel. + * @note DMA1 Channel 6 and 7 are available only for STM32F072 and STM32F091 devices. + * @note DMA2 Channel 1 to 5 are available only for STM32F091 devices. + * @param DataNumber: The number of data units in the current DMAy Channelx + * transfer. + * @note This function can only be used when the DMAy_Channelx is disabled. + * @retval None. + */ +void DMA_SetCurrDataCounter(DMA_Channel_TypeDef* DMAy_Channelx, uint16_t DataNumber) +{ + /* Check the parameters */ + assert_param(IS_DMA_ALL_PERIPH(DMAy_Channelx)); + +/*--------------------------- DMAy Channelx CNDTR Configuration --------------*/ + /* Write to DMAy Channelx CNDTR */ + DMAy_Channelx->CNDTR = DataNumber; +} + +/** + * @brief Returns the number of remaining data units in the current + * DMAy Channelx transfer. + * @param DMAy_Channelx: where y can be 1 to select the DMA and x can be 1 to 7 + * for DMA1 to select the DMA Channel and 1 to 5 for DMA2 to select the DMA Channel. + * @note DMA1 Channel 6 and 7 are available only for STM32F072 and STM32F091 devices. + * @note DMA2 Channel 1 to 5 are available only for STM32F091 devices. + * @retval The number of remaining data units in the current DMAy Channelx + * transfer. + */ +uint16_t DMA_GetCurrDataCounter(DMA_Channel_TypeDef* DMAy_Channelx) +{ + /* Check the parameters */ + assert_param(IS_DMA_ALL_PERIPH(DMAy_Channelx)); + /* Return the number of remaining data units for DMAy Channelx */ + return ((uint16_t)(DMAy_Channelx->CNDTR)); +} + +/** + * @} + */ + +/** @defgroup DMA_Group3 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== + [..] This subsection provides functions allowing to configure the DMA Interrupts + sources and check or clear the flags or pending bits status. + The user should identify which mode will be used in his application to manage + the DMA controller events: Polling mode or Interrupt mode. + *** Polling Mode *** + ==================== + [..] Each DMA channel can be managed through 4 event Flags:(y : DMA Controller + number x : DMA channel number ). + (#) DMAy_FLAG_TCx : to indicate that a Transfer Complete event occurred. + (#) DMAy_FLAG_HTx : to indicate that a Half-Transfer Complete event occurred. + (#) DMAy_FLAG_TEx : to indicate that a Transfer Error occurred. + (#) DMAy_FLAG_GLx : to indicate that at least one of the events described + above occurred. + -@- Clearing DMAy_FLAG_GLx results in clearing all other pending flags of the + same channel (DMAy_FLAG_TCx, DMAy_FLAG_HTx and DMAy_FLAG_TEx). + [..]In this Mode it is advised to use the following functions: + (+) FlagStatus DMA_GetFlagStatus(uint32_t DMA_FLAG); + (+) void DMA_ClearFlag(uint32_t DMA_FLAG); + + *** Interrupt Mode *** + ====================== + [..] Each DMA channel can be managed through 4 Interrupts: + (+) Interrupt Source + (##) DMA_IT_TC: specifies the interrupt source for the Transfer Complete + event. + (##) DMA_IT_HT : specifies the interrupt source for the Half-transfer Complete + event. + (##) DMA_IT_TE : specifies the interrupt source for the transfer errors event. + (##) DMA_IT_GL : to indicate that at least one of the interrupts described + above occurred. + -@@- Clearing DMA_IT_GL interrupt results in clearing all other interrupts of + the same channel (DMA_IT_TCx, DMA_IT_HT and DMA_IT_TE). + [..]In this Mode it is advised to use the following functions: + (+) void DMA_ITConfig(DMA_Channel_TypeDef* DMAy_Channelx, uint32_t DMA_IT, + FunctionalState NewState); + (+) ITStatus DMA_GetITStatus(uint32_t DMA_IT); + (+) void DMA_ClearITPendingBit(uint32_t DMA_IT); + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified DMAy Channelx interrupts. + * @param DMAy_Channelx: where y can be 1 to select the DMA and x can be 1 to 7 + * for DMA1 to select the DMA Channel and 1 to 5 for DMA2 to select the DMA Channel. + * @note DMA1 Channel 6 and 7 are available only for STM32F072 and STM32F091 devices. + * @note DMA2 Channel 1 to 5 are available only for STM32F091 devices. + * @param DMA_IT: specifies the DMA interrupts sources to be enabled + * or disabled. + * This parameter can be any combination of the following values: + * @arg DMA_IT_TC: Transfer complete interrupt mask + * @arg DMA_IT_HT: Half transfer interrupt mask + * @arg DMA_IT_TE: Transfer error interrupt mask + * @param NewState: new state of the specified DMA interrupts. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void DMA_ITConfig(DMA_Channel_TypeDef* DMAy_Channelx, uint32_t DMA_IT, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_DMA_ALL_PERIPH(DMAy_Channelx)); + assert_param(IS_DMA_CONFIG_IT(DMA_IT)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected DMA interrupts */ + DMAy_Channelx->CCR |= DMA_IT; + } + else + { + /* Disable the selected DMA interrupts */ + DMAy_Channelx->CCR &= ~DMA_IT; + } +} + +/** + * @brief Checks whether the specified DMAy Channelx flag is set or not. + * @param DMA_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg DMA1_FLAG_GL1: DMA1 Channel1 global flag. + * @arg DMA1_FLAG_TC1: DMA1 Channel1 transfer complete flag. + * @arg DMA1_FLAG_HT1: DMA1 Channel1 half transfer flag. + * @arg DMA1_FLAG_TE1: DMA1 Channel1 transfer error flag. + * @arg DMA1_FLAG_GL2: DMA1 Channel2 global flag. + * @arg DMA1_FLAG_TC2: DMA1 Channel2 transfer complete flag. + * @arg DMA1_FLAG_HT2: DMA1 Channel2 half transfer flag. + * @arg DMA1_FLAG_TE2: DMA1 Channel2 transfer error flag. + * @arg DMA1_FLAG_GL3: DMA1 Channel3 global flag. + * @arg DMA1_FLAG_TC3: DMA1 Channel3 transfer complete flag. + * @arg DMA1_FLAG_HT3: DMA1 Channel3 half transfer flag. + * @arg DMA1_FLAG_TE3: DMA1 Channel3 transfer error flag. + * @arg DMA1_FLAG_GL4: DMA1 Channel4 global flag. + * @arg DMA1_FLAG_TC4: DMA1 Channel4 transfer complete flag. + * @arg DMA1_FLAG_HT4: DMA1 Channel4 half transfer flag. + * @arg DMA1_FLAG_TE4: DMA1 Channel4 transfer error flag. + * @arg DMA1_FLAG_GL5: DMA1 Channel5 global flag. + * @arg DMA1_FLAG_TC5: DMA1 Channel5 transfer complete flag. + * @arg DMA1_FLAG_HT5: DMA1 Channel5 half transfer flag. + * @arg DMA1_FLAG_TE5: DMA1 Channel5 transfer error flag. + * @arg DMA1_FLAG_GL6: DMA1 Channel6 global flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_TC6: DMA1 Channel6 transfer complete flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_HT6: DMA1 Channel6 half transfer flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_TE6: DMA1 Channel6 transfer error flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_GL7: DMA1 Channel7 global flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_TC7: DMA1 Channel7 transfer complete flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_HT7: DMA1 Channel7 half transfer flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_TE7: DMA1 Channel7 transfer error flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA2_FLAG_GL1: DMA2 Channel1 global flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TC1: DMA2 Channel1 transfer complete flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_HT1: DMA2 Channel1 half transfer flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TE1: DMA2 Channel1 transfer error flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_GL2: DMA2 Channel2 global flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TC2: DMA2 Channel2 transfer complete flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_HT2: DMA2 Channel2 half transfer flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TE2: DMA2 Channel2 transfer error flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_GL3: DMA2 Channel3 global flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TC3: DMA2 Channel3 transfer complete flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_HT3: DMA2 Channel3 half transfer flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TE3: DMA2 Channel3 transfer error flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_GL4: DMA2 Channel4 global flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TC4: DMA2 Channel4 transfer complete flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_HT4: DMA2 Channel4 half transfer flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TE4: DMA2 Channel4 transfer error flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_GL5: DMA2 Channel5 global flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TC5: DMA2 Channel5 transfer complete flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_HT5: DMA2 Channel5 half transfer flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TE5: DMA2 Channel5 transfer error flag, applicable only for STM32FO91 devices. + * @note The Global flag (DMAy_FLAG_GLx) is set whenever any of the other flags + * relative to the same channel is set (Transfer Complete, Half-transfer + * Complete or Transfer Error flags: DMAy_FLAG_TCx, DMAy_FLAG_HTx or + * DMAy_FLAG_TEx). + * + * @retval The new state of DMA_FLAG (SET or RESET). + */ +FlagStatus DMA_GetFlagStatus(uint32_t DMAy_FLAG) +{ + FlagStatus bitstatus = RESET; + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_DMA_GET_FLAG(DMAy_FLAG)); + + /* Calculate the used DMAy */ + if ((DMAy_FLAG & FLAG_Mask) != (uint32_t)RESET) + { + /* Get DMA2 ISR register value */ + tmpreg = DMA2->ISR ; + } + else + { + /* Get DMA1 ISR register value */ + tmpreg = DMA1->ISR ; + } + + /* Check the status of the specified DMAy flag */ + if ((tmpreg & DMAy_FLAG) != (uint32_t)RESET) + { + /* DMAy_FLAG is set */ + bitstatus = SET; + } + else + { + /* DMAy_FLAG is reset */ + bitstatus = RESET; + } + + /* Return the DMAy_FLAG status */ + return bitstatus; +} + +/** + * @brief Clears the DMAy Channelx's pending flags. + * @param DMA_FLAG: specifies the flag to clear. + * This parameter can be any combination (for the same DMA) of the following values: + * @arg DMA1_FLAG_GL1: DMA1 Channel1 global flag. + * @arg DMA1_FLAG_TC1: DMA1 Channel1 transfer complete flag. + * @arg DMA1_FLAG_HT1: DMA1 Channel1 half transfer flag. + * @arg DMA1_FLAG_TE1: DMA1 Channel1 transfer error flag. + * @arg DMA1_FLAG_GL2: DMA1 Channel2 global flag. + * @arg DMA1_FLAG_TC2: DMA1 Channel2 transfer complete flag. + * @arg DMA1_FLAG_HT2: DMA1 Channel2 half transfer flag. + * @arg DMA1_FLAG_TE2: DMA1 Channel2 transfer error flag. + * @arg DMA1_FLAG_GL3: DMA1 Channel3 global flag. + * @arg DMA1_FLAG_TC3: DMA1 Channel3 transfer complete flag. + * @arg DMA1_FLAG_HT3: DMA1 Channel3 half transfer flag. + * @arg DMA1_FLAG_TE3: DMA1 Channel3 transfer error flag. + * @arg DMA1_FLAG_GL4: DMA1 Channel4 global flag. + * @arg DMA1_FLAG_TC4: DMA1 Channel4 transfer complete flag. + * @arg DMA1_FLAG_HT4: DMA1 Channel4 half transfer flag. + * @arg DMA1_FLAG_TE4: DMA1 Channel4 transfer error flag. + * @arg DMA1_FLAG_GL5: DMA1 Channel5 global flag. + * @arg DMA1_FLAG_TC5: DMA1 Channel5 transfer complete flag. + * @arg DMA1_FLAG_HT5: DMA1 Channel5 half transfer flag. + * @arg DMA1_FLAG_TE5: DMA1 Channel5 transfer error flag. + * @arg DMA1_FLAG_GL6: DMA1 Channel6 global flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_TC6: DMA1 Channel6 transfer complete flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_HT6: DMA1 Channel6 half transfer flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_TE6: DMA1 Channel6 transfer error flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_GL7: DMA1 Channel7 global flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_TC7: DMA1 Channel7 transfer complete flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_HT7: DMA1 Channel7 half transfer flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_TE7: DMA1 Channel7 transfer error flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA2_FLAG_GL1: DMA2 Channel1 global flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TC1: DMA2 Channel1 transfer complete flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_HT1: DMA2 Channel1 half transfer flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TE1: DMA2 Channel1 transfer error flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_GL2: DMA2 Channel2 global flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TC2: DMA2 Channel2 transfer complete flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_HT2: DMA2 Channel2 half transfer flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TE2: DMA2 Channel2 transfer error flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_GL3: DMA2 Channel3 global flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TC3: DMA2 Channel3 transfer complete flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_HT3: DMA2 Channel3 half transfer flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TE3: DMA2 Channel3 transfer error flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_GL4: DMA2 Channel4 global flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TC4: DMA2 Channel4 transfer complete flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_HT4: DMA2 Channel4 half transfer flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TE4: DMA2 Channel4 transfer error flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_GL5: DMA2 Channel5 global flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TC5: DMA2 Channel5 transfer complete flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_HT5: DMA2 Channel5 half transfer flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TE5: DMA2 Channel5 transfer error flag, applicable only for STM32FO91 devices. + * + * @note Clearing the Global flag (DMAy_FLAG_GLx) results in clearing all other flags + * relative to the same channel (Transfer Complete, Half-transfer Complete and + * Transfer Error flags: DMAy_FLAG_TCx, DMAy_FLAG_HTx and DMAy_FLAG_TEx). + * + * @retval None + */ +void DMA_ClearFlag(uint32_t DMAy_FLAG) +{ + /* Check the parameters */ + assert_param(IS_DMA_CLEAR_FLAG(DMAy_FLAG)); + +/* Calculate the used DMAy */ + if ((DMAy_FLAG & FLAG_Mask) != (uint32_t)RESET) + { + /* Clear the selected DMAy flags */ + DMA2->IFCR = DMAy_FLAG; + } + else + { + /* Clear the selected DMAy flags */ + DMA1->IFCR = DMAy_FLAG; + } +} + +/** + * @brief Checks whether the specified DMAy Channelx interrupt has occurred or not. + * @param DMA_IT: specifies the DMA interrupt source to check. + * This parameter can be one of the following values: + * @arg DMA1_IT_GL1: DMA1 Channel1 global interrupt. + * @arg DMA1_IT_TC1: DMA1 Channel1 transfer complete interrupt. + * @arg DMA1_IT_HT1: DMA1 Channel1 half transfer interrupt. + * @arg DMA1_IT_TE1: DMA1 Channel1 transfer error interrupt. + * @arg DMA1_IT_GL2: DMA1 Channel2 global interrupt. + * @arg DMA1_IT_TC2: DMA1 Channel2 transfer complete interrupt. + * @arg DMA1_IT_HT2: DMA1 Channel2 half transfer interrupt. + * @arg DMA1_IT_TE2: DMA1 Channel2 transfer error interrupt. + * @arg DMA1_IT_GL3: DMA1 Channel3 global interrupt. + * @arg DMA1_IT_TC3: DMA1 Channel3 transfer complete interrupt. + * @arg DMA1_IT_HT3: DMA1 Channel3 half transfer interrupt. + * @arg DMA1_IT_TE3: DMA1 Channel3 transfer error interrupt. + * @arg DMA1_IT_GL4: DMA1 Channel4 global interrupt. + * @arg DMA1_IT_TC4: DMA1 Channel4 transfer complete interrupt. + * @arg DMA1_IT_HT4: DMA1 Channel4 half transfer interrupt. + * @arg DMA1_IT_TE4: DMA1 Channel4 transfer error interrupt. + * @arg DMA1_IT_GL5: DMA1 Channel5 global interrupt. + * @arg DMA1_IT_TC5: DMA1 Channel5 transfer complete interrupt. + * @arg DMA1_IT_HT5: DMA1 Channel5 half transfer interrupt. + * @arg DMA1_IT_TE5: DMA1 Channel5 transfer error interrupt. + * @arg DMA1_IT_GL6: DMA1 Channel6 global interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_TC6: DMA1 Channel6 transfer complete interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_HT6: DMA1 Channel6 half transfer interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_TE6: DMA1 Channel6 transfer error interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_GL7: DMA1 Channel7 global interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_TC7: DMA1 Channel7 transfer complete interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_HT7: DMA1 Channel7 half transfer interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_TE7: DMA1 Channel7 transfer error interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA2_IT_GL1: DMA2 Channel1 global interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TC1: DMA2 Channel1 transfer complete interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_HT1: DMA2 Channel1 half transfer interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TE1: DMA2 Channel1 transfer error interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_GL2: DMA2 Channel2 global interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TC2: DMA2 Channel2 transfer complete interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_HT2: DMA2 Channel2 half transfer interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TE2: DMA2 Channel2 transfer error interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_GL3: DMA2 Channel3 global interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TC3: DMA2 Channel3 transfer complete interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_HT3: DMA2 Channel3 half transfer interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TE3: DMA2 Channel3 transfer error interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_GL4: DMA2 Channel4 global interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TC4: DMA2 Channel4 transfer complete interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_HT4: DMA2 Channel4 half transfer interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TE4: DMA2 Channel4 transfer error interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_GL5: DMA2 Channel5 global interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TC5: DMA2 Channel5 transfer complete interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_HT5: DMA2 Channel5 half transfer interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TE5: DMA2 Channel5 transfer error interrupt, applicable only for STM32FO91 devices. + * @note The Global interrupt (DMAy_FLAG_GLx) is set whenever any of the other + * interrupts relative to the same channel is set (Transfer Complete, + * Half-transfer Complete or Transfer Error interrupts: DMAy_IT_TCx, + * DMAy_IT_HTx or DMAy_IT_TEx). + * + * @retval The new state of DMA_IT (SET or RESET). + */ +ITStatus DMA_GetITStatus(uint32_t DMAy_IT) +{ + ITStatus bitstatus = RESET; + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_DMA_GET_IT(DMAy_IT)); + + /* Calculate the used DMA */ + if ((DMAy_IT & FLAG_Mask) != (uint32_t)RESET) + { + /* Get DMA2 ISR register value */ + tmpreg = DMA2->ISR; + } + else + { + /* Get DMA1 ISR register value */ + tmpreg = DMA1->ISR; + } + + /* Check the status of the specified DMAy interrupt */ + if ((tmpreg & DMAy_IT) != (uint32_t)RESET) + { + /* DMAy_IT is set */ + bitstatus = SET; + } + else + { + /* DMAy_IT is reset */ + bitstatus = RESET; + } + /* Return the DMAy_IT status */ + return bitstatus; +} + +/** + * @brief Clears the DMAy Channelx's interrupt pending bits. + * @param DMA_IT: specifies the DMA interrupt pending bit to clear. + * This parameter can be any combination (for the same DMA) of the following values: + * @arg DMA1_IT_GL1: DMA1 Channel1 global interrupt. + * @arg DMA1_IT_TC1: DMA1 Channel1 transfer complete interrupt. + * @arg DMA1_IT_HT1: DMA1 Channel1 half transfer interrupt. + * @arg DMA1_IT_TE1: DMA1 Channel1 transfer error interrupt. + * @arg DMA1_IT_GL2: DMA1 Channel2 global interrupt. + * @arg DMA1_IT_TC2: DMA1 Channel2 transfer complete interrupt. + * @arg DMA1_IT_HT2: DMA1 Channel2 half transfer interrupt. + * @arg DMA1_IT_TE2: DMA1 Channel2 transfer error interrupt. + * @arg DMA1_IT_GL3: DMA1 Channel3 global interrupt. + * @arg DMA1_IT_TC3: DMA1 Channel3 transfer complete interrupt. + * @arg DMA1_IT_HT3: DMA1 Channel3 half transfer interrupt. + * @arg DMA1_IT_TE3: DMA1 Channel3 transfer error interrupt. + * @arg DMA1_IT_GL4: DMA1 Channel4 global interrupt. + * @arg DMA1_IT_TC4: DMA1 Channel4 transfer complete interrupt. + * @arg DMA1_IT_HT4: DMA1 Channel4 half transfer interrupt. + * @arg DMA1_IT_TE4: DMA1 Channel4 transfer error interrupt. + * @arg DMA1_IT_GL5: DMA1 Channel5 global interrupt. + * @arg DMA1_IT_TC5: DMA1 Channel5 transfer complete interrupt. + * @arg DMA1_IT_HT5: DMA1 Channel5 half transfer interrupt. + * @arg DMA1_IT_TE5: DMA1 Channel5 transfer error interrupt. + * @arg DMA1_IT_GL6: DMA1 Channel6 global interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_TC6: DMA1 Channel6 transfer complete interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_HT6: DMA1 Channel6 half transfer interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_TE6: DMA1 Channel6 transfer error interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_GL7: DMA1 Channel7 global interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_TC7: DMA1 Channel7 transfer complete interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_HT7: DMA1 Channel7 half transfer interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_TE7: DMA1 Channel7 transfer error interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA2_IT_GL1: DMA2 Channel1 global interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TC1: DMA2 Channel1 transfer complete interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_HT1: DMA2 Channel1 half transfer interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TE1: DMA2 Channel1 transfer error interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_GL2: DMA2 Channel2 global interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TC2: DMA2 Channel2 transfer complete interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_HT2: DMA2 Channel2 half transfer interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TE2: DMA2 Channel2 transfer error interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_GL3: DMA2 Channel3 global interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TC3: DMA2 Channel3 transfer complete interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_HT3: DMA2 Channel3 half transfer interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TE3: DMA2 Channel3 transfer error interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_GL4: DMA2 Channel4 global interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TC4: DMA2 Channel4 transfer complete interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_HT4: DMA2 Channel4 half transfer interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TE4: DMA2 Channel4 transfer error interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_GL5: DMA2 Channel5 global interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TC5: DMA2 Channel5 transfer complete interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_HT5: DMA2 Channel5 half transfer interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TE5: DMA2 Channel5 transfer error interrupt, applicable only for STM32FO91 devices. + * + * @note Clearing the Global interrupt (DMAy_IT_GLx) results in clearing all other + * interrupts relative to the same channel (Transfer Complete, Half-transfer + * Complete and Transfer Error interrupts: DMAy_IT_TCx, DMAy_IT_HTx and + * DMAy_IT_TEx). + * + * @retval None + */ +void DMA_ClearITPendingBit(uint32_t DMAy_IT) +{ + /* Check the parameters */ + assert_param(IS_DMA_CLEAR_IT(DMAy_IT)); + + /* Calculate the used DMAy */ + if ((DMAy_IT & FLAG_Mask) != (uint32_t)RESET) + { + /* Clear the selected DMAy interrupt pending bits */ + DMA2->IFCR = DMAy_IT; + } + else + { + /* Clear the selected DMAy interrupt pending bits */ + DMA1->IFCR = DMAy_IT; + } +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_exti.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_exti.c new file mode 100644 index 00000000..5c0bd6a2 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_exti.c @@ -0,0 +1,314 @@ +/** + ****************************************************************************** + * @file stm32f0xx_exti.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the EXTI peripheral: + * + Initialization and Configuration + * + Interrupts and flags management + * + * @verbatim + ============================================================================== + ##### EXTI features ##### + ============================================================================== + [..] External interrupt/event lines are mapped as following: + (#) All available GPIO pins are connected to the 16 external + interrupt/event lines from EXTI0 to EXTI15. + (#) EXTI line 16 is connected to the PVD output, not applicable for STM32F030 devices. + (#) EXTI line 17 is connected to the RTC Alarm event. + (#) EXTI line 18 is connected to the RTC Alarm event, applicable only for STM32F072 devices. + (#) EXTI line 19 is connected to the RTC Tamper and TimeStamp events. + (#) EXTI line 20 is connected to the RTC wakeup event, applicable only for STM32F072 devices. + (#) EXTI line 21 is connected to the Comparator 1 wakeup event, applicable only for STM32F051 and STM32F072 devices. + (#) EXTI line 22 is connected to the Comparator 2 wakeup event, applicable only for STM32F051 and STM32F072 devices. + (#) EXTI line 23 is connected to the I2C1 wakeup event, not applicable for STM32F030 devices. + (#) EXTI line 25 is connected to the USART1 wakeup event, not applicable for STM32F030 devices. + (#) EXTI line 26 is connected to the USART2 wakeup event, applicable only for STM32F072 devices. + (#) EXTI line 27 is connected to the CEC wakeup event, applicable only for STM32F051 and STM32F072 devices. + (#) EXTI line 31 is connected to the VDD USB monitor event, applicable only for STM32F072 devices. + + ##### How to use this driver ##### + ============================================================================== + [..] In order to use an I/O pin as an external interrupt source, follow + steps below: + (#) Configure the I/O in input mode using GPIO_Init() + (#) Select the input source pin for the EXTI line using + SYSCFG_EXTILineConfig(). + (#) Select the mode(interrupt, event) and configure the trigger selection + (Rising, falling or both) using EXTI_Init(). For the internal interrupt, + the trigger selection is not needed( the active edge is always the rising one). + (#) Configure NVIC IRQ channel mapped to the EXTI line using NVIC_Init(). + (#) Optionally, you can generate a software interrupt using the function EXTI_GenerateSWInterrupt(). + [..] + (@) SYSCFG APB clock must be enabled to get write access to SYSCFG_EXTICRx + registers using RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE); + @endverbatim + * + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_exti.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup EXTI + * @brief EXTI driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +#define EXTI_LINENONE ((uint32_t)0x00000) /* No interrupt selected */ + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup EXTI_Private_Functions + * @{ + */ + +/** @defgroup EXTI_Group1 Initialization and Configuration functions + * @brief Initialization and Configuration functions + * +@verbatim + ============================================================================== + ##### Initialization and Configuration functions ##### + ============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the EXTI peripheral registers to their default reset + * values. + * @param None + * @retval None + */ +void EXTI_DeInit(void) +{ + EXTI->IMR = 0x0F940000; + EXTI->EMR = 0x00000000; + EXTI->RTSR = 0x00000000; + EXTI->FTSR = 0x00000000; + EXTI->PR = 0x006BFFFF; +} + +/** + * @brief Initializes the EXTI peripheral according to the specified + * parameters in the EXTI_InitStruct. + * @param EXTI_InitStruct: pointer to a EXTI_InitTypeDef structure that + * contains the configuration information for the EXTI peripheral. + * @retval None + */ +void EXTI_Init(EXTI_InitTypeDef* EXTI_InitStruct) +{ + uint32_t tmp = 0; + + /* Check the parameters */ + assert_param(IS_EXTI_MODE(EXTI_InitStruct->EXTI_Mode)); + assert_param(IS_EXTI_TRIGGER(EXTI_InitStruct->EXTI_Trigger)); + assert_param(IS_EXTI_LINE(EXTI_InitStruct->EXTI_Line)); + assert_param(IS_FUNCTIONAL_STATE(EXTI_InitStruct->EXTI_LineCmd)); + + tmp = (uint32_t)EXTI_BASE; + + if (EXTI_InitStruct->EXTI_LineCmd != DISABLE) + { + /* Clear EXTI line configuration */ + EXTI->IMR &= ~EXTI_InitStruct->EXTI_Line; + EXTI->EMR &= ~EXTI_InitStruct->EXTI_Line; + + tmp += EXTI_InitStruct->EXTI_Mode; + + *(__IO uint32_t *) tmp |= EXTI_InitStruct->EXTI_Line; + + /* Clear Rising Falling edge configuration */ + EXTI->RTSR &= ~EXTI_InitStruct->EXTI_Line; + EXTI->FTSR &= ~EXTI_InitStruct->EXTI_Line; + + /* Select the trigger for the selected interrupts */ + if (EXTI_InitStruct->EXTI_Trigger == EXTI_Trigger_Rising_Falling) + { + /* Rising Falling edge */ + EXTI->RTSR |= EXTI_InitStruct->EXTI_Line; + EXTI->FTSR |= EXTI_InitStruct->EXTI_Line; + } + else + { + tmp = (uint32_t)EXTI_BASE; + tmp += EXTI_InitStruct->EXTI_Trigger; + + *(__IO uint32_t *) tmp |= EXTI_InitStruct->EXTI_Line; + } + } + else + { + tmp += EXTI_InitStruct->EXTI_Mode; + + /* Disable the selected external lines */ + *(__IO uint32_t *) tmp &= ~EXTI_InitStruct->EXTI_Line; + } +} + +/** + * @brief Fills each EXTI_InitStruct member with its reset value. + * @param EXTI_InitStruct: pointer to a EXTI_InitTypeDef structure which will + * be initialized. + * @retval None + */ +void EXTI_StructInit(EXTI_InitTypeDef* EXTI_InitStruct) +{ + EXTI_InitStruct->EXTI_Line = EXTI_LINENONE; + EXTI_InitStruct->EXTI_Mode = EXTI_Mode_Interrupt; + EXTI_InitStruct->EXTI_Trigger = EXTI_Trigger_Falling; + EXTI_InitStruct->EXTI_LineCmd = DISABLE; +} + +/** + * @brief Generates a Software interrupt on selected EXTI line. + * @param EXTI_Line: specifies the EXTI line on which the software interrupt + * will be generated. + * This parameter can be any combination of EXTI_Linex where x can be (0..27). + * @retval None + */ +void EXTI_GenerateSWInterrupt(uint32_t EXTI_Line) +{ + /* Check the parameters */ + assert_param(IS_EXTI_LINE(EXTI_Line)); + + EXTI->SWIER |= EXTI_Line; +} + +/** + * @} + */ + +/** @defgroup EXTI_Group2 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + ============================================================================== + ##### Interrupts and flags management functions ##### + ============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Checks whether the specified EXTI line flag is set or not. + * @param EXTI_Line: specifies the EXTI line flag to check. + * This parameter can be EXTI_Linex where x can be (0..27). + * @retval The new state of EXTI_Line (SET or RESET). + */ +FlagStatus EXTI_GetFlagStatus(uint32_t EXTI_Line) +{ + FlagStatus bitstatus = RESET; + /* Check the parameters */ + assert_param(IS_GET_EXTI_LINE(EXTI_Line)); + + if ((EXTI->PR & EXTI_Line) != (uint32_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + return bitstatus; +} + +/** + * @brief Clears the EXTI's line pending flags. + * @param EXTI_Line: specifies the EXTI lines flags to clear. + * This parameter can be any combination of EXTI_Linex where x can be (0..27). + * @retval None + */ +void EXTI_ClearFlag(uint32_t EXTI_Line) +{ + /* Check the parameters */ + assert_param(IS_EXTI_LINE(EXTI_Line)); + + EXTI->PR = EXTI_Line; +} + +/** + * @brief Checks whether the specified EXTI line is asserted or not. + * @param EXTI_Line: specifies the EXTI line to check. + * This parameter can be EXTI_Linex where x can be (0..27). + * @retval The new state of EXTI_Line (SET or RESET). + */ +ITStatus EXTI_GetITStatus(uint32_t EXTI_Line) +{ + ITStatus bitstatus = RESET; + + /* Check the parameters */ + assert_param(IS_GET_EXTI_LINE(EXTI_Line)); + + if ((EXTI->PR & EXTI_Line) != (uint32_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + return bitstatus; +} + +/** + * @brief Clears the EXTI's line pending bits. + * @param EXTI_Line: specifies the EXTI lines to clear. + * This parameter can be any combination of EXTI_Linex where x can be (0..27). + * @retval None + */ +void EXTI_ClearITPendingBit(uint32_t EXTI_Line) +{ + /* Check the parameters */ + assert_param(IS_EXTI_LINE(EXTI_Line)); + + EXTI->PR = EXTI_Line; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_flash.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_flash.c new file mode 100644 index 00000000..98ff4aa8 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_flash.c @@ -0,0 +1,1256 @@ +/** + ****************************************************************************** + * @file stm32f0xx_flash.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the FLASH peripheral: + * - FLASH Interface configuration + * - FLASH Memory Programming + * - Option Bytes Programming + * - Interrupts and flags management + * + * @verbatim + =============================================================================== + ##### How to use this driver ##### + =============================================================================== + [..] This driver provides functions to configure and program the Flash + memory of all STM32F0xx devices. These functions are split in 4 groups + (#) FLASH Interface configuration functions: this group includes the + management of following features: + (++) Set the latency + (++) Enable/Disable the prefetch buffer + + (#) FLASH Memory Programming functions: this group includes all needed + functions to erase and program the main memory: + (++) Lock and Unlock the Flash interface. + (++) Erase function: Erase Page, erase all pages. + (++) Program functions: Half Word and Word write. + + (#) FLASH Option Bytes Programming functions: this group includes all + needed functions to: + (++) Lock and Unlock the Flash Option bytes. + (++) Launch the Option Bytes loader + (++) Erase the Option Bytes + (++)Set/Reset the write protection + (++) Set the Read protection Level + (++) Program the user option Bytes + (++) Set/Reset the BOOT1 bit + (++) Enable/Disable the VDDA Analog Monitoring + (++) Get the user option bytes + (++) Get the Write protection + (++) Get the read protection status + + (#) FLASH Interrupts and flag management functions: this group includes + all needed functions to: + (++) Enable/Disable the flash interrupt sources + (++) Get flags status + (++) Clear flags + (++) Get Flash operation status + (++) Wait for last flash operation + + @endverbatim + + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_flash.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup FLASH + * @brief FLASH driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup FLASH_Private_Functions + * @{ + */ + +/** @defgroup FLASH_Group1 FLASH Interface configuration functions + * @brief FLASH Interface configuration functions + * +@verbatim + =============================================================================== + ##### FLASH Interface configuration functions ##### + =============================================================================== + + [..] FLASH_Interface configuration_Functions, includes the following functions: + (+) void FLASH_SetLatency(uint32_t FLASH_Latency): + [..] To correctly read data from Flash memory, the number of wait states (LATENCY) + must be correctly programmed according to the frequency of the CPU clock (HCLK) + [..] + +--------------------------------------------- + + | Wait states | HCLK clock frequency (MHz) | + |---------------|------------------------------| + |0WS(1CPU cycle)| 0 < HCLK <= 24 | + |---------------|------------------------------| + |1WS(2CPU cycle)| 24 < HCLK <= 48 | + +----------------------------------------------+ + [..] + (+) void FLASH_PrefetchBufferCmd(FunctionalState NewState); + [..] + All these functions don't need the unlock sequence. + +@endverbatim + * @{ + */ + +/** + * @brief Sets the code latency value. + * @param FLASH_Latency: specifies the FLASH Latency value. + * This parameter can be one of the following values: + * @arg FLASH_Latency_0: FLASH Zero Latency cycle + * @arg FLASH_Latency_1: FLASH One Latency cycle + * @retval None + */ +void FLASH_SetLatency(uint32_t FLASH_Latency) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_FLASH_LATENCY(FLASH_Latency)); + + /* Read the ACR register */ + tmpreg = FLASH->ACR; + + /* Sets the Latency value */ + tmpreg &= (uint32_t) (~((uint32_t)FLASH_ACR_LATENCY)); + tmpreg |= FLASH_Latency; + + /* Write the ACR register */ + FLASH->ACR = tmpreg; +} + +/** + * @brief Enables or disables the Prefetch Buffer. + * @param NewState: new state of the FLASH prefetch buffer. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void FLASH_PrefetchBufferCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if(NewState != DISABLE) + { + FLASH->ACR |= FLASH_ACR_PRFTBE; + } + else + { + FLASH->ACR &= (uint32_t)(~((uint32_t)FLASH_ACR_PRFTBE)); + } +} + +/** + * @brief Checks whether the FLASH Prefetch Buffer status is set or not. + * @param None + * @retval FLASH Prefetch Buffer Status (SET or RESET). + */ +FlagStatus FLASH_GetPrefetchBufferStatus(void) +{ + FlagStatus bitstatus = RESET; + + if ((FLASH->ACR & FLASH_ACR_PRFTBS) != (uint32_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + /* Return the new state of FLASH Prefetch Buffer Status (SET or RESET) */ + return bitstatus; +} + +/** + * @} + */ + +/** @defgroup FLASH_Group2 FLASH Memory Programming functions + * @brief FLASH Memory Programming functions + * +@verbatim + =============================================================================== + ##### FLASH Memory Programming functions ##### + =============================================================================== + + [..] The FLASH Memory Programming functions, includes the following functions: + (+) void FLASH_Unlock(void); + (+) void FLASH_Lock(void); + (+) FLASH_Status FLASH_ErasePage(uint32_t Page_Address); + (+) FLASH_Status FLASH_EraseAllPages(void); + (+) FLASH_Status FLASH_ProgramWord(uint32_t Address, uint32_t Data); + (+) FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data); + + [..] Any operation of erase or program should follow these steps: + + (#) Call the FLASH_Unlock() function to enable the flash control register and + program memory access + (#) Call the desired function to erase page or program data + (#) Call the FLASH_Lock() to disable the flash program memory access + (recommended to protect the FLASH memory against possible unwanted operation) + +@endverbatim + * @{ + */ + +/** + * @brief Unlocks the FLASH control register and program memory access. + * @param None + * @retval None + */ +void FLASH_Unlock(void) +{ + if((FLASH->CR & FLASH_CR_LOCK) != RESET) + { + /* Unlocking the program memory access */ + FLASH->KEYR = FLASH_FKEY1; + FLASH->KEYR = FLASH_FKEY2; + } +} + +/** + * @brief Locks the Program memory access. + * @param None + * @retval None + */ +void FLASH_Lock(void) +{ + /* Set the LOCK Bit to lock the FLASH control register and program memory access */ + FLASH->CR |= FLASH_CR_LOCK; +} + +/** + * @brief Erases a specified page in program memory. + * @note To correctly run this function, the FLASH_Unlock() function must be called before. + * @note Call the FLASH_Lock() to disable the flash memory access (recommended + * to protect the FLASH memory against possible unwanted operation) + * @param Page_Address: The page address in program memory to be erased. + * @note A Page is erased in the Program memory only if the address to load + * is the start address of a page (multiple of 1024 bytes). + * @retval FLASH Status: The returned value can be: + * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT. + */ +FLASH_Status FLASH_ErasePage(uint32_t Page_Address) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Check the parameters */ + assert_param(IS_FLASH_PROGRAM_ADDRESS(Page_Address)); + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* If the previous operation is completed, proceed to erase the page */ + FLASH->CR |= FLASH_CR_PER; + FLASH->AR = Page_Address; + FLASH->CR |= FLASH_CR_STRT; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + /* Disable the PER Bit */ + FLASH->CR &= ~FLASH_CR_PER; + } + + /* Return the Erase Status */ + return status; +} + +/** + * @brief Erases all FLASH pages. + * @note To correctly run this function, the FLASH_Unlock() function must be called before. + * @note Call the FLASH_Lock() to disable the flash memory access (recommended + * to protect the FLASH memory against possible unwanted operation) + * @param None + * @retval FLASH Status: The returned value can be: FLASH_ERROR_PG, + * FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT. + */ +FLASH_Status FLASH_EraseAllPages(void) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* if the previous operation is completed, proceed to erase all pages */ + FLASH->CR |= FLASH_CR_MER; + FLASH->CR |= FLASH_CR_STRT; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + /* Disable the MER Bit */ + FLASH->CR &= ~FLASH_CR_MER; + } + + /* Return the Erase Status */ + return status; +} + +/** + * @brief Programs a word at a specified address. + * @note To correctly run this function, the FLASH_Unlock() function must be called before. + * @note Call the FLASH_Lock() to disable the flash memory access (recommended + * to protect the FLASH memory against possible unwanted operation) + * @param Address: specifies the address to be programmed. + * @param Data: specifies the data to be programmed. + * @retval FLASH Status: The returned value can be: FLASH_ERROR_PG, + * FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT. + */ +FLASH_Status FLASH_ProgramWord(uint32_t Address, uint32_t Data) +{ + FLASH_Status status = FLASH_COMPLETE; + __IO uint32_t tmp = 0; + + /* Check the parameters */ + assert_param(IS_FLASH_PROGRAM_ADDRESS(Address)); + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* If the previous operation is completed, proceed to program the new first + half word */ + FLASH->CR |= FLASH_CR_PG; + + *(__IO uint16_t*)Address = (uint16_t)Data; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* If the previous operation is completed, proceed to program the new second + half word */ + tmp = Address + 2; + + *(__IO uint16_t*) tmp = Data >> 16; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + /* Disable the PG Bit */ + FLASH->CR &= ~FLASH_CR_PG; + } + else + { + /* Disable the PG Bit */ + FLASH->CR &= ~FLASH_CR_PG; + } + } + + /* Return the Program Status */ + return status; +} + +/** + * @brief Programs a half word at a specified address. + * @note To correctly run this function, the FLASH_Unlock() function must be called before. + * @note Call the FLASH_Lock() to disable the flash memory access (recommended + * to protect the FLASH memory against possible unwanted operation) + * @param Address: specifies the address to be programmed. + * @param Data: specifies the data to be programmed. + * @retval FLASH Status: The returned value can be: FLASH_ERROR_PG, + * FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT. + */ +FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Check the parameters */ + assert_param(IS_FLASH_PROGRAM_ADDRESS(Address)); + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* If the previous operation is completed, proceed to program the new data */ + FLASH->CR |= FLASH_CR_PG; + + *(__IO uint16_t*)Address = Data; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + /* Disable the PG Bit */ + FLASH->CR &= ~FLASH_CR_PG; + } + + /* Return the Program Status */ + return status; +} + +/** + * @} + */ + +/** @defgroup FLASH_Group3 Option Bytes Programming functions + * @brief Option Bytes Programming functions + * +@verbatim + =============================================================================== + ##### Option Bytes Programming functions ##### + =============================================================================== + + [..] The FLASH_Option Bytes Programming_functions, includes the following functions: + (+) void FLASH_OB_Unlock(void); + (+) void FLASH_OB_Lock(void); + (+) void FLASH_OB_Launch(void); + (+) FLASH_Status FLASH_OB_Erase(void); + (+) FLASH_Status FLASH_OB_WRPConfig(uint32_t OB_WRP, FunctionalState NewState); + (+) FLASH_Status FLASH_OB_RDPConfig(uint8_t OB_RDP); + (+) FLASH_Status FLASH_OB_UserConfig(uint8_t OB_IWDG, uint8_t OB_STOP, uint8_t OB_STDBY); + (+) FLASH_Status FLASH_OB_BOOTConfig(uint8_t OB_BOOT1); + (+) FLASH_Status FLASH_OB_VDDAConfig(uint8_t OB_VDDA_ANALOG); + (+) FLASH_Status FLASH_OB_WriteUser(uint8_t OB_USER); + (+) FLASH_OB_ProgramData(uint32_t Address, uint8_t Data); + (+) uint8_t FLASH_OB_GetUser(void); + (+) uint32_t FLASH_OB_GetWRP(void); + (+) FlagStatus FLASH_OB_GetRDP(void); + + [..] Any operation of erase or program should follow these steps: + + (#) Call the FLASH_OB_Unlock() function to enable the Option Bytes registers access + + (#) Call one or several functions to program the desired option bytes + (++) FLASH_Status FLASH_OB_RDPConfig(uint8_t OB_RDP) => to set the desired read Protection Level + (++) FLASH_Status FLASH_OB_WRPConfig(uint32_t OB_WRP, FunctionalState NewState) + => to Enable/Disable the desired sector write protection + (++) FLASH_Status FLASH_OB_UserConfig(uint8_t OB_IWDG, uint8_t OB_STOP, uint8_t OB_STDBY) + => to configure the user option Bytes: IWDG, STOP and the Standby. + (++) FLASH_Status FLASH_OB_BOOTConfig(uint8_t OB_BOOT1) + => to set or reset BOOT1 + (++) FLASH_Status FLASH_OB_VDDAConfig(uint8_t OB_VDDA_ANALOG) + => to enable or disable the VDDA Analog Monitoring + (++) You can write all User Options bytes at once using a single function + by calling FLASH_Status FLASH_OB_WriteUser(uint8_t OB_USER) + (++) FLASH_OB_ProgramData(uint32_t Address, uint8_t Data) to program the + two half word in the option bytes + + (#) Once all needed option bytes to be programmed are correctly written, call the + FLASH_OB_Launch(void) function to launch the Option Bytes programming process. + + (#) Call the FLASH_OB_Lock() to disable the Option Bytes registers access (recommended + to protect the option Bytes against possible unwanted operations) + +@endverbatim + * @{ + */ + +/** + * @brief Unlocks the option bytes block access. + * @param None + * @retval None + */ +void FLASH_OB_Unlock(void) +{ + if((FLASH->CR & FLASH_CR_OPTWRE) == RESET) + { + /* Unlocking the option bytes block access */ + FLASH->OPTKEYR = FLASH_OPTKEY1; + FLASH->OPTKEYR = FLASH_OPTKEY2; + } +} + +/** + * @brief Locks the option bytes block access. + * @param None + * @retval None + */ +void FLASH_OB_Lock(void) +{ + /* Set the OPTWREN Bit to lock the option bytes block access */ + FLASH->CR &= ~FLASH_CR_OPTWRE; +} + +/** + * @brief Launch the option byte loading. + * @param None + * @retval None + */ +void FLASH_OB_Launch(void) +{ + /* Set the OBL_Launch bit to launch the option byte loading */ + FLASH->CR |= FLASH_CR_OBL_LAUNCH; +} + +/** + * @brief Erases the FLASH option bytes. + * @note To correctly run this function, the FLASH_OB_Unlock() function must be called before. + * @note Call the FLASH_OB_Lock() to disable the flash control register access and the option + * bytes (recommended to protect the FLASH memory against possible unwanted operation) + * @note This functions erases all option bytes except the Read protection (RDP). + * @param None + * @retval FLASH Status: The returned value can be: FLASH_ERROR_PG, + * FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT. + */ +FLASH_Status FLASH_OB_Erase(void) +{ + uint16_t rdptmp = OB_RDP_Level_0; + + FLASH_Status status = FLASH_COMPLETE; + + /* Get the actual read protection Option Byte value */ + if(FLASH_OB_GetRDP() != RESET) + { + rdptmp = 0x00; + } + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* If the previous operation is completed, proceed to erase the option bytes */ + FLASH->CR |= FLASH_CR_OPTER; + FLASH->CR |= FLASH_CR_STRT; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* If the erase operation is completed, disable the OPTER Bit */ + FLASH->CR &= ~FLASH_CR_OPTER; + + /* Enable the Option Bytes Programming operation */ + FLASH->CR |= FLASH_CR_OPTPG; + + /* Restore the last read protection Option Byte value */ + OB->RDP = (uint16_t)rdptmp; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status != FLASH_TIMEOUT) + { + /* if the program operation is completed, disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + else + { + if (status != FLASH_TIMEOUT) + { + /* Disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + } + /* Return the erase status */ + return status; +} + +/** + * @brief Write protects the desired pages + * @note To correctly run this function, the FLASH_OB_Unlock() function must be called before. + * @note Call the FLASH_OB_Lock() to disable the flash control register access and the option + * bytes (recommended to protect the FLASH memory against possible unwanted operation) + * @param OB_WRP: specifies the address of the pages to be write protected. + * This parameter can be: + * @arg OB_WRP_Pages0to3..OB_WRP_Pages60to63 + * @arg OB_WRP_AllPages + * @retval FLASH Status: The returned value can be: + * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT. + */ +FLASH_Status FLASH_OB_EnableWRP(uint32_t OB_WRP) +{ + uint16_t WRP0_Data = 0xFFFF, WRP1_Data = 0xFFFF, WRP2_Data = 0xFFFF, WRP3_Data = 0xFFFF; + + FLASH_Status status = FLASH_COMPLETE; + + /* Check the parameters */ + assert_param(IS_OB_WRP(OB_WRP)); + + OB_WRP = (uint32_t)(~OB_WRP); + WRP0_Data = (uint16_t)(OB_WRP & OB_WRP0_WRP0); + WRP1_Data = (uint16_t)((OB_WRP >> 8) & OB_WRP0_WRP0); + WRP2_Data = (uint16_t)((OB_WRP >> 16) & OB_WRP0_WRP0) ; + WRP3_Data = (uint16_t)((OB_WRP >> 24) & OB_WRP0_WRP0) ; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + FLASH->CR |= FLASH_CR_OPTPG; + + if(WRP0_Data != 0xFF) + { + OB->WRP0 = WRP0_Data; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + } + if((status == FLASH_COMPLETE) && (WRP1_Data != 0xFF)) + { + OB->WRP1 = WRP1_Data; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + } + if((status == FLASH_COMPLETE) && (WRP2_Data != 0xFF)) + { + OB->WRP2 = WRP2_Data; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + } + if((status == FLASH_COMPLETE) && (WRP3_Data != 0xFF)) + { + OB->WRP3 = WRP3_Data; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + } + if(status != FLASH_TIMEOUT) + { + /* if the program operation is completed, disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + /* Return the write protection operation Status */ + return status; +} + +/** + * @brief Enables or disables the read out protection. + * @note To correctly run this function, the FLASH_OB_Unlock() function must be called before. + * @note Call the FLASH_OB_Lock() to disable the flash control register access and the option + * bytes (recommended to protect the FLASH memory against possible unwanted operation) + * @param FLASH_ReadProtection_Level: specifies the read protection level. + * This parameter can be: + * @arg OB_RDP_Level_0: No protection + * @arg OB_RDP_Level_1: Read protection of the memory + * @arg OB_RDP_Level_2: Chip protection + * @note When enabling OB_RDP level 2 it's no more possible to go back to level 1 or 0 + * @retval FLASH Status: The returned value can be: + * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT. + */ +FLASH_Status FLASH_OB_RDPConfig(uint8_t OB_RDP) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Check the parameters */ + assert_param(IS_OB_RDP(OB_RDP)); + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + FLASH->CR |= FLASH_CR_OPTER; + FLASH->CR |= FLASH_CR_STRT; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* If the erase operation is completed, disable the OPTER Bit */ + FLASH->CR &= ~FLASH_CR_OPTER; + + /* Enable the Option Bytes Programming operation */ + FLASH->CR |= FLASH_CR_OPTPG; + + OB->RDP = OB_RDP; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status != FLASH_TIMEOUT) + { + /* if the program operation is completed, disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + else + { + if(status != FLASH_TIMEOUT) + { + /* Disable the OPTER Bit */ + FLASH->CR &= ~FLASH_CR_OPTER; + } + } + } + /* Return the protection operation Status */ + return status; +} + +/** + * @brief Programs the FLASH User Option Byte: IWDG_SW / RST_STOP / RST_STDBY. + * @note To correctly run this function, the FLASH_OB_Unlock() function must be called before. + * @note Call the FLASH_OB_Lock() to disable the flash control register access and the option + * bytes (recommended to protect the FLASH memory against possible unwanted operation) + * @param OB_IWDG: Selects the WDG mode + * This parameter can be one of the following values: + * @arg OB_IWDG_SW: Software WDG selected + * @arg OB_IWDG_HW: Hardware WDG selected + * @param OB_STOP: Reset event when entering STOP mode. + * This parameter can be one of the following values: + * @arg OB_STOP_NoRST: No reset generated when entering in STOP + * @arg OB_STOP_RST: Reset generated when entering in STOP + * @param OB_STDBY: Reset event when entering Standby mode. + * This parameter can be one of the following values: + * @arg OB_STDBY_NoRST: No reset generated when entering in STANDBY + * @arg OB_STDBY_RST: Reset generated when entering in STANDBY + * @retval FLASH Status: The returned value can be: + * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT. + */ +FLASH_Status FLASH_OB_UserConfig(uint8_t OB_IWDG, uint8_t OB_STOP, uint8_t OB_STDBY) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Check the parameters */ + assert_param(IS_OB_IWDG_SOURCE(OB_IWDG)); + assert_param(IS_OB_STOP_SOURCE(OB_STOP)); + assert_param(IS_OB_STDBY_SOURCE(OB_STDBY)); + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* Enable the Option Bytes Programming operation */ + FLASH->CR |= FLASH_CR_OPTPG; + + OB->USER = (uint16_t)((uint16_t)(OB_IWDG | OB_STOP) | (uint16_t)(OB_STDBY | 0xF8)); + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status != FLASH_TIMEOUT) + { + /* If the program operation is completed, disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + /* Return the Option Byte program Status */ + return status; +} + +/** + * @brief Sets or resets the BOOT1 option bit. + * @param OB_BOOT1: Set or Reset the BOOT1 option bit. + * This parameter can be one of the following values: + * @arg OB_BOOT1_RESET: BOOT1 option bit reset + * @arg OB_BOOT1_SET: BOOT1 option bit set + * @retval None + */ +FLASH_Status FLASH_OB_BOOTConfig(uint8_t OB_BOOT1) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Check the parameters */ + assert_param(IS_OB_BOOT1(OB_BOOT1)); + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* Enable the Option Bytes Programming operation */ + FLASH->CR |= FLASH_CR_OPTPG; + + OB->USER = OB_BOOT1 | 0xEF; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status != FLASH_TIMEOUT) + { + /* If the program operation is completed, disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + /* Return the Option Byte program Status */ + return status; +} + +/** + * @brief Sets or resets the BOOT0 option bit. + * @note This function is applicable only for the STM32F042 devices. + * @param OB_BOOT0: Set or Reset the BOOT0 option bit. + * This parameter can be one of the following values: + * @arg OB_BOOT0_RESET: BOOT0 option bit reset + * @arg OB_BOOT0_SET: BOOT0 option bit set + * @retval None + */ +FLASH_Status FLASH_OB_BOOT0Config(uint8_t OB_BOOT0) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Check the parameters */ + assert_param(IS_OB_BOOT0(OB_BOOT0)); + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* Enable the Option Bytes Programming operation */ + FLASH->CR |= FLASH_CR_OPTPG; + + OB->USER = OB_BOOT0 | 0xF7; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status != FLASH_TIMEOUT) + { + /* If the program operation is completed, disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + /* Return the Option Byte program Status */ + return status; +} + +/** + * @brief Sets or resets the BOOT0SW option bit. + * @note This function is applicable only for the STM32F042 devices. + * @param OB_BOOT0SW: Set or Reset the BOOT0_SW option bit. + * This parameter can be one of the following values: + * @arg OB_BOOT0_SW: BOOT0_SW option bit reset + * @arg OB_BOOT0_HW: BOOT0_SW option bit set + * @retval None + */ +FLASH_Status FLASH_OB_BOOT0SWConfig(uint8_t OB_BOOT0SW) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Check the parameters */ + assert_param(IS_OB_BOOT0SW(OB_BOOT0SW)); + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* Enable the Option Bytes Programming operation */ + FLASH->CR |= FLASH_CR_OPTPG; + + OB->USER = OB_BOOT0SW | 0x7F; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status != FLASH_TIMEOUT) + { + /* If the program operation is completed, disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + /* Return the Option Byte program Status */ + return status; +} + +/** + * @brief Sets or resets the analogue monitoring on VDDA Power source. + * @param OB_VDDA_ANALOG: Selects the analog monitoring on VDDA Power source. + * This parameter can be one of the following values: + * @arg OB_VDDA_ANALOG_ON: Analog monitoring on VDDA Power source ON + * @arg OB_VDDA_ANALOG_OFF: Analog monitoring on VDDA Power source OFF + * @retval None + */ +FLASH_Status FLASH_OB_VDDAConfig(uint8_t OB_VDDA_ANALOG) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Check the parameters */ + assert_param(IS_OB_VDDA_ANALOG(OB_VDDA_ANALOG)); + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* Enable the Option Bytes Programming operation */ + FLASH->CR |= FLASH_CR_OPTPG; + + OB->USER = OB_VDDA_ANALOG | 0xDF; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status != FLASH_TIMEOUT) + { + /* if the program operation is completed, disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + /* Return the Option Byte program Status */ + return status; +} + +/** + * @brief Sets or resets the SRAM parity. + * @param OB_SRAM_Parity: Set or Reset the SRAM parity enable bit. + * This parameter can be one of the following values: + * @arg OB_SRAM_PARITY_SET: Set SRAM parity. + * @arg OB_SRAM_PARITY_RESET: Reset SRAM parity. + * @retval None + */ +FLASH_Status FLASH_OB_SRAMParityConfig(uint8_t OB_SRAM_Parity) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Check the parameters */ + assert_param(IS_OB_SRAM_PARITY(OB_SRAM_Parity)); + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* Enable the Option Bytes Programming operation */ + FLASH->CR |= FLASH_CR_OPTPG; + + OB->USER = OB_SRAM_Parity | 0xBF; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status != FLASH_TIMEOUT) + { + /* if the program operation is completed, disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + /* Return the Option Byte program Status */ + return status; +} + +/** + * @brief Programs the FLASH User Option Byte: IWDG_SW, RST_STOP, RST_STDBY, + * BOOT1 and VDDA ANALOG monitoring. + * @note To correctly run this function, the FLASH_OB_Unlock() function must be called before. + * @note Call the FLASH_OB_Lock() to disable the flash control register access and the option + * bytes (recommended to protect the FLASH memory against possible unwanted operation) + * @param OB_USER: Selects all user option bytes + * This parameter is a combination of the following values: + * @arg OB_IWDG_SW / OB_IWDG_HW: Software / Hardware WDG selected + * @arg OB_STOP_NoRST / OB_STOP_RST: No reset / Reset generated when entering in STOP + * @arg OB_STDBY_NoRST / OB_STDBY_RST: No reset / Reset generated when entering in STANDBY + * @arg OB_BOOT1_RESET / OB_BOOT1_SET: BOOT1 Reset / Set + * @arg OB_VDDA_ANALOG_ON / OB_VDDA_ANALOG_OFF: Analog monitoring on VDDA Power source ON / OFF + * @arg OB_SRAM_PARITY_SET / OB_SRAM_PARITY_RESET: SRAM Parity SET / RESET + * @arg OB_BOOT0_RESET / OB_BOOT0_SET: BOOT0 Reset / Set + * @arg OB_BOOT0_SW / OB_BOOT0_SW: BOOT0 pin disabled / BOOT0 pin bonded with GPIO + * @retval FLASH Status: The returned value can be: + * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT. + */ +FLASH_Status FLASH_OB_WriteUser(uint8_t OB_USER) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* Enable the Option Bytes Programming operation */ + FLASH->CR |= FLASH_CR_OPTPG; + + OB->USER = OB_USER; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status != FLASH_TIMEOUT) + { + /* If the program operation is completed, disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + /* Return the Option Byte program Status */ + return status; + +} + +/** + * @brief Programs a half word at a specified Option Byte Data address. + * @note To correctly run this function, the FLASH_OB_Unlock() function must be called before. + * @note Call the FLASH_OB_Lock() to disable the flash control register access and the option + * bytes (recommended to protect the FLASH memory against possible unwanted operation) + * @param Address: specifies the address to be programmed. + * This parameter can be 0x1FFFF804 or 0x1FFFF806. + * @param Data: specifies the data to be programmed. + * @retval FLASH Status: The returned value can be: FLASH_ERROR_PG, + * FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT. + */ +FLASH_Status FLASH_OB_ProgramData(uint32_t Address, uint8_t Data) +{ + FLASH_Status status = FLASH_COMPLETE; + /* Check the parameters */ + assert_param(IS_OB_DATA_ADDRESS(Address)); + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* Enables the Option Bytes Programming operation */ + FLASH->CR |= FLASH_CR_OPTPG; + *(__IO uint16_t*)Address = Data; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status != FLASH_TIMEOUT) + { + /* If the program operation is completed, disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + /* Return the Option Byte Data Program Status */ + return status; +} + +/** + * @brief Returns the FLASH User Option Bytes values. + * @param None + * @retval The FLASH User Option Bytes . + */ +uint8_t FLASH_OB_GetUser(void) +{ + /* Return the User Option Byte */ + return (uint8_t)(FLASH->OBR >> 8); +} + +/** + * @brief Returns the FLASH Write Protection Option Bytes value. + * @param None + * @retval The FLASH Write Protection Option Bytes value + */ +uint32_t FLASH_OB_GetWRP(void) +{ + /* Return the FLASH write protection Register value */ + return (uint32_t)(FLASH->WRPR); +} + +/** + * @brief Checks whether the FLASH Read out Protection Status is set or not. + * @param None + * @retval FLASH ReadOut Protection Status(SET or RESET) + */ +FlagStatus FLASH_OB_GetRDP(void) +{ + FlagStatus readstatus = RESET; + + if ((uint8_t)(FLASH->OBR & (FLASH_OBR_RDPRT1 | FLASH_OBR_RDPRT2)) != RESET) + { + readstatus = SET; + } + else + { + readstatus = RESET; + } + return readstatus; +} + +/** + * @} + */ + +/** @defgroup FLASH_Group4 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified FLASH interrupts. + * @param FLASH_IT: specifies the FLASH interrupt sources to be enabled or + * disabled. + * This parameter can be any combination of the following values: + * @arg FLASH_IT_EOP: FLASH end of programming Interrupt + * @arg FLASH_IT_ERR: FLASH Error Interrupt + * @retval None + */ +void FLASH_ITConfig(uint32_t FLASH_IT, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FLASH_IT(FLASH_IT)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if(NewState != DISABLE) + { + /* Enable the interrupt sources */ + FLASH->CR |= FLASH_IT; + } + else + { + /* Disable the interrupt sources */ + FLASH->CR &= ~(uint32_t)FLASH_IT; + } +} + +/** + * @brief Checks whether the specified FLASH flag is set or not. + * @param FLASH_FLAG: specifies the FLASH flag to check. + * This parameter can be one of the following values: + * @arg FLASH_FLAG_BSY: FLASH write/erase operations in progress flag + * @arg FLASH_FLAG_PGERR: FLASH Programming error flag flag + * @arg FLASH_FLAG_WRPERR: FLASH Write protected error flag + * @arg FLASH_FLAG_EOP: FLASH End of Programming flag + * @retval The new state of FLASH_FLAG (SET or RESET). + */ +FlagStatus FLASH_GetFlagStatus(uint32_t FLASH_FLAG) +{ + FlagStatus bitstatus = RESET; + + /* Check the parameters */ + assert_param(IS_FLASH_GET_FLAG(FLASH_FLAG)); + + if((FLASH->SR & FLASH_FLAG) != (uint32_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + /* Return the new state of FLASH_FLAG (SET or RESET) */ + return bitstatus; +} + +/** + * @brief Clears the FLASH's pending flags. + * @param FLASH_FLAG: specifies the FLASH flags to clear. + * This parameter can be any combination of the following values: + * @arg FLASH_FLAG_PGERR: FLASH Programming error flag flag + * @arg FLASH_FLAG_WRPERR: FLASH Write protected error flag + * @arg FLASH_FLAG_EOP: FLASH End of Programming flag + * @retval None + */ +void FLASH_ClearFlag(uint32_t FLASH_FLAG) +{ + /* Check the parameters */ + assert_param(IS_FLASH_CLEAR_FLAG(FLASH_FLAG)); + + /* Clear the flags */ + FLASH->SR = FLASH_FLAG; +} + +/** + * @brief Returns the FLASH Status. + * @param None + * @retval FLASH Status: The returned value can be: + * FLASH_BUSY, FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP or FLASH_COMPLETE. + */ +FLASH_Status FLASH_GetStatus(void) +{ + FLASH_Status FLASHstatus = FLASH_COMPLETE; + + if((FLASH->SR & FLASH_FLAG_BSY) == FLASH_FLAG_BSY) + { + FLASHstatus = FLASH_BUSY; + } + else + { + if((FLASH->SR & (uint32_t)FLASH_FLAG_WRPERR)!= (uint32_t)0x00) + { + FLASHstatus = FLASH_ERROR_WRP; + } + else + { + if((FLASH->SR & (uint32_t)(FLASH_SR_PGERR)) != (uint32_t)0x00) + { + FLASHstatus = FLASH_ERROR_PROGRAM; + } + else + { + FLASHstatus = FLASH_COMPLETE; + } + } + } + /* Return the FLASH Status */ + return FLASHstatus; +} + + +/** + * @brief Waits for a FLASH operation to complete or a TIMEOUT to occur. + * @param Timeout: FLASH programming Timeout + * @retval FLASH Status: The returned value can be: FLASH_BUSY, + * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT. + */ +FLASH_Status FLASH_WaitForLastOperation(uint32_t Timeout) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Check for the FLASH Status */ + status = FLASH_GetStatus(); + + /* Wait for a FLASH operation to complete or a TIMEOUT to occur */ + while((status == FLASH_BUSY) && (Timeout != 0x00)) + { + status = FLASH_GetStatus(); + Timeout--; + } + + if(Timeout == 0x00 ) + { + status = FLASH_TIMEOUT; + } + /* Return the operation status */ + return status; +} + +/** + * @} + */ + +/** + * @} + */ + + /** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_gpio.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_gpio.c new file mode 100644 index 00000000..bb2978cd --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_gpio.c @@ -0,0 +1,542 @@ +/** + ****************************************************************************** + * @file stm32f0xx_gpio.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the GPIO peripheral: + * + Initialization and Configuration functions + * + GPIO Read and Write functions + * + GPIO Alternate functions configuration functions + * + * @verbatim + * + * + =========================================================================== + ##### How to use this driver ##### + =========================================================================== + [..] + (#) Enable the GPIO AHB clock using RCC_AHBPeriphClockCmd() + (#) Configure the GPIO pin(s) using GPIO_Init() + Four possible configuration are available for each pin: + (++) Input: Floating, Pull-up, Pull-down. + (++) Output: Push-Pull (Pull-up, Pull-down or no Pull) + Open Drain (Pull-up, Pull-down or no Pull). + In output mode, the speed is configurable: Low, Medium, Fast or High. + (++) Alternate Function: Push-Pull (Pull-up, Pull-down or no Pull) + Open Drain (Pull-up, Pull-down or no Pull). + (++) Analog: required mode when a pin is to be used as ADC channel, + DAC output or comparator input. + (#) Peripherals alternate function: + (++) For ADC, DAC and comparators, configure the desired pin in analog + mode using GPIO_InitStruct->GPIO_Mode = GPIO_Mode_AN + (++) For other peripherals (TIM, USART...): + (+++) Connect the pin to the desired peripherals' Alternate + Function (AF) using GPIO_PinAFConfig() function. For PortC, + PortD and PortF, no configuration is needed. + (+++) Configure the desired pin in alternate function mode using + GPIO_InitStruct->GPIO_Mode = GPIO_Mode_AF + (+++) Select the type, pull-up/pull-down and output speed via + GPIO_PuPd, GPIO_OType and GPIO_Speed members + (+++) Call GPIO_Init() function + (#) To get the level of a pin configured in input mode use GPIO_ReadInputDataBit() + (#) To set/reset the level of a pin configured in output mode use + GPIO_SetBits()/GPIO_ResetBits() + (#) During and just after reset, the alternate functions are not active and + the GPIO pins are configured in input floating mode (except JTAG pins). + (#) The LSE oscillator pins OSC32_IN and OSC32_OUT can be used as + general-purpose (PC14 and PC15, respectively) when the LSE oscillator + is off. The LSE has priority over the GPIO function. + (#) The HSE oscillator pins OSC_IN/OSC_OUT can be used as general-purpose + PD0 and PD1, respectively, when the HSE oscillator is off. The HSE has + priority over the GPIO function. + @endverbatim + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_gpio.h" +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup GPIO + * @brief GPIO driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup GPIO_Private_Functions + * @{ + */ + +/** @defgroup GPIO_Group1 Initialization and Configuration + * @brief Initialization and Configuration + * +@verbatim + =============================================================================== + ##### Initialization and Configuration ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the GPIOx peripheral registers to their default reset + * values. + * @param GPIOx: where x can be (A, B, C, D, E or F) to select the GPIO peripheral. + * @note GPIOE is available only for STM32F072. + * @note GPIOD is not available for STM32F031. + * @retval None + */ +void GPIO_DeInit(GPIO_TypeDef* GPIOx) +{ + /* Check the parameters */ + assert_param(IS_GPIO_ALL_PERIPH(GPIOx)); + + if(GPIOx == GPIOA) + { + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOA, ENABLE); + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOA, DISABLE); + } + else if(GPIOx == GPIOB) + { + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOB, ENABLE); + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOB, DISABLE); + } + else if(GPIOx == GPIOC) + { + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOC, ENABLE); + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOC, DISABLE); + } + else if(GPIOx == GPIOD) + { + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOD, ENABLE); + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOD, DISABLE); + } + else if(GPIOx == GPIOE) + { + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOE, ENABLE); + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOE, DISABLE); + } + else + { + if(GPIOx == GPIOF) + { + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOF, ENABLE); + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOF, DISABLE); + } + } +} + +/** + * @brief Initializes the GPIOx peripheral according to the specified + * parameters in the GPIO_InitStruct. + * @param GPIOx: where x can be (A, B, C, D, E or F) to select the GPIO peripheral. + * @note GPIOE is available only for STM32F072. + * @note GPIOD is not available for STM32F031. + * @param GPIO_InitStruct: pointer to a GPIO_InitTypeDef structure that contains + * the configuration information for the specified GPIO peripheral. + * @retval None + */ +void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct) +{ + uint32_t pinpos = 0x00, pos = 0x00 , currentpin = 0x00; + + /* Check the parameters */ + assert_param(IS_GPIO_ALL_PERIPH(GPIOx)); + assert_param(IS_GPIO_PIN(GPIO_InitStruct->GPIO_Pin)); + assert_param(IS_GPIO_MODE(GPIO_InitStruct->GPIO_Mode)); + assert_param(IS_GPIO_PUPD(GPIO_InitStruct->GPIO_PuPd)); + + /*-------------------------- Configure the port pins -----------------------*/ + /*-- GPIO Mode Configuration --*/ + for (pinpos = 0x00; pinpos < 0x10; pinpos++) + { + pos = ((uint32_t)0x01) << pinpos; + + /* Get the port pins position */ + currentpin = (GPIO_InitStruct->GPIO_Pin) & pos; + + if (currentpin == pos) + { + if ((GPIO_InitStruct->GPIO_Mode == GPIO_Mode_OUT) || (GPIO_InitStruct->GPIO_Mode == GPIO_Mode_AF)) + { + /* Check Speed mode parameters */ + assert_param(IS_GPIO_SPEED(GPIO_InitStruct->GPIO_Speed)); + + /* Speed mode configuration */ + GPIOx->OSPEEDR &= ~(GPIO_OSPEEDER_OSPEEDR0 << (pinpos * 2)); + GPIOx->OSPEEDR |= ((uint32_t)(GPIO_InitStruct->GPIO_Speed) << (pinpos * 2)); + + /* Check Output mode parameters */ + assert_param(IS_GPIO_OTYPE(GPIO_InitStruct->GPIO_OType)); + + /* Output mode configuration */ + GPIOx->OTYPER &= ~((GPIO_OTYPER_OT_0) << ((uint16_t)pinpos)); + GPIOx->OTYPER |= (uint16_t)(((uint16_t)GPIO_InitStruct->GPIO_OType) << ((uint16_t)pinpos)); + } + + GPIOx->MODER &= ~(GPIO_MODER_MODER0 << (pinpos * 2)); + + GPIOx->MODER |= (((uint32_t)GPIO_InitStruct->GPIO_Mode) << (pinpos * 2)); + + /* Pull-up Pull down resistor configuration */ + GPIOx->PUPDR &= ~(GPIO_PUPDR_PUPDR0 << ((uint16_t)pinpos * 2)); + GPIOx->PUPDR |= (((uint32_t)GPIO_InitStruct->GPIO_PuPd) << (pinpos * 2)); + } + } +} + +/** + * @brief Fills each GPIO_InitStruct member with its default value. + * @param GPIO_InitStruct: pointer to a GPIO_InitTypeDef structure which will + * be initialized. + * @retval None + */ +void GPIO_StructInit(GPIO_InitTypeDef* GPIO_InitStruct) +{ + /* Reset GPIO init structure parameters values */ + GPIO_InitStruct->GPIO_Pin = GPIO_Pin_All; + GPIO_InitStruct->GPIO_Mode = GPIO_Mode_IN; + GPIO_InitStruct->GPIO_Speed = GPIO_Speed_Level_2; + GPIO_InitStruct->GPIO_OType = GPIO_OType_PP; + GPIO_InitStruct->GPIO_PuPd = GPIO_PuPd_NOPULL; +} + +/** + * @brief Locks GPIO Pins configuration registers. + * @note The locked registers are GPIOx_MODER, GPIOx_OTYPER, GPIOx_OSPEEDR, + * GPIOx_PUPDR, GPIOx_AFRL and GPIOx_AFRH. + * @note The configuration of the locked GPIO pins can no longer be modified + * until the next device reset. + * @param GPIOx: where x can be (A or B) to select the GPIO peripheral. + * @param GPIO_Pin: specifies the port bit to be written. + * This parameter can be any combination of GPIO_Pin_x where x can be (0..15). + * @retval None + */ +void GPIO_PinLockConfig(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin) +{ + __IO uint32_t tmp = 0x00010000; + + /* Check the parameters */ + assert_param(IS_GPIO_LIST_PERIPH(GPIOx)); + assert_param(IS_GPIO_PIN(GPIO_Pin)); + + tmp |= GPIO_Pin; + /* Set LCKK bit */ + GPIOx->LCKR = tmp; + /* Reset LCKK bit */ + GPIOx->LCKR = GPIO_Pin; + /* Set LCKK bit */ + GPIOx->LCKR = tmp; + /* Read LCKK bit */ + tmp = GPIOx->LCKR; + /* Read LCKK bit */ + tmp = GPIOx->LCKR; +} + +/** + * @} + */ + +/** @defgroup GPIO_Group2 GPIO Read and Write + * @brief GPIO Read and Write + * +@verbatim + =============================================================================== + ##### GPIO Read and Write ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Reads the specified input port pin. + * @param GPIOx: where x can be (A, B, C, D, E or F) to select the GPIO peripheral. + * @note GPIOE is available only for STM32F072. + * @note GPIOD is not available for STM32F031. + * @param GPIO_Pin: specifies the port bit to read. + * @note This parameter can be GPIO_Pin_x where x can be: + * For STM32F051 and STM32F030: (0..15) for GPIOA, GPIOB, GPIOC, (2) for GPIOD and (0..1, 4..7) for GIIOF. + * For STM32F072: (0..15) for GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, (0..10) for GPIOF. + * For STM32F031: (0..15) for GPIOA, GPIOB, (13..15) for GPIOC and (0..1, 6..7) for GPIOF. + * @retval The input port pin value. + */ +uint8_t GPIO_ReadInputDataBit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin) +{ + uint8_t bitstatus = 0x00; + + /* Check the parameters */ + assert_param(IS_GPIO_ALL_PERIPH(GPIOx)); + assert_param(IS_GET_GPIO_PIN(GPIO_Pin)); + + if ((GPIOx->IDR & GPIO_Pin) != (uint32_t)Bit_RESET) + { + bitstatus = (uint8_t)Bit_SET; + } + else + { + bitstatus = (uint8_t)Bit_RESET; + } + return bitstatus; +} + +/** + * @brief Reads the specified input port pin. + * @param GPIOx: where x can be (A, B, C, D, E or F) to select the GPIO peripheral. + * @note GPIOE is available only for STM32F072. + * @note GPIOD is not available for STM32F031. + * @retval The input port pin value. + */ +uint16_t GPIO_ReadInputData(GPIO_TypeDef* GPIOx) +{ + /* Check the parameters */ + assert_param(IS_GPIO_ALL_PERIPH(GPIOx)); + + return ((uint16_t)GPIOx->IDR); +} + +/** + * @brief Reads the specified output data port bit. + * @param GPIOx: where x can be (A, B, C, D, E or F) to select the GPIO peripheral. + * @note GPIOE is available only for STM32F072. + * @note GPIOD is not available for STM32F031. + * @param GPIO_Pin: Specifies the port bit to read. + * @note This parameter can be GPIO_Pin_x where x can be: + * For STM32F051 and STM32F030: (0..15) for GPIOA, GPIOB, GPIOC, (2) for GPIOD and (0..1, 4..7) for GIIOF. + * For STM32F072: (0..15) for GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, (0..10) for GPIOF. + * For STM32F031: (0..15) for GPIOA, GPIOB, (13..15) for GPIOC and (0..1, 6..7) for GPIOF. + * @retval The output port pin value. + */ +uint8_t GPIO_ReadOutputDataBit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin) +{ + uint8_t bitstatus = 0x00; + + /* Check the parameters */ + assert_param(IS_GPIO_ALL_PERIPH(GPIOx)); + assert_param(IS_GET_GPIO_PIN(GPIO_Pin)); + + if ((GPIOx->ODR & GPIO_Pin) != (uint32_t)Bit_RESET) + { + bitstatus = (uint8_t)Bit_SET; + } + else + { + bitstatus = (uint8_t)Bit_RESET; + } + return bitstatus; +} + +/** + * @brief Reads the specified GPIO output data port. + * @param GPIOx: where x can be (A, B, C, D, E or F) to select the GPIO peripheral. + * @note GPIOE is available only for STM32F072. + * @note GPIOD is not available for STM32F031. + * @retval GPIO output data port value. + */ +uint16_t GPIO_ReadOutputData(GPIO_TypeDef* GPIOx) +{ + /* Check the parameters */ + assert_param(IS_GPIO_ALL_PERIPH(GPIOx)); + + return ((uint16_t)GPIOx->ODR); +} + +/** + * @brief Sets the selected data port bits. + * @param GPIOx: where x can be (A, B, C, D, E or F) to select the GPIO peripheral. + * @note GPIOE is available only for STM32F072. + * @note GPIOD is not available for STM32F031. + * @param GPIO_Pin: specifies the port bits to be written. + * @note This parameter can be GPIO_Pin_x where x can be: + * For STM32F051 and STM32F030: (0..15) for GPIOA, GPIOB, GPIOC, (2) for GPIOD and (0..1, 4..7) for GIIOF. + * For STM32F072: (0..15) for GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, (0..10) for GPIOF. + * For STM32F031: (0..15) for GPIOA, GPIOB, (13..15) for GPIOC and (0..1, 6..7) for GPIOF. + * @retval None + */ +void GPIO_SetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin) +{ + /* Check the parameters */ + assert_param(IS_GPIO_ALL_PERIPH(GPIOx)); + assert_param(IS_GPIO_PIN(GPIO_Pin)); + + GPIOx->BSRR = GPIO_Pin; +} + +/** + * @brief Clears the selected data port bits. + * @param GPIOx: where x can be (A, B, C, D, E or F) to select the GPIO peripheral. + * @note GPIOE is available only for STM32F072. + * @note GPIOD is not available for STM32F031. + * @param GPIO_Pin: specifies the port bits to be written. + * @note This parameter can be GPIO_Pin_x where x can be: + * For STM32F051 and STM32F030: (0..15) for GPIOA, GPIOB, GPIOC, (2) for GPIOD and (0..1, 4..7) for GIIOF. + * For STM32F072: (0..15) for GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, (0..10) for GPIOF. + * For STM32F031: (0..15) for GPIOA, GPIOB, (13..15) for GPIOC and (0..1, 6..7) for GPIOF. + * @retval None + */ +void GPIO_ResetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin) +{ + /* Check the parameters */ + assert_param(IS_GPIO_ALL_PERIPH(GPIOx)); + assert_param(IS_GPIO_PIN(GPIO_Pin)); + + GPIOx->BRR = GPIO_Pin; +} + +/** + * @brief Sets or clears the selected data port bit. + * @param GPIOx: where x can be (A, B, C, D, E or F) to select the GPIO peripheral. + * @note GPIOE is available only for STM32F072. + * @note GPIOD is not available for STM32F031. + * @param GPIO_Pin: specifies the port bit to be written. + * @param BitVal: specifies the value to be written to the selected bit. + * This parameter can be one of the BitAction enumeration values: + * @arg Bit_RESET: to clear the port pin + * @arg Bit_SET: to set the port pin + * @note This parameter can be GPIO_Pin_x where x can be: + * For STM32F051 and STM32F030: (0..15) for GPIOA, GPIOB, GPIOC, (2) for GPIOD and (0..1, 4..7) for GIIOF. + * For STM32F072: (0..15) for GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, (0..10) for GPIOF. + * For STM32F031: (0..15) for GPIOA, GPIOB, (13..15) for GPIOC and (0..1, 6..7) for GPIOF. + * @retval None + */ +void GPIO_WriteBit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, BitAction BitVal) +{ + /* Check the parameters */ + assert_param(IS_GPIO_ALL_PERIPH(GPIOx)); + assert_param(IS_GET_GPIO_PIN(GPIO_Pin)); + assert_param(IS_GPIO_BIT_ACTION(BitVal)); + + if (BitVal != Bit_RESET) + { + GPIOx->BSRR = GPIO_Pin; + } + else + { + GPIOx->BRR = GPIO_Pin ; + } +} + +/** + * @brief Writes data to the specified GPIO data port. + * @param GPIOx: where x can be (A, B, C, D, E or F) to select the GPIO peripheral. + * @note GPIOE is available only for STM32F072. + * @note GPIOD is not available for STM32F031. + * @param PortVal: specifies the value to be written to the port output data register. + * @retval None + */ +void GPIO_Write(GPIO_TypeDef* GPIOx, uint16_t PortVal) +{ + /* Check the parameters */ + assert_param(IS_GPIO_ALL_PERIPH(GPIOx)); + + GPIOx->ODR = PortVal; +} + +/** + * @} + */ + +/** @defgroup GPIO_Group3 GPIO Alternate functions configuration functions + * @brief GPIO Alternate functions configuration functions + * +@verbatim + =============================================================================== + ##### GPIO Alternate functions configuration functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Writes data to the specified GPIO data port. + * @param GPIOx: where x can be (A, B, C, D, E or F) to select the GPIO peripheral. + * @note GPIOC, GPIOD, GPIOE and GPIOF are available only for STM32F072 and STM32F091. + * @param GPIO_PinSource: specifies the pin for the Alternate function. + * This parameter can be GPIO_PinSourcex where x can be (0..15) for GPIOA, GPIOB, GPIOD, GPIOE + * and (0..12) for GPIOC and (0, 2..5, 9..10) for GPIOF. + * @param GPIO_AF: selects the pin to used as Alternate function. + * This parameter can be one of the following value: + * @arg GPIO_AF_0: WKUP, EVENTOUT, TIM15, SPI1, TIM17, MCO, SWDAT, SWCLK, + * TIM14, BOOT, USART1, CEC, IR_OUT, SPI2, TIM3, USART4, + * CAN, USART2, CRS, TIM16, TIM1, TS, USART8 + * @arg GPIO_AF_1: USART2, CEC, TIM3, USART1, USART2, EVENTOUT, I2C1, + * I2C2, TIM15, SPI2, USART3, TS, SPI1, USART7, USART8 + * USART5, USART4, USART6, I2C1 + * @arg GPIO_AF_2: TIM2, TIM1, EVENTOUT, TIM16, TIM17, USB, USART6, USART5, + * USART8, USART7, USART6 + * @arg GPIO_AF_3: TS, I2C1, TIM15, EVENTOUT + * @arg GPIO_AF_4: TIM14, USART4, USART3, CRS, CAN, I2C1, USART5 + * @arg GPIO_AF_5: TIM16, TIM17, TIM15, SPI2, I2C2, USART6, MCO + * @arg GPIO_AF_6: EVENTOUT + * @arg GPIO_AF_7: COMP1 OUT, COMP2 OUT + * @note The pin should already been configured in Alternate Function mode(AF) + * using GPIO_InitStruct->GPIO_Mode = GPIO_Mode_AF + * @note Refer to the Alternate function mapping table in the device datasheet + * for the detailed mapping of the system and peripherals'alternate + * function I/O pins. + * @retval None + */ +void GPIO_PinAFConfig(GPIO_TypeDef* GPIOx, uint16_t GPIO_PinSource, uint8_t GPIO_AF) +{ + uint32_t temp = 0x00; + uint32_t temp_2 = 0x00; + + /* Check the parameters */ + assert_param(IS_GPIO_ALL_PERIPH(GPIOx)); + assert_param(IS_GPIO_PIN_SOURCE(GPIO_PinSource)); + assert_param(IS_GPIO_AF(GPIO_AF)); + + temp = ((uint32_t)(GPIO_AF) << ((uint32_t)((uint32_t)GPIO_PinSource & (uint32_t)0x07) * 4)); + GPIOx->AFR[GPIO_PinSource >> 0x03] &= ~((uint32_t)0xF << ((uint32_t)((uint32_t)GPIO_PinSource & (uint32_t)0x07) * 4)); + temp_2 = GPIOx->AFR[GPIO_PinSource >> 0x03] | temp; + GPIOx->AFR[GPIO_PinSource >> 0x03] = temp_2; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_i2c.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_i2c.c new file mode 100644 index 00000000..d4138e3c --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_i2c.c @@ -0,0 +1,1585 @@ +/** + ****************************************************************************** + * @file stm32f0xx_i2c.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Inter-Integrated circuit (I2C): + * + Initialization and Configuration + * + Communications handling + * + SMBUS management + * + I2C registers management + * + Data transfers management + * + DMA transfers management + * + Interrupts and flags management + * + * @verbatim + ============================================================================ + ##### How to use this driver ##### + ============================================================================ + [..] + (#) Enable peripheral clock using RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2Cx, ENABLE) + function for I2C1 or I2C2. + (#) Enable SDA, SCL and SMBA (when used) GPIO clocks using + RCC_AHBPeriphClockCmd() function. + (#) Peripherals alternate function: + (++) Connect the pin to the desired peripherals' Alternate + Function (AF) using GPIO_PinAFConfig() function. + (++) Configure the desired pin in alternate function by: + GPIO_InitStruct->GPIO_Mode = GPIO_Mode_AF + (++) Select the type, OpenDrain and speed via + GPIO_PuPd, GPIO_OType and GPIO_Speed members + (++) Call GPIO_Init() function. + (#) Program the Mode, Timing , Own address, Ack and Acknowledged Address + using the I2C_Init() function. + (#) Optionally you can enable/configure the following parameters without + re-initialization (i.e there is no need to call again I2C_Init() function): + (++) Enable the acknowledge feature using I2C_AcknowledgeConfig() function. + (++) Enable the dual addressing mode using I2C_DualAddressCmd() function. + (++) Enable the general call using the I2C_GeneralCallCmd() function. + (++) Enable the clock stretching using I2C_StretchClockCmd() function. + (++) Enable the PEC Calculation using I2C_CalculatePEC() function. + (++) For SMBus Mode: + (+++) Enable the SMBusAlert pin using I2C_SMBusAlertCmd() function. + (#) Enable the NVIC and the corresponding interrupt using the function + I2C_ITConfig() if you need to use interrupt mode. + (#) When using the DMA mode + (++) Configure the DMA using DMA_Init() function. + (++) Active the needed channel Request using I2C_DMACmd() function. + (#) Enable the I2C using the I2C_Cmd() function. + (#) Enable the DMA using the DMA_Cmd() function when using DMA mode in the + transfers. + [..] + (@) When using I2C in Fast Mode Plus, SCL and SDA pin 20mA current drive capability + must be enabled by setting the driving capability control bit in SYSCFG. + + @endverbatim + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_i2c.h" +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup I2C + * @brief I2C driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ + +#define CR1_CLEAR_MASK ((uint32_t)0x00CFE0FF) /*I2C_AnalogFilter)); + assert_param(IS_I2C_DIGITAL_FILTER(I2C_InitStruct->I2C_DigitalFilter)); + assert_param(IS_I2C_MODE(I2C_InitStruct->I2C_Mode)); + assert_param(IS_I2C_OWN_ADDRESS1(I2C_InitStruct->I2C_OwnAddress1)); + assert_param(IS_I2C_ACK(I2C_InitStruct->I2C_Ack)); + assert_param(IS_I2C_ACKNOWLEDGE_ADDRESS(I2C_InitStruct->I2C_AcknowledgedAddress)); + + /* Disable I2Cx Peripheral */ + I2Cx->CR1 &= (uint32_t)~((uint32_t)I2C_CR1_PE); + + /*---------------------------- I2Cx FILTERS Configuration ------------------*/ + /* Get the I2Cx CR1 value */ + tmpreg = I2Cx->CR1; + /* Clear I2Cx CR1 register */ + tmpreg &= CR1_CLEAR_MASK; + /* Configure I2Cx: analog and digital filter */ + /* Set ANFOFF bit according to I2C_AnalogFilter value */ + /* Set DFN bits according to I2C_DigitalFilter value */ + tmpreg |= (uint32_t)I2C_InitStruct->I2C_AnalogFilter |(I2C_InitStruct->I2C_DigitalFilter << 8); + + /* Write to I2Cx CR1 */ + I2Cx->CR1 = tmpreg; + + /*---------------------------- I2Cx TIMING Configuration -------------------*/ + /* Configure I2Cx: Timing */ + /* Set TIMINGR bits according to I2C_Timing */ + /* Write to I2Cx TIMING */ + I2Cx->TIMINGR = I2C_InitStruct->I2C_Timing & TIMING_CLEAR_MASK; + + /* Enable I2Cx Peripheral */ + I2Cx->CR1 |= I2C_CR1_PE; + + /*---------------------------- I2Cx OAR1 Configuration ---------------------*/ + /* Clear tmpreg local variable */ + tmpreg = 0; + /* Clear OAR1 register */ + I2Cx->OAR1 = (uint32_t)tmpreg; + /* Clear OAR2 register */ + I2Cx->OAR2 = (uint32_t)tmpreg; + /* Configure I2Cx: Own Address1 and acknowledged address */ + /* Set OA1MODE bit according to I2C_AcknowledgedAddress value */ + /* Set OA1 bits according to I2C_OwnAddress1 value */ + tmpreg = (uint32_t)((uint32_t)I2C_InitStruct->I2C_AcknowledgedAddress | \ + (uint32_t)I2C_InitStruct->I2C_OwnAddress1); + /* Write to I2Cx OAR1 */ + I2Cx->OAR1 = tmpreg; + /* Enable Own Address1 acknowledgement */ + I2Cx->OAR1 |= I2C_OAR1_OA1EN; + + /*---------------------------- I2Cx MODE Configuration ---------------------*/ + /* Configure I2Cx: mode */ + /* Set SMBDEN and SMBHEN bits according to I2C_Mode value */ + tmpreg = I2C_InitStruct->I2C_Mode; + /* Write to I2Cx CR1 */ + I2Cx->CR1 |= tmpreg; + + /*---------------------------- I2Cx ACK Configuration ----------------------*/ + /* Get the I2Cx CR2 value */ + tmpreg = I2Cx->CR2; + /* Clear I2Cx CR2 register */ + tmpreg &= CR2_CLEAR_MASK; + /* Configure I2Cx: acknowledgement */ + /* Set NACK bit according to I2C_Ack value */ + tmpreg |= I2C_InitStruct->I2C_Ack; + /* Write to I2Cx CR2 */ + I2Cx->CR2 = tmpreg; +} + +/** + * @brief Fills each I2C_InitStruct member with its default value. + * @param I2C_InitStruct: pointer to an I2C_InitTypeDef structure which will be initialized. + * @retval None + */ +void I2C_StructInit(I2C_InitTypeDef* I2C_InitStruct) +{ + /*---------------- Reset I2C init structure parameters values --------------*/ + /* Initialize the I2C_Timing member */ + I2C_InitStruct->I2C_Timing = 0; + /* Initialize the I2C_AnalogFilter member */ + I2C_InitStruct->I2C_AnalogFilter = I2C_AnalogFilter_Enable; + /* Initialize the I2C_DigitalFilter member */ + I2C_InitStruct->I2C_DigitalFilter = 0; + /* Initialize the I2C_Mode member */ + I2C_InitStruct->I2C_Mode = I2C_Mode_I2C; + /* Initialize the I2C_OwnAddress1 member */ + I2C_InitStruct->I2C_OwnAddress1 = 0; + /* Initialize the I2C_Ack member */ + I2C_InitStruct->I2C_Ack = I2C_Ack_Disable; + /* Initialize the I2C_AcknowledgedAddress member */ + I2C_InitStruct->I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit; +} + +/** + * @brief Enables or disables the specified I2C peripheral. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the I2Cx peripheral. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_Cmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + if (NewState != DISABLE) + { + /* Enable the selected I2C peripheral */ + I2Cx->CR1 |= I2C_CR1_PE; + } + else + { + /* Disable the selected I2C peripheral */ + I2Cx->CR1 &= (uint32_t)~((uint32_t)I2C_CR1_PE); + } +} + +/** + * @brief Enables or disables the specified I2C software reset. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @retval None + */ +void I2C_SoftwareResetCmd(I2C_TypeDef* I2Cx) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + + /* Disable peripheral */ + I2Cx->CR1 &= (uint32_t)~((uint32_t)I2C_CR1_PE); + + /* Perform a dummy read to delay the disable of peripheral for minimum + 3 APB clock cycles to perform the software reset functionality */ + *(__IO uint32_t *)(uint32_t)I2Cx; + + /* Enable peripheral */ + I2Cx->CR1 |= I2C_CR1_PE; +} + +/** + * @brief Enables or disables the specified I2C interrupts. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param I2C_IT: specifies the I2C interrupts sources to be enabled or disabled. + * This parameter can be any combination of the following values: + * @arg I2C_IT_ERRI: Error interrupt mask + * @arg I2C_IT_TCI: Transfer Complete interrupt mask + * @arg I2C_IT_STOPI: Stop Detection interrupt mask + * @arg I2C_IT_NACKI: Not Acknowledge received interrupt mask + * @arg I2C_IT_ADDRI: Address Match interrupt mask + * @arg I2C_IT_RXI: RX interrupt mask + * @arg I2C_IT_TXI: TX interrupt mask + * @param NewState: new state of the specified I2C interrupts. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_ITConfig(I2C_TypeDef* I2Cx, uint32_t I2C_IT, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + assert_param(IS_I2C_CONFIG_IT(I2C_IT)); + + if (NewState != DISABLE) + { + /* Enable the selected I2C interrupts */ + I2Cx->CR1 |= I2C_IT; + } + else + { + /* Disable the selected I2C interrupts */ + I2Cx->CR1 &= (uint32_t)~((uint32_t)I2C_IT); + } +} + +/** + * @brief Enables or disables the I2C Clock stretching. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the I2Cx Clock stretching. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_StretchClockCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable clock stretching */ + I2Cx->CR1 &= (uint32_t)~((uint32_t)I2C_CR1_NOSTRETCH); + } + else + { + /* Disable clock stretching */ + I2Cx->CR1 |= I2C_CR1_NOSTRETCH; + } +} + +/** + * @brief Enables or disables I2C wakeup from stop mode. + * This function is not applicable for STM32F030 devices. + * @param I2Cx: where x can be 1 to select the I2C peripheral. + * @param NewState: new state of the I2Cx stop mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_StopModeCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_1_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable wakeup from stop mode */ + I2Cx->CR1 |= I2C_CR1_WUPEN; + } + else + { + /* Disable wakeup from stop mode */ + I2Cx->CR1 &= (uint32_t)~((uint32_t)I2C_CR1_WUPEN); + } +} + +/** + * @brief Enables or disables the I2C own address 2. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the I2C own address 2. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_DualAddressCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable own address 2 */ + I2Cx->OAR2 |= I2C_OAR2_OA2EN; + } + else + { + /* Disable own address 2 */ + I2Cx->OAR2 &= (uint32_t)~((uint32_t)I2C_OAR2_OA2EN); + } +} + +/** + * @brief Configures the I2C slave own address 2 and mask. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param Address: specifies the slave address to be programmed. + * @param Mask: specifies own address 2 mask to be programmed. + * This parameter can be one of the following values: + * @arg I2C_OA2_NoMask: no mask. + * @arg I2C_OA2_Mask01: OA2[1] is masked and don't care. + * @arg I2C_OA2_Mask02: OA2[2:1] are masked and don't care. + * @arg I2C_OA2_Mask03: OA2[3:1] are masked and don't care. + * @arg I2C_OA2_Mask04: OA2[4:1] are masked and don't care. + * @arg I2C_OA2_Mask05: OA2[5:1] are masked and don't care. + * @arg I2C_OA2_Mask06: OA2[6:1] are masked and don't care. + * @arg I2C_OA2_Mask07: OA2[7:1] are masked and don't care. + * @retval None + */ +void I2C_OwnAddress2Config(I2C_TypeDef* I2Cx, uint16_t Address, uint8_t Mask) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_I2C_OWN_ADDRESS2(Address)); + assert_param(IS_I2C_OWN_ADDRESS2_MASK(Mask)); + + /* Get the old register value */ + tmpreg = I2Cx->OAR2; + + /* Reset I2Cx OA2 bit [7:1] and OA2MSK bit [1:0] */ + tmpreg &= (uint32_t)~((uint32_t)(I2C_OAR2_OA2 | I2C_OAR2_OA2MSK)); + + /* Set I2Cx SADD */ + tmpreg |= (uint32_t)(((uint32_t)Address & I2C_OAR2_OA2) | \ + (((uint32_t)Mask << 8) & I2C_OAR2_OA2MSK)) ; + + /* Store the new register value */ + I2Cx->OAR2 = tmpreg; +} + +/** + * @brief Enables or disables the I2C general call mode. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the I2C general call mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_GeneralCallCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable general call mode */ + I2Cx->CR1 |= I2C_CR1_GCEN; + } + else + { + /* Disable general call mode */ + I2Cx->CR1 &= (uint32_t)~((uint32_t)I2C_CR1_GCEN); + } +} + +/** + * @brief Enables or disables the I2C slave byte control. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the I2C slave byte control. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_SlaveByteControlCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable slave byte control */ + I2Cx->CR1 |= I2C_CR1_SBC; + } + else + { + /* Disable slave byte control */ + I2Cx->CR1 &= (uint32_t)~((uint32_t)I2C_CR1_SBC); + } +} + +/** + * @brief Configures the slave address to be transmitted after start generation. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param Address: specifies the slave address to be programmed. + * @note This function should be called before generating start condition. + * @retval None + */ +void I2C_SlaveAddressConfig(I2C_TypeDef* I2Cx, uint16_t Address) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_I2C_SLAVE_ADDRESS(Address)); + + /* Get the old register value */ + tmpreg = I2Cx->CR2; + + /* Reset I2Cx SADD bit [9:0] */ + tmpreg &= (uint32_t)~((uint32_t)I2C_CR2_SADD); + + /* Set I2Cx SADD */ + tmpreg |= (uint32_t)((uint32_t)Address & I2C_CR2_SADD); + + /* Store the new register value */ + I2Cx->CR2 = tmpreg; +} + +/** + * @brief Enables or disables the I2C 10-bit addressing mode for the master. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the I2C 10-bit addressing mode. + * This parameter can be: ENABLE or DISABLE. + * @note This function should be called before generating start condition. + * @retval None + */ +void I2C_10BitAddressingModeCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable 10-bit addressing mode */ + I2Cx->CR2 |= I2C_CR2_ADD10; + } + else + { + /* Disable 10-bit addressing mode */ + I2Cx->CR2 &= (uint32_t)~((uint32_t)I2C_CR2_ADD10); + } +} + +/** + * @} + */ + + +/** @defgroup I2C_Group2 Communications handling functions + * @brief Communications handling functions + * +@verbatim + =============================================================================== + ##### Communications handling functions ##### + =============================================================================== + [..] This section provides a set of functions that handles I2C communication. + + [..] Automatic End mode is enabled using I2C_AutoEndCmd() function. When Reload + mode is enabled via I2C_ReloadCmd() AutoEnd bit has no effect. + + [..] I2C_NumberOfBytesConfig() function set the number of bytes to be transferred, + this configuration should be done before generating start condition in master + mode. + + [..] When switching from master write operation to read operation in 10Bit addressing + mode, master can only sends the 1st 7 bits of the 10 bit address, followed by + Read direction by enabling HEADR bit using I2C_10BitAddressHeader() function. + + [..] In master mode, when transferring more than 255 bytes Reload mode should be used + to handle communication. In the first phase of transfer, Nbytes should be set to + 255. After transferring these bytes TCR flag is set and I2C_TransferHandling() + function should be called to handle remaining communication. + + [..] In master mode, when software end mode is selected when all data is transferred + TC flag is set I2C_TransferHandling() function should be called to generate STOP + or generate ReStart. + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the I2C automatic end mode (stop condition is + * automatically sent when nbytes data are transferred). + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the I2C automatic end mode. + * This parameter can be: ENABLE or DISABLE. + * @note This function has effect if Reload mode is disabled. + * @retval None + */ +void I2C_AutoEndCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable Auto end mode */ + I2Cx->CR2 |= I2C_CR2_AUTOEND; + } + else + { + /* Disable Auto end mode */ + I2Cx->CR2 &= (uint32_t)~((uint32_t)I2C_CR2_AUTOEND); + } +} + +/** + * @brief Enables or disables the I2C nbytes reload mode. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the nbytes reload mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_ReloadCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable Auto Reload mode */ + I2Cx->CR2 |= I2C_CR2_RELOAD; + } + else + { + /* Disable Auto Reload mode */ + I2Cx->CR2 &= (uint32_t)~((uint32_t)I2C_CR2_RELOAD); + } +} + +/** + * @brief Configures the number of bytes to be transmitted/received. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param Number_Bytes: specifies the number of bytes to be programmed. + * @retval None + */ +void I2C_NumberOfBytesConfig(I2C_TypeDef* I2Cx, uint8_t Number_Bytes) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + + /* Get the old register value */ + tmpreg = I2Cx->CR2; + + /* Reset I2Cx Nbytes bit [7:0] */ + tmpreg &= (uint32_t)~((uint32_t)I2C_CR2_NBYTES); + + /* Set I2Cx Nbytes */ + tmpreg |= (uint32_t)(((uint32_t)Number_Bytes << 16 ) & I2C_CR2_NBYTES); + + /* Store the new register value */ + I2Cx->CR2 = tmpreg; +} + +/** + * @brief Configures the type of transfer request for the master. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param I2C_Direction: specifies the transfer request direction to be programmed. + * This parameter can be one of the following values: + * @arg I2C_Direction_Transmitter: Master request a write transfer + * @arg I2C_Direction_Receiver: Master request a read transfer + * @retval None + */ +void I2C_MasterRequestConfig(I2C_TypeDef* I2Cx, uint16_t I2C_Direction) +{ +/* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_I2C_DIRECTION(I2C_Direction)); + + /* Test on the direction to set/reset the read/write bit */ + if (I2C_Direction == I2C_Direction_Transmitter) + { + /* Request a write Transfer */ + I2Cx->CR2 &= (uint32_t)~((uint32_t)I2C_CR2_RD_WRN); + } + else + { + /* Request a read Transfer */ + I2Cx->CR2 |= I2C_CR2_RD_WRN; + } +} + +/** + * @brief Generates I2Cx communication START condition. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the I2C START condition generation. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_GenerateSTART(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Generate a START condition */ + I2Cx->CR2 |= I2C_CR2_START; + } + else + { + /* Disable the START condition generation */ + I2Cx->CR2 &= (uint32_t)~((uint32_t)I2C_CR2_START); + } +} + +/** + * @brief Generates I2Cx communication STOP condition. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the I2C STOP condition generation. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_GenerateSTOP(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Generate a STOP condition */ + I2Cx->CR2 |= I2C_CR2_STOP; + } + else + { + /* Disable the STOP condition generation */ + I2Cx->CR2 &= (uint32_t)~((uint32_t)I2C_CR2_STOP); + } +} + +/** + * @brief Enables or disables the I2C 10-bit header only mode with read direction. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the I2C 10-bit header only mode. + * This parameter can be: ENABLE or DISABLE. + * @note This mode can be used only when switching from master transmitter mode + * to master receiver mode. + * @retval None + */ +void I2C_10BitAddressHeaderCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable 10-bit header only mode */ + I2Cx->CR2 |= I2C_CR2_HEAD10R; + } + else + { + /* Disable 10-bit header only mode */ + I2Cx->CR2 &= (uint32_t)~((uint32_t)I2C_CR2_HEAD10R); + } +} + +/** + * @brief Generates I2C communication Acknowledge. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the Acknowledge. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_AcknowledgeConfig(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable ACK generation */ + I2Cx->CR2 &= (uint32_t)~((uint32_t)I2C_CR2_NACK); + } + else + { + /* Enable NACK generation */ + I2Cx->CR2 |= I2C_CR2_NACK; + } +} + +/** + * @brief Returns the I2C slave matched address . + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @retval The value of the slave matched address . + */ +uint8_t I2C_GetAddressMatched(I2C_TypeDef* I2Cx) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + + /* Return the slave matched address in the SR1 register */ + return (uint8_t)(((uint32_t)I2Cx->ISR & I2C_ISR_ADDCODE) >> 16) ; +} + +/** + * @brief Returns the I2C slave received request. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @retval The value of the received request. + */ +uint16_t I2C_GetTransferDirection(I2C_TypeDef* I2Cx) +{ + uint32_t tmpreg = 0; + uint16_t direction = 0; + + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + + /* Return the slave matched address in the SR1 register */ + tmpreg = (uint32_t)(I2Cx->ISR & I2C_ISR_DIR); + + /* If write transfer is requested */ + if (tmpreg == 0) + { + /* write transfer is requested */ + direction = I2C_Direction_Transmitter; + } + else + { + /* Read transfer is requested */ + direction = I2C_Direction_Receiver; + } + return direction; +} + +/** + * @brief Handles I2Cx communication when starting transfer or during transfer (TC or TCR flag are set). + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param Address: specifies the slave address to be programmed. + * @param Number_Bytes: specifies the number of bytes to be programmed. + * This parameter must be a value between 0 and 255. + * @param ReloadEndMode: new state of the I2C START condition generation. + * This parameter can be one of the following values: + * @arg I2C_Reload_Mode: Enable Reload mode . + * @arg I2C_AutoEnd_Mode: Enable Automatic end mode. + * @arg I2C_SoftEnd_Mode: Enable Software end mode. + * @param StartStopMode: new state of the I2C START condition generation. + * This parameter can be one of the following values: + * @arg I2C_No_StartStop: Don't Generate stop and start condition. + * @arg I2C_Generate_Stop: Generate stop condition (Number_Bytes should be set to 0). + * @arg I2C_Generate_Start_Read: Generate Restart for read request. + * @arg I2C_Generate_Start_Write: Generate Restart for write request. + * @retval None + */ +void I2C_TransferHandling(I2C_TypeDef* I2Cx, uint16_t Address, uint8_t Number_Bytes, uint32_t ReloadEndMode, uint32_t StartStopMode) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_I2C_SLAVE_ADDRESS(Address)); + assert_param(IS_RELOAD_END_MODE(ReloadEndMode)); + assert_param(IS_START_STOP_MODE(StartStopMode)); + + /* Get the CR2 register value */ + tmpreg = I2Cx->CR2; + + /* clear tmpreg specific bits */ + tmpreg &= (uint32_t)~((uint32_t)(I2C_CR2_SADD | I2C_CR2_NBYTES | I2C_CR2_RELOAD | I2C_CR2_AUTOEND | I2C_CR2_RD_WRN | I2C_CR2_START | I2C_CR2_STOP)); + + /* update tmpreg */ + tmpreg |= (uint32_t)(((uint32_t)Address & I2C_CR2_SADD) | (((uint32_t)Number_Bytes << 16 ) & I2C_CR2_NBYTES) | \ + (uint32_t)ReloadEndMode | (uint32_t)StartStopMode); + + /* update CR2 register */ + I2Cx->CR2 = tmpreg; +} + +/** + * @} + */ + + +/** @defgroup I2C_Group3 SMBUS management functions + * @brief SMBUS management functions + * +@verbatim + =============================================================================== + ##### SMBUS management functions ##### + =============================================================================== + [..] This section provides a set of functions that handles SMBus communication + and timeouts detection. + + [..] The SMBus Device default address (0b1100 001) is enabled by calling I2C_Init() + function and setting I2C_Mode member of I2C_InitTypeDef() structure to + I2C_Mode_SMBusDevice. + + [..] The SMBus Host address (0b0001 000) is enabled by calling I2C_Init() + function and setting I2C_Mode member of I2C_InitTypeDef() structure to + I2C_Mode_SMBusHost. + + [..] The Alert Response Address (0b0001 100) is enabled using I2C_SMBusAlertCmd() + function. + + [..] To detect cumulative SCL stretch in master and slave mode, TIMEOUTB should be + configured (in accordance to SMBus specification) using I2C_TimeoutBConfig() + function then I2C_ExtendedClockTimeoutCmd() function should be called to enable + the detection. + + [..] SCL low timeout is detected by configuring TIMEOUTB using I2C_TimeoutBConfig() + function followed by the call of I2C_ClockTimeoutCmd(). When adding to this + procedure the call of I2C_IdleClockTimeoutCmd() function, Bus Idle condition + (both SCL and SDA high) is detected also. + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables I2C SMBus alert. + * @param I2Cx: where x can be 1 to select the I2C peripheral. + * @param NewState: new state of the I2Cx SMBus alert. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_SMBusAlertCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_1_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable SMBus alert */ + I2Cx->CR1 |= I2C_CR1_ALERTEN; + } + else + { + /* Disable SMBus alert */ + I2Cx->CR1 &= (uint32_t)~((uint32_t)I2C_CR1_ALERTEN); + } +} + +/** + * @brief Enables or disables I2C Clock Timeout (SCL Timeout detection). + * @param I2Cx: where x can be 1 to select the I2C peripheral. + * @param NewState: new state of the I2Cx clock Timeout. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_ClockTimeoutCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_1_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable Clock Timeout */ + I2Cx->TIMEOUTR |= I2C_TIMEOUTR_TIMOUTEN; + } + else + { + /* Disable Clock Timeout */ + I2Cx->TIMEOUTR &= (uint32_t)~((uint32_t)I2C_TIMEOUTR_TIMOUTEN); + } +} + +/** + * @brief Enables or disables I2C Extended Clock Timeout (SCL cumulative Timeout detection). + * @param I2Cx: where x can be 1 to select the I2C peripheral. + * @param NewState: new state of the I2Cx Extended clock Timeout. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_ExtendedClockTimeoutCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_1_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable Clock Timeout */ + I2Cx->TIMEOUTR |= I2C_TIMEOUTR_TEXTEN; + } + else + { + /* Disable Clock Timeout */ + I2Cx->TIMEOUTR &= (uint32_t)~((uint32_t)I2C_TIMEOUTR_TEXTEN); + } +} + +/** + * @brief Enables or disables I2C Idle Clock Timeout (Bus idle SCL and SDA + * high detection). + * @param I2Cx: where x can be 1 to select the I2C peripheral. + * @param NewState: new state of the I2Cx Idle clock Timeout. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_IdleClockTimeoutCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_1_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable Clock Timeout */ + I2Cx->TIMEOUTR |= I2C_TIMEOUTR_TIDLE; + } + else + { + /* Disable Clock Timeout */ + I2Cx->TIMEOUTR &= (uint32_t)~((uint32_t)I2C_TIMEOUTR_TIDLE); + } +} + +/** + * @brief Configures the I2C Bus Timeout A (SCL Timeout when TIDLE = 0 or Bus + * idle SCL and SDA high when TIDLE = 1). + * @param I2Cx: where x can be 1 to select the I2C peripheral. + * @param Timeout: specifies the TimeoutA to be programmed. + * @retval None + */ +void I2C_TimeoutAConfig(I2C_TypeDef* I2Cx, uint16_t Timeout) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_I2C_1_PERIPH(I2Cx)); + assert_param(IS_I2C_TIMEOUT(Timeout)); + + /* Get the old register value */ + tmpreg = I2Cx->TIMEOUTR; + + /* Reset I2Cx TIMEOUTA bit [11:0] */ + tmpreg &= (uint32_t)~((uint32_t)I2C_TIMEOUTR_TIMEOUTA); + + /* Set I2Cx TIMEOUTA */ + tmpreg |= (uint32_t)((uint32_t)Timeout & I2C_TIMEOUTR_TIMEOUTA) ; + + /* Store the new register value */ + I2Cx->TIMEOUTR = tmpreg; +} + +/** + * @brief Configures the I2C Bus Timeout B (SCL cumulative Timeout). + * @param I2Cx: where x can be 1 to select the I2C peripheral. + * @param Timeout: specifies the TimeoutB to be programmed. + * @retval None + */ +void I2C_TimeoutBConfig(I2C_TypeDef* I2Cx, uint16_t Timeout) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_I2C_1_PERIPH(I2Cx)); + assert_param(IS_I2C_TIMEOUT(Timeout)); + + /* Get the old register value */ + tmpreg = I2Cx->TIMEOUTR; + + /* Reset I2Cx TIMEOUTB bit [11:0] */ + tmpreg &= (uint32_t)~((uint32_t)I2C_TIMEOUTR_TIMEOUTB); + + /* Set I2Cx TIMEOUTB */ + tmpreg |= (uint32_t)(((uint32_t)Timeout << 16) & I2C_TIMEOUTR_TIMEOUTB) ; + + /* Store the new register value */ + I2Cx->TIMEOUTR = tmpreg; +} + +/** + * @brief Enables or disables I2C PEC calculation. + * @param I2Cx: where x can be 1 to select the I2C peripheral. + * @param NewState: new state of the I2Cx PEC calculation. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_CalculatePEC(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_1_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable PEC calculation */ + I2Cx->CR1 |= I2C_CR1_PECEN; + } + else + { + /* Disable PEC calculation */ + I2Cx->CR1 &= (uint32_t)~((uint32_t)I2C_CR1_PECEN); + } +} + +/** + * @brief Enables or disables I2C PEC transmission/reception request. + * @param I2Cx: where x can be 1 to select the I2C peripheral. + * @param NewState: new state of the I2Cx PEC request. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_PECRequestCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_1_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable PEC transmission/reception request */ + I2Cx->CR2 |= I2C_CR2_PECBYTE; + } + else + { + /* Disable PEC transmission/reception request */ + I2Cx->CR2 &= (uint32_t)~((uint32_t)I2C_CR2_PECBYTE); + } +} + +/** + * @brief Returns the I2C PEC. + * @param I2Cx: where x can be 1 to select the I2C peripheral. + * @retval The value of the PEC . + */ +uint8_t I2C_GetPEC(I2C_TypeDef* I2Cx) +{ + /* Check the parameters */ + assert_param(IS_I2C_1_PERIPH(I2Cx)); + + /* Return the slave matched address in the SR1 register */ + return (uint8_t)((uint32_t)I2Cx->PECR & I2C_PECR_PEC); +} + +/** + * @} + */ + + +/** @defgroup I2C_Group4 I2C registers management functions + * @brief I2C registers management functions + * +@verbatim + =============================================================================== + ##### I2C registers management functions ##### + =============================================================================== + [..] This section provides a functions that allow user the management of + I2C registers. + +@endverbatim + * @{ + */ + + /** + * @brief Reads the specified I2C register and returns its value. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param I2C_Register: specifies the register to read. + * This parameter can be one of the following values: + * @arg I2C_Register_CR1: CR1 register. + * @arg I2C_Register_CR2: CR2 register. + * @arg I2C_Register_OAR1: OAR1 register. + * @arg I2C_Register_OAR2: OAR2 register. + * @arg I2C_Register_TIMINGR: TIMING register. + * @arg I2C_Register_TIMEOUTR: TIMEOUTR register. + * @arg I2C_Register_ISR: ISR register. + * @arg I2C_Register_ICR: ICR register. + * @arg I2C_Register_PECR: PECR register. + * @arg I2C_Register_RXDR: RXDR register. + * @arg I2C_Register_TXDR: TXDR register. + * @retval The value of the read register. + */ +uint32_t I2C_ReadRegister(I2C_TypeDef* I2Cx, uint8_t I2C_Register) +{ + __IO uint32_t tmp = 0; + + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_I2C_REGISTER(I2C_Register)); + + tmp = (uint32_t)I2Cx; + tmp += I2C_Register; + + /* Return the selected register value */ + return (*(__IO uint32_t *) tmp); +} + +/** + * @} + */ + +/** @defgroup I2C_Group5 Data transfers management functions + * @brief Data transfers management functions + * +@verbatim + =============================================================================== + ##### Data transfers management functions ##### + =============================================================================== + [..] This subsection provides a set of functions allowing to manage + the I2C data transfers. + + [..] The read access of the I2C_RXDR register can be done using + the I2C_ReceiveData() function and returns the received value. + Whereas a write access to the I2C_TXDR can be done using I2C_SendData() + function and stores the written data into TXDR. +@endverbatim + * @{ + */ + +/** + * @brief Sends a data byte through the I2Cx peripheral. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param Data: Byte to be transmitted.. + * @retval None + */ +void I2C_SendData(I2C_TypeDef* I2Cx, uint8_t Data) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + + /* Write in the DR register the data to be sent */ + I2Cx->TXDR = (uint8_t)Data; +} + +/** + * @brief Returns the most recent received data by the I2Cx peripheral. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @retval The value of the received data. + */ +uint8_t I2C_ReceiveData(I2C_TypeDef* I2Cx) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + + /* Return the data in the DR register */ + return (uint8_t)I2Cx->RXDR; +} + +/** + * @} + */ + + +/** @defgroup I2C_Group6 DMA transfers management functions + * @brief DMA transfers management functions + * +@verbatim + =============================================================================== + ##### DMA transfers management functions ##### + =============================================================================== + [..] This section provides two functions that can be used only in DMA mode. + [..] In DMA Mode, the I2C communication can be managed by 2 DMA Channel + requests: + (#) I2C_DMAReq_Tx: specifies the Tx buffer DMA transfer request. + (#) I2C_DMAReq_Rx: specifies the Rx buffer DMA transfer request. + [..] In this Mode it is advised to use the following function: + (+) I2C_DMACmd(I2C_TypeDef* I2Cx, uint32_t I2C_DMAReq, FunctionalState NewState); +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the I2C DMA interface. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param I2C_DMAReq: specifies the I2C DMA transfer request to be enabled or disabled. + * This parameter can be any combination of the following values: + * @arg I2C_DMAReq_Tx: Tx DMA transfer request + * @arg I2C_DMAReq_Rx: Rx DMA transfer request + * @param NewState: new state of the selected I2C DMA transfer request. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_DMACmd(I2C_TypeDef* I2Cx, uint32_t I2C_DMAReq, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + assert_param(IS_I2C_DMA_REQ(I2C_DMAReq)); + + if (NewState != DISABLE) + { + /* Enable the selected I2C DMA requests */ + I2Cx->CR1 |= I2C_DMAReq; + } + else + { + /* Disable the selected I2C DMA requests */ + I2Cx->CR1 &= (uint32_t)~I2C_DMAReq; + } +} +/** + * @} + */ + + +/** @defgroup I2C_Group7 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== + [..] This section provides functions allowing to configure the I2C Interrupts + sources and check or clear the flags or pending bits status. + The user should identify which mode will be used in his application to manage + the communication: Polling mode, Interrupt mode or DMA mode(refer I2C_Group6). + + *** Polling Mode *** + ==================== + [..] In Polling Mode, the I2C communication can be managed by 15 flags: + (#) I2C_FLAG_TXE: to indicate the status of Transmit data register empty flag. + (#) I2C_FLAG_TXIS: to indicate the status of Transmit interrupt status flag . + (#) I2C_FLAG_RXNE: to indicate the status of Receive data register not empty flag. + (#) I2C_FLAG_ADDR: to indicate the status of Address matched flag (slave mode). + (#) I2C_FLAG_NACKF: to indicate the status of NACK received flag. + (#) I2C_FLAG_STOPF: to indicate the status of STOP detection flag. + (#) I2C_FLAG_TC: to indicate the status of Transfer complete flag(master mode). + (#) I2C_FLAG_TCR: to indicate the status of Transfer complete reload flag. + (#) I2C_FLAG_BERR: to indicate the status of Bus error flag. + (#) I2C_FLAG_ARLO: to indicate the status of Arbitration lost flag. + (#) I2C_FLAG_OVR: to indicate the status of Overrun/Underrun flag. + (#) I2C_FLAG_PECERR: to indicate the status of PEC error in reception flag. + (#) I2C_FLAG_TIMEOUT: to indicate the status of Timeout or Tlow detection flag. + (#) I2C_FLAG_ALERT: to indicate the status of SMBus Alert flag. + (#) I2C_FLAG_BUSY: to indicate the status of Bus busy flag. + + [..] In this Mode it is advised to use the following functions: + (+) FlagStatus I2C_GetFlagStatus(I2C_TypeDef* I2Cx, uint32_t I2C_FLAG); + (+) void I2C_ClearFlag(I2C_TypeDef* I2Cx, uint32_t I2C_FLAG); + + [..] + (@)Do not use the BUSY flag to handle each data transmission or reception.It is + better to use the TXIS and RXNE flags instead. + + *** Interrupt Mode *** + ====================== + [..] In Interrupt Mode, the I2C communication can be managed by 7 interrupt sources + and 15 pending bits: + [..] Interrupt Source: + (#) I2C_IT_ERRI: specifies the interrupt source for the Error interrupt. + (#) I2C_IT_TCI: specifies the interrupt source for the Transfer Complete interrupt. + (#) I2C_IT_STOPI: specifies the interrupt source for the Stop Detection interrupt. + (#) I2C_IT_NACKI: specifies the interrupt source for the Not Acknowledge received interrupt. + (#) I2C_IT_ADDRI: specifies the interrupt source for the Address Match interrupt. + (#) I2C_IT_RXI: specifies the interrupt source for the RX interrupt. + (#) I2C_IT_TXI: specifies the interrupt source for the TX interrupt. + + [..] Pending Bits: + (#) I2C_IT_TXIS: to indicate the status of Transmit interrupt status flag. + (#) I2C_IT_RXNE: to indicate the status of Receive data register not empty flag. + (#) I2C_IT_ADDR: to indicate the status of Address matched flag (slave mode). + (#) I2C_IT_NACKF: to indicate the status of NACK received flag. + (#) I2C_IT_STOPF: to indicate the status of STOP detection flag. + (#) I2C_IT_TC: to indicate the status of Transfer complete flag (master mode). + (#) I2C_IT_TCR: to indicate the status of Transfer complete reload flag. + (#) I2C_IT_BERR: to indicate the status of Bus error flag. + (#) I2C_IT_ARLO: to indicate the status of Arbitration lost flag. + (#) I2C_IT_OVR: to indicate the status of Overrun/Underrun flag. + (#) I2C_IT_PECERR: to indicate the status of PEC error in reception flag. + (#) I2C_IT_TIMEOUT: to indicate the status of Timeout or Tlow detection flag. + (#) I2C_IT_ALERT: to indicate the status of SMBus Alert flag. + + [..] In this Mode it is advised to use the following functions: + (+) void I2C_ClearITPendingBit(I2C_TypeDef* I2Cx, uint32_t I2C_IT); + (+) ITStatus I2C_GetITStatus(I2C_TypeDef* I2Cx, uint32_t I2C_IT); + +@endverbatim + * @{ + */ + +/** + * @brief Checks whether the specified I2C flag is set or not. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param I2C_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg I2C_FLAG_TXE: Transmit data register empty + * @arg I2C_FLAG_TXIS: Transmit interrupt status + * @arg I2C_FLAG_RXNE: Receive data register not empty + * @arg I2C_FLAG_ADDR: Address matched (slave mode) + * @arg I2C_FLAG_NACKF: NACK received flag + * @arg I2C_FLAG_STOPF: STOP detection flag + * @arg I2C_FLAG_TC: Transfer complete (master mode) + * @arg I2C_FLAG_TCR: Transfer complete reload + * @arg I2C_FLAG_BERR: Bus error + * @arg I2C_FLAG_ARLO: Arbitration lost + * @arg I2C_FLAG_OVR: Overrun/Underrun + * @arg I2C_FLAG_PECERR: PEC error in reception + * @arg I2C_FLAG_TIMEOUT: Timeout or Tlow detection flag + * @arg I2C_FLAG_ALERT: SMBus Alert + * @arg I2C_FLAG_BUSY: Bus busy + * @retval The new state of I2C_FLAG (SET or RESET). + */ +FlagStatus I2C_GetFlagStatus(I2C_TypeDef* I2Cx, uint32_t I2C_FLAG) +{ + uint32_t tmpreg = 0; + FlagStatus bitstatus = RESET; + + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_I2C_GET_FLAG(I2C_FLAG)); + + /* Get the ISR register value */ + tmpreg = I2Cx->ISR; + + /* Get flag status */ + tmpreg &= I2C_FLAG; + + if(tmpreg != 0) + { + /* I2C_FLAG is set */ + bitstatus = SET; + } + else + { + /* I2C_FLAG is reset */ + bitstatus = RESET; + } + return bitstatus; +} + +/** + * @brief Clears the I2Cx's pending flags. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param I2C_FLAG: specifies the flag to clear. + * This parameter can be any combination of the following values: + * @arg I2C_FLAG_ADDR: Address matched (slave mode) + * @arg I2C_FLAG_NACKF: NACK received flag + * @arg I2C_FLAG_STOPF: STOP detection flag + * @arg I2C_FLAG_BERR: Bus error + * @arg I2C_FLAG_ARLO: Arbitration lost + * @arg I2C_FLAG_OVR: Overrun/Underrun + * @arg I2C_FLAG_PECERR: PEC error in reception + * @arg I2C_FLAG_TIMEOUT: Timeout or Tlow detection flag + * @arg I2C_FLAG_ALERT: SMBus Alert + * @retval The new state of I2C_FLAG (SET or RESET). + */ +void I2C_ClearFlag(I2C_TypeDef* I2Cx, uint32_t I2C_FLAG) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_I2C_CLEAR_FLAG(I2C_FLAG)); + + /* Clear the selected flag */ + I2Cx->ICR = I2C_FLAG; + } + +/** + * @brief Checks whether the specified I2C interrupt has occurred or not. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param I2C_IT: specifies the interrupt source to check. + * This parameter can be one of the following values: + * @arg I2C_IT_TXIS: Transmit interrupt status + * @arg I2C_IT_RXNE: Receive data register not empty + * @arg I2C_IT_ADDR: Address matched (slave mode) + * @arg I2C_IT_NACKF: NACK received flag + * @arg I2C_IT_STOPF: STOP detection flag + * @arg I2C_IT_TC: Transfer complete (master mode) + * @arg I2C_IT_TCR: Transfer complete reload + * @arg I2C_IT_BERR: Bus error + * @arg I2C_IT_ARLO: Arbitration lost + * @arg I2C_IT_OVR: Overrun/Underrun + * @arg I2C_IT_PECERR: PEC error in reception + * @arg I2C_IT_TIMEOUT: Timeout or Tlow detection flag + * @arg I2C_IT_ALERT: SMBus Alert + * @retval The new state of I2C_IT (SET or RESET). + */ +ITStatus I2C_GetITStatus(I2C_TypeDef* I2Cx, uint32_t I2C_IT) +{ + uint32_t tmpreg = 0; + ITStatus bitstatus = RESET; + uint32_t enablestatus = 0; + + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_I2C_GET_IT(I2C_IT)); + + /* Check if the interrupt source is enabled or not */ + /* If Error interrupt */ + if ((uint32_t)(I2C_IT & ERROR_IT_MASK)) + { + enablestatus = (uint32_t)((I2C_CR1_ERRIE) & (I2Cx->CR1)); + } + /* If TC interrupt */ + else if ((uint32_t)(I2C_IT & TC_IT_MASK)) + { + enablestatus = (uint32_t)((I2C_CR1_TCIE) & (I2Cx->CR1)); + } + else + { + enablestatus = (uint32_t)((I2C_IT) & (I2Cx->CR1)); + } + + /* Get the ISR register value */ + tmpreg = I2Cx->ISR; + + /* Get flag status */ + tmpreg &= I2C_IT; + + /* Check the status of the specified I2C flag */ + if((tmpreg != RESET) && enablestatus) + { + /* I2C_IT is set */ + bitstatus = SET; + } + else + { + /* I2C_IT is reset */ + bitstatus = RESET; + } + + /* Return the I2C_IT status */ + return bitstatus; +} + +/** + * @brief Clears the I2Cx's interrupt pending bits. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param I2C_IT: specifies the interrupt pending bit to clear. + * This parameter can be any combination of the following values: + * @arg I2C_IT_ADDR: Address matched (slave mode) + * @arg I2C_IT_NACKF: NACK received flag + * @arg I2C_IT_STOPF: STOP detection flag + * @arg I2C_IT_BERR: Bus error + * @arg I2C_IT_ARLO: Arbitration lost + * @arg I2C_IT_OVR: Overrun/Underrun + * @arg I2C_IT_PECERR: PEC error in reception + * @arg I2C_IT_TIMEOUT: Timeout or Tlow detection flag + * @arg I2C_IT_ALERT: SMBus Alert + * @retval The new state of I2C_IT (SET or RESET). + */ +void I2C_ClearITPendingBit(I2C_TypeDef* I2Cx, uint32_t I2C_IT) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_I2C_CLEAR_IT(I2C_IT)); + + /* Clear the selected flag */ + I2Cx->ICR = I2C_IT; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_iwdg.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_iwdg.c new file mode 100644 index 00000000..7f00dd17 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_iwdg.c @@ -0,0 +1,293 @@ +/** + ****************************************************************************** + * @file stm32f0xx_iwdg.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Independent watchdog (IWDG) peripheral: + * + Prescaler and Counter configuration + * + IWDG activation + * + Flag management + * + * @verbatim + * + ============================================================================== + ##### IWDG features ##### + ============================================================================== + [..] The IWDG can be started by either software or hardware (configurable + through option byte). + + [..] The IWDG is clocked by its own dedicated low-speed clock (LSI) and + thus stays active even if the main clock fails. + Once the IWDG is started, the LSI is forced ON and cannot be disabled + (LSI cannot be disabled too), and the counter starts counting down from + the reset value of 0xFFF. When it reaches the end of count value (0x000) + a system reset is generated. + The IWDG counter should be reloaded at regular intervals to prevent + an MCU reset. + + [..] The IWDG is implemented in the VDD voltage domain that is still functional + in STOP and STANDBY mode (IWDG reset can wake-up from STANDBY). + + [..] IWDGRST flag in RCC_CSR register can be used to inform when a IWDG + reset occurs. + + [..] Min-max timeout value @40KHz (LSI): ~0.1ms / ~28.3s + The IWDG timeout may vary due to LSI frequency dispersion. STM32F0xx + devices provide the capability to measure the LSI frequency (LSI clock + should be seleted as RTC clock which is internally connected to TIM10 CH1 + input capture). The measured value can be used to have an IWDG timeout with + an acceptable accuracy. + For more information, please refer to the STM32F0xx Reference manual. + + ##### How to use this driver ##### + ============================================================================== + [..] This driver allows to use IWDG peripheral with either window option enabled + or disabled. To do so follow one of the two procedures below. + (#) Window option is enabled: + (++) Start the IWDG using IWDG_Enable() function, when the IWDG is used + in software mode (no need to enable the LSI, it will be enabled + by hardware). + (++) Enable write access to IWDG_PR and IWDG_RLR registers using + IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable) function. + (++) Configure the IWDG prescaler using IWDG_SetPrescaler() function. + (++) Configure the IWDG counter value using IWDG_SetReload() function. + This value will be loaded in the IWDG counter each time the counter + is reloaded, then the IWDG will start counting down from this value. + (++) Wait for the IWDG registers to be updated using IWDG_GetFlagStatus() function. + (++) Configure the IWDG refresh window using IWDG_SetWindowValue() function. + + (#) Window option is disabled: + (++) Enable write access to IWDG_PR and IWDG_RLR registers using + IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable) function. + (++) Configure the IWDG prescaler using IWDG_SetPrescaler() function. + (++) Configure the IWDG counter value using IWDG_SetReload() function. + This value will be loaded in the IWDG counter each time the counter + is reloaded, then the IWDG will start counting down from this value. + (++) Wait for the IWDG registers to be updated using IWDG_GetFlagStatus() function. + (++) reload the IWDG counter at regular intervals during normal operation + to prevent an MCU reset, using IWDG_ReloadCounter() function. + (++) Start the IWDG using IWDG_Enable() function, when the IWDG is used + in software mode (no need to enable the LSI, it will be enabled + by hardware). + + @endverbatim + * + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_iwdg.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup IWDG + * @brief IWDG driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* ---------------------- IWDG registers bit mask ----------------------------*/ +/* KR register bit mask */ +#define KR_KEY_RELOAD ((uint16_t)0xAAAA) +#define KR_KEY_ENABLE ((uint16_t)0xCCCC) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup IWDG_Private_Functions + * @{ + */ + +/** @defgroup IWDG_Group1 Prescaler and Counter configuration functions + * @brief Prescaler and Counter configuration functions + * +@verbatim + ============================================================================== + ##### Prescaler and Counter configuration functions ##### + ============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables write access to IWDG_PR and IWDG_RLR registers. + * @param IWDG_WriteAccess: new state of write access to IWDG_PR and IWDG_RLR registers. + * This parameter can be one of the following values: + * @arg IWDG_WriteAccess_Enable: Enable write access to IWDG_PR and IWDG_RLR registers + * @arg IWDG_WriteAccess_Disable: Disable write access to IWDG_PR and IWDG_RLR registers + * @retval None + */ +void IWDG_WriteAccessCmd(uint16_t IWDG_WriteAccess) +{ + /* Check the parameters */ + assert_param(IS_IWDG_WRITE_ACCESS(IWDG_WriteAccess)); + IWDG->KR = IWDG_WriteAccess; +} + +/** + * @brief Sets IWDG Prescaler value. + * @param IWDG_Prescaler: specifies the IWDG Prescaler value. + * This parameter can be one of the following values: + * @arg IWDG_Prescaler_4: IWDG prescaler set to 4 + * @arg IWDG_Prescaler_8: IWDG prescaler set to 8 + * @arg IWDG_Prescaler_16: IWDG prescaler set to 16 + * @arg IWDG_Prescaler_32: IWDG prescaler set to 32 + * @arg IWDG_Prescaler_64: IWDG prescaler set to 64 + * @arg IWDG_Prescaler_128: IWDG prescaler set to 128 + * @arg IWDG_Prescaler_256: IWDG prescaler set to 256 + * @retval None + */ +void IWDG_SetPrescaler(uint8_t IWDG_Prescaler) +{ + /* Check the parameters */ + assert_param(IS_IWDG_PRESCALER(IWDG_Prescaler)); + IWDG->PR = IWDG_Prescaler; +} + +/** + * @brief Sets IWDG Reload value. + * @param Reload: specifies the IWDG Reload value. + * This parameter must be a number between 0 and 0x0FFF. + * @retval None + */ +void IWDG_SetReload(uint16_t Reload) +{ + /* Check the parameters */ + assert_param(IS_IWDG_RELOAD(Reload)); + IWDG->RLR = Reload; +} + +/** + * @brief Reloads IWDG counter with value defined in the reload register + * (write access to IWDG_PR and IWDG_RLR registers disabled). + * @param None + * @retval None + */ +void IWDG_ReloadCounter(void) +{ + IWDG->KR = KR_KEY_RELOAD; +} + + +/** + * @brief Sets the IWDG window value. + * @param WindowValue: specifies the window value to be compared to the downcounter. + * @retval None + */ +void IWDG_SetWindowValue(uint16_t WindowValue) +{ + /* Check the parameters */ + assert_param(IS_IWDG_WINDOW_VALUE(WindowValue)); + IWDG->WINR = WindowValue; +} + +/** + * @} + */ + +/** @defgroup IWDG_Group2 IWDG activation function + * @brief IWDG activation function + * +@verbatim + ============================================================================== + ##### IWDG activation function ##### + ============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Enables IWDG (write access to IWDG_PR and IWDG_RLR registers disabled). + * @param None + * @retval None + */ +void IWDG_Enable(void) +{ + IWDG->KR = KR_KEY_ENABLE; +} + +/** + * @} + */ + +/** @defgroup IWDG_Group3 Flag management function + * @brief Flag management function + * +@verbatim + =============================================================================== + ##### Flag management function ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Checks whether the specified IWDG flag is set or not. + * @param IWDG_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg IWDG_FLAG_PVU: Prescaler Value Update on going + * @arg IWDG_FLAG_RVU: Reload Value Update on going + * @arg IWDG_FLAG_WVU: Counter Window Value Update on going + * @retval The new state of IWDG_FLAG (SET or RESET). + */ +FlagStatus IWDG_GetFlagStatus(uint16_t IWDG_FLAG) +{ + FlagStatus bitstatus = RESET; + /* Check the parameters */ + assert_param(IS_IWDG_FLAG(IWDG_FLAG)); + if ((IWDG->SR & IWDG_FLAG) != (uint32_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + /* Return the flag status */ + return bitstatus; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_misc.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_misc.c new file mode 100644 index 00000000..b3e0f2b3 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_misc.c @@ -0,0 +1,167 @@ +/** + ****************************************************************************** + * @file stm32f0xx_misc.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides all the miscellaneous firmware functions (add-on + * to CMSIS functions). + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_misc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup MISC + * @brief MISC driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup MISC_Private_Functions + * @{ + */ +/** + * +@verbatim + ******************************************************************************* + ##### Interrupts configuration functions ##### + ******************************************************************************* + [..] This section provide functions allowing to configure the NVIC interrupts + (IRQ). The Cortex-M0 exceptions are managed by CMSIS functions. + (#) Enable and Configure the priority of the selected IRQ Channels. + The priority can be 0..3. + + -@- Lower priority values gives higher priority. + -@- Priority Order: + (#@) Lowest priority. + (#@) Lowest hardware priority (IRQn position). + +@endverbatim +*/ + +/** + * @brief Initializes the NVIC peripheral according to the specified + * parameters in the NVIC_InitStruct. + * @param NVIC_InitStruct: pointer to a NVIC_InitTypeDef structure that contains + * the configuration information for the specified NVIC peripheral. + * @retval None + */ +void NVIC_Init(NVIC_InitTypeDef* NVIC_InitStruct) +{ + uint32_t tmppriority = 0x00; + + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NVIC_InitStruct->NVIC_IRQChannelCmd)); + assert_param(IS_NVIC_PRIORITY(NVIC_InitStruct->NVIC_IRQChannelPriority)); + + if (NVIC_InitStruct->NVIC_IRQChannelCmd != DISABLE) + { + /* Compute the Corresponding IRQ Priority --------------------------------*/ + tmppriority = NVIC->IP[NVIC_InitStruct->NVIC_IRQChannel >> 0x02]; + tmppriority &= (uint32_t)(~(((uint32_t)0xFF) << ((NVIC_InitStruct->NVIC_IRQChannel & 0x03) * 8))); + tmppriority |= (uint32_t)((((uint32_t)NVIC_InitStruct->NVIC_IRQChannelPriority << 6) & 0xFF) << ((NVIC_InitStruct->NVIC_IRQChannel & 0x03) * 8)); + + NVIC->IP[NVIC_InitStruct->NVIC_IRQChannel >> 0x02] = tmppriority; + + /* Enable the Selected IRQ Channels --------------------------------------*/ + NVIC->ISER[0] = (uint32_t)0x01 << (NVIC_InitStruct->NVIC_IRQChannel & (uint8_t)0x1F); + } + else + { + /* Disable the Selected IRQ Channels -------------------------------------*/ + NVIC->ICER[0] = (uint32_t)0x01 << (NVIC_InitStruct->NVIC_IRQChannel & (uint8_t)0x1F); + } +} + +/** + * @brief Selects the condition for the system to enter low power mode. + * @param LowPowerMode: Specifies the new mode for the system to enter low power mode. + * This parameter can be one of the following values: + * @arg NVIC_LP_SEVONPEND: Low Power SEV on Pend. + * @arg NVIC_LP_SLEEPDEEP: Low Power DEEPSLEEP request. + * @arg NVIC_LP_SLEEPONEXIT: Low Power Sleep on Exit. + * @param NewState: new state of LP condition. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void NVIC_SystemLPConfig(uint8_t LowPowerMode, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_NVIC_LP(LowPowerMode)); + + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + SCB->SCR |= LowPowerMode; + } + else + { + SCB->SCR &= (uint32_t)(~(uint32_t)LowPowerMode); + } +} + +/** + * @brief Configures the SysTick clock source. + * @param SysTick_CLKSource: specifies the SysTick clock source. + * This parameter can be one of the following values: + * @arg SysTick_CLKSource_HCLK_Div8: AHB clock divided by 8 selected as SysTick clock source. + * @arg SysTick_CLKSource_HCLK: AHB clock selected as SysTick clock source. + * @retval None + */ +void SysTick_CLKSourceConfig(uint32_t SysTick_CLKSource) +{ + /* Check the parameters */ + assert_param(IS_SYSTICK_CLK_SOURCE(SysTick_CLKSource)); + + if (SysTick_CLKSource == SysTick_CLKSource_HCLK) + { + SysTick->CTRL |= SysTick_CLKSource_HCLK; + } + else + { + SysTick->CTRL &= SysTick_CLKSource_HCLK_Div8; + } +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_pwr.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_pwr.c new file mode 100644 index 00000000..fe654dbf --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_pwr.c @@ -0,0 +1,566 @@ +/** + ****************************************************************************** + * @file stm32f0xx_pwr.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Power Controller (PWR) peripheral: + * + Backup Domain Access + * + PVD configuration + * + WakeUp pins configuration + * + Low Power modes configuration + * + Flags management + * + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_pwr.h" +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup PWR + * @brief PWR driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ + +/* ------------------ PWR registers bit mask ------------------------ */ + +/* CR register bit mask */ +#define CR_DS_MASK ((uint32_t)0xFFFFFFFC) +#define CR_PLS_MASK ((uint32_t)0xFFFFFF1F) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup PWR_Private_Functions + * @{ + */ + +/** @defgroup PWR_Group1 Backup Domain Access function + * @brief Backup Domain Access function + * +@verbatim + ============================================================================== + ##### Backup Domain Access function ##### + ============================================================================== + + [..] After reset, the Backup Domain Registers (RCC BDCR Register, RTC registers + and RTC backup registers) are protected against possible stray write accesses. + [..] To enable access to Backup domain use the PWR_BackupAccessCmd(ENABLE) function. + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the PWR peripheral registers to their default reset values. + * @param None + * @retval None + */ +void PWR_DeInit(void) +{ + RCC_APB1PeriphResetCmd(RCC_APB1Periph_PWR, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_PWR, DISABLE); +} + +/** + * @brief Enables or disables access to the Backup domain registers. + * @note If the HSE divided by 32 is used as the RTC clock, the + * Backup Domain Access should be kept enabled. + * @param NewState: new state of the access to the Backup domain registers. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void PWR_BackupAccessCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the Backup Domain Access */ + PWR->CR |= PWR_CR_DBP; + } + else + { + /* Disable the Backup Domain Access */ + PWR->CR &= (uint32_t)~((uint32_t)PWR_CR_DBP); + } +} + +/** + * @} + */ + +/** @defgroup PWR_Group2 PVD configuration functions + * @brief PVD configuration functions + * +@verbatim + ============================================================================== + ##### PVD configuration functions ##### + ============================================================================== + [..] + (+) The PVD is used to monitor the VDD power supply by comparing it to a threshold + selected by the PVD Level (PLS[2:0] bits in the PWR_CR). + (+) A PVDO flag is available to indicate if VDD/VDDA is higher or lower than the + PVD threshold. This event is internally connected to the EXTI line16 + and can generate an interrupt if enabled through the EXTI registers. + (+) The PVD is stopped in Standby mode. + +@endverbatim + * @{ + */ + +/** + * @brief Configures the voltage threshold detected by the Power Voltage Detector(PVD). + * @note This function is not applicable for STM32F030 devices. + * @param PWR_PVDLevel: specifies the PVD detection level + * This parameter can be one of the following values: + * @arg PWR_PVDLevel_0 + * @arg PWR_PVDLevel_1 + * @arg PWR_PVDLevel_2 + * @arg PWR_PVDLevel_3 + * @arg PWR_PVDLevel_4 + * @arg PWR_PVDLevel_5 + * @arg PWR_PVDLevel_6 + * @arg PWR_PVDLevel_7 + * @note Refer to the electrical characteristics of your device datasheet for + * more details about the voltage threshold corresponding to each + * detection level. + * @retval None + */ +void PWR_PVDLevelConfig(uint32_t PWR_PVDLevel) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_PWR_PVD_LEVEL(PWR_PVDLevel)); + + tmpreg = PWR->CR; + + /* Clear PLS[7:5] bits */ + tmpreg &= CR_PLS_MASK; + + /* Set PLS[7:5] bits according to PWR_PVDLevel value */ + tmpreg |= PWR_PVDLevel; + + /* Store the new value */ + PWR->CR = tmpreg; +} + +/** + * @brief Enables or disables the Power Voltage Detector(PVD). + * @note This function is not applicable for STM32F030 devices. + * @param NewState: new state of the PVD. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void PWR_PVDCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the PVD */ + PWR->CR |= PWR_CR_PVDE; + } + else + { + /* Disable the PVD */ + PWR->CR &= (uint32_t)~((uint32_t)PWR_CR_PVDE); + } +} + +/** + * @} + */ + +/** @defgroup PWR_Group3 WakeUp pins configuration functions + * @brief WakeUp pins configuration functions + * +@verbatim + ============================================================================== + ##### WakeUp pin configuration functions ##### + ============================================================================== + + (+) WakeUp pins are used to wakeup the system from Standby mode. These pins are + forced in input pull down configuration and are active on rising edges. + (+) There are eight WakeUp pins: WakeUp Pin 1 on PA.00 and WakeUp Pin 2 on PC.13. + The following WakeUp pins are only applicable for STM32F072 dvices: + WakeUp Pin 3 on PE.06, WakeUp Pin 4 on PA.02, WakeUp Pin 5 on PC.05, + WakeUp Pin 6 on PB.05, WakeUp Pin 7 on PB.15 and WakeUp Pin 8 on PF.02. + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the WakeUp Pin functionality. + * @param PWR_WakeUpPin: specifies the WakeUpPin. + * This parameter can be one of the following values + * @arg PWR_WakeUpPin_1 + * @arg PWR_WakeUpPin_2 + * @arg PWR_WakeUpPin_3, only applicable for STM32F072 devices + * @arg PWR_WakeUpPin_4, only applicable for STM32F072 devices + * @arg PWR_WakeUpPin_5, only applicable for STM32F072 devices + * @arg PWR_WakeUpPin_6, only applicable for STM32F072 devices + * @arg PWR_WakeUpPin_7, only applicable for STM32F072 devices + * @arg PWR_WakeUpPin_8, only applicable for STM32F072 devices + * @param NewState: new state of the WakeUp Pin functionality. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void PWR_WakeUpPinCmd(uint32_t PWR_WakeUpPin, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_PWR_WAKEUP_PIN(PWR_WakeUpPin)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the EWUPx pin */ + PWR->CSR |= PWR_WakeUpPin; + } + else + { + /* Disable the EWUPx pin */ + PWR->CSR &= ~PWR_WakeUpPin; + } +} + +/** + * @} + */ + + +/** @defgroup PWR_Group4 Low Power modes configuration functions + * @brief Low Power modes configuration functions + * +@verbatim + ============================================================================== + ##### Low Power modes configuration functions ##### + ============================================================================== + + [..] The devices feature three low-power modes: + (+) Sleep mode: Cortex-M0 core stopped, peripherals kept running. + (+) Stop mode: all clocks are stopped, regulator running, regulator in low power mode + (+) Standby mode: VCORE domain powered off + + *** Sleep mode *** + ================== + [..] + (+) Entry: + (++) The Sleep mode is entered by executing the WFE() or WFI() instructions. + (+) Exit: + (++) Any peripheral interrupt acknowledged by the nested vectored interrupt + controller (NVIC) can wake up the device from Sleep mode. + + *** Stop mode *** + ================= + [..] In Stop mode, all clocks in the VCORE domain are stopped, the PLL, the HSI, + the HSI14 and the HSE RC oscillators are disabled. Internal SRAM and register + contents are preserved. + The voltage regulator can be configured either in normal or low-power mode. + + (+) Entry: + (++) The Stop mode is entered using the PWR_EnterSTOPMode(PWR_Regulator_LowPower,) + function with regulator in LowPower or with Regulator ON. + (+) Exit: + (++) Any EXTI Line (Internal or External) configured in Interrupt/Event mode + or any internal IPs (I2C, UASRT or CEC) wakeup event. + + *** Standby mode *** + ==================== + [..] The Standby mode allows to achieve the lowest power consumption. It is based + on the Cortex-M0 deepsleep mode, with the voltage regulator disabled. + The VCORE domain is consequently powered off. The PLL, the HSI, the HSI14 + oscillator and the HSE oscillator are also switched off. SRAM and register + contents are lost except for the Backup domain (RTC registers, RTC backup + registers and Standby circuitry). + + [..] The voltage regulator is OFF. + + (+) Entry: + (++) The Standby mode is entered using the PWR_EnterSTANDBYMode() function. + (+) Exit: + (++) WKUP pin rising edge, RTC alarm (Alarm A and Alarm B), RTC wakeup, + tamper event, time-stamp event, external reset in NRST pin, IWDG reset. + + *** Auto-wakeup (AWU) from low-power mode *** + ============================================= + [..] The MCU can be woken up from low-power mode by an RTC Alarm event, a tamper + event, a time-stamp event, or a comparator event, without depending on an + external interrupt (Auto-wakeup mode). + + (+) RTC auto-wakeup (AWU) from the Stop mode + (++) To wake up from the Stop mode with an RTC alarm event, it is necessary to: + (+++) Configure the EXTI Line 17 to be sensitive to rising edges (Interrupt + or Event modes) using the EXTI_Init() function. + (+++) Enable the RTC Alarm Interrupt using the RTC_ITConfig() function + (+++) Configure the RTC to generate the RTC alarm using the RTC_SetAlarm() + and RTC_AlarmCmd() functions. + (++) To wake up from the Stop mode with an RTC Tamper or time stamp event, it + is necessary to: + (+++) Configure the EXTI Line 19 to be sensitive to rising edges (Interrupt + or Event modes) using the EXTI_Init() function. + (+++) Enable the RTC Tamper or time stamp Interrupt using the RTC_ITConfig() + function. + (+++) Configure the RTC to detect the tamper or time stamp event using the + RTC_TimeStampConfig(), RTC_TamperTriggerConfig() and RTC_TamperCmd() + functions. + + (+) RTC auto-wakeup (AWU) from the Standby mode + (++) To wake up from the Standby mode with an RTC alarm event, it is necessary to: + (+++) Enable the RTC Alarm Interrupt using the RTC_ITConfig() function. + (+++) Configure the RTC to generate the RTC alarm using the RTC_SetAlarm() + and RTC_AlarmCmd() functions. + (++) To wake up from the Standby mode with an RTC Tamper or time stamp event, it + is necessary to: + (+++) Enable the RTC Tamper or time stamp Interrupt using the RTC_ITConfig() + function. + (+++) Configure the RTC to detect the tamper or time stamp event using the + RTC_TimeStampConfig(), RTC_TamperTriggerConfig() and RTC_TamperCmd() + functions. + + (+) Comparator auto-wakeup (AWU) from the Stop mode + (++) To wake up from the Stop mode with an comparator 1 or comparator 2 wakeup + event, it is necessary to: + (+++) Configure the EXTI Line 21 for comparator 1 or EXTI Line 22 for comparator 2 + to be sensitive to to the selected edges (falling, rising or falling + and rising) (Interrupt or Event modes) using the EXTI_Init() function. + (+++) Configure the comparator to generate the event. + +@endverbatim + * @{ + */ + +/** + * @brief Enters Sleep mode. + * @note In Sleep mode, all I/O pins keep the same state as in Run mode. + * @param PWR_SLEEPEntry: specifies if SLEEP mode in entered with WFI or WFE instruction. + * This parameter can be one of the following values: + * @arg PWR_SLEEPEntry_WFI: enter SLEEP mode with WFI instruction + * @arg PWR_SLEEPEntry_WFE: enter SLEEP mode with WFE instruction + * @retval None + */ +void PWR_EnterSleepMode(uint8_t PWR_SLEEPEntry) +{ + /* Check the parameters */ + assert_param(IS_PWR_SLEEP_ENTRY(PWR_SLEEPEntry)); + + /* Clear SLEEPDEEP bit of Cortex-M0 System Control Register */ + SCB->SCR &= (uint32_t)~((uint32_t)SCB_SCR_SLEEPDEEP_Msk); + + /* Select SLEEP mode entry -------------------------------------------------*/ + if(PWR_SLEEPEntry == PWR_SLEEPEntry_WFI) + { + /* Request Wait For Interrupt */ + __WFI(); + } + else + { + /* Request Wait For Event */ + __SEV(); + __WFE(); + __WFE(); + } +} + +/** + * @brief Enters STOP mode. + * @note In Stop mode, all I/O pins keep the same state as in Run mode. + * @note When exiting Stop mode by issuing an interrupt or a wakeup event, + * the HSI RC oscillator is selected as system clock. + * @note When the voltage regulator operates in low power mode, an additional + * startup delay is incurred when waking up from Stop mode. + * By keeping the internal regulator ON during Stop mode, the consumption + * is higher although the startup time is reduced. + * @param PWR_Regulator: specifies the regulator state in STOP mode. + * This parameter can be one of the following values: + * @arg PWR_Regulator_ON: STOP mode with regulator ON + * @arg PWR_Regulator_LowPower: STOP mode with regulator in low power mode + * @param PWR_STOPEntry: specifies if STOP mode in entered with WFI or WFE instruction. + * This parameter can be one of the following values: + * @arg PWR_STOPEntry_WFI: enter STOP mode with WFI instruction + * @arg PWR_STOPEntry_WFE: enter STOP mode with WFE instruction + @arg PWR_STOPEntry_SLEEPONEXIT: enter STOP mode with SLEEPONEXIT instruction + * @retval None + */ +void PWR_EnterSTOPMode(uint32_t PWR_Regulator, uint8_t PWR_STOPEntry) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_PWR_REGULATOR(PWR_Regulator)); + assert_param(IS_PWR_STOP_ENTRY(PWR_STOPEntry)); + + /* Select the regulator state in STOP mode ---------------------------------*/ + tmpreg = PWR->CR; + /* Clear PDDS and LPDSR bits */ + tmpreg &= CR_DS_MASK; + + /* Set LPDSR bit according to PWR_Regulator value */ + tmpreg |= PWR_Regulator; + + /* Store the new value */ + PWR->CR = tmpreg; + + /* Set SLEEPDEEP bit of Cortex-M0 System Control Register */ + SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk; + + /* Select STOP mode entry --------------------------------------------------*/ + if(PWR_STOPEntry == PWR_STOPEntry_WFI) + { + /* Request Wait For Interrupt */ + __WFI(); + /* Reset SLEEPDEEP bit of Cortex System Control Register */ + SCB->SCR &= (uint32_t)~((uint32_t)SCB_SCR_SLEEPDEEP_Msk); + } + else if (PWR_STOPEntry == PWR_STOPEntry_WFE) + { + /* Request Wait For Event */ + __WFE(); + /* Reset SLEEPDEEP bit of Cortex System Control Register */ + SCB->SCR &= (uint32_t)~((uint32_t)SCB_SCR_SLEEPDEEP_Msk); + } + else + { + /* Set SLEEP on exit bit of Cortex-M0 System Control Register */ + SCB->SCR |= SCB_SCR_SLEEPONEXIT_Msk; + } +} + +/** + * @brief Enters STANDBY mode. + * @note In Standby mode, all I/O pins are high impedance except for: + * - Reset pad (still available) + * - RTC_AF1 pin (PC13) if configured for Wakeup pin 2 (WKUP2), tamper, + * time-stamp, RTC Alarm out, or RTC clock calibration out. + * - WKUP pin 1 (PA0) if enabled. + * @note The Wakeup flag (WUF) need to be cleared at application level before to call this function + * @param None + * @retval None + */ +void PWR_EnterSTANDBYMode(void) +{ + /* Select STANDBY mode */ + PWR->CR |= PWR_CR_PDDS; + + /* Set SLEEPDEEP bit of Cortex-M0 System Control Register */ + SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk; + + /* Request Wait For Interrupt */ + __WFI(); +} + +/** + * @} + */ + +/** @defgroup PWR_Group5 Flags management functions + * @brief Flags management functions + * +@verbatim + ============================================================================== + ##### Flags management functions ##### + ============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Checks whether the specified PWR flag is set or not. + * @param PWR_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg PWR_FLAG_WU: Wake Up flag. This flag indicates that a wakeup + * event was received from the WKUP pin or from the RTC alarm + * (Alarm A or Alarm B), RTC Tamper event or RTC TimeStamp event. + * @arg PWR_FLAG_SB: StandBy flag. This flag indicates that the + * system was resumed from StandBy mode. + * @arg PWR_FLAG_PVDO: PVD Output. This flag is valid only if PVD + * is enabled by the PWR_PVDCmd() function. + * @arg PWR_FLAG_VREFINTRDY: Internal Voltage Reference Ready flag. + * This flag indicates the state of the internal voltage + * reference, VREFINT. + * @retval The new state of PWR_FLAG (SET or RESET). + */ +FlagStatus PWR_GetFlagStatus(uint32_t PWR_FLAG) +{ + FlagStatus bitstatus = RESET; + /* Check the parameters */ + assert_param(IS_PWR_GET_FLAG(PWR_FLAG)); + + if ((PWR->CSR & PWR_FLAG) != (uint32_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + /* Return the flag status */ + return bitstatus; +} + +/** + * @brief Clears the PWR's pending flags. + * @param PWR_FLAG: specifies the flag to clear. + * This parameter can be one of the following values: + * @arg PWR_FLAG_WU: Wake Up flag + * @arg PWR_FLAG_SB: StandBy flag + * @retval None + */ +void PWR_ClearFlag(uint32_t PWR_FLAG) +{ + /* Check the parameters */ + assert_param(IS_PWR_CLEAR_FLAG(PWR_FLAG)); + + PWR->CR |= PWR_FLAG << 2; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_rcc.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_rcc.c new file mode 100644 index 00000000..f4f72c2a --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_rcc.c @@ -0,0 +1,1781 @@ +/** + ****************************************************************************** + * @file stm32f0xx_rcc.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Reset and clock control (RCC) peripheral: + * + Internal/external clocks, PLL, CSS and MCO configuration + * + System, AHB and APB busses clocks configuration + * + Peripheral clocks configuration + * + Interrupts and flags management + * + @verbatim + + =============================================================================== + ##### RCC specific features ##### + =============================================================================== + [..] After reset the device is running from HSI (8 MHz) with Flash 0 WS, + all peripherals are off except internal SRAM, Flash and SWD. + (#) There is no prescaler on High speed (AHB) and Low speed (APB) busses; + all peripherals mapped on these busses are running at HSI speed. + (#) The clock for all peripherals is switched off, except the SRAM and FLASH. + (#) All GPIOs are in input floating state, except the SWD pins which + are assigned to be used for debug purpose. + [..] Once the device started from reset, the user application has to: + (#) Configure the clock source to be used to drive the System clock + (if the application needs higher frequency/performance) + (#) Configure the System clock frequency and Flash settings + (#) Configure the AHB and APB busses prescalers + (#) Enable the clock for the peripheral(s) to be used + (#) Configure the clock source(s) for peripherals which clocks are not + derived from the System clock (ADC, CEC, I2C, USART, RTC and IWDG) + + @endverbatim + + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup RCC + * @brief RCC driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ + +/* ---------------------- RCC registers mask -------------------------------- */ +/* RCC Flag Mask */ +#define FLAG_MASK ((uint8_t)0x1F) + +/* CR register byte 2 (Bits[23:16]) base address */ +#define CR_BYTE2_ADDRESS ((uint32_t)0x40021002) + +/* CFGR register byte 3 (Bits[31:23]) base address */ +#define CFGR_BYTE3_ADDRESS ((uint32_t)0x40021007) + +/* CIR register byte 1 (Bits[15:8]) base address */ +#define CIR_BYTE1_ADDRESS ((uint32_t)0x40021009) + +/* CIR register byte 2 (Bits[23:16]) base address */ +#define CIR_BYTE2_ADDRESS ((uint32_t)0x4002100A) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +static __I uint8_t APBAHBPrescTable[16] = {0, 0, 0, 0, 1, 2, 3, 4, 1, 2, 3, 4, 6, 7, 8, 9}; + +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup RCC_Private_Functions + * @{ + */ + +/** @defgroup RCC_Group1 Internal and external clocks, PLL, CSS and MCO configuration functions + * @brief Internal and external clocks, PLL, CSS and MCO configuration functions + * +@verbatim + =============================================================================== + ##### Internal-external clocks, PLL, CSS and MCO configuration functions ##### + =============================================================================== + [..] This section provides functions allowing to configure the internal/external clocks, + PLL, CSS and MCO. + (#) HSI (high-speed internal), 8 MHz factory-trimmed RC used directly + or through the PLL as System clock source. + The HSI clock can be used also to clock the USART, I2C and CEC peripherals. + (#) HSI14 (high-speed internal for ADC), 14 MHz factory-trimmed RC used to clock + the ADC peripheral. + (#) LSI (low-speed internal), 40 KHz low consumption RC used as IWDG and/or RTC + clock source. + (#) HSE (high-speed external), 4 to 32 MHz crystal oscillator used directly or + through the PLL as System clock source. Can be used also as RTC clock source. + (#) LSE (low-speed external), 32 KHz oscillator used as RTC clock source. + LSE can be used also to clock the USART and CEC peripherals. + (#) PLL (clocked by HSI or HSE), for System clock. + (#) CSS (Clock security system), once enabled and if a HSE clock failure occurs + (HSE used directly or through PLL as System clock source), the System clock + is automatically switched to HSI and an interrupt is generated if enabled. + The interrupt is linked to the Cortex-M0 NMI (Non-Maskable Interrupt) + exception vector. + (#) MCO (microcontroller clock output), used to output SYSCLK, HSI, HSI14, LSI, + HSE, LSE or PLL (divided by 2) clock on PA8 pin. + +@endverbatim + * @{ + */ + +/** + * @brief Resets the RCC clock configuration to the default reset state. + * @note The default reset state of the clock configuration is given below: + * @note HSI ON and used as system clock source + * @note HSI14, HSE and PLL OFF + * @note AHB, APB prescaler set to 1. + * @note CSS and MCO OFF + * @note All interrupts disabled + * @note However, this function doesn't modify the configuration of the + * @note Peripheral clocks + * @note LSI, LSE and RTC clocks + * @param None + * @retval None + */ +void RCC_DeInit(void) +{ + /* Set HSION bit */ + RCC->CR |= (uint32_t)0x00000001; + +#if defined (STM32F051) + /* Reset SW[1:0], HPRE[3:0], PPRE[2:0] and MCOSEL[2:0] bits */ + RCC->CFGR &= (uint32_t)0xF8FFB80C; +#else + /* Reset SW[1:0], HPRE[3:0], PPRE[2:0], ADCPRE, MCOSEL[2:0], MCOPRE[2:0] and PLLNODIV bits */ + RCC->CFGR &= (uint32_t)0x08FFB80C; +#endif /* STM32F051 */ + + /* Reset HSEON, CSSON and PLLON bits */ + RCC->CR &= (uint32_t)0xFEF6FFFF; + + /* Reset HSEBYP bit */ + RCC->CR &= (uint32_t)0xFFFBFFFF; + + /* Reset PLLSRC, PLLXTPRE and PLLMUL[3:0] bits */ + RCC->CFGR &= (uint32_t)0xFFC0FFFF; + + /* Reset PREDIV1[3:0] bits */ + RCC->CFGR2 &= (uint32_t)0xFFFFFFF0; + + /* Reset USARTSW[1:0], I2CSW, CECSW and ADCSW bits */ + RCC->CFGR3 &= (uint32_t)0xFFF0FEAC; + + /* Reset HSI14 bit */ + RCC->CR2 &= (uint32_t)0xFFFFFFFE; + + /* Disable all interrupts */ + RCC->CIR = 0x00000000; +} + +/** + * @brief Configures the External High Speed oscillator (HSE). + * @note After enabling the HSE (RCC_HSE_ON or RCC_HSE_Bypass), the application + * software should wait on HSERDY flag to be set indicating that HSE clock + * is stable and can be used to clock the PLL and/or system clock. + * @note HSE state can not be changed if it is used directly or through the + * PLL as system clock. In this case, you have to select another source + * of the system clock then change the HSE state (ex. disable it). + * @note The HSE is stopped by hardware when entering STOP and STANDBY modes. + * @note This function resets the CSSON bit, so if the Clock security system(CSS) + * was previously enabled you have to enable it again after calling this + * function. + * @param RCC_HSE: specifies the new state of the HSE. + * This parameter can be one of the following values: + * @arg RCC_HSE_OFF: turn OFF the HSE oscillator, HSERDY flag goes low after + * 6 HSE oscillator clock cycles. + * @arg RCC_HSE_ON: turn ON the HSE oscillator + * @arg RCC_HSE_Bypass: HSE oscillator bypassed with external clock + * @retval None + */ +void RCC_HSEConfig(uint8_t RCC_HSE) +{ + /* Check the parameters */ + assert_param(IS_RCC_HSE(RCC_HSE)); + + /* Reset HSEON and HSEBYP bits before configuring the HSE ------------------*/ + *(__IO uint8_t *) CR_BYTE2_ADDRESS = RCC_HSE_OFF; + + /* Set the new HSE configuration -------------------------------------------*/ + *(__IO uint8_t *) CR_BYTE2_ADDRESS = RCC_HSE; + +} + +/** + * @brief Waits for HSE start-up. + * @note This function waits on HSERDY flag to be set and return SUCCESS if + * this flag is set, otherwise returns ERROR if the timeout is reached + * and this flag is not set. The timeout value is defined by the constant + * HSE_STARTUP_TIMEOUT in stm32f0xx.h file. You can tailor it depending + * on the HSE crystal used in your application. + * @note The HSE is stopped by hardware when entering STOP and STANDBY modes. + * @param None + * @retval An ErrorStatus enumeration value: + * - SUCCESS: HSE oscillator is stable and ready to use + * - ERROR: HSE oscillator not yet ready + */ +ErrorStatus RCC_WaitForHSEStartUp(void) +{ + __IO uint32_t StartUpCounter = 0; + ErrorStatus status = ERROR; + FlagStatus HSEStatus = RESET; + + /* Wait till HSE is ready and if timeout is reached exit */ + do + { + HSEStatus = RCC_GetFlagStatus(RCC_FLAG_HSERDY); + StartUpCounter++; + } while((StartUpCounter != HSE_STARTUP_TIMEOUT) && (HSEStatus == RESET)); + + if (RCC_GetFlagStatus(RCC_FLAG_HSERDY) != RESET) + { + status = SUCCESS; + } + else + { + status = ERROR; + } + return (status); +} + +/** + * @brief Adjusts the Internal High Speed oscillator (HSI) calibration value. + * @note The calibration is used to compensate for the variations in voltage + * and temperature that influence the frequency of the internal HSI RC. + * Refer to the Application Note AN4067 for more details on how to + * calibrate the HSI. + * @param HSICalibrationValue: specifies the HSI calibration trimming value. + * This parameter must be a number between 0 and 0x1F. + * @retval None + */ +void RCC_AdjustHSICalibrationValue(uint8_t HSICalibrationValue) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RCC_HSI_CALIBRATION_VALUE(HSICalibrationValue)); + + tmpreg = RCC->CR; + + /* Clear HSITRIM[4:0] bits */ + tmpreg &= ~RCC_CR_HSITRIM; + + /* Set the HSITRIM[4:0] bits according to HSICalibrationValue value */ + tmpreg |= (uint32_t)HSICalibrationValue << 3; + + /* Store the new value */ + RCC->CR = tmpreg; +} + +/** + * @brief Enables or disables the Internal High Speed oscillator (HSI). + * @note After enabling the HSI, the application software should wait on + * HSIRDY flag to be set indicating that HSI clock is stable and can + * be used to clock the PLL and/or system clock. + * @note HSI can not be stopped if it is used directly or through the PLL + * as system clock. In this case, you have to select another source + * of the system clock then stop the HSI. + * @note The HSI is stopped by hardware when entering STOP and STANDBY modes. + * @param NewState: new state of the HSI. + * This parameter can be: ENABLE or DISABLE. + * @note When the HSI is stopped, HSIRDY flag goes low after 6 HSI oscillator + * clock cycles. + * @retval None + */ +void RCC_HSICmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->CR |= RCC_CR_HSION; + } + else + { + RCC->CR &= ~RCC_CR_HSION; + } +} + +/** + * @brief Adjusts the Internal High Speed oscillator for ADC (HSI14) + * calibration value. + * @note The calibration is used to compensate for the variations in voltage + * and temperature that influence the frequency of the internal HSI RC. + * Refer to the Application Note AN4067 for more details on how to + * calibrate the HSI14. + * @param HSI14CalibrationValue: specifies the HSI14 calibration trimming value. + * This parameter must be a number between 0 and 0x1F. + * @retval None + */ +void RCC_AdjustHSI14CalibrationValue(uint8_t HSI14CalibrationValue) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RCC_HSI14_CALIBRATION_VALUE(HSI14CalibrationValue)); + + tmpreg = RCC->CR2; + + /* Clear HSI14TRIM[4:0] bits */ + tmpreg &= ~RCC_CR2_HSI14TRIM; + + /* Set the HSITRIM14[4:0] bits according to HSI14CalibrationValue value */ + tmpreg |= (uint32_t)HSI14CalibrationValue << 3; + + /* Store the new value */ + RCC->CR2 = tmpreg; +} + +/** + * @brief Enables or disables the Internal High Speed oscillator for ADC (HSI14). + * @note After enabling the HSI14, the application software should wait on + * HSIRDY flag to be set indicating that HSI clock is stable and can + * be used to clock the ADC. + * @note The HSI14 is stopped by hardware when entering STOP and STANDBY modes. + * @param NewState: new state of the HSI14. + * This parameter can be: ENABLE or DISABLE. + * @note When the HSI14 is stopped, HSI14RDY flag goes low after 6 HSI14 oscillator + * clock cycles. + * @retval None + */ +void RCC_HSI14Cmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->CR2 |= RCC_CR2_HSI14ON; + } + else + { + RCC->CR2 &= ~RCC_CR2_HSI14ON; + } +} + +/** + * @brief Enables or disables the Internal High Speed oscillator request from ADC. + * @param NewState: new state of the HSI14 ADC request. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_HSI14ADCRequestCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->CR2 &= ~RCC_CR2_HSI14DIS; + } + else + { + RCC->CR2 |= RCC_CR2_HSI14DIS; + } +} + +/** + * @brief Configures the External Low Speed oscillator (LSE). + * @note As the LSE is in the Backup domain and write access is denied to this + * domain after reset, you have to enable write access using + * PWR_BackupAccessCmd(ENABLE) function before to configure the LSE + * (to be done once after reset). + * @note After enabling the LSE (RCC_LSE_ON or RCC_LSE_Bypass), the application + * software should wait on LSERDY flag to be set indicating that LSE clock + * is stable and can be used to clock the RTC. + * @param RCC_LSE: specifies the new state of the LSE. + * This parameter can be one of the following values: + * @arg RCC_LSE_OFF: turn OFF the LSE oscillator, LSERDY flag goes low after + * 6 LSE oscillator clock cycles. + * @arg RCC_LSE_ON: turn ON the LSE oscillator + * @arg RCC_LSE_Bypass: LSE oscillator bypassed with external clock + * @retval None + */ +void RCC_LSEConfig(uint32_t RCC_LSE) +{ + /* Check the parameters */ + assert_param(IS_RCC_LSE(RCC_LSE)); + + /* Reset LSEON and LSEBYP bits before configuring the LSE ------------------*/ + /* Reset LSEON bit */ + RCC->BDCR &= ~(RCC_BDCR_LSEON); + + /* Reset LSEBYP bit */ + RCC->BDCR &= ~(RCC_BDCR_LSEBYP); + + /* Configure LSE */ + RCC->BDCR |= RCC_LSE; +} + +/** + * @brief Configures the External Low Speed oscillator (LSE) drive capability. + * @param RCC_LSEDrive: specifies the new state of the LSE drive capability. + * This parameter can be one of the following values: + * @arg RCC_LSEDrive_Low: LSE oscillator low drive capability. + * @arg RCC_LSEDrive_MediumLow: LSE oscillator medium low drive capability. + * @arg RCC_LSEDrive_MediumHigh: LSE oscillator medium high drive capability. + * @arg RCC_LSEDrive_High: LSE oscillator high drive capability. + * @retval None + */ +void RCC_LSEDriveConfig(uint32_t RCC_LSEDrive) +{ + /* Check the parameters */ + assert_param(IS_RCC_LSE_DRIVE(RCC_LSEDrive)); + + /* Clear LSEDRV[1:0] bits */ + RCC->BDCR &= ~(RCC_BDCR_LSEDRV); + + /* Set the LSE Drive */ + RCC->BDCR |= RCC_LSEDrive; +} + +/** + * @brief Enables or disables the Internal Low Speed oscillator (LSI). + * @note After enabling the LSI, the application software should wait on + * LSIRDY flag to be set indicating that LSI clock is stable and can + * be used to clock the IWDG and/or the RTC. + * @note LSI can not be disabled if the IWDG is running. + * @param NewState: new state of the LSI. + * This parameter can be: ENABLE or DISABLE. + * @note When the LSI is stopped, LSIRDY flag goes low after 6 LSI oscillator + * clock cycles. + * @retval None + */ +void RCC_LSICmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->CSR |= RCC_CSR_LSION; + } + else + { + RCC->CSR &= ~RCC_CSR_LSION; + } +} + +/** + * @brief Configures the PLL clock source and multiplication factor. + * @note This function must be used only when the PLL is disabled. + * + * @param RCC_PLLSource: specifies the PLL entry clock source. + * This parameter can be one of the following values: + * @arg RCC_PLLSource_HSI_Div2: HSI oscillator clock selected as PLL clock source + * @arg RCC_PLLSource_PREDIV1: PREDIV1 clock selected as PLL clock entry + * @arg RCC_PLLSource_HSI48 HSI48 oscillator clock selected as PLL clock source, applicable only for STM32F072 devices + * @arg RCC_PLLSource_HSI: HSI clock selected as PLL clock entry, applicable only for STM32F072 devices + * @note The minimum input clock frequency for PLL is 2 MHz (when using HSE as + * PLL source). + * + * @param RCC_PLLMul: specifies the PLL multiplication factor, which drive the PLLVCO clock + * This parameter can be RCC_PLLMul_x where x:[2,16] + * + * @retval None + */ +void RCC_PLLConfig(uint32_t RCC_PLLSource, uint32_t RCC_PLLMul) +{ + /* Check the parameters */ + assert_param(IS_RCC_PLL_SOURCE(RCC_PLLSource)); + assert_param(IS_RCC_PLL_MUL(RCC_PLLMul)); + + /* Clear PLL Source [16] and Multiplier [21:18] bits */ + RCC->CFGR &= ~(RCC_CFGR_PLLMULL | RCC_CFGR_PLLSRC); + + /* Set the PLL Source and Multiplier */ + RCC->CFGR |= (uint32_t)(RCC_PLLSource | RCC_PLLMul); +} + +/** + * @brief Enables or disables the PLL. + * @note After enabling the PLL, the application software should wait on + * PLLRDY flag to be set indicating that PLL clock is stable and can + * be used as system clock source. + * @note The PLL can not be disabled if it is used as system clock source + * @note The PLL is disabled by hardware when entering STOP and STANDBY modes. + * @param NewState: new state of the PLL. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_PLLCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->CR |= RCC_CR_PLLON; + } + else + { + RCC->CR &= ~RCC_CR_PLLON; + } +} + +/** + * @brief Enables or disables the Internal High Speed oscillator for USB (HSI48). + * This function is only applicable for STM32F072 devices. + * @note After enabling the HSI48, the application software should wait on + * HSI48RDY flag to be set indicating that HSI48 clock is stable and can + * be used to clock the USB. + * @note The HSI48 is stopped by hardware when entering STOP and STANDBY modes. + * @param NewState: new state of the HSI48. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_HSI48Cmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->CR2 |= RCC_CR2_HSI48ON; + } + else + { + RCC->CR2 &= ~RCC_CR2_HSI48ON; + } +} + +/** + * @brief Configures the PREDIV1 division factor. + * @note This function must be used only when the PLL is disabled. + * @param RCC_PREDIV1_Div: specifies the PREDIV1 clock division factor. + * This parameter can be RCC_PREDIV1_Divx where x:[1,16] + * @retval None + */ +void RCC_PREDIV1Config(uint32_t RCC_PREDIV1_Div) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RCC_PREDIV1(RCC_PREDIV1_Div)); + + tmpreg = RCC->CFGR2; + /* Clear PREDIV1[3:0] bits */ + tmpreg &= ~(RCC_CFGR2_PREDIV1); + /* Set the PREDIV1 division factor */ + tmpreg |= RCC_PREDIV1_Div; + /* Store the new value */ + RCC->CFGR2 = tmpreg; +} + +/** + * @brief Enables or disables the Clock Security System. + * @note If a failure is detected on the HSE oscillator clock, this oscillator + * is automatically disabled and an interrupt is generated to inform the + * software about the failure (Clock Security System Interrupt, CSSI), + * allowing the MCU to perform rescue operations. The CSSI is linked to + * the Cortex-M0 NMI (Non-Maskable Interrupt) exception vector. + * @param NewState: new state of the Clock Security System. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_ClockSecuritySystemCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->CR |= RCC_CR_CSSON; + } + else + { + RCC->CR &= ~RCC_CR_CSSON; + } +} + +#ifdef STM32F051 +/** + * @brief Selects the clock source to output on MCO pin (PA8). + * @note PA8 should be configured in alternate function mode. + * @param RCC_MCOSource: specifies the clock source to output. + * This parameter can be one of the following values: + * @arg RCC_MCOSource_NoClock: No clock selected. + * @arg RCC_MCOSource_HSI14: HSI14 oscillator clock selected. + * @arg RCC_MCOSource_LSI: LSI oscillator clock selected. + * @arg RCC_MCOSource_LSE: LSE oscillator clock selected. + * @arg RCC_MCOSource_SYSCLK: System clock selected. + * @arg RCC_MCOSource_HSI: HSI oscillator clock selected. + * @arg RCC_MCOSource_HSE: HSE oscillator clock selected. + * @arg RCC_MCOSource_PLLCLK_Div2: PLL clock divided by 2 selected. + * @retval None + */ +void RCC_MCOConfig(uint8_t RCC_MCOSource) +{ + /* Check the parameters */ + assert_param(IS_RCC_MCO_SOURCE(RCC_MCOSource)); + + /* Select MCO clock source and prescaler */ + *(__IO uint8_t *) CFGR_BYTE3_ADDRESS = RCC_MCOSource; +} +#else + +/** + * @brief Selects the clock source to output on MCO pin (PA8) and the corresponding + * prescsaler. + * @note PA8 should be configured in alternate function mode. + * @param RCC_MCOSource: specifies the clock source to output. + * This parameter can be one of the following values: + * @arg RCC_MCOSource_NoClock: No clock selected. + * @arg RCC_MCOSource_HSI14: HSI14 oscillator clock selected. + * @arg RCC_MCOSource_LSI: LSI oscillator clock selected. + * @arg RCC_MCOSource_LSE: LSE oscillator clock selected. + * @arg RCC_MCOSource_SYSCLK: System clock selected. + * @arg RCC_MCOSource_HSI: HSI oscillator clock selected. + * @arg RCC_MCOSource_HSE: HSE oscillator clock selected. + * @arg RCC_MCOSource_PLLCLK_Div2: PLL clock divided by 2 selected. + * @arg RCC_MCOSource_PLLCLK: PLL clock selected. + * @arg RCC_MCOSource_HSI48: HSI48 clock selected. + * @param RCC_MCOPrescaler: specifies the prescaler on MCO pin. + * This parameter can be one of the following values: + * @arg RCC_MCOPrescaler_1: MCO clock is divided by 1. + * @arg RCC_MCOPrescaler_2: MCO clock is divided by 2. + * @arg RCC_MCOPrescaler_4: MCO clock is divided by 4. + * @arg RCC_MCOPrescaler_8: MCO clock is divided by 8. + * @arg RCC_MCOPrescaler_16: MCO clock is divided by 16. + * @arg RCC_MCOPrescaler_32: MCO clock is divided by 32. + * @arg RCC_MCOPrescaler_64: MCO clock is divided by 64. + * @arg RCC_MCOPrescaler_128: MCO clock is divided by 128. + * @retval None + */ +void RCC_MCOConfig(uint8_t RCC_MCOSource, uint32_t RCC_MCOPrescaler) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RCC_MCO_SOURCE(RCC_MCOSource)); + assert_param(IS_RCC_MCO_PRESCALER(RCC_MCOPrescaler)); + + /* Get CFGR value */ + tmpreg = RCC->CFGR; + /* Clear MCOPRE[2:0] bits */ + tmpreg &= ~(RCC_CFGR_MCO_PRE | RCC_CFGR_MCO | RCC_CFGR_PLLNODIV); + /* Set the RCC_MCOSource and RCC_MCOPrescaler */ + tmpreg |= (RCC_MCOPrescaler | ((uint32_t)RCC_MCOSource<<24)); + /* Store the new value */ + RCC->CFGR = tmpreg; +} +#endif /* STM32F072 */ + +/** + * @} + */ + +/** @defgroup RCC_Group2 System AHB and APB busses clocks configuration functions + * @brief System, AHB and APB busses clocks configuration functions + * +@verbatim + =============================================================================== + ##### System, AHB and APB busses clocks configuration functions ##### + =============================================================================== + + [..] This section provide functions allowing to configure the System, AHB and + APB busses clocks. + (#) Several clock sources can be used to drive the System clock (SYSCLK): HSI, + HSE and PLL. + The AHB clock (HCLK) is derived from System clock through configurable prescaler + and used to clock the CPU, memory and peripherals mapped on AHB bus (DMA and GPIO). + and APB (PCLK) clocks are derived from AHB clock through + configurable prescalers and used to clock the peripherals mapped on these busses. + You can use "RCC_GetClocksFreq()" function to retrieve the frequencies of these clocks. + + -@- All the peripheral clocks are derived from the System clock (SYSCLK) except: + (+@) The ADC clock which is derived from HSI14 or APB (APB divided by a + programmable prescaler: 2 or 4). + (+@) The CEC clock which is derived from LSE or HSI divided by 244. + (+@) The I2C clock which is derived from HSI or system clock (SYSCLK). + (+@) The USART clock which is derived from HSI, system clock (SYSCLK), APB or LSE. + (+@) The RTC/LCD clock which is derived from the LSE, LSI or 2 MHz HSE_RTC (HSE + divided by a programmable prescaler). + The System clock (SYSCLK) frequency must be higher or equal to the RTC/LCD + clock frequency. + (+@) IWDG clock which is always the LSI clock. + + (#) The maximum frequency of the SYSCLK, HCLK and PCLK is 48 MHz. + Depending on the maximum frequency, the FLASH wait states (WS) should be + adapted accordingly: + +--------------------------------------------- + + | Wait states | HCLK clock frequency (MHz) | + |---------------|------------------------------| + |0WS(1CPU cycle)| 0 < HCLK <= 24 | + |---------------|------------------------------| + |1WS(2CPU cycle)| 24 < HCLK <= 48 | + +----------------------------------------------+ + + (#) After reset, the System clock source is the HSI (8 MHz) with 0 WS and + prefetch is disabled. + + [..] It is recommended to use the following software sequences to tune the number + of wait states needed to access the Flash memory with the CPU frequency (HCLK). + (+) Increasing the CPU frequency + (++) Program the Flash Prefetch buffer, using "FLASH_PrefetchBufferCmd(ENABLE)" + function + (++) Check that Flash Prefetch buffer activation is taken into account by + reading FLASH_ACR using the FLASH_GetPrefetchBufferStatus() function + (++) Program Flash WS to 1, using "FLASH_SetLatency(FLASH_Latency_1)" function + (++) Check that the new number of WS is taken into account by reading FLASH_ACR + (++) Modify the CPU clock source, using "RCC_SYSCLKConfig()" function + (++) If needed, modify the CPU clock prescaler by using "RCC_HCLKConfig()" function + (++) Check that the new CPU clock source is taken into account by reading + the clock source status, using "RCC_GetSYSCLKSource()" function + (+) Decreasing the CPU frequency + (++) Modify the CPU clock source, using "RCC_SYSCLKConfig()" function + (++) If needed, modify the CPU clock prescaler by using "RCC_HCLKConfig()" function + (++) Check that the new CPU clock source is taken into account by reading + the clock source status, using "RCC_GetSYSCLKSource()" function + (++) Program the new number of WS, using "FLASH_SetLatency()" function + (++) Check that the new number of WS is taken into account by reading FLASH_ACR + (++) Disable the Flash Prefetch buffer using "FLASH_PrefetchBufferCmd(DISABLE)" + function + (++) Check that Flash Prefetch buffer deactivation is taken into account by reading FLASH_ACR + using the FLASH_GetPrefetchBufferStatus() function. + +@endverbatim + * @{ + */ + +/** + * @brief Configures the system clock (SYSCLK). + * @note The HSI is used (enabled by hardware) as system clock source after + * startup from Reset, wake-up from STOP and STANDBY mode, or in case + * of failure of the HSE used directly or indirectly as system clock + * (if the Clock Security System CSS is enabled). + * @note A switch from one clock source to another occurs only if the target + * clock source is ready (clock stable after startup delay or PLL locked). + * If a clock source which is not yet ready is selected, the switch will + * occur when the clock source will be ready. + * You can use RCC_GetSYSCLKSource() function to know which clock is + * currently used as system clock source. + * @param RCC_SYSCLKSource: specifies the clock source used as system clock source + * This parameter can be one of the following values: + * @arg RCC_SYSCLKSource_HSI: HSI selected as system clock source + * @arg RCC_SYSCLKSource_HSE: HSE selected as system clock source + * @arg RCC_SYSCLKSource_PLLCLK: PLL selected as system clock source + * @arg RCC_SYSCLKSource_HSI48: HSI48 selected as system clock source, applicable only for STM32F072 devices + * @retval None + */ +void RCC_SYSCLKConfig(uint32_t RCC_SYSCLKSource) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RCC_SYSCLK_SOURCE(RCC_SYSCLKSource)); + + tmpreg = RCC->CFGR; + + /* Clear SW[1:0] bits */ + tmpreg &= ~RCC_CFGR_SW; + + /* Set SW[1:0] bits according to RCC_SYSCLKSource value */ + tmpreg |= RCC_SYSCLKSource; + + /* Store the new value */ + RCC->CFGR = tmpreg; +} + +/** + * @brief Returns the clock source used as system clock. + * @param None + * @retval The clock source used as system clock. The returned value can be one + * of the following values: + * - 0x00: HSI used as system clock + * - 0x04: HSE used as system clock + * - 0x08: PLL used as system clock + * - 0x0C: HSI48 used as system clock, applicable only for STM32F072 devices + */ +uint8_t RCC_GetSYSCLKSource(void) +{ + return ((uint8_t)(RCC->CFGR & RCC_CFGR_SWS)); +} + +/** + * @brief Configures the AHB clock (HCLK). + * @param RCC_SYSCLK: defines the AHB clock divider. This clock is derived from + * the system clock (SYSCLK). + * This parameter can be one of the following values: + * @arg RCC_SYSCLK_Div1: AHB clock = SYSCLK + * @arg RCC_SYSCLK_Div2: AHB clock = SYSCLK/2 + * @arg RCC_SYSCLK_Div4: AHB clock = SYSCLK/4 + * @arg RCC_SYSCLK_Div8: AHB clock = SYSCLK/8 + * @arg RCC_SYSCLK_Div16: AHB clock = SYSCLK/16 + * @arg RCC_SYSCLK_Div64: AHB clock = SYSCLK/64 + * @arg RCC_SYSCLK_Div128: AHB clock = SYSCLK/128 + * @arg RCC_SYSCLK_Div256: AHB clock = SYSCLK/256 + * @arg RCC_SYSCLK_Div512: AHB clock = SYSCLK/512 + * @retval None + */ +void RCC_HCLKConfig(uint32_t RCC_SYSCLK) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RCC_HCLK(RCC_SYSCLK)); + + tmpreg = RCC->CFGR; + + /* Clear HPRE[3:0] bits */ + tmpreg &= ~RCC_CFGR_HPRE; + + /* Set HPRE[3:0] bits according to RCC_SYSCLK value */ + tmpreg |= RCC_SYSCLK; + + /* Store the new value */ + RCC->CFGR = tmpreg; +} + +/** + * @brief Configures the APB clock (PCLK). + * @param RCC_HCLK: defines the APB clock divider. This clock is derived from + * the AHB clock (HCLK). + * This parameter can be one of the following values: + * @arg RCC_HCLK_Div1: APB clock = HCLK + * @arg RCC_HCLK_Div2: APB clock = HCLK/2 + * @arg RCC_HCLK_Div4: APB clock = HCLK/4 + * @arg RCC_HCLK_Div8: APB clock = HCLK/8 + * @arg RCC_HCLK_Div16: APB clock = HCLK/16 + * @retval None + */ +void RCC_PCLKConfig(uint32_t RCC_HCLK) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RCC_PCLK(RCC_HCLK)); + + tmpreg = RCC->CFGR; + + /* Clear PPRE[2:0] bits */ + tmpreg &= ~RCC_CFGR_PPRE; + + /* Set PPRE[2:0] bits according to RCC_HCLK value */ + tmpreg |= RCC_HCLK; + + /* Store the new value */ + RCC->CFGR = tmpreg; +} + +/** + * @brief Configures the ADC clock (ADCCLK). + * @note This function is obsolete. + * For proper ADC clock selection, refer to ADC_ClockModeConfig() in the ADC driver + * @param RCC_ADCCLK: defines the ADC clock source. This clock is derived + * from the HSI14 or APB clock (PCLK). + * This parameter can be one of the following values: + * @arg RCC_ADCCLK_HSI14: ADC clock = HSI14 (14MHz) + * @arg RCC_ADCCLK_PCLK_Div2: ADC clock = PCLK/2 + * @arg RCC_ADCCLK_PCLK_Div4: ADC clock = PCLK/4 + * @retval None + */ +void RCC_ADCCLKConfig(uint32_t RCC_ADCCLK) +{ + /* Check the parameters */ + assert_param(IS_RCC_ADCCLK(RCC_ADCCLK)); + + /* Clear ADCPRE bit */ + RCC->CFGR &= ~RCC_CFGR_ADCPRE; + /* Set ADCPRE bits according to RCC_PCLK value */ + RCC->CFGR |= RCC_ADCCLK & 0xFFFF; + + /* Clear ADCSW bit */ + RCC->CFGR3 &= ~RCC_CFGR3_ADCSW; + /* Set ADCSW bits according to RCC_ADCCLK value */ + RCC->CFGR3 |= RCC_ADCCLK >> 16; +} + +/** + * @brief Configures the CEC clock (CECCLK). + * @param RCC_CECCLK: defines the CEC clock source. This clock is derived + * from the HSI or LSE clock. + * This parameter can be one of the following values: + * @arg RCC_CECCLK_HSI_Div244: CEC clock = HSI/244 (32768Hz) + * @arg RCC_CECCLK_LSE: CEC clock = LSE + * @retval None + */ +void RCC_CECCLKConfig(uint32_t RCC_CECCLK) +{ + /* Check the parameters */ + assert_param(IS_RCC_CECCLK(RCC_CECCLK)); + + /* Clear CECSW bit */ + RCC->CFGR3 &= ~RCC_CFGR3_CECSW; + /* Set CECSW bits according to RCC_CECCLK value */ + RCC->CFGR3 |= RCC_CECCLK; +} + +/** + * @brief Configures the I2C1 clock (I2C1CLK). + * @param RCC_I2CCLK: defines the I2C1 clock source. This clock is derived + * from the HSI or System clock. + * This parameter can be one of the following values: + * @arg RCC_I2C1CLK_HSI: I2C1 clock = HSI + * @arg RCC_I2C1CLK_SYSCLK: I2C1 clock = System Clock + * @retval None + */ +void RCC_I2CCLKConfig(uint32_t RCC_I2CCLK) +{ + /* Check the parameters */ + assert_param(IS_RCC_I2CCLK(RCC_I2CCLK)); + + /* Clear I2CSW bit */ + RCC->CFGR3 &= ~RCC_CFGR3_I2C1SW; + /* Set I2CSW bits according to RCC_I2CCLK value */ + RCC->CFGR3 |= RCC_I2CCLK; +} + +/** + * @brief Configures the USART1 clock (USART1CLK). + * @param RCC_USARTCLK: defines the USART clock source. This clock is derived + * from the HSI or System clock. + * This parameter can be one of the following values: + * @arg RCC_USART1CLK_PCLK: USART1 clock = APB Clock (PCLK) + * @arg RCC_USART1CLK_SYSCLK: USART1 clock = System Clock + * @arg RCC_USART1CLK_LSE: USART1 clock = LSE Clock + * @arg RCC_USART1CLK_HSI: USART1 clock = HSI Clock + * @arg RCC_USART2CLK_PCLK: USART2 clock = APB Clock (PCLK), applicable only for STM32F072 and STM32F091 devices + * @arg RCC_USART2CLK_SYSCLK: USART2 clock = System Clock, applicable only for STM32F072 and STM32F091 devices + * @arg RCC_USART2CLK_LSE: USART2 clock = LSE Clock, applicable only for STM32F072 and STM32F091 devices + * @arg RCC_USART2CLK_HSI: USART2 clock = HSI Clock, applicable only for STM32F072 and STM32F091 devices + * @arg RCC_USART3CLK_PCLK: USART3 clock = APB Clock (PCLK), applicable only for STM32F091 devices + * @arg RCC_USART3CLK_SYSCLK: USART3 clock = System Clock, applicable only for STM32F091 devices + * @arg RCC_USART3CLK_LSE: USART3 clock = LSE Clock, applicable only for STM32F091 devices + * @arg RCC_USART3CLK_HSI: USART3 clock = HSI Clock, applicable only for STM32F091 devices + * @retval None + */ +void RCC_USARTCLKConfig(uint32_t RCC_USARTCLK) +{ + uint32_t tmp = 0; + + /* Check the parameters */ + assert_param(IS_RCC_USARTCLK(RCC_USARTCLK)); + + /* Get USART index */ + tmp = (RCC_USARTCLK >> 28); + + /* Clear USARTSW[1:0] bit */ + if (tmp == (uint32_t)0x00000001) + { + /* Clear USART1SW[1:0] bit */ + RCC->CFGR3 &= ~RCC_CFGR3_USART1SW; + } + else if (tmp == (uint32_t)0x00000002) + { + /* Clear USART2SW[1:0] bit */ + RCC->CFGR3 &= ~RCC_CFGR3_USART2SW; + } + else + { + /* Clear USART3SW[1:0] bit */ + RCC->CFGR3 &= ~RCC_CFGR3_USART3SW; + } + + /* Set USARTxSW bits according to RCC_USARTCLK value */ + RCC->CFGR3 |= RCC_USARTCLK; +} + +/** + * @brief Configures the USB clock (USBCLK). + * This function is only applicable for STM32F072 devices. + * @param RCC_USBCLK: defines the USB clock source. This clock is derived + * from the HSI48 or system clock. + * This parameter can be one of the following values: + * @arg RCC_USBCLK_HSI48: USB clock = HSI48 + * @arg RCC_USBCLK_PLLCLK: USB clock = PLL clock + * @retval None + */ +void RCC_USBCLKConfig(uint32_t RCC_USBCLK) +{ + /* Check the parameters */ + assert_param(IS_RCC_USBCLK(RCC_USBCLK)); + + /* Clear USBSW bit */ + RCC->CFGR3 &= ~RCC_CFGR3_USBSW; + /* Set USBSW bits according to RCC_USBCLK value */ + RCC->CFGR3 |= RCC_USBCLK; +} + +/** + * @brief Returns the frequencies of the System, AHB and APB busses clocks. + * @note The frequency returned by this function is not the real frequency + * in the chip. It is calculated based on the predefined constant and + * the source selected by RCC_SYSCLKConfig(): + * + * @note If SYSCLK source is HSI, function returns constant HSI_VALUE(*) + * + * @note If SYSCLK source is HSE, function returns constant HSE_VALUE(**) + * + * @note If SYSCLK source is PLL, function returns constant HSE_VALUE(**) + * or HSI_VALUE(*) multiplied by the PLL factors. + * + * @note If SYSCLK source is HSI48, function returns constant HSI48_VALUE(***) + * + * @note (*) HSI_VALUE is a constant defined in stm32f0xx.h file (default value + * 8 MHz) but the real value may vary depending on the variations + * in voltage and temperature, refer to RCC_AdjustHSICalibrationValue(). + * + * @note (**) HSE_VALUE is a constant defined in stm32f0xx.h file (default value + * 8 MHz), user has to ensure that HSE_VALUE is same as the real + * frequency of the crystal used. Otherwise, this function may + * return wrong result. + * + * @note (***) HSI48_VALUE is a constant defined in stm32f0xx.h file (default value + * 48 MHz) but the real value may vary depending on the variations + * in voltage and temperature. + * + * @note The result of this function could be not correct when using fractional + * value for HSE crystal. + * + * @param RCC_Clocks: pointer to a RCC_ClocksTypeDef structure which will hold + * the clocks frequencies. + * + * @note This function can be used by the user application to compute the + * baudrate for the communication peripherals or configure other parameters. + * @note Each time SYSCLK, HCLK and/or PCLK clock changes, this function + * must be called to update the structure's field. Otherwise, any + * configuration based on this function will be incorrect. + * + * @retval None + */ +void RCC_GetClocksFreq(RCC_ClocksTypeDef* RCC_Clocks) +{ + uint32_t tmp = 0, pllmull = 0, pllsource = 0, prediv1factor = 0, presc = 0, pllclk = 0; + + /* Get SYSCLK source -------------------------------------------------------*/ + tmp = RCC->CFGR & RCC_CFGR_SWS; + + switch (tmp) + { + case 0x00: /* HSI used as system clock */ + RCC_Clocks->SYSCLK_Frequency = HSI_VALUE; + break; + case 0x04: /* HSE used as system clock */ + RCC_Clocks->SYSCLK_Frequency = HSE_VALUE; + break; + case 0x08: /* PLL used as system clock */ + /* Get PLL clock source and multiplication factor ----------------------*/ + pllmull = RCC->CFGR & RCC_CFGR_PLLMULL; + pllsource = RCC->CFGR & RCC_CFGR_PLLSRC; + pllmull = ( pllmull >> 18) + 2; + + if (pllsource == 0x00) + { + /* HSI oscillator clock divided by 2 selected as PLL clock entry */ + pllclk = (HSI_VALUE >> 1) * pllmull; + } + else + { + prediv1factor = (RCC->CFGR2 & RCC_CFGR2_PREDIV1) + 1; + /* HSE oscillator clock selected as PREDIV1 clock entry */ + pllclk = (HSE_VALUE / prediv1factor) * pllmull; + } + RCC_Clocks->SYSCLK_Frequency = pllclk; + break; + case 0x0C: /* HSI48 used as system clock */ + RCC_Clocks->SYSCLK_Frequency = HSI48_VALUE; + break; + default: /* HSI used as system clock */ + RCC_Clocks->SYSCLK_Frequency = HSI_VALUE; + break; + } + /* Compute HCLK, PCLK clocks frequencies -----------------------------------*/ + /* Get HCLK prescaler */ + tmp = RCC->CFGR & RCC_CFGR_HPRE; + tmp = tmp >> 4; + presc = APBAHBPrescTable[tmp]; + /* HCLK clock frequency */ + RCC_Clocks->HCLK_Frequency = RCC_Clocks->SYSCLK_Frequency >> presc; + + /* Get PCLK prescaler */ + tmp = RCC->CFGR & RCC_CFGR_PPRE; + tmp = tmp >> 8; + presc = APBAHBPrescTable[tmp]; + /* PCLK clock frequency */ + RCC_Clocks->PCLK_Frequency = RCC_Clocks->HCLK_Frequency >> presc; + + /* ADCCLK clock frequency */ + if((RCC->CFGR3 & RCC_CFGR3_ADCSW) != RCC_CFGR3_ADCSW) + { + /* ADC Clock is HSI14 Osc. */ + RCC_Clocks->ADCCLK_Frequency = HSI14_VALUE; + } + else + { + if((RCC->CFGR & RCC_CFGR_ADCPRE) != RCC_CFGR_ADCPRE) + { + /* ADC Clock is derived from PCLK/2 */ + RCC_Clocks->ADCCLK_Frequency = RCC_Clocks->PCLK_Frequency >> 1; + } + else + { + /* ADC Clock is derived from PCLK/4 */ + RCC_Clocks->ADCCLK_Frequency = RCC_Clocks->PCLK_Frequency >> 2; + } + + } + + /* CECCLK clock frequency */ + if((RCC->CFGR3 & RCC_CFGR3_CECSW) != RCC_CFGR3_CECSW) + { + /* CEC Clock is HSI/244 */ + RCC_Clocks->CECCLK_Frequency = HSI_VALUE / 244; + } + else + { + /* CECC Clock is LSE Osc. */ + RCC_Clocks->CECCLK_Frequency = LSE_VALUE; + } + + /* I2C1CLK clock frequency */ + if((RCC->CFGR3 & RCC_CFGR3_I2C1SW) != RCC_CFGR3_I2C1SW) + { + /* I2C1 Clock is HSI Osc. */ + RCC_Clocks->I2C1CLK_Frequency = HSI_VALUE; + } + else + { + /* I2C1 Clock is System Clock */ + RCC_Clocks->I2C1CLK_Frequency = RCC_Clocks->SYSCLK_Frequency; + } + + /* USART1CLK clock frequency */ + if((RCC->CFGR3 & RCC_CFGR3_USART1SW) == 0x0) + { + /* USART1 Clock is PCLK */ + RCC_Clocks->USART1CLK_Frequency = RCC_Clocks->PCLK_Frequency; + } + else if((RCC->CFGR3 & RCC_CFGR3_USART1SW) == RCC_CFGR3_USART1SW_0) + { + /* USART1 Clock is System Clock */ + RCC_Clocks->USART1CLK_Frequency = RCC_Clocks->SYSCLK_Frequency; + } + else if((RCC->CFGR3 & RCC_CFGR3_USART1SW) == RCC_CFGR3_USART1SW_1) + { + /* USART1 Clock is LSE Osc. */ + RCC_Clocks->USART1CLK_Frequency = LSE_VALUE; + } + else if((RCC->CFGR3 & RCC_CFGR3_USART1SW) == RCC_CFGR3_USART1SW) + { + /* USART1 Clock is HSI Osc. */ + RCC_Clocks->USART1CLK_Frequency = HSI_VALUE; + } + + /* USART2CLK clock frequency */ + if((RCC->CFGR3 & RCC_CFGR3_USART2SW) == 0x0) + { + /* USART Clock is PCLK */ + RCC_Clocks->USART2CLK_Frequency = RCC_Clocks->PCLK_Frequency; + } + else if((RCC->CFGR3 & RCC_CFGR3_USART2SW) == RCC_CFGR3_USART2SW_0) + { + /* USART Clock is System Clock */ + RCC_Clocks->USART2CLK_Frequency = RCC_Clocks->SYSCLK_Frequency; + } + else if((RCC->CFGR3 & RCC_CFGR3_USART2SW) == RCC_CFGR3_USART2SW_1) + { + /* USART Clock is LSE Osc. */ + RCC_Clocks->USART2CLK_Frequency = LSE_VALUE; + } + else if((RCC->CFGR3 & RCC_CFGR3_USART2SW) == RCC_CFGR3_USART2SW) + { + /* USART Clock is HSI Osc. */ + RCC_Clocks->USART2CLK_Frequency = HSI_VALUE; + } + + /* USART3CLK clock frequency */ + if((RCC->CFGR3 & RCC_CFGR3_USART3SW) == 0x0) + { + /* USART Clock is PCLK */ + RCC_Clocks->USART3CLK_Frequency = RCC_Clocks->PCLK_Frequency; + } + else if((RCC->CFGR3 & RCC_CFGR3_USART3SW) == RCC_CFGR3_USART3SW_0) + { + /* USART Clock is System Clock */ + RCC_Clocks->USART3CLK_Frequency = RCC_Clocks->SYSCLK_Frequency; + } + else if((RCC->CFGR3 & RCC_CFGR3_USART3SW) == RCC_CFGR3_USART3SW_1) + { + /* USART Clock is LSE Osc. */ + RCC_Clocks->USART3CLK_Frequency = LSE_VALUE; + } + else if((RCC->CFGR3 & RCC_CFGR3_USART3SW) == RCC_CFGR3_USART3SW) + { + /* USART Clock is HSI Osc. */ + RCC_Clocks->USART3CLK_Frequency = HSI_VALUE; + } + + /* USBCLK clock frequency */ + if((RCC->CFGR3 & RCC_CFGR3_USBSW) != RCC_CFGR3_USBSW) + { + /* USB Clock is HSI48 */ + RCC_Clocks->USBCLK_Frequency = HSI48_VALUE; + } + else + { + /* USB Clock is PLL clock */ + RCC_Clocks->USBCLK_Frequency = pllclk; + } +} + +/** + * @} + */ + +/** @defgroup RCC_Group3 Peripheral clocks configuration functions + * @brief Peripheral clocks configuration functions + * +@verbatim + =============================================================================== + #####Peripheral clocks configuration functions ##### + =============================================================================== + + [..] This section provide functions allowing to configure the Peripheral clocks. + (#) The RTC clock which is derived from the LSE, LSI or HSE_Div32 (HSE + divided by 32). + (#) After restart from Reset or wakeup from STANDBY, all peripherals are off + except internal SRAM, Flash and SWD. Before to start using a peripheral you + have to enable its interface clock. You can do this using RCC_AHBPeriphClockCmd(), + RCC_APB2PeriphClockCmd() and RCC_APB1PeriphClockCmd() functions. + (#) To reset the peripherals configuration (to the default state after device reset) + you can use RCC_AHBPeriphResetCmd(), RCC_APB2PeriphResetCmd() and + RCC_APB1PeriphResetCmd() functions. + +@endverbatim + * @{ + */ + +/** + * @brief Configures the RTC clock (RTCCLK). + * @note As the RTC clock configuration bits are in the Backup domain and write + * access is denied to this domain after reset, you have to enable write + * access using PWR_BackupAccessCmd(ENABLE) function before to configure + * the RTC clock source (to be done once after reset). + * @note Once the RTC clock is configured it can't be changed unless the RTC + * is reset using RCC_BackupResetCmd function, or by a Power On Reset (POR) + * + * @param RCC_RTCCLKSource: specifies the RTC clock source. + * This parameter can be one of the following values: + * @arg RCC_RTCCLKSource_LSE: LSE selected as RTC clock + * @arg RCC_RTCCLKSource_LSI: LSI selected as RTC clock + * @arg RCC_RTCCLKSource_HSE_Div32: HSE divided by 32 selected as RTC clock + * + * @note If the LSE or LSI is used as RTC clock source, the RTC continues to + * work in STOP and STANDBY modes, and can be used as wakeup source. + * However, when the HSE clock is used as RTC clock source, the RTC + * cannot be used in STOP and STANDBY modes. + * + * @note The maximum input clock frequency for RTC is 2MHz (when using HSE as + * RTC clock source). + * + * @retval None + */ +void RCC_RTCCLKConfig(uint32_t RCC_RTCCLKSource) +{ + /* Check the parameters */ + assert_param(IS_RCC_RTCCLK_SOURCE(RCC_RTCCLKSource)); + + /* Select the RTC clock source */ + RCC->BDCR |= RCC_RTCCLKSource; +} + +/** + * @brief Enables or disables the RTC clock. + * @note This function must be used only after the RTC clock source was selected + * using the RCC_RTCCLKConfig function. + * @param NewState: new state of the RTC clock. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_RTCCLKCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->BDCR |= RCC_BDCR_RTCEN; + } + else + { + RCC->BDCR &= ~RCC_BDCR_RTCEN; + } +} + +/** + * @brief Forces or releases the Backup domain reset. + * @note This function resets the RTC peripheral (including the backup registers) + * and the RTC clock source selection in RCC_BDCR register. + * @param NewState: new state of the Backup domain reset. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_BackupResetCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->BDCR |= RCC_BDCR_BDRST; + } + else + { + RCC->BDCR &= ~RCC_BDCR_BDRST; + } +} + +/** + * @brief Enables or disables the AHB peripheral clock. + * @note After reset, the peripheral clock (used for registers read/write access) + * is disabled and the application software has to enable this clock before + * using it. + * @param RCC_AHBPeriph: specifies the AHB peripheral to gates its clock. + * This parameter can be any combination of the following values: + * @arg RCC_AHBPeriph_GPIOA: GPIOA clock + * @arg RCC_AHBPeriph_GPIOB: GPIOB clock + * @arg RCC_AHBPeriph_GPIOC: GPIOC clock + * @arg RCC_AHBPeriph_GPIOD: GPIOD clock + * @arg RCC_AHBPeriph_GPIOE: GPIOE clock, applicable only for STM32F072 devices + * @arg RCC_AHBPeriph_GPIOF: GPIOF clock + * @arg RCC_AHBPeriph_TS: TS clock + * @arg RCC_AHBPeriph_CRC: CRC clock + * @arg RCC_AHBPeriph_FLITF: (has effect only when the Flash memory is in power down mode) + * @arg RCC_AHBPeriph_SRAM: SRAM clock + * @arg RCC_AHBPeriph_DMA1: DMA1 clock + * @arg RCC_AHBPeriph_DMA2: DMA2 clock + * @param NewState: new state of the specified peripheral clock. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_AHBPeriphClockCmd(uint32_t RCC_AHBPeriph, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_RCC_AHB_PERIPH(RCC_AHBPeriph)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->AHBENR |= RCC_AHBPeriph; + } + else + { + RCC->AHBENR &= ~RCC_AHBPeriph; + } +} + +/** + * @brief Enables or disables the High Speed APB (APB2) peripheral clock. + * @note After reset, the peripheral clock (used for registers read/write access) + * is disabled and the application software has to enable this clock before + * using it. + * @param RCC_APB2Periph: specifies the APB2 peripheral to gates its clock. + * This parameter can be any combination of the following values: + * @arg RCC_APB2Periph_SYSCFG: SYSCFG clock + * @arg RCC_APB2Periph_USART6: USART6 clock + * @arg RCC_APB2Periph_USART7: USART7 clock + * @arg RCC_APB2Periph_USART8: USART8 clock + * @arg RCC_APB2Periph_ADC1: ADC1 clock + * @arg RCC_APB2Periph_TIM1: TIM1 clock + * @arg RCC_APB2Periph_SPI1: SPI1 clock + * @arg RCC_APB2Periph_USART1: USART1 clock + * @arg RCC_APB2Periph_TIM15: TIM15 clock + * @arg RCC_APB2Periph_TIM16: TIM16 clock + * @arg RCC_APB2Periph_TIM17: TIM17 clock + * @arg RCC_APB2Periph_DBGMCU: DBGMCU clock + * @param NewState: new state of the specified peripheral clock. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_APB2PeriphClockCmd(uint32_t RCC_APB2Periph, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_RCC_APB2_PERIPH(RCC_APB2Periph)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->APB2ENR |= RCC_APB2Periph; + } + else + { + RCC->APB2ENR &= ~RCC_APB2Periph; + } +} + +/** + * @brief Enables or disables the Low Speed APB (APB1) peripheral clock. + * @note After reset, the peripheral clock (used for registers read/write access) + * is disabled and the application software has to enable this clock before + * using it. + * @param RCC_APB1Periph: specifies the APB1 peripheral to gates its clock. + * This parameter can be any combination of the following values: + * @arg RCC_APB1Periph_TIM2: TIM2 clock, applicable only for STM32F051 and STM32F072 devices + * @arg RCC_APB1Periph_TIM3: TIM3 clock + * @arg RCC_APB1Periph_TIM6: TIM6 clock + * @arg RCC_APB1Periph_TIM7: TIM7 clock, applicable only for STM32F072 devices + * @arg RCC_APB1Periph_TIM14: TIM14 clock + * @arg RCC_APB1Periph_WWDG: WWDG clock + * @arg RCC_APB1Periph_SPI2: SPI2 clock + * @arg RCC_APB1Periph_USART2: USART2 clock + * @arg RCC_APB1Periph_USART3: USART3 clock, applicable only for STM32F072 and STM32F091 devices + * @arg RCC_APB1Periph_USART4: USART4 clock, applicable only for STM32F072 and STM32F091 devices + * @arg RCC_APB1Periph_USART5: USART5 clock, applicable only for STM32F091 devices + * @arg RCC_APB1Periph_I2C1: I2C1 clock + * @arg RCC_APB1Periph_I2C2: I2C2 clock + * @arg RCC_APB1Periph_USB: USB clock, applicable only for STM32F042 and STM32F072 devices + * @arg RCC_APB1Periph_CAN: CAN clock, applicable only for STM32F042 and STM32F072 devices + * @arg RCC_APB1Periph_CRS: CRS clock , applicable only for STM32F042 and STM32F072 devices + * @arg RCC_APB1Periph_PWR: PWR clock + * @arg RCC_APB1Periph_DAC: DAC clock, applicable only for STM32F051 and STM32F072 devices + * @arg RCC_APB1Periph_CEC: CEC clock, applicable only for STM32F051, STM32F042 and STM32F072 devices + * @param NewState: new state of the specified peripheral clock. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_APB1PeriphClockCmd(uint32_t RCC_APB1Periph, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_RCC_APB1_PERIPH(RCC_APB1Periph)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->APB1ENR |= RCC_APB1Periph; + } + else + { + RCC->APB1ENR &= ~RCC_APB1Periph; + } +} + +/** + * @brief Forces or releases AHB peripheral reset. + * @param RCC_AHBPeriph: specifies the AHB peripheral to reset. + * This parameter can be any combination of the following values: + * @arg RCC_AHBPeriph_GPIOA: GPIOA clock + * @arg RCC_AHBPeriph_GPIOB: GPIOB clock + * @arg RCC_AHBPeriph_GPIOC: GPIOC clock + * @arg RCC_AHBPeriph_GPIOD: GPIOD clock + * @arg RCC_AHBPeriph_GPIOE: GPIOE clock, applicable only for STM32F072 devices + * @arg RCC_AHBPeriph_GPIOF: GPIOF clock + * @arg RCC_AHBPeriph_TS: TS clock + * @param NewState: new state of the specified peripheral reset. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_AHBPeriphResetCmd(uint32_t RCC_AHBPeriph, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_RCC_AHB_RST_PERIPH(RCC_AHBPeriph)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->AHBRSTR |= RCC_AHBPeriph; + } + else + { + RCC->AHBRSTR &= ~RCC_AHBPeriph; + } +} + +/** + * @brief Forces or releases High Speed APB (APB2) peripheral reset. + * @param RCC_APB2Periph: specifies the APB2 peripheral to reset. + * This parameter can be any combination of the following values: + * @arg RCC_APB2Periph_SYSCFG: SYSCFG clock + * @arg RCC_APB2Periph_USART6: USART6 clock + * @arg RCC_APB2Periph_USART7: USART7 clock + * @arg RCC_APB2Periph_USART8: USART8 clock + * @arg RCC_APB2Periph_ADC1: ADC1 clock + * @arg RCC_APB2Periph_TIM1: TIM1 clock + * @arg RCC_APB2Periph_SPI1: SPI1 clock + * @arg RCC_APB2Periph_USART1: USART1 clock + * @arg RCC_APB2Periph_TIM15: TIM15 clock + * @arg RCC_APB2Periph_TIM16: TIM16 clock + * @arg RCC_APB2Periph_TIM17: TIM17 clock + * @arg RCC_APB2Periph_DBGMCU: DBGMCU clock + * @param NewState: new state of the specified peripheral reset. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_APB2PeriphResetCmd(uint32_t RCC_APB2Periph, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_RCC_APB2_PERIPH(RCC_APB2Periph)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->APB2RSTR |= RCC_APB2Periph; + } + else + { + RCC->APB2RSTR &= ~RCC_APB2Periph; + } +} + +/** + * @brief Forces or releases Low Speed APB (APB1) peripheral reset. + * @param RCC_APB1Periph: specifies the APB1 peripheral to reset. + * This parameter can be any combination of the following values: + * @arg RCC_APB1Periph_TIM2: TIM2 clock, applicable only for STM32F051 and STM32F072 devices + * @arg RCC_APB1Periph_TIM3: TIM3 clock + * @arg RCC_APB1Periph_TIM6: TIM6 clock + * @arg RCC_APB1Periph_TIM7: TIM7 clock, applicable only for STM32F072 devices + * @arg RCC_APB1Periph_TIM14: TIM14 clock + * @arg RCC_APB1Periph_WWDG: WWDG clock + * @arg RCC_APB1Periph_SPI2: SPI2 clock + * @arg RCC_APB1Periph_USART2: USART2 clock + * @arg RCC_APB1Periph_USART3: USART3 clock, applicable only for STM32F072 and STM32F091 devices + * @arg RCC_APB1Periph_USART4: USART4 clock, applicable only for STM32F072 and STM32F091 devices + * @arg RCC_APB1Periph_USART5: USART5 clock, applicable only for STM32F091 devices + * @arg RCC_APB1Periph_I2C1: I2C1 clock + * @arg RCC_APB1Periph_I2C2: I2C2 clock + * @arg RCC_APB1Periph_USB: USB clock, applicable only for STM32F042 and STM32F072 devices + * @arg RCC_APB1Periph_CAN: CAN clock, applicable only for STM32F042 and STM32F072 devices + * @arg RCC_APB1Periph_CRS: CRS clock , applicable only for STM32F042 and STM32F072 devices + * @arg RCC_APB1Periph_PWR: PWR clock + * @arg RCC_APB1Periph_DAC: DAC clock, applicable only for STM32F051 and STM32F072 devices + * @arg RCC_APB1Periph_CEC: CEC clock, applicable only for STM32F051, STM32F042 and STM32F072 devices + * @param NewState: new state of the specified peripheral clock. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_APB1PeriphResetCmd(uint32_t RCC_APB1Periph, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_RCC_APB1_PERIPH(RCC_APB1Periph)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->APB1RSTR |= RCC_APB1Periph; + } + else + { + RCC->APB1RSTR &= ~RCC_APB1Periph; + } +} + +/** + * @} + */ + +/** @defgroup RCC_Group4 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified RCC interrupts. + * @note The CSS interrupt doesn't have an enable bit; once the CSS is enabled + * and if the HSE clock fails, the CSS interrupt occurs and an NMI is + * automatically generated. The NMI will be executed indefinitely, and + * since NMI has higher priority than any other IRQ (and main program) + * the application will be stacked in the NMI ISR unless the CSS interrupt + * pending bit is cleared. + * @param RCC_IT: specifies the RCC interrupt sources to be enabled or disabled. + * This parameter can be any combination of the following values: + * @arg RCC_IT_LSIRDY: LSI ready interrupt + * @arg RCC_IT_LSERDY: LSE ready interrupt + * @arg RCC_IT_HSIRDY: HSI ready interrupt + * @arg RCC_IT_HSERDY: HSE ready interrupt + * @arg RCC_IT_PLLRDY: PLL ready interrupt + * @arg RCC_IT_HSI14RDY: HSI14 ready interrupt + * @arg RCC_IT_HSI48RDY: HSI48 ready interrupt, applicable only for STM32F072 devices + * @param NewState: new state of the specified RCC interrupts. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_ITConfig(uint8_t RCC_IT, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_RCC_IT(RCC_IT)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Perform Byte access to RCC_CIR[13:8] bits to enable the selected interrupts */ + *(__IO uint8_t *) CIR_BYTE1_ADDRESS |= RCC_IT; + } + else + { + /* Perform Byte access to RCC_CIR[13:8] bits to disable the selected interrupts */ + *(__IO uint8_t *) CIR_BYTE1_ADDRESS &= (uint8_t)~RCC_IT; + } +} + +/** + * @brief Checks whether the specified RCC flag is set or not. + * @param RCC_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg RCC_FLAG_HSIRDY: HSI oscillator clock ready + * @arg RCC_FLAG_HSERDY: HSE oscillator clock ready + * @arg RCC_FLAG_PLLRDY: PLL clock ready + * @arg RCC_FLAG_LSERDY: LSE oscillator clock ready + * @arg RCC_FLAG_LSIRDY: LSI oscillator clock ready + * @arg RCC_FLAG_OBLRST: Option Byte Loader (OBL) reset + * @arg RCC_FLAG_PINRST: Pin reset + * @arg RCC_FLAG_V18PWRRSTF: V1.8 power domain reset + * @arg RCC_FLAG_PORRST: POR/PDR reset + * @arg RCC_FLAG_SFTRST: Software reset + * @arg RCC_FLAG_IWDGRST: Independent Watchdog reset + * @arg RCC_FLAG_WWDGRST: Window Watchdog reset + * @arg RCC_FLAG_LPWRRST: Low Power reset + * @arg RCC_FLAG_HSI14RDY: HSI14 oscillator clock ready + * @arg RCC_FLAG_HSI48RDY: HSI48 oscillator clock ready, applicable only for STM32F072 devices + * @retval The new state of RCC_FLAG (SET or RESET). + */ +FlagStatus RCC_GetFlagStatus(uint8_t RCC_FLAG) +{ + uint32_t tmp = 0; + uint32_t statusreg = 0; + FlagStatus bitstatus = RESET; + + /* Check the parameters */ + assert_param(IS_RCC_FLAG(RCC_FLAG)); + + /* Get the RCC register index */ + tmp = RCC_FLAG >> 5; + + if (tmp == 0) /* The flag to check is in CR register */ + { + statusreg = RCC->CR; + } + else if (tmp == 1) /* The flag to check is in BDCR register */ + { + statusreg = RCC->BDCR; + } + else if (tmp == 2) /* The flag to check is in CSR register */ + { + statusreg = RCC->CSR; + } + else /* The flag to check is in CR2 register */ + { + statusreg = RCC->CR2; + } + + /* Get the flag position */ + tmp = RCC_FLAG & FLAG_MASK; + + if ((statusreg & ((uint32_t)1 << tmp)) != (uint32_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + /* Return the flag status */ + return bitstatus; +} + +/** + * @brief Clears the RCC reset flags. + * The reset flags are: RCC_FLAG_OBLRST, RCC_FLAG_PINRST, RCC_FLAG_V18PWRRSTF, + * RCC_FLAG_PORRST, RCC_FLAG_SFTRST, RCC_FLAG_IWDGRST, RCC_FLAG_WWDGRST, + * RCC_FLAG_LPWRRST. + * @param None + * @retval None + */ +void RCC_ClearFlag(void) +{ + /* Set RMVF bit to clear the reset flags */ + RCC->CSR |= RCC_CSR_RMVF; +} + +/** + * @brief Checks whether the specified RCC interrupt has occurred or not. + * @param RCC_IT: specifies the RCC interrupt source to check. + * This parameter can be one of the following values: + * @arg RCC_IT_LSIRDY: LSI ready interrupt + * @arg RCC_IT_LSERDY: LSE ready interrupt + * @arg RCC_IT_HSIRDY: HSI ready interrupt + * @arg RCC_IT_HSERDY: HSE ready interrupt + * @arg RCC_IT_PLLRDY: PLL ready interrupt + * @arg RCC_IT_HSI14RDY: HSI14 ready interrupt + * @arg RCC_IT_HSI48RDY: HSI48 ready interrupt, applicable only for STM32F072 devices + * @arg RCC_IT_CSS: Clock Security System interrupt + * @retval The new state of RCC_IT (SET or RESET). + */ +ITStatus RCC_GetITStatus(uint8_t RCC_IT) +{ + ITStatus bitstatus = RESET; + + /* Check the parameters */ + assert_param(IS_RCC_GET_IT(RCC_IT)); + + /* Check the status of the specified RCC interrupt */ + if ((RCC->CIR & RCC_IT) != (uint32_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + /* Return the RCC_IT status */ + return bitstatus; +} + +/** + * @brief Clears the RCC's interrupt pending bits. + * @param RCC_IT: specifies the interrupt pending bit to clear. + * This parameter can be any combination of the following values: + * @arg RCC_IT_LSIRDY: LSI ready interrupt + * @arg RCC_IT_LSERDY: LSE ready interrupt + * @arg RCC_IT_HSIRDY: HSI ready interrupt + * @arg RCC_IT_HSERDY: HSE ready interrupt + * @arg RCC_IT_PLLRDY: PLL ready interrupt + * @arg RCC_IT_HSI48RDY: HSI48 ready interrupt, applicable only for STM32F072 devices + * @arg RCC_IT_HSI14RDY: HSI14 ready interrupt + * @arg RCC_IT_CSS: Clock Security System interrupt + * @retval None + */ +void RCC_ClearITPendingBit(uint8_t RCC_IT) +{ + /* Check the parameters */ + assert_param(IS_RCC_CLEAR_IT(RCC_IT)); + + /* Perform Byte access to RCC_CIR[23:16] bits to clear the selected interrupt + pending bits */ + *(__IO uint8_t *) CIR_BYTE2_ADDRESS = RCC_IT; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_rtc.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_rtc.c new file mode 100644 index 00000000..4a8e565a --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_rtc.c @@ -0,0 +1,2518 @@ +/** + ****************************************************************************** + * @file stm32f0xx_rtc.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Real-Time Clock (RTC) peripheral: + * + Initialization + * + Calendar (Time and Date) configuration + * + Alarms (Alarm A) configuration + * + Daylight Saving configuration + * + Output pin Configuration + * + Digital Calibration configuration + * + TimeStamp configuration + * + Tampers configuration + * + Backup Data Registers configuration + * + Output Type Config configuration + * + Shift control synchronisation + * + Interrupts and flags management + * + @verbatim + =============================================================================== + ##### Backup Domain Operating Condition ##### + =============================================================================== + [..] The real-time clock (RTC) and the RTC backup registers can be powered + from the VBAT voltage when the main VDD supply is powered off. + To retain the content of the RTC backup registers and supply the RTC + when VDD is turned off, VBAT pin can be connected to an optional + standby voltage supplied by a battery or by another source. + + [..] To allow the RTC to operate even when the main digital supply (VDD) + is turned off, the VBAT pin powers the following blocks: + (#) The RTC + (#) The LSE oscillator + (#) PC13 to PC15 I/Os I/Os (when available) + + [..] When the backup domain is supplied by VDD (analog switch connected + to VDD), the following functions are available: + (#) PC14 and PC15 can be used as either GPIO or LSE pins + (#) PC13 can be used as a GPIO or as the RTC_AF1 pin + + [..] When the backup domain is supplied by VBAT (analog switch connected + to VBAT because VDD is not present), the following functions are available: + (#) PC14 and PC15 can be used as LSE pins only + (#) PC13 can be used as the RTC_AF1 pin + + ##### Backup Domain Reset ##### + =============================================================================== + [..] The backup domain reset sets all RTC registers and the RCC_BDCR + register to their reset values. + A backup domain reset is generated when one of the following events + occurs: + (#) Software reset, triggered by setting the BDRST bit in the + RCC Backup domain control register (RCC_BDCR). You can use the + RCC_BackupResetCmd(). + (#) VDD or VBAT power on, if both supplies have previously been + powered off. + + ##### Backup Domain Access ##### + =============================================================================== + [..] After reset, the backup domain (RTC registers and RTC backup data + registers) is protected against possible unwanted write accesses. + [..] To enable access to the Backup Domain and RTC registers, proceed as follows: + (#) Enable the Power Controller (PWR) APB1 interface clock using the + RCC_APB1PeriphClockCmd() function. + (#) Enable access to Backup domain using the PWR_BackupAccessCmd() function. + (#) Select the RTC clock source using the RCC_RTCCLKConfig() function. + (#) Enable RTC Clock using the RCC_RTCCLKCmd() function. + + + ##### How to use this driver ##### + =============================================================================== + [..] + (+) Enable the backup domain access (see description in the section above) + (+) Configure the RTC Prescaler (Asynchronous and Synchronous) and + RTC hour format using the RTC_Init() function. + + ***Time and Date configuration *** + ================================== + [..] + (+) To configure the RTC Calendar (Time and Date) use the RTC_SetTime() + and RTC_SetDate() functions. + (+) To read the RTC Calendar, use the RTC_GetTime() and RTC_GetDate() + functions. + (+) To read the RTC subsecond, use the RTC_GetSubSecond() function. + (+) Use the RTC_DayLightSavingConfig() function to add or sub one + hour to the RTC Calendar. + + ***Alarm configuration *** + ========================== + [..] + (+) To configure the RTC Alarm use the RTC_SetAlarm() function. + (+) Enable the selected RTC Alarm using the RTC_AlarmCmd() function + (+) To read the RTC Alarm, use the RTC_GetAlarm() function. + (+) To read the RTC alarm SubSecond, use the RTC_GetAlarmSubSecond() function. + + ***RTC Wakeup configuration*** + ========================== + [..] + (+) Configure the RTC Wakeup Clock source use the RTC_WakeUpClockConfig() + function. + (+) Configure the RTC WakeUp Counter using the RTC_SetWakeUpCounter() + function + (+) Enable the RTC WakeUp using the RTC_WakeUpCmd() function + (+) To read the RTC WakeUp Counter register, use the RTC_GetWakeUpCounter() + function. + + ***Outputs configuration *** + ============================ + [..] The RTC has 2 different outputs: + (+) AFO_ALARM: this output is used to manage the RTC Alarm A. + To output the selected RTC signal on RTC_AF1 pin, use the + RTC_OutputConfig() function. + (+) AFO_CALIB: this output is 512Hz signal or 1Hz . + To output the RTC Clock on RTC_AF1 pin, use the RTC_CalibOutputCmd() + function. + + ***Original Digital Calibration configuration *** + ================================= + [..] Configure the RTC Original Digital Calibration Value and the corresponding + calibration cycle period (32s,16s and 8s) using the RTC_SmoothCalibConfig() + function. + + ***TimeStamp configuration *** + ============================== + [..] + (+) Configure the RTC_AF1 trigger and enables the RTC TimeStamp + using the RTC_TimeStampCmd() function. + (+) To read the RTC TimeStamp Time and Date register, use the + RTC_GetTimeStamp() function. + (+) To read the RTC TimeStamp SubSecond register, use the + RTC_GetTimeStampSubSecond() function. + + ***Tamper configuration *** + =========================== + [..] + (+) Configure the Tamper filter count using RTC_TamperFilterConfig() + function. + (+) Configure the RTC Tamper trigger Edge or Level according to the Tamper + filter (if equal to 0 Edge else Level) value using the RTC_TamperConfig() function + (+) Configure the Tamper sampling frequency using RTC_TamperSamplingFreqConfig() + function. + (+) Configure the Tamper precharge or discharge duration using + RTC_TamperPinsPrechargeDuration() function. + (+) Enable the Tamper Pull-UP using RTC_TamperPullUpDisableCmd() function. + (+) Enable the RTC Tamper using the RTC_TamperCmd() function. + (+) Enable the Time stamp on Tamper detection event using + RTC_TSOnTamperDetecCmd() function. + + ***Backup Data Registers configuration *** + ========================================== + [..] + (+) To write to the RTC Backup Data registers, use the RTC_WriteBackupRegister() + function. + (+) To read the RTC Backup Data registers, use the RTC_ReadBackupRegister() + function. + + ##### RTC and low power modes ##### + =============================================================================== + [..] The MCU can be woken up from a low power mode by an RTC alternate + function. + [..] The RTC alternate functions are the RTC alarm (Alarm A), RTC tamper + event detection and RTC time stamp event detection. + These RTC alternate functions can wake up the system from the Stop + and Standby lowpower modes. + The system can also wake up from low power modes without depending + on an external interrupt (Auto-wakeup mode), by using the RTC alarm events. + [..] The RTC provides a programmable time base for waking up from the + Stop or Standby mode at regular intervals. + Wakeup from STOP and Standby modes is possible only when the RTC + clock source is LSE or LSI. + + ##### Selection of RTC_AF1 alternate functions ##### + =============================================================================== + [..] The RTC_AF1 pin (PC13) can be used for the following purposes: + (+) AFO_ALARM output + (+) AFO_CALIB output + (+) AFI_TAMPER + (+) AFI_TIMESTAMP + + +------------------------------------------------------------------------------------------+ + | Pin |AFO_ALARM |AFO_CALIB |AFI_TAMPER |AFI_TIMESTAMP | WKUP2 |ALARMOUTTYPE | + | configuration | ENABLED | ENABLED | ENABLED | ENABLED |ENABLED | AFO_ALARM | + | and function | | | | | |Configuration | + |-----------------|----------|----------|-----------|--------------|--------|--------------| + | Alarm out | | | | | Don't | | + | output OD | 1 | 0 |Don't care | Don't care | care | 0 | + |-----------------|----------|----------|-----------|--------------|--------|--------------| + | Alarm out | | | | | Don't | | + | output PP | 1 | 0 |Don't care | Don't care | care | 1 | + |-----------------|----------|----------|-----------|--------------|--------|--------------| + | Calibration out | | | | | Don't | | + | output PP | 0 | 1 |Don't care | Don't care | care | Don't care | + |-----------------|----------|----------|-----------|--------------|--------|--------------| + | TAMPER input | | | | | Don't | | + | floating | 0 | 0 | 1 | 0 | care | Don't care | + |-----------------|----------|----------|-----------|--------------|--------|--------------| + | TIMESTAMP and | | | | | Don't | | + | TAMPER input | 0 | 0 | 1 | 1 | care | Don't care | + | floating | | | | | | | + |-----------------|----------|----------|-----------|--------------|--------|--------------| + | TIMESTAMP input | | | | | Don't | | + | floating | 0 | 0 | 0 | 1 | care | Don't care | + |-----------------|----------|----------|-----------|--------------|--------|--------------| + | Wakeup Pin 2 | 0 | 0 | 0 | 0 | 1 | Don't care | + |-----------------|----------|----------|-----------|--------------|--------|--------------| + | Standard GPIO | 0 | 0 | 0 | 0 | 0 | Don't care | + +------------------------------------------------------------------------------------------+ + + @endverbatim + + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_rtc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup RTC + * @brief RTC driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ + +/* Masks Definition */ +#define RTC_TR_RESERVED_MASK ((uint32_t)0x007F7F7F) +#define RTC_DR_RESERVED_MASK ((uint32_t)0x00FFFF3F) +#define RTC_INIT_MASK ((uint32_t)0xFFFFFFFF) +#define RTC_RSF_MASK ((uint32_t)0xFFFFFF5F) +#define RTC_FLAGS_MASK ((uint32_t)(RTC_FLAG_TSOVF | RTC_FLAG_TSF | RTC_FLAG_ALRAF | \ + RTC_FLAG_RSF | RTC_FLAG_INITS |RTC_FLAG_INITF | \ + RTC_FLAG_TAMP1F | RTC_FLAG_TAMP2F | RTC_FLAG_RECALPF | \ + RTC_FLAG_SHPF)) + +#define INITMODE_TIMEOUT ((uint32_t) 0x00004000) +#define SYNCHRO_TIMEOUT ((uint32_t) 0x00008000) +#define RECALPF_TIMEOUT ((uint32_t) 0x00001000) +#define SHPF_TIMEOUT ((uint32_t) 0x00001000) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +static uint8_t RTC_ByteToBcd2(uint8_t Value); +static uint8_t RTC_Bcd2ToByte(uint8_t Value); + +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup RTC_Private_Functions + * @{ + */ + +/** @defgroup RTC_Group1 Initialization and Configuration functions + * @brief Initialization and Configuration functions + * +@verbatim + =============================================================================== + ##### Initialization and Configuration functions ##### + =============================================================================== + + [..] This section provide functions allowing to initialize and configure the RTC + Prescaler (Synchronous and Asynchronous), RTC Hour format, disable RTC registers + Write protection, enter and exit the RTC initialization mode, RTC registers + synchronization check and reference clock detection enable. + + (#) The RTC Prescaler is programmed to generate the RTC 1Hz time base. + It is split into 2 programmable prescalers to minimize power consumption. + (++) A 7-bit asynchronous prescaler and A 13-bit synchronous prescaler. + (++) When both prescalers are used, it is recommended to configure the + asynchronous prescaler to a high value to minimize consumption. + (#) All RTC registers are Write protected. Writing to the RTC registers + is enabled by writing a key into the Write Protection register, RTC_WPR. + (#) To Configure the RTC Calendar, user application should enter + initialization mode. In this mode, the calendar counter is stopped + and its value can be updated. When the initialization sequence is + complete, the calendar restarts counting after 4 RTCCLK cycles. + (#) To read the calendar through the shadow registers after Calendar + initialization, calendar update or after wakeup from low power modes + the software must first clear the RSF flag. The software must then + wait until it is set again before reading the calendar, which means + that the calendar registers have been correctly copied into the + RTC_TR and RTC_DR shadow registers.The RTC_WaitForSynchro() function + implements the above software sequence (RSF clear and RSF check). + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the RTC registers to their default reset values. + * @note This function doesn't reset the RTC Clock source and RTC Backup Data + * registers. + * @param None + * @retval An ErrorStatus enumeration value: + * - SUCCESS: RTC registers are deinitialized + * - ERROR: RTC registers are not deinitialized + */ +ErrorStatus RTC_DeInit(void) +{ + ErrorStatus status = ERROR; + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Set Initialization mode */ + if (RTC_EnterInitMode() == ERROR) + { + status = ERROR; + } + else + { + /* Reset TR, DR and CR registers */ + RTC->TR = (uint32_t)0x00000000; + RTC->WUTR = (uint32_t)0x0000FFFF; + RTC->DR = (uint32_t)0x00002101; + RTC->CR &= (uint32_t)0x00000000; + RTC->PRER = (uint32_t)0x007F00FF; + RTC->ALRMAR = (uint32_t)0x00000000; + RTC->SHIFTR = (uint32_t)0x00000000; + RTC->CALR = (uint32_t)0x00000000; + RTC->ALRMASSR = (uint32_t)0x00000000; + + /* Reset ISR register and exit initialization mode */ + RTC->ISR = (uint32_t)0x00000000; + + /* Reset Tamper and alternate functions configuration register */ + RTC->TAFCR = 0x00000000; + + /* Wait till the RTC RSF flag is set */ + if (RTC_WaitForSynchro() == ERROR) + { + status = ERROR; + } + else + { + status = SUCCESS; + } + + } + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + + return status; +} + +/** + * @brief Initializes the RTC registers according to the specified parameters + * in RTC_InitStruct. + * @param RTC_InitStruct: pointer to a RTC_InitTypeDef structure that contains + * the configuration information for the RTC peripheral. + * @note The RTC Prescaler register is write protected and can be written in + * initialization mode only. + * @retval An ErrorStatus enumeration value: + * - SUCCESS: RTC registers are initialized + * - ERROR: RTC registers are not initialized + */ +ErrorStatus RTC_Init(RTC_InitTypeDef* RTC_InitStruct) +{ + ErrorStatus status = ERROR; + + /* Check the parameters */ + assert_param(IS_RTC_HOUR_FORMAT(RTC_InitStruct->RTC_HourFormat)); + assert_param(IS_RTC_ASYNCH_PREDIV(RTC_InitStruct->RTC_AsynchPrediv)); + assert_param(IS_RTC_SYNCH_PREDIV(RTC_InitStruct->RTC_SynchPrediv)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Set Initialization mode */ + if (RTC_EnterInitMode() == ERROR) + { + status = ERROR; + } + else + { + /* Clear RTC CR FMT Bit */ + RTC->CR &= ((uint32_t)~(RTC_CR_FMT)); + /* Set RTC_CR register */ + RTC->CR |= ((uint32_t)(RTC_InitStruct->RTC_HourFormat)); + + /* Configure the RTC PRER */ + RTC->PRER = (uint32_t)(RTC_InitStruct->RTC_SynchPrediv); + RTC->PRER |= (uint32_t)(RTC_InitStruct->RTC_AsynchPrediv << 16); + + /* Exit Initialization mode */ + RTC_ExitInitMode(); + + status = SUCCESS; + } + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + + return status; +} + +/** + * @brief Fills each RTC_InitStruct member with its default value. + * @param RTC_InitStruct: pointer to a RTC_InitTypeDef structure which will be + * initialized. + * @retval None + */ +void RTC_StructInit(RTC_InitTypeDef* RTC_InitStruct) +{ + /* Initialize the RTC_HourFormat member */ + RTC_InitStruct->RTC_HourFormat = RTC_HourFormat_24; + + /* Initialize the RTC_AsynchPrediv member */ + RTC_InitStruct->RTC_AsynchPrediv = (uint32_t)0x7F; + + /* Initialize the RTC_SynchPrediv member */ + RTC_InitStruct->RTC_SynchPrediv = (uint32_t)0xFF; +} + +/** + * @brief Enables or disables the RTC registers write protection. + * @note All the RTC registers are write protected except for RTC_ISR[13:8], + * RTC_TAFCR and RTC_BKPxR. + * @note Writing a wrong key reactivates the write protection. + * @note The protection mechanism is not affected by system reset. + * @param NewState: new state of the write protection. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RTC_WriteProtectionCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + } + else + { + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + } +} + +/** + * @brief Enters the RTC Initialization mode. + * @note The RTC Initialization mode is write protected, use the + * RTC_WriteProtectionCmd(DISABLE) before calling this function. + * @param None + * @retval An ErrorStatus enumeration value: + * - SUCCESS: RTC is in Init mode + * - ERROR: RTC is not in Init mode + */ +ErrorStatus RTC_EnterInitMode(void) +{ + __IO uint32_t initcounter = 0x00; + ErrorStatus status = ERROR; + uint32_t initstatus = 0x00; + + /* Check if the Initialization mode is set */ + if ((RTC->ISR & RTC_ISR_INITF) == (uint32_t)RESET) + { + /* Set the Initialization mode */ + RTC->ISR = (uint32_t)RTC_INIT_MASK; + + /* Wait till RTC is in INIT state and if Time out is reached exit */ + do + { + initstatus = RTC->ISR & RTC_ISR_INITF; + initcounter++; + } while((initcounter != INITMODE_TIMEOUT) && (initstatus == 0x00)); + + if ((RTC->ISR & RTC_ISR_INITF) != RESET) + { + status = SUCCESS; + } + else + { + status = ERROR; + } + } + else + { + status = SUCCESS; + } + + return (status); +} + +/** + * @brief Exits the RTC Initialization mode. + * @note When the initialization sequence is complete, the calendar restarts + * counting after 4 RTCCLK cycles. + * @note The RTC Initialization mode is write protected, use the + * RTC_WriteProtectionCmd(DISABLE) before calling this function. + * @param None + * @retval None + */ +void RTC_ExitInitMode(void) +{ + /* Exit Initialization mode */ + RTC->ISR &= (uint32_t)~RTC_ISR_INIT; +} + +/** + * @brief Waits until the RTC Time and Date registers (RTC_TR and RTC_DR) are + * synchronized with RTC APB clock. + * @note The RTC Resynchronization mode is write protected, use the + * RTC_WriteProtectionCmd(DISABLE) before calling this function. + * @note To read the calendar through the shadow registers after Calendar + * initialization, calendar update or after wakeup from low power modes + * the software must first clear the RSF flag. + * The software must then wait until it is set again before reading + * the calendar, which means that the calendar registers have been + * correctly copied into the RTC_TR and RTC_DR shadow registers. + * @param None + * @retval An ErrorStatus enumeration value: + * - SUCCESS: RTC registers are synchronised + * - ERROR: RTC registers are not synchronised + */ +ErrorStatus RTC_WaitForSynchro(void) +{ + __IO uint32_t synchrocounter = 0; + ErrorStatus status = ERROR; + uint32_t synchrostatus = 0x00; + + if ((RTC->CR & RTC_CR_BYPSHAD) != RESET) + { + /* Bypass shadow mode */ + status = SUCCESS; + } + else + { + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Clear RSF flag */ + RTC->ISR &= (uint32_t)RTC_RSF_MASK; + + /* Wait the registers to be synchronised */ + do + { + synchrostatus = RTC->ISR & RTC_ISR_RSF; + synchrocounter++; + } while((synchrocounter != SYNCHRO_TIMEOUT) && (synchrostatus == 0x00)); + + if ((RTC->ISR & RTC_ISR_RSF) != RESET) + { + status = SUCCESS; + } + else + { + status = ERROR; + } + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + } + + return (status); +} + +/** + * @brief Enables or disables the RTC reference clock detection. + * @param NewState: new state of the RTC reference clock. + * This parameter can be: ENABLE or DISABLE. + * @retval An ErrorStatus enumeration value: + * - SUCCESS: RTC reference clock detection is enabled + * - ERROR: RTC reference clock detection is disabled + */ +ErrorStatus RTC_RefClockCmd(FunctionalState NewState) +{ + ErrorStatus status = ERROR; + + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Set Initialization mode */ + if (RTC_EnterInitMode() == ERROR) + { + status = ERROR; + } + else + { + if (NewState != DISABLE) + { + /* Enable the RTC reference clock detection */ + RTC->CR |= RTC_CR_REFCKON; + } + else + { + /* Disable the RTC reference clock detection */ + RTC->CR &= ~RTC_CR_REFCKON; + } + /* Exit Initialization mode */ + RTC_ExitInitMode(); + + status = SUCCESS; + } + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + + return status; +} + +/** + * @brief Enables or Disables the Bypass Shadow feature. + * @note When the Bypass Shadow is enabled the calendar value are taken + * directly from the Calendar counter. + * @param NewState: new state of the Bypass Shadow feature. + * This parameter can be: ENABLE or DISABLE. + * @retval None +*/ +void RTC_BypassShadowCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + if (NewState != DISABLE) + { + /* Set the BYPSHAD bit */ + RTC->CR |= (uint8_t)RTC_CR_BYPSHAD; + } + else + { + /* Reset the BYPSHAD bit */ + RTC->CR &= (uint8_t)~RTC_CR_BYPSHAD; + } + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; +} + +/** + * @} + */ + +/** @defgroup RTC_Group2 Time and Date configuration functions + * @brief Time and Date configuration functions + * +@verbatim + =============================================================================== + ##### Time and Date configuration functions ##### + =============================================================================== + [..] This section provide functions allowing to program and read the RTC + Calendar (Time and Date). + +@endverbatim + * @{ + */ + +/** + * @brief Set the RTC current time. + * @param RTC_Format: specifies the format of the entered parameters. + * This parameter can be one of the following values: + * @arg RTC_Format_BIN: Binary data format + * @arg RTC_Format_BCD: BCD data format + * @param RTC_TimeStruct: pointer to a RTC_TimeTypeDef structure that contains + * the time configuration information for the RTC. + * @retval An ErrorStatus enumeration value: + * - SUCCESS: RTC Time register is configured + * - ERROR: RTC Time register is not configured + */ +ErrorStatus RTC_SetTime(uint32_t RTC_Format, RTC_TimeTypeDef* RTC_TimeStruct) +{ + uint32_t tmpreg = 0; + ErrorStatus status = ERROR; + + /* Check the parameters */ + assert_param(IS_RTC_FORMAT(RTC_Format)); + + if (RTC_Format == RTC_Format_BIN) + { + if ((RTC->CR & RTC_CR_FMT) != (uint32_t)RESET) + { + assert_param(IS_RTC_HOUR12(RTC_TimeStruct->RTC_Hours)); + assert_param(IS_RTC_H12(RTC_TimeStruct->RTC_H12)); + } + else + { + RTC_TimeStruct->RTC_H12 = 0x00; + assert_param(IS_RTC_HOUR24(RTC_TimeStruct->RTC_Hours)); + } + assert_param(IS_RTC_MINUTES(RTC_TimeStruct->RTC_Minutes)); + assert_param(IS_RTC_SECONDS(RTC_TimeStruct->RTC_Seconds)); + } + else + { + if ((RTC->CR & RTC_CR_FMT) != (uint32_t)RESET) + { + tmpreg = RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Hours); + assert_param(IS_RTC_HOUR12(tmpreg)); + assert_param(IS_RTC_H12(RTC_TimeStruct->RTC_H12)); + } + else + { + RTC_TimeStruct->RTC_H12 = 0x00; + assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Hours))); + } + assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Minutes))); + assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Seconds))); + } + + /* Check the input parameters format */ + if (RTC_Format != RTC_Format_BIN) + { + tmpreg = (((uint32_t)(RTC_TimeStruct->RTC_Hours) << 16) | \ + ((uint32_t)(RTC_TimeStruct->RTC_Minutes) << 8) | \ + ((uint32_t)RTC_TimeStruct->RTC_Seconds) | \ + ((uint32_t)(RTC_TimeStruct->RTC_H12) << 16)); + } + else + { + tmpreg = (uint32_t)(((uint32_t)RTC_ByteToBcd2(RTC_TimeStruct->RTC_Hours) << 16) | \ + ((uint32_t)RTC_ByteToBcd2(RTC_TimeStruct->RTC_Minutes) << 8) | \ + ((uint32_t)RTC_ByteToBcd2(RTC_TimeStruct->RTC_Seconds)) | \ + (((uint32_t)RTC_TimeStruct->RTC_H12) << 16)); + } + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Set Initialization mode */ + if (RTC_EnterInitMode() == ERROR) + { + status = ERROR; + } + else + { + /* Set the RTC_TR register */ + RTC->TR = (uint32_t)(tmpreg & RTC_TR_RESERVED_MASK); + + /* Exit Initialization mode */ + RTC_ExitInitMode(); + + /* If RTC_CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */ + if ((RTC->CR & RTC_CR_BYPSHAD) == RESET) + { + if (RTC_WaitForSynchro() == ERROR) + { + status = ERROR; + } + else + { + status = SUCCESS; + } + } + else + { + status = SUCCESS; + } + + } + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + + return status; +} + +/** + * @brief Fills each RTC_TimeStruct member with its default value + * (Time = 00h:00min:00sec). + * @param RTC_TimeStruct: pointer to a RTC_TimeTypeDef structure which will be + * initialized. + * @retval None + */ +void RTC_TimeStructInit(RTC_TimeTypeDef* RTC_TimeStruct) +{ + /* Time = 00h:00min:00sec */ + RTC_TimeStruct->RTC_H12 = RTC_H12_AM; + RTC_TimeStruct->RTC_Hours = 0; + RTC_TimeStruct->RTC_Minutes = 0; + RTC_TimeStruct->RTC_Seconds = 0; +} + +/** + * @brief Get the RTC current Time. + * @param RTC_Format: specifies the format of the returned parameters. + * This parameter can be one of the following values: + * @arg RTC_Format_BIN: Binary data format + * @arg RTC_Format_BCD: BCD data format + * @param RTC_TimeStruct: pointer to a RTC_TimeTypeDef structure that will + * contain the returned current time configuration. + * @retval None + */ +void RTC_GetTime(uint32_t RTC_Format, RTC_TimeTypeDef* RTC_TimeStruct) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RTC_FORMAT(RTC_Format)); + + /* Get the RTC_TR register */ + tmpreg = (uint32_t)(RTC->TR & RTC_TR_RESERVED_MASK); + + /* Fill the structure fields with the read parameters */ + RTC_TimeStruct->RTC_Hours = (uint8_t)((tmpreg & (RTC_TR_HT | RTC_TR_HU)) >> 16); + RTC_TimeStruct->RTC_Minutes = (uint8_t)((tmpreg & (RTC_TR_MNT | RTC_TR_MNU)) >>8); + RTC_TimeStruct->RTC_Seconds = (uint8_t)(tmpreg & (RTC_TR_ST | RTC_TR_SU)); + RTC_TimeStruct->RTC_H12 = (uint8_t)((tmpreg & (RTC_TR_PM)) >> 16); + + /* Check the input parameters format */ + if (RTC_Format == RTC_Format_BIN) + { + /* Convert the structure parameters to Binary format */ + RTC_TimeStruct->RTC_Hours = (uint8_t)RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Hours); + RTC_TimeStruct->RTC_Minutes = (uint8_t)RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Minutes); + RTC_TimeStruct->RTC_Seconds = (uint8_t)RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Seconds); + } +} + +/** + * @brief Gets the RTC current Calendar Subseconds value. + * @note This function freeze the Time and Date registers after reading the + * SSR register. + * @param None + * @retval RTC current Calendar Subseconds value. + */ +uint32_t RTC_GetSubSecond(void) +{ + uint32_t tmpreg = 0; + + /* Get subseconds values from the correspondent registers*/ + tmpreg = (uint32_t)(RTC->SSR); + + /* Read DR register to unfroze calendar registers */ + (void) (RTC->DR); + + return (tmpreg); +} + +/** + * @brief Set the RTC current date. + * @param RTC_Format: specifies the format of the entered parameters. + * This parameter can be one of the following values: + * @arg RTC_Format_BIN: Binary data format + * @arg RTC_Format_BCD: BCD data format + * @param RTC_DateStruct: pointer to a RTC_DateTypeDef structure that contains + * the date configuration information for the RTC. + * @retval An ErrorStatus enumeration value: + * - SUCCESS: RTC Date register is configured + * - ERROR: RTC Date register is not configured + */ +ErrorStatus RTC_SetDate(uint32_t RTC_Format, RTC_DateTypeDef* RTC_DateStruct) +{ + uint32_t tmpreg = 0; + ErrorStatus status = ERROR; + + /* Check the parameters */ + assert_param(IS_RTC_FORMAT(RTC_Format)); + + if ((RTC_Format == RTC_Format_BIN) && ((RTC_DateStruct->RTC_Month & 0x10) == 0x10)) + { + RTC_DateStruct->RTC_Month = (RTC_DateStruct->RTC_Month & (uint32_t)~(0x10)) + 0x0A; + } + if (RTC_Format == RTC_Format_BIN) + { + assert_param(IS_RTC_YEAR(RTC_DateStruct->RTC_Year)); + assert_param(IS_RTC_MONTH(RTC_DateStruct->RTC_Month)); + assert_param(IS_RTC_DATE(RTC_DateStruct->RTC_Date)); + } + else + { + assert_param(IS_RTC_YEAR(RTC_Bcd2ToByte(RTC_DateStruct->RTC_Year))); + tmpreg = RTC_Bcd2ToByte(RTC_DateStruct->RTC_Month); + assert_param(IS_RTC_MONTH(tmpreg)); + tmpreg = RTC_Bcd2ToByte(RTC_DateStruct->RTC_Date); + assert_param(IS_RTC_DATE(tmpreg)); + } + assert_param(IS_RTC_WEEKDAY(RTC_DateStruct->RTC_WeekDay)); + + /* Check the input parameters format */ + if (RTC_Format != RTC_Format_BIN) + { + tmpreg = ((((uint32_t)RTC_DateStruct->RTC_Year) << 16) | \ + (((uint32_t)RTC_DateStruct->RTC_Month) << 8) | \ + ((uint32_t)RTC_DateStruct->RTC_Date) | \ + (((uint32_t)RTC_DateStruct->RTC_WeekDay) << 13)); + } + else + { + tmpreg = (((uint32_t)RTC_ByteToBcd2(RTC_DateStruct->RTC_Year) << 16) | \ + ((uint32_t)RTC_ByteToBcd2(RTC_DateStruct->RTC_Month) << 8) | \ + ((uint32_t)RTC_ByteToBcd2(RTC_DateStruct->RTC_Date)) | \ + ((uint32_t)RTC_DateStruct->RTC_WeekDay << 13)); + } + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Set Initialization mode */ + if (RTC_EnterInitMode() == ERROR) + { + status = ERROR; + } + else + { + /* Set the RTC_DR register */ + RTC->DR = (uint32_t)(tmpreg & RTC_DR_RESERVED_MASK); + + /* Exit Initialization mode */ + RTC_ExitInitMode(); + + /* If RTC_CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */ + if ((RTC->CR & RTC_CR_BYPSHAD) == RESET) + { + if (RTC_WaitForSynchro() == ERROR) + { + status = ERROR; + } + else + { + status = SUCCESS; + } + } + else + { + status = SUCCESS; + } + } + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + + return status; +} + +/** + * @brief Fills each RTC_DateStruct member with its default value + * (Monday, January 01 xx00). + * @param RTC_DateStruct: pointer to a RTC_DateTypeDef structure which will be + * initialized. + * @retval None + */ +void RTC_DateStructInit(RTC_DateTypeDef* RTC_DateStruct) +{ + /* Monday, January 01 xx00 */ + RTC_DateStruct->RTC_WeekDay = RTC_Weekday_Monday; + RTC_DateStruct->RTC_Date = 1; + RTC_DateStruct->RTC_Month = RTC_Month_January; + RTC_DateStruct->RTC_Year = 0; +} + +/** + * @brief Get the RTC current date. + * @param RTC_Format: specifies the format of the returned parameters. + * This parameter can be one of the following values: + * @arg RTC_Format_BIN: Binary data format + * @arg RTC_Format_BCD: BCD data format + * @param RTC_DateStruct: pointer to a RTC_DateTypeDef structure that will + * contain the returned current date configuration. + * @retval None + */ +void RTC_GetDate(uint32_t RTC_Format, RTC_DateTypeDef* RTC_DateStruct) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RTC_FORMAT(RTC_Format)); + + /* Get the RTC_TR register */ + tmpreg = (uint32_t)(RTC->DR & RTC_DR_RESERVED_MASK); + + /* Fill the structure fields with the read parameters */ + RTC_DateStruct->RTC_Year = (uint8_t)((tmpreg & (RTC_DR_YT | RTC_DR_YU)) >> 16); + RTC_DateStruct->RTC_Month = (uint8_t)((tmpreg & (RTC_DR_MT | RTC_DR_MU)) >> 8); + RTC_DateStruct->RTC_Date = (uint8_t)(tmpreg & (RTC_DR_DT | RTC_DR_DU)); + RTC_DateStruct->RTC_WeekDay = (uint8_t)((tmpreg & (RTC_DR_WDU)) >> 13); + + /* Check the input parameters format */ + if (RTC_Format == RTC_Format_BIN) + { + /* Convert the structure parameters to Binary format */ + RTC_DateStruct->RTC_Year = (uint8_t)RTC_Bcd2ToByte(RTC_DateStruct->RTC_Year); + RTC_DateStruct->RTC_Month = (uint8_t)RTC_Bcd2ToByte(RTC_DateStruct->RTC_Month); + RTC_DateStruct->RTC_Date = (uint8_t)RTC_Bcd2ToByte(RTC_DateStruct->RTC_Date); + RTC_DateStruct->RTC_WeekDay = (uint8_t)(RTC_DateStruct->RTC_WeekDay); + } +} + +/** + * @} + */ + +/** @defgroup RTC_Group3 Alarms configuration functions + * @brief Alarms (Alarm A) configuration functions + * +@verbatim + =============================================================================== + ##### Alarms (Alarm A and Alarm B) configuration functions ##### + =============================================================================== + [..] This section provide functions allowing to program and read the RTC + Alarms. + +@endverbatim + * @{ + */ + +/** + * @brief Set the specified RTC Alarm. + * @note The Alarm register can only be written when the corresponding Alarm + * is disabled (Use the RTC_AlarmCmd(DISABLE)). + * @param RTC_Format: specifies the format of the returned parameters. + * This parameter can be one of the following values: + * @arg RTC_Format_BIN: Binary data format + * @arg RTC_Format_BCD: BCD data format + * @param RTC_Alarm: specifies the alarm to be configured. + * This parameter can be one of the following values: + * @arg RTC_Alarm_A: to select Alarm A + * @param RTC_AlarmStruct: pointer to a RTC_AlarmTypeDef structure that + * contains the alarm configuration parameters. + * @retval None + */ +void RTC_SetAlarm(uint32_t RTC_Format, uint32_t RTC_Alarm, RTC_AlarmTypeDef* RTC_AlarmStruct) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RTC_FORMAT(RTC_Format)); + assert_param(IS_RTC_ALARM(RTC_Alarm)); + assert_param(IS_RTC_ALARM_MASK(RTC_AlarmStruct->RTC_AlarmMask)); + assert_param(IS_RTC_ALARM_DATE_WEEKDAY_SEL(RTC_AlarmStruct->RTC_AlarmDateWeekDaySel)); + + if (RTC_Format == RTC_Format_BIN) + { + if ((RTC->CR & RTC_CR_FMT) != (uint32_t)RESET) + { + assert_param(IS_RTC_HOUR12(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours)); + assert_param(IS_RTC_H12(RTC_AlarmStruct->RTC_AlarmTime.RTC_H12)); + } + else + { + RTC_AlarmStruct->RTC_AlarmTime.RTC_H12 = 0x00; + assert_param(IS_RTC_HOUR24(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours)); + } + assert_param(IS_RTC_MINUTES(RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes)); + assert_param(IS_RTC_SECONDS(RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds)); + + if(RTC_AlarmStruct->RTC_AlarmDateWeekDaySel == RTC_AlarmDateWeekDaySel_Date) + { + assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(RTC_AlarmStruct->RTC_AlarmDateWeekDay)); + } + else + { + assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(RTC_AlarmStruct->RTC_AlarmDateWeekDay)); + } + } + else + { + if ((RTC->CR & RTC_CR_FMT) != (uint32_t)RESET) + { + tmpreg = RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours); + assert_param(IS_RTC_HOUR12(tmpreg)); + assert_param(IS_RTC_H12(RTC_AlarmStruct->RTC_AlarmTime.RTC_H12)); + } + else + { + RTC_AlarmStruct->RTC_AlarmTime.RTC_H12 = 0x00; + assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours))); + } + + assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes))); + assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds))); + + if(RTC_AlarmStruct->RTC_AlarmDateWeekDaySel == RTC_AlarmDateWeekDaySel_Date) + { + tmpreg = RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmDateWeekDay); + assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(tmpreg)); + } + else + { + tmpreg = RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmDateWeekDay); + assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(tmpreg)); + } + } + + /* Check the input parameters format */ + if (RTC_Format != RTC_Format_BIN) + { + tmpreg = (((uint32_t)(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours) << 16) | \ + ((uint32_t)(RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes) << 8) | \ + ((uint32_t)RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds) | \ + ((uint32_t)(RTC_AlarmStruct->RTC_AlarmTime.RTC_H12) << 16) | \ + ((uint32_t)(RTC_AlarmStruct->RTC_AlarmDateWeekDay) << 24) | \ + ((uint32_t)RTC_AlarmStruct->RTC_AlarmDateWeekDaySel) | \ + ((uint32_t)RTC_AlarmStruct->RTC_AlarmMask)); + } + else + { + tmpreg = (((uint32_t)RTC_ByteToBcd2(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours) << 16) | \ + ((uint32_t)RTC_ByteToBcd2(RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes) << 8) | \ + ((uint32_t)RTC_ByteToBcd2(RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds)) | \ + ((uint32_t)(RTC_AlarmStruct->RTC_AlarmTime.RTC_H12) << 16) | \ + ((uint32_t)RTC_ByteToBcd2(RTC_AlarmStruct->RTC_AlarmDateWeekDay) << 24) | \ + ((uint32_t)RTC_AlarmStruct->RTC_AlarmDateWeekDaySel) | \ + ((uint32_t)RTC_AlarmStruct->RTC_AlarmMask)); + } + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Configure the Alarm register */ + RTC->ALRMAR = (uint32_t)tmpreg; + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; +} + +/** + * @brief Fills each RTC_AlarmStruct member with its default value + * (Time = 00h:00mn:00sec / Date = 1st day of the month/Mask = + * all fields are masked). + * @param RTC_AlarmStruct: pointer to a @ref RTC_AlarmTypeDef structure which + * will be initialized. + * @retval None + */ +void RTC_AlarmStructInit(RTC_AlarmTypeDef* RTC_AlarmStruct) +{ + /* Alarm Time Settings : Time = 00h:00mn:00sec */ + RTC_AlarmStruct->RTC_AlarmTime.RTC_H12 = RTC_H12_AM; + RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours = 0; + RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes = 0; + RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds = 0; + + /* Alarm Date Settings : Date = 1st day of the month */ + RTC_AlarmStruct->RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date; + RTC_AlarmStruct->RTC_AlarmDateWeekDay = 1; + + /* Alarm Masks Settings : Mask = all fields are not masked */ + RTC_AlarmStruct->RTC_AlarmMask = RTC_AlarmMask_None; +} + +/** + * @brief Get the RTC Alarm value and masks. + * @param RTC_Format: specifies the format of the output parameters. + * This parameter can be one of the following values: + * @arg RTC_Format_BIN: Binary data format + * @arg RTC_Format_BCD: BCD data format + * @param RTC_Alarm: specifies the alarm to be read. + * This parameter can be one of the following values: + * @arg RTC_Alarm_A: to select Alarm A + * @param RTC_AlarmStruct: pointer to a RTC_AlarmTypeDef structure that will + * contains the output alarm configuration values. + * @retval None + */ +void RTC_GetAlarm(uint32_t RTC_Format, uint32_t RTC_Alarm, RTC_AlarmTypeDef* RTC_AlarmStruct) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RTC_FORMAT(RTC_Format)); + assert_param(IS_RTC_ALARM(RTC_Alarm)); + + /* Get the RTC_ALRMAR register */ + tmpreg = (uint32_t)(RTC->ALRMAR); + + /* Fill the structure with the read parameters */ + RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours = (uint32_t)((tmpreg & (RTC_ALRMAR_HT | \ + RTC_ALRMAR_HU)) >> 16); + RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes = (uint32_t)((tmpreg & (RTC_ALRMAR_MNT | \ + RTC_ALRMAR_MNU)) >> 8); + RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds = (uint32_t)(tmpreg & (RTC_ALRMAR_ST | \ + RTC_ALRMAR_SU)); + RTC_AlarmStruct->RTC_AlarmTime.RTC_H12 = (uint32_t)((tmpreg & RTC_ALRMAR_PM) >> 16); + RTC_AlarmStruct->RTC_AlarmDateWeekDay = (uint32_t)((tmpreg & (RTC_ALRMAR_DT | RTC_ALRMAR_DU)) >> 24); + RTC_AlarmStruct->RTC_AlarmDateWeekDaySel = (uint32_t)(tmpreg & RTC_ALRMAR_WDSEL); + RTC_AlarmStruct->RTC_AlarmMask = (uint32_t)(tmpreg & RTC_AlarmMask_All); + + if (RTC_Format == RTC_Format_BIN) + { + RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours = RTC_Bcd2ToByte(RTC_AlarmStruct-> \ + RTC_AlarmTime.RTC_Hours); + RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes = RTC_Bcd2ToByte(RTC_AlarmStruct-> \ + RTC_AlarmTime.RTC_Minutes); + RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds = RTC_Bcd2ToByte(RTC_AlarmStruct-> \ + RTC_AlarmTime.RTC_Seconds); + RTC_AlarmStruct->RTC_AlarmDateWeekDay = RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmDateWeekDay); + } +} + +/** + * @brief Enables or disables the specified RTC Alarm. + * @param RTC_Alarm: specifies the alarm to be configured. + * This parameter can be any combination of the following values: + * @arg RTC_Alarm_A: to select Alarm A + * @param NewState: new state of the specified alarm. + * This parameter can be: ENABLE or DISABLE. + * @retval An ErrorStatus enumeration value: + * - SUCCESS: RTC Alarm is enabled/disabled + * - ERROR: RTC Alarm is not enabled/disabled + */ +ErrorStatus RTC_AlarmCmd(uint32_t RTC_Alarm, FunctionalState NewState) +{ + __IO uint32_t alarmcounter = 0x00; + uint32_t alarmstatus = 0x00; + ErrorStatus status = ERROR; + + /* Check the parameters */ + assert_param(IS_RTC_CMD_ALARM(RTC_Alarm)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Configure the Alarm state */ + if (NewState != DISABLE) + { + RTC->CR |= (uint32_t)RTC_Alarm; + + status = SUCCESS; + } + else + { + /* Disable the Alarm in RTC_CR register */ + RTC->CR &= (uint32_t)~RTC_Alarm; + + /* Wait till RTC ALRxWF flag is set and if Time out is reached exit */ + do + { + alarmstatus = RTC->ISR & (RTC_Alarm >> 8); + alarmcounter++; + } while((alarmcounter != INITMODE_TIMEOUT) && (alarmstatus == 0x00)); + + if ((RTC->ISR & (RTC_Alarm >> 8)) == RESET) + { + status = ERROR; + } + else + { + status = SUCCESS; + } + } + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + + return status; +} + +/** + * @brief Configure the RTC AlarmA/B Subseconds value and mask. + * @note This function is performed only when the Alarm is disabled. + * @param RTC_Alarm: specifies the alarm to be configured. + * This parameter can be one of the following values: + * @arg RTC_Alarm_A: to select Alarm A + * @param RTC_AlarmSubSecondValue: specifies the Subseconds value. + * This parameter can be a value from 0 to 0x00007FFF. + * @param RTC_AlarmSubSecondMask: specifies the Subseconds Mask. + * This parameter can be any combination of the following values: + * @arg RTC_AlarmSubSecondMask_All: All Alarm SS fields are masked. + * There is no comparison on sub seconds for Alarm. + * @arg RTC_AlarmSubSecondMask_SS14_1: SS[14:1] are don't care in Alarm comparison. + * Only SS[0] is compared + * @arg RTC_AlarmSubSecondMask_SS14_2: SS[14:2] are don't care in Alarm comparison. + * Only SS[1:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14_3: SS[14:3] are don't care in Alarm comparison. + * Only SS[2:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14_4: SS[14:4] are don't care in Alarm comparison. + * Only SS[3:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14_5: SS[14:5] are don't care in Alarm comparison. + * Only SS[4:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14_6: SS[14:6] are don't care in Alarm comparison. + * Only SS[5:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14_7: SS[14:7] are don't care in Alarm comparison. + * Only SS[6:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14_8: SS[14:8] are don't care in Alarm comparison. + * Only SS[7:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14_9: SS[14:9] are don't care in Alarm comparison. + * Only SS[8:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14_10: SS[14:10] are don't care in Alarm comparison. + * Only SS[9:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14_11: SS[14:11] are don't care in Alarm comparison. + * Only SS[10:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14_12: SS[14:12] are don't care in Alarm comparison. + * Only SS[11:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14_13: SS[14:13] are don't care in Alarm comparison. + * Only SS[12:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14: SS[14] is don't care in Alarm comparison. + * Only SS[13:0] are compared + * @arg RTC_AlarmSubSecondMask_None: SS[14:0] are compared and must match to activate alarm + * @retval None + */ +void RTC_AlarmSubSecondConfig(uint32_t RTC_Alarm, uint32_t RTC_AlarmSubSecondValue, uint8_t RTC_AlarmSubSecondMask) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RTC_ALARM(RTC_Alarm)); + assert_param(IS_RTC_ALARM_SUB_SECOND_VALUE(RTC_AlarmSubSecondValue)); + assert_param(IS_RTC_ALARM_SUB_SECOND_MASK(RTC_AlarmSubSecondMask)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Configure the Alarm A or Alarm B SubSecond registers */ + tmpreg = (uint32_t) (((uint32_t)(RTC_AlarmSubSecondValue)) | ((uint32_t)(RTC_AlarmSubSecondMask) << 24)); + + /* Configure the AlarmA SubSecond register */ + RTC->ALRMASSR = tmpreg; + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + +} + +/** + * @brief Gets the RTC Alarm Subseconds value. + * @param RTC_Alarm: specifies the alarm to be read. + * This parameter can be one of the following values: + * @arg RTC_Alarm_A: to select Alarm A + * @param None + * @retval RTC Alarm Subseconds value. + */ +uint32_t RTC_GetAlarmSubSecond(uint32_t RTC_Alarm) +{ + uint32_t tmpreg = 0; + + /* Get the RTC_ALRMAR register */ + tmpreg = (uint32_t)((RTC->ALRMASSR) & RTC_ALRMASSR_SS); + + return (tmpreg); +} + +/** + * @} + */ + +/** @defgroup RTC_Group4 WakeUp Timer configuration functions + * @brief WakeUp Timer configuration functions + * +@verbatim + =============================================================================== + ##### WakeUp Timer configuration functions ##### + =============================================================================== + + [..] This section provide functions allowing to program and read the RTC WakeUp. + +@endverbatim + * @{ + */ + +/** + * @brief Configures the RTC Wakeup clock source. + * This function is available for STM32F072 devices. + * @note The WakeUp Clock source can only be changed when the RTC WakeUp + * is disabled (Use the RTC_WakeUpCmd(DISABLE)). + * @param RTC_WakeUpClock: Wakeup Clock source. + * This parameter can be one of the following values: + * @arg RTC_WakeUpClock_RTCCLK_Div16 + * @arg RTC_WakeUpClock_RTCCLK_Div8 + * @arg RTC_WakeUpClock_RTCCLK_Div4 + * @arg RTC_WakeUpClock_RTCCLK_Div2 + * @arg RTC_WakeUpClock_CK_SPRE_16bits + * @arg RTC_WakeUpClock_CK_SPRE_17bits + * @retval None + */ +void RTC_WakeUpClockConfig(uint32_t RTC_WakeUpClock) +{ + /* Check the parameters */ + assert_param(IS_RTC_WAKEUP_CLOCK(RTC_WakeUpClock)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Clear the Wakeup Timer clock source bits in CR register */ + RTC->CR &= (uint32_t)~RTC_CR_WUCKSEL; + + /* Configure the clock source */ + RTC->CR |= (uint32_t)RTC_WakeUpClock; + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; +} + +/** + * @brief Configures the RTC Wakeup counter. + * This function is available for STM32F072 devices. + * @note The RTC WakeUp counter can only be written when the RTC WakeUp + * is disabled (Use the RTC_WakeUpCmd(DISABLE)). + * @param RTC_WakeUpCounter: specifies the WakeUp counter. + * This parameter can be a value from 0x0000 to 0xFFFF. + * @retval None + */ +void RTC_SetWakeUpCounter(uint32_t RTC_WakeUpCounter) +{ + /* Check the parameters */ + assert_param(IS_RTC_WAKEUP_COUNTER(RTC_WakeUpCounter)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Configure the Wakeup Timer counter */ + RTC->WUTR = (uint32_t)RTC_WakeUpCounter; + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; +} + +/** + * @brief Returns the RTC WakeUp timer counter value. + * This function is available for STM32F072 devices. + * @param None + * @retval The RTC WakeUp Counter value. + */ +uint32_t RTC_GetWakeUpCounter(void) +{ + /* Get the counter value */ + return ((uint32_t)(RTC->WUTR & RTC_WUTR_WUT)); +} + +/** + * @brief Enables or Disables the RTC WakeUp timer. + * This function is available for STM32F072 devices. + * @param NewState: new state of the WakeUp timer. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +ErrorStatus RTC_WakeUpCmd(FunctionalState NewState) +{ + __IO uint32_t wutcounter = 0x00; + uint32_t wutwfstatus = 0x00; + ErrorStatus status = ERROR; + + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + if (NewState != DISABLE) + { + /* Enable the Wakeup Timer */ + RTC->CR |= (uint32_t)RTC_CR_WUTE; + status = SUCCESS; + } + else + { + /* Disable the Wakeup Timer */ + RTC->CR &= (uint32_t)~RTC_CR_WUTE; + /* Wait till RTC WUTWF flag is set and if Time out is reached exit */ + do + { + wutwfstatus = RTC->ISR & RTC_ISR_WUTWF; + wutcounter++; + } while((wutcounter != INITMODE_TIMEOUT) && (wutwfstatus == 0x00)); + + if ((RTC->ISR & RTC_ISR_WUTWF) == RESET) + { + status = ERROR; + } + else + { + status = SUCCESS; + } + } + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + + return status; +} + +/** + * @} + */ + +/** @defgroup RTC_Group5 Daylight Saving configuration functions + * @brief Daylight Saving configuration functions + * +@verbatim + =============================================================================== + ##### WakeUp Timer configuration functions ##### + =============================================================================== + [..] This section provide functions allowing to program and read the RTC WakeUp. + + This section provide functions allowing to configure the RTC DayLight Saving. + +@endverbatim + * @{ + */ + +/** + * @brief Adds or substract one hour from the current time. + * @param RTC_DayLightSaveOperation: the value of hour adjustment. + * This parameter can be one of the following values: + * @arg RTC_DayLightSaving_SUB1H: Substract one hour (winter time) + * @arg RTC_DayLightSaving_ADD1H: Add one hour (summer time) + * @param RTC_StoreOperation: Specifies the value to be written in the BCK bit + * in CR register to store the operation. + * This parameter can be one of the following values: + * @arg RTC_StoreOperation_Reset: BCK Bit Reset + * @arg RTC_StoreOperation_Set: BCK Bit Set + * @retval None + */ +void RTC_DayLightSavingConfig(uint32_t RTC_DayLightSaving, uint32_t RTC_StoreOperation) +{ + /* Check the parameters */ + assert_param(IS_RTC_DAYLIGHT_SAVING(RTC_DayLightSaving)); + assert_param(IS_RTC_STORE_OPERATION(RTC_StoreOperation)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Clear the bits to be configured */ + RTC->CR &= (uint32_t)~(RTC_CR_BCK); + + /* Configure the RTC_CR register */ + RTC->CR |= (uint32_t)(RTC_DayLightSaving | RTC_StoreOperation); + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; +} + +/** + * @brief Returns the RTC Day Light Saving stored operation. + * @param None + * @retval RTC Day Light Saving stored operation. + * - RTC_StoreOperation_Reset + * - RTC_StoreOperation_Set + */ +uint32_t RTC_GetStoreOperation(void) +{ + return (RTC->CR & RTC_CR_BCK); +} + +/** + * @} + */ + +/** @defgroup RTC_Group6 Output pin Configuration function + * @brief Output pin Configuration function + * +@verbatim + =============================================================================== + ##### Output pin Configuration function ##### + =============================================================================== + [..] This section provide functions allowing to configure the RTC Output source. + +@endverbatim + * @{ + */ + +/** + * @brief Configures the RTC output source (AFO_ALARM). + * @param RTC_Output: Specifies which signal will be routed to the RTC output. + * This parameter can be one of the following values: + * @arg RTC_Output_Disable: No output selected + * @arg RTC_Output_AlarmA: signal of AlarmA mapped to output + * @arg RTC_Output_WakeUp: signal of WakeUp mapped to output, available only for STM32F072 devices + * @param RTC_OutputPolarity: Specifies the polarity of the output signal. + * This parameter can be one of the following: + * @arg RTC_OutputPolarity_High: The output pin is high when the + * ALRAF is high (depending on OSEL) + * @arg RTC_OutputPolarity_Low: The output pin is low when the + * ALRAF is high (depending on OSEL) + * @retval None + */ +void RTC_OutputConfig(uint32_t RTC_Output, uint32_t RTC_OutputPolarity) +{ + /* Check the parameters */ + assert_param(IS_RTC_OUTPUT(RTC_Output)); + assert_param(IS_RTC_OUTPUT_POL(RTC_OutputPolarity)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Clear the bits to be configured */ + RTC->CR &= (uint32_t)~(RTC_CR_OSEL | RTC_CR_POL); + + /* Configure the output selection and polarity */ + RTC->CR |= (uint32_t)(RTC_Output | RTC_OutputPolarity); + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; +} + +/** + * @} + */ + +/** @defgroup RTC_Group7 Digital Calibration configuration functions + * @brief Digital Calibration configuration functions + * +@verbatim + =============================================================================== + ##### Digital Calibration configuration functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the RTC clock to be output through the relative pin. + * @param NewState: new state of the digital calibration Output. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RTC_CalibOutputCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + if (NewState != DISABLE) + { + /* Enable the RTC clock output */ + RTC->CR |= (uint32_t)RTC_CR_COE; + } + else + { + /* Disable the RTC clock output */ + RTC->CR &= (uint32_t)~RTC_CR_COE; + } + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; +} + +/** + * @brief Configure the Calibration Pinout (RTC_CALIB) Selection (1Hz or 512Hz). + * @param RTC_CalibOutput: Select the Calibration output Selection . + * This parameter can be one of the following values: + * @arg RTC_CalibOutput_512Hz: A signal has a regular waveform at 512Hz. + * @arg RTC_CalibOutput_1Hz: A signal has a regular waveform at 1Hz. + * @retval None +*/ +void RTC_CalibOutputConfig(uint32_t RTC_CalibOutput) +{ + /* Check the parameters */ + assert_param(IS_RTC_CALIB_OUTPUT(RTC_CalibOutput)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /*clear flags before config*/ + RTC->CR &= (uint32_t)~(RTC_CR_CALSEL); + + /* Configure the RTC_CR register */ + RTC->CR |= (uint32_t)RTC_CalibOutput; + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; +} + +/** + * @brief Configures the Smooth Calibration Settings. + * @param RTC_SmoothCalibPeriod: Select the Smooth Calibration Period. + * This parameter can be can be one of the following values: + * @arg RTC_SmoothCalibPeriod_32sec: The smooth calibration periode is 32s. + * @arg RTC_SmoothCalibPeriod_16sec: The smooth calibration periode is 16s. + * @arg RTC_SmoothCalibPeriod_8sec: The smooth calibartion periode is 8s. + * @param RTC_SmoothCalibPlusPulses: Select to Set or reset the CALP bit. + * This parameter can be one of the following values: + * @arg RTC_SmoothCalibPlusPulses_Set: Add one RTCCLK puls every 2**11 pulses. + * @arg RTC_SmoothCalibPlusPulses_Reset: No RTCCLK pulses are added. + * @param RTC_SmouthCalibMinusPulsesValue: Select the value of CALM[8:0] bits. + * This parameter can be one any value from 0 to 0x000001FF. + * @retval An ErrorStatus enumeration value: + * - SUCCESS: RTC Calib registers are configured + * - ERROR: RTC Calib registers are not configured +*/ +ErrorStatus RTC_SmoothCalibConfig(uint32_t RTC_SmoothCalibPeriod, + uint32_t RTC_SmoothCalibPlusPulses, + uint32_t RTC_SmouthCalibMinusPulsesValue) +{ + ErrorStatus status = ERROR; + uint32_t recalpfcount = 0; + + /* Check the parameters */ + assert_param(IS_RTC_SMOOTH_CALIB_PERIOD(RTC_SmoothCalibPeriod)); + assert_param(IS_RTC_SMOOTH_CALIB_PLUS(RTC_SmoothCalibPlusPulses)); + assert_param(IS_RTC_SMOOTH_CALIB_MINUS(RTC_SmouthCalibMinusPulsesValue)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* check if a calibration is pending*/ + if ((RTC->ISR & RTC_ISR_RECALPF) != RESET) + { + /* wait until the Calibration is completed*/ + while (((RTC->ISR & RTC_ISR_RECALPF) != RESET) && (recalpfcount != RECALPF_TIMEOUT)) + { + recalpfcount++; + } + } + + /* check if the calibration pending is completed or if there is no calibration operation at all*/ + if ((RTC->ISR & RTC_ISR_RECALPF) == RESET) + { + /* Configure the Smooth calibration settings */ + RTC->CALR = (uint32_t)((uint32_t)RTC_SmoothCalibPeriod | (uint32_t)RTC_SmoothCalibPlusPulses | (uint32_t)RTC_SmouthCalibMinusPulsesValue); + + status = SUCCESS; + } + else + { + status = ERROR; + } + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + + return (ErrorStatus)(status); +} + +/** + * @} + */ + + +/** @defgroup RTC_Group8 TimeStamp configuration functions + * @brief TimeStamp configuration functions + * +@verbatim + =============================================================================== + ##### TimeStamp configuration functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Enables or Disables the RTC TimeStamp functionality with the + * specified time stamp pin stimulating edge. + * @param RTC_TimeStampEdge: Specifies the pin edge on which the TimeStamp is + * activated. + * This parameter can be one of the following: + * @arg RTC_TimeStampEdge_Rising: the Time stamp event occurs on the rising + * edge of the related pin. + * @arg RTC_TimeStampEdge_Falling: the Time stamp event occurs on the + * falling edge of the related pin. + * @param NewState: new state of the TimeStamp. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RTC_TimeStampCmd(uint32_t RTC_TimeStampEdge, FunctionalState NewState) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RTC_TIMESTAMP_EDGE(RTC_TimeStampEdge)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + /* Get the RTC_CR register and clear the bits to be configured */ + tmpreg = (uint32_t)(RTC->CR & (uint32_t)~(RTC_CR_TSEDGE | RTC_CR_TSE)); + + /* Get the new configuration */ + if (NewState != DISABLE) + { + tmpreg |= (uint32_t)(RTC_TimeStampEdge | RTC_CR_TSE); + } + else + { + tmpreg |= (uint32_t)(RTC_TimeStampEdge); + } + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Configure the Time Stamp TSEDGE and Enable bits */ + RTC->CR = (uint32_t)tmpreg; + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; +} + +/** + * @brief Get the RTC TimeStamp value and masks. + * @param RTC_Format: specifies the format of the output parameters. + * This parameter can be one of the following values: + * @arg RTC_Format_BIN: Binary data format + * @arg RTC_Format_BCD: BCD data format + * @param RTC_StampTimeStruct: pointer to a RTC_TimeTypeDef structure that will + * contains the TimeStamp time values. + * @param RTC_StampDateStruct: pointer to a RTC_DateTypeDef structure that will + * contains the TimeStamp date values. + * @retval None + */ +void RTC_GetTimeStamp(uint32_t RTC_Format, RTC_TimeTypeDef* RTC_StampTimeStruct, + RTC_DateTypeDef* RTC_StampDateStruct) +{ + uint32_t tmptime = 0, tmpdate = 0; + + /* Check the parameters */ + assert_param(IS_RTC_FORMAT(RTC_Format)); + + /* Get the TimeStamp time and date registers values */ + tmptime = (uint32_t)(RTC->TSTR & RTC_TR_RESERVED_MASK); + tmpdate = (uint32_t)(RTC->TSDR & RTC_DR_RESERVED_MASK); + + /* Fill the Time structure fields with the read parameters */ + RTC_StampTimeStruct->RTC_Hours = (uint8_t)((tmptime & (RTC_TR_HT | RTC_TR_HU)) >> 16); + RTC_StampTimeStruct->RTC_Minutes = (uint8_t)((tmptime & (RTC_TR_MNT | RTC_TR_MNU)) >> 8); + RTC_StampTimeStruct->RTC_Seconds = (uint8_t)(tmptime & (RTC_TR_ST | RTC_TR_SU)); + RTC_StampTimeStruct->RTC_H12 = (uint8_t)((tmptime & (RTC_TR_PM)) >> 16); + + /* Fill the Date structure fields with the read parameters */ + RTC_StampDateStruct->RTC_Year = 0; + RTC_StampDateStruct->RTC_Month = (uint8_t)((tmpdate & (RTC_DR_MT | RTC_DR_MU)) >> 8); + RTC_StampDateStruct->RTC_Date = (uint8_t)(tmpdate & (RTC_DR_DT | RTC_DR_DU)); + RTC_StampDateStruct->RTC_WeekDay = (uint8_t)((tmpdate & (RTC_DR_WDU)) >> 13); + + /* Check the input parameters format */ + if (RTC_Format == RTC_Format_BIN) + { + /* Convert the Time structure parameters to Binary format */ + RTC_StampTimeStruct->RTC_Hours = (uint8_t)RTC_Bcd2ToByte(RTC_StampTimeStruct->RTC_Hours); + RTC_StampTimeStruct->RTC_Minutes = (uint8_t)RTC_Bcd2ToByte(RTC_StampTimeStruct->RTC_Minutes); + RTC_StampTimeStruct->RTC_Seconds = (uint8_t)RTC_Bcd2ToByte(RTC_StampTimeStruct->RTC_Seconds); + + /* Convert the Date structure parameters to Binary format */ + RTC_StampDateStruct->RTC_Month = (uint8_t)RTC_Bcd2ToByte(RTC_StampDateStruct->RTC_Month); + RTC_StampDateStruct->RTC_Date = (uint8_t)RTC_Bcd2ToByte(RTC_StampDateStruct->RTC_Date); + RTC_StampDateStruct->RTC_WeekDay = (uint8_t)RTC_Bcd2ToByte(RTC_StampDateStruct->RTC_WeekDay); + } +} + +/** + * @brief Get the RTC timestamp Subseconds value. + * @param None + * @retval RTC current timestamp Subseconds value. + */ +uint32_t RTC_GetTimeStampSubSecond(void) +{ + /* Get timestamp subseconds values from the correspondent registers */ + return (uint32_t)(RTC->TSSSR); +} + +/** + * @} + */ + +/** @defgroup RTC_Group9 Tampers configuration functions + * @brief Tampers configuration functions + * +@verbatim + =============================================================================== + ##### Tampers configuration functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Configures the select Tamper pin edge. + * @param RTC_Tamper: Selected tamper pin. + * This parameter can be any combination of the following values: + * @arg RTC_Tamper_1: Select Tamper 1. + * @arg RTC_Tamper_2: Select Tamper 2. + * @param RTC_TamperTrigger: Specifies the trigger on the tamper pin that + * stimulates tamper event. + * This parameter can be one of the following values: + * @arg RTC_TamperTrigger_RisingEdge: Rising Edge of the tamper pin causes tamper event. + * @arg RTC_TamperTrigger_FallingEdge: Falling Edge of the tamper pin causes tamper event. + * @arg RTC_TamperTrigger_LowLevel: Low Level of the tamper pin causes tamper event. + * @arg RTC_TamperTrigger_HighLevel: High Level of the tamper pin causes tamper event. + * @retval None + */ +void RTC_TamperTriggerConfig(uint32_t RTC_Tamper, uint32_t RTC_TamperTrigger) +{ + /* Check the parameters */ + assert_param(IS_RTC_TAMPER(RTC_Tamper)); + assert_param(IS_RTC_TAMPER_TRIGGER(RTC_TamperTrigger)); + + if (RTC_TamperTrigger == RTC_TamperTrigger_RisingEdge) + { + /* Configure the RTC_TAFCR register */ + RTC->TAFCR &= (uint32_t)((uint32_t)~(RTC_Tamper << 1)); + } + else + { + /* Configure the RTC_TAFCR register */ + RTC->TAFCR |= (uint32_t)(RTC_Tamper << 1); + } +} + +/** + * @brief Enables or Disables the Tamper detection. + * @param RTC_Tamper: Selected tamper pin. + * This parameter can be any combination of the following values: + * @arg RTC_Tamper_1: Select Tamper 1. + * @arg RTC_Tamper_2: Select Tamper 2. + * @param NewState: new state of the tamper pin. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RTC_TamperCmd(uint32_t RTC_Tamper, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_RTC_TAMPER(RTC_Tamper)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected Tamper pin */ + RTC->TAFCR |= (uint32_t)RTC_Tamper; + } + else + { + /* Disable the selected Tamper pin */ + RTC->TAFCR &= (uint32_t)~RTC_Tamper; + } +} + +/** + * @brief Configures the Tampers Filter. + * @param RTC_TamperFilter: Specifies the tampers filter. + * This parameter can be one of the following values: + * @arg RTC_TamperFilter_Disable: Tamper filter is disabled. + * @arg RTC_TamperFilter_2Sample: Tamper is activated after 2 consecutive + * samples at the active level + * @arg RTC_TamperFilter_4Sample: Tamper is activated after 4 consecutive + * samples at the active level + * @arg RTC_TamperFilter_8Sample: Tamper is activated after 8 consecutive + * samples at the active level + * @retval None + */ +void RTC_TamperFilterConfig(uint32_t RTC_TamperFilter) +{ + /* Check the parameters */ + assert_param(IS_RTC_TAMPER_FILTER(RTC_TamperFilter)); + + /* Clear TAMPFLT[1:0] bits in the RTC_TAFCR register */ + RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_TAMPFLT); + + /* Configure the RTC_TAFCR register */ + RTC->TAFCR |= (uint32_t)RTC_TamperFilter; +} + +/** + * @brief Configures the Tampers Sampling Frequency. + * @param RTC_TamperSamplingFreq: Specifies the tampers Sampling Frequency. + * This parameter can be one of the following values: + * @arg RTC_TamperSamplingFreq_RTCCLK_Div32768: Each of the tamper inputs are sampled + * with a frequency = RTCCLK / 32768 + * @arg RTC_TamperSamplingFreq_RTCCLK_Div16384: Each of the tamper inputs are sampled + * with a frequency = RTCCLK / 16384 + * @arg RTC_TamperSamplingFreq_RTCCLK_Div8192: Each of the tamper inputs are sampled + * with a frequency = RTCCLK / 8192 + * @arg RTC_TamperSamplingFreq_RTCCLK_Div4096: Each of the tamper inputs are sampled + * with a frequency = RTCCLK / 4096 + * @arg RTC_TamperSamplingFreq_RTCCLK_Div2048: Each of the tamper inputs are sampled + * with a frequency = RTCCLK / 2048 + * @arg RTC_TamperSamplingFreq_RTCCLK_Div1024: Each of the tamper inputs are sampled + * with a frequency = RTCCLK / 1024 + * @arg RTC_TamperSamplingFreq_RTCCLK_Div512: Each of the tamper inputs are sampled + * with a frequency = RTCCLK / 512 + * @arg RTC_TamperSamplingFreq_RTCCLK_Div256: Each of the tamper inputs are sampled + * with a frequency = RTCCLK / 256 + * @retval None + */ +void RTC_TamperSamplingFreqConfig(uint32_t RTC_TamperSamplingFreq) +{ + /* Check the parameters */ + assert_param(IS_RTC_TAMPER_SAMPLING_FREQ(RTC_TamperSamplingFreq)); + + /* Clear TAMPFREQ[2:0] bits in the RTC_TAFCR register */ + RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_TAMPFREQ); + + /* Configure the RTC_TAFCR register */ + RTC->TAFCR |= (uint32_t)RTC_TamperSamplingFreq; +} + +/** + * @brief Configures the Tampers Pins input Precharge Duration. + * @param RTC_TamperPrechargeDuration: Specifies the Tampers Pins input + * Precharge Duration. + * This parameter can be one of the following values: + * @arg RTC_TamperPrechargeDuration_1RTCCLK: Tamper pins are pre-charged before sampling during 1 RTCCLK cycle + * @arg RTC_TamperPrechargeDuration_2RTCCLK: Tamper pins are pre-charged before sampling during 2 RTCCLK cycle + * @arg RTC_TamperPrechargeDuration_4RTCCLK: Tamper pins are pre-charged before sampling during 4 RTCCLK cycle + * @arg RTC_TamperPrechargeDuration_8RTCCLK: Tamper pins are pre-charged before sampling during 8 RTCCLK cycle + * @retval None + */ +void RTC_TamperPinsPrechargeDuration(uint32_t RTC_TamperPrechargeDuration) +{ + /* Check the parameters */ + assert_param(IS_RTC_TAMPER_PRECHARGE_DURATION(RTC_TamperPrechargeDuration)); + + /* Clear TAMPPRCH[1:0] bits in the RTC_TAFCR register */ + RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_TAMPPRCH); + + /* Configure the RTC_TAFCR register */ + RTC->TAFCR |= (uint32_t)RTC_TamperPrechargeDuration; +} + +/** + * @brief Enables or Disables the TimeStamp on Tamper Detection Event. + * @note The timestamp is valid even the TSE bit in tamper control register + * is reset. + * @param NewState: new state of the timestamp on tamper event. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RTC_TimeStampOnTamperDetectionCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Save timestamp on tamper detection event */ + RTC->TAFCR |= (uint32_t)RTC_TAFCR_TAMPTS; + } + else + { + /* Tamper detection does not cause a timestamp to be saved */ + RTC->TAFCR &= (uint32_t)~RTC_TAFCR_TAMPTS; + } +} + +/** + * @brief Enables or Disables the Precharge of Tamper pin. + * @param NewState: new state of tamper pull up. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RTC_TamperPullUpCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable precharge of the selected Tamper pin */ + RTC->TAFCR &= (uint32_t)~RTC_TAFCR_TAMPPUDIS; + } + else + { + /* Disable precharge of the selected Tamper pin */ + RTC->TAFCR |= (uint32_t)RTC_TAFCR_TAMPPUDIS; + } +} + +/** + * @} + */ + +/** @defgroup RTC_Group10 Backup Data Registers configuration functions + * @brief Backup Data Registers configuration functions + * +@verbatim + =============================================================================== + ##### Backup Data Registers configuration functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Writes a data in a specified RTC Backup data register. + * @param RTC_BKP_DR: RTC Backup data Register number. + * This parameter can be: RTC_BKP_DRx where x can be from 0 to 4 to + * specify the register. + * @param Data: Data to be written in the specified RTC Backup data register. + * @retval None + */ +void RTC_WriteBackupRegister(uint32_t RTC_BKP_DR, uint32_t Data) +{ + __IO uint32_t tmp = 0; + + /* Check the parameters */ + assert_param(IS_RTC_BKP(RTC_BKP_DR)); + + tmp = RTC_BASE + 0x50; + tmp += (RTC_BKP_DR * 4); + + /* Write the specified register */ + *(__IO uint32_t *)tmp = (uint32_t)Data; +} + +/** + * @brief Reads data from the specified RTC Backup data Register. + * @param RTC_BKP_DR: RTC Backup data Register number. + * This parameter can be: RTC_BKP_DRx where x can be from 0 to 19 to + * specify the register. + * @retval None + */ +uint32_t RTC_ReadBackupRegister(uint32_t RTC_BKP_DR) +{ + __IO uint32_t tmp = 0; + + /* Check the parameters */ + assert_param(IS_RTC_BKP(RTC_BKP_DR)); + + tmp = RTC_BASE + 0x50; + tmp += (RTC_BKP_DR * 4); + + /* Read the specified register */ + return (*(__IO uint32_t *)tmp); +} + +/** + * @} + */ + +/** @defgroup RTC_Group11 Output Type Config configuration functions + * @brief Output Type Config configuration functions + * +@verbatim + =============================================================================== + ##### Output Type Config configuration functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Configures the RTC Output Pin mode. + * @param RTC_OutputType: specifies the RTC Output (PC13) pin mode. + * This parameter can be one of the following values: + * @arg RTC_OutputType_OpenDrain: RTC Output (PC13) is configured in + * Open Drain mode. + * @arg RTC_OutputType_PushPull: RTC Output (PC13) is configured in + * Push Pull mode. + * @retval None + */ +void RTC_OutputTypeConfig(uint32_t RTC_OutputType) +{ + /* Check the parameters */ + assert_param(IS_RTC_OUTPUT_TYPE(RTC_OutputType)); + + RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_ALARMOUTTYPE); + RTC->TAFCR |= (uint32_t)(RTC_OutputType); +} + +/** + * @} + */ + +/** @defgroup RTC_Group12 Shift control synchronisation functions + * @brief Shift control synchronisation functions + * +@verbatim + =============================================================================== + ##### Shift control synchronisation functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Configures the Synchronization Shift Control Settings. + * @note When REFCKON is set, firmware must not write to Shift control register + * @param RTC_ShiftAdd1S: Select to add or not 1 second to the time Calendar. + * This parameter can be one of the following values : + * @arg RTC_ShiftAdd1S_Set: Add one second to the clock calendar. + * @arg RTC_ShiftAdd1S_Reset: No effect. + * @param RTC_ShiftSubFS: Select the number of Second Fractions to Substitute. + * This parameter can be one any value from 0 to 0x7FFF. + * @retval An ErrorStatus enumeration value: + * - SUCCESS: RTC Shift registers are configured + * - ERROR: RTC Shift registers are not configured +*/ +ErrorStatus RTC_SynchroShiftConfig(uint32_t RTC_ShiftAdd1S, uint32_t RTC_ShiftSubFS) +{ + ErrorStatus status = ERROR; + uint32_t shpfcount = 0; + + /* Check the parameters */ + assert_param(IS_RTC_SHIFT_ADD1S(RTC_ShiftAdd1S)); + assert_param(IS_RTC_SHIFT_SUBFS(RTC_ShiftSubFS)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Check if a Shift is pending*/ + if ((RTC->ISR & RTC_ISR_SHPF) != RESET) + { + /* Wait until the shift is completed*/ + while (((RTC->ISR & RTC_ISR_SHPF) != RESET) && (shpfcount != SHPF_TIMEOUT)) + { + shpfcount++; + } + } + + /* Check if the Shift pending is completed or if there is no Shift operation at all*/ + if ((RTC->ISR & RTC_ISR_SHPF) == RESET) + { + /* check if the reference clock detection is disabled */ + if((RTC->CR & RTC_CR_REFCKON) == RESET) + { + /* Configure the Shift settings */ + RTC->SHIFTR = (uint32_t)(uint32_t)(RTC_ShiftSubFS) | (uint32_t)(RTC_ShiftAdd1S); + + if(RTC_WaitForSynchro() == ERROR) + { + status = ERROR; + } + else + { + status = SUCCESS; + } + } + else + { + status = ERROR; + } + } + else + { + status = ERROR; + } + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + + return (ErrorStatus)(status); +} + +/** + * @} + */ + +/** @defgroup RTC_Group13 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== + [..] All RTC interrupts are connected to the EXTI controller. + + (+) To enable the RTC Alarm interrupt, the following sequence is required: + (++) Configure and enable the EXTI Line 17 in interrupt mode and select the rising + edge sensitivity using the EXTI_Init() function. + (++) Configure and enable the RTC_Alarm IRQ channel in the NVIC using the NVIC_Init() + function. + (++) Configure the RTC to generate RTC alarms (Alarm A) using + the RTC_SetAlarm() and RTC_AlarmCmd() functions. + + (+) To enable the RTC Tamper interrupt, the following sequence is required: + (++) Configure and enable the EXTI Line 19 in interrupt mode and select the rising + edge sensitivity using the EXTI_Init() function. + (++) Configure and enable the TAMP_STAMP IRQ channel in the NVIC using the NVIC_Init() + function. + (++) Configure the RTC to detect the RTC tamper event using the + RTC_TamperTriggerConfig() and RTC_TamperCmd() functions. + + (+) To enable the RTC TimeStamp interrupt, the following sequence is required: + (++) Configure and enable the EXTI Line 19 in interrupt mode and select the rising + edge sensitivity using the EXTI_Init() function. + (++) Configure and enable the TAMP_STAMP IRQ channel in the NVIC using the NVIC_Init() + function. + (++) Configure the RTC to detect the RTC time-stamp event using the + RTC_TimeStampCmd() functions. + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified RTC interrupts. + * @param RTC_IT: specifies the RTC interrupt sources to be enabled or disabled. + * This parameter can be any combination of the following values: + * @arg RTC_IT_TS: Time Stamp interrupt mask + * @arg RTC_IT_WUT: WakeUp Timer interrupt mask, available only for STM32F072 devices + * @arg RTC_IT_ALRA: Alarm A interrupt mask + * @arg RTC_IT_TAMP: Tamper event interrupt mask + * @param NewState: new state of the specified RTC interrupts. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RTC_ITConfig(uint32_t RTC_IT, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_RTC_CONFIG_IT(RTC_IT)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + if (NewState != DISABLE) + { + /* Configure the Interrupts in the RTC_CR register */ + RTC->CR |= (uint32_t)(RTC_IT & ~RTC_TAFCR_TAMPIE); + /* Configure the Tamper Interrupt in the RTC_TAFCR */ + RTC->TAFCR |= (uint32_t)(RTC_IT & RTC_TAFCR_TAMPIE); + } + else + { + /* Configure the Interrupts in the RTC_CR register */ + RTC->CR &= (uint32_t)~(RTC_IT & (uint32_t)~RTC_TAFCR_TAMPIE); + /* Configure the Tamper Interrupt in the RTC_TAFCR */ + RTC->TAFCR &= (uint32_t)~(RTC_IT & RTC_TAFCR_TAMPIE); + } + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; +} + +/** + * @brief Checks whether the specified RTC flag is set or not. + * @param RTC_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg RTC_FLAG_RECALPF: RECALPF event flag + * @arg RTC_FLAG_TAMP2F: Tamper 2 event flag + * @arg RTC_FLAG_TAMP1F: Tamper 1 event flag + * @arg RTC_FLAG_TSOVF: Time Stamp OverFlow flag + * @arg RTC_FLAG_TSF: Time Stamp event flag + * @arg RTC_FLAG_WUTF: WakeUp Timer flag, available only for STM32F072 devices + * @arg RTC_FLAG_ALRAF: Alarm A flag + * @arg RTC_FLAG_INITF: Initialization mode flag + * @arg RTC_FLAG_RSF: Registers Synchronized flag + * @arg RTC_FLAG_INITS: Registers Configured flag + * @retval The new state of RTC_FLAG (SET or RESET). + */ +FlagStatus RTC_GetFlagStatus(uint32_t RTC_FLAG) +{ + FlagStatus bitstatus = RESET; + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RTC_GET_FLAG(RTC_FLAG)); + + /* Get all the flags */ + tmpreg = (uint32_t)(RTC->ISR & RTC_FLAGS_MASK); + + /* Return the status of the flag */ + if ((tmpreg & RTC_FLAG) != (uint32_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + return bitstatus; +} + +/** + * @brief Clears the RTC's pending flags. + * @param RTC_FLAG: specifies the RTC flag to clear. + * This parameter can be any combination of the following values: + * @arg RTC_FLAG_TAMP2F: Tamper 2 event flag + * @arg RTC_FLAG_TAMP1F: Tamper 1 event flag + * @arg RTC_FLAG_TSOVF: Time Stamp Overflow flag + * @arg RTC_FLAG_TSF: Time Stamp event flag + * @arg RTC_FLAG_WUTF: WakeUp Timer flag, available only for STM32F072 devices + * @arg RTC_FLAG_ALRAF: Alarm A flag + * @arg RTC_FLAG_RSF: Registers Synchronized flag + * @retval None + */ +void RTC_ClearFlag(uint32_t RTC_FLAG) +{ + /* Check the parameters */ + assert_param(IS_RTC_CLEAR_FLAG(RTC_FLAG)); + + /* Clear the Flags in the RTC_ISR register */ + RTC->ISR = (uint32_t)((uint32_t)(~((RTC_FLAG | RTC_ISR_INIT)& 0x0001FFFF) | (uint32_t)(RTC->ISR & RTC_ISR_INIT))); +} + +/** + * @brief Checks whether the specified RTC interrupt has occurred or not. + * @param RTC_IT: specifies the RTC interrupt source to check. + * This parameter can be one of the following values: + * @arg RTC_IT_TS: Time Stamp interrupt + * @arg RTC_IT_WUT: WakeUp Timer interrupt, available only for STM32F072 devices + * @arg RTC_IT_ALRA: Alarm A interrupt + * @arg RTC_IT_TAMP1: Tamper1 event interrupt + * @arg RTC_IT_TAMP2: Tamper2 event interrupt + * @retval The new state of RTC_IT (SET or RESET). + */ +ITStatus RTC_GetITStatus(uint32_t RTC_IT) +{ + ITStatus bitstatus = RESET; + uint32_t tmpreg = 0, enablestatus = 0; + + /* Check the parameters */ + assert_param(IS_RTC_GET_IT(RTC_IT)); + + /* Get the TAMPER Interrupt enable bit and pending bit */ + tmpreg = (uint32_t)(RTC->TAFCR & (RTC_TAFCR_TAMPIE)); + + /* Get the Interrupt enable Status */ + enablestatus = (uint32_t)((RTC->CR & RTC_IT) | (tmpreg & ((RTC_IT >> (RTC_IT >> 18)) >> 15))); + + /* Get the Interrupt pending bit */ + tmpreg = (uint32_t)((RTC->ISR & (uint32_t)(RTC_IT >> 4))); + + /* Get the status of the Interrupt */ + if ((enablestatus != (uint32_t)RESET) && ((tmpreg & 0x0000FFFF) != (uint32_t)RESET)) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + return bitstatus; +} + +/** + * @brief Clears the RTC's interrupt pending bits. + * @param RTC_IT: specifies the RTC interrupt pending bit to clear. + * This parameter can be any combination of the following values: + * @arg RTC_IT_TS: Time Stamp interrupt + * @arg RTC_IT_WUT: WakeUp Timer interrupt, available only for STM32F072 devices + * @arg RTC_IT_ALRA: Alarm A interrupt + * @arg RTC_IT_TAMP1: Tamper1 event interrupt + * @arg RTC_IT_TAMP2: Tamper2 event interrupt + * @retval None + */ +void RTC_ClearITPendingBit(uint32_t RTC_IT) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RTC_CLEAR_IT(RTC_IT)); + + /* Get the RTC_ISR Interrupt pending bits mask */ + tmpreg = (uint32_t)(RTC_IT >> 4); + + /* Clear the interrupt pending bits in the RTC_ISR register */ + RTC->ISR = (uint32_t)((uint32_t)(~((tmpreg | RTC_ISR_INIT)& 0x0000FFFF) | (uint32_t)(RTC->ISR & RTC_ISR_INIT))); +} + +/** + * @} + */ + +/** + * @brief Converts a 2 digit decimal to BCD format. + * @param Value: Byte to be converted. + * @retval Converted byte + */ +static uint8_t RTC_ByteToBcd2(uint8_t Value) +{ + uint8_t bcdhigh = 0; + + while (Value >= 10) + { + bcdhigh++; + Value -= 10; + } + + return ((uint8_t)(bcdhigh << 4) | Value); +} + +/** + * @brief Convert from 2 digit BCD to Binary. + * @param Value: BCD value to be converted. + * @retval Converted word + */ +static uint8_t RTC_Bcd2ToByte(uint8_t Value) +{ + uint8_t tmp = 0; + tmp = ((uint8_t)(Value & (uint8_t)0xF0) >> (uint8_t)0x4) * 10; + return (tmp + (Value & (uint8_t)0x0F)); +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_spi.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_spi.c new file mode 100644 index 00000000..f57a82dc --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_spi.c @@ -0,0 +1,1334 @@ +/** + ****************************************************************************** + * @file stm32f0xx_spi.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Serial peripheral interface (SPI): + * + Initialization and Configuration + * + Data transfers functions + * + Hardware CRC Calculation + * + DMA transfers management + * + Interrupts and flags management + * + * @verbatim + + =============================================================================== + ##### How to use this driver ##### + =============================================================================== + [..] + (#) Enable peripheral clock using RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE) + function for SPI1 or using RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE) + function for SPI2. + + (#) Enable SCK, MOSI, MISO and NSS GPIO clocks using + RCC_AHBPeriphClockCmd() function. + + (#) Peripherals alternate function: + (++) Connect the pin to the desired peripherals' Alternate + Function (AF) using GPIO_PinAFConfig() function. + (++) Configure the desired pin in alternate function by: + GPIO_InitStruct->GPIO_Mode = GPIO_Mode_AF. + (++) Select the type, pull-up/pull-down and output speed via + GPIO_PuPd, GPIO_OType and GPIO_Speed members. + (++) Call GPIO_Init() function. + + (#) Program the Polarity, Phase, First Data, Baud Rate Prescaler, Slave + Management, Peripheral Mode and CRC Polynomial values using the SPI_Init() + function.In I2S mode, program the Mode, Standard, Data Format, MCLK + Output, Audio frequency and Polarity using I2S_Init() function. + + (#) Configure the FIFO threshold using SPI_RxFIFOThresholdConfig() to select + at which threshold the RXNE event is generated. + + (#) Enable the NVIC and the corresponding interrupt using the function + SPI_ITConfig() if you need to use interrupt mode. + + (#) When using the DMA mode + (++) Configure the DMA using DMA_Init() function. + (++) Active the needed channel Request using SPI_I2S_DMACmd() function. + + (#) Enable the SPI using the SPI_Cmd() function or enable the I2S using + I2S_Cmd(). + + (#) Enable the DMA using the DMA_Cmd() function when using DMA mode. + + (#) Optionally, you can enable/configure the following parameters without + re-initialization (i.e there is no need to call again SPI_Init() function): + (++) When bidirectional mode (SPI_Direction_1Line_Rx or SPI_Direction_1Line_Tx) + is programmed as Data direction parameter using the SPI_Init() + function it can be possible to switch between SPI_Direction_Tx + or SPI_Direction_Rx using the SPI_BiDirectionalLineConfig() function. + (++) When SPI_NSS_Soft is selected as Slave Select Management parameter + using the SPI_Init() function it can be possible to manage the + NSS internal signal using the SPI_NSSInternalSoftwareConfig() function. + (++) Reconfigure the data size using the SPI_DataSizeConfig() function. + (++) Enable or disable the SS output using the SPI_SSOutputCmd() function. + + (#) To use the CRC Hardware calculation feature refer to the Peripheral + CRC hardware Calculation subsection. + + @endverbatim + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_spi.h" +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup SPI + * @brief SPI driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* SPI registers Masks */ +#define CR1_CLEAR_MASK ((uint16_t)0x3040) +#define CR1_CLEAR_MASK2 ((uint16_t)0xFFFB) +#define CR2_LDMA_MASK ((uint16_t)0x9FFF) + +#define I2SCFGR_CLEAR_Mask ((uint16_t)0xF040) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup SPI_Private_Functions + * @{ + */ + +/** @defgroup SPI_Group1 Initialization and Configuration functions + * @brief Initialization and Configuration functions + * +@verbatim + =============================================================================== + ##### Initialization and Configuration functions ##### + =============================================================================== + [..] This section provides a set of functions allowing to initialize the SPI Direction, + SPI Mode, SPI Data Size, SPI Polarity, SPI Phase, SPI NSS Management, SPI Baud + Rate Prescaler, SPI First Bit and SPI CRC Polynomial. + + [..] The SPI_Init() function follows the SPI configuration procedures for Master mode + and Slave mode (details for these procedures are available in reference manual). + + [..] When the Software NSS management (SPI_InitStruct->SPI_NSS = SPI_NSS_Soft) is selected, + use the following function to manage the NSS bit: + void SPI_NSSInternalSoftwareConfig(SPI_TypeDef* SPIx, uint16_t SPI_NSSInternalSoft); + + [..] In Master mode, when the Hardware NSS management (SPI_InitStruct->SPI_NSS = SPI_NSS_Hard) + is selected, use the follwoing function to enable the NSS output feature. + void SPI_SSOutputCmd(SPI_TypeDef* SPIx, FunctionalState NewState); + + [..] The NSS pulse mode can be managed by the SPI TI mode when enabling it using the following function: + void SPI_TIModeCmd(SPI_TypeDef* SPIx, FunctionalState NewState); + And it can be managed by software in the SPI Motorola mode using this function: + void SPI_NSSPulseModeCmd(SPI_TypeDef* SPIx, FunctionalState NewState); + + [..] This section provides also functions to initialize the I2S Mode, Standard, + Data Format, MCLK Output, Audio frequency and Polarity. + + [..] The I2S_Init() function follows the I2S configuration procedures for Master mode + and Slave mode. + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the SPIx peripheral registers to their default + * reset values. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * I2S mode is not supported for STM32F030 devices. + * @retval None + */ +void SPI_I2S_DeInit(SPI_TypeDef* SPIx) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + + if (SPIx == SPI1) + { + /* Enable SPI1 reset state */ + RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1, ENABLE); + /* Release SPI1 from reset state */ + RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1, DISABLE); + } + else + { + if (SPIx == SPI2) + { + /* Enable SPI2 reset state */ + RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2, ENABLE); + /* Release SPI2 from reset state */ + RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2, DISABLE); + } + } +} + +/** + * @brief Fills each SPI_InitStruct member with its default value. + * @param SPI_InitStruct: pointer to a SPI_InitTypeDef structure which will be initialized. + * @retval None + */ +void SPI_StructInit(SPI_InitTypeDef* SPI_InitStruct) +{ +/*--------------- Reset SPI init structure parameters values -----------------*/ + /* Initialize the SPI_Direction member */ + SPI_InitStruct->SPI_Direction = SPI_Direction_2Lines_FullDuplex; + /* Initialize the SPI_Mode member */ + SPI_InitStruct->SPI_Mode = SPI_Mode_Slave; + /* Initialize the SPI_DataSize member */ + SPI_InitStruct->SPI_DataSize = SPI_DataSize_8b; + /* Initialize the SPI_CPOL member */ + SPI_InitStruct->SPI_CPOL = SPI_CPOL_Low; + /* Initialize the SPI_CPHA member */ + SPI_InitStruct->SPI_CPHA = SPI_CPHA_1Edge; + /* Initialize the SPI_NSS member */ + SPI_InitStruct->SPI_NSS = SPI_NSS_Hard; + /* Initialize the SPI_BaudRatePrescaler member */ + SPI_InitStruct->SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2; + /* Initialize the SPI_FirstBit member */ + SPI_InitStruct->SPI_FirstBit = SPI_FirstBit_MSB; + /* Initialize the SPI_CRCPolynomial member */ + SPI_InitStruct->SPI_CRCPolynomial = 7; +} + +/** + * @brief Initializes the SPIx peripheral according to the specified + * parameters in the SPI_InitStruct. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param SPI_InitStruct: pointer to a SPI_InitTypeDef structure that + * contains the configuration information for the specified SPI peripheral. + * @retval None + */ +void SPI_Init(SPI_TypeDef* SPIx, SPI_InitTypeDef* SPI_InitStruct) +{ + uint16_t tmpreg = 0; + + /* check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + + /* Check the SPI parameters */ + assert_param(IS_SPI_DIRECTION_MODE(SPI_InitStruct->SPI_Direction)); + assert_param(IS_SPI_MODE(SPI_InitStruct->SPI_Mode)); + assert_param(IS_SPI_DATA_SIZE(SPI_InitStruct->SPI_DataSize)); + assert_param(IS_SPI_CPOL(SPI_InitStruct->SPI_CPOL)); + assert_param(IS_SPI_CPHA(SPI_InitStruct->SPI_CPHA)); + assert_param(IS_SPI_NSS(SPI_InitStruct->SPI_NSS)); + assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_InitStruct->SPI_BaudRatePrescaler)); + assert_param(IS_SPI_FIRST_BIT(SPI_InitStruct->SPI_FirstBit)); + assert_param(IS_SPI_CRC_POLYNOMIAL(SPI_InitStruct->SPI_CRCPolynomial)); + + /*---------------------------- SPIx CR1 Configuration ------------------------*/ + /* Get the SPIx CR1 value */ + tmpreg = SPIx->CR1; + /* Clear BIDIMode, BIDIOE, RxONLY, SSM, SSI, LSBFirst, BR, CPOL and CPHA bits */ + tmpreg &= CR1_CLEAR_MASK; + /* Configure SPIx: direction, NSS management, first transmitted bit, BaudRate prescaler + master/slave mode, CPOL and CPHA */ + /* Set BIDImode, BIDIOE and RxONLY bits according to SPI_Direction value */ + /* Set SSM, SSI bit according to SPI_NSS values */ + /* Set LSBFirst bit according to SPI_FirstBit value */ + /* Set BR bits according to SPI_BaudRatePrescaler value */ + /* Set CPOL bit according to SPI_CPOL value */ + /* Set CPHA bit according to SPI_CPHA value */ + tmpreg |= (uint16_t)((uint32_t)SPI_InitStruct->SPI_Direction | SPI_InitStruct->SPI_FirstBit | + SPI_InitStruct->SPI_CPOL | SPI_InitStruct->SPI_CPHA | + SPI_InitStruct->SPI_NSS | SPI_InitStruct->SPI_BaudRatePrescaler); + /* Write to SPIx CR1 */ + SPIx->CR1 = tmpreg; + /*-------------------------Data Size Configuration -----------------------*/ + /* Get the SPIx CR2 value */ + tmpreg = SPIx->CR2; + /* Clear DS[3:0] bits */ + tmpreg &=(uint16_t)~SPI_CR2_DS; + /* Configure SPIx: Data Size */ + tmpreg |= (uint16_t)(SPI_InitStruct->SPI_DataSize); + /* Write to SPIx CR2 */ + SPIx->CR2 = tmpreg; + + /*---------------------------- SPIx CRCPOLY Configuration --------------------*/ + /* Write to SPIx CRCPOLY */ + SPIx->CRCPR = SPI_InitStruct->SPI_CRCPolynomial; + + /*---------------------------- SPIx CR1 Configuration ------------------------*/ + /* Get the SPIx CR1 value */ + tmpreg = SPIx->CR1; + /* Clear MSTR bit */ + tmpreg &= CR1_CLEAR_MASK2; + /* Configure SPIx: master/slave mode */ + /* Set MSTR bit according to SPI_Mode */ + tmpreg |= (uint16_t)((uint32_t)SPI_InitStruct->SPI_Mode); + /* Write to SPIx CR1 */ + SPIx->CR1 = tmpreg; + + /* Activate the SPI mode (Reset I2SMOD bit in I2SCFGR register) */ + SPIx->I2SCFGR &= (uint16_t)~((uint16_t)SPI_I2SCFGR_I2SMOD); +} + +/** + * @brief Fills each I2S_InitStruct member with its default value. + * @note This mode is not supported for STM32F030 devices. + * @param I2S_InitStruct: pointer to a I2S_InitTypeDef structure which will be initialized. + * @retval None + */ +void I2S_StructInit(I2S_InitTypeDef* I2S_InitStruct) +{ +/*--------------- Reset I2S init structure parameters values -----------------*/ + /* Initialize the I2S_Mode member */ + I2S_InitStruct->I2S_Mode = I2S_Mode_SlaveTx; + + /* Initialize the I2S_Standard member */ + I2S_InitStruct->I2S_Standard = I2S_Standard_Phillips; + + /* Initialize the I2S_DataFormat member */ + I2S_InitStruct->I2S_DataFormat = I2S_DataFormat_16b; + + /* Initialize the I2S_MCLKOutput member */ + I2S_InitStruct->I2S_MCLKOutput = I2S_MCLKOutput_Disable; + + /* Initialize the I2S_AudioFreq member */ + I2S_InitStruct->I2S_AudioFreq = I2S_AudioFreq_Default; + + /* Initialize the I2S_CPOL member */ + I2S_InitStruct->I2S_CPOL = I2S_CPOL_Low; +} + +/** + * @brief Initializes the SPIx peripheral according to the specified + * parameters in the I2S_InitStruct. + * @note This mode is not supported for STM32F030 devices. + * @param SPIx: where x can be 1 to select the SPI peripheral (configured in I2S mode). + * @param I2S_InitStruct: pointer to an I2S_InitTypeDef structure that + * contains the configuration information for the specified SPI peripheral + * configured in I2S mode. + * @note This function calculates the optimal prescaler needed to obtain the most + * accurate audio frequency (depending on the I2S clock source, the PLL values + * and the product configuration). But in case the prescaler value is greater + * than 511, the default value (0x02) will be configured instead. + * @retval None + */ +void I2S_Init(SPI_TypeDef* SPIx, I2S_InitTypeDef* I2S_InitStruct) +{ + uint16_t tmpreg = 0, i2sdiv = 2, i2sodd = 0, packetlength = 1; + uint32_t tmp = 0; + RCC_ClocksTypeDef RCC_Clocks; + uint32_t sourceclock = 0; + + /* Check the I2S parameters */ + assert_param(IS_SPI_1_PERIPH(SPIx)); + assert_param(IS_I2S_MODE(I2S_InitStruct->I2S_Mode)); + assert_param(IS_I2S_STANDARD(I2S_InitStruct->I2S_Standard)); + assert_param(IS_I2S_DATA_FORMAT(I2S_InitStruct->I2S_DataFormat)); + assert_param(IS_I2S_MCLK_OUTPUT(I2S_InitStruct->I2S_MCLKOutput)); + assert_param(IS_I2S_AUDIO_FREQ(I2S_InitStruct->I2S_AudioFreq)); + assert_param(IS_I2S_CPOL(I2S_InitStruct->I2S_CPOL)); + +/*----------------------- SPIx I2SCFGR & I2SPR Configuration -----------------*/ + /* Clear I2SMOD, I2SE, I2SCFG, PCMSYNC, I2SSTD, CKPOL, DATLEN and CHLEN bits */ + SPIx->I2SCFGR &= I2SCFGR_CLEAR_Mask; + SPIx->I2SPR = 0x0002; + + /* Get the I2SCFGR register value */ + tmpreg = SPIx->I2SCFGR; + + /* If the default value has to be written, reinitialize i2sdiv and i2sodd*/ + if(I2S_InitStruct->I2S_AudioFreq == I2S_AudioFreq_Default) + { + i2sodd = (uint16_t)0; + i2sdiv = (uint16_t)2; + } + /* If the requested audio frequency is not the default, compute the prescaler */ + else + { + /* Check the frame length (For the Prescaler computing) */ + if(I2S_InitStruct->I2S_DataFormat == I2S_DataFormat_16b) + { + /* Packet length is 16 bits */ + packetlength = 1; + } + else + { + /* Packet length is 32 bits */ + packetlength = 2; + } + + /* I2S Clock source is System clock: Get System Clock frequency */ + RCC_GetClocksFreq(&RCC_Clocks); + + /* Get the source clock value: based on System Clock value */ + sourceclock = RCC_Clocks.SYSCLK_Frequency; + + /* Compute the Real divider depending on the MCLK output state with a floating point */ + if(I2S_InitStruct->I2S_MCLKOutput == I2S_MCLKOutput_Enable) + { + /* MCLK output is enabled */ + tmp = (uint16_t)(((((sourceclock / 256) * 10) / I2S_InitStruct->I2S_AudioFreq)) + 5); + } + else + { + /* MCLK output is disabled */ + tmp = (uint16_t)(((((sourceclock / (32 * packetlength)) *10 ) / I2S_InitStruct->I2S_AudioFreq)) + 5); + } + + /* Remove the floating point */ + tmp = tmp / 10; + + /* Check the parity of the divider */ + i2sodd = (uint16_t)(tmp & (uint16_t)0x0001); + + /* Compute the i2sdiv prescaler */ + i2sdiv = (uint16_t)((tmp - i2sodd) / 2); + + /* Get the Mask for the Odd bit (SPI_I2SPR[8]) register */ + i2sodd = (uint16_t) (i2sodd << 8); + } + + /* Test if the divider is 1 or 0 or greater than 0xFF */ + if ((i2sdiv < 2) || (i2sdiv > 0xFF)) + { + /* Set the default values */ + i2sdiv = 2; + i2sodd = 0; + } + + /* Write to SPIx I2SPR register the computed value */ + SPIx->I2SPR = (uint16_t)(i2sdiv | (uint16_t)(i2sodd | (uint16_t)I2S_InitStruct->I2S_MCLKOutput)); + + /* Configure the I2S with the SPI_InitStruct values */ + tmpreg |= (uint16_t)(SPI_I2SCFGR_I2SMOD | (uint16_t)(I2S_InitStruct->I2S_Mode | \ + (uint16_t)(I2S_InitStruct->I2S_Standard | (uint16_t)(I2S_InitStruct->I2S_DataFormat | \ + (uint16_t)I2S_InitStruct->I2S_CPOL)))); + + /* Write to SPIx I2SCFGR */ + SPIx->I2SCFGR = tmpreg; +} + +/** + * @brief Enables or disables the specified SPI peripheral. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param NewState: new state of the SPIx peripheral. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void SPI_Cmd(SPI_TypeDef* SPIx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected SPI peripheral */ + SPIx->CR1 |= SPI_CR1_SPE; + } + else + { + /* Disable the selected SPI peripheral */ + SPIx->CR1 &= (uint16_t)~((uint16_t)SPI_CR1_SPE); + } +} + +/** + * @brief Enables or disables the TI Mode. + * + * @note This function can be called only after the SPI_Init() function has + * been called. + * @note When TI mode is selected, the control bits SSM, SSI, CPOL and CPHA + * are not taken into consideration and are configured by hardware + * respectively to the TI mode requirements. + * + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param NewState: new state of the selected SPI TI communication mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void SPI_TIModeCmd(SPI_TypeDef* SPIx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the TI mode for the selected SPI peripheral */ + SPIx->CR2 |= SPI_CR2_FRF; + } + else + { + /* Disable the TI mode for the selected SPI peripheral */ + SPIx->CR2 &= (uint16_t)~((uint16_t)SPI_CR2_FRF); + } +} + +/** + * @brief Enables or disables the specified SPI peripheral (in I2S mode). + * @note This mode is not supported for STM32F030 devices. + * @param SPIx: where x can be 1 to select the SPI peripheral. + * @param NewState: new state of the SPIx peripheral. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2S_Cmd(SPI_TypeDef* SPIx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_SPI_1_PERIPH(SPIx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + if (NewState != DISABLE) + { + /* Enable the selected SPI peripheral in I2S mode */ + SPIx->I2SCFGR |= SPI_I2SCFGR_I2SE; + } + else + { + /* Disable the selected SPI peripheral in I2S mode */ + SPIx->I2SCFGR &= (uint16_t)~((uint16_t)SPI_I2SCFGR_I2SE); + } +} + +/** + * @brief Configures the data size for the selected SPI. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param SPI_DataSize: specifies the SPI data size. + * For the SPIx peripheral this parameter can be one of the following values: + * @arg SPI_DataSize_4b: Set data size to 4 bits + * @arg SPI_DataSize_5b: Set data size to 5 bits + * @arg SPI_DataSize_6b: Set data size to 6 bits + * @arg SPI_DataSize_7b: Set data size to 7 bits + * @arg SPI_DataSize_8b: Set data size to 8 bits + * @arg SPI_DataSize_9b: Set data size to 9 bits + * @arg SPI_DataSize_10b: Set data size to 10 bits + * @arg SPI_DataSize_11b: Set data size to 11 bits + * @arg SPI_DataSize_12b: Set data size to 12 bits + * @arg SPI_DataSize_13b: Set data size to 13 bits + * @arg SPI_DataSize_14b: Set data size to 14 bits + * @arg SPI_DataSize_15b: Set data size to 15 bits + * @arg SPI_DataSize_16b: Set data size to 16 bits + * @retval None + */ +void SPI_DataSizeConfig(SPI_TypeDef* SPIx, uint16_t SPI_DataSize) +{ + uint16_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_SPI_DATA_SIZE(SPI_DataSize)); + /* Read the CR2 register */ + tmpreg = SPIx->CR2; + /* Clear DS[3:0] bits */ + tmpreg &= (uint16_t)~SPI_CR2_DS; + /* Set new DS[3:0] bits value */ + tmpreg |= SPI_DataSize; + SPIx->CR2 = tmpreg; +} + +/** + * @brief Configures the FIFO reception threshold for the selected SPI. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param SPI_RxFIFOThreshold: specifies the FIFO reception threshold. + * This parameter can be one of the following values: + * @arg SPI_RxFIFOThreshold_HF: RXNE event is generated if the FIFO + * level is greater or equal to 1/2. + * @arg SPI_RxFIFOThreshold_QF: RXNE event is generated if the FIFO + * level is greater or equal to 1/4. + * @retval None + */ +void SPI_RxFIFOThresholdConfig(SPI_TypeDef* SPIx, uint16_t SPI_RxFIFOThreshold) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_SPI_RX_FIFO_THRESHOLD(SPI_RxFIFOThreshold)); + + /* Clear FRXTH bit */ + SPIx->CR2 &= (uint16_t)~((uint16_t)SPI_CR2_FRXTH); + + /* Set new FRXTH bit value */ + SPIx->CR2 |= SPI_RxFIFOThreshold; +} + +/** + * @brief Selects the data transfer direction in bidirectional mode for the specified SPI. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param SPI_Direction: specifies the data transfer direction in bidirectional mode. + * This parameter can be one of the following values: + * @arg SPI_Direction_Tx: Selects Tx transmission direction + * @arg SPI_Direction_Rx: Selects Rx receive direction + * @retval None + */ +void SPI_BiDirectionalLineConfig(SPI_TypeDef* SPIx, uint16_t SPI_Direction) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_SPI_DIRECTION(SPI_Direction)); + if (SPI_Direction == SPI_Direction_Tx) + { + /* Set the Tx only mode */ + SPIx->CR1 |= SPI_Direction_Tx; + } + else + { + /* Set the Rx only mode */ + SPIx->CR1 &= SPI_Direction_Rx; + } +} + +/** + * @brief Configures internally by software the NSS pin for the selected SPI. + * @note This function can be called only after the SPI_Init() function has + * been called. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param SPI_NSSInternalSoft: specifies the SPI NSS internal state. + * This parameter can be one of the following values: + * @arg SPI_NSSInternalSoft_Set: Set NSS pin internally + * @arg SPI_NSSInternalSoft_Reset: Reset NSS pin internally + * @retval None + */ +void SPI_NSSInternalSoftwareConfig(SPI_TypeDef* SPIx, uint16_t SPI_NSSInternalSoft) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_SPI_NSS_INTERNAL(SPI_NSSInternalSoft)); + + if (SPI_NSSInternalSoft != SPI_NSSInternalSoft_Reset) + { + /* Set NSS pin internally by software */ + SPIx->CR1 |= SPI_NSSInternalSoft_Set; + } + else + { + /* Reset NSS pin internally by software */ + SPIx->CR1 &= SPI_NSSInternalSoft_Reset; + } +} + +/** + * @brief Enables or disables the SS output for the selected SPI. + * @note This function can be called only after the SPI_Init() function has + * been called and the NSS hardware management mode is selected. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param NewState: new state of the SPIx SS output. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void SPI_SSOutputCmd(SPI_TypeDef* SPIx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + if (NewState != DISABLE) + { + /* Enable the selected SPI SS output */ + SPIx->CR2 |= SPI_CR2_SSOE; + } + else + { + /* Disable the selected SPI SS output */ + SPIx->CR2 &= (uint16_t)~((uint16_t)SPI_CR2_SSOE); + } +} + +/** + * @brief Enables or disables the NSS pulse management mode. + * @note This function can be called only after the SPI_Init() function has + * been called. + * @note When TI mode is selected, the control bits NSSP is not taken into + * consideration and are configured by hardware respectively to the + * TI mode requirements. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param NewState: new state of the NSS pulse management mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void SPI_NSSPulseModeCmd(SPI_TypeDef* SPIx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the NSS pulse management mode */ + SPIx->CR2 |= SPI_CR2_NSSP; + } + else + { + /* Disable the NSS pulse management mode */ + SPIx->CR2 &= (uint16_t)~((uint16_t)SPI_CR2_NSSP); + } +} + +/** + * @} + */ + +/** @defgroup SPI_Group2 Data transfers functions + * @brief Data transfers functions + * +@verbatim + =============================================================================== + ##### Data transfers functions ##### + =============================================================================== + [..] This section provides a set of functions allowing to manage the SPI or I2S + data transfers. + + [..] In reception, data are received and then stored into an internal Rx buffer while + In transmission, data are first stored into an internal Tx buffer before being + transmitted. + + [..] The read access of the SPI_DR register can be done using + SPI_ReceiveData8() (when data size is equal or inferior than 8bits) and. + SPI_I2S_ReceiveData16() (when data size is superior than 8bits)function + and returns the Rx buffered value. Whereas a write access to the SPI_DR + can be done using SPI_SendData8() (when data size is equal or inferior than 8bits) + and SPI_I2S_SendData16() (when data size is superior than 8bits) function + and stores the written data into Tx buffer. + +@endverbatim + * @{ + */ + +/** + * @brief Transmits a Data through the SPIx/I2Sx peripheral. + * @param SPIx: where x can be 1 or 2 in SPI mode to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param Data: Data to be transmitted. + * @retval None + */ +void SPI_SendData8(SPI_TypeDef* SPIx, uint8_t Data) +{ + uint32_t spixbase = 0x00; + + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + + spixbase = (uint32_t)SPIx; + spixbase += 0x0C; + + *(__IO uint8_t *) spixbase = Data; +} + +/** + * @brief Transmits a Data through the SPIx/I2Sx peripheral. + * @param SPIx: where x can be 1 or 2 in SPI mode or 1 in I2S mode to select + * the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param Data: Data to be transmitted. + * @retval None + */ +void SPI_I2S_SendData16(SPI_TypeDef* SPIx, uint16_t Data) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + + SPIx->DR = (uint16_t)Data; +} + +/** + * @brief Returns the most recent received data by the SPIx/I2Sx peripheral. + * @param SPIx: where x can be 1 or 2 in SPI mode to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @retval The value of the received data. + */ +uint8_t SPI_ReceiveData8(SPI_TypeDef* SPIx) +{ + uint32_t spixbase = 0x00; + + spixbase = (uint32_t)SPIx; + spixbase += 0x0C; + + return *(__IO uint8_t *) spixbase; +} + +/** + * @brief Returns the most recent received data by the SPIx peripheral. + * @param SPIx: where x can be 1 or 2 in SPI mode or 1 in I2S mode to select + * @note SPI2 is not available for STM32F031 devices. + * the SPI peripheral. + * @retval The value of the received data. + */ +uint16_t SPI_I2S_ReceiveData16(SPI_TypeDef* SPIx) +{ + return SPIx->DR; +} +/** + * @} + */ + +/** @defgroup SPI_Group3 Hardware CRC Calculation functions + * @brief Hardware CRC Calculation functions + * +@verbatim + =============================================================================== + ##### Hardware CRC Calculation functions ##### + =============================================================================== + [..] This section provides a set of functions allowing to manage the SPI CRC hardware + calculation.SPI communication using CRC is possible through the following procedure: + + (#) Program the Data direction, Polarity, Phase, First Data, Baud Rate Prescaler, + Slave Management, Peripheral Mode and CRC Polynomial values using the SPI_Init() + function. + (#) Enable the CRC calculation using the SPI_CalculateCRC() function. + (#) Enable the SPI using the SPI_Cmd() function + (#) Before writing the last data to the TX buffer, set the CRCNext bit using the + SPI_TransmitCRC() function to indicate that after transmission of the last + data, the CRC should be transmitted. + (#) After transmitting the last data, the SPI transmits the CRC. The SPI_CR1_CRCNEXT + bit is reset. The CRC is also received and compared against the SPI_RXCRCR + value. + If the value does not match, the SPI_FLAG_CRCERR flag is set and an interrupt + can be generated when the SPI_I2S_IT_ERR interrupt is enabled. + + -@- + (+@) It is advised to don't read the calculate CRC values during the communication. + (+@) When the SPI is in slave mode, be careful to enable CRC calculation only + when the clock is stable, that is, when the clock is in the steady state. + If not, a wrong CRC calculation may be done. In fact, the CRC is sensitive + to the SCK slave input clock as soon as CRCEN is set, and this, whatever + the value of the SPE bit. + (+@) With high bitrate frequencies, be careful when transmitting the CRC. + As the number of used CPU cycles has to be as low as possible in the CRC + transfer phase, it is forbidden to call software functions in the CRC + transmission sequence to avoid errors in the last data and CRC reception. + In fact, CRCNEXT bit has to be written before the end of the transmission/reception + of the last data. + (+@) For high bit rate frequencies, it is advised to use the DMA mode to avoid the + degradation of the SPI speed performance due to CPU accesses impacting the + SPI bandwidth. + (+@) When the STM32F0xx are configured as slaves and the NSS hardware mode is + used, the NSS pin needs to be kept low between the data phase and the CRC + phase. + (+@) When the SPI is configured in slave mode with the CRC feature enabled, CRC + calculation takes place even if a high level is applied on the NSS pin. + This may happen for example in case of a multislave environment where the + communication master addresses slaves alternately. + (+@) Between a slave deselection (high level on NSS) and a new slave selection + (low level on NSS), the CRC value should be cleared on both master and slave + sides in order to resynchronize the master and slave for their respective + CRC calculation. + + -@- To clear the CRC, follow the procedure below: + (#@) Disable SPI using the SPI_Cmd() function + (#@) Disable the CRC calculation using the SPI_CalculateCRC() function. + (#@) Enable the CRC calculation using the SPI_CalculateCRC() function. + (#@) Enable SPI using the SPI_Cmd() function. + +@endverbatim + * @{ + */ + +/** + * @brief Configures the CRC calculation length for the selected SPI. + * @note This function can be called only after the SPI_Init() function has + * been called. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param SPI_CRCLength: specifies the SPI CRC calculation length. + * This parameter can be one of the following values: + * @arg SPI_CRCLength_8b: Set CRC Calculation to 8 bits + * @arg SPI_CRCLength_16b: Set CRC Calculation to 16 bits + * @retval None + */ +void SPI_CRCLengthConfig(SPI_TypeDef* SPIx, uint16_t SPI_CRCLength) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_SPI_CRC_LENGTH(SPI_CRCLength)); + + /* Clear CRCL bit */ + SPIx->CR1 &= (uint16_t)~((uint16_t)SPI_CR1_CRCL); + + /* Set new CRCL bit value */ + SPIx->CR1 |= SPI_CRCLength; +} + +/** + * @brief Enables or disables the CRC value calculation of the transferred bytes. + * @note This function can be called only after the SPI_Init() function has + * been called. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param NewState: new state of the SPIx CRC value calculation. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void SPI_CalculateCRC(SPI_TypeDef* SPIx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected SPI CRC calculation */ + SPIx->CR1 |= SPI_CR1_CRCEN; + } + else + { + /* Disable the selected SPI CRC calculation */ + SPIx->CR1 &= (uint16_t)~((uint16_t)SPI_CR1_CRCEN); + } +} + +/** + * @brief Transmit the SPIx CRC value. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @retval None + */ +void SPI_TransmitCRC(SPI_TypeDef* SPIx) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + + /* Enable the selected SPI CRC transmission */ + SPIx->CR1 |= SPI_CR1_CRCNEXT; +} + +/** + * @brief Returns the transmit or the receive CRC register value for the specified SPI. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param SPI_CRC: specifies the CRC register to be read. + * This parameter can be one of the following values: + * @arg SPI_CRC_Tx: Selects Tx CRC register + * @arg SPI_CRC_Rx: Selects Rx CRC register + * @retval The selected CRC register value.. + */ +uint16_t SPI_GetCRC(SPI_TypeDef* SPIx, uint8_t SPI_CRC) +{ + uint16_t crcreg = 0; + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_SPI_CRC(SPI_CRC)); + + if (SPI_CRC != SPI_CRC_Rx) + { + /* Get the Tx CRC register */ + crcreg = SPIx->TXCRCR; + } + else + { + /* Get the Rx CRC register */ + crcreg = SPIx->RXCRCR; + } + /* Return the selected CRC register */ + return crcreg; +} + +/** + * @brief Returns the CRC Polynomial register value for the specified SPI. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @retval The CRC Polynomial register value. + */ +uint16_t SPI_GetCRCPolynomial(SPI_TypeDef* SPIx) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + + /* Return the CRC polynomial register */ + return SPIx->CRCPR; +} + +/** + * @} + */ + +/** @defgroup SPI_Group4 DMA transfers management functions + * @brief DMA transfers management functions + * +@verbatim + =============================================================================== + ##### DMA transfers management functions ##### + =============================================================================== + [..] This section provides two functions that can be used only in DMA mode. + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the SPIx/I2Sx DMA interface. + * @param SPIx: where x can be 1 or 2 in SPI mode or 1 in I2S mode to select + * the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * I2S mode is not supported for STM32F030 devices. + * @param SPI_I2S_DMAReq: specifies the SPI DMA transfer request to be enabled or disabled. + * This parameter can be any combination of the following values: + * @arg SPI_I2S_DMAReq_Tx: Tx buffer DMA transfer request + * @arg SPI_I2S_DMAReq_Rx: Rx buffer DMA transfer request + * @param NewState: new state of the selected SPI DMA transfer request. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void SPI_I2S_DMACmd(SPI_TypeDef* SPIx, uint16_t SPI_I2S_DMAReq, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + assert_param(IS_SPI_I2S_DMA_REQ(SPI_I2S_DMAReq)); + + if (NewState != DISABLE) + { + /* Enable the selected SPI DMA requests */ + SPIx->CR2 |= SPI_I2S_DMAReq; + } + else + { + /* Disable the selected SPI DMA requests */ + SPIx->CR2 &= (uint16_t)~SPI_I2S_DMAReq; + } +} + +/** + * @brief Configures the number of data to transfer type(Even/Odd) for the DMA + * last transfers and for the selected SPI. + * @note This function have a meaning only if DMA mode is selected and if + * the packing mode is used (data length <= 8 and DMA transfer size halfword) + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param SPI_LastDMATransfer: specifies the SPI last DMA transfers state. + * This parameter can be one of the following values: + * @arg SPI_LastDMATransfer_TxEvenRxEven: Number of data for transmission Even + * and number of data for reception Even. + * @arg SPI_LastDMATransfer_TxOddRxEven: Number of data for transmission Odd + * and number of data for reception Even. + * @arg SPI_LastDMATransfer_TxEvenRxOdd: Number of data for transmission Even + * and number of data for reception Odd. + * @arg SPI_LastDMATransfer_TxOddRxOdd: Number of data for transmission Odd + * and number of data for reception Odd. + * @retval None + */ +void SPI_LastDMATransferCmd(SPI_TypeDef* SPIx, uint16_t SPI_LastDMATransfer) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_SPI_LAST_DMA_TRANSFER(SPI_LastDMATransfer)); + + /* Clear LDMA_TX and LDMA_RX bits */ + SPIx->CR2 &= CR2_LDMA_MASK; + + /* Set new LDMA_TX and LDMA_RX bits value */ + SPIx->CR2 |= SPI_LastDMATransfer; +} + +/** + * @} + */ + +/** @defgroup SPI_Group5 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== + [..] This section provides a set of functions allowing to configure the SPI/I2S Interrupts + sources and check or clear the flags or pending bits status. + The user should identify which mode will be used in his application to manage + the communication: Polling mode, Interrupt mode or DMA mode. + + *** Polling Mode *** + ==================== + [..] In Polling Mode, the SPI/I2S communication can be managed by 9 flags: + (#) SPI_I2S_FLAG_TXE : to indicate the status of the transmit buffer register + (#) SPI_I2S_FLAG_RXNE : to indicate the status of the receive buffer register + (#) SPI_I2S_FLAG_BSY : to indicate the state of the communication layer of the SPI. + (#) SPI_FLAG_CRCERR : to indicate if a CRC Calculation error occur + (#) SPI_FLAG_MODF : to indicate if a Mode Fault error occur + (#) SPI_I2S_FLAG_OVR : to indicate if an Overrun error occur + (#) SPI_I2S_FLAG_FRE: to indicate a Frame Format error occurs. + (#) I2S_FLAG_UDR: to indicate an Underrun error occurs. + (#) I2S_FLAG_CHSIDE: to indicate Channel Side. + + [..] + (@)Do not use the BSY flag to handle each data transmission or reception. It is better + to use the TXE and RXNE flags instead. + + [..] In this Mode it is advised to use the following functions: + (+) FlagStatus SPI_I2S_GetFlagStatus(SPI_TypeDef* SPIx, uint16_t SPI_I2S_FLAG); + (+) void SPI_I2S_ClearFlag(SPI_TypeDef* SPIx, uint16_t SPI_I2S_FLAG); + + *** Interrupt Mode *** + ====================== + [..] In Interrupt Mode, the SPI/I2S communication can be managed by 3 interrupt sources + and 5 pending bits: + [..] Pending Bits: + (#) SPI_I2S_IT_TXE : to indicate the status of the transmit buffer register + (#) SPI_I2S_IT_RXNE : to indicate the status of the receive buffer register + (#) SPI_I2S_IT_OVR : to indicate if an Overrun error occur + (#) I2S_IT_UDR : to indicate an Underrun Error occurs. + (#) SPI_I2S_FLAG_FRE : to indicate a Frame Format error occurs. + + [..] Interrupt Source: + (#) SPI_I2S_IT_TXE: specifies the interrupt source for the Tx buffer empty + interrupt. + (#) SPI_I2S_IT_RXNE : specifies the interrupt source for the Rx buffer not + empty interrupt. + (#) SPI_I2S_IT_ERR : specifies the interrupt source for the errors interrupt. + + [..] In this Mode it is advised to use the following functions: + (+) void SPI_I2S_ITConfig(SPI_TypeDef* SPIx, uint8_t SPI_I2S_IT, FunctionalState NewState); + (+) ITStatus SPI_I2S_GetITStatus(SPI_TypeDef* SPIx, uint8_t SPI_I2S_IT); + + *** FIFO Status *** + =================== + [..] It is possible to monitor the FIFO status when a transfer is ongoing using the + following function: + (+) uint32_t SPI_GetFIFOStatus(uint8_t SPI_FIFO_Direction); + + *** DMA Mode *** + ================ + [..] In DMA Mode, the SPI communication can be managed by 2 DMA Channel + requests: + (#) SPI_I2S_DMAReq_Tx: specifies the Tx buffer DMA transfer request. + (#) SPI_I2S_DMAReq_Rx: specifies the Rx buffer DMA transfer request. + + [..] In this Mode it is advised to use the following function: + (+) void SPI_I2S_DMACmd(SPI_TypeDef* SPIx, uint16_t SPI_I2S_DMAReq, FunctionalState NewState). + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified SPI/I2S interrupts. + * @param SPIx: where x can be 1 or 2 in SPI mode or 1 in I2S mode to select + * the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * I2S mode is not supported for STM32F030 devices. + * @param SPI_I2S_IT: specifies the SPI interrupt source to be enabled or disabled. + * This parameter can be one of the following values: + * @arg SPI_I2S_IT_TXE: Tx buffer empty interrupt mask + * @arg SPI_I2S_IT_RXNE: Rx buffer not empty interrupt mask + * @arg SPI_I2S_IT_ERR: Error interrupt mask + * @param NewState: new state of the specified SPI interrupt. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void SPI_I2S_ITConfig(SPI_TypeDef* SPIx, uint8_t SPI_I2S_IT, FunctionalState NewState) +{ + uint16_t itpos = 0, itmask = 0 ; + + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + assert_param(IS_SPI_I2S_CONFIG_IT(SPI_I2S_IT)); + + /* Get the SPI IT index */ + itpos = SPI_I2S_IT >> 4; + + /* Set the IT mask */ + itmask = (uint16_t)1 << (uint16_t)itpos; + + if (NewState != DISABLE) + { + /* Enable the selected SPI interrupt */ + SPIx->CR2 |= itmask; + } + else + { + /* Disable the selected SPI interrupt */ + SPIx->CR2 &= (uint16_t)~itmask; + } +} + +/** + * @brief Returns the current SPIx Transmission FIFO filled level. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @retval The Transmission FIFO filling state. + * - SPI_TransmissionFIFOStatus_Empty: when FIFO is empty + * - SPI_TransmissionFIFOStatus_1QuarterFull: if more than 1 quarter-full. + * - SPI_TransmissionFIFOStatus_HalfFull: if more than 1 half-full. + * - SPI_TransmissionFIFOStatus_Full: when FIFO is full. + */ +uint16_t SPI_GetTransmissionFIFOStatus(SPI_TypeDef* SPIx) +{ + /* Get the SPIx Transmission FIFO level bits */ + return (uint16_t)((SPIx->SR & SPI_SR_FTLVL)); +} + +/** + * @brief Returns the current SPIx Reception FIFO filled level. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @retval The Reception FIFO filling state. + * - SPI_ReceptionFIFOStatus_Empty: when FIFO is empty + * - SPI_ReceptionFIFOStatus_1QuarterFull: if more than 1 quarter-full. + * - SPI_ReceptionFIFOStatus_HalfFull: if more than 1 half-full. + * - SPI_ReceptionFIFOStatus_Full: when FIFO is full. + */ +uint16_t SPI_GetReceptionFIFOStatus(SPI_TypeDef* SPIx) +{ + /* Get the SPIx Reception FIFO level bits */ + return (uint16_t)((SPIx->SR & SPI_SR_FRLVL)); +} + +/** + * @brief Checks whether the specified SPI flag is set or not. + * @param SPIx: where x can be 1 or 2 in SPI mode or 1 in I2S mode to select + * the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * I2S mode is not supported for STM32F030 devices. + * @param SPI_I2S_FLAG: specifies the SPI flag to check. + * This parameter can be one of the following values: + * @arg SPI_I2S_FLAG_TXE: Transmit buffer empty flag. + * @arg SPI_I2S_FLAG_RXNE: Receive buffer not empty flag. + * @arg SPI_I2S_FLAG_BSY: Busy flag. + * @arg SPI_I2S_FLAG_OVR: Overrun flag. + * @arg SPI_FLAG_MODF: Mode Fault flag. + * @arg SPI_FLAG_CRCERR: CRC Error flag. + * @arg SPI_I2S_FLAG_FRE: TI frame format error flag. + * @arg I2S_FLAG_UDR: Underrun Error flag. + * @arg I2S_FLAG_CHSIDE: Channel Side flag. + * @retval The new state of SPI_I2S_FLAG (SET or RESET). + */ +FlagStatus SPI_I2S_GetFlagStatus(SPI_TypeDef* SPIx, uint16_t SPI_I2S_FLAG) +{ + FlagStatus bitstatus = RESET; + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_SPI_I2S_GET_FLAG(SPI_I2S_FLAG)); + + /* Check the status of the specified SPI flag */ + if ((SPIx->SR & SPI_I2S_FLAG) != (uint16_t)RESET) + { + /* SPI_I2S_FLAG is set */ + bitstatus = SET; + } + else + { + /* SPI_I2S_FLAG is reset */ + bitstatus = RESET; + } + /* Return the SPI_I2S_FLAG status */ + return bitstatus; +} + +/** + * @brief Clears the SPIx CRC Error (CRCERR) flag. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * I2S mode is not supported for STM32F030 devices. + * @param SPI_I2S_FLAG: specifies the SPI flag to clear. + * This function clears only CRCERR flag. + * @note OVR (OverRun error) flag is cleared by software sequence: a read + * operation to SPI_DR register (SPI_I2S_ReceiveData()) followed by + * a read operation to SPI_SR register (SPI_I2S_GetFlagStatus()). + * @note MODF (Mode Fault) flag is cleared by software sequence: a read/write + * operation to SPI_SR register (SPI_I2S_GetFlagStatus()) followed by + * a write operation to SPI_CR1 register (SPI_Cmd() to enable the SPI). + * @retval None + */ +void SPI_I2S_ClearFlag(SPI_TypeDef* SPIx, uint16_t SPI_I2S_FLAG) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_SPI_CLEAR_FLAG(SPI_I2S_FLAG)); + + /* Clear the selected SPI CRC Error (CRCERR) flag */ + SPIx->SR = (uint16_t)~SPI_I2S_FLAG; +} + +/** + * @brief Checks whether the specified SPI/I2S interrupt has occurred or not. + * @param SPIx: where x can be 1 or 2 in SPI mode or 1 in I2S mode to select + * the SPI peripheral. + * @param SPI_I2S_IT: specifies the SPI interrupt source to check. + * This parameter can be one of the following values: + * @arg SPI_I2S_IT_TXE: Transmit buffer empty interrupt. + * @arg SPI_I2S_IT_RXNE: Receive buffer not empty interrupt. + * @arg SPI_IT_MODF: Mode Fault interrupt. + * @arg SPI_I2S_IT_OVR: Overrun interrupt. + * @arg I2S_IT_UDR: Underrun interrupt. + * @arg SPI_I2S_IT_FRE: Format Error interrupt. + * @retval The new state of SPI_I2S_IT (SET or RESET). + */ +ITStatus SPI_I2S_GetITStatus(SPI_TypeDef* SPIx, uint8_t SPI_I2S_IT) +{ + ITStatus bitstatus = RESET; + uint16_t itpos = 0, itmask = 0, enablestatus = 0; + + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_SPI_I2S_GET_IT(SPI_I2S_IT)); + + /* Get the SPI_I2S_IT index */ + itpos = 0x01 << (SPI_I2S_IT & 0x0F); + + /* Get the SPI_I2S_IT IT mask */ + itmask = SPI_I2S_IT >> 4; + + /* Set the IT mask */ + itmask = 0x01 << itmask; + + /* Get the SPI_I2S_IT enable bit status */ + enablestatus = (SPIx->CR2 & itmask) ; + + /* Check the status of the specified SPI interrupt */ + if (((SPIx->SR & itpos) != (uint16_t)RESET) && enablestatus) + { + /* SPI_I2S_IT is set */ + bitstatus = SET; + } + else + { + /* SPI_I2S_IT is reset */ + bitstatus = RESET; + } + /* Return the SPI_I2S_IT status */ + return bitstatus; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_syscfg.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_syscfg.c new file mode 100644 index 00000000..64a5cf32 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_syscfg.c @@ -0,0 +1,420 @@ +/** + ****************************************************************************** + * @file stm32f0xx_syscfg.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the SYSCFG peripheral: + * + Remapping the memory mapped at 0x00000000 + * + Remapping the DMA channels + * + Enabling I2C fast mode plus driving capability for I2C pins + * + Configuring the EXTI lines connection to the GPIO port + * + Configuring the CFGR2 features (Connecting some internal signal + * to the break input of TIM1) + * + * @verbatim + =============================================================================== + ##### How to use this driver ##### + =============================================================================== + [..] + The SYSCFG registers can be accessed only when the SYSCFG + interface APB clock is enabled. + To enable SYSCFG APB clock use: + RCC_APBPeriphClockCmd(RCC_APBPeriph_SYSCFG, ENABLE). + * @endverbatim + * + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_syscfg.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup SYSCFG + * @brief SYSCFG driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup SYSCFG_Private_Functions + * @{ + */ + +/** @defgroup SYSCFG_Group1 SYSCFG Initialization and Configuration functions + * @brief SYSCFG Initialization and Configuration functions + * +@verbatim + =============================================================================== + ##### SYSCFG Initialization and Configuration functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the SYSCFG registers to their default reset values. + * @param None + * @retval None + * @note MEM_MODE bits are not affected by APB reset. + * @note MEM_MODE bits took the value from the user option bytes. + * @note CFGR2 register is not affected by APB reset. + * @note CLABBB configuration bits are locked when set. + * @note To unlock the configuration, perform a system reset. + */ +void SYSCFG_DeInit(void) +{ + /* Set SYSCFG_CFGR1 register to reset value without affecting MEM_MODE bits */ + SYSCFG->CFGR1 &= SYSCFG_CFGR1_MEM_MODE; + /* Set EXTICRx registers to reset value */ + SYSCFG->EXTICR[0] = 0; + SYSCFG->EXTICR[1] = 0; + SYSCFG->EXTICR[2] = 0; + SYSCFG->EXTICR[3] = 0; + /* Set CFGR2 register to reset value: clear SRAM parity error flag */ + SYSCFG->CFGR2 |= (uint32_t) SYSCFG_CFGR2_SRAM_PE; +} + +/** + * @brief Configures the memory mapping at address 0x00000000. + * @param SYSCFG_MemoryRemap: selects the memory remapping. + * This parameter can be one of the following values: + * @arg SYSCFG_MemoryRemap_Flash: Main Flash memory mapped at 0x00000000 + * @arg SYSCFG_MemoryRemap_SystemMemory: System Flash memory mapped at 0x00000000 + * @arg SYSCFG_MemoryRemap_SRAM: Embedded SRAM mapped at 0x00000000 + * @retval None + */ +void SYSCFG_MemoryRemapConfig(uint32_t SYSCFG_MemoryRemap) +{ + uint32_t tmpctrl = 0; + + /* Check the parameter */ + assert_param(IS_SYSCFG_MEMORY_REMAP(SYSCFG_MemoryRemap)); + + /* Get CFGR1 register value */ + tmpctrl = SYSCFG->CFGR1; + + /* Clear MEM_MODE bits */ + tmpctrl &= (uint32_t) (~SYSCFG_CFGR1_MEM_MODE); + + /* Set the new MEM_MODE bits value */ + tmpctrl |= (uint32_t) SYSCFG_MemoryRemap; + + /* Set CFGR1 register with the new memory remap configuration */ + SYSCFG->CFGR1 = tmpctrl; +} + +/** + * @brief Configure the DMA channels remapping. + * @param SYSCFG_DMARemap: selects the DMA channels remap. + * This parameter can be one of the following values: + * @arg SYSCFG_DMARemap_TIM17: Remap TIM17 DMA requests from channel1 to channel2 + * @arg SYSCFG_DMARemap_TIM16: Remap TIM16 DMA requests from channel3 to channel4 + * @arg SYSCFG_DMARemap_USART1Rx: Remap USART1 Rx DMA requests from channel3 to channel5 + * @arg SYSCFG_DMARemap_USART1Tx: Remap USART1 Tx DMA requests from channel2 to channel4 + * @arg SYSCFG_DMARemap_ADC1: Remap ADC1 DMA requests from channel1 to channel2 + * @param NewState: new state of the DMA channel remapping. + * This parameter can be: ENABLE or DISABLE. + * @note When enabled, DMA channel of the selected peripheral is remapped + * @note When disabled, Default DMA channel is mapped to the selected peripheral + * @note By default TIM17 DMA requests is mapped to channel 1, + * use SYSCFG_DMAChannelRemapConfig(SYSCFG_DMARemap_TIM17, Enable) to remap + * TIM17 DMA requests to channel 2 and use + * SYSCFG_DMAChannelRemapConfig(SYSCFG_DMARemap_TIM17, Disable) to map + * TIM17 DMA requests to channel 1 (default mapping) + * @note This function is only used for STM32F030, STM32F031, STM32F042, STM32F072 and STM32F051 devices. + * @retval None + */ +void SYSCFG_DMAChannelRemapConfig(uint32_t SYSCFG_DMARemap, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_SYSCFG_DMA_REMAP(SYSCFG_DMARemap)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Remap the DMA channel */ + SYSCFG->CFGR1 |= (uint32_t)SYSCFG_DMARemap; + } + else + { + /* use the default DMA channel mapping */ + SYSCFG->CFGR1 &= (uint32_t)(~SYSCFG_DMARemap); + } +} + +/** + * @brief Configure the I2C fast mode plus driving capability. + * @param SYSCFG_I2CFastModePlus: selects the pin. + * This parameter can be one of the following values: + * @arg SYSCFG_I2CFastModePlus_PB6: Configure fast mode plus driving capability for PB6 + * @arg SYSCFG_I2CFastModePlus_PB7: Configure fast mode plus driving capability for PB7 + * @arg SYSCFG_I2CFastModePlus_PB8: Configure fast mode plus driving capability for PB8 + * @arg SYSCFG_I2CFastModePlus_PB9: Configure fast mode plus driving capability for PB9 + * @arg SYSCFG_I2CFastModePlus_PA9: Configure fast mode plus driving capability for PA9 (only for STM32F031 and STM32F030 devices) + * @arg SYSCFG_I2CFastModePlus_PA10: Configure fast mode plus driving capability for PA10 (only for STM32F031 and STM32F030 devices) + * @arg SYSCFG_I2CFastModePlus_I2C1: Configure fast mode plus driving capability for PB10, PB11, PF6 and PF7(only for STM32F031 and STM32F030 devices) + * @arg SYSCFG_I2CFastModePlus_I2C2: Configure fast mode plus driving capability for I2C2 pins, available only for STM32F072 devices + * + * @param NewState: new state of the DMA channel remapping. + * This parameter can be: ENABLE or DISABLE. + * @note ENABLE: Enable fast mode plus driving capability for selected I2C pin + * @note DISABLE: Disable fast mode plus driving capability for selected I2C pin + * @note For I2C1, fast mode plus driving capability can be enabled on all selected + * I2C1 pins using SYSCFG_I2CFastModePlus_I2C1 parameter or independently + * on each one of the following pins PB6, PB7, PB8 and PB9. + * @note For remaining I2C1 pins (PA14, PA15...) fast mode plus driving capability + * can be enabled only by using SYSCFG_I2CFastModePlus_I2C1 parameter. + * @note For all I2C2 pins fast mode plus driving capability can be enabled + * only by using SYSCFG_I2CFastModePlus_I2C2 parameter. + * @retval None + */ +void SYSCFG_I2CFastModePlusConfig(uint32_t SYSCFG_I2CFastModePlus, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_SYSCFG_I2C_FMP(SYSCFG_I2CFastModePlus)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable fast mode plus driving capability for selected pin */ + SYSCFG->CFGR1 |= (uint32_t)SYSCFG_I2CFastModePlus; + } + else + { + /* Disable fast mode plus driving capability for selected pin */ + SYSCFG->CFGR1 &= (uint32_t)(~SYSCFG_I2CFastModePlus); + } +} + +/** @brief select the modulation envelope source + * @param SYSCFG_IRDAEnv: select the envelope source. + * This parameter can be a value + * @arg SYSCFG_IRDA_ENV_SEL_TIM16 + * @arg SYSCFG_IRDA_ENV_SEL_USART1 + * @arg SYSCFG_IRDA_ENV_SEL_USART4 + * @retval None + */ +void SYSCFG_IRDAEnvSelection(uint32_t SYSCFG_IRDAEnv) +{ + /* Check the parameters */ + assert_param(IS_SYSCFG_IRDA_ENV(SYSCFG_IRDAEnv)); + + SYSCFG->CFGR1 &= ~(SYSCFG_CFGR1_IRDA_ENV_SEL); + SYSCFG->CFGR1 |= (SYSCFG_IRDAEnv); +} + +/** + * @brief Selects the GPIO pin used as EXTI Line. + * @param EXTI_PortSourceGPIOx: selects the GPIO port to be used as source + * for EXTI lines where x can be (A, B, C, D, E or F). + * @note GPIOE is available only for STM32F072. + * @note GPIOD is not available for STM32F031. + * @param EXTI_PinSourcex: specifies the EXTI line to be configured. + * @note This parameter can be EXTI_PinSourcex where x can be: + * For STM32F051 and STM32F030: (0..15) for GPIOA, GPIOB, GPIOC, (2) for GPIOD and (0..1, 4..7) for GIIOF. + * For STM32F072: (0..15) for GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, (0..10) for GPIOF. + * For STM32F031: (0..15) for GPIOA, GPIOB, (13..15) for GPIOC and (0..1, 6..7) for GPIOF. + * @retval None + */ +void SYSCFG_EXTILineConfig(uint8_t EXTI_PortSourceGPIOx, uint8_t EXTI_PinSourcex) +{ + uint32_t tmp = 0x00; + + /* Check the parameters */ + assert_param(IS_EXTI_PORT_SOURCE(EXTI_PortSourceGPIOx)); + assert_param(IS_EXTI_PIN_SOURCE(EXTI_PinSourcex)); + + tmp = ((uint32_t)0x0F) << (0x04 * (EXTI_PinSourcex & (uint8_t)0x03)); + SYSCFG->EXTICR[EXTI_PinSourcex >> 0x02] &= ~tmp; + SYSCFG->EXTICR[EXTI_PinSourcex >> 0x02] |= (((uint32_t)EXTI_PortSourceGPIOx) << (0x04 * (EXTI_PinSourcex & (uint8_t)0x03))); +} + +/** + * @brief check ISR wrapper: Allow to determine interrupt source per line . + * @param IT_Source: specifies the interrupt source to check. + * This parameter can be one of the following values: + * @arg ITLINE_EWDG EWDG has expired + * @arg ITLINE_PVDOUT Power voltage detection Interrupt + * @arg ITLINE_VDDIO2 VDDIO2 Interrupt + * @arg ITLINE_RTC_WAKEUP RTC WAKEUP -> exti[20] Interrupt + * @arg ITLINE_RTC_TSTAMP RTC Time Stamp -> exti[19] interrupt + * @arg ITLINE_RTC_ALRA RTC Alarm -> exti[17] interrupt + * @arg ITLINE_FLASH_ITF Flash ITF Interrupt + * @arg ITLINE_CRS CRS Interrupt + * @arg ITLINE_CLK_CTRL CLK Control Interrupt + * @arg ITLINE_EXTI0 External Interrupt 0 + * @arg ITLINE_EXTI1 External Interrupt 1 + * @arg ITLINE_EXTI2 External Interrupt 2 + * @arg ITLINE_EXTI3 External Interrupt 3 + * @arg ITLINE_EXTI4 External Interrupt 4 + * @arg ITLINE_EXTI5 External Interrupt 5 + * @arg ITLINE_EXTI6 External Interrupt 6 + * @arg ITLINE_EXTI7 External Interrupt 7 + * @arg ITLINE_EXTI8 External Interrupt 8 + * @arg ITLINE_EXTI9 External Interrupt 9 + * @arg ITLINE_EXTI10 External Interrupt 10 + * @arg ITLINE_EXTI11 External Interrupt 11 + * @arg ITLINE_EXTI12 External Interrupt 12 + * @arg ITLINE_EXTI13 External Interrupt 13 + * @arg ITLINE_EXTI14 External Interrupt 14 + * @arg ITLINE_EXTI15 External Interrupt 15 + * @arg ITLINE_TSC_EOA Touch control EOA Interrupt + * @arg ITLINE_TSC_MCE Touch control MCE Interrupt + * @arg ITLINE_DMA1_CH1 DMA1 Channel 1 Interrupt + * @arg ITLINE_DMA1_CH2 DMA1 Channel 2 Interrupt + * @arg ITLINE_DMA1_CH3 DMA1 Channel 3 Interrupt + * @arg ITLINE_DMA2_CH1 DMA2 Channel 1 Interrupt + * @arg ITLINE_DMA2_CH2 DMA2 Channel 2 Interrupt + * @arg ITLINE_DMA1_CH4 DMA1 Channel 4 Interrupt + * @arg ITLINE_DMA1_CH5 DMA1 Channel 5 Interrupt + * @arg ITLINE_DMA1_CH6 DMA1 Channel 6 Interrupt + * @arg ITLINE_DMA1_CH7 DMA1 Channel 7 Interrupt + * @arg ITLINE_DMA2_CH3 DMA2 Channel 3 Interrupt + * @arg ITLINE_DMA2_CH4 DMA2 Channel 4 Interrupt + * @arg ITLINE_DMA2_CH5 DMA2 Channel 5 Interrupt + * @arg ITLINE_ADC ADC Interrupt + * @arg ITLINE_COMP1 COMP1 Interrupt -> exti[21] + * @arg ITLINE_COMP2 COMP2 Interrupt -> exti[21] + * @arg ITLINE_TIM1_BRK TIM1 BRK Interrupt + * @arg ITLINE_TIM1_UPD TIM1 UPD Interrupt + * @arg ITLINE_TIM1_TRG TIM1 TRG Interrupt + * @arg ITLINE_TIM1_CCU TIM1 CCU Interrupt + * @arg ITLINE_TIM1_CC TIM1 CC Interrupt + * @arg ITLINE_TIM2 TIM2 Interrupt + * @arg ITLINE_TIM3 TIM3 Interrupt + * @arg ITLINE_DAC DAC Interrupt + * @arg ITLINE_TIM6 TIM6 Interrupt + * @arg ITLINE_TIM7 TIM7 Interrupt + * @arg ITLINE_TIM14 TIM14 Interrupt + * @arg ITLINE_TIM15 TIM15 Interrupt + * @arg ITLINE_TIM16 TIM16 Interrupt + * @arg ITLINE_TIM17 TIM17 Interrupt + * @arg ITLINE_I2C1 I2C1 Interrupt -> exti[23] + * @arg ITLINE_I2C2 I2C2 Interrupt + * @arg ITLINE_SPI1 I2C1 Interrupt -> exti[23] + * @arg ITLINE_SPI2 SPI1 Interrupt + * @arg ITLINE_USART1 USART1 GLB Interrupt -> exti[25] + * @arg ITLINE_USART2 USART2 GLB Interrupt -> exti[26] + * @arg ITLINE_USART3 USART3 Interrupt + * @arg ITLINE_USART4 USART4 Interrupt + * @arg ITLINE_USART5 USART5 Interrupt + * @arg ITLINE_USART6 USART6 Interrupt + * @arg ITLINE_USART7 USART7 Interrupt + * @arg ITLINE_USART8 USART8 Interrupt + * @arg ITLINE_CAN CAN Interrupt + * @arg ITLINE_CEC CEC Interrupt + * @retval The new state of IT_LINE_SR. + */ +uint32_t SYSCFG_GetPendingIT(uint32_t ITSourceLine) +{ + assert_param(IS_SYSCFG_ITLINE(ITSourceLine)); + return(SYSCFG->IT_LINE_SR[(ITSourceLine >> 0x18)] & (ITSourceLine & 0x00FFFFFF)); +} + +/** + * @brief Connect the selected parameter to the break input of TIM1. + * @note The selected configuration is locked and can be unlocked by system reset + * @param SYSCFG_Break: selects the configuration to be connected to break + * input of TIM1 + * This parameter can be any combination of the following values: + * @arg SYSCFG_Break_PVD: Connects the PVD event to the Break Input of TIM1,, not available for STM32F030 devices. + * @arg SYSCFG_Break_SRAMParity: Connects the SRAM_PARITY error signal to the Break Input of TIM1 . + * @arg SYSCFG_Break_Lockup: Connects Lockup output of CortexM0 to the break input of TIM1. + * @retval None + */ +void SYSCFG_BreakConfig(uint32_t SYSCFG_Break) +{ + /* Check the parameter */ + assert_param(IS_SYSCFG_LOCK_CONFIG(SYSCFG_Break)); + + SYSCFG->CFGR2 |= (uint32_t) SYSCFG_Break; +} + +/** + * @brief Checks whether the specified SYSCFG flag is set or not. + * @param SYSCFG_Flag: specifies the SYSCFG flag to check. + * This parameter can be one of the following values: + * @arg SYSCFG_FLAG_PE: SRAM parity error flag. + * @retval The new state of SYSCFG_Flag (SET or RESET). + */ +FlagStatus SYSCFG_GetFlagStatus(uint32_t SYSCFG_Flag) +{ + FlagStatus bitstatus = RESET; + + /* Check the parameter */ + assert_param(IS_SYSCFG_FLAG(SYSCFG_Flag)); + + /* Check the status of the specified SPI flag */ + if ((SYSCFG->CFGR2 & SYSCFG_CFGR2_SRAM_PE) != (uint32_t)RESET) + { + /* SYSCFG_Flag is set */ + bitstatus = SET; + } + else + { + /* SYSCFG_Flag is reset */ + bitstatus = RESET; + } + /* Return the SYSCFG_Flag status */ + return bitstatus; +} + +/** + * @brief Clear the selected SYSCFG flag. + * @param SYSCFG_Flag: selects the flag to be cleared. + * This parameter can be any combination of the following values: + * @arg SYSCFG_FLAG_PE: SRAM parity error flag. + * @retval None + */ +void SYSCFG_ClearFlag(uint32_t SYSCFG_Flag) +{ + /* Check the parameter */ + assert_param(IS_SYSCFG_FLAG(SYSCFG_Flag)); + + SYSCFG->CFGR2 |= (uint32_t) SYSCFG_Flag; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_tim.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_tim.c new file mode 100644 index 00000000..2f1d00ce --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_tim.c @@ -0,0 +1,3349 @@ +/** + ****************************************************************************** + * @file stm32f0xx_tim.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the TIM peripheral: + * + TimeBase management + * + Output Compare management + * + Input Capture management + * + Interrupts, DMA and flags management + * + Clocks management + * + Synchronization management + * + Specific interface management + * + Specific remapping management + * + * @verbatim + + =============================================================================== + ##### How to use this driver ##### + =============================================================================== + [..] This driver provides functions to configure and program the TIM + of all STM32F0xx devices These functions are split in 8 groups: + (#) TIM TimeBase management: this group includes all needed functions + to configure the TM Timebase unit: + (++) Set/Get Prescaler. + (++) Set/Get Autoreload. + (++) Counter modes configuration. + (++) Set Clock division. + (++) Select the One Pulse mode. + (++) Update Request Configuration. + (++) Update Disable Configuration. + (++) Auto-Preload Configuration. + (++) Enable/Disable the counter. + + (#) TIM Output Compare management: this group includes all needed + functions to configure the Capture/Compare unit used in Output + compare mode: + (++) Configure each channel, independently, in Output Compare mode. + (++) Select the output compare modes. + (++) Select the Polarities of each channel. + (++) Set/Get the Capture/Compare register values. + (++) Select the Output Compare Fast mode. + (++) Select the Output Compare Forced mode. + (++) Output Compare-Preload Configuration. + (++) Clear Output Compare Reference. + (++) Select the OCREF Clear signal. + (++) Enable/Disable the Capture/Compare Channels. + + (#) TIM Input Capture management: this group includes all needed + functions to configure the Capture/Compare unit used in + Input Capture mode: + (++) Configure each channel in input capture mode. + (++) Configure Channel1/2 in PWM Input mode. + (++) Set the Input Capture Prescaler. + (++) Get the Capture/Compare values. + + (#) Advanced-control timers (TIM1) specific features + (++) Configures the Break input, dead time, Lock level, the OSSI, + the OSSR State and the AOE(automatic output enable) + (++) Enable/Disable the TIM peripheral Main Outputs + (++) Select the Commutation event + (++) Set/Reset the Capture Compare Preload Control bit + + (#) TIM interrupts, DMA and flags management. + (++) Enable/Disable interrupt sources. + (++) Get flags status. + (++) Clear flags/ Pending bits. + (++) Enable/Disable DMA requests. + (++) Configure DMA burst mode. + (++) Select CaptureCompare DMA request. + + (#) TIM clocks management: this group includes all needed functions + to configure the clock controller unit: + (++) Select internal/External clock. + (++) Select the external clock mode: ETR(Mode1/Mode2), TIx or ITRx. + + (#) TIM synchronization management: this group includes all needed. + functions to configure the Synchronization unit: + (++) Select Input Trigger. + (++) Select Output Trigger. + (++) Select Master Slave Mode. + (++) ETR Configuration when used as external trigger. + + (#) TIM specific interface management, this group includes all + needed functions to use the specific TIM interface: + (++) Encoder Interface Configuration. + (++) Select Hall Sensor. + + (#) TIM specific remapping management includes the Remapping + configuration of specific timers + +@endverbatim + * + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_tim.h" +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup TIM + * @brief TIM driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ + +/* ---------------------- TIM registers bit mask ------------------------ */ +#define SMCR_ETR_MASK ((uint16_t)0x00FF) +#define CCMR_OFFSET ((uint16_t)0x0018) +#define CCER_CCE_SET ((uint16_t)0x0001) +#define CCER_CCNE_SET ((uint16_t)0x0004) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ + +static void TI1_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, + uint16_t TIM_ICFilter); +static void TI2_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, + uint16_t TIM_ICFilter); +static void TI3_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, + uint16_t TIM_ICFilter); +static void TI4_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, + uint16_t TIM_ICFilter); +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup TIM_Private_Functions + * @{ + */ + +/** @defgroup TIM_Group1 TimeBase management functions + * @brief TimeBase management functions + * +@verbatim + =============================================================================== + ##### TimeBase management functions ##### + =============================================================================== + + *** TIM Driver: how to use it in Timing(Time base) Mode *** + =============================================================================== + [..] To use the Timer in Timing(Time base) mode, the following steps are + mandatory: + (#) Enable TIM clock using + RCC_APBxPeriphClockCmd(RCC_APBxPeriph_TIMx, ENABLE) function. + (#) Fill the TIM_TimeBaseInitStruct with the desired parameters. + (#) Call TIM_TimeBaseInit(TIMx, &TIM_TimeBaseInitStruct) to configure + the Time Base unit with the corresponding configuration. + (#) Enable the NVIC if you need to generate the update interrupt. + (#) Enable the corresponding interrupt using the function + TIM_ITConfig(TIMx, TIM_IT_Update). + (#) Call the TIM_Cmd(ENABLE) function to enable the TIM counter. + [..] + (@) All other functions can be used seperatly to modify, if needed, + a specific feature of the Timer. + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the TIMx peripheral registers to their default reset values. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17 to select the TIM peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @retval None + * + */ +void TIM_DeInit(TIM_TypeDef* TIMx) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + + if (TIMx == TIM1) + { + RCC_APB2PeriphResetCmd(RCC_APB2Periph_TIM1, ENABLE); + RCC_APB2PeriphResetCmd(RCC_APB2Periph_TIM1, DISABLE); + } + else if (TIMx == TIM2) + { + RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM2, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM2, DISABLE); + } + else if (TIMx == TIM3) + { + RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM3, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM3, DISABLE); + } + else if (TIMx == TIM6) + { + RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM6, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM6, DISABLE); + } + else if (TIMx == TIM7) + { + RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM7, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM7, DISABLE); + } + else if (TIMx == TIM14) + { + RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM14, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM14, DISABLE); + } + else if (TIMx == TIM15) + { + RCC_APB2PeriphResetCmd(RCC_APB2Periph_TIM15, ENABLE); + RCC_APB2PeriphResetCmd(RCC_APB2Periph_TIM15, DISABLE); + } + else if (TIMx == TIM16) + { + RCC_APB2PeriphResetCmd(RCC_APB2Periph_TIM16, ENABLE); + RCC_APB2PeriphResetCmd(RCC_APB2Periph_TIM16, DISABLE); + } + else + { + if (TIMx == TIM17) + { + RCC_APB2PeriphResetCmd(RCC_APB2Periph_TIM17, ENABLE); + RCC_APB2PeriphResetCmd(RCC_APB2Periph_TIM17, DISABLE); + } + } + +} + +/** + * @brief Initializes the TIMx Time Base Unit peripheral according to + * the specified parameters in the TIM_TimeBaseInitStruct. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17 to select the TIM + * peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_TimeBaseInitStruct: pointer to a TIM_TimeBaseInitTypeDef + * structure that contains the configuration information for + * the specified TIM peripheral. + * @retval None + */ +void TIM_TimeBaseInit(TIM_TypeDef* TIMx, TIM_TimeBaseInitTypeDef* TIM_TimeBaseInitStruct) +{ + uint16_t tmpcr1 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_TIM_COUNTER_MODE(TIM_TimeBaseInitStruct->TIM_CounterMode)); + assert_param(IS_TIM_CKD_DIV(TIM_TimeBaseInitStruct->TIM_ClockDivision)); + + tmpcr1 = TIMx->CR1; + + if((TIMx == TIM1) || (TIMx == TIM2) || (TIMx == TIM3)) + { + /* Select the Counter Mode */ + tmpcr1 &= (uint16_t)(~((uint16_t)(TIM_CR1_DIR | TIM_CR1_CMS))); + tmpcr1 |= (uint32_t)TIM_TimeBaseInitStruct->TIM_CounterMode; + } + + if(TIMx != TIM6) + { + /* Set the clock division */ + tmpcr1 &= (uint16_t)(~((uint16_t)TIM_CR1_CKD)); + tmpcr1 |= (uint32_t)TIM_TimeBaseInitStruct->TIM_ClockDivision; + } + + TIMx->CR1 = tmpcr1; + + /* Set the Autoreload value */ + TIMx->ARR = TIM_TimeBaseInitStruct->TIM_Period ; + + /* Set the Prescaler value */ + TIMx->PSC = TIM_TimeBaseInitStruct->TIM_Prescaler; + + if ((TIMx == TIM1) || (TIMx == TIM15)|| (TIMx == TIM16) || (TIMx == TIM17)) + { + /* Set the Repetition Counter value */ + TIMx->RCR = TIM_TimeBaseInitStruct->TIM_RepetitionCounter; + } + + /* Generate an update event to reload the Prescaler and the Repetition counter + values immediately */ + TIMx->EGR = TIM_PSCReloadMode_Immediate; +} + +/** + * @brief Fills each TIM_TimeBaseInitStruct member with its default value. + * @param TIM_TimeBaseInitStruct: pointer to a TIM_TimeBaseInitTypeDef structure + * which will be initialized. + * @retval None + */ +void TIM_TimeBaseStructInit(TIM_TimeBaseInitTypeDef* TIM_TimeBaseInitStruct) +{ + /* Set the default configuration */ + TIM_TimeBaseInitStruct->TIM_Period = 0xFFFFFFFF; + TIM_TimeBaseInitStruct->TIM_Prescaler = 0x0000; + TIM_TimeBaseInitStruct->TIM_ClockDivision = TIM_CKD_DIV1; + TIM_TimeBaseInitStruct->TIM_CounterMode = TIM_CounterMode_Up; + TIM_TimeBaseInitStruct->TIM_RepetitionCounter = 0x0000; +} + +/** + * @brief Configures the TIMx Prescaler. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17 to select the TIM peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param Prescaler: specifies the Prescaler Register value + * @param TIM_PSCReloadMode: specifies the TIM Prescaler Reload mode + * This parameter can be one of the following values: + * @arg TIM_PSCReloadMode_Update: The Prescaler is loaded at the update event. + * @arg TIM_PSCReloadMode_Immediate: The Prescaler is loaded immediatly. + * @retval None + */ +void TIM_PrescalerConfig(TIM_TypeDef* TIMx, uint16_t Prescaler, uint16_t TIM_PSCReloadMode) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_TIM_PRESCALER_RELOAD(TIM_PSCReloadMode)); + + /* Set the Prescaler value */ + TIMx->PSC = Prescaler; + /* Set or reset the UG Bit */ + TIMx->EGR = TIM_PSCReloadMode; +} + +/** + * @brief Specifies the TIMx Counter Mode to be used. + * @param TIMx: where x can be 1, 2, or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_CounterMode: specifies the Counter Mode to be used + * This parameter can be one of the following values: + * @arg TIM_CounterMode_Up: TIM Up Counting Mode + * @arg TIM_CounterMode_Down: TIM Down Counting Mode + * @arg TIM_CounterMode_CenterAligned1: TIM Center Aligned Mode1 + * @arg TIM_CounterMode_CenterAligned2: TIM Center Aligned Mode2 + * @arg TIM_CounterMode_CenterAligned3: TIM Center Aligned Mode3 + * @retval None + */ +void TIM_CounterModeConfig(TIM_TypeDef* TIMx, uint16_t TIM_CounterMode) +{ + uint16_t tmpcr1 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_COUNTER_MODE(TIM_CounterMode)); + + tmpcr1 = TIMx->CR1; + /* Reset the CMS and DIR Bits */ + tmpcr1 &= (uint16_t)(~((uint16_t)(TIM_CR1_DIR | TIM_CR1_CMS))); + /* Set the Counter Mode */ + tmpcr1 |= TIM_CounterMode; + /* Write to TIMx CR1 register */ + TIMx->CR1 = tmpcr1; +} + +/** + * @brief Sets the TIMx Counter Register value + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17 to select the TIM + * peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param Counter: specifies the Counter register new value. + * @retval None + */ +void TIM_SetCounter(TIM_TypeDef* TIMx, uint32_t Counter) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + + /* Set the Counter Register value */ + TIMx->CNT = Counter; +} + +/** + * @brief Sets the TIMx Autoreload Register value + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17 to select the TIM peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param Autoreload: specifies the Autoreload register new value. + * @retval None + */ +void TIM_SetAutoreload(TIM_TypeDef* TIMx, uint32_t Autoreload) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + + /* Set the Autoreload Register value */ + TIMx->ARR = Autoreload; +} + +/** + * @brief Gets the TIMx Counter value. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17 to select the TIM + * peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @retval Counter Register value. + */ +uint32_t TIM_GetCounter(TIM_TypeDef* TIMx) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + + /* Get the Counter Register value */ + return TIMx->CNT; +} + +/** + * @brief Gets the TIMx Prescaler value. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17 to select the TIM + * peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @retval Prescaler Register value. + */ +uint16_t TIM_GetPrescaler(TIM_TypeDef* TIMx) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + + /* Get the Prescaler Register value */ + return TIMx->PSC; +} + +/** + * @brief Enables or Disables the TIMx Update event. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17 to select the TIM + * peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param NewState: new state of the TIMx UDIS bit + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void TIM_UpdateDisableConfig(TIM_TypeDef* TIMx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Set the Update Disable Bit */ + TIMx->CR1 |= TIM_CR1_UDIS; + } + else + { + /* Reset the Update Disable Bit */ + TIMx->CR1 &= (uint16_t)~((uint16_t)TIM_CR1_UDIS); + } +} + +/** + * @brief Configures the TIMx Update Request Interrupt source. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17 to select the TIM + * peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_UpdateSource: specifies the Update source. + * This parameter can be one of the following values: + * @arg TIM_UpdateSource_Regular: Source of update is the counter + * overflow/underflow or the setting of UG bit, or an update + * generation through the slave mode controller. + * @arg TIM_UpdateSource_Global: Source of update is counter overflow/underflow. + * @retval None + */ +void TIM_UpdateRequestConfig(TIM_TypeDef* TIMx, uint16_t TIM_UpdateSource) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_TIM_UPDATE_SOURCE(TIM_UpdateSource)); + + if (TIM_UpdateSource != TIM_UpdateSource_Global) + { + /* Set the URS Bit */ + TIMx->CR1 |= TIM_CR1_URS; + } + else + { + /* Reset the URS Bit */ + TIMx->CR1 &= (uint16_t)~((uint16_t)TIM_CR1_URS); + } +} + +/** + * @brief Enables or disables TIMx peripheral Preload register on ARR. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17 to select the TIM + * peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param NewState: new state of the TIMx peripheral Preload register + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void TIM_ARRPreloadConfig(TIM_TypeDef* TIMx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Set the ARR Preload Bit */ + TIMx->CR1 |= TIM_CR1_ARPE; + } + else + { + /* Reset the ARR Preload Bit */ + TIMx->CR1 &= (uint16_t)~((uint16_t)TIM_CR1_ARPE); + } +} + +/** + * @brief Selects the TIMx's One Pulse Mode. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17 to select the TIM + * peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OPMode: specifies the OPM Mode to be used. + * This parameter can be one of the following values: + * @arg TIM_OPMode_Single + * @arg TIM_OPMode_Repetitive + * @retval None + */ +void TIM_SelectOnePulseMode(TIM_TypeDef* TIMx, uint16_t TIM_OPMode) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_TIM_OPM_MODE(TIM_OPMode)); + + /* Reset the OPM Bit */ + TIMx->CR1 &= (uint16_t)~((uint16_t)TIM_CR1_OPM); + /* Configure the OPM Mode */ + TIMx->CR1 |= TIM_OPMode; +} + +/** + * @brief Sets the TIMx Clock Division value. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 and 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_CKD: specifies the clock division value. + * This parameter can be one of the following value: + * @arg TIM_CKD_DIV1: TDTS = Tck_tim + * @arg TIM_CKD_DIV2: TDTS = 2*Tck_tim + * @arg TIM_CKD_DIV4: TDTS = 4*Tck_tim + * @retval None + */ +void TIM_SetClockDivision(TIM_TypeDef* TIMx, uint16_t TIM_CKD) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_CKD_DIV(TIM_CKD)); + + /* Reset the CKD Bits */ + TIMx->CR1 &= (uint16_t)~((uint16_t)TIM_CR1_CKD); + /* Set the CKD value */ + TIMx->CR1 |= TIM_CKD; +} + +/** + * @brief Enables or disables the specified TIM peripheral. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17to select the TIMx + * peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param NewState: new state of the TIMx peripheral. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void TIM_Cmd(TIM_TypeDef* TIMx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the TIM Counter */ + TIMx->CR1 |= TIM_CR1_CEN; + } + else + { + /* Disable the TIM Counter */ + TIMx->CR1 &= (uint16_t)(~((uint16_t)TIM_CR1_CEN)); + } +} + +/** + * @} + */ + +/** @defgroup TIM_Group2 Advanced-control timers (TIM1) specific features + * @brief Advanced-control timers (TIM1) specific features + * +@verbatim + =============================================================================== + ##### Advanced-control timers (TIM1) specific features ##### + =============================================================================== + + =================================================================== + *** TIM Driver: how to use the Break feature *** + =================================================================== + [..] After configuring the Timer channel(s) in the appropriate Output Compare mode: + + (#) Fill the TIM_BDTRInitStruct with the desired parameters for the Timer + Break Polarity, dead time, Lock level, the OSSI/OSSR State and the + AOE(automatic output enable). + + (#) Call TIM_BDTRConfig(TIMx, &TIM_BDTRInitStruct) to configure the Timer + + (#) Enable the Main Output using TIM_CtrlPWMOutputs(TIM1, ENABLE) + + (#) Once the break even occurs, the Timer's output signals are put in reset + state or in a known state (according to the configuration made in + TIM_BDTRConfig() function). + +@endverbatim + * @{ + */ +/** + * @brief Configures the: Break feature, dead time, Lock level, OSSI/OSSR State + * and the AOE(automatic output enable). + * @param TIMx: where x can be 1, 15, 16 or 17 to select the TIM + * @param TIM_BDTRInitStruct: pointer to a TIM_BDTRInitTypeDef structure that + * contains the BDTR Register configuration information for the TIM peripheral. + * @retval None + */ +void TIM_BDTRConfig(TIM_TypeDef* TIMx, TIM_BDTRInitTypeDef *TIM_BDTRInitStruct) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST2_PERIPH(TIMx)); + assert_param(IS_TIM_OSSR_STATE(TIM_BDTRInitStruct->TIM_OSSRState)); + assert_param(IS_TIM_OSSI_STATE(TIM_BDTRInitStruct->TIM_OSSIState)); + assert_param(IS_TIM_LOCK_LEVEL(TIM_BDTRInitStruct->TIM_LOCKLevel)); + assert_param(IS_TIM_BREAK_STATE(TIM_BDTRInitStruct->TIM_Break)); + assert_param(IS_TIM_BREAK_POLARITY(TIM_BDTRInitStruct->TIM_BreakPolarity)); + assert_param(IS_TIM_AUTOMATIC_OUTPUT_STATE(TIM_BDTRInitStruct->TIM_AutomaticOutput)); + /* Set the Lock level, the Break enable Bit and the Ploarity, the OSSR State, + the OSSI State, the dead time value and the Automatic Output Enable Bit */ + TIMx->BDTR = (uint32_t)TIM_BDTRInitStruct->TIM_OSSRState | TIM_BDTRInitStruct->TIM_OSSIState | + TIM_BDTRInitStruct->TIM_LOCKLevel | TIM_BDTRInitStruct->TIM_DeadTime | + TIM_BDTRInitStruct->TIM_Break | TIM_BDTRInitStruct->TIM_BreakPolarity | + TIM_BDTRInitStruct->TIM_AutomaticOutput; +} + +/** + * @brief Fills each TIM_BDTRInitStruct member with its default value. + * @param TIM_BDTRInitStruct: pointer to a TIM_BDTRInitTypeDef structure which + * will be initialized. + * @retval None + */ +void TIM_BDTRStructInit(TIM_BDTRInitTypeDef* TIM_BDTRInitStruct) +{ + /* Set the default configuration */ + TIM_BDTRInitStruct->TIM_OSSRState = TIM_OSSRState_Disable; + TIM_BDTRInitStruct->TIM_OSSIState = TIM_OSSIState_Disable; + TIM_BDTRInitStruct->TIM_LOCKLevel = TIM_LOCKLevel_OFF; + TIM_BDTRInitStruct->TIM_DeadTime = 0x00; + TIM_BDTRInitStruct->TIM_Break = TIM_Break_Disable; + TIM_BDTRInitStruct->TIM_BreakPolarity = TIM_BreakPolarity_Low; + TIM_BDTRInitStruct->TIM_AutomaticOutput = TIM_AutomaticOutput_Disable; +} + +/** + * @brief Enables or disables the TIM peripheral Main Outputs. + * @param TIMx: where x can be 1, 15, 16 or 17 to select the TIMx peripheral. + * @param NewState: new state of the TIM peripheral Main Outputs. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void TIM_CtrlPWMOutputs(TIM_TypeDef* TIMx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST2_PERIPH(TIMx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + if (NewState != DISABLE) + { + /* Enable the TIM Main Output */ + TIMx->BDTR |= TIM_BDTR_MOE; + } + else + { + /* Disable the TIM Main Output */ + TIMx->BDTR &= (uint16_t)(~((uint16_t)TIM_BDTR_MOE)); + } +} + +/** + * @} + */ + +/** @defgroup TIM_Group3 Output Compare management functions + * @brief Output Compare management functions + * +@verbatim + =============================================================================== + ##### Output Compare management functions ##### + =============================================================================== + *** TIM Driver: how to use it in Output Compare Mode *** + =============================================================================== + [..] To use the Timer in Output Compare mode, the following steps are mandatory: + (#) Enable TIM clock using + RCC_APBxPeriphClockCmd(RCC_APBxPeriph_TIMx, ENABLE) function. + (#) Configure the TIM pins by configuring the corresponding GPIO pins + (#) Configure the Time base unit as described in the first part of this + driver, if needed, else the Timer will run with the default + configuration: + (++) Autoreload value = 0xFFFF. + (++) Prescaler value = 0x0000. + (++) Counter mode = Up counting. + (++) Clock Division = TIM_CKD_DIV1. + (#) Fill the TIM_OCInitStruct with the desired parameters including: + (++) The TIM Output Compare mode: TIM_OCMode. + (++) TIM Output State: TIM_OutputState. + (++) TIM Pulse value: TIM_Pulse. + (++) TIM Output Compare Polarity : TIM_OCPolarity. + (#) Call TIM_OCxInit(TIMx, &TIM_OCInitStruct) to configure the desired + channel with the corresponding configuration. + (#) Call the TIM_Cmd(ENABLE) function to enable the TIM counter. + [..] + (@) All other functions can be used separately to modify, if needed, + a specific feature of the Timer. + (@) In case of PWM mode, this function is mandatory: + TIM_OCxPreloadConfig(TIMx, TIM_OCPreload_ENABLE). + (@) If the corresponding interrupt or DMA request are needed, the user should: + (#@) Enable the NVIC (or the DMA) to use the TIM interrupts (or DMA requests). + (#@) Enable the corresponding interrupt (or DMA request) using the function + TIM_ITConfig(TIMx, TIM_IT_CCx) (or TIM_DMA_Cmd(TIMx, TIM_DMA_CCx)). + +@endverbatim + * @{ + */ + +/** + * @brief Initializes the TIMx Channel1 according to the specified + * parameters in the TIM_OCInitStruct. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 and 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCInitStruct: pointer to a TIM_OCInitTypeDef structure + * that contains the configuration information for the specified TIM + * peripheral. + * @retval None + */ +void TIM_OC1Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct) +{ + uint16_t tmpccmrx = 0, tmpccer = 0, tmpcr2 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_OC_MODE(TIM_OCInitStruct->TIM_OCMode)); + assert_param(IS_TIM_OUTPUT_STATE(TIM_OCInitStruct->TIM_OutputState)); + assert_param(IS_TIM_OC_POLARITY(TIM_OCInitStruct->TIM_OCPolarity)); + /* Disable the Channel 1: Reset the CC1E Bit */ + TIMx->CCER &= (uint16_t)(~(uint16_t)TIM_CCER_CC1E); + /* Get the TIMx CCER register value */ + tmpccer = TIMx->CCER; + /* Get the TIMx CR2 register value */ + tmpcr2 = TIMx->CR2; + + /* Get the TIMx CCMR1 register value */ + tmpccmrx = TIMx->CCMR1; + + /* Reset the Output Compare Mode Bits */ + tmpccmrx &= (uint16_t)(~((uint16_t)TIM_CCMR1_OC1M)); + tmpccmrx &= (uint16_t)(~((uint16_t)TIM_CCMR1_CC1S)); + + /* Select the Output Compare Mode */ + tmpccmrx |= TIM_OCInitStruct->TIM_OCMode; + + /* Reset the Output Polarity level */ + tmpccer &= (uint16_t)(~((uint16_t)TIM_CCER_CC1P)); + /* Set the Output Compare Polarity */ + tmpccer |= TIM_OCInitStruct->TIM_OCPolarity; + + /* Set the Output State */ + tmpccer |= TIM_OCInitStruct->TIM_OutputState; + + if((TIMx == TIM1) || (TIMx == TIM15) || (TIMx == TIM16) || (TIMx == TIM17)) + { + assert_param(IS_TIM_OUTPUTN_STATE(TIM_OCInitStruct->TIM_OutputNState)); + assert_param(IS_TIM_OCN_POLARITY(TIM_OCInitStruct->TIM_OCNPolarity)); + assert_param(IS_TIM_OCNIDLE_STATE(TIM_OCInitStruct->TIM_OCNIdleState)); + assert_param(IS_TIM_OCIDLE_STATE(TIM_OCInitStruct->TIM_OCIdleState)); + + /* Reset the Output N Polarity level */ + tmpccer &= (uint16_t)(~((uint16_t)TIM_CCER_CC1NP)); + /* Set the Output N Polarity */ + tmpccer |= TIM_OCInitStruct->TIM_OCNPolarity; + + /* Reset the Output N State */ + tmpccer &= (uint16_t)(~((uint16_t)TIM_CCER_CC1NE)); + /* Set the Output N State */ + tmpccer |= TIM_OCInitStruct->TIM_OutputNState; + + /* Reset the Ouput Compare and Output Compare N IDLE State */ + tmpcr2 &= (uint16_t)(~((uint16_t)TIM_CR2_OIS1)); + tmpcr2 &= (uint16_t)(~((uint16_t)TIM_CR2_OIS1N)); + + /* Set the Output Idle state */ + tmpcr2 |= TIM_OCInitStruct->TIM_OCIdleState; + /* Set the Output N Idle state */ + tmpcr2 |= TIM_OCInitStruct->TIM_OCNIdleState; + } + /* Write to TIMx CR2 */ + TIMx->CR2 = tmpcr2; + + /* Write to TIMx CCMR1 */ + TIMx->CCMR1 = tmpccmrx; + + /* Set the Capture Compare Register value */ + TIMx->CCR1 = TIM_OCInitStruct->TIM_Pulse; + + /* Write to TIMx CCER */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Initializes the TIMx Channel2 according to the specified + * parameters in the TIM_OCInitStruct. + * @param TIMx: where x can be 1, 2, 3 or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCInitStruct: pointer to a TIM_OCInitTypeDef structure + * that contains the configuration information for the specified TIM + * peripheral. + * @retval None + */ +void TIM_OC2Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct) +{ + uint16_t tmpccmrx = 0, tmpccer = 0, tmpcr2 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_OC_MODE(TIM_OCInitStruct->TIM_OCMode)); + assert_param(IS_TIM_OUTPUT_STATE(TIM_OCInitStruct->TIM_OutputState)); + assert_param(IS_TIM_OC_POLARITY(TIM_OCInitStruct->TIM_OCPolarity)); + /* Disable the Channel 2: Reset the CC2E Bit */ + TIMx->CCER &= (uint16_t)(~((uint16_t)TIM_CCER_CC2E)); + + /* Get the TIMx CCER register value */ + tmpccer = TIMx->CCER; + /* Get the TIMx CR2 register value */ + tmpcr2 = TIMx->CR2; + + /* Get the TIMx CCMR1 register value */ + tmpccmrx = TIMx->CCMR1; + + /* Reset the Output Compare mode and Capture/Compare selection Bits */ + tmpccmrx &= (uint16_t)(~((uint16_t)TIM_CCMR1_OC2M)); + tmpccmrx &= (uint16_t)(~((uint16_t)TIM_CCMR1_CC2S)); + + /* Select the Output Compare Mode */ + tmpccmrx |= (uint16_t)(TIM_OCInitStruct->TIM_OCMode << 8); + + /* Reset the Output Polarity level */ + tmpccer &= (uint16_t)(~((uint16_t)TIM_CCER_CC2P)); + /* Set the Output Compare Polarity */ + tmpccer |= (uint16_t)(TIM_OCInitStruct->TIM_OCPolarity << 4); + + /* Set the Output State */ + tmpccer |= (uint16_t)(TIM_OCInitStruct->TIM_OutputState << 4); + + if((TIMx == TIM1) || (TIMx == TIM15)) + { + /* Check the parameters */ + assert_param(IS_TIM_OCIDLE_STATE(TIM_OCInitStruct->TIM_OCIdleState)); + + /* Reset the Ouput Compare State */ + tmpcr2 &= (uint16_t)(~((uint16_t)TIM_CR2_OIS2)); + + /* Set the Output Idle state */ + tmpcr2 |= (uint16_t)(TIM_OCInitStruct->TIM_OCIdleState << 2); + + if (TIMx == TIM1) + { + /* Check the parameters */ + assert_param(IS_TIM_OUTPUTN_STATE(TIM_OCInitStruct->TIM_OutputNState)); + assert_param(IS_TIM_OCN_POLARITY(TIM_OCInitStruct->TIM_OCNPolarity)); + assert_param(IS_TIM_OCNIDLE_STATE(TIM_OCInitStruct->TIM_OCNIdleState)); + + /* Reset the Output N Polarity level */ + tmpccer &= (uint16_t)(~((uint16_t)TIM_CCER_CC2NP)); + /* Set the Output N Polarity */ + tmpccer |= (uint16_t)(TIM_OCInitStruct->TIM_OCNPolarity << 4); + + /* Reset the Output N State */ + tmpccer &= (uint16_t)(~((uint16_t)TIM_CCER_CC2NE)); + /* Set the Output N State */ + tmpccer |= (uint16_t)(TIM_OCInitStruct->TIM_OutputNState << 4); + + /* Reset the Output Compare N IDLE State */ + tmpcr2 &= (uint16_t)(~((uint16_t)TIM_CR2_OIS2N)); + + /* Set the Output N Idle state */ + tmpcr2 |= (uint16_t)(TIM_OCInitStruct->TIM_OCNIdleState << 2); + } + } + /* Write to TIMx CR2 */ + TIMx->CR2 = tmpcr2; + + /* Write to TIMx CCMR1 */ + TIMx->CCMR1 = tmpccmrx; + + /* Set the Capture Compare Register value */ + TIMx->CCR2 = TIM_OCInitStruct->TIM_Pulse; + + /* Write to TIMx CCER */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Initializes the TIMx Channel3 according to the specified + * parameters in the TIM_OCInitStruct. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCInitStruct: pointer to a TIM_OCInitTypeDef structure + * that contains the configuration information for the specified TIM + * peripheral. + * @retval None + */ +void TIM_OC3Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct) +{ + uint16_t tmpccmrx = 0, tmpccer = 0, tmpcr2 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_OC_MODE(TIM_OCInitStruct->TIM_OCMode)); + assert_param(IS_TIM_OUTPUT_STATE(TIM_OCInitStruct->TIM_OutputState)); + assert_param(IS_TIM_OC_POLARITY(TIM_OCInitStruct->TIM_OCPolarity)); + /* Disable the Channel 2: Reset the CC2E Bit */ + TIMx->CCER &= (uint16_t)(~((uint16_t)TIM_CCER_CC3E)); + + /* Get the TIMx CCER register value */ + tmpccer = TIMx->CCER; + /* Get the TIMx CR2 register value */ + tmpcr2 = TIMx->CR2; + + /* Get the TIMx CCMR2 register value */ + tmpccmrx = TIMx->CCMR2; + + /* Reset the Output Compare mode and Capture/Compare selection Bits */ + tmpccmrx &= (uint16_t)(~((uint16_t)TIM_CCMR2_OC3M)); + tmpccmrx &= (uint16_t)(~((uint16_t)TIM_CCMR2_CC3S)); + /* Select the Output Compare Mode */ + tmpccmrx |= TIM_OCInitStruct->TIM_OCMode; + + /* Reset the Output Polarity level */ + tmpccer &= (uint16_t)(~((uint16_t)TIM_CCER_CC3P)); + /* Set the Output Compare Polarity */ + tmpccer |= (uint16_t)(TIM_OCInitStruct->TIM_OCPolarity << 8); + + /* Set the Output State */ + tmpccer |= (uint16_t)(TIM_OCInitStruct->TIM_OutputState << 8); + + if(TIMx == TIM1) + { + assert_param(IS_TIM_OUTPUTN_STATE(TIM_OCInitStruct->TIM_OutputNState)); + assert_param(IS_TIM_OCN_POLARITY(TIM_OCInitStruct->TIM_OCNPolarity)); + assert_param(IS_TIM_OCNIDLE_STATE(TIM_OCInitStruct->TIM_OCNIdleState)); + assert_param(IS_TIM_OCIDLE_STATE(TIM_OCInitStruct->TIM_OCIdleState)); + + /* Reset the Output N Polarity level */ + tmpccer &= (uint16_t)(~((uint16_t)TIM_CCER_CC3NP)); + /* Set the Output N Polarity */ + tmpccer |= (uint16_t)(TIM_OCInitStruct->TIM_OCNPolarity << 8); + /* Reset the Output N State */ + tmpccer &= (uint16_t)(~((uint16_t)TIM_CCER_CC3NE)); + + /* Set the Output N State */ + tmpccer |= (uint16_t)(TIM_OCInitStruct->TIM_OutputNState << 8); + /* Reset the Ouput Compare and Output Compare N IDLE State */ + tmpcr2 &= (uint16_t)(~((uint16_t)TIM_CR2_OIS3)); + tmpcr2 &= (uint16_t)(~((uint16_t)TIM_CR2_OIS3N)); + /* Set the Output Idle state */ + tmpcr2 |= (uint16_t)(TIM_OCInitStruct->TIM_OCIdleState << 4); + /* Set the Output N Idle state */ + tmpcr2 |= (uint16_t)(TIM_OCInitStruct->TIM_OCNIdleState << 4); + } + /* Write to TIMx CR2 */ + TIMx->CR2 = tmpcr2; + + /* Write to TIMx CCMR2 */ + TIMx->CCMR2 = tmpccmrx; + + /* Set the Capture Compare Register value */ + TIMx->CCR3 = TIM_OCInitStruct->TIM_Pulse; + + /* Write to TIMx CCER */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Initializes the TIMx Channel4 according to the specified + * parameters in the TIM_OCInitStruct. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCInitStruct: pointer to a TIM_OCInitTypeDef structure + * that contains the configuration information for the specified TIM + * peripheral. + * @retval None + */ +void TIM_OC4Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct) +{ + uint16_t tmpccmrx = 0, tmpccer = 0, tmpcr2 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_OC_MODE(TIM_OCInitStruct->TIM_OCMode)); + assert_param(IS_TIM_OUTPUT_STATE(TIM_OCInitStruct->TIM_OutputState)); + assert_param(IS_TIM_OC_POLARITY(TIM_OCInitStruct->TIM_OCPolarity)); + /* Disable the Channel 2: Reset the CC4E Bit */ + TIMx->CCER &= (uint16_t)(~((uint16_t)TIM_CCER_CC4E)); + + /* Get the TIMx CCER register value */ + tmpccer = TIMx->CCER; + /* Get the TIMx CR2 register value */ + tmpcr2 = TIMx->CR2; + + /* Get the TIMx CCMR2 register value */ + tmpccmrx = TIMx->CCMR2; + + /* Reset the Output Compare mode and Capture/Compare selection Bits */ + tmpccmrx &= (uint16_t)(~((uint16_t)TIM_CCMR2_OC4M)); + tmpccmrx &= (uint16_t)(~((uint16_t)TIM_CCMR2_CC4S)); + + /* Select the Output Compare Mode */ + tmpccmrx |= (uint16_t)(TIM_OCInitStruct->TIM_OCMode << 8); + + /* Reset the Output Polarity level */ + tmpccer &= (uint16_t)(~((uint16_t)TIM_CCER_CC4P)); + /* Set the Output Compare Polarity */ + tmpccer |= (uint16_t)(TIM_OCInitStruct->TIM_OCPolarity << 12); + + /* Set the Output State */ + tmpccer |= (uint16_t)(TIM_OCInitStruct->TIM_OutputState << 12); + + if(TIMx == TIM1) + { + assert_param(IS_TIM_OCIDLE_STATE(TIM_OCInitStruct->TIM_OCIdleState)); + /* Reset the Ouput Compare IDLE State */ + tmpcr2 &= (uint16_t)(~((uint16_t)TIM_CR2_OIS4)); + /* Set the Output Idle state */ + tmpcr2 |= (uint16_t)(TIM_OCInitStruct->TIM_OCIdleState << 6); + } + /* Write to TIMx CR2 */ + TIMx->CR2 = tmpcr2; + + /* Write to TIMx CCMR2 */ + TIMx->CCMR2 = tmpccmrx; + + /* Set the Capture Compare Register value */ + TIMx->CCR4 = TIM_OCInitStruct->TIM_Pulse; + + /* Write to TIMx CCER */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Fills each TIM_OCInitStruct member with its default value. + * @param TIM_OCInitStruct: pointer to a TIM_OCInitTypeDef structure which will + * be initialized. + * @retval None + */ +void TIM_OCStructInit(TIM_OCInitTypeDef* TIM_OCInitStruct) +{ + /* Set the default configuration */ + TIM_OCInitStruct->TIM_OCMode = TIM_OCMode_Timing; + TIM_OCInitStruct->TIM_OutputState = TIM_OutputState_Disable; + TIM_OCInitStruct->TIM_OutputNState = TIM_OutputNState_Disable; + TIM_OCInitStruct->TIM_Pulse = 0x0000000; + TIM_OCInitStruct->TIM_OCPolarity = TIM_OCPolarity_High; + TIM_OCInitStruct->TIM_OCNPolarity = TIM_OCPolarity_High; + TIM_OCInitStruct->TIM_OCIdleState = TIM_OCIdleState_Reset; + TIM_OCInitStruct->TIM_OCNIdleState = TIM_OCNIdleState_Reset; +} + +/** + * @brief Selects the TIM Output Compare Mode. + * @note This function disables the selected channel before changing the Output + * Compare Mode. + * User has to enable this channel using TIM_CCxCmd and TIM_CCxNCmd functions. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_Channel: specifies the TIM Channel + * This parameter can be one of the following values: + * @arg TIM_Channel_1: TIM Channel 1 + * @arg TIM_Channel_2: TIM Channel 2 + * @arg TIM_Channel_3: TIM Channel 3 + * @arg TIM_Channel_4: TIM Channel 4 + * @param TIM_OCMode: specifies the TIM Output Compare Mode. + * This parameter can be one of the following values: + * @arg TIM_OCMode_Timing + * @arg TIM_OCMode_Active + * @arg TIM_OCMode_Toggle + * @arg TIM_OCMode_PWM1 + * @arg TIM_OCMode_PWM2 + * @arg TIM_ForcedAction_Active + * @arg TIM_ForcedAction_InActive + * @retval None + */ +void TIM_SelectOCxM(TIM_TypeDef* TIMx, uint16_t TIM_Channel, uint16_t TIM_OCMode) +{ + uint32_t tmp = 0; + uint16_t tmp1 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_OCM(TIM_OCMode)); + + tmp = (uint32_t) TIMx; + tmp += CCMR_OFFSET; + + tmp1 = CCER_CCE_SET << (uint16_t)TIM_Channel; + + /* Disable the Channel: Reset the CCxE Bit */ + TIMx->CCER &= (uint16_t) ~tmp1; + + if((TIM_Channel == TIM_Channel_1) ||(TIM_Channel == TIM_Channel_3)) + { + tmp += (TIM_Channel>>1); + + /* Reset the OCxM bits in the CCMRx register */ + *(__IO uint32_t *) tmp &= (uint32_t)~((uint32_t)TIM_CCMR1_OC1M); + + /* Configure the OCxM bits in the CCMRx register */ + *(__IO uint32_t *) tmp |= TIM_OCMode; + } + else + { + tmp += (uint16_t)(TIM_Channel - (uint16_t)4)>> (uint16_t)1; + + /* Reset the OCxM bits in the CCMRx register */ + *(__IO uint32_t *) tmp &= (uint32_t)~((uint32_t)TIM_CCMR1_OC2M); + + /* Configure the OCxM bits in the CCMRx register */ + *(__IO uint32_t *) tmp |= (uint16_t)(TIM_OCMode << 8); + } +} + +/** + * @brief Sets the TIMx Capture Compare1 Register value + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param Compare1: specifies the Capture Compare1 register new value. + * @retval None + */ +void TIM_SetCompare1(TIM_TypeDef* TIMx, uint32_t Compare1) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + + /* Set the Capture Compare1 Register value */ + TIMx->CCR1 = Compare1; +} + +/** + * @brief Sets the TIMx Capture Compare2 Register value + * @param TIMx: where x can be 1, 2, 3 or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param Compare2: specifies the Capture Compare2 register new value. + * @retval None + */ +void TIM_SetCompare2(TIM_TypeDef* TIMx, uint32_t Compare2) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + + /* Set the Capture Compare2 Register value */ + TIMx->CCR2 = Compare2; +} + +/** + * @brief Sets the TIMx Capture Compare3 Register value + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @param Compare3: specifies the Capture Compare3 register new value. + * @retval None + */ +void TIM_SetCompare3(TIM_TypeDef* TIMx, uint32_t Compare3) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + + /* Set the Capture Compare3 Register value */ + TIMx->CCR3 = Compare3; +} + +/** + * @brief Sets the TIMx Capture Compare4 Register value + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param Compare4: specifies the Capture Compare4 register new value. + * @retval None + */ +void TIM_SetCompare4(TIM_TypeDef* TIMx, uint32_t Compare4) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + + /* Set the Capture Compare4 Register value */ + TIMx->CCR4 = Compare4; +} + +/** + * @brief Forces the TIMx output 1 waveform to active or inactive level. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ForcedAction: specifies the forced Action to be set to the output waveform. + * This parameter can be one of the following values: + * @arg TIM_ForcedAction_Active: Force active level on OC1REF + * @arg TIM_ForcedAction_InActive: Force inactive level on OC1REF. + * @retval None + */ +void TIM_ForcedOC1Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction) +{ + uint16_t tmpccmr1 = 0; + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_FORCED_ACTION(TIM_ForcedAction)); + tmpccmr1 = TIMx->CCMR1; + /* Reset the OC1M Bits */ + tmpccmr1 &= (uint16_t)~((uint16_t)TIM_CCMR1_OC1M); + /* Configure The Forced output Mode */ + tmpccmr1 |= TIM_ForcedAction; + /* Write to TIMx CCMR1 register */ + TIMx->CCMR1 = tmpccmr1; +} + +/** + * @brief Forces the TIMx output 2 waveform to active or inactive level. + * @param TIMx: where x can be 1, 2, 3, or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ForcedAction: specifies the forced Action to be set to the output waveform. + * This parameter can be one of the following values: + * @arg TIM_ForcedAction_Active: Force active level on OC2REF + * @arg TIM_ForcedAction_InActive: Force inactive level on OC2REF. + * @retval None + */ +void TIM_ForcedOC2Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction) +{ + uint16_t tmpccmr1 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_FORCED_ACTION(TIM_ForcedAction)); + + tmpccmr1 = TIMx->CCMR1; + /* Reset the OC2M Bits */ + tmpccmr1 &= (uint16_t)~((uint16_t)TIM_CCMR1_OC2M); + /* Configure The Forced output Mode */ + tmpccmr1 |= (uint16_t)(TIM_ForcedAction << 8); + /* Write to TIMx CCMR1 register */ + TIMx->CCMR1 = tmpccmr1; +} + +/** + * @brief Forces the TIMx output 3 waveform to active or inactive level. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ForcedAction: specifies the forced Action to be set to the output waveform. + * This parameter can be one of the following values: + * @arg TIM_ForcedAction_Active: Force active level on OC3REF + * @arg TIM_ForcedAction_InActive: Force inactive level on OC3REF. + * @retval None + */ +void TIM_ForcedOC3Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction) +{ + uint16_t tmpccmr2 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_FORCED_ACTION(TIM_ForcedAction)); + + tmpccmr2 = TIMx->CCMR2; + /* Reset the OC1M Bits */ + tmpccmr2 &= (uint16_t)~((uint16_t)TIM_CCMR2_OC3M); + /* Configure The Forced output Mode */ + tmpccmr2 |= TIM_ForcedAction; + /* Write to TIMx CCMR2 register */ + TIMx->CCMR2 = tmpccmr2; +} + +/** + * @brief Forces the TIMx output 4 waveform to active or inactive level. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ForcedAction: specifies the forced Action to be set to the output waveform. + * This parameter can be one of the following values: + * @arg TIM_ForcedAction_Active: Force active level on OC4REF + * @arg TIM_ForcedAction_InActive: Force inactive level on OC4REF. + * @retval None + */ +void TIM_ForcedOC4Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction) +{ + uint16_t tmpccmr2 = 0; + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_FORCED_ACTION(TIM_ForcedAction)); + + tmpccmr2 = TIMx->CCMR2; + /* Reset the OC2M Bits */ + tmpccmr2 &= (uint16_t)~((uint16_t)TIM_CCMR2_OC4M); + /* Configure The Forced output Mode */ + tmpccmr2 |= (uint16_t)(TIM_ForcedAction << 8); + /* Write to TIMx CCMR2 register */ + TIMx->CCMR2 = tmpccmr2; +} + +/** + * @brief Sets or Resets the TIM peripheral Capture Compare Preload Control bit. + * @param TIMx: where x can be 1, 2, 3 or 15 to select the TIMx peripheral + * @note TIM2 is not applicable for STM32F030 devices. + * @param NewState: new state of the Capture Compare Preload Control bit + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void TIM_CCPreloadControl(TIM_TypeDef* TIMx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + if (NewState != DISABLE) + { + /* Set the CCPC Bit */ + TIMx->CR2 |= TIM_CR2_CCPC; + } + else + { + /* Reset the CCPC Bit */ + TIMx->CR2 &= (uint16_t)~((uint16_t)TIM_CR2_CCPC); + } +} + + +/** + * @brief Enables or disables the TIMx peripheral Preload register on CCR1. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 and 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCPreload: new state of the TIMx peripheral Preload register + * This parameter can be one of the following values: + * @arg TIM_OCPreload_Enable + * @arg TIM_OCPreload_Disable + * @retval None + */ +void TIM_OC1PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload) +{ + uint16_t tmpccmr1 = 0; + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_OCPRELOAD_STATE(TIM_OCPreload)); + + tmpccmr1 = TIMx->CCMR1; + /* Reset the OC1PE Bit */ + tmpccmr1 &= (uint16_t)~((uint16_t)TIM_CCMR1_OC1PE); + /* Enable or Disable the Output Compare Preload feature */ + tmpccmr1 |= TIM_OCPreload; + /* Write to TIMx CCMR1 register */ + TIMx->CCMR1 = tmpccmr1; +} + +/** + * @brief Enables or disables the TIMx peripheral Preload register on CCR2. + * @param TIMx: where x can be 1, 2, 3 and 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCPreload: new state of the TIMx peripheral Preload register + * This parameter can be one of the following values: + * @arg TIM_OCPreload_Enable + * @arg TIM_OCPreload_Disable + * @retval None + */ +void TIM_OC2PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload) +{ + uint16_t tmpccmr1 = 0; + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_OCPRELOAD_STATE(TIM_OCPreload)); + + tmpccmr1 = TIMx->CCMR1; + /* Reset the OC2PE Bit */ + tmpccmr1 &= (uint16_t)~((uint16_t)TIM_CCMR1_OC2PE); + /* Enable or Disable the Output Compare Preload feature */ + tmpccmr1 |= (uint16_t)(TIM_OCPreload << 8); + /* Write to TIMx CCMR1 register */ + TIMx->CCMR1 = tmpccmr1; +} + +/** + * @brief Enables or disables the TIMx peripheral Preload register on CCR3. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCPreload: new state of the TIMx peripheral Preload register + * This parameter can be one of the following values: + * @arg TIM_OCPreload_Enable + * @arg TIM_OCPreload_Disable + * @retval None + */ +void TIM_OC3PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload) +{ + uint16_t tmpccmr2 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_OCPRELOAD_STATE(TIM_OCPreload)); + + tmpccmr2 = TIMx->CCMR2; + /* Reset the OC3PE Bit */ + tmpccmr2 &= (uint16_t)~((uint16_t)TIM_CCMR2_OC3PE); + /* Enable or Disable the Output Compare Preload feature */ + tmpccmr2 |= TIM_OCPreload; + /* Write to TIMx CCMR2 register */ + TIMx->CCMR2 = tmpccmr2; +} + +/** + * @brief Enables or disables the TIMx peripheral Preload register on CCR4. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCPreload: new state of the TIMx peripheral Preload register + * This parameter can be one of the following values: + * @arg TIM_OCPreload_Enable + * @arg TIM_OCPreload_Disable + * @retval None + */ +void TIM_OC4PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload) +{ + uint16_t tmpccmr2 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_OCPRELOAD_STATE(TIM_OCPreload)); + + tmpccmr2 = TIMx->CCMR2; + /* Reset the OC4PE Bit */ + tmpccmr2 &= (uint16_t)~((uint16_t)TIM_CCMR2_OC4PE); + /* Enable or Disable the Output Compare Preload feature */ + tmpccmr2 |= (uint16_t)(TIM_OCPreload << 8); + /* Write to TIMx CCMR2 register */ + TIMx->CCMR2 = tmpccmr2; +} + +/** + * @brief Configures the TIMx Output Compare 1 Fast feature. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCFast: new state of the Output Compare Fast Enable Bit. + * This parameter can be one of the following values: + * @arg TIM_OCFast_Enable: TIM output compare fast enable + * @arg TIM_OCFast_Disable: TIM output compare fast disable + * @retval None + */ +void TIM_OC1FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast) +{ + uint16_t tmpccmr1 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_OCFAST_STATE(TIM_OCFast)); + + /* Get the TIMx CCMR1 register value */ + tmpccmr1 = TIMx->CCMR1; + /* Reset the OC1FE Bit */ + tmpccmr1 &= (uint16_t)~((uint16_t)TIM_CCMR1_OC1FE); + /* Enable or Disable the Output Compare Fast Bit */ + tmpccmr1 |= TIM_OCFast; + /* Write to TIMx CCMR1 */ + TIMx->CCMR1 = tmpccmr1; +} + +/** + * @brief Configures the TIMx Output Compare 2 Fast feature. + * @param TIMx: where x can be 1, 2, 3 or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCFast: new state of the Output Compare Fast Enable Bit. + * This parameter can be one of the following values: + * @arg TIM_OCFast_Enable: TIM output compare fast enable + * @arg TIM_OCFast_Disable: TIM output compare fast disable + * @retval None + */ +void TIM_OC2FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast) +{ + uint16_t tmpccmr1 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_OCFAST_STATE(TIM_OCFast)); + + /* Get the TIMx CCMR1 register value */ + tmpccmr1 = TIMx->CCMR1; + /* Reset the OC2FE Bit */ + tmpccmr1 &= (uint16_t)~((uint16_t)TIM_CCMR1_OC2FE); + /* Enable or Disable the Output Compare Fast Bit */ + tmpccmr1 |= (uint16_t)(TIM_OCFast << 8); + /* Write to TIMx CCMR1 */ + TIMx->CCMR1 = tmpccmr1; +} + +/** + * @brief Configures the TIMx Output Compare 3 Fast feature. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCFast: new state of the Output Compare Fast Enable Bit. + * This parameter can be one of the following values: + * @arg TIM_OCFast_Enable: TIM output compare fast enable + * @arg TIM_OCFast_Disable: TIM output compare fast disable + * @retval None + */ +void TIM_OC3FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast) +{ + uint16_t tmpccmr2 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_OCFAST_STATE(TIM_OCFast)); + + /* Get the TIMx CCMR2 register value */ + tmpccmr2 = TIMx->CCMR2; + /* Reset the OC3FE Bit */ + tmpccmr2 &= (uint16_t)~((uint16_t)TIM_CCMR2_OC3FE); + /* Enable or Disable the Output Compare Fast Bit */ + tmpccmr2 |= TIM_OCFast; + /* Write to TIMx CCMR2 */ + TIMx->CCMR2 = tmpccmr2; +} + +/** + * @brief Configures the TIMx Output Compare 4 Fast feature. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCFast: new state of the Output Compare Fast Enable Bit. + * This parameter can be one of the following values: + * @arg TIM_OCFast_Enable: TIM output compare fast enable + * @arg TIM_OCFast_Disable: TIM output compare fast disable + * @retval None + */ +void TIM_OC4FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast) +{ + uint16_t tmpccmr2 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_OCFAST_STATE(TIM_OCFast)); + + /* Get the TIMx CCMR2 register value */ + tmpccmr2 = TIMx->CCMR2; + /* Reset the OC4FE Bit */ + tmpccmr2 &= (uint16_t)~((uint16_t)TIM_CCMR2_OC4FE); + /* Enable or Disable the Output Compare Fast Bit */ + tmpccmr2 |= (uint16_t)(TIM_OCFast << 8); + /* Write to TIMx CCMR2 */ + TIMx->CCMR2 = tmpccmr2; +} + +/** + * @brief Clears or safeguards the OCREF1 signal on an external event + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCClear: new state of the Output Compare Clear Enable Bit. + * This parameter can be one of the following values: + * @arg TIM_OCClear_Enable: TIM Output clear enable + * @arg TIM_OCClear_Disable: TIM Output clear disable + * @retval None + */ +void TIM_ClearOC1Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear) +{ + uint16_t tmpccmr1 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_OCCLEAR_STATE(TIM_OCClear)); + + tmpccmr1 = TIMx->CCMR1; + /* Reset the OC1CE Bit */ + tmpccmr1 &= (uint16_t)~((uint16_t)TIM_CCMR1_OC1CE); + /* Enable or Disable the Output Compare Clear Bit */ + tmpccmr1 |= TIM_OCClear; + /* Write to TIMx CCMR1 register */ + TIMx->CCMR1 = tmpccmr1; +} + +/** + * @brief Clears or safeguards the OCREF2 signal on an external event + * @param TIMx: where x can be 1, 2, 3 or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCClear: new state of the Output Compare Clear Enable Bit. + * This parameter can be one of the following values: + * @arg TIM_OCClear_Enable: TIM Output clear enable + * @arg TIM_OCClear_Disable: TIM Output clear disable + * @retval None + */ +void TIM_ClearOC2Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear) +{ + uint16_t tmpccmr1 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_OCCLEAR_STATE(TIM_OCClear)); + + tmpccmr1 = TIMx->CCMR1; + /* Reset the OC2CE Bit */ + tmpccmr1 &= (uint16_t)~((uint16_t)TIM_CCMR1_OC2CE); + /* Enable or Disable the Output Compare Clear Bit */ + tmpccmr1 |= (uint16_t)(TIM_OCClear << 8); + /* Write to TIMx CCMR1 register */ + TIMx->CCMR1 = tmpccmr1; +} + +/** + * @brief Clears or safeguards the OCREF3 signal on an external event + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCClear: new state of the Output Compare Clear Enable Bit. + * This parameter can be one of the following values: + * @arg TIM_OCClear_Enable: TIM Output clear enable + * @arg TIM_OCClear_Disable: TIM Output clear disable + * @retval None + */ +void TIM_ClearOC3Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear) +{ + uint16_t tmpccmr2 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_OCCLEAR_STATE(TIM_OCClear)); + + tmpccmr2 = TIMx->CCMR2; + /* Reset the OC3CE Bit */ + tmpccmr2 &= (uint16_t)~((uint16_t)TIM_CCMR2_OC3CE); + /* Enable or Disable the Output Compare Clear Bit */ + tmpccmr2 |= TIM_OCClear; + /* Write to TIMx CCMR2 register */ + TIMx->CCMR2 = tmpccmr2; +} + +/** + * @brief Clears or safeguards the OCREF4 signal on an external event + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCClear: new state of the Output Compare Clear Enable Bit. + * This parameter can be one of the following values: + * @arg TIM_OCClear_Enable: TIM Output clear enable + * @arg TIM_OCClear_Disable: TIM Output clear disable + * @retval None + */ +void TIM_ClearOC4Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear) +{ + uint16_t tmpccmr2 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_OCCLEAR_STATE(TIM_OCClear)); + + tmpccmr2 = TIMx->CCMR2; + /* Reset the OC4CE Bit */ + tmpccmr2 &= (uint16_t)~((uint16_t)TIM_CCMR2_OC4CE); + /* Enable or Disable the Output Compare Clear Bit */ + tmpccmr2 |= (uint16_t)(TIM_OCClear << 8); + /* Write to TIMx CCMR2 register */ + TIMx->CCMR2 = tmpccmr2; +} + +/** + * @brief Configures the TIMx channel 1 polarity. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCPolarity: specifies the OC1 Polarity + * This parmeter can be one of the following values: + * @arg TIM_OCPolarity_High: Output Compare active high + * @arg TIM_OCPolarity_Low: Output Compare active low + * @retval None + */ +void TIM_OC1PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity) +{ + uint16_t tmpccer = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_OC_POLARITY(TIM_OCPolarity)); + + tmpccer = TIMx->CCER; + /* Set or Reset the CC1P Bit */ + tmpccer &= (uint16_t)~((uint16_t)TIM_CCER_CC1P); + tmpccer |= TIM_OCPolarity; + /* Write to TIMx CCER register */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Configures the TIMx Channel 1N polarity. + * @param TIMx: where x can be 1, 15, 16 or 17 to select the TIM peripheral. + * @param TIM_OCNPolarity: specifies the OC1N Polarity + * This parmeter can be one of the following values: + * @arg TIM_OCNPolarity_High: Output Compare active high + * @arg TIM_OCNPolarity_Low: Output Compare active low + * @retval None + */ +void TIM_OC1NPolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCNPolarity) +{ + uint16_t tmpccer = 0; + /* Check the parameters */ + assert_param(IS_TIM_LIST2_PERIPH(TIMx)); + assert_param(IS_TIM_OCN_POLARITY(TIM_OCNPolarity)); + + tmpccer = TIMx->CCER; + /* Set or Reset the CC1NP Bit */ + tmpccer &= (uint16_t)~((uint16_t)TIM_CCER_CC1NP); + tmpccer |= TIM_OCNPolarity; + /* Write to TIMx CCER register */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Configures the TIMx channel 2 polarity. + * @param TIMx: where x can be 1, 2, 3, or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCPolarity: specifies the OC2 Polarity + * This parmeter can be one of the following values: + * @arg TIM_OCPolarity_High: Output Compare active high + * @arg TIM_OCPolarity_Low: Output Compare active low + * @retval None + */ +void TIM_OC2PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity) +{ + uint16_t tmpccer = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_OC_POLARITY(TIM_OCPolarity)); + + tmpccer = TIMx->CCER; + /* Set or Reset the CC2P Bit */ + tmpccer &= (uint16_t)~((uint16_t)TIM_CCER_CC2P); + tmpccer |= (uint16_t)(TIM_OCPolarity << 4); + /* Write to TIMx CCER register */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Configures the TIMx Channel 2N polarity. + * @param TIMx: where x can be 1 to select the TIM peripheral. + * @param TIM_OCNPolarity: specifies the OC2N Polarity + * This parmeter can be one of the following values: + * @arg TIM_OCNPolarity_High: Output Compare active high + * @arg TIM_OCNPolarity_Low: Output Compare active low + * @retval None + */ +void TIM_OC2NPolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCNPolarity) +{ + uint16_t tmpccer = 0; + /* Check the parameters */ + assert_param(IS_TIM_LIST1_PERIPH(TIMx)); + assert_param(IS_TIM_OCN_POLARITY(TIM_OCNPolarity)); + + tmpccer = TIMx->CCER; + /* Set or Reset the CC2NP Bit */ + tmpccer &= (uint16_t)~((uint16_t)TIM_CCER_CC2NP); + tmpccer |= (uint16_t)(TIM_OCNPolarity << 4); + /* Write to TIMx CCER register */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Configures the TIMx channel 3 polarity. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCPolarity: specifies the OC3 Polarity + * This parmeter can be one of the following values: + * @arg TIM_OCPolarity_High: Output Compare active high + * @arg TIM_OCPolarity_Low: Output Compare active low + * @retval None + */ +void TIM_OC3PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity) +{ + uint16_t tmpccer = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_OC_POLARITY(TIM_OCPolarity)); + + tmpccer = TIMx->CCER; + /* Set or Reset the CC3P Bit */ + tmpccer &= (uint16_t)~((uint16_t)TIM_CCER_CC3P); + tmpccer |= (uint16_t)(TIM_OCPolarity << 8); + /* Write to TIMx CCER register */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Configures the TIMx Channel 3N polarity. + * @param TIMx: where x can be 1 to select the TIM peripheral. + * @param TIM_OCNPolarity: specifies the OC3N Polarity + * This parmeter can be one of the following values: + * @arg TIM_OCNPolarity_High: Output Compare active high + * @arg TIM_OCNPolarity_Low: Output Compare active low + * @retval None + */ +void TIM_OC3NPolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCNPolarity) +{ + uint16_t tmpccer = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST1_PERIPH(TIMx)); + assert_param(IS_TIM_OCN_POLARITY(TIM_OCNPolarity)); + + tmpccer = TIMx->CCER; + /* Set or Reset the CC3NP Bit */ + tmpccer &= (uint16_t)~((uint16_t)TIM_CCER_CC3NP); + tmpccer |= (uint16_t)(TIM_OCNPolarity << 8); + /* Write to TIMx CCER register */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Configures the TIMx channel 4 polarity. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCPolarity: specifies the OC4 Polarity + * This parmeter can be one of the following values: + * @arg TIM_OCPolarity_High: Output Compare active high + * @arg TIM_OCPolarity_Low: Output Compare active low + * @retval None + */ +void TIM_OC4PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity) +{ + uint16_t tmpccer = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_OC_POLARITY(TIM_OCPolarity)); + + tmpccer = TIMx->CCER; + /* Set or Reset the CC4P Bit */ + tmpccer &= (uint16_t)~((uint16_t)TIM_CCER_CC4P); + tmpccer |= (uint16_t)(TIM_OCPolarity << 12); + /* Write to TIMx CCER register */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Selects the OCReference Clear source. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCReferenceClear: specifies the OCReference Clear source. + * This parameter can be one of the following values: + * @arg TIM_OCReferenceClear_ETRF: The internal OCreference clear input is connected to ETRF. + * @arg TIM_OCReferenceClear_OCREFCLR: The internal OCreference clear input is connected to OCREF_CLR input. + * @retval None + */ +void TIM_SelectOCREFClear(TIM_TypeDef* TIMx, uint16_t TIM_OCReferenceClear) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(TIM_OCREFERENCECECLEAR_SOURCE(TIM_OCReferenceClear)); + + /* Set the TIM_OCReferenceClear source */ + TIMx->SMCR &= (uint16_t)~((uint16_t)TIM_SMCR_OCCS); + TIMx->SMCR |= TIM_OCReferenceClear; +} + +/** + * @brief Enables or disables the TIM Capture Compare Channel x. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_Channel: specifies the TIM Channel + * This parameter can be one of the following values: + * @arg TIM_Channel_1: TIM Channel 1 + * @arg TIM_Channel_2: TIM Channel 2 + * @arg TIM_Channel_3: TIM Channel 3 + * @arg TIM_Channel_4: TIM Channel 4 + * @param TIM_CCx: specifies the TIM Channel CCxE bit new state. + * This parameter can be: TIM_CCx_Enable or TIM_CCx_Disable. + * @retval None + */ +void TIM_CCxCmd(TIM_TypeDef* TIMx, uint16_t TIM_Channel, uint16_t TIM_CCx) +{ + uint16_t tmp = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_CCX(TIM_CCx)); + + tmp = CCER_CCE_SET << TIM_Channel; + + /* Reset the CCxE Bit */ + TIMx->CCER &= (uint16_t)~ tmp; + + /* Set or reset the CCxE Bit */ + TIMx->CCER |= (uint16_t)(TIM_CCx << TIM_Channel); +} + +/** + * @brief Enables or disables the TIM Capture Compare Channel xN. + * @param TIMx: where x can be 1, 15, 16 or 17 to select the TIM peripheral. + * @param TIM_Channel: specifies the TIM Channel + * This parmeter can be one of the following values: + * @arg TIM_Channel_1: TIM Channel 1 + * @arg TIM_Channel_2: TIM Channel 2 + * @arg TIM_Channel_3: TIM Channel 3 + * @param TIM_CCxN: specifies the TIM Channel CCxNE bit new state. + * This parameter can be: TIM_CCxN_Enable or TIM_CCxN_Disable. + * @retval None + */ +void TIM_CCxNCmd(TIM_TypeDef* TIMx, uint16_t TIM_Channel, uint16_t TIM_CCxN) +{ + uint16_t tmp = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST2_PERIPH(TIMx)); + assert_param(IS_TIM_COMPLEMENTARY_CHANNEL(TIM_Channel)); + assert_param(IS_TIM_CCXN(TIM_CCxN)); + + tmp = CCER_CCNE_SET << TIM_Channel; + + /* Reset the CCxNE Bit */ + TIMx->CCER &= (uint16_t) ~tmp; + + /* Set or reset the CCxNE Bit */ + TIMx->CCER |= (uint16_t)(TIM_CCxN << TIM_Channel); +} + +/** + * @brief Selects the TIM peripheral Commutation event. + * @param TIMx: where x can be 1, 15, 16 or 17 to select the TIMx peripheral + * @param NewState: new state of the Commutation event. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void TIM_SelectCOM(TIM_TypeDef* TIMx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST2_PERIPH(TIMx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + if (NewState != DISABLE) + { + /* Set the COM Bit */ + TIMx->CR2 |= TIM_CR2_CCUS; + } + else + { + /* Reset the COM Bit */ + TIMx->CR2 &= (uint16_t)~((uint16_t)TIM_CR2_CCUS); + } +} + +/** + * @} + */ + +/** @defgroup TIM_Group4 Input Capture management functions + * @brief Input Capture management functions + * +@verbatim + =============================================================================== + ##### Input Capture management functions ##### + =============================================================================== + + *** TIM Driver: how to use it in Input Capture Mode *** + =============================================================================== + [..] To use the Timer in Input Capture mode, the following steps are mandatory: + (#) Enable TIM clock using RCC_APBxPeriphClockCmd(RCC_APBxPeriph_TIMx, ENABLE) + function. + (#) Configure the TIM pins by configuring the corresponding GPIO pins. + (#) Configure the Time base unit as described in the first part of this + driver, if needed, else the Timer will run with the default configuration: + (++) Autoreload value = 0xFFFF. + (++) Prescaler value = 0x0000. + (++) Counter mode = Up counting. + (++) Clock Division = TIM_CKD_DIV1. + (#) Fill the TIM_ICInitStruct with the desired parameters including: + (++) TIM Channel: TIM_Channel. + (++) TIM Input Capture polarity: TIM_ICPolarity. + (++) TIM Input Capture selection: TIM_ICSelection. + (++) TIM Input Capture Prescaler: TIM_ICPrescaler. + (++) TIM Input CApture filter value: TIM_ICFilter. + (#) Call TIM_ICInit(TIMx, &TIM_ICInitStruct) to configure the desired + channel with the corresponding configuration and to measure only + frequency or duty cycle of the input signal,or, Call + TIM_PWMIConfig(TIMx, &TIM_ICInitStruct) to configure the desired + channels with the corresponding configuration and to measure the + frequency and the duty cycle of the input signal. + (#) Enable the NVIC or the DMA to read the measured frequency. + (#) Enable the corresponding interrupt (or DMA request) to read + the Captured value, using the function TIM_ITConfig(TIMx, TIM_IT_CCx) + (or TIM_DMA_Cmd(TIMx, TIM_DMA_CCx)). + (#) Call the TIM_Cmd(ENABLE) function to enable the TIM counter. + (#) Use TIM_GetCapturex(TIMx); to read the captured value. + [..] + (@) All other functions can be used separately to modify, if needed, + a specific feature of the Timer. + +@endverbatim + * @{ + */ + +/** + * @brief Initializes the TIM peripheral according to the specified + * parameters in the TIM_ICInitStruct. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ICInitStruct: pointer to a TIM_ICInitTypeDef structure + * that contains the configuration information for the specified TIM + * peripheral. + * @retval None + */ +void TIM_ICInit(TIM_TypeDef* TIMx, TIM_ICInitTypeDef* TIM_ICInitStruct) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_CHANNEL(TIM_ICInitStruct->TIM_Channel)); + assert_param(IS_TIM_IC_SELECTION(TIM_ICInitStruct->TIM_ICSelection)); + assert_param(IS_TIM_IC_PRESCALER(TIM_ICInitStruct->TIM_ICPrescaler)); + assert_param(IS_TIM_IC_FILTER(TIM_ICInitStruct->TIM_ICFilter)); + assert_param(IS_TIM_IC_POLARITY(TIM_ICInitStruct->TIM_ICPolarity)); + + if (TIM_ICInitStruct->TIM_Channel == TIM_Channel_1) + { + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + /* TI1 Configuration */ + TI1_Config(TIMx, TIM_ICInitStruct->TIM_ICPolarity, + TIM_ICInitStruct->TIM_ICSelection, + TIM_ICInitStruct->TIM_ICFilter); + /* Set the Input Capture Prescaler value */ + TIM_SetIC1Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler); + } + else if (TIM_ICInitStruct->TIM_Channel == TIM_Channel_2) + { + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + /* TI2 Configuration */ + TI2_Config(TIMx, TIM_ICInitStruct->TIM_ICPolarity, + TIM_ICInitStruct->TIM_ICSelection, + TIM_ICInitStruct->TIM_ICFilter); + /* Set the Input Capture Prescaler value */ + TIM_SetIC2Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler); + } + else if (TIM_ICInitStruct->TIM_Channel == TIM_Channel_3) + { + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + /* TI3 Configuration */ + TI3_Config(TIMx, TIM_ICInitStruct->TIM_ICPolarity, + TIM_ICInitStruct->TIM_ICSelection, + TIM_ICInitStruct->TIM_ICFilter); + /* Set the Input Capture Prescaler value */ + TIM_SetIC3Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler); + } + else + { + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + /* TI4 Configuration */ + TI4_Config(TIMx, TIM_ICInitStruct->TIM_ICPolarity, + TIM_ICInitStruct->TIM_ICSelection, + TIM_ICInitStruct->TIM_ICFilter); + /* Set the Input Capture Prescaler value */ + TIM_SetIC4Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler); + } +} + +/** + * @brief Fills each TIM_ICInitStruct member with its default value. + * @param TIM_ICInitStruct: pointer to a TIM_ICInitTypeDef structure which will + * be initialized. + * @retval None + */ +void TIM_ICStructInit(TIM_ICInitTypeDef* TIM_ICInitStruct) +{ + /* Set the default configuration */ + TIM_ICInitStruct->TIM_Channel = TIM_Channel_1; + TIM_ICInitStruct->TIM_ICPolarity = TIM_ICPolarity_Rising; + TIM_ICInitStruct->TIM_ICSelection = TIM_ICSelection_DirectTI; + TIM_ICInitStruct->TIM_ICPrescaler = TIM_ICPSC_DIV1; + TIM_ICInitStruct->TIM_ICFilter = 0x00; +} + +/** + * @brief Configures the TIM peripheral according to the specified + * parameters in the TIM_ICInitStruct to measure an external PWM signal. + * @param TIMx: where x can be 1, 2, 3 or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ICInitStruct: pointer to a TIM_ICInitTypeDef structure + * that contains the configuration information for the specified TIM + * peripheral. + * @retval None + */ +void TIM_PWMIConfig(TIM_TypeDef* TIMx, TIM_ICInitTypeDef* TIM_ICInitStruct) +{ + uint16_t icoppositepolarity = TIM_ICPolarity_Rising; + uint16_t icoppositeselection = TIM_ICSelection_DirectTI; + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + /* Select the Opposite Input Polarity */ + if (TIM_ICInitStruct->TIM_ICPolarity == TIM_ICPolarity_Rising) + { + icoppositepolarity = TIM_ICPolarity_Falling; + } + else + { + icoppositepolarity = TIM_ICPolarity_Rising; + } + /* Select the Opposite Input */ + if (TIM_ICInitStruct->TIM_ICSelection == TIM_ICSelection_DirectTI) + { + icoppositeselection = TIM_ICSelection_IndirectTI; + } + else + { + icoppositeselection = TIM_ICSelection_DirectTI; + } + if (TIM_ICInitStruct->TIM_Channel == TIM_Channel_1) + { + /* TI1 Configuration */ + TI1_Config(TIMx, TIM_ICInitStruct->TIM_ICPolarity, TIM_ICInitStruct->TIM_ICSelection, + TIM_ICInitStruct->TIM_ICFilter); + /* Set the Input Capture Prescaler value */ + TIM_SetIC1Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler); + /* TI2 Configuration */ + TI2_Config(TIMx, icoppositepolarity, icoppositeselection, TIM_ICInitStruct->TIM_ICFilter); + /* Set the Input Capture Prescaler value */ + TIM_SetIC2Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler); + } + else + { + /* TI2 Configuration */ + TI2_Config(TIMx, TIM_ICInitStruct->TIM_ICPolarity, TIM_ICInitStruct->TIM_ICSelection, + TIM_ICInitStruct->TIM_ICFilter); + /* Set the Input Capture Prescaler value */ + TIM_SetIC2Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler); + /* TI1 Configuration */ + TI1_Config(TIMx, icoppositepolarity, icoppositeselection, TIM_ICInitStruct->TIM_ICFilter); + /* Set the Input Capture Prescaler value */ + TIM_SetIC1Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler); + } +} + +/** + * @brief Gets the TIMx Input Capture 1 value. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @retval Capture Compare 1 Register value. + */ +uint32_t TIM_GetCapture1(TIM_TypeDef* TIMx) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + + /* Get the Capture 1 Register value */ + return TIMx->CCR1; +} + +/** + * @brief Gets the TIMx Input Capture 2 value. + * @param TIMx: where x can be 1, 2, 3 or 15 to select the TIM peripheral. + * @retval Capture Compare 2 Register value. + */ +uint32_t TIM_GetCapture2(TIM_TypeDef* TIMx) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + + /* Get the Capture 2 Register value */ + return TIMx->CCR2; +} + +/** + * @brief Gets the TIMx Input Capture 3 value. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @retval Capture Compare 3 Register value. + */ +uint32_t TIM_GetCapture3(TIM_TypeDef* TIMx) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + + /* Get the Capture 3 Register value */ + return TIMx->CCR3; +} + +/** + * @brief Gets the TIMx Input Capture 4 value. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @retval Capture Compare 4 Register value. + */ +uint32_t TIM_GetCapture4(TIM_TypeDef* TIMx) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + + /* Get the Capture 4 Register value */ + return TIMx->CCR4; +} + +/** + * @brief Sets the TIMx Input Capture 1 prescaler. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ICPSC: specifies the Input Capture1 prescaler new value. + * This parameter can be one of the following values: + * @arg TIM_ICPSC_DIV1: no prescaler + * @arg TIM_ICPSC_DIV2: capture is done once every 2 events + * @arg TIM_ICPSC_DIV4: capture is done once every 4 events + * @arg TIM_ICPSC_DIV8: capture is done once every 8 events + * @retval None + */ +void TIM_SetIC1Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_IC_PRESCALER(TIM_ICPSC)); + + /* Reset the IC1PSC Bits */ + TIMx->CCMR1 &= (uint16_t)~((uint16_t)TIM_CCMR1_IC1PSC); + /* Set the IC1PSC value */ + TIMx->CCMR1 |= TIM_ICPSC; +} + +/** + * @brief Sets the TIMx Input Capture 2 prescaler. + * @param TIMx: where x can be 1, 2, 3 or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ICPSC: specifies the Input Capture2 prescaler new value. + * This parameter can be one of the following values: + * @arg TIM_ICPSC_DIV1: no prescaler + * @arg TIM_ICPSC_DIV2: capture is done once every 2 events + * @arg TIM_ICPSC_DIV4: capture is done once every 4 events + * @arg TIM_ICPSC_DIV8: capture is done once every 8 events + * @retval None + */ +void TIM_SetIC2Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_IC_PRESCALER(TIM_ICPSC)); + + /* Reset the IC2PSC Bits */ + TIMx->CCMR1 &= (uint16_t)~((uint16_t)TIM_CCMR1_IC2PSC); + /* Set the IC2PSC value */ + TIMx->CCMR1 |= (uint16_t)(TIM_ICPSC << 8); +} + +/** + * @brief Sets the TIMx Input Capture 3 prescaler. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ICPSC: specifies the Input Capture3 prescaler new value. + * This parameter can be one of the following values: + * @arg TIM_ICPSC_DIV1: no prescaler + * @arg TIM_ICPSC_DIV2: capture is done once every 2 events + * @arg TIM_ICPSC_DIV4: capture is done once every 4 events + * @arg TIM_ICPSC_DIV8: capture is done once every 8 events + * @retval None + */ +void TIM_SetIC3Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_IC_PRESCALER(TIM_ICPSC)); + + /* Reset the IC3PSC Bits */ + TIMx->CCMR2 &= (uint16_t)~((uint16_t)TIM_CCMR2_IC3PSC); + /* Set the IC3PSC value */ + TIMx->CCMR2 |= TIM_ICPSC; +} + +/** + * @brief Sets the TIMx Input Capture 4 prescaler. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ICPSC: specifies the Input Capture4 prescaler new value. + * This parameter can be one of the following values: + * @arg TIM_ICPSC_DIV1: no prescaler + * @arg TIM_ICPSC_DIV2: capture is done once every 2 events + * @arg TIM_ICPSC_DIV4: capture is done once every 4 events + * @arg TIM_ICPSC_DIV8: capture is done once every 8 events + * @retval None + */ +void TIM_SetIC4Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_IC_PRESCALER(TIM_ICPSC)); + + /* Reset the IC4PSC Bits */ + TIMx->CCMR2 &= (uint16_t)~((uint16_t)TIM_CCMR2_IC4PSC); + /* Set the IC4PSC value */ + TIMx->CCMR2 |= (uint16_t)(TIM_ICPSC << 8); +} + +/** + * @} + */ + +/** @defgroup TIM_Group5 Interrupts DMA and flags management functions + * @brief Interrupts, DMA and flags management functions + * +@verbatim + =============================================================================== + ##### Interrupts, DMA and flags management functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified TIM interrupts. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 or 17 to select the TIMx peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_IT: specifies the TIM interrupts sources to be enabled or disabled. + * This parameter can be any combination of the following values: + * @arg TIM_IT_Update: TIM update Interrupt source + * @arg TIM_IT_CC1: TIM Capture Compare 1 Interrupt source + * @arg TIM_IT_CC2: TIM Capture Compare 2 Interrupt source + * @arg TIM_IT_CC3: TIM Capture Compare 3 Interrupt source + * @arg TIM_IT_CC4: TIM Capture Compare 4 Interrupt source + * @arg TIM_IT_COM: TIM Commutation Interrupt source + * @arg TIM_IT_Trigger: TIM Trigger Interrupt source + * @arg TIM_IT_Break: TIM Break Interrupt source + * + * @note TIM6 and TIM7 can only generate an update interrupt. + * @note TIM15 can have only TIM_IT_Update, TIM_IT_CC1,TIM_IT_CC2 or TIM_IT_Trigger. + * @note TIM14, TIM16 and TIM17 can have TIM_IT_Update or TIM_IT_CC1. + * @note TIM_IT_Break is used only with TIM1 and TIM15. + * @note TIM_IT_COM is used only with TIM1, TIM15, TIM16 and TIM17. + * + * @param NewState: new state of the TIM interrupts. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void TIM_ITConfig(TIM_TypeDef* TIMx, uint16_t TIM_IT, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_TIM_IT(TIM_IT)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the Interrupt sources */ + TIMx->DIER |= TIM_IT; + } + else + { + /* Disable the Interrupt sources */ + TIMx->DIER &= (uint16_t)~TIM_IT; + } +} + +/** + * @brief Configures the TIMx event to be generate by software. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 or 17 to select the + * TIM peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_EventSource: specifies the event source. + * This parameter can be one or more of the following values: + * @arg TIM_EventSource_Update: Timer update Event source + * @arg TIM_EventSource_CC1: Timer Capture Compare 1 Event source + * @arg TIM_EventSource_CC2: Timer Capture Compare 2 Event source + * @arg TIM_EventSource_CC3: Timer Capture Compare 3 Event source + * @arg TIM_EventSource_CC4: Timer Capture Compare 4 Event source + * @arg TIM_EventSource_COM: Timer COM event source + * @arg TIM_EventSource_Trigger: Timer Trigger Event source + * @arg TIM_EventSource_Break: Timer Break event source + * + * @note TIM6 and TIM7 can only generate an update event. + * @note TIM_EventSource_COM and TIM_EventSource_Break are used only with TIM1. + * + * @retval None + */ +void TIM_GenerateEvent(TIM_TypeDef* TIMx, uint16_t TIM_EventSource) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_TIM_EVENT_SOURCE(TIM_EventSource)); + /* Set the event sources */ + TIMx->EGR = TIM_EventSource; +} + +/** + * @brief Checks whether the specified TIM flag is set or not. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg TIM_FLAG_Update: TIM update Flag + * @arg TIM_FLAG_CC1: TIM Capture Compare 1 Flag + * @arg TIM_FLAG_CC2: TIM Capture Compare 2 Flag + * @arg TIM_FLAG_CC3: TIM Capture Compare 3 Flag + * @arg TIM_FLAG_CC4: TIM Capture Compare 4 Flag + * @arg TIM_FLAG_COM: TIM Commutation Flag + * @arg TIM_FLAG_Trigger: TIM Trigger Flag + * @arg TIM_FLAG_Break: TIM Break Flag + * @arg TIM_FLAG_CC1OF: TIM Capture Compare 1 overcapture Flag + * @arg TIM_FLAG_CC2OF: TIM Capture Compare 2 overcapture Flag + * @arg TIM_FLAG_CC3OF: TIM Capture Compare 3 overcapture Flag + * @arg TIM_FLAG_CC4OF: TIM Capture Compare 4 overcapture Flag + * + * @note TIM6 and TIM7 can have only one update flag. + * @note TIM15 can have only TIM_FLAG_Update, TIM_FLAG_CC1, TIM_FLAG_CC2 or TIM_FLAG_Trigger. + * @note TIM14, TIM16 and TIM17 can have TIM_FLAG_Update or TIM_FLAG_CC1. + * @note TIM_FLAG_Break is used only with TIM1 and TIM15. + * @note TIM_FLAG_COM is used only with TIM1 TIM15, TIM16 and TIM17. + * + * @retval The new state of TIM_FLAG (SET or RESET). + */ +FlagStatus TIM_GetFlagStatus(TIM_TypeDef* TIMx, uint16_t TIM_FLAG) +{ + ITStatus bitstatus = RESET; + + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_TIM_GET_FLAG(TIM_FLAG)); + + if ((TIMx->SR & TIM_FLAG) != (uint16_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + return bitstatus; +} + +/** + * @brief Clears the TIMx's pending flags. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_FLAG: specifies the flag bit to clear. + * This parameter can be any combination of the following values: + * @arg TIM_FLAG_Update: TIM update Flag + * @arg TIM_FLAG_CC1: TIM Capture Compare 1 Flag + * @arg TIM_FLAG_CC2: TIM Capture Compare 2 Flag + * @arg TIM_FLAG_CC3: TIM Capture Compare 3 Flag + * @arg TIM_FLAG_CC4: TIM Capture Compare 4 Flag + * @arg TIM_FLAG_COM: TIM Commutation Flag + * @arg TIM_FLAG_Trigger: TIM Trigger Flag + * @arg TIM_FLAG_Break: TIM Break Flag + * @arg TIM_FLAG_CC1OF: TIM Capture Compare 1 overcapture Flag + * @arg TIM_FLAG_CC2OF: TIM Capture Compare 2 overcapture Flag + * @arg TIM_FLAG_CC3OF: TIM Capture Compare 3 overcapture Flag + * @arg TIM_FLAG_CC4OF: TIM Capture Compare 4 overcapture Flag + * + * @note TIM6 and TIM7 can have only one update flag. + * @note TIM15 can have only TIM_FLAG_Update, TIM_FLAG_CC1,TIM_FLAG_CC2 or + * TIM_FLAG_Trigger. + * @note TIM14, TIM16 and TIM17 can have TIM_FLAG_Update or TIM_FLAG_CC1. + * @note TIM_FLAG_Break is used only with TIM1 and TIM15. + * @note TIM_FLAG_COM is used only with TIM1, TIM15, TIM16 and TIM17. + * + * @retval None + */ +void TIM_ClearFlag(TIM_TypeDef* TIMx, uint16_t TIM_FLAG) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_TIM_CLEAR_FLAG(TIM_FLAG)); + + /* Clear the flags */ + TIMx->SR = (uint16_t)~TIM_FLAG; +} + +/** + * @brief Checks whether the TIM interrupt has occurred or not. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_IT: specifies the TIM interrupt source to check. + * This parameter can be one of the following values: + * @arg TIM_IT_Update: TIM update Interrupt source + * @arg TIM_IT_CC1: TIM Capture Compare 1 Interrupt source + * @arg TIM_IT_CC2: TIM Capture Compare 2 Interrupt source + * @arg TIM_IT_CC3: TIM Capture Compare 3 Interrupt source + * @arg TIM_IT_CC4: TIM Capture Compare 4 Interrupt source + * @arg TIM_IT_COM: TIM Commutation Interrupt source + * @arg TIM_IT_Trigger: TIM Trigger Interrupt source + * @arg TIM_IT_Break: TIM Break Interrupt source + * + * @note TIM6 and TIM7 can generate only an update interrupt. + * @note TIM15 can have only TIM_IT_Update, TIM_IT_CC1, TIM_IT_CC2 or TIM_IT_Trigger. + * @note TIM14, TIM16 and TIM17 can have TIM_IT_Update or TIM_IT_CC1. + * @note TIM_IT_Break is used only with TIM1 and TIM15. + * @note TIM_IT_COM is used only with TIM1, TIM15, TIM16 and TIM17. + * + * @retval The new state of the TIM_IT(SET or RESET). + */ +ITStatus TIM_GetITStatus(TIM_TypeDef* TIMx, uint16_t TIM_IT) +{ + ITStatus bitstatus = RESET; + uint16_t itstatus = 0x0, itenable = 0x0; + + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_TIM_GET_IT(TIM_IT)); + + itstatus = TIMx->SR & TIM_IT; + + itenable = TIMx->DIER & TIM_IT; + if ((itstatus != (uint16_t)RESET) && (itenable != (uint16_t)RESET)) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + return bitstatus; +} + +/** + * @brief Clears the TIMx's interrupt pending bits. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_IT: specifies the pending bit to clear. + * This parameter can be any combination of the following values: + * @arg TIM_IT_Update: TIM1 update Interrupt source + * @arg TIM_IT_CC1: TIM Capture Compare 1 Interrupt source + * @arg TIM_IT_CC2: TIM Capture Compare 2 Interrupt source + * @arg TIM_IT_CC3: TIM Capture Compare 3 Interrupt source + * @arg TIM_IT_CC4: TIM Capture Compare 4 Interrupt source + * @arg TIM_IT_COM: TIM Commutation Interrupt source + * @arg TIM_IT_Trigger: TIM Trigger Interrupt source + * @arg TIM_IT_Break: TIM Break Interrupt source + * + * @note TIM6 and TIM7 can generate only an update interrupt. + * @note TIM15 can have only TIM_IT_Update, TIM_IT_CC1, TIM_IT_CC2 or TIM_IT_Trigger. + * @note TIM14, TIM16 and TIM17 can have TIM_IT_Update or TIM_IT_CC1. + * @note TIM_IT_Break is used only with TIM1 and TIM15. + * @note TIM_IT_COM is used only with TIM1, TIM15, TIM16 and TIM17. + * + * @retval None + */ +void TIM_ClearITPendingBit(TIM_TypeDef* TIMx, uint16_t TIM_IT) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_TIM_IT(TIM_IT)); + + /* Clear the IT pending Bit */ + TIMx->SR = (uint16_t)~TIM_IT; +} + +/** + * @brief Configures the TIMx's DMA interface. + * @param TIMx: where x can be 1, 2, 3, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_DMABase: DMA Base address. + * This parameter can be one of the following values: + * @arg TIM_DMABase_CR1 + * @arg TIM_DMABase_CR2 + * @arg TIM_DMABase_SMCR + * @arg TIM_DMABase_DIER + * @arg TIM_DMABase_SR + * @arg TIM_DMABase_EGR + * @arg TIM_DMABase_CCMR1 + * @arg TIM_DMABase_CCMR2 + * @arg TIM_DMABase_CCER + * @arg TIM_DMABase_CNT + * @arg TIM_DMABase_PSC + * @arg TIM_DMABase_ARR + * @arg TIM_DMABase_CCR1 + * @arg TIM_DMABase_CCR2 + * @arg TIM_DMABase_CCR3 + * @arg TIM_DMABase_CCR4 + * @arg TIM_DMABase_DCR + * @arg TIM_DMABase_OR + * @param TIM_DMABurstLength: DMA Burst length. This parameter can be one value + * between: TIM_DMABurstLength_1Transfer and TIM_DMABurstLength_18Transfers. + * @retval None + */ +void TIM_DMAConfig(TIM_TypeDef* TIMx, uint16_t TIM_DMABase, uint16_t TIM_DMABurstLength) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_DMA_BASE(TIM_DMABase)); + assert_param(IS_TIM_DMA_LENGTH(TIM_DMABurstLength)); + /* Set the DMA Base and the DMA Burst Length */ + TIMx->DCR = TIM_DMABase | TIM_DMABurstLength; +} + +/** + * @brief Enables or disables the TIMx's DMA Requests. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 15, 16 or 17 to select the TIM peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_DMASource: specifies the DMA Request sources. + * This parameter can be any combination of the following values: + * @arg TIM_DMA_Update: TIM update Interrupt source + * @arg TIM_DMA_CC1: TIM Capture Compare 1 DMA source + * @arg TIM_DMA_CC2: TIM Capture Compare 2 DMA source + * @arg TIM_DMA_CC3: TIM Capture Compare 3 DMA source + * @arg TIM_DMA_CC4: TIM Capture Compare 4 DMA source + * @arg TIM_DMA_COM: TIM Commutation DMA source + * @arg TIM_DMA_Trigger: TIM Trigger DMA source + * @param NewState: new state of the DMA Request sources. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void TIM_DMACmd(TIM_TypeDef* TIMx, uint16_t TIM_DMASource, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST10_PERIPH(TIMx)); + assert_param(IS_TIM_DMA_SOURCE(TIM_DMASource)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the DMA sources */ + TIMx->DIER |= TIM_DMASource; + } + else + { + /* Disable the DMA sources */ + TIMx->DIER &= (uint16_t)~TIM_DMASource; + } +} + +/** + * @brief Selects the TIMx peripheral Capture Compare DMA source. + * @param TIMx: where x can be 1, 2, 3, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param NewState: new state of the Capture Compare DMA source + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void TIM_SelectCCDMA(TIM_TypeDef* TIMx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST5_PERIPH(TIMx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Set the CCDS Bit */ + TIMx->CR2 |= TIM_CR2_CCDS; + } + else + { + /* Reset the CCDS Bit */ + TIMx->CR2 &= (uint16_t)~((uint16_t)TIM_CR2_CCDS); + } +} + +/** + * @} + */ + +/** @defgroup TIM_Group6 Clocks management functions + * @brief Clocks management functions + * +@verbatim + =============================================================================== + ##### Clocks management functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Configures the TIMx internal Clock + * @param TIMx: where x can be 1, 2, 3, or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @retval None + */ +void TIM_InternalClockConfig(TIM_TypeDef* TIMx) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + /* Disable slave mode to clock the prescaler directly with the internal clock */ + TIMx->SMCR &= (uint16_t)(~((uint16_t)TIM_SMCR_SMS)); +} + +/** + * @brief Configures the TIMx Internal Trigger as External Clock + * @param TIMx: where x can be 1, 2, 3, or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ITRSource: Trigger source. + * This parameter can be one of the following values: + * @arg TIM_TS_ITR0: Internal Trigger 0 + * @arg TIM_TS_ITR1: Internal Trigger 1 + * @arg TIM_TS_ITR2: Internal Trigger 2 + * @arg TIM_TS_ITR3: Internal Trigger 3 + * @retval None + */ +void TIM_ITRxExternalClockConfig(TIM_TypeDef* TIMx, uint16_t TIM_InputTriggerSource) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_INTERNAL_TRIGGER_SELECTION(TIM_InputTriggerSource)); + /* Select the Internal Trigger */ + TIM_SelectInputTrigger(TIMx, TIM_InputTriggerSource); + /* Select the External clock mode1 */ + TIMx->SMCR |= TIM_SlaveMode_External1; +} + +/** + * @brief Configures the TIMx Trigger as External Clock + * @param TIMx: where x can be 1, 2, 3, or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_TIxExternalCLKSource: Trigger source. + * This parameter can be one of the following values: + * @arg TIM_TIxExternalCLK1Source_TI1ED: TI1 Edge Detector + * @arg TIM_TIxExternalCLK1Source_TI1: Filtered Timer Input 1 + * @arg TIM_TIxExternalCLK1Source_TI2: Filtered Timer Input 2 + * @param TIM_ICPolarity: specifies the TIx Polarity. + * This parameter can be one of the following values: + * @arg TIM_ICPolarity_Rising + * @arg TIM_ICPolarity_Falling + * @param ICFilter: specifies the filter value. + * This parameter must be a value between 0x0 and 0xF. + * @retval None + */ +void TIM_TIxExternalClockConfig(TIM_TypeDef* TIMx, uint16_t TIM_TIxExternalCLKSource, + uint16_t TIM_ICPolarity, uint16_t ICFilter) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_IC_POLARITY(TIM_ICPolarity)); + assert_param(IS_TIM_IC_FILTER(ICFilter)); + + /* Configure the Timer Input Clock Source */ + if (TIM_TIxExternalCLKSource == TIM_TIxExternalCLK1Source_TI2) + { + TI2_Config(TIMx, TIM_ICPolarity, TIM_ICSelection_DirectTI, ICFilter); + } + else + { + TI1_Config(TIMx, TIM_ICPolarity, TIM_ICSelection_DirectTI, ICFilter); + } + /* Select the Trigger source */ + TIM_SelectInputTrigger(TIMx, TIM_TIxExternalCLKSource); + /* Select the External clock mode1 */ + TIMx->SMCR |= TIM_SlaveMode_External1; +} + +/** + * @brief Configures the External clock Mode1 + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ExtTRGPrescaler: The external Trigger Prescaler. + * This parameter can be one of the following values: + * @arg TIM_ExtTRGPSC_OFF: ETRP Prescaler OFF. + * @arg TIM_ExtTRGPSC_DIV2: ETRP frequency divided by 2. + * @arg TIM_ExtTRGPSC_DIV4: ETRP frequency divided by 4. + * @arg TIM_ExtTRGPSC_DIV8: ETRP frequency divided by 8. + * @param TIM_ExtTRGPolarity: The external Trigger Polarity. + * This parameter can be one of the following values: + * @arg TIM_ExtTRGPolarity_Inverted: active low or falling edge active. + * @arg TIM_ExtTRGPolarity_NonInverted: active high or rising edge active. + * @param ExtTRGFilter: External Trigger Filter. + * This parameter must be a value between 0x00 and 0x0F + * @retval None + */ +void TIM_ETRClockMode1Config(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, uint16_t TIM_ExtTRGPolarity, + uint16_t ExtTRGFilter) +{ + uint16_t tmpsmcr = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_EXT_PRESCALER(TIM_ExtTRGPrescaler)); + assert_param(IS_TIM_EXT_POLARITY(TIM_ExtTRGPolarity)); + assert_param(IS_TIM_EXT_FILTER(ExtTRGFilter)); + + /* Configure the ETR Clock source */ + TIM_ETRConfig(TIMx, TIM_ExtTRGPrescaler, TIM_ExtTRGPolarity, ExtTRGFilter); + + /* Get the TIMx SMCR register value */ + tmpsmcr = TIMx->SMCR; + /* Reset the SMS Bits */ + tmpsmcr &= (uint16_t)(~((uint16_t)TIM_SMCR_SMS)); + /* Select the External clock mode1 */ + tmpsmcr |= TIM_SlaveMode_External1; + /* Select the Trigger selection : ETRF */ + tmpsmcr &= (uint16_t)(~((uint16_t)TIM_SMCR_TS)); + tmpsmcr |= TIM_TS_ETRF; + /* Write to TIMx SMCR */ + TIMx->SMCR = tmpsmcr; +} + +/** + * @brief Configures the External clock Mode2 + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ExtTRGPrescaler: The external Trigger Prescaler. + * This parameter can be one of the following values: + * @arg TIM_ExtTRGPSC_OFF: ETRP Prescaler OFF. + * @arg TIM_ExtTRGPSC_DIV2: ETRP frequency divided by 2. + * @arg TIM_ExtTRGPSC_DIV4: ETRP frequency divided by 4. + * @arg TIM_ExtTRGPSC_DIV8: ETRP frequency divided by 8. + * @param TIM_ExtTRGPolarity: The external Trigger Polarity. + * This parameter can be one of the following values: + * @arg TIM_ExtTRGPolarity_Inverted: active low or falling edge active. + * @arg TIM_ExtTRGPolarity_NonInverted: active high or rising edge active. + * @param ExtTRGFilter: External Trigger Filter. + * This parameter must be a value between 0x00 and 0x0F + * @retval None + */ +void TIM_ETRClockMode2Config(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, + uint16_t TIM_ExtTRGPolarity, uint16_t ExtTRGFilter) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_EXT_PRESCALER(TIM_ExtTRGPrescaler)); + assert_param(IS_TIM_EXT_POLARITY(TIM_ExtTRGPolarity)); + assert_param(IS_TIM_EXT_FILTER(ExtTRGFilter)); + + /* Configure the ETR Clock source */ + TIM_ETRConfig(TIMx, TIM_ExtTRGPrescaler, TIM_ExtTRGPolarity, ExtTRGFilter); + /* Enable the External clock mode2 */ + TIMx->SMCR |= TIM_SMCR_ECE; +} + +/** + * @} + */ + +/** @defgroup TIM_Group7 Synchronization management functions + * @brief Synchronization management functions + * +@verbatim + =============================================================================== + ##### Synchronization management functions ##### + =============================================================================== + *** TIM Driver: how to use it in synchronization Mode *** + =============================================================================== + [..] Case of two/several Timers + (#) Configure the Master Timers using the following functions: + (++) void TIM_SelectOutputTrigger(TIM_TypeDef* TIMx, + uint16_t TIM_TRGOSource). + (++) void TIM_SelectMasterSlaveMode(TIM_TypeDef* TIMx, + uint16_t TIM_MasterSlaveMode); + (#) Configure the Slave Timers using the following functions: + (++) void TIM_SelectInputTrigger(TIM_TypeDef* TIMx, + uint16_t TIM_InputTriggerSource); + (++) void TIM_SelectSlaveMode(TIM_TypeDef* TIMx, uint16_t TIM_SlaveMode); + [..] Case of Timers and external trigger(ETR pin) + (#) Configure the Etrenal trigger using this function: + (++) void TIM_ETRConfig(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, + uint16_t TIM_ExtTRGPolarity, uint16_t ExtTRGFilter); + (#) Configure the Slave Timers using the following functions: + (++) void TIM_SelectInputTrigger(TIM_TypeDef* TIMx, + uint16_t TIM_InputTriggerSource); + (++) void TIM_SelectSlaveMode(TIM_TypeDef* TIMx, uint16_t TIM_SlaveMode); + +@endverbatim + * @{ + */ +/** + * @brief Selects the Input Trigger source + * @param TIMx: where x can be 1, 2, 3 or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_InputTriggerSource: The Input Trigger source. + * This parameter can be one of the following values: + * @arg TIM_TS_ITR0: Internal Trigger 0 + * @arg TIM_TS_ITR1: Internal Trigger 1 + * @arg TIM_TS_ITR2: Internal Trigger 2 + * @arg TIM_TS_ITR3: Internal Trigger 3 + * @arg TIM_TS_TI1F_ED: TI1 Edge Detector + * @arg TIM_TS_TI1FP1: Filtered Timer Input 1 + * @arg TIM_TS_TI2FP2: Filtered Timer Input 2 + * @arg TIM_TS_ETRF: External Trigger input + * @retval None + */ +void TIM_SelectInputTrigger(TIM_TypeDef* TIMx, uint16_t TIM_InputTriggerSource) +{ + uint16_t tmpsmcr = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_TRIGGER_SELECTION(TIM_InputTriggerSource)); + + /* Get the TIMx SMCR register value */ + tmpsmcr = TIMx->SMCR; + /* Reset the TS Bits */ + tmpsmcr &= (uint16_t)(~((uint16_t)TIM_SMCR_TS)); + /* Set the Input Trigger source */ + tmpsmcr |= TIM_InputTriggerSource; + /* Write to TIMx SMCR */ + TIMx->SMCR = tmpsmcr; +} + +/** + * @brief Selects the TIMx Trigger Output Mode. + * @param TIMx: where x can be 1, 2, 3, 6, 7, or 15 to select the TIM peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_TRGOSource: specifies the Trigger Output source. + * This parameter can be one of the following values: + * + * - For all TIMx + * @arg TIM_TRGOSource_Reset: The UG bit in the TIM_EGR register is used as the trigger output (TRGO). + * @arg TIM_TRGOSource_Enable: The Counter Enable CEN is used as the trigger output (TRGO). + * @arg TIM_TRGOSource_Update: The update event is selected as the trigger output (TRGO). + * + * - For all TIMx except TIM6 and TIM7 + * @arg TIM_TRGOSource_OC1: The trigger output sends a positive pulse when the CC1IF flag + * is to be set, as soon as a capture or compare match occurs (TRGO). + * @arg TIM_TRGOSource_OC1Ref: OC1REF signal is used as the trigger output (TRGO). + * @arg TIM_TRGOSource_OC2Ref: OC2REF signal is used as the trigger output (TRGO). + * @arg TIM_TRGOSource_OC3Ref: OC3REF signal is used as the trigger output (TRGO). + * @arg TIM_TRGOSource_OC4Ref: OC4REF signal is used as the trigger output (TRGO). + * + * @retval None + */ +void TIM_SelectOutputTrigger(TIM_TypeDef* TIMx, uint16_t TIM_TRGOSource) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST9_PERIPH(TIMx)); + assert_param(IS_TIM_TRGO_SOURCE(TIM_TRGOSource)); + + /* Reset the MMS Bits */ + TIMx->CR2 &= (uint16_t)~((uint16_t)TIM_CR2_MMS); + /* Select the TRGO source */ + TIMx->CR2 |= TIM_TRGOSource; +} + +/** + * @brief Selects the TIMx Slave Mode. + * @param TIMx: where x can be 1, 2, 3 or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_SlaveMode: specifies the Timer Slave Mode. + * This parameter can be one of the following values: + * @arg TIM_SlaveMode_Reset: Rising edge of the selected trigger signal (TRGI) re-initializes + * the counter and triggers an update of the registers. + * @arg TIM_SlaveMode_Gated: The counter clock is enabled when the trigger signal (TRGI) is high. + * @arg TIM_SlaveMode_Trigger: The counter starts at a rising edge of the trigger TRGI. + * @arg TIM_SlaveMode_External1: Rising edges of the selected trigger (TRGI) clock the counter. + * @retval None + */ +void TIM_SelectSlaveMode(TIM_TypeDef* TIMx, uint16_t TIM_SlaveMode) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_SLAVE_MODE(TIM_SlaveMode)); + + /* Reset the SMS Bits */ + TIMx->SMCR &= (uint16_t)~((uint16_t)TIM_SMCR_SMS); + /* Select the Slave Mode */ + TIMx->SMCR |= TIM_SlaveMode; +} + +/** + * @brief Sets or Resets the TIMx Master/Slave Mode. + * @param TIMx: where x can be 1, 2, 3, or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_MasterSlaveMode: specifies the Timer Master Slave Mode. + * This parameter can be one of the following values: + * @arg TIM_MasterSlaveMode_Enable: synchronization between the current timer + * and its slaves (through TRGO). + * @arg TIM_MasterSlaveMode_Disable: No action + * @retval None + */ +void TIM_SelectMasterSlaveMode(TIM_TypeDef* TIMx, uint16_t TIM_MasterSlaveMode) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_MSM_STATE(TIM_MasterSlaveMode)); + + /* Reset the MSM Bit */ + TIMx->SMCR &= (uint16_t)~((uint16_t)TIM_SMCR_MSM); + + /* Set or Reset the MSM Bit */ + TIMx->SMCR |= TIM_MasterSlaveMode; +} + +/** + * @brief Configures the TIMx External Trigger (ETR). + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ExtTRGPrescaler: The external Trigger Prescaler. + * This parameter can be one of the following values: + * @arg TIM_ExtTRGPSC_OFF: ETRP Prescaler OFF. + * @arg TIM_ExtTRGPSC_DIV2: ETRP frequency divided by 2. + * @arg TIM_ExtTRGPSC_DIV4: ETRP frequency divided by 4. + * @arg TIM_ExtTRGPSC_DIV8: ETRP frequency divided by 8. + * @param TIM_ExtTRGPolarity: The external Trigger Polarity. + * This parameter can be one of the following values: + * @arg TIM_ExtTRGPolarity_Inverted: active low or falling edge active. + * @arg TIM_ExtTRGPolarity_NonInverted: active high or rising edge active. + * @param ExtTRGFilter: External Trigger Filter. + * This parameter must be a value between 0x00 and 0x0F + * @retval None + */ +void TIM_ETRConfig(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, uint16_t TIM_ExtTRGPolarity, + uint16_t ExtTRGFilter) +{ + uint16_t tmpsmcr = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_EXT_PRESCALER(TIM_ExtTRGPrescaler)); + assert_param(IS_TIM_EXT_POLARITY(TIM_ExtTRGPolarity)); + assert_param(IS_TIM_EXT_FILTER(ExtTRGFilter)); + + tmpsmcr = TIMx->SMCR; + /* Reset the ETR Bits */ + tmpsmcr &= SMCR_ETR_MASK; + /* Set the Prescaler, the Filter value and the Polarity */ + tmpsmcr |= (uint16_t)(TIM_ExtTRGPrescaler | (uint16_t)(TIM_ExtTRGPolarity | (uint16_t)(ExtTRGFilter << (uint16_t)8))); + /* Write to TIMx SMCR */ + TIMx->SMCR = tmpsmcr; +} + +/** + * @} + */ + +/** @defgroup TIM_Group8 Specific interface management functions + * @brief Specific interface management functions + * +@verbatim + =============================================================================== + ##### Specific interface management functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Configures the TIMx Encoder Interface. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_EncoderMode: specifies the TIMx Encoder Mode. + * This parameter can be one of the following values: + * @arg TIM_EncoderMode_TI1: Counter counts on TI1FP1 edge depending on TI2FP2 level. + * @arg TIM_EncoderMode_TI2: Counter counts on TI2FP2 edge depending on TI1FP1 level. + * @arg TIM_EncoderMode_TI12: Counter counts on both TI1FP1 and TI2FP2 edges depending + * on the level of the other input. + * @param TIM_IC1Polarity: specifies the IC1 Polarity + * This parmeter can be one of the following values: + * @arg TIM_ICPolarity_Falling: IC Falling edge. + * @arg TIM_ICPolarity_Rising: IC Rising edge. + * @param TIM_IC2Polarity: specifies the IC2 Polarity + * This parmeter can be one of the following values: + * @arg TIM_ICPolarity_Falling: IC Falling edge. + * @arg TIM_ICPolarity_Rising: IC Rising edge. + * @retval None + */ +void TIM_EncoderInterfaceConfig(TIM_TypeDef* TIMx, uint16_t TIM_EncoderMode, + uint16_t TIM_IC1Polarity, uint16_t TIM_IC2Polarity) +{ + uint16_t tmpsmcr = 0; + uint16_t tmpccmr1 = 0; + uint16_t tmpccer = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_ENCODER_MODE(TIM_EncoderMode)); + assert_param(IS_TIM_IC_POLARITY(TIM_IC1Polarity)); + assert_param(IS_TIM_IC_POLARITY(TIM_IC2Polarity)); + + /* Get the TIMx SMCR register value */ + tmpsmcr = TIMx->SMCR; + /* Get the TIMx CCMR1 register value */ + tmpccmr1 = TIMx->CCMR1; + /* Get the TIMx CCER register value */ + tmpccer = TIMx->CCER; + /* Set the encoder Mode */ + tmpsmcr &= (uint16_t)(~((uint16_t)TIM_SMCR_SMS)); + tmpsmcr |= TIM_EncoderMode; + /* Select the Capture Compare 1 and the Capture Compare 2 as input */ + tmpccmr1 &= (uint16_t)(((uint16_t)~((uint16_t)TIM_CCMR1_CC1S)) & (uint16_t)(~((uint16_t)TIM_CCMR1_CC2S))); + tmpccmr1 |= TIM_CCMR1_CC1S_0 | TIM_CCMR1_CC2S_0; + /* Set the TI1 and the TI2 Polarities */ + tmpccer &= (uint16_t)~((uint16_t)(TIM_CCER_CC1P | TIM_CCER_CC1NP)) & (uint16_t)~((uint16_t)(TIM_CCER_CC2P | TIM_CCER_CC2NP)); + tmpccer |= (uint16_t)(TIM_IC1Polarity | (uint16_t)(TIM_IC2Polarity << (uint16_t)4)); + /* Write to TIMx SMCR */ + TIMx->SMCR = tmpsmcr; + /* Write to TIMx CCMR1 */ + TIMx->CCMR1 = tmpccmr1; + /* Write to TIMx CCER */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Enables or disables the TIMx's Hall sensor interface. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param NewState: new state of the TIMx Hall sensor interface. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void TIM_SelectHallSensor(TIM_TypeDef* TIMx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Set the TI1S Bit */ + TIMx->CR2 |= TIM_CR2_TI1S; + } + else + { + /* Reset the TI1S Bit */ + TIMx->CR2 &= (uint16_t)~((uint16_t)TIM_CR2_TI1S); + } +} + +/** + * @} + */ + +/** @defgroup TIM_Group9 Specific remapping management function + * @brief Specific remapping management function + * +@verbatim + =============================================================================== + ##### Specific remapping management function ##### + =============================================================================== + +@endverbatim + * @{ + */ +/** + * @brief Configures the TIM14 Remapping input Capabilities. + * @param TIMx: where x can be 14 to select the TIM peripheral. + * @param TIM_Remap: specifies the TIM input reampping source. + * This parameter can be one of the following values: + * @arg TIM14_GPIO: TIM14 Channel 1 is connected to GPIO. + * @arg TIM14_RTC_CLK: TIM14 Channel 1 is connected to RTC input clock. + * RTC input clock can be LSE, LSI or HSE/div128. + * @arg TIM14_HSE_DIV32: TIM14 Channel 1 is connected to HSE/32 clock. + * @arg TIM14_MCO: TIM14 Channel 1 is connected to MCO clock. + * MCO clock can be HSI14, SYSCLK, HSI, HSE or PLL/2. + * @retval None + */ +void TIM_RemapConfig(TIM_TypeDef* TIMx, uint16_t TIM_Remap) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST11_PERIPH(TIMx)); + assert_param(IS_TIM_REMAP(TIM_Remap)); + + /* Set the Timer remapping configuration */ + TIMx->OR = TIM_Remap; +} + +/** + * @} + */ + +/** + * @brief Configure the TI1 as Input. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ICPolarity: The Input Polarity. + * This parameter can be one of the following values: + * @arg TIM_ICPolarity_Rising + * @arg TIM_ICPolarity_Falling + * @param TIM_ICSelection: specifies the input to be used. + * This parameter can be one of the following values: + * @arg TIM_ICSelection_DirectTI: TIM Input 1 is selected to be connected to IC1. + * @arg TIM_ICSelection_IndirectTI: TIM Input 1 is selected to be connected to IC2. + * @arg TIM_ICSelection_TRC: TIM Input 1 is selected to be connected to TRC. + * @param TIM_ICFilter: Specifies the Input Capture Filter. + * This parameter must be a value between 0x00 and 0x0F. + * @retval None + */ +static void TI1_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, + uint16_t TIM_ICFilter) +{ + uint16_t tmpccmr1 = 0, tmpccer = 0; + /* Disable the Channel 1: Reset the CC1E Bit */ + TIMx->CCER &= (uint16_t)~((uint16_t)TIM_CCER_CC1E); + tmpccmr1 = TIMx->CCMR1; + tmpccer = TIMx->CCER; + /* Select the Input and set the filter */ + tmpccmr1 &= (uint16_t)(((uint16_t)~((uint16_t)TIM_CCMR1_CC1S)) & ((uint16_t)~((uint16_t)TIM_CCMR1_IC1F))); + tmpccmr1 |= (uint16_t)(TIM_ICSelection | (uint16_t)(TIM_ICFilter << (uint16_t)4)); + + /* Select the Polarity and set the CC1E Bit */ + tmpccer &= (uint16_t)~((uint16_t)(TIM_CCER_CC1P | TIM_CCER_CC1NP)); + tmpccer |= (uint16_t)(TIM_ICPolarity | (uint16_t)TIM_CCER_CC1E); + /* Write to TIMx CCMR1 and CCER registers */ + TIMx->CCMR1 = tmpccmr1; + TIMx->CCER = tmpccer; +} + +/** + * @brief Configure the TI2 as Input. + * @param TIMx: where x can be 1, 2, 3, or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ICPolarity: The Input Polarity. + * This parameter can be one of the following values: + * @arg TIM_ICPolarity_Rising + * @arg TIM_ICPolarity_Falling + * @param TIM_ICSelection: specifies the input to be used. + * This parameter can be one of the following values: + * @arg TIM_ICSelection_DirectTI: TIM Input 2 is selected to be connected to IC2. + * @arg TIM_ICSelection_IndirectTI: TIM Input 2 is selected to be connected to IC1. + * @arg TIM_ICSelection_TRC: TIM Input 2 is selected to be connected to TRC. + * @param TIM_ICFilter: Specifies the Input Capture Filter. + * This parameter must be a value between 0x00 and 0x0F. + * @retval None + */ +static void TI2_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, + uint16_t TIM_ICFilter) +{ + uint16_t tmpccmr1 = 0, tmpccer = 0, tmp = 0; + /* Disable the Channel 2: Reset the CC2E Bit */ + TIMx->CCER &= (uint16_t)~((uint16_t)TIM_CCER_CC2E); + tmpccmr1 = TIMx->CCMR1; + tmpccer = TIMx->CCER; + tmp = (uint16_t)(TIM_ICPolarity << 4); + /* Select the Input and set the filter */ + tmpccmr1 &= (uint16_t)(((uint16_t)~((uint16_t)TIM_CCMR1_CC2S)) & ((uint16_t)~((uint16_t)TIM_CCMR1_IC2F))); + tmpccmr1 |= (uint16_t)(TIM_ICFilter << 12); + tmpccmr1 |= (uint16_t)(TIM_ICSelection << 8); + /* Select the Polarity and set the CC2E Bit */ + tmpccer &= (uint16_t)~((uint16_t)(TIM_CCER_CC2P | TIM_CCER_CC2NP)); + tmpccer |= (uint16_t)(tmp | (uint16_t)TIM_CCER_CC2E); + /* Write to TIMx CCMR1 and CCER registers */ + TIMx->CCMR1 = tmpccmr1 ; + TIMx->CCER = tmpccer; +} + +/** + * @brief Configure the TI3 as Input. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ICPolarity: The Input Polarity. + * This parameter can be one of the following values: + * @arg TIM_ICPolarity_Rising + * @arg TIM_ICPolarity_Falling + * @param TIM_ICSelection: specifies the input to be used. + * This parameter can be one of the following values: + * @arg TIM_ICSelection_DirectTI: TIM Input 3 is selected to be connected to IC3. + * @arg TIM_ICSelection_IndirectTI: TIM Input 3 is selected to be connected to IC4. + * @arg TIM_ICSelection_TRC: TIM Input 3 is selected to be connected to TRC. + * @param TIM_ICFilter: Specifies the Input Capture Filter. + * This parameter must be a value between 0x00 and 0x0F. + * @retval None + */ +static void TI3_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, + uint16_t TIM_ICFilter) +{ + uint16_t tmpccmr2 = 0, tmpccer = 0, tmp = 0; + /* Disable the Channel 3: Reset the CC3E Bit */ + TIMx->CCER &= (uint16_t)~((uint16_t)TIM_CCER_CC3E); + tmpccmr2 = TIMx->CCMR2; + tmpccer = TIMx->CCER; + tmp = (uint16_t)(TIM_ICPolarity << 8); + /* Select the Input and set the filter */ + tmpccmr2 &= (uint16_t)(((uint16_t)~((uint16_t)TIM_CCMR2_CC3S)) & ((uint16_t)~((uint16_t)TIM_CCMR2_IC3F))); + tmpccmr2 |= (uint16_t)(TIM_ICSelection | (uint16_t)(TIM_ICFilter << (uint16_t)4)); + /* Select the Polarity and set the CC3E Bit */ + tmpccer &= (uint16_t)~((uint16_t)(TIM_CCER_CC3P | TIM_CCER_CC3NP)); + tmpccer |= (uint16_t)(tmp | (uint16_t)TIM_CCER_CC3E); + /* Write to TIMx CCMR2 and CCER registers */ + TIMx->CCMR2 = tmpccmr2; + TIMx->CCER = tmpccer; +} + +/** + * @brief Configure the TI4 as Input. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ICPolarity: The Input Polarity. + * This parameter can be one of the following values: + * @arg TIM_ICPolarity_Rising + * @arg TIM_ICPolarity_Falling + * @param TIM_ICSelection: specifies the input to be used. + * This parameter can be one of the following values: + * @arg TIM_ICSelection_DirectTI: TIM Input 4 is selected to be connected to IC4. + * @arg TIM_ICSelection_IndirectTI: TIM Input 4 is selected to be connected to IC3. + * @arg TIM_ICSelection_TRC: TIM Input 4 is selected to be connected to TRC. + * @param TIM_ICFilter: Specifies the Input Capture Filter. + * This parameter must be a value between 0x00 and 0x0F. + * @retval None + */ +static void TI4_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, + uint16_t TIM_ICFilter) +{ + uint16_t tmpccmr2 = 0, tmpccer = 0, tmp = 0; + + /* Disable the Channel 4: Reset the CC4E Bit */ + TIMx->CCER &= (uint16_t)~((uint16_t)TIM_CCER_CC4E); + tmpccmr2 = TIMx->CCMR2; + tmpccer = TIMx->CCER; + tmp = (uint16_t)(TIM_ICPolarity << 12); + /* Select the Input and set the filter */ + tmpccmr2 &= (uint16_t)((uint16_t)(~(uint16_t)TIM_CCMR2_CC4S) & ((uint16_t)~((uint16_t)TIM_CCMR2_IC4F))); + tmpccmr2 |= (uint16_t)(TIM_ICSelection << 8); + tmpccmr2 |= (uint16_t)(TIM_ICFilter << 12); + /* Select the Polarity and set the CC4E Bit */ + tmpccer &= (uint16_t)~((uint16_t)(TIM_CCER_CC4P | TIM_CCER_CC4NP)); + tmpccer |= (uint16_t)(tmp | (uint16_t)TIM_CCER_CC4E); + /* Write to TIMx CCMR2 and CCER registers */ + TIMx->CCMR2 = tmpccmr2; + TIMx->CCER = tmpccer; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_usart.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_usart.c new file mode 100644 index 00000000..4b81b700 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_usart.c @@ -0,0 +1,2168 @@ +/** + ****************************************************************************** + * @file stm32f0xx_usart.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Universal synchronous asynchronous receiver + * transmitter (USART): + * + Initialization and Configuration + * + STOP Mode + * + AutoBaudRate + * + Data transfers + * + Multi-Processor Communication + * + LIN mode + * + Half-duplex mode + * + Smartcard mode + * + IrDA mode + * + RS485 mode + * + DMA transfers management + * + Interrupts and flags management + * + * @verbatim + =============================================================================== + ##### How to use this driver ##### + =============================================================================== + [..] + (#) Enable peripheral clock using RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE) + function for USART1 or using RCC_APB1PeriphClockCmd(RCC_APB1Periph_USARTx, ENABLE) + function for USART2 and USART3. + (#) According to the USART mode, enable the GPIO clocks using + RCC_AHBPeriphClockCmd() function. (The I/O can be TX, RX, CTS, + or and SCLK). + (#) Peripheral's alternate function: + (++) Connect the pin to the desired peripherals' Alternate + Function (AF) using GPIO_PinAFConfig() function. + (++) Configure the desired pin in alternate function by: + GPIO_InitStruct->GPIO_Mode = GPIO_Mode_AF. + (++) Select the type, pull-up/pull-down and output speed via + GPIO_PuPd, GPIO_OType and GPIO_Speed members. + (++) Call GPIO_Init() function. + (#) Program the Baud Rate, Word Length , Stop Bit, Parity, Hardware + flow control and Mode(Receiver/Transmitter) using the SPI_Init() + function. + (#) For synchronous mode, enable the clock and program the polarity, + phase and last bit using the USART_ClockInit() function. + (#) Enable the NVIC and the corresponding interrupt using the function + USART_ITConfig() if you need to use interrupt mode. + (#) When using the DMA mode: + (++) Configure the DMA using DMA_Init() function. + (++) Active the needed channel Request using USART_DMACmd() function. + (#) Enable the USART using the USART_Cmd() function. + (#) Enable the DMA using the DMA_Cmd() function, when using DMA mode. + [..] + Refer to Multi-Processor, LIN, half-duplex, Smartcard, IrDA sub-sections + for more details. + +@endverbatim + + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_usart.h" +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup USART + * @brief USART driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ + +/*!< USART CR1 register clear Mask ((~(uint32_t)0xFFFFE6F3)) */ +#define CR1_CLEAR_MASK ((uint32_t)(USART_CR1_M | USART_CR1_PCE | \ + USART_CR1_PS | USART_CR1_TE | \ + USART_CR1_RE)) + +/*!< USART CR2 register clock bits clear Mask ((~(uint32_t)0xFFFFF0FF)) */ +#define CR2_CLOCK_CLEAR_MASK ((uint32_t)(USART_CR2_CLKEN | USART_CR2_CPOL | \ + USART_CR2_CPHA | USART_CR2_LBCL)) + +/*!< USART CR3 register clear Mask ((~(uint32_t)0xFFFFFCFF)) */ +#define CR3_CLEAR_MASK ((uint32_t)(USART_CR3_RTSE | USART_CR3_CTSE)) + +/*!< USART Interrupts mask */ +#define IT_MASK ((uint32_t)0x000000FF) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup USART_Private_Functions + * @{ + */ + +/** @defgroup USART_Group1 Initialization and Configuration functions + * @brief Initialization and Configuration functions + * +@verbatim + =============================================================================== + ##### Initialization and Configuration functions ##### + =============================================================================== + [..] + This subsection provides a set of functions allowing to initialize the USART + in asynchronous and in synchronous modes. + (+) For the asynchronous mode only these parameters can be configured: + (++) Baud Rate. + (++) Word Length. + (++) Stop Bit. + (++) Parity: If the parity is enabled, then the MSB bit of the data written + in the data register is transmitted but is changed by the parity bit. + Depending on the frame length defined by the M bit (8-bits or 9-bits), + the possible USART frame formats are as listed in the following table: + + +-------------------------------------------------------------+ + | M bit | PCE bit | USART frame | + |---------------------|---------------------------------------| + | 0 | 0 | | SB | 8 bit data | STB | | + |---------|-----------|---------------------------------------| + | 0 | 1 | | SB | 7 bit data | PB | STB | | + |---------|-----------|---------------------------------------| + | 1 | 0 | | SB | 9 bit data | STB | | + |---------|-----------|---------------------------------------| + | 1 | 1 | | SB | 8 bit data | PB | STB | | + +-------------------------------------------------------------+ + + (++) Hardware flow control. + (++) Receiver/transmitter modes. + [..] The USART_Init() function follows the USART asynchronous configuration + procedure(details for the procedure are available in reference manual. + (+) For the synchronous mode in addition to the asynchronous mode parameters + these parameters should be also configured: + (++) USART Clock Enabled. + (++) USART polarity. + (++) USART phase. + (++) USART LastBit. + [..] These parameters can be configured using the USART_ClockInit() function. + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the USARTx peripheral registers to their default reset values. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @retval None + */ +void USART_DeInit(USART_TypeDef* USARTx) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + + if (USARTx == USART1) + { + RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, ENABLE); + RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, DISABLE); + } + else if (USARTx == USART2) + { + RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, DISABLE); + } + else if (USARTx == USART3) + { + RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, DISABLE); + } + else if (USARTx == USART4) + { + RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART4, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART4, DISABLE); + } + else if (USARTx == USART5) + { + RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART5, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART5, DISABLE); + } + else if (USARTx == USART6) + { + RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART6, ENABLE); + RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART6, DISABLE); + } + else if (USARTx == USART7) + { + RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART7, ENABLE); + RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART7, DISABLE); + } + else + { + if (USARTx == USART8) + { + RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART8, ENABLE); + RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART8, DISABLE); + } + } +} + +/** + * @brief Initializes the USARTx peripheral according to the specified + * parameters in the USART_InitStruct . + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_InitStruct: pointer to a USART_InitTypeDef structure that contains + * the configuration information for the specified USART peripheral. + * @retval None + */ +void USART_Init(USART_TypeDef* USARTx, USART_InitTypeDef* USART_InitStruct) +{ + uint32_t divider = 0, apbclock = 0, tmpreg = 0; + RCC_ClocksTypeDef RCC_ClocksStatus; + + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_BAUDRATE(USART_InitStruct->USART_BaudRate)); + assert_param(IS_USART_WORD_LENGTH(USART_InitStruct->USART_WordLength)); + assert_param(IS_USART_STOPBITS(USART_InitStruct->USART_StopBits)); + assert_param(IS_USART_PARITY(USART_InitStruct->USART_Parity)); + assert_param(IS_USART_MODE(USART_InitStruct->USART_Mode)); + assert_param(IS_USART_HARDWARE_FLOW_CONTROL(USART_InitStruct->USART_HardwareFlowControl)); + + /* Disable USART */ + USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_UE); + + /*---------------------------- USART CR2 Configuration -----------------------*/ + tmpreg = USARTx->CR2; + /* Clear STOP[13:12] bits */ + tmpreg &= (uint32_t)~((uint32_t)USART_CR2_STOP); + + /* Configure the USART Stop Bits, Clock, CPOL, CPHA and LastBit ------------*/ + /* Set STOP[13:12] bits according to USART_StopBits value */ + tmpreg |= (uint32_t)USART_InitStruct->USART_StopBits; + + /* Write to USART CR2 */ + USARTx->CR2 = tmpreg; + + /*---------------------------- USART CR1 Configuration -----------------------*/ + tmpreg = USARTx->CR1; + /* Clear M, PCE, PS, TE and RE bits */ + tmpreg &= (uint32_t)~((uint32_t)CR1_CLEAR_MASK); + + /* Configure the USART Word Length, Parity and mode ----------------------- */ + /* Set the M bits according to USART_WordLength value */ + /* Set PCE and PS bits according to USART_Parity value */ + /* Set TE and RE bits according to USART_Mode value */ + tmpreg |= (uint32_t)USART_InitStruct->USART_WordLength | USART_InitStruct->USART_Parity | + USART_InitStruct->USART_Mode; + + /* Write to USART CR1 */ + USARTx->CR1 = tmpreg; + + /*---------------------------- USART CR3 Configuration -----------------------*/ + tmpreg = USARTx->CR3; + /* Clear CTSE and RTSE bits */ + tmpreg &= (uint32_t)~((uint32_t)CR3_CLEAR_MASK); + + /* Configure the USART HFC -------------------------------------------------*/ + /* Set CTSE and RTSE bits according to USART_HardwareFlowControl value */ + tmpreg |= USART_InitStruct->USART_HardwareFlowControl; + + /* Write to USART CR3 */ + USARTx->CR3 = tmpreg; + + /*---------------------------- USART BRR Configuration -----------------------*/ + /* Configure the USART Baud Rate -------------------------------------------*/ + RCC_GetClocksFreq(&RCC_ClocksStatus); + + if (USARTx == USART1) + { + apbclock = RCC_ClocksStatus.USART1CLK_Frequency; + } + else if (USARTx == USART2) + { + apbclock = RCC_ClocksStatus.USART2CLK_Frequency; + } + else if (USARTx == USART3) + { + apbclock = RCC_ClocksStatus.USART3CLK_Frequency; + } + else + { + apbclock = RCC_ClocksStatus.PCLK_Frequency; + } + + /* Determine the integer part */ + if ((USARTx->CR1 & USART_CR1_OVER8) != 0) + { + /* (divider * 10) computing in case Oversampling mode is 8 Samples */ + divider = (uint32_t)((2 * apbclock) / (USART_InitStruct->USART_BaudRate)); + tmpreg = (uint32_t)((2 * apbclock) % (USART_InitStruct->USART_BaudRate)); + } + else /* if ((USARTx->CR1 & CR1_OVER8_Set) == 0) */ + { + /* (divider * 10) computing in case Oversampling mode is 16 Samples */ + divider = (uint32_t)((apbclock) / (USART_InitStruct->USART_BaudRate)); + tmpreg = (uint32_t)((apbclock) % (USART_InitStruct->USART_BaudRate)); + } + + /* round the divider : if fractional part i greater than 0.5 increment divider */ + if (tmpreg >= (USART_InitStruct->USART_BaudRate) / 2) + { + divider++; + } + + /* Implement the divider in case Oversampling mode is 8 Samples */ + if ((USARTx->CR1 & USART_CR1_OVER8) != 0) + { + /* get the LSB of divider and shift it to the right by 1 bit */ + tmpreg = (divider & (uint16_t)0x000F) >> 1; + + /* update the divider value */ + divider = (divider & (uint16_t)0xFFF0) | tmpreg; + } + + /* Write to USART BRR */ + USARTx->BRR = (uint16_t)divider; +} + +/** + * @brief Fills each USART_InitStruct member with its default value. + * @param USART_InitStruct: pointer to a USART_InitTypeDef structure + * which will be initialized. + * @retval None + */ +void USART_StructInit(USART_InitTypeDef* USART_InitStruct) +{ + /* USART_InitStruct members default value */ + USART_InitStruct->USART_BaudRate = 9600; + USART_InitStruct->USART_WordLength = USART_WordLength_8b; + USART_InitStruct->USART_StopBits = USART_StopBits_1; + USART_InitStruct->USART_Parity = USART_Parity_No ; + USART_InitStruct->USART_Mode = USART_Mode_Rx | USART_Mode_Tx; + USART_InitStruct->USART_HardwareFlowControl = USART_HardwareFlowControl_None; +} + +/** + * @brief Initializes the USARTx peripheral Clock according to the + * specified parameters in the USART_ClockInitStruct. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_ClockInitStruct: pointer to a USART_ClockInitTypeDef + * structure that contains the configuration information for the specified + * USART peripheral. + * @retval None + */ +void USART_ClockInit(USART_TypeDef* USARTx, USART_ClockInitTypeDef* USART_ClockInitStruct) +{ + uint32_t tmpreg = 0; + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_CLOCK(USART_ClockInitStruct->USART_Clock)); + assert_param(IS_USART_CPOL(USART_ClockInitStruct->USART_CPOL)); + assert_param(IS_USART_CPHA(USART_ClockInitStruct->USART_CPHA)); + assert_param(IS_USART_LASTBIT(USART_ClockInitStruct->USART_LastBit)); +/*---------------------------- USART CR2 Configuration -----------------------*/ + tmpreg = USARTx->CR2; + /* Clear CLKEN, CPOL, CPHA, LBCL and SSM bits */ + tmpreg &= (uint32_t)~((uint32_t)CR2_CLOCK_CLEAR_MASK); + /* Configure the USART Clock, CPOL, CPHA, LastBit and SSM ------------*/ + /* Set CLKEN bit according to USART_Clock value */ + /* Set CPOL bit according to USART_CPOL value */ + /* Set CPHA bit according to USART_CPHA value */ + /* Set LBCL bit according to USART_LastBit value */ + tmpreg |= (uint32_t)(USART_ClockInitStruct->USART_Clock | USART_ClockInitStruct->USART_CPOL | + USART_ClockInitStruct->USART_CPHA | USART_ClockInitStruct->USART_LastBit); + /* Write to USART CR2 */ + USARTx->CR2 = tmpreg; +} + +/** + * @brief Fills each USART_ClockInitStruct member with its default value. + * @param USART_ClockInitStruct: pointer to a USART_ClockInitTypeDef + * structure which will be initialized. + * @retval None + */ +void USART_ClockStructInit(USART_ClockInitTypeDef* USART_ClockInitStruct) +{ + /* USART_ClockInitStruct members default value */ + USART_ClockInitStruct->USART_Clock = USART_Clock_Disable; + USART_ClockInitStruct->USART_CPOL = USART_CPOL_Low; + USART_ClockInitStruct->USART_CPHA = USART_CPHA_1Edge; + USART_ClockInitStruct->USART_LastBit = USART_LastBit_Disable; +} + +/** + * @brief Enables or disables the specified USART peripheral. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param NewState: new state of the USARTx peripheral. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_Cmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected USART by setting the UE bit in the CR1 register */ + USARTx->CR1 |= USART_CR1_UE; + } + else + { + /* Disable the selected USART by clearing the UE bit in the CR1 register */ + USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_UE); + } +} + +/** + * @brief Enables or disables the USART's transmitter or receiver. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_Direction: specifies the USART direction. + * This parameter can be any combination of the following values: + * @arg USART_Mode_Tx: USART Transmitter + * @arg USART_Mode_Rx: USART Receiver + * @param NewState: new state of the USART transfer direction. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_DirectionModeCmd(USART_TypeDef* USARTx, uint32_t USART_DirectionMode, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_MODE(USART_DirectionMode)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the USART's transfer interface by setting the TE and/or RE bits + in the USART CR1 register */ + USARTx->CR1 |= USART_DirectionMode; + } + else + { + /* Disable the USART's transfer interface by clearing the TE and/or RE bits + in the USART CR3 register */ + USARTx->CR1 &= (uint32_t)~USART_DirectionMode; + } +} + +/** + * @brief Enables or disables the USART's 8x oversampling mode. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param NewState: new state of the USART 8x oversampling mode. + * This parameter can be: ENABLE or DISABLE. + * @note This function has to be called before calling USART_Init() function + * in order to have correct baudrate Divider value. + * @retval None + */ +void USART_OverSampling8Cmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the 8x Oversampling mode by setting the OVER8 bit in the CR1 register */ + USARTx->CR1 |= USART_CR1_OVER8; + } + else + { + /* Disable the 8x Oversampling mode by clearing the OVER8 bit in the CR1 register */ + USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_OVER8); + } +} + +/** + * @brief Enables or disables the USART's one bit sampling method. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param NewState: new state of the USART one bit sampling method. + * This parameter can be: ENABLE or DISABLE. + * @note This function has to be called before calling USART_Cmd() function. + * @retval None + */ +void USART_OneBitMethodCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the one bit method by setting the ONEBITE bit in the CR3 register */ + USARTx->CR3 |= USART_CR3_ONEBIT; + } + else + { + /* Disable the one bit method by clearing the ONEBITE bit in the CR3 register */ + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_ONEBIT); + } +} + +/** + * @brief Enables or disables the USART's most significant bit first + * transmitted/received following the start bit. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param NewState: new state of the USART most significant bit first + * transmitted/received following the start bit. + * This parameter can be: ENABLE or DISABLE. + * @note This function has to be called before calling USART_Cmd() function. + * @retval None + */ +void USART_MSBFirstCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the most significant bit first transmitted/received following the + start bit by setting the MSBFIRST bit in the CR2 register */ + USARTx->CR2 |= USART_CR2_MSBFIRST; + } + else + { + /* Disable the most significant bit first transmitted/received following the + start bit by clearing the MSBFIRST bit in the CR2 register */ + USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_MSBFIRST); + } +} + +/** + * @brief Enables or disables the binary data inversion. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param NewState: new defined levels for the USART data. + * This parameter can be: + * @arg ENABLE: Logical data from the data register are send/received in negative + * logic (1=L, 0=H). The parity bit is also inverted. + * @arg DISABLE: Logical data from the data register are send/received in positive + * logic (1=H, 0=L) + * @note This function has to be called before calling USART_Cmd() function. + * @retval None + */ +void USART_DataInvCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the binary data inversion feature by setting the DATAINV bit in + the CR2 register */ + USARTx->CR2 |= USART_CR2_DATAINV; + } + else + { + /* Disable the binary data inversion feature by clearing the DATAINV bit in + the CR2 register */ + USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_DATAINV); + } +} + +/** + * @brief Enables or disables the Pin(s) active level inversion. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_InvPin: specifies the USART pin(s) to invert. + * This parameter can be any combination of the following values: + * @arg USART_InvPin_Tx: USART Tx pin active level inversion. + * @arg USART_InvPin_Rx: USART Rx pin active level inversion. + * @param NewState: new active level status for the USART pin(s). + * This parameter can be: + * @arg ENABLE: pin(s) signal values are inverted (Vdd =0, Gnd =1). + * @arg DISABLE: pin(s) signal works using the standard logic levels (Vdd =1, Gnd =0). + * @note This function has to be called before calling USART_Cmd() function. + * @retval None + */ +void USART_InvPinCmd(USART_TypeDef* USARTx, uint32_t USART_InvPin, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_INVERSTION_PIN(USART_InvPin)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the active level inversion for selected pins by setting the TXINV + and/or RXINV bits in the USART CR2 register */ + USARTx->CR2 |= USART_InvPin; + } + else + { + /* Disable the active level inversion for selected requests by clearing the + TXINV and/or RXINV bits in the USART CR2 register */ + USARTx->CR2 &= (uint32_t)~USART_InvPin; + } +} + +/** + * @brief Enables or disables the swap Tx/Rx pins. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param NewState: new state of the USARTx TX/RX pins pinout. + * This parameter can be: + * @arg ENABLE: The TX and RX pins functions are swapped. + * @arg DISABLE: TX/RX pins are used as defined in standard pinout + * @note This function has to be called before calling USART_Cmd() function. + * @retval None + */ +void USART_SWAPPinCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the SWAP feature by setting the SWAP bit in the CR2 register */ + USARTx->CR2 |= USART_CR2_SWAP; + } + else + { + /* Disable the SWAP feature by clearing the SWAP bit in the CR2 register */ + USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_SWAP); + } +} + +/** + * @brief Enables or disables the receiver Time Out feature. + * @param USARTx: where x can be 1, 2 or 3 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param NewState: new state of the USARTx receiver Time Out. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_ReceiverTimeOutCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the receiver time out feature by setting the RTOEN bit in the CR2 + register */ + USARTx->CR2 |= USART_CR2_RTOEN; + } + else + { + /* Disable the receiver time out feature by clearing the RTOEN bit in the CR2 + register */ + USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_RTOEN); + } +} + +/** + * @brief Sets the receiver Time Out value. + * @param USARTx: where x can be 1, 2 or 3 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param USART_ReceiverTimeOut: specifies the Receiver Time Out value. + * @retval None + */ +void USART_SetReceiverTimeOut(USART_TypeDef* USARTx, uint32_t USART_ReceiverTimeOut) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_USART_TIMEOUT(USART_ReceiverTimeOut)); + + /* Clear the receiver Time Out value by clearing the RTO[23:0] bits in the RTOR + register */ + USARTx->RTOR &= (uint32_t)~((uint32_t)USART_RTOR_RTO); + /* Set the receiver Time Out value by setting the RTO[23:0] bits in the RTOR + register */ + USARTx->RTOR |= USART_ReceiverTimeOut; +} + +/** + * @brief Sets the system clock prescaler. + * @note This function is not available for STM32F030 devices. + * @param USARTx: where x can be 1, 2 or 3 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param USART_Prescaler: specifies the prescaler clock. + * @note This function has to be called before calling USART_Cmd() function. + * @retval None + */ +void USART_SetPrescaler(USART_TypeDef* USARTx, uint8_t USART_Prescaler) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + + /* Clear the USART prescaler */ + USARTx->GTPR &= USART_GTPR_GT; + /* Set the USART prescaler */ + USARTx->GTPR |= USART_Prescaler; +} + +/** + * @} + */ + + +/** @defgroup USART_Group2 STOP Mode functions + * @brief STOP Mode functions + * +@verbatim + =============================================================================== + ##### STOP Mode functions ##### + =============================================================================== + [..] This subsection provides a set of functions allowing to manage + WakeUp from STOP mode. + + [..] The USART is able to WakeUp from Stop Mode if USART clock is set to HSI + or LSI. + + [..] The WakeUp source is configured by calling USART_StopModeWakeUpSourceConfig() + function. + + [..] After configuring the source of WakeUp and before entering in Stop Mode + USART_STOPModeCmd() function should be called to allow USART WakeUp. + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified USART peripheral in STOP Mode. + * @param USARTx: where x can be 1 or 2 or 3 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param NewState: new state of the USARTx peripheral state in stop mode. + * This parameter can be: ENABLE or DISABLE. + * @note This function has to be called when USART clock is set to HSI or LSE. + * @retval None + */ +void USART_STOPModeCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected USART in STOP mode by setting the UESM bit in the CR1 + register */ + USARTx->CR1 |= USART_CR1_UESM; + } + else + { + /* Disable the selected USART in STOP mode by clearing the UE bit in the CR1 + register */ + USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_UESM); + } +} + +/** + * @brief Selects the USART WakeUp method form stop mode. + * @note This function is not available for STM32F030 devices. + * @param USARTx: where x can be 1 or 2 or 3 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param USART_WakeUp: specifies the selected USART wakeup method. + * This parameter can be one of the following values: + * @arg USART_WakeUpSource_AddressMatch: WUF active on address match. + * @arg USART_WakeUpSource_StartBit: WUF active on Start bit detection. + * @arg USART_WakeUpSource_RXNE: WUF active on RXNE. + * @note This function has to be called before calling USART_Cmd() function. + * @retval None + */ +void USART_StopModeWakeUpSourceConfig(USART_TypeDef* USARTx, uint32_t USART_WakeUpSource) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_USART_STOPMODE_WAKEUPSOURCE(USART_WakeUpSource)); + + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_WUS); + USARTx->CR3 |= USART_WakeUpSource; +} + +/** + * @} + */ + + +/** @defgroup USART_Group3 AutoBaudRate functions + * @brief AutoBaudRate functions + * +@verbatim + =============================================================================== + ##### AutoBaudRate functions ##### + =============================================================================== + [..] This subsection provides a set of functions allowing to manage + the AutoBaudRate detections. + + [..] Before Enabling AutoBaudRate detection using USART_AutoBaudRateCmd () + The character patterns used to calculate baudrate must be chosen by calling + USART_AutoBaudRateConfig() function. These function take as parameter : + (#)USART_AutoBaudRate_StartBit : any character starting with a bit 1. + (#)USART_AutoBaudRate_FallingEdge : any character starting with a 10xx bit pattern. + + [..] At any later time, another request for AutoBaudRate detection can be performed + using USART_RequestCmd() function. + + [..] The AutoBaudRate detection is monitored by the status of ABRF flag which indicate + that the AutoBaudRate detection is completed. In addition to ABRF flag, the ABRE flag + indicate that this procedure is completed without success. USART_GetFlagStatus () + function should be used to monitor the status of these flags. + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the Auto Baud Rate. + * @param USARTx: where x can be 1or 2 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param NewState: new state of the USARTx auto baud rate. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_AutoBaudRateCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the auto baud rate feature by setting the ABREN bit in the CR2 + register */ + USARTx->CR2 |= USART_CR2_ABREN; + } + else + { + /* Disable the auto baud rate feature by clearing the ABREN bit in the CR2 + register */ + USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_ABREN); + } +} + +/** + * @brief Selects the USART auto baud rate method. + * @param USARTx: where x can be 1or 2 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param USART_AutoBaudRate: specifies the selected USART auto baud rate method. + * This parameter can be one of the following values: + * @arg USART_AutoBaudRate_StartBit: Start Bit duration measurement. + * @arg USART_AutoBaudRate_FallingEdge: Falling edge to falling edge measurement. + * @note This function has to be called before calling USART_Cmd() function. + * @retval None + */ +void USART_AutoBaudRateConfig(USART_TypeDef* USARTx, uint32_t USART_AutoBaudRate) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_USART_AUTOBAUDRATE_MODE(USART_AutoBaudRate)); + + USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_ABRMODE); + USARTx->CR2 |= USART_AutoBaudRate; +} + +/** + * @} + */ + + +/** @defgroup USART_Group4 Data transfers functions + * @brief Data transfers functions + * +@verbatim + =============================================================================== + ##### Data transfers functions ##### + =============================================================================== + [..] This subsection provides a set of functions allowing to manage + the USART data transfers. + [..] During an USART reception, data shifts in least significant bit first + through the RX pin. When a transmission is taking place, a write instruction to + the USART_TDR register stores the data in the shift register. + [..] The read access of the USART_RDR register can be done using + the USART_ReceiveData() function and returns the RDR value. + Whereas a write access to the USART_TDR can be done using USART_SendData() + function and stores the written data into TDR. + +@endverbatim + * @{ + */ + +/** + * @brief Transmits single data through the USARTx peripheral. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param Data: the data to transmit. + * @retval None + */ +void USART_SendData(USART_TypeDef* USARTx, uint16_t Data) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_DATA(Data)); + + /* Transmit Data */ + USARTx->TDR = (Data & (uint16_t)0x01FF); +} + +/** + * @brief Returns the most recent received data by the USARTx peripheral. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @retval The received data. + */ +uint16_t USART_ReceiveData(USART_TypeDef* USARTx) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + + /* Receive Data */ + return (uint16_t)(USARTx->RDR & (uint16_t)0x01FF); +} + +/** + * @} + */ + +/** @defgroup USART_Group5 MultiProcessor Communication functions + * @brief Multi-Processor Communication functions + * +@verbatim + =============================================================================== + ##### Multi-Processor Communication functions ##### + =============================================================================== + [..] This subsection provides a set of functions allowing to manage the USART + multiprocessor communication. + [..] For instance one of the USARTs can be the master, its TX output is + connected to the RX input of the other USART. The others are slaves, + their respective TX outputs are logically ANDed together and connected + to the RX input of the master. USART multiprocessor communication is + possible through the following procedure: + (#) Program the Baud rate, Word length = 9 bits, Stop bits, Parity, + Mode transmitter or Mode receiver and hardware flow control values + using the USART_Init() function. + (#) Configures the USART address using the USART_SetAddress() function. + (#) Configures the wake up methode (USART_WakeUp_IdleLine or + USART_WakeUp_AddressMark) using USART_WakeUpConfig() function only + for the slaves. + (#) Enable the USART using the USART_Cmd() function. + (#) Enter the USART slaves in mute mode using USART_ReceiverWakeUpCmd() + function. + [..] The USART Slave exit from mute mode when receive the wake up condition. + +@endverbatim + * @{ + */ + +/** + * @brief Sets the address of the USART node. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_Address: Indicates the address of the USART node. + * @retval None + */ +void USART_SetAddress(USART_TypeDef* USARTx, uint8_t USART_Address) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + + /* Clear the USART address */ + USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_ADD); + /* Set the USART address node */ + USARTx->CR2 |=((uint32_t)USART_Address << (uint32_t)0x18); +} + +/** + * @brief Enables or disables the USART's mute mode. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param NewState: new state of the USART mute mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_MuteModeCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the USART mute mode by setting the MME bit in the CR1 register */ + USARTx->CR1 |= USART_CR1_MME; + } + else + { + /* Disable the USART mute mode by clearing the MME bit in the CR1 register */ + USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_MME); + } +} + +/** + * @brief Selects the USART WakeUp method from mute mode. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_WakeUp: specifies the USART wakeup method. + * This parameter can be one of the following values: + * @arg USART_WakeUp_IdleLine: WakeUp by an idle line detection + * @arg USART_WakeUp_AddressMark: WakeUp by an address mark + * @retval None + */ +void USART_MuteModeWakeUpConfig(USART_TypeDef* USARTx, uint32_t USART_WakeUp) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_MUTEMODE_WAKEUP(USART_WakeUp)); + + USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_WAKE); + USARTx->CR1 |= USART_WakeUp; +} + +/** + * @brief Configure the the USART Address detection length. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_AddressLength: specifies the USART address length detection. + * This parameter can be one of the following values: + * @arg USART_AddressLength_4b: 4-bit address length detection + * @arg USART_AddressLength_7b: 7-bit address length detection + * @retval None + */ +void USART_AddressDetectionConfig(USART_TypeDef* USARTx, uint32_t USART_AddressLength) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_ADDRESS_DETECTION(USART_AddressLength)); + + USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_ADDM7); + USARTx->CR2 |= USART_AddressLength; +} + +/** + * @} + */ + +/** @defgroup USART_Group6 LIN mode functions + * @brief LIN mode functions + * +@verbatim + =============================================================================== + ##### LIN mode functions ##### + =============================================================================== + [..] This subsection provides a set of functions allowing to manage the USART + LIN Mode communication. + [..] In LIN mode, 8-bit data format with 1 stop bit is required in accordance + with the LIN standard. + [..] Only this LIN Feature is supported by the USART IP: + (+) LIN Master Synchronous Break send capability and LIN slave break + detection capability : 13-bit break generation and 10/11 bit break + detection. + [..] USART LIN Master transmitter communication is possible through the + following procedure: + (#) Program the Baud rate, Word length = 8bits, Stop bits = 1bit, Parity, + Mode transmitter or Mode receiver and hardware flow control values + using the USART_Init() function. + (#) Enable the LIN mode using the USART_LINCmd() function. + (#) Enable the USART using the USART_Cmd() function. + (#) Send the break character using USART_SendBreak() function. + [..] USART LIN Master receiver communication is possible through the + following procedure: + (#) Program the Baud rate, Word length = 8bits, Stop bits = 1bit, Parity, + Mode transmitter or Mode receiver and hardware flow control values + using the USART_Init() function. + (#) Configures the break detection length + using the USART_LINBreakDetectLengthConfig() function. + (#) Enable the LIN mode using the USART_LINCmd() function. + -@- In LIN mode, the following bits must be kept cleared: + (+@) CLKEN in the USART_CR2 register. + (+@) STOP[1:0], SCEN, HDSEL and IREN in the USART_CR3 register. + (#) Enable the USART using the USART_Cmd() function. + +@endverbatim + * @{ + */ + +/** + * @brief Sets the USART LIN Break detection length. + * @note This function is not available for STM32F030 devices. + * @param USARTx: where x can be 1or 2 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param USART_LINBreakDetectLength: specifies the LIN break detection length. + * This parameter can be one of the following values: + * @arg USART_LINBreakDetectLength_10b: 10-bit break detection + * @arg USART_LINBreakDetectLength_11b: 11-bit break detection + * @retval None + */ +void USART_LINBreakDetectLengthConfig(USART_TypeDef* USARTx, uint32_t USART_LINBreakDetectLength) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_USART_LIN_BREAK_DETECT_LENGTH(USART_LINBreakDetectLength)); + + USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_LBDL); + USARTx->CR2 |= USART_LINBreakDetectLength; +} + +/** + * @brief Enables or disables the USART's LIN mode. + * @note This function is not available for STM32F030 devices. + * @param USARTx: where x can be 1or 2 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param NewState: new state of the USART LIN mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_LINCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the LIN mode by setting the LINEN bit in the CR2 register */ + USARTx->CR2 |= USART_CR2_LINEN; + } + else + { + /* Disable the LIN mode by clearing the LINEN bit in the CR2 register */ + USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_LINEN); + } +} + +/** + * @} + */ + +/** @defgroup USART_Group7 Halfduplex mode function + * @brief Half-duplex mode function + * +@verbatim + =============================================================================== + ##### Half-duplex mode function ##### + =============================================================================== + [..] This subsection provides a set of functions allowing to manage the USART + Half-duplex communication. + [..] The USART can be configured to follow a single-wire half-duplex protocol + where the TX and RX lines are internally connected. + [..] USART Half duplex communication is possible through the following procedure: + (#) Program the Baud rate, Word length, Stop bits, Parity, Mode transmitter + or Mode receiver and hardware flow control values using the USART_Init() + function. + (#) Configures the USART address using the USART_SetAddress() function. + (#) Enable the half duplex mode using USART_HalfDuplexCmd() function. + (#) Enable the USART using the USART_Cmd() function. + -@- The RX pin is no longer used. + -@- In Half-duplex mode the following bits must be kept cleared: + (+@) LINEN and CLKEN bits in the USART_CR2 register. + (+@) SCEN and IREN bits in the USART_CR3 register. + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the USART's Half Duplex communication. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param NewState: new state of the USART Communication. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_HalfDuplexCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the Half-Duplex mode by setting the HDSEL bit in the CR3 register */ + USARTx->CR3 |= USART_CR3_HDSEL; + } + else + { + /* Disable the Half-Duplex mode by clearing the HDSEL bit in the CR3 register */ + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_HDSEL); + } +} + +/** + * @} + */ + + +/** @defgroup USART_Group8 Smartcard mode functions + * @brief Smartcard mode functions + * +@verbatim + =============================================================================== + ##### Smartcard mode functions ##### + =============================================================================== + [..] This subsection provides a set of functions allowing to manage the USART + Smartcard communication. + [..] The Smartcard interface is designed to support asynchronous protocol + Smartcards as defined in the ISO 7816-3 standard. The USART can provide + a clock to the smartcard through the SCLK output. In smartcard mode, + SCLK is not associated to the communication but is simply derived from + the internal peripheral input clock through a 5-bit prescaler. + [..] Smartcard communication is possible through the following procedure: + (#) Configures the Smartcard Prsecaler using the USART_SetPrescaler() + function. + (#) Configures the Smartcard Guard Time using the USART_SetGuardTime() + function. + (#) Program the USART clock using the USART_ClockInit() function as following: + (++) USART Clock enabled. + (++) USART CPOL Low. + (++) USART CPHA on first edge. + (++) USART Last Bit Clock Enabled. + (#) Program the Smartcard interface using the USART_Init() function as + following: + (++) Word Length = 9 Bits. + (++) 1.5 Stop Bit. + (++) Even parity. + (++) BaudRate = 12096 baud. + (++) Hardware flow control disabled (RTS and CTS signals). + (++) Tx and Rx enabled + (#) Optionally you can enable the parity error interrupt using + the USART_ITConfig() function. + (#) Enable the Smartcard NACK using the USART_SmartCardNACKCmd() function. + (#) Enable the Smartcard interface using the USART_SmartCardCmd() function. + (#) Enable the USART using the USART_Cmd() function. + [..] + Please refer to the ISO 7816-3 specification for more details. + [..] + (@) It is also possible to choose 0.5 stop bit for receiving but it is + recommended to use 1.5 stop bits for both transmitting and receiving + to avoid switching between the two configurations. + (@) In smartcard mode, the following bits must be kept cleared: + (+@) LINEN bit in the USART_CR2 register. + (+@) HDSEL and IREN bits in the USART_CR3 register. + +@endverbatim + * @{ + */ + +/** + * @brief Sets the specified USART guard time. + * @note This function is not available for STM32F030 devices. + * @param USARTx: where x can be 1or 2 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param USART_GuardTime: specifies the guard time. + * @retval None + */ +void USART_SetGuardTime(USART_TypeDef* USARTx, uint8_t USART_GuardTime) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + + /* Clear the USART Guard time */ + USARTx->GTPR &= USART_GTPR_PSC; + /* Set the USART guard time */ + USARTx->GTPR |= (uint16_t)((uint16_t)USART_GuardTime << 0x08); +} + +/** + * @brief Enables or disables the USART's Smart Card mode. + * @note This function is not available for STM32F030 devices. + * @param USARTx: where x can be 1or 2 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param NewState: new state of the Smart Card mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_SmartCardCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + if (NewState != DISABLE) + { + /* Enable the SC mode by setting the SCEN bit in the CR3 register */ + USARTx->CR3 |= USART_CR3_SCEN; + } + else + { + /* Disable the SC mode by clearing the SCEN bit in the CR3 register */ + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_SCEN); + } +} + +/** + * @brief Enables or disables NACK transmission. + * @note This function is not available for STM32F030 devices. + * @param USARTx: where x can be 1or 2 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param NewState: new state of the NACK transmission. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_SmartCardNACKCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + if (NewState != DISABLE) + { + /* Enable the NACK transmission by setting the NACK bit in the CR3 register */ + USARTx->CR3 |= USART_CR3_NACK; + } + else + { + /* Disable the NACK transmission by clearing the NACK bit in the CR3 register */ + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_NACK); + } +} + +/** + * @brief Sets the Smart Card number of retries in transmit and receive. + * @note This function is not available for STM32F030 devices. + * @param USARTx: where x can be 1or 3 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param USART_AutoCount: specifies the Smart Card auto retry count. + * @retval None + */ +void USART_SetAutoRetryCount(USART_TypeDef* USARTx, uint8_t USART_AutoCount) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_USART_AUTO_RETRY_COUNTER(USART_AutoCount)); + /* Clear the USART auto retry count */ + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_SCARCNT); + /* Set the USART auto retry count*/ + USARTx->CR3 |= (uint32_t)((uint32_t)USART_AutoCount << 0x11); +} + +/** + * @brief Sets the Smart Card Block length. + * @note This function is not available for STM32F030 devices. + * @param USARTx: where x can be 1or 3 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param USART_BlockLength: specifies the Smart Card block length. + * @retval None + */ +void USART_SetBlockLength(USART_TypeDef* USARTx, uint8_t USART_BlockLength) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + + /* Clear the Smart card block length */ + USARTx->RTOR &= (uint32_t)~((uint32_t)USART_RTOR_BLEN); + /* Set the Smart Card block length */ + USARTx->RTOR |= (uint32_t)((uint32_t)USART_BlockLength << 0x18); +} + +/** + * @} + */ + +/** @defgroup USART_Group9 IrDA mode functions + * @brief IrDA mode functions + * +@verbatim + =============================================================================== + ##### IrDA mode functions ##### + =============================================================================== + [..] This subsection provides a set of functions allowing to manage the USART + IrDA communication. + [..] IrDA is a half duplex communication protocol. If the Transmitter is busy, + any data on the IrDA receive line will be ignored by the IrDA decoder + and if the Receiver is busy, data on the TX from the USART to IrDA will + not be encoded by IrDA. While receiving data, transmission should be + avoided as the data to be transmitted could be corrupted. + [..] IrDA communication is possible through the following procedure: + (#) Program the Baud rate, Word length = 8 bits, Stop bits, Parity, + Transmitter/Receiver modes and hardware flow control values using + the USART_Init() function. + (#) Configures the IrDA pulse width by configuring the prescaler using + the USART_SetPrescaler() function. + (#) Configures the IrDA USART_IrDAMode_LowPower or USART_IrDAMode_Normal + mode using the USART_IrDAConfig() function. + (#) Enable the IrDA using the USART_IrDACmd() function. + (#) Enable the USART using the USART_Cmd() function. + [..] + (@) A pulse of width less than two and greater than one PSC period(s) may or + may not be rejected. + (@) The receiver set up time should be managed by software. The IrDA physical + layer specification specifies a minimum of 10 ms delay between + transmission and reception (IrDA is a half duplex protocol). + (@) In IrDA mode, the following bits must be kept cleared: + (+@) LINEN, STOP and CLKEN bits in the USART_CR2 register. + (+@) SCEN and HDSEL bits in the USART_CR3 register. + +@endverbatim + * @{ + */ + +/** + * @brief Configures the USART's IrDA interface. + * @note This function is not available for STM32F030 devices. + * @param USARTx: where x can be 1or 2 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param USART_IrDAMode: specifies the IrDA mode. + * This parameter can be one of the following values: + * @arg USART_IrDAMode_LowPower + * @arg USART_IrDAMode_Normal + * @retval None + */ +void USART_IrDAConfig(USART_TypeDef* USARTx, uint32_t USART_IrDAMode) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_USART_IRDA_MODE(USART_IrDAMode)); + + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_IRLP); + USARTx->CR3 |= USART_IrDAMode; +} + +/** + * @brief Enables or disables the USART's IrDA interface. + * @note This function is not available for STM32F030 devices. + * @param USARTx: where x can be 1or 2 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param NewState: new state of the IrDA mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_IrDACmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the IrDA mode by setting the IREN bit in the CR3 register */ + USARTx->CR3 |= USART_CR3_IREN; + } + else + { + /* Disable the IrDA mode by clearing the IREN bit in the CR3 register */ + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_IREN); + } +} +/** + * @} + */ + +/** @defgroup USART_Group10 RS485 mode function + * @brief RS485 mode function + * +@verbatim + =============================================================================== + ##### RS485 mode functions ##### + =============================================================================== + [..] This subsection provides a set of functions allowing to manage the USART + RS485 flow control. + [..] RS485 flow control (Driver enable feature) handling is possible through + the following procedure: + (#) Program the Baud rate, Word length = 8 bits, Stop bits, Parity, + Transmitter/Receiver modes and hardware flow control values using + the USART_Init() function. + (#) Enable the Driver Enable using the USART_DECmd() function. + (#) Configures the Driver Enable polarity using the USART_DEPolarityConfig() + function. + (#) Configures the Driver Enable assertion time using USART_SetDEAssertionTime() + function and deassertion time using the USART_SetDEDeassertionTime() + function. + (#) Enable the USART using the USART_Cmd() function. + -@- + (+@) The assertion and dessertion times are expressed in sample time units (1/8 or + 1/16 bit time, depending on the oversampling rate). + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the USART's DE functionality. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param NewState: new state of the driver enable mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_DECmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + if (NewState != DISABLE) + { + /* Enable the DE functionality by setting the DEM bit in the CR3 register */ + USARTx->CR3 |= USART_CR3_DEM; + } + else + { + /* Disable the DE functionality by clearing the DEM bit in the CR3 register */ + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_DEM); + } +} + +/** + * @brief Configures the USART's DE polarity + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_DEPolarity: specifies the DE polarity. + * This parameter can be one of the following values: + * @arg USART_DEPolarity_Low + * @arg USART_DEPolarity_High + * @retval None + */ +void USART_DEPolarityConfig(USART_TypeDef* USARTx, uint32_t USART_DEPolarity) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_DE_POLARITY(USART_DEPolarity)); + + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_DEP); + USARTx->CR3 |= USART_DEPolarity; +} + +/** + * @brief Sets the specified RS485 DE assertion time + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_DEAssertionTime: specifies the time between the activation of + * the DE signal and the beginning of the start bit + * @retval None + */ +void USART_SetDEAssertionTime(USART_TypeDef* USARTx, uint32_t USART_DEAssertionTime) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_DE_ASSERTION_DEASSERTION_TIME(USART_DEAssertionTime)); + + /* Clear the DE assertion time */ + USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_DEAT); + /* Set the new value for the DE assertion time */ + USARTx->CR1 |=((uint32_t)USART_DEAssertionTime << (uint32_t)0x15); +} + +/** + * @brief Sets the specified RS485 DE deassertion time + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_DeassertionTime: specifies the time between the middle of the last + * stop bit in a transmitted message and the de-activation of the DE signal + * @retval None + */ +void USART_SetDEDeassertionTime(USART_TypeDef* USARTx, uint32_t USART_DEDeassertionTime) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_DE_ASSERTION_DEASSERTION_TIME(USART_DEDeassertionTime)); + + /* Clear the DE deassertion time */ + USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_DEDT); + /* Set the new value for the DE deassertion time */ + USARTx->CR1 |=((uint32_t)USART_DEDeassertionTime << (uint32_t)0x10); +} + +/** + * @} + */ + +/** @defgroup USART_Group11 DMA transfers management functions + * @brief DMA transfers management functions + * +@verbatim + =============================================================================== + ##### DMA transfers management functions ##### + =============================================================================== + [..] This section provides two functions that can be used only in DMA mode. + [..] In DMA Mode, the USART communication can be managed by 2 DMA Channel + requests: + (#) USART_DMAReq_Tx: specifies the Tx buffer DMA transfer request. + (#) USART_DMAReq_Rx: specifies the Rx buffer DMA transfer request. + [..] In this Mode it is advised to use the following function: + (+) void USART_DMACmd(USART_TypeDef* USARTx, uint16_t USART_DMAReq, + FunctionalState NewState). +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the USART's DMA interface. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_DMAReq: specifies the DMA request. + * This parameter can be any combination of the following values: + * @arg USART_DMAReq_Tx: USART DMA transmit request + * @arg USART_DMAReq_Rx: USART DMA receive request + * @param NewState: new state of the DMA Request sources. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_DMACmd(USART_TypeDef* USARTx, uint32_t USART_DMAReq, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_DMAREQ(USART_DMAReq)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the DMA transfer for selected requests by setting the DMAT and/or + DMAR bits in the USART CR3 register */ + USARTx->CR3 |= USART_DMAReq; + } + else + { + /* Disable the DMA transfer for selected requests by clearing the DMAT and/or + DMAR bits in the USART CR3 register */ + USARTx->CR3 &= (uint32_t)~USART_DMAReq; + } +} + +/** + * @brief Enables or disables the USART's DMA interface when reception error occurs. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_DMAOnError: specifies the DMA status in case of reception error. + * This parameter can be any combination of the following values: + * @arg USART_DMAOnError_Enable: DMA receive request enabled when the USART DMA + * reception error is asserted. + * @arg USART_DMAOnError_Disable: DMA receive request disabled when the USART DMA + * reception error is asserted. + * @retval None + */ +void USART_DMAReceptionErrorConfig(USART_TypeDef* USARTx, uint32_t USART_DMAOnError) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_DMAONERROR(USART_DMAOnError)); + + /* Clear the DMA Reception error detection bit */ + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_DDRE); + /* Set the new value for the DMA Reception error detection bit */ + USARTx->CR3 |= USART_DMAOnError; +} + +/** + * @} + */ + +/** @defgroup USART_Group12 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== + [..] This subsection provides a set of functions allowing to configure the + USART Interrupts sources, Requests and check or clear the flags or pending bits status. + The user should identify which mode will be used in his application to + manage the communication: Polling mode, Interrupt mode. + + *** Polling Mode *** + ==================== + [..] In Polling Mode, the SPI communication can be managed by these flags: + (#) USART_FLAG_REACK: to indicate the status of the Receive Enable + acknowledge flag + (#) USART_FLAG_TEACK: to indicate the status of the Transmit Enable + acknowledge flag. + (#) USART_FLAG_WU: to indicate the status of the Wake up flag. + (#) USART_FLAG_RWU: to indicate the status of the Receive Wake up flag. + (#) USART_FLAG_SBK: to indicate the status of the Send Break flag. + (#) USART_FLAG_CM: to indicate the status of the Character match flag. + (#) USART_FLAG_BUSY: to indicate the status of the Busy flag. + (#) USART_FLAG_ABRF: to indicate the status of the Auto baud rate flag. + (#) USART_FLAG_ABRE: to indicate the status of the Auto baud rate error flag. + (#) USART_FLAG_EOB: to indicate the status of the End of block flag. + (#) USART_FLAG_RTO: to indicate the status of the Receive time out flag. + (#) USART_FLAG_nCTSS: to indicate the status of the Inverted nCTS input + bit status. + (#) USART_FLAG_TXE: to indicate the status of the transmit buffer register. + (#) USART_FLAG_RXNE: to indicate the status of the receive buffer register. + (#) USART_FLAG_TC: to indicate the status of the transmit operation. + (#) USART_FLAG_IDLE: to indicate the status of the Idle Line. + (#) USART_FLAG_CTS: to indicate the status of the nCTS input. + (#) USART_FLAG_LBD: to indicate the status of the LIN break detection. + (#) USART_FLAG_NE: to indicate if a noise error occur. + (#) USART_FLAG_FE: to indicate if a frame error occur. + (#) USART_FLAG_PE: to indicate if a parity error occur. + (#) USART_FLAG_ORE: to indicate if an Overrun error occur. + [..] In this Mode it is advised to use the following functions: + (+) FlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, uint16_t USART_FLAG). + (+) void USART_ClearFlag(USART_TypeDef* USARTx, uint16_t USART_FLAG). + + *** Interrupt Mode *** + ====================== + [..] In Interrupt Mode, the USART communication can be managed by 8 interrupt + sources and 10 pending bits: + (+) Pending Bits: + (##) USART_IT_WU: to indicate the status of the Wake up interrupt. + (##) USART_IT_CM: to indicate the status of Character match interrupt. + (##) USART_IT_EOB: to indicate the status of End of block interrupt. + (##) USART_IT_RTO: to indicate the status of Receive time out interrupt. + (##) USART_IT_CTS: to indicate the status of CTS change interrupt. + (##) USART_IT_LBD: to indicate the status of LIN Break detection interrupt. + (##) USART_IT_TC: to indicate the status of Transmission complete interrupt. + (##) USART_IT_IDLE: to indicate the status of IDLE line detected interrupt. + (##) USART_IT_ORE: to indicate the status of OverRun Error interrupt. + (##) USART_IT_NE: to indicate the status of Noise Error interrupt. + (##) USART_IT_FE: to indicate the status of Framing Error interrupt. + (##) USART_IT_PE: to indicate the status of Parity Error interrupt. + + (+) Interrupt Source: + (##) USART_IT_WU: specifies the interrupt source for Wake up interrupt. + (##) USART_IT_CM: specifies the interrupt source for Character match + interrupt. + (##) USART_IT_EOB: specifies the interrupt source for End of block + interrupt. + (##) USART_IT_RTO: specifies the interrupt source for Receive time-out + interrupt. + (##) USART_IT_CTS: specifies the interrupt source for CTS change interrupt. + (##) USART_IT_LBD: specifies the interrupt source for LIN Break + detection interrupt. + (##) USART_IT_TXE: specifies the interrupt source for Tansmit Data + Register empty interrupt. + (##) USART_IT_TC: specifies the interrupt source for Transmission + complete interrupt. + (##) USART_IT_RXNE: specifies the interrupt source for Receive Data + register not empty interrupt. + (##) USART_IT_IDLE: specifies the interrupt source for Idle line + detection interrupt. + (##) USART_IT_PE: specifies the interrupt source for Parity Error interrupt. + (##) USART_IT_ERR: specifies the interrupt source for Error interrupt + (Frame error, noise error, overrun error) + -@@- Some parameters are coded in order to use them as interrupt + source or as pending bits. + [..] In this Mode it is advised to use the following functions: + (+) void USART_ITConfig(USART_TypeDef* USARTx, uint16_t USART_IT, FunctionalState NewState). + (+) ITStatus USART_GetITStatus(USART_TypeDef* USARTx, uint16_t USART_IT). + (+) void USART_ClearITPendingBit(USART_TypeDef* USARTx, uint16_t USART_IT). + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified USART interrupts. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_IT: specifies the USART interrupt sources to be enabled or disabled. + * This parameter can be one of the following values: + * @arg USART_IT_WU: Wake up interrupt, not available for STM32F030 devices. + * @arg USART_IT_CM: Character match interrupt. + * @arg USART_IT_EOB: End of block interrupt, not available for STM32F030 devices. + * @arg USART_IT_RTO: Receive time out interrupt. + * @arg USART_IT_CTS: CTS change interrupt. + * @arg USART_IT_LBD: LIN Break detection interrupt, not available for STM32F030 devices. + * @arg USART_IT_TXE: Tansmit Data Register empty interrupt. + * @arg USART_IT_TC: Transmission complete interrupt. + * @arg USART_IT_RXNE: Receive Data register not empty interrupt. + * @arg USART_IT_IDLE: Idle line detection interrupt. + * @arg USART_IT_PE: Parity Error interrupt. + * @arg USART_IT_ERR: Error interrupt(Frame error, noise error, overrun error) + * @param NewState: new state of the specified USARTx interrupts. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_ITConfig(USART_TypeDef* USARTx, uint32_t USART_IT, FunctionalState NewState) +{ + uint32_t usartreg = 0, itpos = 0, itmask = 0; + uint32_t usartxbase = 0; + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_CONFIG_IT(USART_IT)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + usartxbase = (uint32_t)USARTx; + + /* Get the USART register index */ + usartreg = (((uint16_t)USART_IT) >> 0x08); + + /* Get the interrupt position */ + itpos = USART_IT & IT_MASK; + itmask = (((uint32_t)0x01) << itpos); + + if (usartreg == 0x02) /* The IT is in CR2 register */ + { + usartxbase += 0x04; + } + else if (usartreg == 0x03) /* The IT is in CR3 register */ + { + usartxbase += 0x08; + } + else /* The IT is in CR1 register */ + { + } + if (NewState != DISABLE) + { + *(__IO uint32_t*)usartxbase |= itmask; + } + else + { + *(__IO uint32_t*)usartxbase &= ~itmask; + } +} + +/** + * @brief Enables the specified USART's Request. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_Request: specifies the USART request. + * This parameter can be any combination of the following values: + * @arg USART_Request_TXFRQ: Transmit data flush ReQuest + * @arg USART_Request_RXFRQ: Receive data flush ReQuest + * @arg USART_Request_MMRQ: Mute Mode ReQuest + * @arg USART_Request_SBKRQ: Send Break ReQuest + * @arg USART_Request_ABRRQ: Auto Baud Rate ReQuest + * @param NewState: new state of the DMA interface when reception error occurs. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_RequestCmd(USART_TypeDef* USARTx, uint32_t USART_Request, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_REQUEST(USART_Request)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the USART ReQuest by setting the dedicated request bit in the RQR + register.*/ + USARTx->RQR |= USART_Request; + } + else + { + /* Disable the USART ReQuest by clearing the dedicated request bit in the RQR + register.*/ + USARTx->RQR &= (uint32_t)~USART_Request; + } +} + +/** + * @brief Enables or disables the USART's Overrun detection. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_OVRDetection: specifies the OVR detection status in case of OVR error. + * This parameter can be any combination of the following values: + * @arg USART_OVRDetection_Enable: OVR error detection enabled when + * the USART OVR error is asserted. + * @arg USART_OVRDetection_Disable: OVR error detection disabled when + * the USART OVR error is asserted. + * @retval None + */ +void USART_OverrunDetectionConfig(USART_TypeDef* USARTx, uint32_t USART_OVRDetection) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_OVRDETECTION(USART_OVRDetection)); + + /* Clear the OVR detection bit */ + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_OVRDIS); + /* Set the new value for the OVR detection bit */ + USARTx->CR3 |= USART_OVRDetection; +} + +/** + * @brief Checks whether the specified USART flag is set or not. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg USART_FLAG_REACK: Receive Enable acknowledge flag. + * @arg USART_FLAG_TEACK: Transmit Enable acknowledge flag. + * @arg USART_FLAG_WU: Wake up flag, not available for STM32F030 devices. + * @arg USART_FLAG_RWU: Receive Wake up flag, not available for STM32F030 devices. + * @arg USART_FLAG_SBK: Send Break flag. + * @arg USART_FLAG_CM: Character match flag. + * @arg USART_FLAG_BUSY: Busy flag. + * @arg USART_FLAG_ABRF: Auto baud rate flag. + * @arg USART_FLAG_ABRE: Auto baud rate error flag. + * @arg USART_FLAG_EOB: End of block flag, not available for STM32F030 devices. + * @arg USART_FLAG_RTO: Receive time out flag. + * @arg USART_FLAG_nCTSS: Inverted nCTS input bit status. + * @arg USART_FLAG_CTS: CTS Change flag. + * @arg USART_FLAG_LBD: LIN Break detection flag, not available for STM32F030 devices. + * @arg USART_FLAG_TXE: Transmit data register empty flag. + * @arg USART_FLAG_TC: Transmission Complete flag. + * @arg USART_FLAG_RXNE: Receive data register not empty flag. + * @arg USART_FLAG_IDLE: Idle Line detection flag. + * @arg USART_FLAG_ORE: OverRun Error flag. + * @arg USART_FLAG_NE: Noise Error flag. + * @arg USART_FLAG_FE: Framing Error flag. + * @arg USART_FLAG_PE: Parity Error flag. + * @retval The new state of USART_FLAG (SET or RESET). + */ +FlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, uint32_t USART_FLAG) +{ + FlagStatus bitstatus = RESET; + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_FLAG(USART_FLAG)); + + if ((USARTx->ISR & USART_FLAG) != (uint16_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + return bitstatus; +} + +/** + * @brief Clears the USARTx's pending flags. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_FLAG: specifies the flag to clear. + * This parameter can be any combination of the following values: + * @arg USART_FLAG_WU: Wake up flag, not available for STM32F030 devices. + * @arg USART_FLAG_CM: Character match flag. + * @arg USART_FLAG_EOB: End of block flag, not available for STM32F030 devices. + * @arg USART_FLAG_RTO: Receive time out flag. + * @arg USART_FLAG_CTS: CTS Change flag. + * @arg USART_FLAG_LBD: LIN Break detection flag, not available for STM32F030 devices. + * @arg USART_FLAG_TC: Transmission Complete flag. + * @arg USART_FLAG_IDLE: IDLE line detected flag. + * @arg USART_FLAG_ORE: OverRun Error flag. + * @arg USART_FLAG_NE: Noise Error flag. + * @arg USART_FLAG_FE: Framing Error flag. + * @arg USART_FLAG_PE: Parity Errorflag. + * + * @note RXNE pending bit is cleared by a read to the USART_RDR register + * (USART_ReceiveData()) or by writing 1 to the RXFRQ in the register + * USART_RQR (USART_RequestCmd()). + * @note TC flag can be also cleared by software sequence: a read operation + * to USART_SR register (USART_GetFlagStatus()) followed by a write + * operation to USART_TDR register (USART_SendData()). + * @note TXE flag is cleared by a write to the USART_TDR register (USART_SendData()) + * or by writing 1 to the TXFRQ in the register USART_RQR (USART_RequestCmd()). + * @note SBKF flag is cleared by 1 to the SBKRQ in the register USART_RQR + * (USART_RequestCmd()). + * @retval None + */ +void USART_ClearFlag(USART_TypeDef* USARTx, uint32_t USART_FLAG) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_CLEAR_FLAG(USART_FLAG)); + + USARTx->ICR = USART_FLAG; +} + +/** + * @brief Checks whether the specified USART interrupt has occurred or not. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_IT: specifies the USART interrupt source to check. + * This parameter can be one of the following values: + * @arg USART_IT_WU: Wake up interrupt, not available for STM32F030 devices. + * @arg USART_IT_CM: Character match interrupt. + * @arg USART_IT_EOB: End of block interrupt, not available for STM32F030 devices. + * @arg USART_IT_RTO: Receive time out interrupt. + * @arg USART_IT_CTS: CTS change interrupt. + * @arg USART_IT_LBD: LIN Break detection interrupt, not available for STM32F030 devices. + * @arg USART_IT_TXE: Tansmit Data Register empty interrupt. + * @arg USART_IT_TC: Transmission complete interrupt. + * @arg USART_IT_RXNE: Receive Data register not empty interrupt. + * @arg USART_IT_IDLE: Idle line detection interrupt. + * @arg USART_IT_ORE: OverRun Error interrupt. + * @arg USART_IT_NE: Noise Error interrupt. + * @arg USART_IT_FE: Framing Error interrupt. + * @arg USART_IT_PE: Parity Error interrupt. + * @retval The new state of USART_IT (SET or RESET). + */ +ITStatus USART_GetITStatus(USART_TypeDef* USARTx, uint32_t USART_IT) +{ + uint32_t bitpos = 0, itmask = 0, usartreg = 0; + ITStatus bitstatus = RESET; + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_GET_IT(USART_IT)); + + /* Get the USART register index */ + usartreg = (((uint16_t)USART_IT) >> 0x08); + /* Get the interrupt position */ + itmask = USART_IT & IT_MASK; + itmask = (uint32_t)0x01 << itmask; + + if (usartreg == 0x01) /* The IT is in CR1 register */ + { + itmask &= USARTx->CR1; + } + else if (usartreg == 0x02) /* The IT is in CR2 register */ + { + itmask &= USARTx->CR2; + } + else /* The IT is in CR3 register */ + { + itmask &= USARTx->CR3; + } + + bitpos = USART_IT >> 0x10; + bitpos = (uint32_t)0x01 << bitpos; + bitpos &= USARTx->ISR; + if ((itmask != (uint16_t)RESET)&&(bitpos != (uint16_t)RESET)) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + + return bitstatus; +} + +/** + * @brief Clears the USARTx's interrupt pending bits. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_IT: specifies the interrupt pending bit to clear. + * This parameter can be one of the following values: + * @arg USART_IT_WU: Wake up interrupt, not available for STM32F030 devices. + * @arg USART_IT_CM: Character match interrupt. + * @arg USART_IT_EOB: End of block interrupt, not available for STM32F030 devices. + * @arg USART_IT_RTO: Receive time out interrupt. + * @arg USART_IT_CTS: CTS change interrupt. + * @arg USART_IT_LBD: LIN Break detection interrupt, not available for STM32F030 devices. + * @arg USART_IT_TC: Transmission complete interrupt. + * @arg USART_IT_IDLE: IDLE line detected interrupt. + * @arg USART_IT_ORE: OverRun Error interrupt. + * @arg USART_IT_NE: Noise Error interrupt. + * @arg USART_IT_FE: Framing Error interrupt. + * @arg USART_IT_PE: Parity Error interrupt. + * + * @note RXNE pending bit is cleared by a read to the USART_RDR register + * (USART_ReceiveData()) or by writing 1 to the RXFRQ in the register + * USART_RQR (USART_RequestCmd()). + * @note TC pending bit can be also cleared by software sequence: a read + * operation to USART_SR register (USART_GetITStatus()) followed by + * a write operation to USART_TDR register (USART_SendData()). + * @note TXE pending bit is cleared by a write to the USART_TDR register + * (USART_SendData()) or by writing 1 to the TXFRQ in the register + * USART_RQR (USART_RequestCmd()). + * @retval None + */ +void USART_ClearITPendingBit(USART_TypeDef* USARTx, uint32_t USART_IT) +{ + uint32_t bitpos = 0, itmask = 0; + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_CLEAR_IT(USART_IT)); + + bitpos = USART_IT >> 0x10; + itmask = ((uint32_t)0x01 << (uint32_t)bitpos); + USARTx->ICR = (uint32_t)itmask; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_wwdg.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_wwdg.c new file mode 100644 index 00000000..da69ed3e --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/SPL/src/stm32f0xx_wwdg.c @@ -0,0 +1,303 @@ +/** + ****************************************************************************** + * @file stm32f0xx_wwdg.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Window watchdog (WWDG) peripheral: + * + Prescaler, Refresh window and Counter configuration + * + WWDG activation + * + Interrupts and flags management + * + * @verbatim + * + ============================================================================== + ##### WWDG features ##### + ============================================================================== + [..] Once enabled the WWDG generates a system reset on expiry of a programmed + time period, unless the program refreshes the counter (downcounter) + before to reach 0x3F value (i.e. a reset is generated when the counter + value rolls over from 0x40 to 0x3F). + [..] An MCU reset is also generated if the counter value is refreshed + before the counter has reached the refresh window value. This + implies that the counter must be refreshed in a limited window. + + [..] Once enabled the WWDG cannot be disabled except by a system reset. + + [..] WWDGRST flag in RCC_CSR register can be used to inform when a WWDG + reset occurs. + + [..] The WWDG counter input clock is derived from the APB clock divided + by a programmable prescaler. + + [..] WWDG counter clock = PCLK1 / Prescaler. + [..] WWDG timeout = (WWDG counter clock) * (counter value). + + [..] Min-max timeout value @32MHz (PCLK1): ~85us / ~43ms. + + ##### How to use this driver ##### + ============================================================================== + [..] + (#) Enable WWDG clock using RCC_APB1PeriphClockCmd(RCC_APB1Periph_WWDG, ENABLE) + function. + + (#) Configure the WWDG prescaler using WWDG_SetPrescaler() function. + + (#) Configure the WWDG refresh window using WWDG_SetWindowValue() function. + + (#) Set the WWDG counter value and start it using WWDG_Enable() function. + When the WWDG is enabled the counter value should be configured to + a value greater than 0x40 to prevent generating an immediate reset. + + (#) Optionally you can enable the Early wakeup interrupt which is + generated when the counter reach 0x40. + Once enabled this interrupt cannot be disabled except by a system reset. + + (#) Then the application program must refresh the WWDG counter at regular + intervals during normal operation to prevent an MCU reset, using + WWDG_SetCounter() function. This operation must occur only when + the counter value is lower than the refresh window value, + programmed using WWDG_SetWindowValue(). + + * @endverbatim + * + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_wwdg.h" +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup WWDG + * @brief WWDG driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* --------------------- WWDG registers bit mask ---------------------------- */ +/* CFR register bit mask */ +#define CFR_WDGTB_MASK ((uint32_t)0xFFFFFE7F) +#define CFR_W_MASK ((uint32_t)0xFFFFFF80) +#define BIT_MASK ((uint8_t)0x7F) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup WWDG_Private_Functions + * @{ + */ + +/** @defgroup WWDG_Group1 Prescaler, Refresh window and Counter configuration functions + * @brief Prescaler, Refresh window and Counter configuration functions + * +@verbatim + ============================================================================== + ##### Prescaler, Refresh window and Counter configuration functions ##### + ============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the WWDG peripheral registers to their default reset values. + * @param None + * @retval None + */ +void WWDG_DeInit(void) +{ + RCC_APB1PeriphResetCmd(RCC_APB1Periph_WWDG, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_WWDG, DISABLE); +} + +/** + * @brief Sets the WWDG Prescaler. + * @param WWDG_Prescaler: specifies the WWDG Prescaler. + * This parameter can be one of the following values: + * @arg WWDG_Prescaler_1: WWDG counter clock = (PCLK1/4096)/1 + * @arg WWDG_Prescaler_2: WWDG counter clock = (PCLK1/4096)/2 + * @arg WWDG_Prescaler_4: WWDG counter clock = (PCLK1/4096)/4 + * @arg WWDG_Prescaler_8: WWDG counter clock = (PCLK1/4096)/8 + * @retval None + */ +void WWDG_SetPrescaler(uint32_t WWDG_Prescaler) +{ + uint32_t tmpreg = 0; + /* Check the parameters */ + assert_param(IS_WWDG_PRESCALER(WWDG_Prescaler)); + /* Clear WDGTB[1:0] bits */ + tmpreg = WWDG->CFR & CFR_WDGTB_MASK; + /* Set WDGTB[1:0] bits according to WWDG_Prescaler value */ + tmpreg |= WWDG_Prescaler; + /* Store the new value */ + WWDG->CFR = tmpreg; +} + +/** + * @brief Sets the WWDG window value. + * @param WindowValue: specifies the window value to be compared to the downcounter. + * This parameter value must be lower than 0x80. + * @retval None + */ +void WWDG_SetWindowValue(uint8_t WindowValue) +{ + __IO uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_WWDG_WINDOW_VALUE(WindowValue)); + /* Clear W[6:0] bits */ + + tmpreg = WWDG->CFR & CFR_W_MASK; + + /* Set W[6:0] bits according to WindowValue value */ + tmpreg |= WindowValue & (uint32_t) BIT_MASK; + + /* Store the new value */ + WWDG->CFR = tmpreg; +} + +/** + * @brief Enables the WWDG Early Wakeup interrupt(EWI). + * @note Once enabled this interrupt cannot be disabled except by a system reset. + * @param None + * @retval None + */ +void WWDG_EnableIT(void) +{ + WWDG->CFR |= WWDG_CFR_EWI; +} + +/** + * @brief Sets the WWDG counter value. + * @param Counter: specifies the watchdog counter value. + * This parameter must be a number between 0x40 and 0x7F (to prevent + * generating an immediate reset). + * @retval None + */ +void WWDG_SetCounter(uint8_t Counter) +{ + /* Check the parameters */ + assert_param(IS_WWDG_COUNTER(Counter)); + /* Write to T[6:0] bits to configure the counter value, no need to do + a read-modify-write; writing a 0 to WDGA bit does nothing */ + WWDG->CR = Counter & BIT_MASK; +} + +/** + * @} + */ + +/** @defgroup WWDG_Group2 WWDG activation functions + * @brief WWDG activation functions + * +@verbatim + ============================================================================== + ##### WWDG activation function ##### + ============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Enables WWDG and load the counter value. + * @param Counter: specifies the watchdog counter value. + * This parameter must be a number between 0x40 and 0x7F (to prevent + * generating an immediate reset). + * @retval None + */ +void WWDG_Enable(uint8_t Counter) +{ + /* Check the parameters */ + assert_param(IS_WWDG_COUNTER(Counter)); + WWDG->CR = WWDG_CR_WDGA | Counter; +} + +/** + * @} + */ + +/** @defgroup WWDG_Group3 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + ============================================================================== + ##### Interrupts and flags management functions ##### + ============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Checks whether the Early Wakeup interrupt flag is set or not. + * @param None + * @retval The new state of the Early Wakeup interrupt flag (SET or RESET). + */ +FlagStatus WWDG_GetFlagStatus(void) +{ + FlagStatus bitstatus = RESET; + + if ((WWDG->SR) != (uint32_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + return bitstatus; +} + +/** + * @brief Clears Early Wakeup interrupt flag. + * @param None + * @retval None + */ +void WWDG_ClearFlag(void) +{ + WWDG->SR = (uint32_t)RESET; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/arm_common_tables.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/arm_common_tables.h new file mode 100644 index 00000000..9c37ab4e --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/arm_common_tables.h @@ -0,0 +1,93 @@ +/* ---------------------------------------------------------------------- +* Copyright (C) 2010-2013 ARM Limited. All rights reserved. +* +* $Date: 17. January 2013 +* $Revision: V1.4.1 +* +* Project: CMSIS DSP Library +* Title: arm_common_tables.h +* +* Description: This file has extern declaration for common tables like Bitreverse, reciprocal etc which are used across different functions +* +* Target Processor: Cortex-M4/Cortex-M3 +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* - Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* - Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in +* the documentation and/or other materials provided with the +* distribution. +* - Neither the name of ARM LIMITED nor the names of its contributors +* may be used to endorse or promote products derived from this +* software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +* -------------------------------------------------------------------- */ + +#ifndef _ARM_COMMON_TABLES_H +#define _ARM_COMMON_TABLES_H + +#include "arm_math.h" + +extern const uint16_t armBitRevTable[1024]; +extern const q15_t armRecipTableQ15[64]; +extern const q31_t armRecipTableQ31[64]; +extern const q31_t realCoefAQ31[1024]; +extern const q31_t realCoefBQ31[1024]; +extern const float32_t twiddleCoef_16[32]; +extern const float32_t twiddleCoef_32[64]; +extern const float32_t twiddleCoef_64[128]; +extern const float32_t twiddleCoef_128[256]; +extern const float32_t twiddleCoef_256[512]; +extern const float32_t twiddleCoef_512[1024]; +extern const float32_t twiddleCoef_1024[2048]; +extern const float32_t twiddleCoef_2048[4096]; +extern const float32_t twiddleCoef_4096[8192]; +#define twiddleCoef twiddleCoef_4096 +extern const q31_t twiddleCoefQ31[6144]; +extern const q15_t twiddleCoefQ15[6144]; +extern const float32_t twiddleCoef_rfft_32[32]; +extern const float32_t twiddleCoef_rfft_64[64]; +extern const float32_t twiddleCoef_rfft_128[128]; +extern const float32_t twiddleCoef_rfft_256[256]; +extern const float32_t twiddleCoef_rfft_512[512]; +extern const float32_t twiddleCoef_rfft_1024[1024]; +extern const float32_t twiddleCoef_rfft_2048[2048]; +extern const float32_t twiddleCoef_rfft_4096[4096]; + + +#define ARMBITREVINDEXTABLE__16_TABLE_LENGTH ((uint16_t)20 ) +#define ARMBITREVINDEXTABLE__32_TABLE_LENGTH ((uint16_t)48 ) +#define ARMBITREVINDEXTABLE__64_TABLE_LENGTH ((uint16_t)56 ) +#define ARMBITREVINDEXTABLE_128_TABLE_LENGTH ((uint16_t)208 ) +#define ARMBITREVINDEXTABLE_256_TABLE_LENGTH ((uint16_t)440 ) +#define ARMBITREVINDEXTABLE_512_TABLE_LENGTH ((uint16_t)448 ) +#define ARMBITREVINDEXTABLE1024_TABLE_LENGTH ((uint16_t)1800) +#define ARMBITREVINDEXTABLE2048_TABLE_LENGTH ((uint16_t)3808) +#define ARMBITREVINDEXTABLE4096_TABLE_LENGTH ((uint16_t)4032) + +extern const uint16_t armBitRevIndexTable16[ARMBITREVINDEXTABLE__16_TABLE_LENGTH]; +extern const uint16_t armBitRevIndexTable32[ARMBITREVINDEXTABLE__32_TABLE_LENGTH]; +extern const uint16_t armBitRevIndexTable64[ARMBITREVINDEXTABLE__64_TABLE_LENGTH]; +extern const uint16_t armBitRevIndexTable128[ARMBITREVINDEXTABLE_128_TABLE_LENGTH]; +extern const uint16_t armBitRevIndexTable256[ARMBITREVINDEXTABLE_256_TABLE_LENGTH]; +extern const uint16_t armBitRevIndexTable512[ARMBITREVINDEXTABLE_512_TABLE_LENGTH]; +extern const uint16_t armBitRevIndexTable1024[ARMBITREVINDEXTABLE1024_TABLE_LENGTH]; +extern const uint16_t armBitRevIndexTable2048[ARMBITREVINDEXTABLE2048_TABLE_LENGTH]; +extern const uint16_t armBitRevIndexTable4096[ARMBITREVINDEXTABLE4096_TABLE_LENGTH]; + +#endif /* ARM_COMMON_TABLES_H */ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/arm_const_structs.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/arm_const_structs.h new file mode 100644 index 00000000..406f737d --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/arm_const_structs.h @@ -0,0 +1,85 @@ +/* ---------------------------------------------------------------------- +* Copyright (C) 2010-2013 ARM Limited. All rights reserved. +* +* $Date: 17. January 2013 +* $Revision: V1.4.1 +* +* Project: CMSIS DSP Library +* Title: arm_const_structs.h +* +* Description: This file has constant structs that are initialized for +* user convenience. For example, some can be given as +* arguments to the arm_cfft_f32() function. +* +* Target Processor: Cortex-M4/Cortex-M3 +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* - Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* - Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in +* the documentation and/or other materials provided with the +* distribution. +* - Neither the name of ARM LIMITED nor the names of its contributors +* may be used to endorse or promote products derived from this +* software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +* -------------------------------------------------------------------- */ + +#ifndef _ARM_CONST_STRUCTS_H +#define _ARM_CONST_STRUCTS_H + +#include "arm_math.h" +#include "arm_common_tables.h" + + const arm_cfft_instance_f32 arm_cfft_sR_f32_len16 = { + 16, twiddleCoef_16, armBitRevIndexTable16, ARMBITREVINDEXTABLE__16_TABLE_LENGTH + }; + + const arm_cfft_instance_f32 arm_cfft_sR_f32_len32 = { + 32, twiddleCoef_32, armBitRevIndexTable32, ARMBITREVINDEXTABLE__32_TABLE_LENGTH + }; + + const arm_cfft_instance_f32 arm_cfft_sR_f32_len64 = { + 64, twiddleCoef_64, armBitRevIndexTable64, ARMBITREVINDEXTABLE__64_TABLE_LENGTH + }; + + const arm_cfft_instance_f32 arm_cfft_sR_f32_len128 = { + 128, twiddleCoef_128, armBitRevIndexTable128, ARMBITREVINDEXTABLE_128_TABLE_LENGTH + }; + + const arm_cfft_instance_f32 arm_cfft_sR_f32_len256 = { + 256, twiddleCoef_256, armBitRevIndexTable256, ARMBITREVINDEXTABLE_256_TABLE_LENGTH + }; + + const arm_cfft_instance_f32 arm_cfft_sR_f32_len512 = { + 512, twiddleCoef_512, armBitRevIndexTable512, ARMBITREVINDEXTABLE_512_TABLE_LENGTH + }; + + const arm_cfft_instance_f32 arm_cfft_sR_f32_len1024 = { + 1024, twiddleCoef_1024, armBitRevIndexTable1024, ARMBITREVINDEXTABLE1024_TABLE_LENGTH + }; + + const arm_cfft_instance_f32 arm_cfft_sR_f32_len2048 = { + 2048, twiddleCoef_2048, armBitRevIndexTable2048, ARMBITREVINDEXTABLE2048_TABLE_LENGTH + }; + + const arm_cfft_instance_f32 arm_cfft_sR_f32_len4096 = { + 4096, twiddleCoef_4096, armBitRevIndexTable4096, ARMBITREVINDEXTABLE4096_TABLE_LENGTH + }; + +#endif diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/arm_math.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/arm_math.h new file mode 100644 index 00000000..59662ae1 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/arm_math.h @@ -0,0 +1,7306 @@ +/* ---------------------------------------------------------------------- +* Copyright (C) 2010-2013 ARM Limited. All rights reserved. +* +* $Date: 17. January 2013 +* $Revision: V1.4.1 +* +* Project: CMSIS DSP Library +* Title: arm_math.h +* +* Description: Public header file for CMSIS DSP Library +* +* Target Processor: Cortex-M4/Cortex-M3/Cortex-M0 +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* - Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* - Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in +* the documentation and/or other materials provided with the +* distribution. +* - Neither the name of ARM LIMITED nor the names of its contributors +* may be used to endorse or promote products derived from this +* software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. + * -------------------------------------------------------------------- */ + +/** + \mainpage CMSIS DSP Software Library + * + * Introduction + * + * This user manual describes the CMSIS DSP software library, + * a suite of common signal processing functions for use on Cortex-M processor based devices. + * + * The library is divided into a number of functions each covering a specific category: + * - Basic math functions + * - Fast math functions + * - Complex math functions + * - Filters + * - Matrix functions + * - Transforms + * - Motor control functions + * - Statistical functions + * - Support functions + * - Interpolation functions + * + * The library has separate functions for operating on 8-bit integers, 16-bit integers, + * 32-bit integer and 32-bit floating-point values. + * + * Using the Library + * + * The library installer contains prebuilt versions of the libraries in the Lib folder. + * - arm_cortexM4lf_math.lib (Little endian and Floating Point Unit on Cortex-M4) + * - arm_cortexM4bf_math.lib (Big endian and Floating Point Unit on Cortex-M4) + * - arm_cortexM4l_math.lib (Little endian on Cortex-M4) + * - arm_cortexM4b_math.lib (Big endian on Cortex-M4) + * - arm_cortexM3l_math.lib (Little endian on Cortex-M3) + * - arm_cortexM3b_math.lib (Big endian on Cortex-M3) + * - arm_cortexM0l_math.lib (Little endian on Cortex-M0) + * - arm_cortexM0b_math.lib (Big endian on Cortex-M3) + * + * The library functions are declared in the public file arm_math.h which is placed in the Include folder. + * Simply include this file and link the appropriate library in the application and begin calling the library functions. The Library supports single + * public header file arm_math.h for Cortex-M4/M3/M0 with little endian and big endian. Same header file will be used for floating point unit(FPU) variants. + * Define the appropriate pre processor MACRO ARM_MATH_CM4 or ARM_MATH_CM3 or + * ARM_MATH_CM0 or ARM_MATH_CM0PLUS depending on the target processor in the application. + * + * Examples + * + * The library ships with a number of examples which demonstrate how to use the library functions. + * + * Toolchain Support + * + * The library has been developed and tested with MDK-ARM version 4.60. + * The library is being tested in GCC and IAR toolchains and updates on this activity will be made available shortly. + * + * Building the Library + * + * The library installer contains project files to re build libraries on MDK Tool chain in the CMSIS\\DSP_Lib\\Source\\ARM folder. + * - arm_cortexM0b_math.uvproj + * - arm_cortexM0l_math.uvproj + * - arm_cortexM3b_math.uvproj + * - arm_cortexM3l_math.uvproj + * - arm_cortexM4b_math.uvproj + * - arm_cortexM4l_math.uvproj + * - arm_cortexM4bf_math.uvproj + * - arm_cortexM4lf_math.uvproj + * + * + * The project can be built by opening the appropriate project in MDK-ARM 4.60 chain and defining the optional pre processor MACROs detailed above. + * + * Pre-processor Macros + * + * Each library project have differant pre-processor macros. + * + * - UNALIGNED_SUPPORT_DISABLE: + * + * Define macro UNALIGNED_SUPPORT_DISABLE, If the silicon does not support unaligned memory access + * + * - ARM_MATH_BIG_ENDIAN: + * + * Define macro ARM_MATH_BIG_ENDIAN to build the library for big endian targets. By default library builds for little endian targets. + * + * - ARM_MATH_MATRIX_CHECK: + * + * Define macro ARM_MATH_MATRIX_CHECK for checking on the input and output sizes of matrices + * + * - ARM_MATH_ROUNDING: + * + * Define macro ARM_MATH_ROUNDING for rounding on support functions + * + * - ARM_MATH_CMx: + * + * Define macro ARM_MATH_CM4 for building the library on Cortex-M4 target, ARM_MATH_CM3 for building library on Cortex-M3 target + * and ARM_MATH_CM0 for building library on cortex-M0 target, ARM_MATH_CM0PLUS for building library on cortex-M0+ target. + * + * - __FPU_PRESENT: + * + * Initialize macro __FPU_PRESENT = 1 when building on FPU supported Targets. Enable this macro for M4bf and M4lf libraries + * + * Copyright Notice + * + * Copyright (C) 2010-2013 ARM Limited. All rights reserved. + */ + + +/** + * @defgroup groupMath Basic Math Functions + */ + +/** + * @defgroup groupFastMath Fast Math Functions + * This set of functions provides a fast approximation to sine, cosine, and square root. + * As compared to most of the other functions in the CMSIS math library, the fast math functions + * operate on individual values and not arrays. + * There are separate functions for Q15, Q31, and floating-point data. + * + */ + +/** + * @defgroup groupCmplxMath Complex Math Functions + * This set of functions operates on complex data vectors. + * The data in the complex arrays is stored in an interleaved fashion + * (real, imag, real, imag, ...). + * In the API functions, the number of samples in a complex array refers + * to the number of complex values; the array contains twice this number of + * real values. + */ + +/** + * @defgroup groupFilters Filtering Functions + */ + +/** + * @defgroup groupMatrix Matrix Functions + * + * This set of functions provides basic matrix math operations. + * The functions operate on matrix data structures. For example, + * the type + * definition for the floating-point matrix structure is shown + * below: + * 
    + *     typedef struct
+ *     {
+ *       uint16_t numRows;     // number of rows of the matrix.
+ *       uint16_t numCols;     // number of columns of the matrix.
+ *       float32_t *pData;     // points to the data of the matrix.
+ *     } arm_matrix_instance_f32;
+ *
    + * There are similar definitions for Q15 and Q31 data types. + * + * The structure specifies the size of the matrix and then points to + * an array of data. The array is of size numRows X numCols + * and the values are arranged in row order. That is, the + * matrix element (i, j) is stored at: + * 
    + *     pData[i*numCols + j]
+ *
    + * + * \par Init Functions + * There is an associated initialization function for each type of matrix + * data structure. + * The initialization function sets the values of the internal structure fields. + * Refer to the function arm_mat_init_f32(), arm_mat_init_q31() + * and arm_mat_init_q15() for floating-point, Q31 and Q15 types, respectively. + * + * \par + * Use of the initialization function is optional. However, if initialization function is used + * then the instance structure cannot be placed into a const data section. + * To place the instance structure in a const data + * section, manually initialize the data structure. For example: + * 
    + * arm_matrix_instance_f32 S = {nRows, nColumns, pData};
+ * arm_matrix_instance_q31 S = {nRows, nColumns, pData};
+ * arm_matrix_instance_q15 S = {nRows, nColumns, pData};
+ *
    + * where nRows specifies the number of rows, nColumns + * specifies the number of columns, and pData points to the + * data array. + * + * \par Size Checking + * By default all of the matrix functions perform size checking on the input and + * output matrices. For example, the matrix addition function verifies that the + * two input matrices and the output matrix all have the same number of rows and + * columns. If the size check fails the functions return: + * 
    + *     ARM_MATH_SIZE_MISMATCH
+ *
    + * Otherwise the functions return + * 
    + *     ARM_MATH_SUCCESS
+ *
    + * There is some overhead associated with this matrix size checking. + * The matrix size checking is enabled via the \#define + * 
    + *     ARM_MATH_MATRIX_CHECK
+ *
    + * within the library project settings. By default this macro is defined + * and size checking is enabled. By changing the project settings and + * undefining this macro size checking is eliminated and the functions + * run a bit faster. With size checking disabled the functions always + * return ARM_MATH_SUCCESS. + */ + +/** + * @defgroup groupTransforms Transform Functions + */ + +/** + * @defgroup groupController Controller Functions + */ + +/** + * @defgroup groupStats Statistics Functions + */ +/** + * @defgroup groupSupport Support Functions + */ + +/** + * @defgroup groupInterpolation Interpolation Functions + * These functions perform 1- and 2-dimensional interpolation of data. + * Linear interpolation is used for 1-dimensional data and + * bilinear interpolation is used for 2-dimensional data. + */ + +/** + * @defgroup groupExamples Examples + */ +#ifndef _ARM_MATH_H +#define _ARM_MATH_H + +#define __CMSIS_GENERIC /* disable NVIC and Systick functions */ + +#if defined (ARM_MATH_CM4) +#include "core_cm4.h" +#elif defined (ARM_MATH_CM3) +#include "core_cm3.h" +#elif defined (ARM_MATH_CM0) +#include "core_cm0.h" +#define ARM_MATH_CM0_FAMILY +#elif defined (ARM_MATH_CM0PLUS) +#include "core_cm0plus.h" +#define ARM_MATH_CM0_FAMILY +#else +#include "ARMCM4.h" +#warning "Define either ARM_MATH_CM4 OR ARM_MATH_CM3...By Default building on ARM_MATH_CM4....." +#endif + +#undef __CMSIS_GENERIC /* enable NVIC and Systick functions */ +#include "string.h" +#include "math.h" +#ifdef __cplusplus +extern "C" +{ +#endif + + + /** + * @brief Macros required for reciprocal calculation in Normalized LMS + */ + +#define DELTA_Q31 (0x100) +#define DELTA_Q15 0x5 +#define INDEX_MASK 0x0000003F +#ifndef PI +#define PI 3.14159265358979f +#endif + + /** + * @brief Macros required for SINE and COSINE Fast math approximations + */ + +#define TABLE_SIZE 256 +#define TABLE_SPACING_Q31 0x800000 +#define TABLE_SPACING_Q15 0x80 + + /** + * @brief Macros required for SINE and COSINE Controller functions + */ + /* 1.31(q31) Fixed value of 2/360 */ + /* -1 to +1 is divided into 360 values so total spacing is (2/360) */ +#define INPUT_SPACING 0xB60B61 + + /** + * @brief Macro for Unaligned Support + */ +#ifndef UNALIGNED_SUPPORT_DISABLE + #define ALIGN4 +#else + #if defined (__GNUC__) + #define ALIGN4 __attribute__((aligned(4))) + #else + #define ALIGN4 __align(4) + #endif +#endif /* #ifndef UNALIGNED_SUPPORT_DISABLE */ + + /** + * @brief Error status returned by some functions in the library. + */ + + typedef enum + { + ARM_MATH_SUCCESS = 0, /**< No error */ + ARM_MATH_ARGUMENT_ERROR = -1, /**< One or more arguments are incorrect */ + ARM_MATH_LENGTH_ERROR = -2, /**< Length of data buffer is incorrect */ + ARM_MATH_SIZE_MISMATCH = -3, /**< Size of matrices is not compatible with the operation. */ + ARM_MATH_NANINF = -4, /**< Not-a-number (NaN) or infinity is generated */ + ARM_MATH_SINGULAR = -5, /**< Generated by matrix inversion if the input matrix is singular and cannot be inverted. */ + ARM_MATH_TEST_FAILURE = -6 /**< Test Failed */ + } arm_status; + + /** + * @brief 8-bit fractional data type in 1.7 format. + */ + typedef int8_t q7_t; + + /** + * @brief 16-bit fractional data type in 1.15 format. + */ + typedef int16_t q15_t; + + /** + * @brief 32-bit fractional data type in 1.31 format. + */ + typedef int32_t q31_t; + + /** + * @brief 64-bit fractional data type in 1.63 format. + */ + typedef int64_t q63_t; + + /** + * @brief 32-bit floating-point type definition. + */ + typedef float float32_t; + + /** + * @brief 64-bit floating-point type definition. + */ + typedef double float64_t; + + /** + * @brief definition to read/write two 16 bit values. + */ +#if defined __CC_ARM +#define __SIMD32_TYPE int32_t __packed +#define CMSIS_UNUSED __attribute__((unused)) +#elif defined __ICCARM__ +#define CMSIS_UNUSED +#define __SIMD32_TYPE int32_t __packed +#elif defined __GNUC__ +#define __SIMD32_TYPE int32_t +#define CMSIS_UNUSED __attribute__((unused)) +#else +#error Unknown compiler +#endif + +#define __SIMD32(addr) (*(__SIMD32_TYPE **) & (addr)) +#define __SIMD32_CONST(addr) ((__SIMD32_TYPE *)(addr)) + +#define _SIMD32_OFFSET(addr) (*(__SIMD32_TYPE *) (addr)) + +#define __SIMD64(addr) (*(int64_t **) & (addr)) + +#if defined (ARM_MATH_CM3) || defined (ARM_MATH_CM0_FAMILY) + /** + * @brief definition to pack two 16 bit values. + */ +#define __PKHBT(ARG1, ARG2, ARG3) ( (((int32_t)(ARG1) << 0) & (int32_t)0x0000FFFF) | \ + (((int32_t)(ARG2) << ARG3) & (int32_t)0xFFFF0000) ) +#define __PKHTB(ARG1, ARG2, ARG3) ( (((int32_t)(ARG1) << 0) & (int32_t)0xFFFF0000) | \ + (((int32_t)(ARG2) >> ARG3) & (int32_t)0x0000FFFF) ) + +#endif + + + /** + * @brief definition to pack four 8 bit values. + */ +#ifndef ARM_MATH_BIG_ENDIAN + +#define __PACKq7(v0,v1,v2,v3) ( (((int32_t)(v0) << 0) & (int32_t)0x000000FF) | \ + (((int32_t)(v1) << 8) & (int32_t)0x0000FF00) | \ + (((int32_t)(v2) << 16) & (int32_t)0x00FF0000) | \ + (((int32_t)(v3) << 24) & (int32_t)0xFF000000) ) +#else + +#define __PACKq7(v0,v1,v2,v3) ( (((int32_t)(v3) << 0) & (int32_t)0x000000FF) | \ + (((int32_t)(v2) << 8) & (int32_t)0x0000FF00) | \ + (((int32_t)(v1) << 16) & (int32_t)0x00FF0000) | \ + (((int32_t)(v0) << 24) & (int32_t)0xFF000000) ) + +#endif + + + /** + * @brief Clips Q63 to Q31 values. + */ + static __INLINE q31_t clip_q63_to_q31( + q63_t x) + { + return ((q31_t) (x >> 32) != ((q31_t) x >> 31)) ? + ((0x7FFFFFFF ^ ((q31_t) (x >> 63)))) : (q31_t) x; + } + + /** + * @brief Clips Q63 to Q15 values. + */ + static __INLINE q15_t clip_q63_to_q15( + q63_t x) + { + return ((q31_t) (x >> 32) != ((q31_t) x >> 31)) ? + ((0x7FFF ^ ((q15_t) (x >> 63)))) : (q15_t) (x >> 15); + } + + /** + * @brief Clips Q31 to Q7 values. + */ + static __INLINE q7_t clip_q31_to_q7( + q31_t x) + { + return ((q31_t) (x >> 24) != ((q31_t) x >> 23)) ? + ((0x7F ^ ((q7_t) (x >> 31)))) : (q7_t) x; + } + + /** + * @brief Clips Q31 to Q15 values. + */ + static __INLINE q15_t clip_q31_to_q15( + q31_t x) + { + return ((q31_t) (x >> 16) != ((q31_t) x >> 15)) ? + ((0x7FFF ^ ((q15_t) (x >> 31)))) : (q15_t) x; + } + + /** + * @brief Multiplies 32 X 64 and returns 32 bit result in 2.30 format. + */ + + static __INLINE q63_t mult32x64( + q63_t x, + q31_t y) + { + return ((((q63_t) (x & 0x00000000FFFFFFFF) * y) >> 32) + + (((q63_t) (x >> 32) * y))); + } + + +#if defined (ARM_MATH_CM0_FAMILY) && defined ( __CC_ARM ) +#define __CLZ __clz +#endif + +#if defined (ARM_MATH_CM0_FAMILY) && ((defined (__ICCARM__)) ||(defined (__GNUC__)) || defined (__TASKING__) ) + + static __INLINE uint32_t __CLZ( + q31_t data); + + + static __INLINE uint32_t __CLZ( + q31_t data) + { + uint32_t count = 0; + uint32_t mask = 0x80000000; + + while((data & mask) == 0) + { + count += 1u; + mask = mask >> 1u; + } + + return (count); + + } + +#endif + + /** + * @brief Function to Calculates 1/in (reciprocal) value of Q31 Data type. + */ + + static __INLINE uint32_t arm_recip_q31( + q31_t in, + q31_t * dst, + q31_t * pRecipTable) + { + + uint32_t out, tempVal; + uint32_t index, i; + uint32_t signBits; + + if(in > 0) + { + signBits = __CLZ(in) - 1; + } + else + { + signBits = __CLZ(-in) - 1; + } + + /* Convert input sample to 1.31 format */ + in = in << signBits; + + /* calculation of index for initial approximated Val */ + index = (uint32_t) (in >> 24u); + index = (index & INDEX_MASK); + + /* 1.31 with exp 1 */ + out = pRecipTable[index]; + + /* calculation of reciprocal value */ + /* running approximation for two iterations */ + for (i = 0u; i < 2u; i++) + { + tempVal = (q31_t) (((q63_t) in * out) >> 31u); + tempVal = 0x7FFFFFFF - tempVal; + /* 1.31 with exp 1 */ + //out = (q31_t) (((q63_t) out * tempVal) >> 30u); + out = (q31_t) clip_q63_to_q31(((q63_t) out * tempVal) >> 30u); + } + + /* write output */ + *dst = out; + + /* return num of signbits of out = 1/in value */ + return (signBits + 1u); + + } + + /** + * @brief Function to Calculates 1/in (reciprocal) value of Q15 Data type. + */ + static __INLINE uint32_t arm_recip_q15( + q15_t in, + q15_t * dst, + q15_t * pRecipTable) + { + + uint32_t out = 0, tempVal = 0; + uint32_t index = 0, i = 0; + uint32_t signBits = 0; + + if(in > 0) + { + signBits = __CLZ(in) - 17; + } + else + { + signBits = __CLZ(-in) - 17; + } + + /* Convert input sample to 1.15 format */ + in = in << signBits; + + /* calculation of index for initial approximated Val */ + index = in >> 8; + index = (index & INDEX_MASK); + + /* 1.15 with exp 1 */ + out = pRecipTable[index]; + + /* calculation of reciprocal value */ + /* running approximation for two iterations */ + for (i = 0; i < 2; i++) + { + tempVal = (q15_t) (((q31_t) in * out) >> 15); + tempVal = 0x7FFF - tempVal; + /* 1.15 with exp 1 */ + out = (q15_t) (((q31_t) out * tempVal) >> 14); + } + + /* write output */ + *dst = out; + + /* return num of signbits of out = 1/in value */ + return (signBits + 1); + + } + + + /* + * @brief C custom defined intrinisic function for only M0 processors + */ +#if defined(ARM_MATH_CM0_FAMILY) + + static __INLINE q31_t __SSAT( + q31_t x, + uint32_t y) + { + int32_t posMax, negMin; + uint32_t i; + + posMax = 1; + for (i = 0; i < (y - 1); i++) + { + posMax = posMax * 2; + } + + if(x > 0) + { + posMax = (posMax - 1); + + if(x > posMax) + { + x = posMax; + } + } + else + { + negMin = -posMax; + + if(x < negMin) + { + x = negMin; + } + } + return (x); + + + } + +#endif /* end of ARM_MATH_CM0_FAMILY */ + + + + /* + * @brief C custom defined intrinsic function for M3 and M0 processors + */ +#if defined (ARM_MATH_CM3) || defined (ARM_MATH_CM0_FAMILY) + + /* + * @brief C custom defined QADD8 for M3 and M0 processors + */ + static __INLINE q31_t __QADD8( + q31_t x, + q31_t y) + { + + q31_t sum; + q7_t r, s, t, u; + + r = (q7_t) x; + s = (q7_t) y; + + r = __SSAT((q31_t) (r + s), 8); + s = __SSAT(((q31_t) (((x << 16) >> 24) + ((y << 16) >> 24))), 8); + t = __SSAT(((q31_t) (((x << 8) >> 24) + ((y << 8) >> 24))), 8); + u = __SSAT(((q31_t) ((x >> 24) + (y >> 24))), 8); + + sum = + (((q31_t) u << 24) & 0xFF000000) | (((q31_t) t << 16) & 0x00FF0000) | + (((q31_t) s << 8) & 0x0000FF00) | (r & 0x000000FF); + + return sum; + + } + + /* + * @brief C custom defined QSUB8 for M3 and M0 processors + */ + static __INLINE q31_t __QSUB8( + q31_t x, + q31_t y) + { + + q31_t sum; + q31_t r, s, t, u; + + r = (q7_t) x; + s = (q7_t) y; + + r = __SSAT((r - s), 8); + s = __SSAT(((q31_t) (((x << 16) >> 24) - ((y << 16) >> 24))), 8) << 8; + t = __SSAT(((q31_t) (((x << 8) >> 24) - ((y << 8) >> 24))), 8) << 16; + u = __SSAT(((q31_t) ((x >> 24) - (y >> 24))), 8) << 24; + + sum = + (u & 0xFF000000) | (t & 0x00FF0000) | (s & 0x0000FF00) | (r & + 0x000000FF); + + return sum; + } + + /* + * @brief C custom defined QADD16 for M3 and M0 processors + */ + + /* + * @brief C custom defined QADD16 for M3 and M0 processors + */ + static __INLINE q31_t __QADD16( + q31_t x, + q31_t y) + { + + q31_t sum; + q31_t r, s; + + r = (short) x; + s = (short) y; + + r = __SSAT(r + s, 16); + s = __SSAT(((q31_t) ((x >> 16) + (y >> 16))), 16) << 16; + + sum = (s & 0xFFFF0000) | (r & 0x0000FFFF); + + return sum; + + } + + /* + * @brief C custom defined SHADD16 for M3 and M0 processors + */ + static __INLINE q31_t __SHADD16( + q31_t x, + q31_t y) + { + + q31_t sum; + q31_t r, s; + + r = (short) x; + s = (short) y; + + r = ((r >> 1) + (s >> 1)); + s = ((q31_t) ((x >> 17) + (y >> 17))) << 16; + + sum = (s & 0xFFFF0000) | (r & 0x0000FFFF); + + return sum; + + } + + /* + * @brief C custom defined QSUB16 for M3 and M0 processors + */ + static __INLINE q31_t __QSUB16( + q31_t x, + q31_t y) + { + + q31_t sum; + q31_t r, s; + + r = (short) x; + s = (short) y; + + r = __SSAT(r - s, 16); + s = __SSAT(((q31_t) ((x >> 16) - (y >> 16))), 16) << 16; + + sum = (s & 0xFFFF0000) | (r & 0x0000FFFF); + + return sum; + } + + /* + * @brief C custom defined SHSUB16 for M3 and M0 processors + */ + static __INLINE q31_t __SHSUB16( + q31_t x, + q31_t y) + { + + q31_t diff; + q31_t r, s; + + r = (short) x; + s = (short) y; + + r = ((r >> 1) - (s >> 1)); + s = (((x >> 17) - (y >> 17)) << 16); + + diff = (s & 0xFFFF0000) | (r & 0x0000FFFF); + + return diff; + } + + /* + * @brief C custom defined QASX for M3 and M0 processors + */ + static __INLINE q31_t __QASX( + q31_t x, + q31_t y) + { + + q31_t sum = 0; + + sum = + ((sum + + clip_q31_to_q15((q31_t) ((short) (x >> 16) + (short) y))) << 16) + + clip_q31_to_q15((q31_t) ((short) x - (short) (y >> 16))); + + return sum; + } + + /* + * @brief C custom defined SHASX for M3 and M0 processors + */ + static __INLINE q31_t __SHASX( + q31_t x, + q31_t y) + { + + q31_t sum; + q31_t r, s; + + r = (short) x; + s = (short) y; + + r = ((r >> 1) - (y >> 17)); + s = (((x >> 17) + (s >> 1)) << 16); + + sum = (s & 0xFFFF0000) | (r & 0x0000FFFF); + + return sum; + } + + + /* + * @brief C custom defined QSAX for M3 and M0 processors + */ + static __INLINE q31_t __QSAX( + q31_t x, + q31_t y) + { + + q31_t sum = 0; + + sum = + ((sum + + clip_q31_to_q15((q31_t) ((short) (x >> 16) - (short) y))) << 16) + + clip_q31_to_q15((q31_t) ((short) x + (short) (y >> 16))); + + return sum; + } + + /* + * @brief C custom defined SHSAX for M3 and M0 processors + */ + static __INLINE q31_t __SHSAX( + q31_t x, + q31_t y) + { + + q31_t sum; + q31_t r, s; + + r = (short) x; + s = (short) y; + + r = ((r >> 1) + (y >> 17)); + s = (((x >> 17) - (s >> 1)) << 16); + + sum = (s & 0xFFFF0000) | (r & 0x0000FFFF); + + return sum; + } + + /* + * @brief C custom defined SMUSDX for M3 and M0 processors + */ + static __INLINE q31_t __SMUSDX( + q31_t x, + q31_t y) + { + + return ((q31_t) (((short) x * (short) (y >> 16)) - + ((short) (x >> 16) * (short) y))); + } + + /* + * @brief C custom defined SMUADX for M3 and M0 processors + */ + static __INLINE q31_t __SMUADX( + q31_t x, + q31_t y) + { + + return ((q31_t) (((short) x * (short) (y >> 16)) + + ((short) (x >> 16) * (short) y))); + } + + /* + * @brief C custom defined QADD for M3 and M0 processors + */ + static __INLINE q31_t __QADD( + q31_t x, + q31_t y) + { + return clip_q63_to_q31((q63_t) x + y); + } + + /* + * @brief C custom defined QSUB for M3 and M0 processors + */ + static __INLINE q31_t __QSUB( + q31_t x, + q31_t y) + { + return clip_q63_to_q31((q63_t) x - y); + } + + /* + * @brief C custom defined SMLAD for M3 and M0 processors + */ + static __INLINE q31_t __SMLAD( + q31_t x, + q31_t y, + q31_t sum) + { + + return (sum + ((short) (x >> 16) * (short) (y >> 16)) + + ((short) x * (short) y)); + } + + /* + * @brief C custom defined SMLADX for M3 and M0 processors + */ + static __INLINE q31_t __SMLADX( + q31_t x, + q31_t y, + q31_t sum) + { + + return (sum + ((short) (x >> 16) * (short) (y)) + + ((short) x * (short) (y >> 16))); + } + + /* + * @brief C custom defined SMLSDX for M3 and M0 processors + */ + static __INLINE q31_t __SMLSDX( + q31_t x, + q31_t y, + q31_t sum) + { + + return (sum - ((short) (x >> 16) * (short) (y)) + + ((short) x * (short) (y >> 16))); + } + + /* + * @brief C custom defined SMLALD for M3 and M0 processors + */ + static __INLINE q63_t __SMLALD( + q31_t x, + q31_t y, + q63_t sum) + { + + return (sum + ((short) (x >> 16) * (short) (y >> 16)) + + ((short) x * (short) y)); + } + + /* + * @brief C custom defined SMLALDX for M3 and M0 processors + */ + static __INLINE q63_t __SMLALDX( + q31_t x, + q31_t y, + q63_t sum) + { + + return (sum + ((short) (x >> 16) * (short) y)) + + ((short) x * (short) (y >> 16)); + } + + /* + * @brief C custom defined SMUAD for M3 and M0 processors + */ + static __INLINE q31_t __SMUAD( + q31_t x, + q31_t y) + { + + return (((x >> 16) * (y >> 16)) + + (((x << 16) >> 16) * ((y << 16) >> 16))); + } + + /* + * @brief C custom defined SMUSD for M3 and M0 processors + */ + static __INLINE q31_t __SMUSD( + q31_t x, + q31_t y) + { + + return (-((x >> 16) * (y >> 16)) + + (((x << 16) >> 16) * ((y << 16) >> 16))); + } + + + /* + * @brief C custom defined SXTB16 for M3 and M0 processors + */ + static __INLINE q31_t __SXTB16( + q31_t x) + { + + return ((((x << 24) >> 24) & 0x0000FFFF) | + (((x << 8) >> 8) & 0xFFFF0000)); + } + + +#endif /* defined (ARM_MATH_CM3) || defined (ARM_MATH_CM0_FAMILY) */ + + + /** + * @brief Instance structure for the Q7 FIR filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of filter coefficients in the filter. */ + q7_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + q7_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + } arm_fir_instance_q7; + + /** + * @brief Instance structure for the Q15 FIR filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of filter coefficients in the filter. */ + q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + } arm_fir_instance_q15; + + /** + * @brief Instance structure for the Q31 FIR filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of filter coefficients in the filter. */ + q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + } arm_fir_instance_q31; + + /** + * @brief Instance structure for the floating-point FIR filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of filter coefficients in the filter. */ + float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + } arm_fir_instance_f32; + + + /** + * @brief Processing function for the Q7 FIR filter. + * @param[in] *S points to an instance of the Q7 FIR filter structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + void arm_fir_q7( + const arm_fir_instance_q7 * S, + q7_t * pSrc, + q7_t * pDst, + uint32_t blockSize); + + + /** + * @brief Initialization function for the Q7 FIR filter. + * @param[in,out] *S points to an instance of the Q7 FIR structure. + * @param[in] numTaps Number of filter coefficients in the filter. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] blockSize number of samples that are processed. + * @return none + */ + void arm_fir_init_q7( + arm_fir_instance_q7 * S, + uint16_t numTaps, + q7_t * pCoeffs, + q7_t * pState, + uint32_t blockSize); + + + /** + * @brief Processing function for the Q15 FIR filter. + * @param[in] *S points to an instance of the Q15 FIR structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + void arm_fir_q15( + const arm_fir_instance_q15 * S, + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Processing function for the fast Q15 FIR filter for Cortex-M3 and Cortex-M4. + * @param[in] *S points to an instance of the Q15 FIR filter structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + void arm_fir_fast_q15( + const arm_fir_instance_q15 * S, + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the Q15 FIR filter. + * @param[in,out] *S points to an instance of the Q15 FIR filter structure. + * @param[in] numTaps Number of filter coefficients in the filter. Must be even and greater than or equal to 4. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] blockSize number of samples that are processed at a time. + * @return The function returns ARM_MATH_SUCCESS if initialization was successful or ARM_MATH_ARGUMENT_ERROR if + * numTaps is not a supported value. + */ + + arm_status arm_fir_init_q15( + arm_fir_instance_q15 * S, + uint16_t numTaps, + q15_t * pCoeffs, + q15_t * pState, + uint32_t blockSize); + + /** + * @brief Processing function for the Q31 FIR filter. + * @param[in] *S points to an instance of the Q31 FIR filter structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + void arm_fir_q31( + const arm_fir_instance_q31 * S, + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Processing function for the fast Q31 FIR filter for Cortex-M3 and Cortex-M4. + * @param[in] *S points to an instance of the Q31 FIR structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + void arm_fir_fast_q31( + const arm_fir_instance_q31 * S, + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the Q31 FIR filter. + * @param[in,out] *S points to an instance of the Q31 FIR structure. + * @param[in] numTaps Number of filter coefficients in the filter. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] blockSize number of samples that are processed at a time. + * @return none. + */ + void arm_fir_init_q31( + arm_fir_instance_q31 * S, + uint16_t numTaps, + q31_t * pCoeffs, + q31_t * pState, + uint32_t blockSize); + + /** + * @brief Processing function for the floating-point FIR filter. + * @param[in] *S points to an instance of the floating-point FIR structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + void arm_fir_f32( + const arm_fir_instance_f32 * S, + float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the floating-point FIR filter. + * @param[in,out] *S points to an instance of the floating-point FIR filter structure. + * @param[in] numTaps Number of filter coefficients in the filter. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] blockSize number of samples that are processed at a time. + * @return none. + */ + void arm_fir_init_f32( + arm_fir_instance_f32 * S, + uint16_t numTaps, + float32_t * pCoeffs, + float32_t * pState, + uint32_t blockSize); + + + /** + * @brief Instance structure for the Q15 Biquad cascade filter. + */ + typedef struct + { + int8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ + q15_t *pState; /**< Points to the array of state coefficients. The array is of length 4*numStages. */ + q15_t *pCoeffs; /**< Points to the array of coefficients. The array is of length 5*numStages. */ + int8_t postShift; /**< Additional shift, in bits, applied to each output sample. */ + + } arm_biquad_casd_df1_inst_q15; + + + /** + * @brief Instance structure for the Q31 Biquad cascade filter. + */ + typedef struct + { + uint32_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ + q31_t *pState; /**< Points to the array of state coefficients. The array is of length 4*numStages. */ + q31_t *pCoeffs; /**< Points to the array of coefficients. The array is of length 5*numStages. */ + uint8_t postShift; /**< Additional shift, in bits, applied to each output sample. */ + + } arm_biquad_casd_df1_inst_q31; + + /** + * @brief Instance structure for the floating-point Biquad cascade filter. + */ + typedef struct + { + uint32_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ + float32_t *pState; /**< Points to the array of state coefficients. The array is of length 4*numStages. */ + float32_t *pCoeffs; /**< Points to the array of coefficients. The array is of length 5*numStages. */ + + + } arm_biquad_casd_df1_inst_f32; + + + + /** + * @brief Processing function for the Q15 Biquad cascade filter. + * @param[in] *S points to an instance of the Q15 Biquad cascade structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_biquad_cascade_df1_q15( + const arm_biquad_casd_df1_inst_q15 * S, + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the Q15 Biquad cascade filter. + * @param[in,out] *S points to an instance of the Q15 Biquad cascade structure. + * @param[in] numStages number of 2nd order stages in the filter. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] postShift Shift to be applied to the output. Varies according to the coefficients format + * @return none + */ + + void arm_biquad_cascade_df1_init_q15( + arm_biquad_casd_df1_inst_q15 * S, + uint8_t numStages, + q15_t * pCoeffs, + q15_t * pState, + int8_t postShift); + + + /** + * @brief Fast but less precise processing function for the Q15 Biquad cascade filter for Cortex-M3 and Cortex-M4. + * @param[in] *S points to an instance of the Q15 Biquad cascade structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_biquad_cascade_df1_fast_q15( + const arm_biquad_casd_df1_inst_q15 * S, + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + + /** + * @brief Processing function for the Q31 Biquad cascade filter + * @param[in] *S points to an instance of the Q31 Biquad cascade structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_biquad_cascade_df1_q31( + const arm_biquad_casd_df1_inst_q31 * S, + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Fast but less precise processing function for the Q31 Biquad cascade filter for Cortex-M3 and Cortex-M4. + * @param[in] *S points to an instance of the Q31 Biquad cascade structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_biquad_cascade_df1_fast_q31( + const arm_biquad_casd_df1_inst_q31 * S, + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the Q31 Biquad cascade filter. + * @param[in,out] *S points to an instance of the Q31 Biquad cascade structure. + * @param[in] numStages number of 2nd order stages in the filter. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] postShift Shift to be applied to the output. Varies according to the coefficients format + * @return none + */ + + void arm_biquad_cascade_df1_init_q31( + arm_biquad_casd_df1_inst_q31 * S, + uint8_t numStages, + q31_t * pCoeffs, + q31_t * pState, + int8_t postShift); + + /** + * @brief Processing function for the floating-point Biquad cascade filter. + * @param[in] *S points to an instance of the floating-point Biquad cascade structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_biquad_cascade_df1_f32( + const arm_biquad_casd_df1_inst_f32 * S, + float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the floating-point Biquad cascade filter. + * @param[in,out] *S points to an instance of the floating-point Biquad cascade structure. + * @param[in] numStages number of 2nd order stages in the filter. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @return none + */ + + void arm_biquad_cascade_df1_init_f32( + arm_biquad_casd_df1_inst_f32 * S, + uint8_t numStages, + float32_t * pCoeffs, + float32_t * pState); + + + /** + * @brief Instance structure for the floating-point matrix structure. + */ + + typedef struct + { + uint16_t numRows; /**< number of rows of the matrix. */ + uint16_t numCols; /**< number of columns of the matrix. */ + float32_t *pData; /**< points to the data of the matrix. */ + } arm_matrix_instance_f32; + + /** + * @brief Instance structure for the Q15 matrix structure. + */ + + typedef struct + { + uint16_t numRows; /**< number of rows of the matrix. */ + uint16_t numCols; /**< number of columns of the matrix. */ + q15_t *pData; /**< points to the data of the matrix. */ + + } arm_matrix_instance_q15; + + /** + * @brief Instance structure for the Q31 matrix structure. + */ + + typedef struct + { + uint16_t numRows; /**< number of rows of the matrix. */ + uint16_t numCols; /**< number of columns of the matrix. */ + q31_t *pData; /**< points to the data of the matrix. */ + + } arm_matrix_instance_q31; + + + + /** + * @brief Floating-point matrix addition. + * @param[in] *pSrcA points to the first input matrix structure + * @param[in] *pSrcB points to the second input matrix structure + * @param[out] *pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_add_f32( + const arm_matrix_instance_f32 * pSrcA, + const arm_matrix_instance_f32 * pSrcB, + arm_matrix_instance_f32 * pDst); + + /** + * @brief Q15 matrix addition. + * @param[in] *pSrcA points to the first input matrix structure + * @param[in] *pSrcB points to the second input matrix structure + * @param[out] *pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_add_q15( + const arm_matrix_instance_q15 * pSrcA, + const arm_matrix_instance_q15 * pSrcB, + arm_matrix_instance_q15 * pDst); + + /** + * @brief Q31 matrix addition. + * @param[in] *pSrcA points to the first input matrix structure + * @param[in] *pSrcB points to the second input matrix structure + * @param[out] *pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_add_q31( + const arm_matrix_instance_q31 * pSrcA, + const arm_matrix_instance_q31 * pSrcB, + arm_matrix_instance_q31 * pDst); + + + /** + * @brief Floating-point matrix transpose. + * @param[in] *pSrc points to the input matrix + * @param[out] *pDst points to the output matrix + * @return The function returns either ARM_MATH_SIZE_MISMATCH + * or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_trans_f32( + const arm_matrix_instance_f32 * pSrc, + arm_matrix_instance_f32 * pDst); + + + /** + * @brief Q15 matrix transpose. + * @param[in] *pSrc points to the input matrix + * @param[out] *pDst points to the output matrix + * @return The function returns either ARM_MATH_SIZE_MISMATCH + * or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_trans_q15( + const arm_matrix_instance_q15 * pSrc, + arm_matrix_instance_q15 * pDst); + + /** + * @brief Q31 matrix transpose. + * @param[in] *pSrc points to the input matrix + * @param[out] *pDst points to the output matrix + * @return The function returns either ARM_MATH_SIZE_MISMATCH + * or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_trans_q31( + const arm_matrix_instance_q31 * pSrc, + arm_matrix_instance_q31 * pDst); + + + /** + * @brief Floating-point matrix multiplication + * @param[in] *pSrcA points to the first input matrix structure + * @param[in] *pSrcB points to the second input matrix structure + * @param[out] *pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_mult_f32( + const arm_matrix_instance_f32 * pSrcA, + const arm_matrix_instance_f32 * pSrcB, + arm_matrix_instance_f32 * pDst); + + /** + * @brief Q15 matrix multiplication + * @param[in] *pSrcA points to the first input matrix structure + * @param[in] *pSrcB points to the second input matrix structure + * @param[out] *pDst points to output matrix structure + * @param[in] *pState points to the array for storing intermediate results + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_mult_q15( + const arm_matrix_instance_q15 * pSrcA, + const arm_matrix_instance_q15 * pSrcB, + arm_matrix_instance_q15 * pDst, + q15_t * pState); + + /** + * @brief Q15 matrix multiplication (fast variant) for Cortex-M3 and Cortex-M4 + * @param[in] *pSrcA points to the first input matrix structure + * @param[in] *pSrcB points to the second input matrix structure + * @param[out] *pDst points to output matrix structure + * @param[in] *pState points to the array for storing intermediate results + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_mult_fast_q15( + const arm_matrix_instance_q15 * pSrcA, + const arm_matrix_instance_q15 * pSrcB, + arm_matrix_instance_q15 * pDst, + q15_t * pState); + + /** + * @brief Q31 matrix multiplication + * @param[in] *pSrcA points to the first input matrix structure + * @param[in] *pSrcB points to the second input matrix structure + * @param[out] *pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_mult_q31( + const arm_matrix_instance_q31 * pSrcA, + const arm_matrix_instance_q31 * pSrcB, + arm_matrix_instance_q31 * pDst); + + /** + * @brief Q31 matrix multiplication (fast variant) for Cortex-M3 and Cortex-M4 + * @param[in] *pSrcA points to the first input matrix structure + * @param[in] *pSrcB points to the second input matrix structure + * @param[out] *pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_mult_fast_q31( + const arm_matrix_instance_q31 * pSrcA, + const arm_matrix_instance_q31 * pSrcB, + arm_matrix_instance_q31 * pDst); + + + /** + * @brief Floating-point matrix subtraction + * @param[in] *pSrcA points to the first input matrix structure + * @param[in] *pSrcB points to the second input matrix structure + * @param[out] *pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_sub_f32( + const arm_matrix_instance_f32 * pSrcA, + const arm_matrix_instance_f32 * pSrcB, + arm_matrix_instance_f32 * pDst); + + /** + * @brief Q15 matrix subtraction + * @param[in] *pSrcA points to the first input matrix structure + * @param[in] *pSrcB points to the second input matrix structure + * @param[out] *pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_sub_q15( + const arm_matrix_instance_q15 * pSrcA, + const arm_matrix_instance_q15 * pSrcB, + arm_matrix_instance_q15 * pDst); + + /** + * @brief Q31 matrix subtraction + * @param[in] *pSrcA points to the first input matrix structure + * @param[in] *pSrcB points to the second input matrix structure + * @param[out] *pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_sub_q31( + const arm_matrix_instance_q31 * pSrcA, + const arm_matrix_instance_q31 * pSrcB, + arm_matrix_instance_q31 * pDst); + + /** + * @brief Floating-point matrix scaling. + * @param[in] *pSrc points to the input matrix + * @param[in] scale scale factor + * @param[out] *pDst points to the output matrix + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_scale_f32( + const arm_matrix_instance_f32 * pSrc, + float32_t scale, + arm_matrix_instance_f32 * pDst); + + /** + * @brief Q15 matrix scaling. + * @param[in] *pSrc points to input matrix + * @param[in] scaleFract fractional portion of the scale factor + * @param[in] shift number of bits to shift the result by + * @param[out] *pDst points to output matrix + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_scale_q15( + const arm_matrix_instance_q15 * pSrc, + q15_t scaleFract, + int32_t shift, + arm_matrix_instance_q15 * pDst); + + /** + * @brief Q31 matrix scaling. + * @param[in] *pSrc points to input matrix + * @param[in] scaleFract fractional portion of the scale factor + * @param[in] shift number of bits to shift the result by + * @param[out] *pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_scale_q31( + const arm_matrix_instance_q31 * pSrc, + q31_t scaleFract, + int32_t shift, + arm_matrix_instance_q31 * pDst); + + + /** + * @brief Q31 matrix initialization. + * @param[in,out] *S points to an instance of the floating-point matrix structure. + * @param[in] nRows number of rows in the matrix. + * @param[in] nColumns number of columns in the matrix. + * @param[in] *pData points to the matrix data array. + * @return none + */ + + void arm_mat_init_q31( + arm_matrix_instance_q31 * S, + uint16_t nRows, + uint16_t nColumns, + q31_t * pData); + + /** + * @brief Q15 matrix initialization. + * @param[in,out] *S points to an instance of the floating-point matrix structure. + * @param[in] nRows number of rows in the matrix. + * @param[in] nColumns number of columns in the matrix. + * @param[in] *pData points to the matrix data array. + * @return none + */ + + void arm_mat_init_q15( + arm_matrix_instance_q15 * S, + uint16_t nRows, + uint16_t nColumns, + q15_t * pData); + + /** + * @brief Floating-point matrix initialization. + * @param[in,out] *S points to an instance of the floating-point matrix structure. + * @param[in] nRows number of rows in the matrix. + * @param[in] nColumns number of columns in the matrix. + * @param[in] *pData points to the matrix data array. + * @return none + */ + + void arm_mat_init_f32( + arm_matrix_instance_f32 * S, + uint16_t nRows, + uint16_t nColumns, + float32_t * pData); + + + + /** + * @brief Instance structure for the Q15 PID Control. + */ + typedef struct + { + q15_t A0; /**< The derived gain, A0 = Kp + Ki + Kd . */ +#ifdef ARM_MATH_CM0_FAMILY + q15_t A1; + q15_t A2; +#else + q31_t A1; /**< The derived gain A1 = -Kp - 2Kd | Kd.*/ +#endif + q15_t state[3]; /**< The state array of length 3. */ + q15_t Kp; /**< The proportional gain. */ + q15_t Ki; /**< The integral gain. */ + q15_t Kd; /**< The derivative gain. */ + } arm_pid_instance_q15; + + /** + * @brief Instance structure for the Q31 PID Control. + */ + typedef struct + { + q31_t A0; /**< The derived gain, A0 = Kp + Ki + Kd . */ + q31_t A1; /**< The derived gain, A1 = -Kp - 2Kd. */ + q31_t A2; /**< The derived gain, A2 = Kd . */ + q31_t state[3]; /**< The state array of length 3. */ + q31_t Kp; /**< The proportional gain. */ + q31_t Ki; /**< The integral gain. */ + q31_t Kd; /**< The derivative gain. */ + + } arm_pid_instance_q31; + + /** + * @brief Instance structure for the floating-point PID Control. + */ + typedef struct + { + float32_t A0; /**< The derived gain, A0 = Kp + Ki + Kd . */ + float32_t A1; /**< The derived gain, A1 = -Kp - 2Kd. */ + float32_t A2; /**< The derived gain, A2 = Kd . */ + float32_t state[3]; /**< The state array of length 3. */ + float32_t Kp; /**< The proportional gain. */ + float32_t Ki; /**< The integral gain. */ + float32_t Kd; /**< The derivative gain. */ + } arm_pid_instance_f32; + + + + /** + * @brief Initialization function for the floating-point PID Control. + * @param[in,out] *S points to an instance of the PID structure. + * @param[in] resetStateFlag flag to reset the state. 0 = no change in state 1 = reset the state. + * @return none. + */ + void arm_pid_init_f32( + arm_pid_instance_f32 * S, + int32_t resetStateFlag); + + /** + * @brief Reset function for the floating-point PID Control. + * @param[in,out] *S is an instance of the floating-point PID Control structure + * @return none + */ + void arm_pid_reset_f32( + arm_pid_instance_f32 * S); + + + /** + * @brief Initialization function for the Q31 PID Control. + * @param[in,out] *S points to an instance of the Q15 PID structure. + * @param[in] resetStateFlag flag to reset the state. 0 = no change in state 1 = reset the state. + * @return none. + */ + void arm_pid_init_q31( + arm_pid_instance_q31 * S, + int32_t resetStateFlag); + + + /** + * @brief Reset function for the Q31 PID Control. + * @param[in,out] *S points to an instance of the Q31 PID Control structure + * @return none + */ + + void arm_pid_reset_q31( + arm_pid_instance_q31 * S); + + /** + * @brief Initialization function for the Q15 PID Control. + * @param[in,out] *S points to an instance of the Q15 PID structure. + * @param[in] resetStateFlag flag to reset the state. 0 = no change in state 1 = reset the state. + * @return none. + */ + void arm_pid_init_q15( + arm_pid_instance_q15 * S, + int32_t resetStateFlag); + + /** + * @brief Reset function for the Q15 PID Control. + * @param[in,out] *S points to an instance of the q15 PID Control structure + * @return none + */ + void arm_pid_reset_q15( + arm_pid_instance_q15 * S); + + + /** + * @brief Instance structure for the floating-point Linear Interpolate function. + */ + typedef struct + { + uint32_t nValues; /**< nValues */ + float32_t x1; /**< x1 */ + float32_t xSpacing; /**< xSpacing */ + float32_t *pYData; /**< pointer to the table of Y values */ + } arm_linear_interp_instance_f32; + + /** + * @brief Instance structure for the floating-point bilinear interpolation function. + */ + + typedef struct + { + uint16_t numRows; /**< number of rows in the data table. */ + uint16_t numCols; /**< number of columns in the data table. */ + float32_t *pData; /**< points to the data table. */ + } arm_bilinear_interp_instance_f32; + + /** + * @brief Instance structure for the Q31 bilinear interpolation function. + */ + + typedef struct + { + uint16_t numRows; /**< number of rows in the data table. */ + uint16_t numCols; /**< number of columns in the data table. */ + q31_t *pData; /**< points to the data table. */ + } arm_bilinear_interp_instance_q31; + + /** + * @brief Instance structure for the Q15 bilinear interpolation function. + */ + + typedef struct + { + uint16_t numRows; /**< number of rows in the data table. */ + uint16_t numCols; /**< number of columns in the data table. */ + q15_t *pData; /**< points to the data table. */ + } arm_bilinear_interp_instance_q15; + + /** + * @brief Instance structure for the Q15 bilinear interpolation function. + */ + + typedef struct + { + uint16_t numRows; /**< number of rows in the data table. */ + uint16_t numCols; /**< number of columns in the data table. */ + q7_t *pData; /**< points to the data table. */ + } arm_bilinear_interp_instance_q7; + + + /** + * @brief Q7 vector multiplication. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_mult_q7( + q7_t * pSrcA, + q7_t * pSrcB, + q7_t * pDst, + uint32_t blockSize); + + /** + * @brief Q15 vector multiplication. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_mult_q15( + q15_t * pSrcA, + q15_t * pSrcB, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Q31 vector multiplication. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_mult_q31( + q31_t * pSrcA, + q31_t * pSrcB, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Floating-point vector multiplication. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_mult_f32( + float32_t * pSrcA, + float32_t * pSrcB, + float32_t * pDst, + uint32_t blockSize); + + + + + + + /** + * @brief Instance structure for the Q15 CFFT/CIFFT function. + */ + + typedef struct + { + uint16_t fftLen; /**< length of the FFT. */ + uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ + uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ + q15_t *pTwiddle; /**< points to the Sin twiddle factor table. */ + uint16_t *pBitRevTable; /**< points to the bit reversal table. */ + uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ + } arm_cfft_radix2_instance_q15; + + arm_status arm_cfft_radix2_init_q15( + arm_cfft_radix2_instance_q15 * S, + uint16_t fftLen, + uint8_t ifftFlag, + uint8_t bitReverseFlag); + + void arm_cfft_radix2_q15( + const arm_cfft_radix2_instance_q15 * S, + q15_t * pSrc); + + + + /** + * @brief Instance structure for the Q15 CFFT/CIFFT function. + */ + + typedef struct + { + uint16_t fftLen; /**< length of the FFT. */ + uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ + uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ + q15_t *pTwiddle; /**< points to the twiddle factor table. */ + uint16_t *pBitRevTable; /**< points to the bit reversal table. */ + uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ + } arm_cfft_radix4_instance_q15; + + arm_status arm_cfft_radix4_init_q15( + arm_cfft_radix4_instance_q15 * S, + uint16_t fftLen, + uint8_t ifftFlag, + uint8_t bitReverseFlag); + + void arm_cfft_radix4_q15( + const arm_cfft_radix4_instance_q15 * S, + q15_t * pSrc); + + /** + * @brief Instance structure for the Radix-2 Q31 CFFT/CIFFT function. + */ + + typedef struct + { + uint16_t fftLen; /**< length of the FFT. */ + uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ + uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ + q31_t *pTwiddle; /**< points to the Twiddle factor table. */ + uint16_t *pBitRevTable; /**< points to the bit reversal table. */ + uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ + } arm_cfft_radix2_instance_q31; + + arm_status arm_cfft_radix2_init_q31( + arm_cfft_radix2_instance_q31 * S, + uint16_t fftLen, + uint8_t ifftFlag, + uint8_t bitReverseFlag); + + void arm_cfft_radix2_q31( + const arm_cfft_radix2_instance_q31 * S, + q31_t * pSrc); + + /** + * @brief Instance structure for the Q31 CFFT/CIFFT function. + */ + + typedef struct + { + uint16_t fftLen; /**< length of the FFT. */ + uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ + uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ + q31_t *pTwiddle; /**< points to the twiddle factor table. */ + uint16_t *pBitRevTable; /**< points to the bit reversal table. */ + uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ + } arm_cfft_radix4_instance_q31; + + + void arm_cfft_radix4_q31( + const arm_cfft_radix4_instance_q31 * S, + q31_t * pSrc); + + arm_status arm_cfft_radix4_init_q31( + arm_cfft_radix4_instance_q31 * S, + uint16_t fftLen, + uint8_t ifftFlag, + uint8_t bitReverseFlag); + + /** + * @brief Instance structure for the floating-point CFFT/CIFFT function. + */ + + typedef struct + { + uint16_t fftLen; /**< length of the FFT. */ + uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ + uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ + float32_t *pTwiddle; /**< points to the Twiddle factor table. */ + uint16_t *pBitRevTable; /**< points to the bit reversal table. */ + uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ + float32_t onebyfftLen; /**< value of 1/fftLen. */ + } arm_cfft_radix2_instance_f32; + +/* Deprecated */ + arm_status arm_cfft_radix2_init_f32( + arm_cfft_radix2_instance_f32 * S, + uint16_t fftLen, + uint8_t ifftFlag, + uint8_t bitReverseFlag); + +/* Deprecated */ + void arm_cfft_radix2_f32( + const arm_cfft_radix2_instance_f32 * S, + float32_t * pSrc); + + /** + * @brief Instance structure for the floating-point CFFT/CIFFT function. + */ + + typedef struct + { + uint16_t fftLen; /**< length of the FFT. */ + uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ + uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ + float32_t *pTwiddle; /**< points to the Twiddle factor table. */ + uint16_t *pBitRevTable; /**< points to the bit reversal table. */ + uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ + float32_t onebyfftLen; /**< value of 1/fftLen. */ + } arm_cfft_radix4_instance_f32; + +/* Deprecated */ + arm_status arm_cfft_radix4_init_f32( + arm_cfft_radix4_instance_f32 * S, + uint16_t fftLen, + uint8_t ifftFlag, + uint8_t bitReverseFlag); + +/* Deprecated */ + void arm_cfft_radix4_f32( + const arm_cfft_radix4_instance_f32 * S, + float32_t * pSrc); + + /** + * @brief Instance structure for the floating-point CFFT/CIFFT function. + */ + + typedef struct + { + uint16_t fftLen; /**< length of the FFT. */ + const float32_t *pTwiddle; /**< points to the Twiddle factor table. */ + const uint16_t *pBitRevTable; /**< points to the bit reversal table. */ + uint16_t bitRevLength; /**< bit reversal table length. */ + } arm_cfft_instance_f32; + + void arm_cfft_f32( + const arm_cfft_instance_f32 * S, + float32_t * p1, + uint8_t ifftFlag, + uint8_t bitReverseFlag); + + /** + * @brief Instance structure for the Q15 RFFT/RIFFT function. + */ + + typedef struct + { + uint32_t fftLenReal; /**< length of the real FFT. */ + uint32_t fftLenBy2; /**< length of the complex FFT. */ + uint8_t ifftFlagR; /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */ + uint8_t bitReverseFlagR; /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */ + uint32_t twidCoefRModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + q15_t *pTwiddleAReal; /**< points to the real twiddle factor table. */ + q15_t *pTwiddleBReal; /**< points to the imag twiddle factor table. */ + arm_cfft_radix4_instance_q15 *pCfft; /**< points to the complex FFT instance. */ + } arm_rfft_instance_q15; + + arm_status arm_rfft_init_q15( + arm_rfft_instance_q15 * S, + arm_cfft_radix4_instance_q15 * S_CFFT, + uint32_t fftLenReal, + uint32_t ifftFlagR, + uint32_t bitReverseFlag); + + void arm_rfft_q15( + const arm_rfft_instance_q15 * S, + q15_t * pSrc, + q15_t * pDst); + + /** + * @brief Instance structure for the Q31 RFFT/RIFFT function. + */ + + typedef struct + { + uint32_t fftLenReal; /**< length of the real FFT. */ + uint32_t fftLenBy2; /**< length of the complex FFT. */ + uint8_t ifftFlagR; /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */ + uint8_t bitReverseFlagR; /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */ + uint32_t twidCoefRModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + q31_t *pTwiddleAReal; /**< points to the real twiddle factor table. */ + q31_t *pTwiddleBReal; /**< points to the imag twiddle factor table. */ + arm_cfft_radix4_instance_q31 *pCfft; /**< points to the complex FFT instance. */ + } arm_rfft_instance_q31; + + arm_status arm_rfft_init_q31( + arm_rfft_instance_q31 * S, + arm_cfft_radix4_instance_q31 * S_CFFT, + uint32_t fftLenReal, + uint32_t ifftFlagR, + uint32_t bitReverseFlag); + + void arm_rfft_q31( + const arm_rfft_instance_q31 * S, + q31_t * pSrc, + q31_t * pDst); + + /** + * @brief Instance structure for the floating-point RFFT/RIFFT function. + */ + + typedef struct + { + uint32_t fftLenReal; /**< length of the real FFT. */ + uint16_t fftLenBy2; /**< length of the complex FFT. */ + uint8_t ifftFlagR; /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */ + uint8_t bitReverseFlagR; /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */ + uint32_t twidCoefRModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + float32_t *pTwiddleAReal; /**< points to the real twiddle factor table. */ + float32_t *pTwiddleBReal; /**< points to the imag twiddle factor table. */ + arm_cfft_radix4_instance_f32 *pCfft; /**< points to the complex FFT instance. */ + } arm_rfft_instance_f32; + + arm_status arm_rfft_init_f32( + arm_rfft_instance_f32 * S, + arm_cfft_radix4_instance_f32 * S_CFFT, + uint32_t fftLenReal, + uint32_t ifftFlagR, + uint32_t bitReverseFlag); + + void arm_rfft_f32( + const arm_rfft_instance_f32 * S, + float32_t * pSrc, + float32_t * pDst); + + /** + * @brief Instance structure for the floating-point RFFT/RIFFT function. + */ + +typedef struct + { + arm_cfft_instance_f32 Sint; /**< Internal CFFT structure. */ + uint16_t fftLenRFFT; /**< length of the real sequence */ + float32_t * pTwiddleRFFT; /**< Twiddle factors real stage */ + } arm_rfft_fast_instance_f32 ; + +arm_status arm_rfft_fast_init_f32 ( + arm_rfft_fast_instance_f32 * S, + uint16_t fftLen); + +void arm_rfft_fast_f32( + arm_rfft_fast_instance_f32 * S, + float32_t * p, float32_t * pOut, + uint8_t ifftFlag); + + /** + * @brief Instance structure for the floating-point DCT4/IDCT4 function. + */ + + typedef struct + { + uint16_t N; /**< length of the DCT4. */ + uint16_t Nby2; /**< half of the length of the DCT4. */ + float32_t normalize; /**< normalizing factor. */ + float32_t *pTwiddle; /**< points to the twiddle factor table. */ + float32_t *pCosFactor; /**< points to the cosFactor table. */ + arm_rfft_instance_f32 *pRfft; /**< points to the real FFT instance. */ + arm_cfft_radix4_instance_f32 *pCfft; /**< points to the complex FFT instance. */ + } arm_dct4_instance_f32; + + /** + * @brief Initialization function for the floating-point DCT4/IDCT4. + * @param[in,out] *S points to an instance of floating-point DCT4/IDCT4 structure. + * @param[in] *S_RFFT points to an instance of floating-point RFFT/RIFFT structure. + * @param[in] *S_CFFT points to an instance of floating-point CFFT/CIFFT structure. + * @param[in] N length of the DCT4. + * @param[in] Nby2 half of the length of the DCT4. + * @param[in] normalize normalizing factor. + * @return arm_status function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_ARGUMENT_ERROR if fftLenReal is not a supported transform length. + */ + + arm_status arm_dct4_init_f32( + arm_dct4_instance_f32 * S, + arm_rfft_instance_f32 * S_RFFT, + arm_cfft_radix4_instance_f32 * S_CFFT, + uint16_t N, + uint16_t Nby2, + float32_t normalize); + + /** + * @brief Processing function for the floating-point DCT4/IDCT4. + * @param[in] *S points to an instance of the floating-point DCT4/IDCT4 structure. + * @param[in] *pState points to state buffer. + * @param[in,out] *pInlineBuffer points to the in-place input and output buffer. + * @return none. + */ + + void arm_dct4_f32( + const arm_dct4_instance_f32 * S, + float32_t * pState, + float32_t * pInlineBuffer); + + /** + * @brief Instance structure for the Q31 DCT4/IDCT4 function. + */ + + typedef struct + { + uint16_t N; /**< length of the DCT4. */ + uint16_t Nby2; /**< half of the length of the DCT4. */ + q31_t normalize; /**< normalizing factor. */ + q31_t *pTwiddle; /**< points to the twiddle factor table. */ + q31_t *pCosFactor; /**< points to the cosFactor table. */ + arm_rfft_instance_q31 *pRfft; /**< points to the real FFT instance. */ + arm_cfft_radix4_instance_q31 *pCfft; /**< points to the complex FFT instance. */ + } arm_dct4_instance_q31; + + /** + * @brief Initialization function for the Q31 DCT4/IDCT4. + * @param[in,out] *S points to an instance of Q31 DCT4/IDCT4 structure. + * @param[in] *S_RFFT points to an instance of Q31 RFFT/RIFFT structure + * @param[in] *S_CFFT points to an instance of Q31 CFFT/CIFFT structure + * @param[in] N length of the DCT4. + * @param[in] Nby2 half of the length of the DCT4. + * @param[in] normalize normalizing factor. + * @return arm_status function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_ARGUMENT_ERROR if N is not a supported transform length. + */ + + arm_status arm_dct4_init_q31( + arm_dct4_instance_q31 * S, + arm_rfft_instance_q31 * S_RFFT, + arm_cfft_radix4_instance_q31 * S_CFFT, + uint16_t N, + uint16_t Nby2, + q31_t normalize); + + /** + * @brief Processing function for the Q31 DCT4/IDCT4. + * @param[in] *S points to an instance of the Q31 DCT4 structure. + * @param[in] *pState points to state buffer. + * @param[in,out] *pInlineBuffer points to the in-place input and output buffer. + * @return none. + */ + + void arm_dct4_q31( + const arm_dct4_instance_q31 * S, + q31_t * pState, + q31_t * pInlineBuffer); + + /** + * @brief Instance structure for the Q15 DCT4/IDCT4 function. + */ + + typedef struct + { + uint16_t N; /**< length of the DCT4. */ + uint16_t Nby2; /**< half of the length of the DCT4. */ + q15_t normalize; /**< normalizing factor. */ + q15_t *pTwiddle; /**< points to the twiddle factor table. */ + q15_t *pCosFactor; /**< points to the cosFactor table. */ + arm_rfft_instance_q15 *pRfft; /**< points to the real FFT instance. */ + arm_cfft_radix4_instance_q15 *pCfft; /**< points to the complex FFT instance. */ + } arm_dct4_instance_q15; + + /** + * @brief Initialization function for the Q15 DCT4/IDCT4. + * @param[in,out] *S points to an instance of Q15 DCT4/IDCT4 structure. + * @param[in] *S_RFFT points to an instance of Q15 RFFT/RIFFT structure. + * @param[in] *S_CFFT points to an instance of Q15 CFFT/CIFFT structure. + * @param[in] N length of the DCT4. + * @param[in] Nby2 half of the length of the DCT4. + * @param[in] normalize normalizing factor. + * @return arm_status function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_ARGUMENT_ERROR if N is not a supported transform length. + */ + + arm_status arm_dct4_init_q15( + arm_dct4_instance_q15 * S, + arm_rfft_instance_q15 * S_RFFT, + arm_cfft_radix4_instance_q15 * S_CFFT, + uint16_t N, + uint16_t Nby2, + q15_t normalize); + + /** + * @brief Processing function for the Q15 DCT4/IDCT4. + * @param[in] *S points to an instance of the Q15 DCT4 structure. + * @param[in] *pState points to state buffer. + * @param[in,out] *pInlineBuffer points to the in-place input and output buffer. + * @return none. + */ + + void arm_dct4_q15( + const arm_dct4_instance_q15 * S, + q15_t * pState, + q15_t * pInlineBuffer); + + /** + * @brief Floating-point vector addition. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_add_f32( + float32_t * pSrcA, + float32_t * pSrcB, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Q7 vector addition. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_add_q7( + q7_t * pSrcA, + q7_t * pSrcB, + q7_t * pDst, + uint32_t blockSize); + + /** + * @brief Q15 vector addition. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_add_q15( + q15_t * pSrcA, + q15_t * pSrcB, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Q31 vector addition. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_add_q31( + q31_t * pSrcA, + q31_t * pSrcB, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Floating-point vector subtraction. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_sub_f32( + float32_t * pSrcA, + float32_t * pSrcB, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Q7 vector subtraction. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_sub_q7( + q7_t * pSrcA, + q7_t * pSrcB, + q7_t * pDst, + uint32_t blockSize); + + /** + * @brief Q15 vector subtraction. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_sub_q15( + q15_t * pSrcA, + q15_t * pSrcB, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Q31 vector subtraction. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_sub_q31( + q31_t * pSrcA, + q31_t * pSrcB, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Multiplies a floating-point vector by a scalar. + * @param[in] *pSrc points to the input vector + * @param[in] scale scale factor to be applied + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_scale_f32( + float32_t * pSrc, + float32_t scale, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Multiplies a Q7 vector by a scalar. + * @param[in] *pSrc points to the input vector + * @param[in] scaleFract fractional portion of the scale value + * @param[in] shift number of bits to shift the result by + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_scale_q7( + q7_t * pSrc, + q7_t scaleFract, + int8_t shift, + q7_t * pDst, + uint32_t blockSize); + + /** + * @brief Multiplies a Q15 vector by a scalar. + * @param[in] *pSrc points to the input vector + * @param[in] scaleFract fractional portion of the scale value + * @param[in] shift number of bits to shift the result by + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_scale_q15( + q15_t * pSrc, + q15_t scaleFract, + int8_t shift, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Multiplies a Q31 vector by a scalar. + * @param[in] *pSrc points to the input vector + * @param[in] scaleFract fractional portion of the scale value + * @param[in] shift number of bits to shift the result by + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_scale_q31( + q31_t * pSrc, + q31_t scaleFract, + int8_t shift, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Q7 vector absolute value. + * @param[in] *pSrc points to the input buffer + * @param[out] *pDst points to the output buffer + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_abs_q7( + q7_t * pSrc, + q7_t * pDst, + uint32_t blockSize); + + /** + * @brief Floating-point vector absolute value. + * @param[in] *pSrc points to the input buffer + * @param[out] *pDst points to the output buffer + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_abs_f32( + float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Q15 vector absolute value. + * @param[in] *pSrc points to the input buffer + * @param[out] *pDst points to the output buffer + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_abs_q15( + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Q31 vector absolute value. + * @param[in] *pSrc points to the input buffer + * @param[out] *pDst points to the output buffer + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_abs_q31( + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Dot product of floating-point vectors. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[in] blockSize number of samples in each vector + * @param[out] *result output result returned here + * @return none. + */ + + void arm_dot_prod_f32( + float32_t * pSrcA, + float32_t * pSrcB, + uint32_t blockSize, + float32_t * result); + + /** + * @brief Dot product of Q7 vectors. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[in] blockSize number of samples in each vector + * @param[out] *result output result returned here + * @return none. + */ + + void arm_dot_prod_q7( + q7_t * pSrcA, + q7_t * pSrcB, + uint32_t blockSize, + q31_t * result); + + /** + * @brief Dot product of Q15 vectors. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[in] blockSize number of samples in each vector + * @param[out] *result output result returned here + * @return none. + */ + + void arm_dot_prod_q15( + q15_t * pSrcA, + q15_t * pSrcB, + uint32_t blockSize, + q63_t * result); + + /** + * @brief Dot product of Q31 vectors. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[in] blockSize number of samples in each vector + * @param[out] *result output result returned here + * @return none. + */ + + void arm_dot_prod_q31( + q31_t * pSrcA, + q31_t * pSrcB, + uint32_t blockSize, + q63_t * result); + + /** + * @brief Shifts the elements of a Q7 vector a specified number of bits. + * @param[in] *pSrc points to the input vector + * @param[in] shiftBits number of bits to shift. A positive value shifts left; a negative value shifts right. + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_shift_q7( + q7_t * pSrc, + int8_t shiftBits, + q7_t * pDst, + uint32_t blockSize); + + /** + * @brief Shifts the elements of a Q15 vector a specified number of bits. + * @param[in] *pSrc points to the input vector + * @param[in] shiftBits number of bits to shift. A positive value shifts left; a negative value shifts right. + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_shift_q15( + q15_t * pSrc, + int8_t shiftBits, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Shifts the elements of a Q31 vector a specified number of bits. + * @param[in] *pSrc points to the input vector + * @param[in] shiftBits number of bits to shift. A positive value shifts left; a negative value shifts right. + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_shift_q31( + q31_t * pSrc, + int8_t shiftBits, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Adds a constant offset to a floating-point vector. + * @param[in] *pSrc points to the input vector + * @param[in] offset is the offset to be added + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_offset_f32( + float32_t * pSrc, + float32_t offset, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Adds a constant offset to a Q7 vector. + * @param[in] *pSrc points to the input vector + * @param[in] offset is the offset to be added + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_offset_q7( + q7_t * pSrc, + q7_t offset, + q7_t * pDst, + uint32_t blockSize); + + /** + * @brief Adds a constant offset to a Q15 vector. + * @param[in] *pSrc points to the input vector + * @param[in] offset is the offset to be added + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_offset_q15( + q15_t * pSrc, + q15_t offset, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Adds a constant offset to a Q31 vector. + * @param[in] *pSrc points to the input vector + * @param[in] offset is the offset to be added + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_offset_q31( + q31_t * pSrc, + q31_t offset, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Negates the elements of a floating-point vector. + * @param[in] *pSrc points to the input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_negate_f32( + float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Negates the elements of a Q7 vector. + * @param[in] *pSrc points to the input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_negate_q7( + q7_t * pSrc, + q7_t * pDst, + uint32_t blockSize); + + /** + * @brief Negates the elements of a Q15 vector. + * @param[in] *pSrc points to the input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_negate_q15( + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Negates the elements of a Q31 vector. + * @param[in] *pSrc points to the input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_negate_q31( + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + /** + * @brief Copies the elements of a floating-point vector. + * @param[in] *pSrc input pointer + * @param[out] *pDst output pointer + * @param[in] blockSize number of samples to process + * @return none. + */ + void arm_copy_f32( + float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Copies the elements of a Q7 vector. + * @param[in] *pSrc input pointer + * @param[out] *pDst output pointer + * @param[in] blockSize number of samples to process + * @return none. + */ + void arm_copy_q7( + q7_t * pSrc, + q7_t * pDst, + uint32_t blockSize); + + /** + * @brief Copies the elements of a Q15 vector. + * @param[in] *pSrc input pointer + * @param[out] *pDst output pointer + * @param[in] blockSize number of samples to process + * @return none. + */ + void arm_copy_q15( + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Copies the elements of a Q31 vector. + * @param[in] *pSrc input pointer + * @param[out] *pDst output pointer + * @param[in] blockSize number of samples to process + * @return none. + */ + void arm_copy_q31( + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + /** + * @brief Fills a constant value into a floating-point vector. + * @param[in] value input value to be filled + * @param[out] *pDst output pointer + * @param[in] blockSize number of samples to process + * @return none. + */ + void arm_fill_f32( + float32_t value, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Fills a constant value into a Q7 vector. + * @param[in] value input value to be filled + * @param[out] *pDst output pointer + * @param[in] blockSize number of samples to process + * @return none. + */ + void arm_fill_q7( + q7_t value, + q7_t * pDst, + uint32_t blockSize); + + /** + * @brief Fills a constant value into a Q15 vector. + * @param[in] value input value to be filled + * @param[out] *pDst output pointer + * @param[in] blockSize number of samples to process + * @return none. + */ + void arm_fill_q15( + q15_t value, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Fills a constant value into a Q31 vector. + * @param[in] value input value to be filled + * @param[out] *pDst output pointer + * @param[in] blockSize number of samples to process + * @return none. + */ + void arm_fill_q31( + q31_t value, + q31_t * pDst, + uint32_t blockSize); + +/** + * @brief Convolution of floating-point sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the location where the output result is written. Length srcALen+srcBLen-1. + * @return none. + */ + + void arm_conv_f32( + float32_t * pSrcA, + uint32_t srcALen, + float32_t * pSrcB, + uint32_t srcBLen, + float32_t * pDst); + + + /** + * @brief Convolution of Q15 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length srcALen+srcBLen-1. + * @param[in] *pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @param[in] *pScratch2 points to scratch buffer of size min(srcALen, srcBLen). + * @return none. + */ + + + void arm_conv_opt_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + q15_t * pScratch1, + q15_t * pScratch2); + + +/** + * @brief Convolution of Q15 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the location where the output result is written. Length srcALen+srcBLen-1. + * @return none. + */ + + void arm_conv_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst); + + /** + * @brief Convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4 + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length srcALen+srcBLen-1. + * @return none. + */ + + void arm_conv_fast_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst); + + /** + * @brief Convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4 + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length srcALen+srcBLen-1. + * @param[in] *pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @param[in] *pScratch2 points to scratch buffer of size min(srcALen, srcBLen). + * @return none. + */ + + void arm_conv_fast_opt_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + q15_t * pScratch1, + q15_t * pScratch2); + + + + /** + * @brief Convolution of Q31 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length srcALen+srcBLen-1. + * @return none. + */ + + void arm_conv_q31( + q31_t * pSrcA, + uint32_t srcALen, + q31_t * pSrcB, + uint32_t srcBLen, + q31_t * pDst); + + /** + * @brief Convolution of Q31 sequences (fast version) for Cortex-M3 and Cortex-M4 + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length srcALen+srcBLen-1. + * @return none. + */ + + void arm_conv_fast_q31( + q31_t * pSrcA, + uint32_t srcALen, + q31_t * pSrcB, + uint32_t srcBLen, + q31_t * pDst); + + + /** + * @brief Convolution of Q7 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length srcALen+srcBLen-1. + * @param[in] *pScratch1 points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @param[in] *pScratch2 points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen). + * @return none. + */ + + void arm_conv_opt_q7( + q7_t * pSrcA, + uint32_t srcALen, + q7_t * pSrcB, + uint32_t srcBLen, + q7_t * pDst, + q15_t * pScratch1, + q15_t * pScratch2); + + + + /** + * @brief Convolution of Q7 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length srcALen+srcBLen-1. + * @return none. + */ + + void arm_conv_q7( + q7_t * pSrcA, + uint32_t srcALen, + q7_t * pSrcB, + uint32_t srcBLen, + q7_t * pDst); + + + /** + * @brief Partial convolution of floating-point sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + + arm_status arm_conv_partial_f32( + float32_t * pSrcA, + uint32_t srcALen, + float32_t * pSrcB, + uint32_t srcBLen, + float32_t * pDst, + uint32_t firstIndex, + uint32_t numPoints); + + /** + * @brief Partial convolution of Q15 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @param[in] * pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @param[in] * pScratch2 points to scratch buffer of size min(srcALen, srcBLen). + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + + arm_status arm_conv_partial_opt_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + uint32_t firstIndex, + uint32_t numPoints, + q15_t * pScratch1, + q15_t * pScratch2); + + +/** + * @brief Partial convolution of Q15 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + + arm_status arm_conv_partial_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + uint32_t firstIndex, + uint32_t numPoints); + + /** + * @brief Partial convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4 + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + + arm_status arm_conv_partial_fast_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + uint32_t firstIndex, + uint32_t numPoints); + + + /** + * @brief Partial convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4 + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @param[in] * pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @param[in] * pScratch2 points to scratch buffer of size min(srcALen, srcBLen). + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + + arm_status arm_conv_partial_fast_opt_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + uint32_t firstIndex, + uint32_t numPoints, + q15_t * pScratch1, + q15_t * pScratch2); + + + /** + * @brief Partial convolution of Q31 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + + arm_status arm_conv_partial_q31( + q31_t * pSrcA, + uint32_t srcALen, + q31_t * pSrcB, + uint32_t srcBLen, + q31_t * pDst, + uint32_t firstIndex, + uint32_t numPoints); + + + /** + * @brief Partial convolution of Q31 sequences (fast version) for Cortex-M3 and Cortex-M4 + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + + arm_status arm_conv_partial_fast_q31( + q31_t * pSrcA, + uint32_t srcALen, + q31_t * pSrcB, + uint32_t srcBLen, + q31_t * pDst, + uint32_t firstIndex, + uint32_t numPoints); + + + /** + * @brief Partial convolution of Q7 sequences + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @param[in] *pScratch1 points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @param[in] *pScratch2 points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen). + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + + arm_status arm_conv_partial_opt_q7( + q7_t * pSrcA, + uint32_t srcALen, + q7_t * pSrcB, + uint32_t srcBLen, + q7_t * pDst, + uint32_t firstIndex, + uint32_t numPoints, + q15_t * pScratch1, + q15_t * pScratch2); + + +/** + * @brief Partial convolution of Q7 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + + arm_status arm_conv_partial_q7( + q7_t * pSrcA, + uint32_t srcALen, + q7_t * pSrcB, + uint32_t srcBLen, + q7_t * pDst, + uint32_t firstIndex, + uint32_t numPoints); + + + + /** + * @brief Instance structure for the Q15 FIR decimator. + */ + + typedef struct + { + uint8_t M; /**< decimation factor. */ + uint16_t numTaps; /**< number of coefficients in the filter. */ + q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + } arm_fir_decimate_instance_q15; + + /** + * @brief Instance structure for the Q31 FIR decimator. + */ + + typedef struct + { + uint8_t M; /**< decimation factor. */ + uint16_t numTaps; /**< number of coefficients in the filter. */ + q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + + } arm_fir_decimate_instance_q31; + + /** + * @brief Instance structure for the floating-point FIR decimator. + */ + + typedef struct + { + uint8_t M; /**< decimation factor. */ + uint16_t numTaps; /**< number of coefficients in the filter. */ + float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + + } arm_fir_decimate_instance_f32; + + + + /** + * @brief Processing function for the floating-point FIR decimator. + * @param[in] *S points to an instance of the floating-point FIR decimator structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] blockSize number of input samples to process per call. + * @return none + */ + + void arm_fir_decimate_f32( + const arm_fir_decimate_instance_f32 * S, + float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @brief Initialization function for the floating-point FIR decimator. + * @param[in,out] *S points to an instance of the floating-point FIR decimator structure. + * @param[in] numTaps number of coefficients in the filter. + * @param[in] M decimation factor. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] blockSize number of input samples to process per call. + * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if + * blockSize is not a multiple of M. + */ + + arm_status arm_fir_decimate_init_f32( + arm_fir_decimate_instance_f32 * S, + uint16_t numTaps, + uint8_t M, + float32_t * pCoeffs, + float32_t * pState, + uint32_t blockSize); + + /** + * @brief Processing function for the Q15 FIR decimator. + * @param[in] *S points to an instance of the Q15 FIR decimator structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] blockSize number of input samples to process per call. + * @return none + */ + + void arm_fir_decimate_q15( + const arm_fir_decimate_instance_q15 * S, + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Processing function for the Q15 FIR decimator (fast variant) for Cortex-M3 and Cortex-M4. + * @param[in] *S points to an instance of the Q15 FIR decimator structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] blockSize number of input samples to process per call. + * @return none + */ + + void arm_fir_decimate_fast_q15( + const arm_fir_decimate_instance_q15 * S, + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + + + /** + * @brief Initialization function for the Q15 FIR decimator. + * @param[in,out] *S points to an instance of the Q15 FIR decimator structure. + * @param[in] numTaps number of coefficients in the filter. + * @param[in] M decimation factor. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] blockSize number of input samples to process per call. + * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if + * blockSize is not a multiple of M. + */ + + arm_status arm_fir_decimate_init_q15( + arm_fir_decimate_instance_q15 * S, + uint16_t numTaps, + uint8_t M, + q15_t * pCoeffs, + q15_t * pState, + uint32_t blockSize); + + /** + * @brief Processing function for the Q31 FIR decimator. + * @param[in] *S points to an instance of the Q31 FIR decimator structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] blockSize number of input samples to process per call. + * @return none + */ + + void arm_fir_decimate_q31( + const arm_fir_decimate_instance_q31 * S, + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Processing function for the Q31 FIR decimator (fast variant) for Cortex-M3 and Cortex-M4. + * @param[in] *S points to an instance of the Q31 FIR decimator structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] blockSize number of input samples to process per call. + * @return none + */ + + void arm_fir_decimate_fast_q31( + arm_fir_decimate_instance_q31 * S, + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @brief Initialization function for the Q31 FIR decimator. + * @param[in,out] *S points to an instance of the Q31 FIR decimator structure. + * @param[in] numTaps number of coefficients in the filter. + * @param[in] M decimation factor. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] blockSize number of input samples to process per call. + * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if + * blockSize is not a multiple of M. + */ + + arm_status arm_fir_decimate_init_q31( + arm_fir_decimate_instance_q31 * S, + uint16_t numTaps, + uint8_t M, + q31_t * pCoeffs, + q31_t * pState, + uint32_t blockSize); + + + + /** + * @brief Instance structure for the Q15 FIR interpolator. + */ + + typedef struct + { + uint8_t L; /**< upsample factor. */ + uint16_t phaseLength; /**< length of each polyphase filter component. */ + q15_t *pCoeffs; /**< points to the coefficient array. The array is of length L*phaseLength. */ + q15_t *pState; /**< points to the state variable array. The array is of length blockSize+phaseLength-1. */ + } arm_fir_interpolate_instance_q15; + + /** + * @brief Instance structure for the Q31 FIR interpolator. + */ + + typedef struct + { + uint8_t L; /**< upsample factor. */ + uint16_t phaseLength; /**< length of each polyphase filter component. */ + q31_t *pCoeffs; /**< points to the coefficient array. The array is of length L*phaseLength. */ + q31_t *pState; /**< points to the state variable array. The array is of length blockSize+phaseLength-1. */ + } arm_fir_interpolate_instance_q31; + + /** + * @brief Instance structure for the floating-point FIR interpolator. + */ + + typedef struct + { + uint8_t L; /**< upsample factor. */ + uint16_t phaseLength; /**< length of each polyphase filter component. */ + float32_t *pCoeffs; /**< points to the coefficient array. The array is of length L*phaseLength. */ + float32_t *pState; /**< points to the state variable array. The array is of length phaseLength+numTaps-1. */ + } arm_fir_interpolate_instance_f32; + + + /** + * @brief Processing function for the Q15 FIR interpolator. + * @param[in] *S points to an instance of the Q15 FIR interpolator structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of input samples to process per call. + * @return none. + */ + + void arm_fir_interpolate_q15( + const arm_fir_interpolate_instance_q15 * S, + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + + /** + * @brief Initialization function for the Q15 FIR interpolator. + * @param[in,out] *S points to an instance of the Q15 FIR interpolator structure. + * @param[in] L upsample factor. + * @param[in] numTaps number of filter coefficients in the filter. + * @param[in] *pCoeffs points to the filter coefficient buffer. + * @param[in] *pState points to the state buffer. + * @param[in] blockSize number of input samples to process per call. + * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if + * the filter length numTaps is not a multiple of the interpolation factor L. + */ + + arm_status arm_fir_interpolate_init_q15( + arm_fir_interpolate_instance_q15 * S, + uint8_t L, + uint16_t numTaps, + q15_t * pCoeffs, + q15_t * pState, + uint32_t blockSize); + + /** + * @brief Processing function for the Q31 FIR interpolator. + * @param[in] *S points to an instance of the Q15 FIR interpolator structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of input samples to process per call. + * @return none. + */ + + void arm_fir_interpolate_q31( + const arm_fir_interpolate_instance_q31 * S, + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the Q31 FIR interpolator. + * @param[in,out] *S points to an instance of the Q31 FIR interpolator structure. + * @param[in] L upsample factor. + * @param[in] numTaps number of filter coefficients in the filter. + * @param[in] *pCoeffs points to the filter coefficient buffer. + * @param[in] *pState points to the state buffer. + * @param[in] blockSize number of input samples to process per call. + * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if + * the filter length numTaps is not a multiple of the interpolation factor L. + */ + + arm_status arm_fir_interpolate_init_q31( + arm_fir_interpolate_instance_q31 * S, + uint8_t L, + uint16_t numTaps, + q31_t * pCoeffs, + q31_t * pState, + uint32_t blockSize); + + + /** + * @brief Processing function for the floating-point FIR interpolator. + * @param[in] *S points to an instance of the floating-point FIR interpolator structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of input samples to process per call. + * @return none. + */ + + void arm_fir_interpolate_f32( + const arm_fir_interpolate_instance_f32 * S, + float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the floating-point FIR interpolator. + * @param[in,out] *S points to an instance of the floating-point FIR interpolator structure. + * @param[in] L upsample factor. + * @param[in] numTaps number of filter coefficients in the filter. + * @param[in] *pCoeffs points to the filter coefficient buffer. + * @param[in] *pState points to the state buffer. + * @param[in] blockSize number of input samples to process per call. + * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if + * the filter length numTaps is not a multiple of the interpolation factor L. + */ + + arm_status arm_fir_interpolate_init_f32( + arm_fir_interpolate_instance_f32 * S, + uint8_t L, + uint16_t numTaps, + float32_t * pCoeffs, + float32_t * pState, + uint32_t blockSize); + + /** + * @brief Instance structure for the high precision Q31 Biquad cascade filter. + */ + + typedef struct + { + uint8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ + q63_t *pState; /**< points to the array of state coefficients. The array is of length 4*numStages. */ + q31_t *pCoeffs; /**< points to the array of coefficients. The array is of length 5*numStages. */ + uint8_t postShift; /**< additional shift, in bits, applied to each output sample. */ + + } arm_biquad_cas_df1_32x64_ins_q31; + + + /** + * @param[in] *S points to an instance of the high precision Q31 Biquad cascade filter structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_biquad_cas_df1_32x64_q31( + const arm_biquad_cas_df1_32x64_ins_q31 * S, + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @param[in,out] *S points to an instance of the high precision Q31 Biquad cascade filter structure. + * @param[in] numStages number of 2nd order stages in the filter. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] postShift shift to be applied to the output. Varies according to the coefficients format + * @return none + */ + + void arm_biquad_cas_df1_32x64_init_q31( + arm_biquad_cas_df1_32x64_ins_q31 * S, + uint8_t numStages, + q31_t * pCoeffs, + q63_t * pState, + uint8_t postShift); + + + + /** + * @brief Instance structure for the floating-point transposed direct form II Biquad cascade filter. + */ + + typedef struct + { + uint8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ + float32_t *pState; /**< points to the array of state coefficients. The array is of length 2*numStages. */ + float32_t *pCoeffs; /**< points to the array of coefficients. The array is of length 5*numStages. */ + } arm_biquad_cascade_df2T_instance_f32; + + + /** + * @brief Processing function for the floating-point transposed direct form II Biquad cascade filter. + * @param[in] *S points to an instance of the filter data structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_biquad_cascade_df2T_f32( + const arm_biquad_cascade_df2T_instance_f32 * S, + float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @brief Initialization function for the floating-point transposed direct form II Biquad cascade filter. + * @param[in,out] *S points to an instance of the filter data structure. + * @param[in] numStages number of 2nd order stages in the filter. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @return none + */ + + void arm_biquad_cascade_df2T_init_f32( + arm_biquad_cascade_df2T_instance_f32 * S, + uint8_t numStages, + float32_t * pCoeffs, + float32_t * pState); + + + + /** + * @brief Instance structure for the Q15 FIR lattice filter. + */ + + typedef struct + { + uint16_t numStages; /**< number of filter stages. */ + q15_t *pState; /**< points to the state variable array. The array is of length numStages. */ + q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numStages. */ + } arm_fir_lattice_instance_q15; + + /** + * @brief Instance structure for the Q31 FIR lattice filter. + */ + + typedef struct + { + uint16_t numStages; /**< number of filter stages. */ + q31_t *pState; /**< points to the state variable array. The array is of length numStages. */ + q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numStages. */ + } arm_fir_lattice_instance_q31; + + /** + * @brief Instance structure for the floating-point FIR lattice filter. + */ + + typedef struct + { + uint16_t numStages; /**< number of filter stages. */ + float32_t *pState; /**< points to the state variable array. The array is of length numStages. */ + float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numStages. */ + } arm_fir_lattice_instance_f32; + + /** + * @brief Initialization function for the Q15 FIR lattice filter. + * @param[in] *S points to an instance of the Q15 FIR lattice structure. + * @param[in] numStages number of filter stages. + * @param[in] *pCoeffs points to the coefficient buffer. The array is of length numStages. + * @param[in] *pState points to the state buffer. The array is of length numStages. + * @return none. + */ + + void arm_fir_lattice_init_q15( + arm_fir_lattice_instance_q15 * S, + uint16_t numStages, + q15_t * pCoeffs, + q15_t * pState); + + + /** + * @brief Processing function for the Q15 FIR lattice filter. + * @param[in] *S points to an instance of the Q15 FIR lattice structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + void arm_fir_lattice_q15( + const arm_fir_lattice_instance_q15 * S, + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the Q31 FIR lattice filter. + * @param[in] *S points to an instance of the Q31 FIR lattice structure. + * @param[in] numStages number of filter stages. + * @param[in] *pCoeffs points to the coefficient buffer. The array is of length numStages. + * @param[in] *pState points to the state buffer. The array is of length numStages. + * @return none. + */ + + void arm_fir_lattice_init_q31( + arm_fir_lattice_instance_q31 * S, + uint16_t numStages, + q31_t * pCoeffs, + q31_t * pState); + + + /** + * @brief Processing function for the Q31 FIR lattice filter. + * @param[in] *S points to an instance of the Q31 FIR lattice structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_fir_lattice_q31( + const arm_fir_lattice_instance_q31 * S, + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + +/** + * @brief Initialization function for the floating-point FIR lattice filter. + * @param[in] *S points to an instance of the floating-point FIR lattice structure. + * @param[in] numStages number of filter stages. + * @param[in] *pCoeffs points to the coefficient buffer. The array is of length numStages. + * @param[in] *pState points to the state buffer. The array is of length numStages. + * @return none. + */ + + void arm_fir_lattice_init_f32( + arm_fir_lattice_instance_f32 * S, + uint16_t numStages, + float32_t * pCoeffs, + float32_t * pState); + + /** + * @brief Processing function for the floating-point FIR lattice filter. + * @param[in] *S points to an instance of the floating-point FIR lattice structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_fir_lattice_f32( + const arm_fir_lattice_instance_f32 * S, + float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Instance structure for the Q15 IIR lattice filter. + */ + typedef struct + { + uint16_t numStages; /**< number of stages in the filter. */ + q15_t *pState; /**< points to the state variable array. The array is of length numStages+blockSize. */ + q15_t *pkCoeffs; /**< points to the reflection coefficient array. The array is of length numStages. */ + q15_t *pvCoeffs; /**< points to the ladder coefficient array. The array is of length numStages+1. */ + } arm_iir_lattice_instance_q15; + + /** + * @brief Instance structure for the Q31 IIR lattice filter. + */ + typedef struct + { + uint16_t numStages; /**< number of stages in the filter. */ + q31_t *pState; /**< points to the state variable array. The array is of length numStages+blockSize. */ + q31_t *pkCoeffs; /**< points to the reflection coefficient array. The array is of length numStages. */ + q31_t *pvCoeffs; /**< points to the ladder coefficient array. The array is of length numStages+1. */ + } arm_iir_lattice_instance_q31; + + /** + * @brief Instance structure for the floating-point IIR lattice filter. + */ + typedef struct + { + uint16_t numStages; /**< number of stages in the filter. */ + float32_t *pState; /**< points to the state variable array. The array is of length numStages+blockSize. */ + float32_t *pkCoeffs; /**< points to the reflection coefficient array. The array is of length numStages. */ + float32_t *pvCoeffs; /**< points to the ladder coefficient array. The array is of length numStages+1. */ + } arm_iir_lattice_instance_f32; + + /** + * @brief Processing function for the floating-point IIR lattice filter. + * @param[in] *S points to an instance of the floating-point IIR lattice structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_iir_lattice_f32( + const arm_iir_lattice_instance_f32 * S, + float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the floating-point IIR lattice filter. + * @param[in] *S points to an instance of the floating-point IIR lattice structure. + * @param[in] numStages number of stages in the filter. + * @param[in] *pkCoeffs points to the reflection coefficient buffer. The array is of length numStages. + * @param[in] *pvCoeffs points to the ladder coefficient buffer. The array is of length numStages+1. + * @param[in] *pState points to the state buffer. The array is of length numStages+blockSize-1. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_iir_lattice_init_f32( + arm_iir_lattice_instance_f32 * S, + uint16_t numStages, + float32_t * pkCoeffs, + float32_t * pvCoeffs, + float32_t * pState, + uint32_t blockSize); + + + /** + * @brief Processing function for the Q31 IIR lattice filter. + * @param[in] *S points to an instance of the Q31 IIR lattice structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_iir_lattice_q31( + const arm_iir_lattice_instance_q31 * S, + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @brief Initialization function for the Q31 IIR lattice filter. + * @param[in] *S points to an instance of the Q31 IIR lattice structure. + * @param[in] numStages number of stages in the filter. + * @param[in] *pkCoeffs points to the reflection coefficient buffer. The array is of length numStages. + * @param[in] *pvCoeffs points to the ladder coefficient buffer. The array is of length numStages+1. + * @param[in] *pState points to the state buffer. The array is of length numStages+blockSize. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_iir_lattice_init_q31( + arm_iir_lattice_instance_q31 * S, + uint16_t numStages, + q31_t * pkCoeffs, + q31_t * pvCoeffs, + q31_t * pState, + uint32_t blockSize); + + + /** + * @brief Processing function for the Q15 IIR lattice filter. + * @param[in] *S points to an instance of the Q15 IIR lattice structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_iir_lattice_q15( + const arm_iir_lattice_instance_q15 * S, + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + +/** + * @brief Initialization function for the Q15 IIR lattice filter. + * @param[in] *S points to an instance of the fixed-point Q15 IIR lattice structure. + * @param[in] numStages number of stages in the filter. + * @param[in] *pkCoeffs points to reflection coefficient buffer. The array is of length numStages. + * @param[in] *pvCoeffs points to ladder coefficient buffer. The array is of length numStages+1. + * @param[in] *pState points to state buffer. The array is of length numStages+blockSize. + * @param[in] blockSize number of samples to process per call. + * @return none. + */ + + void arm_iir_lattice_init_q15( + arm_iir_lattice_instance_q15 * S, + uint16_t numStages, + q15_t * pkCoeffs, + q15_t * pvCoeffs, + q15_t * pState, + uint32_t blockSize); + + /** + * @brief Instance structure for the floating-point LMS filter. + */ + + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + float32_t mu; /**< step size that controls filter coefficient updates. */ + } arm_lms_instance_f32; + + /** + * @brief Processing function for floating-point LMS filter. + * @param[in] *S points to an instance of the floating-point LMS filter structure. + * @param[in] *pSrc points to the block of input data. + * @param[in] *pRef points to the block of reference data. + * @param[out] *pOut points to the block of output data. + * @param[out] *pErr points to the block of error data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_lms_f32( + const arm_lms_instance_f32 * S, + float32_t * pSrc, + float32_t * pRef, + float32_t * pOut, + float32_t * pErr, + uint32_t blockSize); + + /** + * @brief Initialization function for floating-point LMS filter. + * @param[in] *S points to an instance of the floating-point LMS filter structure. + * @param[in] numTaps number of filter coefficients. + * @param[in] *pCoeffs points to the coefficient buffer. + * @param[in] *pState points to state buffer. + * @param[in] mu step size that controls filter coefficient updates. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_lms_init_f32( + arm_lms_instance_f32 * S, + uint16_t numTaps, + float32_t * pCoeffs, + float32_t * pState, + float32_t mu, + uint32_t blockSize); + + /** + * @brief Instance structure for the Q15 LMS filter. + */ + + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + q15_t mu; /**< step size that controls filter coefficient updates. */ + uint32_t postShift; /**< bit shift applied to coefficients. */ + } arm_lms_instance_q15; + + + /** + * @brief Initialization function for the Q15 LMS filter. + * @param[in] *S points to an instance of the Q15 LMS filter structure. + * @param[in] numTaps number of filter coefficients. + * @param[in] *pCoeffs points to the coefficient buffer. + * @param[in] *pState points to the state buffer. + * @param[in] mu step size that controls filter coefficient updates. + * @param[in] blockSize number of samples to process. + * @param[in] postShift bit shift applied to coefficients. + * @return none. + */ + + void arm_lms_init_q15( + arm_lms_instance_q15 * S, + uint16_t numTaps, + q15_t * pCoeffs, + q15_t * pState, + q15_t mu, + uint32_t blockSize, + uint32_t postShift); + + /** + * @brief Processing function for Q15 LMS filter. + * @param[in] *S points to an instance of the Q15 LMS filter structure. + * @param[in] *pSrc points to the block of input data. + * @param[in] *pRef points to the block of reference data. + * @param[out] *pOut points to the block of output data. + * @param[out] *pErr points to the block of error data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_lms_q15( + const arm_lms_instance_q15 * S, + q15_t * pSrc, + q15_t * pRef, + q15_t * pOut, + q15_t * pErr, + uint32_t blockSize); + + + /** + * @brief Instance structure for the Q31 LMS filter. + */ + + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + q31_t mu; /**< step size that controls filter coefficient updates. */ + uint32_t postShift; /**< bit shift applied to coefficients. */ + + } arm_lms_instance_q31; + + /** + * @brief Processing function for Q31 LMS filter. + * @param[in] *S points to an instance of the Q15 LMS filter structure. + * @param[in] *pSrc points to the block of input data. + * @param[in] *pRef points to the block of reference data. + * @param[out] *pOut points to the block of output data. + * @param[out] *pErr points to the block of error data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_lms_q31( + const arm_lms_instance_q31 * S, + q31_t * pSrc, + q31_t * pRef, + q31_t * pOut, + q31_t * pErr, + uint32_t blockSize); + + /** + * @brief Initialization function for Q31 LMS filter. + * @param[in] *S points to an instance of the Q31 LMS filter structure. + * @param[in] numTaps number of filter coefficients. + * @param[in] *pCoeffs points to coefficient buffer. + * @param[in] *pState points to state buffer. + * @param[in] mu step size that controls filter coefficient updates. + * @param[in] blockSize number of samples to process. + * @param[in] postShift bit shift applied to coefficients. + * @return none. + */ + + void arm_lms_init_q31( + arm_lms_instance_q31 * S, + uint16_t numTaps, + q31_t * pCoeffs, + q31_t * pState, + q31_t mu, + uint32_t blockSize, + uint32_t postShift); + + /** + * @brief Instance structure for the floating-point normalized LMS filter. + */ + + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + float32_t mu; /**< step size that control filter coefficient updates. */ + float32_t energy; /**< saves previous frame energy. */ + float32_t x0; /**< saves previous input sample. */ + } arm_lms_norm_instance_f32; + + /** + * @brief Processing function for floating-point normalized LMS filter. + * @param[in] *S points to an instance of the floating-point normalized LMS filter structure. + * @param[in] *pSrc points to the block of input data. + * @param[in] *pRef points to the block of reference data. + * @param[out] *pOut points to the block of output data. + * @param[out] *pErr points to the block of error data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_lms_norm_f32( + arm_lms_norm_instance_f32 * S, + float32_t * pSrc, + float32_t * pRef, + float32_t * pOut, + float32_t * pErr, + uint32_t blockSize); + + /** + * @brief Initialization function for floating-point normalized LMS filter. + * @param[in] *S points to an instance of the floating-point LMS filter structure. + * @param[in] numTaps number of filter coefficients. + * @param[in] *pCoeffs points to coefficient buffer. + * @param[in] *pState points to state buffer. + * @param[in] mu step size that controls filter coefficient updates. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_lms_norm_init_f32( + arm_lms_norm_instance_f32 * S, + uint16_t numTaps, + float32_t * pCoeffs, + float32_t * pState, + float32_t mu, + uint32_t blockSize); + + + /** + * @brief Instance structure for the Q31 normalized LMS filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + q31_t mu; /**< step size that controls filter coefficient updates. */ + uint8_t postShift; /**< bit shift applied to coefficients. */ + q31_t *recipTable; /**< points to the reciprocal initial value table. */ + q31_t energy; /**< saves previous frame energy. */ + q31_t x0; /**< saves previous input sample. */ + } arm_lms_norm_instance_q31; + + /** + * @brief Processing function for Q31 normalized LMS filter. + * @param[in] *S points to an instance of the Q31 normalized LMS filter structure. + * @param[in] *pSrc points to the block of input data. + * @param[in] *pRef points to the block of reference data. + * @param[out] *pOut points to the block of output data. + * @param[out] *pErr points to the block of error data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_lms_norm_q31( + arm_lms_norm_instance_q31 * S, + q31_t * pSrc, + q31_t * pRef, + q31_t * pOut, + q31_t * pErr, + uint32_t blockSize); + + /** + * @brief Initialization function for Q31 normalized LMS filter. + * @param[in] *S points to an instance of the Q31 normalized LMS filter structure. + * @param[in] numTaps number of filter coefficients. + * @param[in] *pCoeffs points to coefficient buffer. + * @param[in] *pState points to state buffer. + * @param[in] mu step size that controls filter coefficient updates. + * @param[in] blockSize number of samples to process. + * @param[in] postShift bit shift applied to coefficients. + * @return none. + */ + + void arm_lms_norm_init_q31( + arm_lms_norm_instance_q31 * S, + uint16_t numTaps, + q31_t * pCoeffs, + q31_t * pState, + q31_t mu, + uint32_t blockSize, + uint8_t postShift); + + /** + * @brief Instance structure for the Q15 normalized LMS filter. + */ + + typedef struct + { + uint16_t numTaps; /**< Number of coefficients in the filter. */ + q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + q15_t mu; /**< step size that controls filter coefficient updates. */ + uint8_t postShift; /**< bit shift applied to coefficients. */ + q15_t *recipTable; /**< Points to the reciprocal initial value table. */ + q15_t energy; /**< saves previous frame energy. */ + q15_t x0; /**< saves previous input sample. */ + } arm_lms_norm_instance_q15; + + /** + * @brief Processing function for Q15 normalized LMS filter. + * @param[in] *S points to an instance of the Q15 normalized LMS filter structure. + * @param[in] *pSrc points to the block of input data. + * @param[in] *pRef points to the block of reference data. + * @param[out] *pOut points to the block of output data. + * @param[out] *pErr points to the block of error data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_lms_norm_q15( + arm_lms_norm_instance_q15 * S, + q15_t * pSrc, + q15_t * pRef, + q15_t * pOut, + q15_t * pErr, + uint32_t blockSize); + + + /** + * @brief Initialization function for Q15 normalized LMS filter. + * @param[in] *S points to an instance of the Q15 normalized LMS filter structure. + * @param[in] numTaps number of filter coefficients. + * @param[in] *pCoeffs points to coefficient buffer. + * @param[in] *pState points to state buffer. + * @param[in] mu step size that controls filter coefficient updates. + * @param[in] blockSize number of samples to process. + * @param[in] postShift bit shift applied to coefficients. + * @return none. + */ + + void arm_lms_norm_init_q15( + arm_lms_norm_instance_q15 * S, + uint16_t numTaps, + q15_t * pCoeffs, + q15_t * pState, + q15_t mu, + uint32_t blockSize, + uint8_t postShift); + + /** + * @brief Correlation of floating-point sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + * @return none. + */ + + void arm_correlate_f32( + float32_t * pSrcA, + uint32_t srcALen, + float32_t * pSrcB, + uint32_t srcBLen, + float32_t * pDst); + + + /** + * @brief Correlation of Q15 sequences + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + * @param[in] *pScratch points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @return none. + */ + void arm_correlate_opt_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + q15_t * pScratch); + + + /** + * @brief Correlation of Q15 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + * @return none. + */ + + void arm_correlate_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst); + + /** + * @brief Correlation of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + * @return none. + */ + + void arm_correlate_fast_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst); + + + + /** + * @brief Correlation of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + * @param[in] *pScratch points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @return none. + */ + + void arm_correlate_fast_opt_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + q15_t * pScratch); + + /** + * @brief Correlation of Q31 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + * @return none. + */ + + void arm_correlate_q31( + q31_t * pSrcA, + uint32_t srcALen, + q31_t * pSrcB, + uint32_t srcBLen, + q31_t * pDst); + + /** + * @brief Correlation of Q31 sequences (fast version) for Cortex-M3 and Cortex-M4 + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + * @return none. + */ + + void arm_correlate_fast_q31( + q31_t * pSrcA, + uint32_t srcALen, + q31_t * pSrcB, + uint32_t srcBLen, + q31_t * pDst); + + + + /** + * @brief Correlation of Q7 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + * @param[in] *pScratch1 points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @param[in] *pScratch2 points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen). + * @return none. + */ + + void arm_correlate_opt_q7( + q7_t * pSrcA, + uint32_t srcALen, + q7_t * pSrcB, + uint32_t srcBLen, + q7_t * pDst, + q15_t * pScratch1, + q15_t * pScratch2); + + + /** + * @brief Correlation of Q7 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + * @return none. + */ + + void arm_correlate_q7( + q7_t * pSrcA, + uint32_t srcALen, + q7_t * pSrcB, + uint32_t srcBLen, + q7_t * pDst); + + + /** + * @brief Instance structure for the floating-point sparse FIR filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */ + float32_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */ + float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */ + int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */ + } arm_fir_sparse_instance_f32; + + /** + * @brief Instance structure for the Q31 sparse FIR filter. + */ + + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */ + q31_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */ + q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */ + int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */ + } arm_fir_sparse_instance_q31; + + /** + * @brief Instance structure for the Q15 sparse FIR filter. + */ + + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */ + q15_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */ + q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */ + int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */ + } arm_fir_sparse_instance_q15; + + /** + * @brief Instance structure for the Q7 sparse FIR filter. + */ + + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */ + q7_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */ + q7_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */ + int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */ + } arm_fir_sparse_instance_q7; + + /** + * @brief Processing function for the floating-point sparse FIR filter. + * @param[in] *S points to an instance of the floating-point sparse FIR structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] *pScratchIn points to a temporary buffer of size blockSize. + * @param[in] blockSize number of input samples to process per call. + * @return none. + */ + + void arm_fir_sparse_f32( + arm_fir_sparse_instance_f32 * S, + float32_t * pSrc, + float32_t * pDst, + float32_t * pScratchIn, + uint32_t blockSize); + + /** + * @brief Initialization function for the floating-point sparse FIR filter. + * @param[in,out] *S points to an instance of the floating-point sparse FIR structure. + * @param[in] numTaps number of nonzero coefficients in the filter. + * @param[in] *pCoeffs points to the array of filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] *pTapDelay points to the array of offset times. + * @param[in] maxDelay maximum offset time supported. + * @param[in] blockSize number of samples that will be processed per block. + * @return none + */ + + void arm_fir_sparse_init_f32( + arm_fir_sparse_instance_f32 * S, + uint16_t numTaps, + float32_t * pCoeffs, + float32_t * pState, + int32_t * pTapDelay, + uint16_t maxDelay, + uint32_t blockSize); + + /** + * @brief Processing function for the Q31 sparse FIR filter. + * @param[in] *S points to an instance of the Q31 sparse FIR structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] *pScratchIn points to a temporary buffer of size blockSize. + * @param[in] blockSize number of input samples to process per call. + * @return none. + */ + + void arm_fir_sparse_q31( + arm_fir_sparse_instance_q31 * S, + q31_t * pSrc, + q31_t * pDst, + q31_t * pScratchIn, + uint32_t blockSize); + + /** + * @brief Initialization function for the Q31 sparse FIR filter. + * @param[in,out] *S points to an instance of the Q31 sparse FIR structure. + * @param[in] numTaps number of nonzero coefficients in the filter. + * @param[in] *pCoeffs points to the array of filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] *pTapDelay points to the array of offset times. + * @param[in] maxDelay maximum offset time supported. + * @param[in] blockSize number of samples that will be processed per block. + * @return none + */ + + void arm_fir_sparse_init_q31( + arm_fir_sparse_instance_q31 * S, + uint16_t numTaps, + q31_t * pCoeffs, + q31_t * pState, + int32_t * pTapDelay, + uint16_t maxDelay, + uint32_t blockSize); + + /** + * @brief Processing function for the Q15 sparse FIR filter. + * @param[in] *S points to an instance of the Q15 sparse FIR structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] *pScratchIn points to a temporary buffer of size blockSize. + * @param[in] *pScratchOut points to a temporary buffer of size blockSize. + * @param[in] blockSize number of input samples to process per call. + * @return none. + */ + + void arm_fir_sparse_q15( + arm_fir_sparse_instance_q15 * S, + q15_t * pSrc, + q15_t * pDst, + q15_t * pScratchIn, + q31_t * pScratchOut, + uint32_t blockSize); + + + /** + * @brief Initialization function for the Q15 sparse FIR filter. + * @param[in,out] *S points to an instance of the Q15 sparse FIR structure. + * @param[in] numTaps number of nonzero coefficients in the filter. + * @param[in] *pCoeffs points to the array of filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] *pTapDelay points to the array of offset times. + * @param[in] maxDelay maximum offset time supported. + * @param[in] blockSize number of samples that will be processed per block. + * @return none + */ + + void arm_fir_sparse_init_q15( + arm_fir_sparse_instance_q15 * S, + uint16_t numTaps, + q15_t * pCoeffs, + q15_t * pState, + int32_t * pTapDelay, + uint16_t maxDelay, + uint32_t blockSize); + + /** + * @brief Processing function for the Q7 sparse FIR filter. + * @param[in] *S points to an instance of the Q7 sparse FIR structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] *pScratchIn points to a temporary buffer of size blockSize. + * @param[in] *pScratchOut points to a temporary buffer of size blockSize. + * @param[in] blockSize number of input samples to process per call. + * @return none. + */ + + void arm_fir_sparse_q7( + arm_fir_sparse_instance_q7 * S, + q7_t * pSrc, + q7_t * pDst, + q7_t * pScratchIn, + q31_t * pScratchOut, + uint32_t blockSize); + + /** + * @brief Initialization function for the Q7 sparse FIR filter. + * @param[in,out] *S points to an instance of the Q7 sparse FIR structure. + * @param[in] numTaps number of nonzero coefficients in the filter. + * @param[in] *pCoeffs points to the array of filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] *pTapDelay points to the array of offset times. + * @param[in] maxDelay maximum offset time supported. + * @param[in] blockSize number of samples that will be processed per block. + * @return none + */ + + void arm_fir_sparse_init_q7( + arm_fir_sparse_instance_q7 * S, + uint16_t numTaps, + q7_t * pCoeffs, + q7_t * pState, + int32_t * pTapDelay, + uint16_t maxDelay, + uint32_t blockSize); + + + /* + * @brief Floating-point sin_cos function. + * @param[in] theta input value in degrees + * @param[out] *pSinVal points to the processed sine output. + * @param[out] *pCosVal points to the processed cos output. + * @return none. + */ + + void arm_sin_cos_f32( + float32_t theta, + float32_t * pSinVal, + float32_t * pCcosVal); + + /* + * @brief Q31 sin_cos function. + * @param[in] theta scaled input value in degrees + * @param[out] *pSinVal points to the processed sine output. + * @param[out] *pCosVal points to the processed cosine output. + * @return none. + */ + + void arm_sin_cos_q31( + q31_t theta, + q31_t * pSinVal, + q31_t * pCosVal); + + + /** + * @brief Floating-point complex conjugate. + * @param[in] *pSrc points to the input vector + * @param[out] *pDst points to the output vector + * @param[in] numSamples number of complex samples in each vector + * @return none. + */ + + void arm_cmplx_conj_f32( + float32_t * pSrc, + float32_t * pDst, + uint32_t numSamples); + + /** + * @brief Q31 complex conjugate. + * @param[in] *pSrc points to the input vector + * @param[out] *pDst points to the output vector + * @param[in] numSamples number of complex samples in each vector + * @return none. + */ + + void arm_cmplx_conj_q31( + q31_t * pSrc, + q31_t * pDst, + uint32_t numSamples); + + /** + * @brief Q15 complex conjugate. + * @param[in] *pSrc points to the input vector + * @param[out] *pDst points to the output vector + * @param[in] numSamples number of complex samples in each vector + * @return none. + */ + + void arm_cmplx_conj_q15( + q15_t * pSrc, + q15_t * pDst, + uint32_t numSamples); + + + + /** + * @brief Floating-point complex magnitude squared + * @param[in] *pSrc points to the complex input vector + * @param[out] *pDst points to the real output vector + * @param[in] numSamples number of complex samples in the input vector + * @return none. + */ + + void arm_cmplx_mag_squared_f32( + float32_t * pSrc, + float32_t * pDst, + uint32_t numSamples); + + /** + * @brief Q31 complex magnitude squared + * @param[in] *pSrc points to the complex input vector + * @param[out] *pDst points to the real output vector + * @param[in] numSamples number of complex samples in the input vector + * @return none. + */ + + void arm_cmplx_mag_squared_q31( + q31_t * pSrc, + q31_t * pDst, + uint32_t numSamples); + + /** + * @brief Q15 complex magnitude squared + * @param[in] *pSrc points to the complex input vector + * @param[out] *pDst points to the real output vector + * @param[in] numSamples number of complex samples in the input vector + * @return none. + */ + + void arm_cmplx_mag_squared_q15( + q15_t * pSrc, + q15_t * pDst, + uint32_t numSamples); + + + /** + * @ingroup groupController + */ + + /** + * @defgroup PID PID Motor Control + * + * A Proportional Integral Derivative (PID) controller is a generic feedback control + * loop mechanism widely used in industrial control systems. + * A PID controller is the most commonly used type of feedback controller. + * + * This set of functions implements (PID) controllers + * for Q15, Q31, and floating-point data types. The functions operate on a single sample + * of data and each call to the function returns a single processed value. + * S points to an instance of the PID control data structure. in + * is the input sample value. The functions return the output value. + * + * \par Algorithm: + * 
    +   *    y[n] = y[n-1] + A0 * x[n] + A1 * x[n-1] + A2 * x[n-2]
+   *    A0 = Kp + Ki + Kd
+   *    A1 = (-Kp ) - (2 * Kd )
+   *    A2 = Kd
    + * + * \par + * where \c Kp is proportional constant, \c Ki is Integral constant and \c Kd is Derivative constant + * + * \par + * \image html PID.gif "Proportional Integral Derivative Controller" + * + * \par + * The PID controller calculates an "error" value as the difference between + * the measured output and the reference input. + * The controller attempts to minimize the error by adjusting the process control inputs. + * The proportional value determines the reaction to the current error, + * the integral value determines the reaction based on the sum of recent errors, + * and the derivative value determines the reaction based on the rate at which the error has been changing. + * + * \par Instance Structure + * The Gains A0, A1, A2 and state variables for a PID controller are stored together in an instance data structure. + * A separate instance structure must be defined for each PID Controller. + * There are separate instance structure declarations for each of the 3 supported data types. + * + * \par Reset Functions + * There is also an associated reset function for each data type which clears the state array. + * + * \par Initialization Functions + * There is also an associated initialization function for each data type. + * The initialization function performs the following operations: + * - Initializes the Gains A0, A1, A2 from Kp,Ki, Kd gains. + * - Zeros out the values in the state buffer. + * + * \par + * Instance structure cannot be placed into a const data section and it is recommended to use the initialization function. + * + * \par Fixed-Point Behavior + * Care must be taken when using the fixed-point versions of the PID Controller functions. + * In particular, the overflow and saturation behavior of the accumulator used in each function must be considered. + * Refer to the function specific documentation below for usage guidelines. + */ + + /** + * @addtogroup PID + * @{ + */ + + /** + * @brief Process function for the floating-point PID Control. + * @param[in,out] *S is an instance of the floating-point PID Control structure + * @param[in] in input sample to process + * @return out processed output sample. + */ + + + static __INLINE float32_t arm_pid_f32( + arm_pid_instance_f32 * S, + float32_t in) + { + float32_t out; + + /* y[n] = y[n-1] + A0 * x[n] + A1 * x[n-1] + A2 * x[n-2] */ + out = (S->A0 * in) + + (S->A1 * S->state[0]) + (S->A2 * S->state[1]) + (S->state[2]); + + /* Update state */ + S->state[1] = S->state[0]; + S->state[0] = in; + S->state[2] = out; + + /* return to application */ + return (out); + + } + + /** + * @brief Process function for the Q31 PID Control. + * @param[in,out] *S points to an instance of the Q31 PID Control structure + * @param[in] in input sample to process + * @return out processed output sample. + * + * Scaling and Overflow Behavior: + * \par + * The function is implemented using an internal 64-bit accumulator. + * The accumulator has a 2.62 format and maintains full precision of the intermediate multiplication results but provides only a single guard bit. + * Thus, if the accumulator result overflows it wraps around rather than clip. + * In order to avoid overflows completely the input signal must be scaled down by 2 bits as there are four additions. + * After all multiply-accumulates are performed, the 2.62 accumulator is truncated to 1.32 format and then saturated to 1.31 format. + */ + + static __INLINE q31_t arm_pid_q31( + arm_pid_instance_q31 * S, + q31_t in) + { + q63_t acc; + q31_t out; + + /* acc = A0 * x[n] */ + acc = (q63_t) S->A0 * in; + + /* acc += A1 * x[n-1] */ + acc += (q63_t) S->A1 * S->state[0]; + + /* acc += A2 * x[n-2] */ + acc += (q63_t) S->A2 * S->state[1]; + + /* convert output to 1.31 format to add y[n-1] */ + out = (q31_t) (acc >> 31u); + + /* out += y[n-1] */ + out += S->state[2]; + + /* Update state */ + S->state[1] = S->state[0]; + S->state[0] = in; + S->state[2] = out; + + /* return to application */ + return (out); + + } + + /** + * @brief Process function for the Q15 PID Control. + * @param[in,out] *S points to an instance of the Q15 PID Control structure + * @param[in] in input sample to process + * @return out processed output sample. + * + * Scaling and Overflow Behavior: + * \par + * The function is implemented using a 64-bit internal accumulator. + * Both Gains and state variables are represented in 1.15 format and multiplications yield a 2.30 result. + * The 2.30 intermediate results are accumulated in a 64-bit accumulator in 34.30 format. + * There is no risk of internal overflow with this approach and the full precision of intermediate multiplications is preserved. + * After all additions have been performed, the accumulator is truncated to 34.15 format by discarding low 15 bits. + * Lastly, the accumulator is saturated to yield a result in 1.15 format. + */ + + static __INLINE q15_t arm_pid_q15( + arm_pid_instance_q15 * S, + q15_t in) + { + q63_t acc; + q15_t out; + +#ifndef ARM_MATH_CM0_FAMILY + __SIMD32_TYPE *vstate; + + /* Implementation of PID controller */ + + /* acc = A0 * x[n] */ + acc = (q31_t) __SMUAD(S->A0, in); + + /* acc += A1 * x[n-1] + A2 * x[n-2] */ + vstate = __SIMD32_CONST(S->state); + acc = __SMLALD(S->A1, (q31_t) *vstate, acc); + +#else + /* acc = A0 * x[n] */ + acc = ((q31_t) S->A0) * in; + + /* acc += A1 * x[n-1] + A2 * x[n-2] */ + acc += (q31_t) S->A1 * S->state[0]; + acc += (q31_t) S->A2 * S->state[1]; + +#endif + + /* acc += y[n-1] */ + acc += (q31_t) S->state[2] << 15; + + /* saturate the output */ + out = (q15_t) (__SSAT((acc >> 15), 16)); + + /* Update state */ + S->state[1] = S->state[0]; + S->state[0] = in; + S->state[2] = out; + + /* return to application */ + return (out); + + } + + /** + * @} end of PID group + */ + + + /** + * @brief Floating-point matrix inverse. + * @param[in] *src points to the instance of the input floating-point matrix structure. + * @param[out] *dst points to the instance of the output floating-point matrix structure. + * @return The function returns ARM_MATH_SIZE_MISMATCH, if the dimensions do not match. + * If the input matrix is singular (does not have an inverse), then the algorithm terminates and returns error status ARM_MATH_SINGULAR. + */ + + arm_status arm_mat_inverse_f32( + const arm_matrix_instance_f32 * src, + arm_matrix_instance_f32 * dst); + + + + /** + * @ingroup groupController + */ + + + /** + * @defgroup clarke Vector Clarke Transform + * Forward Clarke transform converts the instantaneous stator phases into a two-coordinate time invariant vector. + * Generally the Clarke transform uses three-phase currents Ia, Ib and Ic to calculate currents + * in the two-phase orthogonal stator axis Ialpha and Ibeta. + * When Ialpha is superposed with Ia as shown in the figure below + * \image html clarke.gif Stator current space vector and its components in (a,b). + * and Ia + Ib + Ic = 0, in this condition Ialpha and Ibeta + * can be calculated using only Ia and Ib. + * + * The function operates on a single sample of data and each call to the function returns the processed output. + * The library provides separate functions for Q31 and floating-point data types. + * \par Algorithm + * \image html clarkeFormula.gif + * where Ia and Ib are the instantaneous stator phases and + * pIalpha and pIbeta are the two coordinates of time invariant vector. + * \par Fixed-Point Behavior + * Care must be taken when using the Q31 version of the Clarke transform. + * In particular, the overflow and saturation behavior of the accumulator used must be considered. + * Refer to the function specific documentation below for usage guidelines. + */ + + /** + * @addtogroup clarke + * @{ + */ + + /** + * + * @brief Floating-point Clarke transform + * @param[in] Ia input three-phase coordinate a + * @param[in] Ib input three-phase coordinate b + * @param[out] *pIalpha points to output two-phase orthogonal vector axis alpha + * @param[out] *pIbeta points to output two-phase orthogonal vector axis beta + * @return none. + */ + + static __INLINE void arm_clarke_f32( + float32_t Ia, + float32_t Ib, + float32_t * pIalpha, + float32_t * pIbeta) + { + /* Calculate pIalpha using the equation, pIalpha = Ia */ + *pIalpha = Ia; + + /* Calculate pIbeta using the equation, pIbeta = (1/sqrt(3)) * Ia + (2/sqrt(3)) * Ib */ + *pIbeta = + ((float32_t) 0.57735026919 * Ia + (float32_t) 1.15470053838 * Ib); + + } + + /** + * @brief Clarke transform for Q31 version + * @param[in] Ia input three-phase coordinate a + * @param[in] Ib input three-phase coordinate b + * @param[out] *pIalpha points to output two-phase orthogonal vector axis alpha + * @param[out] *pIbeta points to output two-phase orthogonal vector axis beta + * @return none. + * + * Scaling and Overflow Behavior: + * \par + * The function is implemented using an internal 32-bit accumulator. + * The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format. + * There is saturation on the addition, hence there is no risk of overflow. + */ + + static __INLINE void arm_clarke_q31( + q31_t Ia, + q31_t Ib, + q31_t * pIalpha, + q31_t * pIbeta) + { + q31_t product1, product2; /* Temporary variables used to store intermediate results */ + + /* Calculating pIalpha from Ia by equation pIalpha = Ia */ + *pIalpha = Ia; + + /* Intermediate product is calculated by (1/(sqrt(3)) * Ia) */ + product1 = (q31_t) (((q63_t) Ia * 0x24F34E8B) >> 30); + + /* Intermediate product is calculated by (2/sqrt(3) * Ib) */ + product2 = (q31_t) (((q63_t) Ib * 0x49E69D16) >> 30); + + /* pIbeta is calculated by adding the intermediate products */ + *pIbeta = __QADD(product1, product2); + } + + /** + * @} end of clarke group + */ + + /** + * @brief Converts the elements of the Q7 vector to Q31 vector. + * @param[in] *pSrc input pointer + * @param[out] *pDst output pointer + * @param[in] blockSize number of samples to process + * @return none. + */ + void arm_q7_to_q31( + q7_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + + + + /** + * @ingroup groupController + */ + + /** + * @defgroup inv_clarke Vector Inverse Clarke Transform + * Inverse Clarke transform converts the two-coordinate time invariant vector into instantaneous stator phases. + * + * The function operates on a single sample of data and each call to the function returns the processed output. + * The library provides separate functions for Q31 and floating-point data types. + * \par Algorithm + * \image html clarkeInvFormula.gif + * where pIa and pIb are the instantaneous stator phases and + * Ialpha and Ibeta are the two coordinates of time invariant vector. + * \par Fixed-Point Behavior + * Care must be taken when using the Q31 version of the Clarke transform. + * In particular, the overflow and saturation behavior of the accumulator used must be considered. + * Refer to the function specific documentation below for usage guidelines. + */ + + /** + * @addtogroup inv_clarke + * @{ + */ + + /** + * @brief Floating-point Inverse Clarke transform + * @param[in] Ialpha input two-phase orthogonal vector axis alpha + * @param[in] Ibeta input two-phase orthogonal vector axis beta + * @param[out] *pIa points to output three-phase coordinate a + * @param[out] *pIb points to output three-phase coordinate b + * @return none. + */ + + + static __INLINE void arm_inv_clarke_f32( + float32_t Ialpha, + float32_t Ibeta, + float32_t * pIa, + float32_t * pIb) + { + /* Calculating pIa from Ialpha by equation pIa = Ialpha */ + *pIa = Ialpha; + + /* Calculating pIb from Ialpha and Ibeta by equation pIb = -(1/2) * Ialpha + (sqrt(3)/2) * Ibeta */ + *pIb = -0.5 * Ialpha + (float32_t) 0.8660254039 *Ibeta; + + } + + /** + * @brief Inverse Clarke transform for Q31 version + * @param[in] Ialpha input two-phase orthogonal vector axis alpha + * @param[in] Ibeta input two-phase orthogonal vector axis beta + * @param[out] *pIa points to output three-phase coordinate a + * @param[out] *pIb points to output three-phase coordinate b + * @return none. + * + * Scaling and Overflow Behavior: + * \par + * The function is implemented using an internal 32-bit accumulator. + * The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format. + * There is saturation on the subtraction, hence there is no risk of overflow. + */ + + static __INLINE void arm_inv_clarke_q31( + q31_t Ialpha, + q31_t Ibeta, + q31_t * pIa, + q31_t * pIb) + { + q31_t product1, product2; /* Temporary variables used to store intermediate results */ + + /* Calculating pIa from Ialpha by equation pIa = Ialpha */ + *pIa = Ialpha; + + /* Intermediate product is calculated by (1/(2*sqrt(3)) * Ia) */ + product1 = (q31_t) (((q63_t) (Ialpha) * (0x40000000)) >> 31); + + /* Intermediate product is calculated by (1/sqrt(3) * pIb) */ + product2 = (q31_t) (((q63_t) (Ibeta) * (0x6ED9EBA1)) >> 31); + + /* pIb is calculated by subtracting the products */ + *pIb = __QSUB(product2, product1); + + } + + /** + * @} end of inv_clarke group + */ + + /** + * @brief Converts the elements of the Q7 vector to Q15 vector. + * @param[in] *pSrc input pointer + * @param[out] *pDst output pointer + * @param[in] blockSize number of samples to process + * @return none. + */ + void arm_q7_to_q15( + q7_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + + + /** + * @ingroup groupController + */ + + /** + * @defgroup park Vector Park Transform + * + * Forward Park transform converts the input two-coordinate vector to flux and torque components. + * The Park transform can be used to realize the transformation of the Ialpha and the Ibeta currents + * from the stationary to the moving reference frame and control the spatial relationship between + * the stator vector current and rotor flux vector. + * If we consider the d axis aligned with the rotor flux, the diagram below shows the + * current vector and the relationship from the two reference frames: + * \image html park.gif "Stator current space vector and its component in (a,b) and in the d,q rotating reference frame" + * + * The function operates on a single sample of data and each call to the function returns the processed output. + * The library provides separate functions for Q31 and floating-point data types. + * \par Algorithm + * \image html parkFormula.gif + * where Ialpha and Ibeta are the stator vector components, + * pId and pIq are rotor vector components and cosVal and sinVal are the + * cosine and sine values of theta (rotor flux position). + * \par Fixed-Point Behavior + * Care must be taken when using the Q31 version of the Park transform. + * In particular, the overflow and saturation behavior of the accumulator used must be considered. + * Refer to the function specific documentation below for usage guidelines. + */ + + /** + * @addtogroup park + * @{ + */ + + /** + * @brief Floating-point Park transform + * @param[in] Ialpha input two-phase vector coordinate alpha + * @param[in] Ibeta input two-phase vector coordinate beta + * @param[out] *pId points to output rotor reference frame d + * @param[out] *pIq points to output rotor reference frame q + * @param[in] sinVal sine value of rotation angle theta + * @param[in] cosVal cosine value of rotation angle theta + * @return none. + * + * The function implements the forward Park transform. + * + */ + + static __INLINE void arm_park_f32( + float32_t Ialpha, + float32_t Ibeta, + float32_t * pId, + float32_t * pIq, + float32_t sinVal, + float32_t cosVal) + { + /* Calculate pId using the equation, pId = Ialpha * cosVal + Ibeta * sinVal */ + *pId = Ialpha * cosVal + Ibeta * sinVal; + + /* Calculate pIq using the equation, pIq = - Ialpha * sinVal + Ibeta * cosVal */ + *pIq = -Ialpha * sinVal + Ibeta * cosVal; + + } + + /** + * @brief Park transform for Q31 version + * @param[in] Ialpha input two-phase vector coordinate alpha + * @param[in] Ibeta input two-phase vector coordinate beta + * @param[out] *pId points to output rotor reference frame d + * @param[out] *pIq points to output rotor reference frame q + * @param[in] sinVal sine value of rotation angle theta + * @param[in] cosVal cosine value of rotation angle theta + * @return none. + * + * Scaling and Overflow Behavior: + * \par + * The function is implemented using an internal 32-bit accumulator. + * The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format. + * There is saturation on the addition and subtraction, hence there is no risk of overflow. + */ + + + static __INLINE void arm_park_q31( + q31_t Ialpha, + q31_t Ibeta, + q31_t * pId, + q31_t * pIq, + q31_t sinVal, + q31_t cosVal) + { + q31_t product1, product2; /* Temporary variables used to store intermediate results */ + q31_t product3, product4; /* Temporary variables used to store intermediate results */ + + /* Intermediate product is calculated by (Ialpha * cosVal) */ + product1 = (q31_t) (((q63_t) (Ialpha) * (cosVal)) >> 31); + + /* Intermediate product is calculated by (Ibeta * sinVal) */ + product2 = (q31_t) (((q63_t) (Ibeta) * (sinVal)) >> 31); + + + /* Intermediate product is calculated by (Ialpha * sinVal) */ + product3 = (q31_t) (((q63_t) (Ialpha) * (sinVal)) >> 31); + + /* Intermediate product is calculated by (Ibeta * cosVal) */ + product4 = (q31_t) (((q63_t) (Ibeta) * (cosVal)) >> 31); + + /* Calculate pId by adding the two intermediate products 1 and 2 */ + *pId = __QADD(product1, product2); + + /* Calculate pIq by subtracting the two intermediate products 3 from 4 */ + *pIq = __QSUB(product4, product3); + } + + /** + * @} end of park group + */ + + /** + * @brief Converts the elements of the Q7 vector to floating-point vector. + * @param[in] *pSrc is input pointer + * @param[out] *pDst is output pointer + * @param[in] blockSize is the number of samples to process + * @return none. + */ + void arm_q7_to_float( + q7_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @ingroup groupController + */ + + /** + * @defgroup inv_park Vector Inverse Park transform + * Inverse Park transform converts the input flux and torque components to two-coordinate vector. + * + * The function operates on a single sample of data and each call to the function returns the processed output. + * The library provides separate functions for Q31 and floating-point data types. + * \par Algorithm + * \image html parkInvFormula.gif + * where pIalpha and pIbeta are the stator vector components, + * Id and Iq are rotor vector components and cosVal and sinVal are the + * cosine and sine values of theta (rotor flux position). + * \par Fixed-Point Behavior + * Care must be taken when using the Q31 version of the Park transform. + * In particular, the overflow and saturation behavior of the accumulator used must be considered. + * Refer to the function specific documentation below for usage guidelines. + */ + + /** + * @addtogroup inv_park + * @{ + */ + + /** + * @brief Floating-point Inverse Park transform + * @param[in] Id input coordinate of rotor reference frame d + * @param[in] Iq input coordinate of rotor reference frame q + * @param[out] *pIalpha points to output two-phase orthogonal vector axis alpha + * @param[out] *pIbeta points to output two-phase orthogonal vector axis beta + * @param[in] sinVal sine value of rotation angle theta + * @param[in] cosVal cosine value of rotation angle theta + * @return none. + */ + + static __INLINE void arm_inv_park_f32( + float32_t Id, + float32_t Iq, + float32_t * pIalpha, + float32_t * pIbeta, + float32_t sinVal, + float32_t cosVal) + { + /* Calculate pIalpha using the equation, pIalpha = Id * cosVal - Iq * sinVal */ + *pIalpha = Id * cosVal - Iq * sinVal; + + /* Calculate pIbeta using the equation, pIbeta = Id * sinVal + Iq * cosVal */ + *pIbeta = Id * sinVal + Iq * cosVal; + + } + + + /** + * @brief Inverse Park transform for Q31 version + * @param[in] Id input coordinate of rotor reference frame d + * @param[in] Iq input coordinate of rotor reference frame q + * @param[out] *pIalpha points to output two-phase orthogonal vector axis alpha + * @param[out] *pIbeta points to output two-phase orthogonal vector axis beta + * @param[in] sinVal sine value of rotation angle theta + * @param[in] cosVal cosine value of rotation angle theta + * @return none. + * + * Scaling and Overflow Behavior: + * \par + * The function is implemented using an internal 32-bit accumulator. + * The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format. + * There is saturation on the addition, hence there is no risk of overflow. + */ + + + static __INLINE void arm_inv_park_q31( + q31_t Id, + q31_t Iq, + q31_t * pIalpha, + q31_t * pIbeta, + q31_t sinVal, + q31_t cosVal) + { + q31_t product1, product2; /* Temporary variables used to store intermediate results */ + q31_t product3, product4; /* Temporary variables used to store intermediate results */ + + /* Intermediate product is calculated by (Id * cosVal) */ + product1 = (q31_t) (((q63_t) (Id) * (cosVal)) >> 31); + + /* Intermediate product is calculated by (Iq * sinVal) */ + product2 = (q31_t) (((q63_t) (Iq) * (sinVal)) >> 31); + + + /* Intermediate product is calculated by (Id * sinVal) */ + product3 = (q31_t) (((q63_t) (Id) * (sinVal)) >> 31); + + /* Intermediate product is calculated by (Iq * cosVal) */ + product4 = (q31_t) (((q63_t) (Iq) * (cosVal)) >> 31); + + /* Calculate pIalpha by using the two intermediate products 1 and 2 */ + *pIalpha = __QSUB(product1, product2); + + /* Calculate pIbeta by using the two intermediate products 3 and 4 */ + *pIbeta = __QADD(product4, product3); + + } + + /** + * @} end of Inverse park group + */ + + + /** + * @brief Converts the elements of the Q31 vector to floating-point vector. + * @param[in] *pSrc is input pointer + * @param[out] *pDst is output pointer + * @param[in] blockSize is the number of samples to process + * @return none. + */ + void arm_q31_to_float( + q31_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + /** + * @ingroup groupInterpolation + */ + + /** + * @defgroup LinearInterpolate Linear Interpolation + * + * Linear interpolation is a method of curve fitting using linear polynomials. + * Linear interpolation works by effectively drawing a straight line between two neighboring samples and returning the appropriate point along that line + * + * \par + * \image html LinearInterp.gif "Linear interpolation" + * + * \par + * A Linear Interpolate function calculates an output value(y), for the input(x) + * using linear interpolation of the input values x0, x1( nearest input values) and the output values y0 and y1(nearest output values) + * + * \par Algorithm: + * 
    +   *       y = y0 + (x - x0) * ((y1 - y0)/(x1-x0))
+   *       where x0, x1 are nearest values of input x
+   *             y0, y1 are nearest values to output y
+   *
    + * + * \par + * This set of functions implements Linear interpolation process + * for Q7, Q15, Q31, and floating-point data types. The functions operate on a single + * sample of data and each call to the function returns a single processed value. + * S points to an instance of the Linear Interpolate function data structure. + * x is the input sample value. The functions returns the output value. + * + * \par + * if x is outside of the table boundary, Linear interpolation returns first value of the table + * if x is below input range and returns last value of table if x is above range. + */ + + /** + * @addtogroup LinearInterpolate + * @{ + */ + + /** + * @brief Process function for the floating-point Linear Interpolation Function. + * @param[in,out] *S is an instance of the floating-point Linear Interpolation structure + * @param[in] x input sample to process + * @return y processed output sample. + * + */ + + static __INLINE float32_t arm_linear_interp_f32( + arm_linear_interp_instance_f32 * S, + float32_t x) + { + + float32_t y; + float32_t x0, x1; /* Nearest input values */ + float32_t y0, y1; /* Nearest output values */ + float32_t xSpacing = S->xSpacing; /* spacing between input values */ + int32_t i; /* Index variable */ + float32_t *pYData = S->pYData; /* pointer to output table */ + + /* Calculation of index */ + i = (int32_t) ((x - S->x1) / xSpacing); + + if(i < 0) + { + /* Iniatilize output for below specified range as least output value of table */ + y = pYData[0]; + } + else if((uint32_t)i >= S->nValues) + { + /* Iniatilize output for above specified range as last output value of table */ + y = pYData[S->nValues - 1]; + } + else + { + /* Calculation of nearest input values */ + x0 = S->x1 + i * xSpacing; + x1 = S->x1 + (i + 1) * xSpacing; + + /* Read of nearest output values */ + y0 = pYData[i]; + y1 = pYData[i + 1]; + + /* Calculation of output */ + y = y0 + (x - x0) * ((y1 - y0) / (x1 - x0)); + + } + + /* returns output value */ + return (y); + } + + /** + * + * @brief Process function for the Q31 Linear Interpolation Function. + * @param[in] *pYData pointer to Q31 Linear Interpolation table + * @param[in] x input sample to process + * @param[in] nValues number of table values + * @return y processed output sample. + * + * \par + * Input sample x is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part. + * This function can support maximum of table size 2^12. + * + */ + + + static __INLINE q31_t arm_linear_interp_q31( + q31_t * pYData, + q31_t x, + uint32_t nValues) + { + q31_t y; /* output */ + q31_t y0, y1; /* Nearest output values */ + q31_t fract; /* fractional part */ + int32_t index; /* Index to read nearest output values */ + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + index = ((x & 0xFFF00000) >> 20); + + if(index >= (int32_t)(nValues - 1)) + { + return (pYData[nValues - 1]); + } + else if(index < 0) + { + return (pYData[0]); + } + else + { + + /* 20 bits for the fractional part */ + /* shift left by 11 to keep fract in 1.31 format */ + fract = (x & 0x000FFFFF) << 11; + + /* Read two nearest output values from the index in 1.31(q31) format */ + y0 = pYData[index]; + y1 = pYData[index + 1u]; + + /* Calculation of y0 * (1-fract) and y is in 2.30 format */ + y = ((q31_t) ((q63_t) y0 * (0x7FFFFFFF - fract) >> 32)); + + /* Calculation of y0 * (1-fract) + y1 *fract and y is in 2.30 format */ + y += ((q31_t) (((q63_t) y1 * fract) >> 32)); + + /* Convert y to 1.31 format */ + return (y << 1u); + + } + + } + + /** + * + * @brief Process function for the Q15 Linear Interpolation Function. + * @param[in] *pYData pointer to Q15 Linear Interpolation table + * @param[in] x input sample to process + * @param[in] nValues number of table values + * @return y processed output sample. + * + * \par + * Input sample x is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part. + * This function can support maximum of table size 2^12. + * + */ + + + static __INLINE q15_t arm_linear_interp_q15( + q15_t * pYData, + q31_t x, + uint32_t nValues) + { + q63_t y; /* output */ + q15_t y0, y1; /* Nearest output values */ + q31_t fract; /* fractional part */ + int32_t index; /* Index to read nearest output values */ + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + index = ((x & 0xFFF00000) >> 20u); + + if(index >= (int32_t)(nValues - 1)) + { + return (pYData[nValues - 1]); + } + else if(index < 0) + { + return (pYData[0]); + } + else + { + /* 20 bits for the fractional part */ + /* fract is in 12.20 format */ + fract = (x & 0x000FFFFF); + + /* Read two nearest output values from the index */ + y0 = pYData[index]; + y1 = pYData[index + 1u]; + + /* Calculation of y0 * (1-fract) and y is in 13.35 format */ + y = ((q63_t) y0 * (0xFFFFF - fract)); + + /* Calculation of (y0 * (1-fract) + y1 * fract) and y is in 13.35 format */ + y += ((q63_t) y1 * (fract)); + + /* convert y to 1.15 format */ + return (y >> 20); + } + + + } + + /** + * + * @brief Process function for the Q7 Linear Interpolation Function. + * @param[in] *pYData pointer to Q7 Linear Interpolation table + * @param[in] x input sample to process + * @param[in] nValues number of table values + * @return y processed output sample. + * + * \par + * Input sample x is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part. + * This function can support maximum of table size 2^12. + */ + + + static __INLINE q7_t arm_linear_interp_q7( + q7_t * pYData, + q31_t x, + uint32_t nValues) + { + q31_t y; /* output */ + q7_t y0, y1; /* Nearest output values */ + q31_t fract; /* fractional part */ + uint32_t index; /* Index to read nearest output values */ + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + if (x < 0) + { + return (pYData[0]); + } + index = (x >> 20) & 0xfff; + + + if(index >= (nValues - 1)) + { + return (pYData[nValues - 1]); + } + else + { + + /* 20 bits for the fractional part */ + /* fract is in 12.20 format */ + fract = (x & 0x000FFFFF); + + /* Read two nearest output values from the index and are in 1.7(q7) format */ + y0 = pYData[index]; + y1 = pYData[index + 1u]; + + /* Calculation of y0 * (1-fract ) and y is in 13.27(q27) format */ + y = ((y0 * (0xFFFFF - fract))); + + /* Calculation of y1 * fract + y0 * (1-fract) and y is in 13.27(q27) format */ + y += (y1 * fract); + + /* convert y to 1.7(q7) format */ + return (y >> 20u); + + } + + } + /** + * @} end of LinearInterpolate group + */ + + /** + * @brief Fast approximation to the trigonometric sine function for floating-point data. + * @param[in] x input value in radians. + * @return sin(x). + */ + + float32_t arm_sin_f32( + float32_t x); + + /** + * @brief Fast approximation to the trigonometric sine function for Q31 data. + * @param[in] x Scaled input value in radians. + * @return sin(x). + */ + + q31_t arm_sin_q31( + q31_t x); + + /** + * @brief Fast approximation to the trigonometric sine function for Q15 data. + * @param[in] x Scaled input value in radians. + * @return sin(x). + */ + + q15_t arm_sin_q15( + q15_t x); + + /** + * @brief Fast approximation to the trigonometric cosine function for floating-point data. + * @param[in] x input value in radians. + * @return cos(x). + */ + + float32_t arm_cos_f32( + float32_t x); + + /** + * @brief Fast approximation to the trigonometric cosine function for Q31 data. + * @param[in] x Scaled input value in radians. + * @return cos(x). + */ + + q31_t arm_cos_q31( + q31_t x); + + /** + * @brief Fast approximation to the trigonometric cosine function for Q15 data. + * @param[in] x Scaled input value in radians. + * @return cos(x). + */ + + q15_t arm_cos_q15( + q15_t x); + + + /** + * @ingroup groupFastMath + */ + + + /** + * @defgroup SQRT Square Root + * + * Computes the square root of a number. + * There are separate functions for Q15, Q31, and floating-point data types. + * The square root function is computed using the Newton-Raphson algorithm. + * This is an iterative algorithm of the form: + * 
    +   *      x1 = x0 - f(x0)/f'(x0)
+   *
    + * where x1 is the current estimate, + * x0 is the previous estimate, and + * f'(x0) is the derivative of f() evaluated at x0. + * For the square root function, the algorithm reduces to: + * 
    +   *     x0 = in/2                         [initial guess]
+   *     x1 = 1/2 * ( x0 + in / x0)        [each iteration]
+   *
    + */ + + + /** + * @addtogroup SQRT + * @{ + */ + + /** + * @brief Floating-point square root function. + * @param[in] in input value. + * @param[out] *pOut square root of input value. + * @return The function returns ARM_MATH_SUCCESS if input value is positive value or ARM_MATH_ARGUMENT_ERROR if + * in is negative value and returns zero output for negative values. + */ + + static __INLINE arm_status arm_sqrt_f32( + float32_t in, + float32_t * pOut) + { + if(in > 0) + { + +// #if __FPU_USED +#if (__FPU_USED == 1) && defined ( __CC_ARM ) + *pOut = __sqrtf(in); +#else + *pOut = sqrtf(in); +#endif + + return (ARM_MATH_SUCCESS); + } + else + { + *pOut = 0.0f; + return (ARM_MATH_ARGUMENT_ERROR); + } + + } + + + /** + * @brief Q31 square root function. + * @param[in] in input value. The range of the input value is [0 +1) or 0x00000000 to 0x7FFFFFFF. + * @param[out] *pOut square root of input value. + * @return The function returns ARM_MATH_SUCCESS if input value is positive value or ARM_MATH_ARGUMENT_ERROR if + * in is negative value and returns zero output for negative values. + */ + arm_status arm_sqrt_q31( + q31_t in, + q31_t * pOut); + + /** + * @brief Q15 square root function. + * @param[in] in input value. The range of the input value is [0 +1) or 0x0000 to 0x7FFF. + * @param[out] *pOut square root of input value. + * @return The function returns ARM_MATH_SUCCESS if input value is positive value or ARM_MATH_ARGUMENT_ERROR if + * in is negative value and returns zero output for negative values. + */ + arm_status arm_sqrt_q15( + q15_t in, + q15_t * pOut); + + /** + * @} end of SQRT group + */ + + + + + + + /** + * @brief floating-point Circular write function. + */ + + static __INLINE void arm_circularWrite_f32( + int32_t * circBuffer, + int32_t L, + uint16_t * writeOffset, + int32_t bufferInc, + const int32_t * src, + int32_t srcInc, + uint32_t blockSize) + { + uint32_t i = 0u; + int32_t wOffset; + + /* Copy the value of Index pointer that points + * to the current location where the input samples to be copied */ + wOffset = *writeOffset; + + /* Loop over the blockSize */ + i = blockSize; + + while(i > 0u) + { + /* copy the input sample to the circular buffer */ + circBuffer[wOffset] = *src; + + /* Update the input pointer */ + src += srcInc; + + /* Circularly update wOffset. Watch out for positive and negative value */ + wOffset += bufferInc; + if(wOffset >= L) + wOffset -= L; + + /* Decrement the loop counter */ + i--; + } + + /* Update the index pointer */ + *writeOffset = wOffset; + } + + + + /** + * @brief floating-point Circular Read function. + */ + static __INLINE void arm_circularRead_f32( + int32_t * circBuffer, + int32_t L, + int32_t * readOffset, + int32_t bufferInc, + int32_t * dst, + int32_t * dst_base, + int32_t dst_length, + int32_t dstInc, + uint32_t blockSize) + { + uint32_t i = 0u; + int32_t rOffset, dst_end; + + /* Copy the value of Index pointer that points + * to the current location from where the input samples to be read */ + rOffset = *readOffset; + dst_end = (int32_t) (dst_base + dst_length); + + /* Loop over the blockSize */ + i = blockSize; + + while(i > 0u) + { + /* copy the sample from the circular buffer to the destination buffer */ + *dst = circBuffer[rOffset]; + + /* Update the input pointer */ + dst += dstInc; + + if(dst == (int32_t *) dst_end) + { + dst = dst_base; + } + + /* Circularly update rOffset. Watch out for positive and negative value */ + rOffset += bufferInc; + + if(rOffset >= L) + { + rOffset -= L; + } + + /* Decrement the loop counter */ + i--; + } + + /* Update the index pointer */ + *readOffset = rOffset; + } + + /** + * @brief Q15 Circular write function. + */ + + static __INLINE void arm_circularWrite_q15( + q15_t * circBuffer, + int32_t L, + uint16_t * writeOffset, + int32_t bufferInc, + const q15_t * src, + int32_t srcInc, + uint32_t blockSize) + { + uint32_t i = 0u; + int32_t wOffset; + + /* Copy the value of Index pointer that points + * to the current location where the input samples to be copied */ + wOffset = *writeOffset; + + /* Loop over the blockSize */ + i = blockSize; + + while(i > 0u) + { + /* copy the input sample to the circular buffer */ + circBuffer[wOffset] = *src; + + /* Update the input pointer */ + src += srcInc; + + /* Circularly update wOffset. Watch out for positive and negative value */ + wOffset += bufferInc; + if(wOffset >= L) + wOffset -= L; + + /* Decrement the loop counter */ + i--; + } + + /* Update the index pointer */ + *writeOffset = wOffset; + } + + + + /** + * @brief Q15 Circular Read function. + */ + static __INLINE void arm_circularRead_q15( + q15_t * circBuffer, + int32_t L, + int32_t * readOffset, + int32_t bufferInc, + q15_t * dst, + q15_t * dst_base, + int32_t dst_length, + int32_t dstInc, + uint32_t blockSize) + { + uint32_t i = 0; + int32_t rOffset, dst_end; + + /* Copy the value of Index pointer that points + * to the current location from where the input samples to be read */ + rOffset = *readOffset; + + dst_end = (int32_t) (dst_base + dst_length); + + /* Loop over the blockSize */ + i = blockSize; + + while(i > 0u) + { + /* copy the sample from the circular buffer to the destination buffer */ + *dst = circBuffer[rOffset]; + + /* Update the input pointer */ + dst += dstInc; + + if(dst == (q15_t *) dst_end) + { + dst = dst_base; + } + + /* Circularly update wOffset. Watch out for positive and negative value */ + rOffset += bufferInc; + + if(rOffset >= L) + { + rOffset -= L; + } + + /* Decrement the loop counter */ + i--; + } + + /* Update the index pointer */ + *readOffset = rOffset; + } + + + /** + * @brief Q7 Circular write function. + */ + + static __INLINE void arm_circularWrite_q7( + q7_t * circBuffer, + int32_t L, + uint16_t * writeOffset, + int32_t bufferInc, + const q7_t * src, + int32_t srcInc, + uint32_t blockSize) + { + uint32_t i = 0u; + int32_t wOffset; + + /* Copy the value of Index pointer that points + * to the current location where the input samples to be copied */ + wOffset = *writeOffset; + + /* Loop over the blockSize */ + i = blockSize; + + while(i > 0u) + { + /* copy the input sample to the circular buffer */ + circBuffer[wOffset] = *src; + + /* Update the input pointer */ + src += srcInc; + + /* Circularly update wOffset. Watch out for positive and negative value */ + wOffset += bufferInc; + if(wOffset >= L) + wOffset -= L; + + /* Decrement the loop counter */ + i--; + } + + /* Update the index pointer */ + *writeOffset = wOffset; + } + + + + /** + * @brief Q7 Circular Read function. + */ + static __INLINE void arm_circularRead_q7( + q7_t * circBuffer, + int32_t L, + int32_t * readOffset, + int32_t bufferInc, + q7_t * dst, + q7_t * dst_base, + int32_t dst_length, + int32_t dstInc, + uint32_t blockSize) + { + uint32_t i = 0; + int32_t rOffset, dst_end; + + /* Copy the value of Index pointer that points + * to the current location from where the input samples to be read */ + rOffset = *readOffset; + + dst_end = (int32_t) (dst_base + dst_length); + + /* Loop over the blockSize */ + i = blockSize; + + while(i > 0u) + { + /* copy the sample from the circular buffer to the destination buffer */ + *dst = circBuffer[rOffset]; + + /* Update the input pointer */ + dst += dstInc; + + if(dst == (q7_t *) dst_end) + { + dst = dst_base; + } + + /* Circularly update rOffset. Watch out for positive and negative value */ + rOffset += bufferInc; + + if(rOffset >= L) + { + rOffset -= L; + } + + /* Decrement the loop counter */ + i--; + } + + /* Update the index pointer */ + *readOffset = rOffset; + } + + + /** + * @brief Sum of the squares of the elements of a Q31 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_power_q31( + q31_t * pSrc, + uint32_t blockSize, + q63_t * pResult); + + /** + * @brief Sum of the squares of the elements of a floating-point vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_power_f32( + float32_t * pSrc, + uint32_t blockSize, + float32_t * pResult); + + /** + * @brief Sum of the squares of the elements of a Q15 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_power_q15( + q15_t * pSrc, + uint32_t blockSize, + q63_t * pResult); + + /** + * @brief Sum of the squares of the elements of a Q7 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_power_q7( + q7_t * pSrc, + uint32_t blockSize, + q31_t * pResult); + + /** + * @brief Mean value of a Q7 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_mean_q7( + q7_t * pSrc, + uint32_t blockSize, + q7_t * pResult); + + /** + * @brief Mean value of a Q15 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + void arm_mean_q15( + q15_t * pSrc, + uint32_t blockSize, + q15_t * pResult); + + /** + * @brief Mean value of a Q31 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + void arm_mean_q31( + q31_t * pSrc, + uint32_t blockSize, + q31_t * pResult); + + /** + * @brief Mean value of a floating-point vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + void arm_mean_f32( + float32_t * pSrc, + uint32_t blockSize, + float32_t * pResult); + + /** + * @brief Variance of the elements of a floating-point vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_var_f32( + float32_t * pSrc, + uint32_t blockSize, + float32_t * pResult); + + /** + * @brief Variance of the elements of a Q31 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_var_q31( + q31_t * pSrc, + uint32_t blockSize, + q63_t * pResult); + + /** + * @brief Variance of the elements of a Q15 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_var_q15( + q15_t * pSrc, + uint32_t blockSize, + q31_t * pResult); + + /** + * @brief Root Mean Square of the elements of a floating-point vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_rms_f32( + float32_t * pSrc, + uint32_t blockSize, + float32_t * pResult); + + /** + * @brief Root Mean Square of the elements of a Q31 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_rms_q31( + q31_t * pSrc, + uint32_t blockSize, + q31_t * pResult); + + /** + * @brief Root Mean Square of the elements of a Q15 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_rms_q15( + q15_t * pSrc, + uint32_t blockSize, + q15_t * pResult); + + /** + * @brief Standard deviation of the elements of a floating-point vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_std_f32( + float32_t * pSrc, + uint32_t blockSize, + float32_t * pResult); + + /** + * @brief Standard deviation of the elements of a Q31 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_std_q31( + q31_t * pSrc, + uint32_t blockSize, + q31_t * pResult); + + /** + * @brief Standard deviation of the elements of a Q15 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_std_q15( + q15_t * pSrc, + uint32_t blockSize, + q15_t * pResult); + + /** + * @brief Floating-point complex magnitude + * @param[in] *pSrc points to the complex input vector + * @param[out] *pDst points to the real output vector + * @param[in] numSamples number of complex samples in the input vector + * @return none. + */ + + void arm_cmplx_mag_f32( + float32_t * pSrc, + float32_t * pDst, + uint32_t numSamples); + + /** + * @brief Q31 complex magnitude + * @param[in] *pSrc points to the complex input vector + * @param[out] *pDst points to the real output vector + * @param[in] numSamples number of complex samples in the input vector + * @return none. + */ + + void arm_cmplx_mag_q31( + q31_t * pSrc, + q31_t * pDst, + uint32_t numSamples); + + /** + * @brief Q15 complex magnitude + * @param[in] *pSrc points to the complex input vector + * @param[out] *pDst points to the real output vector + * @param[in] numSamples number of complex samples in the input vector + * @return none. + */ + + void arm_cmplx_mag_q15( + q15_t * pSrc, + q15_t * pDst, + uint32_t numSamples); + + /** + * @brief Q15 complex dot product + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[in] numSamples number of complex samples in each vector + * @param[out] *realResult real part of the result returned here + * @param[out] *imagResult imaginary part of the result returned here + * @return none. + */ + + void arm_cmplx_dot_prod_q15( + q15_t * pSrcA, + q15_t * pSrcB, + uint32_t numSamples, + q31_t * realResult, + q31_t * imagResult); + + /** + * @brief Q31 complex dot product + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[in] numSamples number of complex samples in each vector + * @param[out] *realResult real part of the result returned here + * @param[out] *imagResult imaginary part of the result returned here + * @return none. + */ + + void arm_cmplx_dot_prod_q31( + q31_t * pSrcA, + q31_t * pSrcB, + uint32_t numSamples, + q63_t * realResult, + q63_t * imagResult); + + /** + * @brief Floating-point complex dot product + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[in] numSamples number of complex samples in each vector + * @param[out] *realResult real part of the result returned here + * @param[out] *imagResult imaginary part of the result returned here + * @return none. + */ + + void arm_cmplx_dot_prod_f32( + float32_t * pSrcA, + float32_t * pSrcB, + uint32_t numSamples, + float32_t * realResult, + float32_t * imagResult); + + /** + * @brief Q15 complex-by-real multiplication + * @param[in] *pSrcCmplx points to the complex input vector + * @param[in] *pSrcReal points to the real input vector + * @param[out] *pCmplxDst points to the complex output vector + * @param[in] numSamples number of samples in each vector + * @return none. + */ + + void arm_cmplx_mult_real_q15( + q15_t * pSrcCmplx, + q15_t * pSrcReal, + q15_t * pCmplxDst, + uint32_t numSamples); + + /** + * @brief Q31 complex-by-real multiplication + * @param[in] *pSrcCmplx points to the complex input vector + * @param[in] *pSrcReal points to the real input vector + * @param[out] *pCmplxDst points to the complex output vector + * @param[in] numSamples number of samples in each vector + * @return none. + */ + + void arm_cmplx_mult_real_q31( + q31_t * pSrcCmplx, + q31_t * pSrcReal, + q31_t * pCmplxDst, + uint32_t numSamples); + + /** + * @brief Floating-point complex-by-real multiplication + * @param[in] *pSrcCmplx points to the complex input vector + * @param[in] *pSrcReal points to the real input vector + * @param[out] *pCmplxDst points to the complex output vector + * @param[in] numSamples number of samples in each vector + * @return none. + */ + + void arm_cmplx_mult_real_f32( + float32_t * pSrcCmplx, + float32_t * pSrcReal, + float32_t * pCmplxDst, + uint32_t numSamples); + + /** + * @brief Minimum value of a Q7 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *result is output pointer + * @param[in] index is the array index of the minimum value in the input buffer. + * @return none. + */ + + void arm_min_q7( + q7_t * pSrc, + uint32_t blockSize, + q7_t * result, + uint32_t * index); + + /** + * @brief Minimum value of a Q15 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output pointer + * @param[in] *pIndex is the array index of the minimum value in the input buffer. + * @return none. + */ + + void arm_min_q15( + q15_t * pSrc, + uint32_t blockSize, + q15_t * pResult, + uint32_t * pIndex); + + /** + * @brief Minimum value of a Q31 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output pointer + * @param[out] *pIndex is the array index of the minimum value in the input buffer. + * @return none. + */ + void arm_min_q31( + q31_t * pSrc, + uint32_t blockSize, + q31_t * pResult, + uint32_t * pIndex); + + /** + * @brief Minimum value of a floating-point vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output pointer + * @param[out] *pIndex is the array index of the minimum value in the input buffer. + * @return none. + */ + + void arm_min_f32( + float32_t * pSrc, + uint32_t blockSize, + float32_t * pResult, + uint32_t * pIndex); + +/** + * @brief Maximum value of a Q7 vector. + * @param[in] *pSrc points to the input buffer + * @param[in] blockSize length of the input vector + * @param[out] *pResult maximum value returned here + * @param[out] *pIndex index of maximum value returned here + * @return none. + */ + + void arm_max_q7( + q7_t * pSrc, + uint32_t blockSize, + q7_t * pResult, + uint32_t * pIndex); + +/** + * @brief Maximum value of a Q15 vector. + * @param[in] *pSrc points to the input buffer + * @param[in] blockSize length of the input vector + * @param[out] *pResult maximum value returned here + * @param[out] *pIndex index of maximum value returned here + * @return none. + */ + + void arm_max_q15( + q15_t * pSrc, + uint32_t blockSize, + q15_t * pResult, + uint32_t * pIndex); + +/** + * @brief Maximum value of a Q31 vector. + * @param[in] *pSrc points to the input buffer + * @param[in] blockSize length of the input vector + * @param[out] *pResult maximum value returned here + * @param[out] *pIndex index of maximum value returned here + * @return none. + */ + + void arm_max_q31( + q31_t * pSrc, + uint32_t blockSize, + q31_t * pResult, + uint32_t * pIndex); + +/** + * @brief Maximum value of a floating-point vector. + * @param[in] *pSrc points to the input buffer + * @param[in] blockSize length of the input vector + * @param[out] *pResult maximum value returned here + * @param[out] *pIndex index of maximum value returned here + * @return none. + */ + + void arm_max_f32( + float32_t * pSrc, + uint32_t blockSize, + float32_t * pResult, + uint32_t * pIndex); + + /** + * @brief Q15 complex-by-complex multiplication + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] numSamples number of complex samples in each vector + * @return none. + */ + + void arm_cmplx_mult_cmplx_q15( + q15_t * pSrcA, + q15_t * pSrcB, + q15_t * pDst, + uint32_t numSamples); + + /** + * @brief Q31 complex-by-complex multiplication + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] numSamples number of complex samples in each vector + * @return none. + */ + + void arm_cmplx_mult_cmplx_q31( + q31_t * pSrcA, + q31_t * pSrcB, + q31_t * pDst, + uint32_t numSamples); + + /** + * @brief Floating-point complex-by-complex multiplication + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] numSamples number of complex samples in each vector + * @return none. + */ + + void arm_cmplx_mult_cmplx_f32( + float32_t * pSrcA, + float32_t * pSrcB, + float32_t * pDst, + uint32_t numSamples); + + /** + * @brief Converts the elements of the floating-point vector to Q31 vector. + * @param[in] *pSrc points to the floating-point input vector + * @param[out] *pDst points to the Q31 output vector + * @param[in] blockSize length of the input vector + * @return none. + */ + void arm_float_to_q31( + float32_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Converts the elements of the floating-point vector to Q15 vector. + * @param[in] *pSrc points to the floating-point input vector + * @param[out] *pDst points to the Q15 output vector + * @param[in] blockSize length of the input vector + * @return none + */ + void arm_float_to_q15( + float32_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Converts the elements of the floating-point vector to Q7 vector. + * @param[in] *pSrc points to the floating-point input vector + * @param[out] *pDst points to the Q7 output vector + * @param[in] blockSize length of the input vector + * @return none + */ + void arm_float_to_q7( + float32_t * pSrc, + q7_t * pDst, + uint32_t blockSize); + + + /** + * @brief Converts the elements of the Q31 vector to Q15 vector. + * @param[in] *pSrc is input pointer + * @param[out] *pDst is output pointer + * @param[in] blockSize is the number of samples to process + * @return none. + */ + void arm_q31_to_q15( + q31_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Converts the elements of the Q31 vector to Q7 vector. + * @param[in] *pSrc is input pointer + * @param[out] *pDst is output pointer + * @param[in] blockSize is the number of samples to process + * @return none. + */ + void arm_q31_to_q7( + q31_t * pSrc, + q7_t * pDst, + uint32_t blockSize); + + /** + * @brief Converts the elements of the Q15 vector to floating-point vector. + * @param[in] *pSrc is input pointer + * @param[out] *pDst is output pointer + * @param[in] blockSize is the number of samples to process + * @return none. + */ + void arm_q15_to_float( + q15_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @brief Converts the elements of the Q15 vector to Q31 vector. + * @param[in] *pSrc is input pointer + * @param[out] *pDst is output pointer + * @param[in] blockSize is the number of samples to process + * @return none. + */ + void arm_q15_to_q31( + q15_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @brief Converts the elements of the Q15 vector to Q7 vector. + * @param[in] *pSrc is input pointer + * @param[out] *pDst is output pointer + * @param[in] blockSize is the number of samples to process + * @return none. + */ + void arm_q15_to_q7( + q15_t * pSrc, + q7_t * pDst, + uint32_t blockSize); + + + /** + * @ingroup groupInterpolation + */ + + /** + * @defgroup BilinearInterpolate Bilinear Interpolation + * + * Bilinear interpolation is an extension of linear interpolation applied to a two dimensional grid. + * The underlying function f(x, y) is sampled on a regular grid and the interpolation process + * determines values between the grid points. + * Bilinear interpolation is equivalent to two step linear interpolation, first in the x-dimension and then in the y-dimension. + * Bilinear interpolation is often used in image processing to rescale images. + * The CMSIS DSP library provides bilinear interpolation functions for Q7, Q15, Q31, and floating-point data types. + * + * Algorithm + * \par + * The instance structure used by the bilinear interpolation functions describes a two dimensional data table. + * For floating-point, the instance structure is defined as: + * 
    +   *   typedef struct
+   *   {
+   *     uint16_t numRows;
+   *     uint16_t numCols;
+   *     float32_t *pData;
+   * } arm_bilinear_interp_instance_f32;
+   *
    + * + * \par + * where numRows specifies the number of rows in the table; + * numCols specifies the number of columns in the table; + * and pData points to an array of size numRows*numCols values. + * The data table pTable is organized in row order and the supplied data values fall on integer indexes. + * That is, table element (x,y) is located at pTable[x + y*numCols] where x and y are integers. + * + * \par + * Let (x, y) specify the desired interpolation point. Then define: + * 
    +   *     XF = floor(x)
+   *     YF = floor(y)
+   *
    + * \par + * The interpolated output point is computed as: + * 
    +   *  f(x, y) = f(XF, YF) * (1-(x-XF)) * (1-(y-YF))
+   *           + f(XF+1, YF) * (x-XF)*(1-(y-YF))
+   *           + f(XF, YF+1) * (1-(x-XF))*(y-YF)
+   *           + f(XF+1, YF+1) * (x-XF)*(y-YF)
+   *
    + * Note that the coordinates (x, y) contain integer and fractional components. + * The integer components specify which portion of the table to use while the + * fractional components control the interpolation processor. + * + * \par + * if (x,y) are outside of the table boundary, Bilinear interpolation returns zero output. + */ + + /** + * @addtogroup BilinearInterpolate + * @{ + */ + + /** + * + * @brief Floating-point bilinear interpolation. + * @param[in,out] *S points to an instance of the interpolation structure. + * @param[in] X interpolation coordinate. + * @param[in] Y interpolation coordinate. + * @return out interpolated value. + */ + + + static __INLINE float32_t arm_bilinear_interp_f32( + const arm_bilinear_interp_instance_f32 * S, + float32_t X, + float32_t Y) + { + float32_t out; + float32_t f00, f01, f10, f11; + float32_t *pData = S->pData; + int32_t xIndex, yIndex, index; + float32_t xdiff, ydiff; + float32_t b1, b2, b3, b4; + + xIndex = (int32_t) X; + yIndex = (int32_t) Y; + + /* Care taken for table outside boundary */ + /* Returns zero output when values are outside table boundary */ + if(xIndex < 0 || xIndex > (S->numRows - 1) || yIndex < 0 + || yIndex > (S->numCols - 1)) + { + return (0); + } + + /* Calculation of index for two nearest points in X-direction */ + index = (xIndex - 1) + (yIndex - 1) * S->numCols; + + + /* Read two nearest points in X-direction */ + f00 = pData[index]; + f01 = pData[index + 1]; + + /* Calculation of index for two nearest points in Y-direction */ + index = (xIndex - 1) + (yIndex) * S->numCols; + + + /* Read two nearest points in Y-direction */ + f10 = pData[index]; + f11 = pData[index + 1]; + + /* Calculation of intermediate values */ + b1 = f00; + b2 = f01 - f00; + b3 = f10 - f00; + b4 = f00 - f01 - f10 + f11; + + /* Calculation of fractional part in X */ + xdiff = X - xIndex; + + /* Calculation of fractional part in Y */ + ydiff = Y - yIndex; + + /* Calculation of bi-linear interpolated output */ + out = b1 + b2 * xdiff + b3 * ydiff + b4 * xdiff * ydiff; + + /* return to application */ + return (out); + + } + + /** + * + * @brief Q31 bilinear interpolation. + * @param[in,out] *S points to an instance of the interpolation structure. + * @param[in] X interpolation coordinate in 12.20 format. + * @param[in] Y interpolation coordinate in 12.20 format. + * @return out interpolated value. + */ + + static __INLINE q31_t arm_bilinear_interp_q31( + arm_bilinear_interp_instance_q31 * S, + q31_t X, + q31_t Y) + { + q31_t out; /* Temporary output */ + q31_t acc = 0; /* output */ + q31_t xfract, yfract; /* X, Y fractional parts */ + q31_t x1, x2, y1, y2; /* Nearest output values */ + int32_t rI, cI; /* Row and column indices */ + q31_t *pYData = S->pData; /* pointer to output table values */ + uint32_t nCols = S->numCols; /* num of rows */ + + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + rI = ((X & 0xFFF00000) >> 20u); + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + cI = ((Y & 0xFFF00000) >> 20u); + + /* Care taken for table outside boundary */ + /* Returns zero output when values are outside table boundary */ + if(rI < 0 || rI > (S->numRows - 1) || cI < 0 || cI > (S->numCols - 1)) + { + return (0); + } + + /* 20 bits for the fractional part */ + /* shift left xfract by 11 to keep 1.31 format */ + xfract = (X & 0x000FFFFF) << 11u; + + /* Read two nearest output values from the index */ + x1 = pYData[(rI) + nCols * (cI)]; + x2 = pYData[(rI) + nCols * (cI) + 1u]; + + /* 20 bits for the fractional part */ + /* shift left yfract by 11 to keep 1.31 format */ + yfract = (Y & 0x000FFFFF) << 11u; + + /* Read two nearest output values from the index */ + y1 = pYData[(rI) + nCols * (cI + 1)]; + y2 = pYData[(rI) + nCols * (cI + 1) + 1u]; + + /* Calculation of x1 * (1-xfract ) * (1-yfract) and acc is in 3.29(q29) format */ + out = ((q31_t) (((q63_t) x1 * (0x7FFFFFFF - xfract)) >> 32)); + acc = ((q31_t) (((q63_t) out * (0x7FFFFFFF - yfract)) >> 32)); + + /* x2 * (xfract) * (1-yfract) in 3.29(q29) and adding to acc */ + out = ((q31_t) ((q63_t) x2 * (0x7FFFFFFF - yfract) >> 32)); + acc += ((q31_t) ((q63_t) out * (xfract) >> 32)); + + /* y1 * (1 - xfract) * (yfract) in 3.29(q29) and adding to acc */ + out = ((q31_t) ((q63_t) y1 * (0x7FFFFFFF - xfract) >> 32)); + acc += ((q31_t) ((q63_t) out * (yfract) >> 32)); + + /* y2 * (xfract) * (yfract) in 3.29(q29) and adding to acc */ + out = ((q31_t) ((q63_t) y2 * (xfract) >> 32)); + acc += ((q31_t) ((q63_t) out * (yfract) >> 32)); + + /* Convert acc to 1.31(q31) format */ + return (acc << 2u); + + } + + /** + * @brief Q15 bilinear interpolation. + * @param[in,out] *S points to an instance of the interpolation structure. + * @param[in] X interpolation coordinate in 12.20 format. + * @param[in] Y interpolation coordinate in 12.20 format. + * @return out interpolated value. + */ + + static __INLINE q15_t arm_bilinear_interp_q15( + arm_bilinear_interp_instance_q15 * S, + q31_t X, + q31_t Y) + { + q63_t acc = 0; /* output */ + q31_t out; /* Temporary output */ + q15_t x1, x2, y1, y2; /* Nearest output values */ + q31_t xfract, yfract; /* X, Y fractional parts */ + int32_t rI, cI; /* Row and column indices */ + q15_t *pYData = S->pData; /* pointer to output table values */ + uint32_t nCols = S->numCols; /* num of rows */ + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + rI = ((X & 0xFFF00000) >> 20); + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + cI = ((Y & 0xFFF00000) >> 20); + + /* Care taken for table outside boundary */ + /* Returns zero output when values are outside table boundary */ + if(rI < 0 || rI > (S->numRows - 1) || cI < 0 || cI > (S->numCols - 1)) + { + return (0); + } + + /* 20 bits for the fractional part */ + /* xfract should be in 12.20 format */ + xfract = (X & 0x000FFFFF); + + /* Read two nearest output values from the index */ + x1 = pYData[(rI) + nCols * (cI)]; + x2 = pYData[(rI) + nCols * (cI) + 1u]; + + + /* 20 bits for the fractional part */ + /* yfract should be in 12.20 format */ + yfract = (Y & 0x000FFFFF); + + /* Read two nearest output values from the index */ + y1 = pYData[(rI) + nCols * (cI + 1)]; + y2 = pYData[(rI) + nCols * (cI + 1) + 1u]; + + /* Calculation of x1 * (1-xfract ) * (1-yfract) and acc is in 13.51 format */ + + /* x1 is in 1.15(q15), xfract in 12.20 format and out is in 13.35 format */ + /* convert 13.35 to 13.31 by right shifting and out is in 1.31 */ + out = (q31_t) (((q63_t) x1 * (0xFFFFF - xfract)) >> 4u); + acc = ((q63_t) out * (0xFFFFF - yfract)); + + /* x2 * (xfract) * (1-yfract) in 1.51 and adding to acc */ + out = (q31_t) (((q63_t) x2 * (0xFFFFF - yfract)) >> 4u); + acc += ((q63_t) out * (xfract)); + + /* y1 * (1 - xfract) * (yfract) in 1.51 and adding to acc */ + out = (q31_t) (((q63_t) y1 * (0xFFFFF - xfract)) >> 4u); + acc += ((q63_t) out * (yfract)); + + /* y2 * (xfract) * (yfract) in 1.51 and adding to acc */ + out = (q31_t) (((q63_t) y2 * (xfract)) >> 4u); + acc += ((q63_t) out * (yfract)); + + /* acc is in 13.51 format and down shift acc by 36 times */ + /* Convert out to 1.15 format */ + return (acc >> 36); + + } + + /** + * @brief Q7 bilinear interpolation. + * @param[in,out] *S points to an instance of the interpolation structure. + * @param[in] X interpolation coordinate in 12.20 format. + * @param[in] Y interpolation coordinate in 12.20 format. + * @return out interpolated value. + */ + + static __INLINE q7_t arm_bilinear_interp_q7( + arm_bilinear_interp_instance_q7 * S, + q31_t X, + q31_t Y) + { + q63_t acc = 0; /* output */ + q31_t out; /* Temporary output */ + q31_t xfract, yfract; /* X, Y fractional parts */ + q7_t x1, x2, y1, y2; /* Nearest output values */ + int32_t rI, cI; /* Row and column indices */ + q7_t *pYData = S->pData; /* pointer to output table values */ + uint32_t nCols = S->numCols; /* num of rows */ + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + rI = ((X & 0xFFF00000) >> 20); + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + cI = ((Y & 0xFFF00000) >> 20); + + /* Care taken for table outside boundary */ + /* Returns zero output when values are outside table boundary */ + if(rI < 0 || rI > (S->numRows - 1) || cI < 0 || cI > (S->numCols - 1)) + { + return (0); + } + + /* 20 bits for the fractional part */ + /* xfract should be in 12.20 format */ + xfract = (X & 0x000FFFFF); + + /* Read two nearest output values from the index */ + x1 = pYData[(rI) + nCols * (cI)]; + x2 = pYData[(rI) + nCols * (cI) + 1u]; + + + /* 20 bits for the fractional part */ + /* yfract should be in 12.20 format */ + yfract = (Y & 0x000FFFFF); + + /* Read two nearest output values from the index */ + y1 = pYData[(rI) + nCols * (cI + 1)]; + y2 = pYData[(rI) + nCols * (cI + 1) + 1u]; + + /* Calculation of x1 * (1-xfract ) * (1-yfract) and acc is in 16.47 format */ + out = ((x1 * (0xFFFFF - xfract))); + acc = (((q63_t) out * (0xFFFFF - yfract))); + + /* x2 * (xfract) * (1-yfract) in 2.22 and adding to acc */ + out = ((x2 * (0xFFFFF - yfract))); + acc += (((q63_t) out * (xfract))); + + /* y1 * (1 - xfract) * (yfract) in 2.22 and adding to acc */ + out = ((y1 * (0xFFFFF - xfract))); + acc += (((q63_t) out * (yfract))); + + /* y2 * (xfract) * (yfract) in 2.22 and adding to acc */ + out = ((y2 * (yfract))); + acc += (((q63_t) out * (xfract))); + + /* acc in 16.47 format and down shift by 40 to convert to 1.7 format */ + return (acc >> 40); + + } + + /** + * @} end of BilinearInterpolate group + */ + + +#if defined ( __CC_ARM ) //Keil +//SMMLAR + #define multAcc_32x32_keep32_R(a, x, y) \ + a = (q31_t) (((((q63_t) a) << 32) + ((q63_t) x * y) + 0x80000000LL ) >> 32) + +//SMMLSR + #define multSub_32x32_keep32_R(a, x, y) \ + a = (q31_t) (((((q63_t) a) << 32) - ((q63_t) x * y) + 0x80000000LL ) >> 32) + +//SMMULR + #define mult_32x32_keep32_R(a, x, y) \ + a = (q31_t) (((q63_t) x * y + 0x80000000LL ) >> 32) + +//Enter low optimization region - place directly above function definition + #define LOW_OPTIMIZATION_ENTER \ + _Pragma ("push") \ + _Pragma ("O1") + +//Exit low optimization region - place directly after end of function definition + #define LOW_OPTIMIZATION_EXIT \ + _Pragma ("pop") + +//Enter low optimization region - place directly above function definition + #define IAR_ONLY_LOW_OPTIMIZATION_ENTER + +//Exit low optimization region - place directly after end of function definition + #define IAR_ONLY_LOW_OPTIMIZATION_EXIT + +#elif defined(__ICCARM__) //IAR + //SMMLA + #define multAcc_32x32_keep32_R(a, x, y) \ + a += (q31_t) (((q63_t) x * y) >> 32) + + //SMMLS + #define multSub_32x32_keep32_R(a, x, y) \ + a -= (q31_t) (((q63_t) x * y) >> 32) + +//SMMUL + #define mult_32x32_keep32_R(a, x, y) \ + a = (q31_t) (((q63_t) x * y ) >> 32) + +//Enter low optimization region - place directly above function definition + #define LOW_OPTIMIZATION_ENTER \ + _Pragma ("optimize=low") + +//Exit low optimization region - place directly after end of function definition + #define LOW_OPTIMIZATION_EXIT + +//Enter low optimization region - place directly above function definition + #define IAR_ONLY_LOW_OPTIMIZATION_ENTER \ + _Pragma ("optimize=low") + +//Exit low optimization region - place directly after end of function definition + #define IAR_ONLY_LOW_OPTIMIZATION_EXIT + +#elif defined(__GNUC__) + //SMMLA + #define multAcc_32x32_keep32_R(a, x, y) \ + a += (q31_t) (((q63_t) x * y) >> 32) + + //SMMLS + #define multSub_32x32_keep32_R(a, x, y) \ + a -= (q31_t) (((q63_t) x * y) >> 32) + +//SMMUL + #define mult_32x32_keep32_R(a, x, y) \ + a = (q31_t) (((q63_t) x * y ) >> 32) + + #define LOW_OPTIMIZATION_ENTER __attribute__(( optimize("-O1") )) + + #define LOW_OPTIMIZATION_EXIT + + #define IAR_ONLY_LOW_OPTIMIZATION_ENTER + + #define IAR_ONLY_LOW_OPTIMIZATION_EXIT + +#endif + + + + + +#ifdef __cplusplus +} +#endif + + +#endif /* _ARM_MATH_H */ + + +/** + * + * End of file. + */ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/core_cm0.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/core_cm0.h new file mode 100644 index 00000000..1b6b54ef --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/core_cm0.h @@ -0,0 +1,682 @@ +/**************************************************************************//** + * @file core_cm0.h + * @brief CMSIS Cortex-M0 Core Peripheral Access Layer Header File + * @version V3.20 + * @date 25. February 2013 + * + * @note + * + ******************************************************************************/ +/* Copyright (c) 2009 - 2013 ARM LIMITED + + All rights reserved. + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + - Neither the name of ARM nor the names of its contributors may be used + to endorse or promote products derived from this software without + specific prior written permission. + * + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + ---------------------------------------------------------------------------*/ + + +#if defined ( __ICCARM__ ) + #pragma system_include /* treat file as system include file for MISRA check */ +#endif + +#ifdef __cplusplus + extern "C" { +#endif + +#ifndef __CORE_CM0_H_GENERIC +#define __CORE_CM0_H_GENERIC + +/** \page CMSIS_MISRA_Exceptions MISRA-C:2004 Compliance Exceptions + CMSIS violates the following MISRA-C:2004 rules: + + \li Required Rule 8.5, object/function definition in header file.
    + Function definitions in header files are used to allow 'inlining'. + + \li Required Rule 18.4, declaration of union type or object of union type: '{...}'.
    + Unions are used for effective representation of core registers. + + \li Advisory Rule 19.7, Function-like macro defined.
    + Function-like macros are used to allow more efficient code. + */ + + +/******************************************************************************* + * CMSIS definitions + ******************************************************************************/ +/** \ingroup Cortex_M0 + @{ + */ + +/* CMSIS CM0 definitions */ +#define __CM0_CMSIS_VERSION_MAIN (0x03) /*!< [31:16] CMSIS HAL main version */ +#define __CM0_CMSIS_VERSION_SUB (0x20) /*!< [15:0] CMSIS HAL sub version */ +#define __CM0_CMSIS_VERSION ((__CM0_CMSIS_VERSION_MAIN << 16) | \ + __CM0_CMSIS_VERSION_SUB ) /*!< CMSIS HAL version number */ + +#define __CORTEX_M (0x00) /*!< Cortex-M Core */ + + +#if defined ( __CC_ARM ) + #define __ASM __asm /*!< asm keyword for ARM Compiler */ + #define __INLINE __inline /*!< inline keyword for ARM Compiler */ + #define __STATIC_INLINE static __inline + +#elif defined ( __ICCARM__ ) + #define __ASM __asm /*!< asm keyword for IAR Compiler */ + #define __INLINE inline /*!< inline keyword for IAR Compiler. Only available in High optimization mode! */ + #define __STATIC_INLINE static inline + +#elif defined ( __GNUC__ ) + #define __ASM __asm /*!< asm keyword for GNU Compiler */ + #define __INLINE inline /*!< inline keyword for GNU Compiler */ + #define __STATIC_INLINE static inline + +#elif defined ( __TASKING__ ) + #define __ASM __asm /*!< asm keyword for TASKING Compiler */ + #define __INLINE inline /*!< inline keyword for TASKING Compiler */ + #define __STATIC_INLINE static inline + +#endif + +/** __FPU_USED indicates whether an FPU is used or not. This core does not support an FPU at all +*/ +#define __FPU_USED 0 + +#if defined ( __CC_ARM ) + #if defined __TARGET_FPU_VFP + #warning "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __ICCARM__ ) + #if defined __ARMVFP__ + #warning "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __GNUC__ ) + #if defined (__VFP_FP__) && !defined(__SOFTFP__) + #warning "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __TASKING__ ) + #if defined __FPU_VFP__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif +#endif + +#include /* standard types definitions */ +#include /* Core Instruction Access */ +#include /* Core Function Access */ + +#endif /* __CORE_CM0_H_GENERIC */ + +#ifndef __CMSIS_GENERIC + +#ifndef __CORE_CM0_H_DEPENDANT +#define __CORE_CM0_H_DEPENDANT + +/* check device defines and use defaults */ +#if defined __CHECK_DEVICE_DEFINES + #ifndef __CM0_REV + #define __CM0_REV 0x0000 + #warning "__CM0_REV not defined in device header file; using default!" + #endif + + #ifndef __NVIC_PRIO_BITS + #define __NVIC_PRIO_BITS 2 + #warning "__NVIC_PRIO_BITS not defined in device header file; using default!" + #endif + + #ifndef __Vendor_SysTickConfig + #define __Vendor_SysTickConfig 0 + #warning "__Vendor_SysTickConfig not defined in device header file; using default!" + #endif +#endif + +/* IO definitions (access restrictions to peripheral registers) */ +/** + \defgroup CMSIS_glob_defs CMSIS Global Defines + + IO Type Qualifiers are used + \li to specify the access to peripheral variables. + \li for automatic generation of peripheral register debug information. +*/ +#ifdef __cplusplus + #define __I volatile /*!< Defines 'read only' permissions */ +#else + #define __I volatile const /*!< Defines 'read only' permissions */ +#endif +#define __O volatile /*!< Defines 'write only' permissions */ +#define __IO volatile /*!< Defines 'read / write' permissions */ + +/*@} end of group Cortex_M0 */ + + + +/******************************************************************************* + * Register Abstraction + Core Register contain: + - Core Register + - Core NVIC Register + - Core SCB Register + - Core SysTick Register + ******************************************************************************/ +/** \defgroup CMSIS_core_register Defines and Type Definitions + \brief Type definitions and defines for Cortex-M processor based devices. +*/ + +/** \ingroup CMSIS_core_register + \defgroup CMSIS_CORE Status and Control Registers + \brief Core Register type definitions. + @{ + */ + +/** \brief Union type to access the Application Program Status Register (APSR). + */ +typedef union +{ + struct + { +#if (__CORTEX_M != 0x04) + uint32_t _reserved0:27; /*!< bit: 0..26 Reserved */ +#else + uint32_t _reserved0:16; /*!< bit: 0..15 Reserved */ + uint32_t GE:4; /*!< bit: 16..19 Greater than or Equal flags */ + uint32_t _reserved1:7; /*!< bit: 20..26 Reserved */ +#endif + uint32_t Q:1; /*!< bit: 27 Saturation condition flag */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} APSR_Type; + + +/** \brief Union type to access the Interrupt Program Status Register (IPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:23; /*!< bit: 9..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} IPSR_Type; + + +/** \brief Union type to access the Special-Purpose Program Status Registers (xPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ +#if (__CORTEX_M != 0x04) + uint32_t _reserved0:15; /*!< bit: 9..23 Reserved */ +#else + uint32_t _reserved0:7; /*!< bit: 9..15 Reserved */ + uint32_t GE:4; /*!< bit: 16..19 Greater than or Equal flags */ + uint32_t _reserved1:4; /*!< bit: 20..23 Reserved */ +#endif + uint32_t T:1; /*!< bit: 24 Thumb bit (read 0) */ + uint32_t IT:2; /*!< bit: 25..26 saved IT state (read 0) */ + uint32_t Q:1; /*!< bit: 27 Saturation condition flag */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} xPSR_Type; + + +/** \brief Union type to access the Control Registers (CONTROL). + */ +typedef union +{ + struct + { + uint32_t nPRIV:1; /*!< bit: 0 Execution privilege in Thread mode */ + uint32_t SPSEL:1; /*!< bit: 1 Stack to be used */ + uint32_t FPCA:1; /*!< bit: 2 FP extension active flag */ + uint32_t _reserved0:29; /*!< bit: 3..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} CONTROL_Type; + +/*@} end of group CMSIS_CORE */ + + +/** \ingroup CMSIS_core_register + \defgroup CMSIS_NVIC Nested Vectored Interrupt Controller (NVIC) + \brief Type definitions for the NVIC Registers + @{ + */ + +/** \brief Structure type to access the Nested Vectored Interrupt Controller (NVIC). + */ +typedef struct +{ + __IO uint32_t ISER[1]; /*!< Offset: 0x000 (R/W) Interrupt Set Enable Register */ + uint32_t RESERVED0[31]; + __IO uint32_t ICER[1]; /*!< Offset: 0x080 (R/W) Interrupt Clear Enable Register */ + uint32_t RSERVED1[31]; + __IO uint32_t ISPR[1]; /*!< Offset: 0x100 (R/W) Interrupt Set Pending Register */ + uint32_t RESERVED2[31]; + __IO uint32_t ICPR[1]; /*!< Offset: 0x180 (R/W) Interrupt Clear Pending Register */ + uint32_t RESERVED3[31]; + uint32_t RESERVED4[64]; + __IO uint32_t IP[8]; /*!< Offset: 0x300 (R/W) Interrupt Priority Register */ +} NVIC_Type; + +/*@} end of group CMSIS_NVIC */ + + +/** \ingroup CMSIS_core_register + \defgroup CMSIS_SCB System Control Block (SCB) + \brief Type definitions for the System Control Block Registers + @{ + */ + +/** \brief Structure type to access the System Control Block (SCB). + */ +typedef struct +{ + __I uint32_t CPUID; /*!< Offset: 0x000 (R/ ) CPUID Base Register */ + __IO uint32_t ICSR; /*!< Offset: 0x004 (R/W) Interrupt Control and State Register */ + uint32_t RESERVED0; + __IO uint32_t AIRCR; /*!< Offset: 0x00C (R/W) Application Interrupt and Reset Control Register */ + __IO uint32_t SCR; /*!< Offset: 0x010 (R/W) System Control Register */ + __IO uint32_t CCR; /*!< Offset: 0x014 (R/W) Configuration Control Register */ + uint32_t RESERVED1; + __IO uint32_t SHP[2]; /*!< Offset: 0x01C (R/W) System Handlers Priority Registers. [0] is RESERVED */ + __IO uint32_t SHCSR; /*!< Offset: 0x024 (R/W) System Handler Control and State Register */ +} SCB_Type; + +/* SCB CPUID Register Definitions */ +#define SCB_CPUID_IMPLEMENTER_Pos 24 /*!< SCB CPUID: IMPLEMENTER Position */ +#define SCB_CPUID_IMPLEMENTER_Msk (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos) /*!< SCB CPUID: IMPLEMENTER Mask */ + +#define SCB_CPUID_VARIANT_Pos 20 /*!< SCB CPUID: VARIANT Position */ +#define SCB_CPUID_VARIANT_Msk (0xFUL << SCB_CPUID_VARIANT_Pos) /*!< SCB CPUID: VARIANT Mask */ + +#define SCB_CPUID_ARCHITECTURE_Pos 16 /*!< SCB CPUID: ARCHITECTURE Position */ +#define SCB_CPUID_ARCHITECTURE_Msk (0xFUL << SCB_CPUID_ARCHITECTURE_Pos) /*!< SCB CPUID: ARCHITECTURE Mask */ + +#define SCB_CPUID_PARTNO_Pos 4 /*!< SCB CPUID: PARTNO Position */ +#define SCB_CPUID_PARTNO_Msk (0xFFFUL << SCB_CPUID_PARTNO_Pos) /*!< SCB CPUID: PARTNO Mask */ + +#define SCB_CPUID_REVISION_Pos 0 /*!< SCB CPUID: REVISION Position */ +#define SCB_CPUID_REVISION_Msk (0xFUL << SCB_CPUID_REVISION_Pos) /*!< SCB CPUID: REVISION Mask */ + +/* SCB Interrupt Control State Register Definitions */ +#define SCB_ICSR_NMIPENDSET_Pos 31 /*!< SCB ICSR: NMIPENDSET Position */ +#define SCB_ICSR_NMIPENDSET_Msk (1UL << SCB_ICSR_NMIPENDSET_Pos) /*!< SCB ICSR: NMIPENDSET Mask */ + +#define SCB_ICSR_PENDSVSET_Pos 28 /*!< SCB ICSR: PENDSVSET Position */ +#define SCB_ICSR_PENDSVSET_Msk (1UL << SCB_ICSR_PENDSVSET_Pos) /*!< SCB ICSR: PENDSVSET Mask */ + +#define SCB_ICSR_PENDSVCLR_Pos 27 /*!< SCB ICSR: PENDSVCLR Position */ +#define SCB_ICSR_PENDSVCLR_Msk (1UL << SCB_ICSR_PENDSVCLR_Pos) /*!< SCB ICSR: PENDSVCLR Mask */ + +#define SCB_ICSR_PENDSTSET_Pos 26 /*!< SCB ICSR: PENDSTSET Position */ +#define SCB_ICSR_PENDSTSET_Msk (1UL << SCB_ICSR_PENDSTSET_Pos) /*!< SCB ICSR: PENDSTSET Mask */ + +#define SCB_ICSR_PENDSTCLR_Pos 25 /*!< SCB ICSR: PENDSTCLR Position */ +#define SCB_ICSR_PENDSTCLR_Msk (1UL << SCB_ICSR_PENDSTCLR_Pos) /*!< SCB ICSR: PENDSTCLR Mask */ + +#define SCB_ICSR_ISRPREEMPT_Pos 23 /*!< SCB ICSR: ISRPREEMPT Position */ +#define SCB_ICSR_ISRPREEMPT_Msk (1UL << SCB_ICSR_ISRPREEMPT_Pos) /*!< SCB ICSR: ISRPREEMPT Mask */ + +#define SCB_ICSR_ISRPENDING_Pos 22 /*!< SCB ICSR: ISRPENDING Position */ +#define SCB_ICSR_ISRPENDING_Msk (1UL << SCB_ICSR_ISRPENDING_Pos) /*!< SCB ICSR: ISRPENDING Mask */ + +#define SCB_ICSR_VECTPENDING_Pos 12 /*!< SCB ICSR: VECTPENDING Position */ +#define SCB_ICSR_VECTPENDING_Msk (0x1FFUL << SCB_ICSR_VECTPENDING_Pos) /*!< SCB ICSR: VECTPENDING Mask */ + +#define SCB_ICSR_VECTACTIVE_Pos 0 /*!< SCB ICSR: VECTACTIVE Position */ +#define SCB_ICSR_VECTACTIVE_Msk (0x1FFUL << SCB_ICSR_VECTACTIVE_Pos) /*!< SCB ICSR: VECTACTIVE Mask */ + +/* SCB Application Interrupt and Reset Control Register Definitions */ +#define SCB_AIRCR_VECTKEY_Pos 16 /*!< SCB AIRCR: VECTKEY Position */ +#define SCB_AIRCR_VECTKEY_Msk (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos) /*!< SCB AIRCR: VECTKEY Mask */ + +#define SCB_AIRCR_VECTKEYSTAT_Pos 16 /*!< SCB AIRCR: VECTKEYSTAT Position */ +#define SCB_AIRCR_VECTKEYSTAT_Msk (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos) /*!< SCB AIRCR: VECTKEYSTAT Mask */ + +#define SCB_AIRCR_ENDIANESS_Pos 15 /*!< SCB AIRCR: ENDIANESS Position */ +#define SCB_AIRCR_ENDIANESS_Msk (1UL << SCB_AIRCR_ENDIANESS_Pos) /*!< SCB AIRCR: ENDIANESS Mask */ + +#define SCB_AIRCR_SYSRESETREQ_Pos 2 /*!< SCB AIRCR: SYSRESETREQ Position */ +#define SCB_AIRCR_SYSRESETREQ_Msk (1UL << SCB_AIRCR_SYSRESETREQ_Pos) /*!< SCB AIRCR: SYSRESETREQ Mask */ + +#define SCB_AIRCR_VECTCLRACTIVE_Pos 1 /*!< SCB AIRCR: VECTCLRACTIVE Position */ +#define SCB_AIRCR_VECTCLRACTIVE_Msk (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos) /*!< SCB AIRCR: VECTCLRACTIVE Mask */ + +/* SCB System Control Register Definitions */ +#define SCB_SCR_SEVONPEND_Pos 4 /*!< SCB SCR: SEVONPEND Position */ +#define SCB_SCR_SEVONPEND_Msk (1UL << SCB_SCR_SEVONPEND_Pos) /*!< SCB SCR: SEVONPEND Mask */ + +#define SCB_SCR_SLEEPDEEP_Pos 2 /*!< SCB SCR: SLEEPDEEP Position */ +#define SCB_SCR_SLEEPDEEP_Msk (1UL << SCB_SCR_SLEEPDEEP_Pos) /*!< SCB SCR: SLEEPDEEP Mask */ + +#define SCB_SCR_SLEEPONEXIT_Pos 1 /*!< SCB SCR: SLEEPONEXIT Position */ +#define SCB_SCR_SLEEPONEXIT_Msk (1UL << SCB_SCR_SLEEPONEXIT_Pos) /*!< SCB SCR: SLEEPONEXIT Mask */ + +/* SCB Configuration Control Register Definitions */ +#define SCB_CCR_STKALIGN_Pos 9 /*!< SCB CCR: STKALIGN Position */ +#define SCB_CCR_STKALIGN_Msk (1UL << SCB_CCR_STKALIGN_Pos) /*!< SCB CCR: STKALIGN Mask */ + +#define SCB_CCR_UNALIGN_TRP_Pos 3 /*!< SCB CCR: UNALIGN_TRP Position */ +#define SCB_CCR_UNALIGN_TRP_Msk (1UL << SCB_CCR_UNALIGN_TRP_Pos) /*!< SCB CCR: UNALIGN_TRP Mask */ + +/* SCB System Handler Control and State Register Definitions */ +#define SCB_SHCSR_SVCALLPENDED_Pos 15 /*!< SCB SHCSR: SVCALLPENDED Position */ +#define SCB_SHCSR_SVCALLPENDED_Msk (1UL << SCB_SHCSR_SVCALLPENDED_Pos) /*!< SCB SHCSR: SVCALLPENDED Mask */ + +/*@} end of group CMSIS_SCB */ + + +/** \ingroup CMSIS_core_register + \defgroup CMSIS_SysTick System Tick Timer (SysTick) + \brief Type definitions for the System Timer Registers. + @{ + */ + +/** \brief Structure type to access the System Timer (SysTick). + */ +typedef struct +{ + __IO uint32_t CTRL; /*!< Offset: 0x000 (R/W) SysTick Control and Status Register */ + __IO uint32_t LOAD; /*!< Offset: 0x004 (R/W) SysTick Reload Value Register */ + __IO uint32_t VAL; /*!< Offset: 0x008 (R/W) SysTick Current Value Register */ + __I uint32_t CALIB; /*!< Offset: 0x00C (R/ ) SysTick Calibration Register */ +} SysTick_Type; + +/* SysTick Control / Status Register Definitions */ +#define SysTick_CTRL_COUNTFLAG_Pos 16 /*!< SysTick CTRL: COUNTFLAG Position */ +#define SysTick_CTRL_COUNTFLAG_Msk (1UL << SysTick_CTRL_COUNTFLAG_Pos) /*!< SysTick CTRL: COUNTFLAG Mask */ + +#define SysTick_CTRL_CLKSOURCE_Pos 2 /*!< SysTick CTRL: CLKSOURCE Position */ +#define SysTick_CTRL_CLKSOURCE_Msk (1UL << SysTick_CTRL_CLKSOURCE_Pos) /*!< SysTick CTRL: CLKSOURCE Mask */ + +#define SysTick_CTRL_TICKINT_Pos 1 /*!< SysTick CTRL: TICKINT Position */ +#define SysTick_CTRL_TICKINT_Msk (1UL << SysTick_CTRL_TICKINT_Pos) /*!< SysTick CTRL: TICKINT Mask */ + +#define SysTick_CTRL_ENABLE_Pos 0 /*!< SysTick CTRL: ENABLE Position */ +#define SysTick_CTRL_ENABLE_Msk (1UL << SysTick_CTRL_ENABLE_Pos) /*!< SysTick CTRL: ENABLE Mask */ + +/* SysTick Reload Register Definitions */ +#define SysTick_LOAD_RELOAD_Pos 0 /*!< SysTick LOAD: RELOAD Position */ +#define SysTick_LOAD_RELOAD_Msk (0xFFFFFFUL << SysTick_LOAD_RELOAD_Pos) /*!< SysTick LOAD: RELOAD Mask */ + +/* SysTick Current Register Definitions */ +#define SysTick_VAL_CURRENT_Pos 0 /*!< SysTick VAL: CURRENT Position */ +#define SysTick_VAL_CURRENT_Msk (0xFFFFFFUL << SysTick_VAL_CURRENT_Pos) /*!< SysTick VAL: CURRENT Mask */ + +/* SysTick Calibration Register Definitions */ +#define SysTick_CALIB_NOREF_Pos 31 /*!< SysTick CALIB: NOREF Position */ +#define SysTick_CALIB_NOREF_Msk (1UL << SysTick_CALIB_NOREF_Pos) /*!< SysTick CALIB: NOREF Mask */ + +#define SysTick_CALIB_SKEW_Pos 30 /*!< SysTick CALIB: SKEW Position */ +#define SysTick_CALIB_SKEW_Msk (1UL << SysTick_CALIB_SKEW_Pos) /*!< SysTick CALIB: SKEW Mask */ + +#define SysTick_CALIB_TENMS_Pos 0 /*!< SysTick CALIB: TENMS Position */ +#define SysTick_CALIB_TENMS_Msk (0xFFFFFFUL << SysTick_VAL_CURRENT_Pos) /*!< SysTick CALIB: TENMS Mask */ + +/*@} end of group CMSIS_SysTick */ + + +/** \ingroup CMSIS_core_register + \defgroup CMSIS_CoreDebug Core Debug Registers (CoreDebug) + \brief Cortex-M0 Core Debug Registers (DCB registers, SHCSR, and DFSR) + are only accessible over DAP and not via processor. Therefore + they are not covered by the Cortex-M0 header file. + @{ + */ +/*@} end of group CMSIS_CoreDebug */ + + +/** \ingroup CMSIS_core_register + \defgroup CMSIS_core_base Core Definitions + \brief Definitions for base addresses, unions, and structures. + @{ + */ + +/* Memory mapping of Cortex-M0 Hardware */ +#define SCS_BASE (0xE000E000UL) /*!< System Control Space Base Address */ +#define SysTick_BASE (SCS_BASE + 0x0010UL) /*!< SysTick Base Address */ +#define NVIC_BASE (SCS_BASE + 0x0100UL) /*!< NVIC Base Address */ +#define SCB_BASE (SCS_BASE + 0x0D00UL) /*!< System Control Block Base Address */ + +#define SCB ((SCB_Type *) SCB_BASE ) /*!< SCB configuration struct */ +#define SysTick ((SysTick_Type *) SysTick_BASE ) /*!< SysTick configuration struct */ +#define NVIC ((NVIC_Type *) NVIC_BASE ) /*!< NVIC configuration struct */ + + +/*@} */ + + + +/******************************************************************************* + * Hardware Abstraction Layer + Core Function Interface contains: + - Core NVIC Functions + - Core SysTick Functions + - Core Register Access Functions + ******************************************************************************/ +/** \defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference +*/ + + + +/* ########################## NVIC functions #################################### */ +/** \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_NVICFunctions NVIC Functions + \brief Functions that manage interrupts and exceptions via the NVIC. + @{ + */ + +/* Interrupt Priorities are WORD accessible only under ARMv6M */ +/* The following MACROS handle generation of the register offset and byte masks */ +#define _BIT_SHIFT(IRQn) ( (((uint32_t)(IRQn) ) & 0x03) * 8 ) +#define _SHP_IDX(IRQn) ( ((((uint32_t)(IRQn) & 0x0F)-8) >> 2) ) +#define _IP_IDX(IRQn) ( ((uint32_t)(IRQn) >> 2) ) + + +/** \brief Enable External Interrupt + + The function enables a device-specific interrupt in the NVIC interrupt controller. + + \param [in] IRQn External interrupt number. Value cannot be negative. + */ +__STATIC_INLINE void NVIC_EnableIRQ(IRQn_Type IRQn) +{ + NVIC->ISER[0] = (1 << ((uint32_t)(IRQn) & 0x1F)); +} + + +/** \brief Disable External Interrupt + + The function disables a device-specific interrupt in the NVIC interrupt controller. + + \param [in] IRQn External interrupt number. Value cannot be negative. + */ +__STATIC_INLINE void NVIC_DisableIRQ(IRQn_Type IRQn) +{ + NVIC->ICER[0] = (1 << ((uint32_t)(IRQn) & 0x1F)); +} + + +/** \brief Get Pending Interrupt + + The function reads the pending register in the NVIC and returns the pending bit + for the specified interrupt. + + \param [in] IRQn Interrupt number. + + \return 0 Interrupt status is not pending. + \return 1 Interrupt status is pending. + */ +__STATIC_INLINE uint32_t NVIC_GetPendingIRQ(IRQn_Type IRQn) +{ + return((uint32_t) ((NVIC->ISPR[0] & (1 << ((uint32_t)(IRQn) & 0x1F)))?1:0)); +} + + +/** \brief Set Pending Interrupt + + The function sets the pending bit of an external interrupt. + + \param [in] IRQn Interrupt number. Value cannot be negative. + */ +__STATIC_INLINE void NVIC_SetPendingIRQ(IRQn_Type IRQn) +{ + NVIC->ISPR[0] = (1 << ((uint32_t)(IRQn) & 0x1F)); +} + + +/** \brief Clear Pending Interrupt + + The function clears the pending bit of an external interrupt. + + \param [in] IRQn External interrupt number. Value cannot be negative. + */ +__STATIC_INLINE void NVIC_ClearPendingIRQ(IRQn_Type IRQn) +{ + NVIC->ICPR[0] = (1 << ((uint32_t)(IRQn) & 0x1F)); /* Clear pending interrupt */ +} + + +/** \brief Set Interrupt Priority + + The function sets the priority of an interrupt. + + \note The priority cannot be set for every core interrupt. + + \param [in] IRQn Interrupt number. + \param [in] priority Priority to set. + */ +__STATIC_INLINE void NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority) +{ + if(IRQn < 0) { + SCB->SHP[_SHP_IDX(IRQn)] = (SCB->SHP[_SHP_IDX(IRQn)] & ~(0xFF << _BIT_SHIFT(IRQn))) | + (((priority << (8 - __NVIC_PRIO_BITS)) & 0xFF) << _BIT_SHIFT(IRQn)); } + else { + NVIC->IP[_IP_IDX(IRQn)] = (NVIC->IP[_IP_IDX(IRQn)] & ~(0xFF << _BIT_SHIFT(IRQn))) | + (((priority << (8 - __NVIC_PRIO_BITS)) & 0xFF) << _BIT_SHIFT(IRQn)); } +} + + +/** \brief Get Interrupt Priority + + The function reads the priority of an interrupt. The interrupt + number can be positive to specify an external (device specific) + interrupt, or negative to specify an internal (core) interrupt. + + + \param [in] IRQn Interrupt number. + \return Interrupt Priority. Value is aligned automatically to the implemented + priority bits of the microcontroller. + */ +__STATIC_INLINE uint32_t NVIC_GetPriority(IRQn_Type IRQn) +{ + + if(IRQn < 0) { + return((uint32_t)(((SCB->SHP[_SHP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & 0xFF) >> (8 - __NVIC_PRIO_BITS))); } /* get priority for Cortex-M0 system interrupts */ + else { + return((uint32_t)(((NVIC->IP[ _IP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & 0xFF) >> (8 - __NVIC_PRIO_BITS))); } /* get priority for device specific interrupts */ +} + + +/** \brief System Reset + + The function initiates a system reset request to reset the MCU. + */ +__STATIC_INLINE void NVIC_SystemReset(void) +{ + __DSB(); /* Ensure all outstanding memory accesses included + buffered write are completed before reset */ + SCB->AIRCR = ((0x5FA << SCB_AIRCR_VECTKEY_Pos) | + SCB_AIRCR_SYSRESETREQ_Msk); + __DSB(); /* Ensure completion of memory access */ + while(1); /* wait until reset */ +} + +/*@} end of CMSIS_Core_NVICFunctions */ + + + +/* ################################## SysTick function ############################################ */ +/** \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_SysTickFunctions SysTick Functions + \brief Functions that configure the System. + @{ + */ + +#if (__Vendor_SysTickConfig == 0) + +/** \brief System Tick Configuration + + The function initializes the System Timer and its interrupt, and starts the System Tick Timer. + Counter is in free running mode to generate periodic interrupts. + + \param [in] ticks Number of ticks between two interrupts. + + \return 0 Function succeeded. + \return 1 Function failed. + + \note When the variable __Vendor_SysTickConfig is set to 1, then the + function SysTick_Config is not included. In this case, the file device.h + must contain a vendor-specific implementation of this function. + + */ +__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks) +{ + if ((ticks - 1) > SysTick_LOAD_RELOAD_Msk) return (1); /* Reload value impossible */ + + SysTick->LOAD = ticks - 1; /* set reload register */ + NVIC_SetPriority (SysTick_IRQn, (1<<__NVIC_PRIO_BITS) - 1); /* set Priority for Systick Interrupt */ + SysTick->VAL = 0; /* Load the SysTick Counter Value */ + SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk | + SysTick_CTRL_TICKINT_Msk | + SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */ + return (0); /* Function successful */ +} + +#endif + +/*@} end of CMSIS_Core_SysTickFunctions */ + + + + +#endif /* __CORE_CM0_H_DEPENDANT */ + +#endif /* __CMSIS_GENERIC */ + +#ifdef __cplusplus +} +#endif diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/core_cmFunc.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/core_cmFunc.h new file mode 100644 index 00000000..139bc3c5 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/core_cmFunc.h @@ -0,0 +1,636 @@ +/**************************************************************************//** + * @file core_cmFunc.h + * @brief CMSIS Cortex-M Core Function Access Header File + * @version V3.20 + * @date 25. February 2013 + * + * @note + * + ******************************************************************************/ +/* Copyright (c) 2009 - 2013 ARM LIMITED + + All rights reserved. + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + - Neither the name of ARM nor the names of its contributors may be used + to endorse or promote products derived from this software without + specific prior written permission. + * + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + ---------------------------------------------------------------------------*/ + + +#ifndef __CORE_CMFUNC_H +#define __CORE_CMFUNC_H + + +/* ########################### Core Function Access ########################### */ +/** \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_RegAccFunctions CMSIS Core Register Access Functions + @{ + */ + +#if defined ( __CC_ARM ) /*------------------RealView Compiler -----------------*/ +/* ARM armcc specific functions */ + +#if (__ARMCC_VERSION < 400677) + #error "Please use ARM Compiler Toolchain V4.0.677 or later!" +#endif + +/* intrinsic void __enable_irq(); */ +/* intrinsic void __disable_irq(); */ + +/** \brief Get Control Register + + This function returns the content of the Control Register. + + \return Control Register value + */ +__STATIC_INLINE uint32_t __get_CONTROL(void) +{ + register uint32_t __regControl __ASM("control"); + return(__regControl); +} + + +/** \brief Set Control Register + + This function writes the given value to the Control Register. + + \param [in] control Control Register value to set + */ +__STATIC_INLINE void __set_CONTROL(uint32_t control) +{ + register uint32_t __regControl __ASM("control"); + __regControl = control; +} + + +/** \brief Get IPSR Register + + This function returns the content of the IPSR Register. + + \return IPSR Register value + */ +__STATIC_INLINE uint32_t __get_IPSR(void) +{ + register uint32_t __regIPSR __ASM("ipsr"); + return(__regIPSR); +} + + +/** \brief Get APSR Register + + This function returns the content of the APSR Register. + + \return APSR Register value + */ +__STATIC_INLINE uint32_t __get_APSR(void) +{ + register uint32_t __regAPSR __ASM("apsr"); + return(__regAPSR); +} + + +/** \brief Get xPSR Register + + This function returns the content of the xPSR Register. + + \return xPSR Register value + */ +__STATIC_INLINE uint32_t __get_xPSR(void) +{ + register uint32_t __regXPSR __ASM("xpsr"); + return(__regXPSR); +} + + +/** \brief Get Process Stack Pointer + + This function returns the current value of the Process Stack Pointer (PSP). + + \return PSP Register value + */ +__STATIC_INLINE uint32_t __get_PSP(void) +{ + register uint32_t __regProcessStackPointer __ASM("psp"); + return(__regProcessStackPointer); +} + + +/** \brief Set Process Stack Pointer + + This function assigns the given value to the Process Stack Pointer (PSP). + + \param [in] topOfProcStack Process Stack Pointer value to set + */ +__STATIC_INLINE void __set_PSP(uint32_t topOfProcStack) +{ + register uint32_t __regProcessStackPointer __ASM("psp"); + __regProcessStackPointer = topOfProcStack; +} + + +/** \brief Get Main Stack Pointer + + This function returns the current value of the Main Stack Pointer (MSP). + + \return MSP Register value + */ +__STATIC_INLINE uint32_t __get_MSP(void) +{ + register uint32_t __regMainStackPointer __ASM("msp"); + return(__regMainStackPointer); +} + + +/** \brief Set Main Stack Pointer + + This function assigns the given value to the Main Stack Pointer (MSP). + + \param [in] topOfMainStack Main Stack Pointer value to set + */ +__STATIC_INLINE void __set_MSP(uint32_t topOfMainStack) +{ + register uint32_t __regMainStackPointer __ASM("msp"); + __regMainStackPointer = topOfMainStack; +} + + +/** \brief Get Priority Mask + + This function returns the current state of the priority mask bit from the Priority Mask Register. + + \return Priority Mask value + */ +__STATIC_INLINE uint32_t __get_PRIMASK(void) +{ + register uint32_t __regPriMask __ASM("primask"); + return(__regPriMask); +} + + +/** \brief Set Priority Mask + + This function assigns the given value to the Priority Mask Register. + + \param [in] priMask Priority Mask + */ +__STATIC_INLINE void __set_PRIMASK(uint32_t priMask) +{ + register uint32_t __regPriMask __ASM("primask"); + __regPriMask = (priMask); +} + + +#if (__CORTEX_M >= 0x03) + +/** \brief Enable FIQ + + This function enables FIQ interrupts by clearing the F-bit in the CPSR. + Can only be executed in Privileged modes. + */ +#define __enable_fault_irq __enable_fiq + + +/** \brief Disable FIQ + + This function disables FIQ interrupts by setting the F-bit in the CPSR. + Can only be executed in Privileged modes. + */ +#define __disable_fault_irq __disable_fiq + + +/** \brief Get Base Priority + + This function returns the current value of the Base Priority register. + + \return Base Priority register value + */ +__STATIC_INLINE uint32_t __get_BASEPRI(void) +{ + register uint32_t __regBasePri __ASM("basepri"); + return(__regBasePri); +} + + +/** \brief Set Base Priority + + This function assigns the given value to the Base Priority register. + + \param [in] basePri Base Priority value to set + */ +__STATIC_INLINE void __set_BASEPRI(uint32_t basePri) +{ + register uint32_t __regBasePri __ASM("basepri"); + __regBasePri = (basePri & 0xff); +} + + +/** \brief Get Fault Mask + + This function returns the current value of the Fault Mask register. + + \return Fault Mask register value + */ +__STATIC_INLINE uint32_t __get_FAULTMASK(void) +{ + register uint32_t __regFaultMask __ASM("faultmask"); + return(__regFaultMask); +} + + +/** \brief Set Fault Mask + + This function assigns the given value to the Fault Mask register. + + \param [in] faultMask Fault Mask value to set + */ +__STATIC_INLINE void __set_FAULTMASK(uint32_t faultMask) +{ + register uint32_t __regFaultMask __ASM("faultmask"); + __regFaultMask = (faultMask & (uint32_t)1); +} + +#endif /* (__CORTEX_M >= 0x03) */ + + +#if (__CORTEX_M == 0x04) + +/** \brief Get FPSCR + + This function returns the current value of the Floating Point Status/Control register. + + \return Floating Point Status/Control register value + */ +__STATIC_INLINE uint32_t __get_FPSCR(void) +{ +#if (__FPU_PRESENT == 1) && (__FPU_USED == 1) + register uint32_t __regfpscr __ASM("fpscr"); + return(__regfpscr); +#else + return(0); +#endif +} + + +/** \brief Set FPSCR + + This function assigns the given value to the Floating Point Status/Control register. + + \param [in] fpscr Floating Point Status/Control value to set + */ +__STATIC_INLINE void __set_FPSCR(uint32_t fpscr) +{ +#if (__FPU_PRESENT == 1) && (__FPU_USED == 1) + register uint32_t __regfpscr __ASM("fpscr"); + __regfpscr = (fpscr); +#endif +} + +#endif /* (__CORTEX_M == 0x04) */ + + +#elif defined ( __ICCARM__ ) /*------------------ ICC Compiler -------------------*/ +/* IAR iccarm specific functions */ + +#include + + +#elif defined ( __TMS470__ ) /*---------------- TI CCS Compiler ------------------*/ +/* TI CCS specific functions */ + +#include + + +#elif defined ( __GNUC__ ) /*------------------ GNU Compiler ---------------------*/ +/* GNU gcc specific functions */ + +/** \brief Enable IRQ Interrupts + + This function enables IRQ interrupts by clearing the I-bit in the CPSR. + Can only be executed in Privileged modes. + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __enable_irq(void) +{ + __ASM volatile ("cpsie i" : : : "memory"); +} + + +/** \brief Disable IRQ Interrupts + + This function disables IRQ interrupts by setting the I-bit in the CPSR. + Can only be executed in Privileged modes. + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __disable_irq(void) +{ + __ASM volatile ("cpsid i" : : : "memory"); +} + + +/** \brief Get Control Register + + This function returns the content of the Control Register. + + \return Control Register value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_CONTROL(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, control" : "=r" (result) ); + return(result); +} + + +/** \brief Set Control Register + + This function writes the given value to the Control Register. + + \param [in] control Control Register value to set + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __set_CONTROL(uint32_t control) +{ + __ASM volatile ("MSR control, %0" : : "r" (control) : "memory"); +} + + +/** \brief Get IPSR Register + + This function returns the content of the IPSR Register. + + \return IPSR Register value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_IPSR(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, ipsr" : "=r" (result) ); + return(result); +} + + +/** \brief Get APSR Register + + This function returns the content of the APSR Register. + + \return APSR Register value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_APSR(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, apsr" : "=r" (result) ); + return(result); +} + + +/** \brief Get xPSR Register + + This function returns the content of the xPSR Register. + + \return xPSR Register value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_xPSR(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, xpsr" : "=r" (result) ); + return(result); +} + + +/** \brief Get Process Stack Pointer + + This function returns the current value of the Process Stack Pointer (PSP). + + \return PSP Register value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_PSP(void) +{ + register uint32_t result; + + __ASM volatile ("MRS %0, psp\n" : "=r" (result) ); + return(result); +} + + +/** \brief Set Process Stack Pointer + + This function assigns the given value to the Process Stack Pointer (PSP). + + \param [in] topOfProcStack Process Stack Pointer value to set + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __set_PSP(uint32_t topOfProcStack) +{ + __ASM volatile ("MSR psp, %0\n" : : "r" (topOfProcStack) : "sp"); +} + + +/** \brief Get Main Stack Pointer + + This function returns the current value of the Main Stack Pointer (MSP). + + \return MSP Register value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_MSP(void) +{ + register uint32_t result; + + __ASM volatile ("MRS %0, msp\n" : "=r" (result) ); + return(result); +} + + +/** \brief Set Main Stack Pointer + + This function assigns the given value to the Main Stack Pointer (MSP). + + \param [in] topOfMainStack Main Stack Pointer value to set + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __set_MSP(uint32_t topOfMainStack) +{ + __ASM volatile ("MSR msp, %0\n" : : "r" (topOfMainStack) : "sp"); +} + + +/** \brief Get Priority Mask + + This function returns the current state of the priority mask bit from the Priority Mask Register. + + \return Priority Mask value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_PRIMASK(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, primask" : "=r" (result) ); + return(result); +} + + +/** \brief Set Priority Mask + + This function assigns the given value to the Priority Mask Register. + + \param [in] priMask Priority Mask + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __set_PRIMASK(uint32_t priMask) +{ + __ASM volatile ("MSR primask, %0" : : "r" (priMask) : "memory"); +} + + +#if (__CORTEX_M >= 0x03) + +/** \brief Enable FIQ + + This function enables FIQ interrupts by clearing the F-bit in the CPSR. + Can only be executed in Privileged modes. + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __enable_fault_irq(void) +{ + __ASM volatile ("cpsie f" : : : "memory"); +} + + +/** \brief Disable FIQ + + This function disables FIQ interrupts by setting the F-bit in the CPSR. + Can only be executed in Privileged modes. + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __disable_fault_irq(void) +{ + __ASM volatile ("cpsid f" : : : "memory"); +} + + +/** \brief Get Base Priority + + This function returns the current value of the Base Priority register. + + \return Base Priority register value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_BASEPRI(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, basepri_max" : "=r" (result) ); + return(result); +} + + +/** \brief Set Base Priority + + This function assigns the given value to the Base Priority register. + + \param [in] basePri Base Priority value to set + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __set_BASEPRI(uint32_t value) +{ + __ASM volatile ("MSR basepri, %0" : : "r" (value) : "memory"); +} + + +/** \brief Get Fault Mask + + This function returns the current value of the Fault Mask register. + + \return Fault Mask register value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_FAULTMASK(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, faultmask" : "=r" (result) ); + return(result); +} + + +/** \brief Set Fault Mask + + This function assigns the given value to the Fault Mask register. + + \param [in] faultMask Fault Mask value to set + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __set_FAULTMASK(uint32_t faultMask) +{ + __ASM volatile ("MSR faultmask, %0" : : "r" (faultMask) : "memory"); +} + +#endif /* (__CORTEX_M >= 0x03) */ + + +#if (__CORTEX_M == 0x04) + +/** \brief Get FPSCR + + This function returns the current value of the Floating Point Status/Control register. + + \return Floating Point Status/Control register value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_FPSCR(void) +{ +#if (__FPU_PRESENT == 1) && (__FPU_USED == 1) + uint32_t result; + + /* Empty asm statement works as a scheduling barrier */ + __ASM volatile (""); + __ASM volatile ("VMRS %0, fpscr" : "=r" (result) ); + __ASM volatile (""); + return(result); +#else + return(0); +#endif +} + + +/** \brief Set FPSCR + + This function assigns the given value to the Floating Point Status/Control register. + + \param [in] fpscr Floating Point Status/Control value to set + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __set_FPSCR(uint32_t fpscr) +{ +#if (__FPU_PRESENT == 1) && (__FPU_USED == 1) + /* Empty asm statement works as a scheduling barrier */ + __ASM volatile (""); + __ASM volatile ("VMSR fpscr, %0" : : "r" (fpscr) : "vfpcc"); + __ASM volatile (""); +#endif +} + +#endif /* (__CORTEX_M == 0x04) */ + + +#elif defined ( __TASKING__ ) /*------------------ TASKING Compiler --------------*/ +/* TASKING carm specific functions */ + +/* + * The CMSIS functions have been implemented as intrinsics in the compiler. + * Please use "carm -?i" to get an up to date list of all instrinsics, + * Including the CMSIS ones. + */ + +#endif + +/*@} end of CMSIS_Core_RegAccFunctions */ + + +#endif /* __CORE_CMFUNC_H */ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/core_cmInstr.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/core_cmInstr.h new file mode 100644 index 00000000..8946c2c4 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/cmsis/core_cmInstr.h @@ -0,0 +1,688 @@ +/**************************************************************************//** + * @file core_cmInstr.h + * @brief CMSIS Cortex-M Core Instruction Access Header File + * @version V3.20 + * @date 05. March 2013 + * + * @note + * + ******************************************************************************/ +/* Copyright (c) 2009 - 2013 ARM LIMITED + + All rights reserved. + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + - Neither the name of ARM nor the names of its contributors may be used + to endorse or promote products derived from this software without + specific prior written permission. + * + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + ---------------------------------------------------------------------------*/ + + +#ifndef __CORE_CMINSTR_H +#define __CORE_CMINSTR_H + + +/* ########################## Core Instruction Access ######################### */ +/** \defgroup CMSIS_Core_InstructionInterface CMSIS Core Instruction Interface + Access to dedicated instructions + @{ +*/ + +#if defined ( __CC_ARM ) /*------------------RealView Compiler -----------------*/ +/* ARM armcc specific functions */ + +#if (__ARMCC_VERSION < 400677) + #error "Please use ARM Compiler Toolchain V4.0.677 or later!" +#endif + + +/** \brief No Operation + + No Operation does nothing. This instruction can be used for code alignment purposes. + */ +#define __NOP __nop + + +/** \brief Wait For Interrupt + + Wait For Interrupt is a hint instruction that suspends execution + until one of a number of events occurs. + */ +#define __WFI __wfi + + +/** \brief Wait For Event + + Wait For Event is a hint instruction that permits the processor to enter + a low-power state until one of a number of events occurs. + */ +#define __WFE __wfe + + +/** \brief Send Event + + Send Event is a hint instruction. It causes an event to be signaled to the CPU. + */ +#define __SEV __sev + + +/** \brief Instruction Synchronization Barrier + + Instruction Synchronization Barrier flushes the pipeline in the processor, + so that all instructions following the ISB are fetched from cache or + memory, after the instruction has been completed. + */ +#define __ISB() __isb(0xF) + + +/** \brief Data Synchronization Barrier + + This function acts as a special kind of Data Memory Barrier. + It completes when all explicit memory accesses before this instruction complete. + */ +#define __DSB() __dsb(0xF) + + +/** \brief Data Memory Barrier + + This function ensures the apparent order of the explicit memory operations before + and after the instruction, without ensuring their completion. + */ +#define __DMB() __dmb(0xF) + + +/** \brief Reverse byte order (32 bit) + + This function reverses the byte order in integer value. + + \param [in] value Value to reverse + \return Reversed value + */ +#define __REV __rev + + +/** \brief Reverse byte order (16 bit) + + This function reverses the byte order in two unsigned short values. + + \param [in] value Value to reverse + \return Reversed value + */ +#ifndef __NO_EMBEDDED_ASM +__attribute__((section(".rev16_text"))) __STATIC_INLINE __ASM uint32_t __REV16(uint32_t value) +{ + rev16 r0, r0 + bx lr +} +#endif + +/** \brief Reverse byte order in signed short value + + This function reverses the byte order in a signed short value with sign extension to integer. + + \param [in] value Value to reverse + \return Reversed value + */ +#ifndef __NO_EMBEDDED_ASM +__attribute__((section(".revsh_text"))) __STATIC_INLINE __ASM int32_t __REVSH(int32_t value) +{ + revsh r0, r0 + bx lr +} +#endif + + +/** \brief Rotate Right in unsigned value (32 bit) + + This function Rotate Right (immediate) provides the value of the contents of a register rotated by a variable number of bits. + + \param [in] value Value to rotate + \param [in] value Number of Bits to rotate + \return Rotated value + */ +#define __ROR __ror + + +/** \brief Breakpoint + + This function causes the processor to enter Debug state. + Debug tools can use this to investigate system state when the instruction at a particular address is reached. + + \param [in] value is ignored by the processor. + If required, a debugger can use it to store additional information about the breakpoint. + */ +#define __BKPT(value) __breakpoint(value) + + +#if (__CORTEX_M >= 0x03) + +/** \brief Reverse bit order of value + + This function reverses the bit order of the given value. + + \param [in] value Value to reverse + \return Reversed value + */ +#define __RBIT __rbit + + +/** \brief LDR Exclusive (8 bit) + + This function performs a exclusive LDR command for 8 bit value. + + \param [in] ptr Pointer to data + \return value of type uint8_t at (*ptr) + */ +#define __LDREXB(ptr) ((uint8_t ) __ldrex(ptr)) + + +/** \brief LDR Exclusive (16 bit) + + This function performs a exclusive LDR command for 16 bit values. + + \param [in] ptr Pointer to data + \return value of type uint16_t at (*ptr) + */ +#define __LDREXH(ptr) ((uint16_t) __ldrex(ptr)) + + +/** \brief LDR Exclusive (32 bit) + + This function performs a exclusive LDR command for 32 bit values. + + \param [in] ptr Pointer to data + \return value of type uint32_t at (*ptr) + */ +#define __LDREXW(ptr) ((uint32_t ) __ldrex(ptr)) + + +/** \brief STR Exclusive (8 bit) + + This function performs a exclusive STR command for 8 bit values. + + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +#define __STREXB(value, ptr) __strex(value, ptr) + + +/** \brief STR Exclusive (16 bit) + + This function performs a exclusive STR command for 16 bit values. + + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +#define __STREXH(value, ptr) __strex(value, ptr) + + +/** \brief STR Exclusive (32 bit) + + This function performs a exclusive STR command for 32 bit values. + + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +#define __STREXW(value, ptr) __strex(value, ptr) + + +/** \brief Remove the exclusive lock + + This function removes the exclusive lock which is created by LDREX. + + */ +#define __CLREX __clrex + + +/** \brief Signed Saturate + + This function saturates a signed value. + + \param [in] value Value to be saturated + \param [in] sat Bit position to saturate to (1..32) + \return Saturated value + */ +#define __SSAT __ssat + + +/** \brief Unsigned Saturate + + This function saturates an unsigned value. + + \param [in] value Value to be saturated + \param [in] sat Bit position to saturate to (0..31) + \return Saturated value + */ +#define __USAT __usat + + +/** \brief Count leading zeros + + This function counts the number of leading zeros of a data value. + + \param [in] value Value to count the leading zeros + \return number of leading zeros in value + */ +#define __CLZ __clz + +#endif /* (__CORTEX_M >= 0x03) */ + + + +#elif defined ( __ICCARM__ ) /*------------------ ICC Compiler -------------------*/ +/* IAR iccarm specific functions */ + +#include + + +#elif defined ( __TMS470__ ) /*---------------- TI CCS Compiler ------------------*/ +/* TI CCS specific functions */ + +#include + + +#elif defined ( __GNUC__ ) /*------------------ GNU Compiler ---------------------*/ +/* GNU gcc specific functions */ + +/* Define macros for porting to both thumb1 and thumb2. + * For thumb1, use low register (r0-r7), specified by constrant "l" + * Otherwise, use general registers, specified by constrant "r" */ +#if defined (__thumb__) && !defined (__thumb2__) +#define __CMSIS_GCC_OUT_REG(r) "=l" (r) +#define __CMSIS_GCC_USE_REG(r) "l" (r) +#else +#define __CMSIS_GCC_OUT_REG(r) "=r" (r) +#define __CMSIS_GCC_USE_REG(r) "r" (r) +#endif + +/** \brief No Operation + + No Operation does nothing. This instruction can be used for code alignment purposes. + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __NOP(void) +{ + __ASM volatile ("nop"); +} + + +/** \brief Wait For Interrupt + + Wait For Interrupt is a hint instruction that suspends execution + until one of a number of events occurs. + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __WFI(void) +{ + __ASM volatile ("wfi"); +} + + +/** \brief Wait For Event + + Wait For Event is a hint instruction that permits the processor to enter + a low-power state until one of a number of events occurs. + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __WFE(void) +{ + __ASM volatile ("wfe"); +} + + +/** \brief Send Event + + Send Event is a hint instruction. It causes an event to be signaled to the CPU. + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __SEV(void) +{ + __ASM volatile ("sev"); +} + + +/** \brief Instruction Synchronization Barrier + + Instruction Synchronization Barrier flushes the pipeline in the processor, + so that all instructions following the ISB are fetched from cache or + memory, after the instruction has been completed. + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __ISB(void) +{ + __ASM volatile ("isb"); +} + + +/** \brief Data Synchronization Barrier + + This function acts as a special kind of Data Memory Barrier. + It completes when all explicit memory accesses before this instruction complete. + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __DSB(void) +{ + __ASM volatile ("dsb"); +} + + +/** \brief Data Memory Barrier + + This function ensures the apparent order of the explicit memory operations before + and after the instruction, without ensuring their completion. + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __DMB(void) +{ + __ASM volatile ("dmb"); +} + + +/** \brief Reverse byte order (32 bit) + + This function reverses the byte order in integer value. + + \param [in] value Value to reverse + \return Reversed value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __REV(uint32_t value) +{ +#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5) + return __builtin_bswap32(value); +#else + uint32_t result; + + __ASM volatile ("rev %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) ); + return(result); +#endif +} + + +/** \brief Reverse byte order (16 bit) + + This function reverses the byte order in two unsigned short values. + + \param [in] value Value to reverse + \return Reversed value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __REV16(uint32_t value) +{ + uint32_t result; + + __ASM volatile ("rev16 %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) ); + return(result); +} + + +/** \brief Reverse byte order in signed short value + + This function reverses the byte order in a signed short value with sign extension to integer. + + \param [in] value Value to reverse + \return Reversed value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE int32_t __REVSH(int32_t value) +{ +#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8) + return (short)__builtin_bswap16(value); +#else + uint32_t result; + + __ASM volatile ("revsh %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) ); + return(result); +#endif +} + + +/** \brief Rotate Right in unsigned value (32 bit) + + This function Rotate Right (immediate) provides the value of the contents of a register rotated by a variable number of bits. + + \param [in] value Value to rotate + \param [in] value Number of Bits to rotate + \return Rotated value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __ROR(uint32_t op1, uint32_t op2) +{ + return (op1 >> op2) | (op1 << (32 - op2)); +} + + +/** \brief Breakpoint + + This function causes the processor to enter Debug state. + Debug tools can use this to investigate system state when the instruction at a particular address is reached. + + \param [in] value is ignored by the processor. + If required, a debugger can use it to store additional information about the breakpoint. + */ +#define __BKPT(value) __ASM volatile ("bkpt "#value) + + +#if (__CORTEX_M >= 0x03) + +/** \brief Reverse bit order of value + + This function reverses the bit order of the given value. + + \param [in] value Value to reverse + \return Reversed value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __RBIT(uint32_t value) +{ + uint32_t result; + + __ASM volatile ("rbit %0, %1" : "=r" (result) : "r" (value) ); + return(result); +} + + +/** \brief LDR Exclusive (8 bit) + + This function performs a exclusive LDR command for 8 bit value. + + \param [in] ptr Pointer to data + \return value of type uint8_t at (*ptr) + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint8_t __LDREXB(volatile uint8_t *addr) +{ + uint32_t result; + +#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8) + __ASM volatile ("ldrexb %0, %1" : "=r" (result) : "Q" (*addr) ); +#else + /* Prior to GCC 4.8, "Q" will be expanded to [rx, #0] which is not + accepted by assembler. So has to use following less efficient pattern. + */ + __ASM volatile ("ldrexb %0, [%1]" : "=r" (result) : "r" (addr) : "memory" ); +#endif + return(result); +} + + +/** \brief LDR Exclusive (16 bit) + + This function performs a exclusive LDR command for 16 bit values. + + \param [in] ptr Pointer to data + \return value of type uint16_t at (*ptr) + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint16_t __LDREXH(volatile uint16_t *addr) +{ + uint32_t result; + +#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8) + __ASM volatile ("ldrexh %0, %1" : "=r" (result) : "Q" (*addr) ); +#else + /* Prior to GCC 4.8, "Q" will be expanded to [rx, #0] which is not + accepted by assembler. So has to use following less efficient pattern. + */ + __ASM volatile ("ldrexh %0, [%1]" : "=r" (result) : "r" (addr) : "memory" ); +#endif + return(result); +} + + +/** \brief LDR Exclusive (32 bit) + + This function performs a exclusive LDR command for 32 bit values. + + \param [in] ptr Pointer to data + \return value of type uint32_t at (*ptr) + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __LDREXW(volatile uint32_t *addr) +{ + uint32_t result; + + __ASM volatile ("ldrex %0, %1" : "=r" (result) : "Q" (*addr) ); + return(result); +} + + +/** \brief STR Exclusive (8 bit) + + This function performs a exclusive STR command for 8 bit values. + + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __STREXB(uint8_t value, volatile uint8_t *addr) +{ + uint32_t result; + + __ASM volatile ("strexb %0, %2, %1" : "=&r" (result), "=Q" (*addr) : "r" (value) ); + return(result); +} + + +/** \brief STR Exclusive (16 bit) + + This function performs a exclusive STR command for 16 bit values. + + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __STREXH(uint16_t value, volatile uint16_t *addr) +{ + uint32_t result; + + __ASM volatile ("strexh %0, %2, %1" : "=&r" (result), "=Q" (*addr) : "r" (value) ); + return(result); +} + + +/** \brief STR Exclusive (32 bit) + + This function performs a exclusive STR command for 32 bit values. + + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __STREXW(uint32_t value, volatile uint32_t *addr) +{ + uint32_t result; + + __ASM volatile ("strex %0, %2, %1" : "=&r" (result), "=Q" (*addr) : "r" (value) ); + return(result); +} + + +/** \brief Remove the exclusive lock + + This function removes the exclusive lock which is created by LDREX. + + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __CLREX(void) +{ + __ASM volatile ("clrex" ::: "memory"); +} + + +/** \brief Signed Saturate + + This function saturates a signed value. + + \param [in] value Value to be saturated + \param [in] sat Bit position to saturate to (1..32) + \return Saturated value + */ +#define __SSAT(ARG1,ARG2) \ +({ \ + uint32_t __RES, __ARG1 = (ARG1); \ + __ASM ("ssat %0, %1, %2" : "=r" (__RES) : "I" (ARG2), "r" (__ARG1) ); \ + __RES; \ + }) + + +/** \brief Unsigned Saturate + + This function saturates an unsigned value. + + \param [in] value Value to be saturated + \param [in] sat Bit position to saturate to (0..31) + \return Saturated value + */ +#define __USAT(ARG1,ARG2) \ +({ \ + uint32_t __RES, __ARG1 = (ARG1); \ + __ASM ("usat %0, %1, %2" : "=r" (__RES) : "I" (ARG2), "r" (__ARG1) ); \ + __RES; \ + }) + + +/** \brief Count leading zeros + + This function counts the number of leading zeros of a data value. + + \param [in] value Value to count the leading zeros + \return number of leading zeros in value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint8_t __CLZ(uint32_t value) +{ + uint32_t result; + + __ASM volatile ("clz %0, %1" : "=r" (result) : "r" (value) ); + return(result); +} + +#endif /* (__CORTEX_M >= 0x03) */ + + + + +#elif defined ( __TASKING__ ) /*------------------ TASKING Compiler --------------*/ +/* TASKING carm specific functions */ + +/* + * The CMSIS functions have been implemented as intrinsics in the compiler. + * Please use "carm -?i" to get an up to date list of all intrinsics, + * Including the CMSIS ones. + */ + +#endif + +/*@}*/ /* end of group CMSIS_Core_InstructionInterface */ + +#endif /* __CORE_CMINSTR_H */ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/stm32f0xx.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/stm32f0xx.h new file mode 100644 index 00000000..b868a975 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/stm32f0xx.h @@ -0,0 +1,5707 @@ +/** + ****************************************************************************** + * @file stm32f0xx.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief CMSIS Cortex-M0 Device Peripheral Access Layer Header File. + * This file contains all the peripheral register's definitions, bits + * definitions and memory mapping for STM32F0xx devices. + * + * The file is the unique include file that the application programmer + * is using in the C source code, usually in main.c. This file contains: + * - Configuration section that allows to select: + * - The device used in the target application + * - To use or not the peripheral’s drivers in application code(i.e. + * code will be based on direct access to peripheral’s registers + * rather than drivers API), this option is controlled by + * "#define USE_STDPERIPH_DRIVER" + * - To change few application-specific parameters such as the HSE + * crystal frequency + * - Data structures and the address mapping for all peripherals + * - Peripheral's registers declarations and bits definition + * - Macros to access peripheral’s registers hardware + * + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/** @addtogroup CMSIS + * @{ + */ + +/** @addtogroup stm32f0xx + * @{ + */ + +#ifndef __STM32F0XX_H +#define __STM32F0XX_H + +#ifdef __cplusplus + extern "C" { +#endif + +/** @addtogroup Library_configuration_section + * @{ + */ + +/* Uncomment the line below according to the target STM32F0 device used in your + application + */ + +#if !defined (STM32F030) && !defined (STM32F031) && !defined (STM32F051) && \ + !defined (STM32F072) && !defined (STM32F042) && !defined (STM32F091) && \ + !defined (STM32F070xB) && !defined (STM32F070x6) && !defined (STM32F030xC) + /* #define STM32F030 */ + /* #define STM32F031 */ + /* #define STM32F051 */ + /* #define STM32F072 */ + /* #define STM32F070xB */ + /* #define STM32F042 */ + /* #define STM32F070x6 */ + /* #define STM32F091 */ + /* #define STM32F030xC */ +#endif /* STM32F030 || STM32F031 || STM32F051 || STM32F072 || STM32F042 || STM32F091 || + STM32F070xB || STM32F070x6 || STM32F030xC */ + +/* Tip: To avoid modifying this file each time you need to switch between these + devices, you can define the device in your toolchain compiler preprocessor. + */ + +/* Old STM32F0XX definition, maintained for legacy purpose */ +#if defined(STM32F0XX) || defined(STM32F0XX_MD) + #define STM32F051 +#endif /* STM32F0XX */ + +/* Old STM32F0XX_LD definition, maintained for legacy purpose */ +#ifdef STM32F0XX_LD + #define STM32F031 +#endif /* STM32F0XX_LD */ + +/* Old STM32F0XX_HD definition, maintained for legacy purpose */ +#ifdef STM32F0XX_HD + #define STM32F072 +#endif /* STM32F0XX_HD */ + +/* Old STM32F030X6/X8 definition, maintained for legacy purpose */ +#if defined (STM32F030X8) || defined (STM32F030X6) + #define STM32F030 +#endif /* STM32F030X8 or STM32F030X6 */ + + +#if !defined (STM32F030) && !defined (STM32F031) && !defined (STM32F051) && \ + !defined (STM32F072) && !defined (STM32F042) && !defined (STM32F091) && \ + !defined (STM32F070xB) && !defined (STM32F070x6) && !defined (STM32F030xC) + #error "Please select first the target STM32F0xx device used in your application (in stm32f0xx.h file)" +#endif /* STM32F030 || STM32F031 || STM32F051 || STM32F072 || STM32F042 || STM32F091 || + STM32F070xB || STM32F070x6 || STM32F030xC */ + +#if !defined USE_STDPERIPH_DRIVER +/** + * @brief Comment the line below if you will not use the peripherals drivers. + In this case, these drivers will not be included and the application code will + be based on direct access to peripherals registers + */ + /*#define USE_STDPERIPH_DRIVER*/ +#endif /* USE_STDPERIPH_DRIVER */ + +/** + * @brief In the following line adjust the value of External High Speed oscillator (HSE) + used in your application + + Tip: To avoid modifying this file each time you need to use different HSE, you + can define the HSE value in your toolchain compiler preprocessor. + */ +#if !defined (HSE_VALUE) +#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz*/ +#endif /* HSE_VALUE */ + +/** + * @brief In the following line adjust the External High Speed oscillator (HSE) Startup + Timeout value + */ +#if !defined (HSE_STARTUP_TIMEOUT) +#define HSE_STARTUP_TIMEOUT ((uint16_t)0x5000) /*!< Time out for HSE start up */ +#endif /* HSE_STARTUP_TIMEOUT */ + +/** + * @brief In the following line adjust the Internal High Speed oscillator (HSI) Startup + Timeout value + */ +#if !defined (HSI_STARTUP_TIMEOUT) +#define HSI_STARTUP_TIMEOUT ((uint16_t)0x5000) /*!< Time out for HSI start up */ +#endif /* HSI_STARTUP_TIMEOUT */ + +#if !defined (HSI_VALUE) +#define HSI_VALUE ((uint32_t)8000000) /*!< Value of the Internal High Speed oscillator in Hz. + The real value may vary depending on the variations + in voltage and temperature. */ +#endif /* HSI_VALUE */ + +#if !defined (HSI14_VALUE) +#define HSI14_VALUE ((uint32_t)14000000) /*!< Value of the Internal High Speed oscillator for ADC in Hz. + The real value may vary depending on the variations + in voltage and temperature. */ +#endif /* HSI14_VALUE */ + +#if !defined (HSI48_VALUE) +#define HSI48_VALUE ((uint32_t)48000000) /*!< Value of the Internal High Speed oscillator for USB in Hz. + The real value may vary depending on the variations + in voltage and temperature. */ +#endif /* HSI48_VALUE */ + +#if !defined (LSI_VALUE) +#define LSI_VALUE ((uint32_t)40000) /*!< Value of the Internal Low Speed oscillator in Hz + The real value may vary depending on the variations + in voltage and temperature. */ +#endif /* LSI_VALUE */ + +#if !defined (LSE_VALUE) +#define LSE_VALUE ((uint32_t)32768) /*!< Value of the External Low Speed oscillator in Hz */ +#endif /* LSE_VALUE */ + +/** + * @brief STM32F0xx Standard Peripheral Library version number V1.4.0 + */ +#define __STM32F0XX_STDPERIPH_VERSION_MAIN (0x01) /*!< [31:24] main version */ +#define __STM32F0XX_STDPERIPH_VERSION_SUB1 (0x05) /*!< [23:16] sub1 version */ +#define __STM32F0XX_STDPERIPH_VERSION_SUB2 (0x00) /*!< [15:8] sub2 version */ +#define __STM32F0XX_STDPERIPH_VERSION_RC (0x00) /*!< [7:0] release candidate */ +#define __STM32F0XX_STDPERIPH_VERSION ((__STM32F0XX_STDPERIPH_VERSION_MAIN << 24)\ + |(__STM32F0XX_STDPERIPH_VERSION_SUB1 << 16)\ + |(__STM32F0XX_STDPERIPH_VERSION_SUB2 << 8)\ + |(__STM32F0XX_STDPERIPH_VERSION_RC)) + +/** + * @} + */ + +/** @addtogroup Configuration_section_for_CMSIS + * @{ + */ + +/** + * @brief STM32F0xx Interrupt Number Definition, according to the selected device + * in @ref Library_configuration_section + */ +#define __CM0_REV 0 /*!< Core Revision r0p0 */ +#define __MPU_PRESENT 0 /*!< STM32F0xx do not provide MPU */ +#define __NVIC_PRIO_BITS 2 /*!< STM32F0xx uses 2 Bits for the Priority Levels */ +#define __Vendor_SysTickConfig 0 /*!< Set to 1 if different SysTick Config is used */ + +/*!< Interrupt Number Definition */ +typedef enum IRQn +{ +/****** Cortex-M0 Processor Exceptions Numbers ******************************************************/ + NonMaskableInt_IRQn = -14, /*!< 2 Non Maskable Interrupt */ + HardFault_IRQn = -13, /*!< 3 Cortex-M0 Hard Fault Interrupt */ + SVC_IRQn = -5, /*!< 11 Cortex-M0 SV Call Interrupt */ + PendSV_IRQn = -2, /*!< 14 Cortex-M0 Pend SV Interrupt */ + SysTick_IRQn = -1, /*!< 15 Cortex-M0 System Tick Interrupt */ + +#if defined (STM32F051) +/****** STM32F051 specific Interrupt Numbers *************************************/ + WWDG_IRQn = 0, /*!< Window WatchDog Interrupt */ + PVD_IRQn = 1, /*!< PVD through EXTI Line detect Interrupt */ + RTC_IRQn = 2, /*!< RTC through EXTI Line Interrupt */ + FLASH_IRQn = 3, /*!< FLASH Interrupt */ + RCC_IRQn = 4, /*!< RCC Interrupt */ + EXTI0_1_IRQn = 5, /*!< EXTI Line 0 and 1 Interrupts */ + EXTI2_3_IRQn = 6, /*!< EXTI Line 2 and 3 Interrupts */ + EXTI4_15_IRQn = 7, /*!< EXTI Line 4 to 15 Interrupts */ + TS_IRQn = 8, /*!< Touch sense controller Interrupt */ + DMA1_Channel1_IRQn = 9, /*!< DMA1 Channel 1 Interrupt */ + DMA1_Channel2_3_IRQn = 10, /*!< DMA1 Channel 2 and Channel 3 Interrupts */ + DMA1_Channel4_5_IRQn = 11, /*!< DMA1 Channel 4 and Channel 5 Interrupts */ + ADC1_COMP_IRQn = 12, /*!< ADC1, COMP1 and COMP2 Interrupts */ + TIM1_BRK_UP_TRG_COM_IRQn = 13, /*!< TIM1 Break, Update, Trigger and Commutation Interrupts */ + TIM1_CC_IRQn = 14, /*!< TIM1 Capture Compare Interrupt */ + TIM2_IRQn = 15, /*!< TIM2 Interrupt */ + TIM3_IRQn = 16, /*!< TIM3 Interrupt */ + TIM6_DAC_IRQn = 17, /*!< TIM6 and DAC Interrupts */ + TIM14_IRQn = 19, /*!< TIM14 Interrupt */ + TIM15_IRQn = 20, /*!< TIM15 Interrupt */ + TIM16_IRQn = 21, /*!< TIM16 Interrupt */ + TIM17_IRQn = 22, /*!< TIM17 Interrupt */ + I2C1_IRQn = 23, /*!< I2C1 Interrupt */ + I2C2_IRQn = 24, /*!< I2C2 Interrupt */ + SPI1_IRQn = 25, /*!< SPI1 Interrupt */ + SPI2_IRQn = 26, /*!< SPI2 Interrupt */ + USART1_IRQn = 27, /*!< USART1 Interrupt */ + USART2_IRQn = 28, /*!< USART2 Interrupt */ + CEC_IRQn = 30 /*!< CEC Interrupt */ +#elif defined (STM32F031) +/****** STM32F031 specific Interrupt Numbers *************************************/ + WWDG_IRQn = 0, /*!< Window WatchDog Interrupt */ + PVD_IRQn = 1, /*!< PVD through EXTI Line detect Interrupt */ + RTC_IRQn = 2, /*!< RTC through EXTI Line Interrupt */ + FLASH_IRQn = 3, /*!< FLASH Interrupt */ + RCC_IRQn = 4, /*!< RCC Interrupt */ + EXTI0_1_IRQn = 5, /*!< EXTI Line 0 and 1 Interrupts */ + EXTI2_3_IRQn = 6, /*!< EXTI Line 2 and 3 Interrupts */ + EXTI4_15_IRQn = 7, /*!< EXTI Line 4 to 15 Interrupts */ + DMA1_Channel1_IRQn = 9, /*!< DMA1 Channel 1 Interrupt */ + DMA1_Channel2_3_IRQn = 10, /*!< DMA1 Channel 2 and Channel 3 Interrupts */ + DMA1_Channel4_5_IRQn = 11, /*!< DMA1 Channel 4 and Channel 5 Interrupts */ + ADC1_IRQn = 12, /*!< ADC1 Interrupt */ + TIM1_BRK_UP_TRG_COM_IRQn = 13, /*!< TIM1 Break, Update, Trigger and Commutation Interrupts */ + TIM1_CC_IRQn = 14, /*!< TIM1 Capture Compare Interrupt */ + TIM2_IRQn = 15, /*!< TIM2 Interrupt */ + TIM3_IRQn = 16, /*!< TIM3 Interrupt */ + TIM14_IRQn = 19, /*!< TIM14 Interrupt */ + TIM16_IRQn = 21, /*!< TIM16 Interrupt */ + TIM17_IRQn = 22, /*!< TIM17 Interrupt */ + I2C1_IRQn = 23, /*!< I2C1 Interrupt */ + SPI1_IRQn = 25, /*!< SPI1 Interrupt */ + USART1_IRQn = 27 /*!< USART1 Interrupt */ +#elif defined (STM32F030) +/****** STM32F030 specific Interrupt Numbers *************************************/ + WWDG_IRQn = 0, /*!< Window WatchDog Interrupt */ + RTC_IRQn = 2, /*!< RTC through EXTI Line Interrupt */ + FLASH_IRQn = 3, /*!< FLASH Interrupt */ + RCC_IRQn = 4, /*!< RCC Interrupt */ + EXTI0_1_IRQn = 5, /*!< EXTI Line 0 and 1 Interrupts */ + EXTI2_3_IRQn = 6, /*!< EXTI Line 2 and 3 Interrupts */ + EXTI4_15_IRQn = 7, /*!< EXTI Line 4 to 15 Interrupts */ + DMA1_Channel1_IRQn = 9, /*!< DMA1 Channel 1 Interrupt */ + DMA1_Channel2_3_IRQn = 10, /*!< DMA1 Channel 2 and Channel 3 Interrupts */ + DMA1_Channel4_5_IRQn = 11, /*!< DMA1 Channel 4 and Channel 5 Interrupts */ + ADC1_IRQn = 12, /*!< ADC1 Interrupt */ + TIM1_BRK_UP_TRG_COM_IRQn = 13, /*!< TIM1 Break, Update, Trigger and Commutation Interrupts */ + TIM1_CC_IRQn = 14, /*!< TIM1 Capture Compare Interrupt */ + TIM3_IRQn = 16, /*!< TIM3 Interrupt */ + TIM14_IRQn = 19, /*!< TIM14 Interrupt */ + TIM15_IRQn = 20, /*!< TIM15 Interrupt */ + TIM16_IRQn = 21, /*!< TIM16 Interrupt */ + TIM17_IRQn = 22, /*!< TIM17 Interrupt */ + I2C1_IRQn = 23, /*!< I2C1 Interrupt */ + I2C2_IRQn = 24, /*!< I2C2 Interrupt */ + SPI1_IRQn = 25, /*!< SPI1 Interrupt */ + SPI2_IRQn = 26, /*!< SPI2 Interrupt */ + USART1_IRQn = 27, /*!< USART1 Interrupt */ + USART2_IRQn = 28 /*!< USART2 Interrupt */ +#elif defined (STM32F072) + WWDG_IRQn = 0, /*!< Window WatchDog Interrupt */ + PVD_VDDIO2_IRQn = 1, /*!< PVD and VDDIO2 supply comparator through EXTI Line detect Interrupt */ + RTC_IRQn = 2, /*!< RTC through EXTI Line Interrupt */ + FLASH_IRQn = 3, /*!< FLASH Interrupt */ + RCC_CRS_IRQn = 4, /*!< RCC and CRS Interrupts */ + EXTI0_1_IRQn = 5, /*!< EXTI Line 0 and 1 Interrupts */ + EXTI2_3_IRQn = 6, /*!< EXTI Line 2 and 3 Interrupts */ + EXTI4_15_IRQn = 7, /*!< EXTI Line 4 to 15 Interrupts */ + TSC_IRQn = 8, /*!< TSC Interrupt */ + DMA1_Channel1_IRQn = 9, /*!< DMA1 Channel 1 Interrupt */ + DMA1_Channel2_3_IRQn = 10, /*!< DMA1 Channel 2 and Channel 3 Interrupts */ + DMA1_Channel4_5_6_7_IRQn = 11, /*!< DMA1 Channel 4, Channel 5, Channel 6 and Channel 7 Interrupts */ + ADC1_COMP_IRQn = 12, /*!< ADC1, COMP1 and COMP2 Interrupts */ + TIM1_BRK_UP_TRG_COM_IRQn = 13, /*!< TIM1 Break, Update, Trigger and Commutation Interrupts */ + TIM1_CC_IRQn = 14, /*!< TIM1 Capture Compare Interrupt */ + TIM2_IRQn = 15, /*!< TIM2 Interrupt */ + TIM3_IRQn = 16, /*!< TIM3 Interrupt */ + TIM6_DAC_IRQn = 17, /*!< TIM6 and DAC Interrupts */ + TIM7_IRQn = 18, /*!< TIM7 Interrupts */ + TIM14_IRQn = 19, /*!< TIM14 Interrupt */ + TIM15_IRQn = 20, /*!< TIM15 Interrupt */ + TIM16_IRQn = 21, /*!< TIM16 Interrupt */ + TIM17_IRQn = 22, /*!< TIM17 Interrupt */ + I2C1_IRQn = 23, /*!< I2C1 Interrupt */ + I2C2_IRQn = 24, /*!< I2C2 Interrupt */ + SPI1_IRQn = 25, /*!< SPI1 Interrupt */ + SPI2_IRQn = 26, /*!< SPI2 Interrupt */ + USART1_IRQn = 27, /*!< USART1 Interrupt */ + USART2_IRQn = 28, /*!< USART2 Interrupt */ + USART3_4_IRQn = 29, /*!< USART3 and USART4 Interrupts */ + CEC_CAN_IRQn = 30, /*!< CEC and CAN Interrupts */ + USB_IRQn = 31 /*!< USB Low Priority global Interrupt */ +#elif defined (STM32F042) + WWDG_IRQn = 0, /*!< Window WatchDog Interrupt */ + PVD_VDDIO2_IRQn = 1, /*!< PVD and VDDIO2 supply comparator through EXTI Line detect Interrupt */ + RTC_IRQn = 2, /*!< RTC through EXTI Line Interrupt */ + FLASH_IRQn = 3, /*!< FLASH Interrupt */ + RCC_CRS_IRQn = 4, /*!< RCC and CRS Interrupts */ + EXTI0_1_IRQn = 5, /*!< EXTI Line 0 and 1 Interrupts */ + EXTI2_3_IRQn = 6, /*!< EXTI Line 2 and 3 Interrupts */ + EXTI4_15_IRQn = 7, /*!< EXTI Line 4 to 15 Interrupts */ + TSC_IRQn = 8, /*!< TSC Interrupt */ + DMA1_Channel1_IRQn = 9, /*!< DMA1 Channel 1 Interrupt */ + DMA1_Channel2_3_IRQn = 10, /*!< DMA1 Channel 2 and Channel 3 Interrupts */ + DMA1_Channel4_5_IRQn = 11, /*!< DMA1 Channel 4, Channel 5 Interrupts */ + ADC1_IRQn = 12, /*!< ADC1 Interrupts */ + TIM1_BRK_UP_TRG_COM_IRQn = 13, /*!< TIM1 Break, Update, Trigger and Commutation Interrupts */ + TIM1_CC_IRQn = 14, /*!< TIM1 Capture Compare Interrupt */ + TIM2_IRQn = 15, /*!< TIM2 Interrupt */ + TIM3_IRQn = 16, /*!< TIM3 Interrupt */ + TIM14_IRQn = 19, /*!< TIM14 Interrupt */ + TIM16_IRQn = 21, /*!< TIM16 Interrupt */ + TIM17_IRQn = 22, /*!< TIM17 Interrupt */ + I2C1_IRQn = 23, /*!< I2C1 Interrupt */ + SPI1_IRQn = 25, /*!< SPI1 Interrupt */ + SPI2_IRQn = 26, /*!< SPI2 Interrupt */ + USART1_IRQn = 27, /*!< USART1 Interrupt */ + USART2_IRQn = 28, /*!< USART2 Interrupt */ + CEC_CAN_IRQn = 30, /*!< CEC and CAN Interrupts */ + USB_IRQn = 31 /*!< USB Low Priority global Interrupt */ +#elif defined (STM32F091) + WWDG_IRQn = 0, /*!< Window WatchDog Interrupt */ + PVD_VDDIO2_IRQn = 1, /*!< PVD & VDDIO2 Interrupts through EXTI Lines 16 and 31 */ + RTC_IRQn = 2, /*!< RTC Interrupt through EXTI Lines 17, 19 and 20 */ + FLASH_IRQn = 3, /*!< FLASH global Interrupt */ + RCC_CRS_IRQn = 4, /*!< RCC & CRS Global Interrupts */ + EXTI0_1_IRQn = 5, /*!< EXTI Line 0 and 1 Interrupts */ + EXTI2_3_IRQn = 6, /*!< EXTI Line 2 and 3 Interrupts */ + EXTI4_15_IRQn = 7, /*!< EXTI Line 4 to 15 Interrupts */ + TSC_IRQn = 8, /*!< Touch Sensing Controller Interrupts */ + DMA1_Ch1_IRQn = 9, /*!< DMA1 Channel 1 Interrupt */ + DMA1_Ch2_3_DMA2_Ch1_2_IRQn = 10, /*!< DMA1 Channel 2 and 3 & DMA2 Channel 1 and 2 Interrupts */ + DMA1_Ch4_7_DMA2_Ch3_5_IRQn = 11, /*!< DMA1 Channel 4 to 7 & DMA2 Channel 3 to 5 Interrupts */ + ADC1_COMP_IRQn = 12, /*!< ADC, COMP1 and COMP2 Interrupts (EXTI Lines 21 and 22) */ + TIM1_BRK_UP_TRG_COM_IRQn = 13, /*!< TIM1 Break, Update, Trigger and Commutation Interrupts */ + TIM1_CC_IRQn = 14, /*!< TIM1 Capture Compare Interrupt */ + TIM2_IRQn = 15, /*!< TIM2 global Interrupt */ + TIM3_IRQn = 16, /*!< TIM3 global Interrupt */ + TIM6_DAC_IRQn = 17, /*!< TIM6 global and DAC channel underrun error Interrupts */ + TIM7_IRQn = 18, /*!< TIM7 global Interrupt */ + TIM14_IRQn = 19, /*!< TIM14 global Interrupt */ + TIM15_IRQn = 20, /*!< TIM15 global Interrupt */ + TIM16_IRQn = 21, /*!< TIM16 global Interrupt */ + TIM17_IRQn = 22, /*!< TIM17 global Interrupt */ + I2C1_IRQn = 23, /*!< I2C1 Event Interrupt & EXTI Line23 Interrupt (I2C1 wakeup) */ + I2C2_IRQn = 24, /*!< I2C2 Event Interrupt & EXTI Line24 Interrupt (I2C2 wakeup) */ + SPI1_IRQn = 25, /*!< SPI1 global Interrupt */ + SPI2_IRQn = 26, /*!< SPI2 global Interrupt */ + USART1_IRQn = 27, /*!< USART1 global Interrupt & EXTI Line25 Interrupt (USART1 wakeup) */ + USART2_IRQn = 28, /*!< USART2 global Interrupt & EXTI Line26 Interrupt (USART2 wakeup) */ + USART3_8_IRQn = 29, /*!< USART3 to USART8 global Interrupts */ + CEC_CAN_IRQn = 30 /*!< CEC and CAN global Interrupts & EXTI Line27 Interrupt */ +#elif defined (STM32F070xB) + WWDG_IRQn = 0, /*!< Window WatchDog Interrupt */ + RTC_IRQn = 2, /*!< RTC Interrupt through EXTI Lines 17, 19 and 20 */ + FLASH_IRQn = 3, /*!< FLASH global Interrupt */ + RCC_IRQn = 4, /*!< RCC Global Interrupts */ + EXTI0_1_IRQn = 5, /*!< EXTI Line 0 and 1 Interrupts */ + EXTI2_3_IRQn = 6, /*!< EXTI Line 2 and 3 Interrupts */ + EXTI4_15_IRQn = 7, /*!< EXTI Line 4 to 15 Interrupts */ + DMA1_Channel1_IRQn = 9, /*!< DMA1 Channel 1 Interrupt */ + DMA1_Channel2_3_IRQn = 10, /*!< DMA1 Channel 2 and Channel 3 Interrupts */ + DMA1_Channel4_5_IRQn = 11, /*!< DMA1 Channel 4 and Channel 5 Interrupts */ + ADC1_IRQn = 12, /*!< ADC1 interrupts (ADC interrupt combined with EXTI Lines 21 and 22 */ + TIM1_BRK_UP_TRG_COM_IRQn = 13, /*!< TIM1 Break, Update, Trigger and Commutation Interrupts */ + TIM1_CC_IRQn = 14, /*!< TIM1 Capture Compare Interrupt */ + TIM3_IRQn = 16, /*!< TIM3 global Interrupt */ + TIM6_IRQn = 17, /*!< TIM6 global Interrupts */ + TIM7_IRQn = 18, /*!< TIM7 global Interrupt */ + TIM14_IRQn = 19, /*!< TIM14 global Interrupt */ + TIM15_IRQn = 20, /*!< TIM15 global Interrupt */ + TIM16_IRQn = 21, /*!< TIM16 global Interrupt */ + TIM17_IRQn = 22, /*!< TIM17 global Interrupt */ + I2C1_IRQn = 23, /*!< I2C1 Event Interrupt & EXTI Line23 Interrupt (I2C1 wakeup) */ + I2C2_IRQn = 24, /*!< I2C2 Event Interrupt */ + SPI1_IRQn = 25, /*!< SPI1 global Interrupt */ + SPI2_IRQn = 26, /*!< SPI2 global Interrupt */ + USART1_IRQn = 27, /*!< USART1 global Interrupt */ + USART2_IRQn = 28, /*!< USART2 global Interrupt */ + USART3_4_IRQn = 29, /*!< USART3 and USART4 global Interrupts */ + USB_IRQn = 31 /*!< USB global Interrupts & EXTI Line18 Interrupt */ +#elif defined (STM32F070x6) + WWDG_IRQn = 0, /*!< Window WatchDog Interrupt */ + RTC_IRQn = 2, /*!< RTC Interrupt through EXTI Lines 17, 19 and 20 */ + FLASH_IRQn = 3, /*!< FLASH global Interrupt */ + RCC_IRQn = 4, /*!< RCC Global Interrupts */ + EXTI0_1_IRQn = 5, /*!< EXTI Line 0 and 1 Interrupts */ + EXTI2_3_IRQn = 6, /*!< EXTI Line 2 and 3 Interrupts */ + EXTI4_15_IRQn = 7, /*!< EXTI Line 4 to 15 Interrupts */ + DMA1_Channel1_IRQn = 9, /*!< DMA1 Channel 1 Interrupt */ + DMA1_Channel2_3_IRQn = 10, /*!< DMA1 Channel 2 and Channel 3 Interrupts */ + DMA1_Channel4_5_IRQn = 11, /*!< DMA1 Channel 4 and Channel 5 Interrupts */ + ADC1_IRQn = 12, /*!< ADC1 Interrupt */ + TIM1_BRK_UP_TRG_COM_IRQn = 13, /*!< TIM1 Break, Update, Trigger and Commutation Interrupts */ + TIM1_CC_IRQn = 14, /*!< TIM1 Capture Compare Interrupt */ + TIM3_IRQn = 16, /*!< TIM3 global Interrupt */ + TIM14_IRQn = 19, /*!< TIM14 global Interrupt */ + TIM16_IRQn = 21, /*!< TIM16 global Interrupt */ + TIM17_IRQn = 22, /*!< TIM17 global Interrupt */ + I2C1_IRQn = 23, /*!< I2C1 Event Interrupt & EXTI Line23 Interrupt (I2C1 wakeup) */ + SPI1_IRQn = 25, /*!< SPI1 global Interrupt */ + USART1_IRQn = 27, /*!< USART1 global Interrupt & EXTI Line25 Interrupt (USART1 wakeup) */ + USART2_IRQn = 28, /*!< USART2 global Interrupt */ + USB_IRQn = 31 /*!< USB global Interrupts & EXTI Line18 Interrupt */ +#elif defined (STM32F030xC) + WWDG_IRQn = 0, /*!< Window WatchDog Interrupt */ + RTC_IRQn = 2, /*!< RTC Interrupt through EXTI Lines 17, 19 and 20 */ + FLASH_IRQn = 3, /*!< FLASH global Interrupt */ + RCC_IRQn = 4, /*!< RCC Global Interrupts */ + EXTI0_1_IRQn = 5, /*!< EXTI Line 0 and 1 Interrupts */ + EXTI2_3_IRQn = 6, /*!< EXTI Line 2 and 3 Interrupts */ + EXTI4_15_IRQn = 7, /*!< EXTI Line 4 to 15 Interrupts */ + DMA1_Channel1_IRQn = 9, /*!< DMA1 Channel 1 Interrupt */ + DMA1_Channel2_3_IRQn = 10, /*!< DMA1 Channel 2 and Channel 3 Interrupts */ + DMA1_Channel4_5_IRQn = 11, /*!< DMA1 Channel 4 and Channel 5 Interrupts */ + ADC1_IRQn = 12, /*!< ADC Interrupts */ + TIM1_BRK_UP_TRG_COM_IRQn = 13, /*!< TIM1 Break, Update, Trigger and Commutation Interrupts */ + TIM1_CC_IRQn = 14, /*!< TIM1 Capture Compare Interrupt */ + TIM3_IRQn = 16, /*!< TIM3 global Interrupt */ + TIM6_IRQn = 17, /*!< TIM6 global Interrupts */ + TIM7_IRQn = 18, /*!< TIM7 global Interrupt */ + TIM14_IRQn = 19, /*!< TIM14 global Interrupt */ + TIM15_IRQn = 20, /*!< TIM15 global Interrupt */ + TIM16_IRQn = 21, /*!< TIM16 global Interrupt */ + TIM17_IRQn = 22, /*!< TIM17 global Interrupt */ + I2C1_IRQn = 23, /*!< I2C1 Event Interrupt & EXTI Line23 Interrupt (I2C1 wakeup) */ + I2C2_IRQn = 24, /*!< I2C2 Event Interrupt */ + SPI1_IRQn = 25, /*!< SPI1 global Interrupt */ + SPI2_IRQn = 26, /*!< SPI2 global Interrupt */ + USART1_IRQn = 27, /*!< USART1 global Interrupt & EXTI Line25 Interrupt (USART1 wakeup) */ + USART2_IRQn = 28, /*!< USART2 global Interrupt & EXTI Line26 Interrupt (USART2 wakeup) */ + USART3_6_IRQn = 29, /*!< USART3 to USART6 global Interrupts */ +#endif /* STM32F051 */ +}IRQn_Type; + +/** + * @} + */ + +#include "core_cm0.h" +#include "system_stm32f0xx.h" +#include + +/** @addtogroup Exported_types + * @{ + */ + +typedef enum {RESET = 0, SET = !RESET} FlagStatus, ITStatus; + +typedef enum {DISABLE = 0, ENABLE = !DISABLE} FunctionalState; +#define IS_FUNCTIONAL_STATE(STATE) (((STATE) == DISABLE) || ((STATE) == ENABLE)) + +typedef enum {ERROR = 0, SUCCESS = !ERROR} ErrorStatus; + +/** @addtogroup Peripheral_registers_structures + * @{ + */ + +/** + * @brief Analog to Digital Converter + */ + +typedef struct +{ + __IO uint32_t ISR; /*!< ADC Interrupt and Status register, Address offset:0x00 */ + __IO uint32_t IER; /*!< ADC Interrupt Enable register, Address offset:0x04 */ + __IO uint32_t CR; /*!< ADC Control register, Address offset:0x08 */ + __IO uint32_t CFGR1; /*!< ADC Configuration register 1, Address offset:0x0C */ + __IO uint32_t CFGR2; /*!< ADC Configuration register 2, Address offset:0x10 */ + __IO uint32_t SMPR; /*!< ADC Sampling time register, Address offset:0x14 */ + uint32_t RESERVED1; /*!< Reserved, 0x18 */ + uint32_t RESERVED2; /*!< Reserved, 0x1C */ + __IO uint32_t TR; /*!< ADC watchdog threshold register, Address offset:0x20 */ + uint32_t RESERVED3; /*!< Reserved, 0x24 */ + __IO uint32_t CHSELR; /*!< ADC channel selection register, Address offset:0x28 */ + uint32_t RESERVED4[5]; /*!< Reserved, 0x2C */ + __IO uint32_t DR; /*!< ADC data register, Address offset:0x40 */ +} ADC_TypeDef; + +typedef struct +{ + __IO uint32_t CCR; +} ADC_Common_TypeDef; + + +/** + * @brief Controller Area Network TxMailBox + */ +typedef struct +{ + __IO uint32_t TIR; /*!< CAN TX mailbox identifier register */ + __IO uint32_t TDTR; /*!< CAN mailbox data length control and time stamp register */ + __IO uint32_t TDLR; /*!< CAN mailbox data low register */ + __IO uint32_t TDHR; /*!< CAN mailbox data high register */ +} CAN_TxMailBox_TypeDef; + +/** + * @brief Controller Area Network FIFOMailBox + */ +typedef struct +{ + __IO uint32_t RIR; /*!< CAN receive FIFO mailbox identifier register */ + __IO uint32_t RDTR; /*!< CAN receive FIFO mailbox data length control and time stamp register */ + __IO uint32_t RDLR; /*!< CAN receive FIFO mailbox data low register */ + __IO uint32_t RDHR; /*!< CAN receive FIFO mailbox data high register */ +} CAN_FIFOMailBox_TypeDef; + +/** + * @brief Controller Area Network FilterRegister + */ +typedef struct +{ + __IO uint32_t FR1; /*!< CAN Filter bank register 1 */ + __IO uint32_t FR2; /*!< CAN Filter bank register 1 */ +} CAN_FilterRegister_TypeDef; + +/** + * @brief Controller Area Network + */ +typedef struct +{ + __IO uint32_t MCR; /*!< CAN master control register, Address offset: 0x00 */ + __IO uint32_t MSR; /*!< CAN master status register, Address offset: 0x04 */ + __IO uint32_t TSR; /*!< CAN transmit status register, Address offset: 0x08 */ + __IO uint32_t RF0R; /*!< CAN receive FIFO 0 register, Address offset: 0x0C */ + __IO uint32_t RF1R; /*!< CAN receive FIFO 1 register, Address offset: 0x10 */ + __IO uint32_t IER; /*!< CAN interrupt enable register, Address offset: 0x14 */ + __IO uint32_t ESR; /*!< CAN error status register, Address offset: 0x18 */ + __IO uint32_t BTR; /*!< CAN bit timing register, Address offset: 0x1C */ + uint32_t RESERVED0[88]; /*!< Reserved, 0x020 - 0x17F */ + CAN_TxMailBox_TypeDef sTxMailBox[3]; /*!< CAN Tx MailBox, Address offset: 0x180 - 0x1AC */ + CAN_FIFOMailBox_TypeDef sFIFOMailBox[2]; /*!< CAN FIFO MailBox, Address offset: 0x1B0 - 0x1CC */ + uint32_t RESERVED1[12]; /*!< Reserved, 0x1D0 - 0x1FF */ + __IO uint32_t FMR; /*!< CAN filter master register, Address offset: 0x200 */ + __IO uint32_t FM1R; /*!< CAN filter mode register, Address offset: 0x204 */ + uint32_t RESERVED2; /*!< Reserved, 0x208 */ + __IO uint32_t FS1R; /*!< CAN filter scale register, Address offset: 0x20C */ + uint32_t RESERVED3; /*!< Reserved, 0x210 */ + __IO uint32_t FFA1R; /*!< CAN filter FIFO assignment register, Address offset: 0x214 */ + uint32_t RESERVED4; /*!< Reserved, 0x218 */ + __IO uint32_t FA1R; /*!< CAN filter activation register, Address offset: 0x21C */ + uint32_t RESERVED5[8]; /*!< Reserved, 0x220-0x23F */ + CAN_FilterRegister_TypeDef sFilterRegister[28]; /*!< CAN Filter Register, Address offset: 0x240-0x31C */ +} CAN_TypeDef; + +/** + * @brief HDMI-CEC + */ + +typedef struct +{ + __IO uint32_t CR; /*!< CEC control register, Address offset:0x00 */ + __IO uint32_t CFGR; /*!< CEC configuration register, Address offset:0x04 */ + __IO uint32_t TXDR; /*!< CEC Tx data register , Address offset:0x08 */ + __IO uint32_t RXDR; /*!< CEC Rx Data Register, Address offset:0x0C */ + __IO uint32_t ISR; /*!< CEC Interrupt and Status Register, Address offset:0x10 */ + __IO uint32_t IER; /*!< CEC interrupt enable register, Address offset:0x14 */ +}CEC_TypeDef; + +/** + * @brief Comparator + */ + +typedef struct +{ + __IO uint32_t CSR; /*!< COMP comparator control and status register, Address offset: 0x1C */ +} COMP_TypeDef; + + +/** + * @brief CRC calculation unit + */ + +typedef struct +{ + __IO uint32_t DR; /*!< CRC Data register, Address offset: 0x00 */ + __IO uint8_t IDR; /*!< CRC Independent data register, Address offset: 0x04 */ + uint8_t RESERVED0; /*!< Reserved, 0x05 */ + uint16_t RESERVED1; /*!< Reserved, 0x06 */ + __IO uint32_t CR; /*!< CRC Control register, Address offset: 0x08 */ + uint32_t RESERVED2; /*!< Reserved, 0x0C */ + __IO uint32_t INIT; /*!< Initial CRC value register, Address offset: 0x10 */ + __IO uint32_t POL; /*!< CRC polynomial register, Address offset: 0x14 */ +} CRC_TypeDef; + +/** + * @brief Clock Recovery System + */ +typedef struct +{ +__IO uint32_t CR; /*!< CRS ccontrol register, Address offset: 0x00 */ +__IO uint32_t CFGR; /*!< CRS configuration register, Address offset: 0x04 */ +__IO uint32_t ISR; /*!< CRS interrupt and status register, Address offset: 0x08 */ +__IO uint32_t ICR; /*!< CRS interrupt flag clear register, Address offset: 0x0C */ +} CRS_TypeDef; + +/** + * @brief Digital to Analog Converter + */ + +typedef struct +{ + __IO uint32_t CR; /*!< DAC control register, Address offset: 0x00 */ + __IO uint32_t SWTRIGR; /*!< DAC software trigger register, Address offset: 0x04 */ + __IO uint32_t DHR12R1; /*!< DAC channel1 12-bit right-aligned data holding register, Address offset: 0x08 */ + __IO uint32_t DHR12L1; /*!< DAC channel1 12-bit left aligned data holding register, Address offset: 0x0C */ + __IO uint32_t DHR8R1; /*!< DAC channel1 8-bit right aligned data holding register, Address offset: 0x10 */ + __IO uint32_t DHR12R2; /*!< DAC channel2 12-bit right aligned data holding register, Address offset: 0x14 */ + __IO uint32_t DHR12L2; /*!< DAC channel2 12-bit left aligned data holding register, Address offset: 0x18 */ + __IO uint32_t DHR8R2; /*!< DAC channel2 8-bit right-aligned data holding register, Address offset: 0x1C */ + __IO uint32_t DHR12RD; /*!< Dual DAC 12-bit right-aligned data holding register, Address offset: 0x20 */ + __IO uint32_t DHR12LD; /*!< DUAL DAC 12-bit left aligned data holding register, Address offset: 0x24 */ + __IO uint32_t DHR8RD; /*!< DUAL DAC 8-bit right aligned data holding register, Address offset: 0x28 */ + __IO uint32_t DOR1; /*!< DAC channel1 data output register, Address offset: 0x2C */ + __IO uint32_t DOR2; /*!< DAC channel2 data output register, Address offset: 0x30 */ + __IO uint32_t SR; /*!< DAC status register, Address offset: 0x34 */ +} DAC_TypeDef; + +/** + * @brief Debug MCU + */ + +typedef struct +{ + __IO uint32_t IDCODE; /*!< MCU device ID code, Address offset: 0x00 */ + __IO uint32_t CR; /*!< Debug MCU configuration register, Address offset: 0x04 */ + __IO uint32_t APB1FZ; /*!< Debug MCU APB1 freeze register, Address offset: 0x08 */ + __IO uint32_t APB2FZ; /*!< Debug MCU APB2 freeze register, Address offset: 0x0C */ +}DBGMCU_TypeDef; + +/** + * @brief DMA Controller + */ + +typedef struct +{ + __IO uint32_t CCR; /*!< DMA channel x configuration register */ + __IO uint32_t CNDTR; /*!< DMA channel x number of data register */ + __IO uint32_t CPAR; /*!< DMA channel x peripheral address register */ + __IO uint32_t CMAR; /*!< DMA channel x memory address register */ +} DMA_Channel_TypeDef; + +typedef struct +{ + __IO uint32_t ISR; /*!< DMA interrupt status register, Address offset: 0x00 */ + __IO uint32_t IFCR; /*!< DMA interrupt flag clear register, Address offset: 0x04 */ + uint32_t RESERVED0[40];/*!< Reserved as declared by channel typedef 0x08 - 0xA4*/ + __IO uint32_t RMPCR; /*!< Remap control register, Address offset: 0xA8 */ +}DMA_TypeDef; + +/** + * @brief External Interrupt/Event Controller + */ + +typedef struct +{ + __IO uint32_t IMR; /*! exti[31] Interrupt */ +#define SYSCFG_ITLINE1_SR_VDDIO2 ((uint32_t)0x00000002) /*!< VDDIO2 -> exti[16] Interrupt */ +#define SYSCFG_ITLINE2_SR_RTC_WAKEUP ((uint32_t)0x00000001) /*!< RTC WAKEUP -> exti[20] Interrupt */ +#define SYSCFG_ITLINE2_SR_RTC_TSTAMP ((uint32_t)0x00000002) /*!< RTC Time Stamp -> exti[19] interrupt */ +#define SYSCFG_ITLINE2_SR_RTC_ALRA ((uint32_t)0x00000003) /*!< RTC Alarm -> exti[17] interrupt .... */ +#define SYSCFG_ITLINE3_SR_FLASH_ITF ((uint32_t)0x00000001) /*!< Flash ITF Interrupt */ +#define SYSCFG_ITLINE4_SR_CRS ((uint32_t)0x00000001) /*!< CRS interrupt */ +#define SYSCFG_ITLINE4_SR_CLK_CTRL ((uint32_t)0x00000002) /*!< CLK CTRL interrupt */ +#define SYSCFG_ITLINE5_SR_EXTI0 ((uint32_t)0x00000001) /*!< External Interrupt 0 */ +#define SYSCFG_ITLINE5_SR_EXTI1 ((uint32_t)0x00000002) /*!< External Interrupt 1 */ +#define SYSCFG_ITLINE6_SR_EXTI2 ((uint32_t)0x00000001) /*!< External Interrupt 2 */ +#define SYSCFG_ITLINE6_SR_EXTI3 ((uint32_t)0x00000002) /*!< External Interrupt 3 */ +#define SYSCFG_ITLINE7_SR_EXTI4 ((uint32_t)0x00000001) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE7_SR_EXTI5 ((uint32_t)0x00000002) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE7_SR_EXTI6 ((uint32_t)0x00000004) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE7_SR_EXTI7 ((uint32_t)0x00000008) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE7_SR_EXTI8 ((uint32_t)0x00000010) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE7_SR_EXTI9 ((uint32_t)0x00000020) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE7_SR_EXTI10 ((uint32_t)0x00000040) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE7_SR_EXTI11 ((uint32_t)0x00000080) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE7_SR_EXTI12 ((uint32_t)0x00000100) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE7_SR_EXTI13 ((uint32_t)0x00000200) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE7_SR_EXTI14 ((uint32_t)0x00000400) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE7_SR_EXTI15 ((uint32_t)0x00000800) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE8_SR_TSC_EOA ((uint32_t)0x00000001) /*!< Touch control EOA Interrupt */ +#define SYSCFG_ITLINE8_SR_TSC_MCE ((uint32_t)0x00000002) /*!< Touch control MCE Interrupt */ +#define SYSCFG_ITLINE9_SR_DMA1_CH1 ((uint32_t)0x00000001) /*!< DMA1 Channel 1 Interrupt */ +#define SYSCFG_ITLINE10_SR_DMA1_CH2 ((uint32_t)0x00000001) /*!< DMA1 Channel 2 Interrupt */ +#define SYSCFG_ITLINE10_SR_DMA1_CH3 ((uint32_t)0x00000002) /*!< DMA2 Channel 3 Interrupt */ +#define SYSCFG_ITLINE10_SR_DMA2_CH1 ((uint32_t)0x00000004) /*!< DMA2 Channel 1 Interrupt */ +#define SYSCFG_ITLINE10_SR_DMA2_CH2 ((uint32_t)0x00000008) /*!< DMA2 Channel 2 Interrupt */ +#define SYSCFG_ITLINE11_SR_DMA1_CH4 ((uint32_t)0x00000001) /*!< DMA1 Channel 4 Interrupt */ +#define SYSCFG_ITLINE11_SR_DMA1_CH5 ((uint32_t)0x00000002) /*!< DMA1 Channel 5 Interrupt */ +#define SYSCFG_ITLINE11_SR_DMA1_CH6 ((uint32_t)0x00000004) /*!< DMA1 Channel 6 Interrupt */ +#define SYSCFG_ITLINE11_SR_DMA1_CH7 ((uint32_t)0x00000008) /*!< DMA1 Channel 7 Interrupt */ +#define SYSCFG_ITLINE11_SR_DMA2_CH3 ((uint32_t)0x00000010) /*!< DMA2 Channel 3 Interrupt */ +#define SYSCFG_ITLINE11_SR_DMA2_CH4 ((uint32_t)0x00000020) /*!< DMA2 Channel 4 Interrupt */ +#define SYSCFG_ITLINE11_SR_DMA2_CH5 ((uint32_t)0x00000040) /*!< DMA2 Channel 5 Interrupt */ +#define SYSCFG_ITLINE12_SR_ADC ((uint32_t)0x00000001) /*!< ADC Interrupt */ +#define SYSCFG_ITLINE12_SR_COMP1 ((uint32_t)0x00000002) /*!< COMP1 Interrupt -> exti[21] */ +#define SYSCFG_ITLINE12_SR_COMP2 ((uint32_t)0x00000004) /*!< COMP2 Interrupt -> exti[22] */ +#define SYSCFG_ITLINE13_SR_TIM1_BRK ((uint32_t)0x00000001) /*!< TIM1 BRK Interrupt */ +#define SYSCFG_ITLINE13_SR_TIM1_UPD ((uint32_t)0x00000002) /*!< TIM1 UPD Interrupt */ +#define SYSCFG_ITLINE13_SR_TIM1_TRG ((uint32_t)0x00000004) /*!< TIM1 TRG Interrupt */ +#define SYSCFG_ITLINE13_SR_TIM1_CCU ((uint32_t)0x00000008) /*!< TIM1 CCU Interrupt */ +#define SYSCFG_ITLINE14_SR_TIM1_CC ((uint32_t)0x00000001) /*!< TIM1 CC Interrupt */ +#define SYSCFG_ITLINE15_SR_TIM2_GLB ((uint32_t)0x00000001) /*!< TIM2 GLB Interrupt */ +#define SYSCFG_ITLINE16_SR_TIM3_GLB ((uint32_t)0x00000001) /*!< TIM3 GLB Interrupt */ +#define SYSCFG_ITLINE17_SR_DAC ((uint32_t)0x00000001) /*!< DAC Interrupt */ +#define SYSCFG_ITLINE17_SR_TIM6_GLB ((uint32_t)0x00000002) /*!< TIM6 GLB Interrupt */ +#define SYSCFG_ITLINE18_SR_TIM7_GLB ((uint32_t)0x00000001) /*!< TIM7 GLB Interrupt */ +#define SYSCFG_ITLINE19_SR_TIM14_GLB ((uint32_t)0x00000001) /*!< TIM14 GLB Interrupt */ +#define SYSCFG_ITLINE20_SR_TIM15_GLB ((uint32_t)0x00000001) /*!< TIM15 GLB Interrupt */ +#define SYSCFG_ITLINE21_SR_TIM16_GLB ((uint32_t)0x00000001) /*!< TIM16 GLB Interrupt */ +#define SYSCFG_ITLINE22_SR_TIM17_GLB ((uint32_t)0x00000001) /*!< TIM17 GLB Interrupt */ +#define SYSCFG_ITLINE23_SR_I2C1_GLB ((uint32_t)0x00000001) /*!< I2C1 GLB Interrupt -> exti[23] */ +#define SYSCFG_ITLINE24_SR_I2C2_GLB ((uint32_t)0x00000001) /*!< I2C2 GLB Interrupt */ +#define SYSCFG_ITLINE25_SR_SPI1 ((uint32_t)0x00000001) /*!< SPI1 Interrupt */ +#define SYSCFG_ITLINE26_SR_SPI2 ((uint32_t)0x00000001) /*!< SPI2 Interrupt */ +#define SYSCFG_ITLINE27_SR_USART1_GLB ((uint32_t)0x00000001) /*!< USART1 GLB Interrupt -> exti[25] */ +#define SYSCFG_ITLINE28_SR_USART2_GLB ((uint32_t)0x00000001) /*!< USART2 GLB Interrupt -> exti[26] */ +#define SYSCFG_ITLINE29_SR_USART3_GLB ((uint32_t)0x00000001) /*!< USART3 GLB Interrupt -> exti[28] */ +#define SYSCFG_ITLINE29_SR_USART4_GLB ((uint32_t)0x00000002) /*!< USART4 GLB Interrupt */ +#define SYSCFG_ITLINE29_SR_USART5_GLB ((uint32_t)0x00000004) /*!< USART5 GLB Interrupt */ +#define SYSCFG_ITLINE29_SR_USART6_GLB ((uint32_t)0x00000008) /*!< USART6 GLB Interrupt */ +#define SYSCFG_ITLINE29_SR_USART7_GLB ((uint32_t)0x00000010) /*!< USART7 GLB Interrupt */ +#define SYSCFG_ITLINE29_SR_USART8_GLB ((uint32_t)0x00000020) /*!< USART8 GLB Interrupt */ +#define SYSCFG_ITLINE30_SR_CAN ((uint32_t)0x00000001) /*!< CAN Interrupt */ +#define SYSCFG_ITLINE30_SR_CEC ((uint32_t)0x00000002) /*!< CEC Interrupt */ + +/******************************************************************************/ +/* */ +/* Timers (TIM) */ +/* */ +/******************************************************************************/ +/******************* Bit definition for TIM_CR1 register ********************/ +#define TIM_CR1_CEN ((uint16_t)0x0001) /*!
    © COPYRIGHT 2014 STMicroelectronics
    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_CONF_H +#define __STM32F0XX_CONF_H + +/* Includes ------------------------------------------------------------------*/ +/* Comment the line below to disable peripheral header file inclusion */ +#include "stm32f0xx_adc.h" +#include "stm32f0xx_can.h" +#include "stm32f0xx_cec.h" +#include "stm32f0xx_comp.h" +#include "stm32f0xx_crc.h" +#include "stm32f0xx_crs.h" +#include "stm32f0xx_dac.h" +#include "stm32f0xx_dbgmcu.h" +#include "stm32f0xx_dma.h" +#include "stm32f0xx_exti.h" +#include "stm32f0xx_flash.h" +#include "stm32f0xx_gpio.h" +#include "stm32f0xx_i2c.h" +#include "stm32f0xx_iwdg.h" +#include "stm32f0xx_pwr.h" +#include "stm32f0xx_rcc.h" +#include "stm32f0xx_rtc.h" +#include "stm32f0xx_spi.h" +#include "stm32f0xx_syscfg.h" +#include "stm32f0xx_tim.h" +#include "stm32f0xx_usart.h" +#include "stm32f0xx_wwdg.h" +#include "stm32f0xx_misc.h" /* High level functions for NVIC and SysTick (add-on to CMSIS functions) */ + +/* Exported types ------------------------------------------------------------*/ +/* Exported constants --------------------------------------------------------*/ +/* Uncomment the line below to expanse the "assert_param" macro in the + Standard Peripheral Library drivers code */ +/* #define USE_FULL_ASSERT 1 */ + +/* Exported macro ------------------------------------------------------------*/ +#ifdef USE_FULL_ASSERT + +/** + * @brief The assert_param macro is used for function's parameters check. + * @param expr: If expr is false, it calls assert_failed function which reports + * the name of the source file and the source line number of the call + * that failed. If expr is true, it returns no value. + * @retval None + */ + #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__)) +/* Exported functions ------------------------------------------------------- */ + void assert_failed(uint8_t* file, uint32_t line); +#else + #define assert_param(expr) ((void)0) +#endif /* USE_FULL_ASSERT */ + +#endif /* __STM32F0XX_CONF_H */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/system_stm32f0xx.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/system_stm32f0xx.c new file mode 100644 index 00000000..a9aa42f7 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/system_stm32f0xx.c @@ -0,0 +1,331 @@ +/** + ****************************************************************************** + * @file system_stm32f0xx.c + * @author MCD Application Team + * @version V1.0.1 + * @date 17-August-2016 + * @brief CMSIS Cortex-M0 Device Peripheral Access Layer System Source File. + * This file contains the system clock configuration for STM32F0xx devices, + * and is generated by the clock configuration tool + * STM32f0xx_Clock_Configuration_V1.0.1.xls + * + * 1. This file provides two functions and one global variable to be called from + * user application: + * - SystemInit(): Setups the system clock (System clock source, PLL Multiplier + * and Divider factors, AHB/APBx prescalers and Flash settings), + * depending on the configuration made in the clock xls tool. + * This function is called at startup just after reset and + * before branch to main program. This call is made inside + * the "startup_stm32f0xx.s" file. + * + * - SystemCoreClock variable: Contains the core clock (HCLK), it can be used + * by the user application to setup the SysTick + * timer or configure other parameters. + * + * - SystemCoreClockUpdate(): Updates the variable SystemCoreClock and must + * be called whenever the core clock is changed + * during program execution. + * + * 2. After each device reset the HSI (8 MHz Range) is used as system clock source. + * Then SystemInit() function is called, in "startup_stm32f0xx.s" file, to + * configure the system clock before to branch to main program. + * + * 3. If the system clock source selected by user fails to startup, the SystemInit() + * function will do nothing and HSI still used as system clock source. User can + * add some code to deal with this issue inside the SetSysClock() function. + * + * 4. The default value of HSE crystal is set to 8MHz, refer to "HSE_VALUE" define + * in "stm32f0xx.h" file. When HSE is used as system clock source, directly or + * through PLL, and you are using different crystal you have to adapt the HSE + * value to your own configuration. + * + * 5. This file configures the system clock as follows: + *============================================================================= + *============================================================================= + * System Clock source | PLL(HSI) + *----------------------------------------------------------------------------- + * SYSCLK(Hz) | 48000000 + *----------------------------------------------------------------------------- + * HCLK(Hz) | 48000000 + *----------------------------------------------------------------------------- + * AHB Prescaler | 1 + *----------------------------------------------------------------------------- + * APB Prescaler | 1 + *----------------------------------------------------------------------------- + * HSE Frequency(Hz) | NA + *---------------------------------------------------------------------------- + * PLLMUL | 12 + *----------------------------------------------------------------------------- + * PREDIV | 2 + *----------------------------------------------------------------------------- + * Flash Latency(WS) | 1 + *----------------------------------------------------------------------------- + * Prefetch Buffer | ON + *----------------------------------------------------------------------------- + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2012 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/** @addtogroup CMSIS + * @{ + */ + +/** @addtogroup stm32f0xx_system + * @{ + */ + +/** @addtogroup STM32F0xx_System_Private_Includes + * @{ + */ + +#include "stm32f0xx.h" + +/** + * @} + */ + +/** @addtogroup STM32F0xx_System_Private_TypesDefinitions + * @{ + */ + +/** + * @} + */ + +/** @addtogroup STM32F0xx_System_Private_Defines + * @{ + */ +/** + * @} + */ + +/** @addtogroup STM32F0xx_System_Private_Macros + * @{ + */ + +/** + * @} + */ + +/** @addtogroup STM32F0xx_System_Private_Variables + * @{ + */ +uint32_t SystemCoreClock = 48000000; +__I uint8_t AHBPrescTable[16] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 6, 7, 8, 9}; + +/** + * @} + */ + +/** @addtogroup STM32F0xx_System_Private_FunctionPrototypes + * @{ + */ + +static void SetSysClock(void); + +/** + * @} + */ + +/** @addtogroup STM32F0xx_System_Private_Functions + * @{ + */ + +/** + * @brief Setup the microcontroller system. + * Initialize the Embedded Flash Interface, the PLL and update the + * SystemCoreClock variable. + * @param None + * @retval None + */ +void SystemInit (void) +{ + /* Set HSION bit */ + RCC->CR |= (uint32_t)0x00000001; + + /* Reset SW[1:0], HPRE[3:0], PPRE[2:0], ADCPRE and MCOSEL[2:0] bits */ + RCC->CFGR &= (uint32_t)0xF8FFB80C; + + /* Reset HSEON, CSSON and PLLON bits */ + RCC->CR &= (uint32_t)0xFEF6FFFF; + + /* Reset HSEBYP bit */ + RCC->CR &= (uint32_t)0xFFFBFFFF; + + /* Reset PLLSRC, PLLXTPRE and PLLMUL[3:0] bits */ + RCC->CFGR &= (uint32_t)0xFFC0FFFF; + + /* Reset PREDIV1[3:0] bits */ + RCC->CFGR2 &= (uint32_t)0xFFFFFFF0; + + /* Reset USARTSW[1:0], I2CSW, CECSW and ADCSW bits */ + RCC->CFGR3 &= (uint32_t)0xFFFFFEAC; + + /* Reset HSI14 bit */ + RCC->CR2 &= (uint32_t)0xFFFFFFFE; + + /* Disable all interrupts */ + RCC->CIR = 0x00000000; + + /* Configure the System clock frequency, AHB/APBx prescalers and Flash settings */ + SetSysClock(); +} + +/** + * @brief Update SystemCoreClock according to Clock Register Values + * The SystemCoreClock variable contains the core clock (HCLK), it can + * be used by the user application to setup the SysTick timer or configure + * other parameters. + * + * @note Each time the core clock (HCLK) changes, this function must be called + * to update SystemCoreClock variable value. Otherwise, any configuration + * based on this variable will be incorrect. + * + * @note - The system frequency computed by this function is not the real + * frequency in the chip. It is calculated based on the predefined + * constant and the selected clock source: + * + * - If SYSCLK source is HSI, SystemCoreClock will contain the HSI_VALUE(*) + * + * - If SYSCLK source is HSE, SystemCoreClock will contain the HSE_VALUE(**) + * + * - If SYSCLK source is PLL, SystemCoreClock will contain the HSE_VALUE(**) + * or HSI_VALUE(*) multiplied/divided by the PLL factors. + * + * (*) HSI_VALUE is a constant defined in stm32f0xx.h file (default value + * 8 MHz) but the real value may vary depending on the variations + * in voltage and temperature. + * + * (**) HSE_VALUE is a constant defined in stm32f0xx.h file (default value + * 8 MHz), user has to ensure that HSE_VALUE is same as the real + * frequency of the crystal used. Otherwise, this function may + * have wrong result. + * + * - The result of this function could be not correct when using fractional + * value for HSE crystal. + * @param None + * @retval None + */ +void SystemCoreClockUpdate (void) +{ + uint32_t tmp = 0, pllmull = 0, pllsource = 0, prediv1factor = 0; + + /* Get SYSCLK source -------------------------------------------------------*/ + tmp = RCC->CFGR & RCC_CFGR_SWS; + + switch (tmp) + { + case 0x00: /* HSI used as system clock */ + SystemCoreClock = HSI_VALUE; + break; + case 0x04: /* HSE used as system clock */ + SystemCoreClock = HSE_VALUE; + break; + case 0x08: /* PLL used as system clock */ + /* Get PLL clock source and multiplication factor ----------------------*/ + pllmull = RCC->CFGR & RCC_CFGR_PLLMULL; + pllsource = RCC->CFGR & RCC_CFGR_PLLSRC; + pllmull = ( pllmull >> 18) + 2; + + if (pllsource == 0x00) + { + /* HSI oscillator clock divided by 2 selected as PLL clock entry */ + SystemCoreClock = (HSI_VALUE >> 1) * pllmull; + } + else + { + prediv1factor = (RCC->CFGR2 & RCC_CFGR2_PREDIV1) + 1; + /* HSE oscillator clock selected as PREDIV1 clock entry */ + SystemCoreClock = (HSE_VALUE / prediv1factor) * pllmull; + } + break; + default: /* HSI used as system clock */ + SystemCoreClock = HSI_VALUE; + break; + } + /* Compute HCLK clock frequency ----------------*/ + /* Get HCLK prescaler */ + tmp = AHBPrescTable[((RCC->CFGR & RCC_CFGR_HPRE) >> 4)]; + /* HCLK clock frequency */ + SystemCoreClock >>= tmp; +} + +/** + * @brief Configures the System clock frequency, AHB/APBx prescalers and Flash + * settings. + * @note This function should be called only once the RCC clock configuration + * is reset to the default reset state (done in SystemInit() function). + * @param None + * @retval None + */ +static void SetSysClock(void) +{ +/******************************************************************************/ +/* PLL (clocked by HSI) used as System clock source */ +/******************************************************************************/ + + /* At this stage the HSI is already enabled and used as System clock source */ + + /* SYSCLK, HCLK, PCLK configuration ----------------------------------------*/ + + /* Enable Prefetch Buffer and set Flash Latency */ + FLASH->ACR = FLASH_ACR_PRFTBE | FLASH_ACR_LATENCY; + + /* HCLK = SYSCLK / 1 */ + RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1; + + /* PCLK = HCLK / 1 */ + RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE_DIV1; + + /* PLL configuration */ + RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLMULL)); + RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSI_Div2 | RCC_CFGR_PLLXTPRE_PREDIV1 | RCC_CFGR_PLLMULL12); + + /* Enable PLL */ + RCC->CR |= RCC_CR_PLLON; + + /* Wait till PLL is ready */ + while((RCC->CR & RCC_CR_PLLRDY) == 0) + { + } + + /* Select PLL as system clock source */ + RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW)); + RCC->CFGR |= (uint32_t)RCC_CFGR_SW_PLL; + + /* Wait till PLL is used as system clock source */ + while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)RCC_CFGR_SWS_PLL) + { + } +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ + diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/system_stm32f0xx.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/system_stm32f0xx.h new file mode 100644 index 00000000..619055de --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/lib/system_stm32f0xx.h @@ -0,0 +1,104 @@ +/** + ****************************************************************************** + * @file system_stm32f0xx.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief CMSIS Cortex-M0 Device Peripheral Access Layer System Header File. + ****************************************************************************** + * @attention + * + *

    © COPYRIGHT 2014 STMicroelectronics

    + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/** @addtogroup CMSIS + * @{ + */ + +/** @addtogroup stm32f0xx_system + * @{ + */ + +/** + * @brief Define to prevent recursive inclusion + */ +#ifndef __SYSTEM_STM32F0XX_H +#define __SYSTEM_STM32F0XX_H + +#ifdef __cplusplus + extern "C" { +#endif + +/** @addtogroup STM32F0xx_System_Includes + * @{ + */ + +/** + * @} + */ + + +/** @addtogroup STM32F0xx_System_Exported_types + * @{ + */ + +extern uint32_t SystemCoreClock; /*!< System Clock Frequency (Core Clock) */ + +/** + * @} + */ + +/** @addtogroup STM32F0xx_System_Exported_Constants + * @{ + */ + +/** + * @} + */ + +/** @addtogroup STM32F0xx_System_Exported_Macros + * @{ + */ + +/** + * @} + */ + +/** @addtogroup STM32F0xx_System_Exported_Functions + * @{ + */ + +extern void SystemInit(void); +extern void SystemCoreClockUpdate(void); +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif /*__SYSTEM_STM32F0XX_H */ + +/** + * @} + */ + +/** + * @} + */ +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/main.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/main.c new file mode 100644 index 00000000..a94a51d8 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Boot/main.c @@ -0,0 +1,130 @@ +/************************************************************************************//** +* \file Demo\ARMCM0_STM32F0_Nucleo_F091RC_GCC\Boot\main.c +* \brief Bootloader application source file. +* \ingroup Boot_ARMCM0_STM32F0_Nucleo_F091RC_GCC +* \internal +*---------------------------------------------------------------------------------------- +* C O P Y R I G H T +*---------------------------------------------------------------------------------------- +* Copyright (c) 2016 by Feaser http://www.feaser.com All rights reserved +* +*---------------------------------------------------------------------------------------- +* L I C E N S E +*---------------------------------------------------------------------------------------- +* This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +* modify it under the terms of the GNU General Public License as published by the Free +* Software Foundation, either version 3 of the License, or (at your option) any later +* version. +* +* OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +* PURPOSE. See the GNU General Public License for more details. +* +* You have received a copy of the GNU General Public License along with OpenBLT. It +* should be located in ".\Doc\license.html". If not, contact Feaser to obtain a copy. +* +* \endinternal +****************************************************************************************/ + +/**************************************************************************************** +* Include files +****************************************************************************************/ +#include "boot.h" /* bootloader generic header */ +#include "stm32f0xx.h" /* STM32 registers and drivers */ + + +/**************************************************************************************** +* Function prototypes +****************************************************************************************/ +static void Init(void); + + +/************************************************************************************//** +** \brief This is the entry point for the bootloader application and is called +** by the reset interrupt vector after the C-startup routines executed. +** \return Program return code. +** +****************************************************************************************/ +int main(void) +{ + /* initialize the microcontroller */ + Init(); + /* initialize the bootloader */ + BootInit(); + + /* start the infinite program loop */ + while (1) + { + /* run the bootloader task */ + BootTask(); + } + + /* program should never get here */ + return 0; +} /*** end of main ***/ + + +/************************************************************************************//** +** \brief Initializes the microcontroller. +** \return none. +** +****************************************************************************************/ +static void Init(void) +{ + GPIO_InitTypeDef GPIO_InitStructure; + + /* enable the GPIO_LED Clock */ + RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE); + /* configure the GPIO_LED pin */ + GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; + GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; + GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; + GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; + GPIO_Init(GPIOA, &GPIO_InitStructure); + GPIO_ResetBits(GPIOA, GPIO_Pin_5); + + /* configure the pushbutton pin as input for backdoor entry */ + RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC, ENABLE); + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN; + GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; + GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13; + GPIO_Init(GPIOC, &GPIO_InitStructure); + +#if (BOOT_COM_UART_ENABLE > 0) + /* enable the USART2 clock */ + RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE); + /* enable the USART2 Tx/Rx and pushbutton GPIO clock */ + RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE); + /* configure alternate function for the USART2 Tx/Rx pins */ + GPIO_PinAFConfig(GPIOA, GPIO_PinSource2, GPIO_AF_1); + GPIO_PinAFConfig(GPIOA, GPIO_PinSource3, GPIO_AF_1); + /* Configure USART2 pins: Rx (PA2) and Tx (PA3) */ + GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_3; + GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; + GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; + GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; + GPIO_Init(GPIOA, &GPIO_InitStructure); +#endif + +#if (BOOT_COM_CAN_ENABLE > 0) + /* enable CAN1 clock */ + RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN, ENABLE); + /* enable clocks for CAN1 transmitter and receiver pins */ + RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE); + /* select alternate function for the CAN1 pins */ + GPIO_PinAFConfig(GPIOB, GPIO_PinSource8, GPIO_AF_4); + GPIO_PinAFConfig(GPIOB, GPIO_PinSource9, GPIO_AF_4); + /* configure CAN1 RX and TX pins */ + GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; + GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; + GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; + GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; + GPIO_Init(GPIOB, &GPIO_InitStructure); +#endif +} /*** end of Init ***/ + + +/*********************************** end of main.c *************************************/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/bin/demoprog_stm32f091.elf b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/bin/demoprog_stm32f091.elf new file mode 100644 index 0000000000000000000000000000000000000000..df5e1ae9876d7c58cbf4d4ebfd984a9b81fc6a63 GIT binary patch literal 489656 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૧>~XiU^uta*q`TLE<)Z2UU4A6i~MS5 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%0Afqx1brR9DoZF_Qkh9wudqPt0?}lzHIN$;H7*H^ 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 DRCSW! literal 0 HcmV?d00001 diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/bin/demoprog_stm32f091.map b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/bin/demoprog_stm32f091.map new file mode 100644 index 00000000..ec351eb6 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/bin/demoprog_stm32f091.map @@ -0,0 +1,3957 @@ +Archive member included to satisfy reference by file (symbol) + +c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_udivsi3.o) + ..\obj\boot.o (__aeabi_uidiv) +c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_dvmd_tls.o) + c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_udivsi3.o) (__aeabi_idiv0) +c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-exit.o) + c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m/crt0.o (exit) +c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-impure.o) + c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-exit.o) (_global_impure_ptr) +c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-init.o) + c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m/crt0.o (__libc_init_array) +c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-memcpy-stub.o) + ..\obj\boot.o (memcpy) +c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-memset.o) + c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m/crt0.o (memset) +c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libnosys_s.a(_exit.o) + c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-exit.o) (_exit) + +Discarded input sections + + .text 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crti.o + .data 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crti.o + .bss 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crti.o + .data 0x00000000 0x4 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o + .data 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m/crt0.o + .bss 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m/crt0.o + .ARM.extab 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m/crt0.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\boot.o + .text 0x00000000 0x0 ..\obj\boot.o + .data 0x00000000 0x0 ..\obj\boot.o + .bss 0x00000000 0x0 ..\obj\boot.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .group 0x00000000 0x8 ..\obj\led.o + .text 0x00000000 0x0 ..\obj\led.o + .data 0x00000000 0x0 ..\obj\led.o + .bss 0x00000000 0x0 ..\obj\led.o + .debug_macro 0x00000000 0x832 ..\obj\led.o + .debug_macro 0x00000000 0x93 ..\obj\led.o + .debug_macro 0x00000000 0x81 ..\obj\led.o + .debug_macro 0x00000000 0x3a ..\obj\led.o + .debug_macro 0x00000000 0x22 ..\obj\led.o + .debug_macro 0x00000000 0x87 ..\obj\led.o + .debug_macro 0x00000000 0x44 ..\obj\led.o + .debug_macro 0x00000000 0xfd ..\obj\led.o + .debug_macro 0x00000000 0x5e ..\obj\led.o + .debug_macro 0x00000000 0x1df ..\obj\led.o + .debug_macro 0x00000000 0x1f ..\obj\led.o + .debug_macro 0x00000000 0x242 ..\obj\led.o + .debug_macro 0x00000000 0x632a ..\obj\led.o + .debug_macro 0x00000000 0x2eb ..\obj\led.o + .debug_macro 0x00000000 0x3cf ..\obj\led.o + .debug_macro 0x00000000 0x191 ..\obj\led.o + .debug_macro 0x00000000 0xef ..\obj\led.o + .debug_macro 0x00000000 0x46 ..\obj\led.o + .debug_macro 0x00000000 0xd9 ..\obj\led.o + .debug_macro 0x00000000 0x184 ..\obj\led.o + .debug_macro 0x00000000 0x7c ..\obj\led.o + .debug_macro 0x00000000 0x85b ..\obj\led.o + .debug_macro 0x00000000 0xd5 ..\obj\led.o + .debug_macro 0x00000000 0x2b7 ..\obj\led.o + .debug_macro 0x00000000 0x185 ..\obj\led.o + .debug_macro 0x00000000 0x2a0 ..\obj\led.o + .debug_macro 0x00000000 0x70 ..\obj\led.o + .debug_macro 0x00000000 0xdf ..\obj\led.o + .debug_macro 0x00000000 0x561 ..\obj\led.o + .debug_macro 0x00000000 0x4c5 ..\obj\led.o + .debug_macro 0x00000000 0x396 ..\obj\led.o + .debug_macro 0x00000000 0x471 ..\obj\led.o + .debug_macro 0x00000000 0x750 ..\obj\led.o + .debug_macro 0x00000000 0x356 ..\obj\led.o + .debug_macro 0x00000000 0x34 ..\obj\led.o + .debug_macro 0x00000000 0x3a ..\obj\led.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_adc.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_adc.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_DeInit + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_Init + 0x00000000 0x2c ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_StructInit + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_Cmd 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_ClockModeConfig + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_JitterCmd + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_AutoPowerOffCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_WaitModeCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_AnalogWatchdogCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_AnalogWatchdogThresholdsConfig + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_AnalogWatchdogSingleChannelConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_AnalogWatchdogSingleChannelCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_TempSensorCmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_VrefintCmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_VbatCmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_ChannelConfig + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_ContinuousModeCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_DiscModeCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_OverrunModeCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_GetCalibrationFactor + 0x00000000 0x30 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_StopOfConversion + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_StartOfConversion + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_GetConversionValue + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_DMACmd + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_DMARequestModeConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_ITConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_GetFlagStatus + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_ClearFlag + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_GetITStatus + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_adc.o + .text.ADC_ClearITPendingBit + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_info 0x00000000 0x902 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_abbrev 0x00000000 0x1b0 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_loc 0x00000000 0x3a7 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_aranges + 0x00000000 0x108 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_ranges 0x00000000 0xf8 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x19f ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x3c9 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_line 0x00000000 0x6bb ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_str 0x00000000 0x4a552 ..\obj\lib\spl\src\stm32f0xx_adc.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_adc.o + .debug_frame 0x00000000 0x200 ..\obj\lib\spl\src\stm32f0xx_adc.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_adc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_can.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_can.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CheckITStatus + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_SlaveStartBank + 0x00000000 0x30 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_DBGFreeze + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_TTComModeCmd + 0x00000000 0x58 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_Transmit + 0x00000000 0xd0 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_TransmitStatus + 0x00000000 0x68 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_CancelTransmit + 0x00000000 0x30 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_FIFORelease + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_OperatingModeRequest + 0x00000000 0xa0 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_Sleep + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_WakeUp + 0x00000000 0x2c ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_GetLastErrorCode + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_GetReceiveErrorCounter + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_GetLSBTransmitErrorCounter + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_ITConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_GetFlagStatus + 0x00000000 0x64 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_ClearFlag + 0x00000000 0x30 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_GetITStatus + 0x00000000 0x104 ..\obj\lib\spl\src\stm32f0xx_can.o + .text.CAN_ClearITPendingBit + 0x00000000 0xb0 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x00000000 0x3c9 ..\obj\lib\spl\src\stm32f0xx_can.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_cec.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_cec.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_DeInit + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_Init + 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_StructInit + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_Cmd 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_ListenModeCmd + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_OwnAddressConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_OwnAddressClear + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_SendData + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_ReceiveData + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_StartOfMessage + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_EndOfMessage + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_ITConfig + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_GetFlagStatus + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_ClearFlag + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_GetITStatus + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_cec.o + .text.CEC_ClearITPendingBit + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_info 0x00000000 0x47d ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_abbrev 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_loc 0x00000000 0x1a8 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_aranges + 0x00000000 0x98 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_ranges 0x00000000 0x88 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x19f ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_macro 0x00000000 0x18b ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_line 0x00000000 0x57f ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_str 0x00000000 0x4a347 ..\obj\lib\spl\src\stm32f0xx_cec.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_cec.o + .debug_frame 0x00000000 0x120 ..\obj\lib\spl\src\stm32f0xx_cec.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_cec.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_comp.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_comp.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_comp.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_comp.o + .text.COMP_DeInit + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_comp.o + .text.COMP_Init + 0x00000000 0x30 ..\obj\lib\spl\src\stm32f0xx_comp.o + .text.COMP_StructInit + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_comp.o + .text.COMP_Cmd + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_comp.o + .text.COMP_SwitchCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_comp.o + .text.COMP_GetOutputLevel + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_comp.o + .text.COMP_WindowCmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_comp.o + .text.COMP_LockConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_info 0x00000000 0x27a ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_abbrev 0x00000000 0x181 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_loc 0x00000000 0xd3 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_aranges + 0x00000000 0x58 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_ranges 0x00000000 0x48 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x199 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_macro 0x00000000 0xe9 ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_line 0x00000000 0x4df ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_str 0x00000000 0x4a1e5 ..\obj\lib\spl\src\stm32f0xx_comp.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_comp.o + .debug_frame 0x00000000 0x9c ..\obj\lib\spl\src\stm32f0xx_comp.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_comp.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_crc.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_crc.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_DeInit + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_ResetDR + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_PolynomialSizeSelect + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_ReverseInputDataSelect + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_ReverseOutputDataCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_SetInitRegister + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_SetPolynomial + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_CalcCRC + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_CalcCRC16bits + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_CalcCRC8bits + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_CalcBlockCRC + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_GetCRC + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_SetIDRegister + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_crc.o + .text.CRC_GetIDRegister + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_info 0x00000000 0x377 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_abbrev 0x00000000 0x192 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_loc 0x00000000 0x133 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_aranges + 0x00000000 0x88 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_ranges 0x00000000 0x78 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x193 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_macro 0x00000000 0x40 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_line 0x00000000 0x555 ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_str 0x00000000 0x4a26e ..\obj\lib\spl\src\stm32f0xx_crc.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_crc.o + .debug_frame 0x00000000 0xf8 ..\obj\lib\spl\src\stm32f0xx_crc.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_crc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_crs.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_crs.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_DeInit + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_AdjustHSI48CalibrationValue + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_FrequencyErrorCounterCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_AutomaticCalibrationCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_SoftwareSynchronizationGenerate + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_FrequencyErrorCounterReload + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_FrequencyErrorLimitConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_SynchronizationPrescalerConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_SynchronizationSourceConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_SynchronizationPolarityConfig + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_GetReloadValue + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_GetHSI48CalibrationValue + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_GetFrequencyErrorValue + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_GetFrequencyErrorDirection + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_ITConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_GetFlagStatus + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_ClearFlag + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_GetITStatus + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_crs.o + .text.CRS_ClearITPendingBit + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_info 0x00000000 0x401 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_abbrev 0x00000000 0x18d ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_loc 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_aranges + 0x00000000 0xb0 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_ranges 0x00000000 0xa0 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x199 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_macro 0x00000000 0xd3 ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_line 0x00000000 0x59f ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_str 0x00000000 0x4a37f ..\obj\lib\spl\src\stm32f0xx_crs.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_crs.o + .debug_frame 0x00000000 0x148 ..\obj\lib\spl\src\stm32f0xx_crs.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_crs.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_dac.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_dac.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_DeInit + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_Init + 0x00000000 0x2c ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_StructInit + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_Cmd 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_SoftwareTriggerCmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_DualSoftwareTriggerCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_WaveGenerationCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_SetChannel1Data + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_SetChannel2Data + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_SetDualChannelData + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_GetDataOutputValue + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_DMACmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_ITConfig + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_GetFlagStatus + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_ClearFlag + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_GetITStatus + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_dac.o + .text.DAC_ClearITPendingBit + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_info 0x00000000 0x671 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_abbrev 0x00000000 0x1bc ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_loc 0x00000000 0x516 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_aranges + 0x00000000 0xa0 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_ranges 0x00000000 0x90 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x1c1 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_macro 0x00000000 0x17e ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_line 0x00000000 0x5a1 ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_str 0x00000000 0x4a479 ..\obj\lib\spl\src\stm32f0xx_dac.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_dac.o + .debug_frame 0x00000000 0x140 ..\obj\lib\spl\src\stm32f0xx_dac.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_dac.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .text.DBGMCU_GetREVID + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .text.DBGMCU_GetDEVID + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .text.DBGMCU_Config + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .text.DBGMCU_APB1PeriphConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .text.DBGMCU_APB2PeriphConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_info 0x00000000 0x1bd ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_abbrev 0x00000000 0xfb ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_loc 0x00000000 0xae ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_aranges + 0x00000000 0x40 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_ranges 0x00000000 0x30 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x199 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_macro 0x00000000 0x76 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_line 0x00000000 0x49b ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_str 0x00000000 0x4a16f ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .debug_frame 0x00000000 0x60 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_dma.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_dma.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_DeInit + 0x00000000 0x138 ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_Init + 0x00000000 0x40 ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_StructInit + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_Cmd 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_RemapConfig + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_SetCurrDataCounter + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_GetCurrDataCounter + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_ITConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_GetFlagStatus + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_ClearFlag + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_GetITStatus + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_dma.o + .text.DMA_ClearITPendingBit + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_info 0x00000000 0x4ba ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_abbrev 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_loc 0x00000000 0x1e0 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_aranges + 0x00000000 0x78 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_ranges 0x00000000 0x68 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x1e7 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_macro 0x00000000 0x855 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_line 0x00000000 0x559 ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_str 0x00000000 0x4a7db ..\obj\lib\spl\src\stm32f0xx_dma.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_dma.o + .debug_frame 0x00000000 0xe4 ..\obj\lib\spl\src\stm32f0xx_dma.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_dma.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_exti.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_exti.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_exti.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_exti.o + .text.EXTI_DeInit + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_exti.o + .text.EXTI_Init + 0x00000000 0x78 ..\obj\lib\spl\src\stm32f0xx_exti.o + .text.EXTI_StructInit + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_exti.o + .text.EXTI_GenerateSWInterrupt + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_exti.o + .text.EXTI_GetFlagStatus + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_exti.o + .text.EXTI_ClearFlag + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_exti.o + .text.EXTI_GetITStatus + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_exti.o + .text.EXTI_ClearITPendingBit + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_info 0x00000000 0x327 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_abbrev 0x00000000 0x1b9 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_loc 0x00000000 0x12c ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_aranges + 0x00000000 0x58 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_ranges 0x00000000 0x48 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x199 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_macro 0x00000000 0xcf ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_line 0x00000000 0x4e3 ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_str 0x00000000 0x4a274 ..\obj\lib\spl\src\stm32f0xx_exti.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_exti.o + .debug_frame 0x00000000 0x98 ..\obj\lib\spl\src\stm32f0xx_exti.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_exti.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_flash.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_flash.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_SetLatency + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_PrefetchBufferCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_GetPrefetchBufferStatus + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_Unlock + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_Lock + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_Unlock + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_Lock + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_Launch + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_GetUser + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_GetWRP + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_GetRDP + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_ITConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_GetFlagStatus + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_ClearFlag + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_GetStatus + 0x00000000 0x2c ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_WaitForLastOperation + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_ErasePage + 0x00000000 0x38 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_EraseAllPages + 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_ProgramWord + 0x00000000 0x64 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_ProgramHalfWord + 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_Erase + 0x00000000 0x80 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_EnableWRP + 0x00000000 0x90 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_RDPConfig + 0x00000000 0x78 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_UserConfig + 0x00000000 0x50 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_BOOTConfig + 0x00000000 0x48 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_BOOT0Config + 0x00000000 0x48 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_BOOT0SWConfig + 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_VDDAConfig + 0x00000000 0x48 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_SRAMParityConfig + 0x00000000 0x48 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_WriteUser + 0x00000000 0x40 ..\obj\lib\spl\src\stm32f0xx_flash.o + .text.FLASH_OB_ProgramData + 0x00000000 0x3c ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_info 0x00000000 0xb48 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_abbrev 0x00000000 0x211 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_loc 0x00000000 0x7ec ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_aranges + 0x00000000 0x110 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_ranges 0x00000000 0x100 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x193 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_macro 0x00000000 0x2b1 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_line 0x00000000 0x724 ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_str 0x00000000 0x4a4f1 ..\obj\lib\spl\src\stm32f0xx_flash.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_flash.o + .debug_frame 0x00000000 0x2a4 ..\obj\lib\spl\src\stm32f0xx_flash.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_flash.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .text.GPIO_DeInit + 0x00000000 0xc0 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .text.GPIO_StructInit + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .text.GPIO_PinLockConfig + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .text.GPIO_ReadInputDataBit + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .text.GPIO_ReadInputData + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .text.GPIO_ReadOutputDataBit + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .text.GPIO_ReadOutputData + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .text.GPIO_WriteBit + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_gpio.o + .text.GPIO_Write + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_gpio.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_DeInit + 0x00000000 0x38 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_Init + 0x00000000 0x64 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_StructInit + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_Cmd 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_SoftwareResetCmd + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_ITConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_StretchClockCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_StopModeCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_DualAddressCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_OwnAddress2Config + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_GeneralCallCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_SlaveByteControlCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_SlaveAddressConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_10BitAddressingModeCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_AutoEndCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_ReloadCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_NumberOfBytesConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_MasterRequestConfig + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_GenerateSTART + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_GenerateSTOP + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_10BitAddressHeaderCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_AcknowledgeConfig + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_GetAddressMatched + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_GetTransferDirection + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_TransferHandling + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_SMBusAlertCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_ClockTimeoutCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_ExtendedClockTimeoutCmd + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_IdleClockTimeoutCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_TimeoutAConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_TimeoutBConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_CalculatePEC + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_PECRequestCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_GetPEC + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_ReadRegister + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_SendData + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_ReceiveData + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_DMACmd + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_GetFlagStatus + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_ClearFlag + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_GetITStatus + 0x00000000 0x38 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .text.I2C_ClearITPendingBit + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_info 0x00000000 0xc17 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_abbrev 0x00000000 0x1ad ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_loc 0x00000000 0x613 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_aranges + 0x00000000 0x168 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_ranges 0x00000000 0x158 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x1b1 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_macro 0x00000000 0x29a ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_line 0x00000000 0x7ac ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_str 0x00000000 0x4a630 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_i2c.o + .debug_frame 0x00000000 0x2e0 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_i2c.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .text.IWDG_WriteAccessCmd + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .text.IWDG_SetPrescaler + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .text.IWDG_SetReload + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .text.IWDG_ReloadCounter + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .text.IWDG_SetWindowValue + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .text.IWDG_Enable + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .text.IWDG_GetFlagStatus + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_info 0x00000000 0x21d ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_abbrev 0x00000000 0x113 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_loc 0x00000000 0x59 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_aranges + 0x00000000 0x50 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_ranges 0x00000000 0x40 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x19f ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_macro 0x00000000 0x6a ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_line 0x00000000 0x4b9 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_str 0x00000000 0x4a1d9 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .debug_frame 0x00000000 0x80 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_iwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_misc.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_misc.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_misc.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_misc.o + .text.NVIC_Init + 0x00000000 0x54 ..\obj\lib\spl\src\stm32f0xx_misc.o + .text.NVIC_SystemLPConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_misc.o + .text.SysTick_CLKSourceConfig + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_info 0x00000000 0x375 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_abbrev 0x00000000 0x159 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_loc 0x00000000 0x7f ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_aranges + 0x00000000 0x30 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_ranges 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x193 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_line 0x00000000 0x479 ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_str 0x00000000 0x4a219 ..\obj\lib\spl\src\stm32f0xx_misc.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_misc.o + .debug_frame 0x00000000 0x4c ..\obj\lib\spl\src\stm32f0xx_misc.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_misc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .text.PWR_DeInit + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .text.PWR_BackupAccessCmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .text.PWR_PVDLevelConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .text.PWR_PVDCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .text.PWR_WakeUpPinCmd + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_pwr.o + .text.PWR_EnterSleepMode + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .text.PWR_EnterSTOPMode + 0x00000000 0x50 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .text.PWR_EnterSTANDBYMode + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .text.PWR_GetFlagStatus + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .text.PWR_ClearFlag + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_info 0x00000000 0x44a ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_abbrev 0x00000000 0x1b0 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_loc 0x00000000 0x1ac ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_aranges + 0x00000000 0x68 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_ranges 0x00000000 0x58 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x19f ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_line 0x00000000 0x533 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_str 0x00000000 0x4a2a0 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_pwr.o + .debug_frame 0x00000000 0xc0 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_pwr.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_DeInit + 0x00000000 0x60 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_HSEConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_AdjustHSICalibrationValue + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_HSICmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_AdjustHSI14CalibrationValue + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_HSI14Cmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_HSI14ADCRequestCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_LSEConfig + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_LSEDriveConfig + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_LSICmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_PLLConfig + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_PLLCmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_HSI48Cmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_PREDIV1Config + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_ClockSecuritySystemCmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_MCOConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_SYSCLKConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_GetSYSCLKSource + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_HCLKConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_PCLKConfig + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_ADCCLKConfig + 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_CECCLKConfig + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_I2CCLKConfig + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_USARTCLKConfig + 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_USBCLKConfig + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_RTCCLKConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_RTCCLKCmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_BackupResetCmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_APB2PeriphClockCmd + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_AHBPeriphResetCmd + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_APB2PeriphResetCmd + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_ITConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_GetFlagStatus + 0x00000000 0x38 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_WaitForHSEStartUp + 0x00000000 0x38 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_ClearFlag + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_GetITStatus + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .text.RCC_ClearITPendingBit + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_rcc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_ByteToBcd2 + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_Bcd2ToByte + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_StructInit + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_WriteProtectionCmd + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_EnterInitMode + 0x00000000 0x4c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_ExitInitMode + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_Init + 0x00000000 0x4c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_WaitForSynchro + 0x00000000 0x5c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_DeInit + 0x00000000 0x60 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_RefClockCmd + 0x00000000 0x48 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_BypassShadowCmd + 0x00000000 0x30 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_SetTime + 0x00000000 0xa8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_TimeStructInit + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_GetTime + 0x00000000 0x4c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_GetSubSecond + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_SetDate + 0x00000000 0x9c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_DateStructInit + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_GetDate + 0x00000000 0x4c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_SetAlarm + 0x00000000 0x94 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_AlarmStructInit + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_GetAlarm + 0x00000000 0x74 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_AlarmCmd + 0x00000000 0x64 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_AlarmSubSecondConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_GetAlarmSubSecond + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_WakeUpClockConfig + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_SetWakeUpCounter + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_GetWakeUpCounter + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_WakeUpCmd + 0x00000000 0x6c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_DayLightSavingConfig + 0x00000000 0x2c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_GetStoreOperation + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_OutputConfig + 0x00000000 0x2c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_CalibOutputCmd + 0x00000000 0x38 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_CalibOutputConfig + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_SmoothCalibConfig + 0x00000000 0x4c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_TimeStampCmd + 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_GetTimeStamp + 0x00000000 0x98 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_GetTimeStampSubSecond + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_TamperTriggerConfig + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_TamperCmd + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_TamperFilterConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_TamperSamplingFreqConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_TamperPinsPrechargeDuration + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_TimeStampOnTamperDetectionCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_TamperPullUpCmd + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_WriteBackupRegister + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_ReadBackupRegister + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_OutputTypeConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_SynchroShiftConfig + 0x00000000 0x60 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_ITConfig + 0x00000000 0x4c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_GetFlagStatus + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_ClearFlag + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_GetITStatus + 0x00000000 0x38 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .text.RTC_ClearITPendingBit + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_info 0x00000000 0x1101 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_abbrev 0x00000000 0x1e2 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_loc 0x00000000 0xf0e ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_aranges + 0x00000000 0x1c0 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_ranges 0x00000000 0x1b0 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x1d3 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_macro 0x00000000 0x4bf ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_line 0x00000000 0x9e8 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_str 0x00000000 0x4ab6c ..\obj\lib\spl\src\stm32f0xx_rtc.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_rtc.o + .debug_frame 0x00000000 0x430 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_rtc.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_spi.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_spi.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_I2S_DeInit + 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_StructInit + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_Init + 0x00000000 0x58 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.I2S_StructInit + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.I2S_Init + 0x00000000 0xb4 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_Cmd 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_TIModeCmd + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.I2S_Cmd 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_DataSizeConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_RxFIFOThresholdConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_BiDirectionalLineConfig + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_NSSInternalSoftwareConfig + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_SSOutputCmd + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_NSSPulseModeCmd + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_SendData8 + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_I2S_SendData16 + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_ReceiveData8 + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_I2S_ReceiveData16 + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_CRCLengthConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_CalculateCRC + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_TransmitCRC + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_GetCRC + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_GetCRCPolynomial + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_I2S_DMACmd + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_LastDMATransferCmd + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_I2S_ITConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_GetTransmissionFIFOStatus + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_GetReceptionFIFOStatus + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_I2S_GetFlagStatus + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_I2S_ClearFlag + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_spi.o + .text.SPI_I2S_GetITStatus + 0x00000000 0x2c ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_info 0x00000000 0xb5c ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_abbrev 0x00000000 0x1d6 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_loc 0x00000000 0x704 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_aranges + 0x00000000 0x110 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_ranges 0x00000000 0x100 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x1ab ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_macro 0x00000000 0x390 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_line 0x00000000 0x6e4 ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_str 0x00000000 0x4a726 ..\obj\lib\spl\src\stm32f0xx_spi.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_spi.o + .debug_frame 0x00000000 0x230 ..\obj\lib\spl\src\stm32f0xx_spi.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_spi.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .text.SYSCFG_DeInit + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .text.SYSCFG_MemoryRemapConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .text.SYSCFG_DMAChannelRemapConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .text.SYSCFG_I2CFastModePlusConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .text.SYSCFG_IRDAEnvSelection + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .text.SYSCFG_EXTILineConfig + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .text.SYSCFG_GetPendingIT + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .text.SYSCFG_BreakConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .text.SYSCFG_GetFlagStatus + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .text.SYSCFG_ClearFlag + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_info 0x00000000 0x354 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_abbrev 0x00000000 0x177 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_loc 0x00000000 0x20c ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_aranges + 0x00000000 0x68 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_ranges 0x00000000 0x58 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x193 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_macro 0x00000000 0x46b ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_line 0x00000000 0x500 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_str 0x00000000 0x4a29b ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .debug_frame 0x00000000 0xbc ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_syscfg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_tim.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_tim.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TI1_Config + 0x00000000 0x2c ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TI2_Config + 0x00000000 0x3c ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TI3_Config + 0x00000000 0x3c ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TI4_Config + 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_DeInit + 0x00000000 0x110 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_TimeBaseInit + 0x00000000 0x78 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_TimeBaseStructInit + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_PrescalerConfig + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_CounterModeConfig + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SetCounter + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SetAutoreload + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_GetCounter + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_GetPrescaler + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_UpdateDisableConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_UpdateRequestConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ARRPreloadConfig + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SelectOnePulseMode + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SetClockDivision + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_Cmd 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_BDTRConfig + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_BDTRStructInit + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_CtrlPWMOutputs + 0x00000000 0x24 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC1Init + 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC2Init + 0x00000000 0x9c ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC3Init + 0x00000000 0x88 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC4Init + 0x00000000 0x64 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OCStructInit + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SelectOCxM + 0x00000000 0x50 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SetCompare1 + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SetCompare2 + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SetCompare3 + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SetCompare4 + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ForcedOC1Config + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ForcedOC2Config + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ForcedOC3Config + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ForcedOC4Config + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_CCPreloadControl + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC1PreloadConfig + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC2PreloadConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC3PreloadConfig + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC4PreloadConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC1FastConfig + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC2FastConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC3FastConfig + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC4FastConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ClearOC1Ref + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ClearOC2Ref + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ClearOC3Ref + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ClearOC4Ref + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC1PolarityConfig + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC1NPolarityConfig + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC2PolarityConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC2NPolarityConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC3PolarityConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC3NPolarityConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_OC4PolarityConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SelectOCREFClear + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_CCxCmd + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_CCxNCmd + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SelectCOM + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ICStructInit + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_GetCapture1 + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_GetCapture2 + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_GetCapture3 + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_GetCapture4 + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SetIC1Prescaler + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SetIC2Prescaler + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_PWMIConfig + 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SetIC3Prescaler + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SetIC4Prescaler + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ICInit + 0x00000000 0x64 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ITConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_GenerateEvent + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_GetFlagStatus + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ClearFlag + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_GetITStatus + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ClearITPendingBit + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_DMAConfig + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_DMACmd + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SelectCCDMA + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_InternalClockConfig + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SelectInputTrigger + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ITRxExternalClockConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_TIxExternalClockConfig + 0x00000000 0x30 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SelectOutputTrigger + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SelectSlaveMode + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SelectMasterSlaveMode + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ETRConfig + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ETRClockMode1Config + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_ETRClockMode2Config + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_EncoderInterfaceConfig + 0x00000000 0x30 ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_SelectHallSensor + 0x00000000 0x1c ..\obj\lib\spl\src\stm32f0xx_tim.o + .text.TIM_RemapConfig + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_info 0x00000000 0x2021 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_abbrev 0x00000000 0x1b2 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_loc 0x00000000 0x1a30 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_aranges + 0x00000000 0x300 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_ranges 0x00000000 0x2f0 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x1af ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_macro 0x00000000 0x74a ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_line 0x00000000 0xc77 ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_str 0x00000000 0x4adb0 ..\obj\lib\spl\src\stm32f0xx_tim.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_tim.o + .debug_frame 0x00000000 0x6d4 ..\obj\lib\spl\src\stm32f0xx_tim.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_tim.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_usart.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_usart.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_DeInit + 0x00000000 0xf8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_StructInit + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_ClockInit + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_ClockStructInit + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_DirectionModeCmd + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_OverSampling8Cmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_OneBitMethodCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_MSBFirstCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_DataInvCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_InvPinCmd + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_SWAPPinCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_ReceiverTimeOutCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_SetReceiverTimeOut + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_SetPrescaler + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_STOPModeCmd + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_StopModeWakeUpSourceConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_AutoBaudRateCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_AutoBaudRateConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_SendData + 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_SetAddress + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_MuteModeCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_MuteModeWakeUpConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_AddressDetectionConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_LINBreakDetectLengthConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_LINCmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_HalfDuplexCmd + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_SetGuardTime + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_SmartCardCmd + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_SmartCardNACKCmd + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_SetAutoRetryCount + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_SetBlockLength + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_IrDAConfig + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_IrDACmd + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_DECmd + 0x00000000 0x20 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_DEPolarityConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_SetDEAssertionTime + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_SetDEDeassertionTime + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_DMACmd + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_DMAReceptionErrorConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_ITConfig + 0x00000000 0x38 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_RequestCmd + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_OverrunDetectionConfig + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_ClearFlag + 0x00000000 0x4 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_GetITStatus + 0x00000000 0x48 ..\obj\lib\spl\src\stm32f0xx_usart.o + .text.USART_ClearITPendingBit + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x34 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_usart.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .text 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .data 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .bss 0x00000000 0x0 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .text.WWDG_DeInit + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .text.WWDG_SetPrescaler + 0x00000000 0x18 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .text.WWDG_SetWindowValue + 0x00000000 0x28 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .text.WWDG_EnableIT + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .text.WWDG_SetCounter + 0x00000000 0x10 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .text.WWDG_Enable + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .text.WWDG_GetFlagStatus + 0x00000000 0x14 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .text.WWDG_ClearFlag + 0x00000000 0xc ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_info 0x00000000 0x288 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_abbrev 0x00000000 0x162 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_loc 0x00000000 0xcd ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_aranges + 0x00000000 0x58 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_ranges 0x00000000 0x48 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x1a5 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x832 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x81 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x22 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x87 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x44 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0xfd ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x5e ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x1df ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x1f ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x242 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x632a ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x191 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0xef ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x46 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x184 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x7c ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x85b ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x185 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x70 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0xdf ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x561 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x396 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x471 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x750 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x356 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x3a ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_macro 0x00000000 0x2e ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_line 0x00000000 0x4d1 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_str 0x00000000 0x4a209 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .comment 0x00000000 0x6f ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .debug_frame 0x00000000 0x9c ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .ARM.attributes + 0x00000000 0x31 ..\obj\lib\spl\src\stm32f0xx_wwdg.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\lib\system_stm32f0xx.o + .text 0x00000000 0x0 ..\obj\lib\system_stm32f0xx.o + .data 0x00000000 0x0 ..\obj\lib\system_stm32f0xx.o + .bss 0x00000000 0x0 ..\obj\lib\system_stm32f0xx.o + .text.SystemCoreClockUpdate + 0x00000000 0x94 ..\obj\lib\system_stm32f0xx.o + .data.AHBPrescTable + 0x00000000 0x10 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x832 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x81 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x3a ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x22 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x87 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x44 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0xfd ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x5e ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x1df ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x1f ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x242 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x632a ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x2eb ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x3cf ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x191 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0xef ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x46 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0xd9 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x184 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x7c ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x85b ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0xd5 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x2b7 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x185 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x2a0 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x70 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0xdf ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x561 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x4c5 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x396 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x471 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x750 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x356 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x34 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x00000000 0x3a ..\obj\lib\system_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .group 0x00000000 0x8 ..\obj\main.o + .text 0x00000000 0x0 ..\obj\main.o + .data 0x00000000 0x0 ..\obj\main.o + .bss 0x00000000 0x0 ..\obj\main.o + .debug_macro 0x00000000 0x832 ..\obj\main.o + .debug_macro 0x00000000 0x93 ..\obj\main.o + .debug_macro 0x00000000 0x81 ..\obj\main.o + .debug_macro 0x00000000 0x3a ..\obj\main.o + .debug_macro 0x00000000 0x22 ..\obj\main.o + .debug_macro 0x00000000 0x87 ..\obj\main.o + .debug_macro 0x00000000 0x44 ..\obj\main.o + .debug_macro 0x00000000 0xfd ..\obj\main.o + .debug_macro 0x00000000 0x5e ..\obj\main.o + .debug_macro 0x00000000 0x1df ..\obj\main.o + .debug_macro 0x00000000 0x1f ..\obj\main.o + .debug_macro 0x00000000 0x242 ..\obj\main.o + .debug_macro 0x00000000 0x632a ..\obj\main.o + .debug_macro 0x00000000 0x2eb ..\obj\main.o + .debug_macro 0x00000000 0x3cf ..\obj\main.o + .debug_macro 0x00000000 0x191 ..\obj\main.o + .debug_macro 0x00000000 0xef ..\obj\main.o + .debug_macro 0x00000000 0x46 ..\obj\main.o + .debug_macro 0x00000000 0xd9 ..\obj\main.o + .debug_macro 0x00000000 0x184 ..\obj\main.o + .debug_macro 0x00000000 0x7c ..\obj\main.o + .debug_macro 0x00000000 0x85b ..\obj\main.o + .debug_macro 0x00000000 0xd5 ..\obj\main.o + .debug_macro 0x00000000 0x2b7 ..\obj\main.o + .debug_macro 0x00000000 0x185 ..\obj\main.o + .debug_macro 0x00000000 0x2a0 ..\obj\main.o + .debug_macro 0x00000000 0x70 ..\obj\main.o + .debug_macro 0x00000000 0xdf ..\obj\main.o + .debug_macro 0x00000000 0x561 ..\obj\main.o + .debug_macro 0x00000000 0x4c5 ..\obj\main.o + .debug_macro 0x00000000 0x396 ..\obj\main.o + .debug_macro 0x00000000 0x471 ..\obj\main.o + .debug_macro 0x00000000 0x750 ..\obj\main.o + .debug_macro 0x00000000 0x356 ..\obj\main.o + .debug_macro 0x00000000 0x34 ..\obj\main.o + .debug_macro 0x00000000 0x3a ..\obj\main.o + .data 0x00000000 0x0 ..\obj\startup_stm32f0xx.o + .bss 0x00000000 0x0 ..\obj\startup_stm32f0xx.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .group 0x00000000 0x8 ..\obj\timer.o + .text 0x00000000 0x0 ..\obj\timer.o + .data 0x00000000 0x0 ..\obj\timer.o + .bss 0x00000000 0x0 ..\obj\timer.o + .text.TimerDeinit + 0x00000000 0xc ..\obj\timer.o + .debug_macro 0x00000000 0x832 ..\obj\timer.o + .debug_macro 0x00000000 0x93 ..\obj\timer.o + .debug_macro 0x00000000 0x81 ..\obj\timer.o + .debug_macro 0x00000000 0x3a ..\obj\timer.o + .debug_macro 0x00000000 0x22 ..\obj\timer.o + .debug_macro 0x00000000 0x87 ..\obj\timer.o + .debug_macro 0x00000000 0x44 ..\obj\timer.o + .debug_macro 0x00000000 0xfd ..\obj\timer.o + .debug_macro 0x00000000 0x5e ..\obj\timer.o + .debug_macro 0x00000000 0x1df ..\obj\timer.o + .debug_macro 0x00000000 0x1f ..\obj\timer.o + .debug_macro 0x00000000 0x242 ..\obj\timer.o + .debug_macro 0x00000000 0x632a ..\obj\timer.o + .debug_macro 0x00000000 0x2eb ..\obj\timer.o + .debug_macro 0x00000000 0x3cf ..\obj\timer.o + .debug_macro 0x00000000 0x191 ..\obj\timer.o + .debug_macro 0x00000000 0xef ..\obj\timer.o + .debug_macro 0x00000000 0x46 ..\obj\timer.o + .debug_macro 0x00000000 0xd9 ..\obj\timer.o + .debug_macro 0x00000000 0x184 ..\obj\timer.o + .debug_macro 0x00000000 0x7c ..\obj\timer.o + .debug_macro 0x00000000 0x85b ..\obj\timer.o + .debug_macro 0x00000000 0xd5 ..\obj\timer.o + .debug_macro 0x00000000 0x2b7 ..\obj\timer.o + .debug_macro 0x00000000 0x185 ..\obj\timer.o + .debug_macro 0x00000000 0x2a0 ..\obj\timer.o + .debug_macro 0x00000000 0x70 ..\obj\timer.o + .debug_macro 0x00000000 0xdf ..\obj\timer.o + .debug_macro 0x00000000 0x561 ..\obj\timer.o + .debug_macro 0x00000000 0x4c5 ..\obj\timer.o + .debug_macro 0x00000000 0x396 ..\obj\timer.o + .debug_macro 0x00000000 0x471 ..\obj\timer.o + .debug_macro 0x00000000 0x750 ..\obj\timer.o + .debug_macro 0x00000000 0x356 ..\obj\timer.o + .debug_macro 0x00000000 0x34 ..\obj\timer.o + .debug_macro 0x00000000 0x3a ..\obj\timer.o + .data 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_udivsi3.o) + .bss 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_udivsi3.o) + .data 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_dvmd_tls.o) + .bss 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_dvmd_tls.o) + .text 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-exit.o) + .data 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-exit.o) + .bss 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-exit.o) + .text 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-impure.o) + .data 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-impure.o) + .bss 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-impure.o) + .data._impure_ptr + 0x00000000 0x4 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-impure.o) + .text 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-init.o) + .data 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-init.o) + .bss 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-init.o) + .text 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-memcpy-stub.o) + .data 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-memcpy-stub.o) + .bss 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-memcpy-stub.o) + .text 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-memset.o) + .data 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-memset.o) + .bss 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-memset.o) + .text 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libnosys_s.a(_exit.o) + .data 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libnosys_s.a(_exit.o) + .bss 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libnosys_s.a(_exit.o) + .text 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtend.o + .data 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtend.o + .bss 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtend.o + .jcr 0x00000000 0x4 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtend.o + .text 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtn.o + .data 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtn.o + .bss 0x00000000 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtn.o + +Memory Configuration + +Name Origin Length Attributes +ROM 0x08002000 0x0003e000 xr +RAM 0x200000c0 0x00007f40 xrw +*default* 0x00000000 0xffffffff + +Linker script and memory map + +LOAD c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crti.o +LOAD c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o +LOAD c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m/crt0.o + 0x00000000 __HEAP_SIZE = 0x0 + 0x00000100 __STACK_SIZE = 0x100 + +.text 0x08002000 0xfe8 + *(.isr_vector) + .isr_vector 0x08002000 0xc4 ..\obj\startup_stm32f0xx.o + 0x08002000 __isr_vector + *(.text*) + .text 0x080020c4 0x60 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o + .text 0x08002124 0x78 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m/crt0.o + 0x08002124 _start + 0x08002124 _mainCRTStartup + .text.BootComUartInit + 0x0800219c 0x78 ..\obj\boot.o + .text.CanGetSpeedConfig + 0x08002214 0x7c ..\obj\boot.o + .text.BootComCanInit + 0x08002290 0xd0 ..\obj\boot.o + .text.UartReceiveByte + 0x08002360 0x24 ..\obj\boot.o + .text.BootComInit + 0x08002384 0xc ..\obj\boot.o + 0x08002384 BootComInit + .text.BootActivate + 0x08002390 0x18 ..\obj\boot.o + 0x08002390 BootActivate + .text.BootComUartCheckActivationRequest + 0x080023a8 0x70 ..\obj\boot.o + .text.BootComCanCheckActivationRequest + 0x08002418 0x44 ..\obj\boot.o + .text.BootComCheckActivationRequest + 0x0800245c 0xc ..\obj\boot.o + 0x0800245c BootComCheckActivationRequest + .text.LedInit 0x08002468 0x3c ..\obj\led.o + 0x08002468 LedInit + .text.LedToggle + 0x080024a4 0x50 ..\obj\led.o + 0x080024a4 LedToggle + .text.CAN_DeInit + 0x080024f4 0x18 ..\obj\lib\spl\src\stm32f0xx_can.o + 0x080024f4 CAN_DeInit + .text.CAN_Init + 0x0800250c 0x108 ..\obj\lib\spl\src\stm32f0xx_can.o + 0x0800250c CAN_Init + .text.CAN_FilterInit + 0x08002614 0xfc ..\obj\lib\spl\src\stm32f0xx_can.o + 0x08002614 CAN_FilterInit + .text.CAN_StructInit + 0x08002710 0x20 ..\obj\lib\spl\src\stm32f0xx_can.o + 0x08002710 CAN_StructInit + .text.CAN_Receive + 0x08002730 0x9c ..\obj\lib\spl\src\stm32f0xx_can.o + 0x08002730 CAN_Receive + .text.CAN_MessagePending + 0x080027cc 0x1c ..\obj\lib\spl\src\stm32f0xx_can.o + 0x080027cc CAN_MessagePending + .text.GPIO_Init + 0x080027e8 0x84 ..\obj\lib\spl\src\stm32f0xx_gpio.o + 0x080027e8 GPIO_Init + .text.GPIO_SetBits + 0x0800286c 0x4 ..\obj\lib\spl\src\stm32f0xx_gpio.o + 0x0800286c GPIO_SetBits + .text.GPIO_ResetBits + 0x08002870 0x4 ..\obj\lib\spl\src\stm32f0xx_gpio.o + 0x08002870 GPIO_ResetBits + .text.GPIO_PinAFConfig + 0x08002874 0x24 ..\obj\lib\spl\src\stm32f0xx_gpio.o + 0x08002874 GPIO_PinAFConfig + .text.RCC_GetClocksFreq + 0x08002898 0x1f0 ..\obj\lib\spl\src\stm32f0xx_rcc.o + 0x08002898 RCC_GetClocksFreq + .text.RCC_AHBPeriphClockCmd + 0x08002a88 0x1c ..\obj\lib\spl\src\stm32f0xx_rcc.o + 0x08002a88 RCC_AHBPeriphClockCmd + .text.RCC_APB1PeriphClockCmd + 0x08002aa4 0x1c ..\obj\lib\spl\src\stm32f0xx_rcc.o + 0x08002aa4 RCC_APB1PeriphClockCmd + .text.RCC_APB1PeriphResetCmd + 0x08002ac0 0x1c ..\obj\lib\spl\src\stm32f0xx_rcc.o + 0x08002ac0 RCC_APB1PeriphResetCmd + .text.USART_Init + 0x08002adc 0xdc ..\obj\lib\spl\src\stm32f0xx_usart.o + 0x08002adc USART_Init + .text.USART_Cmd + 0x08002bb8 0x18 ..\obj\lib\spl\src\stm32f0xx_usart.o + 0x08002bb8 USART_Cmd + .text.USART_ReceiveData + 0x08002bd0 0x8 ..\obj\lib\spl\src\stm32f0xx_usart.o + 0x08002bd0 USART_ReceiveData + .text.USART_GetFlagStatus + 0x08002bd8 0x10 ..\obj\lib\spl\src\stm32f0xx_usart.o + 0x08002bd8 USART_GetFlagStatus + .text.SetSysClock + 0x08002be8 0x60 ..\obj\lib\system_stm32f0xx.o + .text.SystemInit + 0x08002c48 0x64 ..\obj\lib\system_stm32f0xx.o + 0x08002c48 SystemInit + .text.Init 0x08002cac 0xc ..\obj\main.o + .text.main 0x08002cb8 0x14 ..\obj\main.o + 0x08002cb8 main + .text 0x08002ccc 0xa8 ..\obj\startup_stm32f0xx.o + 0x08002ccc Reset_Handler + 0x08002d1e NMI_Handler + 0x08002d20 HardFault_Handler + 0x08002d22 SVC_Handler + 0x08002d24 PendSV_Handler + 0x08002d28 Default_Handler + 0x08002d2a WWDG_IRQHandler + 0x08002d2c PVD_IRQHandler + 0x08002d2e RTC_IRQHandler + 0x08002d30 FLASH_IRQHandler + 0x08002d32 RCC_IRQHandler + 0x08002d34 EXTI0_1_IRQHandler + 0x08002d36 EXTI2_3_IRQHandler + 0x08002d38 EXTI4_15_IRQHandler + 0x08002d3a TS_IRQHandler + 0x08002d3c DMA1_Channel1_IRQHandler + 0x08002d3e DMA1_Channel2_3_IRQHandler + 0x08002d40 DMA1_Channel4_5_IRQHandler + 0x08002d42 ADC1_COMP_IRQHandler + 0x08002d44 TIM1_BRK_UP_TRG_COM_IRQHandler + 0x08002d46 TIM1_CC_IRQHandler + 0x08002d48 TIM2_IRQHandler + 0x08002d4a TIM3_IRQHandler + 0x08002d4c TIM6_DAC_IRQHandler + 0x08002d4e TIM7_IRQHandler + 0x08002d50 TIM14_IRQHandler + 0x08002d52 TIM15_IRQHandler + 0x08002d54 TIM16_IRQHandler + 0x08002d56 TIM17_IRQHandler + 0x08002d58 I2C1_IRQHandler + 0x08002d5a I2C2_IRQHandler + 0x08002d5c SPI1_IRQHandler + 0x08002d5e SPI2_IRQHandler + 0x08002d60 USART1_IRQHandler + 0x08002d62 USART2_IRQHandler + 0x08002d64 USART3_4_IRQHandler + 0x08002d66 CEC_IRQHandler + 0x08002d68 USB_IRQHandler + 0x08002d6a BootRAM + .text.TimerSet + 0x08002d74 0xc ..\obj\timer.o + 0x08002d74 TimerSet + .text.TimerInit + 0x08002d80 0x4c ..\obj\timer.o + 0x08002d80 TimerInit + .text.TimerGet + 0x08002dcc 0xc ..\obj\timer.o + 0x08002dcc TimerGet + .text.SysTick_Handler + 0x08002dd8 0x10 ..\obj\timer.o + 0x08002dd8 SysTick_Handler + .text 0x08002de8 0x114 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_udivsi3.o) + 0x08002de8 __aeabi_uidiv + 0x08002de8 __udivsi3 + 0x08002ef4 __aeabi_uidivmod + .text 0x08002efc 0x4 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_dvmd_tls.o) + 0x08002efc __aeabi_idiv0 + 0x08002efc __aeabi_ldiv0 + .text.exit 0x08002f00 0x2c c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-exit.o) + 0x08002f00 exit + .text.__libc_init_array + 0x08002f2c 0x4c c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-init.o) + 0x08002f2c __libc_init_array + .text.memcpy 0x08002f78 0x12 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-memcpy-stub.o) + 0x08002f78 memcpy + .text.memset 0x08002f8a 0x10 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-memset.o) + 0x08002f8a memset + .text._exit 0x08002f9a 0x2 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libnosys_s.a(_exit.o) + 0x08002f9a _exit + *(.init) + .init 0x08002f9c 0x4 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crti.o + 0x08002f9c _init + .init 0x08002fa0 0x8 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtn.o + *(.fini) + .fini 0x08002fa8 0x4 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crti.o + 0x08002fa8 _fini + .fini 0x08002fac 0x8 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtn.o + *crtbegin.o(.ctors) + *crtbegin?.o(.ctors) + *(EXCLUDE_FILE(*crtend.o *crtend?.o) .ctors) + *(SORT(.ctors.*)) + *(.ctors) + *crtbegin.o(.dtors) + *crtbegin?.o(.dtors) + *(EXCLUDE_FILE(*crtend.o *crtend?.o) .dtors) + *(SORT(.dtors.*)) + *(.dtors) + *(.rodata*) + .rodata 0x08002fb4 0x2 ..\obj\boot.o + *fill* 0x08002fb6 0x2 + .rodata.canTiming + 0x08002fb8 0x24 ..\obj\boot.o + .rodata.str1.1 + 0x08002fdc 0x2 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-impure.o) + *fill* 0x08002fde 0x2 + .rodata._global_impure_ptr + 0x08002fe0 0x4 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-impure.o) + 0x08002fe0 _global_impure_ptr + *(.eh_frame*) + .eh_frame 0x08002fe4 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o + .eh_frame 0x08002fe4 0x4 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtend.o + +.glue_7 0x08002fe8 0x0 + .glue_7 0x08002fe8 0x0 linker stubs + +.glue_7t 0x08002fe8 0x0 + .glue_7t 0x08002fe8 0x0 linker stubs + +.vfp11_veneer 0x08002fe8 0x0 + .vfp11_veneer 0x08002fe8 0x0 linker stubs + +.v4_bx 0x08002fe8 0x0 + .v4_bx 0x08002fe8 0x0 linker stubs + +.iplt 0x08002fe8 0x0 + .iplt 0x08002fe8 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o + +.ARM.extab + *(.ARM.extab* .gnu.linkonce.armextab.*) + 0x08002fe8 __exidx_start = . + +.ARM.exidx 0x08002fe8 0x8 + *(.ARM.exidx* .gnu.linkonce.armexidx.*) + .ARM.exidx 0x08002fe8 0x8 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m/crt0.o + 0x08002ff0 __exidx_end = . + 0x08002ff0 __etext = . + +.rel.dyn 0x08002ff0 0x0 + .rel.iplt 0x08002ff0 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o + +.data 0x200000c0 0x7c load address 0x08002ff0 + 0x200000c0 __data_start__ = . + *(vtable) + *(.data*) + .data.APBAHBPrescTable + 0x200000c0 0x10 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .data.SystemCoreClock + 0x200000d0 0x4 ..\obj\lib\system_stm32f0xx.o + 0x200000d0 SystemCoreClock + .data.impure_data + 0x200000d4 0x60 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-impure.o) + 0x20000134 . = ALIGN (0x4) + 0x20000134 PROVIDE (__preinit_array_start, .) + *(.preinit_array) + 0x20000134 PROVIDE (__preinit_array_end, .) + 0x20000134 . = ALIGN (0x4) + 0x20000134 PROVIDE (__init_array_start, .) + *(SORT(.init_array.*)) + *(.init_array) + .init_array 0x20000134 0x4 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o + 0x20000138 PROVIDE (__init_array_end, .) + 0x20000138 . = ALIGN (0x4) + [!provide] PROVIDE (__fini_array_start, .) + *(SORT(.fini_array.*)) + *(.fini_array) + .fini_array 0x20000138 0x4 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o + [!provide] PROVIDE (__fini_array_end, .) + 0x2000013c . = ALIGN (0x4) + 0x2000013c __data_end__ = . + +.jcr 0x2000013c 0x0 load address 0x0800306c + .jcr 0x2000013c 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o + +.igot.plt 0x2000013c 0x0 load address 0x0800306c + .igot.plt 0x2000013c 0x0 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o + +.bss 0x2000013c 0x6c load address 0x0800306c + 0x2000013c __bss_start__ = . + *(.bss*) + .bss 0x2000013c 0x1c c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o + .bss.xcpCtoReqPacket.6496 + 0x20000158 0x41 ..\obj\boot.o + .bss.xcpCtoRxLength.6497 + 0x20000199 0x1 ..\obj\boot.o + .bss.xcpCtoRxInProgress.6498 + 0x2000019a 0x1 ..\obj\boot.o + *fill* 0x2000019b 0x1 + .bss.timer_counter_last.6477 + 0x2000019c 0x4 ..\obj\led.o + .bss.led_toggle_state.6476 + 0x200001a0 0x1 ..\obj\led.o + *fill* 0x200001a1 0x3 + .bss.millisecond_counter + 0x200001a4 0x4 ..\obj\timer.o + *(COMMON) + 0x200001a8 __bss_end__ = . + +.heap 0x200001a8 0x0 + 0x200001a8 __end__ = . + 0x200001a8 end = __end__ + *(.heap*) + .heap 0x200001a8 0x0 ..\obj\startup_stm32f0xx.o + 0x200001a8 __HeapLimit = . + +.stack_dummy 0x200001a8 0x100 + *(.stack) + .stack 0x200001a8 0x100 ..\obj\startup_stm32f0xx.o + 0x20008000 __StackTop = (ORIGIN (RAM) + LENGTH (RAM)) + 0x20007f00 __StackLimit = (__StackTop - SIZEOF (.stack_dummy)) + 0x20008000 PROVIDE (__stack, __StackTop) + 0x00000001 ASSERT ((__StackLimit >= __HeapLimit), region RAM overflowed with stack) +LOAD ..\obj\boot.o +LOAD ..\obj\led.o +LOAD ..\obj\lib\spl\src\stm32f0xx_adc.o +LOAD ..\obj\lib\spl\src\stm32f0xx_can.o +LOAD ..\obj\lib\spl\src\stm32f0xx_cec.o +LOAD ..\obj\lib\spl\src\stm32f0xx_comp.o +LOAD ..\obj\lib\spl\src\stm32f0xx_crc.o +LOAD ..\obj\lib\spl\src\stm32f0xx_crs.o +LOAD ..\obj\lib\spl\src\stm32f0xx_dac.o +LOAD ..\obj\lib\spl\src\stm32f0xx_dbgmcu.o +LOAD ..\obj\lib\spl\src\stm32f0xx_dma.o +LOAD ..\obj\lib\spl\src\stm32f0xx_exti.o +LOAD ..\obj\lib\spl\src\stm32f0xx_flash.o +LOAD ..\obj\lib\spl\src\stm32f0xx_gpio.o +LOAD ..\obj\lib\spl\src\stm32f0xx_i2c.o +LOAD ..\obj\lib\spl\src\stm32f0xx_iwdg.o +LOAD ..\obj\lib\spl\src\stm32f0xx_misc.o +LOAD ..\obj\lib\spl\src\stm32f0xx_pwr.o +LOAD ..\obj\lib\spl\src\stm32f0xx_rcc.o +LOAD ..\obj\lib\spl\src\stm32f0xx_rtc.o +LOAD ..\obj\lib\spl\src\stm32f0xx_spi.o +LOAD ..\obj\lib\spl\src\stm32f0xx_syscfg.o +LOAD ..\obj\lib\spl\src\stm32f0xx_tim.o +LOAD ..\obj\lib\spl\src\stm32f0xx_usart.o +LOAD ..\obj\lib\spl\src\stm32f0xx_wwdg.o +LOAD ..\obj\lib\system_stm32f0xx.o +LOAD ..\obj\main.o +LOAD ..\obj\startup_stm32f0xx.o +LOAD ..\obj\timer.o +START GROUP +LOAD c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a +LOAD c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a +LOAD c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libc_n.a +END GROUP +START GROUP +LOAD c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a +LOAD c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libc_n.a +LOAD c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libnosys_s.a +END GROUP +LOAD c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtend.o +LOAD c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtn.o +OUTPUT(..\bin\demoprog_stm32f091.elf elf32-littlearm) + +.ARM.attributes + 0x00000000 0x28 + .ARM.attributes + 0x00000000 0x1e c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crti.o + .ARM.attributes + 0x0000001e 0x2c c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtbegin.o + .ARM.attributes + 0x0000004a 0x1b c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m/crt0.o + .ARM.attributes + 0x00000065 0x31 ..\obj\boot.o + .ARM.attributes + 0x00000096 0x31 ..\obj\led.o + .ARM.attributes + 0x000000c7 0x31 ..\obj\lib\spl\src\stm32f0xx_can.o + .ARM.attributes + 0x000000f8 0x31 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .ARM.attributes + 0x00000129 0x31 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .ARM.attributes + 0x0000015a 0x31 ..\obj\lib\spl\src\stm32f0xx_usart.o + .ARM.attributes + 0x0000018b 0x31 ..\obj\lib\system_stm32f0xx.o + .ARM.attributes + 0x000001bc 0x31 ..\obj\main.o + .ARM.attributes + 0x000001ed 0x1b ..\obj\startup_stm32f0xx.o + .ARM.attributes + 0x00000208 0x31 ..\obj\timer.o + .ARM.attributes + 0x00000239 0x1e c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_udivsi3.o) + .ARM.attributes + 0x00000257 0x1e c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_dvmd_tls.o) + .ARM.attributes + 0x00000275 0x2c c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-exit.o) + .ARM.attributes + 0x000002a1 0x2c c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-impure.o) + .ARM.attributes + 0x000002cd 0x2c c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-init.o) + .ARM.attributes + 0x000002f9 0x2c c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-memcpy-stub.o) + .ARM.attributes + 0x00000325 0x2c c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-memset.o) + .ARM.attributes + 0x00000351 0x2c c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libnosys_s.a(_exit.o) + .ARM.attributes + 0x0000037d 0x2c c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtend.o + .ARM.attributes + 0x000003a9 0x1e c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m/crtn.o + +.comment 0x00000000 0x6e + .comment 0x00000000 0x6e ..\obj\boot.o + 0x6f (size before relaxing) + .comment 0x0000006e 0x6f ..\obj\led.o + .comment 0x0000006e 0x6f ..\obj\lib\spl\src\stm32f0xx_can.o + .comment 0x0000006e 0x6f ..\obj\lib\spl\src\stm32f0xx_gpio.o + .comment 0x0000006e 0x6f ..\obj\lib\spl\src\stm32f0xx_rcc.o + .comment 0x0000006e 0x6f ..\obj\lib\spl\src\stm32f0xx_usart.o + .comment 0x0000006e 0x6f ..\obj\lib\system_stm32f0xx.o + .comment 0x0000006e 0x6f ..\obj\main.o + .comment 0x0000006e 0x6f ..\obj\timer.o + +.debug_info 0x00000000 0x4abf + .debug_info 0x00000000 0xf4d ..\obj\boot.o + .debug_info 0x00000f4d 0x3cb ..\obj\led.o + .debug_info 0x00001318 0xcdf ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_info 0x00001ff7 0x724 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_info 0x0000271b 0xaa0 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_info 0x000031bb 0x1012 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_info 0x000041cd 0x2c4 ..\obj\lib\system_stm32f0xx.o + .debug_info 0x00004491 0x114 ..\obj\main.o + .debug_info 0x000045a5 0x8e ..\obj\startup_stm32f0xx.o + .debug_info 0x00004633 0x48c ..\obj\timer.o + +.debug_abbrev 0x00000000 0xf79 + .debug_abbrev 0x00000000 0x2b1 ..\obj\boot.o + .debug_abbrev 0x000002b1 0x157 ..\obj\led.o + .debug_abbrev 0x00000408 0x220 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_abbrev 0x00000628 0x1d4 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_abbrev 0x000007fc 0x235 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_abbrev 0x00000a31 0x1b8 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_abbrev 0x00000be9 0x116 ..\obj\lib\system_stm32f0xx.o + .debug_abbrev 0x00000cff 0x80 ..\obj\main.o + .debug_abbrev 0x00000d7f 0x14 ..\obj\startup_stm32f0xx.o + .debug_abbrev 0x00000d93 0x1e6 ..\obj\timer.o + +.debug_loc 0x00000000 0x258e + .debug_loc 0x00000000 0xfa ..\obj\boot.o + .debug_loc 0x000000fa 0x34 ..\obj\led.o + .debug_loc 0x0000012e 0xde0 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_loc 0x00000f0e 0x2b0 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_loc 0x000011be 0x937 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_loc 0x00001af5 0x921 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_loc 0x00002416 0x11f ..\obj\lib\system_stm32f0xx.o + .debug_loc 0x00002535 0x59 ..\obj\timer.o + +.debug_aranges 0x00000000 0x5a0 + .debug_aranges + 0x00000000 0x60 ..\obj\boot.o + .debug_aranges + 0x00000060 0x28 ..\obj\led.o + .debug_aranges + 0x00000088 0xe0 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_aranges + 0x00000168 0x80 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_aranges + 0x000001e8 0x160 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_aranges + 0x00000348 0x1a0 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_aranges + 0x000004e8 0x30 ..\obj\lib\system_stm32f0xx.o + .debug_aranges + 0x00000518 0x28 ..\obj\main.o + .debug_aranges + 0x00000540 0x20 ..\obj\startup_stm32f0xx.o + .debug_aranges + 0x00000560 0x40 ..\obj\timer.o + +.debug_ranges 0x00000000 0x4f0 + .debug_ranges 0x00000000 0x50 ..\obj\boot.o + .debug_ranges 0x00000050 0x18 ..\obj\led.o + .debug_ranges 0x00000068 0xd0 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_ranges 0x00000138 0x70 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_ranges 0x000001a8 0x150 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_ranges 0x000002f8 0x190 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_ranges 0x00000488 0x20 ..\obj\lib\system_stm32f0xx.o + .debug_ranges 0x000004a8 0x18 ..\obj\main.o + .debug_ranges 0x000004c0 0x30 ..\obj\timer.o + +.debug_macro 0x00000000 0xc79e + .debug_macro 0x00000000 0x1ba ..\obj\boot.o + .debug_macro 0x000001ba 0x832 ..\obj\boot.o + .debug_macro 0x000009ec 0x93 ..\obj\boot.o + .debug_macro 0x00000a7f 0x81 ..\obj\boot.o + .debug_macro 0x00000b00 0x3a ..\obj\boot.o + .debug_macro 0x00000b3a 0x22 ..\obj\boot.o + .debug_macro 0x00000b5c 0x87 ..\obj\boot.o + .debug_macro 0x00000be3 0x44 ..\obj\boot.o + .debug_macro 0x00000c27 0xfd ..\obj\boot.o + .debug_macro 0x00000d24 0x5e ..\obj\boot.o + .debug_macro 0x00000d82 0x1df ..\obj\boot.o + .debug_macro 0x00000f61 0x1f ..\obj\boot.o + .debug_macro 0x00000f80 0x242 ..\obj\boot.o + .debug_macro 0x000011c2 0x632a ..\obj\boot.o + .debug_macro 0x000074ec 0x2eb ..\obj\boot.o + .debug_macro 0x000077d7 0x3cf ..\obj\boot.o + .debug_macro 0x00007ba6 0x191 ..\obj\boot.o + .debug_macro 0x00007d37 0xef ..\obj\boot.o + .debug_macro 0x00007e26 0x46 ..\obj\boot.o + .debug_macro 0x00007e6c 0xd9 ..\obj\boot.o + .debug_macro 0x00007f45 0x184 ..\obj\boot.o + .debug_macro 0x000080c9 0x7c ..\obj\boot.o + .debug_macro 0x00008145 0x85b ..\obj\boot.o + .debug_macro 0x000089a0 0xd5 ..\obj\boot.o + .debug_macro 0x00008a75 0x2b7 ..\obj\boot.o + .debug_macro 0x00008d2c 0x185 ..\obj\boot.o + .debug_macro 0x00008eb1 0x2a0 ..\obj\boot.o + .debug_macro 0x00009151 0x70 ..\obj\boot.o + .debug_macro 0x000091c1 0xdf ..\obj\boot.o + .debug_macro 0x000092a0 0x561 ..\obj\boot.o + .debug_macro 0x00009801 0x4c5 ..\obj\boot.o + .debug_macro 0x00009cc6 0x396 ..\obj\boot.o + .debug_macro 0x0000a05c 0x471 ..\obj\boot.o + .debug_macro 0x0000a4cd 0x750 ..\obj\boot.o + .debug_macro 0x0000ac1d 0x356 ..\obj\boot.o + .debug_macro 0x0000af73 0x34 ..\obj\boot.o + .debug_macro 0x0000afa7 0x3a ..\obj\boot.o + .debug_macro 0x0000afe1 0x1c0 ..\obj\led.o + .debug_macro 0x0000b1a1 0x1e7 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_macro 0x0000b388 0x193 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x0000b51b 0x17f ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_macro 0x0000b69a 0x1b1 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x0000b84b 0x55b ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_macro 0x0000bda6 0x1ab ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x0000bf51 0x350 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_macro 0x0000c2a1 0x189 ..\obj\lib\system_stm32f0xx.o + .debug_macro 0x0000c42a 0x1ba ..\obj\main.o + .debug_macro 0x0000c5e4 0x1ba ..\obj\timer.o + +.debug_line 0x00000000 0x362f + .debug_line 0x00000000 0x591 ..\obj\boot.o + .debug_line 0x00000591 0x4a2 ..\obj\led.o + .debug_line 0x00000a33 0x7a8 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_line 0x000011db 0x567 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_line 0x00001742 0x7e3 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_line 0x00001f25 0x84e ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_line 0x00002773 0x49c ..\obj\lib\system_stm32f0xx.o + .debug_line 0x00002c0f 0x4a0 ..\obj\main.o + .debug_line 0x000030af 0x9f ..\obj\startup_stm32f0xx.o + .debug_line 0x0000314e 0x4e1 ..\obj\timer.o + +.debug_str 0x00000000 0x4bf36 + .debug_str 0x00000000 0x4a9a1 ..\obj\boot.o + 0x4ab5f (size before relaxing) + .debug_str 0x0004a9a1 0x8a ..\obj\led.o + 0x4a5aa (size before relaxing) + .debug_str 0x0004aa2b 0x4ae ..\obj\lib\spl\src\stm32f0xx_can.o + 0x4a847 (size before relaxing) + .debug_str 0x0004aed9 0x148 ..\obj\lib\spl\src\stm32f0xx_gpio.o + 0x4a3c5 (size before relaxing) + .debug_str 0x0004b021 0x543 ..\obj\lib\spl\src\stm32f0xx_rcc.o + 0x4a780 (size before relaxing) + .debug_str 0x0004b564 0x72d ..\obj\lib\spl\src\stm32f0xx_usart.o + 0x4aa17 (size before relaxing) + .debug_str 0x0004bc91 0x7b ..\obj\lib\system_stm32f0xx.o + 0x4a17f (size before relaxing) + .debug_str 0x0004bd0c 0x19 ..\obj\main.o + 0x4a375 (size before relaxing) + .debug_str 0x0004bd25 0x211 ..\obj\timer.o + 0x4a653 (size before relaxing) + +.debug_frame 0x00000000 0xc2c + .debug_frame 0x00000000 0x100 ..\obj\boot.o + .debug_frame 0x00000100 0x44 ..\obj\led.o + .debug_frame 0x00000144 0x1f4 ..\obj\lib\spl\src\stm32f0xx_can.o + .debug_frame 0x00000338 0x104 ..\obj\lib\spl\src\stm32f0xx_gpio.o + .debug_frame 0x0000043c 0x2c8 ..\obj\lib\spl\src\stm32f0xx_rcc.o + .debug_frame 0x00000704 0x354 ..\obj\lib\spl\src\stm32f0xx_usart.o + .debug_frame 0x00000a58 0x50 ..\obj\lib\system_stm32f0xx.o + .debug_frame 0x00000aa8 0x40 ..\obj\main.o + .debug_frame 0x00000ae8 0x68 ..\obj\timer.o + .debug_frame 0x00000b50 0x20 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/armv6-m\libgcc.a(_udivsi3.o) + .debug_frame 0x00000b70 0x28 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-exit.o) + .debug_frame 0x00000b98 0x2c c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-init.o) + .debug_frame 0x00000bc4 0x28 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-memcpy-stub.o) + .debug_frame 0x00000bec 0x20 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libg_n.a(lib_a-memset.o) + .debug_frame 0x00000c0c 0x20 c:/program files (x86)/embitz/1.00/share/em_armgcc/bin/../lib/gcc/arm-none-eabi/5.4.1/../../../../arm-none-eabi/lib/armv6-m\libnosys_s.a(_exit.o) diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/bin/demoprog_stm32f091.srec b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/bin/demoprog_stm32f091.srec new file mode 100644 index 00000000..8adc26ac --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/bin/demoprog_stm32f091.srec @@ -0,0 +1,266 @@ +S02100002E2E5C62696E5C64656D6F70726F675F73746D3332663039312E7372656341 +S3150800200000800020CD2C00081F2D0008212D000877 +S3150800201000000000000000000000000000000000B2 +S31508002020000000000000000000000000232D00084A +S315080020300000000000000000252D0008D92D00082A +S315080020402B2D00082D2D00082F2D0008312D0008F6 +S31508002050332D0008352D0008372D0008392D0008C6 +S315080020603B2D00083D2D00083F2D0008412D000896 +S31508002070432D0008452D0008472D0008492D000866 +S315080020804B2D00084D2D00084F2D0008512D000836 +S31508002090532D0008552D0008572D0008592D000806 +S315080020A05B2D00085D2D00085F2D0008612D0008D6 +S315080020B0632D0008652D0008672D0008692D0008A6 +S315080020C0EE11AA5510B5064C2378002B07D1054BFF +S315080020D0002B02D0044800E000BF0123237010BD86 +S315080020E03C01002000000000E42F0008084B10B552 +S315080020F0002B03D00749084800E000BF07480368DB +S31508002100002B00D110BD064B002BFBD09847F9E7F2 +S315080021100000000040010020E42F00083C010020D8 +S3150800212000000000164B002B00D1144B9D464022A0 +S3150800213092029A1A924600218B460F461348144A71 +S31508002140121A00F022FF0F4B002B00D098470E4BB7 +S31508002150002B00D098470020002104000D000D48F0 +S31508002160002802D00C4800E000BF00F0DFFE200087 +S31508002170290000F0A1FD00F0C3FEC04600000800DB +S315080021800080002000000000000000003C01002044 +S31508002190A8010020000000000000000070B588B00B +S315080021A08024A4020121200000F07CFC01212000EB +S315080021B000F06AFC9025ED0501220221280000F0B6 +S315080021C059FB01220321280000F054FB06A90C261E +S315080021D0069603234B71013B0B7100248C71013B5E +S315080021E0CB71280000F000FBE1231B020093019449 +S315080021F00294039405940496054C6946200000F061 +S315080022006DFC0121200000F0D7FC08B070BDC04667 +S3150800221000440040F0B557464E46C0B48DB08146DE +S315080022208A46019202A800F037FB049B009300251A +S3150800223021E0154A6B009E5CD3185F78F4190134C7 +S315080022404B465C432100009800F054FE002910D14B +S315080022502100009800F0C8FD80B253461880013866 +S3150800226080B20A4B984204D8019B1E705F70012009 +S3150800227004E00135EDB2112DDBD900200DB00CBC00 +S3150800228091469A46F0BDC046B82F0008FF030000E5 +S31508002290F0B58BB06B469E1C0123338002222C4975 +S315080022A0684600F069FE01218020800400F0FAFBF0 +S315080022B001218020C00200F0E7FB264D04220821F8 +S315080022C0280000F0D7FA04220921280000F0D2FAE3 +S315080022D008A9C0239B00089302230B7101334B7195 +S315080022E000248C7101270123CB71280000F07CFAA9 +S315080022F06A4631001848FFF78DFF184800F0FAF8CB +S3150800230005AD280000F004FAAC71EC712C726C7201 +S31508002310AC72EC72AC70EC706B461B78013B2B719F +S315080023206B465B78013B6B7133882B8029000B4821 +S3150800233000F0ECF801A88472C47207730480448024 +S315080023408480C4800481477300F064F90BB0F0BD43 +S31508002350B42F00080004004820A1070000640040CC +S3150800236010B504002021064800F036FC012805D1E6 +S31508002370034800F02DFC2070012000E0002010BD6D +S315080023800044004010B5FFF709FFFFF781FF10BDB5 +S31508002390BFF34F8F024A034BDA60BFF34F8FFEE756 +S315080023A00400FA0500ED00E010B5184B1B78002B69 +S315080023B00BD11748FFF7D4FF012825D10122134B6B +S315080023C01A700022134B1A701EE0124B187801304F +S315080023D00F4B1818FFF7C4FF012815D10D4A1378BB +S315080023E00133DBB213700A4A127893420CD10022E9 +S315080023F0064B1A70064B5B78FF2B05D1044B9B786E +S31508002400002B01D1FFF7C4FF10BDC0469A0100207A +S31508002410580100209901002000B587B000210D4819 +S3150800242000F0D4F9002812D001AA0021094800F0CA +S315080024307FF9094B019A9A4209D101ABDB7AFF2B46 +S3150800244005D101AB1B7B002B01D1FFF7A1FF07B01C +S3150800245000BDC046006400406706000010B5FFF7DF +S31508002460A3FFFFF7D9FF10BD10B582B00121802068 +S31508002470800200F009FB202300931F3B6A46137174 +S3150800248000239371032269464A71CB719024E405AF +S31508002490200000F0A9F92021200000F0E9F902B097 +S315080024A010BDC04610B500F091FC04000F4B1B6828 +S315080024B0C31AF422FF32934217D90D4B1B78002B0F +S315080024C009D1F33AFF3A0A4B1A7020219020C00529 +S315080024D000F0CCF907E00022054B1A702021902065 +S315080024E0C00500F0C5F9014B1C6010BD9C01002019 +S315080024F0A001002010B58024A4040121200000F0CA +S31508002500DFFA0021200000F0DBFA10BD10B50368E1 +S3150800251002229343036002680123134303600023E6 +S3150800252000E001334268D20702D4394A9342F8D10F +S315080025304368DB0768D58B79012B04D102687F33A2 +S315080025401343036003E00368802293430360CB7957 +S31508002550012B04D102683F331343036003E0036889 +S315080025604022934303600B7A012B04D102681F3380 +S315080025701343036003E003682022934303604B7A06 +S31508002580012B04D102680F331343036003E0036889 +S315080025901022934303608B7A012B04D10268073318 +S315080025A01343036003E00368082293430360CB7A6E +S315080025B0012B04D1026803331343036003E0036865 +S315080025C00422934303608B789C07CA781306234337 +S315080025D00A79120413434A79120513430A88013A01 +S315080025E01343C3610368012293430360002300E099 +S315080025F001334268D20702D5054A9342F8D14368A7 +S31508002600DB0703D5002002E0002000E0012010BD12 +S31508002610FFFFFF0070B5837A012214009C403B4BF4 +S31508002620802189005D582A435A508725AD0059599B +S31508002630E24311405951037B002B17D13349103D12 +S315080026404B5913404B51837AC5882D044688354328 +S315080026504833DB005D50837A81880904058829435D +S315080026604833DB00294DAC4663445960037B012B94 +S3150800267018D126498325AD004B5923434B51837AFC +S3150800268005882D04468835434833DB005D50837A38 +S3150800269081880904C58829434833DB001B4DAC46AD +S315080026A063445960C37A002B06D1184D81218900ED +S315080026B06B5813406B5005E0144D812189006B5807 +S315080026C023436B500389002B05D1104985239B00B2 +S315080026D0CD582A40CA500389012B05D10B498522BA +S315080026E092008B5823438B50437B012B05D1074916 +S315080026F0872292008B581C438C50044980229200F2 +S315080027008B58012083438B5070BDC046006400403F +S3150800271000238371C371037243728372C372837019 +S31508002720C37003330371013B4371013B0380704758 +S3150800273030B50B001B331B011B58042423401372AE +S3150800274006D10B001B331B011B585B0D136005E0FC +S315080027500B001B331B011B58DB0853600B001B3394 +S315080027601B011C5802252C405472C3185C680D3591 +S315080027702C4094725B681B0AD3740B01C3181C00A7 +S31508002780B934FF342568D57225682D0A157325686E +S315080027902D0C55732468240E9473BD33FF331C68BF +S315080027A0D4731C68240A14741C68240C54741B689B +S315080027B01B0E9374002904D1C26820231343C360F7 +S315080027C003E0026920231343036130BD002903D1C6 +S315080027D0C0680323184006E0012903D100690323D2 +S315080027E0184000E00020704770B500223AE0012347 +S315080027F093400C681C40A34233D10B79013BDBB2F2 +S31508002800012B17D8836855000324AC40A343836083 +S3150800281084684B79AB402343836083881404240C73 +S315080028200125A540AB43838085888B79A3402B433C +S315080028309BB283800368550003242600AE40B34349 +S31508002840036006680B79AB4033430360C36816041C +S31508002850F60BB440A343C360C468CB79AB402343AB +S31508002860C36001320F2AC2D970BDC0468161704764 +S315080028700185704730B507230B409B009A40C9086D +S31508002880083189000C580F259D40AC430C500B5855 +S315080028901A430A5030BDC046F8B50400734B5B684E +S315080028A00C221340042B0CD002D8002B05D029E0AB +S315080028B0082B0AD00C2B21D024E06D4B0360002096 +S315080028C023E06B4B036000201FE0684B58685A688A +S315080028D0C0235B02800C0F252840851C1A4202D1B2 +S315080028E06448684308E0614BDB6A0F2119400131EF +S315080028F05F4800F079FA6843206006E05E4B0360A3 +S31508002900002002E05A4B2360002058494B681B09F7 +S315080029100F221340594DEB5CDBB226683200DA40D1 +S31508002920130062604A68120A07273A40AA5CD2B2C4 +S31508002930D340A3600A6BD20502D4514AE26008E08C +S315080029404A4A5268520402D45A08E26001E09A08D8 +S31508002950E260464A126B520602D44A4A226102E0F3 +S31508002960802212022261414A126BD20602D4404AE0 +S31508002970626100E066613D4A126B920701D1A3616C +S3150800298019E03A4A126B03210A40012A01D1A661CD +S3150800299011E0364A126B03210A40022A03D180222B +S315080029A01202A26107E0314A126B03210A40032A88 +S315080029B001D12F4AA2612D4A116BC02292021142FF +S315080029C001D1E36120E0294A116BC02292020A4034 +S315080029D0802149028A4201D1E66115E0234A116B3A +S315080029E0C02292020A40802189028A4203D18022AB +S315080029F01202E26108E01D4A126BC02189020A40F0 +S31508002A008A4201D11A4AE261184A116BC02212039E +S31508002A10114201D1236220E0144B1A6BC0231B0319 +S31508002A2013408022D202934201D1266215E00F4B51 +S31508002A301A6BC0231B03134080221203934203D14F +S31508002A4080231B02236208E0084B1B6BC02212037B +S31508002A501340934201D1064B2362044B1B6B1B06A2 +S31508002A6002D4054B636200E06062F8BD00100240C4 +S31508002A7000127A0000093D00006CDC02C00000204C +S31508002A80809FD50012800000002904D0044B5A69A3 +S31508002A901043586103E0024A536983435361704700 +S31508002AA000100240002904D0044BDA691043D861AB +S31508002AB003E0024AD3698343D3617047001002409A +S31508002AC0002904D0044B1A691043186103E0024A2E +S31508002AD0136983431361704700100240F0B58DB047 +S31508002AE004000D00036801229343036042682B4BE0 +S31508002AF013408A68134343600168294B19406B6881 +S31508002B00EA6813432A691A430B0013430360826871 +S31508002B10244B13406A691343836002A8FFF7BCFE7F +S31508002B20214B9C4201D1089E0AE0204B9C4201D1D0 +S31508002B30099E05E01E4B9C4201D10A9E00E0049EB8 +S31508002B4023681B040CD576002B6801931900300006 +S31508002B5000F04AF907000199300000F0CBF90AE0C5 +S31508002B602B6801931900300000F03EF9070001991F +S31508002B70300000F0BFF92B685B08994200D3013793 +S31508002B8023681B0406D57B0807221A40094B3B40DD +S31508002B901A431700BBB2A3810DB0F0BDFFCFFFFFEC +S31508002BA0F3E9FFFFFFFCFFFF003801400044004047 +S31508002BB000480040F0FF0000002904D00268012305 +S31508002BC01343036003E003680122934303607047DD +S31508002BD0808CC005C00D7047C369194201D0012019 +S31508002BE000E000207047C0461122144B1A60144BAF +S31508002BF05A685A605A685A605968124A0A405A60AE +S31508002C005A68A02189030A435A601A688021490430 +S31508002C100A431A600A4B1B689B01FBD5084B5A6886 +S31508002C2003218A435A60596802220A435A60044BB0 +S31508002C305B680C221340082BF9D17047002002402C +S31508002C4000100240FF7FC0FF10B5124B1A68012121 +S31508002C500A431A605868104A02405A6018680F4AB0 +S31508002C6002401A6018680E4A02401A6058680D4AEF +S31508002C7002405A60DA6A0F208243DA62186B0A4AFF +S31508002C8002401A635A6B8A435A6300229A60FFF716 +S31508002C90ABFF10BD001002400CB8FFF8FFFFF6FEB0 +S31508002CA0FFFFFBFFFFFFC0FFACFEFFFF10B5FFF7FE +S31508002CB0DBFB00F065F810BD10B5FFF7F7FFFFF76F +S31508002CC061FBFFF7EFFBFFF7C9FBFAE708498D46FB +S31508002CD00849094A094B9B1A05DD00240859105171 +S31508002CE004349C42FADB0648804706480047000041 +S31508002CF000800020F02F0008C00000203C010020C2 +S31508002D00492C0008252100081849194A002301E022 +S31508002D100B6004319142FBD3FFF7CEFFFEE7FEE7D7 +S31508002D20FEE7FEE7FEE7FEE7FEE7FEE7FEE7FEE76D +S31508002D30FEE7FEE7FEE7FEE7FEE7FEE7FEE7FEE75D +S31508002D40FEE7FEE7FEE7FEE7FEE7FEE7FEE7FEE74D +S31508002D50FEE7FEE7FEE7FEE7FEE7FEE7FEE7FEE73D +S31508002D60FEE7FEE7FEE7FEE7FEE7FEE73C0100209A +S31508002D70A8010020014B18607047C046A401002036 +S31508002D8010B50E4B1868FA21890000F02DF80138A5 +S31508002D900B4B98420DD80B4A50600B490B6A1B0225 +S31508002DA01B0AC020000603430B6200239360073307 +S31508002DB013600020FFF7DEFF10BDC046D0000020DC +S31508002DC0FFFFFF0010E000E000ED00E0014B18688F +S31508002DD07047C046A4010020024A136801331360F5 +S31508002DE07047C046A4010020002243088B4274D3D2 +S31508002DF003098B425FD3030A8B4244D3030B8B42EE +S31508002E0028D3030C8B420DD3FF22090212BA030CF6 +S31508002E108B4202D31212090265D0030B8B4219D3D7 +S31508002E2000E0090AC30B8B4201D3CB03C01A5241F7 +S31508002E30830B8B4201D38B03C01A5241430B8B423F +S31508002E4001D34B03C01A5241030B8B4201D30B0328 +S31508002E50C01A5241C30A8B4201D3CB02C01A52414F +S31508002E60830A8B4201D38B02C01A5241430A8B4212 +S31508002E7001D34B02C01A5241030A8B4201D30B02FB +S31508002E80C01A5241CDD2C3098B4201D3CB01C01A15 +S31508002E90524183098B4201D38B01C01A524143091F +S31508002EA08B4201D34B01C01A524103098B4201D30D +S31508002EB00B01C01A5241C3088B4201D3CB00C01A7A +S31508002EC0524183088B4201D38B00C01A52414308F2 +S31508002ED08B4201D34B00C01A5241411A00D2014617 +S31508002EE0524110467047FFE701B5002000F006F88A +S31508002EF002BDC0460029F7D076E770477047C0463E +S31508002F00084B10B50400002B02D0002100E000BFDA +S31508002F10054B1868836A002B00D09847200000F0FC +S31508002F203CF8C04600000000E02F00080E4B70B5C4 +S31508002F3000251E000D4CE41AA410A54204D0AB00CF +S31508002F40F35898470135F8E700F028F8084B0025AC +S31508002F501E00084CE41AA410A54204D0AB00F3588E +S31508002F6098470135F8E770BD340100203401002088 +S31508002F703401002038010020002310B59A4203D0FE +S31508002F80CC5CC4540133F9E710BD030082189342A0 +S31508002F9002D019700133FAE77047FEE7F8B5C04664 +S31508002FA0F8BC08BC9E467047F8B5C046F8BC08BCD5 +S31508002FB09E46704701010000050206020603070344 +S31508002FC00803090309040A040B040C040C050D057F +S31508002FD00E050F050F06100610071008430000001F +S30D08002FE0D400002000000000E7 +S30D08002FE83CF1FF7F0100000027 +S31508002FF00000000001020304010203040607080991 +S31508003000006CDC0200000000000000000000000068 +S3150800301000000000000000000000000000000000A2 +S3150800302000000000DC2F000800000000000000007F +S315080030300000000000000000000000000000000082 +S315080030400000000000000000000000000000000072 +S315080030500000000000000000000000000000000062 +S3110800306000000000ED200008C520000854 +S70508002000D2 diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/boot.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/boot.c new file mode 100644 index 00000000..c04a1d86 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/boot.c @@ -0,0 +1,397 @@ +/************************************************************************************//** +* \file Demo\ARMCM0_STM32F0_Nucleo_F091RC_GCC\Prog\boot.c +* \brief Demo program bootloader interface source file. +* \ingroup Prog_ARMCM0_STM32F0_Nucleo_F091RC_GCC +* \internal +*---------------------------------------------------------------------------------------- +* C O P Y R I G H T +*---------------------------------------------------------------------------------------- +* Copyright (c) 2016 by Feaser http://www.feaser.com All rights reserved +* +*---------------------------------------------------------------------------------------- +* L I C E N S E +*---------------------------------------------------------------------------------------- +* This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +* modify it under the terms of the GNU General Public License as published by the Free +* Software Foundation, either version 3 of the License, or (at your option) any later +* version. +* +* OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +* PURPOSE. See the GNU General Public License for more details. +* +* You have received a copy of the GNU General Public License along with OpenBLT. It +* should be located in ".\Doc\license.html". If not, contact Feaser to obtain a copy. +* +* \endinternal +****************************************************************************************/ + +/**************************************************************************************** +* Include files +****************************************************************************************/ +#include "header.h" /* generic header */ + + +/**************************************************************************************** +* Function prototypes +****************************************************************************************/ +#if (BOOT_COM_UART_ENABLE > 0) +static void BootComUartInit(void); +static void BootComUartCheckActivationRequest(void); +#endif +#if (BOOT_COM_CAN_ENABLE > 0) +static void BootComCanInit(void); +static void BootComCanCheckActivationRequest(void); +#endif + +/************************************************************************************//** +** \brief Initializes the communication interface. +** \return none. +** +****************************************************************************************/ +void BootComInit(void) +{ +#if (BOOT_COM_UART_ENABLE > 0) + BootComUartInit(); +#endif +#if (BOOT_COM_CAN_ENABLE > 0) + BootComCanInit(); +#endif +} /*** end of BootComInit ***/ + + +/************************************************************************************//** +** \brief Receives the CONNECT request from the host, which indicates that the +** bootloader should be activated and, if so, activates it. +** \return none. +** +****************************************************************************************/ +void BootComCheckActivationRequest(void) +{ +#if (BOOT_COM_UART_ENABLE > 0) + BootComUartCheckActivationRequest(); +#endif +#if (BOOT_COM_CAN_ENABLE > 0) + BootComCanCheckActivationRequest(); +#endif +} /*** end of BootComCheckActivationRequest ***/ + + +/************************************************************************************//** +** \brief Bootloader activation function. +** \return none. +** +****************************************************************************************/ +void BootActivate(void) +{ + /* perform software reset to activate the bootoader again */ + NVIC_SystemReset(); +} /*** end of BootActivate ***/ + + +#if (BOOT_COM_UART_ENABLE > 0) +/**************************************************************************************** +* U N I V E R S A L A S Y N C H R O N O U S R X T X I N T E R F A C E +****************************************************************************************/ + +/**************************************************************************************** +* Function prototypes +****************************************************************************************/ +static unsigned char UartReceiveByte(unsigned char *data); + + +/************************************************************************************//** +** \brief Initializes the UART communication interface. +** \return none. +** +****************************************************************************************/ +static void BootComUartInit(void) +{ + GPIO_InitTypeDef GPIO_InitStructure; + USART_InitTypeDef USART_InitStructure; + + /* enable UART peripheral clock */ + RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE); + /* enable GPIO peripheral clock for transmitter and receiver pins */ + RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE); + /* configure alternate function for the USART2 Tx/Rx pins */ + GPIO_PinAFConfig(GPIOA, GPIO_PinSource2, GPIO_AF_1); + GPIO_PinAFConfig(GPIOA, GPIO_PinSource3, GPIO_AF_1); + /* Configure USART2 pins: Rx (PA2) and Tx (PA3) */ + GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_3; + GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; + GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; + GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; + GPIO_Init(GPIOA, &GPIO_InitStructure); + /* configure UART communication parameters */ + USART_InitStructure.USART_BaudRate = BOOT_COM_UART_BAUDRATE; + USART_InitStructure.USART_WordLength = USART_WordLength_8b; + USART_InitStructure.USART_StopBits = USART_StopBits_1; + USART_InitStructure.USART_Parity = USART_Parity_No; + USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; + USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; + USART_Init(USART2, &USART_InitStructure); + /* enable UART */ + USART_Cmd(USART2, ENABLE); +} /*** end of BootComUartInit ***/ + + +/************************************************************************************//** +** \brief Receives the CONNECT request from the host, which indicates that the +** bootloader should be activated and, if so, activates it. +** \return none. +** +****************************************************************************************/ +static void BootComUartCheckActivationRequest(void) +{ + static unsigned char xcpCtoReqPacket[BOOT_COM_UART_RX_MAX_DATA+1]; + static unsigned char xcpCtoRxLength; + static unsigned char xcpCtoRxInProgress = 0; + + /* start of cto packet received? */ + if (xcpCtoRxInProgress == 0) + { + /* store the message length when received */ + if (UartReceiveByte(&xcpCtoReqPacket[0]) == 1) + { + /* indicate that a cto packet is being received */ + xcpCtoRxInProgress = 1; + + /* reset packet data count */ + xcpCtoRxLength = 0; + } + } + else + { + /* store the next packet byte */ + if (UartReceiveByte(&xcpCtoReqPacket[xcpCtoRxLength+1]) == 1) + { + /* increment the packet data count */ + xcpCtoRxLength++; + + /* check to see if the entire packet was received */ + if (xcpCtoRxLength == xcpCtoReqPacket[0]) + { + /* done with cto packet reception */ + xcpCtoRxInProgress = 0; + + /* check if this was an XCP CONNECT command */ + if ((xcpCtoReqPacket[1] == 0xff) && (xcpCtoReqPacket[2] == 0x00)) + { + /* connection request received so start the bootloader */ + BootActivate(); + } + } + } + } +} /*** end of BootComUartCheckActivationRequest ***/ + + +/************************************************************************************//** +** \brief Receives a communication interface byte if one is present. +** \param data Pointer to byte where the data is to be stored. +** \return 1 if a byte was received, 0 otherwise. +** +****************************************************************************************/ +static unsigned char UartReceiveByte(unsigned char *data) +{ + /* check flag to see if a byte was received */ + if (USART_GetFlagStatus(USART2, USART_FLAG_RXNE) == SET) + { + /* retrieve and store the newly received byte */ + *data = (unsigned char)USART_ReceiveData(USART2); + /* all done */ + return 1; + } + /* still here to no new byte received */ + return 0; +} /*** end of UartReceiveByte ***/ +#endif /* BOOT_COM_UART_ENABLE > 0 */ + + +#if (BOOT_COM_CAN_ENABLE > 0) +/**************************************************************************************** +* C O N T R O L L E R A R E A N E T W O R K I N T E R F A C E +****************************************************************************************/ + +/**************************************************************************************** +* Type definitions +****************************************************************************************/ +/** \brief Structure type for grouping CAN bus timing related information. */ +typedef struct t_can_bus_timing +{ + unsigned char tseg1; /**< CAN time segment 1 */ + unsigned char tseg2; /**< CAN time segment 2 */ +} tCanBusTiming; + + +/**************************************************************************************** +* Local constant declarations +****************************************************************************************/ +/** \brief CAN bittiming table for dynamically calculating the bittiming settings. + * \details According to the CAN protocol 1 bit-time can be made up of between 8..25 + * time quanta (TQ). The total TQ in a bit is SYNC + TSEG1 + TSEG2 with SYNC + * always being 1. The sample point is (SYNC + TSEG1) / (SYNC + TSEG1 + SEG2) * + * 100%. This array contains possible and valid time quanta configurations with + * a sample point between 68..78%. + */ +static const tCanBusTiming canTiming[] = +{ /* TQ | TSEG1 | TSEG2 | SP */ + /* ------------------------- */ + { 5, 2 }, /* 8 | 5 | 2 | 75% */ + { 6, 2 }, /* 9 | 6 | 2 | 78% */ + { 6, 3 }, /* 10 | 6 | 3 | 70% */ + { 7, 3 }, /* 11 | 7 | 3 | 73% */ + { 8, 3 }, /* 12 | 8 | 3 | 75% */ + { 9, 3 }, /* 13 | 9 | 3 | 77% */ + { 9, 4 }, /* 14 | 9 | 4 | 71% */ + { 10, 4 }, /* 15 | 10 | 4 | 73% */ + { 11, 4 }, /* 16 | 11 | 4 | 75% */ + { 12, 4 }, /* 17 | 12 | 4 | 76% */ + { 12, 5 }, /* 18 | 12 | 5 | 72% */ + { 13, 5 }, /* 19 | 13 | 5 | 74% */ + { 14, 5 }, /* 20 | 14 | 5 | 75% */ + { 15, 5 }, /* 21 | 15 | 5 | 76% */ + { 15, 6 }, /* 22 | 15 | 6 | 73% */ + { 16, 6 }, /* 23 | 16 | 6 | 74% */ + { 16, 7 }, /* 24 | 16 | 7 | 71% */ + { 16, 8 } /* 25 | 16 | 8 | 68% */ +}; + + +/************************************************************************************//** +** \brief Search algorithm to match the desired baudrate to a possible bus +** timing configuration. +** \param baud The desired baudrate in bps. Valid values are 10..1000kpbs. +** \param prescaler Pointer to where the value for the prescaler will be stored. +** \param bitTiming Pointer to where the values for TSEG1 and TSEG2 will be stored. +** \return 1 if the CAN bustiming register values were found, 0 otherwise. +** +****************************************************************************************/ +static unsigned char CanGetSpeedConfig(unsigned long baud, unsigned short *prescaler, + tCanBusTiming *bitTiming) +{ + unsigned char cnt; + unsigned long canClockFreqHz; + RCC_ClocksTypeDef rccClocks; + + /* get the speed of the CAN peripheral clock (fAPB) */ + RCC_GetClocksFreq(&rccClocks); + canClockFreqHz = rccClocks.PCLK_Frequency; + + /* loop through all possible time quanta configurations to find a match */ + for (cnt=0; cnt < sizeof(canTiming)/sizeof(canTiming[0]); cnt++) + { + if ((canClockFreqHz % (baud*(canTiming[cnt].tseg1+canTiming[cnt].tseg2+1))) == 0) + { + /* compute the prescaler that goes with this TQ configuration */ + *prescaler = canClockFreqHz/(baud*(canTiming[cnt].tseg1+canTiming[cnt].tseg2+1)); + + /* make sure the prescaler is valid */ + if ((*prescaler > 0) && (*prescaler <= 1024)) + { + /* store the bittiming configuration */ + bitTiming->tseg1 = canTiming[cnt].tseg1; + bitTiming->tseg2 = canTiming[cnt].tseg2; + /* found a good bus timing configuration */ + return 1; + } + } + } + /* could not find a good bus timing configuration */ + return 0; +} /*** end of CanGetSpeedConfig ***/ + + +/************************************************************************************//** +** \brief Initializes the CAN communication interface. +** \return none. +** +****************************************************************************************/ +static void BootComCanInit(void) +{ + GPIO_InitTypeDef GPIO_InitStructure; + CAN_InitTypeDef CAN_InitStructure; + CAN_FilterInitTypeDef CAN_FilterInitStructure; + unsigned short prescaler = 1; + tCanBusTiming bitTiming = { 1, 1 }; + + /* enable CAN1 clock */ + RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN, ENABLE); + /* enable clocks for CAN1 transmitter and receiver pins */ + RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE); + /* select alternate function for the CAN1 pins */ + GPIO_PinAFConfig(GPIOB, GPIO_PinSource8, GPIO_AF_4); + GPIO_PinAFConfig(GPIOB, GPIO_PinSource9, GPIO_AF_4); + /* configure CAN1 RX and TX pins */ + GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; + GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; + GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; + GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; + GPIO_Init(GPIOB, &GPIO_InitStructure); + + /* configure bittiming */ + CanGetSpeedConfig(BOOT_COM_CAN_BAUDRATE, &prescaler, &bitTiming); + + /* CAN register init */ + CAN_DeInit(CAN); + CAN_StructInit(&CAN_InitStructure); + /* CAN cell init */ + CAN_InitStructure.CAN_TTCM = DISABLE; + CAN_InitStructure.CAN_ABOM = DISABLE; + CAN_InitStructure.CAN_AWUM = DISABLE; + CAN_InitStructure.CAN_NART = DISABLE; + CAN_InitStructure.CAN_RFLM = DISABLE; + CAN_InitStructure.CAN_TXFP = DISABLE; + CAN_InitStructure.CAN_Mode = CAN_Mode_Normal; + CAN_InitStructure.CAN_SJW = CAN_SJW_1tq; + CAN_InitStructure.CAN_BS1 = bitTiming.tseg1 - 1; + CAN_InitStructure.CAN_BS2 = bitTiming.tseg2 - 1; + CAN_InitStructure.CAN_Prescaler = prescaler; + CAN_Init(CAN, &CAN_InitStructure); + /* CAN filter init - receive all messages */ + CAN_FilterInitStructure.CAN_FilterNumber = 0; + CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdMask; + CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit; + CAN_FilterInitStructure.CAN_FilterIdHigh = 0x0000; + CAN_FilterInitStructure.CAN_FilterIdLow = 0x0000; + CAN_FilterInitStructure.CAN_FilterMaskIdHigh = 0x0000; + CAN_FilterInitStructure.CAN_FilterMaskIdLow = 0x0000; + CAN_FilterInitStructure.CAN_FilterFIFOAssignment = 0; + CAN_FilterInitStructure.CAN_FilterActivation = ENABLE; + CAN_FilterInit(&CAN_FilterInitStructure); +} /*** end of BootComCanInit ***/ + + +/************************************************************************************//** +** \brief Receives the CONNECT request from the host, which indicates that the +** bootloader should be activated and, if so, activates it. +** \return none. +** +****************************************************************************************/ +static void BootComCanCheckActivationRequest(void) +{ + CanRxMsg RxMessage; + + /* check if a new message was received */ + if (CAN_MessagePending(CAN, CAN_FIFO0) > 0) + { + /* receive the message */ + CAN_Receive(CAN, CAN_FIFO0, &RxMessage); + if (RxMessage.StdId == BOOT_COM_CAN_RX_MSG_ID) + { + /* check if this was an XCP CONNECT command */ + if ((RxMessage.Data[0] == 0xff) && (RxMessage.Data[1] == 0x00)) + { + /* connection request received so start the bootloader */ + BootActivate(); + } + } + } +} /*** end of BootComCanCheckActivationRequest ***/ +#endif /* BOOT_COM_CAN_ENABLE > 0 */ + + +/*********************************** end of boot.c *************************************/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/boot.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/boot.h new file mode 100644 index 00000000..0da7ab29 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/boot.h @@ -0,0 +1,40 @@ +/************************************************************************************//** +* \file Demo\ARMCM0_STM32F0_Nucleo_F091RC_GCC\Prog\boot.h +* \brief Demo program bootloader interface header file. +* \ingroup Prog_ARMCM0_STM32F0_Nucleo_F091RC_GCC +* \internal +*---------------------------------------------------------------------------------------- +* C O P Y R I G H T +*---------------------------------------------------------------------------------------- +* Copyright (c) 2016 by Feaser http://www.feaser.com All rights reserved +* +*---------------------------------------------------------------------------------------- +* L I C E N S E +*---------------------------------------------------------------------------------------- +* This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +* modify it under the terms of the GNU General Public License as published by the Free +* Software Foundation, either version 3 of the License, or (at your option) any later +* version. +* +* OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +* PURPOSE. See the GNU General Public License for more details. +* +* You have received a copy of the GNU General Public License along with OpenBLT. It +* should be located in ".\Doc\license.html". If not, contact Feaser to obtain a copy. +* +* \endinternal +****************************************************************************************/ +#ifndef BOOT_H +#define BOOT_H + +/**************************************************************************************** +* Function prototypes +****************************************************************************************/ +void BootComInit(void); +void BootComCheckActivationRequest(void); +void BootActivate(void); + + +#endif /* BOOT_H */ +/*********************************** end of boot.h *************************************/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/cfg/STM32F091x.svd b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/cfg/STM32F091x.svd new file mode 100644 index 00000000..2b84ea3d --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/cfg/STM32F091x.svd @@ -0,0 +1,31643 @@ + + + STM32F091x + 1.0 + STM32F091x + + + 8 + + 32 + + 0x20 + 0x0 + 0xFFFFFFFF + + + CRC + cyclic redundancy check calculation + unit + CRC + 0x40023000 + + 0x0 + 0x400 + registers + + + + DR + DR + Data register + 0x0 + 0x20 + read-write + 0xFFFFFFFF + + + DR + Data register bits + 0 + 32 + + + + + IDR + IDR + Independent data register + 0x4 + 0x20 + read-write + 0x00000000 + + + IDR + General-purpose 8-bit data register + bits + 0 + 8 + + + + + CR + CR + Control register + 0x8 + 0x20 + read-write + 0x00000000 + + + RESET + reset bit + 0 + 1 + + + REV_IN + Reverse input data + 5 + 2 + + + REV_OUT + Reverse output data + 7 + 1 + + + + + INIT + INIT + Initial CRC value + 0xC + 0x20 + read-write + 0xFFFFFFFF + + + INIT + Programmable initial CRC + value + 0 + 32 + + + + + + + GPIOF + General-purpose I/Os + GPIO + 0x48001400 + + 0x0 + 0x400 + registers + + + + MODER + MODER + GPIO port mode register + 0x0 + 0x20 + read-write + 0x00000000 + + + MODER15 + Port x configuration bits (y = + 0..15) + 30 + 2 + + + MODER14 + Port x configuration bits (y = + 0..15) + 28 + 2 + + + MODER13 + Port x configuration bits (y = + 0..15) + 26 + 2 + + + MODER12 + Port x configuration bits (y = + 0..15) + 24 + 2 + + + MODER11 + Port x configuration bits (y = + 0..15) + 22 + 2 + + + MODER10 + Port x configuration bits (y = + 0..15) + 20 + 2 + + + MODER9 + Port x configuration bits (y = + 0..15) + 18 + 2 + + + MODER8 + Port x configuration bits (y = + 0..15) + 16 + 2 + + + MODER7 + Port x configuration bits (y = + 0..15) + 14 + 2 + + + MODER6 + Port x configuration bits (y = + 0..15) + 12 + 2 + + + MODER5 + Port x configuration bits (y = + 0..15) + 10 + 2 + + + MODER4 + Port x configuration bits (y = + 0..15) + 8 + 2 + + + MODER3 + Port x configuration bits (y = + 0..15) + 6 + 2 + + + MODER2 + Port x configuration bits (y = + 0..15) + 4 + 2 + + + MODER1 + Port x configuration bits (y = + 0..15) + 2 + 2 + + + MODER0 + Port x configuration bits (y = + 0..15) + 0 + 2 + + + + + OTYPER + OTYPER + GPIO port output type register + 0x4 + 0x20 + read-write + 0x00000000 + + + OT15 + Port x configuration bit + 15 + 15 + 1 + + + OT14 + Port x configuration bit + 14 + 14 + 1 + + + OT13 + Port x configuration bit + 13 + 13 + 1 + + + OT12 + Port x configuration bit + 12 + 12 + 1 + + + OT11 + Port x configuration bit + 11 + 11 + 1 + + + OT10 + Port x configuration bit + 10 + 10 + 1 + + + OT9 + Port x configuration bit 9 + 9 + 1 + + + OT8 + Port x configuration bit 8 + 8 + 1 + + + OT7 + Port x configuration bit 7 + 7 + 1 + + + OT6 + Port x configuration bit 6 + 6 + 1 + + + OT5 + Port x configuration bit 5 + 5 + 1 + + + OT4 + Port x configuration bit 4 + 4 + 1 + + + OT3 + Port x configuration bit 3 + 3 + 1 + + + OT2 + Port x configuration bit 2 + 2 + 1 + + + OT1 + Port x configuration bit 1 + 1 + 1 + + + OT0 + Port x configuration bit 0 + 0 + 1 + + + + + OSPEEDR + OSPEEDR + GPIO port output speed + register + 0x8 + 0x20 + read-write + 0x00000000 + + + OSPEEDR15 + Port x configuration bits (y = + 0..15) + 30 + 2 + + + OSPEEDR14 + Port x configuration bits (y = + 0..15) + 28 + 2 + + + OSPEEDR13 + Port x configuration bits (y = + 0..15) + 26 + 2 + + + OSPEEDR12 + Port x configuration bits (y = + 0..15) + 24 + 2 + + + OSPEEDR11 + Port x configuration bits (y = + 0..15) + 22 + 2 + + + OSPEEDR10 + Port x configuration bits (y = + 0..15) + 20 + 2 + + + OSPEEDR9 + Port x configuration bits (y = + 0..15) + 18 + 2 + + + OSPEEDR8 + Port x configuration bits (y = + 0..15) + 16 + 2 + + + OSPEEDR7 + Port x configuration bits (y = + 0..15) + 14 + 2 + + + OSPEEDR6 + Port x configuration bits (y = + 0..15) + 12 + 2 + + + OSPEEDR5 + Port x configuration bits (y = + 0..15) + 10 + 2 + + + OSPEEDR4 + Port x configuration bits (y = + 0..15) + 8 + 2 + + + OSPEEDR3 + Port x configuration bits (y = + 0..15) + 6 + 2 + + + OSPEEDR2 + Port x configuration bits (y = + 0..15) + 4 + 2 + + + OSPEEDR1 + Port x configuration bits (y = + 0..15) + 2 + 2 + + + OSPEEDR0 + Port x configuration bits (y = + 0..15) + 0 + 2 + + + + + PUPDR + PUPDR + GPIO port pull-up/pull-down + register + 0xC + 0x20 + read-write + 0x00000000 + + + PUPDR15 + Port x configuration bits (y = + 0..15) + 30 + 2 + + + PUPDR14 + Port x configuration bits (y = + 0..15) + 28 + 2 + + + PUPDR13 + Port x configuration bits (y = + 0..15) + 26 + 2 + + + PUPDR12 + Port x configuration bits (y = + 0..15) + 24 + 2 + + + PUPDR11 + Port x configuration bits (y = + 0..15) + 22 + 2 + + + PUPDR10 + Port x configuration bits (y = + 0..15) + 20 + 2 + + + PUPDR9 + Port x configuration bits (y = + 0..15) + 18 + 2 + + + PUPDR8 + Port x configuration bits (y = + 0..15) + 16 + 2 + + + PUPDR7 + Port x configuration bits (y = + 0..15) + 14 + 2 + + + PUPDR6 + Port x configuration bits (y = + 0..15) + 12 + 2 + + + PUPDR5 + Port x configuration bits (y = + 0..15) + 10 + 2 + + + PUPDR4 + Port x configuration bits (y = + 0..15) + 8 + 2 + + + PUPDR3 + Port x configuration bits (y = + 0..15) + 6 + 2 + + + PUPDR2 + Port x configuration bits (y = + 0..15) + 4 + 2 + + + PUPDR1 + Port x configuration bits (y = + 0..15) + 2 + 2 + + + PUPDR0 + Port x configuration bits (y = + 0..15) + 0 + 2 + + + + + IDR + IDR + GPIO port input data register + 0x10 + 0x20 + read-only + 0x00000000 + + + IDR15 + Port input data (y = + 0..15) + 15 + 1 + + + IDR14 + Port input data (y = + 0..15) + 14 + 1 + + + IDR13 + Port input data (y = + 0..15) + 13 + 1 + + + IDR12 + Port input data (y = + 0..15) + 12 + 1 + + + IDR11 + Port input data (y = + 0..15) + 11 + 1 + + + IDR10 + Port input data (y = + 0..15) + 10 + 1 + + + IDR9 + Port input data (y = + 0..15) + 9 + 1 + + + IDR8 + Port input data (y = + 0..15) + 8 + 1 + + + IDR7 + Port input data (y = + 0..15) + 7 + 1 + + + IDR6 + Port input data (y = + 0..15) + 6 + 1 + + + IDR5 + Port input data (y = + 0..15) + 5 + 1 + + + IDR4 + Port input data (y = + 0..15) + 4 + 1 + + + IDR3 + Port input data (y = + 0..15) + 3 + 1 + + + IDR2 + Port input data (y = + 0..15) + 2 + 1 + + + IDR1 + Port input data (y = + 0..15) + 1 + 1 + + + IDR0 + Port input data (y = + 0..15) + 0 + 1 + + + + + ODR + ODR + GPIO port output data register + 0x14 + 0x20 + read-write + 0x00000000 + + + ODR15 + Port output data (y = + 0..15) + 15 + 1 + + + ODR14 + Port output data (y = + 0..15) + 14 + 1 + + + ODR13 + Port output data (y = + 0..15) + 13 + 1 + + + ODR12 + Port output data (y = + 0..15) + 12 + 1 + + + ODR11 + Port output data (y = + 0..15) + 11 + 1 + + + ODR10 + Port output data (y = + 0..15) + 10 + 1 + + + ODR9 + Port output data (y = + 0..15) + 9 + 1 + + + ODR8 + Port output data (y = + 0..15) + 8 + 1 + + + ODR7 + Port output data (y = + 0..15) + 7 + 1 + + + ODR6 + Port output data (y = + 0..15) + 6 + 1 + + + ODR5 + Port output data (y = + 0..15) + 5 + 1 + + + ODR4 + Port output data (y = + 0..15) + 4 + 1 + + + ODR3 + Port output data (y = + 0..15) + 3 + 1 + + + ODR2 + Port output data (y = + 0..15) + 2 + 1 + + + ODR1 + Port output data (y = + 0..15) + 1 + 1 + + + ODR0 + Port output data (y = + 0..15) + 0 + 1 + + + + + BSRR + BSRR + GPIO port bit set/reset + register + 0x18 + 0x20 + write-only + 0x00000000 + + + BR15 + Port x reset bit y (y = + 0..15) + 31 + 1 + + + BR14 + Port x reset bit y (y = + 0..15) + 30 + 1 + + + BR13 + Port x reset bit y (y = + 0..15) + 29 + 1 + + + BR12 + Port x reset bit y (y = + 0..15) + 28 + 1 + + + BR11 + Port x reset bit y (y = + 0..15) + 27 + 1 + + + BR10 + Port x reset bit y (y = + 0..15) + 26 + 1 + + + BR9 + Port x reset bit y (y = + 0..15) + 25 + 1 + + + BR8 + Port x reset bit y (y = + 0..15) + 24 + 1 + + + BR7 + Port x reset bit y (y = + 0..15) + 23 + 1 + + + BR6 + Port x reset bit y (y = + 0..15) + 22 + 1 + + + BR5 + Port x reset bit y (y = + 0..15) + 21 + 1 + + + BR4 + Port x reset bit y (y = + 0..15) + 20 + 1 + + + BR3 + Port x reset bit y (y = + 0..15) + 19 + 1 + + + BR2 + Port x reset bit y (y = + 0..15) + 18 + 1 + + + BR1 + Port x reset bit y (y = + 0..15) + 17 + 1 + + + BR0 + Port x set bit y (y= + 0..15) + 16 + 1 + + + BS15 + Port x set bit y (y= + 0..15) + 15 + 1 + + + BS14 + Port x set bit y (y= + 0..15) + 14 + 1 + + + BS13 + Port x set bit y (y= + 0..15) + 13 + 1 + + + BS12 + Port x set bit y (y= + 0..15) + 12 + 1 + + + BS11 + Port x set bit y (y= + 0..15) + 11 + 1 + + + BS10 + Port x set bit y (y= + 0..15) + 10 + 1 + + + BS9 + Port x set bit y (y= + 0..15) + 9 + 1 + + + BS8 + Port x set bit y (y= + 0..15) + 8 + 1 + + + BS7 + Port x set bit y (y= + 0..15) + 7 + 1 + + + BS6 + Port x set bit y (y= + 0..15) + 6 + 1 + + + BS5 + Port x set bit y (y= + 0..15) + 5 + 1 + + + BS4 + Port x set bit y (y= + 0..15) + 4 + 1 + + + BS3 + Port x set bit y (y= + 0..15) + 3 + 1 + + + BS2 + Port x set bit y (y= + 0..15) + 2 + 1 + + + BS1 + Port x set bit y (y= + 0..15) + 1 + 1 + + + BS0 + Port x set bit y (y= + 0..15) + 0 + 1 + + + + + LCKR + LCKR + GPIO port configuration lock + register + 0x1C + 0x20 + read-write + 0x00000000 + + + LCKK + Port x lock bit y + 16 + 1 + + + LCK15 + Port x lock bit y (y= + 0..15) + 15 + 1 + + + LCK14 + Port x lock bit y (y= + 0..15) + 14 + 1 + + + LCK13 + Port x lock bit y (y= + 0..15) + 13 + 1 + + + LCK12 + Port x lock bit y (y= + 0..15) + 12 + 1 + + + LCK11 + Port x lock bit y (y= + 0..15) + 11 + 1 + + + LCK10 + Port x lock bit y (y= + 0..15) + 10 + 1 + + + LCK9 + Port x lock bit y (y= + 0..15) + 9 + 1 + + + LCK8 + Port x lock bit y (y= + 0..15) + 8 + 1 + + + LCK7 + Port x lock bit y (y= + 0..15) + 7 + 1 + + + LCK6 + Port x lock bit y (y= + 0..15) + 6 + 1 + + + LCK5 + Port x lock bit y (y= + 0..15) + 5 + 1 + + + LCK4 + Port x lock bit y (y= + 0..15) + 4 + 1 + + + LCK3 + Port x lock bit y (y= + 0..15) + 3 + 1 + + + LCK2 + Port x lock bit y (y= + 0..15) + 2 + 1 + + + LCK1 + Port x lock bit y (y= + 0..15) + 1 + 1 + + + LCK0 + Port x lock bit y (y= + 0..15) + 0 + 1 + + + + + AFRL + AFRL + GPIO alternate function low + register + 0x20 + 0x20 + read-write + 0x00000000 + + + AFRL7 + Alternate function selection for port x + bit y (y = 0..7) + 28 + 4 + + + AFRL6 + Alternate function selection for port x + bit y (y = 0..7) + 24 + 4 + + + AFRL5 + Alternate function selection for port x + bit y (y = 0..7) + 20 + 4 + + + AFRL4 + Alternate function selection for port x + bit y (y = 0..7) + 16 + 4 + + + AFRL3 + Alternate function selection for port x + bit y (y = 0..7) + 12 + 4 + + + AFRL2 + Alternate function selection for port x + bit y (y = 0..7) + 8 + 4 + + + AFRL1 + Alternate function selection for port x + bit y (y = 0..7) + 4 + 4 + + + AFRL0 + Alternate function selection for port x + bit y (y = 0..7) + 0 + 4 + + + + + AFRH + AFRH + GPIO alternate function high + register + 0x24 + 0x20 + read-write + 0x00000000 + + + AFRH15 + Alternate function selection for port x + bit y (y = 8..15) + 28 + 4 + + + AFRH14 + Alternate function selection for port x + bit y (y = 8..15) + 24 + 4 + + + AFRH13 + Alternate function selection for port x + bit y (y = 8..15) + 20 + 4 + + + AFRH12 + Alternate function selection for port x + bit y (y = 8..15) + 16 + 4 + + + AFRH11 + Alternate function selection for port x + bit y (y = 8..15) + 12 + 4 + + + AFRH10 + Alternate function selection for port x + bit y (y = 8..15) + 8 + 4 + + + AFRH9 + Alternate function selection for port x + bit y (y = 8..15) + 4 + 4 + + + AFRH8 + Alternate function selection for port x + bit y (y = 8..15) + 0 + 4 + + + + + BRR + BRR + Port bit reset register + 0x28 + 0x20 + write-only + 0x00000000 + + + BR0 + Port x Reset bit y + 0 + 1 + + + BR1 + Port x Reset bit y + 1 + 1 + + + BR2 + Port x Reset bit y + 2 + 1 + + + BR3 + Port x Reset bit y + 3 + 1 + + + BR4 + Port x Reset bit y + 4 + 1 + + + BR5 + Port x Reset bit y + 5 + 1 + + + BR6 + Port x Reset bit y + 6 + 1 + + + BR7 + Port x Reset bit y + 7 + 1 + + + BR8 + Port x Reset bit y + 8 + 1 + + + BR9 + Port x Reset bit y + 9 + 1 + + + BR10 + Port x Reset bit y + 10 + 1 + + + BR11 + Port x Reset bit y + 11 + 1 + + + BR12 + Port x Reset bit y + 12 + 1 + + + BR13 + Port x Reset bit y + 13 + 1 + + + BR14 + Port x Reset bit y + 14 + 1 + + + BR15 + Port x Reset bit y + 15 + 1 + + + + + + + GPIOD + 0x48000C00 + + + GPIOC + 0x48000800 + + + GPIOB + 0x48000400 + + + GPIOE + 0x48001000 + + + GPIOA + General-purpose I/Os + GPIO + 0x48000000 + + 0x0 + 0x400 + registers + + + + MODER + MODER + GPIO port mode register + 0x0 + 0x20 + read-write + 0x28000000 + + + MODER15 + Port x configuration bits (y = + 0..15) + 30 + 2 + + + MODER14 + Port x configuration bits (y = + 0..15) + 28 + 2 + + + MODER13 + Port x configuration bits (y = + 0..15) + 26 + 2 + + + MODER12 + Port x configuration bits (y = + 0..15) + 24 + 2 + + + MODER11 + Port x configuration bits (y = + 0..15) + 22 + 2 + + + MODER10 + Port x configuration bits (y = + 0..15) + 20 + 2 + + + MODER9 + Port x configuration bits (y = + 0..15) + 18 + 2 + + + MODER8 + Port x configuration bits (y = + 0..15) + 16 + 2 + + + MODER7 + Port x configuration bits (y = + 0..15) + 14 + 2 + + + MODER6 + Port x configuration bits (y = + 0..15) + 12 + 2 + + + MODER5 + Port x configuration bits (y = + 0..15) + 10 + 2 + + + MODER4 + Port x configuration bits (y = + 0..15) + 8 + 2 + + + MODER3 + Port x configuration bits (y = + 0..15) + 6 + 2 + + + MODER2 + Port x configuration bits (y = + 0..15) + 4 + 2 + + + MODER1 + Port x configuration bits (y = + 0..15) + 2 + 2 + + + MODER0 + Port x configuration bits (y = + 0..15) + 0 + 2 + + + + + OTYPER + OTYPER + GPIO port output type register + 0x4 + 0x20 + read-write + 0x00000000 + + + OT15 + Port x configuration bits (y = + 0..15) + 15 + 1 + + + OT14 + Port x configuration bits (y = + 0..15) + 14 + 1 + + + OT13 + Port x configuration bits (y = + 0..15) + 13 + 1 + + + OT12 + Port x configuration bits (y = + 0..15) + 12 + 1 + + + OT11 + Port x configuration bits (y = + 0..15) + 11 + 1 + + + OT10 + Port x configuration bits (y = + 0..15) + 10 + 1 + + + OT9 + Port x configuration bits (y = + 0..15) + 9 + 1 + + + OT8 + Port x configuration bits (y = + 0..15) + 8 + 1 + + + OT7 + Port x configuration bits (y = + 0..15) + 7 + 1 + + + OT6 + Port x configuration bits (y = + 0..15) + 6 + 1 + + + OT5 + Port x configuration bits (y = + 0..15) + 5 + 1 + + + OT4 + Port x configuration bits (y = + 0..15) + 4 + 1 + + + OT3 + Port x configuration bits (y = + 0..15) + 3 + 1 + + + OT2 + Port x configuration bits (y = + 0..15) + 2 + 1 + + + OT1 + Port x configuration bits (y = + 0..15) + 1 + 1 + + + OT0 + Port x configuration bits (y = + 0..15) + 0 + 1 + + + + + OSPEEDR + OSPEEDR + GPIO port output speed + register + 0x8 + 0x20 + read-write + 0x00000000 + + + OSPEEDR15 + Port x configuration bits (y = + 0..15) + 30 + 2 + + + OSPEEDR14 + Port x configuration bits (y = + 0..15) + 28 + 2 + + + OSPEEDR13 + Port x configuration bits (y = + 0..15) + 26 + 2 + + + OSPEEDR12 + Port x configuration bits (y = + 0..15) + 24 + 2 + + + OSPEEDR11 + Port x configuration bits (y = + 0..15) + 22 + 2 + + + OSPEEDR10 + Port x configuration bits (y = + 0..15) + 20 + 2 + + + OSPEEDR9 + Port x configuration bits (y = + 0..15) + 18 + 2 + + + OSPEEDR8 + Port x configuration bits (y = + 0..15) + 16 + 2 + + + OSPEEDR7 + Port x configuration bits (y = + 0..15) + 14 + 2 + + + OSPEEDR6 + Port x configuration bits (y = + 0..15) + 12 + 2 + + + OSPEEDR5 + Port x configuration bits (y = + 0..15) + 10 + 2 + + + OSPEEDR4 + Port x configuration bits (y = + 0..15) + 8 + 2 + + + OSPEEDR3 + Port x configuration bits (y = + 0..15) + 6 + 2 + + + OSPEEDR2 + Port x configuration bits (y = + 0..15) + 4 + 2 + + + OSPEEDR1 + Port x configuration bits (y = + 0..15) + 2 + 2 + + + OSPEEDR0 + Port x configuration bits (y = + 0..15) + 0 + 2 + + + + + PUPDR + PUPDR + GPIO port pull-up/pull-down + register + 0xC + 0x20 + read-write + 0x24000000 + + + PUPDR15 + Port x configuration bits (y = + 0..15) + 30 + 2 + + + PUPDR14 + Port x configuration bits (y = + 0..15) + 28 + 2 + + + PUPDR13 + Port x configuration bits (y = + 0..15) + 26 + 2 + + + PUPDR12 + Port x configuration bits (y = + 0..15) + 24 + 2 + + + PUPDR11 + Port x configuration bits (y = + 0..15) + 22 + 2 + + + PUPDR10 + Port x configuration bits (y = + 0..15) + 20 + 2 + + + PUPDR9 + Port x configuration bits (y = + 0..15) + 18 + 2 + + + PUPDR8 + Port x configuration bits (y = + 0..15) + 16 + 2 + + + PUPDR7 + Port x configuration bits (y = + 0..15) + 14 + 2 + + + PUPDR6 + Port x configuration bits (y = + 0..15) + 12 + 2 + + + PUPDR5 + Port x configuration bits (y = + 0..15) + 10 + 2 + + + PUPDR4 + Port x configuration bits (y = + 0..15) + 8 + 2 + + + PUPDR3 + Port x configuration bits (y = + 0..15) + 6 + 2 + + + PUPDR2 + Port x configuration bits (y = + 0..15) + 4 + 2 + + + PUPDR1 + Port x configuration bits (y = + 0..15) + 2 + 2 + + + PUPDR0 + Port x configuration bits (y = + 0..15) + 0 + 2 + + + + + IDR + IDR + GPIO port input data register + 0x10 + 0x20 + read-only + 0x00000000 + + + IDR15 + Port input data (y = + 0..15) + 15 + 1 + + + IDR14 + Port input data (y = + 0..15) + 14 + 1 + + + IDR13 + Port input data (y = + 0..15) + 13 + 1 + + + IDR12 + Port input data (y = + 0..15) + 12 + 1 + + + IDR11 + Port input data (y = + 0..15) + 11 + 1 + + + IDR10 + Port input data (y = + 0..15) + 10 + 1 + + + IDR9 + Port input data (y = + 0..15) + 9 + 1 + + + IDR8 + Port input data (y = + 0..15) + 8 + 1 + + + IDR7 + Port input data (y = + 0..15) + 7 + 1 + + + IDR6 + Port input data (y = + 0..15) + 6 + 1 + + + IDR5 + Port input data (y = + 0..15) + 5 + 1 + + + IDR4 + Port input data (y = + 0..15) + 4 + 1 + + + IDR3 + Port input data (y = + 0..15) + 3 + 1 + + + IDR2 + Port input data (y = + 0..15) + 2 + 1 + + + IDR1 + Port input data (y = + 0..15) + 1 + 1 + + + IDR0 + Port input data (y = + 0..15) + 0 + 1 + + + + + ODR + ODR + GPIO port output data register + 0x14 + 0x20 + read-write + 0x00000000 + + + ODR15 + Port output data (y = + 0..15) + 15 + 1 + + + ODR14 + Port output data (y = + 0..15) + 14 + 1 + + + ODR13 + Port output data (y = + 0..15) + 13 + 1 + + + ODR12 + Port output data (y = + 0..15) + 12 + 1 + + + ODR11 + Port output data (y = + 0..15) + 11 + 1 + + + ODR10 + Port output data (y = + 0..15) + 10 + 1 + + + ODR9 + Port output data (y = + 0..15) + 9 + 1 + + + ODR8 + Port output data (y = + 0..15) + 8 + 1 + + + ODR7 + Port output data (y = + 0..15) + 7 + 1 + + + ODR6 + Port output data (y = + 0..15) + 6 + 1 + + + ODR5 + Port output data (y = + 0..15) + 5 + 1 + + + ODR4 + Port output data (y = + 0..15) + 4 + 1 + + + ODR3 + Port output data (y = + 0..15) + 3 + 1 + + + ODR2 + Port output data (y = + 0..15) + 2 + 1 + + + ODR1 + Port output data (y = + 0..15) + 1 + 1 + + + ODR0 + Port output data (y = + 0..15) + 0 + 1 + + + + + BSRR + BSRR + GPIO port bit set/reset + register + 0x18 + 0x20 + write-only + 0x00000000 + + + BR15 + Port x reset bit y (y = + 0..15) + 31 + 1 + + + BR14 + Port x reset bit y (y = + 0..15) + 30 + 1 + + + BR13 + Port x reset bit y (y = + 0..15) + 29 + 1 + + + BR12 + Port x reset bit y (y = + 0..15) + 28 + 1 + + + BR11 + Port x reset bit y (y = + 0..15) + 27 + 1 + + + BR10 + Port x reset bit y (y = + 0..15) + 26 + 1 + + + BR9 + Port x reset bit y (y = + 0..15) + 25 + 1 + + + BR8 + Port x reset bit y (y = + 0..15) + 24 + 1 + + + BR7 + Port x reset bit y (y = + 0..15) + 23 + 1 + + + BR6 + Port x reset bit y (y = + 0..15) + 22 + 1 + + + BR5 + Port x reset bit y (y = + 0..15) + 21 + 1 + + + BR4 + Port x reset bit y (y = + 0..15) + 20 + 1 + + + BR3 + Port x reset bit y (y = + 0..15) + 19 + 1 + + + BR2 + Port x reset bit y (y = + 0..15) + 18 + 1 + + + BR1 + Port x reset bit y (y = + 0..15) + 17 + 1 + + + BR0 + Port x set bit y (y= + 0..15) + 16 + 1 + + + BS15 + Port x set bit y (y= + 0..15) + 15 + 1 + + + BS14 + Port x set bit y (y= + 0..15) + 14 + 1 + + + BS13 + Port x set bit y (y= + 0..15) + 13 + 1 + + + BS12 + Port x set bit y (y= + 0..15) + 12 + 1 + + + BS11 + Port x set bit y (y= + 0..15) + 11 + 1 + + + BS10 + Port x set bit y (y= + 0..15) + 10 + 1 + + + BS9 + Port x set bit y (y= + 0..15) + 9 + 1 + + + BS8 + Port x set bit y (y= + 0..15) + 8 + 1 + + + BS7 + Port x set bit y (y= + 0..15) + 7 + 1 + + + BS6 + Port x set bit y (y= + 0..15) + 6 + 1 + + + BS5 + Port x set bit y (y= + 0..15) + 5 + 1 + + + BS4 + Port x set bit y (y= + 0..15) + 4 + 1 + + + BS3 + Port x set bit y (y= + 0..15) + 3 + 1 + + + BS2 + Port x set bit y (y= + 0..15) + 2 + 1 + + + BS1 + Port x set bit y (y= + 0..15) + 1 + 1 + + + BS0 + Port x set bit y (y= + 0..15) + 0 + 1 + + + + + LCKR + LCKR + GPIO port configuration lock + register + 0x1C + 0x20 + read-write + 0x00000000 + + + LCKK + Port x lock bit y (y= + 0..15) + 16 + 1 + + + LCK15 + Port x lock bit y (y= + 0..15) + 15 + 1 + + + LCK14 + Port x lock bit y (y= + 0..15) + 14 + 1 + + + LCK13 + Port x lock bit y (y= + 0..15) + 13 + 1 + + + LCK12 + Port x lock bit y (y= + 0..15) + 12 + 1 + + + LCK11 + Port x lock bit y (y= + 0..15) + 11 + 1 + + + LCK10 + Port x lock bit y (y= + 0..15) + 10 + 1 + + + LCK9 + Port x lock bit y (y= + 0..15) + 9 + 1 + + + LCK8 + Port x lock bit y (y= + 0..15) + 8 + 1 + + + LCK7 + Port x lock bit y (y= + 0..15) + 7 + 1 + + + LCK6 + Port x lock bit y (y= + 0..15) + 6 + 1 + + + LCK5 + Port x lock bit y (y= + 0..15) + 5 + 1 + + + LCK4 + Port x lock bit y (y= + 0..15) + 4 + 1 + + + LCK3 + Port x lock bit y (y= + 0..15) + 3 + 1 + + + LCK2 + Port x lock bit y (y= + 0..15) + 2 + 1 + + + LCK1 + Port x lock bit y (y= + 0..15) + 1 + 1 + + + LCK0 + Port x lock bit y (y= + 0..15) + 0 + 1 + + + + + AFRL + AFRL + GPIO alternate function low + register + 0x20 + 0x20 + read-write + 0x00000000 + + + AFRL7 + Alternate function selection for port x + bit y (y = 0..7) + 28 + 4 + + + AFRL6 + Alternate function selection for port x + bit y (y = 0..7) + 24 + 4 + + + AFRL5 + Alternate function selection for port x + bit y (y = 0..7) + 20 + 4 + + + AFRL4 + Alternate function selection for port x + bit y (y = 0..7) + 16 + 4 + + + AFRL3 + Alternate function selection for port x + bit y (y = 0..7) + 12 + 4 + + + AFRL2 + Alternate function selection for port x + bit y (y = 0..7) + 8 + 4 + + + AFRL1 + Alternate function selection for port x + bit y (y = 0..7) + 4 + 4 + + + AFRL0 + Alternate function selection for port x + bit y (y = 0..7) + 0 + 4 + + + + + AFRH + AFRH + GPIO alternate function high + register + 0x24 + 0x20 + read-write + 0x00000000 + + + AFRH15 + Alternate function selection for port x + bit y (y = 8..15) + 28 + 4 + + + AFRH14 + Alternate function selection for port x + bit y (y = 8..15) + 24 + 4 + + + AFRH13 + Alternate function selection for port x + bit y (y = 8..15) + 20 + 4 + + + AFRH12 + Alternate function selection for port x + bit y (y = 8..15) + 16 + 4 + + + AFRH11 + Alternate function selection for port x + bit y (y = 8..15) + 12 + 4 + + + AFRH10 + Alternate function selection for port x + bit y (y = 8..15) + 8 + 4 + + + AFRH9 + Alternate function selection for port x + bit y (y = 8..15) + 4 + 4 + + + AFRH8 + Alternate function selection for port x + bit y (y = 8..15) + 0 + 4 + + + + + BRR + BRR + Port bit reset register + 0x28 + 0x20 + write-only + 0x00000000 + + + BR0 + Port x Reset bit y + 0 + 1 + + + BR1 + Port x Reset bit y + 1 + 1 + + + BR2 + Port x Reset bit y + 2 + 1 + + + BR3 + Port x Reset bit y + 3 + 1 + + + BR4 + Port x Reset bit y + 4 + 1 + + + BR5 + Port x Reset bit y + 5 + 1 + + + BR6 + Port x Reset bit y + 6 + 1 + + + BR7 + Port x Reset bit y + 7 + 1 + + + BR8 + Port x Reset bit y + 8 + 1 + + + BR9 + Port x Reset bit y + 9 + 1 + + + BR10 + Port x Reset bit y + 10 + 1 + + + BR11 + Port x Reset bit y + 11 + 1 + + + BR12 + Port x Reset bit y + 12 + 1 + + + BR13 + Port x Reset bit y + 13 + 1 + + + BR14 + Port x Reset bit y + 14 + 1 + + + BR15 + Port x Reset bit y + 15 + 1 + + + + + + + SPI1 + Serial peripheral interface + SPI + 0x40013000 + + 0x0 + 0x400 + registers + + + SPI1 + SPI1_global_interrupt + 25 + + + + CR1 + CR1 + control register 1 + 0x0 + 0x20 + read-write + 0x0000 + + + BIDIMODE + Bidirectional data mode + enable + 15 + 1 + + + BIDIOE + Output enable in bidirectional + mode + 14 + 1 + + + CRCEN + Hardware CRC calculation + enable + 13 + 1 + + + CRCNEXT + CRC transfer next + 12 + 1 + + + DFF + Data frame format + 11 + 1 + + + RXONLY + Receive only + 10 + 1 + + + SSM + Software slave management + 9 + 1 + + + SSI + Internal slave select + 8 + 1 + + + LSBFIRST + Frame format + 7 + 1 + + + SPE + SPI enable + 6 + 1 + + + BR + Baud rate control + 3 + 3 + + + MSTR + Master selection + 2 + 1 + + + CPOL + Clock polarity + 1 + 1 + + + CPHA + Clock phase + 0 + 1 + + + + + CR2 + CR2 + control register 2 + 0x4 + 0x20 + read-write + 0x0000 + + + RXDMAEN + Rx buffer DMA enable + 0 + 1 + + + TXDMAEN + Tx buffer DMA enable + 1 + 1 + + + SSOE + SS output enable + 2 + 1 + + + NSSP + NSS pulse management + 3 + 1 + + + FRF + Frame format + 4 + 1 + + + ERRIE + Error interrupt enable + 5 + 1 + + + RXNEIE + RX buffer not empty interrupt + enable + 6 + 1 + + + TXEIE + Tx buffer empty interrupt + enable + 7 + 1 + + + DS + Data size + 8 + 4 + + + FRXTH + FIFO reception threshold + 12 + 1 + + + LDMA_RX + Last DMA transfer for + reception + 13 + 1 + + + LDMA_TX + Last DMA transfer for + transmission + 14 + 1 + + + + + SR + SR + status register + 0x8 + 0x20 + 0x0002 + + + RXNE + Receive buffer not empty + 0 + 1 + read-only + + + TXE + Transmit buffer empty + 1 + 1 + read-only + + + CHSIDE + Channel side + 2 + 1 + read-only + + + UDR + Underrun flag + 3 + 1 + read-only + + + CRCERR + CRC error flag + 4 + 1 + read-write + + + MODF + Mode fault + 5 + 1 + read-only + + + OVR + Overrun flag + 6 + 1 + read-only + + + BSY + Busy flag + 7 + 1 + read-only + + + TIFRFE + TI frame format error + 8 + 1 + read-only + + + FRLVL + FIFO reception level + 9 + 2 + read-only + + + FTLVL + FIFO transmission level + 11 + 2 + read-only + + + + + DR + DR + data register + 0xC + 0x20 + read-write + 0x0000 + + + DR + Data register + 0 + 16 + + + + + CRCPR + CRCPR + CRC polynomial register + 0x10 + 0x20 + read-write + 0x0007 + + + CRCPOLY + CRC polynomial register + 0 + 16 + + + + + RXCRCR + RXCRCR + RX CRC register + 0x14 + 0x20 + read-only + 0x0000 + + + RxCRC + Rx CRC register + 0 + 16 + + + + + TXCRCR + TXCRCR + TX CRC register + 0x18 + 0x20 + read-only + 0x0000 + + + TxCRC + Tx CRC register + 0 + 16 + + + + + I2SCFGR + I2SCFGR + I2S configuration register + 0x1C + 0x20 + read-write + 0x0000 + + + I2SMOD + I2S mode selection + 11 + 1 + + + I2SE + I2S Enable + 10 + 1 + + + I2SCFG + I2S configuration mode + 8 + 2 + + + PCMSYNC + PCM frame synchronization + 7 + 1 + + + I2SSTD + I2S standard selection + 4 + 2 + + + CKPOL + Steady state clock + polarity + 3 + 1 + + + DATLEN + Data length to be + transferred + 1 + 2 + + + CHLEN + Channel length (number of bits per audio + channel) + 0 + 1 + + + + + I2SPR + I2SPR + I2S prescaler register + 0x20 + 0x20 + read-write + 0x00000010 + + + MCKOE + Master clock output enable + 9 + 1 + + + ODD + Odd factor for the + prescaler + 8 + 1 + + + I2SDIV + I2S Linear prescaler + 0 + 8 + + + + + + + SPI2 + 0x40003800 + + SPI2 + SPI2 global interrupt + 26 + + + + DAC + Digital-to-analog converter + DAC + 0x40007400 + + 0x0 + 0x400 + registers + + + TIM6_DAC + TIM6 global interrupt and DAC underrun + interrupt + 17 + + + + CR + CR + control register + 0x0 + 0x20 + read-write + 0x00000000 + + + EN1 + DAC channel1 enable + 0 + 1 + + + BOFF1 + DAC channel1 output buffer + disable + 1 + 1 + + + TEN1 + DAC channel1 trigger + enable + 2 + 1 + + + TSEL10 + DAC channel1 trigger + selection + 3 + 1 + + + TSEL11 + DAC channel1 trigger + selection + 4 + 1 + + + TSEL12 + DAC channel1 trigger + selection + 5 + 1 + + + DMAEN1 + DAC channel1 DMA enable + 12 + 1 + + + DMAUDRIE1 + DAC channel1 DMA Underrun Interrupt + enable + 13 + 1 + + + + + SWTRIGR + SWTRIGR + software trigger register + 0x4 + 0x20 + write-only + 0x00000000 + + + SWTRIG1 + DAC channel1 software + trigger + 0 + 1 + + + + + DHR12R1 + DHR12R1 + channel1 12-bit right-aligned data holding + register + 0x8 + 0x20 + read-write + 0x00000000 + + + DACC1DHR + DAC channel1 12-bit right-aligned + data + 0 + 12 + + + + + DHR12L1 + DHR12L1 + channel1 12-bit left aligned data holding + register + 0xC + 0x20 + read-write + 0x00000000 + + + DACC1DHR + DAC channel1 12-bit left-aligned + data + 4 + 12 + + + + + DHR8R1 + DHR8R1 + channel1 8-bit right aligned data holding + register + 0x10 + 0x20 + read-write + 0x00000000 + + + DACC1DHR + DAC channel1 8-bit right-aligned + data + 0 + 8 + + + + + DOR1 + DOR1 + channel1 data output register + 0x2C + 0x20 + read-only + 0x00000000 + + + DACC1DOR + DAC channel1 data output + 0 + 12 + + + + + SR + SR + status register + 0x34 + 0x20 + read-write + 0x00000000 + + + DMAUDR2 + DAC channel2 DMA underrun + flag + 29 + 1 + + + DMAUDR1 + DAC channel1 DMA underrun + flag + 13 + 1 + + + + + + + PWR + Power control + PWR + 0x40007000 + + 0x0 + 0x400 + registers + + + + CR + CR + power control register + 0x0 + 0x20 + read-write + 0x00000000 + + + FPDS + Flash power down in Stop + mode + 9 + 1 + + + DBP + Disable backup domain write + protection + 8 + 1 + + + PLS + PVD level selection + 5 + 3 + + + PVDE + Power voltage detector + enable + 4 + 1 + + + CSBF + Clear standby flag + 3 + 1 + + + CWUF + Clear wakeup flag + 2 + 1 + + + PDDS + Power down deepsleep + 1 + 1 + + + LPDS + Low-power deep sleep + 0 + 1 + + + + + CSR + CSR + power control/status register + 0x4 + 0x20 + 0x00000000 + + + BRE + Backup regulator enable + 9 + 1 + read-write + + + EWUP + Enable WKUP pin + 8 + 1 + read-write + + + BRR + Backup regulator ready + 3 + 1 + read-only + + + PVDO + PVD output + 2 + 1 + read-only + + + SBF + Standby flag + 1 + 1 + read-only + + + WUF + Wakeup flag + 0 + 1 + read-only + + + + + + + I2C1 + Inter-integrated circuit + I2C + 0x40005400 + + 0x0 + 0x400 + registers + + + I2C1 + I2C1 global interrupt + 23 + + + + CR1 + CR1 + Control register 1 + 0x0 + 0x20 + 0x00000000 + + + PE + Peripheral enable + 0 + 1 + read-write + + + TXIE + TX Interrupt enable + 1 + 1 + read-write + + + RXIE + RX Interrupt enable + 2 + 1 + read-write + + + ADDRIE + Address match interrupt enable (slave + only) + 3 + 1 + read-write + + + NACKIE + Not acknowledge received interrupt + enable + 4 + 1 + read-write + + + STOPIE + STOP detection Interrupt + enable + 5 + 1 + read-write + + + TCIE + Transfer Complete interrupt + enable + 6 + 1 + read-write + + + ERRIE + Error interrupts enable + 7 + 1 + read-write + + + DNF + Digital noise filter + 8 + 4 + read-write + + + ANFOFF + Analog noise filter OFF + 12 + 1 + read-write + + + SWRST + Software reset + 13 + 1 + write-only + + + TXDMAEN + DMA transmission requests + enable + 14 + 1 + read-write + + + RXDMAEN + DMA reception requests + enable + 15 + 1 + read-write + + + SBC + Slave byte control + 16 + 1 + read-write + + + NOSTRETCH + Clock stretching disable + 17 + 1 + read-write + + + WUPEN + Wakeup from STOP enable + 18 + 1 + read-write + + + GCEN + General call enable + 19 + 1 + read-write + + + SMBHEN + SMBus Host address enable + 20 + 1 + read-write + + + SMBDEN + SMBus Device Default address + enable + 21 + 1 + read-write + + + ALERTEN + SMBUS alert enable + 22 + 1 + read-write + + + PECEN + PEC enable + 23 + 1 + read-write + + + + + CR2 + CR2 + Control register 2 + 0x4 + 0x20 + read-write + 0x00000000 + + + PECBYTE + Packet error checking byte + 26 + 1 + + + AUTOEND + Automatic end mode (master + mode) + 25 + 1 + + + RELOAD + NBYTES reload mode + 24 + 1 + + + NBYTES + Number of bytes + 16 + 8 + + + NACK + NACK generation (slave + mode) + 15 + 1 + + + STOP + Stop generation (master + mode) + 14 + 1 + + + START + Start generation + 13 + 1 + + + HEAD10R + 10-bit address header only read + direction (master receiver mode) + 12 + 1 + + + ADD10 + 10-bit addressing mode (master + mode) + 11 + 1 + + + RD_WRN + Transfer direction (master + mode) + 10 + 1 + + + SADD8 + Slave address bit 9:8 (master + mode) + 8 + 2 + + + SADD1 + Slave address bit 7:1 (master + mode) + 1 + 7 + + + SADD0 + Slave address bit 0 (master + mode) + 0 + 1 + + + + + OAR1 + OAR1 + Own address register 1 + 0x8 + 0x20 + read-write + 0x00000000 + + + OA1_0 + Interface address + 0 + 1 + + + OA1_1 + Interface address + 1 + 7 + + + OA1_8 + Interface address + 8 + 2 + + + OA1MODE + Own Address 1 10-bit mode + 10 + 1 + + + OA1EN + Own Address 1 enable + 15 + 1 + + + + + OAR2 + OAR2 + Own address register 2 + 0xC + 0x20 + read-write + 0x00000000 + + + OA2 + Interface address + 1 + 7 + + + OA2MSK + Own Address 2 masks + 8 + 3 + + + OA2EN + Own Address 2 enable + 15 + 1 + + + + + TIMINGR + TIMINGR + Timing register + 0x10 + 0x20 + read-write + 0x00000000 + + + SCLL + SCL low period (master + mode) + 0 + 8 + + + SCLH + SCL high period (master + mode) + 8 + 8 + + + SDADEL + Data hold time + 16 + 4 + + + SCLDEL + Data setup time + 20 + 4 + + + PRESC + Timing prescaler + 28 + 4 + + + + + TIMEOUTR + TIMEOUTR + Status register 1 + 0x14 + 0x20 + read-write + 0x00000000 + + + TIMEOUTA + Bus timeout A + 0 + 12 + + + TIDLE + Idle clock timeout + detection + 12 + 1 + + + TIMOUTEN + Clock timeout enable + 15 + 1 + + + TIMEOUTB + Bus timeout B + 16 + 12 + + + TEXTEN + Extended clock timeout + enable + 31 + 1 + + + + + ISR + ISR + Interrupt and Status register + 0x18 + 0x20 + 0x00000001 + + + ADDCODE + Address match code (Slave + mode) + 17 + 7 + read-only + + + DIR + Transfer direction (Slave + mode) + 16 + 1 + read-only + + + BUSY + Bus busy + 15 + 1 + read-only + + + ALERT + SMBus alert + 13 + 1 + read-only + + + TIMEOUT + Timeout or t_low detection + flag + 12 + 1 + read-only + + + PECERR + PEC Error in reception + 11 + 1 + read-only + + + OVR + Overrun/Underrun (slave + mode) + 10 + 1 + read-only + + + ARLO + Arbitration lost + 9 + 1 + read-only + + + BERR + Bus error + 8 + 1 + read-only + + + TCR + Transfer Complete Reload + 7 + 1 + read-only + + + TC + Transfer Complete (master + mode) + 6 + 1 + read-only + + + STOPF + Stop detection flag + 5 + 1 + read-only + + + NACKF + Not acknowledge received + flag + 4 + 1 + read-only + + + ADDR + Address matched (slave + mode) + 3 + 1 + read-only + + + RXNE + Receive data register not empty + (receivers) + 2 + 1 + read-only + + + TXIS + Transmit interrupt status + (transmitters) + 1 + 1 + read-write + + + TXE + Transmit data register empty + (transmitters) + 0 + 1 + read-write + + + + + ICR + ICR + Interrupt clear register + 0x1C + 0x20 + write-only + 0x00000000 + + + ALERTCF + Alert flag clear + 13 + 1 + + + TIMOUTCF + Timeout detection flag + clear + 12 + 1 + + + PECCF + PEC Error flag clear + 11 + 1 + + + OVRCF + Overrun/Underrun flag + clear + 10 + 1 + + + ARLOCF + Arbitration lost flag + clear + 9 + 1 + + + BERRCF + Bus error flag clear + 8 + 1 + + + STOPCF + Stop detection flag clear + 5 + 1 + + + NACKCF + Not Acknowledge flag clear + 4 + 1 + + + ADDRCF + Address Matched flag clear + 3 + 1 + + + + + PECR + PECR + PEC register + 0x20 + 0x20 + read-only + 0x00000000 + + + PEC + Packet error checking + register + 0 + 8 + + + + + RXDR + RXDR + Receive data register + 0x24 + 0x20 + read-only + 0x00000000 + + + RXDATA + 8-bit receive data + 0 + 8 + + + + + TXDR + TXDR + Transmit data register + 0x28 + 0x20 + read-write + 0x00000000 + + + TXDATA + 8-bit transmit data + 0 + 8 + + + + + + + I2C2 + 0x40005800 + + I2C2 + I2C2 global interrupt + 24 + + + + IWDG + Independent watchdog + IWDG + 0x40003000 + + 0x0 + 0x400 + registers + + + + KR + KR + Key register + 0x0 + 0x20 + write-only + 0x00000000 + + + KEY + Key value + 0 + 16 + + + + + PR + PR + Prescaler register + 0x4 + 0x20 + read-write + 0x00000000 + + + PR + Prescaler divider + 0 + 3 + + + + + RLR + RLR + Reload register + 0x8 + 0x20 + read-write + 0x00000FFF + + + RL + Watchdog counter reload + value + 0 + 12 + + + + + SR + SR + Status register + 0xC + 0x20 + read-only + 0x00000000 + + + PVU + Watchdog prescaler value + update + 0 + 1 + + + RVU + Watchdog counter reload value + update + 1 + 1 + + + WVU + Watchdog counter window value + update + 2 + 1 + + + + + WINR + WINR + Window register + 0x10 + 0x20 + read-write + 0x00000FFF + + + WIN + Watchdog counter window + value + 0 + 12 + + + + + + + WWDG + Window watchdog + WWDG + 0x40002C00 + + 0x0 + 0x400 + registers + + + WWDG + Window Watchdog interrupt + 0 + + + + CR + CR + Control register + 0x0 + 0x20 + read-write + 0x0000007F + + + WDGA + Activation bit + 7 + 1 + + + T + 7-bit counter + 0 + 7 + + + + + CFR + CFR + Configuration register + 0x4 + 0x20 + read-write + 0x0000007F + + + EWI + Early wakeup interrupt + 9 + 1 + + + WDGTB + Timer base + 7 + 2 + + + W + 7-bit window value + 0 + 7 + + + + + SR + SR + Status register + 0x8 + 0x20 + read-write + 0x00000000 + + + EWIF + Early wakeup interrupt + flag + 0 + 1 + + + + + + + TIM1 + Advanced-timers + TIM + 0x40012C00 + + 0x0 + 0x400 + registers + + + TIM1_BRK_UP_TRG_COM + TIM1 break, update, trigger and commutation + interrupt + 13 + + + TIM1_CC + TIM1 Capture Compare interrupt + 14 + + + + CR1 + CR1 + control register 1 + 0x0 + 0x20 + read-write + 0x0000 + + + CKD + Clock division + 8 + 2 + + + ARPE + Auto-reload preload enable + 7 + 1 + + + CMS + Center-aligned mode + selection + 5 + 2 + + + DIR + Direction + 4 + 1 + + + OPM + One-pulse mode + 3 + 1 + + + URS + Update request source + 2 + 1 + + + UDIS + Update disable + 1 + 1 + + + CEN + Counter enable + 0 + 1 + + + + + CR2 + CR2 + control register 2 + 0x4 + 0x20 + read-write + 0x0000 + + + OIS4 + Output Idle state 4 + 14 + 1 + + + OIS3N + Output Idle state 3 + 13 + 1 + + + OIS3 + Output Idle state 3 + 12 + 1 + + + OIS2N + Output Idle state 2 + 11 + 1 + + + OIS2 + Output Idle state 2 + 10 + 1 + + + OIS1N + Output Idle state 1 + 9 + 1 + + + OIS1 + Output Idle state 1 + 8 + 1 + + + TI1S + TI1 selection + 7 + 1 + + + MMS + Master mode selection + 4 + 3 + + + CCDS + Capture/compare DMA + selection + 3 + 1 + + + CCUS + Capture/compare control update + selection + 2 + 1 + + + CCPC + Capture/compare preloaded + control + 0 + 1 + + + + + SMCR + SMCR + slave mode control register + 0x8 + 0x20 + read-write + 0x0000 + + + ETP + External trigger polarity + 15 + 1 + + + ECE + External clock enable + 14 + 1 + + + ETPS + External trigger prescaler + 12 + 2 + + + ETF + External trigger filter + 8 + 4 + + + MSM + Master/Slave mode + 7 + 1 + + + TS + Trigger selection + 4 + 3 + + + SMS + Slave mode selection + 0 + 3 + + + + + DIER + DIER + DMA/Interrupt enable register + 0xC + 0x20 + read-write + 0x0000 + + + TDE + Trigger DMA request enable + 14 + 1 + + + COMDE + Reserved + 13 + 1 + + + CC4DE + Capture/Compare 4 DMA request + enable + 12 + 1 + + + CC3DE + Capture/Compare 3 DMA request + enable + 11 + 1 + + + CC2DE + Capture/Compare 2 DMA request + enable + 10 + 1 + + + CC1DE + Capture/Compare 1 DMA request + enable + 9 + 1 + + + UDE + Update DMA request enable + 8 + 1 + + + BIE + Break interrupt enable + 7 + 1 + + + TIE + Trigger interrupt enable + 6 + 1 + + + COMIE + COM interrupt enable + 5 + 1 + + + CC4IE + Capture/Compare 4 interrupt + enable + 4 + 1 + + + CC3IE + Capture/Compare 3 interrupt + enable + 3 + 1 + + + CC2IE + Capture/Compare 2 interrupt + enable + 2 + 1 + + + CC1IE + Capture/Compare 1 interrupt + enable + 1 + 1 + + + UIE + Update interrupt enable + 0 + 1 + + + + + SR + SR + status register + 0x10 + 0x20 + read-write + 0x0000 + + + CC4OF + Capture/Compare 4 overcapture + flag + 12 + 1 + + + CC3OF + Capture/Compare 3 overcapture + flag + 11 + 1 + + + CC2OF + Capture/compare 2 overcapture + flag + 10 + 1 + + + CC1OF + Capture/Compare 1 overcapture + flag + 9 + 1 + + + BIF + Break interrupt flag + 7 + 1 + + + TIF + Trigger interrupt flag + 6 + 1 + + + COMIF + COM interrupt flag + 5 + 1 + + + CC4IF + Capture/Compare 4 interrupt + flag + 4 + 1 + + + CC3IF + Capture/Compare 3 interrupt + flag + 3 + 1 + + + CC2IF + Capture/Compare 2 interrupt + flag + 2 + 1 + + + CC1IF + Capture/compare 1 interrupt + flag + 1 + 1 + + + UIF + Update interrupt flag + 0 + 1 + + + + + EGR + EGR + event generation register + 0x14 + 0x20 + write-only + 0x0000 + + + BG + Break generation + 7 + 1 + + + TG + Trigger generation + 6 + 1 + + + COMG + Capture/Compare control update + generation + 5 + 1 + + + CC4G + Capture/compare 4 + generation + 4 + 1 + + + CC3G + Capture/compare 3 + generation + 3 + 1 + + + CC2G + Capture/compare 2 + generation + 2 + 1 + + + CC1G + Capture/compare 1 + generation + 1 + 1 + + + UG + Update generation + 0 + 1 + + + + + CCMR1_Output + CCMR1_Output + capture/compare mode register (output + mode) + 0x18 + 0x20 + read-write + 0x00000000 + + + OC2CE + Output Compare 2 clear + enable + 15 + 1 + + + OC2M + Output Compare 2 mode + 12 + 3 + + + OC2PE + Output Compare 2 preload + enable + 11 + 1 + + + OC2FE + Output Compare 2 fast + enable + 10 + 1 + + + CC2S + Capture/Compare 2 + selection + 8 + 2 + + + OC1CE + Output Compare 1 clear + enable + 7 + 1 + + + OC1M + Output Compare 1 mode + 4 + 3 + + + OC1PE + Output Compare 1 preload + enable + 3 + 1 + + + OC1FE + Output Compare 1 fast + enable + 2 + 1 + + + CC1S + Capture/Compare 1 + selection + 0 + 2 + + + + + CCMR1_Input + CCMR1_Input + capture/compare mode register 1 (input + mode) + CCMR1_Output + 0x18 + 0x20 + read-write + 0x00000000 + + + IC2F + Input capture 2 filter + 12 + 4 + + + IC2PCS + Input capture 2 prescaler + 10 + 2 + + + CC2S + Capture/Compare 2 + selection + 8 + 2 + + + IC1F + Input capture 1 filter + 4 + 4 + + + IC1PCS + Input capture 1 prescaler + 2 + 2 + + + CC1S + Capture/Compare 1 + selection + 0 + 2 + + + + + CCMR2_Output + CCMR2_Output + capture/compare mode register (output + mode) + 0x1C + 0x20 + read-write + 0x00000000 + + + OC4CE + Output compare 4 clear + enable + 15 + 1 + + + OC4M + Output compare 4 mode + 12 + 3 + + + OC4PE + Output compare 4 preload + enable + 11 + 1 + + + OC4FE + Output compare 4 fast + enable + 10 + 1 + + + CC4S + Capture/Compare 4 + selection + 8 + 2 + + + OC3CE + Output compare 3 clear + enable + 7 + 1 + + + OC3M + Output compare 3 mode + 4 + 3 + + + OC3PE + Output compare 3 preload + enable + 3 + 1 + + + OC3FE + Output compare 3 fast + enable + 2 + 1 + + + CC3S + Capture/Compare 3 + selection + 0 + 2 + + + + + CCMR2_Input + CCMR2_Input + capture/compare mode register 2 (input + mode) + CCMR2_Output + 0x1C + 0x20 + read-write + 0x00000000 + + + IC4F + Input capture 4 filter + 12 + 4 + + + IC4PSC + Input capture 4 prescaler + 10 + 2 + + + CC4S + Capture/Compare 4 + selection + 8 + 2 + + + IC3F + Input capture 3 filter + 4 + 4 + + + IC3PSC + Input capture 3 prescaler + 2 + 2 + + + CC3S + Capture/compare 3 + selection + 0 + 2 + + + + + CCER + CCER + capture/compare enable + register + 0x20 + 0x20 + read-write + 0x0000 + + + CC4P + Capture/Compare 3 output + Polarity + 13 + 1 + + + CC4E + Capture/Compare 4 output + enable + 12 + 1 + + + CC3NP + Capture/Compare 3 output + Polarity + 11 + 1 + + + CC3NE + Capture/Compare 3 complementary output + enable + 10 + 1 + + + CC3P + Capture/Compare 3 output + Polarity + 9 + 1 + + + CC3E + Capture/Compare 3 output + enable + 8 + 1 + + + CC2NP + Capture/Compare 2 output + Polarity + 7 + 1 + + + CC2NE + Capture/Compare 2 complementary output + enable + 6 + 1 + + + CC2P + Capture/Compare 2 output + Polarity + 5 + 1 + + + CC2E + Capture/Compare 2 output + enable + 4 + 1 + + + CC1NP + Capture/Compare 1 output + Polarity + 3 + 1 + + + CC1NE + Capture/Compare 1 complementary output + enable + 2 + 1 + + + CC1P + Capture/Compare 1 output + Polarity + 1 + 1 + + + CC1E + Capture/Compare 1 output + enable + 0 + 1 + + + + + CNT + CNT + counter + 0x24 + 0x20 + read-write + 0x00000000 + + + CNT + counter value + 0 + 16 + + + + + PSC + PSC + prescaler + 0x28 + 0x20 + read-write + 0x0000 + + + PSC + Prescaler value + 0 + 16 + + + + + ARR + ARR + auto-reload register + 0x2C + 0x20 + read-write + 0x00000000 + + + ARR + Auto-reload value + 0 + 16 + + + + + RCR + RCR + repetition counter register + 0x30 + 0x20 + read-write + 0x0000 + + + REP + Repetition counter value + 0 + 8 + + + + + CCR1 + CCR1 + capture/compare register 1 + 0x34 + 0x20 + read-write + 0x00000000 + + + CCR1 + Capture/Compare 1 value + 0 + 16 + + + + + CCR2 + CCR2 + capture/compare register 2 + 0x38 + 0x20 + read-write + 0x00000000 + + + CCR2 + Capture/Compare 2 value + 0 + 16 + + + + + CCR3 + CCR3 + capture/compare register 3 + 0x3C + 0x20 + read-write + 0x00000000 + + + CCR3 + Capture/Compare 3 value + 0 + 16 + + + + + CCR4 + CCR4 + capture/compare register 4 + 0x40 + 0x20 + read-write + 0x00000000 + + + CCR4 + Capture/Compare 3 value + 0 + 16 + + + + + BDTR + BDTR + break and dead-time register + 0x44 + 0x20 + read-write + 0x0000 + + + MOE + Main output enable + 15 + 1 + + + AOE + Automatic output enable + 14 + 1 + + + BKP + Break polarity + 13 + 1 + + + BKE + Break enable + 12 + 1 + + + OSSR + Off-state selection for Run + mode + 11 + 1 + + + OSSI + Off-state selection for Idle + mode + 10 + 1 + + + LOCK + Lock configuration + 8 + 2 + + + DTG + Dead-time generator setup + 0 + 8 + + + + + DCR + DCR + DMA control register + 0x48 + 0x20 + read-write + 0x0000 + + + DBL + DMA burst length + 8 + 5 + + + DBA + DMA base address + 0 + 5 + + + + + DMAR + DMAR + DMA address for full transfer + 0x4C + 0x20 + read-write + 0x0000 + + + DMAB + DMA register for burst + accesses + 0 + 16 + + + + + + + TIM2 + General-purpose-timers + TIM + 0x40000000 + + 0x0 + 0x400 + registers + + + TIM2 + TIM2 global interrupt + 15 + + + + CR1 + CR1 + control register 1 + 0x0 + 0x20 + read-write + 0x0000 + + + CKD + Clock division + 8 + 2 + + + ARPE + Auto-reload preload enable + 7 + 1 + + + CMS + Center-aligned mode + selection + 5 + 2 + + + DIR + Direction + 4 + 1 + + + OPM + One-pulse mode + 3 + 1 + + + URS + Update request source + 2 + 1 + + + UDIS + Update disable + 1 + 1 + + + CEN + Counter enable + 0 + 1 + + + + + CR2 + CR2 + control register 2 + 0x4 + 0x20 + read-write + 0x0000 + + + TI1S + TI1 selection + 7 + 1 + + + MMS + Master mode selection + 4 + 3 + + + CCDS + Capture/compare DMA + selection + 3 + 1 + + + + + SMCR + SMCR + slave mode control register + 0x8 + 0x20 + read-write + 0x0000 + + + ETP + External trigger polarity + 15 + 1 + + + ECE + External clock enable + 14 + 1 + + + ETPS + External trigger prescaler + 12 + 2 + + + ETF + External trigger filter + 8 + 4 + + + MSM + Master/Slave mode + 7 + 1 + + + TS + Trigger selection + 4 + 3 + + + SMS + Slave mode selection + 0 + 3 + + + + + DIER + DIER + DMA/Interrupt enable register + 0xC + 0x20 + read-write + 0x0000 + + + TDE + Trigger DMA request enable + 14 + 1 + + + COMDE + Reserved + 13 + 1 + + + CC4DE + Capture/Compare 4 DMA request + enable + 12 + 1 + + + CC3DE + Capture/Compare 3 DMA request + enable + 11 + 1 + + + CC2DE + Capture/Compare 2 DMA request + enable + 10 + 1 + + + CC1DE + Capture/Compare 1 DMA request + enable + 9 + 1 + + + UDE + Update DMA request enable + 8 + 1 + + + TIE + Trigger interrupt enable + 6 + 1 + + + CC4IE + Capture/Compare 4 interrupt + enable + 4 + 1 + + + CC3IE + Capture/Compare 3 interrupt + enable + 3 + 1 + + + CC2IE + Capture/Compare 2 interrupt + enable + 2 + 1 + + + CC1IE + Capture/Compare 1 interrupt + enable + 1 + 1 + + + UIE + Update interrupt enable + 0 + 1 + + + + + SR + SR + status register + 0x10 + 0x20 + read-write + 0x0000 + + + CC4OF + Capture/Compare 4 overcapture + flag + 12 + 1 + + + CC3OF + Capture/Compare 3 overcapture + flag + 11 + 1 + + + CC2OF + Capture/compare 2 overcapture + flag + 10 + 1 + + + CC1OF + Capture/Compare 1 overcapture + flag + 9 + 1 + + + TIF + Trigger interrupt flag + 6 + 1 + + + CC4IF + Capture/Compare 4 interrupt + flag + 4 + 1 + + + CC3IF + Capture/Compare 3 interrupt + flag + 3 + 1 + + + CC2IF + Capture/Compare 2 interrupt + flag + 2 + 1 + + + CC1IF + Capture/compare 1 interrupt + flag + 1 + 1 + + + UIF + Update interrupt flag + 0 + 1 + + + + + EGR + EGR + event generation register + 0x14 + 0x20 + write-only + 0x0000 + + + TG + Trigger generation + 6 + 1 + + + CC4G + Capture/compare 4 + generation + 4 + 1 + + + CC3G + Capture/compare 3 + generation + 3 + 1 + + + CC2G + Capture/compare 2 + generation + 2 + 1 + + + CC1G + Capture/compare 1 + generation + 1 + 1 + + + UG + Update generation + 0 + 1 + + + + + CCMR1_Output + CCMR1_Output + capture/compare mode register 1 (output + mode) + 0x18 + 0x20 + read-write + 0x00000000 + + + OC2CE + Output compare 2 clear + enable + 15 + 1 + + + OC2M + Output compare 2 mode + 12 + 3 + + + OC2PE + Output compare 2 preload + enable + 11 + 1 + + + OC2FE + Output compare 2 fast + enable + 10 + 1 + + + CC2S + Capture/Compare 2 + selection + 8 + 2 + + + OC1CE + Output compare 1 clear + enable + 7 + 1 + + + OC1M + Output compare 1 mode + 4 + 3 + + + OC1PE + Output compare 1 preload + enable + 3 + 1 + + + OC1FE + Output compare 1 fast + enable + 2 + 1 + + + CC1S + Capture/Compare 1 + selection + 0 + 2 + + + + + CCMR1_Input + CCMR1_Input + capture/compare mode register 1 (input + mode) + CCMR1_Output + 0x18 + 0x20 + read-write + 0x00000000 + + + IC2F + Input capture 2 filter + 12 + 4 + + + IC2PSC + Input capture 2 prescaler + 10 + 2 + + + CC2S + Capture/compare 2 + selection + 8 + 2 + + + IC1F + Input capture 1 filter + 4 + 4 + + + IC1PSC + Input capture 1 prescaler + 2 + 2 + + + CC1S + Capture/Compare 1 + selection + 0 + 2 + + + + + CCMR2_Output + CCMR2_Output + capture/compare mode register 2 (output + mode) + 0x1C + 0x20 + read-write + 0x00000000 + + + OC4CE + Output compare 4 clear + enable + 15 + 1 + + + OC4M + Output compare 4 mode + 12 + 3 + + + OC4PE + Output compare 4 preload + enable + 11 + 1 + + + OC4FE + Output compare 4 fast + enable + 10 + 1 + + + CC4S + Capture/Compare 4 + selection + 8 + 2 + + + OC3CE + Output compare 3 clear + enable + 7 + 1 + + + OC3M + Output compare 3 mode + 4 + 3 + + + OC3PE + Output compare 3 preload + enable + 3 + 1 + + + OC3FE + Output compare 3 fast + enable + 2 + 1 + + + CC3S + Capture/Compare 3 + selection + 0 + 2 + + + + + CCMR2_Input + CCMR2_Input + capture/compare mode register 2 (input + mode) + CCMR2_Output + 0x1C + 0x20 + read-write + 0x00000000 + + + IC4F + Input capture 4 filter + 12 + 4 + + + IC4PSC + Input capture 4 prescaler + 10 + 2 + + + CC4S + Capture/Compare 4 + selection + 8 + 2 + + + IC3F + Input capture 3 filter + 4 + 4 + + + IC3PSC + Input capture 3 prescaler + 2 + 2 + + + CC3S + Capture/Compare 3 + selection + 0 + 2 + + + + + CCER + CCER + capture/compare enable + register + 0x20 + 0x20 + read-write + 0x0000 + + + CC4NP + Capture/Compare 4 output + Polarity + 15 + 1 + + + CC4P + Capture/Compare 3 output + Polarity + 13 + 1 + + + CC4E + Capture/Compare 4 output + enable + 12 + 1 + + + CC3NP + Capture/Compare 3 output + Polarity + 11 + 1 + + + CC3P + Capture/Compare 3 output + Polarity + 9 + 1 + + + CC3E + Capture/Compare 3 output + enable + 8 + 1 + + + CC2NP + Capture/Compare 2 output + Polarity + 7 + 1 + + + CC2P + Capture/Compare 2 output + Polarity + 5 + 1 + + + CC2E + Capture/Compare 2 output + enable + 4 + 1 + + + CC1NP + Capture/Compare 1 output + Polarity + 3 + 1 + + + CC1P + Capture/Compare 1 output + Polarity + 1 + 1 + + + CC1E + Capture/Compare 1 output + enable + 0 + 1 + + + + + CNT + CNT + counter + 0x24 + 0x20 + read-write + 0x00000000 + + + CNT_H + High counter value (TIM2 + only) + 16 + 16 + + + CNT_L + Low counter value + 0 + 16 + + + + + PSC + PSC + prescaler + 0x28 + 0x20 + read-write + 0x0000 + + + PSC + Prescaler value + 0 + 16 + + + + + ARR + ARR + auto-reload register + 0x2C + 0x20 + read-write + 0x00000000 + + + ARR_H + High Auto-reload value (TIM2 + only) + 16 + 16 + + + ARR_L + Low Auto-reload value + 0 + 16 + + + + + CCR1 + CCR1 + capture/compare register 1 + 0x34 + 0x20 + read-write + 0x00000000 + + + CCR1_H + High Capture/Compare 1 value (TIM2 + only) + 16 + 16 + + + CCR1_L + Low Capture/Compare 1 + value + 0 + 16 + + + + + CCR2 + CCR2 + capture/compare register 2 + 0x38 + 0x20 + read-write + 0x00000000 + + + CCR2_H + High Capture/Compare 2 value (TIM2 + only) + 16 + 16 + + + CCR2_L + Low Capture/Compare 2 + value + 0 + 16 + + + + + CCR3 + CCR3 + capture/compare register 3 + 0x3C + 0x20 + read-write + 0x00000000 + + + CCR3_H + High Capture/Compare value (TIM2 + only) + 16 + 16 + + + CCR3_L + Low Capture/Compare value + 0 + 16 + + + + + CCR4 + CCR4 + capture/compare register 4 + 0x40 + 0x20 + read-write + 0x00000000 + + + CCR4_H + High Capture/Compare value (TIM2 + only) + 16 + 16 + + + CCR4_L + Low Capture/Compare value + 0 + 16 + + + + + DCR + DCR + DMA control register + 0x48 + 0x20 + read-write + 0x0000 + + + DBL + DMA burst length + 8 + 5 + + + DBA + DMA base address + 0 + 5 + + + + + DMAR + DMAR + DMA address for full transfer + 0x4C + 0x20 + read-write + 0x0000 + + + DMAR + DMA register for burst + accesses + 0 + 16 + + + + + + + TIM3 + 0x40000400 + + TIM3 + TIM3 global interrupt + 16 + + + + TIM14 + General-purpose-timers + TIM + 0x40002000 + + 0x0 + 0x400 + registers + + + TIM14 + TIM14 global interrupt + 19 + + + + CR1 + CR1 + control register 1 + 0x0 + 0x20 + read-write + 0x0000 + + + CKD + Clock division + 8 + 2 + + + ARPE + Auto-reload preload enable + 7 + 1 + + + URS + Update request source + 2 + 1 + + + UDIS + Update disable + 1 + 1 + + + CEN + Counter enable + 0 + 1 + + + + + DIER + DIER + DMA/Interrupt enable register + 0xC + 0x20 + read-write + 0x0000 + + + CC1IE + Capture/Compare 1 interrupt + enable + 1 + 1 + + + UIE + Update interrupt enable + 0 + 1 + + + + + SR + SR + status register + 0x10 + 0x20 + read-write + 0x0000 + + + CC1OF + Capture/Compare 1 overcapture + flag + 9 + 1 + + + CC1IF + Capture/compare 1 interrupt + flag + 1 + 1 + + + UIF + Update interrupt flag + 0 + 1 + + + + + EGR + EGR + event generation register + 0x14 + 0x20 + write-only + 0x0000 + + + CC1G + Capture/compare 1 + generation + 1 + 1 + + + UG + Update generation + 0 + 1 + + + + + CCMR1_Output + CCMR1_Output + capture/compare mode register (output + mode) + 0x18 + 0x20 + read-write + 0x00000000 + + + CC1S + Capture/Compare 1 + selection + 0 + 2 + + + OC1FE + Output compare 1 fast + enable + 2 + 1 + + + OC1PE + Output Compare 1 preload + enable + 3 + 1 + + + OC1M + Output Compare 1 mode + 4 + 3 + + + + + CCMR1_Input + CCMR1_Input + capture/compare mode register (input + mode) + CCMR1_Output + 0x18 + 0x20 + read-write + 0x00000000 + + + IC1F + Input capture 1 filter + 4 + 4 + + + IC1PSC + Input capture 1 prescaler + 2 + 2 + + + CC1S + Capture/Compare 1 + selection + 0 + 2 + + + + + CCER + CCER + capture/compare enable + register + 0x20 + 0x20 + read-write + 0x0000 + + + CC1NP + Capture/Compare 1 output + Polarity + 3 + 1 + + + CC1P + Capture/Compare 1 output + Polarity + 1 + 1 + + + CC1E + Capture/Compare 1 output + enable + 0 + 1 + + + + + CNT + CNT + counter + 0x24 + 0x20 + read-write + 0x00000000 + + + CNT + counter value + 0 + 16 + + + + + PSC + PSC + prescaler + 0x28 + 0x20 + read-write + 0x0000 + + + PSC + Prescaler value + 0 + 16 + + + + + ARR + ARR + auto-reload register + 0x2C + 0x20 + read-write + 0x00000000 + + + ARR + Auto-reload value + 0 + 16 + + + + + CCR1 + CCR1 + capture/compare register 1 + 0x34 + 0x20 + read-write + 0x00000000 + + + CCR1 + Capture/Compare 1 value + 0 + 16 + + + + + OR + OR + option register + 0x50 + 0x20 + read-write + 0x00000000 + + + RMP + Timer input 1 remap + 0 + 2 + + + + + + + TIM6 + Basic-timers + TIM + 0x40001000 + + 0x0 + 0x400 + registers + + + TIM6_DAC + TIM6 global interrupt and DAC underrun + interrupt + 17 + + + + CR1 + CR1 + control register 1 + 0x0 + 0x20 + read-write + 0x0000 + + + ARPE + Auto-reload preload enable + 7 + 1 + + + OPM + One-pulse mode + 3 + 1 + + + URS + Update request source + 2 + 1 + + + UDIS + Update disable + 1 + 1 + + + CEN + Counter enable + 0 + 1 + + + + + CR2 + CR2 + control register 2 + 0x4 + 0x20 + read-write + 0x0000 + + + MMS + Master mode selection + 4 + 3 + + + + + DIER + DIER + DMA/Interrupt enable register + 0xC + 0x20 + read-write + 0x0000 + + + UDE + Update DMA request enable + 8 + 1 + + + UIE + Update interrupt enable + 0 + 1 + + + + + SR + SR + status register + 0x10 + 0x20 + read-write + 0x0000 + + + UIF + Update interrupt flag + 0 + 1 + + + + + EGR + EGR + event generation register + 0x14 + 0x20 + write-only + 0x0000 + + + UG + Update generation + 0 + 1 + + + + + CNT + CNT + counter + 0x24 + 0x20 + read-write + 0x00000000 + + + CNT + Low counter value + 0 + 16 + + + + + PSC + PSC + prescaler + 0x28 + 0x20 + read-write + 0x0000 + + + PSC + Prescaler value + 0 + 16 + + + + + ARR + ARR + auto-reload register + 0x2C + 0x20 + read-write + 0x00000000 + + + ARR + Low Auto-reload value + 0 + 16 + + + + + + + TIM7 + 0x40001400 + + TIM7 + TIM7 global interrupt + 18 + + + + EXTI + External interrupt/event + controller + EXTI + 0x40010400 + + 0x0 + 0x400 + registers + + + PVD + PVD and VDDIO2 supply comparator + interrupt + 1 + + + EXTI0_1 + EXTI Line[1:0] interrupts + 5 + + + EXTI2_3 + EXTI Line[3:2] interrupts + 6 + + + EXTI4_15 + EXTI Line15 and EXTI4 interrupts + 7 + + + + IMR + IMR + Interrupt mask register + (EXTI_IMR) + 0x0 + 0x20 + read-write + 0x0F940000 + + + MR0 + Interrupt Mask on line 0 + 0 + 1 + + + MR1 + Interrupt Mask on line 1 + 1 + 1 + + + MR2 + Interrupt Mask on line 2 + 2 + 1 + + + MR3 + Interrupt Mask on line 3 + 3 + 1 + + + MR4 + Interrupt Mask on line 4 + 4 + 1 + + + MR5 + Interrupt Mask on line 5 + 5 + 1 + + + MR6 + Interrupt Mask on line 6 + 6 + 1 + + + MR7 + Interrupt Mask on line 7 + 7 + 1 + + + MR8 + Interrupt Mask on line 8 + 8 + 1 + + + MR9 + Interrupt Mask on line 9 + 9 + 1 + + + MR10 + Interrupt Mask on line 10 + 10 + 1 + + + MR11 + Interrupt Mask on line 11 + 11 + 1 + + + MR12 + Interrupt Mask on line 12 + 12 + 1 + + + MR13 + Interrupt Mask on line 13 + 13 + 1 + + + MR14 + Interrupt Mask on line 14 + 14 + 1 + + + MR15 + Interrupt Mask on line 15 + 15 + 1 + + + MR16 + Interrupt Mask on line 16 + 16 + 1 + + + MR17 + Interrupt Mask on line 17 + 17 + 1 + + + MR18 + Interrupt Mask on line 18 + 18 + 1 + + + MR19 + Interrupt Mask on line 19 + 19 + 1 + + + MR20 + Interrupt Mask on line 20 + 20 + 1 + + + MR21 + Interrupt Mask on line 21 + 21 + 1 + + + MR22 + Interrupt Mask on line 22 + 22 + 1 + + + MR23 + Interrupt Mask on line 23 + 23 + 1 + + + MR24 + Interrupt Mask on line 24 + 24 + 1 + + + MR25 + Interrupt Mask on line 25 + 25 + 1 + + + MR26 + Interrupt Mask on line 26 + 26 + 1 + + + MR27 + Interrupt Mask on line 27 + 27 + 1 + + + + + EMR + EMR + Event mask register (EXTI_EMR) + 0x4 + 0x20 + read-write + 0x00000000 + + + MR0 + Event Mask on line 0 + 0 + 1 + + + MR1 + Event Mask on line 1 + 1 + 1 + + + MR2 + Event Mask on line 2 + 2 + 1 + + + MR3 + Event Mask on line 3 + 3 + 1 + + + MR4 + Event Mask on line 4 + 4 + 1 + + + MR5 + Event Mask on line 5 + 5 + 1 + + + MR6 + Event Mask on line 6 + 6 + 1 + + + MR7 + Event Mask on line 7 + 7 + 1 + + + MR8 + Event Mask on line 8 + 8 + 1 + + + MR9 + Event Mask on line 9 + 9 + 1 + + + MR10 + Event Mask on line 10 + 10 + 1 + + + MR11 + Event Mask on line 11 + 11 + 1 + + + MR12 + Event Mask on line 12 + 12 + 1 + + + MR13 + Event Mask on line 13 + 13 + 1 + + + MR14 + Event Mask on line 14 + 14 + 1 + + + MR15 + Event Mask on line 15 + 15 + 1 + + + MR16 + Event Mask on line 16 + 16 + 1 + + + MR17 + Event Mask on line 17 + 17 + 1 + + + MR18 + Event Mask on line 18 + 18 + 1 + + + MR19 + Event Mask on line 19 + 19 + 1 + + + MR20 + Event Mask on line 20 + 20 + 1 + + + MR21 + Event Mask on line 21 + 21 + 1 + + + MR22 + Event Mask on line 22 + 22 + 1 + + + MR23 + Event Mask on line 23 + 23 + 1 + + + MR24 + Event Mask on line 24 + 24 + 1 + + + MR25 + Event Mask on line 25 + 25 + 1 + + + MR26 + Event Mask on line 26 + 26 + 1 + + + MR27 + Event Mask on line 27 + 27 + 1 + + + + + RTSR + RTSR + Rising Trigger selection register + (EXTI_RTSR) + 0x8 + 0x20 + read-write + 0x00000000 + + + TR0 + Rising trigger event configuration of + line 0 + 0 + 1 + + + TR1 + Rising trigger event configuration of + line 1 + 1 + 1 + + + TR2 + Rising trigger event configuration of + line 2 + 2 + 1 + + + TR3 + Rising trigger event configuration of + line 3 + 3 + 1 + + + TR4 + Rising trigger event configuration of + line 4 + 4 + 1 + + + TR5 + Rising trigger event configuration of + line 5 + 5 + 1 + + + TR6 + Rising trigger event configuration of + line 6 + 6 + 1 + + + TR7 + Rising trigger event configuration of + line 7 + 7 + 1 + + + TR8 + Rising trigger event configuration of + line 8 + 8 + 1 + + + TR9 + Rising trigger event configuration of + line 9 + 9 + 1 + + + TR10 + Rising trigger event configuration of + line 10 + 10 + 1 + + + TR11 + Rising trigger event configuration of + line 11 + 11 + 1 + + + TR12 + Rising trigger event configuration of + line 12 + 12 + 1 + + + TR13 + Rising trigger event configuration of + line 13 + 13 + 1 + + + TR14 + Rising trigger event configuration of + line 14 + 14 + 1 + + + TR15 + Rising trigger event configuration of + line 15 + 15 + 1 + + + TR16 + Rising trigger event configuration of + line 16 + 16 + 1 + + + TR17 + Rising trigger event configuration of + line 17 + 17 + 1 + + + TR19 + Rising trigger event configuration of + line 19 + 19 + 1 + + + + + FTSR + FTSR + Falling Trigger selection register + (EXTI_FTSR) + 0xC + 0x20 + read-write + 0x00000000 + + + TR0 + Falling trigger event configuration of + line 0 + 0 + 1 + + + TR1 + Falling trigger event configuration of + line 1 + 1 + 1 + + + TR2 + Falling trigger event configuration of + line 2 + 2 + 1 + + + TR3 + Falling trigger event configuration of + line 3 + 3 + 1 + + + TR4 + Falling trigger event configuration of + line 4 + 4 + 1 + + + TR5 + Falling trigger event configuration of + line 5 + 5 + 1 + + + TR6 + Falling trigger event configuration of + line 6 + 6 + 1 + + + TR7 + Falling trigger event configuration of + line 7 + 7 + 1 + + + TR8 + Falling trigger event configuration of + line 8 + 8 + 1 + + + TR9 + Falling trigger event configuration of + line 9 + 9 + 1 + + + TR10 + Falling trigger event configuration of + line 10 + 10 + 1 + + + TR11 + Falling trigger event configuration of + line 11 + 11 + 1 + + + TR12 + Falling trigger event configuration of + line 12 + 12 + 1 + + + TR13 + Falling trigger event configuration of + line 13 + 13 + 1 + + + TR14 + Falling trigger event configuration of + line 14 + 14 + 1 + + + TR15 + Falling trigger event configuration of + line 15 + 15 + 1 + + + TR16 + Falling trigger event configuration of + line 16 + 16 + 1 + + + TR17 + Falling trigger event configuration of + line 17 + 17 + 1 + + + TR19 + Falling trigger event configuration of + line 19 + 19 + 1 + + + + + SWIER + SWIER + Software interrupt event register + (EXTI_SWIER) + 0x10 + 0x20 + read-write + 0x00000000 + + + SWIER0 + Software Interrupt on line + 0 + 0 + 1 + + + SWIER1 + Software Interrupt on line + 1 + 1 + 1 + + + SWIER2 + Software Interrupt on line + 2 + 2 + 1 + + + SWIER3 + Software Interrupt on line + 3 + 3 + 1 + + + SWIER4 + Software Interrupt on line + 4 + 4 + 1 + + + SWIER5 + Software Interrupt on line + 5 + 5 + 1 + + + SWIER6 + Software Interrupt on line + 6 + 6 + 1 + + + SWIER7 + Software Interrupt on line + 7 + 7 + 1 + + + SWIER8 + Software Interrupt on line + 8 + 8 + 1 + + + SWIER9 + Software Interrupt on line + 9 + 9 + 1 + + + SWIER10 + Software Interrupt on line + 10 + 10 + 1 + + + SWIER11 + Software Interrupt on line + 11 + 11 + 1 + + + SWIER12 + Software Interrupt on line + 12 + 12 + 1 + + + SWIER13 + Software Interrupt on line + 13 + 13 + 1 + + + SWIER14 + Software Interrupt on line + 14 + 14 + 1 + + + SWIER15 + Software Interrupt on line + 15 + 15 + 1 + + + SWIER16 + Software Interrupt on line + 16 + 16 + 1 + + + SWIER17 + Software Interrupt on line + 17 + 17 + 1 + + + SWIER19 + Software Interrupt on line + 19 + 19 + 1 + + + + + PR + PR + Pending register (EXTI_PR) + 0x14 + 0x20 + read-write + 0x00000000 + + + PR0 + Pending bit 0 + 0 + 1 + + + PR1 + Pending bit 1 + 1 + 1 + + + PR2 + Pending bit 2 + 2 + 1 + + + PR3 + Pending bit 3 + 3 + 1 + + + PR4 + Pending bit 4 + 4 + 1 + + + PR5 + Pending bit 5 + 5 + 1 + + + PR6 + Pending bit 6 + 6 + 1 + + + PR7 + Pending bit 7 + 7 + 1 + + + PR8 + Pending bit 8 + 8 + 1 + + + PR9 + Pending bit 9 + 9 + 1 + + + PR10 + Pending bit 10 + 10 + 1 + + + PR11 + Pending bit 11 + 11 + 1 + + + PR12 + Pending bit 12 + 12 + 1 + + + PR13 + Pending bit 13 + 13 + 1 + + + PR14 + Pending bit 14 + 14 + 1 + + + PR15 + Pending bit 15 + 15 + 1 + + + PR16 + Pending bit 16 + 16 + 1 + + + PR17 + Pending bit 17 + 17 + 1 + + + PR19 + Pending bit 19 + 19 + 1 + + + + + + + NVIC + Nested Vectored Interrupt + Controller + NVIC + 0xE000E100 + + 0x0 + 0x33D + registers + + + + ISER + ISER + Interrupt Set Enable Register + 0x0 + 0x20 + read-write + 0x00000000 + + + SETENA + SETENA + 0 + 32 + + + + + ICER + ICER + Interrupt Clear Enable + Register + 0x80 + 0x20 + read-write + 0x00000000 + + + CLRENA + CLRENA + 0 + 32 + + + + + ISPR + ISPR + Interrupt Set-Pending Register + 0x100 + 0x20 + read-write + 0x00000000 + + + SETPEND + SETPEND + 0 + 32 + + + + + ICPR + ICPR + Interrupt Clear-Pending + Register + 0x180 + 0x20 + read-write + 0x00000000 + + + CLRPEND + CLRPEND + 0 + 32 + + + + + IPR0 + IPR0 + Interrupt Priority Register 0 + 0x300 + 0x20 + read-write + 0x00000000 + + + PRI_00 + PRI_00 + 6 + 2 + + + PRI_01 + PRI_01 + 14 + 2 + + + PRI_02 + PRI_02 + 22 + 2 + + + PRI_03 + PRI_03 + 30 + 2 + + + + + IPR1 + IPR1 + Interrupt Priority Register 1 + 0x304 + 0x20 + read-write + 0x00000000 + + + PRI_40 + PRI_40 + 6 + 2 + + + PRI_41 + PRI_41 + 14 + 2 + + + PRI_42 + PRI_42 + 22 + 2 + + + PRI_43 + PRI_43 + 30 + 2 + + + + + IPR2 + IPR2 + Interrupt Priority Register 2 + 0x308 + 0x20 + read-write + 0x00000000 + + + PRI_80 + PRI_80 + 6 + 2 + + + PRI_81 + PRI_81 + 14 + 2 + + + PRI_82 + PRI_82 + 22 + 2 + + + PRI_83 + PRI_83 + 30 + 2 + + + + + IPR3 + IPR3 + Interrupt Priority Register 3 + 0x30C + 0x20 + read-write + 0x00000000 + + + PRI_120 + PRI_120 + 6 + 2 + + + PRI_121 + PRI_121 + 14 + 2 + + + PRI_122 + PRI_122 + 22 + 2 + + + PRI_123 + PRI_123 + 30 + 2 + + + + + IPR4 + IPR4 + Interrupt Priority Register 4 + 0x310 + 0x20 + read-write + 0x00000000 + + + PRI_160 + PRI_160 + 6 + 2 + + + PRI_161 + PRI_161 + 14 + 2 + + + PRI_162 + PRI_162 + 22 + 2 + + + PRI_163 + PRI_163 + 30 + 2 + + + + + IPR5 + IPR5 + Interrupt Priority Register 5 + 0x314 + 0x20 + read-write + 0x00000000 + + + PRI_200 + PRI_200 + 6 + 2 + + + PRI_201 + PRI_201 + 14 + 2 + + + PRI_202 + PRI_202 + 22 + 2 + + + PRI_203 + PRI_203 + 30 + 2 + + + + + IPR6 + IPR6 + Interrupt Priority Register 6 + 0x318 + 0x20 + read-write + 0x00000000 + + + PRI_240 + PRI_240 + 6 + 2 + + + PRI_241 + PRI_241 + 14 + 2 + + + PRI_242 + PRI_242 + 22 + 2 + + + PRI_243 + PRI_243 + 30 + 2 + + + + + IPR7 + IPR7 + Interrupt Priority Register 7 + 0x31C + 0x20 + read-write + 0x00000000 + + + PRI_280 + PRI_280 + 6 + 2 + + + PRI_281 + PRI_281 + 14 + 2 + + + PRI_282 + PRI_282 + 22 + 2 + + + PRI_283 + PRI_283 + 30 + 2 + + + + + + + DMA + DMA controller + DMA + 0x40020000 + + 0x0 + 0x400 + registers + + + DMA_CH1 + DMA channel 1 interrupt + 9 + + + DMA_CH2_3 + DMA channel 2 and 3 interrupts + 10 + + + DMA_CH4_5_6_7 + DMA channel 4, 5, 6 and 7 + interrupts + 11 + + + + ISR + ISR + DMA interrupt status register + (DMA_ISR) + 0x0 + 0x20 + read-only + 0x00000000 + + + GIF1 + Channel 1 Global interrupt + flag + 0 + 1 + + + TCIF1 + Channel 1 Transfer Complete + flag + 1 + 1 + + + HTIF1 + Channel 1 Half Transfer Complete + flag + 2 + 1 + + + TEIF1 + Channel 1 Transfer Error + flag + 3 + 1 + + + GIF2 + Channel 2 Global interrupt + flag + 4 + 1 + + + TCIF2 + Channel 2 Transfer Complete + flag + 5 + 1 + + + HTIF2 + Channel 2 Half Transfer Complete + flag + 6 + 1 + + + TEIF2 + Channel 2 Transfer Error + flag + 7 + 1 + + + GIF3 + Channel 3 Global interrupt + flag + 8 + 1 + + + TCIF3 + Channel 3 Transfer Complete + flag + 9 + 1 + + + HTIF3 + Channel 3 Half Transfer Complete + flag + 10 + 1 + + + TEIF3 + Channel 3 Transfer Error + flag + 11 + 1 + + + GIF4 + Channel 4 Global interrupt + flag + 12 + 1 + + + TCIF4 + Channel 4 Transfer Complete + flag + 13 + 1 + + + HTIF4 + Channel 4 Half Transfer Complete + flag + 14 + 1 + + + TEIF4 + Channel 4 Transfer Error + flag + 15 + 1 + + + GIF5 + Channel 5 Global interrupt + flag + 16 + 1 + + + TCIF5 + Channel 5 Transfer Complete + flag + 17 + 1 + + + HTIF5 + Channel 5 Half Transfer Complete + flag + 18 + 1 + + + TEIF5 + Channel 5 Transfer Error + flag + 19 + 1 + + + GIF6 + Channel 6 Global interrupt + flag + 20 + 1 + + + TCIF6 + Channel 6 Transfer Complete + flag + 21 + 1 + + + HTIF6 + Channel 6 Half Transfer Complete + flag + 22 + 1 + + + TEIF6 + Channel 6 Transfer Error + flag + 23 + 1 + + + GIF7 + Channel 7 Global interrupt + flag + 24 + 1 + + + TCIF7 + Channel 7 Transfer Complete + flag + 25 + 1 + + + HTIF7 + Channel 7 Half Transfer Complete + flag + 26 + 1 + + + TEIF7 + Channel 7 Transfer Error + flag + 27 + 1 + + + + + IFCR + IFCR + DMA interrupt flag clear register + (DMA_IFCR) + 0x4 + 0x20 + write-only + 0x00000000 + + + CGIF1 + Channel 1 Global interrupt + clear + 0 + 1 + + + CTCIF1 + Channel 1 Transfer Complete + clear + 1 + 1 + + + CHTIF1 + Channel 1 Half Transfer + clear + 2 + 1 + + + CTEIF1 + Channel 1 Transfer Error + clear + 3 + 1 + + + CGIF2 + Channel 2 Global interrupt + clear + 4 + 1 + + + CTCIF2 + Channel 2 Transfer Complete + clear + 5 + 1 + + + CHTIF2 + Channel 2 Half Transfer + clear + 6 + 1 + + + CTEIF2 + Channel 2 Transfer Error + clear + 7 + 1 + + + CGIF3 + Channel 3 Global interrupt + clear + 8 + 1 + + + CTCIF3 + Channel 3 Transfer Complete + clear + 9 + 1 + + + CHTIF3 + Channel 3 Half Transfer + clear + 10 + 1 + + + CTEIF3 + Channel 3 Transfer Error + clear + 11 + 1 + + + CGIF4 + Channel 4 Global interrupt + clear + 12 + 1 + + + CTCIF4 + Channel 4 Transfer Complete + clear + 13 + 1 + + + CHTIF4 + Channel 4 Half Transfer + clear + 14 + 1 + + + CTEIF4 + Channel 4 Transfer Error + clear + 15 + 1 + + + CGIF5 + Channel 5 Global interrupt + clear + 16 + 1 + + + CTCIF5 + Channel 5 Transfer Complete + clear + 17 + 1 + + + CHTIF5 + Channel 5 Half Transfer + clear + 18 + 1 + + + CTEIF5 + Channel 5 Transfer Error + clear + 19 + 1 + + + CGIF6 + Channel 6 Global interrupt + clear + 20 + 1 + + + CTCIF6 + Channel 6 Transfer Complete + clear + 21 + 1 + + + CHTIF6 + Channel 6 Half Transfer + clear + 22 + 1 + + + CTEIF6 + Channel 6 Transfer Error + clear + 23 + 1 + + + CGIF7 + Channel 7 Global interrupt + clear + 24 + 1 + + + CTCIF7 + Channel 7 Transfer Complete + clear + 25 + 1 + + + CHTIF7 + Channel 7 Half Transfer + clear + 26 + 1 + + + CTEIF7 + Channel 7 Transfer Error + clear + 27 + 1 + + + + + CCR1 + CCR1 + DMA channel configuration register + (DMA_CCR) + 0x8 + 0x20 + read-write + 0x00000000 + + + EN + Channel enable + 0 + 1 + + + TCIE + Transfer complete interrupt + enable + 1 + 1 + + + HTIE + Half Transfer interrupt + enable + 2 + 1 + + + TEIE + Transfer error interrupt + enable + 3 + 1 + + + DIR + Data transfer direction + 4 + 1 + + + CIRC + Circular mode + 5 + 1 + + + PINC + Peripheral increment mode + 6 + 1 + + + MINC + Memory increment mode + 7 + 1 + + + PSIZE + Peripheral size + 8 + 2 + + + MSIZE + Memory size + 10 + 2 + + + PL + Channel Priority level + 12 + 2 + + + MEM2MEM + Memory to memory mode + 14 + 1 + + + + + CNDTR1 + CNDTR1 + DMA channel 1 number of data + register + 0xC + 0x20 + read-write + 0x00000000 + + + NDT + Number of data to transfer + 0 + 16 + + + + + CPAR1 + CPAR1 + DMA channel 1 peripheral address + register + 0x10 + 0x20 + read-write + 0x00000000 + + + PA + Peripheral address + 0 + 32 + + + + + CMAR1 + CMAR1 + DMA channel 1 memory address + register + 0x14 + 0x20 + read-write + 0x00000000 + + + MA + Memory address + 0 + 32 + + + + + CCR2 + CCR2 + DMA channel configuration register + (DMA_CCR) + 0x1C + 0x20 + read-write + 0x00000000 + + + EN + Channel enable + 0 + 1 + + + TCIE + Transfer complete interrupt + enable + 1 + 1 + + + HTIE + Half Transfer interrupt + enable + 2 + 1 + + + TEIE + Transfer error interrupt + enable + 3 + 1 + + + DIR + Data transfer direction + 4 + 1 + + + CIRC + Circular mode + 5 + 1 + + + PINC + Peripheral increment mode + 6 + 1 + + + MINC + Memory increment mode + 7 + 1 + + + PSIZE + Peripheral size + 8 + 2 + + + MSIZE + Memory size + 10 + 2 + + + PL + Channel Priority level + 12 + 2 + + + MEM2MEM + Memory to memory mode + 14 + 1 + + + + + CNDTR2 + CNDTR2 + DMA channel 2 number of data + register + 0x20 + 0x20 + read-write + 0x00000000 + + + NDT + Number of data to transfer + 0 + 16 + + + + + CPAR2 + CPAR2 + DMA channel 2 peripheral address + register + 0x24 + 0x20 + read-write + 0x00000000 + + + PA + Peripheral address + 0 + 32 + + + + + CMAR2 + CMAR2 + DMA channel 2 memory address + register + 0x28 + 0x20 + read-write + 0x00000000 + + + MA + Memory address + 0 + 32 + + + + + CCR3 + CCR3 + DMA channel configuration register + (DMA_CCR) + 0x30 + 0x20 + read-write + 0x00000000 + + + EN + Channel enable + 0 + 1 + + + TCIE + Transfer complete interrupt + enable + 1 + 1 + + + HTIE + Half Transfer interrupt + enable + 2 + 1 + + + TEIE + Transfer error interrupt + enable + 3 + 1 + + + DIR + Data transfer direction + 4 + 1 + + + CIRC + Circular mode + 5 + 1 + + + PINC + Peripheral increment mode + 6 + 1 + + + MINC + Memory increment mode + 7 + 1 + + + PSIZE + Peripheral size + 8 + 2 + + + MSIZE + Memory size + 10 + 2 + + + PL + Channel Priority level + 12 + 2 + + + MEM2MEM + Memory to memory mode + 14 + 1 + + + + + CNDTR3 + CNDTR3 + DMA channel 3 number of data + register + 0x34 + 0x20 + read-write + 0x00000000 + + + NDT + Number of data to transfer + 0 + 16 + + + + + CPAR3 + CPAR3 + DMA channel 3 peripheral address + register + 0x38 + 0x20 + read-write + 0x00000000 + + + PA + Peripheral address + 0 + 32 + + + + + CMAR3 + CMAR3 + DMA channel 3 memory address + register + 0x3C + 0x20 + read-write + 0x00000000 + + + MA + Memory address + 0 + 32 + + + + + CCR4 + CCR4 + DMA channel configuration register + (DMA_CCR) + 0x44 + 0x20 + read-write + 0x00000000 + + + EN + Channel enable + 0 + 1 + + + TCIE + Transfer complete interrupt + enable + 1 + 1 + + + HTIE + Half Transfer interrupt + enable + 2 + 1 + + + TEIE + Transfer error interrupt + enable + 3 + 1 + + + DIR + Data transfer direction + 4 + 1 + + + CIRC + Circular mode + 5 + 1 + + + PINC + Peripheral increment mode + 6 + 1 + + + MINC + Memory increment mode + 7 + 1 + + + PSIZE + Peripheral size + 8 + 2 + + + MSIZE + Memory size + 10 + 2 + + + PL + Channel Priority level + 12 + 2 + + + MEM2MEM + Memory to memory mode + 14 + 1 + + + + + CNDTR4 + CNDTR4 + DMA channel 4 number of data + register + 0x48 + 0x20 + read-write + 0x00000000 + + + NDT + Number of data to transfer + 0 + 16 + + + + + CPAR4 + CPAR4 + DMA channel 4 peripheral address + register + 0x4C + 0x20 + read-write + 0x00000000 + + + PA + Peripheral address + 0 + 32 + + + + + CMAR4 + CMAR4 + DMA channel 4 memory address + register + 0x50 + 0x20 + read-write + 0x00000000 + + + MA + Memory address + 0 + 32 + + + + + CCR5 + CCR5 + DMA channel configuration register + (DMA_CCR) + 0x58 + 0x20 + read-write + 0x00000000 + + + EN + Channel enable + 0 + 1 + + + TCIE + Transfer complete interrupt + enable + 1 + 1 + + + HTIE + Half Transfer interrupt + enable + 2 + 1 + + + TEIE + Transfer error interrupt + enable + 3 + 1 + + + DIR + Data transfer direction + 4 + 1 + + + CIRC + Circular mode + 5 + 1 + + + PINC + Peripheral increment mode + 6 + 1 + + + MINC + Memory increment mode + 7 + 1 + + + PSIZE + Peripheral size + 8 + 2 + + + MSIZE + Memory size + 10 + 2 + + + PL + Channel Priority level + 12 + 2 + + + MEM2MEM + Memory to memory mode + 14 + 1 + + + + + CNDTR5 + CNDTR5 + DMA channel 5 number of data + register + 0x5C + 0x20 + read-write + 0x00000000 + + + NDT + Number of data to transfer + 0 + 16 + + + + + CPAR5 + CPAR5 + DMA channel 5 peripheral address + register + 0x60 + 0x20 + read-write + 0x00000000 + + + PA + Peripheral address + 0 + 32 + + + + + CMAR5 + CMAR5 + DMA channel 5 memory address + register + 0x64 + 0x20 + read-write + 0x00000000 + + + MA + Memory address + 0 + 32 + + + + + CCR6 + CCR6 + DMA channel configuration register + (DMA_CCR) + 0x6C + 0x20 + read-write + 0x00000000 + + + EN + Channel enable + 0 + 1 + + + TCIE + Transfer complete interrupt + enable + 1 + 1 + + + HTIE + Half Transfer interrupt + enable + 2 + 1 + + + TEIE + Transfer error interrupt + enable + 3 + 1 + + + DIR + Data transfer direction + 4 + 1 + + + CIRC + Circular mode + 5 + 1 + + + PINC + Peripheral increment mode + 6 + 1 + + + MINC + Memory increment mode + 7 + 1 + + + PSIZE + Peripheral size + 8 + 2 + + + MSIZE + Memory size + 10 + 2 + + + PL + Channel Priority level + 12 + 2 + + + MEM2MEM + Memory to memory mode + 14 + 1 + + + + + CNDTR6 + CNDTR6 + DMA channel 6 number of data + register + 0x70 + 0x20 + read-write + 0x00000000 + + + NDT + Number of data to transfer + 0 + 16 + + + + + CPAR6 + CPAR6 + DMA channel 6 peripheral address + register + 0x74 + 0x20 + read-write + 0x00000000 + + + PA + Peripheral address + 0 + 32 + + + + + CMAR6 + CMAR6 + DMA channel 6 memory address + register + 0x78 + 0x20 + read-write + 0x00000000 + + + MA + Memory address + 0 + 32 + + + + + CCR7 + CCR7 + DMA channel configuration register + (DMA_CCR) + 0x80 + 0x20 + read-write + 0x00000000 + + + EN + Channel enable + 0 + 1 + + + TCIE + Transfer complete interrupt + enable + 1 + 1 + + + HTIE + Half Transfer interrupt + enable + 2 + 1 + + + TEIE + Transfer error interrupt + enable + 3 + 1 + + + DIR + Data transfer direction + 4 + 1 + + + CIRC + Circular mode + 5 + 1 + + + PINC + Peripheral increment mode + 6 + 1 + + + MINC + Memory increment mode + 7 + 1 + + + PSIZE + Peripheral size + 8 + 2 + + + MSIZE + Memory size + 10 + 2 + + + PL + Channel Priority level + 12 + 2 + + + MEM2MEM + Memory to memory mode + 14 + 1 + + + + + CNDTR7 + CNDTR7 + DMA channel 7 number of data + register + 0x84 + 0x20 + read-write + 0x00000000 + + + NDT + Number of data to transfer + 0 + 16 + + + + + CPAR7 + CPAR7 + DMA channel 7 peripheral address + register + 0x88 + 0x20 + read-write + 0x00000000 + + + PA + Peripheral address + 0 + 32 + + + + + CMAR7 + CMAR7 + DMA channel 7 memory address + register + 0x8C + 0x20 + read-write + 0x00000000 + + + MA + Memory address + 0 + 32 + + + + + + + RCC + Reset and clock control + RCC + 0x40021000 + + 0x0 + 0x400 + registers + + + RCC_CRS + RCC and CRS global interrupts + 4 + + + + CR + CR + Clock control register + 0x0 + 0x20 + 0x00000083 + + + HSION + Internal High Speed clock + enable + 0 + 1 + read-write + + + HSIRDY + Internal High Speed clock ready + flag + 1 + 1 + read-only + + + HSITRIM + Internal High Speed clock + trimming + 3 + 5 + read-write + + + HSICAL + Internal High Speed clock + Calibration + 8 + 8 + read-only + + + HSEON + External High Speed clock + enable + 16 + 1 + read-write + + + HSERDY + External High Speed clock ready + flag + 17 + 1 + read-only + + + HSEBYP + External High Speed clock + Bypass + 18 + 1 + read-write + + + CSSON + Clock Security System + enable + 19 + 1 + read-write + + + PLLON + PLL enable + 24 + 1 + read-write + + + PLLRDY + PLL clock ready flag + 25 + 1 + read-only + + + + + CFGR + CFGR + Clock configuration register + (RCC_CFGR) + 0x4 + 0x20 + 0x00000000 + + + SW + System clock Switch + 0 + 2 + read-write + + + SWS + System Clock Switch Status + 2 + 2 + read-only + + + HPRE + AHB prescaler + 4 + 4 + read-write + + + PPRE + APB Low speed prescaler + (APB1) + 8 + 3 + read-write + + + ADCPRE + ADC prescaler + 14 + 1 + read-write + + + PLLSRC + PLL input clock source + 15 + 2 + read-write + + + PLLXTPRE + HSE divider for PLL entry + 17 + 1 + read-write + + + PLLMUL + PLL Multiplication Factor + 18 + 4 + read-write + + + MCO + Microcontroller clock + output + 24 + 3 + read-write + + + MCOPRE + Microcontroller Clock Output + Prescaler + 28 + 3 + read-write + + + PLLNODIV + PLL clock not divided for + MCO + 31 + 1 + read-write + + + + + CIR + CIR + Clock interrupt register + (RCC_CIR) + 0x8 + 0x20 + 0x00000000 + + + LSIRDYF + LSI Ready Interrupt flag + 0 + 1 + read-only + + + LSERDYF + LSE Ready Interrupt flag + 1 + 1 + read-only + + + HSIRDYF + HSI Ready Interrupt flag + 2 + 1 + read-only + + + HSERDYF + HSE Ready Interrupt flag + 3 + 1 + read-only + + + PLLRDYF + PLL Ready Interrupt flag + 4 + 1 + read-only + + + HSI14RDYF + HSI14 ready interrupt flag + 5 + 1 + read-only + + + HSI48RDYF + HSI48 ready interrupt flag + 6 + 1 + read-only + + + CSSF + Clock Security System Interrupt + flag + 7 + 1 + read-only + + + LSIRDYIE + LSI Ready Interrupt Enable + 8 + 1 + read-write + + + LSERDYIE + LSE Ready Interrupt Enable + 9 + 1 + read-write + + + HSIRDYIE + HSI Ready Interrupt Enable + 10 + 1 + read-write + + + HSERDYIE + HSE Ready Interrupt Enable + 11 + 1 + read-write + + + PLLRDYIE + PLL Ready Interrupt Enable + 12 + 1 + read-write + + + HSI14RDYE + HSI14 ready interrupt + enable + 13 + 1 + read-write + + + HSI48RDYIE + HSI48 ready interrupt + enable + 14 + 1 + read-write + + + LSIRDYC + LSI Ready Interrupt Clear + 16 + 1 + write-only + + + LSERDYC + LSE Ready Interrupt Clear + 17 + 1 + write-only + + + HSIRDYC + HSI Ready Interrupt Clear + 18 + 1 + write-only + + + HSERDYC + HSE Ready Interrupt Clear + 19 + 1 + write-only + + + PLLRDYC + PLL Ready Interrupt Clear + 20 + 1 + write-only + + + HSI14RDYC + HSI 14 MHz Ready Interrupt + Clear + 21 + 1 + write-only + + + HSI48RDYC + HSI48 Ready Interrupt + Clear + 22 + 1 + write-only + + + CSSC + Clock security system interrupt + clear + 23 + 1 + write-only + + + + + APB2RSTR + APB2RSTR + APB2 peripheral reset register + (RCC_APB2RSTR) + 0xC + 0x20 + read-write + 0x00000000 + + + SYSCFGRST + SYSCFG and COMP reset + 0 + 1 + + + ADCRST + ADC interface reset + 9 + 1 + + + TIM1RST + TIM1 timer reset + 11 + 1 + + + SPI1RST + SPI 1 reset + 12 + 1 + + + USART1RST + USART1 reset + 14 + 1 + + + TIM15RST + TIM15 timer reset + 16 + 1 + + + TIM16RST + TIM16 timer reset + 17 + 1 + + + TIM17RST + TIM17 timer reset + 18 + 1 + + + DBGMCURST + Debug MCU reset + 22 + 1 + + + + + APB1RSTR + APB1RSTR + APB1 peripheral reset register + (RCC_APB1RSTR) + 0x10 + 0x20 + read-write + 0x00000000 + + + TIM2RST + Timer 2 reset + 0 + 1 + + + TIM3RST + Timer 3 reset + 1 + 1 + + + TIM6RST + Timer 6 reset + 4 + 1 + + + TIM7RST + TIM7 timer reset + 5 + 1 + + + TIM14RST + Timer 14 reset + 8 + 1 + + + WWDGRST + Window watchdog reset + 11 + 1 + + + SPI2RST + SPI2 reset + 14 + 1 + + + USART2RST + USART 2 reset + 17 + 1 + + + USART3RST + USART3 reset + 18 + 1 + + + USART4RST + USART4 reset + 19 + 1 + + + I2C1RST + I2C1 reset + 21 + 1 + + + I2C2RST + I2C2 reset + 22 + 1 + + + USBRST + USB interface reset + 23 + 1 + + + CANRST + CAN interface reset + 25 + 1 + + + CRSRST + Clock Recovery System interface + reset + 27 + 1 + + + PWRRST + Power interface reset + 28 + 1 + + + DACRST + DAC interface reset + 29 + 1 + + + CECRST + HDMI CEC reset + 30 + 1 + + + + + AHBENR + AHBENR + AHB Peripheral Clock enable register + (RCC_AHBENR) + 0x14 + 0x20 + read-write + 0x00000014 + + + DMAEN + DMA1 clock enable + 0 + 1 + + + SRAMEN + SRAM interface clock + enable + 2 + 1 + + + FLITFEN + FLITF clock enable + 4 + 1 + + + CRCEN + CRC clock enable + 6 + 1 + + + IOPAEN + I/O port A clock enable + 17 + 1 + + + IOPBEN + I/O port B clock enable + 18 + 1 + + + IOPCEN + I/O port C clock enable + 19 + 1 + + + IOPDEN + I/O port D clock enable + 20 + 1 + + + IOPFEN + I/O port F clock enable + 22 + 1 + + + TSCEN + Touch sensing controller clock + enable + 24 + 1 + + + + + APB2ENR + APB2ENR + APB2 peripheral clock enable register + (RCC_APB2ENR) + 0x18 + 0x20 + read-write + 0x00000000 + + + SYSCFGEN + SYSCFG clock enable + 0 + 1 + + + ADCEN + ADC 1 interface clock + enable + 9 + 1 + + + TIM1EN + TIM1 Timer clock enable + 11 + 1 + + + SPI1EN + SPI 1 clock enable + 12 + 1 + + + USART1EN + USART1 clock enable + 14 + 1 + + + TIM15EN + TIM15 timer clock enable + 16 + 1 + + + TIM16EN + TIM16 timer clock enable + 17 + 1 + + + TIM17EN + TIM17 timer clock enable + 18 + 1 + + + DBGMCUEN + MCU debug module clock + enable + 22 + 1 + + + + + APB1ENR + APB1ENR + APB1 peripheral clock enable register + (RCC_APB1ENR) + 0x1C + 0x20 + read-write + 0x00000000 + + + TIM2EN + Timer 2 clock enable + 0 + 1 + + + TIM3EN + Timer 3 clock enable + 1 + 1 + + + TIM6EN + Timer 6 clock enable + 4 + 1 + + + TIM7EN + TIM7 timer clock enable + 5 + 1 + + + TIM14EN + Timer 14 clock enable + 8 + 1 + + + WWDGEN + Window watchdog clock + enable + 11 + 1 + + + SPI2EN + SPI 2 clock enable + 14 + 1 + + + USART2EN + USART 2 clock enable + 17 + 1 + + + USART3EN + USART3 clock enable + 18 + 1 + + + USART4EN + USART4 clock enable + 19 + 1 + + + I2C1EN + I2C 1 clock enable + 21 + 1 + + + I2C2EN + I2C 2 clock enable + 22 + 1 + + + USBRST + USB interface clock enable + 23 + 1 + + + CANEN + CAN interface clock enable + 25 + 1 + + + CRSEN + Clock Recovery System interface clock + enable + 27 + 1 + + + PWREN + Power interface clock + enable + 28 + 1 + + + DACEN + DAC interface clock enable + 29 + 1 + + + CECEN + HDMI CEC interface clock + enable + 30 + 1 + + + + + BDCR + BDCR + Backup domain control register + (RCC_BDCR) + 0x20 + 0x20 + 0x00000000 + + + LSEON + External Low Speed oscillator + enable + 0 + 1 + read-write + + + LSERDY + External Low Speed oscillator + ready + 1 + 1 + read-only + + + LSEBYP + External Low Speed oscillator + bypass + 2 + 1 + read-write + + + LSEDRV + LSE oscillator drive + capability + 3 + 2 + read-write + + + RTCSEL + RTC clock source selection + 8 + 2 + read-write + + + RTCEN + RTC clock enable + 15 + 1 + read-write + + + BDRST + Backup domain software + reset + 16 + 1 + read-write + + + + + CSR + CSR + Control/status register + (RCC_CSR) + 0x24 + 0x20 + 0x0C000000 + + + LSION + Internal low speed oscillator + enable + 0 + 1 + read-write + + + LSIRDY + Internal low speed oscillator + ready + 1 + 1 + read-only + + + RMVF + Remove reset flag + 24 + 1 + read-write + + + OBLRSTF + Option byte loader reset + flag + 25 + 1 + read-write + + + PINRSTF + PIN reset flag + 26 + 1 + read-write + + + PORRSTF + POR/PDR reset flag + 27 + 1 + read-write + + + SFTRSTF + Software reset flag + 28 + 1 + read-write + + + IWDGRSTF + Independent watchdog reset + flag + 29 + 1 + read-write + + + WWDGRSTF + Window watchdog reset flag + 30 + 1 + read-write + + + LPWRRSTF + Low-power reset flag + 31 + 1 + read-write + + + + + AHBRSTR + AHBRSTR + AHB peripheral reset register + 0x28 + 0x20 + read-write + 0x00000000 + + + IOPARST + I/O port A reset + 17 + 1 + + + IOPBRST + I/O port B reset + 18 + 1 + + + IOPCRST + I/O port C reset + 19 + 1 + + + IOPDRST + I/O port D reset + 20 + 1 + + + IOPFRST + I/O port F reset + 22 + 1 + + + TSCRST + Touch sensing controller + reset + 24 + 1 + + + + + CFGR2 + CFGR2 + Clock configuration register 2 + 0x2C + 0x20 + read-write + 0x00000000 + + + PREDIV + PREDIV division factor + 0 + 4 + + + + + CFGR3 + CFGR3 + Clock configuration register 3 + 0x30 + 0x20 + read-write + 0x00000000 + + + USART1SW + USART1 clock source + selection + 0 + 2 + + + I2C1SW + I2C1 clock source + selection + 4 + 1 + + + CECSW + HDMI CEC clock source + selection + 6 + 1 + + + USBSW + USB clock source selection + 7 + 1 + + + ADCSW + ADC clock source selection + 8 + 1 + + + USART2SW + USART2 clock source + selection + 16 + 2 + + + + + CR2 + CR2 + Clock control register 2 + 0x34 + 0x20 + 0x00000080 + + + HSI14ON + HSI14 clock enable + 0 + 1 + read-write + + + HSI14RDY + HR14 clock ready flag + 1 + 1 + read-only + + + HSI14DIS + HSI14 clock request from ADC + disable + 2 + 1 + read-write + + + HSI14TRIM + HSI14 clock trimming + 3 + 5 + read-write + + + HSI14CAL + HSI14 clock calibration + 8 + 8 + read-only + + + HSI48ON + HSI48 clock enable + 16 + 1 + read-write + + + HSI48RDY + HSI48 clock ready flag + 17 + 1 + read-only + + + HSI48CAL + HSI48 factory clock + calibration + 24 + 1 + read-only + + + + + + + SYSCFG + System configuration controller + SYSCFG + 0x40010000 + + 0x0 + 0x400 + registers + + + + CFGR1 + CFGR1 + configuration register 1 + 0x0 + 0x20 + read-write + 0x00000000 + + + MEM_MODE + Memory mapping selection + bits + 0 + 2 + + + ADC_DMA_RMP + ADC DMA remapping bit + 8 + 1 + + + USART1_TX_DMA_RMP + USART1_TX DMA remapping + bit + 9 + 1 + + + USART1_RX_DMA_RMP + USART1_RX DMA request remapping + bit + 10 + 1 + + + TIM16_DMA_RMP + TIM16 DMA request remapping + bit + 11 + 1 + + + TIM17_DMA_RMP + TIM17 DMA request remapping + bit + 12 + 1 + + + I2C_PB6_FM + Fast Mode Plus (FM plus) driving + capability activation bits. + 16 + 1 + + + I2C_PB7_FM + Fast Mode Plus (FM+) driving capability + activation bits. + 17 + 1 + + + I2C_PB8_FM + Fast Mode Plus (FM+) driving capability + activation bits. + 18 + 1 + + + I2C_PB9_FM + Fast Mode Plus (FM+) driving capability + activation bits. + 19 + 1 + + + I2C1_FM_plus + FM+ driving capability activation for + I2C1 + 20 + 1 + + + I2C2_FM_plus + FM+ driving capability activation for + I2C2 + 21 + 1 + + + SPI2_DMA_RMP + SPI2 DMA request remapping + bit + 24 + 1 + + + USART2_DMA_RMP + USART2 DMA request remapping + bit + 25 + 1 + + + USART3_DMA_RMP + USART3 DMA request remapping + bit + 26 + 1 + + + I2C1_DMA_RMP + I2C1 DMA request remapping + bit + 27 + 1 + + + TIM1_DMA_RMP + TIM1 DMA request remapping + bit + 28 + 1 + + + TIM2_DMA_RMP + TIM2 DMA request remapping + bit + 29 + 1 + + + TIM3_DMA_RMP + TIM3 DMA request remapping + bit + 30 + 1 + + + + + EXTICR1 + EXTICR1 + external interrupt configuration register + 1 + 0x8 + 0x20 + read-write + 0x0000 + + + EXTI3 + EXTI 3 configuration bits + 12 + 4 + + + EXTI2 + EXTI 2 configuration bits + 8 + 4 + + + EXTI1 + EXTI 1 configuration bits + 4 + 4 + + + EXTI0 + EXTI 0 configuration bits + 0 + 4 + + + + + EXTICR2 + EXTICR2 + external interrupt configuration register + 2 + 0xC + 0x20 + read-write + 0x0000 + + + EXTI7 + EXTI 7 configuration bits + 12 + 4 + + + EXTI6 + EXTI 6 configuration bits + 8 + 4 + + + EXTI5 + EXTI 5 configuration bits + 4 + 4 + + + EXTI4 + EXTI 4 configuration bits + 0 + 4 + + + + + EXTICR3 + EXTICR3 + external interrupt configuration register + 3 + 0x10 + 0x20 + read-write + 0x0000 + + + EXTI11 + EXTI 11 configuration bits + 12 + 4 + + + EXTI10 + EXTI 10 configuration bits + 8 + 4 + + + EXTI9 + EXTI 9 configuration bits + 4 + 4 + + + EXTI8 + EXTI 8 configuration bits + 0 + 4 + + + + + EXTICR4 + EXTICR4 + external interrupt configuration register + 4 + 0x14 + 0x20 + read-write + 0x0000 + + + EXTI15 + EXTI 15 configuration bits + 12 + 4 + + + EXTI14 + EXTI 14 configuration bits + 8 + 4 + + + EXTI13 + EXTI 13 configuration bits + 4 + 4 + + + EXTI12 + EXTI 12 configuration bits + 0 + 4 + + + + + CFGR2 + CFGR2 + configuration register 2 + 0x18 + 0x20 + read-write + 0x0000 + + + SRAM_PEF + SRAM parity flag + 8 + 1 + + + PVD_LOCK + PVD lock enable bit + 2 + 1 + + + SRAM_PARITY_LOCK + SRAM parity lock bit + 1 + 1 + + + LOCUP_LOCK + Cortex-M0 LOCKUP bit enable + bit + 0 + 1 + + + + + + + ADC + Analog-to-digital converter + ADC + 0x40012400 + + 0x0 + 0x400 + registers + + + ADC_COMP + ADC and comparator interrupts + 12 + + + + ISR + ISR + interrupt and status register + 0x0 + 0x20 + read-write + 0x00000000 + + + AWD + Analog watchdog flag + 7 + 1 + + + OVR + ADC overrun + 4 + 1 + + + EOS + End of sequence flag + 3 + 1 + + + EOC + End of conversion flag + 2 + 1 + + + EOSMP + End of sampling flag + 1 + 1 + + + ADRDY + ADC ready + 0 + 1 + + + + + IER + IER + interrupt enable register + 0x4 + 0x20 + read-write + 0x00000000 + + + AWDIE + Analog watchdog interrupt + enable + 7 + 1 + + + OVRIE + Overrun interrupt enable + 4 + 1 + + + EOSIE + End of conversion sequence interrupt + enable + 3 + 1 + + + EOCIE + End of conversion interrupt + enable + 2 + 1 + + + EOSMPIE + End of sampling flag interrupt + enable + 1 + 1 + + + ADRDYIE + ADC ready interrupt enable + 0 + 1 + + + + + CR + CR + control register + 0x8 + 0x20 + read-write + 0x00000000 + + + ADCAL + ADC calibration + 31 + 1 + + + ADSTP + ADC stop conversion + command + 4 + 1 + + + ADSTART + ADC start conversion + command + 2 + 1 + + + ADDIS + ADC disable command + 1 + 1 + + + ADEN + ADC enable command + 0 + 1 + + + + + CFGR1 + CFGR1 + configuration register 1 + 0xC + 0x20 + read-write + 0x00000000 + + + AWDCH + Analog watchdog channel + selection + 26 + 5 + + + AWDEN + Analog watchdog enable + 23 + 1 + + + AWDSGL + Enable the watchdog on a single channel + or on all channels + 22 + 1 + + + DISCEN + Discontinuous mode + 16 + 1 + + + AUTOFF + Auto-off mode + 15 + 1 + + + AUTDLY + Auto-delayed conversion + mode + 14 + 1 + + + CONT + Single / continuous conversion + mode + 13 + 1 + + + OVRMOD + Overrun management mode + 12 + 1 + + + EXTEN + External trigger enable and polarity + selection + 10 + 2 + + + EXTSEL + External trigger selection + 6 + 3 + + + ALIGN + Data alignment + 5 + 1 + + + RES + Data resolution + 3 + 2 + + + SCANDIR + Scan sequence direction + 2 + 1 + + + DMACFG + Direct memery access + configuration + 1 + 1 + + + DMAEN + Direct memory access + enable + 0 + 1 + + + + + CFGR2 + CFGR2 + configuration register 2 + 0x10 + 0x20 + read-write + 0x00008000 + + + JITOFF_D4 + JITOFF_D4 + 31 + 1 + + + JITOFF_D2 + JITOFF_D2 + 30 + 1 + + + + + SMPR + SMPR + sampling time register + 0x14 + 0x20 + read-write + 0x00000000 + + + SMPR + Sampling time selection + 0 + 3 + + + + + TR + TR + watchdog threshold register + 0x20 + 0x20 + read-write + 0x00000FFF + + + HT + Analog watchdog higher + threshold + 16 + 12 + + + LT + Analog watchdog lower + threshold + 0 + 12 + + + + + CHSELR + CHSELR + channel selection register + 0x28 + 0x20 + read-write + 0x00000000 + + + CHSEL18 + Channel-x selection + 18 + 1 + + + CHSEL17 + Channel-x selection + 17 + 1 + + + CHSEL16 + Channel-x selection + 16 + 1 + + + CHSEL15 + Channel-x selection + 15 + 1 + + + CHSEL14 + Channel-x selection + 14 + 1 + + + CHSEL13 + Channel-x selection + 13 + 1 + + + CHSEL12 + Channel-x selection + 12 + 1 + + + CHSEL11 + Channel-x selection + 11 + 1 + + + CHSEL10 + Channel-x selection + 10 + 1 + + + CHSEL9 + Channel-x selection + 9 + 1 + + + CHSEL8 + Channel-x selection + 8 + 1 + + + CHSEL7 + Channel-x selection + 7 + 1 + + + CHSEL6 + Channel-x selection + 6 + 1 + + + CHSEL5 + Channel-x selection + 5 + 1 + + + CHSEL4 + Channel-x selection + 4 + 1 + + + CHSEL3 + Channel-x selection + 3 + 1 + + + CHSEL2 + Channel-x selection + 2 + 1 + + + CHSEL1 + Channel-x selection + 1 + 1 + + + CHSEL0 + Channel-x selection + 0 + 1 + + + + + DR + DR + data register + 0x40 + 0x20 + read-only + 0x00000000 + + + DATA + Converted data + 0 + 16 + + + + + CCR + CCR + common configuration register + 0x308 + 0x20 + read-write + 0x00000000 + + + VBATEN + VBAT enable + 24 + 1 + + + TSEN + Temperature sensor enable + 23 + 1 + + + VREFEN + Temperature sensor and VREFINT + enable + 22 + 1 + + + + + + + USART1 + Universal synchronous asynchronous receiver + transmitter + USART + 0x40013800 + + 0x0 + 0x400 + registers + + + USART1 + USART1 global interrupt + 27 + + + + CR1 + CR1 + Control register 1 + 0x0 + 0x20 + read-write + 0x0000 + + + UE + USART enable + 0 + 1 + + + UESM + USART enable in Stop mode + 1 + 1 + + + RE + Receiver enable + 2 + 1 + + + TE + Transmitter enable + 3 + 1 + + + IDLEIE + IDLE interrupt enable + 4 + 1 + + + RXNEIE + RXNE interrupt enable + 5 + 1 + + + TCIE + Transmission complete interrupt + enable + 6 + 1 + + + TXEIE + interrupt enable + 7 + 1 + + + PEIE + PE interrupt enable + 8 + 1 + + + PS + Parity selection + 9 + 1 + + + PCE + Parity control enable + 10 + 1 + + + WAKE + Receiver wakeup method + 11 + 1 + + + M + Word length + 12 + 1 + + + MME + Mute mode enable + 13 + 1 + + + CMIE + Character match interrupt + enable + 14 + 1 + + + OVER8 + Oversampling mode + 15 + 1 + + + DEDT + Driver Enable deassertion + time + 16 + 5 + + + DEAT + Driver Enable assertion + time + 21 + 5 + + + RTOIE + Receiver timeout interrupt + enable + 26 + 1 + + + EOBIE + End of Block interrupt + enable + 27 + 1 + + + M1 + Word length + 28 + 1 + + + + + CR2 + CR2 + Control register 2 + 0x4 + 0x20 + read-write + 0x0000 + + + ADD4 + Address of the USART node + 28 + 4 + + + ADD0 + Address of the USART node + 24 + 4 + + + RTOEN + Receiver timeout enable + 23 + 1 + + + ABRMOD + Auto baud rate mode + 21 + 2 + + + ABREN + Auto baud rate enable + 20 + 1 + + + MSBFIRST + Most significant bit first + 19 + 1 + + + DATAINV + Binary data inversion + 18 + 1 + + + TXINV + TX pin active level + inversion + 17 + 1 + + + RXINV + RX pin active level + inversion + 16 + 1 + + + SWAP + Swap TX/RX pins + 15 + 1 + + + LINEN + LIN mode enable + 14 + 1 + + + STOP + STOP bits + 12 + 2 + + + CLKEN + Clock enable + 11 + 1 + + + CPOL + Clock polarity + 10 + 1 + + + CPHA + Clock phase + 9 + 1 + + + LBCL + Last bit clock pulse + 8 + 1 + + + LBDIE + LIN break detection interrupt + enable + 6 + 1 + + + LBDL + LIN break detection length + 5 + 1 + + + ADDM7 + 7-bit Address Detection/4-bit Address + Detection + 4 + 1 + + + + + CR3 + CR3 + Control register 3 + 0x8 + 0x20 + read-write + 0x0000 + + + WUFIE + Wakeup from Stop mode interrupt + enable + 22 + 1 + + + WUS + Wakeup from Stop mode interrupt flag + selection + 20 + 2 + + + SCARCNT + Smartcard auto-retry count + 17 + 3 + + + DEP + Driver enable polarity + selection + 15 + 1 + + + DEM + Driver enable mode + 14 + 1 + + + DDRE + DMA Disable on Reception + Error + 13 + 1 + + + OVRDIS + Overrun Disable + 12 + 1 + + + ONEBIT + One sample bit method + enable + 11 + 1 + + + CTSIE + CTS interrupt enable + 10 + 1 + + + CTSE + CTS enable + 9 + 1 + + + RTSE + RTS enable + 8 + 1 + + + DMAT + DMA enable transmitter + 7 + 1 + + + DMAR + DMA enable receiver + 6 + 1 + + + SCEN + Smartcard mode enable + 5 + 1 + + + NACK + Smartcard NACK enable + 4 + 1 + + + HDSEL + Half-duplex selection + 3 + 1 + + + IRLP + IrDA low-power + 2 + 1 + + + IREN + IrDA mode enable + 1 + 1 + + + EIE + Error interrupt enable + 0 + 1 + + + + + BRR + BRR + Baud rate register + 0xC + 0x20 + read-write + 0x0000 + + + DIV_Mantissa + mantissa of USARTDIV + 4 + 12 + + + DIV_Fraction + fraction of USARTDIV + 0 + 4 + + + + + GTPR + GTPR + Guard time and prescaler + register + 0x10 + 0x20 + read-write + 0x0000 + + + GT + Guard time value + 8 + 8 + + + PSC + Prescaler value + 0 + 8 + + + + + RTOR + RTOR + Receiver timeout register + 0x14 + 0x20 + read-write + 0x0000 + + + BLEN + Block Length + 24 + 8 + + + RTO + Receiver timeout value + 0 + 24 + + + + + RQR + RQR + Request register + 0x18 + 0x20 + read-write + 0x0000 + + + TXFRQ + Transmit data flush + request + 4 + 1 + + + RXFRQ + Receive data flush request + 3 + 1 + + + MMRQ + Mute mode request + 2 + 1 + + + SBKRQ + Send break request + 1 + 1 + + + ABRRQ + Auto baud rate request + 0 + 1 + + + + + ISR + ISR + Interrupt & status + register + 0x1C + 0x20 + read-only + 0x00C0 + + + REACK + Receive enable acknowledge + flag + 22 + 1 + + + TEACK + Transmit enable acknowledge + flag + 21 + 1 + + + WUF + Wakeup from Stop mode flag + 20 + 1 + + + RWU + Receiver wakeup from Mute + mode + 19 + 1 + + + SBKF + Send break flag + 18 + 1 + + + CMF + character match flag + 17 + 1 + + + BUSY + Busy flag + 16 + 1 + + + ABRF + Auto baud rate flag + 15 + 1 + + + ABRE + Auto baud rate error + 14 + 1 + + + EOBF + End of block flag + 12 + 1 + + + RTOF + Receiver timeout + 11 + 1 + + + CTS + CTS flag + 10 + 1 + + + CTSIF + CTS interrupt flag + 9 + 1 + + + LBDF + LIN break detection flag + 8 + 1 + + + TXE + Transmit data register + empty + 7 + 1 + + + TC + Transmission complete + 6 + 1 + + + RXNE + Read data register not + empty + 5 + 1 + + + IDLE + Idle line detected + 4 + 1 + + + ORE + Overrun error + 3 + 1 + + + NF + Noise detected flag + 2 + 1 + + + FE + Framing error + 1 + 1 + + + PE + Parity error + 0 + 1 + + + + + ICR + ICR + Interrupt flag clear register + 0x20 + 0x20 + read-write + 0x0000 + + + WUCF + Wakeup from Stop mode clear + flag + 20 + 1 + + + CMCF + Character match clear flag + 17 + 1 + + + EOBCF + End of timeout clear flag + 12 + 1 + + + RTOCF + Receiver timeout clear + flag + 11 + 1 + + + CTSCF + CTS clear flag + 9 + 1 + + + LBDCF + LIN break detection clear + flag + 8 + 1 + + + TCCF + Transmission complete clear + flag + 6 + 1 + + + IDLECF + Idle line detected clear + flag + 4 + 1 + + + ORECF + Overrun error clear flag + 3 + 1 + + + NCF + Noise detected clear flag + 2 + 1 + + + FECF + Framing error clear flag + 1 + 1 + + + PECF + Parity error clear flag + 0 + 1 + + + + + RDR + RDR + Receive data register + 0x24 + 0x20 + read-only + 0x0000 + + + RDR + Receive data value + 0 + 9 + + + + + TDR + TDR + Transmit data register + 0x28 + 0x20 + read-write + 0x0000 + + + TDR + Transmit data value + 0 + 9 + + + + + + + USART2 + 0x40004400 + + USART2 + USART2 global interrupt + 28 + + + + USART3 + 0x40004800 + + USART3_4 + USART3 and USART4 global + interrupt + 29 + + + + USART4 + 0x40004C00 + + USART3_4 + USART3 and USART4 global + interrupt + 29 + + + + USART6 + 0x40011400 + + USART1 + USART1 global interrupt + 27 + + + + USART7 + 0x40011800 + + USART1 + USART1 global interrupt + 27 + + + + USART8 + 0x40011C00 + + USART1 + USART1 global interrupt + 27 + + + + COMP + Comparator + COMP + 0x4001001C + + 0x0 + 0x400 + registers + + + ADC_COMP + ADC and comparator interrupts + 12 + + + + CSR + CSR + control and status register + 0x0 + 0x20 + 0x00000000 + + + COMP1EN + Comparator 1 enable + 0 + 1 + read-write + + + COMP1_INP_DAC + COMP1_INP_DAC + 1 + 1 + read-write + + + COMP1MODE + Comparator 1 mode + 2 + 2 + read-write + + + COMP1INSEL + Comparator 1 inverting input + selection + 4 + 3 + read-write + + + COMP1OUTSEL + Comparator 1 output + selection + 8 + 3 + read-write + + + COMP1POL + Comparator 1 output + polarity + 11 + 1 + read-write + + + COMP1HYST + Comparator 1 hysteresis + 12 + 2 + read-write + + + COMP1OUT + Comparator 1 output + 14 + 1 + read-only + + + COMP1LOCK + Comparator 1 lock + 15 + 1 + read-write + + + COMP2EN + Comparator 2 enable + 16 + 1 + read-write + + + COMP2MODE + Comparator 2 mode + 18 + 2 + read-write + + + COMP2INSEL + Comparator 2 inverting input + selection + 20 + 3 + read-write + + + WNDWEN + Window mode enable + 23 + 1 + read-write + + + COMP2OUTSEL + Comparator 2 output + selection + 24 + 3 + read-write + + + COMP2POL + Comparator 2 output + polarity + 27 + 1 + read-write + + + COMP2HYST + Comparator 2 hysteresis + 28 + 2 + read-write + + + COMP2OUT + Comparator 2 output + 30 + 1 + read-only + + + COMP2LOCK + Comparator 2 lock + 31 + 1 + read-write + + + + + + + RTC + Real-time clock + RTC + 0x40002800 + + 0x0 + 0x400 + registers + + + RTC + RTC interrupts + 2 + + + + TR + TR + time register + 0x0 + 0x20 + read-write + 0x00000000 + + + PM + AM/PM notation + 22 + 1 + + + HT + Hour tens in BCD format + 20 + 2 + + + HU + Hour units in BCD format + 16 + 4 + + + MNT + Minute tens in BCD format + 12 + 3 + + + MNU + Minute units in BCD format + 8 + 4 + + + ST + Second tens in BCD format + 4 + 3 + + + SU + Second units in BCD format + 0 + 4 + + + + + DR + DR + date register + 0x4 + 0x20 + read-write + 0x00002101 + + + YT + Year tens in BCD format + 20 + 4 + + + YU + Year units in BCD format + 16 + 4 + + + WDU + Week day units + 13 + 3 + + + MT + Month tens in BCD format + 12 + 1 + + + MU + Month units in BCD format + 8 + 4 + + + DT + Date tens in BCD format + 4 + 2 + + + DU + Date units in BCD format + 0 + 4 + + + + + CR + CR + control register + 0x8 + 0x20 + 0x00000000 + + + TSEDGE + Time-stamp event active + edge + 3 + 1 + read-write + + + REFCKON + RTC_REFIN reference clock detection + enable (50 or 60 Hz) + 4 + 1 + read-write + + + BYPSHAD + Bypass the shadow + registers + 5 + 1 + read-write + + + FMT + Hour format + 6 + 1 + read-write + + + ALRAE + Alarm A enable + 8 + 1 + read-write + + + TSE + timestamp enable + 11 + 1 + read-write + + + ALRAIE + Alarm A interrupt enable + 12 + 1 + read-write + + + TSIE + Time-stamp interrupt + enable + 15 + 1 + read-write + + + ADD1H + Add 1 hour (summer time + change) + 16 + 1 + write-only + + + SUB1H + Subtract 1 hour (winter time + change) + 17 + 1 + write-only + + + BKP + Backup + 18 + 1 + read-write + + + COSEL + Calibration output + selection + 19 + 1 + read-write + + + POL + Output polarity + 20 + 1 + read-write + + + OSEL + Output selection + 21 + 2 + read-write + + + COE + Calibration output enable + 23 + 1 + read-write + + + + + ISR + ISR + initialization and status + register + 0xC + 0x20 + 0x00000007 + + + ALRAWF + Alarm A write flag + 0 + 1 + read-only + + + SHPF + Shift operation pending + 3 + 1 + read-write + + + INITS + Initialization status flag + 4 + 1 + read-only + + + RSF + Registers synchronization + flag + 5 + 1 + read-write + + + INITF + Initialization flag + 6 + 1 + read-only + + + INIT + Initialization mode + 7 + 1 + read-write + + + ALRAF + Alarm A flag + 8 + 1 + read-write + + + TSF + Time-stamp flag + 11 + 1 + read-write + + + TSOVF + Time-stamp overflow flag + 12 + 1 + read-write + + + TAMP1F + RTC_TAMP1 detection flag + 13 + 1 + read-write + + + TAMP2F + RTC_TAMP2 detection flag + 14 + 1 + read-write + + + RECALPF + Recalibration pending Flag + 16 + 1 + read-only + + + + + PRER + PRER + prescaler register + 0x10 + 0x20 + read-write + 0x007F00FF + + + PREDIV_A + Asynchronous prescaler + factor + 16 + 7 + + + PREDIV_S + Synchronous prescaler + factor + 0 + 15 + + + + + ALRMAR + ALRMAR + alarm A register + 0x1C + 0x20 + read-write + 0x00000000 + + + MSK4 + Alarm A date mask + 31 + 1 + + + WDSEL + Week day selection + 30 + 1 + + + DT + Date tens in BCD format. + 28 + 2 + + + DU + Date units or day in BCD + format. + 24 + 4 + + + MSK3 + Alarm A hours mask + 23 + 1 + + + PM + AM/PM notation + 22 + 1 + + + HT + Hour tens in BCD format. + 20 + 2 + + + HU + Hour units in BCD format. + 16 + 4 + + + MSK2 + Alarm A minutes mask + 15 + 1 + + + MNT + Minute tens in BCD format. + 12 + 3 + + + MNU + Minute units in BCD + format. + 8 + 4 + + + MSK1 + Alarm A seconds mask + 7 + 1 + + + ST + Second tens in BCD format. + 4 + 3 + + + SU + Second units in BCD + format. + 0 + 4 + + + + + WPR + WPR + write protection register + 0x24 + 0x20 + write-only + 0x00000000 + + + KEY + Write protection key + 0 + 8 + + + + + SSR + SSR + sub second register + 0x28 + 0x20 + read-only + 0x00000000 + + + SS + Sub second value + 0 + 16 + + + + + SHIFTR + SHIFTR + shift control register + 0x2C + 0x20 + write-only + 0x00000000 + + + ADD1S + Reserved + 31 + 1 + + + SUBFS + Subtract a fraction of a + second + 0 + 15 + + + + + TSTR + TSTR + timestamp time register + 0x30 + 0x20 + read-only + 0x00000000 + + + PM + AM/PM notation + 22 + 1 + + + HT + Hour tens in BCD format. + 20 + 2 + + + HU + Hour units in BCD format. + 16 + 4 + + + MNT + Minute tens in BCD format. + 12 + 3 + + + MNU + Minute units in BCD + format. + 8 + 4 + + + ST + Second tens in BCD format. + 4 + 3 + + + SU + Second units in BCD + format. + 0 + 4 + + + + + TSDR + TSDR + timestamp date register + 0x34 + 0x20 + read-only + 0x00000000 + + + WDU + Week day units + 13 + 3 + + + MT + Month tens in BCD format + 12 + 1 + + + MU + Month units in BCD format + 8 + 4 + + + DT + Date tens in BCD format + 4 + 2 + + + DU + Date units in BCD format + 0 + 4 + + + + + TSSSR + TSSSR + time-stamp sub second register + 0x38 + 0x20 + read-only + 0x00000000 + + + SS + Sub second value + 0 + 16 + + + + + CALR + CALR + calibration register + 0x3C + 0x20 + read-write + 0x00000000 + + + CALP + Use an 8-second calibration cycle + period + 15 + 1 + + + CALW8 + Use a 16-second calibration cycle + period + 14 + 1 + + + CALW16 + Reserved + 13 + 1 + + + CALM + Calibration minus + 0 + 9 + + + + + TAFCR + TAFCR + tamper and alternate function configuration + register + 0x40 + 0x20 + read-write + 0x00000000 + + + PC15MODE + PC15 mode + 23 + 1 + + + PC15VALUE + PC15 value + 22 + 1 + + + PC14MODE + PC14 mode + 21 + 1 + + + PC14VALUE + PC14 value + 20 + 1 + + + PC13MODE + PC13 mode + 19 + 1 + + + PC13VALUE + RTC_ALARM output type/PC13 + value + 18 + 1 + + + TAMP_PUDIS + RTC_TAMPx pull-up disable + 15 + 1 + + + TAMP_PRCH + RTC_TAMPx precharge + duration + 13 + 2 + + + TAMPFLT + RTC_TAMPx filter count + 11 + 2 + + + TAMPFREQ + Tamper sampling frequency + 8 + 3 + + + TAMPTS + Activate timestamp on tamper detection + event + 7 + 1 + + + TAMP2_TRG + Active level for RTC_TAMP2 + input + 4 + 1 + + + TAMP2E + RTC_TAMP2 input detection + enable + 3 + 1 + + + TAMPIE + Tamper interrupt enable + 2 + 1 + + + TAMP1TRG + Active level for RTC_TAMP1 + input + 1 + 1 + + + TAMP1E + RTC_TAMP1 input detection + enable + 0 + 1 + + + + + ALRMASSR + ALRMASSR + alarm A sub second register + 0x44 + 0x20 + read-write + 0x00000000 + + + MASKSS + Mask the most-significant bits starting + at this bit + 24 + 4 + + + SS + Sub seconds value + 0 + 15 + + + + + BKP0R + BKP0R + backup register + 0x50 + 0x20 + read-write + 0x00000000 + + + BKP + BKP + 0 + 32 + + + + + BKP1R + BKP1R + backup register + 0x54 + 0x20 + read-write + 0x00000000 + + + BKP + BKP + 0 + 32 + + + + + BKP2R + BKP2R + backup register + 0x58 + 0x20 + read-write + 0x00000000 + + + BKP + BKP + 0 + 32 + + + + + BKP3R + BKP3R + backup register + 0x5C + 0x20 + read-write + 0x00000000 + + + BKP + BKP + 0 + 32 + + + + + BKP4R + BKP4R + backup register + 0x60 + 0x20 + read-write + 0x00000000 + + + BKP + BKP + 0 + 32 + + + + + + + TIM15 + General-purpose-timers + TIM + 0x40014000 + + 0x0 + 0x400 + registers + + + TIM15 + TIM15 global interrupt + 20 + + + + CR1 + CR1 + control register 1 + 0x0 + 0x20 + read-write + 0x0000 + + + CKD + Clock division + 8 + 2 + + + ARPE + Auto-reload preload enable + 7 + 1 + + + OPM + One-pulse mode + 3 + 1 + + + URS + Update request source + 2 + 1 + + + UDIS + Update disable + 1 + 1 + + + CEN + Counter enable + 0 + 1 + + + + + CR2 + CR2 + control register 2 + 0x4 + 0x20 + read-write + 0x0000 + + + OIS2 + Output Idle state 2 + 10 + 1 + + + OIS1N + Output Idle state 1 + 9 + 1 + + + OIS1 + Output Idle state 1 + 8 + 1 + + + MMS + Master mode selection + 4 + 3 + + + CCDS + Capture/compare DMA + selection + 3 + 1 + + + CCUS + Capture/compare control update + selection + 2 + 1 + + + CCPC + Capture/compare preloaded + control + 0 + 1 + + + + + SMCR + SMCR + slave mode control register + 0x8 + 0x20 + read-write + 0x0000 + + + MSM + Master/Slave mode + 7 + 1 + + + TS + Trigger selection + 4 + 3 + + + SMS + Slave mode selection + 0 + 3 + + + + + DIER + DIER + DMA/Interrupt enable register + 0xC + 0x20 + read-write + 0x0000 + + + TDE + Trigger DMA request enable + 14 + 1 + + + CC2DE + Capture/Compare 2 DMA request + enable + 10 + 1 + + + CC1DE + Capture/Compare 1 DMA request + enable + 9 + 1 + + + UDE + Update DMA request enable + 8 + 1 + + + BIE + Break interrupt enable + 7 + 1 + + + TIE + Trigger interrupt enable + 6 + 1 + + + COMIE + COM interrupt enable + 5 + 1 + + + CC2IE + Capture/Compare 2 interrupt + enable + 2 + 1 + + + CC1IE + Capture/Compare 1 interrupt + enable + 1 + 1 + + + UIE + Update interrupt enable + 0 + 1 + + + + + SR + SR + status register + 0x10 + 0x20 + read-write + 0x0000 + + + CC2OF + Capture/compare 2 overcapture + flag + 10 + 1 + + + CC1OF + Capture/Compare 1 overcapture + flag + 9 + 1 + + + BIF + Break interrupt flag + 7 + 1 + + + TIF + Trigger interrupt flag + 6 + 1 + + + COMIF + COM interrupt flag + 5 + 1 + + + CC2IF + Capture/Compare 2 interrupt + flag + 2 + 1 + + + CC1IF + Capture/compare 1 interrupt + flag + 1 + 1 + + + UIF + Update interrupt flag + 0 + 1 + + + + + EGR + EGR + event generation register + 0x14 + 0x20 + write-only + 0x0000 + + + BG + Break generation + 7 + 1 + + + TG + Trigger generation + 6 + 1 + + + COMG + Capture/Compare control update + generation + 5 + 1 + + + CC2G + Capture/compare 2 + generation + 2 + 1 + + + CC1G + Capture/compare 1 + generation + 1 + 1 + + + UG + Update generation + 0 + 1 + + + + + CCMR1_Output + CCMR1_Output + capture/compare mode register (output + mode) + 0x18 + 0x20 + read-write + 0x00000000 + + + OC2M + Output Compare 2 mode + 12 + 3 + + + OC2PE + Output Compare 2 preload + enable + 11 + 1 + + + OC2FE + Output Compare 2 fast + enable + 10 + 1 + + + CC2S + Capture/Compare 2 + selection + 8 + 2 + + + OC1M + Output Compare 1 mode + 4 + 3 + + + OC1PE + Output Compare 1 preload + enable + 3 + 1 + + + OC1FE + Output Compare 1 fast + enable + 2 + 1 + + + CC1S + Capture/Compare 1 + selection + 0 + 2 + + + + + CCMR1_Input + CCMR1_Input + capture/compare mode register 1 (input + mode) + CCMR1_Output + 0x18 + 0x20 + read-write + 0x00000000 + + + IC2F + Input capture 2 filter + 12 + 4 + + + IC2PSC + Input capture 2 prescaler + 10 + 2 + + + CC2S + Capture/Compare 2 + selection + 8 + 2 + + + IC1F + Input capture 1 filter + 4 + 4 + + + IC1PSC + Input capture 1 prescaler + 2 + 2 + + + CC1S + Capture/Compare 1 + selection + 0 + 2 + + + + + CCER + CCER + capture/compare enable + register + 0x20 + 0x20 + read-write + 0x0000 + + + CC2NP + Capture/Compare 2 output + Polarity + 7 + 1 + + + CC2P + Capture/Compare 2 output + Polarity + 5 + 1 + + + CC2E + Capture/Compare 2 output + enable + 4 + 1 + + + CC1NP + Capture/Compare 1 output + Polarity + 3 + 1 + + + CC1NE + Capture/Compare 1 complementary output + enable + 2 + 1 + + + CC1P + Capture/Compare 1 output + Polarity + 1 + 1 + + + CC1E + Capture/Compare 1 output + enable + 0 + 1 + + + + + CNT + CNT + counter + 0x24 + 0x20 + read-write + 0x00000000 + + + CNT + counter value + 0 + 16 + + + + + PSC + PSC + prescaler + 0x28 + 0x20 + read-write + 0x0000 + + + PSC + Prescaler value + 0 + 16 + + + + + ARR + ARR + auto-reload register + 0x2C + 0x20 + read-write + 0x00000000 + + + ARR + Auto-reload value + 0 + 16 + + + + + RCR + RCR + repetition counter register + 0x30 + 0x20 + read-write + 0x0000 + + + REP + Repetition counter value + 0 + 8 + + + + + CCR1 + CCR1 + capture/compare register 1 + 0x34 + 0x20 + read-write + 0x00000000 + + + CCR1 + Capture/Compare 1 value + 0 + 16 + + + + + CCR2 + CCR2 + capture/compare register 2 + 0x38 + 0x20 + read-write + 0x00000000 + + + CCR2 + Capture/Compare 2 value + 0 + 16 + + + + + BDTR + BDTR + break and dead-time register + 0x44 + 0x20 + read-write + 0x0000 + + + MOE + Main output enable + 15 + 1 + + + AOE + Automatic output enable + 14 + 1 + + + BKP + Break polarity + 13 + 1 + + + BKE + Break enable + 12 + 1 + + + OSSR + Off-state selection for Run + mode + 11 + 1 + + + OSSI + Off-state selection for Idle + mode + 10 + 1 + + + LOCK + Lock configuration + 8 + 2 + + + DTG + Dead-time generator setup + 0 + 8 + + + + + DCR + DCR + DMA control register + 0x48 + 0x20 + read-write + 0x0000 + + + DBL + DMA burst length + 8 + 5 + + + DBA + DMA base address + 0 + 5 + + + + + DMAR + DMAR + DMA address for full transfer + 0x4C + 0x20 + read-write + 0x0000 + + + DMAB + DMA register for burst + accesses + 0 + 16 + + + + + + + TIM16 + General-purpose-timers + TIM + 0x40014400 + + 0x0 + 0x400 + registers + + + TIM16 + TIM16 global interrupt + 21 + + + + CR1 + CR1 + control register 1 + 0x0 + 0x20 + read-write + 0x0000 + + + CKD + Clock division + 8 + 2 + + + ARPE + Auto-reload preload enable + 7 + 1 + + + OPM + One-pulse mode + 3 + 1 + + + URS + Update request source + 2 + 1 + + + UDIS + Update disable + 1 + 1 + + + CEN + Counter enable + 0 + 1 + + + + + CR2 + CR2 + control register 2 + 0x4 + 0x20 + read-write + 0x0000 + + + OIS1N + Output Idle state 1 + 9 + 1 + + + OIS1 + Output Idle state 1 + 8 + 1 + + + CCDS + Capture/compare DMA + selection + 3 + 1 + + + CCUS + Capture/compare control update + selection + 2 + 1 + + + CCPC + Capture/compare preloaded + control + 0 + 1 + + + + + DIER + DIER + DMA/Interrupt enable register + 0xC + 0x20 + read-write + 0x0000 + + + TDE + Trigger DMA request enable + 14 + 1 + + + CC1DE + Capture/Compare 1 DMA request + enable + 9 + 1 + + + UDE + Update DMA request enable + 8 + 1 + + + BIE + Break interrupt enable + 7 + 1 + + + TIE + Trigger interrupt enable + 6 + 1 + + + COMIE + COM interrupt enable + 5 + 1 + + + CC1IE + Capture/Compare 1 interrupt + enable + 1 + 1 + + + UIE + Update interrupt enable + 0 + 1 + + + + + SR + SR + status register + 0x10 + 0x20 + read-write + 0x0000 + + + CC1OF + Capture/Compare 1 overcapture + flag + 9 + 1 + + + BIF + Break interrupt flag + 7 + 1 + + + TIF + Trigger interrupt flag + 6 + 1 + + + COMIF + COM interrupt flag + 5 + 1 + + + CC1IF + Capture/compare 1 interrupt + flag + 1 + 1 + + + UIF + Update interrupt flag + 0 + 1 + + + + + EGR + EGR + event generation register + 0x14 + 0x20 + write-only + 0x0000 + + + BG + Break generation + 7 + 1 + + + TG + Trigger generation + 6 + 1 + + + COMG + Capture/Compare control update + generation + 5 + 1 + + + CC1G + Capture/compare 1 + generation + 1 + 1 + + + UG + Update generation + 0 + 1 + + + + + CCMR1_Output + CCMR1_Output + capture/compare mode register (output + mode) + 0x18 + 0x20 + read-write + 0x00000000 + + + OC1M + Output Compare 1 mode + 4 + 3 + + + OC1PE + Output Compare 1 preload + enable + 3 + 1 + + + OC1FE + Output Compare 1 fast + enable + 2 + 1 + + + CC1S + Capture/Compare 1 + selection + 0 + 2 + + + + + CCMR1_Input + CCMR1_Input + capture/compare mode register 1 (input + mode) + CCMR1_Output + 0x18 + 0x20 + read-write + 0x00000000 + + + IC1F + Input capture 1 filter + 4 + 4 + + + IC1PSC + Input capture 1 prescaler + 2 + 2 + + + CC1S + Capture/Compare 1 + selection + 0 + 2 + + + + + CCER + CCER + capture/compare enable + register + 0x20 + 0x20 + read-write + 0x0000 + + + CC1NP + Capture/Compare 1 output + Polarity + 3 + 1 + + + CC1NE + Capture/Compare 1 complementary output + enable + 2 + 1 + + + CC1P + Capture/Compare 1 output + Polarity + 1 + 1 + + + CC1E + Capture/Compare 1 output + enable + 0 + 1 + + + + + CNT + CNT + counter + 0x24 + 0x20 + read-write + 0x00000000 + + + CNT + counter value + 0 + 16 + + + + + PSC + PSC + prescaler + 0x28 + 0x20 + read-write + 0x0000 + + + PSC + Prescaler value + 0 + 16 + + + + + ARR + ARR + auto-reload register + 0x2C + 0x20 + read-write + 0x00000000 + + + ARR + Auto-reload value + 0 + 16 + + + + + RCR + RCR + repetition counter register + 0x30 + 0x20 + read-write + 0x0000 + + + REP + Repetition counter value + 0 + 8 + + + + + CCR1 + CCR1 + capture/compare register 1 + 0x34 + 0x20 + read-write + 0x00000000 + + + CCR1 + Capture/Compare 1 value + 0 + 16 + + + + + BDTR + BDTR + break and dead-time register + 0x44 + 0x20 + read-write + 0x0000 + + + MOE + Main output enable + 15 + 1 + + + AOE + Automatic output enable + 14 + 1 + + + BKP + Break polarity + 13 + 1 + + + BKE + Break enable + 12 + 1 + + + OSSR + Off-state selection for Run + mode + 11 + 1 + + + OSSI + Off-state selection for Idle + mode + 10 + 1 + + + LOCK + Lock configuration + 8 + 2 + + + DTG + Dead-time generator setup + 0 + 8 + + + + + DCR + DCR + DMA control register + 0x48 + 0x20 + read-write + 0x0000 + + + DBL + DMA burst length + 8 + 5 + + + DBA + DMA base address + 0 + 5 + + + + + DMAR + DMAR + DMA address for full transfer + 0x4C + 0x20 + read-write + 0x0000 + + + DMAB + DMA register for burst + accesses + 0 + 16 + + + + + + + TIM17 + 0x40014800 + + TIM17 + TIM17 global interrupt + 22 + + + + TSC + Touch sensing controller + TSC + 0x40024000 + + 0x0 + 0x400 + registers + + + TSC + Touch sensing interrupt + 8 + + + + CR + CR + control register + 0x0 + 0x20 + read-write + 0x00000000 + + + CTPH + Charge transfer pulse high + 28 + 4 + + + CTPL + Charge transfer pulse low + 24 + 4 + + + SSD + Spread spectrum deviation + 17 + 7 + + + SSE + Spread spectrum enable + 16 + 1 + + + SSPSC + Spread spectrum prescaler + 15 + 1 + + + PGPSC + pulse generator prescaler + 12 + 3 + + + MCV + Max count value + 5 + 3 + + + IODEF + I/O Default mode + 4 + 1 + + + SYNCPOL + Synchronization pin + polarity + 3 + 1 + + + AM + Acquisition mode + 2 + 1 + + + START + Start a new acquisition + 1 + 1 + + + TSCE + Touch sensing controller + enable + 0 + 1 + + + + + IER + IER + interrupt enable register + 0x4 + 0x20 + read-write + 0x00000000 + + + MCEIE + Max count error interrupt + enable + 1 + 1 + + + EOAIE + End of acquisition interrupt + enable + 0 + 1 + + + + + ICR + ICR + interrupt clear register + 0x8 + 0x20 + read-write + 0x00000000 + + + MCEIC + Max count error interrupt + clear + 1 + 1 + + + EOAIC + End of acquisition interrupt + clear + 0 + 1 + + + + + ISR + ISR + interrupt status register + 0xC + 0x20 + read-write + 0x00000000 + + + MCEF + Max count error flag + 1 + 1 + + + EOAF + End of acquisition flag + 0 + 1 + + + + + IOHCR + IOHCR + I/O hysteresis control + register + 0x10 + 0x20 + read-write + 0xFFFFFFFF + + + G6_IO4 + G6_IO4 Schmitt trigger hysteresis + mode + 23 + 1 + + + G6_IO3 + G6_IO3 Schmitt trigger hysteresis + mode + 22 + 1 + + + G6_IO2 + G6_IO2 Schmitt trigger hysteresis + mode + 21 + 1 + + + G6_IO1 + G6_IO1 Schmitt trigger hysteresis + mode + 20 + 1 + + + G5_IO4 + G5_IO4 Schmitt trigger hysteresis + mode + 19 + 1 + + + G5_IO3 + G5_IO3 Schmitt trigger hysteresis + mode + 18 + 1 + + + G5_IO2 + G5_IO2 Schmitt trigger hysteresis + mode + 17 + 1 + + + G5_IO1 + G5_IO1 Schmitt trigger hysteresis + mode + 16 + 1 + + + G4_IO4 + G4_IO4 Schmitt trigger hysteresis + mode + 15 + 1 + + + G4_IO3 + G4_IO3 Schmitt trigger hysteresis + mode + 14 + 1 + + + G4_IO2 + G4_IO2 Schmitt trigger hysteresis + mode + 13 + 1 + + + G4_IO1 + G4_IO1 Schmitt trigger hysteresis + mode + 12 + 1 + + + G3_IO4 + G3_IO4 Schmitt trigger hysteresis + mode + 11 + 1 + + + G3_IO3 + G3_IO3 Schmitt trigger hysteresis + mode + 10 + 1 + + + G3_IO2 + G3_IO2 Schmitt trigger hysteresis + mode + 9 + 1 + + + G3_IO1 + G3_IO1 Schmitt trigger hysteresis + mode + 8 + 1 + + + G2_IO4 + G2_IO4 Schmitt trigger hysteresis + mode + 7 + 1 + + + G2_IO3 + G2_IO3 Schmitt trigger hysteresis + mode + 6 + 1 + + + G2_IO2 + G2_IO2 Schmitt trigger hysteresis + mode + 5 + 1 + + + G2_IO1 + G2_IO1 Schmitt trigger hysteresis + mode + 4 + 1 + + + G1_IO4 + G1_IO4 Schmitt trigger hysteresis + mode + 3 + 1 + + + G1_IO3 + G1_IO3 Schmitt trigger hysteresis + mode + 2 + 1 + + + G1_IO2 + G1_IO2 Schmitt trigger hysteresis + mode + 1 + 1 + + + G1_IO1 + G1_IO1 Schmitt trigger hysteresis + mode + 0 + 1 + + + + + IOASCR + IOASCR + I/O analog switch control + register + 0x18 + 0x20 + read-write + 0x00000000 + + + G6_IO4 + G6_IO4 analog switch + enable + 23 + 1 + + + G6_IO3 + G6_IO3 analog switch + enable + 22 + 1 + + + G6_IO2 + G6_IO2 analog switch + enable + 21 + 1 + + + G6_IO1 + G6_IO1 analog switch + enable + 20 + 1 + + + G5_IO4 + G5_IO4 analog switch + enable + 19 + 1 + + + G5_IO3 + G5_IO3 analog switch + enable + 18 + 1 + + + G5_IO2 + G5_IO2 analog switch + enable + 17 + 1 + + + G5_IO1 + G5_IO1 analog switch + enable + 16 + 1 + + + G4_IO4 + G4_IO4 analog switch + enable + 15 + 1 + + + G4_IO3 + G4_IO3 analog switch + enable + 14 + 1 + + + G4_IO2 + G4_IO2 analog switch + enable + 13 + 1 + + + G4_IO1 + G4_IO1 analog switch + enable + 12 + 1 + + + G3_IO4 + G3_IO4 analog switch + enable + 11 + 1 + + + G3_IO3 + G3_IO3 analog switch + enable + 10 + 1 + + + G3_IO2 + G3_IO2 analog switch + enable + 9 + 1 + + + G3_IO1 + G3_IO1 analog switch + enable + 8 + 1 + + + G2_IO4 + G2_IO4 analog switch + enable + 7 + 1 + + + G2_IO3 + G2_IO3 analog switch + enable + 6 + 1 + + + G2_IO2 + G2_IO2 analog switch + enable + 5 + 1 + + + G2_IO1 + G2_IO1 analog switch + enable + 4 + 1 + + + G1_IO4 + G1_IO4 analog switch + enable + 3 + 1 + + + G1_IO3 + G1_IO3 analog switch + enable + 2 + 1 + + + G1_IO2 + G1_IO2 analog switch + enable + 1 + 1 + + + G1_IO1 + G1_IO1 analog switch + enable + 0 + 1 + + + + + IOSCR + IOSCR + I/O sampling control register + 0x20 + 0x20 + read-write + 0x00000000 + + + G6_IO4 + G6_IO4 sampling mode + 23 + 1 + + + G6_IO3 + G6_IO3 sampling mode + 22 + 1 + + + G6_IO2 + G6_IO2 sampling mode + 21 + 1 + + + G6_IO1 + G6_IO1 sampling mode + 20 + 1 + + + G5_IO4 + G5_IO4 sampling mode + 19 + 1 + + + G5_IO3 + G5_IO3 sampling mode + 18 + 1 + + + G5_IO2 + G5_IO2 sampling mode + 17 + 1 + + + G5_IO1 + G5_IO1 sampling mode + 16 + 1 + + + G4_IO4 + G4_IO4 sampling mode + 15 + 1 + + + G4_IO3 + G4_IO3 sampling mode + 14 + 1 + + + G4_IO2 + G4_IO2 sampling mode + 13 + 1 + + + G4_IO1 + G4_IO1 sampling mode + 12 + 1 + + + G3_IO4 + G3_IO4 sampling mode + 11 + 1 + + + G3_IO3 + G3_IO3 sampling mode + 10 + 1 + + + G3_IO2 + G3_IO2 sampling mode + 9 + 1 + + + G3_IO1 + G3_IO1 sampling mode + 8 + 1 + + + G2_IO4 + G2_IO4 sampling mode + 7 + 1 + + + G2_IO3 + G2_IO3 sampling mode + 6 + 1 + + + G2_IO2 + G2_IO2 sampling mode + 5 + 1 + + + G2_IO1 + G2_IO1 sampling mode + 4 + 1 + + + G1_IO4 + G1_IO4 sampling mode + 3 + 1 + + + G1_IO3 + G1_IO3 sampling mode + 2 + 1 + + + G1_IO2 + G1_IO2 sampling mode + 1 + 1 + + + G1_IO1 + G1_IO1 sampling mode + 0 + 1 + + + + + IOCCR + IOCCR + I/O channel control register + 0x28 + 0x20 + read-write + 0x00000000 + + + G6_IO4 + G6_IO4 channel mode + 23 + 1 + + + G6_IO3 + G6_IO3 channel mode + 22 + 1 + + + G6_IO2 + G6_IO2 channel mode + 21 + 1 + + + G6_IO1 + G6_IO1 channel mode + 20 + 1 + + + G5_IO4 + G5_IO4 channel mode + 19 + 1 + + + G5_IO3 + G5_IO3 channel mode + 18 + 1 + + + G5_IO2 + G5_IO2 channel mode + 17 + 1 + + + G5_IO1 + G5_IO1 channel mode + 16 + 1 + + + G4_IO4 + G4_IO4 channel mode + 15 + 1 + + + G4_IO3 + G4_IO3 channel mode + 14 + 1 + + + G4_IO2 + G4_IO2 channel mode + 13 + 1 + + + G4_IO1 + G4_IO1 channel mode + 12 + 1 + + + G3_IO4 + G3_IO4 channel mode + 11 + 1 + + + G3_IO3 + G3_IO3 channel mode + 10 + 1 + + + G3_IO2 + G3_IO2 channel mode + 9 + 1 + + + G3_IO1 + G3_IO1 channel mode + 8 + 1 + + + G2_IO4 + G2_IO4 channel mode + 7 + 1 + + + G2_IO3 + G2_IO3 channel mode + 6 + 1 + + + G2_IO2 + G2_IO2 channel mode + 5 + 1 + + + G2_IO1 + G2_IO1 channel mode + 4 + 1 + + + G1_IO4 + G1_IO4 channel mode + 3 + 1 + + + G1_IO3 + G1_IO3 channel mode + 2 + 1 + + + G1_IO2 + G1_IO2 channel mode + 1 + 1 + + + G1_IO1 + G1_IO1 channel mode + 0 + 1 + + + + + IOGCSR + IOGCSR + I/O group control status + register + 0x30 + 0x20 + 0x00000000 + + + G8S + Analog I/O group x status + 23 + 1 + read-write + + + G7S + Analog I/O group x status + 22 + 1 + read-write + + + G6S + Analog I/O group x status + 21 + 1 + read-only + + + G5S + Analog I/O group x status + 20 + 1 + read-only + + + G4S + Analog I/O group x status + 19 + 1 + read-only + + + G3S + Analog I/O group x status + 18 + 1 + read-only + + + G2S + Analog I/O group x status + 17 + 1 + read-only + + + G1S + Analog I/O group x status + 16 + 1 + read-only + + + G8E + Analog I/O group x enable + 7 + 1 + read-write + + + G7E + Analog I/O group x enable + 6 + 1 + read-write + + + G6E + Analog I/O group x enable + 5 + 1 + read-write + + + G5E + Analog I/O group x enable + 4 + 1 + read-write + + + G4E + Analog I/O group x enable + 3 + 1 + read-write + + + G3E + Analog I/O group x enable + 2 + 1 + read-write + + + G2E + Analog I/O group x enable + 1 + 1 + read-write + + + G1E + Analog I/O group x enable + 0 + 1 + read-write + + + + + IOG1CR + IOG1CR + I/O group x counter register + 0x34 + 0x20 + read-only + 0x00000000 + + + CNT + Counter value + 0 + 14 + + + + + IOG2CR + IOG2CR + I/O group x counter register + 0x38 + 0x20 + read-only + 0x00000000 + + + CNT + Counter value + 0 + 14 + + + + + IOG3CR + IOG3CR + I/O group x counter register + 0x3C + 0x20 + read-only + 0x00000000 + + + CNT + Counter value + 0 + 14 + + + + + IOG4CR + IOG4CR + I/O group x counter register + 0x40 + 0x20 + read-only + 0x00000000 + + + CNT + Counter value + 0 + 14 + + + + + IOG5CR + IOG5CR + I/O group x counter register + 0x44 + 0x20 + read-only + 0x00000000 + + + CNT + Counter value + 0 + 14 + + + + + IOG6CR + IOG6CR + I/O group x counter register + 0x48 + 0x20 + read-only + 0x00000000 + + + CNT + Counter value + 0 + 14 + + + + + + + CEC + HDMI-CEC controller + CEC + 0x40007800 + + 0x0 + 0x400 + registers + + + CEC_CAN + CEC and CAN global interrupt + 30 + + + + CR + CR + control register + 0x0 + 0x20 + read-write + 0x00000000 + + + TXEOM + Tx End Of Message + 2 + 1 + + + TXSOM + Tx start of message + 1 + 1 + + + CECEN + CEC Enable + 0 + 1 + + + + + CFGR + CFGR + configuration register + 0x4 + 0x20 + read-write + 0x00000000 + + + LBPEGEN + Generate Error-Bit on Long Bit Period + Error + 11 + 1 + + + BREGEN + Generate error-bit on bit rising + error + 10 + 1 + + + BRESTP + Rx-stop on bit rising + error + 9 + 1 + + + RXTOL + Rx-Tolerance + 8 + 1 + + + SFT + Signal Free Time + 5 + 3 + + + LSTN + Listen mode + 4 + 1 + + + OAR + Own Address + 0 + 4 + + + + + TXDR + TXDR + Tx data register + 0x8 + 0x20 + write-only + 0x00000000 + + + TXD + Tx Data register + 0 + 8 + + + + + RXDR + RXDR + Rx Data Register + 0xC + 0x20 + read-only + 0x00000000 + + + RXDR + CEC Rx Data Register + 0 + 8 + + + + + ISR + ISR + Interrupt and Status Register + 0x10 + 0x20 + read-write + 0x00000000 + + + TXACKE + Tx-Missing acknowledge + error + 12 + 1 + + + TXERR + Tx-Error + 11 + 1 + + + TXUDR + Tx-Buffer Underrun + 10 + 1 + + + TXEND + End of Transmission + 9 + 1 + + + TXBR + Tx-Byte Request + 8 + 1 + + + ARBLST + Arbitration Lost + 7 + 1 + + + RXACKE + Rx-Missing Acknowledge + 6 + 1 + + + LBPE + Rx-Long Bit Period Error + 5 + 1 + + + SBPE + Rx-Short Bit period error + 4 + 1 + + + BRE + Rx-Bit rising error + 3 + 1 + + + RXOVR + Rx-Overrun + 2 + 1 + + + RXEND + End Of Reception + 1 + 1 + + + RXBR + Rx-Byte Received + 0 + 1 + + + + + IER + IER + interrupt enable register + 0x14 + 0x20 + read-write + 0x00000000 + + + TXACKIE + Tx-Missing Acknowledge Error Interrupt + Enable + 12 + 1 + + + TXERRIE + Tx-Error Interrupt Enable + 11 + 1 + + + TXUDRIE + Tx-Underrun interrupt + enable + 10 + 1 + + + TXENDIE + Tx-End of message interrupt + enable + 9 + 1 + + + TXBRIE + Tx-Byte Request Interrupt + Enable + 8 + 1 + + + ARBLSTIE + Arbitration Lost Interrupt + Enable + 7 + 1 + + + RXACKIE + Rx-Missing Acknowledge Error Interrupt + Enable + 6 + 1 + + + LBPEIE + Long Bit Period Error Interrupt + Enable + 5 + 1 + + + SBPEIE + Short Bit Period Error Interrupt + Enable + 4 + 1 + + + BREIE + Bit Rising Error Interrupt + Enable + 3 + 1 + + + RXOVRIE + Rx-Buffer Overrun Interrupt + Enable + 2 + 1 + + + RXENDIE + End Of Reception Interrupt + Enable + 1 + 1 + + + RXBRIE + Rx-Byte Received Interrupt + Enable + 0 + 1 + + + + + + + Flash + Flash + Flash + 0x40022000 + + 0x0 + 0x400 + registers + + + FLASH + Flash global interrupt + 3 + + + + ACR + ACR + Flash access control register + 0x0 + 0x20 + 0x00000030 + + + LATENCY + LATENCY + 0 + 3 + read-write + + + PRFTBE + PRFTBE + 4 + 1 + read-write + + + PRFTBS + PRFTBS + 5 + 1 + read-only + + + + + KEYR + KEYR + Flash key register + 0x4 + 0x20 + write-only + 0x00000000 + + + FKEYR + Flash Key + 0 + 32 + + + + + OPTKEYR + OPTKEYR + Flash option key register + 0x8 + 0x20 + write-only + 0x00000000 + + + OPTKEYR + Option byte key + 0 + 32 + + + + + SR + SR + Flash status register + 0xC + 0x20 + 0x00000000 + + + EOP + End of operation + 5 + 1 + read-write + + + WRPRT + Write protection error + 4 + 1 + read-write + + + PGERR + Programming error + 2 + 1 + read-write + + + BSY + Busy + 0 + 1 + read-only + + + + + CR + CR + Flash control register + 0x10 + 0x20 + read-write + 0x00000080 + + + FORCE_OPTLOAD + Force option byte loading + 13 + 1 + + + EOPIE + End of operation interrupt + enable + 12 + 1 + + + ERRIE + Error interrupt enable + 10 + 1 + + + OPTWRE + Option bytes write enable + 9 + 1 + + + LOCK + Lock + 7 + 1 + + + STRT + Start + 6 + 1 + + + OPTER + Option byte erase + 5 + 1 + + + OPTPG + Option byte programming + 4 + 1 + + + MER + Mass erase + 2 + 1 + + + PER + Page erase + 1 + 1 + + + PG + Programming + 0 + 1 + + + + + AR + AR + Flash address register + 0x14 + 0x20 + write-only + 0x00000000 + + + FAR + Flash address + 0 + 32 + + + + + OBR + OBR + Option byte register + 0x1C + 0x20 + read-only + 0x03FFFFF2 + + + Data1 + Data1 + 24 + 8 + + + Data0 + Data0 + 16 + 8 + + + VDDA_MONITOR + VDDA_MONITOR + 13 + 1 + + + BOOT1 + BOOT1 + 12 + 1 + + + nRST_STDBY + nRST_STDBY + 10 + 1 + + + nRST_STOP + nRST_STOP + 9 + 1 + + + WDG_SW + WDG_SW + 8 + 1 + + + LEVEL2_PROT + Level 2 protection status + 2 + 1 + + + LEVEL1_PROT + Level 1 protection status + 1 + 1 + + + OPTERR + Option byte error + 0 + 1 + + + + + WRPR + WRPR + Write protection register + 0x20 + 0x20 + read-only + 0xFFFFFFFF + + + WRP + Write protect + 0 + 32 + + + + + + + DBGMCU + Debug support + DBGMCU + 0x40015800 + + 0x0 + 0x400 + registers + + + + IDCODE + IDCODE + MCU Device ID Code Register + 0x0 + 0x20 + read-only + 0x0 + + + DEV_ID + Device Identifier + 0 + 12 + + + DIV_ID + Division Identifier + 12 + 4 + + + REV_ID + Revision Identifier + 16 + 16 + + + + + CR + CR + Debug MCU Configuration + Register + 0x4 + 0x20 + read-write + 0x0 + + + DBG_STOP + Debug Stop Mode + 1 + 1 + + + DBG_STANDBY + Debug Standby Mode + 2 + 1 + + + + + APBLFZ + APBLFZ + APB Low Freeze Register + 0x8 + 0x20 + read-write + 0x0 + + + DBG_TIMER2_STOP + Debug Timer 2 stopped when Core is + halted + 0 + 1 + + + DBG_TIMER3_STOP + Debug Timer 3 stopped when Core is + halted + 1 + 1 + + + DBG_TIMER6_STOP + Debug Timer 6 stopped when Core is + halted + 4 + 1 + + + DBG_TIMER14_STOP + Debug Timer 14 stopped when Core is + halted + 8 + 1 + + + DBG_RTC_STOP + Debug RTC stopped when Core is + halted + 10 + 1 + + + DBG_WWDG_STOP + Debug Window Wachdog stopped when Core + is halted + 11 + 1 + + + DBG_IWDG_STOP + Debug Independent Wachdog stopped when + Core is halted + 12 + 1 + + + I2C1_SMBUS_TIMEOUT + SMBUS timeout mode stopped when Core is + halted + 21 + 1 + + + + + APBHFZ + APBHFZ + APB High Freeze Register + 0xC + 0x20 + read-write + 0x0 + + + DBG_TIMER1_STOP + Debug Timer 1 stopped when Core is + halted + 11 + 1 + + + DBG_TIMER15_STO + Debug Timer 15 stopped when Core is + halted + 16 + 1 + + + DBG_TIMER16_STO + Debug Timer 16 stopped when Core is + halted + 17 + 1 + + + DBG_TIMER17_STO + Debug Timer 17 stopped when Core is + halted + 18 + 1 + + + + + + + USB + Universal serial bus full-speed device + interface + USB + 0x40005C00 + + 0x0 + 0x400 + registers + + + USB + USB global interrupt + 31 + + + + EP0R + EP0R + endpoint 0 register + 0x0 + 0x20 + read-write + 0x00000000 + + + EA + Endpoint address + 0 + 4 + + + STAT_TX + Status bits, for transmission + transfers + 4 + 2 + + + DTOG_TX + Data Toggle, for transmission + transfers + 6 + 1 + + + CTR_TX + Correct Transfer for + transmission + 7 + 1 + + + EP_KIND + Endpoint kind + 8 + 1 + + + EP_TYPE + Endpoint type + 9 + 2 + + + SETUP + Setup transaction + completed + 11 + 1 + + + STAT_RX + Status bits, for reception + transfers + 12 + 2 + + + DTOG_RX + Data Toggle, for reception + transfers + 14 + 1 + + + CTR_RX + Correct transfer for + reception + 15 + 1 + + + + + EP1R + EP1R + endpoint 1 register + 0x4 + 0x20 + read-write + 0x00000000 + + + EA + Endpoint address + 0 + 4 + + + STAT_TX + Status bits, for transmission + transfers + 4 + 2 + + + DTOG_TX + Data Toggle, for transmission + transfers + 6 + 1 + + + CTR_TX + Correct Transfer for + transmission + 7 + 1 + + + EP_KIND + Endpoint kind + 8 + 1 + + + EP_TYPE + Endpoint type + 9 + 2 + + + SETUP + Setup transaction + completed + 11 + 1 + + + STAT_RX + Status bits, for reception + transfers + 12 + 2 + + + DTOG_RX + Data Toggle, for reception + transfers + 14 + 1 + + + CTR_RX + Correct transfer for + reception + 15 + 1 + + + + + EP2R + EP2R + endpoint 2 register + 0x8 + 0x20 + read-write + 0x00000000 + + + EA + Endpoint address + 0 + 4 + + + STAT_TX + Status bits, for transmission + transfers + 4 + 2 + + + DTOG_TX + Data Toggle, for transmission + transfers + 6 + 1 + + + CTR_TX + Correct Transfer for + transmission + 7 + 1 + + + EP_KIND + Endpoint kind + 8 + 1 + + + EP_TYPE + Endpoint type + 9 + 2 + + + SETUP + Setup transaction + completed + 11 + 1 + + + STAT_RX + Status bits, for reception + transfers + 12 + 2 + + + DTOG_RX + Data Toggle, for reception + transfers + 14 + 1 + + + CTR_RX + Correct transfer for + reception + 15 + 1 + + + + + EP3R + EP3R + endpoint 3 register + 0xC + 0x20 + read-write + 0x00000000 + + + EA + Endpoint address + 0 + 4 + + + STAT_TX + Status bits, for transmission + transfers + 4 + 2 + + + DTOG_TX + Data Toggle, for transmission + transfers + 6 + 1 + + + CTR_TX + Correct Transfer for + transmission + 7 + 1 + + + EP_KIND + Endpoint kind + 8 + 1 + + + EP_TYPE + Endpoint type + 9 + 2 + + + SETUP + Setup transaction + completed + 11 + 1 + + + STAT_RX + Status bits, for reception + transfers + 12 + 2 + + + DTOG_RX + Data Toggle, for reception + transfers + 14 + 1 + + + CTR_RX + Correct transfer for + reception + 15 + 1 + + + + + EP4R + EP4R + endpoint 4 register + 0x10 + 0x20 + read-write + 0x00000000 + + + EA + Endpoint address + 0 + 4 + + + STAT_TX + Status bits, for transmission + transfers + 4 + 2 + + + DTOG_TX + Data Toggle, for transmission + transfers + 6 + 1 + + + CTR_TX + Correct Transfer for + transmission + 7 + 1 + + + EP_KIND + Endpoint kind + 8 + 1 + + + EP_TYPE + Endpoint type + 9 + 2 + + + SETUP + Setup transaction + completed + 11 + 1 + + + STAT_RX + Status bits, for reception + transfers + 12 + 2 + + + DTOG_RX + Data Toggle, for reception + transfers + 14 + 1 + + + CTR_RX + Correct transfer for + reception + 15 + 1 + + + + + EP5R + EP5R + endpoint 5 register + 0x14 + 0x20 + read-write + 0x00000000 + + + EA + Endpoint address + 0 + 4 + + + STAT_TX + Status bits, for transmission + transfers + 4 + 2 + + + DTOG_TX + Data Toggle, for transmission + transfers + 6 + 1 + + + CTR_TX + Correct Transfer for + transmission + 7 + 1 + + + EP_KIND + Endpoint kind + 8 + 1 + + + EP_TYPE + Endpoint type + 9 + 2 + + + SETUP + Setup transaction + completed + 11 + 1 + + + STAT_RX + Status bits, for reception + transfers + 12 + 2 + + + DTOG_RX + Data Toggle, for reception + transfers + 14 + 1 + + + CTR_RX + Correct transfer for + reception + 15 + 1 + + + + + EP6R + EP6R + endpoint 6 register + 0x18 + 0x20 + read-write + 0x00000000 + + + EA + Endpoint address + 0 + 4 + + + STAT_TX + Status bits, for transmission + transfers + 4 + 2 + + + DTOG_TX + Data Toggle, for transmission + transfers + 6 + 1 + + + CTR_TX + Correct Transfer for + transmission + 7 + 1 + + + EP_KIND + Endpoint kind + 8 + 1 + + + EP_TYPE + Endpoint type + 9 + 2 + + + SETUP + Setup transaction + completed + 11 + 1 + + + STAT_RX + Status bits, for reception + transfers + 12 + 2 + + + DTOG_RX + Data Toggle, for reception + transfers + 14 + 1 + + + CTR_RX + Correct transfer for + reception + 15 + 1 + + + + + EP7R + EP7R + endpoint 7 register + 0x1C + 0x20 + read-write + 0x00000000 + + + EA + Endpoint address + 0 + 4 + + + STAT_TX + Status bits, for transmission + transfers + 4 + 2 + + + DTOG_TX + Data Toggle, for transmission + transfers + 6 + 1 + + + CTR_TX + Correct Transfer for + transmission + 7 + 1 + + + EP_KIND + Endpoint kind + 8 + 1 + + + EP_TYPE + Endpoint type + 9 + 2 + + + SETUP + Setup transaction + completed + 11 + 1 + + + STAT_RX + Status bits, for reception + transfers + 12 + 2 + + + DTOG_RX + Data Toggle, for reception + transfers + 14 + 1 + + + CTR_RX + Correct transfer for + reception + 15 + 1 + + + + + CNTR + CNTR + control register + 0x40 + 0x20 + read-write + 0x00000003 + + + FRES + Force USB Reset + 0 + 1 + + + PDWN + Power down + 1 + 1 + + + LPMODE + Low-power mode + 2 + 1 + + + FSUSP + Force suspend + 3 + 1 + + + RESUME + Resume request + 4 + 1 + + + L1RESUME + LPM L1 Resume request + 5 + 1 + + + L1REQM + LPM L1 state request interrupt + mask + 7 + 1 + + + ESOFM + Expected start of frame interrupt + mask + 8 + 1 + + + SOFM + Start of frame interrupt + mask + 9 + 1 + + + RESETM + USB reset interrupt mask + 10 + 1 + + + SUSPM + Suspend mode interrupt + mask + 11 + 1 + + + WKUPM + Wakeup interrupt mask + 12 + 1 + + + ERRM + Error interrupt mask + 13 + 1 + + + PMAOVRM + Packet memory area over / underrun + interrupt mask + 14 + 1 + + + CTRM + Correct transfer interrupt + mask + 15 + 1 + + + + + ISTR + ISTR + interrupt status register + 0x44 + 0x20 + 0x00000000 + + + EP_ID + Endpoint Identifier + 0 + 4 + read-only + + + DIR + Direction of transaction + 4 + 1 + read-only + + + L1REQ + LPM L1 state request + 7 + 1 + read-write + + + ESOF + Expected start frame + 8 + 1 + read-write + + + SOF + start of frame + 9 + 1 + read-write + + + RESET + reset request + 10 + 1 + read-write + + + SUSP + Suspend mode request + 11 + 1 + read-write + + + WKUP + Wakeup + 12 + 1 + read-write + + + ERR + Error + 13 + 1 + read-write + + + PMAOVR + Packet memory area over / + underrun + 14 + 1 + read-write + + + CTR + Correct transfer + 15 + 1 + read-only + + + + + FNR + FNR + frame number register + 0x48 + 0x20 + read-only + 0x0000 + + + FN + Frame number + 0 + 11 + + + LSOF + Lost SOF + 11 + 2 + + + LCK + Locked + 13 + 1 + + + RXDM + Receive data - line status + 14 + 1 + + + RXDP + Receive data + line status + 15 + 1 + + + + + DADDR + DADDR + device address + 0x4C + 0x20 + read-write + 0x0000 + + + ADD + Device address + 0 + 7 + + + EF + Enable function + 7 + 1 + + + + + BTABLE + BTABLE + Buffer table address + 0x50 + 0x20 + read-write + 0x0000 + + + BTABLE + Buffer table + 3 + 13 + + + + + LPMCSR + LPMCSR + LPM control and status + register + 0x54 + 0x20 + 0x0000 + + + LPMEN + LPM support enable + 0 + 1 + read-write + + + LPMACK + LPM Token acknowledge + enable + 1 + 1 + read-write + + + REMWAKE + bRemoteWake value + 3 + 1 + read-only + + + BESL + BESL value + 4 + 4 + read-only + + + + + BCDR + BCDR + Battery charging detector + 0x58 + 0x20 + 0x0000 + + + BCDEN + Battery charging detector (BCD) + enable + 0 + 1 + read-write + + + DCDEN + Data contact detection (DCD) mode + enable + 1 + 1 + read-write + + + PDEN + Primary detection (PD) mode + enable + 2 + 1 + read-write + + + SDEN + Secondary detection (SD) mode + enable + 3 + 1 + read-write + + + DCDET + Data contact detection (DCD) + status + 4 + 1 + read-only + + + PDET + Primary detection (PD) + status + 5 + 1 + read-only + + + SDET + Secondary detection (SD) + status + 6 + 1 + read-only + + + PS2DET + DM pull-up detection + status + 7 + 1 + read-only + + + DPPU + DP pull-up control + 15 + 1 + read-write + + + + + + + CRS + Clock recovery system + CRS + 0x40006C00 + + 0x0 + 0x400 + registers + + + RCC_CRS + RCC and CRS global interrupts + 4 + + + + CR + CR + control register + 0x0 + 0x20 + read-write + 0x00002000 + + + TRIM + HSI48 oscillator smooth + trimming + 8 + 6 + + + SWSYNC + Generate software SYNC + event + 7 + 1 + + + AUTOTRIMEN + Automatic trimming enable + 6 + 1 + + + CEN + Frequency error counter + enable + 5 + 1 + + + ESYNCIE + Expected SYNC interrupt + enable + 3 + 1 + + + ERRIE + Synchronization or trimming error + interrupt enable + 2 + 1 + + + SYNCWARNIE + SYNC warning interrupt + enable + 1 + 1 + + + SYNCOKIE + SYNC event OK interrupt + enable + 0 + 1 + + + + + CFGR + CFGR + configuration register + 0x4 + 0x20 + read-write + 0x2022BB7F + + + SYNCPOL + SYNC polarity selection + 31 + 1 + + + SYNCSRC + SYNC signal source + selection + 28 + 2 + + + SYNCDIV + SYNC divider + 24 + 3 + + + FELIM + Frequency error limit + 16 + 8 + + + RELOAD + Counter reload value + 0 + 16 + + + + + ISR + ISR + interrupt and status register + 0x8 + 0x20 + read-only + 0x00000000 + + + FECAP + Frequency error capture + 16 + 16 + + + FEDIR + Frequency error direction + 15 + 1 + + + TRIMOVF + Trimming overflow or + underflow + 10 + 1 + + + SYNCMISS + SYNC missed + 9 + 1 + + + SYNCERR + SYNC error + 8 + 1 + + + ESYNCF + Expected SYNC flag + 3 + 1 + + + ERRF + Error flag + 2 + 1 + + + SYNCWARNF + SYNC warning flag + 1 + 1 + + + SYNCOKF + SYNC event OK flag + 0 + 1 + + + + + ICR + ICR + interrupt flag clear register + 0xC + 0x20 + read-write + 0x00000000 + + + ESYNCC + Expected SYNC clear flag + 3 + 1 + + + ERRC + Error clear flag + 2 + 1 + + + SYNCWARNC + SYNC warning clear flag + 1 + 1 + + + SYNCOKC + SYNC event OK clear flag + 0 + 1 + + + + + + + CAN + Controller area network + CAN + 0x40006400 + + 0x0 + 0x400 + registers + + + CEC_CAN + CEC and CAN global interrupt + 30 + + + + CAN_MCR + CAN_MCR + CAN_MCR + 0x0 + 0x20 + read-write + 0x00000000 + + + DBF + DBF + 16 + 1 + + + RESET + RESET + 15 + 1 + + + TTCM + TTCM + 7 + 1 + + + ABOM + ABOM + 6 + 1 + + + AWUM + AWUM + 5 + 1 + + + NART + NART + 4 + 1 + + + RFLM + RFLM + 3 + 1 + + + TXFP + TXFP + 2 + 1 + + + SLEEP + SLEEP + 1 + 1 + + + INRQ + INRQ + 0 + 1 + + + + + CAN_MSR + CAN_MSR + CAN_MSR + 0x4 + 0x20 + 0x00000000 + + + RX + RX + 11 + 1 + read-only + + + SAMP + SAMP + 10 + 1 + read-only + + + RXM + RXM + 9 + 1 + read-only + + + TXM + TXM + 8 + 1 + read-only + + + SLAKI + SLAKI + 4 + 1 + read-write + + + WKUI + WKUI + 3 + 1 + read-write + + + ERRI + ERRI + 2 + 1 + read-write + + + SLAK + SLAK + 1 + 1 + read-only + + + INAK + INAK + 0 + 1 + read-only + + + + + CAN_TSR + CAN_TSR + CAN_TSR + 0x8 + 0x20 + 0x00000000 + + + LOW2 + Lowest priority flag for mailbox + 2 + 31 + 1 + read-only + + + LOW1 + Lowest priority flag for mailbox + 1 + 30 + 1 + read-only + + + LOW0 + Lowest priority flag for mailbox + 0 + 29 + 1 + read-only + + + TME2 + Lowest priority flag for mailbox + 2 + 28 + 1 + read-only + + + TME1 + Lowest priority flag for mailbox + 1 + 27 + 1 + read-only + + + TME0 + Lowest priority flag for mailbox + 0 + 26 + 1 + read-only + + + CODE + CODE + 24 + 2 + read-only + + + ABRQ2 + ABRQ2 + 23 + 1 + read-write + + + TERR2 + TERR2 + 19 + 1 + read-write + + + ALST2 + ALST2 + 18 + 1 + read-write + + + TXOK2 + TXOK2 + 17 + 1 + read-write + + + RQCP2 + RQCP2 + 16 + 1 + read-write + + + ABRQ1 + ABRQ1 + 15 + 1 + read-write + + + TERR1 + TERR1 + 11 + 1 + read-write + + + ALST1 + ALST1 + 10 + 1 + read-write + + + TXOK1 + TXOK1 + 9 + 1 + read-write + + + RQCP1 + RQCP1 + 8 + 1 + read-write + + + ABRQ0 + ABRQ0 + 7 + 1 + read-write + + + TERR0 + TERR0 + 3 + 1 + read-write + + + ALST0 + ALST0 + 2 + 1 + read-write + + + TXOK0 + TXOK0 + 1 + 1 + read-write + + + RQCP0 + RQCP0 + 0 + 1 + read-write + + + + + CAN_RF0R + CAN_RF0R + CAN_RF0R + 0xC + 0x20 + 0x00000000 + + + RFOM0 + RFOM0 + 5 + 1 + read-write + + + FOVR0 + FOVR0 + 4 + 1 + read-write + + + FULL0 + FULL0 + 3 + 1 + read-write + + + FMP0 + FMP0 + 0 + 2 + read-only + + + + + CAN_RF1R + CAN_RF1R + CAN_RF1R + 0x10 + 0x20 + 0x00000000 + + + RFOM1 + RFOM1 + 5 + 1 + read-write + + + FOVR1 + FOVR1 + 4 + 1 + read-write + + + FULL1 + FULL1 + 3 + 1 + read-write + + + FMP1 + FMP1 + 0 + 2 + read-only + + + + + CAN_IER + CAN_IER + CAN_IER + 0x14 + 0x20 + read-write + 0x00000000 + + + SLKIE + SLKIE + 17 + 1 + + + WKUIE + WKUIE + 16 + 1 + + + ERRIE + ERRIE + 15 + 1 + + + LECIE + LECIE + 11 + 1 + + + BOFIE + BOFIE + 10 + 1 + + + EPVIE + EPVIE + 9 + 1 + + + EWGIE + EWGIE + 8 + 1 + + + FOVIE1 + FOVIE1 + 6 + 1 + + + FFIE1 + FFIE1 + 5 + 1 + + + FMPIE1 + FMPIE1 + 4 + 1 + + + FOVIE0 + FOVIE0 + 3 + 1 + + + FFIE0 + FFIE0 + 2 + 1 + + + FMPIE0 + FMPIE0 + 1 + 1 + + + TMEIE + TMEIE + 0 + 1 + + + + + CAN_ESR + CAN_ESR + CAN_ESR + 0x18 + 0x20 + 0x00000000 + + + REC + REC + 24 + 8 + read-only + + + TEC + TEC + 16 + 8 + read-only + + + LEC + LEC + 4 + 3 + read-write + + + BOFF + BOFF + 2 + 1 + read-only + + + EPVF + EPVF + 1 + 1 + read-only + + + EWGF + EWGF + 0 + 1 + read-only + + + + + CAN_BTR + CAN_BTR + CAN_BTR + 0x1C + 0x20 + read-write + 0x00000000 + + + SILM + SILM + 31 + 1 + + + LBKM + LBKM + 30 + 1 + + + SJW + SJW + 24 + 2 + + + TS2 + TS2 + 20 + 3 + + + TS1 + TS1 + 16 + 4 + + + BRP + BRP + 0 + 10 + + + + + CAN_TI0R + CAN_TI0R + CAN_TI0R + 0x180 + 0x20 + read-write + 0x00000000 + + + STID + STID + 21 + 11 + + + EXID + EXID + 3 + 18 + + + IDE + IDE + 2 + 1 + + + RTR + RTR + 1 + 1 + + + TXRQ + TXRQ + 0 + 1 + + + + + CAN_TDT0R + CAN_TDT0R + CAN_TDT0R + 0x184 + 0x20 + read-write + 0x00000000 + + + TIME + TIME + 16 + 16 + + + TGT + TGT + 8 + 1 + + + DLC + DLC + 0 + 4 + + + + + CAN_TDL0R + CAN_TDL0R + CAN_TDL0R + 0x188 + 0x20 + read-write + 0x00000000 + + + DATA3 + DATA3 + 24 + 8 + + + DATA2 + DATA2 + 16 + 8 + + + DATA1 + DATA1 + 8 + 8 + + + DATA0 + DATA0 + 0 + 8 + + + + + CAN_TDH0R + CAN_TDH0R + CAN_TDH0R + 0x18C + 0x20 + read-write + 0x00000000 + + + DATA7 + DATA7 + 24 + 8 + + + DATA6 + DATA6 + 16 + 8 + + + DATA5 + DATA5 + 8 + 8 + + + DATA4 + DATA4 + 0 + 8 + + + + + CAN_TI1R + CAN_TI1R + CAN_TI1R + 0x190 + 0x20 + read-write + 0x00000000 + + + STID + STID + 21 + 11 + + + EXID + EXID + 3 + 18 + + + IDE + IDE + 2 + 1 + + + RTR + RTR + 1 + 1 + + + TXRQ + TXRQ + 0 + 1 + + + + + CAN_TDT1R + CAN_TDT1R + CAN_TDT1R + 0x194 + 0x20 + read-write + 0x00000000 + + + TIME + TIME + 16 + 16 + + + TGT + TGT + 8 + 1 + + + DLC + DLC + 0 + 4 + + + + + CAN_TDL1R + CAN_TDL1R + CAN_TDL1R + 0x198 + 0x20 + read-write + 0x00000000 + + + DATA3 + DATA3 + 24 + 8 + + + DATA2 + DATA2 + 16 + 8 + + + DATA1 + DATA1 + 8 + 8 + + + DATA0 + DATA0 + 0 + 8 + + + + + CAN_TDH1R + CAN_TDH1R + CAN_TDH1R + 0x19C + 0x20 + read-write + 0x00000000 + + + DATA7 + DATA7 + 24 + 8 + + + DATA6 + DATA6 + 16 + 8 + + + DATA5 + DATA5 + 8 + 8 + + + DATA4 + DATA4 + 0 + 8 + + + + + CAN_TI2R + CAN_TI2R + CAN_TI2R + 0x1A0 + 0x20 + read-write + 0x00000000 + + + STID + STID + 21 + 11 + + + EXID + EXID + 3 + 18 + + + IDE + IDE + 2 + 1 + + + RTR + RTR + 1 + 1 + + + TXRQ + TXRQ + 0 + 1 + + + + + CAN_TDT2R + CAN_TDT2R + CAN_TDT2R + 0x1A4 + 0x20 + read-write + 0x00000000 + + + TIME + TIME + 16 + 16 + + + TGT + TGT + 8 + 1 + + + DLC + DLC + 0 + 4 + + + + + CAN_TDL2R + CAN_TDL2R + CAN_TDL2R + 0x1A8 + 0x20 + read-write + 0x00000000 + + + DATA3 + DATA3 + 24 + 8 + + + DATA2 + DATA2 + 16 + 8 + + + DATA1 + DATA1 + 8 + 8 + + + DATA0 + DATA0 + 0 + 8 + + + + + CAN_TDH2R + CAN_TDH2R + CAN_TDH2R + 0x1AC + 0x20 + read-write + 0x00000000 + + + DATA7 + DATA7 + 24 + 8 + + + DATA6 + DATA6 + 16 + 8 + + + DATA5 + DATA5 + 8 + 8 + + + DATA4 + DATA4 + 0 + 8 + + + + + CAN_RI0R + CAN_RI0R + CAN_RI0R + 0x1B0 + 0x20 + read-only + 0x00000000 + + + STID + STID + 21 + 11 + + + EXID + EXID + 3 + 18 + + + IDE + IDE + 2 + 1 + + + RTR + RTR + 1 + 1 + + + + + CAN_RDT0R + CAN_RDT0R + CAN_RDT0R + 0x1B4 + 0x20 + read-only + 0x00000000 + + + TIME + TIME + 16 + 16 + + + FMI + FMI + 8 + 8 + + + DLC + DLC + 0 + 4 + + + + + CAN_RDL0R + CAN_RDL0R + CAN_RDL0R + 0x1B8 + 0x20 + read-only + 0x00000000 + + + DATA3 + DATA3 + 24 + 8 + + + DATA2 + DATA2 + 16 + 8 + + + DATA1 + DATA1 + 8 + 8 + + + DATA0 + DATA0 + 0 + 8 + + + + + CAN_RDH0R + CAN_RDH0R + CAN_RDH0R + 0x1BC + 0x20 + read-only + 0x00000000 + + + DATA7 + DATA7 + 24 + 8 + + + DATA6 + DATA6 + 16 + 8 + + + DATA5 + DATA5 + 8 + 8 + + + DATA4 + DATA4 + 0 + 8 + + + + + CAN_RI1R + CAN_RI1R + CAN_RI1R + 0x1C0 + 0x20 + read-only + 0x00000000 + + + STID + STID + 21 + 11 + + + EXID + EXID + 3 + 18 + + + IDE + IDE + 2 + 1 + + + RTR + RTR + 1 + 1 + + + + + CAN_RDT1R + CAN_RDT1R + CAN_RDT1R + 0x1C4 + 0x20 + read-only + 0x00000000 + + + TIME + TIME + 16 + 16 + + + FMI + FMI + 8 + 8 + + + DLC + DLC + 0 + 4 + + + + + CAN_RDL1R + CAN_RDL1R + CAN_RDL1R + 0x1C8 + 0x20 + read-only + 0x00000000 + + + DATA3 + DATA3 + 24 + 8 + + + DATA2 + DATA2 + 16 + 8 + + + DATA1 + DATA1 + 8 + 8 + + + DATA0 + DATA0 + 0 + 8 + + + + + CAN_RDH1R + CAN_RDH1R + CAN_RDH1R + 0x1CC + 0x20 + read-only + 0x00000000 + + + DATA7 + DATA7 + 24 + 8 + + + DATA6 + DATA6 + 16 + 8 + + + DATA5 + DATA5 + 8 + 8 + + + DATA4 + DATA4 + 0 + 8 + + + + + CAN_FMR + CAN_FMR + CAN_FMR + 0x200 + 0x20 + read-write + 0x00000000 + + + CAN2SB + CAN2SB + 8 + 6 + + + FINIT + FINIT + 0 + 1 + + + + + CAN_FM1R + CAN_FM1R + CAN_FM1R + 0x204 + 0x20 + read-write + 0x00000000 + + + FBM0 + Filter mode + 0 + 1 + + + FBM1 + Filter mode + 1 + 1 + + + FBM2 + Filter mode + 2 + 1 + + + FBM3 + Filter mode + 3 + 1 + + + FBM4 + Filter mode + 4 + 1 + + + FBM5 + Filter mode + 5 + 1 + + + FBM6 + Filter mode + 6 + 1 + + + FBM7 + Filter mode + 7 + 1 + + + FBM8 + Filter mode + 8 + 1 + + + FBM9 + Filter mode + 9 + 1 + + + FBM10 + Filter mode + 10 + 1 + + + FBM11 + Filter mode + 11 + 1 + + + FBM12 + Filter mode + 12 + 1 + + + FBM13 + Filter mode + 13 + 1 + + + FBM14 + Filter mode + 14 + 1 + + + FBM15 + Filter mode + 15 + 1 + + + FBM16 + Filter mode + 16 + 1 + + + FBM17 + Filter mode + 17 + 1 + + + FBM18 + Filter mode + 18 + 1 + + + FBM19 + Filter mode + 19 + 1 + + + FBM20 + Filter mode + 20 + 1 + + + FBM21 + Filter mode + 21 + 1 + + + FBM22 + Filter mode + 22 + 1 + + + FBM23 + Filter mode + 23 + 1 + + + FBM24 + Filter mode + 24 + 1 + + + FBM25 + Filter mode + 25 + 1 + + + FBM26 + Filter mode + 26 + 1 + + + FBM27 + Filter mode + 27 + 1 + + + + + CAN_FS1R + CAN_FS1R + CAN_FS1R + 0x20C + 0x20 + read-write + 0x00000000 + + + FSC0 + Filter scale configuration + 0 + 1 + + + FSC1 + Filter scale configuration + 1 + 1 + + + FSC2 + Filter scale configuration + 2 + 1 + + + FSC3 + Filter scale configuration + 3 + 1 + + + FSC4 + Filter scale configuration + 4 + 1 + + + FSC5 + Filter scale configuration + 5 + 1 + + + FSC6 + Filter scale configuration + 6 + 1 + + + FSC7 + Filter scale configuration + 7 + 1 + + + FSC8 + Filter scale configuration + 8 + 1 + + + FSC9 + Filter scale configuration + 9 + 1 + + + FSC10 + Filter scale configuration + 10 + 1 + + + FSC11 + Filter scale configuration + 11 + 1 + + + FSC12 + Filter scale configuration + 12 + 1 + + + FSC13 + Filter scale configuration + 13 + 1 + + + FSC14 + Filter scale configuration + 14 + 1 + + + FSC15 + Filter scale configuration + 15 + 1 + + + FSC16 + Filter scale configuration + 16 + 1 + + + FSC17 + Filter scale configuration + 17 + 1 + + + FSC18 + Filter scale configuration + 18 + 1 + + + FSC19 + Filter scale configuration + 19 + 1 + + + FSC20 + Filter scale configuration + 20 + 1 + + + FSC21 + Filter scale configuration + 21 + 1 + + + FSC22 + Filter scale configuration + 22 + 1 + + + FSC23 + Filter scale configuration + 23 + 1 + + + FSC24 + Filter scale configuration + 24 + 1 + + + FSC25 + Filter scale configuration + 25 + 1 + + + FSC26 + Filter scale configuration + 26 + 1 + + + FSC27 + Filter scale configuration + 27 + 1 + + + + + CAN_FFA1R + CAN_FFA1R + CAN_FFA1R + 0x214 + 0x20 + read-write + 0x00000000 + + + FFA0 + Filter FIFO assignment for filter + 0 + 0 + 1 + + + FFA1 + Filter FIFO assignment for filter + 1 + 1 + 1 + + + FFA2 + Filter FIFO assignment for filter + 2 + 2 + 1 + + + FFA3 + Filter FIFO assignment for filter + 3 + 3 + 1 + + + FFA4 + Filter FIFO assignment for filter + 4 + 4 + 1 + + + FFA5 + Filter FIFO assignment for filter + 5 + 5 + 1 + + + FFA6 + Filter FIFO assignment for filter + 6 + 6 + 1 + + + FFA7 + Filter FIFO assignment for filter + 7 + 7 + 1 + + + FFA8 + Filter FIFO assignment for filter + 8 + 8 + 1 + + + FFA9 + Filter FIFO assignment for filter + 9 + 9 + 1 + + + FFA10 + Filter FIFO assignment for filter + 10 + 10 + 1 + + + FFA11 + Filter FIFO assignment for filter + 11 + 11 + 1 + + + FFA12 + Filter FIFO assignment for filter + 12 + 12 + 1 + + + FFA13 + Filter FIFO assignment for filter + 13 + 13 + 1 + + + FFA14 + Filter FIFO assignment for filter + 14 + 14 + 1 + + + FFA15 + Filter FIFO assignment for filter + 15 + 15 + 1 + + + FFA16 + Filter FIFO assignment for filter + 16 + 16 + 1 + + + FFA17 + Filter FIFO assignment for filter + 17 + 17 + 1 + + + FFA18 + Filter FIFO assignment for filter + 18 + 18 + 1 + + + FFA19 + Filter FIFO assignment for filter + 19 + 19 + 1 + + + FFA20 + Filter FIFO assignment for filter + 20 + 20 + 1 + + + FFA21 + Filter FIFO assignment for filter + 21 + 21 + 1 + + + FFA22 + Filter FIFO assignment for filter + 22 + 22 + 1 + + + FFA23 + Filter FIFO assignment for filter + 23 + 23 + 1 + + + FFA24 + Filter FIFO assignment for filter + 24 + 24 + 1 + + + FFA25 + Filter FIFO assignment for filter + 25 + 25 + 1 + + + FFA26 + Filter FIFO assignment for filter + 26 + 26 + 1 + + + FFA27 + Filter FIFO assignment for filter + 27 + 27 + 1 + + + + + CAN_FA1R + CAN_FA1R + CAN_FA1R + 0x21C + 0x20 + read-write + 0x00000000 + + + FACT0 + Filter active + 0 + 1 + + + FACT1 + Filter active + 1 + 1 + + + FACT2 + Filter active + 2 + 1 + + + FACT3 + Filter active + 3 + 1 + + + FACT4 + Filter active + 4 + 1 + + + FACT5 + Filter active + 5 + 1 + + + FACT6 + Filter active + 6 + 1 + + + FACT7 + Filter active + 7 + 1 + + + FACT8 + Filter active + 8 + 1 + + + FACT9 + Filter active + 9 + 1 + + + FACT10 + Filter active + 10 + 1 + + + FACT11 + Filter active + 11 + 1 + + + FACT12 + Filter active + 12 + 1 + + + FACT13 + Filter active + 13 + 1 + + + FACT14 + Filter active + 14 + 1 + + + FACT15 + Filter active + 15 + 1 + + + FACT16 + Filter active + 16 + 1 + + + FACT17 + Filter active + 17 + 1 + + + FACT18 + Filter active + 18 + 1 + + + FACT19 + Filter active + 19 + 1 + + + FACT20 + Filter active + 20 + 1 + + + FACT21 + Filter active + 21 + 1 + + + FACT22 + Filter active + 22 + 1 + + + FACT23 + Filter active + 23 + 1 + + + FACT24 + Filter active + 24 + 1 + + + FACT25 + Filter active + 25 + 1 + + + FACT26 + Filter active + 26 + 1 + + + FACT27 + Filter active + 27 + 1 + + + + + F0R1 + F0R1 + Filter bank 0 register 1 + 0x240 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F0R2 + F0R2 + Filter bank 0 register 2 + 0x244 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F1R1 + F1R1 + Filter bank 1 register 1 + 0x248 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F1R2 + F1R2 + Filter bank 1 register 2 + 0x24C + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F2R1 + F2R1 + Filter bank 2 register 1 + 0x250 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F2R2 + F2R2 + Filter bank 2 register 2 + 0x254 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F3R1 + F3R1 + Filter bank 3 register 1 + 0x258 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F3R2 + F3R2 + Filter bank 3 register 2 + 0x25C + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F4R1 + F4R1 + Filter bank 4 register 1 + 0x260 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F4R2 + F4R2 + Filter bank 4 register 2 + 0x264 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F5R1 + F5R1 + Filter bank 5 register 1 + 0x268 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F5R2 + F5R2 + Filter bank 5 register 2 + 0x26C + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F6R1 + F6R1 + Filter bank 6 register 1 + 0x270 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F6R2 + F6R2 + Filter bank 6 register 2 + 0x274 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F7R1 + F7R1 + Filter bank 7 register 1 + 0x278 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F7R2 + F7R2 + Filter bank 7 register 2 + 0x27C + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F8R1 + F8R1 + Filter bank 8 register 1 + 0x280 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F8R2 + F8R2 + Filter bank 8 register 2 + 0x284 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F9R1 + F9R1 + Filter bank 9 register 1 + 0x288 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F9R2 + F9R2 + Filter bank 9 register 2 + 0x28C + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F10R1 + F10R1 + Filter bank 10 register 1 + 0x290 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F10R2 + F10R2 + Filter bank 10 register 2 + 0x294 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F11R1 + F11R1 + Filter bank 11 register 1 + 0x298 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F11R2 + F11R2 + Filter bank 11 register 2 + 0x29C + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F12R1 + F12R1 + Filter bank 4 register 1 + 0x2A0 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F12R2 + F12R2 + Filter bank 12 register 2 + 0x2A4 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F13R1 + F13R1 + Filter bank 13 register 1 + 0x2A8 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F13R2 + F13R2 + Filter bank 13 register 2 + 0x2AC + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F14R1 + F14R1 + Filter bank 14 register 1 + 0x2B0 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F14R2 + F14R2 + Filter bank 14 register 2 + 0x2B4 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F15R1 + F15R1 + Filter bank 15 register 1 + 0x2B8 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F15R2 + F15R2 + Filter bank 15 register 2 + 0x2BC + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F16R1 + F16R1 + Filter bank 16 register 1 + 0x2C0 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F16R2 + F16R2 + Filter bank 16 register 2 + 0x2C4 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F17R1 + F17R1 + Filter bank 17 register 1 + 0x2C8 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F17R2 + F17R2 + Filter bank 17 register 2 + 0x2CC + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F18R1 + F18R1 + Filter bank 18 register 1 + 0x2D0 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F18R2 + F18R2 + Filter bank 18 register 2 + 0x2D4 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F19R1 + F19R1 + Filter bank 19 register 1 + 0x2D8 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F19R2 + F19R2 + Filter bank 19 register 2 + 0x2DC + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F20R1 + F20R1 + Filter bank 20 register 1 + 0x2E0 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F20R2 + F20R2 + Filter bank 20 register 2 + 0x2E4 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F21R1 + F21R1 + Filter bank 21 register 1 + 0x2E8 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F21R2 + F21R2 + Filter bank 21 register 2 + 0x2EC + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F22R1 + F22R1 + Filter bank 22 register 1 + 0x2F0 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F22R2 + F22R2 + Filter bank 22 register 2 + 0x2F4 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F23R1 + F23R1 + Filter bank 23 register 1 + 0x2F8 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F23R2 + F23R2 + Filter bank 23 register 2 + 0x2FC + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F24R1 + F24R1 + Filter bank 24 register 1 + 0x300 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F24R2 + F24R2 + Filter bank 24 register 2 + 0x304 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F25R1 + F25R1 + Filter bank 25 register 1 + 0x308 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F25R2 + F25R2 + Filter bank 25 register 2 + 0x30C + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F26R1 + F26R1 + Filter bank 26 register 1 + 0x310 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F26R2 + F26R2 + Filter bank 26 register 2 + 0x314 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F27R1 + F27R1 + Filter bank 27 register 1 + 0x318 + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + F27R2 + F27R2 + Filter bank 27 register 2 + 0x31C + 0x20 + read-write + 0x00000000 + + + FB0 + Filter bits + 0 + 1 + + + FB1 + Filter bits + 1 + 1 + + + FB2 + Filter bits + 2 + 1 + + + FB3 + Filter bits + 3 + 1 + + + FB4 + Filter bits + 4 + 1 + + + FB5 + Filter bits + 5 + 1 + + + FB6 + Filter bits + 6 + 1 + + + FB7 + Filter bits + 7 + 1 + + + FB8 + Filter bits + 8 + 1 + + + FB9 + Filter bits + 9 + 1 + + + FB10 + Filter bits + 10 + 1 + + + FB11 + Filter bits + 11 + 1 + + + FB12 + Filter bits + 12 + 1 + + + FB13 + Filter bits + 13 + 1 + + + FB14 + Filter bits + 14 + 1 + + + FB15 + Filter bits + 15 + 1 + + + FB16 + Filter bits + 16 + 1 + + + FB17 + Filter bits + 17 + 1 + + + FB18 + Filter bits + 18 + 1 + + + FB19 + Filter bits + 19 + 1 + + + FB20 + Filter bits + 20 + 1 + + + FB21 + Filter bits + 21 + 1 + + + FB22 + Filter bits + 22 + 1 + + + FB23 + Filter bits + 23 + 1 + + + FB24 + Filter bits + 24 + 1 + + + FB25 + Filter bits + 25 + 1 + + + FB26 + Filter bits + 26 + 1 + + + FB27 + Filter bits + 27 + 1 + + + FB28 + Filter bits + 28 + 1 + + + FB29 + Filter bits + 29 + 1 + + + FB30 + Filter bits + 30 + 1 + + + FB31 + Filter bits + 31 + 1 + + + + + + + diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/cfg/stm32f091rc_flash.ld b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/cfg/stm32f091rc_flash.ld new file mode 100644 index 00000000..822ff6c4 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/cfg/stm32f091rc_flash.ld @@ -0,0 +1,186 @@ +/* ---------------------------------------------------------------------------- */ +/* Em::Blocks embedded development Support */ +/* ---------------------------------------------------------------------------- */ +/* Copyright (c) 2014, EmBlocks */ +/* */ +/* All rights reserved. */ +/* */ +/* Redistribution and use in source and binary forms, with or without */ +/* modification, are permitted provided that the following condition is met: */ +/* */ +/* - Redistributions of source code must retain the above copyright notice, */ +/* this list of conditions and the disclaimer below. */ +/* */ +/* EmBlocks's name may not be used to endorse or promote products derived from */ +/* this software without specific prior written permission. */ +/* */ +/* DISCLAIMER: THIS SOFTWARE IS PROVIDED BY EBLOCKS "AS IS" AND ANY EXPRESS OR */ +/* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE */ +/* DISCLAIMED. IN NO EVENT SHALL EMBLOCKS BE LIABLE FOR ANY DIRECT, INDIRECT, */ +/* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */ +/* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF */ +/* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, */ +/* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* ---------------------------------------------------------------------------- */ + +/*------------------------------------------------------------------------------ + * Linker script for running in internal FLASH on the STM32F091RC + *----------------------------------------------------------------------------*/ + +OUTPUT_FORMAT("elf32-littlearm", "elf32-littlearm", "elf32-littlearm") +OUTPUT_ARCH(arm) +SEARCH_DIR(.) + +/* Memory Spaces Definitions */ +MEMORY +{ + /* The first part in flash is reserved for OpenBLT */ + ROM (rx) : ORIGIN = 0x08002000, LENGTH = 256K - 8K + /* The first 192 bytes in RAM are reserved for OpenBLT. Right before + * starting this program, OpenBLT copies our interrupt vector table + * to the start of RAM and remap the RAM to also appear at address + * 0x00000000. + */ + RAM (rwx) : ORIGIN = 0x200000C0, LENGTH = 32K - 192 +} + +/* Linker script to place sections and symbol values. Should be used together + * with other linker script that defines memory regions FLASH and RAM. + * It references following symbols, which must be defined in code: + * Reset_Handler : Entry of reset handler + * + * It defines following symbols, which code can use without definition: + * __exidx_start + * __exidx_end + * __etext + * __data_start__ + * __preinit_array_start + * __preinit_array_end + * __init_array_start + * __init_array_end + * __fini_array_start + * __fini_array_end + * __data_end__ + * __bss_start__ + * __bss_end__ + * __end__ + * end + * __HeapLimit + * __StackLimit + * __StackTop + * __stack + */ + + +SECTIONS +{ + .text : + { + KEEP(*(.isr_vector)) + *(.text*) + + KEEP(*(.init)) + KEEP(*(.fini)) + + /* .ctors */ + *crtbegin.o(.ctors) + *crtbegin?.o(.ctors) + *(EXCLUDE_FILE(*crtend?.o *crtend.o) .ctors) + *(SORT(.ctors.*)) + *(.ctors) + + /* .dtors */ + *crtbegin.o(.dtors) + *crtbegin?.o(.dtors) + *(EXCLUDE_FILE(*crtend?.o *crtend.o) .dtors) + *(SORT(.dtors.*)) + *(.dtors) + + *(.rodata*) + + KEEP(*(.eh_frame*)) + } > ROM + + .ARM.extab : + { + *(.ARM.extab* .gnu.linkonce.armextab.*) + } > ROM + + __exidx_start = .; + .ARM.exidx : + { + *(.ARM.exidx* .gnu.linkonce.armexidx.*) + } > ROM + __exidx_end = .; + + __etext = .; + + .data : AT (__etext) + { + __data_start__ = .; + *(vtable) + *(.data*) + + . = ALIGN(4); + /* preinit data */ + PROVIDE_HIDDEN (__preinit_array_start = .); + KEEP(*(.preinit_array)) + PROVIDE_HIDDEN (__preinit_array_end = .); + + . = ALIGN(4); + /* init data */ + PROVIDE_HIDDEN (__init_array_start = .); + KEEP(*(SORT(.init_array.*))) + KEEP(*(.init_array)) + PROVIDE_HIDDEN (__init_array_end = .); + + + . = ALIGN(4); + /* finit data */ + PROVIDE_HIDDEN (__fini_array_start = .); + KEEP(*(SORT(.fini_array.*))) + KEEP(*(.fini_array)) + PROVIDE_HIDDEN (__fini_array_end = .); + + . = ALIGN(4); + /* All data end */ + __data_end__ = .; + + } > RAM + + .bss (NOLOAD): + { + __bss_start__ = .; + *(.bss*) + *(COMMON) + __bss_end__ = .; + } > RAM + + .heap (NOLOAD): + { + __end__ = .; + end = __end__; + *(.heap*) + __HeapLimit = .; + } > RAM + + /* .stack_dummy section doesn't contains any symbols. It is only + * used for linker to calculate size of stack sections, and assign + * values to stack symbols later */ + .stack_dummy (NOLOAD): + { + *(.stack) + } > RAM + + /* Set stack top to end of RAM, and stack limit move down by + * size of stack_dummy section */ + __StackTop = ORIGIN(RAM) + LENGTH(RAM); + __StackLimit = __StackTop - SIZEOF(.stack_dummy); + PROVIDE(__stack = __StackTop); + + /* Check if data + heap + stack exceeds RAM limit */ + ASSERT(__StackLimit >= __HeapLimit, "region RAM overflowed with stack") +} diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/header.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/header.h new file mode 100644 index 00000000..9154b983 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/header.h @@ -0,0 +1,42 @@ +/************************************************************************************//** +* \file Demo\ARMCM0_STM32F0_Nucleo_F091RC_GCC\Prog\header.h +* \brief Generic header file. +* \ingroup Prog_ARMCM0_STM32F0_Nucleo_F091RC_GCC +* \internal +*---------------------------------------------------------------------------------------- +* C O P Y R I G H T +*---------------------------------------------------------------------------------------- +* Copyright (c) 2016 by Feaser http://www.feaser.com All rights reserved +* +*---------------------------------------------------------------------------------------- +* L I C E N S E +*---------------------------------------------------------------------------------------- +* This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +* modify it under the terms of the GNU General Public License as published by the Free +* Software Foundation, either version 3 of the License, or (at your option) any later +* version. +* +* OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +* PURPOSE. See the GNU General Public License for more details. +* +* You have received a copy of the GNU General Public License along with OpenBLT. It +* should be located in ".\Doc\license.html". If not, contact Feaser to obtain a copy. +* +* \endinternal +****************************************************************************************/ +#ifndef HEADER_H +#define HEADER_H + +/**************************************************************************************** +* Include files +****************************************************************************************/ +#include "../Boot/blt_conf.h" /* bootloader configuration */ +#include "stm32f0xx.h" /* for STM32F0 registers and drivers */ +#include "boot.h" /* bootloader interface driver */ +#include "led.h" /* LED driver */ +#include "timer.h" /* Timer driver */ + + +#endif /* HEADER_H */ +/*********************************** end of header.h ***********************************/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/ide/stm32f091.depend b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/ide/stm32f091.depend new file mode 100644 index 00000000..3762bc39 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/ide/stm32f091.depend @@ -0,0 +1,788 @@ +# depslib dependency file v1.0 +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_adc.c + "stm32f0xx_adc.h" + "stm32f0xx_rcc.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_adc.h + "stm32f0xx.h" + +1417710862 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\stm32f0xx.h + "core_cm0.h" + "system_stm32f0xx.h" + + "stm32f0xx_conf.h" + +1417516674 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\cmsis\core_cm0.h + + + + +1417516674 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\cmsis\core_cminstr.h + + + +1417516674 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\cmsis\core_cmfunc.h + + + +1417714462 c:\users\voorburg\desktop\stm32f091_emblocks_os\src\hw\system_stm32f0xx.h + +1417516578 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\stm32f0xx_conf.h + "stm32f0xx_adc.h" + "stm32f0xx_can.h" + "stm32f0xx_cec.h" + "stm32f0xx_comp.h" + "stm32f0xx_crc.h" + "stm32f0xx_crs.h" + "stm32f0xx_dac.h" + "stm32f0xx_dbgmcu.h" + "stm32f0xx_dma.h" + "stm32f0xx_exti.h" + "stm32f0xx_flash.h" + "stm32f0xx_gpio.h" + "stm32f0xx_i2c.h" + "stm32f0xx_iwdg.h" + "stm32f0xx_pwr.h" + "stm32f0xx_rcc.h" + "stm32f0xx_rtc.h" + "stm32f0xx_spi.h" + "stm32f0xx_syscfg.h" + "stm32f0xx_tim.h" + "stm32f0xx_usart.h" + "stm32f0xx_wwdg.h" + "stm32f0xx_misc.h" + +1417710865 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_can.h + "stm32f0xx.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_cec.h + "stm32f0xx.h" + +1417710865 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_comp.h + "stm32f0xx.h" + +1417710865 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_crc.h + "stm32f0xx.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_crs.h + "stm32f0xx.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_dac.h + "stm32f0xx.h" + +1417710865 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_dbgmcu.h + "stm32f0xx.h" + +1417710865 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_dma.h + "stm32f0xx.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_exti.h + "stm32f0xx.h" + +1417710865 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_flash.h + "stm32f0xx.h" + +1417710865 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_gpio.h + "stm32f0xx.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_i2c.h + "stm32f0xx.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_iwdg.h + "stm32f0xx.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_pwr.h + "stm32f0xx.h" + +1417710865 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_rcc.h + "stm32f0xx.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_rtc.h + "stm32f0xx.h" + +1417710865 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_spi.h + "stm32f0xx.h" + +1417710865 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_syscfg.h + "stm32f0xx.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_tim.h + "stm32f0xx.h" + +1417710865 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_usart.h + "stm32f0xx.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_wwdg.h + "stm32f0xx.h" + +1417710864 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\inc\stm32f0xx_misc.h + "stm32f0xx.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_can.c + "stm32f0xx_can.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_cec.c + "stm32f0xx_cec.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_comp.c + "stm32f0xx_comp.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_crc.c + "stm32f0xx_crc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_crs.c + "stm32f0xx_crs.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_dac.c + "stm32f0xx_dac.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_dbgmcu.c + "stm32f0xx_dbgmcu.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_dma.c + "stm32f0xx_dma.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_exti.c + "stm32f0xx_exti.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_flash.c + "stm32f0xx_flash.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_gpio.c + "stm32f0xx_gpio.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_i2c.c + "stm32f0xx_i2c.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_iwdg.c + "stm32f0xx_iwdg.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_misc.c + "stm32f0xx_misc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_pwr.c + "stm32f0xx_pwr.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_rcc.c + "stm32f0xx_rcc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_rtc.c + "stm32f0xx_rtc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_spi.c + "stm32f0xx_spi.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_syscfg.c + "stm32f0xx_syscfg.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_tim.c + "stm32f0xx_tim.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_usart.c + "stm32f0xx_usart.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\spl\src\stm32f0xx_wwdg.c + "stm32f0xx_wwdg.h" + "stm32f0xx_rcc.h" + +1479203609 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\src\app\app.c + "header.h" + +1461835068 c:\users\voorburg\desktop\stm32f091_emblocks_os\src\header.h + + + "os.h" + "hw.h" + "app.h" + +1452182352 c:\users\voorburg\desktop\stm32f091_emblocks_os\src\os\os.h + +1461835274 c:\users\voorburg\desktop\stm32f091_emblocks_os\src\hw\hw.h + "stm32f0xx_conf.h" + "led.h" + +1452182499 c:\users\voorburg\desktop\stm32f091_emblocks_os\src\hw\led.h + +1452182185 c:\users\voorburg\desktop\stm32f091_emblocks_os\src\app\app.h + "assert.h" + +1452181838 c:\users\voorburg\desktop\stm32f091_emblocks_os\src\app\assert.h + +1452181962 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\src\app\assert.c + "header.h" + +1461835384 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\src\hw\hw.c + "header.h" + +1471419376 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\src\hw\startup_stm32f0xx.s + +1471422675 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\src\hw\system_stm32f0xx.c + "stm32f0xx.h" + +1452182352 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\src\os\os.c + "os.h" + +1471421727 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\src\hw\led.c + "header.h" + +1417710862 c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\system_stm32f0xx.h + +1471419075 source:c:\users\voorburg\desktop\stm32f091_emblocks_os\lib\system_stm32f0xx.c + "stm32f0xx.h" + +1479205364 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\hooks.c + "boot.h" + "led.h" + "stm32f0xx.h" + +1477216154 c:\work\software\openblt\target\source\boot.h + "types.h" + "assert.h" + "blt_conf.h" + "plausibility.h" + "cpu.h" + "cop.h" + "nvm.h" + "timer.h" + "backdoor.h" + "file.h" + "com.h" + +1477294386 c:\work\software\openblt\target\source\armcm0_stm32f0\types.h + +1469431761 c:\work\software\openblt\target\source\assert.h + +1479210119 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\blt_conf.h + +1469431761 c:\work\software\openblt\target\source\plausibility.h + +1476728168 c:\work\software\openblt\target\source\cpu.h + +1469431761 c:\work\software\openblt\target\source\cop.h + +1469431761 c:\work\software\openblt\target\source\nvm.h + +1469431761 c:\work\software\openblt\target\source\timer.h + +1469431761 c:\work\software\openblt\target\source\backdoor.h + +1469431761 c:\work\software\openblt\target\source\file.h + "ff.h" + +1469431761 c:\work\software\openblt\target\source\com.h + "xcp.h" + +1476783465 c:\work\software\openblt\target\source\xcp.h + +1479203921 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\led.h + +1417710862 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\stm32f0xx.h + "core_cm0.h" + "system_stm32f0xx.h" + + "stm32f0xx_conf.h" + +1417516674 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\cmsis\core_cm0.h + + + + +1417516674 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\cmsis\core_cminstr.h + + + +1417516674 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\cmsis\core_cmfunc.h + + + +1417710862 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\system_stm32f0xx.h + +1417516578 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\stm32f0xx_conf.h + "stm32f0xx_adc.h" + "stm32f0xx_can.h" + "stm32f0xx_cec.h" + "stm32f0xx_comp.h" + "stm32f0xx_crc.h" + "stm32f0xx_crs.h" + "stm32f0xx_dac.h" + "stm32f0xx_dbgmcu.h" + "stm32f0xx_dma.h" + "stm32f0xx_exti.h" + "stm32f0xx_flash.h" + "stm32f0xx_gpio.h" + "stm32f0xx_i2c.h" + "stm32f0xx_iwdg.h" + "stm32f0xx_pwr.h" + "stm32f0xx_rcc.h" + "stm32f0xx_rtc.h" + "stm32f0xx_spi.h" + "stm32f0xx_syscfg.h" + "stm32f0xx_tim.h" + "stm32f0xx_usart.h" + "stm32f0xx_wwdg.h" + "stm32f0xx_misc.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_adc.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_can.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_cec.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_comp.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_crc.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_crs.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_dac.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_dbgmcu.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_dma.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_exti.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_flash.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_gpio.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_i2c.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_iwdg.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_pwr.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_rcc.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_rtc.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_spi.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_syscfg.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_tim.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_usart.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_wwdg.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\inc\stm32f0xx_misc.h + "stm32f0xx.h" + +1479205544 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\led.c + "boot.h" + "led.h" + "stm32f0xx.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_adc.c + "stm32f0xx_adc.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_can.c + "stm32f0xx_can.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_cec.c + "stm32f0xx_cec.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_comp.c + "stm32f0xx_comp.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_crc.c + "stm32f0xx_crc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_crs.c + "stm32f0xx_crs.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_dac.c + "stm32f0xx_dac.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_dbgmcu.c + "stm32f0xx_dbgmcu.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_dma.c + "stm32f0xx_dma.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_exti.c + "stm32f0xx_exti.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_flash.c + "stm32f0xx_flash.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_gpio.c + "stm32f0xx_gpio.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_i2c.c + "stm32f0xx_i2c.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_iwdg.c + "stm32f0xx_iwdg.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_misc.c + "stm32f0xx_misc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_pwr.c + "stm32f0xx_pwr.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_rcc.c + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_rtc.c + "stm32f0xx_rtc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_spi.c + "stm32f0xx_spi.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_syscfg.c + "stm32f0xx_syscfg.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_tim.c + "stm32f0xx_tim.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_usart.c + "stm32f0xx_usart.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\spl\src\stm32f0xx_wwdg.c + "stm32f0xx_wwdg.h" + "stm32f0xx_rcc.h" + +1471419075 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\lib\system_stm32f0xx.c + "stm32f0xx.h" + +1479206258 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\boot\main.c + "boot.h" + "stm32f0xx.h" + +1477294428 source:c:\work\software\openblt\target\source\armcm0_stm32f0\cpu.c + "boot.h" + "stm32f0xx.h" + +1477294420 source:c:\work\software\openblt\target\source\armcm0_stm32f0\flash.c + "boot.h" + "stm32f0xx.h" + "flash_layout.c" + +1477294453 source:c:\work\software\openblt\target\source\armcm0_stm32f0\gcc\cpu_comp.c + "boot.h" + +1476741290 source:c:\work\software\openblt\target\source\armcm0_stm32f0\gcc\cstart.s + +1477294404 source:c:\work\software\openblt\target\source\armcm0_stm32f0\nvm.c + "boot.h" + "flash.h" + +1477294413 c:\work\software\openblt\target\source\armcm0_stm32f0\flash.h + +1477294395 source:c:\work\software\openblt\target\source\armcm0_stm32f0\timer.c + "boot.h" + "stm32f0xx.h" + +1479206221 source:c:\work\software\openblt\target\source\armcm0_stm32f0\uart.c + "boot.h" + "stm32f0xx.h" + +1477295250 source:c:\work\software\openblt\target\source\assert.c + "boot.h" + +1469431756 source:c:\work\software\openblt\target\source\backdoor.c + "boot.h" + +1476728156 source:c:\work\software\openblt\target\source\boot.c + "boot.h" + +1469431756 source:c:\work\software\openblt\target\source\com.c + "boot.h" + "can.h" + "uart.h" + "usb.h" + "net.h" + +1469431761 c:\work\software\openblt\target\source\can.h + +1469431761 c:\work\software\openblt\target\source\uart.h + +1469431761 c:\work\software\openblt\target\source\usb.h + +1469431761 c:\work\software\openblt\target\source\net.h + +1469431756 source:c:\work\software\openblt\target\source\cop.c + "boot.h" + +1469281006 source:c:\work\software\openblt\target\source\file.c + "boot.h" + + + +1469431757 source:c:\work\software\openblt\target\source\net.c + "boot.h" + "netdev.h" + "uip.h" + "uip_arp.h" + +1476783463 source:c:\work\software\openblt\target\source\xcp.c + "boot.h" + +1479225622 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\boot.c + "header.h" + +1479207500 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\header.h + "../Boot/blt_conf.h" + "stm32f0xx.h" + "boot.h" + "led.h" + "timer.h" + +1417710862 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\stm32f0xx.h + "core_cm0.h" + "system_stm32f0xx.h" + + "stm32f0xx_conf.h" + +1417516674 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\cmsis\core_cm0.h + + + + +1417516674 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\cmsis\core_cminstr.h + + + +1417516674 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\cmsis\core_cmfunc.h + + + +1417710862 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\system_stm32f0xx.h + +1417516578 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\stm32f0xx_conf.h + "stm32f0xx_adc.h" + "stm32f0xx_can.h" + "stm32f0xx_cec.h" + "stm32f0xx_comp.h" + "stm32f0xx_crc.h" + "stm32f0xx_crs.h" + "stm32f0xx_dac.h" + "stm32f0xx_dbgmcu.h" + "stm32f0xx_dma.h" + "stm32f0xx_exti.h" + "stm32f0xx_flash.h" + "stm32f0xx_gpio.h" + "stm32f0xx_i2c.h" + "stm32f0xx_iwdg.h" + "stm32f0xx_pwr.h" + "stm32f0xx_rcc.h" + "stm32f0xx_rtc.h" + "stm32f0xx_spi.h" + "stm32f0xx_syscfg.h" + "stm32f0xx_tim.h" + "stm32f0xx_usart.h" + "stm32f0xx_wwdg.h" + "stm32f0xx_misc.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\inc\stm32f0xx_adc.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\inc\stm32f0xx_can.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\inc\stm32f0xx_cec.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\inc\stm32f0xx_comp.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\inc\stm32f0xx_crc.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\inc\stm32f0xx_crs.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\inc\stm32f0xx_dac.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\inc\stm32f0xx_dbgmcu.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\inc\stm32f0xx_dma.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\inc\stm32f0xx_exti.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\inc\stm32f0xx_flash.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\inc\stm32f0xx_gpio.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\inc\stm32f0xx_i2c.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\inc\stm32f0xx_iwdg.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\inc\stm32f0xx_pwr.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\inc\stm32f0xx_rcc.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\inc\stm32f0xx_rtc.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\inc\stm32f0xx_spi.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\inc\stm32f0xx_syscfg.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\inc\stm32f0xx_tim.h + "stm32f0xx.h" + +1417710865 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\inc\stm32f0xx_usart.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\inc\stm32f0xx_wwdg.h + "stm32f0xx.h" + +1417710864 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\inc\stm32f0xx_misc.h + "stm32f0xx.h" + +1479207489 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\boot.h + +1479207516 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\led.h + +1479207543 c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\timer.h + +1479207651 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\led.c + "header.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\src\stm32f0xx_adc.c + "stm32f0xx_adc.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\src\stm32f0xx_can.c + "stm32f0xx_can.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\src\stm32f0xx_cec.c + "stm32f0xx_cec.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\src\stm32f0xx_comp.c + "stm32f0xx_comp.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\src\stm32f0xx_crc.c + "stm32f0xx_crc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\src\stm32f0xx_crs.c + "stm32f0xx_crs.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\src\stm32f0xx_dac.c + "stm32f0xx_dac.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\src\stm32f0xx_dbgmcu.c + "stm32f0xx_dbgmcu.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\src\stm32f0xx_dma.c + "stm32f0xx_dma.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\src\stm32f0xx_exti.c + "stm32f0xx_exti.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\src\stm32f0xx_flash.c + "stm32f0xx_flash.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\src\stm32f0xx_gpio.c + "stm32f0xx_gpio.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\src\stm32f0xx_i2c.c + "stm32f0xx_i2c.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\src\stm32f0xx_iwdg.c + "stm32f0xx_iwdg.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\src\stm32f0xx_misc.c + "stm32f0xx_misc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\src\stm32f0xx_pwr.c + "stm32f0xx_pwr.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\src\stm32f0xx_rcc.c + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\src\stm32f0xx_rtc.c + "stm32f0xx_rtc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\src\stm32f0xx_spi.c + "stm32f0xx_spi.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\src\stm32f0xx_syscfg.c + "stm32f0xx_syscfg.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\src\stm32f0xx_tim.c + "stm32f0xx_tim.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\src\stm32f0xx_usart.c + "stm32f0xx_usart.h" + "stm32f0xx_rcc.h" + +1417710867 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\spl\src\stm32f0xx_wwdg.c + "stm32f0xx_wwdg.h" + "stm32f0xx_rcc.h" + +1471419075 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\lib\system_stm32f0xx.c + "stm32f0xx.h" + +1479207524 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\main.c + "header.h" + +1479207898 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\startup_stm32f0xx.s + +1479207534 source:c:\work\software\openblt\target\demo\armcm0_stm32f0_nucleo_f091rc_gcc\prog\timer.c + "header.h" + diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/ide/stm32f091.ebp b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/ide/stm32f091.ebp new file mode 100644 index 00000000..1b087abc --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/ide/stm32f091.ebp @@ -0,0 +1,307 @@ + + + + + + + diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/ide/stm32f091.elay b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/ide/stm32f091.elay new file mode 100644 index 00000000..18668102 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/ide/stm32f091.elay @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/led.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/led.c new file mode 100644 index 00000000..7cef51e2 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/led.c @@ -0,0 +1,103 @@ +/************************************************************************************//** +* \file Demo\ARMCM0_STM32F0_Nucleo_F091RC_GCC\Prog\led.c +* \brief LED driver source file. +* \ingroup Prog_ARMCM0_STM32F0_Nucleo_F091RC_GCC +* \internal +*---------------------------------------------------------------------------------------- +* C O P Y R I G H T +*---------------------------------------------------------------------------------------- +* Copyright (c) 2016 by Feaser http://www.feaser.com All rights reserved +* +*---------------------------------------------------------------------------------------- +* L I C E N S E +*---------------------------------------------------------------------------------------- +* This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +* modify it under the terms of the GNU General Public License as published by the Free +* Software Foundation, either version 3 of the License, or (at your option) any later +* version. +* +* OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +* PURPOSE. See the GNU General Public License for more details. +* +* You have received a copy of the GNU General Public License along with OpenBLT. It +* should be located in ".\Doc\license.html". If not, contact Feaser to obtain a copy. +* +* \endinternal +****************************************************************************************/ + +/**************************************************************************************** +* Include files +****************************************************************************************/ +#include "header.h" /* generic header */ + + +/**************************************************************************************** +* Macro definitions +****************************************************************************************/ +/** \brief Toggle interval time in milliseconds. */ +#define LED_TOGGLE_MS (500) + + +/************************************************************************************//** +** \brief Initializes the LED. The board doesn't have a dedicted LED so an +** indicator on the LCD is used instead. +** \return none. +** +****************************************************************************************/ +void LedInit(void) +{ + GPIO_InitTypeDef GPIO_InitStructure; + + /* enable the GPIO_LED Clock */ + RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE); + /* configure the GPIO_LED pin */ + GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; + GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; + GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; + GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; + GPIO_Init(GPIOA, &GPIO_InitStructure); + GPIO_ResetBits(GPIOA, GPIO_Pin_5); +} /*** end of LedInit ***/ + + +/************************************************************************************//** +** \brief Toggles the LED at a fixed time interval. +** \return none. +** +****************************************************************************************/ +void LedToggle(void) +{ + static unsigned char led_toggle_state = 0; + static unsigned long timer_counter_last = 0; + unsigned long timer_counter_now; + + /* check if toggle interval time passed */ + timer_counter_now = TimerGet(); + if ( (timer_counter_now - timer_counter_last) < LED_TOGGLE_MS) + { + /* not yet time to toggle */ + return; + } + + /* determine toggle action */ + if (led_toggle_state == 0) + { + led_toggle_state = 1; + /* turn the LED on */ + GPIO_SetBits(GPIOA, GPIO_Pin_5); + } + else + { + led_toggle_state = 0; + /* turn the LED off */ + GPIO_ResetBits(GPIOA, GPIO_Pin_5); + } + + /* store toggle time to determine next toggle interval */ + timer_counter_last = timer_counter_now; +} /*** end of LedToggle ***/ + + +/*********************************** end of led.c **************************************/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/led.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/led.h new file mode 100644 index 00000000..770e0cba --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/led.h @@ -0,0 +1,39 @@ +/************************************************************************************//** +* \file Demo\ARMCM0_STM32F0_Nucleo_F091RC_GCC\Prog\led.h +* \brief LED driver header file. +* \ingroup Prog_ARMCM0_STM32F0_Nucleo_F091RC_GCC +* \internal +*---------------------------------------------------------------------------------------- +* C O P Y R I G H T +*---------------------------------------------------------------------------------------- +* Copyright (c) 2016 by Feaser http://www.feaser.com All rights reserved +* +*---------------------------------------------------------------------------------------- +* L I C E N S E +*---------------------------------------------------------------------------------------- +* This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +* modify it under the terms of the GNU General Public License as published by the Free +* Software Foundation, either version 3 of the License, or (at your option) any later +* version. +* +* OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +* PURPOSE. See the GNU General Public License for more details. +* +* You have received a copy of the GNU General Public License along with OpenBLT. It +* should be located in ".\Doc\license.html". If not, contact Feaser to obtain a copy. +* +* \endinternal +****************************************************************************************/ +#ifndef LED_H +#define LED_H + +/**************************************************************************************** +* Function prototypes +****************************************************************************************/ +void LedInit(void); +void LedToggle(void); + + +#endif /* LED_H */ +/*********************************** end of led.h **************************************/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/Release_Notes.html b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/Release_Notes.html new file mode 100644 index 00000000..e3f0d1de --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/Release_Notes.html @@ -0,0 +1,390 @@ + + + + + + + + + + +Release Notes for STM32F0xx Standard Peripherals Library Drivers + + + + + + +

    +


    +

    +
    + + + + + + +
    + + + + + + +
    + +

    Release +Notes for STM32F0xx Standard Peripherals Drivers
    +

    +

    Copyright +© 2014 STMicroelectronics

    +

    +
    + + + + + + + +
    +

    Update history

    V1.5.0 / 05-December-2015

    Main +Changes

    +
    • Add support of the STM32F070xB, STM32F070x6 and STM32F030xC  devices.
    • stm32f0xx_flash.c/.h: update for STM32F070xB, STM32F070x6 and STM32F030xC devices

    V1.4.0 / 24-July-2014

    Main +Changes

    +
    • Add support of the STM32F091 devices.
    • stm32f0xx_dma.c/.h: update for STM32F091 devices
      • Add the support of the DMA2 channels.
      • Add new function "void DMA_RemapConfig(DMA_TypeDef* DMAy, uint32_t DMAx_CHy_RemapRequest);"
    • stm32f0xx_flash.c/.h: update for STM32F091 devices
      • Add definition for new option bytes on the STM32F091 devices.
    • stm32f0xx_gpio.c/.h: update for STM32F091 devices
      • Update the GPIO_AF definition comments with the new supported alternate functions
    • stm32f0xx_rcc.c/.h: update for STM32F091 devices
      • Add USART3CLK_Frequency fields in the RCC_ClocksTypeDef structure.
        +
      • Add definition for USART3 clock sources
      • Add USART4, USART5, USART6, USART7 and USART8 clock and reset configuration.
      • Add DMA2 clock configuration.
    • stm32f0xx_syscfg.c/.h: update for STM32F091 devices
      • Add new function "void SYSCFG_IRDAEnvSelection(uint32_t SYSCFG_IRDAEnv);"
      • Add new function "uint32_t SYSCFG_GetPendingIT(uint32_t ITSourceLine);"
    • stm32f0xx_usart.c/.h:  update for STM32F091 devices
      • Add support of the USART3,USART4, USART5, USART6, USART7 and USART8.
    • stm32f0xx_pwr.c 
      • Fix +PWR_EnterSTANDBYMode() to not clear Wakeup flag (WUF), this flag need +to be cleared at application level before to call this function 
      • PWR_EnterSleepMode(): +update usage of __WFE() in low power entry function. If there is a +pending event, calling __WFE() instruction, the CortexM0 core will not +enter to sleep mode. The solution is to make the call below: the first +__WFE() is always ignored and clears the event if one was already +pending, the second is always applied

        __SEV()
        __WFE()
        __WFE()

    V1.3.0 / 16-January-2014

    Main +Changes

    +
    • Add support of the STM32042 and STM32F072 devices.
    • Update to support the new STM32F0xx family devices names.
      • STM32F0XX_MD  replaced by STM32F051
      • STM32F0XX_LD  replaced by STM32F031
      • STM32F030x8 and STM32F030x6 replaced by STM32F030
    • Add Clock Recovery System(CRS) driver.
    • Add CAN driver.
    • Update RCC driver to manage the High Speed Internal RC48MHz oscillator.
    • stm32f0xx_adc.c/.h: update for STM32F042 and STM32F072 devices
      • Add note to no more use the ADC_JitterOff definition as obsolete and maintained for legacy purpose. They are replaced by ADC_ClockMode definition.
      • Add new ADC_ClockMode definition for proper ADC clock configuration.
      • Update ADC_FLAG_ADSTP definition.
      • Update ADC_FLAG_ADCAL definition.
      • Add ADC_ClockModeConfig() function for proper ADC clock configuration.
      • Add note to no more use the ADC_JitterCmd() function as obsolete.
    • stm32f0xx_comp.c/.h: update for STM32F042 and STM32F072 devices
      • Add define for the COMP_InvertingInput_DAC2.
    • stm32f0xx_crc.c/.h: update for STM32F042 and STM32F072 devices
      • Add definition for the CRC Polynomial Size.
      • Add CRC_SetPolynomial(), CRC_CalcCRC16bits(), CRC_PolynomialSizeSelect(), CRC_CalcCRC16bits(), CRC_CalcCRC8bits() functions for the polynomial configuration management.
    • stm32f0xx_dac.c/.h: update for STM32F042 and STM32F072 devices
      • Add DAC_WaveGeneration and DAC_LFSRUnmask_TriangleAmplitude fields in the DAC_InitTypeDef structure. 
      • Add DAC_WaveGeneration definitions.
      • Add DAC_lfsrunmask_triangleamplitude definitions.
      • Add definition for DAC_Channel_2.
      • Add DAC_DualSoftwareTriggerCmd(), DAC_WaveGenerationCmd(), DAC_SetChannel2Data(), DAC_SetDualChannelData() for wave generation and dual channel management.
    • stm32f0xx_dbgmcu.c/.h: update for STM32F042 and STM32F072 devices
      • Add define for DBGMCU_TIM7_STOP.
      • Add define for DBGMCU_CAN1_STOP.
    • stm32f0xx_dma.c/.h: update for STM32F042 and STM32F072 devices
      • Add the support of the DMA channel 6 and DMA Channel 7
    • stm32f0xx_exti.c/.h: update for STM32F042 and STM32F072 devices
      • Add defines for EXTI Lines 18, 20, 26 and 31.
    • stm32f0xx_flash.c/.h: update for STM32F042 and STM32F072 devices
      • Add definition for option bytes on the STM32F072 devices.
      • Update IS_FLASH_CLEAR_FLAG macro definition.
      • Add definition of the BOOT0 and BOOT0_SW option bytes.
      • Add FLASH_OB_BOOT0Config() and FLASH_OB_BOOT0SWConfig() function for the BOOT0 Option bytes configuration.
    • stm32f0xx_gpio.c/.h: update for STM32F042 and STM32F072 devices
      • Add the support of the PortE.
      • Update the GPIO_AF definition comments with the new supported alternate functions
    • stm32f0xx_pwr.c/.h: update for STM32F042 and STM32F072 devices
      • Add definition for Wake up pins 3, 4, 5, 6, 7 and 8.
      • Update PWR_EnterSTOPMode() function to support of the SLEEPONEXIT entry mode.
    • stm32f0xx_rcc.c/.h: update for STM32F042 and STM32F072 devices
      • Replace references to STM32F0XX_MD device definition by STM32F051.
      • Add USART2CLK_Frequency and  USBCLK_Frequency fields in the RCC_ClocksTypeDef structure.
        +
      • Add definition of HSE, HSI48 and HSI clocks as new PLL clock sources.
      • Add definition of HSI48 clock as system clock source.
      • Add definition for USB clock sources.
      • Add definition for USART2 clock sources
      • Add definition for HSI48 and PLL clock as MCO sources
      • Add RCC_HSI48Cmd() and RCC_GetHSI48CalibrationValue() functions for the HSI48 clock source management.
      • Add RCC_USBCLKConfig() function for USB clock management.
      • Add note to no more use the RCC_ADCCLKConfig() as obsolete, however maintained for legacy purpose. Proper ADC clock configuration is managed by new function ADC_ClockModeConfig() available within the ADC driver.
    • stm32f0xx_rtc.c/.h: update for STM32F042 and STM32F072 devices
      • Add definition of the Tamper 3.
      • Add definiton for the Wake up counter in the RTC output selection
      • Add RTC_WakeUpClockConfig(), RTC_SetWakeUpCounter(), RTC_GetWakeUpCounter(), RTC_WakeUpCmd() functions for the wakeup counter configuration.
    • stm32f0xx_syscfg.c/.h: update for STM32F042 and STM32F072 devices
      • Add definition for EXTI_PortSourceGPIOE.
      • Add DMA remap definition for TIM3, TIM2, TIM1, I2C1, USART3, USART2, SPI2.
      • Add new DMA remap possibility definition for TIM17 and TIM16.
      • Add definition for SYSCFG_I2CFastModePlus_I2C2.
    • stm32f0xx_tim.c/.h: update for STM32F042 and STM32F072 devices
      • Add support of the TIM7.
    • stm32f0xx_usart.c/.h: update for STM32F042 and STM32F072 devices
      • Add support of the USART3 and USART4.

    V1.2.1 / 22-November-2013
    +

    +

    Main +Changes

    + +
    • Update the support of STM32F030 devices by removing the references to STM32F030x8 and STM32F030x6 devices and replacing them in by STM32F030 in the SYSCFG and GPIO drivers 
      +

    V1.2.0 / 01-Agust-2013
    +

    +

    Main +Changes

    + +
    • Add support of STM32F030x8 and STM32F030x6 devices (STM32F030 devices are  microcontrollers where the Flash memory ranges between 16 and 32 Kbytes)
      +

    V1.1.1 / 31-July-2013
    +

    + + +

    Main +Changes

    + + + +
    • stm32f0xx_tim.c
      • TIM_OC2Init(): add configuration of OC2 output idle state for TIM15
        +
    + +

    V1.1.0 / 10-May-2013
    +

    +

    Main +Changes

    + +
    • Add support of STM32F0xx Low-density devices (STM32F0XX_LD devices, STM32F050xx and STM32F060xx microcontrollers where the Flash memory ranges between 16 and 32 Kbytes) and miscellaneous update
      +
    • stm32f0xx_rcc.c/.h: update for STM32F0XX_LD devices
      • Add new function RCC_MCOConfig(uint8_t RCC_MCOSource, +uint32_t RCC_MCOPrescaler)
        +
      • RCC_DeInit(): update to reset new bits added in RCC_CFGR register
    • stm32f0xx_syscfg.c/.h: update for STM32F0XX_LD devices
      • Add defines for "I2C fast mode plus" new AF mapping: SYSCFG_I2CFastModePlus_PA9, SYSCFG_I2CFastModePlus_PA10 and SYSCFG_I2CFastModePlus_I2C1
        +
    • stm32f0xx_gpio.h: update for STM32F0XX_LD devices
      • GPIO_PinAFConfig(): in the function header add reference to I2C1's new AF4 remapping
        +
    • stm32f0xx_flash.h
      • Swap the value of these defines OB_VDDA_ANALOG_ON and OB_VDDA_ANALOG_OFF
    • stm32f0xx_misc.c
      • NVIC_Init(): remove reference to NVIC_PriorityGroupConfig() function (not available)
        +
    • stm32f0xx_gpio.h
      • Update GPIOSpeed_TypeDef members naming to be in line w/ the Reference Manual
        +
    • stm32f0xx_exti.c
      +
      • EXTI_GetITStatus() updated to remove test on IMR register to avoid corner case limitation
    +

    V1.0.2 / 13-July-2012

    Main +Changes

    +
    • stm32f0xx_i2c.c/.h
      • I2C_SoftwareResetCmd(): update function coding to be in line with I2C software reset procedure recommended in STM32F0xx lasted documentation. As consequence NewState parameter was removed.
    • stm32f0xx_flash.c/.h
      • Rename FLASH_ProgramOptionByteData() to FLASH_OB_ProgramData()
      • Add some legacy defines for compatibility with STM32F10x Flash driver
    • stm32f0xx_rtc.c
      • RTC_DeInit(): remove unused variable “wutcounter”
    • stm32f0xx_spi.c 
      • File header's comment: add details how to configure the FIFO threshold 

    V1.0.1 / 20-April-2012

    Main +Changes

    +
    • All drivers, function's header: update comments and Doxygen tags formatting
    • stm32f0xx_pwr.c
      • PWR_PVDLevelConfig() +function: remove value of the voltage threshold corresponding to each +PVD detection level, user should refer to the electrical +characteristics of the STM32F0xx device datasheet to have the correct +value
    • stm32f0xx_usart.c/.h
      • USART_Init() function: update baudrate computation to be in line with the formula described in the Reference Manual (RM0091)
      • USART_AutoBaudRateNewRequest() function removed
    • stm32f0xx_i2c.c
      • I2C_GetITStatus() function: add test to check if the interrupt source is enabled or not

    V1.0.0 / 23-March-2012

    Main +Changes

    +
    • First official release for STM32F0xx devices
    • All source files: license disclaimer text update and add link to the License file on ST Internet
    • stm32f0xx_comp.h
      •  Correct values of COMP_Mode parameter
    • stm32f0xx_rcc.c/.h
      • Add new reset flag V18PWRRSTF in the RCC CSR register
      • Add new MCO clock sources (LSI and LSE) and change value of RCC_MCOSource_HSI14 
    • stm32f0xx_flash.c/.h
      • Add new function FLASH_OB_SRAMParityConfig() to manage the SRAM parity enable option bit
      • Flash and OB keys moved to stm32f0xx.h file
    • stm32f0xx_tim.c/.h
      • Add additional input for TIM14 clock  (HSE divided by 32 and MCO) 
      • Miscellaneous enhancement
    • stm32f0xx_adc.c/.h
      • Miscellaneous update to be in line with bits naming in the Reference Manual (update done also in stm32f0xx.h file)
    • stm32f0xx_i2c.c/.h
      • Miscellaneous enhancement
    + +

    V1.0.0RC1 / 27-January-2012

    +

    Main +Changes

    + + + + + +
      +
    • Official version (V1.0.0) Release Candidate 1
      • + +
    +
      + +

      License

      Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); You may not use this package except in compliance with the License. You may obtain a copy of the License at:


      Unless +required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS,
      WITHOUT +WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See +the License for the specific language governing permissions and +limitations under the License.
      +
      +

      For + complete documentation on STM32 + Microcontrollers visit www.st.com/STM32

      +
      +

      +
      +
      +

       

      +
      + \ No newline at end of file diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_adc.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_adc.h new file mode 100644 index 00000000..900803a5 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_adc.h @@ -0,0 +1,450 @@ +/** + ****************************************************************************** + * @file stm32f0xx_adc.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the ADC firmware + * library + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_ADC_H +#define __STM32F0XX_ADC_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup ADC + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief ADC Init structure definition + */ + +typedef struct +{ + uint32_t ADC_Resolution; /*!< Selects the resolution of the conversion. + This parameter can be a value of @ref ADC_Resolution */ + + FunctionalState ADC_ContinuousConvMode; /*!< Specifies whether the conversion is performed in + Continuous or Single mode. + This parameter can be set to ENABLE or DISABLE. */ + + uint32_t ADC_ExternalTrigConvEdge; /*!< Selects the external trigger Edge and enables the + trigger of a regular group. This parameter can be a value + of @ref ADC_external_trigger_edge_conversion */ + + uint32_t ADC_ExternalTrigConv; /*!< Defines the external trigger used to start the analog + to digital conversion of regular channels. This parameter + can be a value of @ref ADC_external_trigger_sources_for_channels_conversion */ + + uint32_t ADC_DataAlign; /*!< Specifies whether the ADC data alignment is left or right. + This parameter can be a value of @ref ADC_data_align */ + + uint32_t ADC_ScanDirection; /*!< Specifies in which direction the channels will be scanned + in the sequence. + This parameter can be a value of @ref ADC_Scan_Direction */ +}ADC_InitTypeDef; + + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup ADC_Exported_Constants + * @{ + */ +#define IS_ADC_ALL_PERIPH(PERIPH) ((PERIPH) == ADC1) + +/** @defgroup ADC_JitterOff + * @{ + */ +/* These defines are obsolete and maintained for legacy purpose only. They are replaced by the ADC_ClockMode */ +#define ADC_JitterOff_PCLKDiv2 ADC_CFGR2_JITOFFDIV2 +#define ADC_JitterOff_PCLKDiv4 ADC_CFGR2_JITOFFDIV4 + +#define IS_ADC_JITTEROFF(JITTEROFF) (((JITTEROFF) & 0x3FFFFFFF) == (uint32_t)RESET) + +/** + * @} + */ + +/** @defgroup ADC_ClockMode + * @{ + */ +#define ADC_ClockMode_AsynClk ((uint32_t)0x00000000) /*!< ADC Asynchronous clock mode */ +#define ADC_ClockMode_SynClkDiv2 ADC_CFGR2_CKMODE_0 /*!< Synchronous clock mode divided by 2 */ +#define ADC_ClockMode_SynClkDiv4 ADC_CFGR2_CKMODE_1 /*!< Synchronous clock mode divided by 4 */ +#define IS_ADC_CLOCKMODE(CLOCK) (((CLOCK) == ADC_ClockMode_AsynClk) ||\ + ((CLOCK) == ADC_ClockMode_SynClkDiv2) ||\ + ((CLOCK) == ADC_ClockMode_SynClkDiv4)) + +/** + * @} + */ + +/** @defgroup ADC_Resolution + * @{ + */ +#define ADC_Resolution_12b ((uint32_t)0x00000000) +#define ADC_Resolution_10b ADC_CFGR1_RES_0 +#define ADC_Resolution_8b ADC_CFGR1_RES_1 +#define ADC_Resolution_6b ADC_CFGR1_RES + +#define IS_ADC_RESOLUTION(RESOLUTION) (((RESOLUTION) == ADC_Resolution_12b) || \ + ((RESOLUTION) == ADC_Resolution_10b) || \ + ((RESOLUTION) == ADC_Resolution_8b) || \ + ((RESOLUTION) == ADC_Resolution_6b)) + +/** + * @} + */ + +/** @defgroup ADC_external_trigger_edge_conversion + * @{ + */ +#define ADC_ExternalTrigConvEdge_None ((uint32_t)0x00000000) +#define ADC_ExternalTrigConvEdge_Rising ADC_CFGR1_EXTEN_0 +#define ADC_ExternalTrigConvEdge_Falling ADC_CFGR1_EXTEN_1 +#define ADC_ExternalTrigConvEdge_RisingFalling ADC_CFGR1_EXTEN + +#define IS_ADC_EXT_TRIG_EDGE(EDGE) (((EDGE) == ADC_ExternalTrigConvEdge_None) || \ + ((EDGE) == ADC_ExternalTrigConvEdge_Rising) || \ + ((EDGE) == ADC_ExternalTrigConvEdge_Falling) || \ + ((EDGE) == ADC_ExternalTrigConvEdge_RisingFalling)) +/** + * @} + */ + +/** @defgroup ADC_external_trigger_sources_for_channels_conversion + * @{ + */ + +/* TIM1 */ +#define ADC_ExternalTrigConv_T1_TRGO ((uint32_t)0x00000000) +#define ADC_ExternalTrigConv_T1_CC4 ADC_CFGR1_EXTSEL_0 + +/* TIM2 */ +#define ADC_ExternalTrigConv_T2_TRGO ADC_CFGR1_EXTSEL_1 + +/* TIM3 */ +#define ADC_ExternalTrigConv_T3_TRGO ((uint32_t)(ADC_CFGR1_EXTSEL_0 | ADC_CFGR1_EXTSEL_1)) + +/* TIM15 */ +#define ADC_ExternalTrigConv_T15_TRGO ADC_CFGR1_EXTSEL_2 + +#define IS_ADC_EXTERNAL_TRIG_CONV(CONV) (((CONV) == ADC_ExternalTrigConv_T1_TRGO) || \ + ((CONV) == ADC_ExternalTrigConv_T1_CC4) || \ + ((CONV) == ADC_ExternalTrigConv_T2_TRGO) || \ + ((CONV) == ADC_ExternalTrigConv_T3_TRGO) || \ + ((CONV) == ADC_ExternalTrigConv_T15_TRGO)) +/** + * @} + */ + +/** @defgroup ADC_data_align + * @{ + */ + +#define ADC_DataAlign_Right ((uint32_t)0x00000000) +#define ADC_DataAlign_Left ADC_CFGR1_ALIGN + +#define IS_ADC_DATA_ALIGN(ALIGN) (((ALIGN) == ADC_DataAlign_Right) || \ + ((ALIGN) == ADC_DataAlign_Left)) +/** + * @} + */ + +/** @defgroup ADC_Scan_Direction + * @{ + */ + +#define ADC_ScanDirection_Upward ((uint32_t)0x00000000) +#define ADC_ScanDirection_Backward ADC_CFGR1_SCANDIR + +#define IS_ADC_SCAN_DIRECTION(DIRECTION) (((DIRECTION) == ADC_ScanDirection_Upward) || \ + ((DIRECTION) == ADC_ScanDirection_Backward)) +/** + * @} + */ + +/** @defgroup ADC_DMA_Mode + * @{ + */ + +#define ADC_DMAMode_OneShot ((uint32_t)0x00000000) +#define ADC_DMAMode_Circular ADC_CFGR1_DMACFG + +#define IS_ADC_DMA_MODE(MODE) (((MODE) == ADC_DMAMode_OneShot) || \ + ((MODE) == ADC_DMAMode_Circular)) +/** + * @} + */ + +/** @defgroup ADC_analog_watchdog_selection + * @{ + */ + +#define ADC_AnalogWatchdog_Channel_0 ((uint32_t)0x00000000) +#define ADC_AnalogWatchdog_Channel_1 ((uint32_t)0x04000000) +#define ADC_AnalogWatchdog_Channel_2 ((uint32_t)0x08000000) +#define ADC_AnalogWatchdog_Channel_3 ((uint32_t)0x0C000000) +#define ADC_AnalogWatchdog_Channel_4 ((uint32_t)0x10000000) +#define ADC_AnalogWatchdog_Channel_5 ((uint32_t)0x14000000) +#define ADC_AnalogWatchdog_Channel_6 ((uint32_t)0x18000000) +#define ADC_AnalogWatchdog_Channel_7 ((uint32_t)0x1C000000) +#define ADC_AnalogWatchdog_Channel_8 ((uint32_t)0x20000000) +#define ADC_AnalogWatchdog_Channel_9 ((uint32_t)0x24000000) +#define ADC_AnalogWatchdog_Channel_10 ((uint32_t)0x28000000) /*!< Not available for STM32F031 devices */ +#define ADC_AnalogWatchdog_Channel_11 ((uint32_t)0x2C000000) /*!< Not available for STM32F031 devices */ +#define ADC_AnalogWatchdog_Channel_12 ((uint32_t)0x30000000) /*!< Not available for STM32F031 devices */ +#define ADC_AnalogWatchdog_Channel_13 ((uint32_t)0x34000000) /*!< Not available for STM32F031 devices */ +#define ADC_AnalogWatchdog_Channel_14 ((uint32_t)0x38000000) /*!< Not available for STM32F031 devices */ +#define ADC_AnalogWatchdog_Channel_15 ((uint32_t)0x3C000000) /*!< Not available for STM32F031 devices */ +#define ADC_AnalogWatchdog_Channel_16 ((uint32_t)0x40000000) +#define ADC_AnalogWatchdog_Channel_17 ((uint32_t)0x44000000) +#define ADC_AnalogWatchdog_Channel_18 ((uint32_t)0x48000000) + + +#define IS_ADC_ANALOG_WATCHDOG_CHANNEL(CHANNEL) (((CHANNEL) == ADC_AnalogWatchdog_Channel_0) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_1) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_2) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_3) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_4) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_5) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_6) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_7) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_8) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_9) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_10) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_11) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_12) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_13) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_14) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_15) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_16) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_17) || \ + ((CHANNEL) == ADC_AnalogWatchdog_Channel_18)) +/** + * @} + */ + +/** @defgroup ADC_sampling_times + * @{ + */ + +#define ADC_SampleTime_1_5Cycles ((uint32_t)0x00000000) +#define ADC_SampleTime_7_5Cycles ((uint32_t)0x00000001) +#define ADC_SampleTime_13_5Cycles ((uint32_t)0x00000002) +#define ADC_SampleTime_28_5Cycles ((uint32_t)0x00000003) +#define ADC_SampleTime_41_5Cycles ((uint32_t)0x00000004) +#define ADC_SampleTime_55_5Cycles ((uint32_t)0x00000005) +#define ADC_SampleTime_71_5Cycles ((uint32_t)0x00000006) +#define ADC_SampleTime_239_5Cycles ((uint32_t)0x00000007) + +#define IS_ADC_SAMPLE_TIME(TIME) (((TIME) == ADC_SampleTime_1_5Cycles) || \ + ((TIME) == ADC_SampleTime_7_5Cycles) || \ + ((TIME) == ADC_SampleTime_13_5Cycles) || \ + ((TIME) == ADC_SampleTime_28_5Cycles) || \ + ((TIME) == ADC_SampleTime_41_5Cycles) || \ + ((TIME) == ADC_SampleTime_55_5Cycles) || \ + ((TIME) == ADC_SampleTime_71_5Cycles) || \ + ((TIME) == ADC_SampleTime_239_5Cycles)) +/** + * @} + */ + +/** @defgroup ADC_thresholds + * @{ + */ + +#define IS_ADC_THRESHOLD(THRESHOLD) ((THRESHOLD) <= 0xFFF) + +/** + * @} + */ + +/** @defgroup ADC_channels + * @{ + */ + +#define ADC_Channel_0 ADC_CHSELR_CHSEL0 +#define ADC_Channel_1 ADC_CHSELR_CHSEL1 +#define ADC_Channel_2 ADC_CHSELR_CHSEL2 +#define ADC_Channel_3 ADC_CHSELR_CHSEL3 +#define ADC_Channel_4 ADC_CHSELR_CHSEL4 +#define ADC_Channel_5 ADC_CHSELR_CHSEL5 +#define ADC_Channel_6 ADC_CHSELR_CHSEL6 +#define ADC_Channel_7 ADC_CHSELR_CHSEL7 +#define ADC_Channel_8 ADC_CHSELR_CHSEL8 +#define ADC_Channel_9 ADC_CHSELR_CHSEL9 +#define ADC_Channel_10 ADC_CHSELR_CHSEL10 /*!< Not available for STM32F031 devices */ +#define ADC_Channel_11 ADC_CHSELR_CHSEL11 /*!< Not available for STM32F031 devices */ +#define ADC_Channel_12 ADC_CHSELR_CHSEL12 /*!< Not available for STM32F031 devices */ +#define ADC_Channel_13 ADC_CHSELR_CHSEL13 /*!< Not available for STM32F031 devices */ +#define ADC_Channel_14 ADC_CHSELR_CHSEL14 /*!< Not available for STM32F031 devices */ +#define ADC_Channel_15 ADC_CHSELR_CHSEL15 /*!< Not available for STM32F031 devices */ +#define ADC_Channel_16 ADC_CHSELR_CHSEL16 +#define ADC_Channel_17 ADC_CHSELR_CHSEL17 +#define ADC_Channel_18 ADC_CHSELR_CHSEL18 /*!< Not available for STM32F030 devices */ + +#define ADC_Channel_TempSensor ((uint32_t)ADC_Channel_16) +#define ADC_Channel_Vrefint ((uint32_t)ADC_Channel_17) +#define ADC_Channel_Vbat ((uint32_t)ADC_Channel_18) /*!< Not available for STM32F030 devices */ + +#define IS_ADC_CHANNEL(CHANNEL) (((CHANNEL) != (uint32_t)RESET) && (((CHANNEL) & 0xFFF80000) == (uint32_t)RESET)) + +/** + * @} + */ + +/** @defgroup ADC_interrupts_definition + * @{ + */ + +#define ADC_IT_ADRDY ADC_IER_ADRDYIE +#define ADC_IT_EOSMP ADC_IER_EOSMPIE +#define ADC_IT_EOC ADC_IER_EOCIE +#define ADC_IT_EOSEQ ADC_IER_EOSEQIE +#define ADC_IT_OVR ADC_IER_OVRIE +#define ADC_IT_AWD ADC_IER_AWDIE + +#define IS_ADC_CONFIG_IT(IT) (((IT) != (uint32_t)RESET) && (((IT) & 0xFFFFFF60) == (uint32_t)RESET)) + +#define IS_ADC_GET_IT(IT) (((IT) == ADC_IT_ADRDY) || ((IT) == ADC_IT_EOSMP) || \ + ((IT) == ADC_IT_EOC) || ((IT) == ADC_IT_EOSEQ) || \ + ((IT) == ADC_IT_OVR) || ((IT) == ADC_IT_AWD)) + +#define IS_ADC_CLEAR_IT(IT) (((IT) != (uint32_t)RESET) && (((IT) & 0xFFFFFF60) == (uint32_t)RESET)) + +/** + * @} + */ + +/** @defgroup ADC_flags_definition + * @{ + */ + +#define ADC_FLAG_ADRDY ADC_ISR_ADRDY +#define ADC_FLAG_EOSMP ADC_ISR_EOSMP +#define ADC_FLAG_EOC ADC_ISR_EOC +#define ADC_FLAG_EOSEQ ADC_ISR_EOSEQ +#define ADC_FLAG_OVR ADC_ISR_OVR +#define ADC_FLAG_AWD ADC_ISR_AWD + +#define ADC_FLAG_ADEN ((uint32_t)0x01000001) +#define ADC_FLAG_ADDIS ((uint32_t)0x01000002) +#define ADC_FLAG_ADSTART ((uint32_t)0x01000004) +#define ADC_FLAG_ADSTP ((uint32_t)0x01000010) +#define ADC_FLAG_ADCAL ((uint32_t)0x81000000) + +#define IS_ADC_CLEAR_FLAG(FLAG) (((FLAG) != (uint32_t)RESET) && (((FLAG) & 0xFFFFFF60) == (uint32_t)RESET)) + +#define IS_ADC_GET_FLAG(FLAG) (((FLAG) == ADC_FLAG_ADRDY) || ((FLAG) == ADC_FLAG_EOSMP) || \ + ((FLAG) == ADC_FLAG_EOC) || ((FLAG) == ADC_FLAG_EOSEQ) || \ + ((FLAG) == ADC_FLAG_AWD) || ((FLAG) == ADC_FLAG_OVR) || \ + ((FLAG) == ADC_FLAG_ADEN) || ((FLAG) == ADC_FLAG_ADDIS) || \ + ((FLAG) == ADC_FLAG_ADSTART) || ((FLAG) == ADC_FLAG_ADSTP) || \ + ((FLAG) == ADC_FLAG_ADCAL)) +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Function used to set the ADC configuration to the default reset state *****/ +void ADC_DeInit(ADC_TypeDef* ADCx); + +/* Initialization and Configuration functions *********************************/ +void ADC_Init(ADC_TypeDef* ADCx, ADC_InitTypeDef* ADC_InitStruct); +void ADC_StructInit(ADC_InitTypeDef* ADC_InitStruct); +void ADC_ClockModeConfig(ADC_TypeDef* ADCx, uint32_t ADC_ClockMode); +void ADC_Cmd(ADC_TypeDef* ADCx, FunctionalState NewState); +/* This Function is obsolete and maintained for legacy purpose only. + ADC_ClockModeConfig() function should be used instead */ +void ADC_JitterCmd(ADC_TypeDef* ADCx, uint32_t ADC_JitterOff, FunctionalState NewState); + +/* Power saving functions *****************************************************/ +void ADC_AutoPowerOffCmd(ADC_TypeDef* ADCx, FunctionalState NewState); +void ADC_WaitModeCmd(ADC_TypeDef* ADCx, FunctionalState NewState); + +/* Analog Watchdog configuration functions ************************************/ +void ADC_AnalogWatchdogCmd(ADC_TypeDef* ADCx, FunctionalState NewState); +void ADC_AnalogWatchdogThresholdsConfig(ADC_TypeDef* ADCx, uint16_t HighThreshold,uint16_t LowThreshold); +void ADC_AnalogWatchdogSingleChannelConfig(ADC_TypeDef* ADCx, uint32_t ADC_AnalogWatchdog_Channel); +void ADC_AnalogWatchdogSingleChannelCmd(ADC_TypeDef* ADCx, FunctionalState NewState); + +/* Temperature Sensor , Vrefint and Vbat management function ******************/ +void ADC_TempSensorCmd(FunctionalState NewState); +void ADC_VrefintCmd(FunctionalState NewState); +void ADC_VbatCmd(FunctionalState NewState); /*!< Not applicable for STM32F030 devices */ + +/* Channels Configuration functions *******************************************/ +void ADC_ChannelConfig(ADC_TypeDef* ADCx, uint32_t ADC_Channel, uint32_t ADC_SampleTime); +void ADC_ContinuousModeCmd(ADC_TypeDef* ADCx, FunctionalState NewState); +void ADC_DiscModeCmd(ADC_TypeDef* ADCx, FunctionalState NewState); +void ADC_OverrunModeCmd(ADC_TypeDef* ADCx, FunctionalState NewState); +uint32_t ADC_GetCalibrationFactor(ADC_TypeDef* ADCx); +void ADC_StopOfConversion(ADC_TypeDef* ADCx); +void ADC_StartOfConversion(ADC_TypeDef* ADCx); +uint16_t ADC_GetConversionValue(ADC_TypeDef* ADCx); + +/* Regular Channels DMA Configuration functions *******************************/ +void ADC_DMACmd(ADC_TypeDef* ADCx, FunctionalState NewState); +void ADC_DMARequestModeConfig(ADC_TypeDef* ADCx, uint32_t ADC_DMARequestMode); + +/* Interrupts and flags management functions **********************************/ +void ADC_ITConfig(ADC_TypeDef* ADCx, uint32_t ADC_IT, FunctionalState NewState); +FlagStatus ADC_GetFlagStatus(ADC_TypeDef* ADCx, uint32_t ADC_FLAG); +void ADC_ClearFlag(ADC_TypeDef* ADCx, uint32_t ADC_FLAG); +ITStatus ADC_GetITStatus(ADC_TypeDef* ADCx, uint32_t ADC_IT); +void ADC_ClearITPendingBit(ADC_TypeDef* ADCx, uint32_t ADC_IT); + +#ifdef __cplusplus +} +#endif + +#endif /*__STM32F0XX_ADC_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_can.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_can.h new file mode 100644 index 00000000..d8a178ea --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_can.h @@ -0,0 +1,643 @@ +/** + ****************************************************************************** + * @file stm32f0xx_can.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the CAN firmware + * library, applicable only for STM32F072 devices. + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0xx_CAN_H +#define __STM32F0xx_CAN_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup CAN + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +#define IS_CAN_ALL_PERIPH(PERIPH) (((PERIPH) == CAN)) + +/** + * @brief CAN init structure definition + */ +typedef struct +{ + uint16_t CAN_Prescaler; /*!< Specifies the length of a time quantum. + It ranges from 1 to 1024. */ + + uint8_t CAN_Mode; /*!< Specifies the CAN operating mode. + This parameter can be a value of @ref CAN_operating_mode */ + + uint8_t CAN_SJW; /*!< Specifies the maximum number of time quanta + the CAN hardware is allowed to lengthen or + shorten a bit to perform resynchronization. + This parameter can be a value of @ref CAN_synchronisation_jump_width */ + + uint8_t CAN_BS1; /*!< Specifies the number of time quanta in Bit + Segment 1. This parameter can be a value of + @ref CAN_time_quantum_in_bit_segment_1 */ + + uint8_t CAN_BS2; /*!< Specifies the number of time quanta in Bit Segment 2. + This parameter can be a value of @ref CAN_time_quantum_in_bit_segment_2 */ + + FunctionalState CAN_TTCM; /*!< Enable or disable the time triggered communication mode. + This parameter can be set either to ENABLE or DISABLE. */ + + FunctionalState CAN_ABOM; /*!< Enable or disable the automatic bus-off management. + This parameter can be set either to ENABLE or DISABLE. */ + + FunctionalState CAN_AWUM; /*!< Enable or disable the automatic wake-up mode. + This parameter can be set either to ENABLE or DISABLE. */ + + FunctionalState CAN_NART; /*!< Enable or disable the non-automatic retransmission mode. + This parameter can be set either to ENABLE or DISABLE. */ + + FunctionalState CAN_RFLM; /*!< Enable or disable the Receive FIFO Locked mode. + This parameter can be set either to ENABLE or DISABLE. */ + + FunctionalState CAN_TXFP; /*!< Enable or disable the transmit FIFO priority. + This parameter can be set either to ENABLE or DISABLE. */ +} CAN_InitTypeDef; + +/** + * @brief CAN filter init structure definition + */ +typedef struct +{ + uint16_t CAN_FilterIdHigh; /*!< Specifies the filter identification number (MSBs for a 32-bit + configuration, first one for a 16-bit configuration). + This parameter can be a value between 0x0000 and 0xFFFF */ + + uint16_t CAN_FilterIdLow; /*!< Specifies the filter identification number (LSBs for a 32-bit + configuration, second one for a 16-bit configuration). + This parameter can be a value between 0x0000 and 0xFFFF */ + + uint16_t CAN_FilterMaskIdHigh; /*!< Specifies the filter mask number or identification number, + according to the mode (MSBs for a 32-bit configuration, + first one for a 16-bit configuration). + This parameter can be a value between 0x0000 and 0xFFFF */ + + uint16_t CAN_FilterMaskIdLow; /*!< Specifies the filter mask number or identification number, + according to the mode (LSBs for a 32-bit configuration, + second one for a 16-bit configuration). + This parameter can be a value between 0x0000 and 0xFFFF */ + + uint16_t CAN_FilterFIFOAssignment; /*!< Specifies the FIFO (0 or 1) which will be assigned to the filter. + This parameter can be a value of @ref CAN_filter_FIFO */ + + uint8_t CAN_FilterNumber; /*!< Specifies the filter which will be initialized. It ranges from 0 to 13. */ + + uint8_t CAN_FilterMode; /*!< Specifies the filter mode to be initialized. + This parameter can be a value of @ref CAN_filter_mode */ + + uint8_t CAN_FilterScale; /*!< Specifies the filter scale. + This parameter can be a value of @ref CAN_filter_scale */ + + FunctionalState CAN_FilterActivation; /*!< Enable or disable the filter. + This parameter can be set either to ENABLE or DISABLE. */ +} CAN_FilterInitTypeDef; + +/** + * @brief CAN Tx message structure definition + */ +typedef struct +{ + uint32_t StdId; /*!< Specifies the standard identifier. + This parameter can be a value between 0 to 0x7FF. */ + + uint32_t ExtId; /*!< Specifies the extended identifier. + This parameter can be a value between 0 to 0x1FFFFFFF. */ + + uint8_t IDE; /*!< Specifies the type of identifier for the message that + will be transmitted. This parameter can be a value + of @ref CAN_identifier_type */ + + uint8_t RTR; /*!< Specifies the type of frame for the message that will + be transmitted. This parameter can be a value of + @ref CAN_remote_transmission_request */ + + uint8_t DLC; /*!< Specifies the length of the frame that will be + transmitted. This parameter can be a value between + 0 to 8 */ + + uint8_t Data[8]; /*!< Contains the data to be transmitted. It ranges from 0 + to 0xFF. */ +} CanTxMsg; + +/** + * @brief CAN Rx message structure definition + */ +typedef struct +{ + uint32_t StdId; /*!< Specifies the standard identifier. + This parameter can be a value between 0 to 0x7FF. */ + + uint32_t ExtId; /*!< Specifies the extended identifier. + This parameter can be a value between 0 to 0x1FFFFFFF. */ + + uint8_t IDE; /*!< Specifies the type of identifier for the message that + will be received. This parameter can be a value of + @ref CAN_identifier_type */ + + uint8_t RTR; /*!< Specifies the type of frame for the received message. + This parameter can be a value of + @ref CAN_remote_transmission_request */ + + uint8_t DLC; /*!< Specifies the length of the frame that will be received. + This parameter can be a value between 0 to 8 */ + + uint8_t Data[8]; /*!< Contains the data to be received. It ranges from 0 to + 0xFF. */ + + uint8_t FMI; /*!< Specifies the index of the filter the message stored in + the mailbox passes through. This parameter can be a + value between 0 to 0xFF */ +} CanRxMsg; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup CAN_Exported_Constants + * @{ + */ + +/** @defgroup CAN_InitStatus + * @{ + */ + +#define CAN_InitStatus_Failed ((uint8_t)0x00) /*!< CAN initialization failed */ +#define CAN_InitStatus_Success ((uint8_t)0x01) /*!< CAN initialization OK */ + + +/* Legacy defines */ +#define CANINITFAILED CAN_InitStatus_Failed +#define CANINITOK CAN_InitStatus_Success +/** + * @} + */ + +/** @defgroup CAN_operating_mode + * @{ + */ + +#define CAN_Mode_Normal ((uint8_t)0x00) /*!< normal mode */ +#define CAN_Mode_LoopBack ((uint8_t)0x01) /*!< loopback mode */ +#define CAN_Mode_Silent ((uint8_t)0x02) /*!< silent mode */ +#define CAN_Mode_Silent_LoopBack ((uint8_t)0x03) /*!< loopback combined with silent mode */ + +#define IS_CAN_MODE(MODE) (((MODE) == CAN_Mode_Normal) || \ + ((MODE) == CAN_Mode_LoopBack)|| \ + ((MODE) == CAN_Mode_Silent) || \ + ((MODE) == CAN_Mode_Silent_LoopBack)) +/** + * @} + */ + + + /** + * @defgroup CAN_operating_mode + * @{ + */ +#define CAN_OperatingMode_Initialization ((uint8_t)0x00) /*!< Initialization mode */ +#define CAN_OperatingMode_Normal ((uint8_t)0x01) /*!< Normal mode */ +#define CAN_OperatingMode_Sleep ((uint8_t)0x02) /*!< sleep mode */ + + +#define IS_CAN_OPERATING_MODE(MODE) (((MODE) == CAN_OperatingMode_Initialization) ||\ + ((MODE) == CAN_OperatingMode_Normal)|| \ + ((MODE) == CAN_OperatingMode_Sleep)) +/** + * @} + */ + +/** + * @defgroup CAN_operating_mode_status + * @{ + */ + +#define CAN_ModeStatus_Failed ((uint8_t)0x00) /*!< CAN entering the specific mode failed */ +#define CAN_ModeStatus_Success ((uint8_t)!CAN_ModeStatus_Failed) /*!< CAN entering the specific mode Succeed */ +/** + * @} + */ + +/** @defgroup CAN_synchronisation_jump_width + * @{ + */ +#define CAN_SJW_1tq ((uint8_t)0x00) /*!< 1 time quantum */ +#define CAN_SJW_2tq ((uint8_t)0x01) /*!< 2 time quantum */ +#define CAN_SJW_3tq ((uint8_t)0x02) /*!< 3 time quantum */ +#define CAN_SJW_4tq ((uint8_t)0x03) /*!< 4 time quantum */ + +#define IS_CAN_SJW(SJW) (((SJW) == CAN_SJW_1tq) || ((SJW) == CAN_SJW_2tq)|| \ + ((SJW) == CAN_SJW_3tq) || ((SJW) == CAN_SJW_4tq)) +/** + * @} + */ + +/** @defgroup CAN_time_quantum_in_bit_segment_1 + * @{ + */ +#define CAN_BS1_1tq ((uint8_t)0x00) /*!< 1 time quantum */ +#define CAN_BS1_2tq ((uint8_t)0x01) /*!< 2 time quantum */ +#define CAN_BS1_3tq ((uint8_t)0x02) /*!< 3 time quantum */ +#define CAN_BS1_4tq ((uint8_t)0x03) /*!< 4 time quantum */ +#define CAN_BS1_5tq ((uint8_t)0x04) /*!< 5 time quantum */ +#define CAN_BS1_6tq ((uint8_t)0x05) /*!< 6 time quantum */ +#define CAN_BS1_7tq ((uint8_t)0x06) /*!< 7 time quantum */ +#define CAN_BS1_8tq ((uint8_t)0x07) /*!< 8 time quantum */ +#define CAN_BS1_9tq ((uint8_t)0x08) /*!< 9 time quantum */ +#define CAN_BS1_10tq ((uint8_t)0x09) /*!< 10 time quantum */ +#define CAN_BS1_11tq ((uint8_t)0x0A) /*!< 11 time quantum */ +#define CAN_BS1_12tq ((uint8_t)0x0B) /*!< 12 time quantum */ +#define CAN_BS1_13tq ((uint8_t)0x0C) /*!< 13 time quantum */ +#define CAN_BS1_14tq ((uint8_t)0x0D) /*!< 14 time quantum */ +#define CAN_BS1_15tq ((uint8_t)0x0E) /*!< 15 time quantum */ +#define CAN_BS1_16tq ((uint8_t)0x0F) /*!< 16 time quantum */ + +#define IS_CAN_BS1(BS1) ((BS1) <= CAN_BS1_16tq) +/** + * @} + */ + +/** @defgroup CAN_time_quantum_in_bit_segment_2 + * @{ + */ +#define CAN_BS2_1tq ((uint8_t)0x00) /*!< 1 time quantum */ +#define CAN_BS2_2tq ((uint8_t)0x01) /*!< 2 time quantum */ +#define CAN_BS2_3tq ((uint8_t)0x02) /*!< 3 time quantum */ +#define CAN_BS2_4tq ((uint8_t)0x03) /*!< 4 time quantum */ +#define CAN_BS2_5tq ((uint8_t)0x04) /*!< 5 time quantum */ +#define CAN_BS2_6tq ((uint8_t)0x05) /*!< 6 time quantum */ +#define CAN_BS2_7tq ((uint8_t)0x06) /*!< 7 time quantum */ +#define CAN_BS2_8tq ((uint8_t)0x07) /*!< 8 time quantum */ + +#define IS_CAN_BS2(BS2) ((BS2) <= CAN_BS2_8tq) +/** + * @} + */ + +/** @defgroup CAN_clock_prescaler + * @{ + */ +#define IS_CAN_PRESCALER(PRESCALER) (((PRESCALER) >= 1) && ((PRESCALER) <= 1024)) +/** + * @} + */ + +/** @defgroup CAN_filter_number + * @{ + */ +#define IS_CAN_FILTER_NUMBER(NUMBER) ((NUMBER) <= 27) +/** + * @} + */ + +/** @defgroup CAN_filter_mode + * @{ + */ +#define CAN_FilterMode_IdMask ((uint8_t)0x00) /*!< identifier/mask mode */ +#define CAN_FilterMode_IdList ((uint8_t)0x01) /*!< identifier list mode */ + +#define IS_CAN_FILTER_MODE(MODE) (((MODE) == CAN_FilterMode_IdMask) || \ + ((MODE) == CAN_FilterMode_IdList)) +/** + * @} + */ + +/** @defgroup CAN_filter_scale + * @{ + */ +#define CAN_FilterScale_16bit ((uint8_t)0x00) /*!< Two 16-bit filters */ +#define CAN_FilterScale_32bit ((uint8_t)0x01) /*!< One 32-bit filter */ + +#define IS_CAN_FILTER_SCALE(SCALE) (((SCALE) == CAN_FilterScale_16bit) || \ + ((SCALE) == CAN_FilterScale_32bit)) +/** + * @} + */ + +/** @defgroup CAN_filter_FIFO + * @{ + */ +#define CAN_Filter_FIFO0 ((uint8_t)0x00) /*!< Filter FIFO 0 assignment for filter x */ +#define CAN_Filter_FIFO1 ((uint8_t)0x01) /*!< Filter FIFO 1 assignment for filter x */ +#define IS_CAN_FILTER_FIFO(FIFO) (((FIFO) == CAN_FilterFIFO0) || \ + ((FIFO) == CAN_FilterFIFO1)) + +/* Legacy defines */ +#define CAN_FilterFIFO0 CAN_Filter_FIFO0 +#define CAN_FilterFIFO1 CAN_Filter_FIFO1 +/** + * @} + */ + +/** @defgroup CAN_Start_bank_filter_for_slave_CAN + * @{ + */ +#define IS_CAN_BANKNUMBER(BANKNUMBER) (((BANKNUMBER) >= 1) && ((BANKNUMBER) <= 27)) +/** + * @} + */ + +/** @defgroup CAN_Tx + * @{ + */ +#define IS_CAN_TRANSMITMAILBOX(TRANSMITMAILBOX) ((TRANSMITMAILBOX) <= ((uint8_t)0x02)) +#define IS_CAN_STDID(STDID) ((STDID) <= ((uint32_t)0x7FF)) +#define IS_CAN_EXTID(EXTID) ((EXTID) <= ((uint32_t)0x1FFFFFFF)) +#define IS_CAN_DLC(DLC) ((DLC) <= ((uint8_t)0x08)) +/** + * @} + */ + +/** @defgroup CAN_identifier_type + * @{ + */ +#define CAN_Id_Standard ((uint32_t)0x00000000) /*!< Standard Id */ +#define CAN_Id_Extended ((uint32_t)0x00000004) /*!< Extended Id */ +#define IS_CAN_IDTYPE(IDTYPE) (((IDTYPE) == CAN_Id_Standard) || \ + ((IDTYPE) == CAN_Id_Extended)) + +/* Legacy defines */ +#define CAN_ID_STD CAN_Id_Standard +#define CAN_ID_EXT CAN_Id_Extended +/** + * @} + */ + +/** @defgroup CAN_remote_transmission_request + * @{ + */ +#define CAN_RTR_Data ((uint32_t)0x00000000) /*!< Data frame */ +#define CAN_RTR_Remote ((uint32_t)0x00000002) /*!< Remote frame */ +#define IS_CAN_RTR(RTR) (((RTR) == CAN_RTR_Data) || ((RTR) == CAN_RTR_Remote)) + +/* Legacy defines */ +#define CAN_RTR_DATA CAN_RTR_Data +#define CAN_RTR_REMOTE CAN_RTR_Remote +/** + * @} + */ + +/** @defgroup CAN_transmit_constants + * @{ + */ +#define CAN_TxStatus_Failed ((uint8_t)0x00)/*!< CAN transmission failed */ +#define CAN_TxStatus_Ok ((uint8_t)0x01) /*!< CAN transmission succeeded */ +#define CAN_TxStatus_Pending ((uint8_t)0x02) /*!< CAN transmission pending */ +#define CAN_TxStatus_NoMailBox ((uint8_t)0x04) /*!< CAN cell did not provide + an empty mailbox */ +/* Legacy defines */ +#define CANTXFAILED CAN_TxStatus_Failed +#define CANTXOK CAN_TxStatus_Ok +#define CANTXPENDING CAN_TxStatus_Pending +#define CAN_NO_MB CAN_TxStatus_NoMailBox +/** + * @} + */ + +/** @defgroup CAN_receive_FIFO_number_constants + * @{ + */ +#define CAN_FIFO0 ((uint8_t)0x00) /*!< CAN FIFO 0 used to receive */ +#define CAN_FIFO1 ((uint8_t)0x01) /*!< CAN FIFO 1 used to receive */ + +#define IS_CAN_FIFO(FIFO) (((FIFO) == CAN_FIFO0) || ((FIFO) == CAN_FIFO1)) +/** + * @} + */ + +/** @defgroup CAN_sleep_constants + * @{ + */ +#define CAN_Sleep_Failed ((uint8_t)0x00) /*!< CAN did not enter the sleep mode */ +#define CAN_Sleep_Ok ((uint8_t)0x01) /*!< CAN entered the sleep mode */ + +/* Legacy defines */ +#define CANSLEEPFAILED CAN_Sleep_Failed +#define CANSLEEPOK CAN_Sleep_Ok +/** + * @} + */ + +/** @defgroup CAN_wake_up_constants + * @{ + */ +#define CAN_WakeUp_Failed ((uint8_t)0x00) /*!< CAN did not leave the sleep mode */ +#define CAN_WakeUp_Ok ((uint8_t)0x01) /*!< CAN leaved the sleep mode */ + +/* Legacy defines */ +#define CANWAKEUPFAILED CAN_WakeUp_Failed +#define CANWAKEUPOK CAN_WakeUp_Ok +/** + * @} + */ + +/** + * @defgroup CAN_Error_Code_constants + * @{ + */ +#define CAN_ErrorCode_NoErr ((uint8_t)0x00) /*!< No Error */ +#define CAN_ErrorCode_StuffErr ((uint8_t)0x10) /*!< Stuff Error */ +#define CAN_ErrorCode_FormErr ((uint8_t)0x20) /*!< Form Error */ +#define CAN_ErrorCode_ACKErr ((uint8_t)0x30) /*!< Acknowledgment Error */ +#define CAN_ErrorCode_BitRecessiveErr ((uint8_t)0x40) /*!< Bit Recessive Error */ +#define CAN_ErrorCode_BitDominantErr ((uint8_t)0x50) /*!< Bit Dominant Error */ +#define CAN_ErrorCode_CRCErr ((uint8_t)0x60) /*!< CRC Error */ +#define CAN_ErrorCode_SoftwareSetErr ((uint8_t)0x70) /*!< Software Set Error */ +/** + * @} + */ + +/** @defgroup CAN_flags + * @{ + */ +/* If the flag is 0x3XXXXXXX, it means that it can be used with CAN_GetFlagStatus() + and CAN_ClearFlag() functions. */ +/* If the flag is 0x1XXXXXXX, it means that it can only be used with + CAN_GetFlagStatus() function. */ + +/* Transmit Flags */ +#define CAN_FLAG_RQCP0 ((uint32_t)0x38000001) /*!< Request MailBox0 Flag */ +#define CAN_FLAG_RQCP1 ((uint32_t)0x38000100) /*!< Request MailBox1 Flag */ +#define CAN_FLAG_RQCP2 ((uint32_t)0x38010000) /*!< Request MailBox2 Flag */ + +/* Receive Flags */ +#define CAN_FLAG_FMP0 ((uint32_t)0x12000003) /*!< FIFO 0 Message Pending Flag */ +#define CAN_FLAG_FF0 ((uint32_t)0x32000008) /*!< FIFO 0 Full Flag */ +#define CAN_FLAG_FOV0 ((uint32_t)0x32000010) /*!< FIFO 0 Overrun Flag */ +#define CAN_FLAG_FMP1 ((uint32_t)0x14000003) /*!< FIFO 1 Message Pending Flag */ +#define CAN_FLAG_FF1 ((uint32_t)0x34000008) /*!< FIFO 1 Full Flag */ +#define CAN_FLAG_FOV1 ((uint32_t)0x34000010) /*!< FIFO 1 Overrun Flag */ + +/* Operating Mode Flags */ +#define CAN_FLAG_WKU ((uint32_t)0x31000008) /*!< Wake up Flag */ +#define CAN_FLAG_SLAK ((uint32_t)0x31000012) /*!< Sleep acknowledge Flag */ +/* @note When SLAK interrupt is disabled (SLKIE=0), no polling on SLAKI is possible. + In this case the SLAK bit can be polled.*/ + +/* Error Flags */ +#define CAN_FLAG_EWG ((uint32_t)0x10F00001) /*!< Error Warning Flag */ +#define CAN_FLAG_EPV ((uint32_t)0x10F00002) /*!< Error Passive Flag */ +#define CAN_FLAG_BOF ((uint32_t)0x10F00004) /*!< Bus-Off Flag */ +#define CAN_FLAG_LEC ((uint32_t)0x30F00070) /*!< Last error code Flag */ + +#define IS_CAN_GET_FLAG(FLAG) (((FLAG) == CAN_FLAG_LEC) || ((FLAG) == CAN_FLAG_BOF) || \ + ((FLAG) == CAN_FLAG_EPV) || ((FLAG) == CAN_FLAG_EWG) || \ + ((FLAG) == CAN_FLAG_WKU) || ((FLAG) == CAN_FLAG_FOV0) || \ + ((FLAG) == CAN_FLAG_FF0) || ((FLAG) == CAN_FLAG_FMP0) || \ + ((FLAG) == CAN_FLAG_FOV1) || ((FLAG) == CAN_FLAG_FF1) || \ + ((FLAG) == CAN_FLAG_FMP1) || ((FLAG) == CAN_FLAG_RQCP2) || \ + ((FLAG) == CAN_FLAG_RQCP1)|| ((FLAG) == CAN_FLAG_RQCP0) || \ + ((FLAG) == CAN_FLAG_SLAK )) + +#define IS_CAN_CLEAR_FLAG(FLAG)(((FLAG) == CAN_FLAG_LEC) || ((FLAG) == CAN_FLAG_RQCP2) || \ + ((FLAG) == CAN_FLAG_RQCP1) || ((FLAG) == CAN_FLAG_RQCP0) || \ + ((FLAG) == CAN_FLAG_FF0) || ((FLAG) == CAN_FLAG_FOV0) ||\ + ((FLAG) == CAN_FLAG_FF1) || ((FLAG) == CAN_FLAG_FOV1) || \ + ((FLAG) == CAN_FLAG_WKU) || ((FLAG) == CAN_FLAG_SLAK)) +/** + * @} + */ + + +/** @defgroup CAN_interrupts + * @{ + */ +#define CAN_IT_TME ((uint32_t)0x00000001) /*!< Transmit mailbox empty Interrupt*/ + +/* Receive Interrupts */ +#define CAN_IT_FMP0 ((uint32_t)0x00000002) /*!< FIFO 0 message pending Interrupt*/ +#define CAN_IT_FF0 ((uint32_t)0x00000004) /*!< FIFO 0 full Interrupt*/ +#define CAN_IT_FOV0 ((uint32_t)0x00000008) /*!< FIFO 0 overrun Interrupt*/ +#define CAN_IT_FMP1 ((uint32_t)0x00000010) /*!< FIFO 1 message pending Interrupt*/ +#define CAN_IT_FF1 ((uint32_t)0x00000020) /*!< FIFO 1 full Interrupt*/ +#define CAN_IT_FOV1 ((uint32_t)0x00000040) /*!< FIFO 1 overrun Interrupt*/ + +/* Operating Mode Interrupts */ +#define CAN_IT_WKU ((uint32_t)0x00010000) /*!< Wake-up Interrupt*/ +#define CAN_IT_SLK ((uint32_t)0x00020000) /*!< Sleep acknowledge Interrupt*/ + +/* Error Interrupts */ +#define CAN_IT_EWG ((uint32_t)0x00000100) /*!< Error warning Interrupt*/ +#define CAN_IT_EPV ((uint32_t)0x00000200) /*!< Error passive Interrupt*/ +#define CAN_IT_BOF ((uint32_t)0x00000400) /*!< Bus-off Interrupt*/ +#define CAN_IT_LEC ((uint32_t)0x00000800) /*!< Last error code Interrupt*/ +#define CAN_IT_ERR ((uint32_t)0x00008000) /*!< Error Interrupt*/ + +/* Flags named as Interrupts : kept only for FW compatibility */ +#define CAN_IT_RQCP0 CAN_IT_TME +#define CAN_IT_RQCP1 CAN_IT_TME +#define CAN_IT_RQCP2 CAN_IT_TME + + +#define IS_CAN_IT(IT) (((IT) == CAN_IT_TME) || ((IT) == CAN_IT_FMP0) ||\ + ((IT) == CAN_IT_FF0) || ((IT) == CAN_IT_FOV0) ||\ + ((IT) == CAN_IT_FMP1) || ((IT) == CAN_IT_FF1) ||\ + ((IT) == CAN_IT_FOV1) || ((IT) == CAN_IT_EWG) ||\ + ((IT) == CAN_IT_EPV) || ((IT) == CAN_IT_BOF) ||\ + ((IT) == CAN_IT_LEC) || ((IT) == CAN_IT_ERR) ||\ + ((IT) == CAN_IT_WKU) || ((IT) == CAN_IT_SLK)) + +#define IS_CAN_CLEAR_IT(IT) (((IT) == CAN_IT_TME) || ((IT) == CAN_IT_FF0) ||\ + ((IT) == CAN_IT_FOV0)|| ((IT) == CAN_IT_FF1) ||\ + ((IT) == CAN_IT_FOV1)|| ((IT) == CAN_IT_EWG) ||\ + ((IT) == CAN_IT_EPV) || ((IT) == CAN_IT_BOF) ||\ + ((IT) == CAN_IT_LEC) || ((IT) == CAN_IT_ERR) ||\ + ((IT) == CAN_IT_WKU) || ((IT) == CAN_IT_SLK)) +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions --------------------------------------------------------*/ + +/* Function used to set the CAN configuration to the default reset state *****/ +void CAN_DeInit(CAN_TypeDef* CANx); + +/* Initialization and Configuration functions *********************************/ +uint8_t CAN_Init(CAN_TypeDef* CANx, CAN_InitTypeDef* CAN_InitStruct); +void CAN_FilterInit(CAN_FilterInitTypeDef* CAN_FilterInitStruct); +void CAN_StructInit(CAN_InitTypeDef* CAN_InitStruct); +void CAN_SlaveStartBank(uint8_t CAN_BankNumber); +void CAN_DBGFreeze(CAN_TypeDef* CANx, FunctionalState NewState); +void CAN_TTComModeCmd(CAN_TypeDef* CANx, FunctionalState NewState); + +/* CAN Frames Transmission functions ******************************************/ +uint8_t CAN_Transmit(CAN_TypeDef* CANx, CanTxMsg* TxMessage); +uint8_t CAN_TransmitStatus(CAN_TypeDef* CANx, uint8_t TransmitMailbox); +void CAN_CancelTransmit(CAN_TypeDef* CANx, uint8_t Mailbox); + +/* CAN Frames Reception functions *********************************************/ +void CAN_Receive(CAN_TypeDef* CANx, uint8_t FIFONumber, CanRxMsg* RxMessage); +void CAN_FIFORelease(CAN_TypeDef* CANx, uint8_t FIFONumber); +uint8_t CAN_MessagePending(CAN_TypeDef* CANx, uint8_t FIFONumber); + +/* Operation modes functions **************************************************/ +uint8_t CAN_OperatingModeRequest(CAN_TypeDef* CANx, uint8_t CAN_OperatingMode); +uint8_t CAN_Sleep(CAN_TypeDef* CANx); +uint8_t CAN_WakeUp(CAN_TypeDef* CANx); + +/* CAN Bus Error management functions *****************************************/ +uint8_t CAN_GetLastErrorCode(CAN_TypeDef* CANx); +uint8_t CAN_GetReceiveErrorCounter(CAN_TypeDef* CANx); +uint8_t CAN_GetLSBTransmitErrorCounter(CAN_TypeDef* CANx); + +/* Interrupts and flags management functions **********************************/ +void CAN_ITConfig(CAN_TypeDef* CANx, uint32_t CAN_IT, FunctionalState NewState); +FlagStatus CAN_GetFlagStatus(CAN_TypeDef* CANx, uint32_t CAN_FLAG); +void CAN_ClearFlag(CAN_TypeDef* CANx, uint32_t CAN_FLAG); +ITStatus CAN_GetITStatus(CAN_TypeDef* CANx, uint32_t CAN_IT); +void CAN_ClearITPendingBit(CAN_TypeDef* CANx, uint32_t CAN_IT); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0xx_CAN_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_cec.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_cec.h new file mode 100644 index 00000000..ca1244e2 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_cec.h @@ -0,0 +1,300 @@ +/** + ****************************************************************************** + * @file stm32f0xx_cec.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the CEC firmware + * library, applicable only for STM32F051, STM32F042 and STM32F072 devices. + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_CEC_H +#define __STM32F0XX_CEC_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup CEC + * @{ + */ +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief CEC Init structure definition + */ +typedef struct +{ + uint32_t CEC_SignalFreeTime; /*!< Specifies the CEC Signal Free Time configuration. + This parameter can be a value of @ref CEC_Signal_Free_Time */ + uint32_t CEC_RxTolerance; /*!< Specifies the CEC Reception Tolerance. + This parameter can be a value of @ref CEC_RxTolerance */ + uint32_t CEC_StopReception; /*!< Specifies the CEC Stop Reception. + This parameter can be a value of @ref CEC_Stop_Reception */ + uint32_t CEC_BitRisingError; /*!< Specifies the CEC Bit Rising Error generation. + This parameter can be a value of @ref CEC_Bit_Rising_Error_Generation */ + uint32_t CEC_LongBitPeriodError; /*!< Specifies the CEC Long Bit Error generation. + This parameter can be a value of @ref CEC_Long_Bit_Error_Generation */ + uint32_t CEC_BRDNoGen; /*!< Specifies the CEC Broadcast Error generation. + This parameter can be a value of @ref CEC_BDR_No_Gen */ + uint32_t CEC_SFTOption; /*!< Specifies the CEC Signal Free Time option. + This parameter can be a value of @ref CEC_SFT_Option */ + +}CEC_InitTypeDef; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup CEC_Exported_Constants + * @{ + */ + +/** @defgroup CEC_Signal_Free_Time + * @{ + */ +#define CEC_SignalFreeTime_Standard ((uint32_t)0x00000000) /*!< CEC Signal Free Time Standard */ +#define CEC_SignalFreeTime_1T ((uint32_t)0x00000001) /*!< CEC 1.5 nominal data bit periods */ +#define CEC_SignalFreeTime_2T ((uint32_t)0x00000002) /*!< CEC 2.5 nominal data bit periods */ +#define CEC_SignalFreeTime_3T ((uint32_t)0x00000003) /*!< CEC 3.5 nominal data bit periods */ +#define CEC_SignalFreeTime_4T ((uint32_t)0x00000004) /*!< CEC 4.5 nominal data bit periods */ +#define CEC_SignalFreeTime_5T ((uint32_t)0x00000005) /*!< CEC 5.5 nominal data bit periods */ +#define CEC_SignalFreeTime_6T ((uint32_t)0x00000006) /*!< CEC 6.5 nominal data bit periods */ +#define CEC_SignalFreeTime_7T ((uint32_t)0x00000007) /*!< CEC 7.5 nominal data bit periods */ + +#define IS_CEC_SIGNAL_FREE_TIME(TIME) (((TIME) == CEC_SignalFreeTime_Standard) || \ + ((TIME) == CEC_SignalFreeTime_1T)|| \ + ((TIME) == CEC_SignalFreeTime_2T)|| \ + ((TIME) == CEC_SignalFreeTime_3T)|| \ + ((TIME) == CEC_SignalFreeTime_4T)|| \ + ((TIME) == CEC_SignalFreeTime_5T)|| \ + ((TIME) == CEC_SignalFreeTime_6T)|| \ + ((TIME) == CEC_SignalFreeTime_7T)) +/** + * @} + */ + +/** @defgroup CEC_RxTolerance + * @{ + */ +#define CEC_RxTolerance_Standard ((uint32_t)0x00000000) /*!< Standard Tolerance Margin */ +#define CEC_RxTolerance_Extended CEC_CFGR_RXTOL /*!< Extended Tolerance Margin */ + +#define IS_CEC_RX_TOLERANCE(TOLERANCE) (((TOLERANCE) == CEC_RxTolerance_Standard) || \ + ((TOLERANCE) == CEC_RxTolerance_Extended)) +/** + * @} + */ + +/** @defgroup CEC_Stop_Reception + * @{ + */ +#define CEC_StopReception_Off ((uint32_t)0x00000000) /*!< No RX Stop on bit Rising Error (BRE) */ +#define CEC_StopReception_On CEC_CFGR_BRESTP /*!< RX Stop on bit Rising Error (BRE) */ + +#define IS_CEC_STOP_RECEPTION(RECEPTION) (((RECEPTION) == CEC_StopReception_On) || \ + ((RECEPTION) == CEC_StopReception_Off)) +/** + * @} + */ + +/** @defgroup CEC_Bit_Rising_Error_Generation + * @{ + */ +#define CEC_BitRisingError_Off ((uint32_t)0x00000000) /*!< Bit Rising Error generation turned Off */ +#define CEC_BitRisingError_On CEC_CFGR_BREGEN /*!< Bit Rising Error generation turned On */ + +#define IS_CEC_BIT_RISING_ERROR(ERROR) (((ERROR) == CEC_BitRisingError_Off) || \ + ((ERROR) == CEC_BitRisingError_On)) +/** + * @} + */ + +/** @defgroup CEC_Long_Bit_Error_Generation + * @{ + */ +#define CEC_LongBitPeriodError_Off ((uint32_t)0x00000000) /*!< Long Bit Period Error generation turned Off */ +#define CEC_LongBitPeriodError_On CEC_CFGR_LREGEN /*!< Long Bit Period Error generation turned On */ + +#define IS_CEC_LONG_BIT_PERIOD_ERROR(ERROR) (((ERROR) == CEC_LongBitPeriodError_Off) || \ + ((ERROR) == CEC_LongBitPeriodError_On)) +/** + * @} + */ + +/** @defgroup CEC_BDR_No_Gen + * @{ + */ + +#define CEC_BRDNoGen_Off ((uint32_t)0x00000000) /*!< Broadcast Bit Rising Error generation turned Off */ +#define CEC_BRDNoGen_On CEC_CFGR_BRDNOGEN /*!< Broadcast Bit Rising Error generation turned On */ + +#define IS_CEC_BDR_NO_GEN_ERROR(ERROR) (((ERROR) == CEC_BRDNoGen_Off) || \ + ((ERROR) == CEC_BRDNoGen_On)) +/** + * @} + */ + +/** @defgroup CEC_SFT_Option + * @{ + */ +#define CEC_SFTOption_Off ((uint32_t)0x00000000) /*!< SFT option turned Off */ +#define CEC_SFTOption_On CEC_CFGR_SFTOPT /*!< SFT option turned On */ + +#define IS_CEC_SFT_OPTION(OPTION) (((OPTION) == CEC_SFTOption_Off) || \ + ((OPTION) == CEC_SFTOption_On)) +/** + * @} + */ + +/** @defgroup CEC_Own_Address + * @{ + */ +#define IS_CEC_ADDRESS(ADDRESS) ((ADDRESS) < 0x10) + +/** + * @} + */ + +/** @defgroup CEC_Interrupt_Configuration_definition + * @{ + */ +#define CEC_IT_TXACKE CEC_IER_TXACKEIE +#define CEC_IT_TXERR CEC_IER_TXERRIE +#define CEC_IT_TXUDR CEC_IER_TXUDRIE +#define CEC_IT_TXEND CEC_IER_TXENDIE +#define CEC_IT_TXBR CEC_IER_TXBRIE +#define CEC_IT_ARBLST CEC_IER_ARBLSTIE +#define CEC_IT_RXACKE CEC_IER_RXACKEIE +#define CEC_IT_LBPE CEC_IER_LBPEIE +#define CEC_IT_SBPE CEC_IER_SBPEIE +#define CEC_IT_BRE CEC_IER_BREIEIE +#define CEC_IT_RXOVR CEC_IER_RXOVRIE +#define CEC_IT_RXEND CEC_IER_RXENDIE +#define CEC_IT_RXBR CEC_IER_RXBRIE + +#define IS_CEC_IT(IT) ((((IT) & (uint32_t)0xFFFFE000) == 0x00) && ((IT) != 0x00)) + +#define IS_CEC_GET_IT(IT) (((IT) == CEC_IT_TXACKE) || \ + ((IT) == CEC_IT_TXERR)|| \ + ((IT) == CEC_IT_TXUDR)|| \ + ((IT) == CEC_IT_TXEND)|| \ + ((IT) == CEC_IT_TXBR)|| \ + ((IT) == CEC_IT_ARBLST)|| \ + ((IT) == CEC_IT_RXACKE)|| \ + ((IT) == CEC_IT_LBPE)|| \ + ((IT) == CEC_IT_SBPE)|| \ + ((IT) == CEC_IT_BRE)|| \ + ((IT) == CEC_IT_RXOVR)|| \ + ((IT) == CEC_IT_RXEND)|| \ + ((IT) == CEC_IT_RXBR)) +/** + * @} + */ + +/** @defgroup CEC_ISR_register_flags_definition + * @{ + */ +#define CEC_FLAG_TXACKE CEC_ISR_TXACKE +#define CEC_FLAG_TXERR CEC_ISR_TXERR +#define CEC_FLAG_TXUDR CEC_ISR_TXUDR +#define CEC_FLAG_TXEND CEC_ISR_TXEND +#define CEC_FLAG_TXBR CEC_ISR_TXBR +#define CEC_FLAG_ARBLST CEC_ISR_ARBLST +#define CEC_FLAG_RXACKE CEC_ISR_RXACKE +#define CEC_FLAG_LBPE CEC_ISR_LBPE +#define CEC_FLAG_SBPE CEC_ISR_SBPE +#define CEC_FLAG_BRE CEC_ISR_BRE +#define CEC_FLAG_RXOVR CEC_ISR_RXOVR +#define CEC_FLAG_RXEND CEC_ISR_RXEND +#define CEC_FLAG_RXBR CEC_ISR_RXBR + +#define IS_CEC_CLEAR_FLAG(FLAG) ((((FLAG) & (uint32_t)0xFFFFE000) == 0x00) && ((FLAG) != 0x00)) + +#define IS_CEC_GET_FLAG(FLAG) (((FLAG) == CEC_FLAG_TXACKE) || \ + ((FLAG) == CEC_FLAG_TXERR)|| \ + ((FLAG) == CEC_FLAG_TXUDR)|| \ + ((FLAG) == CEC_FLAG_TXEND)|| \ + ((FLAG) == CEC_FLAG_TXBR)|| \ + ((FLAG) == CEC_FLAG_ARBLST)|| \ + ((FLAG) == CEC_FLAG_RXACKE)|| \ + ((FLAG) == CEC_FLAG_LBPE)|| \ + ((FLAG) == CEC_FLAG_SBPE)|| \ + ((FLAG) == CEC_FLAG_BRE)|| \ + ((FLAG) == CEC_FLAG_RXOVR)|| \ + ((FLAG) == CEC_FLAG_RXEND)|| \ + ((FLAG) == CEC_FLAG_RXBR)) +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Function used to set the CEC configuration to the default reset state *****/ +void CEC_DeInit(void); + +/* CEC_Initialization and Configuration functions *****************************/ +void CEC_Init(CEC_InitTypeDef* CEC_InitStruct); +void CEC_StructInit(CEC_InitTypeDef* CEC_InitStruct); +void CEC_Cmd(FunctionalState NewState); +void CEC_ListenModeCmd(FunctionalState NewState); +void CEC_OwnAddressConfig(uint8_t CEC_OwnAddress); +void CEC_OwnAddressClear(void); + +/* CEC_Data transfers functions ***********************************************/ +void CEC_SendData(uint8_t Data); +uint8_t CEC_ReceiveData(void); +void CEC_StartOfMessage(void); +void CEC_EndOfMessage(void); + +/* CEC_Interrupts and flags management functions ******************************/ +void CEC_ITConfig(uint16_t CEC_IT, FunctionalState NewState); +FlagStatus CEC_GetFlagStatus(uint16_t CEC_FLAG); +void CEC_ClearFlag(uint32_t CEC_FLAG); +ITStatus CEC_GetITStatus(uint16_t CEC_IT); +void CEC_ClearITPendingBit(uint16_t CEC_IT); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_CEC_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_comp.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_comp.h new file mode 100644 index 00000000..12d1493b --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_comp.h @@ -0,0 +1,245 @@ +/** + ****************************************************************************** + * @file stm32f0xx_comp.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the COMP firmware + * library, applicable only for STM32F051 and STM32F072 devices. + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_COMP_H +#define __STM32F0XX_COMP_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup COMP + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief COMP Init structure definition + */ + +typedef struct +{ + + uint32_t COMP_InvertingInput; /*!< Selects the inverting input of the comparator. + This parameter can be a value of @ref COMP_InvertingInput */ + + uint32_t COMP_Output; /*!< Selects the output redirection of the comparator. + This parameter can be a value of @ref COMP_Output */ + + uint32_t COMP_OutputPol; /*!< Selects the output polarity of the comparator. + This parameter can be a value of @ref COMP_OutputPolarity */ + + uint32_t COMP_Hysteresis; /*!< Selects the hysteresis voltage of the comparator. + This parameter can be a value of @ref COMP_Hysteresis */ + + uint32_t COMP_Mode; /*!< Selects the operating mode of the comparator + and allows to adjust the speed/consumption. + This parameter can be a value of @ref COMP_Mode */ + +}COMP_InitTypeDef; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup COMP_Exported_Constants + * @{ + */ + +/** @defgroup COMP_Selection + * @{ + */ + +#define COMP_Selection_COMP1 ((uint32_t)0x00000000) /*!< COMP1 Selection */ +#define COMP_Selection_COMP2 ((uint32_t)0x00000010) /*!< COMP2 Selection */ + +#define IS_COMP_ALL_PERIPH(PERIPH) (((PERIPH) == COMP_Selection_COMP1) || \ + ((PERIPH) == COMP_Selection_COMP2)) + +/** + * @} + */ + +/** @defgroup COMP_InvertingInput + * @{ + */ + +#define COMP_InvertingInput_1_4VREFINT ((uint32_t)0x00000000) /*!< 1/4 VREFINT connected to comparator inverting input */ +#define COMP_InvertingInput_1_2VREFINT COMP_CSR_COMP1INSEL_0 /*!< 1/2 VREFINT connected to comparator inverting input */ +#define COMP_InvertingInput_3_4VREFINT COMP_CSR_COMP1INSEL_1 /*!< 3/4 VREFINT connected to comparator inverting input */ +#define COMP_InvertingInput_VREFINT ((uint32_t)0x00000030) /*!< VREFINT connected to comparator inverting input */ +#define COMP_InvertingInput_DAC1 COMP_CSR_COMP1INSEL_2 /*!< DAC1_OUT (PA4) connected to comparator inverting input */ +#define COMP_InvertingInput_DAC2 ((uint32_t)0x00000050) /*!< DAC2_OUT (PA5) connected to comparator inverting input, applicable only for STM32F072 devices */ +#define COMP_InvertingInput_IO ((uint32_t)0x00000060) /*!< I/O (PA0 for COMP1 and PA2 for COMP2) connected to comparator inverting input */ + +#define IS_COMP_INVERTING_INPUT(INPUT) (((INPUT) == COMP_InvertingInput_1_4VREFINT) || \ + ((INPUT) == COMP_InvertingInput_1_2VREFINT) || \ + ((INPUT) == COMP_InvertingInput_3_4VREFINT) || \ + ((INPUT) == COMP_InvertingInput_VREFINT) || \ + ((INPUT) == COMP_InvertingInput_DAC1) || \ + ((INPUT) == COMP_InvertingInput_DAC2) || \ + ((INPUT) == COMP_InvertingInput_1_4VREFINT) || \ + ((INPUT) == COMP_InvertingInput_IO)) +/** + * @} + */ + +/** @defgroup COMP_Output + * @{ + */ + +#define COMP_Output_None ((uint32_t)0x00000000) /*!< COMP output isn't connected to other peripherals */ +#define COMP_Output_TIM1BKIN COMP_CSR_COMP1OUTSEL_0 /*!< COMP output connected to TIM1 Break Input (BKIN) */ +#define COMP_Output_TIM1IC1 COMP_CSR_COMP1OUTSEL_1 /*!< COMP output connected to TIM1 Input Capture 1 */ +#define COMP_Output_TIM1OCREFCLR ((uint32_t)0x00000300) /*!< COMP output connected to TIM1 OCREF Clear */ +#define COMP_Output_TIM2IC4 COMP_CSR_COMP1OUTSEL_2 /*!< COMP output connected to TIM2 Input Capture 4 */ +#define COMP_Output_TIM2OCREFCLR ((uint32_t)0x00000500) /*!< COMP output connected to TIM2 OCREF Clear */ +#define COMP_Output_TIM3IC1 ((uint32_t)0x00000600) /*!< COMP output connected to TIM3 Input Capture 1 */ +#define COMP_Output_TIM3OCREFCLR COMP_CSR_COMP1OUTSEL /*!< COMP output connected to TIM3 OCREF Clear */ + + +#define IS_COMP_OUTPUT(OUTPUT) (((OUTPUT) == COMP_Output_None) || \ + ((OUTPUT) == COMP_Output_TIM1BKIN) || \ + ((OUTPUT) == COMP_Output_TIM1IC1) || \ + ((OUTPUT) == COMP_Output_TIM1OCREFCLR) || \ + ((OUTPUT) == COMP_Output_TIM2IC4) || \ + ((OUTPUT) == COMP_Output_TIM2OCREFCLR) || \ + ((OUTPUT) == COMP_Output_TIM3IC1) || \ + ((OUTPUT) == COMP_Output_TIM3OCREFCLR)) +/** + * @} + */ + +/** @defgroup COMP_OutputPolarity + * @{ + */ +#define COMP_OutputPol_NonInverted ((uint32_t)0x00000000) /*!< COMP output on GPIO isn't inverted */ +#define COMP_OutputPol_Inverted COMP_CSR_COMP1POL /*!< COMP output on GPIO is inverted */ + +#define IS_COMP_OUTPUT_POL(POL) (((POL) == COMP_OutputPol_NonInverted) || \ + ((POL) == COMP_OutputPol_Inverted)) + +/** + * @} + */ + +/** @defgroup COMP_Hysteresis + * @{ + */ +/* Please refer to the electrical characteristics in the device datasheet for + the hysteresis level */ +#define COMP_Hysteresis_No 0x00000000 /*!< No hysteresis */ +#define COMP_Hysteresis_Low COMP_CSR_COMP1HYST_0 /*!< Hysteresis level low */ +#define COMP_Hysteresis_Medium COMP_CSR_COMP1HYST_1 /*!< Hysteresis level medium */ +#define COMP_Hysteresis_High COMP_CSR_COMP1HYST /*!< Hysteresis level high */ + +#define IS_COMP_HYSTERESIS(HYSTERESIS) (((HYSTERESIS) == COMP_Hysteresis_No) || \ + ((HYSTERESIS) == COMP_Hysteresis_Low) || \ + ((HYSTERESIS) == COMP_Hysteresis_Medium) || \ + ((HYSTERESIS) == COMP_Hysteresis_High)) +/** + * @} + */ + +/** @defgroup COMP_Mode + * @{ + */ +/* Please refer to the electrical characteristics in the device datasheet for + the power consumption values */ +#define COMP_Mode_HighSpeed 0x00000000 /*!< High Speed */ +#define COMP_Mode_MediumSpeed COMP_CSR_COMP1MODE_0 /*!< Medium Speed */ +#define COMP_Mode_LowPower COMP_CSR_COMP1MODE_1 /*!< Low power mode */ +#define COMP_Mode_UltraLowPower COMP_CSR_COMP1MODE /*!< Ultra-low power mode */ + +#define IS_COMP_MODE(MODE) (((MODE) == COMP_Mode_UltraLowPower) || \ + ((MODE) == COMP_Mode_LowPower) || \ + ((MODE) == COMP_Mode_MediumSpeed) || \ + ((MODE) == COMP_Mode_HighSpeed)) +/** + * @} + */ + +/** @defgroup COMP_OutputLevel + * @{ + */ +/* When output polarity is not inverted, comparator output is high when + the non-inverting input is at a higher voltage than the inverting input */ +#define COMP_OutputLevel_High COMP_CSR_COMP1OUT +/* When output polarity is not inverted, comparator output is low when + the non-inverting input is at a lower voltage than the inverting input*/ +#define COMP_OutputLevel_Low ((uint32_t)0x00000000) + +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Function used to set the COMP configuration to the default reset state ****/ +void COMP_DeInit(void); + +/* Initialization and Configuration functions *********************************/ +void COMP_Init(uint32_t COMP_Selection, COMP_InitTypeDef* COMP_InitStruct); +void COMP_StructInit(COMP_InitTypeDef* COMP_InitStruct); +void COMP_Cmd(uint32_t COMP_Selection, FunctionalState NewState); +void COMP_SwitchCmd(FunctionalState NewState); +uint32_t COMP_GetOutputLevel(uint32_t COMP_Selection); + +/* Window mode control function ***********************************************/ +void COMP_WindowCmd(FunctionalState NewState); + +/* COMP configuration locking function ****************************************/ +void COMP_LockConfig(uint32_t COMP_Selection); + +#ifdef __cplusplus +} +#endif + +#endif /*__STM32F0XX_COMP_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_crc.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_crc.h new file mode 100644 index 00000000..e639df63 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_crc.h @@ -0,0 +1,122 @@ +/** + ****************************************************************************** + * @file stm32f0xx_crc.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the CRC firmware + * library. + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_CRC_H +#define __STM32F0XX_CRC_H + +#ifdef __cplusplus + extern "C" { +#endif + +/*!< Includes ----------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup CRC + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup CRC_ReverseInputData + * @{ + */ +#define CRC_ReverseInputData_No ((uint32_t)0x00000000) /*!< No reverse operation of Input Data */ +#define CRC_ReverseInputData_8bits CRC_CR_REV_IN_0 /*!< Reverse operation of Input Data on 8 bits */ +#define CRC_ReverseInputData_16bits CRC_CR_REV_IN_1 /*!< Reverse operation of Input Data on 16 bits */ +#define CRC_ReverseInputData_32bits CRC_CR_REV_IN /*!< Reverse operation of Input Data on 32 bits */ + +#define IS_CRC_REVERSE_INPUT_DATA(DATA) (((DATA) == CRC_ReverseInputData_No) || \ + ((DATA) == CRC_ReverseInputData_8bits) || \ + ((DATA) == CRC_ReverseInputData_16bits) || \ + ((DATA) == CRC_ReverseInputData_32bits)) + +/** + * @} + */ + +/** @defgroup CRC_PolynomialSize + * @brief Only applicable for STM32F042 and STM32F072 devices + * @{ + */ +#define CRC_PolSize_7 CRC_CR_POLSIZE /*!< 7-bit polynomial for CRC calculation */ +#define CRC_PolSize_8 CRC_CR_POLSIZE_1 /*!< 8-bit polynomial for CRC calculation */ +#define CRC_PolSize_16 CRC_CR_POLSIZE_0 /*!< 16-bit polynomial for CRC calculation */ +#define CRC_PolSize_32 ((uint32_t)0x00000000)/*!< 32-bit polynomial for CRC calculation */ + +#define IS_CRC_POL_SIZE(SIZE) (((SIZE) == CRC_PolSize_7) || \ + ((SIZE) == CRC_PolSize_8) || \ + ((SIZE) == CRC_PolSize_16) || \ + ((SIZE) == CRC_PolSize_32)) + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ +/* Configuration of the CRC computation unit **********************************/ +void CRC_DeInit(void); +void CRC_ResetDR(void); +void CRC_PolynomialSizeSelect(uint32_t CRC_PolSize); /*!< Only applicable for STM32F042 and STM32F072 devices */ +void CRC_ReverseInputDataSelect(uint32_t CRC_ReverseInputData); +void CRC_ReverseOutputDataCmd(FunctionalState NewState); +void CRC_SetInitRegister(uint32_t CRC_InitValue); +void CRC_SetPolynomial(uint32_t CRC_Pol); /*!< Only applicable for STM32F042 and STM32F072 devices */ + +/* CRC computation ************************************************************/ +uint32_t CRC_CalcCRC(uint32_t CRC_Data); +uint32_t CRC_CalcCRC16bits(uint16_t CRC_Data); /*!< Only applicable for STM32F042 and STM32F072 devices */ +uint32_t CRC_CalcCRC8bits(uint8_t CRC_Data); /*!< Only applicable for STM32F042 and STM32F072 devices */ +uint32_t CRC_CalcBlockCRC(uint32_t pBuffer[], uint32_t BufferLength); +uint32_t CRC_GetCRC(void); + +/* Independent register (IDR) access (write/read) *****************************/ +void CRC_SetIDRegister(uint8_t CRC_IDValue); +uint8_t CRC_GetIDRegister(void); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_CRC_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_crs.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_crs.h new file mode 100644 index 00000000..ed63e981 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_crs.h @@ -0,0 +1,183 @@ +/** + ****************************************************************************** + * @file stm32f0xx_crs.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the CRS firmware + * library, applicable only for STM32F042 and STM32F072 devices. + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_CRS_H +#define __STM32F0XX_CRS_H + +#ifdef __cplusplus + extern "C" { +#endif + +/*!< Includes ----------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup CRS + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup CRS_Interrupt_Sources + * @{ + */ +#define CRS_IT_SYNCOK CRS_ISR_SYNCOKF /*!< SYNC event OK */ +#define CRS_IT_SYNCWARN CRS_ISR_SYNCWARNF /*!< SYNC warning */ +#define CRS_IT_ERR CRS_ISR_ERRF /*!< error */ +#define CRS_IT_ESYNC CRS_ISR_ESYNCF /*!< Expected SYNC */ +#define CRS_IT_TRIMOVF CRS_ISR_TRIMOVF /*!< Trimming overflow or underflow */ +#define CRS_IT_SYNCERR CRS_ISR_SYNCERR /*!< SYNC error */ +#define CRS_IT_SYNCMISS CRS_ISR_SYNCMISS /*!< SYNC missed*/ + +#define IS_CRS_IT(IT) (((IT) == CRS_IT_SYNCOK) || ((IT) == CRS_IT_SYNCWARN) || \ + ((IT) == CRS_IT_ERR) || ((IT) == CRS_IT_ESYNC)) + +#define IS_CRS_GET_IT(IT) (((IT) == CRS_IT_SYNCOK) || ((IT) == CRS_IT_SYNCWARN) || \ + ((IT) == CRS_IT_ERR) || ((IT) == CRS_IT_ESYNC) || \ + ((IT) == CRS_IT_TRIMOVF) || ((IT) == CRS_IT_SYNCERR) || \ + ((IT) == CRS_IT_SYNCMISS)) + +#define IS_CRS_CLEAR_IT(IT) ((IT) != 0x00) + +/** + * @} + */ + +/** @defgroup CRS_Flags + * @{ + */ +#define CRS_FLAG_SYNCOK CRS_ISR_SYNCOKF /*!< SYNC event OK */ +#define CRS_FLAG_SYNCWARN CRS_ISR_SYNCWARNF /*!< SYNC warning */ +#define CRS_FLAG_ERR CRS_ISR_ERRF /*!< error */ +#define CRS_FLAG_ESYNC CRS_ISR_ESYNCF /*!< Expected SYNC */ +#define CRS_FLAG_TRIMOVF CRS_ISR_TRIMOVF /*!< Trimming overflow or underflow */ +#define CRS_FLAG_SYNCERR CRS_ISR_SYNCERR /*!< SYNC error */ +#define CRS_FLAG_SYNCMISS CRS_ISR_SYNCMISS /*!< SYNC missed*/ + +#define IS_CRS_FLAG(FLAG) (((FLAG) == CRS_FLAG_SYNCOK) || ((FLAG) == CRS_FLAG_SYNCWARN) || \ + ((FLAG) == CRS_FLAG_ERR) || ((FLAG) == CRS_FLAG_ESYNC) || \ + ((FLAG) == CRS_FLAG_TRIMOVF) || ((FLAG) == CRS_FLAG_SYNCERR) || \ + ((FLAG) == CRS_FLAG_SYNCMISS)) + +/** + * @} + */ + +/** @defgroup CRS_Synchro_Source + * @{ + */ +#define CRS_SYNCSource_GPIO ((uint32_t)0x00) /*!< Synchro Signal soucre GPIO */ +#define CRS_SYNCSource_LSE CRS_CFGR_SYNCSRC_0 /*!< Synchro Signal source LSE */ +#define CRS_SYNCSource_USB CRS_CFGR_SYNCSRC_1 /*!< Synchro Signal source USB SOF */ + +#define IS_CRS_SYNC_SOURCE(SOURCE) (((SOURCE) == CRS_SYNCSource_GPIO) || \ + ((SOURCE) == CRS_SYNCSource_LSE) ||\ + ((SOURCE) == CRS_SYNCSource_USB)) +/** + * @} + */ + +/** @defgroup CRS_SynchroDivider + * @{ + */ +#define CRS_SYNC_Div1 ((uint32_t)0x00) /*!< Synchro Signal not divided */ +#define CRS_SYNC_Div2 CRS_CFGR_SYNCDIV_0 /*!< Synchro Signal divided by 2 */ +#define CRS_SYNC_Div4 CRS_CFGR_SYNCDIV_1 /*!< Synchro Signal divided by 4 */ +#define CRS_SYNC_Div8 (CRS_CFGR_SYNCDIV_1 | CRS_CFGR_SYNCDIV_0) /*!< Synchro Signal divided by 8 */ +#define CRS_SYNC_Div16 CRS_CFGR_SYNCDIV_2 /*!< Synchro Signal divided by 16 */ +#define CRS_SYNC_Div32 (CRS_CFGR_SYNCDIV_2 | CRS_CFGR_SYNCDIV_0) /*!< Synchro Signal divided by 32 */ +#define CRS_SYNC_Div64 (CRS_CFGR_SYNCDIV_2 | CRS_CFGR_SYNCDIV_1) /*!< Synchro Signal divided by 64 */ +#define CRS_SYNC_Div128 CRS_CFGR_SYNCDIV /*!< Synchro Signal divided by 128 */ + +#define IS_CRS_SYNC_DIV(DIV) (((DIV) == CRS_SYNC_Div1) || ((DIV) == CRS_SYNC_Div2) ||\ + ((DIV) == CRS_SYNC_Div4) || ((DIV) == CRS_SYNC_Div8) || \ + ((DIV) == CRS_SYNC_Div16) || ((DIV) == CRS_SYNC_Div32) || \ + ((DIV) == CRS_SYNC_Div64) || ((DIV) == CRS_SYNC_Div128)) +/** + * @} + */ + +/** @defgroup CRS_SynchroPolarity + * @{ + */ +#define CRS_SYNCPolarity_Rising ((uint32_t)0x00) /*!< Synchro Active on rising edge */ +#define CRS_SYNCPolarity_Falling CRS_CFGR_SYNCPOL /*!< Synchro Active on falling edge */ + +#define IS_CRS_SYNC_POLARITY(POLARITY) (((POLARITY) == CRS_SYNCPolarity_Rising) || \ + ((POLARITY) == CRS_SYNCPolarity_Falling)) +/** + * @} + */ + + + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ +/* Configuration of the CRS **********************************/ +void CRS_DeInit(void); +void CRS_AdjustHSI48CalibrationValue(uint8_t CRS_HSI48CalibrationValue); +void CRS_FrequencyErrorCounterCmd(FunctionalState NewState); +void CRS_AutomaticCalibrationCmd(FunctionalState NewState); +void CRS_SoftwareSynchronizationGenerate(void); +void CRS_FrequencyErrorCounterReload(uint32_t CRS_ReloadValue); +void CRS_FrequencyErrorLimitConfig(uint8_t CRS_ErrorLimitValue); +void CRS_SynchronizationPrescalerConfig(uint32_t CRS_Prescaler); +void CRS_SynchronizationSourceConfig(uint32_t CRS_Source); +void CRS_SynchronizationPolarityConfig(uint32_t CRS_Polarity); +uint32_t CRS_GetReloadValue(void); +uint32_t CRS_GetHSI48CalibrationValue(void); +uint32_t CRS_GetFrequencyErrorValue(void); +uint32_t CRS_GetFrequencyErrorDirection(void); + +/* Interrupts and flags management functions **********************************/ +void CRS_ITConfig(uint32_t CRS_IT, FunctionalState NewState); +FlagStatus CRS_GetFlagStatus(uint32_t CRS_FLAG); +void CRS_ClearFlag(uint32_t CRS_FLAG); +ITStatus CRS_GetITStatus(uint32_t CRS_IT); +void CRS_ClearITPendingBit(uint32_t CRS_IT); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_CRS_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_dac.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_dac.h new file mode 100644 index 00000000..75896b45 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_dac.h @@ -0,0 +1,312 @@ +/** + ****************************************************************************** + * @file stm32f0xx_dac.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the DAC firmware + * library, applicable only for STM32F051 and STM32F072 devices. + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_DAC_H +#define __STM32F0XX_DAC_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup DAC + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief DAC Init structure definition + */ + +typedef struct +{ + uint32_t DAC_Trigger; /*!< Specifies the external trigger for the selected DAC channel. + This parameter can be a value of @ref DAC_trigger_selection */ + + uint32_t DAC_WaveGeneration; /*!< Specifies whether DAC channel noise waves or triangle waves + are generated, or whether no wave is generated. + This parameter can be a value of @ref DAC_wave_generation + This parameter is only applicable for STM32F072 devices */ + + uint32_t DAC_LFSRUnmask_TriangleAmplitude; /*!< Specifies the LFSR mask for noise wave generation or + the maximum amplitude triangle generation for the DAC channel. + This parameter can be a value of @ref DAC_lfsrunmask_triangleamplitude + This parameter is only applicable for STM32F072 devices */ + + uint32_t DAC_OutputBuffer; /*!< Specifies whether the DAC channel output buffer is enabled or disabled. + This parameter can be a value of @ref DAC_output_buffer */ +}DAC_InitTypeDef; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup DAC_Exported_Constants + * @{ + */ + +/** @defgroup DAC_Trigger + * @{ + */ + +#define DAC_Trigger_None ((uint32_t)0x00000000) /*!< Conversion is automatic once the DAC1_DHRxxxx register + has been loaded, and not by external trigger */ +#define DAC_Trigger_T6_TRGO ((uint32_t)0x00000004) /*!< TIM6 TRGO selected as external conversion trigger for DAC channel1 */ +#define DAC_Trigger_T3_TRGO ((uint32_t)0x0000000C) /*!< TIM3 TRGO selected as external conversion trigger for DAC channel1 */ +#define DAC_Trigger_T7_TRGO ((uint32_t)0x00000014) /*!< TIM7 TRGO selected as external conversion trigger for DAC channel1, + applicable only for STM32F072 devices */ +#define DAC_Trigger_T15_TRGO ((uint32_t)0x0000001C) /*!< TIM15 TRGO selected as external conversion trigger for DAC channel1 */ +#define DAC_Trigger_T2_TRGO ((uint32_t)0x00000024) /*!< TIM2 TRGO selected as external conversion trigger for DAC channel1 */ +#define DAC_Trigger_Ext_IT9 ((uint32_t)0x00000034) /*!< EXTI Line9 event selected as external conversion trigger for DAC channels */ +#define DAC_Trigger_Software ((uint32_t)0x0000003C) /*!< Conversion started by software trigger for DAC channels */ + +#define IS_DAC_TRIGGER(TRIGGER) (((TRIGGER) == DAC_Trigger_None) || \ + ((TRIGGER) == DAC_Trigger_T6_TRGO) || \ + ((TRIGGER) == DAC_Trigger_T7_TRGO) || \ + ((TRIGGER) == DAC_Trigger_T3_TRGO) || \ + ((TRIGGER) == DAC_Trigger_T15_TRGO) || \ + ((TRIGGER) == DAC_Trigger_T2_TRGO) || \ + ((TRIGGER) == DAC_Trigger_Ext_IT9) || \ + ((TRIGGER) == DAC_Trigger_Software)) + +/** + * @} + */ + +/** @defgroup DAC_wave_generation + * @brief This parameters are only applicable for STM32F072 devices. + * @{ + */ + +#define DAC_WaveGeneration_None ((uint32_t)0x00000000) +#define DAC_WaveGeneration_Noise ((uint32_t)0x00000040) +#define DAC_WaveGeneration_Triangle ((uint32_t)0x00000080) +#define IS_DAC_GENERATE_WAVE(WAVE) (((WAVE) == DAC_WaveGeneration_None) || \ + ((WAVE) == DAC_WaveGeneration_Noise) || \ + ((WAVE) == DAC_WaveGeneration_Triangle)) +/** + * @} + */ + +/** @defgroup DAC_lfsrunmask_triangleamplitude + * @brief These parameters are only applicable for STM32F072 devices. + * @{ + */ + +#define DAC_LFSRUnmask_Bit0 ((uint32_t)0x00000000) /*!< Unmask DAC channel LFSR bit0 for noise wave generation */ +#define DAC_LFSRUnmask_Bits1_0 ((uint32_t)0x00000100) /*!< Unmask DAC channel LFSR bit[1:0] for noise wave generation */ +#define DAC_LFSRUnmask_Bits2_0 ((uint32_t)0x00000200) /*!< Unmask DAC channel LFSR bit[2:0] for noise wave generation */ +#define DAC_LFSRUnmask_Bits3_0 ((uint32_t)0x00000300) /*!< Unmask DAC channel LFSR bit[3:0] for noise wave generation */ +#define DAC_LFSRUnmask_Bits4_0 ((uint32_t)0x00000400) /*!< Unmask DAC channel LFSR bit[4:0] for noise wave generation */ +#define DAC_LFSRUnmask_Bits5_0 ((uint32_t)0x00000500) /*!< Unmask DAC channel LFSR bit[5:0] for noise wave generation */ +#define DAC_LFSRUnmask_Bits6_0 ((uint32_t)0x00000600) /*!< Unmask DAC channel LFSR bit[6:0] for noise wave generation */ +#define DAC_LFSRUnmask_Bits7_0 ((uint32_t)0x00000700) /*!< Unmask DAC channel LFSR bit[7:0] for noise wave generation */ +#define DAC_LFSRUnmask_Bits8_0 ((uint32_t)0x00000800) /*!< Unmask DAC channel LFSR bit[8:0] for noise wave generation */ +#define DAC_LFSRUnmask_Bits9_0 ((uint32_t)0x00000900) /*!< Unmask DAC channel LFSR bit[9:0] for noise wave generation */ +#define DAC_LFSRUnmask_Bits10_0 ((uint32_t)0x00000A00) /*!< Unmask DAC channel LFSR bit[10:0] for noise wave generation */ +#define DAC_LFSRUnmask_Bits11_0 ((uint32_t)0x00000B00) /*!< Unmask DAC channel LFSR bit[11:0] for noise wave generation */ +#define DAC_TriangleAmplitude_1 ((uint32_t)0x00000000) /*!< Select max triangle amplitude of 1 */ +#define DAC_TriangleAmplitude_3 ((uint32_t)0x00000100) /*!< Select max triangle amplitude of 3 */ +#define DAC_TriangleAmplitude_7 ((uint32_t)0x00000200) /*!< Select max triangle amplitude of 7 */ +#define DAC_TriangleAmplitude_15 ((uint32_t)0x00000300) /*!< Select max triangle amplitude of 15 */ +#define DAC_TriangleAmplitude_31 ((uint32_t)0x00000400) /*!< Select max triangle amplitude of 31 */ +#define DAC_TriangleAmplitude_63 ((uint32_t)0x00000500) /*!< Select max triangle amplitude of 63 */ +#define DAC_TriangleAmplitude_127 ((uint32_t)0x00000600) /*!< Select max triangle amplitude of 127 */ +#define DAC_TriangleAmplitude_255 ((uint32_t)0x00000700) /*!< Select max triangle amplitude of 255 */ +#define DAC_TriangleAmplitude_511 ((uint32_t)0x00000800) /*!< Select max triangle amplitude of 511 */ +#define DAC_TriangleAmplitude_1023 ((uint32_t)0x00000900) /*!< Select max triangle amplitude of 1023 */ +#define DAC_TriangleAmplitude_2047 ((uint32_t)0x00000A00) /*!< Select max triangle amplitude of 2047 */ +#define DAC_TriangleAmplitude_4095 ((uint32_t)0x00000B00) /*!< Select max triangle amplitude of 4095 */ + +#define IS_DAC_LFSR_UNMASK_TRIANGLE_AMPLITUDE(VALUE) (((VALUE) == DAC_LFSRUnmask_Bit0) || \ + ((VALUE) == DAC_LFSRUnmask_Bits1_0) || \ + ((VALUE) == DAC_LFSRUnmask_Bits2_0) || \ + ((VALUE) == DAC_LFSRUnmask_Bits3_0) || \ + ((VALUE) == DAC_LFSRUnmask_Bits4_0) || \ + ((VALUE) == DAC_LFSRUnmask_Bits5_0) || \ + ((VALUE) == DAC_LFSRUnmask_Bits6_0) || \ + ((VALUE) == DAC_LFSRUnmask_Bits7_0) || \ + ((VALUE) == DAC_LFSRUnmask_Bits8_0) || \ + ((VALUE) == DAC_LFSRUnmask_Bits9_0) || \ + ((VALUE) == DAC_LFSRUnmask_Bits10_0) || \ + ((VALUE) == DAC_LFSRUnmask_Bits11_0) || \ + ((VALUE) == DAC_TriangleAmplitude_1) || \ + ((VALUE) == DAC_TriangleAmplitude_3) || \ + ((VALUE) == DAC_TriangleAmplitude_7) || \ + ((VALUE) == DAC_TriangleAmplitude_15) || \ + ((VALUE) == DAC_TriangleAmplitude_31) || \ + ((VALUE) == DAC_TriangleAmplitude_63) || \ + ((VALUE) == DAC_TriangleAmplitude_127) || \ + ((VALUE) == DAC_TriangleAmplitude_255) || \ + ((VALUE) == DAC_TriangleAmplitude_511) || \ + ((VALUE) == DAC_TriangleAmplitude_1023) || \ + ((VALUE) == DAC_TriangleAmplitude_2047) || \ + ((VALUE) == DAC_TriangleAmplitude_4095)) +/** + * @} + */ + +/** @defgroup DAC_OutputBuffer + * @{ + */ + +#define DAC_OutputBuffer_Enable ((uint32_t)0x00000000) +#define DAC_OutputBuffer_Disable DAC_CR_BOFF1 +#define IS_DAC_OUTPUT_BUFFER_STATE(STATE) (((STATE) == DAC_OutputBuffer_Enable) || \ + ((STATE) == DAC_OutputBuffer_Disable)) +/** + * @} + */ + +/** @defgroup DAC_Channel_selection + * @{ + */ + +#define DAC_Channel_1 ((uint32_t)0x00000000) +#define DAC_Channel_2 ((uint32_t)0x00000010) /*!< Only applicable for STM32F072 devices */ +#define IS_DAC_CHANNEL(CHANNEL) (((CHANNEL) == DAC_Channel_1) || \ + ((CHANNEL) == DAC_Channel_2)) + +/** + * @} + */ + +/** @defgroup DAC_data_alignment + * @{ + */ + +#define DAC_Align_12b_R ((uint32_t)0x00000000) +#define DAC_Align_12b_L ((uint32_t)0x00000004) +#define DAC_Align_8b_R ((uint32_t)0x00000008) +#define IS_DAC_ALIGN(ALIGN) (((ALIGN) == DAC_Align_12b_R) || \ + ((ALIGN) == DAC_Align_12b_L) || \ + ((ALIGN) == DAC_Align_8b_R)) +/** + * @} + */ + +/** @defgroup DAC_wave_generation + * @brief These parameters are only applicable for STM32F072 devices. + * @{ + */ + +#define DAC_Wave_Noise ((uint32_t)0x00000040) +#define DAC_Wave_Triangle ((uint32_t)0x00000080) +#define IS_DAC_WAVE(WAVE) (((WAVE) == DAC_Wave_Noise) || \ + ((WAVE) == DAC_Wave_Triangle)) +/** + * @} + */ + +/** @defgroup DAC_data + * @{ + */ + +#define IS_DAC_DATA(DATA) ((DATA) <= 0xFFF0) + +/** + * @} + */ + +/** @defgroup DAC_interrupts_definition + * @{ + */ + +#define DAC_IT_DMAUDR DAC_SR_DMAUDR1 +#define IS_DAC_IT(IT) (((IT) == DAC_IT_DMAUDR)) + +/** + * @} + */ + + +/** @defgroup DAC_flags_definition + * @{ + */ + +#define DAC_FLAG_DMAUDR DAC_SR_DMAUDR1 + +#define IS_DAC_FLAG(FLAG) (((FLAG) == DAC_FLAG_DMAUDR)) + +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Function used to set the DAC configuration to the default reset state *****/ +void DAC_DeInit(void); + +/* DAC channels configuration: trigger, output buffer, data format functions */ +void DAC_Init(uint32_t DAC_Channel, DAC_InitTypeDef* DAC_InitStruct); +void DAC_StructInit(DAC_InitTypeDef* DAC_InitStruct); +void DAC_Cmd(uint32_t DAC_Channel, FunctionalState NewState); +void DAC_SoftwareTriggerCmd(uint32_t DAC_Channel, FunctionalState NewState); +void DAC_DualSoftwareTriggerCmd(FunctionalState NewState); /*!< Only applicable for STM32F072 devices */ +void DAC_WaveGenerationCmd(uint32_t DAC_Channel, uint32_t DAC_Wave, FunctionalState NewState); /*!< Only applicable for STM32F072 devices */ +void DAC_SetChannel1Data(uint32_t DAC_Align, uint16_t Data); +void DAC_SetChannel2Data(uint32_t DAC_Align, uint16_t Data); /*!< Only applicable for STM32F072 devices */ +void DAC_SetDualChannelData(uint32_t DAC_Align, uint16_t Data2, uint16_t Data1); /*!< Only applicable for STM32F072 devices */ +uint16_t DAC_GetDataOutputValue(uint32_t DAC_Channel); + +/* DMA management functions ***************************************************/ +void DAC_DMACmd(uint32_t DAC_Channel, FunctionalState NewState); + +/* Interrupts and flags management functions **********************************/ +void DAC_ITConfig(uint32_t DAC_Channel, uint32_t DAC_IT, FunctionalState NewState); +FlagStatus DAC_GetFlagStatus(uint32_t DAC_Channel, uint32_t DAC_FLAG); +void DAC_ClearFlag(uint32_t DAC_Channel, uint32_t DAC_FLAG); +ITStatus DAC_GetITStatus(uint32_t DAC_Channel, uint32_t DAC_IT); +void DAC_ClearITPendingBit(uint32_t DAC_Channel, uint32_t DAC_IT); + +#ifdef __cplusplus +} +#endif + +#endif /*__STM32F0XX_DAC_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_dbgmcu.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_dbgmcu.h new file mode 100644 index 00000000..4ee2916f --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_dbgmcu.h @@ -0,0 +1,107 @@ +/** + ****************************************************************************** + * @file stm32f0xx_dbgmcu.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the DBGMCU firmware + * library. + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_DBGMCU_H +#define __STM32F0XX_DBGMCU_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup DBGMCU + * @{ + */ +/* Exported types ------------------------------------------------------------*/ +/* Exported constants --------------------------------------------------------*/ + + +/** @defgroup DBGMCU_Exported_Constants + * @{ + */ + +#define DBGMCU_STOP DBGMCU_CR_DBG_STOP +#define DBGMCU_STANDBY DBGMCU_CR_DBG_STANDBY +#define IS_DBGMCU_PERIPH(PERIPH) ((((PERIPH) & 0xFFFFFFF9) == 0x00) && ((PERIPH) != 0x00)) + +#define DBGMCU_TIM2_STOP DBGMCU_APB1_FZ_DBG_TIM2_STOP /*!< Not applicable for STM32F030 devices */ +#define DBGMCU_TIM3_STOP DBGMCU_APB1_FZ_DBG_TIM3_STOP +#define DBGMCU_TIM6_STOP DBGMCU_APB1_FZ_DBG_TIM6_STOP +#define DBGMCU_TIM7_STOP DBGMCU_APB1_FZ_DBG_TIM7_STOP /*!< Only applicable for STM32F072 devices */ +#define DBGMCU_TIM14_STOP DBGMCU_APB1_FZ_DBG_TIM14_STOP +#define DBGMCU_RTC_STOP DBGMCU_APB1_FZ_DBG_RTC_STOP +#define DBGMCU_WWDG_STOP DBGMCU_APB1_FZ_DBG_WWDG_STOP +#define DBGMCU_IWDG_STOP DBGMCU_APB1_FZ_DBG_IWDG_STOP +#define DBGMCU_I2C1_SMBUS_TIMEOUT DBGMCU_APB1_FZ_DBG_I2C1_SMBUS_TIMEOUT +#define DBGMCU_CAN1_STOP DBGMCU_APB1_FZ_DBG_CAN1_STOP /*!< Only applicable for STM32F042 and STM32F072 devices */ +#define IS_DBGMCU_APB1PERIPH(PERIPH) ((((PERIPH) & 0xFDDFE2CC) == 0x00) && ((PERIPH) != 0x00)) + +#define DBGMCU_TIM1_STOP DBGMCU_APB2_FZ_DBG_TIM1_STOP +#define DBGMCU_TIM15_STOP DBGMCU_APB2_FZ_DBG_TIM15_STOP +#define DBGMCU_TIM16_STOP DBGMCU_APB2_FZ_DBG_TIM16_STOP +#define DBGMCU_TIM17_STOP DBGMCU_APB2_FZ_DBG_TIM17_STOP +#define IS_DBGMCU_APB2PERIPH(PERIPH) ((((PERIPH) & 0xFFF8F7FF) == 0x00) && ((PERIPH) != 0x00)) + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Device and Revision ID management functions ********************************/ +uint32_t DBGMCU_GetREVID(void); +uint32_t DBGMCU_GetDEVID(void); + +/* Peripherals Configuration functions ****************************************/ +void DBGMCU_Config(uint32_t DBGMCU_Periph, FunctionalState NewState); +void DBGMCU_APB1PeriphConfig(uint32_t DBGMCU_Periph, FunctionalState NewState); +void DBGMCU_APB2PeriphConfig(uint32_t DBGMCU_Periph, FunctionalState NewState); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_DBGMCU_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_dma.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_dma.h new file mode 100644 index 00000000..2c6492c7 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_dma.h @@ -0,0 +1,804 @@ +/** + ****************************************************************************** + * @file stm32f0xx_dma.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the DMA firmware + * library. + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_DMA_H +#define __STM32F0XX_DMA_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup DMA + * @{ + */ +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief DMA Init structures definition + */ +typedef struct +{ + uint32_t DMA_PeripheralBaseAddr; /*!< Specifies the peripheral base address for DMAy Channelx. */ + + uint32_t DMA_MemoryBaseAddr; /*!< Specifies the memory base address for DMAy Channelx. */ + + uint32_t DMA_DIR; /*!< Specifies if the peripheral is the source or destination. + This parameter can be a value of @ref DMA_data_transfer_direction */ + + uint32_t DMA_BufferSize; /*!< Specifies the buffer size, in data unit, of the specified Channel. + The data unit is equal to the configuration set in DMA_PeripheralDataSize + or DMA_MemoryDataSize members depending in the transfer direction */ + + uint32_t DMA_PeripheralInc; /*!< Specifies whether the Peripheral address register is incremented or not. + This parameter can be a value of @ref DMA_peripheral_incremented_mode */ + + uint32_t DMA_MemoryInc; /*!< Specifies whether the memory address register is incremented or not. + This parameter can be a value of @ref DMA_memory_incremented_mode */ + + uint32_t DMA_PeripheralDataSize; /*!< Specifies the Peripheral data width. + This parameter can be a value of @ref DMA_peripheral_data_size */ + + uint32_t DMA_MemoryDataSize; /*!< Specifies the Memory data width. + This parameter can be a value of @ref DMA_memory_data_size */ + + uint32_t DMA_Mode; /*!< Specifies the operation mode of the DMAy Channelx. + This parameter can be a value of @ref DMA_circular_normal_mode + @note: The circular buffer mode cannot be used if the memory-to-memory + data transfer is configured on the selected Channel */ + + uint32_t DMA_Priority; /*!< Specifies the software priority for the DMAy Channelx. + This parameter can be a value of @ref DMA_priority_level */ + + uint32_t DMA_M2M; /*!< Specifies if the DMAy Channelx will be used in memory-to-memory transfer. + This parameter can be a value of @ref DMA_memory_to_memory */ +}DMA_InitTypeDef; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup DMA_Exported_Constants + * @{ + */ + +#define IS_DMA_ALL_PERIPH(PERIPH) (((PERIPH) == DMA1_Channel1) || \ + ((PERIPH) == DMA1_Channel2) || \ + ((PERIPH) == DMA1_Channel3) || \ + ((PERIPH) == DMA1_Channel4) || \ + ((PERIPH) == DMA1_Channel5) || \ + ((PERIPH) == DMA1_Channel6) || \ + ((PERIPH) == DMA1_Channel7) || \ + ((PERIPH) == DMA2_Channel1) || \ + ((PERIPH) == DMA2_Channel2) || \ + ((PERIPH) == DMA2_Channel3) || \ + ((PERIPH) == DMA2_Channel4) || \ + ((PERIPH) == DMA2_Channel5)) + +/** @defgroup DMA_data_transfer_direction + * @{ + */ + +#define DMA_DIR_PeripheralSRC ((uint32_t)0x00000000) +#define DMA_DIR_PeripheralDST DMA_CCR_DIR + +#define IS_DMA_DIR(DIR) (((DIR) == DMA_DIR_PeripheralSRC) || \ + ((DIR) == DMA_DIR_PeripheralDST)) +/** + * @} + */ + +/** @defgroup DMA_peripheral_incremented_mode + * @{ + */ + +#define DMA_PeripheralInc_Disable ((uint32_t)0x00000000) +#define DMA_PeripheralInc_Enable DMA_CCR_PINC + +#define IS_DMA_PERIPHERAL_INC_STATE(STATE) (((STATE) == DMA_PeripheralInc_Disable) || \ + ((STATE) == DMA_PeripheralInc_Enable)) +/** + * @} + */ + +/** @defgroup DMA_memory_incremented_mode + * @{ + */ + +#define DMA_MemoryInc_Disable ((uint32_t)0x00000000) +#define DMA_MemoryInc_Enable DMA_CCR_MINC + +#define IS_DMA_MEMORY_INC_STATE(STATE) (((STATE) == DMA_MemoryInc_Disable) || \ + ((STATE) == DMA_MemoryInc_Enable)) +/** + * @} + */ + +/** @defgroup DMA_peripheral_data_size + * @{ + */ + +#define DMA_PeripheralDataSize_Byte ((uint32_t)0x00000000) +#define DMA_PeripheralDataSize_HalfWord DMA_CCR_PSIZE_0 +#define DMA_PeripheralDataSize_Word DMA_CCR_PSIZE_1 + +#define IS_DMA_PERIPHERAL_DATA_SIZE(SIZE) (((SIZE) == DMA_PeripheralDataSize_Byte) || \ + ((SIZE) == DMA_PeripheralDataSize_HalfWord) || \ + ((SIZE) == DMA_PeripheralDataSize_Word)) +/** + * @} + */ + +/** @defgroup DMA_memory_data_size + * @{ + */ + +#define DMA_MemoryDataSize_Byte ((uint32_t)0x00000000) +#define DMA_MemoryDataSize_HalfWord DMA_CCR_MSIZE_0 +#define DMA_MemoryDataSize_Word DMA_CCR_MSIZE_1 + +#define IS_DMA_MEMORY_DATA_SIZE(SIZE) (((SIZE) == DMA_MemoryDataSize_Byte) || \ + ((SIZE) == DMA_MemoryDataSize_HalfWord) || \ + ((SIZE) == DMA_MemoryDataSize_Word)) +/** + * @} + */ + +/** @defgroup DMA_circular_normal_mode + * @{ + */ + +#define DMA_Mode_Normal ((uint32_t)0x00000000) +#define DMA_Mode_Circular DMA_CCR_CIRC + +#define IS_DMA_MODE(MODE) (((MODE) == DMA_Mode_Normal) || ((MODE) == DMA_Mode_Circular)) +/** + * @} + */ + +/** @defgroup DMA_priority_level + * @{ + */ + +#define DMA_Priority_VeryHigh DMA_CCR_PL +#define DMA_Priority_High DMA_CCR_PL_1 +#define DMA_Priority_Medium DMA_CCR_PL_0 +#define DMA_Priority_Low ((uint32_t)0x00000000) + +#define IS_DMA_PRIORITY(PRIORITY) (((PRIORITY) == DMA_Priority_VeryHigh) || \ + ((PRIORITY) == DMA_Priority_High) || \ + ((PRIORITY) == DMA_Priority_Medium) || \ + ((PRIORITY) == DMA_Priority_Low)) +/** + * @} + */ + +/** @defgroup DMA_memory_to_memory + * @{ + */ + +#define DMA_M2M_Disable ((uint32_t)0x00000000) +#define DMA_M2M_Enable DMA_CCR_MEM2MEM + +#define IS_DMA_M2M_STATE(STATE) (((STATE) == DMA_M2M_Disable) || ((STATE) == DMA_M2M_Enable)) + +/** + * @} + */ + +/** @defgroup DMA_Remap_Config + * @{ + */ +#define DMAx_CHANNEL1_RMP 0x00000000 +#define DMAx_CHANNEL2_RMP 0x10000000 +#define DMAx_CHANNEL3_RMP 0x20000000 +#define DMAx_CHANNEL4_RMP 0x30000000 +#define DMAx_CHANNEL5_RMP 0x40000000 +#define DMAx_CHANNEL6_RMP 0x50000000 +#define DMAx_CHANNEL7_RMP 0x60000000 + + +#define IS_DMA_ALL_LIST(LIST) (((LIST) == DMA1) || \ + ((LIST) == DMA2)) + +/****************** DMA1 remap bit field definition********************/ +/* DMA1 - Channel 1 */ +#define DMA1_CH1_DEFAULT (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_DEFAULT) /*!< Default remap position for DMA1 */ +#define DMA1_CH1_ADC (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_CH1_ADC) /*!< Remap ADC on DMA1 Channel 1*/ +#define DMA1_CH1_TIM17_CH1 (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_CH1_TIM17_CH1) /*!< Remap TIM17 channel 1 on DMA1 channel 1 */ +#define DMA1_CH1_TIM17_UP (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_CH1_TIM17_UP) /*!< Remap TIM17 up on DMA1 channel 1 */ +#define DMA1_CH1_USART1_RX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_CH1_USART1_RX) /*!< Remap USART1 Rx on DMA1 channel 1 */ +#define DMA1_CH1_USART2_RX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_CH1_USART2_RX) /*!< Remap USART2 Rx on DMA1 channel 1 */ +#define DMA1_CH1_USART3_RX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_CH1_USART3_RX) /*!< Remap USART3 Rx on DMA1 channel 1 */ +#define DMA1_CH1_USART4_RX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_CH1_USART4_RX) /*!< Remap USART4 Rx on DMA1 channel 1 */ +#define DMA1_CH1_USART5_RX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_CH1_USART5_RX) /*!< Remap USART5 Rx on DMA1 channel 1 */ +#define DMA1_CH1_USART6_RX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_CH1_USART6_RX) /*!< Remap USART6 Rx on DMA1 channel 1 */ +#define DMA1_CH1_USART7_RX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_CH1_USART7_RX) /*!< Remap USART7 Rx on DMA1 channel 1 */ +#define DMA1_CH1_USART8_RX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR1_CH1_USART8_RX) /*!< Remap USART8 Rx on DMA1 channel 1 */ +/* DMA1 - Channel 2 */ +#define DMA1_CH2_DEFAULT (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_DEFAULT) /*!< Default remap position for DMA1 */ +#define DMA1_CH2_ADC (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_ADC) /*!< Remap ADC on DMA1 channel 2 */ +#define DMA1_CH2_I2C1_TX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_I2C1_TX) /*!< Remap I2C1 Tx on DMA1 channel 2 */ +#define DMA1_CH2_SPI1_RX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_SPI_1RX) /*!< Remap SPI1 Rx on DMA1 channel 2 */ +#define DMA1_CH2_TIM1_CH1 (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_TIM1_CH1) /*!< Remap TIM1 channel 1 on DMA1 channel 2 */ +#define DMA1_CH2_TIM17_CH1 (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_TIM17_CH1) /*!< Remap TIM17 channel 1 on DMA1 channel 2 */ +#define DMA1_CH2_TIM17_UP (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_TIM17_UP) /*!< Remap TIM17 up on DMA1 channel 2 */ +#define DMA1_CH2_USART1_TX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_USART1_TX) /*!< Remap USART1 Tx on DMA1 channel 2 */ +#define DMA1_CH2_USART2_TX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_USART2_TX) /*!< Remap USART2 Tx on DMA1 channel 2 */ +#define DMA1_CH2_USART3_TX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_USART3_TX) /*!< Remap USART3 Tx on DMA1 channel 2 */ +#define DMA1_CH2_USART4_TX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_USART4_TX) /*!< Remap USART4 Tx on DMA1 channel 2 */ +#define DMA1_CH2_USART5_TX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_USART5_TX) /*!< Remap USART5 Tx on DMA1 channel 2 */ +#define DMA1_CH2_USART6_TX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_USART6_TX) /*!< Remap USART6 Tx on DMA1 channel 2 */ +#define DMA1_CH2_USART7_TX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_USART7_TX) /*!< Remap USART7 Tx on DMA1 channel 2 */ +#define DMA1_CH2_USART8_TX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR1_CH2_USART8_TX) /*!< Remap USART8 Tx on DMA1 channel 2 */ +/* DMA1 - Channel 3 */ +#define DMA1_CH3_DEFAULT (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_DEFAULT) /*!< Default remap position for DMAx */ +#define DMA1_CH3_TIM6_UP (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_TIM6_UP) /*!< Remap TIM6 up on DMA1 channel 3 */ +#define DMA1_CH3_DAC_CH1 (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_DAC_CH1) /*!< Remap DAC Channel 1on DMA1 channel 3 */ +#define DMA1_CH3_I2C1_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_I2C1_RX) /*!< Remap I2C1 Rx on DMA1 channel 3 */ +#define DMA1_CH3_SPI1_TX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_SPI1_TX) /*!< Remap SPI1 Tx on DMA1 channel 3 */ +#define DMA1_CH3_TIM1_CH2 (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_TIM1_CH2) /*!< Remap TIM1 channel 2 on DMA1 channel 3 */ +#define DMA1_CH3_TIM2_CH2 (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_TIM2_CH2) /*!< Remap TIM2 channel 2 on DMA1 channel 3 */ +#define DMA1_CH3_TIM16_CH1 (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_TIM16_CH1) /*!< Remap TIM16 channel 1 on DMA1 channel 3 */ +#define DMA1_CH3_TIM16_UP (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_TIM16_UP) /*!< Remap TIM16 up on DMA1 channel 3 */ +#define DMA1_CH3_USART1_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_USART1_RX) /*!< Remap USART1 Rx on DMA1 channel 3 */ +#define DMA1_CH3_USART2_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_USART2_RX) /*!< Remap USART2 Rx on DMA1 channel 3 */ +#define DMA1_CH3_USART3_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_USART3_RX) /*!< Remap USART3 Rx on DMA1 channel 3 */ +#define DMA1_CH3_USART4_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_USART4_RX) /*!< Remap USART4 Rx on DMA1 channel 3 */ +#define DMA1_CH3_USART5_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_USART5_RX) /*!< Remap USART5 Rx on DMA1 channel 3 */ +#define DMA1_CH3_USART6_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_USART6_RX) /*!< Remap USART6 Rx on DMA1 channel 3 */ +#define DMA1_CH3_USART7_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_USART7_RX) /*!< Remap USART7 Rx on DMA1 channel 3 */ +#define DMA1_CH3_USART8_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR1_CH3_USART8_RX) /*!< Remap USART8 Rx on DMA1 channel 3 */ +/* DMA1 - Channel 4 */ +#define DMA1_CH4_DEFAULT (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_DEFAULT) /*!< Default remap position for DMA1 */ +#define DMA1_CH4_TIM7_UP (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_TIM7_UP) /*!< Remap TIM7 up on DMA1 channel 4 */ +#define DMA1_CH4_DAC_CH2 (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_DAC_CH2) /*!< Remap DAC Channel 2 on DMA1 channel 4 */ +#define DMA1_CH4_I2C2_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_I2C2_TX) /*!< Remap I2C2 Tx on DMA1 channel 4 */ +#define DMA1_CH4_SPI2_RX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_SPI2_RX) /*!< Remap SPI2 Rx on DMA1 channel 4 */ +#define DMA1_CH4_TIM2_CH4 (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_TIM2_CH4) /*!< Remap TIM2 channel 4 on DMA1 channel 4 */ +#define DMA1_CH4_TIM3_CH1 (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_TIM3_CH1) /*!< Remap TIM3 channel 1 on DMA1 channel 4 */ +#define DMA1_CH4_TIM3_TRIG (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_TIM3_TRIG) /*!< Remap TIM3 Trig on DMA1 channel 4 */ +#define DMA1_CH4_TIM16_CH1 (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_TIM16_CH1) /*!< Remap TIM16 channel 1 on DMA1 channel 4 */ +#define DMA1_CH4_TIM16_UP (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_TIM16_UP) /*!< Remap TIM16 up on DMA1 channel 4 */ +#define DMA1_CH4_USART1_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_USART1_TX) /*!< Remap USART1 Tx on DMA1 channel 4 */ +#define DMA1_CH4_USART2_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_USART2_TX) /*!< Remap USART2 Tx on DMA1 channel 4 */ +#define DMA1_CH4_USART3_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_USART3_TX) /*!< Remap USART3 Tx on DMA1 channel 4 */ +#define DMA1_CH4_USART4_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_USART4_TX) /*!< Remap USART4 Tx on DMA1 channel 4 */ +#define DMA1_CH4_USART5_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_USART5_TX) /*!< Remap USART5 Tx on DMA1 channel 4 */ +#define DMA1_CH4_USART6_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_USART6_TX) /*!< Remap USART6 Tx on DMA1 channel 4 */ +#define DMA1_CH4_USART7_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_USART7_TX) /*!< Remap USART7 Tx on DMA1 channel 4 */ +#define DMA1_CH4_USART8_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR1_CH4_USART8_TX) /*!< Remap USART8 Tx on DMA1 channel 4 */ +/* DMA1 - Channel 5 */ +#define DMA1_CH5_DEFAULT (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_DEFAULT) /*!< Default remap position for DMA1 */ +#define DMA1_CH5_I2C2_RX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_CH5_I2C2_RX) /*!< Remap I2C2 Rx on DMA1 channel 5 */ +#define DMA1_CH5_SPI2_TX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_CH5_SPI2_TX) /*!< Remap SPI1 Tx on DMA1 channel 5 */ +#define DMA1_CH5_TIM1_CH3 (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_CH5_TIM1_CH3) /*!< Remap TIM1 channel 3 on DMA1 channel 5 */ +#define DMA1_CH5_USART1_RX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_CH5_USART1_RX) /*!< Remap USART1 Rx on DMA1 channel 5 */ +#define DMA1_CH5_USART2_RX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_CH5_USART2_RX) /*!< Remap USART2 Rx on DMA1 channel 5 */ +#define DMA1_CH5_USART3_RX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_CH5_USART3_RX) /*!< Remap USART3 Rx on DMA1 channel 5 */ +#define DMA1_CH5_USART4_RX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_CH5_USART4_RX) /*!< Remap USART4 Rx on DMA1 channel 5 */ +#define DMA1_CH5_USART5_RX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_CH5_USART5_RX) /*!< Remap USART5 Rx on DMA1 channel 5 */ +#define DMA1_CH5_USART6_RX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_CH5_USART6_RX) /*!< Remap USART6 Rx on DMA1 channel 5 */ +#define DMA1_CH5_USART7_RX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_CH5_USART7_RX) /*!< Remap USART7 Rx on DMA1 channel 5 */ +#define DMA1_CH5_USART8_RX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR1_CH5_USART8_RX) /*!< Remap USART8 Rx on DMA1 channel 5 */ +/* DMA1 - Channel 6 */ +#define DMA1_CH6_DEFAULT (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_DEFAULT) /*!< Default remap position for DMA1 */ +#define DMA1_CH6_I2C1_TX (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_I2C1_TX) /*!< Remap I2C1 Tx on DMA1 channel 6 */ +#define DMA1_CH6_SPI2_RX (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_SPI2_RX) /*!< Remap SPI2 Rx on DMA1 channel 6 */ +#define DMA1_CH6_TIM1_CH1 (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_TIM1_CH1) /*!< Remap TIM1 channel 1 on DMA1 channel 6 */ +#define DMA1_CH6_TIM1_CH2 (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_TIM1_CH2) /*!< Remap TIM1 channel 2 on DMA1 channel 6 */ +#define DMA1_CH6_TIM1_CH3 (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_TIM1_CH3) /*!< Remap TIM1 channel 3 on DMA1 channel 6 */ +#define DMA1_CH6_TIM3_CH1 (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_TIM3_CH1) /*!< Remap TIM3 channel 1 on DMA1 channel 6 */ +#define DMA1_CH6_TIM3_TRIG (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_TIM3_TRIG) /*!< Remap TIM3 Trig on DMA1 channel 6 */ +#define DMA1_CH6_TIM16_CH1 (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_TIM16_CH1) /*!< Remap TIM16 channel 1 on DMA1 channel 6 */ +#define DMA1_CH6_TIM16_UP (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_TIM16_UP) /*!< Remap TIM16 up on DMA1 channel 6 */ +#define DMA1_CH6_USART1_RX (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_USART1_RX) /*!< Remap USART1 Rx on DMA1 channel 6 */ +#define DMA1_CH6_USART2_RX (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_USART2_RX) /*!< Remap USART2 Rx on DMA1 channel 6 */ +#define DMA1_CH6_USART3_RX (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_USART3_RX) /*!< Remap USART3 Rx on DMA1 channel 6 */ +#define DMA1_CH6_USART4_RX (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_USART4_RX) /*!< Remap USART4 Rx on DMA1 channel 6 */ +#define DMA1_CH6_USART5_RX (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_USART5_RX) /*!< Remap USART5 Rx on DMA1 channel 6 */ +#define DMA1_CH6_USART6_RX (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_USART6_RX) /*!< Remap USART6 Rx on DMA1 channel 6 */ +#define DMA1_CH6_USART7_RX (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_USART7_RX) /*!< Remap USART7 Rx on DMA1 channel 6 */ +#define DMA1_CH6_USART8_RX (uint32_t) (DMAx_CHANNEL6_RMP | DMA_RMPCR1_CH6_USART8_RX) /*!< Remap USART8 Rx on DMA1 channel 6 */ +/* DMA1 - Channel 7 */ +#define DMA1_CH7_DEFAULT (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_DEFAULT) /*!< Default remap position for DMA1 */ +#define DMA1_CH7_I2C1_RX (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_I2C1_RX) /*!< Remap I2C1 Rx on DMA1 channel 7 */ +#define DMA1_CH7_SPI2_TX (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_SPI2_TX) /*!< Remap SPI2 Tx on DMA1 channel 7 */ +#define DMA1_CH7_TIM2_CH2 (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_TIM2_CH2) /*!< Remap TIM2 channel 2 on DMA1 channel 7 */ +#define DMA1_CH7_TIM2_CH4 (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_TIM2_CH4) /*!< Remap TIM2 channel 4 on DMA1 channel 7 */ +#define DMA1_CH7_TIM17_CH1 (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_TIM17_CH1) /*!< Remap TIM17 channel 1 on DMA1 channel 7 */ +#define DMA1_CH7_TIM17_UP (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_TIM17_UP) /*!< Remap TIM17 up on DMA1 channel 7 */ +#define DMA1_CH7_USART1_TX (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_USART1_TX) /*!< Remap USART1 Tx on DMA1 channel 7 */ +#define DMA1_CH7_USART2_TX (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_USART2_TX) /*!< Remap USART2 Tx on DMA1 channel 7 */ +#define DMA1_CH7_USART3_TX (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_USART3_TX) /*!< Remap USART3 Tx on DMA1 channel 7 */ +#define DMA1_CH7_USART4_TX (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_USART4_TX) /*!< Remap USART4 Tx on DMA1 channel 7 */ +#define DMA1_CH7_USART5_TX (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_USART5_TX) /*!< Remap USART5 Tx on DMA1 channel 7 */ +#define DMA1_CH7_USART6_TX (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_USART6_TX) /*!< Remap USART6 Tx on DMA1 channel 7 */ +#define DMA1_CH7_USART7_TX (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_USART7_TX) /*!< Remap USART7 Tx on DMA1 channel 7 */ +#define DMA1_CH7_USART8_TX (uint32_t) (DMAx_CHANNEL7_RMP | DMA_RMPCR1_CH7_USART8_TX) /*!< Remap USART8 Tx on DMA1 channel 7 */ + +#define IS_DMA1_REMAP(REMAP) ((REMAP == DMA1_CH1_DEFAULT) ||\ + (REMAP == DMA1_CH1_ADC) ||\ + (REMAP == DMA1_CH1_TIM17_CH1) ||\ + (REMAP == DMA1_CH1_TIM17_UP) ||\ + (REMAP == DMA1_CH1_USART1_RX) ||\ + (REMAP == DMA1_CH1_USART2_RX) ||\ + (REMAP == DMA1_CH1_USART3_RX) ||\ + (REMAP == DMA1_CH1_USART4_RX) ||\ + (REMAP == DMA1_CH1_USART5_RX) ||\ + (REMAP == DMA1_CH1_USART6_RX) ||\ + (REMAP == DMA1_CH1_USART7_RX) ||\ + (REMAP == DMA1_CH1_USART8_RX) ||\ + (REMAP == DMA1_CH2_DEFAULT) ||\ + (REMAP == DMA1_CH2_ADC) ||\ + (REMAP == DMA1_CH2_I2C1_TX) ||\ + (REMAP == DMA1_CH2_SPI1_RX) ||\ + (REMAP == DMA1_CH2_TIM1_CH1) ||\ + (REMAP == DMA1_CH2_I2C1_TX) ||\ + (REMAP == DMA1_CH2_TIM17_CH1) ||\ + (REMAP == DMA1_CH2_TIM17_UP) ||\ + (REMAP == DMA1_CH2_USART1_TX) ||\ + (REMAP == DMA1_CH2_USART2_TX) ||\ + (REMAP == DMA1_CH2_USART3_TX) ||\ + (REMAP == DMA1_CH2_USART4_TX) ||\ + (REMAP == DMA1_CH2_USART5_TX) ||\ + (REMAP == DMA1_CH2_USART6_TX) ||\ + (REMAP == DMA1_CH2_USART7_TX) ||\ + (REMAP == DMA1_CH2_USART8_TX) ||\ + (REMAP == DMA1_CH3_DEFAULT) ||\ + (REMAP == DMA1_CH3_TIM6_UP) ||\ + (REMAP == DMA1_CH3_DAC_CH1) ||\ + (REMAP == DMA1_CH3_I2C1_RX) ||\ + (REMAP == DMA1_CH3_SPI1_TX) ||\ + (REMAP == DMA1_CH3_TIM1_CH2) ||\ + (REMAP == DMA1_CH3_TIM2_CH2) ||\ + (REMAP == DMA1_CH3_TIM16_CH1) ||\ + (REMAP == DMA1_CH3_TIM16_UP) ||\ + (REMAP == DMA1_CH3_USART1_RX) ||\ + (REMAP == DMA1_CH3_USART2_RX) ||\ + (REMAP == DMA1_CH3_USART3_RX) ||\ + (REMAP == DMA1_CH3_USART4_RX) ||\ + (REMAP == DMA1_CH3_USART5_RX) ||\ + (REMAP == DMA1_CH3_USART6_RX) ||\ + (REMAP == DMA1_CH3_USART7_RX) ||\ + (REMAP == DMA1_CH3_USART8_RX) ||\ + (REMAP == DMA1_CH4_DEFAULT) ||\ + (REMAP == DMA1_CH4_TIM7_UP) ||\ + (REMAP == DMA1_CH4_DAC_CH2) ||\ + (REMAP == DMA1_CH4_I2C2_TX) ||\ + (REMAP == DMA1_CH4_SPI2_RX) ||\ + (REMAP == DMA1_CH4_TIM2_CH4) ||\ + (REMAP == DMA1_CH4_TIM3_CH1) ||\ + (REMAP == DMA1_CH4_TIM3_TRIG) ||\ + (REMAP == DMA1_CH4_TIM16_CH1) ||\ + (REMAP == DMA1_CH4_TIM16_UP) ||\ + (REMAP == DMA1_CH4_USART1_TX) ||\ + (REMAP == DMA1_CH4_USART2_TX) ||\ + (REMAP == DMA1_CH4_USART3_TX) ||\ + (REMAP == DMA1_CH4_USART4_TX) ||\ + (REMAP == DMA1_CH4_USART5_TX) ||\ + (REMAP == DMA1_CH4_USART6_TX) ||\ + (REMAP == DMA1_CH4_USART7_TX) ||\ + (REMAP == DMA1_CH4_USART8_TX) ||\ + (REMAP == DMA1_CH5_DEFAULT) ||\ + (REMAP == DMA1_CH5_I2C2_RX) ||\ + (REMAP == DMA1_CH5_SPI2_TX) ||\ + (REMAP == DMA1_CH5_TIM1_CH3) ||\ + (REMAP == DMA1_CH5_USART1_RX) ||\ + (REMAP == DMA1_CH5_USART2_RX) ||\ + (REMAP == DMA1_CH5_USART3_RX) ||\ + (REMAP == DMA1_CH5_USART4_RX) ||\ + (REMAP == DMA1_CH5_USART5_RX) ||\ + (REMAP == DMA1_CH5_USART6_RX) ||\ + (REMAP == DMA1_CH5_USART7_RX) ||\ + (REMAP == DMA1_CH5_USART8_RX) ||\ + (REMAP == DMA1_CH6_DEFAULT) ||\ + (REMAP == DMA1_CH6_I2C1_TX) ||\ + (REMAP == DMA1_CH6_SPI2_RX) ||\ + (REMAP == DMA1_CH6_TIM1_CH1) ||\ + (REMAP == DMA1_CH6_TIM1_CH2) ||\ + (REMAP == DMA1_CH6_TIM1_CH3) ||\ + (REMAP == DMA1_CH6_TIM3_CH1) ||\ + (REMAP == DMA1_CH6_TIM3_TRIG) ||\ + (REMAP == DMA1_CH6_TIM16_CH1) ||\ + (REMAP == DMA1_CH6_TIM16_UP) ||\ + (REMAP == DMA1_CH6_USART1_RX) ||\ + (REMAP == DMA1_CH6_USART2_RX) ||\ + (REMAP == DMA1_CH6_USART3_RX) ||\ + (REMAP == DMA1_CH6_USART4_RX) ||\ + (REMAP == DMA1_CH6_USART5_RX) ||\ + (REMAP == DMA1_CH6_USART6_RX) ||\ + (REMAP == DMA1_CH6_USART7_RX) ||\ + (REMAP == DMA1_CH6_USART8_RX) ||\ + (REMAP == DMA1_CH7_DEFAULT) ||\ + (REMAP == DMA1_CH7_I2C1_RX) ||\ + (REMAP == DMA1_CH7_SPI2_TX) ||\ + (REMAP == DMA1_CH7_TIM2_CH2) ||\ + (REMAP == DMA1_CH7_TIM2_CH4) ||\ + (REMAP == DMA1_CH7_TIM17_CH1) ||\ + (REMAP == DMA1_CH7_TIM17_UP) ||\ + (REMAP == DMA1_CH7_USART1_TX) ||\ + (REMAP == DMA1_CH7_USART2_TX) ||\ + (REMAP == DMA1_CH7_USART3_TX) ||\ + (REMAP == DMA1_CH7_USART4_TX) ||\ + (REMAP == DMA1_CH7_USART5_TX) ||\ + (REMAP == DMA1_CH7_USART6_TX) ||\ + (REMAP == DMA1_CH7_USART7_TX) ||\ + (REMAP == DMA1_CH7_USART8_TX)) + +/****************** DMA2 remap bit field definition********************/ +/* DMA2 - Channel 1 */ +#define DMA2_CH1_DEFAULT (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR2_DEFAULT) /*!< Default remap position for DMA2 */ +#define DMA2_CH1_I2C2_TX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR2_CH1_I2C2_TX) /*!< Remap I2C2 TX on DMA2 channel 1 */ +#define DMA2_CH1_USART1_TX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR2_CH1_USART1_TX) /*!< Remap USART1 Tx on DMA2 channel 1 */ +#define DMA2_CH1_USART2_TX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR2_CH1_USART2_TX) /*!< Remap USART2 Tx on DMA2 channel 1 */ +#define DMA2_CH1_USART3_TX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR2_CH1_USART3_TX) /*!< Remap USART3 Tx on DMA2 channel 1 */ +#define DMA2_CH1_USART4_TX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR2_CH1_USART4_TX) /*!< Remap USART4 Tx on DMA2 channel 1 */ +#define DMA2_CH1_USART5_TX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR2_CH1_USART5_TX) /*!< Remap USART5 Tx on DMA2 channel 1 */ +#define DMA2_CH1_USART6_TX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR2_CH1_USART6_TX) /*!< Remap USART6 Tx on DMA2 channel 1 */ +#define DMA2_CH1_USART7_TX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR2_CH1_USART7_TX) /*!< Remap USART7 Tx on DMA2 channel 1 */ +#define DMA2_CH1_USART8_TX (uint32_t) (DMAx_CHANNEL1_RMP | DMA_RMPCR2_CH1_USART8_TX) /*!< Remap USART8 Tx on DMA2 channel 1 */ +/* DMA2 - Channel 2 */ +#define DMA2_CH2_DEFAULT (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR2_DEFAULT) /*!< Default remap position for DMA2 */ +#define DMA2_CH2_I2C2_RX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR2_CH2_I2C2_RX) /*!< Remap I2C2 Rx on DMA2 channel 2 */ +#define DMA2_CH2_USART1_RX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR2_CH2_USART1_RX) /*!< Remap USART1 Rx on DMA2 channel 2 */ +#define DMA2_CH2_USART2_RX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR2_CH2_USART2_RX) /*!< Remap USART2 Rx on DMA2 channel 2 */ +#define DMA2_CH2_USART3_RX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR2_CH2_USART3_RX) /*!< Remap USART3 Rx on DMA2 channel 2 */ +#define DMA2_CH2_USART4_RX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR2_CH2_USART4_RX) /*!< Remap USART4 Rx on DMA2 channel 2 */ +#define DMA2_CH2_USART5_RX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR2_CH2_USART5_RX) /*!< Remap USART5 Rx on DMA2 channel 2 */ +#define DMA2_CH2_USART6_RX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR2_CH2_USART6_RX) /*!< Remap USART6 Rx on DMA2 channel 2 */ +#define DMA2_CH2_USART7_RX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR2_CH2_USART7_RX) /*!< Remap USART7 Rx on DMA2 channel 2 */ +#define DMA2_CH2_USART8_RX (uint32_t) (DMAx_CHANNEL2_RMP | DMA_RMPCR2_CH2_USART8_RX) /*!< Remap USART8 Rx on DMA2 channel 2 */ +/* DMA2 - Channel 3 */ +#define DMA2_CH3_DEFAULT (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_DEFAULT) /*!< Default remap position for DMA2 */ +#define DMA2_CH3_TIM6_UP (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_CH3_TIM6_UP) /*!< Remap TIM6 up on DMA2 channel 3 */ +#define DMA2_CH3_DAC_CH1 (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_CH3_DAC_CH1) /*!< Remap DAC channel 1 on DMA2 channel 3 */ +#define DMA2_CH3_SPI1_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_CH3_SPI1_RX) /*!< Remap SPI1 Rx on DMA2 channel 3 */ +#define DMA2_CH3_USART1_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_CH3_USART1_RX) /*!< Remap USART1 Rx on DMA2 channel 3 */ +#define DMA2_CH3_USART2_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_CH3_USART2_RX) /*!< Remap USART2 Rx on DMA2 channel 3 */ +#define DMA2_CH3_USART3_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_CH3_USART3_RX) /*!< Remap USART3 Rx on DMA2 channel 3 */ +#define DMA2_CH3_USART4_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_CH3_USART4_RX) /*!< Remap USART4 Rx on DMA2 channel 3 */ +#define DMA2_CH3_USART5_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_CH3_USART5_RX) /*!< Remap USART5 Rx on DMA2 channel 3 */ +#define DMA2_CH3_USART6_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_CH3_USART6_RX) /*!< Remap USART6 Rx on DMA2 channel 3 */ +#define DMA2_CH3_USART7_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_CH3_USART7_RX) /*!< Remap USART7 Rx on DMA2 channel 3 */ +#define DMA2_CH3_USART8_RX (uint32_t) (DMAx_CHANNEL3_RMP | DMA_RMPCR2_CH3_USART8_RX) /*!< Remap USART8 Rx on DMA2 channel 3 */ +/* DMA2 - Channel 4 */ +#define DMA2_CH4_DEFAULT (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_DEFAULT) /*!< Default remap position for DMA2 */ +#define DMA2_CH4_TIM7_UP (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_CH4_TIM7_UP) /*!< Remap TIM7 up on DMA2 channel 4 */ +#define DMA2_CH4_DAC_CH2 (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_CH4_DAC_CH2) /*!< Remap DAC channel 2 on DMA2 channel 4 */ +#define DMA2_CH4_SPI1_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_CH4_SPI1_TX) /*!< Remap SPI1 Tx on DMA2 channel 4 */ +#define DMA2_CH4_USART1_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_CH4_USART1_TX) /*!< Remap USART1 Tx on DMA2 channel 4 */ +#define DMA2_CH4_USART2_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_CH4_USART2_TX) /*!< Remap USART2 Tx on DMA2 channel 4 */ +#define DMA2_CH4_USART3_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_CH4_USART3_TX) /*!< Remap USART3 Tx on DMA2 channel 4 */ +#define DMA2_CH4_USART4_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_CH4_USART4_TX) /*!< Remap USART4 Tx on DMA2 channel 4 */ +#define DMA2_CH4_USART5_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_CH4_USART5_TX) /*!< Remap USART5 Tx on DMA2 channel 4 */ +#define DMA2_CH4_USART6_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_CH4_USART6_TX) /*!< Remap USART6 Tx on DMA2 channel 4 */ +#define DMA2_CH4_USART7_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_CH4_USART7_TX) /*!< Remap USART7 Tx on DMA2 channel 4 */ +#define DMA2_CH4_USART8_TX (uint32_t) (DMAx_CHANNEL4_RMP | DMA_RMPCR2_CH4_USART8_TX) /*!< Remap USART8 Tx on DMA2 channel 4 */ +/* DMA2 - Channel 5 */ +#define DMA2_CH5_DEFAULT (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR2_DEFAULT) /*!< Default remap position for DMA2 */ +#define DMA2_CH5_ADC (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR2_CH5_ADC) /*!< Remap ADC on DMA2 channel 5 */ +#define DMA2_CH5_USART1_TX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR2_CH5_USART1_TX) /*!< Remap USART1 Tx on DMA2 channel 5 */ +#define DMA2_CH5_USART2_TX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR2_CH5_USART2_TX) /*!< Remap USART2 Tx on DMA2 channel 5 */ +#define DMA2_CH5_USART3_TX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR2_CH5_USART3_TX) /*!< Remap USART3 Tx on DMA2 channel 5 */ +#define DMA2_CH5_USART4_TX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR2_CH5_USART4_TX) /*!< Remap USART4 Tx on DMA2 channel 5 */ +#define DMA2_CH5_USART5_TX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR2_CH5_USART5_TX) /*!< Remap USART5 Tx on DMA2 channel 5 */ +#define DMA2_CH5_USART6_TX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR2_CH5_USART6_TX) /*!< Remap USART6 Tx on DMA2 channel 5 */ +#define DMA2_CH5_USART7_TX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR2_CH5_USART7_TX) /*!< Remap USART7 Tx on DMA2 channel 5 */ +#define DMA2_CH5_USART8_TX (uint32_t) (DMAx_CHANNEL5_RMP | DMA_RMPCR2_CH5_USART8_TX) /*!< Remap USART8 Tx on DMA2 channel 5 */ + +#define IS_DMA2_REMAP(REMAP) ((REMAP == DMA2_CH1_DEFAULT) ||\ + (REMAP == DMA2_CH1_I2C2_TX) ||\ + (REMAP == DMA2_CH1_USART1_TX) ||\ + (REMAP == DMA2_CH1_USART2_TX) ||\ + (REMAP == DMA2_CH1_USART3_TX) ||\ + (REMAP == DMA2_CH1_USART4_TX) ||\ + (REMAP == DMA2_CH1_USART5_TX) ||\ + (REMAP == DMA2_CH1_USART6_TX) ||\ + (REMAP == DMA2_CH1_USART7_TX) ||\ + (REMAP == DMA2_CH1_USART8_TX) ||\ + (REMAP == DMA2_CH2_DEFAULT) ||\ + (REMAP == DMA2_CH2_I2C2_RX) ||\ + (REMAP == DMA2_CH2_USART1_RX) ||\ + (REMAP == DMA2_CH2_USART2_RX) ||\ + (REMAP == DMA2_CH2_USART3_RX) ||\ + (REMAP == DMA2_CH2_USART4_RX) ||\ + (REMAP == DMA2_CH2_USART5_RX) ||\ + (REMAP == DMA2_CH2_USART6_RX) ||\ + (REMAP == DMA2_CH2_USART7_RX) ||\ + (REMAP == DMA2_CH2_USART8_RX) ||\ + (REMAP == DMA2_CH3_DEFAULT) ||\ + (REMAP == DMA2_CH3_TIM6_UP) ||\ + (REMAP == DMA2_CH3_DAC_CH1) ||\ + (REMAP == DMA2_CH3_SPI1_RX) ||\ + (REMAP == DMA2_CH3_USART1_RX) ||\ + (REMAP == DMA2_CH3_USART2_RX) ||\ + (REMAP == DMA2_CH3_USART3_RX) ||\ + (REMAP == DMA2_CH3_USART4_RX) ||\ + (REMAP == DMA2_CH3_USART5_RX) ||\ + (REMAP == DMA2_CH3_USART6_RX) ||\ + (REMAP == DMA2_CH3_USART7_RX) ||\ + (REMAP == DMA2_CH3_USART8_RX) ||\ + (REMAP == DMA2_CH4_DEFAULT) ||\ + (REMAP == DMA2_CH4_TIM7_UP) ||\ + (REMAP == DMA2_CH4_DAC_CH2) ||\ + (REMAP == DMA2_CH4_SPI1_TX) ||\ + (REMAP == DMA2_CH4_USART1_TX) ||\ + (REMAP == DMA2_CH4_USART2_TX) ||\ + (REMAP == DMA2_CH4_USART3_TX) ||\ + (REMAP == DMA2_CH4_USART4_TX) ||\ + (REMAP == DMA2_CH4_USART5_TX) ||\ + (REMAP == DMA2_CH4_USART6_TX) ||\ + (REMAP == DMA2_CH4_USART7_TX) ||\ + (REMAP == DMA2_CH4_USART8_TX) ||\ + (REMAP == DMA2_CH5_DEFAULT) ||\ + (REMAP == DMA2_CH5_ADC) ||\ + (REMAP == DMA2_CH5_USART1_TX) ||\ + (REMAP == DMA2_CH5_USART2_TX) ||\ + (REMAP == DMA2_CH5_USART3_TX) ||\ + (REMAP == DMA2_CH5_USART4_TX) ||\ + (REMAP == DMA2_CH5_USART5_TX) ||\ + (REMAP == DMA2_CH5_USART6_TX) ||\ + (REMAP == DMA2_CH5_USART7_TX) ||\ + (REMAP == DMA2_CH5_USART8_TX )) + +/** + * @} + */ + +/** @defgroup DMA_interrupts_definition + * @{ + */ + +#define DMA_IT_TC DMA_CCR_TCIE +#define DMA_IT_HT DMA_CCR_HTIE +#define DMA_IT_TE DMA_CCR_TEIE + +#define IS_DMA_CONFIG_IT(IT) ((((IT) & 0xFFFFFFF1) == 0x00) && ((IT) != 0x00)) + +#define DMA1_IT_GL1 DMA_ISR_GIF1 +#define DMA1_IT_TC1 DMA_ISR_TCIF1 +#define DMA1_IT_HT1 DMA_ISR_HTIF1 +#define DMA1_IT_TE1 DMA_ISR_TEIF1 +#define DMA1_IT_GL2 DMA_ISR_GIF2 +#define DMA1_IT_TC2 DMA_ISR_TCIF2 +#define DMA1_IT_HT2 DMA_ISR_HTIF2 +#define DMA1_IT_TE2 DMA_ISR_TEIF2 +#define DMA1_IT_GL3 DMA_ISR_GIF3 +#define DMA1_IT_TC3 DMA_ISR_TCIF3 +#define DMA1_IT_HT3 DMA_ISR_HTIF3 +#define DMA1_IT_TE3 DMA_ISR_TEIF3 +#define DMA1_IT_GL4 DMA_ISR_GIF4 +#define DMA1_IT_TC4 DMA_ISR_TCIF4 +#define DMA1_IT_HT4 DMA_ISR_HTIF4 +#define DMA1_IT_TE4 DMA_ISR_TEIF4 +#define DMA1_IT_GL5 DMA_ISR_GIF5 +#define DMA1_IT_TC5 DMA_ISR_TCIF5 +#define DMA1_IT_HT5 DMA_ISR_HTIF5 +#define DMA1_IT_TE5 DMA_ISR_TEIF5 +#define DMA1_IT_GL6 DMA_ISR_GIF6 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_IT_TC6 DMA_ISR_TCIF6 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_IT_HT6 DMA_ISR_HTIF6 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_IT_TE6 DMA_ISR_TEIF6 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_IT_GL7 DMA_ISR_GIF7 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_IT_TC7 DMA_ISR_TCIF7 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_IT_HT7 DMA_ISR_HTIF7 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_IT_TE7 DMA_ISR_TEIF7 /*!< Only applicable for STM32F072 and STM32F091 devices */ + +#define DMA2_IT_GL1 ((uint32_t)0x10000001) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_TC1 ((uint32_t)0x10000002) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_HT1 ((uint32_t)0x10000004) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_TE1 ((uint32_t)0x10000008) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_GL2 ((uint32_t)0x10000010) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_TC2 ((uint32_t)0x10000020) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_HT2 ((uint32_t)0x10000040) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_TE2 ((uint32_t)0x10000080) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_GL3 ((uint32_t)0x10000100) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_TC3 ((uint32_t)0x10000200) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_HT3 ((uint32_t)0x10000400) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_TE3 ((uint32_t)0x10000800) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_GL4 ((uint32_t)0x10001000) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_TC4 ((uint32_t)0x10002000) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_HT4 ((uint32_t)0x10004000) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_TE4 ((uint32_t)0x10008000) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_GL5 ((uint32_t)0x10010000) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_TC5 ((uint32_t)0x10020000) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_HT5 ((uint32_t)0x10040000) /*!< Only applicable for STM32F091 devices */ +#define DMA2_IT_TE5 ((uint32_t)0x10080000) /*!< Only applicable for STM32F091 devices */ + +#define IS_DMA_CLEAR_IT(IT) (((((IT) & 0xF0000000) == 0x00) || (((IT) & 0xEFF00000) == 0x00)) && ((IT) != 0x00)) + +#define IS_DMA_GET_IT(IT) (((IT) == DMA1_IT_GL1) || ((IT) == DMA1_IT_TC1) || \ + ((IT) == DMA1_IT_HT1) || ((IT) == DMA1_IT_TE1) || \ + ((IT) == DMA1_IT_GL2) || ((IT) == DMA1_IT_TC2) || \ + ((IT) == DMA1_IT_HT2) || ((IT) == DMA1_IT_TE2) || \ + ((IT) == DMA1_IT_GL3) || ((IT) == DMA1_IT_TC3) || \ + ((IT) == DMA1_IT_HT3) || ((IT) == DMA1_IT_TE3) || \ + ((IT) == DMA1_IT_GL4) || ((IT) == DMA1_IT_TC4) || \ + ((IT) == DMA1_IT_HT4) || ((IT) == DMA1_IT_TE4) || \ + ((IT) == DMA1_IT_GL5) || ((IT) == DMA1_IT_TC5) || \ + ((IT) == DMA1_IT_HT5) || ((IT) == DMA1_IT_TE5) || \ + ((IT) == DMA1_IT_GL6) || ((IT) == DMA1_IT_TC6) || \ + ((IT) == DMA1_IT_HT6) || ((IT) == DMA1_IT_TE6) || \ + ((IT) == DMA1_IT_GL7) || ((IT) == DMA1_IT_TC7) || \ + ((IT) == DMA1_IT_HT7) || ((IT) == DMA1_IT_TE7) || \ + ((IT) == DMA2_IT_GL1) || ((IT) == DMA2_IT_TC1) || \ + ((IT) == DMA2_IT_HT1) || ((IT) == DMA2_IT_TE1) || \ + ((IT) == DMA2_IT_GL2) || ((IT) == DMA2_IT_TC2) || \ + ((IT) == DMA2_IT_HT2) || ((IT) == DMA2_IT_TE2) || \ + ((IT) == DMA2_IT_GL3) || ((IT) == DMA2_IT_TC3) || \ + ((IT) == DMA2_IT_HT3) || ((IT) == DMA2_IT_TE3) || \ + ((IT) == DMA2_IT_GL4) || ((IT) == DMA2_IT_TC4) || \ + ((IT) == DMA2_IT_HT4) || ((IT) == DMA2_IT_TE4) || \ + ((IT) == DMA2_IT_GL5) || ((IT) == DMA2_IT_TC5) || \ + ((IT) == DMA2_IT_HT5) || ((IT) == DMA2_IT_TE5)) + +/** + * @} + */ + +/** @defgroup DMA_flags_definition + * @{ + */ +#define DMA1_FLAG_GL1 DMA_ISR_GIF1 +#define DMA1_FLAG_TC1 DMA_ISR_TCIF1 +#define DMA1_FLAG_HT1 DMA_ISR_HTIF1 +#define DMA1_FLAG_TE1 DMA_ISR_TEIF1 +#define DMA1_FLAG_GL2 DMA_ISR_GIF2 +#define DMA1_FLAG_TC2 DMA_ISR_TCIF2 +#define DMA1_FLAG_HT2 DMA_ISR_HTIF2 +#define DMA1_FLAG_TE2 DMA_ISR_TEIF2 +#define DMA1_FLAG_GL3 DMA_ISR_GIF3 +#define DMA1_FLAG_TC3 DMA_ISR_TCIF3 +#define DMA1_FLAG_HT3 DMA_ISR_HTIF3 +#define DMA1_FLAG_TE3 DMA_ISR_TEIF3 +#define DMA1_FLAG_GL4 DMA_ISR_GIF4 +#define DMA1_FLAG_TC4 DMA_ISR_TCIF4 +#define DMA1_FLAG_HT4 DMA_ISR_HTIF4 +#define DMA1_FLAG_TE4 DMA_ISR_TEIF4 +#define DMA1_FLAG_GL5 DMA_ISR_GIF5 +#define DMA1_FLAG_TC5 DMA_ISR_TCIF5 +#define DMA1_FLAG_HT5 DMA_ISR_HTIF5 +#define DMA1_FLAG_TE5 DMA_ISR_TEIF5 +#define DMA1_FLAG_GL6 DMA_ISR_GIF6 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_FLAG_TC6 DMA_ISR_TCIF6 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_FLAG_HT6 DMA_ISR_HTIF6 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_FLAG_TE6 DMA_ISR_TEIF6 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_FLAG_GL7 DMA_ISR_GIF7 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_FLAG_TC7 DMA_ISR_TCIF7 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_FLAG_HT7 DMA_ISR_HTIF7 /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_FLAG_TE7 DMA_ISR_TEIF7 /*!< Only applicable for STM32F072 and STM32F091 devices */ + +#define DMA2_FLAG_GL1 ((uint32_t)0x10000001) +#define DMA2_FLAG_TC1 ((uint32_t)0x10000002) +#define DMA2_FLAG_HT1 ((uint32_t)0x10000004) +#define DMA2_FLAG_TE1 ((uint32_t)0x10000008) +#define DMA2_FLAG_GL2 ((uint32_t)0x10000010) +#define DMA2_FLAG_TC2 ((uint32_t)0x10000020) +#define DMA2_FLAG_HT2 ((uint32_t)0x10000040) +#define DMA2_FLAG_TE2 ((uint32_t)0x10000080) +#define DMA2_FLAG_GL3 ((uint32_t)0x10000100) +#define DMA2_FLAG_TC3 ((uint32_t)0x10000200) +#define DMA2_FLAG_HT3 ((uint32_t)0x10000400) +#define DMA2_FLAG_TE3 ((uint32_t)0x10000800) +#define DMA2_FLAG_GL4 ((uint32_t)0x10001000) +#define DMA2_FLAG_TC4 ((uint32_t)0x10002000) +#define DMA2_FLAG_HT4 ((uint32_t)0x10004000) +#define DMA2_FLAG_TE4 ((uint32_t)0x10008000) +#define DMA2_FLAG_GL5 ((uint32_t)0x10010000) +#define DMA2_FLAG_TC5 ((uint32_t)0x10020000) +#define DMA2_FLAG_HT5 ((uint32_t)0x10040000) +#define DMA2_FLAG_TE5 ((uint32_t)0x10080000) + +#define IS_DMA_CLEAR_FLAG(FLAG) (((((FLAG) & 0xF0000000) == 0x00) || (((FLAG) & 0xEFF00000) == 0x00)) && ((FLAG) != 0x00)) + +#define IS_DMA_GET_FLAG(FLAG) (((FLAG) == DMA1_FLAG_GL1) || ((FLAG) == DMA1_FLAG_TC1) || \ + ((FLAG) == DMA1_FLAG_HT1) || ((FLAG) == DMA1_FLAG_TE1) || \ + ((FLAG) == DMA1_FLAG_GL2) || ((FLAG) == DMA1_FLAG_TC2) || \ + ((FLAG) == DMA1_FLAG_HT2) || ((FLAG) == DMA1_FLAG_TE2) || \ + ((FLAG) == DMA1_FLAG_GL3) || ((FLAG) == DMA1_FLAG_TC3) || \ + ((FLAG) == DMA1_FLAG_HT3) || ((FLAG) == DMA1_FLAG_TE3) || \ + ((FLAG) == DMA1_FLAG_GL4) || ((FLAG) == DMA1_FLAG_TC4) || \ + ((FLAG) == DMA1_FLAG_HT4) || ((FLAG) == DMA1_FLAG_TE4) || \ + ((FLAG) == DMA1_FLAG_GL5) || ((FLAG) == DMA1_FLAG_TC5) || \ + ((FLAG) == DMA1_FLAG_HT5) || ((FLAG) == DMA1_FLAG_TE5) || \ + ((FLAG) == DMA1_FLAG_GL6) || ((FLAG) == DMA1_FLAG_TC6) || \ + ((FLAG) == DMA1_FLAG_HT6) || ((FLAG) == DMA1_FLAG_TE6) || \ + ((FLAG) == DMA1_FLAG_GL7) || ((FLAG) == DMA1_FLAG_TC7) || \ + ((FLAG) == DMA1_FLAG_HT7) || ((FLAG) == DMA1_FLAG_TE7) || \ + ((FLAG) == DMA2_FLAG_GL1) || ((FLAG) == DMA2_FLAG_TC1) || \ + ((FLAG) == DMA2_FLAG_HT1) || ((FLAG) == DMA2_FLAG_TE1) || \ + ((FLAG) == DMA2_FLAG_GL2) || ((FLAG) == DMA2_FLAG_TC2) || \ + ((FLAG) == DMA2_FLAG_HT2) || ((FLAG) == DMA2_FLAG_TE2) || \ + ((FLAG) == DMA2_FLAG_GL3) || ((FLAG) == DMA2_FLAG_TC3) || \ + ((FLAG) == DMA2_FLAG_HT3) || ((FLAG) == DMA2_FLAG_TE3) || \ + ((FLAG) == DMA2_FLAG_GL4) || ((FLAG) == DMA2_FLAG_TC4) || \ + ((FLAG) == DMA2_FLAG_HT4) || ((FLAG) == DMA2_FLAG_TE4) || \ + ((FLAG) == DMA2_FLAG_GL5) || ((FLAG) == DMA2_FLAG_TC5) || \ + ((FLAG) == DMA2_FLAG_HT5) || ((FLAG) == DMA2_FLAG_TE5)) +/** + * @} + */ + +/** @defgroup DMA_Buffer_Size + * @{ + */ + +#define IS_DMA_BUFFER_SIZE(SIZE) (((SIZE) >= 0x1) && ((SIZE) < 0x10000)) + +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Function used to set the DMA configuration to the default reset state ******/ +void DMA_DeInit(DMA_Channel_TypeDef* DMAy_Channelx); + +/* Initialization and Configuration functions *********************************/ +void DMA_Init(DMA_Channel_TypeDef* DMAy_Channelx, DMA_InitTypeDef* DMA_InitStruct); +void DMA_StructInit(DMA_InitTypeDef* DMA_InitStruct); +void DMA_Cmd(DMA_Channel_TypeDef* DMAy_Channelx, FunctionalState NewState); +void DMA_RemapConfig(DMA_TypeDef* DMAy, uint32_t DMAx_CHy_RemapRequest); + +/* Data Counter functions******************************************************/ +void DMA_SetCurrDataCounter(DMA_Channel_TypeDef* DMAy_Channelx, uint16_t DataNumber); +uint16_t DMA_GetCurrDataCounter(DMA_Channel_TypeDef* DMAy_Channelx); + +/* Interrupts and flags management functions **********************************/ +void DMA_ITConfig(DMA_Channel_TypeDef* DMAy_Channelx, uint32_t DMA_IT, FunctionalState NewState); +FlagStatus DMA_GetFlagStatus(uint32_t DMAy_FLAG); +void DMA_ClearFlag(uint32_t DMAy_FLAG); +ITStatus DMA_GetITStatus(uint32_t DMAy_IT); +void DMA_ClearITPendingBit(uint32_t DMAy_IT); + +#ifdef __cplusplus +} +#endif + +#endif /*__STM32F0XX_DMA_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_exti.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_exti.h new file mode 100644 index 00000000..4db573ce --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_exti.h @@ -0,0 +1,216 @@ +/** + ****************************************************************************** + * @file stm32f0xx_exti.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the EXTI + * firmware library + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_EXTI_H +#define __STM32F0XX_EXTI_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup EXTI + * @{ + */ +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief EXTI mode enumeration + */ + +typedef enum +{ + EXTI_Mode_Interrupt = 0x00, + EXTI_Mode_Event = 0x04 +}EXTIMode_TypeDef; + +#define IS_EXTI_MODE(MODE) (((MODE) == EXTI_Mode_Interrupt) || ((MODE) == EXTI_Mode_Event)) + +/** + * @brief EXTI Trigger enumeration + */ + +typedef enum +{ + EXTI_Trigger_Rising = 0x08, + EXTI_Trigger_Falling = 0x0C, + EXTI_Trigger_Rising_Falling = 0x10 +}EXTITrigger_TypeDef; + +#define IS_EXTI_TRIGGER(TRIGGER) (((TRIGGER) == EXTI_Trigger_Rising) || \ + ((TRIGGER) == EXTI_Trigger_Falling) || \ + ((TRIGGER) == EXTI_Trigger_Rising_Falling)) +/** + * @brief EXTI Init Structure definition + */ + +typedef struct +{ + uint32_t EXTI_Line; /*!< Specifies the EXTI lines to be enabled or disabled. + This parameter can be any combination of @ref EXTI_Lines */ + + EXTIMode_TypeDef EXTI_Mode; /*!< Specifies the mode for the EXTI lines. + This parameter can be a value of @ref EXTIMode_TypeDef */ + + EXTITrigger_TypeDef EXTI_Trigger; /*!< Specifies the trigger signal active edge for the EXTI lines. + This parameter can be a value of @ref EXTIMode_TypeDef */ + + FunctionalState EXTI_LineCmd; /*!< Specifies the new state of the selected EXTI lines. + This parameter can be set either to ENABLE or DISABLE */ +}EXTI_InitTypeDef; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup EXTI_Exported_Constants + * @{ + */ +/** @defgroup EXTI_Lines + * @{ + */ + +#define EXTI_Line0 ((uint32_t)0x00000001) /*!< External interrupt line 0 */ +#define EXTI_Line1 ((uint32_t)0x00000002) /*!< External interrupt line 1 */ +#define EXTI_Line2 ((uint32_t)0x00000004) /*!< External interrupt line 2 */ +#define EXTI_Line3 ((uint32_t)0x00000008) /*!< External interrupt line 3 */ +#define EXTI_Line4 ((uint32_t)0x00000010) /*!< External interrupt line 4 */ +#define EXTI_Line5 ((uint32_t)0x00000020) /*!< External interrupt line 5 */ +#define EXTI_Line6 ((uint32_t)0x00000040) /*!< External interrupt line 6 */ +#define EXTI_Line7 ((uint32_t)0x00000080) /*!< External interrupt line 7 */ +#define EXTI_Line8 ((uint32_t)0x00000100) /*!< External interrupt line 8 */ +#define EXTI_Line9 ((uint32_t)0x00000200) /*!< External interrupt line 9 */ +#define EXTI_Line10 ((uint32_t)0x00000400) /*!< External interrupt line 10 */ +#define EXTI_Line11 ((uint32_t)0x00000800) /*!< External interrupt line 11 */ +#define EXTI_Line12 ((uint32_t)0x00001000) /*!< External interrupt line 12 */ +#define EXTI_Line13 ((uint32_t)0x00002000) /*!< External interrupt line 13 */ +#define EXTI_Line14 ((uint32_t)0x00004000) /*!< External interrupt line 14 */ +#define EXTI_Line15 ((uint32_t)0x00008000) /*!< External interrupt line 15 */ +#define EXTI_Line16 ((uint32_t)0x00010000) /*!< External interrupt line 16 + Connected to the PVD Output, + not applicable for STM32F030 devices */ +#define EXTI_Line17 ((uint32_t)0x00020000) /*!< Internal interrupt line 17 + Connected to the RTC Alarm + event */ +#define EXTI_Line18 ((uint32_t)0x00040000) /*!< Internal interrupt line 18 + Connected to the USB + event, only applicable for + STM32F072 devices */ +#define EXTI_Line19 ((uint32_t)0x00080000) /*!< Internal interrupt line 19 + Connected to the RTC Tamper + and Time Stamp events */ +#define EXTI_Line20 ((uint32_t)0x00100000) /*!< Internal interrupt line 20 + Connected to the RTC wakeup + event, only applicable for + STM32F072 devices */ +#define EXTI_Line21 ((uint32_t)0x00200000) /*!< Internal interrupt line 21 + Connected to the Comparator 1 + event, only applicable for STM32F051 + ans STM32F072 devices */ +#define EXTI_Line22 ((uint32_t)0x00400000) /*!< Internal interrupt line 22 + Connected to the Comparator 2 + event, only applicable for STM32F051 + and STM32F072 devices */ +#define EXTI_Line23 ((uint32_t)0x00800000) /*!< Internal interrupt line 23 + Connected to the I2C1 wakeup + event, not applicable for STM32F030 devices */ +#define EXTI_Line25 ((uint32_t)0x02000000) /*!< Internal interrupt line 25 + Connected to the USART1 wakeup + event, not applicable for STM32F030 devices */ +#define EXTI_Line26 ((uint32_t)0x04000000) /*!< Internal interrupt line 26 + Connected to the USART2 wakeup + event, applicable only for + STM32F072 devices */ +#define EXTI_Line27 ((uint32_t)0x08000000) /*!< Internal interrupt line 27 + Connected to the CEC wakeup + event, applicable only for STM32F051 + and STM32F072 devices */ +#define EXTI_Line31 ((uint32_t)0x80000000) /*!< Internal interrupt line 31 + Connected to the VDD USB monitor + event, applicable only for + STM32F072 devices */ +#define IS_EXTI_LINE(LINE) ((((LINE) & (uint32_t)0x71000000) == 0x00) && ((LINE) != (uint16_t)0x00)) + +#define IS_GET_EXTI_LINE(LINE) (((LINE) == EXTI_Line0) || ((LINE) == EXTI_Line1) || \ + ((LINE) == EXTI_Line2) || ((LINE) == EXTI_Line3) || \ + ((LINE) == EXTI_Line4) || ((LINE) == EXTI_Line5) || \ + ((LINE) == EXTI_Line6) || ((LINE) == EXTI_Line7) || \ + ((LINE) == EXTI_Line8) || ((LINE) == EXTI_Line9) || \ + ((LINE) == EXTI_Line10) || ((LINE) == EXTI_Line11) || \ + ((LINE) == EXTI_Line12) || ((LINE) == EXTI_Line13) || \ + ((LINE) == EXTI_Line14) || ((LINE) == EXTI_Line15) || \ + ((LINE) == EXTI_Line16) || ((LINE) == EXTI_Line17) || \ + ((LINE) == EXTI_Line18) || ((LINE) == EXTI_Line19) || \ + ((LINE) == EXTI_Line20) || ((LINE) == EXTI_Line21) || \ + ((LINE) == EXTI_Line22) || ((LINE) == EXTI_Line23) || \ + ((LINE) == EXTI_Line25) || ((LINE) == EXTI_Line26) || \ + ((LINE) == EXTI_Line27) || ((LINE) == EXTI_Line31)) + +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ +/* Function used to set the EXTI configuration to the default reset state *****/ +void EXTI_DeInit(void); + +/* Initialization and Configuration functions *********************************/ +void EXTI_Init(EXTI_InitTypeDef* EXTI_InitStruct); +void EXTI_StructInit(EXTI_InitTypeDef* EXTI_InitStruct); +void EXTI_GenerateSWInterrupt(uint32_t EXTI_Line); + +/* Interrupts and flags management functions **********************************/ +FlagStatus EXTI_GetFlagStatus(uint32_t EXTI_Line); +void EXTI_ClearFlag(uint32_t EXTI_Line); +ITStatus EXTI_GetITStatus(uint32_t EXTI_Line); +void EXTI_ClearITPendingBit(uint32_t EXTI_Line); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_EXTI_H */ +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_flash.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_flash.h new file mode 100644 index 00000000..f647684a --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_flash.h @@ -0,0 +1,435 @@ +/** + ****************************************************************************** + * @file stm32f0xx_flash.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the FLASH + * firmware library. + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_FLASH_H +#define __STM32F0XX_FLASH_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup FLASH + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief FLASH Status + */ +typedef enum +{ + FLASH_BUSY = 1, + FLASH_ERROR_WRP, + FLASH_ERROR_PROGRAM, + FLASH_COMPLETE, + FLASH_TIMEOUT +}FLASH_Status; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup FLASH_Exported_Constants + * @{ + */ + +/** @defgroup FLASH_Latency + * @{ + */ +#define FLASH_Latency_0 ((uint32_t)0x00000000) /*!< FLASH Zero Latency cycle */ +#define FLASH_Latency_1 FLASH_ACR_LATENCY /*!< FLASH One Latency cycle */ + +#define IS_FLASH_LATENCY(LATENCY) (((LATENCY) == FLASH_Latency_0) || \ + ((LATENCY) == FLASH_Latency_1)) +/** + * @} + */ + +/** @defgroup FLASH_Interrupts + * @{ + */ + +#define FLASH_IT_EOP FLASH_CR_EOPIE /*!< End of programming interrupt source */ +#define FLASH_IT_ERR FLASH_CR_ERRIE /*!< Error interrupt source */ +#define IS_FLASH_IT(IT) ((((IT) & (uint32_t)0xFFFFEBFF) == 0x00000000) && (((IT) != 0x00000000))) +/** + * @} + */ + +/** @defgroup FLASH_Address + * @{ + */ +#if defined(STM32F042) || defined(STM32F031) || defined(STM32F070x6) /*32K devices */ + #define IS_FLASH_PROGRAM_ADDRESS(ADDRESS) (((ADDRESS) >= 0x08000000) && ((ADDRESS) <= 0x08007FFF)) +#elif defined(STM32F030) || defined(STM32F051) /*64K devices */ + #define IS_FLASH_PROGRAM_ADDRESS(ADDRESS) (((ADDRESS) >= 0x08000000) && ((ADDRESS) <= 0x0800FFFF)) +#elif defined(STM32F072) || defined(STM32F070xB) /*128K devices */ + #define IS_FLASH_PROGRAM_ADDRESS(ADDRESS) (((ADDRESS) >= 0x08000000) && ((ADDRESS) <= 0x0801FFFF)) +#else /* STM32F091 || STM32F030 || STM32F030xC */ /*256K Flash devices */ + #define IS_FLASH_PROGRAM_ADDRESS(ADDRESS) (((ADDRESS) >= 0x08000000) && ((ADDRESS) <= 0x0800FFFF)) +#endif /* STM32F042 || STM32F031 || STM32F070x6 */ +/** + * @} + */ + +/** @defgroup FLASH_OB_DATA_ADDRESS + * @{ + */ +#define IS_OB_DATA_ADDRESS(ADDRESS) (((ADDRESS) == 0x1FFFF804) || ((ADDRESS) == 0x1FFFF806)) + +/** + * @} + */ + +/** @defgroup FLASH_Option_Bytes_Write_Protection + * @{ + */ + +#if !defined (STM32F072) && !defined (STM32F070xB) && !defined (STM32F091) && !defined (STM32F030) && !defined (STM32F030xC) /* 32K and 64K Flash devices */ +#define OB_WRP_Pages0to3 ((uint32_t)0x00000001) /* Write protection of page 0 to 3 */ +#define OB_WRP_Pages4to7 ((uint32_t)0x00000002) /* Write protection of page 4 to 7 */ +#define OB_WRP_Pages8to11 ((uint32_t)0x00000004) /* Write protection of page 8 to 11 */ +#define OB_WRP_Pages12to15 ((uint32_t)0x00000008) /* Write protection of page 12 to 15 */ +#define OB_WRP_Pages16to19 ((uint32_t)0x00000010) /* Write protection of page 16 to 19 */ +#define OB_WRP_Pages20to23 ((uint32_t)0x00000020) /* Write protection of page 20 to 23 */ +#define OB_WRP_Pages24to27 ((uint32_t)0x00000040) /* Write protection of page 24 to 27 */ +#define OB_WRP_Pages28to31 ((uint32_t)0x00000080) /* Write protection of page 28 to 31 */ +#define OB_WRP_Pages32to35 ((uint32_t)0x00000100) /* Write protection of page 32 to 35 */ +#define OB_WRP_Pages36to39 ((uint32_t)0x00000200) /* Write protection of page 36 to 39 */ +#define OB_WRP_Pages40to43 ((uint32_t)0x00000400) /* Write protection of page 40 to 43 */ +#define OB_WRP_Pages44to47 ((uint32_t)0x00000800) /* Write protection of page 44 to 47 */ +#define OB_WRP_Pages48to51 ((uint32_t)0x00001000) /* Write protection of page 48 to 51 */ +#define OB_WRP_Pages52to55 ((uint32_t)0x00002000) /* Write protection of page 52 to 55 */ +#define OB_WRP_Pages56to59 ((uint32_t)0x00004000) /* Write protection of page 56 to 59 */ +#define OB_WRP_Pages60to63 ((uint32_t)0x00008000) /* Write protection of page 60 to 63 */ + +#define OB_WRP_AllPages ((uint32_t)0x0000FFFF) /*!< Write protection of all Sectors */ + +#define IS_OB_WRP(PAGE) (((PAGE) != 0x0000000)) + +#else /* 128K and 256K Flash devices */ + +#define OB_WRP_Pages0to1 ((uint32_t)0x00000001) /* Write protection of page 0 to 1 */ +#define OB_WRP_Pages2to3 ((uint32_t)0x00000002) /* Write protection of page 2 to 3 */ +#define OB_WRP_Pages4to5 ((uint32_t)0x00000004) /* Write protection of page 4 to 5 */ +#define OB_WRP_Pages6to7 ((uint32_t)0x00000008) /* Write protection of page 6 to 7 */ +#define OB_WRP_Pages8to9 ((uint32_t)0x00000010) /* Write protection of page 8 to 9 */ +#define OB_WRP_Pages10to11 ((uint32_t)0x00000020) /* Write protection of page 10 to 11 */ +#define OB_WRP_Pages12to13 ((uint32_t)0x00000040) /* Write protection of page 12 to 13 */ +#define OB_WRP_Pages14to15 ((uint32_t)0x00000080) /* Write protection of page 14 to 15 */ +#define OB_WRP_Pages16to17 ((uint32_t)0x00000100) /* Write protection of page 16 to 17 */ +#define OB_WRP_Pages18to19 ((uint32_t)0x00000200) /* Write protection of page 18 to 19 */ +#define OB_WRP_Pages20to21 ((uint32_t)0x00000400) /* Write protection of page 20 to 21 */ +#define OB_WRP_Pages22to23 ((uint32_t)0x00000800) /* Write protection of page 22 to 23 */ +#define OB_WRP_Pages24to25 ((uint32_t)0x00001000) /* Write protection of page 24 to 25 */ +#define OB_WRP_Pages26to27 ((uint32_t)0x00002000) /* Write protection of page 26 to 27 */ +#define OB_WRP_Pages28to29 ((uint32_t)0x00004000) /* Write protection of page 28 to 29 */ +#define OB_WRP_Pages30to31 ((uint32_t)0x00008000) /* Write protection of page 30 to 31 */ +#define OB_WRP_Pages32to33 ((uint32_t)0x00010000) /* Write protection of page 32 to 33 */ +#define OB_WRP_Pages34to35 ((uint32_t)0x00020000) /* Write protection of page 34 to 35 */ +#define OB_WRP_Pages36to37 ((uint32_t)0x00040000) /* Write protection of page 36 to 37 */ +#define OB_WRP_Pages38to39 ((uint32_t)0x00080000) /* Write protection of page 38 to 39 */ +#define OB_WRP_Pages40to41 ((uint32_t)0x00100000) /* Write protection of page 40 to 41 */ +#define OB_WRP_Pages42to43 ((uint32_t)0x00200000) /* Write protection of page 42 to 43 */ +#define OB_WRP_Pages44to45 ((uint32_t)0x00400000) /* Write protection of page 44 to 45 */ +#define OB_WRP_Pages46to47 ((uint32_t)0x00800000) /* Write protection of page 46 to 47 */ +#define OB_WRP_Pages48to49 ((uint32_t)0x01000000) /* Write protection of page 48 to 49 */ +#define OB_WRP_Pages50to51 ((uint32_t)0x02000000) /* Write protection of page 50 to 51 */ +#define OB_WRP_Pages52to53 ((uint32_t)0x04000000) /* Write protection of page 52 to 53 */ +#define OB_WRP_Pages54to55 ((uint32_t)0x08000000) /* Write protection of page 54 to 55 */ +#define OB_WRP_Pages56to57 ((uint32_t)0x10000000) /* Write protection of page 56 to 57 */ +#define OB_WRP_Pages58to59 ((uint32_t)0x20000000) /* Write protection of page 58 to 59 */ +#define OB_WRP_Pages60to61 ((uint32_t)0x40000000) /* Write protection of page 60 to 61 */ + +#if defined(STM32F091) || defined(STM32F030xC) /* 256K Flash devices */ +#define OB_WRP_Pages62to127 ((uint32_t)0x80000000) /* Write protection of page 62 to 127 */ +#else /* 128K Flash devices */ +#define OB_WRP_Pages62to63 ((uint32_t)0x80000000) /* Write protection of page 62 to 63 */ +#endif /* STM32F091 || STM32F030xC */ +#define OB_WRP_AllPages ((uint32_t)0xFFFFFFFF) /*!< Write protection of all Sectors */ +#define IS_OB_WRP(PAGE) (((PAGE) != 0x0000000)) + +#endif /* STM32F072 || STM32F070xB || STM32F091 || STM32F030 || STM32F030xC */ +/** + * @} + */ + +/** @defgroup FLASH_Option_Bytes_Read_Protection + * @{ + */ + +/** + * @brief FLASH_Read Protection Level + */ +#define OB_RDP_Level_0 ((uint8_t)0xAA) +#define OB_RDP_Level_1 ((uint8_t)0xBB) +/*#define OB_RDP_Level_2 ((uint8_t)0xCC)*/ /* Warning: When enabling read protection level 2 + it's no more possible to go back to level 1 or 0 */ + +#define IS_OB_RDP(LEVEL) (((LEVEL) == OB_RDP_Level_0)||\ + ((LEVEL) == OB_RDP_Level_1))/*||\ + ((LEVEL) == OB_RDP_Level_2))*/ +/** + * @} + */ + +/** @defgroup FLASH_Option_Bytes_IWatchdog + * @{ + */ + +#define OB_IWDG_SW ((uint8_t)0x01) /*!< Software IWDG selected */ +#define OB_IWDG_HW ((uint8_t)0x00) /*!< Hardware IWDG selected */ +#define IS_OB_IWDG_SOURCE(SOURCE) (((SOURCE) == OB_IWDG_SW) || ((SOURCE) == OB_IWDG_HW)) + +/** + * @} + */ + +/** @defgroup FLASH_Option_Bytes_nRST_STOP + * @{ + */ + +#define OB_STOP_NoRST ((uint8_t)0x02) /*!< No reset generated when entering in STOP */ +#define OB_STOP_RST ((uint8_t)0x00) /*!< Reset generated when entering in STOP */ +#define IS_OB_STOP_SOURCE(SOURCE) (((SOURCE) == OB_STOP_NoRST) || ((SOURCE) == OB_STOP_RST)) + +/** + * @} + */ + +/** @defgroup FLASH_Option_Bytes_nRST_STDBY + * @{ + */ + +#define OB_STDBY_NoRST ((uint8_t)0x04) /*!< No reset generated when entering in STANDBY */ +#define OB_STDBY_RST ((uint8_t)0x00) /*!< Reset generated when entering in STANDBY */ +#define IS_OB_STDBY_SOURCE(SOURCE) (((SOURCE) == OB_STDBY_NoRST) || ((SOURCE) == OB_STDBY_RST)) + +/** + * @} + */ + +/** @defgroup FLASH_Option_Bytes_BOOT1 + * @{ + */ + +#define OB_BOOT1_RESET ((uint8_t)0x00) /*!< BOOT1 Reset */ +#define OB_BOOT1_SET ((uint8_t)0x10) /*!< BOOT1 Set */ +#define IS_OB_BOOT1(BOOT1) (((BOOT1) == OB_BOOT1_RESET) || ((BOOT1) == OB_BOOT1_SET)) + +/** + * @} + */ + +/** @defgroup FLASH_Option_Bytes_BOOT0 + * @{ + */ + +#define OB_BOOT0_RESET ((uint8_t)0x00) /*!< BOOT0 Reset */ +#define OB_BOOT0_SET ((uint8_t)0x08) /*!< BOOT0 Set */ +#define IS_OB_BOOT0(BOOT0) (((BOOT0) == OB_BOOT0_RESET) || ((BOOT0) == OB_BOOT0_SET)) + +/** + * @} + */ + +/** @defgroup FLASH_Option_Bytes_BOOT0SW + * @{ + */ + +#define OB_BOOT0_SW ((uint8_t)0x00) /*!< BOOT0 pin disabled */ +#define OB_BOOT0_HW ((uint8_t)0x80) /*!< BOOT0 pin bonded with GPIO */ +#define IS_OB_BOOT0SW(BOOT0) (((BOOT0) == OB_BOOT0_SW) || ((BOOT0) == OB_BOOT0_HW)) + +/** + * @} + */ + +/** @defgroup FLASH_Option_Bytes_VDDA_Analog_Monitoring + * @{ + */ + +#define OB_VDDA_ANALOG_ON ((uint8_t)0x20) /*!< Analog monitoring on VDDA Power source ON */ +#define OB_VDDA_ANALOG_OFF ((uint8_t)0x00) /*!< Analog monitoring on VDDA Power source OFF */ + +#define IS_OB_VDDA_ANALOG(ANALOG) (((ANALOG) == OB_VDDA_ANALOG_ON) || ((ANALOG) == OB_VDDA_ANALOG_OFF)) + +/** + * @} + */ + +/** @defgroup FLASH_Option_Bytes_SRAM_Parity_Enable + * @{ + */ + +#define OB_SRAM_PARITY_SET ((uint8_t)0x00) /*!< SRAM parity enable Set */ +#define OB_SRAM_PARITY_RESET ((uint8_t)0x40) /*!< SRAM parity enable reset */ + +#define IS_OB_SRAM_PARITY(PARITY) (((PARITY) == OB_SRAM_PARITY_SET) || ((PARITY) == OB_SRAM_PARITY_RESET)) + +/** + * @} + */ + +/** @defgroup FLASH_Flags + * @{ + */ + +#define FLASH_FLAG_BSY FLASH_SR_BSY /*!< FLASH Busy flag */ +#define FLASH_FLAG_PGERR FLASH_SR_PGERR /*!< FLASH Programming error flag */ +#define FLASH_FLAG_WRPERR FLASH_SR_WRPERR /*!< FLASH Write protected error flag */ +#define FLASH_FLAG_EOP FLASH_SR_EOP /*!< FLASH End of Programming flag */ + +#define IS_FLASH_CLEAR_FLAG(FLAG) ((((FLAG) & (uint32_t)0xFFFFFFCB) == 0x00000000) && ((FLAG) != 0x00000000)) + +#define IS_FLASH_GET_FLAG(FLAG) (((FLAG) == FLASH_FLAG_BSY) || ((FLAG) == FLASH_FLAG_PGERR) || \ + ((FLAG) == FLASH_FLAG_WRPERR) || ((FLAG) == FLASH_FLAG_EOP)) +/** + * @} + */ + +/** @defgroup FLASH_Timeout_definition + * @{ + */ +#define FLASH_ER_PRG_TIMEOUT ((uint32_t)0x000B0000) + +/** + * @} + */ + +/** @defgroup FLASH_Legacy + * @{ + */ +#define FLASH_WRProt_Pages0to3 OB_WRP_Pages0to3 +#define FLASH_WRProt_Pages4to7 OB_WRP_Pages4to7 +#define FLASH_WRProt_Pages8to11 OB_WRP_Pages8to11 +#define FLASH_WRProt_Pages12to15 OB_WRP_Pages12to15 +#define FLASH_WRProt_Pages16to19 OB_WRP_Pages16to19 +#define FLASH_WRProt_Pages20to23 OB_WRP_Pages20to23 +#define FLASH_WRProt_Pages24to27 OB_WRP_Pages24to27 +#define FLASH_WRProt_Pages28to31 OB_WRP_Pages28to31 +#define FLASH_WRProt_Pages32to35 OB_WRP_Pages32to35 +#define FLASH_WRProt_Pages36to39 OB_WRP_Pages36to39 +#define FLASH_WRProt_Pages40to43 OB_WRP_Pages40to21 +#define FLASH_WRProt_Pages44to47 OB_WRP_Pages44to23 +#define FLASH_WRProt_Pages48to51 OB_WRP_Pages48to51 +#define FLASH_WRProt_Pages52to55 OB_WRP_Pages52to55 +#define FLASH_WRProt_Pages56to59 OB_WRP_Pages56to59 +#define FLASH_WRProt_Pages60to63 OB_WRP_Pages60to63 + + +#define FLASH_WRProt_AllPages OB_WRP_AllPages +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/** + * @brief FLASH memory functions that can be executed from FLASH. + */ +/* FLASH Interface configuration functions ************************************/ +void FLASH_SetLatency(uint32_t FLASH_Latency); +void FLASH_PrefetchBufferCmd(FunctionalState NewState); +FlagStatus FLASH_GetPrefetchBufferStatus(void); + +/* FLASH Memory Programming functions *****************************************/ +void FLASH_Unlock(void); +void FLASH_Lock(void); +FLASH_Status FLASH_ErasePage(uint32_t Page_Address); +FLASH_Status FLASH_EraseAllPages(void); +FLASH_Status FLASH_ProgramWord(uint32_t Address, uint32_t Data); +FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data); + +/* FLASH Option Bytes Programming functions *****************************************/ +void FLASH_OB_Unlock(void); +void FLASH_OB_Lock(void); +void FLASH_OB_Launch(void); +FLASH_Status FLASH_OB_Erase(void); +FLASH_Status FLASH_OB_EnableWRP(uint32_t OB_WRP); +FLASH_Status FLASH_OB_RDPConfig(uint8_t OB_RDP); +FLASH_Status FLASH_OB_UserConfig(uint8_t OB_IWDG, uint8_t OB_STOP, uint8_t OB_STDBY); +FLASH_Status FLASH_OB_BOOTConfig(uint8_t OB_BOOT1); +FLASH_Status FLASH_OB_BOOT0Config(uint8_t OB_BOOT0); +FLASH_Status FLASH_OB_BOOT0SWConfig(uint8_t OB_BOOT0SW); +FLASH_Status FLASH_OB_VDDAConfig(uint8_t OB_VDDA_ANALOG); +FLASH_Status FLASH_OB_SRAMParityConfig(uint8_t OB_SRAM_Parity); +FLASH_Status FLASH_OB_WriteUser(uint8_t OB_USER); +FLASH_Status FLASH_OB_ProgramData(uint32_t Address, uint8_t Data); +uint8_t FLASH_OB_GetUser(void); +uint32_t FLASH_OB_GetWRP(void); +FlagStatus FLASH_OB_GetRDP(void); + +/* FLASH Interrupts and flags management functions **********************************/ +void FLASH_ITConfig(uint32_t FLASH_IT, FunctionalState NewState); +FlagStatus FLASH_GetFlagStatus(uint32_t FLASH_FLAG); +void FLASH_ClearFlag(uint32_t FLASH_FLAG); +FLASH_Status FLASH_GetStatus(void); +FLASH_Status FLASH_WaitForLastOperation(uint32_t Timeout); + +/** @defgroup FLASH_Legacy + * @{ + */ +#define FLASH_EraseOptionBytes FLASH_OB_Erase +#define FLASH_EnableWriteProtection FLASH_OB_EnableWRP +#define FLASH_UserOptionByteConfig FLASH_OB_UserConfig +#define FLASH_ProgramOptionByteData FLASH_OB_ProgramData +#define FLASH_GetUserOptionByte FLASH_OB_GetUser +#define FLASH_GetWriteProtectionOptionByte FLASH_OB_GetWRP + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_FLASH_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_gpio.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_gpio.h new file mode 100644 index 00000000..8a2aa9be --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_gpio.h @@ -0,0 +1,358 @@ +/** + ****************************************************************************** + * @file stm32f0xx_gpio.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the GPIO + * firmware library. + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_GPIO_H +#define __STM32F0XX_GPIO_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup GPIO + * @{ + */ +/* Exported types ------------------------------------------------------------*/ + +#define IS_GPIO_ALL_PERIPH(PERIPH) (((PERIPH) == GPIOA) || \ + ((PERIPH) == GPIOB) || \ + ((PERIPH) == GPIOC) || \ + ((PERIPH) == GPIOD) || \ + ((PERIPH) == GPIOE) || \ + ((PERIPH) == GPIOF)) + +#define IS_GPIO_LIST_PERIPH(PERIPH) (((PERIPH) == GPIOA) || \ + ((PERIPH) == GPIOB)) + +/** @defgroup Configuration_Mode_enumeration + * @{ + */ +typedef enum +{ + GPIO_Mode_IN = 0x00, /*!< GPIO Input Mode */ + GPIO_Mode_OUT = 0x01, /*!< GPIO Output Mode */ + GPIO_Mode_AF = 0x02, /*!< GPIO Alternate function Mode */ + GPIO_Mode_AN = 0x03 /*!< GPIO Analog In/Out Mode */ +}GPIOMode_TypeDef; + +#define IS_GPIO_MODE(MODE) (((MODE) == GPIO_Mode_IN)|| ((MODE) == GPIO_Mode_OUT) || \ + ((MODE) == GPIO_Mode_AF)|| ((MODE) == GPIO_Mode_AN)) +/** + * @} + */ + +/** @defgroup Output_type_enumeration + * @{ + */ +typedef enum +{ + GPIO_OType_PP = 0x00, + GPIO_OType_OD = 0x01 +}GPIOOType_TypeDef; + +#define IS_GPIO_OTYPE(OTYPE) (((OTYPE) == GPIO_OType_PP) || ((OTYPE) == GPIO_OType_OD)) + +/** + * @} + */ + +/** @defgroup Output_Maximum_frequency_enumeration + * @{ + */ +typedef enum +{ + GPIO_Speed_Level_1 = 0x00, /*!< I/O output speed: Low 2 MHz */ + GPIO_Speed_Level_2 = 0x01, /*!< I/O output speed: Medium 10 MHz */ + GPIO_Speed_Level_3 = 0x03 /*!< I/O output speed: High 50 MHz */ +}GPIOSpeed_TypeDef; + +#define IS_GPIO_SPEED(SPEED) (((SPEED) == GPIO_Speed_Level_1) || ((SPEED) == GPIO_Speed_Level_2) || \ + ((SPEED) == GPIO_Speed_Level_3)) +/** + * @} + */ + +/** @defgroup Configuration_Pull-Up_Pull-Down_enumeration + * @{ + */ +typedef enum +{ + GPIO_PuPd_NOPULL = 0x00, + GPIO_PuPd_UP = 0x01, + GPIO_PuPd_DOWN = 0x02 +}GPIOPuPd_TypeDef; + +#define IS_GPIO_PUPD(PUPD) (((PUPD) == GPIO_PuPd_NOPULL) || ((PUPD) == GPIO_PuPd_UP) || \ + ((PUPD) == GPIO_PuPd_DOWN)) +/** + * @} + */ + +/** @defgroup Bit_SET_and_Bit_RESET_enumeration + * @{ + */ +typedef enum +{ + Bit_RESET = 0, + Bit_SET +}BitAction; + +#define IS_GPIO_BIT_ACTION(ACTION) (((ACTION) == Bit_RESET) || ((ACTION) == Bit_SET)) +/** + * @} + */ + +/** + * @brief GPIO Init structure definition + */ +typedef struct +{ + uint32_t GPIO_Pin; /*!< Specifies the GPIO pins to be configured. + This parameter can be any value of @ref GPIO_pins_define */ + + GPIOMode_TypeDef GPIO_Mode; /*!< Specifies the operating mode for the selected pins. + This parameter can be a value of @ref GPIOMode_TypeDef */ + + GPIOSpeed_TypeDef GPIO_Speed; /*!< Specifies the speed for the selected pins. + This parameter can be a value of @ref GPIOSpeed_TypeDef */ + + GPIOOType_TypeDef GPIO_OType; /*!< Specifies the operating output type for the selected pins. + This parameter can be a value of @ref GPIOOType_TypeDef */ + + GPIOPuPd_TypeDef GPIO_PuPd; /*!< Specifies the operating Pull-up/Pull down for the selected pins. + This parameter can be a value of @ref GPIOPuPd_TypeDef */ +}GPIO_InitTypeDef; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup GPIO_Exported_Constants + * @{ + */ + +/** @defgroup GPIO_pins_define + * @{ + */ +#define GPIO_Pin_0 ((uint16_t)0x0001) /*!< Pin 0 selected */ +#define GPIO_Pin_1 ((uint16_t)0x0002) /*!< Pin 1 selected */ +#define GPIO_Pin_2 ((uint16_t)0x0004) /*!< Pin 2 selected */ +#define GPIO_Pin_3 ((uint16_t)0x0008) /*!< Pin 3 selected */ +#define GPIO_Pin_4 ((uint16_t)0x0010) /*!< Pin 4 selected */ +#define GPIO_Pin_5 ((uint16_t)0x0020) /*!< Pin 5 selected */ +#define GPIO_Pin_6 ((uint16_t)0x0040) /*!< Pin 6 selected */ +#define GPIO_Pin_7 ((uint16_t)0x0080) /*!< Pin 7 selected */ +#define GPIO_Pin_8 ((uint16_t)0x0100) /*!< Pin 8 selected */ +#define GPIO_Pin_9 ((uint16_t)0x0200) /*!< Pin 9 selected */ +#define GPIO_Pin_10 ((uint16_t)0x0400) /*!< Pin 10 selected */ +#define GPIO_Pin_11 ((uint16_t)0x0800) /*!< Pin 11 selected */ +#define GPIO_Pin_12 ((uint16_t)0x1000) /*!< Pin 12 selected */ +#define GPIO_Pin_13 ((uint16_t)0x2000) /*!< Pin 13 selected */ +#define GPIO_Pin_14 ((uint16_t)0x4000) /*!< Pin 14 selected */ +#define GPIO_Pin_15 ((uint16_t)0x8000) /*!< Pin 15 selected */ +#define GPIO_Pin_All ((uint16_t)0xFFFF) /*!< All pins selected */ + +#define IS_GPIO_PIN(PIN) ((PIN) != (uint16_t)0x00) + +#define IS_GET_GPIO_PIN(PIN) (((PIN) == GPIO_Pin_0) || \ + ((PIN) == GPIO_Pin_1) || \ + ((PIN) == GPIO_Pin_2) || \ + ((PIN) == GPIO_Pin_3) || \ + ((PIN) == GPIO_Pin_4) || \ + ((PIN) == GPIO_Pin_5) || \ + ((PIN) == GPIO_Pin_6) || \ + ((PIN) == GPIO_Pin_7) || \ + ((PIN) == GPIO_Pin_8) || \ + ((PIN) == GPIO_Pin_9) || \ + ((PIN) == GPIO_Pin_10) || \ + ((PIN) == GPIO_Pin_11) || \ + ((PIN) == GPIO_Pin_12) || \ + ((PIN) == GPIO_Pin_13) || \ + ((PIN) == GPIO_Pin_14) || \ + ((PIN) == GPIO_Pin_15)) + +/** + * @} + */ + +/** @defgroup GPIO_Pin_sources + * @{ + */ +#define GPIO_PinSource0 ((uint8_t)0x00) +#define GPIO_PinSource1 ((uint8_t)0x01) +#define GPIO_PinSource2 ((uint8_t)0x02) +#define GPIO_PinSource3 ((uint8_t)0x03) +#define GPIO_PinSource4 ((uint8_t)0x04) +#define GPIO_PinSource5 ((uint8_t)0x05) +#define GPIO_PinSource6 ((uint8_t)0x06) +#define GPIO_PinSource7 ((uint8_t)0x07) +#define GPIO_PinSource8 ((uint8_t)0x08) +#define GPIO_PinSource9 ((uint8_t)0x09) +#define GPIO_PinSource10 ((uint8_t)0x0A) +#define GPIO_PinSource11 ((uint8_t)0x0B) +#define GPIO_PinSource12 ((uint8_t)0x0C) +#define GPIO_PinSource13 ((uint8_t)0x0D) +#define GPIO_PinSource14 ((uint8_t)0x0E) +#define GPIO_PinSource15 ((uint8_t)0x0F) + +#define IS_GPIO_PIN_SOURCE(PINSOURCE) (((PINSOURCE) == GPIO_PinSource0) || \ + ((PINSOURCE) == GPIO_PinSource1) || \ + ((PINSOURCE) == GPIO_PinSource2) || \ + ((PINSOURCE) == GPIO_PinSource3) || \ + ((PINSOURCE) == GPIO_PinSource4) || \ + ((PINSOURCE) == GPIO_PinSource5) || \ + ((PINSOURCE) == GPIO_PinSource6) || \ + ((PINSOURCE) == GPIO_PinSource7) || \ + ((PINSOURCE) == GPIO_PinSource8) || \ + ((PINSOURCE) == GPIO_PinSource9) || \ + ((PINSOURCE) == GPIO_PinSource10) || \ + ((PINSOURCE) == GPIO_PinSource11) || \ + ((PINSOURCE) == GPIO_PinSource12) || \ + ((PINSOURCE) == GPIO_PinSource13) || \ + ((PINSOURCE) == GPIO_PinSource14) || \ + ((PINSOURCE) == GPIO_PinSource15)) +/** + * @} + */ + +/** @defgroup GPIO_Alternate_function_selection_define + * @{ + */ + +/** + * @brief AF 0 selection + */ +#define GPIO_AF_0 ((uint8_t)0x00) /* WKUP, EVENTOUT, TIM15, SPI1, TIM17, + MCO, SWDAT, SWCLK, TIM14, BOOT, + USART1, CEC, IR_OUT, SPI2, TS, TIM3, + USART4, CAN, TIM3, USART2, USART3, + CRS, TIM16, TIM1 */ +/** + * @brief AF 1 selection + */ +#define GPIO_AF_1 ((uint8_t)0x01) /* USART2, CEC, TIM3, USART1, IR, + EVENTOUT, I2C1, I2C2, TIM15, SPI2, + USART3, TS, SPI1 */ +/** + * @brief AF 2 selection + */ +#define GPIO_AF_2 ((uint8_t)0x02) /* TIM2, TIM1, EVENTOUT, TIM16, TIM17, + USB */ +/** + * @brief AF 3 selection + */ +#define GPIO_AF_3 ((uint8_t)0x03) /* TS, I2C1, TIM15, EVENTOUT */ + +/** + * @brief AF 4 selection + */ +#define GPIO_AF_4 ((uint8_t)0x04) /* TIM14, USART4, USART3, CRS, CAN, + I2C1 */ + +/** + * @brief AF 5 selection + */ +#define GPIO_AF_5 ((uint8_t)0x05) /* TIM16, TIM17, TIM15, SPI2, I2C2, + MCO, I2C1, USB */ + +/** + * @brief AF 6 selection + */ +#define GPIO_AF_6 ((uint8_t)0x06) /* EVENTOUT */ +/** + * @brief AF 7 selection + */ +#define GPIO_AF_7 ((uint8_t)0x07) /* COMP1 OUT and COMP2 OUT */ + +#define IS_GPIO_AF(AF) (((AF) == GPIO_AF_0) || ((AF) == GPIO_AF_1) || \ + ((AF) == GPIO_AF_2) || ((AF) == GPIO_AF_3) || \ + ((AF) == GPIO_AF_4) || ((AF) == GPIO_AF_5) || \ + ((AF) == GPIO_AF_6) || ((AF) == GPIO_AF_7)) + +/** + * @} + */ + +/** @defgroup GPIO_Speed_Legacy + * @{ + */ + +#define GPIO_Speed_2MHz GPIO_Speed_Level_1 /*!< I/O output speed: Low 2 MHz */ +#define GPIO_Speed_10MHz GPIO_Speed_Level_2 /*!< I/O output speed: Medium 10 MHz */ +#define GPIO_Speed_50MHz GPIO_Speed_Level_3 /*!< I/O output speed: High 50 MHz */ + +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ +/* Function used to set the GPIO configuration to the default reset state *****/ +void GPIO_DeInit(GPIO_TypeDef* GPIOx); + +/* Initialization and Configuration functions *********************************/ +void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct); +void GPIO_StructInit(GPIO_InitTypeDef* GPIO_InitStruct); +void GPIO_PinLockConfig(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin); + +/* GPIO Read and Write functions **********************************************/ +uint8_t GPIO_ReadInputDataBit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin); +uint16_t GPIO_ReadInputData(GPIO_TypeDef* GPIOx); +uint8_t GPIO_ReadOutputDataBit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin); +uint16_t GPIO_ReadOutputData(GPIO_TypeDef* GPIOx); +void GPIO_SetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin); +void GPIO_ResetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin); +void GPIO_WriteBit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, BitAction BitVal); +void GPIO_Write(GPIO_TypeDef* GPIOx, uint16_t PortVal); + +/* GPIO Alternate functions configuration functions ***************************/ +void GPIO_PinAFConfig(GPIO_TypeDef* GPIOx, uint16_t GPIO_PinSource, uint8_t GPIO_AF); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_GPIO_H */ +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_i2c.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_i2c.h new file mode 100644 index 00000000..12247991 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_i2c.h @@ -0,0 +1,478 @@ +/** + ****************************************************************************** + * @file stm32f0xx_i2c.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the I2C firmware + * library + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_I2C_H +#define __STM32F0XX_I2C_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup I2C + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief I2C Init structure definition + */ + +typedef struct +{ + uint32_t I2C_Timing; /*!< Specifies the I2C_TIMINGR_register value. + This parameter must be set by referring to I2C_Timing_Config_Tool*/ + + uint32_t I2C_AnalogFilter; /*!< Enables or disables analog noise filter. + This parameter can be a value of @ref I2C_Analog_Filter*/ + + uint32_t I2C_DigitalFilter; /*!< Configures the digital noise filter. + This parameter can be a number between 0x00 and 0x0F*/ + + uint32_t I2C_Mode; /*!< Specifies the I2C mode. + This parameter can be a value of @ref I2C_mode*/ + + uint32_t I2C_OwnAddress1; /*!< Specifies the device own address 1. + This parameter can be a 7-bit or 10-bit address*/ + + uint32_t I2C_Ack; /*!< Enables or disables the acknowledgement. + This parameter can be a value of @ref I2C_acknowledgement*/ + + uint32_t I2C_AcknowledgedAddress; /*!< Specifies if 7-bit or 10-bit address is acknowledged. + This parameter can be a value of @ref I2C_acknowledged_address*/ +}I2C_InitTypeDef; + +/* Exported constants --------------------------------------------------------*/ + + +/** @defgroup I2C_Exported_Constants + * @{ + */ + +#define IS_I2C_ALL_PERIPH(PERIPH) (((PERIPH) == I2C1) || \ + ((PERIPH) == I2C2)) + +#define IS_I2C_1_PERIPH(PERIPH) ((PERIPH) == I2C1) + +/** @defgroup I2C_Analog_Filter + * @{ + */ + +#define I2C_AnalogFilter_Enable ((uint32_t)0x00000000) +#define I2C_AnalogFilter_Disable I2C_CR1_ANFOFF + +#define IS_I2C_ANALOG_FILTER(FILTER) (((FILTER) == I2C_AnalogFilter_Enable) || \ + ((FILTER) == I2C_AnalogFilter_Disable)) +/** + * @} + */ + +/** @defgroup I2C_Digital_Filter + * @{ + */ + +#define IS_I2C_DIGITAL_FILTER(FILTER) ((FILTER) <= 0x0000000F) +/** + * @} + */ + +/** @defgroup I2C_mode + * @{ + */ + +#define I2C_Mode_I2C ((uint32_t)0x00000000) +#define I2C_Mode_SMBusDevice I2C_CR1_SMBDEN +#define I2C_Mode_SMBusHost I2C_CR1_SMBHEN + +#define IS_I2C_MODE(MODE) (((MODE) == I2C_Mode_I2C) || \ + ((MODE) == I2C_Mode_SMBusDevice) || \ + ((MODE) == I2C_Mode_SMBusHost)) +/** + * @} + */ + +/** @defgroup I2C_acknowledgement + * @{ + */ + +#define I2C_Ack_Enable ((uint32_t)0x00000000) +#define I2C_Ack_Disable I2C_CR2_NACK + +#define IS_I2C_ACK(ACK) (((ACK) == I2C_Ack_Enable) || \ + ((ACK) == I2C_Ack_Disable)) +/** + * @} + */ + +/** @defgroup I2C_acknowledged_address + * @{ + */ + +#define I2C_AcknowledgedAddress_7bit ((uint32_t)0x00000000) +#define I2C_AcknowledgedAddress_10bit I2C_OAR1_OA1MODE + +#define IS_I2C_ACKNOWLEDGE_ADDRESS(ADDRESS) (((ADDRESS) == I2C_AcknowledgedAddress_7bit) || \ + ((ADDRESS) == I2C_AcknowledgedAddress_10bit)) +/** + * @} + */ + +/** @defgroup I2C_own_address1 + * @{ + */ + +#define IS_I2C_OWN_ADDRESS1(ADDRESS1) ((ADDRESS1) <= (uint32_t)0x000003FF) +/** + * @} + */ + +/** @defgroup I2C_transfer_direction + * @{ + */ + +#define I2C_Direction_Transmitter ((uint16_t)0x0000) +#define I2C_Direction_Receiver ((uint16_t)0x0400) + +#define IS_I2C_DIRECTION(DIRECTION) (((DIRECTION) == I2C_Direction_Transmitter) || \ + ((DIRECTION) == I2C_Direction_Receiver)) +/** + * @} + */ + +/** @defgroup I2C_DMA_transfer_requests + * @{ + */ + +#define I2C_DMAReq_Tx I2C_CR1_TXDMAEN +#define I2C_DMAReq_Rx I2C_CR1_RXDMAEN + +#define IS_I2C_DMA_REQ(REQ) ((((REQ) & (uint32_t)0xFFFF3FFF) == 0x00) && ((REQ) != 0x00)) +/** + * @} + */ + +/** @defgroup I2C_slave_address + * @{ + */ + +#define IS_I2C_SLAVE_ADDRESS(ADDRESS) ((ADDRESS) <= (uint16_t)0x03FF) +/** + * @} + */ + + +/** @defgroup I2C_own_address2 + * @{ + */ + +#define IS_I2C_OWN_ADDRESS2(ADDRESS2) ((ADDRESS2) <= (uint16_t)0x00FF) + +/** + * @} + */ + +/** @defgroup I2C_own_address2_mask + * @{ + */ + +#define I2C_OA2_NoMask ((uint8_t)0x00) +#define I2C_OA2_Mask01 ((uint8_t)0x01) +#define I2C_OA2_Mask02 ((uint8_t)0x02) +#define I2C_OA2_Mask03 ((uint8_t)0x03) +#define I2C_OA2_Mask04 ((uint8_t)0x04) +#define I2C_OA2_Mask05 ((uint8_t)0x05) +#define I2C_OA2_Mask06 ((uint8_t)0x06) +#define I2C_OA2_Mask07 ((uint8_t)0x07) + +#define IS_I2C_OWN_ADDRESS2_MASK(MASK) (((MASK) == I2C_OA2_NoMask) || \ + ((MASK) == I2C_OA2_Mask01) || \ + ((MASK) == I2C_OA2_Mask02) || \ + ((MASK) == I2C_OA2_Mask03) || \ + ((MASK) == I2C_OA2_Mask04) || \ + ((MASK) == I2C_OA2_Mask05) || \ + ((MASK) == I2C_OA2_Mask06) || \ + ((MASK) == I2C_OA2_Mask07)) + +/** + * @} + */ + +/** @defgroup I2C_timeout + * @{ + */ + +#define IS_I2C_TIMEOUT(TIMEOUT) ((TIMEOUT) <= (uint16_t)0x0FFF) + +/** + * @} + */ + +/** @defgroup I2C_registers + * @{ + */ + +#define I2C_Register_CR1 ((uint8_t)0x00) +#define I2C_Register_CR2 ((uint8_t)0x04) +#define I2C_Register_OAR1 ((uint8_t)0x08) +#define I2C_Register_OAR2 ((uint8_t)0x0C) +#define I2C_Register_TIMINGR ((uint8_t)0x10) +#define I2C_Register_TIMEOUTR ((uint8_t)0x14) +#define I2C_Register_ISR ((uint8_t)0x18) +#define I2C_Register_ICR ((uint8_t)0x1C) +#define I2C_Register_PECR ((uint8_t)0x20) +#define I2C_Register_RXDR ((uint8_t)0x24) +#define I2C_Register_TXDR ((uint8_t)0x28) + +#define IS_I2C_REGISTER(REGISTER) (((REGISTER) == I2C_Register_CR1) || \ + ((REGISTER) == I2C_Register_CR2) || \ + ((REGISTER) == I2C_Register_OAR1) || \ + ((REGISTER) == I2C_Register_OAR2) || \ + ((REGISTER) == I2C_Register_TIMINGR) || \ + ((REGISTER) == I2C_Register_TIMEOUTR) || \ + ((REGISTER) == I2C_Register_ISR) || \ + ((REGISTER) == I2C_Register_ICR) || \ + ((REGISTER) == I2C_Register_PECR) || \ + ((REGISTER) == I2C_Register_RXDR) || \ + ((REGISTER) == I2C_Register_TXDR)) +/** + * @} + */ + +/** @defgroup I2C_interrupts_definition + * @{ + */ + +#define I2C_IT_ERRI I2C_CR1_ERRIE +#define I2C_IT_TCI I2C_CR1_TCIE +#define I2C_IT_STOPI I2C_CR1_STOPIE +#define I2C_IT_NACKI I2C_CR1_NACKIE +#define I2C_IT_ADDRI I2C_CR1_ADDRIE +#define I2C_IT_RXI I2C_CR1_RXIE +#define I2C_IT_TXI I2C_CR1_TXIE + +#define IS_I2C_CONFIG_IT(IT) ((((IT) & (uint32_t)0xFFFFFF01) == 0x00) && ((IT) != 0x00)) + +/** + * @} + */ + +/** @defgroup I2C_flags_definition + * @{ + */ + +#define I2C_FLAG_TXE I2C_ISR_TXE +#define I2C_FLAG_TXIS I2C_ISR_TXIS +#define I2C_FLAG_RXNE I2C_ISR_RXNE +#define I2C_FLAG_ADDR I2C_ISR_ADDR +#define I2C_FLAG_NACKF I2C_ISR_NACKF +#define I2C_FLAG_STOPF I2C_ISR_STOPF +#define I2C_FLAG_TC I2C_ISR_TC +#define I2C_FLAG_TCR I2C_ISR_TCR +#define I2C_FLAG_BERR I2C_ISR_BERR +#define I2C_FLAG_ARLO I2C_ISR_ARLO +#define I2C_FLAG_OVR I2C_ISR_OVR +#define I2C_FLAG_PECERR I2C_ISR_PECERR +#define I2C_FLAG_TIMEOUT I2C_ISR_TIMEOUT +#define I2C_FLAG_ALERT I2C_ISR_ALERT +#define I2C_FLAG_BUSY I2C_ISR_BUSY + +#define IS_I2C_CLEAR_FLAG(FLAG) ((((FLAG) & (uint32_t)0xFFFF4000) == 0x00) && ((FLAG) != 0x00)) + +#define IS_I2C_GET_FLAG(FLAG) (((FLAG) == I2C_FLAG_TXE) || ((FLAG) == I2C_FLAG_TXIS) || \ + ((FLAG) == I2C_FLAG_RXNE) || ((FLAG) == I2C_FLAG_ADDR) || \ + ((FLAG) == I2C_FLAG_NACKF) || ((FLAG) == I2C_FLAG_STOPF) || \ + ((FLAG) == I2C_FLAG_TC) || ((FLAG) == I2C_FLAG_TCR) || \ + ((FLAG) == I2C_FLAG_BERR) || ((FLAG) == I2C_FLAG_ARLO) || \ + ((FLAG) == I2C_FLAG_OVR) || ((FLAG) == I2C_FLAG_PECERR) || \ + ((FLAG) == I2C_FLAG_TIMEOUT) || ((FLAG) == I2C_FLAG_ALERT) || \ + ((FLAG) == I2C_FLAG_BUSY)) + +/** + * @} + */ + + +/** @defgroup I2C_interrupts_definition + * @{ + */ + +#define I2C_IT_TXIS I2C_ISR_TXIS +#define I2C_IT_RXNE I2C_ISR_RXNE +#define I2C_IT_ADDR I2C_ISR_ADDR +#define I2C_IT_NACKF I2C_ISR_NACKF +#define I2C_IT_STOPF I2C_ISR_STOPF +#define I2C_IT_TC I2C_ISR_TC +#define I2C_IT_TCR I2C_ISR_TCR +#define I2C_IT_BERR I2C_ISR_BERR +#define I2C_IT_ARLO I2C_ISR_ARLO +#define I2C_IT_OVR I2C_ISR_OVR +#define I2C_IT_PECERR I2C_ISR_PECERR +#define I2C_IT_TIMEOUT I2C_ISR_TIMEOUT +#define I2C_IT_ALERT I2C_ISR_ALERT + +#define IS_I2C_CLEAR_IT(IT) ((((IT) & (uint32_t)0xFFFFC001) == 0x00) && ((IT) != 0x00)) + +#define IS_I2C_GET_IT(IT) (((IT) == I2C_IT_TXIS) || ((IT) == I2C_IT_RXNE) || \ + ((IT) == I2C_IT_ADDR) || ((IT) == I2C_IT_NACKF) || \ + ((IT) == I2C_IT_STOPF) || ((IT) == I2C_IT_TC) || \ + ((IT) == I2C_IT_TCR) || ((IT) == I2C_IT_BERR) || \ + ((IT) == I2C_IT_ARLO) || ((IT) == I2C_IT_OVR) || \ + ((IT) == I2C_IT_PECERR) || ((IT) == I2C_IT_TIMEOUT) || \ + ((IT) == I2C_IT_ALERT)) + + +/** + * @} + */ + +/** @defgroup I2C_ReloadEndMode_definition + * @{ + */ + +#define I2C_Reload_Mode I2C_CR2_RELOAD +#define I2C_AutoEnd_Mode I2C_CR2_AUTOEND +#define I2C_SoftEnd_Mode ((uint32_t)0x00000000) + + +#define IS_RELOAD_END_MODE(MODE) (((MODE) == I2C_Reload_Mode) || \ + ((MODE) == I2C_AutoEnd_Mode) || \ + ((MODE) == I2C_SoftEnd_Mode)) + + +/** + * @} + */ + +/** @defgroup I2C_StartStopMode_definition + * @{ + */ + +#define I2C_No_StartStop ((uint32_t)0x00000000) +#define I2C_Generate_Stop I2C_CR2_STOP +#define I2C_Generate_Start_Read (uint32_t)(I2C_CR2_START | I2C_CR2_RD_WRN) +#define I2C_Generate_Start_Write I2C_CR2_START + + +#define IS_START_STOP_MODE(MODE) (((MODE) == I2C_Generate_Stop) || \ + ((MODE) == I2C_Generate_Start_Read) || \ + ((MODE) == I2C_Generate_Start_Write) || \ + ((MODE) == I2C_No_StartStop)) + + +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + + +/* Initialization and Configuration functions *********************************/ +void I2C_DeInit(I2C_TypeDef* I2Cx); +void I2C_Init(I2C_TypeDef* I2Cx, I2C_InitTypeDef* I2C_InitStruct); +void I2C_StructInit(I2C_InitTypeDef* I2C_InitStruct); +void I2C_Cmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_SoftwareResetCmd(I2C_TypeDef* I2Cx); +void I2C_ITConfig(I2C_TypeDef* I2Cx, uint32_t I2C_IT, FunctionalState NewState); +void I2C_StretchClockCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_StopModeCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); /*!< not applicable for STM32F030 devices */ +void I2C_DualAddressCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_OwnAddress2Config(I2C_TypeDef* I2Cx, uint16_t Address, uint8_t Mask); +void I2C_GeneralCallCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_SlaveByteControlCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_SlaveAddressConfig(I2C_TypeDef* I2Cx, uint16_t Address); +void I2C_10BitAddressingModeCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); + +/* Communications handling functions ******************************************/ +void I2C_AutoEndCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_ReloadCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_NumberOfBytesConfig(I2C_TypeDef* I2Cx, uint8_t Number_Bytes); +void I2C_MasterRequestConfig(I2C_TypeDef* I2Cx, uint16_t I2C_Direction); +void I2C_GenerateSTART(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_GenerateSTOP(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_10BitAddressHeaderCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_AcknowledgeConfig(I2C_TypeDef* I2Cx, FunctionalState NewState); +uint8_t I2C_GetAddressMatched(I2C_TypeDef* I2Cx); +uint16_t I2C_GetTransferDirection(I2C_TypeDef* I2Cx); +void I2C_TransferHandling(I2C_TypeDef* I2Cx, uint16_t Address, uint8_t Number_Bytes, uint32_t ReloadEndMode, uint32_t StartStopMode); + +/* SMBUS management functions ************************************************/ +void I2C_SMBusAlertCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_ClockTimeoutCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_ExtendedClockTimeoutCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_IdleClockTimeoutCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_TimeoutAConfig(I2C_TypeDef* I2Cx, uint16_t Timeout); +void I2C_TimeoutBConfig(I2C_TypeDef* I2Cx, uint16_t Timeout); +void I2C_CalculatePEC(I2C_TypeDef* I2Cx, FunctionalState NewState); +void I2C_PECRequestCmd(I2C_TypeDef* I2Cx, FunctionalState NewState); +uint8_t I2C_GetPEC(I2C_TypeDef* I2Cx); + +/* I2C registers management functions *****************************************/ +uint32_t I2C_ReadRegister(I2C_TypeDef* I2Cx, uint8_t I2C_Register); + +/* Data transfers management functions ****************************************/ +void I2C_SendData(I2C_TypeDef* I2Cx, uint8_t Data); +uint8_t I2C_ReceiveData(I2C_TypeDef* I2Cx); + +/* DMA transfers management functions *****************************************/ +void I2C_DMACmd(I2C_TypeDef* I2Cx, uint32_t I2C_DMAReq, FunctionalState NewState); + +/* Interrupts and flags management functions **********************************/ +FlagStatus I2C_GetFlagStatus(I2C_TypeDef* I2Cx, uint32_t I2C_FLAG); +void I2C_ClearFlag(I2C_TypeDef* I2Cx, uint32_t I2C_FLAG); +ITStatus I2C_GetITStatus(I2C_TypeDef* I2Cx, uint32_t I2C_IT); +void I2C_ClearITPendingBit(I2C_TypeDef* I2Cx, uint32_t I2C_IT); + + +#ifdef __cplusplus +} +#endif + +#endif /*__STM32F0XX_I2C_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_iwdg.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_iwdg.h new file mode 100644 index 00000000..e65c8ded --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_iwdg.h @@ -0,0 +1,140 @@ +/** + ****************************************************************************** + * @file stm32f0xx_iwdg.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the IWDG + * firmware library. + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_IWDG_H +#define __STM32F0XX_IWDG_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup IWDG + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup IWDG_Exported_Constants + * @{ + */ + +/** @defgroup IWDG_WriteAccess + * @{ + */ + +#define IWDG_WriteAccess_Enable ((uint16_t)0x5555) +#define IWDG_WriteAccess_Disable ((uint16_t)0x0000) +#define IS_IWDG_WRITE_ACCESS(ACCESS) (((ACCESS) == IWDG_WriteAccess_Enable) || \ + ((ACCESS) == IWDG_WriteAccess_Disable)) +/** + * @} + */ + +/** @defgroup IWDG_prescaler + * @{ + */ + +#define IWDG_Prescaler_4 ((uint8_t)0x00) +#define IWDG_Prescaler_8 ((uint8_t)0x01) +#define IWDG_Prescaler_16 ((uint8_t)0x02) +#define IWDG_Prescaler_32 ((uint8_t)0x03) +#define IWDG_Prescaler_64 ((uint8_t)0x04) +#define IWDG_Prescaler_128 ((uint8_t)0x05) +#define IWDG_Prescaler_256 ((uint8_t)0x06) +#define IS_IWDG_PRESCALER(PRESCALER) (((PRESCALER) == IWDG_Prescaler_4) || \ + ((PRESCALER) == IWDG_Prescaler_8) || \ + ((PRESCALER) == IWDG_Prescaler_16) || \ + ((PRESCALER) == IWDG_Prescaler_32) || \ + ((PRESCALER) == IWDG_Prescaler_64) || \ + ((PRESCALER) == IWDG_Prescaler_128)|| \ + ((PRESCALER) == IWDG_Prescaler_256)) +/** + * @} + */ + +/** @defgroup IWDG_Flag + * @{ + */ + +#define IWDG_FLAG_PVU IWDG_SR_PVU +#define IWDG_FLAG_RVU IWDG_SR_RVU +#define IWDG_FLAG_WVU IWDG_SR_WVU +#define IS_IWDG_FLAG(FLAG) (((FLAG) == IWDG_FLAG_PVU) || ((FLAG) == IWDG_FLAG_RVU) || \ + ((FLAG) == IWDG_FLAG_WVU)) + +#define IS_IWDG_RELOAD(RELOAD) ((RELOAD) <= 0xFFF) + +#define IS_IWDG_WINDOW_VALUE(VALUE) ((VALUE) <= 0xFFF) +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Prescaler and Counter configuration functions ******************************/ +void IWDG_WriteAccessCmd(uint16_t IWDG_WriteAccess); +void IWDG_SetPrescaler(uint8_t IWDG_Prescaler); +void IWDG_SetReload(uint16_t Reload); +void IWDG_ReloadCounter(void); +void IWDG_SetWindowValue(uint16_t WindowValue); + +/* IWDG activation function ***************************************************/ +void IWDG_Enable(void); + +/* Flag management function ***************************************************/ +FlagStatus IWDG_GetFlagStatus(uint16_t IWDG_FLAG); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_IWDG_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_misc.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_misc.h new file mode 100644 index 00000000..750dc287 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_misc.h @@ -0,0 +1,143 @@ +/** + ****************************************************************************** + * @file stm32f0xx_misc.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the miscellaneous + * firmware library functions (add-on to CMSIS functions). + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_MISC_H +#define __STM32F0XX_MISC_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup MISC + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief NVIC Init Structure definition + */ + +typedef struct +{ + uint8_t NVIC_IRQChannel; /*!< Specifies the IRQ channel to be enabled or disabled. + This parameter can be a value of @ref IRQn_Type + (For the complete STM32 Devices IRQ Channels list, + please refer to stm32f0xx.h file) */ + + uint8_t NVIC_IRQChannelPriority; /*!< Specifies the priority level for the IRQ channel specified + in NVIC_IRQChannel. This parameter can be a value + between 0 and 3. */ + + FunctionalState NVIC_IRQChannelCmd; /*!< Specifies whether the IRQ channel defined in NVIC_IRQChannel + will be enabled or disabled. + This parameter can be set either to ENABLE or DISABLE */ +} NVIC_InitTypeDef; + +/** + * +@verbatim + +@endverbatim +*/ + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup MISC_Exported_Constants + * @{ + */ + +/** @defgroup MISC_System_Low_Power + * @{ + */ + +#define NVIC_LP_SEVONPEND ((uint8_t)0x10) +#define NVIC_LP_SLEEPDEEP ((uint8_t)0x04) +#define NVIC_LP_SLEEPONEXIT ((uint8_t)0x02) +#define IS_NVIC_LP(LP) (((LP) == NVIC_LP_SEVONPEND) || \ + ((LP) == NVIC_LP_SLEEPDEEP) || \ + ((LP) == NVIC_LP_SLEEPONEXIT)) +/** + * @} + */ + +/** @defgroup MISC_Preemption_Priority_Group + * @{ + */ +#define IS_NVIC_PRIORITY(PRIORITY) ((PRIORITY) < 0x04) + +/** + * @} + */ + +/** @defgroup MISC_SysTick_clock_source + * @{ + */ + +#define SysTick_CLKSource_HCLK_Div8 ((uint32_t)0xFFFFFFFB) +#define SysTick_CLKSource_HCLK ((uint32_t)0x00000004) +#define IS_SYSTICK_CLK_SOURCE(SOURCE) (((SOURCE) == SysTick_CLKSource_HCLK) || \ + ((SOURCE) == SysTick_CLKSource_HCLK_Div8)) +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +void NVIC_Init(NVIC_InitTypeDef* NVIC_InitStruct); +void NVIC_SystemLPConfig(uint8_t LowPowerMode, FunctionalState NewState); +void SysTick_CLKSourceConfig(uint32_t SysTick_CLKSource); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_MISC_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_pwr.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_pwr.h new file mode 100644 index 00000000..7044b678 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_pwr.h @@ -0,0 +1,197 @@ +/** + ****************************************************************************** + * @file stm32f0xx_pwr.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the PWR firmware + * library. + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_PWR_H +#define __STM32F0XX_PWR_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup PWR + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup PWR_Exported_Constants + * @{ + */ + +/** @defgroup PWR_PVD_detection_level + * @brief This parameters are only applicable for STM32F051 and STM32F072 devices + * @{ + */ + +#define PWR_PVDLevel_0 PWR_CR_PLS_LEV0 +#define PWR_PVDLevel_1 PWR_CR_PLS_LEV1 +#define PWR_PVDLevel_2 PWR_CR_PLS_LEV2 +#define PWR_PVDLevel_3 PWR_CR_PLS_LEV3 +#define PWR_PVDLevel_4 PWR_CR_PLS_LEV4 +#define PWR_PVDLevel_5 PWR_CR_PLS_LEV5 +#define PWR_PVDLevel_6 PWR_CR_PLS_LEV6 +#define PWR_PVDLevel_7 PWR_CR_PLS_LEV7 + +#define IS_PWR_PVD_LEVEL(LEVEL) (((LEVEL) == PWR_PVDLevel_0) || ((LEVEL) == PWR_PVDLevel_1)|| \ + ((LEVEL) == PWR_PVDLevel_2) || ((LEVEL) == PWR_PVDLevel_3)|| \ + ((LEVEL) == PWR_PVDLevel_4) || ((LEVEL) == PWR_PVDLevel_5)|| \ + ((LEVEL) == PWR_PVDLevel_6) || ((LEVEL) == PWR_PVDLevel_7)) +/** + * @} + */ + +/** @defgroup PWR_WakeUp_Pins + * @{ + */ + +#define PWR_WakeUpPin_1 PWR_CSR_EWUP1 +#define PWR_WakeUpPin_2 PWR_CSR_EWUP2 +#define PWR_WakeUpPin_3 PWR_CSR_EWUP3 /*!< only applicable for STM32F072 devices */ +#define PWR_WakeUpPin_4 PWR_CSR_EWUP4 /*!< only applicable for STM32F072 devices */ +#define PWR_WakeUpPin_5 PWR_CSR_EWUP5 /*!< only applicable for STM32F072 devices */ +#define PWR_WakeUpPin_6 PWR_CSR_EWUP6 /*!< only applicable for STM32F072 devices */ +#define PWR_WakeUpPin_7 PWR_CSR_EWUP7 /*!< only applicable for STM32F072 devices */ +#define PWR_WakeUpPin_8 PWR_CSR_EWUP8 /*!< only applicable for STM32F072 devices */ +#define IS_PWR_WAKEUP_PIN(PIN) (((PIN) == PWR_WakeUpPin_1) || ((PIN) == PWR_WakeUpPin_2) || \ + ((PIN) == PWR_WakeUpPin_3) || ((PIN) == PWR_WakeUpPin_4) || \ + ((PIN) == PWR_WakeUpPin_5) || ((PIN) == PWR_WakeUpPin_6) || \ + ((PIN) == PWR_WakeUpPin_7) || ((PIN) == PWR_WakeUpPin_8)) +/** + * @} + */ + + +/** @defgroup PWR_Regulator_state_is_Sleep_STOP_mode + * @{ + */ + +#define PWR_Regulator_ON ((uint32_t)0x00000000) +#define PWR_Regulator_LowPower PWR_CR_LPSDSR +#define IS_PWR_REGULATOR(REGULATOR) (((REGULATOR) == PWR_Regulator_ON) || \ + ((REGULATOR) == PWR_Regulator_LowPower)) +/** + * @} + */ + +/** @defgroup PWR_SLEEP_mode_entry + * @{ + */ + +#define PWR_SLEEPEntry_WFI ((uint8_t)0x01) +#define PWR_SLEEPEntry_WFE ((uint8_t)0x02) +#define IS_PWR_SLEEP_ENTRY(ENTRY) (((ENTRY) == PWR_SLEEPEntry_WFI) || ((ENTRY) == PWR_SLEEPEntry_WFE)) + +/** + * @} + */ + +/** @defgroup PWR_STOP_mode_entry + * @{ + */ + +#define PWR_STOPEntry_WFI ((uint8_t)0x01) +#define PWR_STOPEntry_WFE ((uint8_t)0x02) +#define PWR_STOPEntry_SLEEPONEXIT ((uint8_t)0x03) +#define IS_PWR_STOP_ENTRY(ENTRY) (((ENTRY) == PWR_STOPEntry_WFI) || ((ENTRY) == PWR_STOPEntry_WFE) ||\ + ((ENTRY) == PWR_STOPEntry_SLEEPONEXIT)) + +/** + * @} + */ + +/** @defgroup PWR_Flag + * @{ + */ + +#define PWR_FLAG_WU PWR_CSR_WUF +#define PWR_FLAG_SB PWR_CSR_SBF +#define PWR_FLAG_PVDO PWR_CSR_PVDO /*!< Not applicable for STM32F030 devices */ +#define PWR_FLAG_VREFINTRDY PWR_CSR_VREFINTRDYF + +#define IS_PWR_GET_FLAG(FLAG) (((FLAG) == PWR_FLAG_WU) || ((FLAG) == PWR_FLAG_SB) || \ + ((FLAG) == PWR_FLAG_PVDO) || ((FLAG) == PWR_FLAG_VREFINTRDY)) + +#define IS_PWR_CLEAR_FLAG(FLAG) (((FLAG) == PWR_FLAG_WU) || ((FLAG) == PWR_FLAG_SB)) +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Function used to set the PWR configuration to the default reset state ******/ +void PWR_DeInit(void); + +/* Backup Domain Access function **********************************************/ +void PWR_BackupAccessCmd(FunctionalState NewState); + +/* PVD configuration functions ************************************************/ +void PWR_PVDLevelConfig(uint32_t PWR_PVDLevel); /*!< only applicable for STM32F051 and STM32F072 devices */ +void PWR_PVDCmd(FunctionalState NewState); /*!< only applicable for STM32F051 and STM32F072 devices */ + +/* WakeUp pins configuration functions ****************************************/ +void PWR_WakeUpPinCmd(uint32_t PWR_WakeUpPin, FunctionalState NewState); + +/* Low Power modes configuration functions ************************************/ +void PWR_EnterSleepMode(uint8_t PWR_SLEEPEntry); +void PWR_EnterSTOPMode(uint32_t PWR_Regulator, uint8_t PWR_STOPEntry); +void PWR_EnterSTANDBYMode(void); + +/* Flags management functions *************************************************/ +FlagStatus PWR_GetFlagStatus(uint32_t PWR_FLAG); +void PWR_ClearFlag(uint32_t PWR_FLAG); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_PWR_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_rcc.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_rcc.h new file mode 100644 index 00000000..cf3c10a3 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_rcc.h @@ -0,0 +1,624 @@ +/** + ****************************************************************************** + * @file stm32f0xx_rcc.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the RCC + * firmware library. + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_RCC_H +#define __STM32F0XX_RCC_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup RCC + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +typedef struct +{ + uint32_t SYSCLK_Frequency; + uint32_t HCLK_Frequency; + uint32_t PCLK_Frequency; + uint32_t ADCCLK_Frequency; + uint32_t CECCLK_Frequency; + uint32_t I2C1CLK_Frequency; + uint32_t USART1CLK_Frequency; + uint32_t USART2CLK_Frequency; /*!< Only applicable for STM32F072 and STM32F091 devices */ + uint32_t USART3CLK_Frequency; /*!< Only applicable for STM32F091 devices */ + uint32_t USBCLK_Frequency; /*!< Only applicable for STM32F072 devices */ +}RCC_ClocksTypeDef; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup RCC_Exported_Constants + * @{ + */ + +/** @defgroup RCC_HSE_configuration + * @{ + */ + +#define RCC_HSE_OFF ((uint8_t)0x00) +#define RCC_HSE_ON ((uint8_t)0x01) +#define RCC_HSE_Bypass ((uint8_t)0x05) +#define IS_RCC_HSE(HSE) (((HSE) == RCC_HSE_OFF) || ((HSE) == RCC_HSE_ON) || \ + ((HSE) == RCC_HSE_Bypass)) + +/** + * @} + */ + +/** @defgroup RCC_PLL_Clock_Source + * @{ + */ + +#define RCC_PLLSource_HSI_Div2 RCC_CFGR_PLLSRC_HSI_Div2 +#define RCC_PLLSource_PREDIV1 RCC_CFGR_PLLSRC_HSE_PREDIV /* Old HSEPREDIV1 bit definition, maintained for legacy purpose */ +#define RCC_PLLSource_HSE RCC_CFGR_PLLSRC_HSE_PREDIV /*!< Only applicable for STM32F072 devices */ +#define RCC_PLLSource_HSI48 RCC_CFGR_PLLSRC_HSI48_PREDIV /*!< Only applicable for STM32F072 devices */ +#define RCC_PLLSource_HSI RCC_CFGR_PLLSRC_HSI_PREDIV /*!< Only applicable for STM32F072 devices */ + +#define IS_RCC_PLL_SOURCE(SOURCE) (((SOURCE) == RCC_PLLSource_HSI_Div2) || \ + ((SOURCE) == RCC_PLLSource_HSI48) || \ + ((SOURCE) == RCC_PLLSource_HSI) || \ + ((SOURCE) == RCC_PLLSource_HSE) || \ + ((SOURCE) == RCC_PLLSource_PREDIV1)) +/** + * @} + */ + +/** @defgroup RCC_PLL_Multiplication_Factor + * @{ + */ + +#define RCC_PLLMul_2 RCC_CFGR_PLLMULL2 +#define RCC_PLLMul_3 RCC_CFGR_PLLMULL3 +#define RCC_PLLMul_4 RCC_CFGR_PLLMULL4 +#define RCC_PLLMul_5 RCC_CFGR_PLLMULL5 +#define RCC_PLLMul_6 RCC_CFGR_PLLMULL6 +#define RCC_PLLMul_7 RCC_CFGR_PLLMULL7 +#define RCC_PLLMul_8 RCC_CFGR_PLLMULL8 +#define RCC_PLLMul_9 RCC_CFGR_PLLMULL9 +#define RCC_PLLMul_10 RCC_CFGR_PLLMULL10 +#define RCC_PLLMul_11 RCC_CFGR_PLLMULL11 +#define RCC_PLLMul_12 RCC_CFGR_PLLMULL12 +#define RCC_PLLMul_13 RCC_CFGR_PLLMULL13 +#define RCC_PLLMul_14 RCC_CFGR_PLLMULL14 +#define RCC_PLLMul_15 RCC_CFGR_PLLMULL15 +#define RCC_PLLMul_16 RCC_CFGR_PLLMULL16 +#define IS_RCC_PLL_MUL(MUL) (((MUL) == RCC_PLLMul_2) || ((MUL) == RCC_PLLMul_3) || \ + ((MUL) == RCC_PLLMul_4) || ((MUL) == RCC_PLLMul_5) || \ + ((MUL) == RCC_PLLMul_6) || ((MUL) == RCC_PLLMul_7) || \ + ((MUL) == RCC_PLLMul_8) || ((MUL) == RCC_PLLMul_9) || \ + ((MUL) == RCC_PLLMul_10) || ((MUL) == RCC_PLLMul_11) || \ + ((MUL) == RCC_PLLMul_12) || ((MUL) == RCC_PLLMul_13) || \ + ((MUL) == RCC_PLLMul_14) || ((MUL) == RCC_PLLMul_15) || \ + ((MUL) == RCC_PLLMul_16)) +/** + * @} + */ + +/** @defgroup RCC_PREDIV1_division_factor + * @{ + */ +#define RCC_PREDIV1_Div1 RCC_CFGR2_PREDIV1_DIV1 +#define RCC_PREDIV1_Div2 RCC_CFGR2_PREDIV1_DIV2 +#define RCC_PREDIV1_Div3 RCC_CFGR2_PREDIV1_DIV3 +#define RCC_PREDIV1_Div4 RCC_CFGR2_PREDIV1_DIV4 +#define RCC_PREDIV1_Div5 RCC_CFGR2_PREDIV1_DIV5 +#define RCC_PREDIV1_Div6 RCC_CFGR2_PREDIV1_DIV6 +#define RCC_PREDIV1_Div7 RCC_CFGR2_PREDIV1_DIV7 +#define RCC_PREDIV1_Div8 RCC_CFGR2_PREDIV1_DIV8 +#define RCC_PREDIV1_Div9 RCC_CFGR2_PREDIV1_DIV9 +#define RCC_PREDIV1_Div10 RCC_CFGR2_PREDIV1_DIV10 +#define RCC_PREDIV1_Div11 RCC_CFGR2_PREDIV1_DIV11 +#define RCC_PREDIV1_Div12 RCC_CFGR2_PREDIV1_DIV12 +#define RCC_PREDIV1_Div13 RCC_CFGR2_PREDIV1_DIV13 +#define RCC_PREDIV1_Div14 RCC_CFGR2_PREDIV1_DIV14 +#define RCC_PREDIV1_Div15 RCC_CFGR2_PREDIV1_DIV15 +#define RCC_PREDIV1_Div16 RCC_CFGR2_PREDIV1_DIV16 + +#define IS_RCC_PREDIV1(PREDIV1) (((PREDIV1) == RCC_PREDIV1_Div1) || ((PREDIV1) == RCC_PREDIV1_Div2) || \ + ((PREDIV1) == RCC_PREDIV1_Div3) || ((PREDIV1) == RCC_PREDIV1_Div4) || \ + ((PREDIV1) == RCC_PREDIV1_Div5) || ((PREDIV1) == RCC_PREDIV1_Div6) || \ + ((PREDIV1) == RCC_PREDIV1_Div7) || ((PREDIV1) == RCC_PREDIV1_Div8) || \ + ((PREDIV1) == RCC_PREDIV1_Div9) || ((PREDIV1) == RCC_PREDIV1_Div10) || \ + ((PREDIV1) == RCC_PREDIV1_Div11) || ((PREDIV1) == RCC_PREDIV1_Div12) || \ + ((PREDIV1) == RCC_PREDIV1_Div13) || ((PREDIV1) == RCC_PREDIV1_Div14) || \ + ((PREDIV1) == RCC_PREDIV1_Div15) || ((PREDIV1) == RCC_PREDIV1_Div16)) +/** + * @} + */ + +/** @defgroup RCC_System_Clock_Source + * @{ + */ + +#define RCC_SYSCLKSource_HSI RCC_CFGR_SW_HSI +#define RCC_SYSCLKSource_HSE RCC_CFGR_SW_HSE +#define RCC_SYSCLKSource_PLLCLK RCC_CFGR_SW_PLL +#define RCC_SYSCLKSource_HSI48 RCC_CFGR_SW_HSI48 /*!< Only applicable for STM32F072 devices */ + +#define IS_RCC_SYSCLK_SOURCE(SOURCE) (((SOURCE) == RCC_SYSCLKSource_HSI) || \ + ((SOURCE) == RCC_SYSCLKSource_HSE) || \ + ((SOURCE) == RCC_SYSCLKSource_HSI48) || \ + ((SOURCE) == RCC_SYSCLKSource_PLLCLK)) +/** + * @} + */ + +/** @defgroup RCC_AHB_Clock_Source + * @{ + */ + +#define RCC_SYSCLK_Div1 RCC_CFGR_HPRE_DIV1 +#define RCC_SYSCLK_Div2 RCC_CFGR_HPRE_DIV2 +#define RCC_SYSCLK_Div4 RCC_CFGR_HPRE_DIV4 +#define RCC_SYSCLK_Div8 RCC_CFGR_HPRE_DIV8 +#define RCC_SYSCLK_Div16 RCC_CFGR_HPRE_DIV16 +#define RCC_SYSCLK_Div64 RCC_CFGR_HPRE_DIV64 +#define RCC_SYSCLK_Div128 RCC_CFGR_HPRE_DIV128 +#define RCC_SYSCLK_Div256 RCC_CFGR_HPRE_DIV256 +#define RCC_SYSCLK_Div512 RCC_CFGR_HPRE_DIV512 +#define IS_RCC_HCLK(HCLK) (((HCLK) == RCC_SYSCLK_Div1) || ((HCLK) == RCC_SYSCLK_Div2) || \ + ((HCLK) == RCC_SYSCLK_Div4) || ((HCLK) == RCC_SYSCLK_Div8) || \ + ((HCLK) == RCC_SYSCLK_Div16) || ((HCLK) == RCC_SYSCLK_Div64) || \ + ((HCLK) == RCC_SYSCLK_Div128) || ((HCLK) == RCC_SYSCLK_Div256) || \ + ((HCLK) == RCC_SYSCLK_Div512)) +/** + * @} + */ + +/** @defgroup RCC_APB_Clock_Source + * @{ + */ + +#define RCC_HCLK_Div1 RCC_CFGR_PPRE_DIV1 +#define RCC_HCLK_Div2 RCC_CFGR_PPRE_DIV2 +#define RCC_HCLK_Div4 RCC_CFGR_PPRE_DIV4 +#define RCC_HCLK_Div8 RCC_CFGR_PPRE_DIV8 +#define RCC_HCLK_Div16 RCC_CFGR_PPRE_DIV16 +#define IS_RCC_PCLK(PCLK) (((PCLK) == RCC_HCLK_Div1) || ((PCLK) == RCC_HCLK_Div2) || \ + ((PCLK) == RCC_HCLK_Div4) || ((PCLK) == RCC_HCLK_Div8) || \ + ((PCLK) == RCC_HCLK_Div16)) +/** + * @} + */ + +/** @defgroup RCC_ADC_clock_source + * @{ + */ +/* These defines are obsolete and kept for legacy purpose only. +Proper ADC clock selection is done within ADC driver by mean of the ADC_ClockModeConfig() function */ +#define RCC_ADCCLK_HSI14 ((uint32_t)0x00000000) +#define RCC_ADCCLK_PCLK_Div2 ((uint32_t)0x01000000) +#define RCC_ADCCLK_PCLK_Div4 ((uint32_t)0x01004000) + +#define IS_RCC_ADCCLK(ADCCLK) (((ADCCLK) == RCC_ADCCLK_HSI14) || ((ADCCLK) == RCC_ADCCLK_PCLK_Div2) || \ + ((ADCCLK) == RCC_ADCCLK_PCLK_Div4)) + +/** + * @} + */ + +/** @defgroup RCC_CEC_clock_source + * @{ + */ + +#define RCC_CECCLK_HSI_Div244 ((uint32_t)0x00000000) +#define RCC_CECCLK_LSE RCC_CFGR3_CECSW + +#define IS_RCC_CECCLK(CECCLK) (((CECCLK) == RCC_CECCLK_HSI_Div244) || ((CECCLK) == RCC_CECCLK_LSE)) + +/** + * @} + */ + +/** @defgroup RCC_I2C_clock_source + * @{ + */ + +#define RCC_I2C1CLK_HSI ((uint32_t)0x00000000) +#define RCC_I2C1CLK_SYSCLK RCC_CFGR3_I2C1SW + +#define IS_RCC_I2CCLK(I2CCLK) (((I2CCLK) == RCC_I2C1CLK_HSI) || ((I2CCLK) == RCC_I2C1CLK_SYSCLK)) + +/** + * @} + */ + +/** @defgroup RCC_USB_clock_source + * @brief Applicable only for STM32F072 devices + * @{ + */ + +#define RCC_USBCLK_HSI48 ((uint32_t)0x00000000) +#define RCC_USBCLK_PLLCLK RCC_CFGR3_USBSW + +#define IS_RCC_USBCLK(USBCLK) (((USBCLK) == RCC_USBCLK_HSI48) || ((USBCLK) == RCC_USBCLK_PLLCLK)) + +/** + * @} + */ + +/** @defgroup RCC_USART_clock_source + * @{ + */ + +#define RCC_USART1CLK_PCLK ((uint32_t)0x10000000) +#define RCC_USART1CLK_SYSCLK ((uint32_t)0x10000001) +#define RCC_USART1CLK_LSE ((uint32_t)0x10000002) +#define RCC_USART1CLK_HSI ((uint32_t)0x10000003) + +#define RCC_USART2CLK_PCLK ((uint32_t)0x20000000) /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define RCC_USART2CLK_SYSCLK ((uint32_t)0x20010000) /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define RCC_USART2CLK_LSE ((uint32_t)0x20020000) /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define RCC_USART2CLK_HSI ((uint32_t)0x20030000) /*!< Only applicable for STM32F072 and STM32F091 devices */ + +#define RCC_USART3CLK_PCLK ((uint32_t)0x30000000) /*!< Only applicable for STM32F091 devices */ +#define RCC_USART3CLK_SYSCLK ((uint32_t)0x30040000) /*!< Only applicable for STM32F091 devices */ +#define RCC_USART3CLK_LSE ((uint32_t)0x30080000) /*!< Only applicable for STM32F091 devices */ +#define RCC_USART3CLK_HSI ((uint32_t)0x300C0000) /*!< Only applicable for STM32F091 devices */ + + +#define IS_RCC_USARTCLK(USARTCLK) (((USARTCLK) == RCC_USART1CLK_PCLK) || \ + ((USARTCLK) == RCC_USART1CLK_SYSCLK) || \ + ((USARTCLK) == RCC_USART1CLK_LSE) || \ + ((USARTCLK) == RCC_USART1CLK_HSI) || \ + ((USARTCLK) == RCC_USART2CLK_PCLK) || \ + ((USARTCLK) == RCC_USART2CLK_SYSCLK) || \ + ((USARTCLK) == RCC_USART2CLK_LSE) || \ + ((USARTCLK) == RCC_USART2CLK_HSI)|| \ + ((USARTCLK) == RCC_USART3CLK_PCLK) || \ + ((USARTCLK) == RCC_USART3CLK_SYSCLK) || \ + ((USARTCLK) == RCC_USART3CLK_LSE) || \ + ((USARTCLK) == RCC_USART3CLK_HSI)) + +/** + * @} + */ + +/** @defgroup RCC_Interrupt_Source + * @{ + */ + +#define RCC_IT_LSIRDY ((uint8_t)0x01) +#define RCC_IT_LSERDY ((uint8_t)0x02) +#define RCC_IT_HSIRDY ((uint8_t)0x04) +#define RCC_IT_HSERDY ((uint8_t)0x08) +#define RCC_IT_PLLRDY ((uint8_t)0x10) +#define RCC_IT_HSI14RDY ((uint8_t)0x20) +#define RCC_IT_HSI48RDY ((uint8_t)0x40) /*!< Only applicable for STM32F072 devices */ +#define RCC_IT_CSS ((uint8_t)0x80) + +#define IS_RCC_IT(IT) ((((IT) & (uint8_t)0x80) == 0x00) && ((IT) != 0x00)) + +#define IS_RCC_GET_IT(IT) (((IT) == RCC_IT_LSIRDY) || ((IT) == RCC_IT_LSERDY) || \ + ((IT) == RCC_IT_HSIRDY) || ((IT) == RCC_IT_HSERDY) || \ + ((IT) == RCC_IT_PLLRDY) || ((IT) == RCC_IT_HSI14RDY) || \ + ((IT) == RCC_IT_CSS) || ((IT) == RCC_IT_HSI48RDY)) + +#define IS_RCC_CLEAR_IT(IT) ((IT) != 0x00) + +/** + * @} + */ + +/** @defgroup RCC_LSE_Configuration + * @{ + */ + +#define RCC_LSE_OFF ((uint32_t)0x00000000) +#define RCC_LSE_ON RCC_BDCR_LSEON +#define RCC_LSE_Bypass ((uint32_t)(RCC_BDCR_LSEON | RCC_BDCR_LSEBYP)) +#define IS_RCC_LSE(LSE) (((LSE) == RCC_LSE_OFF) || ((LSE) == RCC_LSE_ON) || \ + ((LSE) == RCC_LSE_Bypass)) +/** + * @} + */ + +/** @defgroup RCC_RTC_Clock_Source + * @{ + */ + +#define RCC_RTCCLKSource_LSE RCC_BDCR_RTCSEL_LSE +#define RCC_RTCCLKSource_LSI RCC_BDCR_RTCSEL_LSI +#define RCC_RTCCLKSource_HSE_Div32 RCC_BDCR_RTCSEL_HSE + +#define IS_RCC_RTCCLK_SOURCE(SOURCE) (((SOURCE) == RCC_RTCCLKSource_LSE) || \ + ((SOURCE) == RCC_RTCCLKSource_LSI) || \ + ((SOURCE) == RCC_RTCCLKSource_HSE_Div32)) +/** + * @} + */ + +/** @defgroup RCC_LSE_Drive_Configuration + * @{ + */ + +#define RCC_LSEDrive_Low ((uint32_t)0x00000000) +#define RCC_LSEDrive_MediumLow RCC_BDCR_LSEDRV_0 +#define RCC_LSEDrive_MediumHigh RCC_BDCR_LSEDRV_1 +#define RCC_LSEDrive_High RCC_BDCR_LSEDRV +#define IS_RCC_LSE_DRIVE(DRIVE) (((DRIVE) == RCC_LSEDrive_Low) || ((DRIVE) == RCC_LSEDrive_MediumLow) || \ + ((DRIVE) == RCC_LSEDrive_MediumHigh) || ((DRIVE) == RCC_LSEDrive_High)) +/** + * @} + */ + +/** @defgroup RCC_AHB_Peripherals + * @{ + */ + +#define RCC_AHBPeriph_GPIOA RCC_AHBENR_GPIOAEN +#define RCC_AHBPeriph_GPIOB RCC_AHBENR_GPIOBEN +#define RCC_AHBPeriph_GPIOC RCC_AHBENR_GPIOCEN +#define RCC_AHBPeriph_GPIOD RCC_AHBENR_GPIODEN +#define RCC_AHBPeriph_GPIOE RCC_AHBENR_GPIOEEN /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define RCC_AHBPeriph_GPIOF RCC_AHBENR_GPIOFEN +#define RCC_AHBPeriph_TS RCC_AHBENR_TSEN +#define RCC_AHBPeriph_CRC RCC_AHBENR_CRCEN +#define RCC_AHBPeriph_FLITF RCC_AHBENR_FLITFEN +#define RCC_AHBPeriph_SRAM RCC_AHBENR_SRAMEN +#define RCC_AHBPeriph_DMA1 RCC_AHBENR_DMA1EN +#define RCC_AHBPeriph_DMA2 RCC_AHBENR_DMA2EN + +#define IS_RCC_AHB_PERIPH(PERIPH) ((((PERIPH) & 0xFE81FFA8) == 0x00) && ((PERIPH) != 0x00)) +#define IS_RCC_AHB_RST_PERIPH(PERIPH) ((((PERIPH) & 0xFE81FFA8) == 0x00) && ((PERIPH) != 0x00)) + +/** + * @} + */ + +/** @defgroup RCC_APB2_Peripherals + * @{ + */ + +#define RCC_APB2Periph_SYSCFG RCC_APB2ENR_SYSCFGEN +#define RCC_APB2Periph_USART6 RCC_APB2ENR_USART6EN +#define RCC_APB2Periph_USART7 RCC_APB2ENR_USART7EN +#define RCC_APB2Periph_USART8 RCC_APB2ENR_USART8EN +#define RCC_APB2Periph_ADC1 RCC_APB2ENR_ADC1EN +#define RCC_APB2Periph_TIM1 RCC_APB2ENR_TIM1EN +#define RCC_APB2Periph_SPI1 RCC_APB2ENR_SPI1EN +#define RCC_APB2Periph_USART1 RCC_APB2ENR_USART1EN +#define RCC_APB2Periph_TIM15 RCC_APB2ENR_TIM15EN +#define RCC_APB2Periph_TIM16 RCC_APB2ENR_TIM16EN +#define RCC_APB2Periph_TIM17 RCC_APB2ENR_TIM17EN +#define RCC_APB2Periph_DBGMCU RCC_APB2ENR_DBGMCUEN + +#define IS_RCC_APB2_PERIPH(PERIPH) ((((PERIPH) & 0xFFB8A51E) == 0x00) && ((PERIPH) != 0x00)) + +/** + * @} + */ + +/** @defgroup RCC_APB1_Peripherals + * @{ + */ + +#define RCC_APB1Periph_TIM2 RCC_APB1ENR_TIM2EN /*!< Only applicable for STM32F051, STM32F072 and STM32F091 devices */ +#define RCC_APB1Periph_TIM3 RCC_APB1ENR_TIM3EN +#define RCC_APB1Periph_TIM6 RCC_APB1ENR_TIM6EN +#define RCC_APB1Periph_TIM7 RCC_APB1ENR_TIM7EN /*!< Only applicable for STM32F072 devices */ +#define RCC_APB1Periph_TIM14 RCC_APB1ENR_TIM14EN +#define RCC_APB1Periph_WWDG RCC_APB1ENR_WWDGEN +#define RCC_APB1Periph_SPI2 RCC_APB1ENR_SPI2EN +#define RCC_APB1Periph_USART2 RCC_APB1ENR_USART2EN +#define RCC_APB1Periph_USART3 RCC_APB1ENR_USART3EN /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define RCC_APB1Periph_USART4 RCC_APB1ENR_USART4EN /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define RCC_APB1Periph_USART5 RCC_APB1ENR_USART5EN /*!< Only applicable for STM32F091 devices */ +#define RCC_APB1Periph_I2C1 RCC_APB1ENR_I2C1EN +#define RCC_APB1Periph_I2C2 RCC_APB1ENR_I2C2EN +#define RCC_APB1Periph_USB RCC_APB1ENR_USBEN /*!< Only applicable for STM32F072 and STM32F042 devices */ +#define RCC_APB1Periph_CAN RCC_APB1ENR_CANEN /*!< Only applicable for STM32F072, STM32F042 and STM32F091 devices */ +#define RCC_APB1Periph_CRS RCC_APB1ENR_CRSEN /*!< Only applicable for STM32F072, STM32F042 and STM32F091 devices */ +#define RCC_APB1Periph_PWR RCC_APB1ENR_PWREN +#define RCC_APB1Periph_DAC RCC_APB1ENR_DACEN /*!< Only applicable for STM32F051, STM32F072 and STM32F091 devices */ +#define RCC_APB1Periph_CEC RCC_APB1ENR_CECEN /*!< Only applicable for STM32F051, STM32F042, STM32F072 and STM32F091 devices */ + +#define IS_RCC_APB1_PERIPH(PERIPH) ((((PERIPH) & 0x8581B6CC) == 0x00) && ((PERIPH) != 0x00)) +/** + * @} + */ + +/** @defgroup RCC_MCO_Clock_Source + * @{ + */ + +#define RCC_MCOSource_NoClock ((uint8_t)0x00) +#define RCC_MCOSource_HSI14 ((uint8_t)0x01) +#define RCC_MCOSource_LSI ((uint8_t)0x02) +#define RCC_MCOSource_LSE ((uint8_t)0x03) +#define RCC_MCOSource_SYSCLK ((uint8_t)0x04) +#define RCC_MCOSource_HSI ((uint8_t)0x05) +#define RCC_MCOSource_HSE ((uint8_t)0x06) +#define RCC_MCOSource_PLLCLK_Div2 ((uint8_t)0x07) +#define RCC_MCOSource_HSI48 ((uint8_t)0x08) /*!< Only applicable for STM32F072 devices */ +#define RCC_MCOSource_PLLCLK ((uint8_t)0x87) + +#define IS_RCC_MCO_SOURCE(SOURCE) (((SOURCE) == RCC_MCOSource_NoClock) || ((SOURCE) == RCC_MCOSource_HSI14) || \ + ((SOURCE) == RCC_MCOSource_SYSCLK) || ((SOURCE) == RCC_MCOSource_HSI) || \ + ((SOURCE) == RCC_MCOSource_HSE) || ((SOURCE) == RCC_MCOSource_PLLCLK_Div2)|| \ + ((SOURCE) == RCC_MCOSource_LSI) || ((SOURCE) == RCC_MCOSource_HSI48) || \ + ((SOURCE) == RCC_MCOSource_PLLCLK) || ((SOURCE) == RCC_MCOSource_LSE)) +/** + * @} + */ + +/** @defgroup RCC_MCOPrescaler + * @{ + */ +#if !defined (STM32F051) +#define RCC_MCOPrescaler_1 RCC_CFGR_MCO_PRE_1 +#define RCC_MCOPrescaler_2 RCC_CFGR_MCO_PRE_2 +#define RCC_MCOPrescaler_4 RCC_CFGR_MCO_PRE_4 +#define RCC_MCOPrescaler_8 RCC_CFGR_MCO_PRE_8 +#define RCC_MCOPrescaler_16 RCC_CFGR_MCO_PRE_16 +#define RCC_MCOPrescaler_32 RCC_CFGR_MCO_PRE_32 +#define RCC_MCOPrescaler_64 RCC_CFGR_MCO_PRE_64 +#define RCC_MCOPrescaler_128 RCC_CFGR_MCO_PRE_128 + +#define IS_RCC_MCO_PRESCALER(PRESCALER) (((PRESCALER) == RCC_MCOPrescaler_1) || \ + ((PRESCALER) == RCC_MCOPrescaler_2) || \ + ((PRESCALER) == RCC_MCOPrescaler_4) || \ + ((PRESCALER) == RCC_MCOPrescaler_8) || \ + ((PRESCALER) == RCC_MCOPrescaler_16) || \ + ((PRESCALER) == RCC_MCOPrescaler_32) || \ + ((PRESCALER) == RCC_MCOPrescaler_64) || \ + ((PRESCALER) == RCC_MCOPrescaler_128)) +#endif /* STM32F051 */ +/** + * @} + */ + +/** @defgroup RCC_Flag + * @{ + */ +#define RCC_FLAG_HSIRDY ((uint8_t)0x01) +#define RCC_FLAG_HSERDY ((uint8_t)0x11) +#define RCC_FLAG_PLLRDY ((uint8_t)0x19) +#define RCC_FLAG_LSERDY ((uint8_t)0x21) +#define RCC_FLAG_LSIRDY ((uint8_t)0x41) +#define RCC_FLAG_V18PWRRSTF ((uint8_t)0x57) +#define RCC_FLAG_OBLRST ((uint8_t)0x59) +#define RCC_FLAG_PINRST ((uint8_t)0x5A) +#define RCC_FLAG_PORRST ((uint8_t)0x5B) +#define RCC_FLAG_SFTRST ((uint8_t)0x5C) +#define RCC_FLAG_IWDGRST ((uint8_t)0x5D) +#define RCC_FLAG_WWDGRST ((uint8_t)0x5E) +#define RCC_FLAG_LPWRRST ((uint8_t)0x5F) +#define RCC_FLAG_HSI14RDY ((uint8_t)0x61) +#define RCC_FLAG_HSI48RDY ((uint8_t)0x71) /*!< Only applicable for STM32F072 devices */ + +#define IS_RCC_FLAG(FLAG) (((FLAG) == RCC_FLAG_HSIRDY) || ((FLAG) == RCC_FLAG_HSERDY) || \ + ((FLAG) == RCC_FLAG_PLLRDY) || ((FLAG) == RCC_FLAG_LSERDY) || \ + ((FLAG) == RCC_FLAG_LSIRDY) || ((FLAG) == RCC_FLAG_OBLRST) || \ + ((FLAG) == RCC_FLAG_PINRST) || ((FLAG) == RCC_FLAG_PORRST) || \ + ((FLAG) == RCC_FLAG_SFTRST) || ((FLAG) == RCC_FLAG_IWDGRST) || \ + ((FLAG) == RCC_FLAG_WWDGRST) || ((FLAG) == RCC_FLAG_LPWRRST) || \ + ((FLAG) == RCC_FLAG_HSI14RDY)|| ((FLAG) == RCC_FLAG_HSI48RDY)|| \ + ((FLAG) == RCC_FLAG_V18PWRRSTF)) + +#define IS_RCC_HSI_CALIBRATION_VALUE(VALUE) ((VALUE) <= 0x1F) +#define IS_RCC_HSI14_CALIBRATION_VALUE(VALUE) ((VALUE) <= 0x1F) + +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Function used to set the RCC clock configuration to the default reset state */ +void RCC_DeInit(void); + +/* Internal/external clocks, PLL, CSS and MCO configuration functions *********/ +void RCC_HSEConfig(uint8_t RCC_HSE); +ErrorStatus RCC_WaitForHSEStartUp(void); +void RCC_AdjustHSICalibrationValue(uint8_t HSICalibrationValue); +void RCC_HSICmd(FunctionalState NewState); +void RCC_AdjustHSI14CalibrationValue(uint8_t HSI14CalibrationValue); +void RCC_HSI14Cmd(FunctionalState NewState); +void RCC_HSI14ADCRequestCmd(FunctionalState NewState); +void RCC_LSEConfig(uint32_t RCC_LSE); +void RCC_LSEDriveConfig(uint32_t RCC_LSEDrive); +void RCC_LSICmd(FunctionalState NewState); +void RCC_PLLConfig(uint32_t RCC_PLLSource, uint32_t RCC_PLLMul); +void RCC_PLLCmd(FunctionalState NewState); +void RCC_HSI48Cmd(FunctionalState NewState); /*!< Only applicable for STM32F072 devices */ +uint32_t RCC_GetHSI48CalibrationValue(void); /*!< Only applicable for STM32F072 devices */ +void RCC_PREDIV1Config(uint32_t RCC_PREDIV1_Div); +void RCC_ClockSecuritySystemCmd(FunctionalState NewState); +#ifdef STM32F051 +void RCC_MCOConfig(uint8_t RCC_MCOSource); +#else +void RCC_MCOConfig(uint8_t RCC_MCOSource,uint32_t RCC_MCOPrescaler); +#endif /* STM32F051 */ + +/* System, AHB and APB busses clocks configuration functions ******************/ +void RCC_SYSCLKConfig(uint32_t RCC_SYSCLKSource); +uint8_t RCC_GetSYSCLKSource(void); +void RCC_HCLKConfig(uint32_t RCC_SYSCLK); +void RCC_PCLKConfig(uint32_t RCC_HCLK); +void RCC_ADCCLKConfig(uint32_t RCC_ADCCLK); /* This function is obsolete. + For proper ADC clock selection, refer to + ADC_ClockModeConfig() in the ADC driver */ +void RCC_CECCLKConfig(uint32_t RCC_CECCLK); +void RCC_I2CCLKConfig(uint32_t RCC_I2CCLK); +void RCC_USARTCLKConfig(uint32_t RCC_USARTCLK); +void RCC_USBCLKConfig(uint32_t RCC_USBCLK); /*!< Only applicable for STM32F042 and STM32F072 devices */ +void RCC_GetClocksFreq(RCC_ClocksTypeDef* RCC_Clocks); + +/* Peripheral clocks configuration functions **********************************/ +void RCC_RTCCLKConfig(uint32_t RCC_RTCCLKSource); +void RCC_RTCCLKCmd(FunctionalState NewState); +void RCC_BackupResetCmd(FunctionalState NewState); + +void RCC_AHBPeriphClockCmd(uint32_t RCC_AHBPeriph, FunctionalState NewState); +void RCC_APB2PeriphClockCmd(uint32_t RCC_APB2Periph, FunctionalState NewState); +void RCC_APB1PeriphClockCmd(uint32_t RCC_APB1Periph, FunctionalState NewState); + +void RCC_AHBPeriphResetCmd(uint32_t RCC_AHBPeriph, FunctionalState NewState); +void RCC_APB2PeriphResetCmd(uint32_t RCC_APB2Periph, FunctionalState NewState); +void RCC_APB1PeriphResetCmd(uint32_t RCC_APB1Periph, FunctionalState NewState); + +/* Interrupts and flags management functions **********************************/ +void RCC_ITConfig(uint8_t RCC_IT, FunctionalState NewState); +FlagStatus RCC_GetFlagStatus(uint8_t RCC_FLAG); +void RCC_ClearFlag(void); +ITStatus RCC_GetITStatus(uint8_t RCC_IT); +void RCC_ClearITPendingBit(uint8_t RCC_IT); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_RCC_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_rtc.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_rtc.h new file mode 100644 index 00000000..83d2b258 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_rtc.h @@ -0,0 +1,807 @@ +/** + ****************************************************************************** + * @file stm32f0xx_rtc.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the RTC firmware + * library. + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_RTC_H +#define __STM32F0XX_RTC_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup RTC + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief RTC Init structures definition + */ +typedef struct +{ + uint32_t RTC_HourFormat; /*!< Specifies the RTC Hour Format. + This parameter can be a value of @ref RTC_Hour_Formats */ + + uint32_t RTC_AsynchPrediv; /*!< Specifies the RTC Asynchronous Predivider value. + This parameter must be set to a value lower than 0x7F */ + + uint32_t RTC_SynchPrediv; /*!< Specifies the RTC Synchronous Predivider value. + This parameter must be set to a value lower than 0x1FFF */ +}RTC_InitTypeDef; + +/** + * @brief RTC Time structure definition + */ +typedef struct +{ + uint8_t RTC_Hours; /*!< Specifies the RTC Time Hour. + This parameter must be set to a value in the 0-12 range + if the RTC_HourFormat_12 is selected or 0-23 range if + the RTC_HourFormat_24 is selected. */ + + uint8_t RTC_Minutes; /*!< Specifies the RTC Time Minutes. + This parameter must be set to a value in the 0-59 range. */ + + uint8_t RTC_Seconds; /*!< Specifies the RTC Time Seconds. + This parameter must be set to a value in the 0-59 range. */ + + uint8_t RTC_H12; /*!< Specifies the RTC AM/PM Time. + This parameter can be a value of @ref RTC_AM_PM_Definitions */ +}RTC_TimeTypeDef; + +/** + * @brief RTC Date structure definition + */ +typedef struct +{ + uint8_t RTC_WeekDay; /*!< Specifies the RTC Date WeekDay. + This parameter can be a value of @ref RTC_WeekDay_Definitions */ + + uint8_t RTC_Month; /*!< Specifies the RTC Date Month. + This parameter can be a value of @ref RTC_Month_Date_Definitions */ + + uint8_t RTC_Date; /*!< Specifies the RTC Date. + This parameter must be set to a value in the 1-31 range. */ + + uint8_t RTC_Year; /*!< Specifies the RTC Date Year. + This parameter must be set to a value in the 0-99 range. */ +}RTC_DateTypeDef; + +/** + * @brief RTC Alarm structure definition + */ +typedef struct +{ + RTC_TimeTypeDef RTC_AlarmTime; /*!< Specifies the RTC Alarm Time members. */ + + uint32_t RTC_AlarmMask; /*!< Specifies the RTC Alarm Masks. + This parameter can be a value of @ref RTC_AlarmMask_Definitions */ + + uint32_t RTC_AlarmDateWeekDaySel; /*!< Specifies the RTC Alarm is on Date or WeekDay. + This parameter can be a value of @ref RTC_AlarmDateWeekDay_Definitions */ + + uint8_t RTC_AlarmDateWeekDay; /*!< Specifies the RTC Alarm Date/WeekDay. + This parameter must be set to a value in the 1-31 range + if the Alarm Date is selected. + This parameter can be a value of @ref RTC_WeekDay_Definitions + if the Alarm WeekDay is selected. */ +}RTC_AlarmTypeDef; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup RTC_Exported_Constants + * @{ + */ + + +/** @defgroup RTC_Hour_Formats + * @{ + */ +#define RTC_HourFormat_24 ((uint32_t)0x00000000) +#define RTC_HourFormat_12 ((uint32_t)0x00000040) +#define IS_RTC_HOUR_FORMAT(FORMAT) (((FORMAT) == RTC_HourFormat_12) || \ + ((FORMAT) == RTC_HourFormat_24)) +/** + * @} + */ + +/** @defgroup RTC_Asynchronous_Predivider + * @{ + */ +#define IS_RTC_ASYNCH_PREDIV(PREDIV) ((PREDIV) <= 0x7F) + +/** + * @} + */ + + +/** @defgroup RTC_Synchronous_Predivider + * @{ + */ +#define IS_RTC_SYNCH_PREDIV(PREDIV) ((PREDIV) <= 0x7FFF) + +/** + * @} + */ + +/** @defgroup RTC_Time_Definitions + * @{ + */ +#define IS_RTC_HOUR12(HOUR) (((HOUR) > 0) && ((HOUR) <= 12)) +#define IS_RTC_HOUR24(HOUR) ((HOUR) <= 23) +#define IS_RTC_MINUTES(MINUTES) ((MINUTES) <= 59) +#define IS_RTC_SECONDS(SECONDS) ((SECONDS) <= 59) + +/** + * @} + */ + +/** @defgroup RTC_AM_PM_Definitions + * @{ + */ +#define RTC_H12_AM ((uint8_t)0x00) +#define RTC_H12_PM ((uint8_t)0x40) +#define IS_RTC_H12(PM) (((PM) == RTC_H12_AM) || ((PM) == RTC_H12_PM)) + +/** + * @} + */ + +/** @defgroup RTC_Year_Date_Definitions + * @{ + */ +#define IS_RTC_YEAR(YEAR) ((YEAR) <= 99) + +/** + * @} + */ + +/** @defgroup RTC_Month_Date_Definitions + * @{ + */ +#define RTC_Month_January ((uint8_t)0x01) +#define RTC_Month_February ((uint8_t)0x02) +#define RTC_Month_March ((uint8_t)0x03) +#define RTC_Month_April ((uint8_t)0x04) +#define RTC_Month_May ((uint8_t)0x05) +#define RTC_Month_June ((uint8_t)0x06) +#define RTC_Month_July ((uint8_t)0x07) +#define RTC_Month_August ((uint8_t)0x08) +#define RTC_Month_September ((uint8_t)0x09) +#define RTC_Month_October ((uint8_t)0x10) +#define RTC_Month_November ((uint8_t)0x11) +#define RTC_Month_December ((uint8_t)0x12) +#define IS_RTC_MONTH(MONTH) (((MONTH) >= 1) && ((MONTH) <= 12)) +#define IS_RTC_DATE(DATE) (((DATE) >= 1) && ((DATE) <= 31)) + +/** + * @} + */ + +/** @defgroup RTC_WeekDay_Definitions + * @{ + */ + +#define RTC_Weekday_Monday ((uint8_t)0x01) +#define RTC_Weekday_Tuesday ((uint8_t)0x02) +#define RTC_Weekday_Wednesday ((uint8_t)0x03) +#define RTC_Weekday_Thursday ((uint8_t)0x04) +#define RTC_Weekday_Friday ((uint8_t)0x05) +#define RTC_Weekday_Saturday ((uint8_t)0x6) +#define RTC_Weekday_Sunday ((uint8_t)0x07) +#define IS_RTC_WEEKDAY(WEEKDAY) (((WEEKDAY) == RTC_Weekday_Monday) || \ + ((WEEKDAY) == RTC_Weekday_Tuesday) || \ + ((WEEKDAY) == RTC_Weekday_Wednesday) || \ + ((WEEKDAY) == RTC_Weekday_Thursday) || \ + ((WEEKDAY) == RTC_Weekday_Friday) || \ + ((WEEKDAY) == RTC_Weekday_Saturday) || \ + ((WEEKDAY) == RTC_Weekday_Sunday)) +/** + * @} + */ + + +/** @defgroup RTC_Alarm_Definitions + * @{ + */ +#define IS_RTC_ALARM_DATE_WEEKDAY_DATE(DATE) (((DATE) > 0) && ((DATE) <= 31)) +#define IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(WEEKDAY) (((WEEKDAY) == RTC_Weekday_Monday) || \ + ((WEEKDAY) == RTC_Weekday_Tuesday) || \ + ((WEEKDAY) == RTC_Weekday_Wednesday) || \ + ((WEEKDAY) == RTC_Weekday_Thursday) || \ + ((WEEKDAY) == RTC_Weekday_Friday) || \ + ((WEEKDAY) == RTC_Weekday_Saturday) || \ + ((WEEKDAY) == RTC_Weekday_Sunday)) + +/** + * @} + */ + + +/** @defgroup RTC_AlarmDateWeekDay_Definitions + * @{ + */ +#define RTC_AlarmDateWeekDaySel_Date ((uint32_t)0x00000000) +#define RTC_AlarmDateWeekDaySel_WeekDay ((uint32_t)0x40000000) + +#define IS_RTC_ALARM_DATE_WEEKDAY_SEL(SEL) (((SEL) == RTC_AlarmDateWeekDaySel_Date) || \ + ((SEL) == RTC_AlarmDateWeekDaySel_WeekDay)) + +/** + * @} + */ + + +/** @defgroup RTC_AlarmMask_Definitions + * @{ + */ +#define RTC_AlarmMask_None ((uint32_t)0x00000000) +#define RTC_AlarmMask_DateWeekDay ((uint32_t)0x80000000) +#define RTC_AlarmMask_Hours ((uint32_t)0x00800000) +#define RTC_AlarmMask_Minutes ((uint32_t)0x00008000) +#define RTC_AlarmMask_Seconds ((uint32_t)0x00000080) +#define RTC_AlarmMask_All ((uint32_t)0x80808080) +#define IS_RTC_ALARM_MASK(MASK) (((MASK) & 0x7F7F7F7F) == (uint32_t)RESET) + +/** + * @} + */ + +/** @defgroup RTC_Alarms_Definitions + * @{ + */ +#define RTC_Alarm_A ((uint32_t)0x00000100) +#define IS_RTC_ALARM(ALARM) ((ALARM) == RTC_Alarm_A) +#define IS_RTC_CMD_ALARM(ALARM) (((ALARM) & (RTC_Alarm_A)) != (uint32_t)RESET) + +/** + * @} + */ + +/** @defgroup RTC_Alarm_Sub_Seconds_Masks Definitions. + * @{ + */ +#define RTC_AlarmSubSecondMask_All ((uint8_t)0x00) /*!< All Alarm SS fields are masked. + There is no comparison on sub seconds + for Alarm */ +#define RTC_AlarmSubSecondMask_SS14_1 ((uint8_t)0x01) /*!< SS[14:1] are don't care in Alarm + comparison. Only SS[0] is compared. */ +#define RTC_AlarmSubSecondMask_SS14_2 ((uint8_t)0x02) /*!< SS[14:2] are don't care in Alarm + comparison. Only SS[1:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14_3 ((uint8_t)0x03) /*!< SS[14:3] are don't care in Alarm + comparison. Only SS[2:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14_4 ((uint8_t)0x04) /*!< SS[14:4] are don't care in Alarm + comparison. Only SS[3:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14_5 ((uint8_t)0x05) /*!< SS[14:5] are don't care in Alarm + comparison. Only SS[4:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14_6 ((uint8_t)0x06) /*!< SS[14:6] are don't care in Alarm + comparison. Only SS[5:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14_7 ((uint8_t)0x07) /*!< SS[14:7] are don't care in Alarm + comparison. Only SS[6:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14_8 ((uint8_t)0x08) /*!< SS[14:8] are don't care in Alarm + comparison. Only SS[7:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14_9 ((uint8_t)0x09) /*!< SS[14:9] are don't care in Alarm + comparison. Only SS[8:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14_10 ((uint8_t)0x0A) /*!< SS[14:10] are don't care in Alarm + comparison. Only SS[9:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14_11 ((uint8_t)0x0B) /*!< SS[14:11] are don't care in Alarm + comparison. Only SS[10:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14_12 ((uint8_t)0x0C) /*!< SS[14:12] are don't care in Alarm + comparison.Only SS[11:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14_13 ((uint8_t)0x0D) /*!< SS[14:13] are don't care in Alarm + comparison. Only SS[12:0] are compared */ +#define RTC_AlarmSubSecondMask_SS14 ((uint8_t)0x0E) /*!< SS[14] is don't care in Alarm + comparison.Only SS[13:0] are compared */ +#define RTC_AlarmSubSecondMask_None ((uint8_t)0x0F) /*!< SS[14:0] are compared and must match + to activate alarm. */ +#define IS_RTC_ALARM_SUB_SECOND_MASK(MASK) (((MASK) == RTC_AlarmSubSecondMask_All) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_1) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_2) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_3) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_4) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_5) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_6) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_7) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_8) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_9) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_10) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_11) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_12) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14_13) || \ + ((MASK) == RTC_AlarmSubSecondMask_SS14) || \ + ((MASK) == RTC_AlarmSubSecondMask_None)) +/** + * @} + */ + +/** @defgroup RTC_Alarm_Sub_Seconds_Value + * @{ + */ + +#define IS_RTC_ALARM_SUB_SECOND_VALUE(VALUE) ((VALUE) <= 0x00007FFF) + +/** + * @} + */ + +/** @defgroup RTC_Wakeup_Timer_Definitions + * @brief These parameters are only available for STM32F072 devices + * @{ + */ +#define RTC_WakeUpClock_RTCCLK_Div16 ((uint32_t)0x00000000) +#define RTC_WakeUpClock_RTCCLK_Div8 ((uint32_t)0x00000001) +#define RTC_WakeUpClock_RTCCLK_Div4 ((uint32_t)0x00000002) +#define RTC_WakeUpClock_RTCCLK_Div2 ((uint32_t)0x00000003) +#define RTC_WakeUpClock_CK_SPRE_16bits ((uint32_t)0x00000004) +#define RTC_WakeUpClock_CK_SPRE_17bits ((uint32_t)0x00000006) +#define IS_RTC_WAKEUP_CLOCK(CLOCK) (((CLOCK) == RTC_WakeUpClock_RTCCLK_Div16) || \ + ((CLOCK) == RTC_WakeUpClock_RTCCLK_Div8) || \ + ((CLOCK) == RTC_WakeUpClock_RTCCLK_Div4) || \ + ((CLOCK) == RTC_WakeUpClock_RTCCLK_Div2) || \ + ((CLOCK) == RTC_WakeUpClock_CK_SPRE_16bits) || \ + ((CLOCK) == RTC_WakeUpClock_CK_SPRE_17bits)) +#define IS_RTC_WAKEUP_COUNTER(COUNTER) ((COUNTER) <= 0xFFFF) +/** + * @} + */ + +/** @defgroup RTC_Time_Stamp_Edges_definitions + * @{ + */ +#define RTC_TimeStampEdge_Rising ((uint32_t)0x00000000) +#define RTC_TimeStampEdge_Falling ((uint32_t)0x00000008) +#define IS_RTC_TIMESTAMP_EDGE(EDGE) (((EDGE) == RTC_TimeStampEdge_Rising) || \ + ((EDGE) == RTC_TimeStampEdge_Falling)) +/** + * @} + */ + +/** @defgroup RTC_Output_selection_Definitions + * @{ + */ +#define RTC_Output_Disable ((uint32_t)0x00000000) +#define RTC_Output_AlarmA ((uint32_t)0x00200000) +#define RTC_Output_WakeUp ((uint32_t)0x00600000) /*!< available only for STM32F072 devices */ + +#define IS_RTC_OUTPUT(OUTPUT) (((OUTPUT) == RTC_Output_Disable) || \ + ((OUTPUT) == RTC_Output_AlarmA) || \ + ((OUTPUT) == RTC_Output_WakeUp)) + +/** + * @} + */ + +/** @defgroup RTC_Output_Polarity_Definitions + * @{ + */ +#define RTC_OutputPolarity_High ((uint32_t)0x00000000) +#define RTC_OutputPolarity_Low ((uint32_t)0x00100000) +#define IS_RTC_OUTPUT_POL(POL) (((POL) == RTC_OutputPolarity_High) || \ + ((POL) == RTC_OutputPolarity_Low)) +/** + * @} + */ + + +/** @defgroup RTC_Calib_Output_selection_Definitions + * @{ + */ +#define RTC_CalibOutput_512Hz ((uint32_t)0x00000000) +#define RTC_CalibOutput_1Hz ((uint32_t)0x00080000) +#define IS_RTC_CALIB_OUTPUT(OUTPUT) (((OUTPUT) == RTC_CalibOutput_512Hz) || \ + ((OUTPUT) == RTC_CalibOutput_1Hz)) +/** + * @} + */ + +/** @defgroup RTC_Smooth_calib_period_Definitions + * @{ + */ +#define RTC_SmoothCalibPeriod_32sec ((uint32_t)0x00000000) /*!< if RTCCLK = 32768 Hz, Smooth calibation + period is 32s, else 2exp20 RTCCLK seconds */ +#define RTC_SmoothCalibPeriod_16sec ((uint32_t)0x00002000) /*!< if RTCCLK = 32768 Hz, Smooth calibation + period is 16s, else 2exp19 RTCCLK seconds */ +#define RTC_SmoothCalibPeriod_8sec ((uint32_t)0x00004000) /*!< if RTCCLK = 32768 Hz, Smooth calibation + period is 8s, else 2exp18 RTCCLK seconds */ +#define IS_RTC_SMOOTH_CALIB_PERIOD(PERIOD) (((PERIOD) == RTC_SmoothCalibPeriod_32sec) || \ + ((PERIOD) == RTC_SmoothCalibPeriod_16sec) || \ + ((PERIOD) == RTC_SmoothCalibPeriod_8sec)) + +/** + * @} + */ + +/** @defgroup RTC_Smooth_calib_Plus_pulses_Definitions + * @{ + */ +#define RTC_SmoothCalibPlusPulses_Set ((uint32_t)0x00008000) /*!< The number of RTCCLK pulses added + during a X -second window = Y - CALM[8:0]. + with Y = 512, 256, 128 when X = 32, 16, 8 */ +#define RTC_SmoothCalibPlusPulses_Reset ((uint32_t)0x00000000) /*!< The number of RTCCLK pulses subbstited + during a 32-second window = CALM[8:0]. */ +#define IS_RTC_SMOOTH_CALIB_PLUS(PLUS) (((PLUS) == RTC_SmoothCalibPlusPulses_Set) || \ + ((PLUS) == RTC_SmoothCalibPlusPulses_Reset)) + +/** + * @} + */ + +/** @defgroup RTC_Smooth_calib_Minus_pulses_Definitions + * @{ + */ +#define IS_RTC_SMOOTH_CALIB_MINUS(VALUE) ((VALUE) <= 0x000001FF) + +/** + * @} + */ + +/** @defgroup RTC_DayLightSaving_Definitions + * @{ + */ +#define RTC_DayLightSaving_SUB1H ((uint32_t)0x00020000) +#define RTC_DayLightSaving_ADD1H ((uint32_t)0x00010000) +#define IS_RTC_DAYLIGHT_SAVING(SAVING) (((SAVING) == RTC_DayLightSaving_SUB1H) || \ + ((SAVING) == RTC_DayLightSaving_ADD1H)) + +#define RTC_StoreOperation_Reset ((uint32_t)0x00000000) +#define RTC_StoreOperation_Set ((uint32_t)0x00040000) +#define IS_RTC_STORE_OPERATION(OPERATION) (((OPERATION) == RTC_StoreOperation_Reset) || \ + ((OPERATION) == RTC_StoreOperation_Set)) +/** + * @} + */ + +/** @defgroup RTC_Tamper_Trigger_Definitions + * @{ + */ +#define RTC_TamperTrigger_RisingEdge ((uint32_t)0x00000000) +#define RTC_TamperTrigger_FallingEdge ((uint32_t)0x00000001) +#define RTC_TamperTrigger_LowLevel ((uint32_t)0x00000000) +#define RTC_TamperTrigger_HighLevel ((uint32_t)0x00000001) +#define IS_RTC_TAMPER_TRIGGER(TRIGGER) (((TRIGGER) == RTC_TamperTrigger_RisingEdge) || \ + ((TRIGGER) == RTC_TamperTrigger_FallingEdge) || \ + ((TRIGGER) == RTC_TamperTrigger_LowLevel) || \ + ((TRIGGER) == RTC_TamperTrigger_HighLevel)) + +/** + * @} + */ + +/** @defgroup RTC_Tamper_Filter_Definitions + * @{ + */ +#define RTC_TamperFilter_Disable ((uint32_t)0x00000000) /*!< Tamper filter is disabled */ + +#define RTC_TamperFilter_2Sample ((uint32_t)0x00000800) /*!< Tamper is activated after 2 + consecutive samples at the active level */ +#define RTC_TamperFilter_4Sample ((uint32_t)0x00001000) /*!< Tamper is activated after 4 + consecutive samples at the active level */ +#define RTC_TamperFilter_8Sample ((uint32_t)0x00001800) /*!< Tamper is activated after 8 + consecutive samples at the active leve. */ +#define IS_RTC_TAMPER_FILTER(FILTER) (((FILTER) == RTC_TamperFilter_Disable) || \ + ((FILTER) == RTC_TamperFilter_2Sample) || \ + ((FILTER) == RTC_TamperFilter_4Sample) || \ + ((FILTER) == RTC_TamperFilter_8Sample)) +/** + * @} + */ + +/** @defgroup RTC_Tamper_Sampling_Frequencies_Definitions + * @{ + */ +#define RTC_TamperSamplingFreq_RTCCLK_Div32768 ((uint32_t)0x00000000) /*!< Each of the tamper inputs are sampled + with a frequency = RTCCLK / 32768 */ +#define RTC_TamperSamplingFreq_RTCCLK_Div16384 ((uint32_t)0x00000100) /*!< Each of the tamper inputs are sampled + with a frequency = RTCCLK / 16384 */ +#define RTC_TamperSamplingFreq_RTCCLK_Div8192 ((uint32_t)0x00000200) /*!< Each of the tamper inputs are sampled + with a frequency = RTCCLK / 8192 */ +#define RTC_TamperSamplingFreq_RTCCLK_Div4096 ((uint32_t)0x00000300) /*!< Each of the tamper inputs are sampled + with a frequency = RTCCLK / 4096 */ +#define RTC_TamperSamplingFreq_RTCCLK_Div2048 ((uint32_t)0x00000400) /*!< Each of the tamper inputs are sampled + with a frequency = RTCCLK / 2048 */ +#define RTC_TamperSamplingFreq_RTCCLK_Div1024 ((uint32_t)0x00000500) /*!< Each of the tamper inputs are sampled + with a frequency = RTCCLK / 1024 */ +#define RTC_TamperSamplingFreq_RTCCLK_Div512 ((uint32_t)0x00000600) /*!< Each of the tamper inputs are sampled + with a frequency = RTCCLK / 512 */ +#define RTC_TamperSamplingFreq_RTCCLK_Div256 ((uint32_t)0x00000700) /*!< Each of the tamper inputs are sampled + with a frequency = RTCCLK / 256 */ +#define IS_RTC_TAMPER_SAMPLING_FREQ(FREQ) (((FREQ) ==RTC_TamperSamplingFreq_RTCCLK_Div32768) || \ + ((FREQ) ==RTC_TamperSamplingFreq_RTCCLK_Div16384) || \ + ((FREQ) ==RTC_TamperSamplingFreq_RTCCLK_Div8192) || \ + ((FREQ) ==RTC_TamperSamplingFreq_RTCCLK_Div4096) || \ + ((FREQ) ==RTC_TamperSamplingFreq_RTCCLK_Div2048) || \ + ((FREQ) ==RTC_TamperSamplingFreq_RTCCLK_Div1024) || \ + ((FREQ) ==RTC_TamperSamplingFreq_RTCCLK_Div512) || \ + ((FREQ) ==RTC_TamperSamplingFreq_RTCCLK_Div256)) + +/** + * @} + */ + + /** @defgroup RTC_Tamper_Pin_Precharge_Duration_Definitions + * @{ + */ +#define RTC_TamperPrechargeDuration_1RTCCLK ((uint32_t)0x00000000) /*!< Tamper pins are pre-charged before + sampling during 1 RTCCLK cycle */ +#define RTC_TamperPrechargeDuration_2RTCCLK ((uint32_t)0x00002000) /*!< Tamper pins are pre-charged before + sampling during 2 RTCCLK cycles */ +#define RTC_TamperPrechargeDuration_4RTCCLK ((uint32_t)0x00004000) /*!< Tamper pins are pre-charged before + sampling during 4 RTCCLK cycles */ +#define RTC_TamperPrechargeDuration_8RTCCLK ((uint32_t)0x00006000) /*!< Tamper pins are pre-charged before + sampling during 8 RTCCLK cycles */ + +#define IS_RTC_TAMPER_PRECHARGE_DURATION(DURATION) (((DURATION) == RTC_TamperPrechargeDuration_1RTCCLK) || \ + ((DURATION) == RTC_TamperPrechargeDuration_2RTCCLK) || \ + ((DURATION) == RTC_TamperPrechargeDuration_4RTCCLK) || \ + ((DURATION) == RTC_TamperPrechargeDuration_8RTCCLK)) +/** + * @} + */ + +/** @defgroup RTC_Tamper_Pins_Definitions + * @{ + */ +#define RTC_Tamper_1 RTC_TAFCR_TAMP1E /*!< Tamper detection enable for + input tamper 1 */ +#define RTC_Tamper_2 RTC_TAFCR_TAMP2E /*!< Tamper detection enable for + input tamper 2 */ +#define RTC_Tamper_3 RTC_TAFCR_TAMP3E /*!< Tamper detection enable for + input tamper 3, available only + for STM32F072 devices */ +#define IS_RTC_TAMPER(TAMPER) ((((TAMPER) & (uint32_t)0xFFFFFFD6) == 0x00) && ((TAMPER) != (uint32_t)RESET)) + +/** + * @} + */ + +/** @defgroup RTC_Output_Type_ALARM_OUT + * @{ + */ +#define RTC_OutputType_OpenDrain ((uint32_t)0x00000000) +#define RTC_OutputType_PushPull ((uint32_t)0x00040000) +#define IS_RTC_OUTPUT_TYPE(TYPE) (((TYPE) == RTC_OutputType_OpenDrain) || \ + ((TYPE) == RTC_OutputType_PushPull)) + +/** + * @} + */ + +/** @defgroup RTC_Add_1_Second_Parameter_Definitions + * @{ + */ +#define RTC_ShiftAdd1S_Reset ((uint32_t)0x00000000) +#define RTC_ShiftAdd1S_Set ((uint32_t)0x80000000) +#define IS_RTC_SHIFT_ADD1S(SEL) (((SEL) == RTC_ShiftAdd1S_Reset) || \ + ((SEL) == RTC_ShiftAdd1S_Set)) +/** + * @} + */ + +/** @defgroup RTC_Substract_Fraction_Of_Second_Value + * @{ + */ +#define IS_RTC_SHIFT_SUBFS(FS) ((FS) <= 0x00007FFF) + +/** + * @} + */ + +/** @defgroup RTC_Backup_Registers_Definitions + * @{ + */ + +#define RTC_BKP_DR0 ((uint32_t)0x00000000) +#define RTC_BKP_DR1 ((uint32_t)0x00000001) +#define RTC_BKP_DR2 ((uint32_t)0x00000002) +#define RTC_BKP_DR3 ((uint32_t)0x00000003) +#define RTC_BKP_DR4 ((uint32_t)0x00000004) +#define IS_RTC_BKP(BKP) (((BKP) == RTC_BKP_DR0) || \ + ((BKP) == RTC_BKP_DR1) || \ + ((BKP) == RTC_BKP_DR2) || \ + ((BKP) == RTC_BKP_DR3) || \ + ((BKP) == RTC_BKP_DR4)) +/** + * @} + */ + +/** @defgroup RTC_Input_parameter_format_definitions + * @{ + */ +#define RTC_Format_BIN ((uint32_t)0x000000000) +#define RTC_Format_BCD ((uint32_t)0x000000001) +#define IS_RTC_FORMAT(FORMAT) (((FORMAT) == RTC_Format_BIN) || ((FORMAT) == RTC_Format_BCD)) + +/** + * @} + */ + +/** @defgroup RTC_Flags_Definitions + * @{ + */ +#define RTC_FLAG_RECALPF RTC_ISR_RECALPF +#define RTC_FLAG_TAMP3F RTC_ISR_TAMP3F /*!< Only available for STM32F072 devices */ +#define RTC_FLAG_TAMP2F RTC_ISR_TAMP2F +#define RTC_FLAG_TAMP1F RTC_ISR_TAMP1F +#define RTC_FLAG_TSOVF RTC_ISR_TSOVF +#define RTC_FLAG_TSF RTC_ISR_TSF +#define RTC_FLAG_WUTF RTC_ISR_WUTF /*!< Only available for STM32F072 devices */ +#define RTC_FLAG_ALRAF RTC_ISR_ALRAF +#define RTC_FLAG_INITF RTC_ISR_INITF +#define RTC_FLAG_RSF RTC_ISR_RSF +#define RTC_FLAG_INITS RTC_ISR_INITS +#define RTC_FLAG_SHPF RTC_ISR_SHPF +#define RTC_FLAG_WUTWF RTC_ISR_WUTWF /*!< Only available for STM32F072 devices */ +#define RTC_FLAG_ALRAWF RTC_ISR_ALRAWF + +#define IS_RTC_GET_FLAG(FLAG) (((FLAG) == RTC_FLAG_TSOVF) || ((FLAG) == RTC_FLAG_TSF) || \ + ((FLAG) == RTC_FLAG_WUTF) || ((FLAG) == RTC_FLAG_ALRAWF) || \ + ((FLAG) == RTC_FLAG_ALRAF) || ((FLAG) == RTC_FLAG_INITF) || \ + ((FLAG) == RTC_FLAG_RSF) || ((FLAG) == RTC_FLAG_WUTWF) || \ + ((FLAG) == RTC_FLAG_TAMP1F) || ((FLAG) == RTC_FLAG_TAMP2F) || \ + ((FLAG) == RTC_FLAG_TAMP3F) || ((FLAG) == RTC_FLAG_RECALPF) || \ + ((FLAG) == RTC_FLAG_SHPF)) +#define IS_RTC_CLEAR_FLAG(FLAG) (((FLAG) != (uint32_t)RESET) && (((FLAG) & 0xFFFF02DF) == (uint32_t)RESET)) + +/** + * @} + */ + +/** @defgroup RTC_Interrupts_Definitions + * @{ + */ +#define RTC_IT_TS ((uint32_t)0x00008000) +#define RTC_IT_WUT ((uint32_t)0x00004000) /* Available only for STM32F072 devices */ +#define RTC_IT_ALRA ((uint32_t)0x00001000) +#define RTC_IT_TAMP ((uint32_t)0x00000004) /* Used only to Enable the Tamper Interrupt */ +#define RTC_IT_TAMP1 ((uint32_t)0x00020000) +#define RTC_IT_TAMP2 ((uint32_t)0x00040000) +#define RTC_IT_TAMP3 ((uint32_t)0x00080000) /* Available only for STM32F072 devices */ + +#define IS_RTC_CONFIG_IT(IT) (((IT) != (uint32_t)RESET) && (((IT) & 0xFFFF2FFB) == (uint32_t)RESET)) +#define IS_RTC_GET_IT(IT) (((IT) == RTC_IT_TS) || ((IT) == RTC_IT_ALRA) || \ + ((IT) == RTC_IT_TAMP1) || ((IT) == RTC_IT_WUT) || \ + ((IT) == RTC_IT_TAMP2) || ((IT) == RTC_IT_TAMP3)) + +#define IS_RTC_CLEAR_IT(IT) (((IT) != (uint32_t)RESET) && (((IT) & 0xFFF12FFF) == (uint32_t)RESET)) + +/** + * @} + */ + +/** + * @} + */ + + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ +/* Function used to set the RTC configuration to the default reset state *****/ +ErrorStatus RTC_DeInit(void); + + +/* Initialization and Configuration functions *********************************/ +ErrorStatus RTC_Init(RTC_InitTypeDef* RTC_InitStruct); +void RTC_StructInit(RTC_InitTypeDef* RTC_InitStruct); +void RTC_WriteProtectionCmd(FunctionalState NewState); +ErrorStatus RTC_EnterInitMode(void); +void RTC_ExitInitMode(void); +ErrorStatus RTC_WaitForSynchro(void); +ErrorStatus RTC_RefClockCmd(FunctionalState NewState); +void RTC_BypassShadowCmd(FunctionalState NewState); + +/* Time and Date configuration functions **************************************/ +ErrorStatus RTC_SetTime(uint32_t RTC_Format, RTC_TimeTypeDef* RTC_TimeStruct); +void RTC_TimeStructInit(RTC_TimeTypeDef* RTC_TimeStruct); +void RTC_GetTime(uint32_t RTC_Format, RTC_TimeTypeDef* RTC_TimeStruct); +uint32_t RTC_GetSubSecond(void); +ErrorStatus RTC_SetDate(uint32_t RTC_Format, RTC_DateTypeDef* RTC_DateStruct); +void RTC_DateStructInit(RTC_DateTypeDef* RTC_DateStruct); +void RTC_GetDate(uint32_t RTC_Format, RTC_DateTypeDef* RTC_DateStruct); + +/* Alarms (Alarm A) configuration functions **********************************/ +void RTC_SetAlarm(uint32_t RTC_Format, uint32_t RTC_Alarm, RTC_AlarmTypeDef* RTC_AlarmStruct); +void RTC_AlarmStructInit(RTC_AlarmTypeDef* RTC_AlarmStruct); +void RTC_GetAlarm(uint32_t RTC_Format, uint32_t RTC_Alarm, RTC_AlarmTypeDef* RTC_AlarmStruct); +ErrorStatus RTC_AlarmCmd(uint32_t RTC_Alarm, FunctionalState NewState); +void RTC_AlarmSubSecondConfig(uint32_t RTC_Alarm, uint32_t RTC_AlarmSubSecondValue, uint8_t RTC_AlarmSubSecondMask); +uint32_t RTC_GetAlarmSubSecond(uint32_t RTC_Alarm); + +/* WakeUp Timer configuration functions ***************************************/ +void RTC_WakeUpClockConfig(uint32_t RTC_WakeUpClock); /*!< available only for STM32F072 devices */ +void RTC_SetWakeUpCounter(uint32_t RTC_WakeUpCounter); /*!< available only for STM32F072 devices */ +uint32_t RTC_GetWakeUpCounter(void); /*!< available only for STM32F072 devices */ +ErrorStatus RTC_WakeUpCmd(FunctionalState NewState); /*!< available only for STM32F072 devices */ + +/* Daylight Saving configuration functions ************************************/ +void RTC_DayLightSavingConfig(uint32_t RTC_DayLightSaving, uint32_t RTC_StoreOperation); +uint32_t RTC_GetStoreOperation(void); + +/* Output pin Configuration function ******************************************/ +void RTC_OutputConfig(uint32_t RTC_Output, uint32_t RTC_OutputPolarity); + +/* Digital Calibration configuration functions ********************************/ +void RTC_CalibOutputCmd(FunctionalState NewState); +void RTC_CalibOutputConfig(uint32_t RTC_CalibOutput); +ErrorStatus RTC_SmoothCalibConfig(uint32_t RTC_SmoothCalibPeriod, + uint32_t RTC_SmoothCalibPlusPulses, + uint32_t RTC_SmouthCalibMinusPulsesValue); + +/* TimeStamp configuration functions ******************************************/ +void RTC_TimeStampCmd(uint32_t RTC_TimeStampEdge, FunctionalState NewState); +void RTC_GetTimeStamp(uint32_t RTC_Format, RTC_TimeTypeDef* RTC_StampTimeStruct, RTC_DateTypeDef* RTC_StampDateStruct); +uint32_t RTC_GetTimeStampSubSecond(void); + +/* Tampers configuration functions ********************************************/ +void RTC_TamperTriggerConfig(uint32_t RTC_Tamper, uint32_t RTC_TamperTrigger); +void RTC_TamperCmd(uint32_t RTC_Tamper, FunctionalState NewState); +void RTC_TamperFilterConfig(uint32_t RTC_TamperFilter); +void RTC_TamperSamplingFreqConfig(uint32_t RTC_TamperSamplingFreq); +void RTC_TamperPinsPrechargeDuration(uint32_t RTC_TamperPrechargeDuration); +void RTC_TimeStampOnTamperDetectionCmd(FunctionalState NewState); +void RTC_TamperPullUpCmd(FunctionalState NewState); + +/* Backup Data Registers configuration functions ******************************/ +void RTC_WriteBackupRegister(uint32_t RTC_BKP_DR, uint32_t Data); +uint32_t RTC_ReadBackupRegister(uint32_t RTC_BKP_DR); + +/* Output Type Config configuration functions *********************************/ +void RTC_OutputTypeConfig(uint32_t RTC_OutputType); + +/* RTC_Shift_control_synchonisation_functions *********************************/ +ErrorStatus RTC_SynchroShiftConfig(uint32_t RTC_ShiftAdd1S, uint32_t RTC_ShiftSubFS); + +/* Interrupts and flags management functions **********************************/ +void RTC_ITConfig(uint32_t RTC_IT, FunctionalState NewState); +FlagStatus RTC_GetFlagStatus(uint32_t RTC_FLAG); +void RTC_ClearFlag(uint32_t RTC_FLAG); +ITStatus RTC_GetITStatus(uint32_t RTC_IT); +void RTC_ClearITPendingBit(uint32_t RTC_IT); + +#ifdef __cplusplus +} +#endif + +#endif /*__STM32F0XX_RTC_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_spi.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_spi.h new file mode 100644 index 00000000..711d908c --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_spi.h @@ -0,0 +1,588 @@ +/** + ****************************************************************************** + * @file stm32f0xx_spi.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the SPI + * firmware library. + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_SPI_H +#define __STM32F0XX_SPI_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup SPI + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief SPI Init structure definition + */ + +typedef struct +{ + uint16_t SPI_Direction; /*!< Specifies the SPI unidirectional or bidirectional data mode. + This parameter can be a value of @ref SPI_data_direction */ + + uint16_t SPI_Mode; /*!< Specifies the SPI mode (Master/Slave). + This parameter can be a value of @ref SPI_mode */ + + uint16_t SPI_DataSize; /*!< Specifies the SPI data size. + This parameter can be a value of @ref SPI_data_size */ + + uint16_t SPI_CPOL; /*!< Specifies the serial clock steady state. + This parameter can be a value of @ref SPI_Clock_Polarity */ + + uint16_t SPI_CPHA; /*!< Specifies the clock active edge for the bit capture. + This parameter can be a value of @ref SPI_Clock_Phase */ + + uint16_t SPI_NSS; /*!< Specifies whether the NSS signal is managed by + hardware (NSS pin) or by software using the SSI bit. + This parameter can be a value of @ref SPI_Slave_Select_management */ + + uint16_t SPI_BaudRatePrescaler; /*!< Specifies the Baud Rate prescaler value which will be + used to configure the transmit and receive SCK clock. + This parameter can be a value of @ref SPI_BaudRate_Prescaler + @note The communication clock is derived from the master + clock. The slave clock does not need to be set. */ + + uint16_t SPI_FirstBit; /*!< Specifies whether data transfers start from MSB or LSB bit. + This parameter can be a value of @ref SPI_MSB_LSB_transmission */ + + uint16_t SPI_CRCPolynomial; /*!< Specifies the polynomial used for the CRC calculation. */ +}SPI_InitTypeDef; + + +/** + * @brief I2S Init structure definition + * @note These parameters are not available for STM32F030 devices. + */ + +typedef struct +{ + uint16_t I2S_Mode; /*!< Specifies the I2S operating mode. + This parameter can be a value of @ref SPI_I2S_Mode */ + + uint16_t I2S_Standard; /*!< Specifies the standard used for the I2S communication. + This parameter can be a value of @ref SPI_I2S_Standard */ + + uint16_t I2S_DataFormat; /*!< Specifies the data format for the I2S communication. + This parameter can be a value of @ref SPI_I2S_Data_Format */ + + uint16_t I2S_MCLKOutput; /*!< Specifies whether the I2S MCLK output is enabled or not. + This parameter can be a value of @ref SPI_I2S_MCLK_Output */ + + uint32_t I2S_AudioFreq; /*!< Specifies the frequency selected for the I2S communication. + This parameter can be a value of @ref SPI_I2S_Audio_Frequency */ + + uint16_t I2S_CPOL; /*!< Specifies the idle state of the I2S clock. + This parameter can be a value of @ref SPI_I2S_Clock_Polarity */ +}I2S_InitTypeDef; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup SPI_Exported_Constants + * @{ + */ + +#define IS_SPI_ALL_PERIPH(PERIPH) (((PERIPH) == SPI1) || \ + ((PERIPH) == SPI2)) + +#define IS_SPI_1_PERIPH(PERIPH) (((PERIPH) == SPI1)) + +/** @defgroup SPI_data_direction + * @{ + */ + +#define SPI_Direction_2Lines_FullDuplex ((uint16_t)0x0000) +#define SPI_Direction_2Lines_RxOnly ((uint16_t)0x0400) +#define SPI_Direction_1Line_Rx ((uint16_t)0x8000) +#define SPI_Direction_1Line_Tx ((uint16_t)0xC000) +#define IS_SPI_DIRECTION_MODE(MODE) (((MODE) == SPI_Direction_2Lines_FullDuplex) || \ + ((MODE) == SPI_Direction_2Lines_RxOnly) || \ + ((MODE) == SPI_Direction_1Line_Rx) || \ + ((MODE) == SPI_Direction_1Line_Tx)) +/** + * @} + */ + +/** @defgroup SPI_mode + * @{ + */ + +#define SPI_Mode_Master ((uint16_t)0x0104) +#define SPI_Mode_Slave ((uint16_t)0x0000) +#define IS_SPI_MODE(MODE) (((MODE) == SPI_Mode_Master) || \ + ((MODE) == SPI_Mode_Slave)) +/** + * @} + */ + +/** @defgroup SPI_data_size + * @{ + */ + +#define SPI_DataSize_4b ((uint16_t)0x0300) +#define SPI_DataSize_5b ((uint16_t)0x0400) +#define SPI_DataSize_6b ((uint16_t)0x0500) +#define SPI_DataSize_7b ((uint16_t)0x0600) +#define SPI_DataSize_8b ((uint16_t)0x0700) +#define SPI_DataSize_9b ((uint16_t)0x0800) +#define SPI_DataSize_10b ((uint16_t)0x0900) +#define SPI_DataSize_11b ((uint16_t)0x0A00) +#define SPI_DataSize_12b ((uint16_t)0x0B00) +#define SPI_DataSize_13b ((uint16_t)0x0C00) +#define SPI_DataSize_14b ((uint16_t)0x0D00) +#define SPI_DataSize_15b ((uint16_t)0x0E00) +#define SPI_DataSize_16b ((uint16_t)0x0F00) +#define IS_SPI_DATA_SIZE(SIZE) (((SIZE) == SPI_DataSize_4b) || \ + ((SIZE) == SPI_DataSize_5b) || \ + ((SIZE) == SPI_DataSize_6b) || \ + ((SIZE) == SPI_DataSize_7b) || \ + ((SIZE) == SPI_DataSize_8b) || \ + ((SIZE) == SPI_DataSize_9b) || \ + ((SIZE) == SPI_DataSize_10b) || \ + ((SIZE) == SPI_DataSize_11b) || \ + ((SIZE) == SPI_DataSize_12b) || \ + ((SIZE) == SPI_DataSize_13b) || \ + ((SIZE) == SPI_DataSize_14b) || \ + ((SIZE) == SPI_DataSize_15b) || \ + ((SIZE) == SPI_DataSize_16b)) +/** + * @} + */ + +/** @defgroup SPI_CRC_length + * @{ + */ + +#define SPI_CRCLength_8b ((uint16_t)0x0000) +#define SPI_CRCLength_16b SPI_CR1_CRCL +#define IS_SPI_CRC_LENGTH(LENGTH) (((LENGTH) == SPI_CRCLength_8b) || \ + ((LENGTH) == SPI_CRCLength_16b)) +/** + * @} + */ + +/** @defgroup SPI_Clock_Polarity + * @{ + */ + +#define SPI_CPOL_Low ((uint16_t)0x0000) +#define SPI_CPOL_High SPI_CR1_CPOL +#define IS_SPI_CPOL(CPOL) (((CPOL) == SPI_CPOL_Low) || \ + ((CPOL) == SPI_CPOL_High)) +/** + * @} + */ + +/** @defgroup SPI_Clock_Phase + * @{ + */ + +#define SPI_CPHA_1Edge ((uint16_t)0x0000) +#define SPI_CPHA_2Edge SPI_CR1_CPHA +#define IS_SPI_CPHA(CPHA) (((CPHA) == SPI_CPHA_1Edge) || \ + ((CPHA) == SPI_CPHA_2Edge)) +/** + * @} + */ + +/** @defgroup SPI_Slave_Select_management + * @{ + */ + +#define SPI_NSS_Soft SPI_CR1_SSM +#define SPI_NSS_Hard ((uint16_t)0x0000) +#define IS_SPI_NSS(NSS) (((NSS) == SPI_NSS_Soft) || \ + ((NSS) == SPI_NSS_Hard)) +/** + * @} + */ + +/** @defgroup SPI_BaudRate_Prescaler + * @{ + */ + +#define SPI_BaudRatePrescaler_2 ((uint16_t)0x0000) +#define SPI_BaudRatePrescaler_4 ((uint16_t)0x0008) +#define SPI_BaudRatePrescaler_8 ((uint16_t)0x0010) +#define SPI_BaudRatePrescaler_16 ((uint16_t)0x0018) +#define SPI_BaudRatePrescaler_32 ((uint16_t)0x0020) +#define SPI_BaudRatePrescaler_64 ((uint16_t)0x0028) +#define SPI_BaudRatePrescaler_128 ((uint16_t)0x0030) +#define SPI_BaudRatePrescaler_256 ((uint16_t)0x0038) +#define IS_SPI_BAUDRATE_PRESCALER(PRESCALER) (((PRESCALER) == SPI_BaudRatePrescaler_2) || \ + ((PRESCALER) == SPI_BaudRatePrescaler_4) || \ + ((PRESCALER) == SPI_BaudRatePrescaler_8) || \ + ((PRESCALER) == SPI_BaudRatePrescaler_16) || \ + ((PRESCALER) == SPI_BaudRatePrescaler_32) || \ + ((PRESCALER) == SPI_BaudRatePrescaler_64) || \ + ((PRESCALER) == SPI_BaudRatePrescaler_128) || \ + ((PRESCALER) == SPI_BaudRatePrescaler_256)) +/** + * @} + */ + +/** @defgroup SPI_MSB_LSB_transmission + * @{ + */ + +#define SPI_FirstBit_MSB ((uint16_t)0x0000) +#define SPI_FirstBit_LSB SPI_CR1_LSBFIRST +#define IS_SPI_FIRST_BIT(BIT) (((BIT) == SPI_FirstBit_MSB) || \ + ((BIT) == SPI_FirstBit_LSB)) +/** + * @} + */ + +/** @defgroup SPI_I2S_Mode + * @{ + */ + +#define I2S_Mode_SlaveTx ((uint16_t)0x0000) +#define I2S_Mode_SlaveRx ((uint16_t)0x0100) +#define I2S_Mode_MasterTx ((uint16_t)0x0200) +#define I2S_Mode_MasterRx ((uint16_t)0x0300) +#define IS_I2S_MODE(MODE) (((MODE) == I2S_Mode_SlaveTx) || \ + ((MODE) == I2S_Mode_SlaveRx) || \ + ((MODE) == I2S_Mode_MasterTx)|| \ + ((MODE) == I2S_Mode_MasterRx)) +/** + * @} + */ + +/** @defgroup SPI_I2S_Standard + * @{ + */ + +#define I2S_Standard_Phillips ((uint16_t)0x0000) +#define I2S_Standard_MSB ((uint16_t)0x0010) +#define I2S_Standard_LSB ((uint16_t)0x0020) +#define I2S_Standard_PCMShort ((uint16_t)0x0030) +#define I2S_Standard_PCMLong ((uint16_t)0x00B0) +#define IS_I2S_STANDARD(STANDARD) (((STANDARD) == I2S_Standard_Phillips) || \ + ((STANDARD) == I2S_Standard_MSB) || \ + ((STANDARD) == I2S_Standard_LSB) || \ + ((STANDARD) == I2S_Standard_PCMShort) || \ + ((STANDARD) == I2S_Standard_PCMLong)) +/** + * @} + */ + +/** @defgroup SPI_I2S_Data_Format + * @{ + */ + +#define I2S_DataFormat_16b ((uint16_t)0x0000) +#define I2S_DataFormat_16bextended ((uint16_t)0x0001) +#define I2S_DataFormat_24b ((uint16_t)0x0003) +#define I2S_DataFormat_32b ((uint16_t)0x0005) +#define IS_I2S_DATA_FORMAT(FORMAT) (((FORMAT) == I2S_DataFormat_16b) || \ + ((FORMAT) == I2S_DataFormat_16bextended) || \ + ((FORMAT) == I2S_DataFormat_24b) || \ + ((FORMAT) == I2S_DataFormat_32b)) +/** + * @} + */ + +/** @defgroup SPI_I2S_MCLK_Output + * @{ + */ + +#define I2S_MCLKOutput_Enable SPI_I2SPR_MCKOE +#define I2S_MCLKOutput_Disable ((uint16_t)0x0000) +#define IS_I2S_MCLK_OUTPUT(OUTPUT) (((OUTPUT) == I2S_MCLKOutput_Enable) || \ + ((OUTPUT) == I2S_MCLKOutput_Disable)) +/** + * @} + */ + +/** @defgroup SPI_I2S_Audio_Frequency + * @{ + */ + +#define I2S_AudioFreq_192k ((uint32_t)192000) +#define I2S_AudioFreq_96k ((uint32_t)96000) +#define I2S_AudioFreq_48k ((uint32_t)48000) +#define I2S_AudioFreq_44k ((uint32_t)44100) +#define I2S_AudioFreq_32k ((uint32_t)32000) +#define I2S_AudioFreq_22k ((uint32_t)22050) +#define I2S_AudioFreq_16k ((uint32_t)16000) +#define I2S_AudioFreq_11k ((uint32_t)11025) +#define I2S_AudioFreq_8k ((uint32_t)8000) +#define I2S_AudioFreq_Default ((uint32_t)2) + +#define IS_I2S_AUDIO_FREQ(FREQ) ((((FREQ) >= I2S_AudioFreq_8k) && \ + ((FREQ) <= I2S_AudioFreq_192k)) || \ + ((FREQ) == I2S_AudioFreq_Default)) +/** + * @} + */ + +/** @defgroup SPI_I2S_Clock_Polarity + * @{ + */ + +#define I2S_CPOL_Low ((uint16_t)0x0000) +#define I2S_CPOL_High SPI_I2SCFGR_CKPOL +#define IS_I2S_CPOL(CPOL) (((CPOL) == I2S_CPOL_Low) || \ + ((CPOL) == I2S_CPOL_High)) +/** + * @} + */ + +/** @defgroup SPI_FIFO_reception_threshold + * @{ + */ + +#define SPI_RxFIFOThreshold_HF ((uint16_t)0x0000) +#define SPI_RxFIFOThreshold_QF SPI_CR2_FRXTH +#define IS_SPI_RX_FIFO_THRESHOLD(THRESHOLD) (((THRESHOLD) == SPI_RxFIFOThreshold_HF) || \ + ((THRESHOLD) == SPI_RxFIFOThreshold_QF)) +/** + * @} + */ + +/** @defgroup SPI_I2S_DMA_transfer_requests + * @{ + */ + +#define SPI_I2S_DMAReq_Tx SPI_CR2_TXDMAEN +#define SPI_I2S_DMAReq_Rx SPI_CR2_RXDMAEN +#define IS_SPI_I2S_DMA_REQ(REQ) ((((REQ) & (uint16_t)0xFFFC) == 0x00) && ((REQ) != 0x00)) +/** + * @} + */ + +/** @defgroup SPI_last_DMA_transfers + * @{ + */ + +#define SPI_LastDMATransfer_TxEvenRxEven ((uint16_t)0x0000) +#define SPI_LastDMATransfer_TxOddRxEven ((uint16_t)0x4000) +#define SPI_LastDMATransfer_TxEvenRxOdd ((uint16_t)0x2000) +#define SPI_LastDMATransfer_TxOddRxOdd ((uint16_t)0x6000) +#define IS_SPI_LAST_DMA_TRANSFER(TRANSFER) (((TRANSFER) == SPI_LastDMATransfer_TxEvenRxEven) || \ + ((TRANSFER) == SPI_LastDMATransfer_TxOddRxEven) || \ + ((TRANSFER) == SPI_LastDMATransfer_TxEvenRxOdd) || \ + ((TRANSFER) == SPI_LastDMATransfer_TxOddRxOdd)) +/** + * @} + */ +/** @defgroup SPI_NSS_internal_software_management + * @{ + */ + +#define SPI_NSSInternalSoft_Set SPI_CR1_SSI +#define SPI_NSSInternalSoft_Reset ((uint16_t)0xFEFF) +#define IS_SPI_NSS_INTERNAL(INTERNAL) (((INTERNAL) == SPI_NSSInternalSoft_Set) || \ + ((INTERNAL) == SPI_NSSInternalSoft_Reset)) +/** + * @} + */ + +/** @defgroup SPI_CRC_Transmit_Receive + * @{ + */ + +#define SPI_CRC_Tx ((uint8_t)0x00) +#define SPI_CRC_Rx ((uint8_t)0x01) +#define IS_SPI_CRC(CRC) (((CRC) == SPI_CRC_Tx) || ((CRC) == SPI_CRC_Rx)) +/** + * @} + */ + +/** @defgroup SPI_direction_transmit_receive + * @{ + */ + +#define SPI_Direction_Rx ((uint16_t)0xBFFF) +#define SPI_Direction_Tx ((uint16_t)0x4000) +#define IS_SPI_DIRECTION(DIRECTION) (((DIRECTION) == SPI_Direction_Rx) || \ + ((DIRECTION) == SPI_Direction_Tx)) +/** + * @} + */ + +/** @defgroup SPI_I2S_interrupts_definition + * @{ + */ + +#define SPI_I2S_IT_TXE ((uint8_t)0x71) +#define SPI_I2S_IT_RXNE ((uint8_t)0x60) +#define SPI_I2S_IT_ERR ((uint8_t)0x50) + +#define IS_SPI_I2S_CONFIG_IT(IT) (((IT) == SPI_I2S_IT_TXE) || \ + ((IT) == SPI_I2S_IT_RXNE) || \ + ((IT) == SPI_I2S_IT_ERR)) + +#define I2S_IT_UDR ((uint8_t)0x53) +#define SPI_IT_MODF ((uint8_t)0x55) +#define SPI_I2S_IT_OVR ((uint8_t)0x56) +#define SPI_I2S_IT_FRE ((uint8_t)0x58) + +#define IS_SPI_I2S_GET_IT(IT) (((IT) == SPI_I2S_IT_RXNE) || ((IT) == SPI_I2S_IT_TXE) || \ + ((IT) == SPI_I2S_IT_OVR) || ((IT) == SPI_IT_MODF) || \ + ((IT) == SPI_I2S_IT_FRE)|| ((IT) == I2S_IT_UDR)) +/** + * @} + */ + + +/** @defgroup SPI_transmission_fifo_status_level + * @{ + */ + +#define SPI_TransmissionFIFOStatus_Empty ((uint16_t)0x0000) +#define SPI_TransmissionFIFOStatus_1QuarterFull ((uint16_t)0x0800) +#define SPI_TransmissionFIFOStatus_HalfFull ((uint16_t)0x1000) +#define SPI_TransmissionFIFOStatus_Full ((uint16_t)0x1800) + +/** + * @} + */ + +/** @defgroup SPI_reception_fifo_status_level + * @{ + */ +#define SPI_ReceptionFIFOStatus_Empty ((uint16_t)0x0000) +#define SPI_ReceptionFIFOStatus_1QuarterFull ((uint16_t)0x0200) +#define SPI_ReceptionFIFOStatus_HalfFull ((uint16_t)0x0400) +#define SPI_ReceptionFIFOStatus_Full ((uint16_t)0x0600) + +/** + * @} + */ + + +/** @defgroup SPI_I2S_flags_definition + * @{ + */ + +#define SPI_I2S_FLAG_RXNE SPI_SR_RXNE +#define SPI_I2S_FLAG_TXE SPI_SR_TXE +#define I2S_FLAG_CHSIDE SPI_SR_CHSIDE +#define I2S_FLAG_UDR SPI_SR_UDR +#define SPI_FLAG_CRCERR SPI_SR_CRCERR +#define SPI_FLAG_MODF SPI_SR_MODF +#define SPI_I2S_FLAG_OVR SPI_SR_OVR +#define SPI_I2S_FLAG_BSY SPI_SR_BSY +#define SPI_I2S_FLAG_FRE SPI_SR_FRE + + + +#define IS_SPI_CLEAR_FLAG(FLAG) (((FLAG) == SPI_FLAG_CRCERR)) +#define IS_SPI_I2S_GET_FLAG(FLAG) (((FLAG) == SPI_I2S_FLAG_BSY) || ((FLAG) == SPI_I2S_FLAG_OVR) || \ + ((FLAG) == SPI_FLAG_MODF) || ((FLAG) == SPI_FLAG_CRCERR) || \ + ((FLAG) == SPI_I2S_FLAG_TXE) || ((FLAG) == SPI_I2S_FLAG_RXNE)|| \ + ((FLAG) == SPI_I2S_FLAG_FRE)|| ((FLAG) == I2S_FLAG_CHSIDE)|| \ + ((FLAG) == I2S_FLAG_UDR)) +/** + * @} + */ + +/** @defgroup SPI_CRC_polynomial + * @{ + */ + +#define IS_SPI_CRC_POLYNOMIAL(POLYNOMIAL) ((POLYNOMIAL) >= 0x1) +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Initialization and Configuration functions *********************************/ +void SPI_I2S_DeInit(SPI_TypeDef* SPIx); +void SPI_Init(SPI_TypeDef* SPIx, SPI_InitTypeDef* SPI_InitStruct); +void I2S_Init(SPI_TypeDef* SPIx, I2S_InitTypeDef* I2S_InitStruct); /*!< Not applicable for STM32F030 devices */ +void SPI_StructInit(SPI_InitTypeDef* SPI_InitStruct); +void I2S_StructInit(I2S_InitTypeDef* I2S_InitStruct); /*!< Not applicable for STM32F030 devices */ +void SPI_TIModeCmd(SPI_TypeDef* SPIx, FunctionalState NewState); +void SPI_NSSPulseModeCmd(SPI_TypeDef* SPIx, FunctionalState NewState); +void SPI_Cmd(SPI_TypeDef* SPIx, FunctionalState NewState); +void I2S_Cmd(SPI_TypeDef* SPIx, FunctionalState NewState); /*!< Not applicable for STM32F030 devices */ +void SPI_DataSizeConfig(SPI_TypeDef* SPIx, uint16_t SPI_DataSize); +void SPI_RxFIFOThresholdConfig(SPI_TypeDef* SPIx, uint16_t SPI_RxFIFOThreshold); +void SPI_BiDirectionalLineConfig(SPI_TypeDef* SPIx, uint16_t SPI_Direction); +void SPI_NSSInternalSoftwareConfig(SPI_TypeDef* SPIx, uint16_t SPI_NSSInternalSoft); +void SPI_SSOutputCmd(SPI_TypeDef* SPIx, FunctionalState NewState); + +/* Data transfers functions ***************************************************/ +void SPI_SendData8(SPI_TypeDef* SPIx, uint8_t Data); +void SPI_I2S_SendData16(SPI_TypeDef* SPIx, uint16_t Data); +uint8_t SPI_ReceiveData8(SPI_TypeDef* SPIx); +uint16_t SPI_I2S_ReceiveData16(SPI_TypeDef* SPIx); + +/* Hardware CRC Calculation functions *****************************************/ +void SPI_CRCLengthConfig(SPI_TypeDef* SPIx, uint16_t SPI_CRCLength); +void SPI_CalculateCRC(SPI_TypeDef* SPIx, FunctionalState NewState); +void SPI_TransmitCRC(SPI_TypeDef* SPIx); +uint16_t SPI_GetCRC(SPI_TypeDef* SPIx, uint8_t SPI_CRC); +uint16_t SPI_GetCRCPolynomial(SPI_TypeDef* SPIx); + +/* DMA transfers management functions *****************************************/ +void SPI_I2S_DMACmd(SPI_TypeDef* SPIx, uint16_t SPI_I2S_DMAReq, FunctionalState NewState); +void SPI_LastDMATransferCmd(SPI_TypeDef* SPIx, uint16_t SPI_LastDMATransfer); + +/* Interrupts and flags management functions **********************************/ +void SPI_I2S_ITConfig(SPI_TypeDef* SPIx, uint8_t SPI_I2S_IT, FunctionalState NewState); +uint16_t SPI_GetTransmissionFIFOStatus(SPI_TypeDef* SPIx); +uint16_t SPI_GetReceptionFIFOStatus(SPI_TypeDef* SPIx); +FlagStatus SPI_I2S_GetFlagStatus(SPI_TypeDef* SPIx, uint16_t SPI_I2S_FLAG); +void SPI_I2S_ClearFlag(SPI_TypeDef* SPIx, uint16_t SPI_I2S_FLAG); +ITStatus SPI_I2S_GetITStatus(SPI_TypeDef* SPIx, uint8_t SPI_I2S_IT); + +#ifdef __cplusplus +} +#endif + +#endif /*__STM32F0XX_SPI_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_syscfg.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_syscfg.h new file mode 100644 index 00000000..86560377 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_syscfg.h @@ -0,0 +1,459 @@ +/** + ****************************************************************************** + * @file stm32f0xx_syscfg.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the SYSCFG firmware + * library. + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/*!< Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_SYSCFG_H +#define __STM32F0XX_SYSCFG_H + +#ifdef __cplusplus + extern "C" { +#endif + +/*!< Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup SYSCFG + * @{ + */ +/* Exported types ------------------------------------------------------------*/ +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup SYSCFG_Exported_Constants + * @{ + */ + +/** @defgroup SYSCFG_EXTI_Port_Sources + * @{ + */ +#define EXTI_PortSourceGPIOA ((uint8_t)0x00) +#define EXTI_PortSourceGPIOB ((uint8_t)0x01) +#define EXTI_PortSourceGPIOC ((uint8_t)0x02) +#define EXTI_PortSourceGPIOD ((uint8_t)0x03) /*!< not available for STM32F031 devices */ +#define EXTI_PortSourceGPIOE ((uint8_t)0x04) /*!< only available for STM32F072 devices */ +#define EXTI_PortSourceGPIOF ((uint8_t)0x05) + +#define IS_EXTI_PORT_SOURCE(PORTSOURCE) (((PORTSOURCE) == EXTI_PortSourceGPIOA) || \ + ((PORTSOURCE) == EXTI_PortSourceGPIOB) || \ + ((PORTSOURCE) == EXTI_PortSourceGPIOC) || \ + ((PORTSOURCE) == EXTI_PortSourceGPIOD) || \ + ((PORTSOURCE) == EXTI_PortSourceGPIOE) || \ + ((PORTSOURCE) == EXTI_PortSourceGPIOF)) +/** + * @} + */ + +/** @defgroup SYSCFG_EXTI_Pin_sources + * @{ + */ +#define EXTI_PinSource0 ((uint8_t)0x00) +#define EXTI_PinSource1 ((uint8_t)0x01) +#define EXTI_PinSource2 ((uint8_t)0x02) +#define EXTI_PinSource3 ((uint8_t)0x03) +#define EXTI_PinSource4 ((uint8_t)0x04) +#define EXTI_PinSource5 ((uint8_t)0x05) +#define EXTI_PinSource6 ((uint8_t)0x06) +#define EXTI_PinSource7 ((uint8_t)0x07) +#define EXTI_PinSource8 ((uint8_t)0x08) +#define EXTI_PinSource9 ((uint8_t)0x09) +#define EXTI_PinSource10 ((uint8_t)0x0A) +#define EXTI_PinSource11 ((uint8_t)0x0B) +#define EXTI_PinSource12 ((uint8_t)0x0C) +#define EXTI_PinSource13 ((uint8_t)0x0D) +#define EXTI_PinSource14 ((uint8_t)0x0E) +#define EXTI_PinSource15 ((uint8_t)0x0F) + +#define IS_EXTI_PIN_SOURCE(PINSOURCE) (((PINSOURCE) == EXTI_PinSource0) || \ + ((PINSOURCE) == EXTI_PinSource1) || \ + ((PINSOURCE) == EXTI_PinSource2) || \ + ((PINSOURCE) == EXTI_PinSource3) || \ + ((PINSOURCE) == EXTI_PinSource4) || \ + ((PINSOURCE) == EXTI_PinSource5) || \ + ((PINSOURCE) == EXTI_PinSource6) || \ + ((PINSOURCE) == EXTI_PinSource7) || \ + ((PINSOURCE) == EXTI_PinSource8) || \ + ((PINSOURCE) == EXTI_PinSource9) || \ + ((PINSOURCE) == EXTI_PinSource10) || \ + ((PINSOURCE) == EXTI_PinSource11) || \ + ((PINSOURCE) == EXTI_PinSource12) || \ + ((PINSOURCE) == EXTI_PinSource13) || \ + ((PINSOURCE) == EXTI_PinSource14) || \ + ((PINSOURCE) == EXTI_PinSource15)) +/** + * @} + */ + +/** @defgroup SYSCFG_Memory_Remap_Config + * @{ + */ +#define SYSCFG_MemoryRemap_Flash ((uint8_t)0x00) +#define SYSCFG_MemoryRemap_SystemMemory ((uint8_t)0x01) +#define SYSCFG_MemoryRemap_SRAM ((uint8_t)0x03) + + +#define IS_SYSCFG_MEMORY_REMAP(REMAP) (((REMAP) == SYSCFG_MemoryRemap_Flash) || \ + ((REMAP) == SYSCFG_MemoryRemap_SystemMemory) || \ + ((REMAP) == SYSCFG_MemoryRemap_SRAM)) + +/** + * @} + */ + +/** @defgroup SYSCFG_DMA_Remap_Config + * @{ + */ +#define SYSCFG_DMARemap_TIM3 SYSCFG_CFGR1_TIM3_DMA_RMP /* Remap TIM3 DMA requests from channel4 to channel6, + available only for STM32F072 devices */ +#define SYSCFG_DMARemap_TIM2 SYSCFG_CFGR1_TIM2_DMA_RMP /* Remap TIM2 DMA requests from channel3/4 to channel7, + available only for STM32F072 devices */ +#define SYSCFG_DMARemap_TIM1 SYSCFG_CFGR1_TIM1_DMA_RMP /* Remap TIM1 DMA requests from channel2/3/4 to channel6, + available only for STM32F072 devices */ +#define SYSCFG_DMARemap_I2C1 SYSCFG_CFGR1_I2C1_DMA_RMP /* Remap I2C1 DMA requests from channel3/2 to channel7/6, + available only for STM32F072 devices */ +#define SYSCFG_DMARemap_USART3 SYSCFG_CFGR1_USART3_DMA_RMP /* Remap USART3 DMA requests from channel6/7 to channel3/2, + available only for STM32F072 devices */ +#define SYSCFG_DMARemap_USART2 SYSCFG_CFGR1_USART2_DMA_RMP /* Remap USART2 DMA requests from channel4/5 to channel6/7, + available only for STM32F072 devices */ +#define SYSCFG_DMARemap_SPI2 SYSCFG_CFGR1_SPI2_DMA_RMP /* Remap SPI2 DMA requests from channel4/5 to channel6/7, + available only for STM32F072 devices */ +#define SYSCFG_DMARemap_TIM17_2 SYSCFG_CFGR1_TIM17_DMA_RMP2 /* Remap TIM17 DMA requests from channel1/2 to channel7, + available only for STM32F072 devices */ +#define SYSCFG_DMARemap_TIM16_2 SYSCFG_CFGR1_TIM16_DMA_RMP2 /* Remap TIM16 DMA requests from channel3/4 to channel6, + available only for STM32F072 devices */ +#define SYSCFG_DMARemap_TIM17 SYSCFG_CFGR1_TIM17_DMA_RMP /* Remap TIM17 DMA requests from channel1 to channel2 */ +#define SYSCFG_DMARemap_TIM16 SYSCFG_CFGR1_TIM16_DMA_RMP /* Remap TIM16 DMA requests from channel3 to channel4 */ +#define SYSCFG_DMARemap_USART1Rx SYSCFG_CFGR1_USART1RX_DMA_RMP /* Remap USART1 Rx DMA requests from channel3 to channel5 */ +#define SYSCFG_DMARemap_USART1Tx SYSCFG_CFGR1_USART1TX_DMA_RMP /* Remap USART1 Tx DMA requests from channel2 to channel4 */ +#define SYSCFG_DMARemap_ADC1 SYSCFG_CFGR1_ADC_DMA_RMP /* Remap ADC1 DMA requests from channel1 to channel2 */ + +#define IS_SYSCFG_DMA_REMAP(REMAP) (((REMAP) == SYSCFG_DMARemap_TIM17) || \ + ((REMAP) == SYSCFG_DMARemap_TIM16) || \ + ((REMAP) == SYSCFG_DMARemap_USART1Rx) || \ + ((REMAP) == SYSCFG_DMARemap_USART1Tx) || \ + ((REMAP) == SYSCFG_CFGR1_TIM3_DMA_RMP) || \ + ((REMAP) == SYSCFG_CFGR1_TIM2_DMA_RMP) || \ + ((REMAP) == SYSCFG_CFGR1_TIM1_DMA_RMP) || \ + ((REMAP) == SYSCFG_CFGR1_I2C1_DMA_RMP) || \ + ((REMAP) == SYSCFG_CFGR1_USART3_DMA_RMP) || \ + ((REMAP) == SYSCFG_CFGR1_USART2_DMA_RMP) || \ + ((REMAP) == SYSCFG_CFGR1_SPI2_DMA_RMP) || \ + ((REMAP) == SYSCFG_CFGR1_TIM17_DMA_RMP2) || \ + ((REMAP) == SYSCFG_CFGR1_TIM16_DMA_RMP2) || \ + ((REMAP) == SYSCFG_DMARemap_ADC1)) + +/** + * @} + */ + +/** @defgroup SYSCFG_I2C_FastModePlus_Config + * @{ + */ +#define SYSCFG_I2CFastModePlus_PB6 SYSCFG_CFGR1_I2C_FMP_PB6 /* Enable Fast Mode Plus on PB6 */ +#define SYSCFG_I2CFastModePlus_PB7 SYSCFG_CFGR1_I2C_FMP_PB7 /* Enable Fast Mode Plus on PB7 */ +#define SYSCFG_I2CFastModePlus_PB8 SYSCFG_CFGR1_I2C_FMP_PB8 /* Enable Fast Mode Plus on PB8 */ +#define SYSCFG_I2CFastModePlus_PB9 SYSCFG_CFGR1_I2C_FMP_PB9 /* Enable Fast Mode Plus on PB9 */ +#define SYSCFG_I2CFastModePlus_I2C1 SYSCFG_CFGR1_I2C_FMP_I2C1 /* Enable Fast Mode Plus on PB10, PB11, PF6 and PF7(only for STM32F0031 and STM32F030 devices) */ +#define SYSCFG_I2CFastModePlus_I2C2 SYSCFG_CFGR1_I2C_FMP_I2C2 /* Enable Fast Mode Plus on I2C2 pins, available only for STM32F072 devices */ +#define SYSCFG_I2CFastModePlus_PA9 SYSCFG_CFGR1_I2C_FMP_PA9 /* Enable Fast Mode Plus on PA9 (only for STM32F031 and STM32F030 devices) */ +#define SYSCFG_I2CFastModePlus_PA10 SYSCFG_CFGR1_I2C_FMP_PA10/* Enable Fast Mode Plus on PA10(only for STM32F031 and STM32F030 devices) */ + +#define IS_SYSCFG_I2C_FMP(PIN) (((PIN) == SYSCFG_I2CFastModePlus_PB6) || \ + ((PIN) == SYSCFG_I2CFastModePlus_PB7) || \ + ((PIN) == SYSCFG_I2CFastModePlus_PB8) || \ + ((PIN) == SYSCFG_I2CFastModePlus_PB9) || \ + ((PIN) == SYSCFG_I2CFastModePlus_I2C1) || \ + ((PIN) == SYSCFG_I2CFastModePlus_I2C2) || \ + ((PIN) == SYSCFG_I2CFastModePlus_PA9) || \ + ((PIN) == SYSCFG_I2CFastModePlus_PA10)) + + +/** + * @} + */ + +/** @defgroup SYSCFG_Lock_Config + * @{ + */ +#define SYSCFG_Break_PVD SYSCFG_CFGR2_PVD_LOCK /*!< Connects the PVD event to the Break Input of TIM1, not available for STM32F030 devices */ +#define SYSCFG_Break_SRAMParity SYSCFG_CFGR2_SRAM_PARITY_LOCK /*!< Connects the SRAM_PARITY error signal to the Break Input of TIM1 */ +#define SYSCFG_Break_Lockup SYSCFG_CFGR2_LOCKUP_LOCK /*!< Connects Lockup output of CortexM0 to the break input of TIM1 */ + +#define IS_SYSCFG_LOCK_CONFIG(CONFIG) (((CONFIG) == SYSCFG_Break_PVD) || \ + ((CONFIG) == SYSCFG_Break_SRAMParity) || \ + ((CONFIG) == SYSCFG_Break_Lockup)) + +/** + * @} + */ + +/** @defgroup SYSCFG_flags_definition + * @{ + */ + +#define SYSCFG_FLAG_PE SYSCFG_CFGR2_SRAM_PE + +#define IS_SYSCFG_FLAG(FLAG) (((FLAG) == SYSCFG_FLAG_PE)) + +/** + * @} + */ + +/** @defgroup SYSCFG_ISR_WRAPPER + * @{ + */ +#define SYSCFG_ITLINE0 ((uint32_t) 0x00000000) +#define SYSCFG_ITLINE1 ((uint32_t) 0x00000001) +#define SYSCFG_ITLINE2 ((uint32_t) 0x00000002) +#define SYSCFG_ITLINE3 ((uint32_t) 0x00000003) +#define SYSCFG_ITLINE4 ((uint32_t) 0x00000004) +#define SYSCFG_ITLINE5 ((uint32_t) 0x00000005) +#define SYSCFG_ITLINE6 ((uint32_t) 0x00000006) +#define SYSCFG_ITLINE7 ((uint32_t) 0x00000007) +#define SYSCFG_ITLINE8 ((uint32_t) 0x00000008) +#define SYSCFG_ITLINE9 ((uint32_t) 0x00000009) +#define SYSCFG_ITLINE10 ((uint32_t) 0x0000000A) +#define SYSCFG_ITLINE11 ((uint32_t) 0x0000000B) +#define SYSCFG_ITLINE12 ((uint32_t) 0x0000000C) +#define SYSCFG_ITLINE13 ((uint32_t) 0x0000000D) +#define SYSCFG_ITLINE14 ((uint32_t) 0x0000000E) +#define SYSCFG_ITLINE15 ((uint32_t) 0x0000000F) +#define SYSCFG_ITLINE16 ((uint32_t) 0x00000010) +#define SYSCFG_ITLINE17 ((uint32_t) 0x00000011) +#define SYSCFG_ITLINE18 ((uint32_t) 0x00000012) +#define SYSCFG_ITLINE19 ((uint32_t) 0x00000013) +#define SYSCFG_ITLINE20 ((uint32_t) 0x00000014) +#define SYSCFG_ITLINE21 ((uint32_t) 0x00000015) +#define SYSCFG_ITLINE22 ((uint32_t) 0x00000016) +#define SYSCFG_ITLINE23 ((uint32_t) 0x00000017) +#define SYSCFG_ITLINE24 ((uint32_t) 0x00000018) +#define SYSCFG_ITLINE25 ((uint32_t) 0x00000019) +#define SYSCFG_ITLINE26 ((uint32_t) 0x0000001A) +#define SYSCFG_ITLINE27 ((uint32_t) 0x0000001B) +#define SYSCFG_ITLINE28 ((uint32_t) 0x0000001C) +#define SYSCFG_ITLINE29 ((uint32_t) 0x0000001D) +#define SYSCFG_ITLINE30 ((uint32_t) 0x0000001E) +#define SYSCFG_ITLINE31 ((uint32_t) 0x0000001F) + +#define ITLINE_EWDG ((uint32_t) ((SYSCFG_ITLINE0 << 0x18) | SYSCFG_ITLINE0_SR_EWDG)) /* EWDG Interrupt */ +#define ITLINE_PVDOUT ((uint32_t) ((SYSCFG_ITLINE1 << 0x18) | SYSCFG_ITLINE1_SR_PVDOUT)) /* Power voltage detection Interrupt */ +#define ITLINE_VDDIO2 ((uint32_t) ((SYSCFG_ITLINE1 << 0x18) | SYSCFG_ITLINE1_SR_VDDIO2)) /* VDDIO2 Interrupt */ +#define ITLINE_RTC_WAKEUP ((uint32_t) ((SYSCFG_ITLINE2 << 0x18) | SYSCFG_ITLINE2_SR_RTC_WAKEUP)) /* RTC WAKEUP -> exti[20] Interrupt */ +#define ITLINE_RTC_TSTAMP ((uint32_t) ((SYSCFG_ITLINE2 << 0x18) | SYSCFG_ITLINE2_SR_RTC_TSTAMP)) /* RTC Time Stamp -> exti[19] interrupt */ +#define ITLINE_RTC_ALRA ((uint32_t) ((SYSCFG_ITLINE2 << 0x18) | SYSCFG_ITLINE2_SR_RTC_ALRA)) /* RTC Alarm -> exti[17] interrupt */ +#define ITLINE_FLASH_ITF ((uint32_t) ((SYSCFG_ITLINE3 << 0x18) | SYSCFG_ITLINE3_SR_FLASH_ITF)) /* Flash ITF Interrupt */ +#define ITLINE_CRS ((uint32_t) ((SYSCFG_ITLINE4 << 0x18) | SYSCFG_ITLINE4_SR_CRS)) /* CRS Interrupt */ +#define ITLINE_CLK_CTRL ((uint32_t) ((SYSCFG_ITLINE4 << 0x18) | SYSCFG_ITLINE4_SR_CLK_CTRL)) /* CLK Control Interrupt */ +#define ITLINE_EXTI0 ((uint32_t) ((SYSCFG_ITLINE5 << 0x18) | SYSCFG_ITLINE5_SR_EXTI0)) /* External Interrupt 0 */ +#define ITLINE_EXTI1 ((uint32_t) ((SYSCFG_ITLINE5 << 0x18) | SYSCFG_ITLINE5_SR_EXTI1)) /* External Interrupt 1 */ +#define ITLINE_EXTI2 ((uint32_t) ((SYSCFG_ITLINE6 << 0x18) | SYSCFG_ITLINE6_SR_EXTI2)) /* External Interrupt 2 */ +#define ITLINE_EXTI3 ((uint32_t) ((SYSCFG_ITLINE6 << 0x18) | SYSCFG_ITLINE6_SR_EXTI3)) /* External Interrupt 3 */ +#define ITLINE_EXTI4 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI4)) /* EXTI4 Interrupt */ +#define ITLINE_EXTI5 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI5)) /* EXTI5 Interrupt */ +#define ITLINE_EXTI6 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI6)) /* EXTI6 Interrupt */ +#define ITLINE_EXTI7 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI7)) /* EXTI7 Interrupt */ +#define ITLINE_EXTI8 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI8)) /* EXTI8 Interrupt */ +#define ITLINE_EXTI9 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI9)) /* EXTI9 Interrupt */ +#define ITLINE_EXTI10 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI10)) /* EXTI10 Interrupt */ +#define ITLINE_EXTI11 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI11)) /* EXTI11 Interrupt */ +#define ITLINE_EXTI12 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI12)) /* EXTI12 Interrupt */ +#define ITLINE_EXTI13 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI13)) /* EXTI13 Interrupt */ +#define ITLINE_EXTI14 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI14)) /* EXTI14 Interrupt */ +#define ITLINE_EXTI15 ((uint32_t) ((SYSCFG_ITLINE7 << 0x18) | SYSCFG_ITLINE7_SR_EXTI15)) /* EXTI15 Interrupt */ +#define ITLINE_TSC_EOA ((uint32_t) ((SYSCFG_ITLINE8 << 0x18) | SYSCFG_ITLINE8_SR_TSC_EOA)) /* Touch control EOA Interrupt */ +#define ITLINE_TSC_MCE ((uint32_t) ((SYSCFG_ITLINE8 << 0x18) | SYSCFG_ITLINE8_SR_TSC_MCE)) /* Touch control MCE Interrupt */ +#define ITLINE_DMA1_CH1 ((uint32_t) ((SYSCFG_ITLINE9 << 0x18) | SYSCFG_ITLINE9_SR_DMA1_CH1)) /* DMA1 Channel 1 Interrupt */ +#define ITLINE_DMA1_CH2 ((uint32_t) ((SYSCFG_ITLINE10 << 0x18) | SYSCFG_ITLINE10_SR_DMA1_CH2)) /* DMA1 Channel 2 Interrupt */ +#define ITLINE_DMA1_CH3 ((uint32_t) ((SYSCFG_ITLINE10 << 0x18) | SYSCFG_ITLINE10_SR_DMA1_CH3)) /* DMA1 Channel 3 Interrupt */ +#define ITLINE_DMA2_CH1 ((uint32_t) ((SYSCFG_ITLINE10 << 0x18) | SYSCFG_ITLINE10_SR_DMA2_CH1)) /* DMA2 Channel 1 Interrupt */ +#define ITLINE_DMA2_CH2 ((uint32_t) ((SYSCFG_ITLINE10 << 0x18) | SYSCFG_ITLINE10_SR_DMA2_CH2)) /* DMA2 Channel 2 Interrupt */ +#define ITLINE_DMA1_CH4 ((uint32_t) ((SYSCFG_ITLINE11 << 0x18) | SYSCFG_ITLINE11_SR_DMA1_CH4)) /* DMA1 Channel 4 Interrupt */ +#define ITLINE_DMA1_CH5 ((uint32_t) ((SYSCFG_ITLINE11 << 0x18) | SYSCFG_ITLINE11_SR_DMA1_CH5)) /* DMA1 Channel 5 Interrupt */ +#define ITLINE_DMA1_CH6 ((uint32_t) ((SYSCFG_ITLINE11 << 0x18) | SYSCFG_ITLINE11_SR_DMA1_CH6)) /* DMA1 Channel 6 Interrupt */ +#define ITLINE_DMA1_CH7 ((uint32_t) ((SYSCFG_ITLINE11 << 0x18) | SYSCFG_ITLINE11_SR_DMA1_CH7)) /* DMA1 Channel 7 Interrupt */ +#define ITLINE_DMA2_CH3 ((uint32_t) ((SYSCFG_ITLINE11 << 0x18) | SYSCFG_ITLINE11_SR_DMA2_CH3)) /* DMA2 Channel 3 Interrupt */ +#define ITLINE_DMA2_CH4 ((uint32_t) ((SYSCFG_ITLINE11 << 0x18) | SYSCFG_ITLINE11_SR_DMA2_CH4)) /* DMA2 Channel 4 Interrupt */ +#define ITLINE_DMA2_CH5 ((uint32_t) ((SYSCFG_ITLINE11 << 0x18) | SYSCFG_ITLINE11_SR_DMA2_CH5)) /* DMA2 Channel 5 Interrupt */ +#define ITLINE_ADC ((uint32_t) ((SYSCFG_ITLINE12 << 0x18) | SYSCFG_ITLINE12_SR_ADC)) /* ADC Interrupt */ +#define ITLINE_COMP1 ((uint32_t) ((SYSCFG_ITLINE12 << 0x18) | SYSCFG_ITLINE12_SR_COMP1)) /* COMP1 Interrupt -> exti[21] */ +#define ITLINE_COMP2 ((uint32_t) ((SYSCFG_ITLINE12 << 0x18) | SYSCFG_ITLINE12_SR_COMP2)) /* COMP2 Interrupt -> exti[21] */ +#define ITLINE_TIM1_BRK ((uint32_t) ((SYSCFG_ITLINE13 << 0x18) | SYSCFG_ITLINE13_SR_TIM1_BRK)) /* TIM1 BRK Interrupt */ +#define ITLINE_TIM1_UPD ((uint32_t) ((SYSCFG_ITLINE13 << 0x18) | SYSCFG_ITLINE13_SR_TIM1_UPD)) /* TIM1 UPD Interrupt */ +#define ITLINE_TIM1_TRG ((uint32_t) ((SYSCFG_ITLINE13 << 0x18) | SYSCFG_ITLINE13_SR_TIM1_TRG)) /* TIM1 TRG Interrupt */ +#define ITLINE_TIM1_CCU ((uint32_t) ((SYSCFG_ITLINE13 << 0x18) | SYSCFG_ITLINE13_SR_TIM1_CCU)) /* TIM1 CCU Interrupt */ +#define ITLINE_TIM1_CC ((uint32_t) ((SYSCFG_ITLINE14 << 0x18) | SYSCFG_ITLINE14_SR_TIM1_CC)) /* TIM1 CC Interrupt */ +#define ITLINE_TIM2 ((uint32_t) ((SYSCFG_ITLINE15 << 0x18) | SYSCFG_ITLINE15_SR_TIM2_GLB)) /* TIM2 Interrupt */ +#define ITLINE_TIM3 ((uint32_t) ((SYSCFG_ITLINE16 << 0x18) | SYSCFG_ITLINE16_SR_TIM3_GLB)) /* TIM3 Interrupt */ +#define ITLINE_DAC ((uint32_t) ((SYSCFG_ITLINE17 << 0x18) | SYSCFG_ITLINE17_SR_DAC)) /* DAC Interrupt */ +#define ITLINE_TIM6 ((uint32_t) ((SYSCFG_ITLINE17 << 0x18) | SYSCFG_ITLINE17_SR_TIM6_GLB)) /* TIM6 Interrupt */ +#define ITLINE_TIM7 ((uint32_t) ((SYSCFG_ITLINE18 << 0x18) | SYSCFG_ITLINE18_SR_TIM7_GLB)) /* TIM7 Interrupt */ +#define ITLINE_TIM14 ((uint32_t) ((SYSCFG_ITLINE19 << 0x18) | SYSCFG_ITLINE19_SR_TIM14_GLB)) /* TIM14 Interrupt */ +#define ITLINE_TIM15 ((uint32_t) ((SYSCFG_ITLINE20 << 0x18) | SYSCFG_ITLINE20_SR_TIM15_GLB)) /* TIM15 Interrupt */ +#define ITLINE_TIM16 ((uint32_t) ((SYSCFG_ITLINE21 << 0x18) | SYSCFG_ITLINE21_SR_TIM16_GLB)) /* TIM16 Interrupt */ +#define ITLINE_TIM17 ((uint32_t) ((SYSCFG_ITLINE22 << 0x18) | SYSCFG_ITLINE22_SR_TIM17_GLB)) /* TIM17 Interrupt */ +#define ITLINE_I2C1 ((uint32_t) ((SYSCFG_ITLINE23 << 0x18) | SYSCFG_ITLINE23_SR_I2C1_GLB)) /* I2C1 Interrupt -> exti[23] */ +#define ITLINE_I2C2 ((uint32_t) ((SYSCFG_ITLINE24 << 0x18) | SYSCFG_ITLINE24_SR_I2C2_GLB)) /* I2C2 Interrupt */ +#define ITLINE_SPI1 ((uint32_t) ((SYSCFG_ITLINE25 << 0x18) | SYSCFG_ITLINE25_SR_SPI1)) /* I2C1 Interrupt -> exti[23] */ +#define ITLINE_SPI2 ((uint32_t) ((SYSCFG_ITLINE26 << 0x18) | SYSCFG_ITLINE26_SR_SPI2)) /* SPI1 Interrupt */ +#define ITLINE_USART1 ((uint32_t) ((SYSCFG_ITLINE27 << 0x18) | SYSCFG_ITLINE27_SR_USART1_GLB)) /*!< USART1 GLB Interrupt -> exti[25] */ +#define ITLINE_USART2 ((uint32_t) ((SYSCFG_ITLINE28 << 0x18) | SYSCFG_ITLINE28_SR_USART2_GLB)) /*!< USART2 GLB Interrupt -> exti[26] */ +#define ITLINE_USART3 ((uint32_t) ((SYSCFG_ITLINE29 << 0x18) | SYSCFG_ITLINE29_SR_USART3_GLB)) /* USART3 Interrupt */ +#define ITLINE_USART4 ((uint32_t) ((SYSCFG_ITLINE29 << 0x18) | SYSCFG_ITLINE29_SR_USART4_GLB)) /* USART4 Interrupt */ +#define ITLINE_USART5 ((uint32_t) ((SYSCFG_ITLINE29 << 0x18) | SYSCFG_ITLINE29_SR_USART5_GLB)) /* USART5 Interrupt */ +#define ITLINE_USART6 ((uint32_t) ((SYSCFG_ITLINE29 << 0x18) | SYSCFG_ITLINE29_SR_USART6_GLB)) /* USART6 Interrupt */ +#define ITLINE_USART7 ((uint32_t) ((SYSCFG_ITLINE29 << 0x18) | SYSCFG_ITLINE29_SR_USART7_GLB)) /* USART7 Interrupt */ +#define ITLINE_USART8 ((uint32_t) ((SYSCFG_ITLINE29 << 0x18) | SYSCFG_ITLINE29_SR_USART8_GLB)) /* USART8 Interrupt */ +#define ITLINE_CAN ((uint32_t) ((SYSCFG_ITLINE30 << 0x18) | SYSCFG_ITLINE30_SR_CAN)) /* CAN Interrupt */ +#define ITLINE_CEC ((uint32_t) ((SYSCFG_ITLINE30 << 0x18) | SYSCFG_ITLINE30_SR_CEC)) /* CEC Interrupt -> exti[27] */ + +#define IS_SYSCFG_ITLINE(LINE) (((LINE) == ITLINE_EWDG) || \ + ((LINE) == ITLINE_PVDOUT) || \ + ((LINE) == ITLINE_VDDIO2) || \ + ((LINE) == ITLINE_RTC_WAKEUP) || \ + ((LINE) == ITLINE_RTC_TSTAMP) || \ + ((LINE) == ITLINE_RTC_ALRA) || \ + ((LINE) == ITLINE_FLASH_ITF) || \ + ((LINE) == ITLINE_CRS) || \ + ((LINE) == ITLINE_CLK_CTRL) || \ + ((LINE) == ITLINE_EXTI0) || \ + ((LINE) == ITLINE_EXTI1) || \ + ((LINE) == ITLINE_EXTI2) || \ + ((LINE) == ITLINE_EXTI3) || \ + ((LINE) == ITLINE_EXTI4) || \ + ((LINE) == ITLINE_EXTI5) || \ + ((LINE) == ITLINE_EXTI6) || \ + ((LINE) == ITLINE_EXTI7) || \ + ((LINE) == ITLINE_EXTI8) || \ + ((LINE) == ITLINE_EXTI9) || \ + ((LINE) == ITLINE_EXTI10) || \ + ((LINE) == ITLINE_EXTI11) || \ + ((LINE) == ITLINE_EXTI12) || \ + ((LINE) == ITLINE_EXTI13) || \ + ((LINE) == ITLINE_EXTI14) || \ + ((LINE) == ITLINE_EXTI15) || \ + ((LINE) == ITLINE_TSC_EOA) || \ + ((LINE) == ITLINE_TSC_MCE) || \ + ((LINE) == ITLINE_DMA1_CH1) || \ + ((LINE) == ITLINE_DMA1_CH2) || \ + ((LINE) == ITLINE_DMA1_CH3) || \ + ((LINE) == ITLINE_DMA1_CH4) || \ + ((LINE) == ITLINE_DMA1_CH5) || \ + ((LINE) == ITLINE_DMA1_CH6) || \ + ((LINE) == ITLINE_DMA1_CH7) || \ + ((LINE) == ITLINE_DMA2_CH1) || \ + ((LINE) == ITLINE_DMA2_CH2) || \ + ((LINE) == ITLINE_DMA2_CH3) || \ + ((LINE) == ITLINE_DMA2_CH4) || \ + ((LINE) == ITLINE_DMA2_CH5) || \ + ((LINE) == ITLINE_ADC) || \ + ((LINE) == ITLINE_COMP1) || \ + ((LINE) == ITLINE_COMP2) || \ + ((LINE) == ITLINE_TIM1_BRK) || \ + ((LINE) == ITLINE_TIM1_UPD) || \ + ((LINE) == ITLINE_TIM1_TRG) || \ + ((LINE) == ITLINE_TIM1_CCU) || \ + ((LINE) == ITLINE_TIM1_CC) || \ + ((LINE) == ITLINE_TIM2) || \ + ((LINE) == ITLINE_TIM3) || \ + ((LINE) == ITLINE_DAC) || \ + ((LINE) == ITLINE_TIM6) || \ + ((LINE) == ITLINE_TIM7) || \ + ((LINE) == ITLINE_TIM14) || \ + ((LINE) == ITLINE_TIM15) || \ + ((LINE) == ITLINE_TIM16) || \ + ((LINE) == ITLINE_TIM17) || \ + ((LINE) == ITLINE_I2C1) || \ + ((LINE) == ITLINE_I2C2) || \ + ((LINE) == ITLINE_SPI1) || \ + ((LINE) == ITLINE_SPI2) || \ + ((LINE) == ITLINE_USART1) || \ + ((LINE) == ITLINE_USART2) || \ + ((LINE) == ITLINE_USART3) || \ + ((LINE) == ITLINE_USART4) || \ + ((LINE) == ITLINE_USART5) || \ + ((LINE) == ITLINE_USART6) || \ + ((LINE) == ITLINE_USART7) || \ + ((LINE) == ITLINE_USART8) || \ + ((LINE) == ITLINE_CAN) || \ + ((LINE) == ITLINE_CEC)) + +/** + * @} + */ +/** @defgroup IRDA_ENV_SEL + * @{ + */ +#define SYSCFG_IRDA_ENV_SEL_TIM16 (SYSCFG_CFGR1_IRDA_ENV_SEL_0&SYSCFG_CFGR1_IRDA_ENV_SEL_1) /* Timer16 is selected as IRDA Modulation envelope source */ +#define SYSCFG_IRDA_ENV_SEL_USART1 (SYSCFG_CFGR1_IRDA_ENV_SEL_0) /* USART1 is selected as IRDA Modulation envelope source.*/ +#define SYSCFG_IRDA_ENV_SEL_USART4 (SYSCFG_CFGR1_IRDA_ENV_SEL_1) /* USART4 is selected as IRDA Modulation envelope source.*/ + +#define IS_SYSCFG_IRDA_ENV(ENV) (((ENV) == SYSCFG_IRDA_ENV_SEL_TIM16) || \ + ((ENV) == SYSCFG_IRDA_ENV_SEL_USART1) || \ + ((ENV) == SYSCFG_IRDA_ENV_SEL_USART4)) +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Function used to set the SYSCFG configuration to the default reset state **/ +void SYSCFG_DeInit(void); + +/* SYSCFG configuration functions *********************************************/ +void SYSCFG_MemoryRemapConfig(uint32_t SYSCFG_MemoryRemap); +void SYSCFG_DMAChannelRemapConfig(uint32_t SYSCFG_DMARemap, FunctionalState NewState); +void SYSCFG_I2CFastModePlusConfig(uint32_t SYSCFG_I2CFastModePlus, FunctionalState NewState); +void SYSCFG_IRDAEnvSelection(uint32_t SYSCFG_IRDAEnv); +void SYSCFG_EXTILineConfig(uint8_t EXTI_PortSourceGPIOx, uint8_t EXTI_PinSourcex); +uint32_t SYSCFG_GetPendingIT(uint32_t ITSourceLine); +void SYSCFG_BreakConfig(uint32_t SYSCFG_Break); +FlagStatus SYSCFG_GetFlagStatus(uint32_t SYSCFG_Flag); +void SYSCFG_ClearFlag(uint32_t SYSCFG_Flag); + +#ifdef __cplusplus +} +#endif + +#endif /*__STM32F0XX_SYSCFG_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_tim.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_tim.h new file mode 100644 index 00000000..7a4c8b99 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_tim.h @@ -0,0 +1,1186 @@ +/** + ****************************************************************************** + * @file stm32f0xx_tim.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the TIM + * firmware library. + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_TIM_H +#define __STM32F0XX_TIM_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup TIM + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + +/** + * @brief TIM Time Base Init structure definition + * @note This sturcture is used with all TIMx. + */ + +typedef struct +{ + uint16_t TIM_Prescaler; /*!< Specifies the prescaler value used to divide the TIM clock. + This parameter can be a number between 0x0000 and 0xFFFF */ + + uint16_t TIM_CounterMode; /*!< Specifies the counter mode. + This parameter can be a value of @ref TIM_Counter_Mode */ + + uint32_t TIM_Period; /*!< Specifies the period value to be loaded into the active + Auto-Reload Register at the next update event. + This parameter must be a number between 0x0000 and 0xFFFF. */ + + uint16_t TIM_ClockDivision; /*!< Specifies the clock division. + This parameter can be a value of @ref TIM_Clock_Division_CKD */ + + uint8_t TIM_RepetitionCounter; /*!< Specifies the repetition counter value. Each time the RCR downcounter + reaches zero, an update event is generated and counting restarts + from the RCR value (N). + This means in PWM mode that (N+1) corresponds to: + - the number of PWM periods in edge-aligned mode + - the number of half PWM period in center-aligned mode + This parameter must be a number between 0x00 and 0xFF. + @note This parameter is valid only for TIM1. */ +} TIM_TimeBaseInitTypeDef; + +/** + * @brief TIM Output Compare Init structure definition + */ + +typedef struct +{ + uint16_t TIM_OCMode; /*!< Specifies the TIM mode. + This parameter can be a value of @ref TIM_Output_Compare_and_PWM_modes */ + + uint16_t TIM_OutputState; /*!< Specifies the TIM Output Compare state. + This parameter can be a value of @ref TIM_Output_Compare_state */ + + uint16_t TIM_OutputNState; /*!< Specifies the TIM complementary Output Compare state. + This parameter can be a value of @ref TIM_Output_Compare_N_state + @note This parameter is valid only for TIM1. */ + + uint32_t TIM_Pulse; /*!< Specifies the pulse value to be loaded into the Capture Compare Register. + This parameter can be a number between 0x0000 and 0xFFFF ( or 0xFFFFFFFF + for TIM2) */ + + uint16_t TIM_OCPolarity; /*!< Specifies the output polarity. + This parameter can be a value of @ref TIM_Output_Compare_Polarity */ + + uint16_t TIM_OCNPolarity; /*!< Specifies the complementary output polarity. + This parameter can be a value of @ref TIM_Output_Compare_N_Polarity + @note This parameter is valid only for TIM1. */ + + uint16_t TIM_OCIdleState; /*!< Specifies the TIM Output Compare pin state during Idle state. + This parameter can be a value of @ref TIM_Output_Compare_Idle_State + @note This parameter is valid only for TIM1. */ + + uint16_t TIM_OCNIdleState; /*!< Specifies the TIM Output Compare pin state during Idle state. + This parameter can be a value of @ref TIM_Output_Compare_N_Idle_State + @note This parameter is valid only for TIM1. */ +} TIM_OCInitTypeDef; + +/** + * @brief TIM Input Capture Init structure definition + */ + +typedef struct +{ + + uint16_t TIM_Channel; /*!< Specifies the TIM channel. + This parameter can be a value of @ref TIM_Channel */ + + uint16_t TIM_ICPolarity; /*!< Specifies the active edge of the input signal. + This parameter can be a value of @ref TIM_Input_Capture_Polarity */ + + uint16_t TIM_ICSelection; /*!< Specifies the input. + This parameter can be a value of @ref TIM_Input_Capture_Selection */ + + uint16_t TIM_ICPrescaler; /*!< Specifies the Input Capture Prescaler. + This parameter can be a value of @ref TIM_Input_Capture_Prescaler */ + + uint16_t TIM_ICFilter; /*!< Specifies the input capture filter. + This parameter can be a number between 0x0 and 0xF */ +} TIM_ICInitTypeDef; + +/** + * @brief TIM_BDTR structure definition + * @note This sturcture is used only with TIM1. + */ + +typedef struct +{ + + uint16_t TIM_OSSRState; /*!< Specifies the Off-State selection used in Run mode. + This parameter can be a value of @ref TIM_OSSR_Off_State_Selection_for_Run_mode_state */ + + uint16_t TIM_OSSIState; /*!< Specifies the Off-State used in Idle state. + This parameter can be a value of @ref TIM_OSSI_Off_State_Selection_for_Idle_mode_state */ + + uint16_t TIM_LOCKLevel; /*!< Specifies the LOCK level parameters. + This parameter can be a value of @ref TIM_Lock_level */ + + uint16_t TIM_DeadTime; /*!< Specifies the delay time between the switching-off and the + switching-on of the outputs. + This parameter can be a number between 0x00 and 0xFF */ + + uint16_t TIM_Break; /*!< Specifies whether the TIM Break input is enabled or not. + This parameter can be a value of @ref TIM_Break_Input_enable_disable */ + + uint16_t TIM_BreakPolarity; /*!< Specifies the TIM Break Input pin polarity. + This parameter can be a value of @ref TIM_Break_Polarity */ + + uint16_t TIM_AutomaticOutput; /*!< Specifies whether the TIM Automatic Output feature is enabled or not. + This parameter can be a value of @ref TIM_AOE_Bit_Set_Reset */ +} TIM_BDTRInitTypeDef; + +/** + * @brief TIM Input Capture Init structure definition + */ + +/* Exported constants --------------------------------------------------------*/ + + +/** @defgroup TIM_Exported_constants + * @{ + */ + +#define IS_TIM_ALL_PERIPH(PERIPH) (((PERIPH) == TIM1) || \ + ((PERIPH) == TIM2) || \ + ((PERIPH) == TIM3) || \ + ((PERIPH) == TIM6) || \ + ((PERIPH) == TIM7) || \ + ((PERIPH) == TIM14)|| \ + ((PERIPH) == TIM15)|| \ + ((PERIPH) == TIM16)|| \ + ((PERIPH) == TIM17)) + +/* LIST1: TIM 1 */ +#define IS_TIM_LIST1_PERIPH(PERIPH) ((PERIPH) == TIM1) + +/* LIST2: TIM 1, 15, 16 and 17 */ +#define IS_TIM_LIST2_PERIPH(PERIPH) (((PERIPH) == TIM1) || \ + ((PERIPH) == TIM15)|| \ + ((PERIPH) == TIM16)|| \ + ((PERIPH) == TIM17)) + +/* LIST3: TIM 1, 2 and 3 */ +#define IS_TIM_LIST3_PERIPH(PERIPH) (((PERIPH) == TIM1) || \ + ((PERIPH) == TIM2) || \ + ((PERIPH) == TIM3)) + +/* LIST4: TIM 1, 2, 3, 14, 15, 16 and 17 */ +#define IS_TIM_LIST4_PERIPH(PERIPH) (((PERIPH) == TIM1) || \ + ((PERIPH) == TIM2) || \ + ((PERIPH) == TIM3) || \ + ((PERIPH) == TIM14) || \ + ((PERIPH) == TIM15)|| \ + ((PERIPH) == TIM16)|| \ + ((PERIPH) == TIM17)) + +/* LIST5: TIM 1, 2, 3, 15, 16 and 17 */ +#define IS_TIM_LIST5_PERIPH(PERIPH) (((PERIPH) == TIM1) || \ + ((PERIPH) == TIM2) || \ + ((PERIPH) == TIM3) || \ + ((PERIPH) == TIM15)|| \ + ((PERIPH) == TIM16)|| \ + ((PERIPH) == TIM17)) + +/* LIST6: TIM 1, 2, 3 and 15 */ +#define IS_TIM_LIST6_PERIPH(PERIPH) (((PERIPH) == TIM1) || \ + ((PERIPH) == TIM2) || \ + ((PERIPH) == TIM3) || \ + ((PERIPH) == TIM15)) + +/* LIST7: TIM 1, 2, 3, 6, 7 and 14 */ +#define IS_TIM_LIST7_PERIPH(PERIPH) (((PERIPH) == TIM1) || \ + ((PERIPH) == TIM2) || \ + ((PERIPH) == TIM3) || \ + ((PERIPH) == TIM6) || \ + ((PERIPH) == TIM7) || \ + ((PERIPH) == TIM14)) + +/* LIST8: TIM 1, 2, 3 and 14 */ +#define IS_TIM_LIST8_PERIPH(PERIPH) (((PERIPH) == TIM1) || \ + ((PERIPH) == TIM2) || \ + ((PERIPH) == TIM3) || \ + ((PERIPH) == TIM14)) + +/* LIST9: TIM 1, 2, 3, 6, 7 and 15 */ +#define IS_TIM_LIST9_PERIPH(PERIPH) (((PERIPH) == TIM1) || \ + ((PERIPH) == TIM2) || \ + ((PERIPH) == TIM3) || \ + ((PERIPH) == TIM6) || \ + ((PERIPH) == TIM7) || \ + ((PERIPH) == TIM15)) + +/* LIST10: TIM 1, 2, 3, 6, 7, 15, 16 and 17 */ +#define IS_TIM_LIST10_PERIPH(PERIPH) (((PERIPH) == TIM1) || \ + ((PERIPH) == TIM2) || \ + ((PERIPH) == TIM3) || \ + ((PERIPH) == TIM6) || \ + ((PERIPH) == TIM7) || \ + ((PERIPH) == TIM15)|| \ + ((PERIPH) == TIM16)|| \ + ((PERIPH) == TIM17)) + +/* LIST1: TIM 11 */ +#define IS_TIM_LIST11_PERIPH(PERIPH) ((PERIPH) == TIM14) + + +/** + * @} + */ + +/** @defgroup TIM_Output_Compare_and_PWM_modes + * @{ + */ + +#define TIM_OCMode_Timing ((uint16_t)0x0000) +#define TIM_OCMode_Active ((uint16_t)0x0010) +#define TIM_OCMode_Inactive ((uint16_t)0x0020) +#define TIM_OCMode_Toggle ((uint16_t)0x0030) +#define TIM_OCMode_PWM1 ((uint16_t)0x0060) +#define TIM_OCMode_PWM2 ((uint16_t)0x0070) +#define IS_TIM_OC_MODE(MODE) (((MODE) == TIM_OCMode_Timing) || \ + ((MODE) == TIM_OCMode_Active) || \ + ((MODE) == TIM_OCMode_Inactive) || \ + ((MODE) == TIM_OCMode_Toggle)|| \ + ((MODE) == TIM_OCMode_PWM1) || \ + ((MODE) == TIM_OCMode_PWM2)) +#define IS_TIM_OCM(MODE) (((MODE) == TIM_OCMode_Timing) || \ + ((MODE) == TIM_OCMode_Active) || \ + ((MODE) == TIM_OCMode_Inactive) || \ + ((MODE) == TIM_OCMode_Toggle)|| \ + ((MODE) == TIM_OCMode_PWM1) || \ + ((MODE) == TIM_OCMode_PWM2) || \ + ((MODE) == TIM_ForcedAction_Active) || \ + ((MODE) == TIM_ForcedAction_InActive)) +/** + * @} + */ + +/** @defgroup TIM_One_Pulse_Mode + * @{ + */ + +#define TIM_OPMode_Single ((uint16_t)0x0008) +#define TIM_OPMode_Repetitive ((uint16_t)0x0000) +#define IS_TIM_OPM_MODE(MODE) (((MODE) == TIM_OPMode_Single) || \ + ((MODE) == TIM_OPMode_Repetitive)) +/** + * @} + */ + +/** @defgroup TIM_Channel + * @{ + */ + +#define TIM_Channel_1 ((uint16_t)0x0000) +#define TIM_Channel_2 ((uint16_t)0x0004) +#define TIM_Channel_3 ((uint16_t)0x0008) +#define TIM_Channel_4 ((uint16_t)0x000C) + +#define IS_TIM_CHANNEL(CHANNEL) (((CHANNEL) == TIM_Channel_1) || \ + ((CHANNEL) == TIM_Channel_2) || \ + ((CHANNEL) == TIM_Channel_3) || \ + ((CHANNEL) == TIM_Channel_4)) +#define IS_TIM_COMPLEMENTARY_CHANNEL(CHANNEL) (((CHANNEL) == TIM_Channel_1) || \ + ((CHANNEL) == TIM_Channel_2) || \ + ((CHANNEL) == TIM_Channel_3)) +#define IS_TIM_PWMI_CHANNEL(CHANNEL) (((CHANNEL) == TIM_Channel_1) || \ + ((CHANNEL) == TIM_Channel_2)) + +/** + * @} + */ + +/** @defgroup TIM_Clock_Division_CKD + * @{ + */ + +#define TIM_CKD_DIV1 ((uint16_t)0x0000) +#define TIM_CKD_DIV2 ((uint16_t)0x0100) +#define TIM_CKD_DIV4 ((uint16_t)0x0200) +#define IS_TIM_CKD_DIV(DIV) (((DIV) == TIM_CKD_DIV1) || \ + ((DIV) == TIM_CKD_DIV2) || \ + ((DIV) == TIM_CKD_DIV4)) +/** + * @} + */ + +/** @defgroup TIM_Counter_Mode + * @{ + */ + +#define TIM_CounterMode_Up ((uint16_t)0x0000) +#define TIM_CounterMode_Down ((uint16_t)0x0010) +#define TIM_CounterMode_CenterAligned1 ((uint16_t)0x0020) +#define TIM_CounterMode_CenterAligned2 ((uint16_t)0x0040) +#define TIM_CounterMode_CenterAligned3 ((uint16_t)0x0060) +#define IS_TIM_COUNTER_MODE(MODE) (((MODE) == TIM_CounterMode_Up) || \ + ((MODE) == TIM_CounterMode_Down) || \ + ((MODE) == TIM_CounterMode_CenterAligned1) || \ + ((MODE) == TIM_CounterMode_CenterAligned2) || \ + ((MODE) == TIM_CounterMode_CenterAligned3)) +/** + * @} + */ + +/** @defgroup TIM_Output_Compare_Polarity + * @{ + */ + +#define TIM_OCPolarity_High ((uint16_t)0x0000) +#define TIM_OCPolarity_Low ((uint16_t)0x0002) +#define IS_TIM_OC_POLARITY(POLARITY) (((POLARITY) == TIM_OCPolarity_High) || \ + ((POLARITY) == TIM_OCPolarity_Low)) +/** + * @} + */ + +/** @defgroup TIM_Output_Compare_N_Polarity + * @{ + */ + +#define TIM_OCNPolarity_High ((uint16_t)0x0000) +#define TIM_OCNPolarity_Low ((uint16_t)0x0008) +#define IS_TIM_OCN_POLARITY(POLARITY) (((POLARITY) == TIM_OCNPolarity_High) || \ + ((POLARITY) == TIM_OCNPolarity_Low)) +/** + * @} + */ + +/** @defgroup TIM_Output_Compare_state + * @{ + */ + +#define TIM_OutputState_Disable ((uint16_t)0x0000) +#define TIM_OutputState_Enable ((uint16_t)0x0001) +#define IS_TIM_OUTPUT_STATE(STATE) (((STATE) == TIM_OutputState_Disable) || \ + ((STATE) == TIM_OutputState_Enable)) +/** + * @} + */ + +/** @defgroup TIM_Output_Compare_N_state + * @{ + */ + +#define TIM_OutputNState_Disable ((uint16_t)0x0000) +#define TIM_OutputNState_Enable ((uint16_t)0x0004) +#define IS_TIM_OUTPUTN_STATE(STATE) (((STATE) == TIM_OutputNState_Disable) || \ + ((STATE) == TIM_OutputNState_Enable)) +/** + * @} + */ + +/** @defgroup TIM_Capture_Compare_state + * @{ + */ + +#define TIM_CCx_Enable ((uint16_t)0x0001) +#define TIM_CCx_Disable ((uint16_t)0x0000) +#define IS_TIM_CCX(CCX) (((CCX) == TIM_CCx_Enable) || \ + ((CCX) == TIM_CCx_Disable)) +/** + * @} + */ + +/** @defgroup TIM_Capture_Compare_N_state + * @{ + */ + +#define TIM_CCxN_Enable ((uint16_t)0x0004) +#define TIM_CCxN_Disable ((uint16_t)0x0000) +#define IS_TIM_CCXN(CCXN) (((CCXN) == TIM_CCxN_Enable) || \ + ((CCXN) == TIM_CCxN_Disable)) +/** + * @} + */ + +/** @defgroup TIM_Break_Input_enable_disable + * @{ + */ + +#define TIM_Break_Enable ((uint16_t)0x1000) +#define TIM_Break_Disable ((uint16_t)0x0000) +#define IS_TIM_BREAK_STATE(STATE) (((STATE) == TIM_Break_Enable) || \ + ((STATE) == TIM_Break_Disable)) +/** + * @} + */ + +/** @defgroup TIM_Break_Polarity + * @{ + */ + +#define TIM_BreakPolarity_Low ((uint16_t)0x0000) +#define TIM_BreakPolarity_High ((uint16_t)0x2000) +#define IS_TIM_BREAK_POLARITY(POLARITY) (((POLARITY) == TIM_BreakPolarity_Low) || \ + ((POLARITY) == TIM_BreakPolarity_High)) +/** + * @} + */ + +/** @defgroup TIM_AOE_Bit_Set_Reset + * @{ + */ + +#define TIM_AutomaticOutput_Enable ((uint16_t)0x4000) +#define TIM_AutomaticOutput_Disable ((uint16_t)0x0000) +#define IS_TIM_AUTOMATIC_OUTPUT_STATE(STATE) (((STATE) == TIM_AutomaticOutput_Enable) || \ + ((STATE) == TIM_AutomaticOutput_Disable)) +/** + * @} + */ + +/** @defgroup TIM_Lock_level + * @{ + */ + +#define TIM_LOCKLevel_OFF ((uint16_t)0x0000) +#define TIM_LOCKLevel_1 ((uint16_t)0x0100) +#define TIM_LOCKLevel_2 ((uint16_t)0x0200) +#define TIM_LOCKLevel_3 ((uint16_t)0x0300) +#define IS_TIM_LOCK_LEVEL(LEVEL) (((LEVEL) == TIM_LOCKLevel_OFF) || \ + ((LEVEL) == TIM_LOCKLevel_1) || \ + ((LEVEL) == TIM_LOCKLevel_2) || \ + ((LEVEL) == TIM_LOCKLevel_3)) +/** + * @} + */ + +/** @defgroup TIM_OSSI_Off_State_Selection_for_Idle_mode_state + * @{ + */ + +#define TIM_OSSIState_Enable ((uint16_t)0x0400) +#define TIM_OSSIState_Disable ((uint16_t)0x0000) +#define IS_TIM_OSSI_STATE(STATE) (((STATE) == TIM_OSSIState_Enable) || \ + ((STATE) == TIM_OSSIState_Disable)) +/** + * @} + */ + +/** @defgroup TIM_OSSR_Off_State_Selection_for_Run_mode_state + * @{ + */ + +#define TIM_OSSRState_Enable ((uint16_t)0x0800) +#define TIM_OSSRState_Disable ((uint16_t)0x0000) +#define IS_TIM_OSSR_STATE(STATE) (((STATE) == TIM_OSSRState_Enable) || \ + ((STATE) == TIM_OSSRState_Disable)) +/** + * @} + */ + +/** @defgroup TIM_Output_Compare_Idle_State + * @{ + */ + +#define TIM_OCIdleState_Set ((uint16_t)0x0100) +#define TIM_OCIdleState_Reset ((uint16_t)0x0000) +#define IS_TIM_OCIDLE_STATE(STATE) (((STATE) == TIM_OCIdleState_Set) || \ + ((STATE) == TIM_OCIdleState_Reset)) +/** + * @} + */ + +/** @defgroup TIM_Output_Compare_N_Idle_State + * @{ + */ + +#define TIM_OCNIdleState_Set ((uint16_t)0x0200) +#define TIM_OCNIdleState_Reset ((uint16_t)0x0000) +#define IS_TIM_OCNIDLE_STATE(STATE) (((STATE) == TIM_OCNIdleState_Set) || \ + ((STATE) == TIM_OCNIdleState_Reset)) +/** + * @} + */ + +/** @defgroup TIM_Input_Capture_Polarity + * @{ + */ + +#define TIM_ICPolarity_Rising ((uint16_t)0x0000) +#define TIM_ICPolarity_Falling ((uint16_t)0x0002) +#define TIM_ICPolarity_BothEdge ((uint16_t)0x000A) +#define IS_TIM_IC_POLARITY(POLARITY) (((POLARITY) == TIM_ICPolarity_Rising) || \ + ((POLARITY) == TIM_ICPolarity_Falling)|| \ + ((POLARITY) == TIM_ICPolarity_BothEdge)) +/** + * @} + */ + +/** @defgroup TIM_Input_Capture_Selection + * @{ + */ + +#define TIM_ICSelection_DirectTI ((uint16_t)0x0001) /*!< TIM Input 1, 2, 3 or 4 is selected to be + connected to IC1, IC2, IC3 or IC4, respectively */ +#define TIM_ICSelection_IndirectTI ((uint16_t)0x0002) /*!< TIM Input 1, 2, 3 or 4 is selected to be + connected to IC2, IC1, IC4 or IC3, respectively. */ +#define TIM_ICSelection_TRC ((uint16_t)0x0003) /*!< TIM Input 1, 2, 3 or 4 is selected to be connected to TRC. */ +#define IS_TIM_IC_SELECTION(SELECTION) (((SELECTION) == TIM_ICSelection_DirectTI) || \ + ((SELECTION) == TIM_ICSelection_IndirectTI) || \ + ((SELECTION) == TIM_ICSelection_TRC)) +/** + * @} + */ + +/** @defgroup TIM_Input_Capture_Prescaler + * @{ + */ + +#define TIM_ICPSC_DIV1 ((uint16_t)0x0000) /*!< Capture performed each time an edge is detected on the capture input. */ +#define TIM_ICPSC_DIV2 ((uint16_t)0x0004) /*!< Capture performed once every 2 events. */ +#define TIM_ICPSC_DIV4 ((uint16_t)0x0008) /*!< Capture performed once every 4 events. */ +#define TIM_ICPSC_DIV8 ((uint16_t)0x000C) /*!< Capture performed once every 8 events. */ +#define IS_TIM_IC_PRESCALER(PRESCALER) (((PRESCALER) == TIM_ICPSC_DIV1) || \ + ((PRESCALER) == TIM_ICPSC_DIV2) || \ + ((PRESCALER) == TIM_ICPSC_DIV4) || \ + ((PRESCALER) == TIM_ICPSC_DIV8)) +/** + * @} + */ + +/** @defgroup TIM_interrupt_sources + * @{ + */ + +#define TIM_IT_Update ((uint16_t)0x0001) +#define TIM_IT_CC1 ((uint16_t)0x0002) +#define TIM_IT_CC2 ((uint16_t)0x0004) +#define TIM_IT_CC3 ((uint16_t)0x0008) +#define TIM_IT_CC4 ((uint16_t)0x0010) +#define TIM_IT_COM ((uint16_t)0x0020) +#define TIM_IT_Trigger ((uint16_t)0x0040) +#define TIM_IT_Break ((uint16_t)0x0080) +#define IS_TIM_IT(IT) ((((IT) & (uint16_t)0xFF00) == 0x0000) && ((IT) != 0x0000)) + +#define IS_TIM_GET_IT(IT) (((IT) == TIM_IT_Update) || \ + ((IT) == TIM_IT_CC1) || \ + ((IT) == TIM_IT_CC2) || \ + ((IT) == TIM_IT_CC3) || \ + ((IT) == TIM_IT_CC4) || \ + ((IT) == TIM_IT_COM) || \ + ((IT) == TIM_IT_Trigger) || \ + ((IT) == TIM_IT_Break)) +/** + * @} + */ + +/** @defgroup TIM_DMA_Base_address + * @{ + */ + +#define TIM_DMABase_CR1 ((uint16_t)0x0000) +#define TIM_DMABase_CR2 ((uint16_t)0x0001) +#define TIM_DMABase_SMCR ((uint16_t)0x0002) +#define TIM_DMABase_DIER ((uint16_t)0x0003) +#define TIM_DMABase_SR ((uint16_t)0x0004) +#define TIM_DMABase_EGR ((uint16_t)0x0005) +#define TIM_DMABase_CCMR1 ((uint16_t)0x0006) +#define TIM_DMABase_CCMR2 ((uint16_t)0x0007) +#define TIM_DMABase_CCER ((uint16_t)0x0008) +#define TIM_DMABase_CNT ((uint16_t)0x0009) +#define TIM_DMABase_PSC ((uint16_t)0x000A) +#define TIM_DMABase_ARR ((uint16_t)0x000B) +#define TIM_DMABase_RCR ((uint16_t)0x000C) +#define TIM_DMABase_CCR1 ((uint16_t)0x000D) +#define TIM_DMABase_CCR2 ((uint16_t)0x000E) +#define TIM_DMABase_CCR3 ((uint16_t)0x000F) +#define TIM_DMABase_CCR4 ((uint16_t)0x0010) +#define TIM_DMABase_BDTR ((uint16_t)0x0011) +#define TIM_DMABase_DCR ((uint16_t)0x0012) +#define TIM_DMABase_OR ((uint16_t)0x0013) +#define IS_TIM_DMA_BASE(BASE) (((BASE) == TIM_DMABase_CR1) || \ + ((BASE) == TIM_DMABase_CR2) || \ + ((BASE) == TIM_DMABase_SMCR) || \ + ((BASE) == TIM_DMABase_DIER) || \ + ((BASE) == TIM_DMABase_SR) || \ + ((BASE) == TIM_DMABase_EGR) || \ + ((BASE) == TIM_DMABase_CCMR1) || \ + ((BASE) == TIM_DMABase_CCMR2) || \ + ((BASE) == TIM_DMABase_CCER) || \ + ((BASE) == TIM_DMABase_CNT) || \ + ((BASE) == TIM_DMABase_PSC) || \ + ((BASE) == TIM_DMABase_ARR) || \ + ((BASE) == TIM_DMABase_RCR) || \ + ((BASE) == TIM_DMABase_CCR1) || \ + ((BASE) == TIM_DMABase_CCR2) || \ + ((BASE) == TIM_DMABase_CCR3) || \ + ((BASE) == TIM_DMABase_CCR4) || \ + ((BASE) == TIM_DMABase_BDTR) || \ + ((BASE) == TIM_DMABase_DCR) || \ + ((BASE) == TIM_DMABase_OR)) +/** + * @} + */ + + +/** @defgroup TIM_DMA_Burst_Length + * @{ + */ + +#define TIM_DMABurstLength_1Transfer ((uint16_t)0x0000) +#define TIM_DMABurstLength_2Transfers ((uint16_t)0x0100) +#define TIM_DMABurstLength_3Transfers ((uint16_t)0x0200) +#define TIM_DMABurstLength_4Transfers ((uint16_t)0x0300) +#define TIM_DMABurstLength_5Transfers ((uint16_t)0x0400) +#define TIM_DMABurstLength_6Transfers ((uint16_t)0x0500) +#define TIM_DMABurstLength_7Transfers ((uint16_t)0x0600) +#define TIM_DMABurstLength_8Transfers ((uint16_t)0x0700) +#define TIM_DMABurstLength_9Transfers ((uint16_t)0x0800) +#define TIM_DMABurstLength_10Transfers ((uint16_t)0x0900) +#define TIM_DMABurstLength_11Transfers ((uint16_t)0x0A00) +#define TIM_DMABurstLength_12Transfers ((uint16_t)0x0B00) +#define TIM_DMABurstLength_13Transfers ((uint16_t)0x0C00) +#define TIM_DMABurstLength_14Transfers ((uint16_t)0x0D00) +#define TIM_DMABurstLength_15Transfers ((uint16_t)0x0E00) +#define TIM_DMABurstLength_16Transfers ((uint16_t)0x0F00) +#define TIM_DMABurstLength_17Transfers ((uint16_t)0x1000) +#define TIM_DMABurstLength_18Transfers ((uint16_t)0x1100) +#define IS_TIM_DMA_LENGTH(LENGTH) (((LENGTH) == TIM_DMABurstLength_1Transfer) || \ + ((LENGTH) == TIM_DMABurstLength_2Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_3Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_4Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_5Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_6Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_7Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_8Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_9Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_10Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_11Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_12Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_13Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_14Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_15Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_16Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_17Transfers) || \ + ((LENGTH) == TIM_DMABurstLength_18Transfers)) +/** + * @} + */ + +/** @defgroup TIM_DMA_sources + * @{ + */ + +#define TIM_DMA_Update ((uint16_t)0x0100) +#define TIM_DMA_CC1 ((uint16_t)0x0200) +#define TIM_DMA_CC2 ((uint16_t)0x0400) +#define TIM_DMA_CC3 ((uint16_t)0x0800) +#define TIM_DMA_CC4 ((uint16_t)0x1000) +#define TIM_DMA_COM ((uint16_t)0x2000) +#define TIM_DMA_Trigger ((uint16_t)0x4000) +#define IS_TIM_DMA_SOURCE(SOURCE) ((((SOURCE) & (uint16_t)0x80FF) == 0x0000) && ((SOURCE) != 0x0000)) + +/** + * @} + */ + +/** @defgroup TIM_External_Trigger_Prescaler + * @{ + */ + +#define TIM_ExtTRGPSC_OFF ((uint16_t)0x0000) +#define TIM_ExtTRGPSC_DIV2 ((uint16_t)0x1000) +#define TIM_ExtTRGPSC_DIV4 ((uint16_t)0x2000) +#define TIM_ExtTRGPSC_DIV8 ((uint16_t)0x3000) +#define IS_TIM_EXT_PRESCALER(PRESCALER) (((PRESCALER) == TIM_ExtTRGPSC_OFF) || \ + ((PRESCALER) == TIM_ExtTRGPSC_DIV2) || \ + ((PRESCALER) == TIM_ExtTRGPSC_DIV4) || \ + ((PRESCALER) == TIM_ExtTRGPSC_DIV8)) +/** + * @} + */ + +/** @defgroup TIM_Internal_Trigger_Selection + * @{ + */ + +#define TIM_TS_ITR0 ((uint16_t)0x0000) +#define TIM_TS_ITR1 ((uint16_t)0x0010) +#define TIM_TS_ITR2 ((uint16_t)0x0020) +#define TIM_TS_ITR3 ((uint16_t)0x0030) +#define TIM_TS_TI1F_ED ((uint16_t)0x0040) +#define TIM_TS_TI1FP1 ((uint16_t)0x0050) +#define TIM_TS_TI2FP2 ((uint16_t)0x0060) +#define TIM_TS_ETRF ((uint16_t)0x0070) +#define IS_TIM_TRIGGER_SELECTION(SELECTION) (((SELECTION) == TIM_TS_ITR0) || \ + ((SELECTION) == TIM_TS_ITR1) || \ + ((SELECTION) == TIM_TS_ITR2) || \ + ((SELECTION) == TIM_TS_ITR3) || \ + ((SELECTION) == TIM_TS_TI1F_ED) || \ + ((SELECTION) == TIM_TS_TI1FP1) || \ + ((SELECTION) == TIM_TS_TI2FP2) || \ + ((SELECTION) == TIM_TS_ETRF)) +#define IS_TIM_INTERNAL_TRIGGER_SELECTION(SELECTION) (((SELECTION) == TIM_TS_ITR0) || \ + ((SELECTION) == TIM_TS_ITR1) || \ + ((SELECTION) == TIM_TS_ITR2) || \ + ((SELECTION) == TIM_TS_ITR3)) +/** + * @} + */ + +/** @defgroup TIM_TIx_External_Clock_Source + * @{ + */ + +#define TIM_TIxExternalCLK1Source_TI1 ((uint16_t)0x0050) +#define TIM_TIxExternalCLK1Source_TI2 ((uint16_t)0x0060) +#define TIM_TIxExternalCLK1Source_TI1ED ((uint16_t)0x0040) + +/** + * @} + */ + +/** @defgroup TIM_External_Trigger_Polarity + * @{ + */ +#define TIM_ExtTRGPolarity_Inverted ((uint16_t)0x8000) +#define TIM_ExtTRGPolarity_NonInverted ((uint16_t)0x0000) +#define IS_TIM_EXT_POLARITY(POLARITY) (((POLARITY) == TIM_ExtTRGPolarity_Inverted) || \ + ((POLARITY) == TIM_ExtTRGPolarity_NonInverted)) +/** + * @} + */ + +/** @defgroup TIM_Prescaler_Reload_Mode + * @{ + */ + +#define TIM_PSCReloadMode_Update ((uint16_t)0x0000) +#define TIM_PSCReloadMode_Immediate ((uint16_t)0x0001) +#define IS_TIM_PRESCALER_RELOAD(RELOAD) (((RELOAD) == TIM_PSCReloadMode_Update) || \ + ((RELOAD) == TIM_PSCReloadMode_Immediate)) +/** + * @} + */ + +/** @defgroup TIM_Forced_Action + * @{ + */ + +#define TIM_ForcedAction_Active ((uint16_t)0x0050) +#define TIM_ForcedAction_InActive ((uint16_t)0x0040) +#define IS_TIM_FORCED_ACTION(ACTION) (((ACTION) == TIM_ForcedAction_Active) || \ + ((ACTION) == TIM_ForcedAction_InActive)) +/** + * @} + */ + +/** @defgroup TIM_Encoder_Mode + * @{ + */ + +#define TIM_EncoderMode_TI1 ((uint16_t)0x0001) +#define TIM_EncoderMode_TI2 ((uint16_t)0x0002) +#define TIM_EncoderMode_TI12 ((uint16_t)0x0003) +#define IS_TIM_ENCODER_MODE(MODE) (((MODE) == TIM_EncoderMode_TI1) || \ + ((MODE) == TIM_EncoderMode_TI2) || \ + ((MODE) == TIM_EncoderMode_TI12)) +/** + * @} + */ + + +/** @defgroup TIM_Event_Source + * @{ + */ + +#define TIM_EventSource_Update ((uint16_t)0x0001) +#define TIM_EventSource_CC1 ((uint16_t)0x0002) +#define TIM_EventSource_CC2 ((uint16_t)0x0004) +#define TIM_EventSource_CC3 ((uint16_t)0x0008) +#define TIM_EventSource_CC4 ((uint16_t)0x0010) +#define TIM_EventSource_COM ((uint16_t)0x0020) +#define TIM_EventSource_Trigger ((uint16_t)0x0040) +#define TIM_EventSource_Break ((uint16_t)0x0080) +#define IS_TIM_EVENT_SOURCE(SOURCE) ((((SOURCE) & (uint16_t)0xFF00) == 0x0000) && ((SOURCE) != 0x0000)) + +/** + * @} + */ + +/** @defgroup TIM_Update_Source + * @{ + */ + +#define TIM_UpdateSource_Global ((uint16_t)0x0000) /*!< Source of update is the counter overflow/underflow + or the setting of UG bit, or an update generation + through the slave mode controller. */ +#define TIM_UpdateSource_Regular ((uint16_t)0x0001) /*!< Source of update is counter overflow/underflow. */ +#define IS_TIM_UPDATE_SOURCE(SOURCE) (((SOURCE) == TIM_UpdateSource_Global) || \ + ((SOURCE) == TIM_UpdateSource_Regular)) +/** + * @} + */ + +/** @defgroup TIM_Output_Compare_Preload_State + * @{ + */ + +#define TIM_OCPreload_Enable ((uint16_t)0x0008) +#define TIM_OCPreload_Disable ((uint16_t)0x0000) +#define IS_TIM_OCPRELOAD_STATE(STATE) (((STATE) == TIM_OCPreload_Enable) || \ + ((STATE) == TIM_OCPreload_Disable)) +/** + * @} + */ + +/** @defgroup TIM_Output_Compare_Fast_State + * @{ + */ + +#define TIM_OCFast_Enable ((uint16_t)0x0004) +#define TIM_OCFast_Disable ((uint16_t)0x0000) +#define IS_TIM_OCFAST_STATE(STATE) (((STATE) == TIM_OCFast_Enable) || \ + ((STATE) == TIM_OCFast_Disable)) + +/** + * @} + */ + +/** @defgroup TIM_Output_Compare_Clear_State + * @{ + */ + +#define TIM_OCClear_Enable ((uint16_t)0x0080) +#define TIM_OCClear_Disable ((uint16_t)0x0000) +#define IS_TIM_OCCLEAR_STATE(STATE) (((STATE) == TIM_OCClear_Enable) || \ + ((STATE) == TIM_OCClear_Disable)) +/** + * @} + */ + +/** @defgroup TIM_Trigger_Output_Source + * @{ + */ + +#define TIM_TRGOSource_Reset ((uint16_t)0x0000) +#define TIM_TRGOSource_Enable ((uint16_t)0x0010) +#define TIM_TRGOSource_Update ((uint16_t)0x0020) +#define TIM_TRGOSource_OC1 ((uint16_t)0x0030) +#define TIM_TRGOSource_OC1Ref ((uint16_t)0x0040) +#define TIM_TRGOSource_OC2Ref ((uint16_t)0x0050) +#define TIM_TRGOSource_OC3Ref ((uint16_t)0x0060) +#define TIM_TRGOSource_OC4Ref ((uint16_t)0x0070) +#define IS_TIM_TRGO_SOURCE(SOURCE) (((SOURCE) == TIM_TRGOSource_Reset) || \ + ((SOURCE) == TIM_TRGOSource_Enable) || \ + ((SOURCE) == TIM_TRGOSource_Update) || \ + ((SOURCE) == TIM_TRGOSource_OC1) || \ + ((SOURCE) == TIM_TRGOSource_OC1Ref) || \ + ((SOURCE) == TIM_TRGOSource_OC2Ref) || \ + ((SOURCE) == TIM_TRGOSource_OC3Ref) || \ + ((SOURCE) == TIM_TRGOSource_OC4Ref)) +/** + * @} + */ + +/** @defgroup TIM_Slave_Mode + * @{ + */ + +#define TIM_SlaveMode_Reset ((uint16_t)0x0004) +#define TIM_SlaveMode_Gated ((uint16_t)0x0005) +#define TIM_SlaveMode_Trigger ((uint16_t)0x0006) +#define TIM_SlaveMode_External1 ((uint16_t)0x0007) +#define IS_TIM_SLAVE_MODE(MODE) (((MODE) == TIM_SlaveMode_Reset) || \ + ((MODE) == TIM_SlaveMode_Gated) || \ + ((MODE) == TIM_SlaveMode_Trigger) || \ + ((MODE) == TIM_SlaveMode_External1)) +/** + * @} + */ + +/** @defgroup TIM_Master_Slave_Mode + * @{ + */ + +#define TIM_MasterSlaveMode_Enable ((uint16_t)0x0080) +#define TIM_MasterSlaveMode_Disable ((uint16_t)0x0000) +#define IS_TIM_MSM_STATE(STATE) (((STATE) == TIM_MasterSlaveMode_Enable) || \ + ((STATE) == TIM_MasterSlaveMode_Disable)) +/** + * @} + */ + +/** @defgroup TIM_Flags + * @{ + */ + +#define TIM_FLAG_Update ((uint16_t)0x0001) +#define TIM_FLAG_CC1 ((uint16_t)0x0002) +#define TIM_FLAG_CC2 ((uint16_t)0x0004) +#define TIM_FLAG_CC3 ((uint16_t)0x0008) +#define TIM_FLAG_CC4 ((uint16_t)0x0010) +#define TIM_FLAG_COM ((uint16_t)0x0020) +#define TIM_FLAG_Trigger ((uint16_t)0x0040) +#define TIM_FLAG_Break ((uint16_t)0x0080) +#define TIM_FLAG_CC1OF ((uint16_t)0x0200) +#define TIM_FLAG_CC2OF ((uint16_t)0x0400) +#define TIM_FLAG_CC3OF ((uint16_t)0x0800) +#define TIM_FLAG_CC4OF ((uint16_t)0x1000) +#define IS_TIM_GET_FLAG(FLAG) (((FLAG) == TIM_FLAG_Update) || \ + ((FLAG) == TIM_FLAG_CC1) || \ + ((FLAG) == TIM_FLAG_CC2) || \ + ((FLAG) == TIM_FLAG_CC3) || \ + ((FLAG) == TIM_FLAG_CC4) || \ + ((FLAG) == TIM_FLAG_COM) || \ + ((FLAG) == TIM_FLAG_Trigger) || \ + ((FLAG) == TIM_FLAG_Break) || \ + ((FLAG) == TIM_FLAG_CC1OF) || \ + ((FLAG) == TIM_FLAG_CC2OF) || \ + ((FLAG) == TIM_FLAG_CC3OF) || \ + ((FLAG) == TIM_FLAG_CC4OF)) + + +#define IS_TIM_CLEAR_FLAG(TIM_FLAG) ((((TIM_FLAG) & (uint16_t)0xE100) == 0x0000) && ((TIM_FLAG) != 0x0000)) +/** + * @} + */ + + +/** @defgroup TIM_Input_Capture_Filer_Value + * @{ + */ + +#define IS_TIM_IC_FILTER(ICFILTER) ((ICFILTER) <= 0xF) +/** + * @} + */ + +/** @defgroup TIM_External_Trigger_Filter + * @{ + */ + +#define IS_TIM_EXT_FILTER(EXTFILTER) ((EXTFILTER) <= 0xF) +/** + * @} + */ + +/** @defgroup TIM_OCReferenceClear + * @{ + */ +#define TIM_OCReferenceClear_ETRF ((uint16_t)0x0008) +#define TIM_OCReferenceClear_OCREFCLR ((uint16_t)0x0000) +#define TIM_OCREFERENCECECLEAR_SOURCE(SOURCE) (((SOURCE) == TIM_OCReferenceClear_ETRF) || \ + ((SOURCE) == TIM_OCReferenceClear_OCREFCLR)) + +/** + * @} + */ +/** @defgroup TIM_Remap + * @{ + */ +#define TIM14_GPIO ((uint16_t)0x0000) +#define TIM14_RTC_CLK ((uint16_t)0x0001) +#define TIM14_HSEDiv32 ((uint16_t)0x0002) +#define TIM14_MCO ((uint16_t)0x0003) + +#define IS_TIM_REMAP(TIM_REMAP) (((TIM_REMAP) == TIM14_GPIO)|| \ + ((TIM_REMAP) == TIM14_RTC_CLK) || \ + ((TIM_REMAP) == TIM14_HSEDiv32) || \ + ((TIM_REMAP) == TIM14_MCO)) +/** + * @} + */ + +/** @defgroup TIM_Legacy + * @{ + */ + +#define TIM_DMABurstLength_1Byte TIM_DMABurstLength_1Transfer +#define TIM_DMABurstLength_2Bytes TIM_DMABurstLength_2Transfers +#define TIM_DMABurstLength_3Bytes TIM_DMABurstLength_3Transfers +#define TIM_DMABurstLength_4Bytes TIM_DMABurstLength_4Transfers +#define TIM_DMABurstLength_5Bytes TIM_DMABurstLength_5Transfers +#define TIM_DMABurstLength_6Bytes TIM_DMABurstLength_6Transfers +#define TIM_DMABurstLength_7Bytes TIM_DMABurstLength_7Transfers +#define TIM_DMABurstLength_8Bytes TIM_DMABurstLength_8Transfers +#define TIM_DMABurstLength_9Bytes TIM_DMABurstLength_9Transfers +#define TIM_DMABurstLength_10Bytes TIM_DMABurstLength_10Transfers +#define TIM_DMABurstLength_11Bytes TIM_DMABurstLength_11Transfers +#define TIM_DMABurstLength_12Bytes TIM_DMABurstLength_12Transfers +#define TIM_DMABurstLength_13Bytes TIM_DMABurstLength_13Transfers +#define TIM_DMABurstLength_14Bytes TIM_DMABurstLength_14Transfers +#define TIM_DMABurstLength_15Bytes TIM_DMABurstLength_15Transfers +#define TIM_DMABurstLength_16Bytes TIM_DMABurstLength_16Transfers +#define TIM_DMABurstLength_17Bytes TIM_DMABurstLength_17Transfers +#define TIM_DMABurstLength_18Bytes TIM_DMABurstLength_18Transfers +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* TimeBase management ********************************************************/ +void TIM_DeInit(TIM_TypeDef* TIMx); +void TIM_TimeBaseInit(TIM_TypeDef* TIMx, TIM_TimeBaseInitTypeDef* TIM_TimeBaseInitStruct); +void TIM_TimeBaseStructInit(TIM_TimeBaseInitTypeDef* TIM_TimeBaseInitStruct); +void TIM_PrescalerConfig(TIM_TypeDef* TIMx, uint16_t Prescaler, uint16_t TIM_PSCReloadMode); +void TIM_CounterModeConfig(TIM_TypeDef* TIMx, uint16_t TIM_CounterMode); +void TIM_SetCounter(TIM_TypeDef* TIMx, uint32_t Counter); +void TIM_SetAutoreload(TIM_TypeDef* TIMx, uint32_t Autoreload); +uint32_t TIM_GetCounter(TIM_TypeDef* TIMx); +uint16_t TIM_GetPrescaler(TIM_TypeDef* TIMx); +void TIM_UpdateDisableConfig(TIM_TypeDef* TIMx, FunctionalState NewState); +void TIM_UpdateRequestConfig(TIM_TypeDef* TIMx, uint16_t TIM_UpdateSource); +void TIM_ARRPreloadConfig(TIM_TypeDef* TIMx, FunctionalState NewState); +void TIM_SelectOnePulseMode(TIM_TypeDef* TIMx, uint16_t TIM_OPMode); +void TIM_SetClockDivision(TIM_TypeDef* TIMx, uint16_t TIM_CKD); +void TIM_Cmd(TIM_TypeDef* TIMx, FunctionalState NewState); + +/* Advanced-control timers (TIM1) specific features*******************/ +void TIM_BDTRConfig(TIM_TypeDef* TIMx, TIM_BDTRInitTypeDef *TIM_BDTRInitStruct); +void TIM_BDTRStructInit(TIM_BDTRInitTypeDef* TIM_BDTRInitStruct); +void TIM_CtrlPWMOutputs(TIM_TypeDef* TIMx, FunctionalState NewState); + +/* Output Compare management **************************************************/ +void TIM_OC1Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct); +void TIM_OC2Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct); +void TIM_OC3Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct); +void TIM_OC4Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct); +void TIM_OCStructInit(TIM_OCInitTypeDef* TIM_OCInitStruct); +void TIM_SelectOCxM(TIM_TypeDef* TIMx, uint16_t TIM_Channel, uint16_t TIM_OCMode); +void TIM_SetCompare1(TIM_TypeDef* TIMx, uint32_t Compare1); +void TIM_SetCompare2(TIM_TypeDef* TIMx, uint32_t Compare2); +void TIM_SetCompare3(TIM_TypeDef* TIMx, uint32_t Compare3); +void TIM_SetCompare4(TIM_TypeDef* TIMx, uint32_t Compare4); +void TIM_ForcedOC1Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction); +void TIM_ForcedOC2Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction); +void TIM_ForcedOC3Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction); +void TIM_ForcedOC4Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction); +void TIM_CCPreloadControl(TIM_TypeDef* TIMx, FunctionalState NewState); +void TIM_OC1PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload); +void TIM_OC2PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload); +void TIM_OC3PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload); +void TIM_OC4PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload); +void TIM_OC1FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast); +void TIM_OC2FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast); +void TIM_OC3FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast); +void TIM_OC4FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast); +void TIM_ClearOC1Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear); +void TIM_ClearOC2Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear); +void TIM_ClearOC3Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear); +void TIM_ClearOC4Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear); +void TIM_OC1PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity); +void TIM_OC1NPolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCNPolarity); +void TIM_OC2PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity); +void TIM_OC2NPolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCNPolarity); +void TIM_OC3PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity); +void TIM_OC3NPolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCNPolarity); +void TIM_OC4PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity); +void TIM_SelectOCREFClear(TIM_TypeDef* TIMx, uint16_t TIM_OCReferenceClear); +void TIM_CCxCmd(TIM_TypeDef* TIMx, uint16_t TIM_Channel, uint16_t TIM_CCx); +void TIM_CCxNCmd(TIM_TypeDef* TIMx, uint16_t TIM_Channel, uint16_t TIM_CCxN); +void TIM_SelectCOM(TIM_TypeDef* TIMx, FunctionalState NewState); + +/* Input Capture management ***************************************************/ +void TIM_ICInit(TIM_TypeDef* TIMx, TIM_ICInitTypeDef* TIM_ICInitStruct); +void TIM_ICStructInit(TIM_ICInitTypeDef* TIM_ICInitStruct); +void TIM_PWMIConfig(TIM_TypeDef* TIMx, TIM_ICInitTypeDef* TIM_ICInitStruct); +uint32_t TIM_GetCapture1(TIM_TypeDef* TIMx); +uint32_t TIM_GetCapture2(TIM_TypeDef* TIMx); +uint32_t TIM_GetCapture3(TIM_TypeDef* TIMx); +uint32_t TIM_GetCapture4(TIM_TypeDef* TIMx); +void TIM_SetIC1Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC); +void TIM_SetIC2Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC); +void TIM_SetIC3Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC); +void TIM_SetIC4Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC); + +/* Interrupts, DMA and flags management ***************************************/ +void TIM_ITConfig(TIM_TypeDef* TIMx, uint16_t TIM_IT, FunctionalState NewState); +void TIM_GenerateEvent(TIM_TypeDef* TIMx, uint16_t TIM_EventSource); +FlagStatus TIM_GetFlagStatus(TIM_TypeDef* TIMx, uint16_t TIM_FLAG); +void TIM_ClearFlag(TIM_TypeDef* TIMx, uint16_t TIM_FLAG); +ITStatus TIM_GetITStatus(TIM_TypeDef* TIMx, uint16_t TIM_IT); +void TIM_ClearITPendingBit(TIM_TypeDef* TIMx, uint16_t TIM_IT); +void TIM_DMAConfig(TIM_TypeDef* TIMx, uint16_t TIM_DMABase, uint16_t TIM_DMABurstLength); +void TIM_DMACmd(TIM_TypeDef* TIMx, uint16_t TIM_DMASource, FunctionalState NewState); +void TIM_SelectCCDMA(TIM_TypeDef* TIMx, FunctionalState NewState); + +/* Clocks management **********************************************************/ +void TIM_InternalClockConfig(TIM_TypeDef* TIMx); +void TIM_ITRxExternalClockConfig(TIM_TypeDef* TIMx, uint16_t TIM_InputTriggerSource); +void TIM_TIxExternalClockConfig(TIM_TypeDef* TIMx, uint16_t TIM_TIxExternalCLKSource, + uint16_t TIM_ICPolarity, uint16_t ICFilter); +void TIM_ETRClockMode1Config(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, uint16_t TIM_ExtTRGPolarity, + uint16_t ExtTRGFilter); +void TIM_ETRClockMode2Config(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, + uint16_t TIM_ExtTRGPolarity, uint16_t ExtTRGFilter); + + +/* Synchronization management *************************************************/ +void TIM_SelectInputTrigger(TIM_TypeDef* TIMx, uint16_t TIM_InputTriggerSource); +void TIM_SelectOutputTrigger(TIM_TypeDef* TIMx, uint16_t TIM_TRGOSource); +void TIM_SelectSlaveMode(TIM_TypeDef* TIMx, uint16_t TIM_SlaveMode); +void TIM_SelectMasterSlaveMode(TIM_TypeDef* TIMx, uint16_t TIM_MasterSlaveMode); +void TIM_ETRConfig(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, uint16_t TIM_ExtTRGPolarity, + uint16_t ExtTRGFilter); + +/* Specific interface management **********************************************/ +void TIM_EncoderInterfaceConfig(TIM_TypeDef* TIMx, uint16_t TIM_EncoderMode, + uint16_t TIM_IC1Polarity, uint16_t TIM_IC2Polarity); +void TIM_SelectHallSensor(TIM_TypeDef* TIMx, FunctionalState NewState); + +/* Specific remapping management **********************************************/ +void TIM_RemapConfig(TIM_TypeDef* TIMx, uint16_t TIM_Remap); + + +#ifdef __cplusplus +} +#endif + +#endif /*__STM32F0XX_TIM_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_usart.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_usart.h new file mode 100644 index 00000000..85ff3c6f --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_usart.h @@ -0,0 +1,604 @@ +/** + ****************************************************************************** + * @file stm32f0xx_usart.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the USART + * firmware library. + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_USART_H +#define __STM32F0XX_USART_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup USART + * @{ + */ + +/* Exported types ------------------------------------------------------------*/ + + + +/** + * @brief USART Init Structure definition + */ + +typedef struct +{ + uint32_t USART_BaudRate; /*!< This member configures the USART communication baud rate. + The baud rate is computed using the following formula: + - IntegerDivider = ((PCLKx) / (16 * (USART_InitStruct->USART_BaudRate))) + - FractionalDivider = ((IntegerDivider - ((uint32_t) IntegerDivider)) * 16) + 0.5 */ + + uint32_t USART_WordLength; /*!< Specifies the number of data bits transmitted or received in a frame. + This parameter can be a value of @ref USART_Word_Length */ + + uint32_t USART_StopBits; /*!< Specifies the number of stop bits transmitted. + This parameter can be a value of @ref USART_Stop_Bits */ + + uint32_t USART_Parity; /*!< Specifies the parity mode. + This parameter can be a value of @ref USART_Parity + @note When parity is enabled, the computed parity is inserted + at the MSB position of the transmitted data (9th bit when + the word length is set to 9 data bits; 8th bit when the + word length is set to 8 data bits). */ + + uint32_t USART_Mode; /*!< Specifies wether the Receive or Transmit mode is enabled or disabled. + This parameter can be a value of @ref USART_Mode */ + + uint32_t USART_HardwareFlowControl; /*!< Specifies wether the hardware flow control mode is enabled + or disabled. + This parameter can be a value of @ref USART_Hardware_Flow_Control*/ +} USART_InitTypeDef; + +/** + * @brief USART Clock Init Structure definition + */ + +typedef struct +{ + uint32_t USART_Clock; /*!< Specifies whether the USART clock is enabled or disabled. + This parameter can be a value of @ref USART_Clock */ + + uint32_t USART_CPOL; /*!< Specifies the steady state of the serial clock. + This parameter can be a value of @ref USART_Clock_Polarity */ + + uint32_t USART_CPHA; /*!< Specifies the clock transition on which the bit capture is made. + This parameter can be a value of @ref USART_Clock_Phase */ + + uint32_t USART_LastBit; /*!< Specifies whether the clock pulse corresponding to the last transmitted + data bit (MSB) has to be output on the SCLK pin in synchronous mode. + This parameter can be a value of @ref USART_Last_Bit */ +} USART_ClockInitTypeDef; + +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup USART_Exported_Constants + * @{ + */ + +#define IS_USART_ALL_PERIPH(PERIPH) (((PERIPH) == USART1) || \ + ((PERIPH) == USART2) || \ + ((PERIPH) == USART3) || \ + ((PERIPH) == USART4) || \ + ((PERIPH) == USART5) || \ + ((PERIPH) == USART6) || \ + ((PERIPH) == USART7) || \ + ((PERIPH) == USART8)) + +#define IS_USART_123_PERIPH(PERIPH) (((PERIPH) == USART1) || \ + ((PERIPH) == USART2) || \ + ((PERIPH) == USART3)) + +/** @defgroup USART_Word_Length + * @{ + */ + +#define USART_WordLength_8b ((uint32_t)0x00000000) +#define USART_WordLength_9b USART_CR1_M /* should be ((uint32_t)0x00001000) */ +#define USART_WordLength_7b ((uint32_t)0x10001000) /*!< only available for STM32F072 and STM32F030 devices */ +#define IS_USART_WORD_LENGTH(LENGTH) (((LENGTH) == USART_WordLength_8b) || \ + ((LENGTH) == USART_WordLength_9b) || \ + ((LENGTH) == USART_WordLength_7b)) +/** + * @} + */ + +/** @defgroup USART_Stop_Bits + * @{ + */ + +#define USART_StopBits_1 ((uint32_t)0x00000000) +#define USART_StopBits_2 USART_CR2_STOP_1 +#define USART_StopBits_1_5 (USART_CR2_STOP_0 | USART_CR2_STOP_1) +#define IS_USART_STOPBITS(STOPBITS) (((STOPBITS) == USART_StopBits_1) || \ + ((STOPBITS) == USART_StopBits_2) || \ + ((STOPBITS) == USART_StopBits_1_5)) +/** + * @} + */ + +/** @defgroup USART_Parity + * @{ + */ + +#define USART_Parity_No ((uint32_t)0x00000000) +#define USART_Parity_Even USART_CR1_PCE +#define USART_Parity_Odd (USART_CR1_PCE | USART_CR1_PS) +#define IS_USART_PARITY(PARITY) (((PARITY) == USART_Parity_No) || \ + ((PARITY) == USART_Parity_Even) || \ + ((PARITY) == USART_Parity_Odd)) +/** + * @} + */ + +/** @defgroup USART_Mode + * @{ + */ + +#define USART_Mode_Rx USART_CR1_RE +#define USART_Mode_Tx USART_CR1_TE +#define IS_USART_MODE(MODE) ((((MODE) & (uint32_t)0xFFFFFFF3) == 0x00) && \ + ((MODE) != (uint32_t)0x00)) +/** + * @} + */ + +/** @defgroup USART_Hardware_Flow_Control + * @{ + */ + +#define USART_HardwareFlowControl_None ((uint32_t)0x00000000) +#define USART_HardwareFlowControl_RTS USART_CR3_RTSE +#define USART_HardwareFlowControl_CTS USART_CR3_CTSE +#define USART_HardwareFlowControl_RTS_CTS (USART_CR3_RTSE | USART_CR3_CTSE) +#define IS_USART_HARDWARE_FLOW_CONTROL(CONTROL)\ + (((CONTROL) == USART_HardwareFlowControl_None) || \ + ((CONTROL) == USART_HardwareFlowControl_RTS) || \ + ((CONTROL) == USART_HardwareFlowControl_CTS) || \ + ((CONTROL) == USART_HardwareFlowControl_RTS_CTS)) +/** + * @} + */ + +/** @defgroup USART_Clock + * @{ + */ + +#define USART_Clock_Disable ((uint32_t)0x00000000) +#define USART_Clock_Enable USART_CR2_CLKEN +#define IS_USART_CLOCK(CLOCK) (((CLOCK) == USART_Clock_Disable) || \ + ((CLOCK) == USART_Clock_Enable)) +/** + * @} + */ + +/** @defgroup USART_Clock_Polarity + * @{ + */ + +#define USART_CPOL_Low ((uint32_t)0x00000000) +#define USART_CPOL_High USART_CR2_CPOL +#define IS_USART_CPOL(CPOL) (((CPOL) == USART_CPOL_Low) || ((CPOL) == USART_CPOL_High)) + +/** + * @} + */ + +/** @defgroup USART_Clock_Phase + * @{ + */ + +#define USART_CPHA_1Edge ((uint32_t)0x00000000) +#define USART_CPHA_2Edge USART_CR2_CPHA +#define IS_USART_CPHA(CPHA) (((CPHA) == USART_CPHA_1Edge) || ((CPHA) == USART_CPHA_2Edge)) + +/** + * @} + */ + +/** @defgroup USART_Last_Bit + * @{ + */ + +#define USART_LastBit_Disable ((uint32_t)0x00000000) +#define USART_LastBit_Enable USART_CR2_LBCL +#define IS_USART_LASTBIT(LASTBIT) (((LASTBIT) == USART_LastBit_Disable) || \ + ((LASTBIT) == USART_LastBit_Enable)) +/** + * @} + */ + +/** @defgroup USART_DMA_Requests + * @{ + */ + +#define USART_DMAReq_Tx USART_CR3_DMAT +#define USART_DMAReq_Rx USART_CR3_DMAR +#define IS_USART_DMAREQ(DMAREQ) ((((DMAREQ) & (uint32_t)0xFFFFFF3F) == 0x00) && \ + ((DMAREQ) != (uint32_t)0x00)) + +/** + * @} + */ + +/** @defgroup USART_DMA_Recception_Error + * @{ + */ + +#define USART_DMAOnError_Enable ((uint32_t)0x00000000) +#define USART_DMAOnError_Disable USART_CR3_DDRE +#define IS_USART_DMAONERROR(DMAERROR) (((DMAERROR) == USART_DMAOnError_Disable)|| \ + ((DMAERROR) == USART_DMAOnError_Enable)) +/** + * @} + */ + +/** @defgroup USART_MuteMode_WakeUp_methods + * @{ + */ + +#define USART_WakeUp_IdleLine ((uint32_t)0x00000000) +#define USART_WakeUp_AddressMark USART_CR1_WAKE +#define IS_USART_MUTEMODE_WAKEUP(WAKEUP) (((WAKEUP) == USART_WakeUp_IdleLine) || \ + ((WAKEUP) == USART_WakeUp_AddressMark)) +/** + * @} + */ + +/** @defgroup USART_Address_Detection + * @{ + */ + +#define USART_AddressLength_4b ((uint32_t)0x00000000) +#define USART_AddressLength_7b USART_CR2_ADDM7 +#define IS_USART_ADDRESS_DETECTION(ADDRESS) (((ADDRESS) == USART_AddressLength_4b) || \ + ((ADDRESS) == USART_AddressLength_7b)) +/** + * @} + */ + +/** @defgroup USART_StopMode_WakeUp_methods + * @note These parameters are only available for STM32F051 and STM32F072 devices + * @{ + */ + +#define USART_WakeUpSource_AddressMatch ((uint32_t)0x00000000) +#define USART_WakeUpSource_StartBit USART_CR3_WUS_1 +#define USART_WakeUpSource_RXNE (USART_CR3_WUS_0 | USART_CR3_WUS_1) +#define IS_USART_STOPMODE_WAKEUPSOURCE(SOURCE) (((SOURCE) == USART_WakeUpSource_AddressMatch) || \ + ((SOURCE) == USART_WakeUpSource_StartBit) || \ + ((SOURCE) == USART_WakeUpSource_RXNE)) +/** + * @} + */ + +/** @defgroup USART_LIN_Break_Detection_Length + * @{ + */ + +#define USART_LINBreakDetectLength_10b ((uint32_t)0x00000000) +#define USART_LINBreakDetectLength_11b USART_CR2_LBDL +#define IS_USART_LIN_BREAK_DETECT_LENGTH(LENGTH) \ + (((LENGTH) == USART_LINBreakDetectLength_10b) || \ + ((LENGTH) == USART_LINBreakDetectLength_11b)) +/** + * @} + */ + +/** @defgroup USART_IrDA_Low_Power + * @{ + */ + +#define USART_IrDAMode_LowPower USART_CR3_IRLP +#define USART_IrDAMode_Normal ((uint32_t)0x00000000) +#define IS_USART_IRDA_MODE(MODE) (((MODE) == USART_IrDAMode_LowPower) || \ + ((MODE) == USART_IrDAMode_Normal)) +/** + * @} + */ + +/** @defgroup USART_DE_Polarity + * @{ + */ + +#define USART_DEPolarity_High ((uint32_t)0x00000000) +#define USART_DEPolarity_Low USART_CR3_DEP +#define IS_USART_DE_POLARITY(POLARITY) (((POLARITY) == USART_DEPolarity_Low) || \ + ((POLARITY) == USART_DEPolarity_High)) +/** + * @} + */ + +/** @defgroup USART_Inversion_Pins + * @{ + */ + +#define USART_InvPin_Tx USART_CR2_TXINV +#define USART_InvPin_Rx USART_CR2_RXINV +#define IS_USART_INVERSTION_PIN(PIN) ((((PIN) & (uint32_t)0xFFFCFFFF) == 0x00) && \ + ((PIN) != (uint32_t)0x00)) + +/** + * @} + */ + +/** @defgroup USART_AutoBaudRate_Mode + * @{ + */ + +#define USART_AutoBaudRate_StartBit ((uint32_t)0x00000000) +#define USART_AutoBaudRate_FallingEdge USART_CR2_ABRMODE_0 +#define IS_USART_AUTOBAUDRATE_MODE(MODE) (((MODE) == USART_AutoBaudRate_StartBit) || \ + ((MODE) == USART_AutoBaudRate_FallingEdge)) +/** + * @} + */ + +/** @defgroup USART_OVR_DETECTION + * @{ + */ + +#define USART_OVRDetection_Enable ((uint32_t)0x00000000) +#define USART_OVRDetection_Disable USART_CR3_OVRDIS +#define IS_USART_OVRDETECTION(OVR) (((OVR) == USART_OVRDetection_Enable)|| \ + ((OVR) == USART_OVRDetection_Disable)) +/** + * @} + */ +/** @defgroup USART_Request + * @{ + */ + +#define USART_Request_ABRRQ USART_RQR_ABRRQ +#define USART_Request_SBKRQ USART_RQR_SBKRQ +#define USART_Request_MMRQ USART_RQR_MMRQ +#define USART_Request_RXFRQ USART_RQR_RXFRQ +#define USART_Request_TXFRQ USART_RQR_TXFRQ + +#define IS_USART_REQUEST(REQUEST) (((REQUEST) == USART_Request_TXFRQ) || \ + ((REQUEST) == USART_Request_RXFRQ) || \ + ((REQUEST) == USART_Request_MMRQ) || \ + ((REQUEST) == USART_Request_SBKRQ) || \ + ((REQUEST) == USART_Request_ABRRQ)) +/** + * @} + */ + +/** @defgroup USART_Flags + * @{ + */ +#define USART_FLAG_REACK USART_ISR_REACK +#define USART_FLAG_TEACK USART_ISR_TEACK +#define USART_FLAG_WU USART_ISR_WUF /*!< Not available for STM32F030 devices */ +#define USART_FLAG_RWU USART_ISR_RWU /*!< Not available for STM32F030 devices */ +#define USART_FLAG_SBK USART_ISR_SBKF +#define USART_FLAG_CM USART_ISR_CMF +#define USART_FLAG_BUSY USART_ISR_BUSY +#define USART_FLAG_ABRF USART_ISR_ABRF +#define USART_FLAG_ABRE USART_ISR_ABRE +#define USART_FLAG_EOB USART_ISR_EOBF /*!< Not available for STM32F030 devices */ +#define USART_FLAG_RTO USART_ISR_RTOF +#define USART_FLAG_nCTSS USART_ISR_CTS +#define USART_FLAG_CTS USART_ISR_CTSIF +#define USART_FLAG_LBD USART_ISR_LBD /*!< Not available for STM32F030 devices */ +#define USART_FLAG_TXE USART_ISR_TXE +#define USART_FLAG_TC USART_ISR_TC +#define USART_FLAG_RXNE USART_ISR_RXNE +#define USART_FLAG_IDLE USART_ISR_IDLE +#define USART_FLAG_ORE USART_ISR_ORE +#define USART_FLAG_NE USART_ISR_NE +#define USART_FLAG_FE USART_ISR_FE +#define USART_FLAG_PE USART_ISR_PE +#define IS_USART_FLAG(FLAG) (((FLAG) == USART_FLAG_PE) || ((FLAG) == USART_FLAG_TXE) || \ + ((FLAG) == USART_FLAG_TC) || ((FLAG) == USART_FLAG_RXNE) || \ + ((FLAG) == USART_FLAG_IDLE) || ((FLAG) == USART_FLAG_LBD) || \ + ((FLAG) == USART_FLAG_CTS) || ((FLAG) == USART_FLAG_ORE) || \ + ((FLAG) == USART_FLAG_NE) || ((FLAG) == USART_FLAG_FE) || \ + ((FLAG) == USART_FLAG_nCTSS) || ((FLAG) == USART_FLAG_RTO) || \ + ((FLAG) == USART_FLAG_EOB) || ((FLAG) == USART_FLAG_ABRE) || \ + ((FLAG) == USART_FLAG_ABRF) || ((FLAG) == USART_FLAG_BUSY) || \ + ((FLAG) == USART_FLAG_CM) || ((FLAG) == USART_FLAG_SBK) || \ + ((FLAG) == USART_FLAG_RWU) || ((FLAG) == USART_FLAG_WU) || \ + ((FLAG) == USART_FLAG_TEACK)|| ((FLAG) == USART_FLAG_REACK)) + +#define IS_USART_CLEAR_FLAG(FLAG) (((FLAG) == USART_FLAG_WU) || ((FLAG) == USART_FLAG_TC) || \ + ((FLAG) == USART_FLAG_IDLE) || ((FLAG) == USART_FLAG_ORE) || \ + ((FLAG) == USART_FLAG_NE) || ((FLAG) == USART_FLAG_FE) || \ + ((FLAG) == USART_FLAG_LBD) || ((FLAG) == USART_FLAG_CTS) || \ + ((FLAG) == USART_FLAG_RTO) || ((FLAG) == USART_FLAG_EOB) || \ + ((FLAG) == USART_FLAG_CM) || ((FLAG) == USART_FLAG_PE)) +/** + * @} + */ + +/** @defgroup USART_Interrupt_definition + * @brief USART Interrupt definition + * USART_IT possible values + * Elements values convention: 0xZZZZYYXX + * XX: Position of the corresponding Interrupt + * YY: Register index + * ZZZZ: Flag position + * @{ + */ + +#define USART_IT_WU ((uint32_t)0x00140316) /*!< Not available for STM32F030 devices */ +#define USART_IT_CM ((uint32_t)0x0011010E) +#define USART_IT_EOB ((uint32_t)0x000C011B) /*!< Not available for STM32F030 devices */ +#define USART_IT_RTO ((uint32_t)0x000B011A) +#define USART_IT_PE ((uint32_t)0x00000108) +#define USART_IT_TXE ((uint32_t)0x00070107) +#define USART_IT_TC ((uint32_t)0x00060106) +#define USART_IT_RXNE ((uint32_t)0x00050105) +#define USART_IT_IDLE ((uint32_t)0x00040104) +#define USART_IT_LBD ((uint32_t)0x00080206) /*!< Not available for STM32F030 devices */ +#define USART_IT_CTS ((uint32_t)0x0009030A) +#define USART_IT_ERR ((uint32_t)0x00000300) +#define USART_IT_ORE ((uint32_t)0x00030300) +#define USART_IT_NE ((uint32_t)0x00020300) +#define USART_IT_FE ((uint32_t)0x00010300) + +#define IS_USART_CONFIG_IT(IT) (((IT) == USART_IT_PE) || ((IT) == USART_IT_TXE) || \ + ((IT) == USART_IT_TC) || ((IT) == USART_IT_RXNE) || \ + ((IT) == USART_IT_IDLE) || ((IT) == USART_IT_LBD) || \ + ((IT) == USART_IT_CTS) || ((IT) == USART_IT_ERR) || \ + ((IT) == USART_IT_RTO) || ((IT) == USART_IT_EOB) || \ + ((IT) == USART_IT_CM) || ((IT) == USART_IT_WU)) + +#define IS_USART_GET_IT(IT) (((IT) == USART_IT_PE) || ((IT) == USART_IT_TXE) || \ + ((IT) == USART_IT_TC) || ((IT) == USART_IT_RXNE) || \ + ((IT) == USART_IT_IDLE) || ((IT) == USART_IT_LBD) || \ + ((IT) == USART_IT_CTS) || ((IT) == USART_IT_ORE) || \ + ((IT) == USART_IT_NE) || ((IT) == USART_IT_FE) || \ + ((IT) == USART_IT_RTO) || ((IT) == USART_IT_EOB) || \ + ((IT) == USART_IT_CM) || ((IT) == USART_IT_WU)) + +#define IS_USART_CLEAR_IT(IT) (((IT) == USART_IT_TC) || ((IT) == USART_IT_PE) || \ + ((IT) == USART_IT_FE) || ((IT) == USART_IT_NE) || \ + ((IT) == USART_IT_ORE) || ((IT) == USART_IT_IDLE) || \ + ((IT) == USART_IT_LBD) || ((IT) == USART_IT_CTS) || \ + ((IT) == USART_IT_RTO) || ((IT) == USART_IT_EOB) || \ + ((IT) == USART_IT_CM) || ((IT) == USART_IT_WU)) +/** + * @} + */ + +/** @defgroup USART_Global_definition + * @{ + */ + +#define IS_USART_BAUDRATE(BAUDRATE) (((BAUDRATE) > 0) && ((BAUDRATE) < 0x005B8D81)) +#define IS_USART_DE_ASSERTION_DEASSERTION_TIME(TIME) ((TIME) <= 0x1F) +#define IS_USART_AUTO_RETRY_COUNTER(COUNTER) ((COUNTER) <= 0x7) +#define IS_USART_TIMEOUT(TIMEOUT) ((TIMEOUT) <= 0x00FFFFFF) +#define IS_USART_DATA(DATA) ((DATA) <= 0x1FF) + +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +/* Initialization and Configuration functions *********************************/ +void USART_DeInit(USART_TypeDef* USARTx); +void USART_Init(USART_TypeDef* USARTx, USART_InitTypeDef* USART_InitStruct); +void USART_StructInit(USART_InitTypeDef* USART_InitStruct); +void USART_ClockInit(USART_TypeDef* USARTx, USART_ClockInitTypeDef* USART_ClockInitStruct); +void USART_ClockStructInit(USART_ClockInitTypeDef* USART_ClockInitStruct); +void USART_Cmd(USART_TypeDef* USARTx, FunctionalState NewState); +void USART_DirectionModeCmd(USART_TypeDef* USARTx, uint32_t USART_DirectionMode, FunctionalState NewState); +void USART_SetPrescaler(USART_TypeDef* USARTx, uint8_t USART_Prescaler); /* Not available for STM32F030 devices */ +void USART_OverSampling8Cmd(USART_TypeDef* USARTx, FunctionalState NewState); +void USART_OneBitMethodCmd(USART_TypeDef* USARTx, FunctionalState NewState); +void USART_MSBFirstCmd(USART_TypeDef* USARTx, FunctionalState NewState); +void USART_DataInvCmd(USART_TypeDef* USARTx, FunctionalState NewState); +void USART_InvPinCmd(USART_TypeDef* USARTx, uint32_t USART_InvPin, FunctionalState NewState); +void USART_SWAPPinCmd(USART_TypeDef* USARTx, FunctionalState NewState); +void USART_ReceiverTimeOutCmd(USART_TypeDef* USARTx, FunctionalState NewState); +void USART_SetReceiverTimeOut(USART_TypeDef* USARTx, uint32_t USART_ReceiverTimeOut); + +/* STOP Mode functions ********************************************************/ +void USART_STOPModeCmd(USART_TypeDef* USARTx, FunctionalState NewState); +void USART_StopModeWakeUpSourceConfig(USART_TypeDef* USARTx, uint32_t USART_WakeUpSource); /* Not available for STM32F030 devices */ + +/* AutoBaudRate functions *****************************************************/ +void USART_AutoBaudRateCmd(USART_TypeDef* USARTx, FunctionalState NewState); +void USART_AutoBaudRateConfig(USART_TypeDef* USARTx, uint32_t USART_AutoBaudRate); + +/* Data transfers functions ***************************************************/ +void USART_SendData(USART_TypeDef* USARTx, uint16_t Data); +uint16_t USART_ReceiveData(USART_TypeDef* USARTx); + +/* Multi-Processor Communication functions ************************************/ +void USART_SetAddress(USART_TypeDef* USARTx, uint8_t USART_Address); +void USART_MuteModeWakeUpConfig(USART_TypeDef* USARTx, uint32_t USART_WakeUp); +void USART_MuteModeCmd(USART_TypeDef* USARTx, FunctionalState NewState); +void USART_AddressDetectionConfig(USART_TypeDef* USARTx, uint32_t USART_AddressLength); + +/* LIN mode functions *********************************************************/ +void USART_LINBreakDetectLengthConfig(USART_TypeDef* USARTx, uint32_t USART_LINBreakDetectLength); /* Not available for STM32F030 devices */ +void USART_LINCmd(USART_TypeDef* USARTx, FunctionalState NewState); /* Not available for STM32F030 devices */ + +/* Half-duplex mode function **************************************************/ +void USART_HalfDuplexCmd(USART_TypeDef* USARTx, FunctionalState NewState); + +/* Smartcard mode functions ***************************************************/ +void USART_SmartCardCmd(USART_TypeDef* USARTx, FunctionalState NewState); /* Not available for STM32F030 devices */ +void USART_SmartCardNACKCmd(USART_TypeDef* USARTx, FunctionalState NewState); /* Not available for STM32F030 devices */ +void USART_SetGuardTime(USART_TypeDef* USARTx, uint8_t USART_GuardTime); /* Not available for STM32F030 devices */ +void USART_SetAutoRetryCount(USART_TypeDef* USARTx, uint8_t USART_AutoCount); /* Not available for STM32F030 devices */ +void USART_SetBlockLength(USART_TypeDef* USARTx, uint8_t USART_BlockLength); /* Not available for STM32F030 devices */ + +/* IrDA mode functions ********************************************************/ +void USART_IrDAConfig(USART_TypeDef* USARTx, uint32_t USART_IrDAMode); /* Not available for STM32F030 devices */ +void USART_IrDACmd(USART_TypeDef* USARTx, FunctionalState NewState); /* Not available for STM32F030 devices */ + +/* RS485 mode functions *******************************************************/ +void USART_DECmd(USART_TypeDef* USARTx, FunctionalState NewState); +void USART_DEPolarityConfig(USART_TypeDef* USARTx, uint32_t USART_DEPolarity); +void USART_SetDEAssertionTime(USART_TypeDef* USARTx, uint32_t USART_DEAssertionTime); +void USART_SetDEDeassertionTime(USART_TypeDef* USARTx, uint32_t USART_DEDeassertionTime); + +/* DMA transfers management functions *****************************************/ +void USART_DMACmd(USART_TypeDef* USARTx, uint32_t USART_DMAReq, FunctionalState NewState); +void USART_DMAReceptionErrorConfig(USART_TypeDef* USARTx, uint32_t USART_DMAOnError); + +/* Interrupts and flags management functions **********************************/ +void USART_ITConfig(USART_TypeDef* USARTx, uint32_t USART_IT, FunctionalState NewState); +void USART_RequestCmd(USART_TypeDef* USARTx, uint32_t USART_Request, FunctionalState NewState); +void USART_OverrunDetectionConfig(USART_TypeDef* USARTx, uint32_t USART_OVRDetection); +FlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, uint32_t USART_FLAG); +void USART_ClearFlag(USART_TypeDef* USARTx, uint32_t USART_FLAG); +ITStatus USART_GetITStatus(USART_TypeDef* USARTx, uint32_t USART_IT); +void USART_ClearITPendingBit(USART_TypeDef* USARTx, uint32_t USART_IT); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_USART_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_wwdg.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_wwdg.h new file mode 100644 index 00000000..435fcb27 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/inc/stm32f0xx_wwdg.h @@ -0,0 +1,109 @@ +/** + ****************************************************************************** + * @file stm32f0xx_wwdg.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file contains all the functions prototypes for the WWDG + * firmware library. + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_WWDG_H +#define __STM32F0XX_WWDG_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @addtogroup WWDG + * @{ + */ +/* Exported types ------------------------------------------------------------*/ +/* Exported constants --------------------------------------------------------*/ + +/** @defgroup WWDG_Exported_Constants + * @{ + */ + +/** @defgroup WWDG_Prescaler + * @{ + */ + +#define WWDG_Prescaler_1 ((uint32_t)0x00000000) +#define WWDG_Prescaler_2 ((uint32_t)0x00000080) +#define WWDG_Prescaler_4 ((uint32_t)0x00000100) +#define WWDG_Prescaler_8 ((uint32_t)0x00000180) +#define IS_WWDG_PRESCALER(PRESCALER) (((PRESCALER) == WWDG_Prescaler_1) || \ + ((PRESCALER) == WWDG_Prescaler_2) || \ + ((PRESCALER) == WWDG_Prescaler_4) || \ + ((PRESCALER) == WWDG_Prescaler_8)) +#define IS_WWDG_WINDOW_VALUE(VALUE) ((VALUE) <= 0x7F) +#define IS_WWDG_COUNTER(COUNTER) (((COUNTER) >= 0x40) && ((COUNTER) <= 0x7F)) + +/** + * @} + */ + +/** + * @} + */ + +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ +/* Function used to set the WWDG configuration to the default reset state ****/ +void WWDG_DeInit(void); + +/* Prescaler, Refresh window and Counter configuration functions **************/ +void WWDG_SetPrescaler(uint32_t WWDG_Prescaler); +void WWDG_SetWindowValue(uint8_t WindowValue); +void WWDG_EnableIT(void); +void WWDG_SetCounter(uint8_t Counter); + +/* WWDG activation functions **************************************************/ +void WWDG_Enable(uint8_t Counter); + +/* Interrupts and flags management functions **********************************/ +FlagStatus WWDG_GetFlagStatus(void); +void WWDG_ClearFlag(void); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F0XX_WWDG_H */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_adc.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_adc.c new file mode 100644 index 00000000..e0f13358 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_adc.c @@ -0,0 +1,1240 @@ +/** + ****************************************************************************** + * @file stm32f0xx_adc.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Analog to Digital Convertor (ADC) peripheral: + * + Initialization and Configuration + * + Power saving + * + Analog Watchdog configuration + * + Temperature Sensor, Vrefint (Internal Reference Voltage) and + * Vbat (Voltage battery) management + * + ADC Channels Configuration + * + ADC Channels DMA Configuration + * + Interrupts and flags management + * + * @verbatim +================================================================================ + ##### How to use this driver ##### +================================================================================ + [..] + (#) Enable the ADC interface clock using + RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE); + (#) ADC pins configuration + (++) Enable the clock for the ADC GPIOs using the following function: + RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOx, ENABLE); + (++) Configure these ADC pins in analog mode using GPIO_Init(); + (#) Configure the ADC conversion resolution, data alignment, external + trigger and edge, scan direction and Enable/Disable the continuous mode + using the ADC_Init() function. + (#) Activate the ADC peripheral using ADC_Cmd() function. + + *** ADC channels group configuration *** + ============================================ + [..] + (+) To configure the ADC channels features, use ADC_Init() and + ADC_ChannelConfig() functions. + (+) To activate the continuous mode, use the ADC_ContinuousModeCmd() + function. + (+) To activate the Discontinuous mode, use the ADC_DiscModeCmd() functions. + (+) To activate the overrun mode, use the ADC_OverrunModeCmd() functions. + (+) To activate the calibration mode, use the ADC_GetCalibrationFactor() functions. + (+) To read the ADC converted values, use the ADC_GetConversionValue() + function. + + *** DMA for ADC channels features configuration *** + ============================================================= + [..] + (+) To enable the DMA mode for ADC channels group, use the ADC_DMACmd() function. + (+) To configure the DMA transfer request, use ADC_DMARequestModeConfig() function. + + * @endverbatim + * + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_adc.h" +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup ADC + * @brief ADC driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* ADC CFGR mask */ +#define CFGR1_CLEAR_MASK ((uint32_t)0xFFFFD203) + +/* Calibration time out */ +#define CALIBRATION_TIMEOUT ((uint32_t)0x0000F000) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup ADC_Private_Functions + * @{ + */ + +/** @defgroup ADC_Group1 Initialization and Configuration functions + * @brief Initialization and Configuration functions + * +@verbatim + =============================================================================== + ##### Initialization and Configuration functions ##### + =============================================================================== + [..] This section provides functions allowing to: + (+) Initialize and configure the ADC Prescaler + (+) ADC Conversion Resolution (12bit..6bit) + (+) ADC Continuous Conversion Mode (Continuous or Single conversion) + (+) External trigger Edge and source + (+) Converted data alignment (left or right) + (+) The direction in which the channels will be scanned in the sequence + (+) Enable or disable the ADC peripheral + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes ADC1 peripheral registers to their default reset values. + * @param ADCx: where x can be 1 to select the ADC peripheral. + * @retval None + */ +void ADC_DeInit(ADC_TypeDef* ADCx) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + + if(ADCx == ADC1) + { + /* Enable ADC1 reset state */ + RCC_APB2PeriphResetCmd(RCC_APB2Periph_ADC1, ENABLE); + + /* Release ADC1 from reset state */ + RCC_APB2PeriphResetCmd(RCC_APB2Periph_ADC1, DISABLE); + } +} + +/** + * @brief Initializes the ADCx peripheral according to the specified parameters + * in the ADC_InitStruct. + * @note This function is used to configure the global features of the ADC ( + * Resolution, Data Alignment, continuous mode activation, External + * trigger source and edge, Sequence Scan Direction). + * @param ADCx: where x can be 1 to select the ADC peripheral. + * @param ADC_InitStruct: pointer to an ADC_InitTypeDef structure that contains + * the configuration information for the specified ADC peripheral. + * @retval None + */ +void ADC_Init(ADC_TypeDef* ADCx, ADC_InitTypeDef* ADC_InitStruct) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_ADC_RESOLUTION(ADC_InitStruct->ADC_Resolution)); + assert_param(IS_FUNCTIONAL_STATE(ADC_InitStruct->ADC_ContinuousConvMode)); + assert_param(IS_ADC_EXT_TRIG_EDGE(ADC_InitStruct->ADC_ExternalTrigConvEdge)); + assert_param(IS_ADC_EXTERNAL_TRIG_CONV(ADC_InitStruct->ADC_ExternalTrigConv)); + assert_param(IS_ADC_DATA_ALIGN(ADC_InitStruct->ADC_DataAlign)); + assert_param(IS_ADC_SCAN_DIRECTION(ADC_InitStruct->ADC_ScanDirection)); + + /* Get the ADCx CFGR value */ + tmpreg = ADCx->CFGR1; + + /* Clear SCANDIR, RES[1:0], ALIGN, EXTSEL[2:0], EXTEN[1:0] and CONT bits */ + tmpreg &= CFGR1_CLEAR_MASK; + + /*---------------------------- ADCx CFGR Configuration ---------------------*/ + + /* Set RES[1:0] bits according to ADC_Resolution value */ + /* Set CONT bit according to ADC_ContinuousConvMode value */ + /* Set EXTEN[1:0] bits according to ADC_ExternalTrigConvEdge value */ + /* Set EXTSEL[2:0] bits according to ADC_ExternalTrigConv value */ + /* Set ALIGN bit according to ADC_DataAlign value */ + /* Set SCANDIR bit according to ADC_ScanDirection value */ + + tmpreg |= (uint32_t)(ADC_InitStruct->ADC_Resolution | ((uint32_t)(ADC_InitStruct->ADC_ContinuousConvMode) << 13) | + ADC_InitStruct->ADC_ExternalTrigConvEdge | ADC_InitStruct->ADC_ExternalTrigConv | + ADC_InitStruct->ADC_DataAlign | ADC_InitStruct->ADC_ScanDirection); + + /* Write to ADCx CFGR */ + ADCx->CFGR1 = tmpreg; +} + +/** + * @brief Fills each ADC_InitStruct member with its default value. + * @note This function is used to initialize the global features of the ADC ( + * Resolution, Data Alignment, continuous mode activation, External + * trigger source and edge, Sequence Scan Direction). + * @param ADC_InitStruct: pointer to an ADC_InitTypeDef structure which will + * be initialized. + * @retval None + */ +void ADC_StructInit(ADC_InitTypeDef* ADC_InitStruct) +{ + /* Reset ADC init structure parameters values */ + /* Initialize the ADC_Resolution member */ + ADC_InitStruct->ADC_Resolution = ADC_Resolution_12b; + + /* Initialize the ADC_ContinuousConvMode member */ + ADC_InitStruct->ADC_ContinuousConvMode = DISABLE; + + /* Initialize the ADC_ExternalTrigConvEdge member */ + ADC_InitStruct->ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_None; + + /* Initialize the ADC_ExternalTrigConv member */ + ADC_InitStruct->ADC_ExternalTrigConv = ADC_ExternalTrigConv_T1_TRGO; + + /* Initialize the ADC_DataAlign member */ + ADC_InitStruct->ADC_DataAlign = ADC_DataAlign_Right; + + /* Initialize the ADC_ScanDirection member */ + ADC_InitStruct->ADC_ScanDirection = ADC_ScanDirection_Upward; +} + +/** + * @brief Enables or disables the specified ADC peripheral. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param NewState: new state of the ADCx peripheral. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_Cmd(ADC_TypeDef* ADCx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Set the ADEN bit to Enable the ADC peripheral */ + ADCx->CR |= (uint32_t)ADC_CR_ADEN; + } + else + { + /* Set the ADDIS to Disable the ADC peripheral */ + ADCx->CR |= (uint32_t)ADC_CR_ADDIS; + } +} + +/** + * @brief Configure the ADC to either be clocked by the asynchronous clock(which is + * independent, the dedicated 14MHz clock) or the synchronous clock derived from + * the APB clock of the ADC bus interface divided by 2 or 4 + * @note This function can be called only when ADC is disabled. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param ADC_ClockMode: This parameter can be : + * @arg ADC_ClockMode_AsynClk: ADC clocked by the dedicated 14MHz clock + * @arg ADC_ClockMode_SynClkDiv2: ADC clocked by PCLK/2 + * @arg ADC_ClockMode_SynClkDiv4: ADC clocked by PCLK/4 + * @retval None + */ +void ADC_ClockModeConfig(ADC_TypeDef* ADCx, uint32_t ADC_ClockMode) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_ADC_CLOCKMODE(ADC_ClockMode)); + + /* Configure the ADC Clock mode according to ADC_ClockMode */ + ADCx->CFGR2 = (uint32_t)ADC_ClockMode; + +} + +/** + * @brief Enables or disables the jitter when the ADC is clocked by PCLK div2 + * or div4 + * @note This function is obsolete and maintained for legacy purpose only. ADC_ClockModeConfig() + * function should be used instead. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param ADC_JitterOff: This parameter can be : + * @arg ADC_JitterOff_PCLKDiv2: Remove jitter when ADC is clocked by PLCK divided by 2 + * @arg ADC_JitterOff_PCLKDiv4: Remove jitter when ADC is clocked by PLCK divided by 4 + * @param NewState: new state of the ADCx jitter. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_JitterCmd(ADC_TypeDef* ADCx, uint32_t ADC_JitterOff, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_ADC_JITTEROFF(ADC_JitterOff)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Disable Jitter */ + ADCx->CFGR2 |= (uint32_t)ADC_JitterOff; + } + else + { + /* Enable Jitter */ + ADCx->CFGR2 &= (uint32_t)(~ADC_JitterOff); + } +} + +/** + * @} + */ + +/** @defgroup ADC_Group2 Power saving functions + * @brief Power saving functions + * +@verbatim + =============================================================================== + ##### Power saving functions ##### + =============================================================================== + [..] This section provides functions allowing to reduce power consumption. + [..] The two function must be combined to get the maximal benefits: + When the ADC frequency is higher than the CPU one, it is recommended to + (#) Enable the Auto Delayed Conversion mode : + ==> using ADC_WaitModeCmd(ADC_TypeDef* ADCx, FunctionalState NewState); + (#) Enable the power off in Delay phases : + ==> using ADC_AutoPowerOffCmd(ADC_TypeDef* ADCx, FunctionalState NewState); + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the ADC Power Off. + * @note ADC power-on and power-off can be managed by hardware to cut the + * consumption when the ADC is not converting. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @note The ADC can be powered down: + * - During the Auto delay phase: The ADC is powered on again at the end + * of the delay (until the previous data is read from the ADC data register). + * - During the ADC is waiting for a trigger event: The ADC is powered up + * at the next trigger event (when the conversion is started). + * @param NewState: new state of the ADCx power Off. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_AutoPowerOffCmd(ADC_TypeDef* ADCx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the ADC Automatic Power-Off */ + ADCx->CFGR1 |= ADC_CFGR1_AUTOFF; + } + else + { + /* Disable the ADC Automatic Power-Off */ + ADCx->CFGR1 &= (uint32_t)~ADC_CFGR1_AUTOFF; + } +} + +/** + * @brief Enables or disables the Wait conversion mode. + * @note When the CPU clock is not fast enough to manage the data rate, a + * Hardware delay can be introduced between ADC conversions to reduce + * this data rate. + * @note The Hardware delay is inserted after each conversions and until the + * previous data is read from the ADC data register + * @note This is a way to automatically adapt the speed of the ADC to the speed + * of the system which will read the data. + * @note Any hardware triggers wich occur while a conversion is on going or + * while the automatic Delay is applied are ignored + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param NewState: new state of the ADCx Auto-Delay. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_WaitModeCmd(ADC_TypeDef* ADCx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the ADC Automatic Delayed conversion */ + ADCx->CFGR1 |= ADC_CFGR1_WAIT; + } + else + { + /* Disable the ADC Automatic Delayed conversion */ + ADCx->CFGR1 &= (uint32_t)~ADC_CFGR1_WAIT; + } +} + +/** + * @} + */ + +/** @defgroup ADC_Group3 Analog Watchdog configuration functions + * @brief Analog Watchdog configuration functions + * +@verbatim + =============================================================================== + ##### Analog Watchdog configuration functions ##### + =============================================================================== + [..] This section provides functions allowing to configure the Analog Watchdog + (AWD) feature in the ADC. + [..] A typical configuration Analog Watchdog is done following these steps : + (#) the ADC guarded channel(s) is (are) selected using the + ADC_AnalogWatchdogSingleChannelConfig() function. + (#) The Analog watchdog lower and higher threshold are configured using the + ADC_AnalogWatchdogThresholdsConfig() function. + (#) The Analog watchdog is enabled and configured to enable the check, on one + or more channels, using the ADC_AnalogWatchdogCmd() function. + (#) Enable the analog watchdog on the selected channel using + ADC_AnalogWatchdogSingleChannelCmd() function + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the analog watchdog + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param NewState: new state of the ADCx Analog Watchdog. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_AnalogWatchdogCmd(ADC_TypeDef* ADCx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the ADC Analog Watchdog */ + ADCx->CFGR1 |= ADC_CFGR1_AWDEN; + } + else + { + /* Disable the ADC Analog Watchdog */ + ADCx->CFGR1 &= (uint32_t)~ADC_CFGR1_AWDEN; + } +} + +/** + * @brief Configures the high and low thresholds of the analog watchdog. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param HighThreshold: the ADC analog watchdog High threshold value. + * This parameter must be a 12bit value. + * @param LowThreshold: the ADC analog watchdog Low threshold value. + * This parameter must be a 12bit value. + * @retval None + */ +void ADC_AnalogWatchdogThresholdsConfig(ADC_TypeDef* ADCx, uint16_t HighThreshold, + uint16_t LowThreshold) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_ADC_THRESHOLD(HighThreshold)); + assert_param(IS_ADC_THRESHOLD(LowThreshold)); + + /* Set the ADCx high and low threshold */ + ADCx->TR = LowThreshold | ((uint32_t)HighThreshold << 16); + +} + +/** + * @brief Configures the analog watchdog guarded single channel + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param ADC_AnalogWatchdog_Channel: the ADC channel to configure for the analog watchdog. + * This parameter can be one of the following values: + * @arg ADC_AnalogWatchdog_Channel_0: ADC Channel0 selected + * @arg ADC_AnalogWatchdog_Channel_1: ADC Channel1 selected + * @arg ADC_AnalogWatchdog_Channel_2: ADC Channel2 selected + * @arg ADC_AnalogWatchdog_Channel_3: ADC Channel3 selected + * @arg ADC_AnalogWatchdog_Channel_4: ADC Channel4 selected + * @arg ADC_AnalogWatchdog_Channel_5: ADC Channel5 selected + * @arg ADC_AnalogWatchdog_Channel_6: ADC Channel6 selected + * @arg ADC_AnalogWatchdog_Channel_7: ADC Channel7 selected + * @arg ADC_AnalogWatchdog_Channel_8: ADC Channel8 selected + * @arg ADC_AnalogWatchdog_Channel_9: ADC Channel9 selected + * @arg ADC_AnalogWatchdog_Channel_10: ADC Channel10 selected, not available for STM32F031 devices + * @arg ADC_AnalogWatchdog_Channel_11: ADC Channel11 selected, not available for STM32F031 devices + * @arg ADC_AnalogWatchdog_Channel_12: ADC Channel12 selected, not available for STM32F031 devices + * @arg ADC_AnalogWatchdog_Channel_13: ADC Channel13 selected, not available for STM32F031 devices + * @arg ADC_AnalogWatchdog_Channel_14: ADC Channel14 selected, not available for STM32F031 devices + * @arg ADC_AnalogWatchdog_Channel_15: ADC Channel15 selected, not available for STM32F031 devices + * @arg ADC_AnalogWatchdog_Channel_16: ADC Channel16 selected + * @arg ADC_AnalogWatchdog_Channel_17: ADC Channel17 selected + * @arg ADC_AnalogWatchdog_Channel_18: ADC Channel18 selected, not available for STM32F030 devices + * @note The channel selected on the AWDCH must be also set into the CHSELR + * register + * @retval None + */ +void ADC_AnalogWatchdogSingleChannelConfig(ADC_TypeDef* ADCx, uint32_t ADC_AnalogWatchdog_Channel) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_ADC_ANALOG_WATCHDOG_CHANNEL(ADC_AnalogWatchdog_Channel)); + + /* Get the old register value */ + tmpreg = ADCx->CFGR1; + + /* Clear the Analog watchdog channel select bits */ + tmpreg &= ~ADC_CFGR1_AWDCH; + + /* Set the Analog watchdog channel */ + tmpreg |= ADC_AnalogWatchdog_Channel; + + /* Store the new register value */ + ADCx->CFGR1 = tmpreg; +} + +/** + * @brief Enables or disables the ADC Analog Watchdog Single Channel. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param NewState: new state of the ADCx ADC Analog Watchdog Single Channel. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_AnalogWatchdogSingleChannelCmd(ADC_TypeDef* ADCx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the ADC Analog Watchdog Single Channel */ + ADCx->CFGR1 |= ADC_CFGR1_AWDSGL; + } + else + { + /* Disable the ADC Analog Watchdog Single Channel */ + ADCx->CFGR1 &= (uint32_t)~ADC_CFGR1_AWDSGL; + } +} + +/** + * @} + */ + +/** @defgroup ADC_Group4 Temperature Sensor, Vrefint and Vbat management functions + * @brief Temperature Sensor, Vrefint and Vbat management functions + * +@verbatim + =============================================================================== + ##### Temperature Sensor, Vrefint and Vbat management function ##### + =============================================================================== + [..] This section provides a function allowing to enable/disable the internal + connections between the ADC and the Temperature Sensor, the Vrefint and + Vbat source. + + [..] A typical configuration to get the Temperature sensor, Vrefint and Vbat channels + voltages is done following these steps : + (#) Enable the internal connection of Temperature sensor, Vrefint or Vbat sources + with the ADC channels using ADC_TempSensorCmd(), ADC_VrefintCmd() or ADC_VbatCmd() + functions. + (#) select the ADC_Channel_16(Temperature sensor), ADC_Channel_17(Vrefint) + or ADC_Channel_18(Voltage battery) using ADC_ChannelConfig() function + (#) Get the voltage values, using ADC_GetConversionValue() function + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the temperature sensor channel. + * @param NewState: new state of the temperature sensor input channel. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_TempSensorCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the temperature sensor channel*/ + ADC->CCR |= (uint32_t)ADC_CCR_TSEN; + } + else + { + /* Disable the temperature sensor channel*/ + ADC->CCR &= (uint32_t)(~ADC_CCR_TSEN); + } +} + +/** + * @brief Enables or disables the Vrefint channel. + * @param NewState: new state of the Vref input channel. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_VrefintCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the Vrefint channel*/ + ADC->CCR |= (uint32_t)ADC_CCR_VREFEN; + } + else + { + /* Disable the Vrefint channel*/ + ADC->CCR &= (uint32_t)(~ADC_CCR_VREFEN); + } +} + +/** + * @brief Enables or disables the Vbat channel. + * @note This feature is not applicable for STM32F030 devices. + * @param NewState: new state of the Vbat input channel. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_VbatCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the Vbat channel*/ + ADC->CCR |= (uint32_t)ADC_CCR_VBATEN; + } + else + { + /* Disable the Vbat channel*/ + ADC->CCR &= (uint32_t)(~ADC_CCR_VBATEN); + } +} + +/** + * @} + */ + +/** @defgroup ADC_Group5 Channels Configuration functions + * @brief Channels Configuration functions + * +@verbatim + =============================================================================== + ##### Channels Configuration functions ##### + =============================================================================== + [..] This section provides functions allowing to manage the ADC channels, + it is composed of 3 sub sections : + (#) Configuration and management functions for ADC channels: This subsection + provides functions allowing to configure the ADC channels : + (++) Select the ADC channels + (++) Activate ADC Calibration + (++) Activate the Overrun Mode. + (++) Activate the Discontinuous Mode + (++) Activate the Continuous Mode. + (++) Configure the sampling time for each channel + (++) Select the conversion Trigger and Edge for ADC channels + (++) Select the scan direction. + -@@- Please Note that the following features for ADC channels are configurated + using the ADC_Init() function : + (+@@) Activate the Continuous Mode (can be also activated by ADC_OverrunModeCmd(). + (+@@) Select the conversion Trigger and Edge for ADC channels + (+@@) Select the scan direction. + (#) Control the ADC peripheral : This subsection permits to command the ADC: + (++) Stop or discard an on-going conversion (ADSTP command) + (++) Start the ADC conversion . + (#) Get the conversion data: This subsection provides an important function in + the ADC peripheral since it returns the converted data of the current + ADC channel. When the Conversion value is read, the EOC Flag is + automatically cleared. + +@endverbatim + * @{ + */ + +/** + * @brief Configures for the selected ADC and its sampling time. + * @param ADCx: where x can be 1 to select the ADC peripheral. + * @param ADC_Channel: the ADC channel to configure. + * This parameter can be any combination of the following values: + * @arg ADC_Channel_0: ADC Channel0 selected + * @arg ADC_Channel_1: ADC Channel1 selected + * @arg ADC_Channel_2: ADC Channel2 selected + * @arg ADC_Channel_3: ADC Channel3 selected + * @arg ADC_Channel_4: ADC Channel4 selected + * @arg ADC_Channel_5: ADC Channel5 selected + * @arg ADC_Channel_6: ADC Channel6 selected + * @arg ADC_Channel_7: ADC Channel7 selected + * @arg ADC_Channel_8: ADC Channel8 selected + * @arg ADC_Channel_9: ADC Channel9 selected + * @arg ADC_Channel_10: ADC Channel10 selected, not available for STM32F031 devices + * @arg ADC_Channel_11: ADC Channel11 selected, not available for STM32F031 devices + * @arg ADC_Channel_12: ADC Channel12 selected, not available for STM32F031 devices + * @arg ADC_Channel_13: ADC Channel13 selected, not available for STM32F031 devices + * @arg ADC_Channel_14: ADC Channel14 selected, not available for STM32F031 devices + * @arg ADC_Channel_15: ADC Channel15 selected, not available for STM32F031 devices + * @arg ADC_Channel_16: ADC Channel16 selected + * @arg ADC_Channel_17: ADC Channel17 selected + * @arg ADC_Channel_18: ADC Channel18 selected, not available for STM32F030 devices + * @param ADC_SampleTime: The sample time value to be set for the selected channel. + * This parameter can be one of the following values: + * @arg ADC_SampleTime_1_5Cycles: Sample time equal to 1.5 cycles + * @arg ADC_SampleTime_7_5Cycles: Sample time equal to 7.5 cycles + * @arg ADC_SampleTime_13_5Cycles: Sample time equal to 13.5 cycles + * @arg ADC_SampleTime_28_5Cycles: Sample time equal to 28.5 cycles + * @arg ADC_SampleTime_41_5Cycles: Sample time equal to 41.5 cycles + * @arg ADC_SampleTime_55_5Cycles: Sample time equal to 55.5 cycles + * @arg ADC_SampleTime_71_5Cycles: Sample time equal to 71.5 cycles + * @arg ADC_SampleTime_239_5Cycles: Sample time equal to 239.5 cycles + * @retval None + */ +void ADC_ChannelConfig(ADC_TypeDef* ADCx, uint32_t ADC_Channel, uint32_t ADC_SampleTime) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_ADC_CHANNEL(ADC_Channel)); + assert_param(IS_ADC_SAMPLE_TIME(ADC_SampleTime)); + + /* Configure the ADC Channel */ + ADCx->CHSELR |= (uint32_t)ADC_Channel; + + /* Clear the Sampling time Selection bits */ + tmpreg &= ~ADC_SMPR1_SMPR; + + /* Set the ADC Sampling Time register */ + tmpreg |= (uint32_t)ADC_SampleTime; + + /* Configure the ADC Sample time register */ + ADCx->SMPR = tmpreg ; +} + +/** + * @brief Enable the Continuous mode for the selected ADCx channels. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param NewState: new state of the Continuous mode. + * This parameter can be: ENABLE or DISABLE. + * @note It is not possible to have both discontinuous mode and continuous mode + * enabled. In this case (If DISCEN and CONT are Set), the ADC behaves + * as if continuous mode was disabled + * @retval None + */ +void ADC_ContinuousModeCmd(ADC_TypeDef* ADCx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the Continuous mode*/ + ADCx->CFGR1 |= (uint32_t)ADC_CFGR1_CONT; + } + else + { + /* Disable the Continuous mode */ + ADCx->CFGR1 &= (uint32_t)(~ADC_CFGR1_CONT); + } +} + +/** + * @brief Enable the discontinuous mode for the selected ADC channels. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param NewState: new state of the discontinuous mode. + * This parameter can be: ENABLE or DISABLE. + * @note It is not possible to have both discontinuous mode and continuous mode + * enabled. In this case (If DISCEN and CONT are Set), the ADC behaves + * as if continuous mode was disabled + * @retval None + */ +void ADC_DiscModeCmd(ADC_TypeDef* ADCx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the Discontinuous mode */ + ADCx->CFGR1 |= (uint32_t)ADC_CFGR1_DISCEN; + } + else + { + /* Disable the Discontinuous mode */ + ADCx->CFGR1 &= (uint32_t)(~ADC_CFGR1_DISCEN); + } +} + +/** + * @brief Enable the Overrun mode for the selected ADC channels. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param NewState: new state of the Overrun mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_OverrunModeCmd(ADC_TypeDef* ADCx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the Overrun mode */ + ADCx->CFGR1 |= (uint32_t)ADC_CFGR1_OVRMOD; + } + else + { + /* Disable the Overrun mode */ + ADCx->CFGR1 &= (uint32_t)(~ADC_CFGR1_OVRMOD); + } +} + +/** + * @brief Active the Calibration operation for the selected ADC. + * @note The Calibration can be initiated only when ADC is still in the + * reset configuration (ADEN must be equal to 0). + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @retval ADC Calibration factor + */ +uint32_t ADC_GetCalibrationFactor(ADC_TypeDef* ADCx) +{ + uint32_t tmpreg = 0, calibrationcounter = 0, calibrationstatus = 0; + + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + + /* Set the ADC calibartion */ + ADCx->CR |= (uint32_t)ADC_CR_ADCAL; + + /* Wait until no ADC calibration is completed */ + do + { + calibrationstatus = ADCx->CR & ADC_CR_ADCAL; + calibrationcounter++; + } while((calibrationcounter != CALIBRATION_TIMEOUT) && (calibrationstatus != 0x00)); + + if((uint32_t)(ADCx->CR & ADC_CR_ADCAL) == RESET) + { + /*Get the calibration factor from the ADC data register */ + tmpreg = ADCx->DR; + } + else + { + /* Error factor */ + tmpreg = 0x00000000; + } + return tmpreg; +} + +/** + * @brief Stop the on going conversions for the selected ADC. + * @note When ADSTP is set, any on going conversion is aborted, and the ADC + * data register is not updated with current conversion. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @retval None + */ +void ADC_StopOfConversion(ADC_TypeDef* ADCx) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + + ADCx->CR |= (uint32_t)ADC_CR_ADSTP; +} + +/** + * @brief Start Conversion for the selected ADC channels. + * @note In continuous mode, ADSTART is not cleared by hardware with the + * assertion of EOSEQ because the sequence is automatic relaunched + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @retval None + */ +void ADC_StartOfConversion(ADC_TypeDef* ADCx) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + + ADCx->CR |= (uint32_t)ADC_CR_ADSTART; +} + +/** + * @brief Returns the last ADCx conversion result data for ADC channel. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @retval The Data conversion value. + */ +uint16_t ADC_GetConversionValue(ADC_TypeDef* ADCx) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + + /* Return the selected ADC conversion value */ + return (uint16_t) ADCx->DR; +} + +/** + * @} + */ + +/** @defgroup ADC_Group6 DMA Configuration functions + * @brief Regular Channels DMA Configuration functions + * +@verbatim + =============================================================================== + ##### DMA Configuration functions ##### + =============================================================================== + [..] This section provides functions allowing to configure the DMA for ADC hannels. + Since converted channel values are stored into a unique data register, + it is useful to use DMA for conversion of more than one channel. This + avoids the loss of the data already stored in the ADC Data register. + When the DMA mode is enabled (using the ADC_DMACmd() function), after each + conversion of a channel, a DMA request is generated. + + [..] Depending on the "DMA disable selection" configuration (using the + ADC_DMARequestModeConfig() function), at the end of the last DMA + transfer, two possibilities are allowed: + (+) No new DMA request is issued to the DMA controller (One Shot Mode) + (+) Requests can continue to be generated (Circular Mode). + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified ADC DMA request. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param NewState: new state of the selected ADC DMA transfer. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_DMACmd(ADC_TypeDef* ADCx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected ADC DMA request */ + ADCx->CFGR1 |= (uint32_t)ADC_CFGR1_DMAEN; + } + else + { + /* Disable the selected ADC DMA request */ + ADCx->CFGR1 &= (uint32_t)(~ADC_CFGR1_DMAEN); + } +} + +/** + * @brief Enables or disables the ADC DMA request after last transfer (Single-ADC mode) + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param ADC_DMARequestMode: the ADC channel to configure. + * This parameter can be one of the following values: + * @arg ADC_DMAMode_OneShot: DMA One Shot Mode + * @arg ADC_DMAMode_Circular: DMA Circular Mode + * @retval None + */ +void ADC_DMARequestModeConfig(ADC_TypeDef* ADCx, uint32_t ADC_DMARequestMode) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + + ADCx->CFGR1 &= (uint32_t)~ADC_CFGR1_DMACFG; + ADCx->CFGR1 |= (uint32_t)ADC_DMARequestMode; +} + +/** + * @} + */ + +/** @defgroup ADC_Group7 Interrupts and flags management functions + * @brief Interrupts and flags management functions. + * +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== + [..] This section provides functions allowing to configure the ADC Interrupts + and get the status and clear flags and Interrupts pending bits. + + [..] The ADC provide 6 Interrupts sources and 11 Flags which can be divided into + 3 groups: + + *** Flags for ADC status *** + ====================================================== + [..] + (+)Flags : + (##) ADC_FLAG_ADRDY : This flag is set after the ADC has been enabled (bit ADEN=1) + and when the ADC reaches a state where it is ready to accept conversion requests + (##) ADC_FLAG_ADEN : This flag is set by software to enable the ADC. + The ADC will be effectively ready to operate once the ADRDY flag has been set. + (##) ADC_FLAG_ADDIS : This flag is cleared once the ADC is effectively + disabled. + (##) ADC_FLAG_ADSTART : This flag is cleared after the execution of + ADC_StopOfConversion() function, at the same time as the ADSTP bit is + cleared by hardware + (##) ADC_FLAG_ADSTP : This flag is cleared by hardware when the conversion + is effectively discarded and the ADC is ready to accept a new start conversion + (##) ADC_FLAG_ADCAL : This flag is set once the calibration is complete. + + (+)Interrupts + (##) ADC_IT_ADRDY : specifies the interrupt source for ADC ready event. + + *** Flags and Interrupts for ADC channel conversion *** + ===================================================== + [..] + (+)Flags : + (##) ADC_FLAG_EOC : This flag is set by hardware at the end of each conversion + of a channel when a new data result is available in the data register + (##) ADC_FLAG_EOSEQ : This bit is set by hardware at the end of the conversion + of a sequence of channels selected by ADC_ChannelConfig() function. + (##) ADC_FLAG_EOSMP : This bit is set by hardware at the end of the sampling phase. + (##) ADC_FLAG_OVR : This flag is set by hardware when an overrun occurs, + meaning that a new conversion has complete while the EOC flag was already set. + + (+)Interrupts : + (##) ADC_IT_EOC : specifies the interrupt source for end of conversion event. + (##) ADC_IT_EOSEQ : specifies the interrupt source for end of sequence event. + (##) ADC_IT_EOSMP : specifies the interrupt source for end of sampling event. + (##) ADC_IT_OVR : specifies the interrupt source for Overrun detection + event. + + *** Flags and Interrupts for the Analog Watchdog *** + ================================================ + [..] + (+)Flags : + (##) ADC_FLAG_AWD: This flag is set by hardware when the converted + voltage crosses the values programmed thrsholds + + (+)Interrupts : + (##) ADC_IT_AWD : specifies the interrupt source for Analog watchdog + event. + + [..] The user should identify which mode will be used in his application to + manage the ADC controller events: Polling mode or Interrupt mode. + + [..] In the Polling Mode it is advised to use the following functions: + (+) ADC_GetFlagStatus() : to check if flags events occur. + (+) ADC_ClearFlag() : to clear the flags events. + + [..] In the Interrupt Mode it is advised to use the following functions: + (+) ADC_ITConfig() : to enable or disable the interrupt source. + (+) ADC_GetITStatus() : to check if Interrupt occurs. + (+) ADC_ClearITPendingBit() : to clear the Interrupt pending Bit + (corresponding Flag). + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified ADC interrupts. + * @param ADCx: where x can be 1 to select the ADC peripheral. + * @param ADC_IT: specifies the ADC interrupt sources to be enabled or disabled. + * This parameter can be one of the following values: + * @arg ADC_IT_ADRDY: ADC ready interrupt + * @arg ADC_IT_EOSMP: End of sampling interrupt + * @arg ADC_IT_EOC: End of conversion interrupt + * @arg ADC_IT_EOSEQ: End of sequence of conversion interrupt + * @arg ADC_IT_OVR: overrun interrupt + * @arg ADC_IT_AWD: Analog watchdog interrupt + * @param NewState: new state of the specified ADC interrupts. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void ADC_ITConfig(ADC_TypeDef* ADCx, uint32_t ADC_IT, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + assert_param(IS_ADC_CONFIG_IT(ADC_IT)); + + if (NewState != DISABLE) + { + /* Enable the selected ADC interrupts */ + ADCx->IER |= ADC_IT; + } + else + { + /* Disable the selected ADC interrupts */ + ADCx->IER &= (~(uint32_t)ADC_IT); + } +} + +/** + * @brief Checks whether the specified ADC flag is set or not. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param ADC_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg ADC_FLAG_AWD: Analog watchdog flag + * @arg ADC_FLAG_OVR: Overrun flag + * @arg ADC_FLAG_EOSEQ: End of Sequence flag + * @arg ADC_FLAG_EOC: End of conversion flag + * @arg ADC_FLAG_EOSMP: End of sampling flag + * @arg ADC_FLAG_ADRDY: ADC Ready flag + * @arg ADC_FLAG_ADEN: ADC enable flag + * @arg ADC_FLAG_ADDIS: ADC disable flag + * @arg ADC_FLAG_ADSTART: ADC start flag + * @arg ADC_FLAG_ADSTP: ADC stop flag + * @arg ADC_FLAG_ADCAL: ADC Calibration flag + * @retval The new state of ADC_FLAG (SET or RESET). + */ +FlagStatus ADC_GetFlagStatus(ADC_TypeDef* ADCx, uint32_t ADC_FLAG) +{ + FlagStatus bitstatus = RESET; + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_ADC_GET_FLAG(ADC_FLAG)); + + if((uint32_t)(ADC_FLAG & 0x01000000)) + { + tmpreg = ADCx->CR & 0xFEFFFFFF; + } + else + { + tmpreg = ADCx->ISR; + } + + /* Check the status of the specified ADC flag */ + if ((tmpreg & ADC_FLAG) != (uint32_t)RESET) + { + /* ADC_FLAG is set */ + bitstatus = SET; + } + else + { + /* ADC_FLAG is reset */ + bitstatus = RESET; + } + /* Return the ADC_FLAG status */ + return bitstatus; +} + +/** + * @brief Clears the ADCx's pending flags. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param ADC_FLAG: specifies the flag to clear. + * This parameter can be any combination of the following values: + * @arg ADC_FLAG_AWD: Analog watchdog flag + * @arg ADC_FLAG_EOC: End of conversion flag + * @arg ADC_FLAG_ADRDY: ADC Ready flag + * @arg ADC_FLAG_EOSMP: End of sampling flag + * @arg ADC_FLAG_EOSEQ: End of Sequence flag + * @arg ADC_FLAG_OVR: Overrun flag + * @retval None + */ +void ADC_ClearFlag(ADC_TypeDef* ADCx, uint32_t ADC_FLAG) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_ADC_CLEAR_FLAG(ADC_FLAG)); + + /* Clear the selected ADC flags */ + ADCx->ISR = (uint32_t)ADC_FLAG; +} + +/** + * @brief Checks whether the specified ADC interrupt has occurred or not. + * @param ADCx: where x can be 1 to select the ADC1 peripheral + * @param ADC_IT: specifies the ADC interrupt source to check. + * This parameter can be one of the following values: + * @arg ADC_IT_ADRDY: ADC ready interrupt + * @arg ADC_IT_EOSMP: End of sampling interrupt + * @arg ADC_IT_EOC: End of conversion interrupt + * @arg ADC_IT_EOSEQ: End of sequence of conversion interrupt + * @arg ADC_IT_OVR: overrun interrupt + * @arg ADC_IT_AWD: Analog watchdog interrupt + * @retval The new state of ADC_IT (SET or RESET). + */ +ITStatus ADC_GetITStatus(ADC_TypeDef* ADCx, uint32_t ADC_IT) +{ + ITStatus bitstatus = RESET; + uint32_t enablestatus = 0; + + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_ADC_GET_IT(ADC_IT)); + + /* Get the ADC_IT enable bit status */ + enablestatus = (uint32_t)(ADCx->IER & ADC_IT); + + /* Check the status of the specified ADC interrupt */ + if (((uint32_t)(ADCx->ISR & ADC_IT) != (uint32_t)RESET) && (enablestatus != (uint32_t)RESET)) + { + /* ADC_IT is set */ + bitstatus = SET; + } + else + { + /* ADC_IT is reset */ + bitstatus = RESET; + } + /* Return the ADC_IT status */ + return bitstatus; +} + +/** + * @brief Clears the ADCx's interrupt pending bits. + * @param ADCx: where x can be 1 to select the ADC1 peripheral. + * @param ADC_IT: specifies the ADC interrupt pending bit to clear. + * This parameter can be one of the following values: + * @arg ADC_IT_ADRDY: ADC ready interrupt + * @arg ADC_IT_EOSMP: End of sampling interrupt + * @arg ADC_IT_EOC: End of conversion interrupt + * @arg ADC_IT_EOSEQ: End of sequence of conversion interrupt + * @arg ADC_IT_OVR: overrun interrupt + * @arg ADC_IT_AWD: Analog watchdog interrupt + * @retval None + */ +void ADC_ClearITPendingBit(ADC_TypeDef* ADCx, uint32_t ADC_IT) +{ + /* Check the parameters */ + assert_param(IS_ADC_ALL_PERIPH(ADCx)); + assert_param(IS_ADC_CLEAR_IT(ADC_IT)); + + /* Clear the selected ADC interrupt pending bits */ + ADCx->ISR = (uint32_t)ADC_IT; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_can.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_can.c new file mode 100644 index 00000000..c051ab49 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_can.c @@ -0,0 +1,1631 @@ +/** + ****************************************************************************** + * @file stm32f0xx_can.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Controller area network (CAN) peripheral and + * applicable only for STM32F072 devices : + * + Initialization and Configuration + * + CAN Frames Transmission + * + CAN Frames Reception + * + Operation modes switch + * + Error management + * + Interrupts and flags + * + @verbatim + + =============================================================================== + ##### How to use this driver ##### + =============================================================================== + [..] + (#) Enable the CAN controller interface clock using + RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN, ENABLE); + (#) CAN pins configuration: + (++) Enable the clock for the CAN GPIOs using the following function: + RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOx, ENABLE); + (++) Connect the involved CAN pins to AF0 using the following function + GPIO_PinAFConfig(GPIOx, GPIO_PinSourcex, GPIO_AF_CANx); + (++) Configure these CAN pins in alternate function mode by calling + the function GPIO_Init(); + (#) Initialise and configure the CAN using CAN_Init() and + CAN_FilterInit() functions. + (#) Transmit the desired CAN frame using CAN_Transmit() function. + (#) Check the transmission of a CAN frame using CAN_TransmitStatus() function. + (#) Cancel the transmission of a CAN frame using CAN_CancelTransmit() function. + (#) Receive a CAN frame using CAN_Recieve() function. + (#) Release the receive FIFOs using CAN_FIFORelease() function. + (#) Return the number of pending received frames using CAN_MessagePending() function. + (#) To control CAN events you can use one of the following two methods: + (++) Check on CAN flags using the CAN_GetFlagStatus() function. + (++) Use CAN interrupts through the function CAN_ITConfig() at initialization + phase and CAN_GetITStatus() function into interrupt routines to check + if the event has occurred or not. + After checking on a flag you should clear it using CAN_ClearFlag() + function. And after checking on an interrupt event you should clear it + using CAN_ClearITPendingBit() function. + + @endverbatim + * + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_can.h" +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup CAN + * @brief CAN driver modules + * @{ + */ +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ + +/* CAN Master Control Register bits */ +#define MCR_DBF ((uint32_t)0x00010000) /* software master reset */ + +/* CAN Mailbox Transmit Request */ +#define TMIDxR_TXRQ ((uint32_t)0x00000001) /* Transmit mailbox request */ + +/* CAN Filter Master Register bits */ +#define FMR_FINIT ((uint32_t)0x00000001) /* Filter init mode */ + +/* Time out for INAK bit */ +#define INAK_TIMEOUT ((uint32_t)0x00FFFFFF) +/* Time out for SLAK bit */ +#define SLAK_TIMEOUT ((uint32_t)0x00FFFFFF) + +/* Flags in TSR register */ +#define CAN_FLAGS_TSR ((uint32_t)0x08000000) +/* Flags in RF1R register */ +#define CAN_FLAGS_RF1R ((uint32_t)0x04000000) +/* Flags in RF0R register */ +#define CAN_FLAGS_RF0R ((uint32_t)0x02000000) +/* Flags in MSR register */ +#define CAN_FLAGS_MSR ((uint32_t)0x01000000) +/* Flags in ESR register */ +#define CAN_FLAGS_ESR ((uint32_t)0x00F00000) + +/* Mailboxes definition */ +#define CAN_TXMAILBOX_0 ((uint8_t)0x00) +#define CAN_TXMAILBOX_1 ((uint8_t)0x01) +#define CAN_TXMAILBOX_2 ((uint8_t)0x02) + +#define CAN_MODE_MASK ((uint32_t) 0x00000003) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ +static ITStatus CheckITStatus(uint32_t CAN_Reg, uint32_t It_Bit); + +/** @defgroup CAN_Private_Functions + * @{ + */ + +/** @defgroup CAN_Group1 Initialization and Configuration functions + * @brief Initialization and Configuration functions + * +@verbatim + =============================================================================== + ##### Initialization and Configuration functions ##### + =============================================================================== + [..] This section provides functions allowing to: + (+) Initialize the CAN peripherals : Prescaler, operating mode, the maximum + number of time quanta to perform resynchronization, the number of time + quanta in Bit Segment 1 and 2 and many other modes. + (+) Configure the CAN reception filter. + (+) Select the start bank filter for slave CAN. + (+) Enable or disable the Debug Freeze mode for CAN. + (+) Enable or disable the CAN Time Trigger Operation communication mode. + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the CAN peripheral registers to their default reset values. + * @param CANx: where x can be 1 to select the CAN peripheral. + * @retval None. + */ +void CAN_DeInit(CAN_TypeDef* CANx) +{ + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + + /* Enable CAN reset state */ + RCC_APB1PeriphResetCmd(RCC_APB1Periph_CAN, ENABLE); + /* Release CAN from reset state */ + RCC_APB1PeriphResetCmd(RCC_APB1Periph_CAN, DISABLE); +} + +/** + * @brief Initializes the CAN peripheral according to the specified + * parameters in the CAN_InitStruct. + * @param CANx: where x can be 1 to select the CAN peripheral. + * @param CAN_InitStruct: pointer to a CAN_InitTypeDef structure that contains + * the configuration information for the CAN peripheral. + * @retval Constant indicates initialization succeed which will be + * CAN_InitStatus_Failed or CAN_InitStatus_Success. + */ +uint8_t CAN_Init(CAN_TypeDef* CANx, CAN_InitTypeDef* CAN_InitStruct) +{ + uint8_t InitStatus = CAN_InitStatus_Failed; + uint32_t wait_ack = 0x00000000; + + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_TTCM)); + assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_ABOM)); + assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_AWUM)); + assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_NART)); + assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_RFLM)); + assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_TXFP)); + assert_param(IS_CAN_MODE(CAN_InitStruct->CAN_Mode)); + assert_param(IS_CAN_SJW(CAN_InitStruct->CAN_SJW)); + assert_param(IS_CAN_BS1(CAN_InitStruct->CAN_BS1)); + assert_param(IS_CAN_BS2(CAN_InitStruct->CAN_BS2)); + assert_param(IS_CAN_PRESCALER(CAN_InitStruct->CAN_Prescaler)); + + /* Exit from sleep mode */ + CANx->MCR &= (~(uint32_t)CAN_MCR_SLEEP); + + /* Request initialisation */ + CANx->MCR |= CAN_MCR_INRQ ; + + /* Wait the acknowledge */ + while (((CANx->MSR & CAN_MSR_INAK) != CAN_MSR_INAK) && (wait_ack != INAK_TIMEOUT)) + { + wait_ack++; + } + + /* Check acknowledge */ + if ((CANx->MSR & CAN_MSR_INAK) != CAN_MSR_INAK) + { + InitStatus = CAN_InitStatus_Failed; + } + else + { + /* Set the time triggered communication mode */ + if (CAN_InitStruct->CAN_TTCM == ENABLE) + { + CANx->MCR |= CAN_MCR_TTCM; + } + else + { + CANx->MCR &= ~(uint32_t)CAN_MCR_TTCM; + } + + /* Set the automatic bus-off management */ + if (CAN_InitStruct->CAN_ABOM == ENABLE) + { + CANx->MCR |= CAN_MCR_ABOM; + } + else + { + CANx->MCR &= ~(uint32_t)CAN_MCR_ABOM; + } + + /* Set the automatic wake-up mode */ + if (CAN_InitStruct->CAN_AWUM == ENABLE) + { + CANx->MCR |= CAN_MCR_AWUM; + } + else + { + CANx->MCR &= ~(uint32_t)CAN_MCR_AWUM; + } + + /* Set the no automatic retransmission */ + if (CAN_InitStruct->CAN_NART == ENABLE) + { + CANx->MCR |= CAN_MCR_NART; + } + else + { + CANx->MCR &= ~(uint32_t)CAN_MCR_NART; + } + + /* Set the receive FIFO locked mode */ + if (CAN_InitStruct->CAN_RFLM == ENABLE) + { + CANx->MCR |= CAN_MCR_RFLM; + } + else + { + CANx->MCR &= ~(uint32_t)CAN_MCR_RFLM; + } + + /* Set the transmit FIFO priority */ + if (CAN_InitStruct->CAN_TXFP == ENABLE) + { + CANx->MCR |= CAN_MCR_TXFP; + } + else + { + CANx->MCR &= ~(uint32_t)CAN_MCR_TXFP; + } + + /* Set the bit timing register */ + CANx->BTR = (uint32_t)((uint32_t)CAN_InitStruct->CAN_Mode << 30) | \ + ((uint32_t)CAN_InitStruct->CAN_SJW << 24) | \ + ((uint32_t)CAN_InitStruct->CAN_BS1 << 16) | \ + ((uint32_t)CAN_InitStruct->CAN_BS2 << 20) | \ + ((uint32_t)CAN_InitStruct->CAN_Prescaler - 1); + + /* Request leave initialisation */ + CANx->MCR &= ~(uint32_t)CAN_MCR_INRQ; + + /* Wait the acknowledge */ + wait_ack = 0; + + while (((CANx->MSR & CAN_MSR_INAK) == (uint16_t)CAN_MSR_INAK) && (wait_ack != INAK_TIMEOUT)) + { + wait_ack++; + } + + /* ...and check acknowledged */ + if ((CANx->MSR & CAN_MSR_INAK) == CAN_MSR_INAK) + { + InitStatus = CAN_InitStatus_Failed; + } + else + { + InitStatus = CAN_InitStatus_Success ; + } + } + + /* At this step, return the status of initialization */ + return InitStatus; +} + +/** + * @brief Configures the CAN reception filter according to the specified + * parameters in the CAN_FilterInitStruct. + * @param CAN_FilterInitStruct: pointer to a CAN_FilterInitTypeDef structure that + * contains the configuration information. + * @retval None + */ +void CAN_FilterInit(CAN_FilterInitTypeDef* CAN_FilterInitStruct) +{ + uint32_t filter_number_bit_pos = 0; + /* Check the parameters */ + assert_param(IS_CAN_FILTER_NUMBER(CAN_FilterInitStruct->CAN_FilterNumber)); + assert_param(IS_CAN_FILTER_MODE(CAN_FilterInitStruct->CAN_FilterMode)); + assert_param(IS_CAN_FILTER_SCALE(CAN_FilterInitStruct->CAN_FilterScale)); + assert_param(IS_CAN_FILTER_FIFO(CAN_FilterInitStruct->CAN_FilterFIFOAssignment)); + assert_param(IS_FUNCTIONAL_STATE(CAN_FilterInitStruct->CAN_FilterActivation)); + + filter_number_bit_pos = ((uint32_t)1) << CAN_FilterInitStruct->CAN_FilterNumber; + + /* Initialisation mode for the filter */ + CAN->FMR |= FMR_FINIT; + + /* Filter Deactivation */ + CAN->FA1R &= ~(uint32_t)filter_number_bit_pos; + + /* Filter Scale */ + if (CAN_FilterInitStruct->CAN_FilterScale == CAN_FilterScale_16bit) + { + /* 16-bit scale for the filter */ + CAN->FS1R &= ~(uint32_t)filter_number_bit_pos; + + /* First 16-bit identifier and First 16-bit mask */ + /* Or First 16-bit identifier and Second 16-bit identifier */ + CAN->sFilterRegister[CAN_FilterInitStruct->CAN_FilterNumber].FR1 = + ((0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterMaskIdLow) << 16) | + (0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterIdLow); + + /* Second 16-bit identifier and Second 16-bit mask */ + /* Or Third 16-bit identifier and Fourth 16-bit identifier */ + CAN->sFilterRegister[CAN_FilterInitStruct->CAN_FilterNumber].FR2 = + ((0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterMaskIdHigh) << 16) | + (0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterIdHigh); + } + + if (CAN_FilterInitStruct->CAN_FilterScale == CAN_FilterScale_32bit) + { + /* 32-bit scale for the filter */ + CAN->FS1R |= filter_number_bit_pos; + /* 32-bit identifier or First 32-bit identifier */ + CAN->sFilterRegister[CAN_FilterInitStruct->CAN_FilterNumber].FR1 = + ((0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterIdHigh) << 16) | + (0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterIdLow); + /* 32-bit mask or Second 32-bit identifier */ + CAN->sFilterRegister[CAN_FilterInitStruct->CAN_FilterNumber].FR2 = + ((0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterMaskIdHigh) << 16) | + (0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterMaskIdLow); + } + + /* Filter Mode */ + if (CAN_FilterInitStruct->CAN_FilterMode == CAN_FilterMode_IdMask) + { + /*Id/Mask mode for the filter*/ + CAN->FM1R &= ~(uint32_t)filter_number_bit_pos; + } + else /* CAN_FilterInitStruct->CAN_FilterMode == CAN_FilterMode_IdList */ + { + /*Identifier list mode for the filter*/ + CAN->FM1R |= (uint32_t)filter_number_bit_pos; + } + + /* Filter FIFO assignment */ + if (CAN_FilterInitStruct->CAN_FilterFIFOAssignment == CAN_Filter_FIFO0) + { + /* FIFO 0 assignation for the filter */ + CAN->FFA1R &= ~(uint32_t)filter_number_bit_pos; + } + + if (CAN_FilterInitStruct->CAN_FilterFIFOAssignment == CAN_Filter_FIFO1) + { + /* FIFO 1 assignation for the filter */ + CAN->FFA1R |= (uint32_t)filter_number_bit_pos; + } + + /* Filter activation */ + if (CAN_FilterInitStruct->CAN_FilterActivation == ENABLE) + { + CAN->FA1R |= filter_number_bit_pos; + } + + /* Leave the initialisation mode for the filter */ + CAN->FMR &= ~FMR_FINIT; +} + +/** + * @brief Fills each CAN_InitStruct member with its default value. + * @param CAN_InitStruct: pointer to a CAN_InitTypeDef structure which ill be initialized. + * @retval None + */ +void CAN_StructInit(CAN_InitTypeDef* CAN_InitStruct) +{ + /* Reset CAN init structure parameters values */ + + /* Initialize the time triggered communication mode */ + CAN_InitStruct->CAN_TTCM = DISABLE; + + /* Initialize the automatic bus-off management */ + CAN_InitStruct->CAN_ABOM = DISABLE; + + /* Initialize the automatic wake-up mode */ + CAN_InitStruct->CAN_AWUM = DISABLE; + + /* Initialize the no automatic retransmission */ + CAN_InitStruct->CAN_NART = DISABLE; + + /* Initialize the receive FIFO locked mode */ + CAN_InitStruct->CAN_RFLM = DISABLE; + + /* Initialize the transmit FIFO priority */ + CAN_InitStruct->CAN_TXFP = DISABLE; + + /* Initialize the CAN_Mode member */ + CAN_InitStruct->CAN_Mode = CAN_Mode_Normal; + + /* Initialize the CAN_SJW member */ + CAN_InitStruct->CAN_SJW = CAN_SJW_1tq; + + /* Initialize the CAN_BS1 member */ + CAN_InitStruct->CAN_BS1 = CAN_BS1_4tq; + + /* Initialize the CAN_BS2 member */ + CAN_InitStruct->CAN_BS2 = CAN_BS2_3tq; + + /* Initialize the CAN_Prescaler member */ + CAN_InitStruct->CAN_Prescaler = 1; +} + +/** + * @brief Select the start bank filter for slave CAN. + * @param CAN_BankNumber: Select the start slave bank filter from 1..27. + * @retval None + */ +void CAN_SlaveStartBank(uint8_t CAN_BankNumber) +{ + /* Check the parameters */ + assert_param(IS_CAN_BANKNUMBER(CAN_BankNumber)); + + /* Enter Initialisation mode for the filter */ + CAN->FMR |= FMR_FINIT; + + /* Select the start slave bank */ + CAN->FMR &= (uint32_t)0xFFFFC0F1 ; + CAN->FMR |= (uint32_t)(CAN_BankNumber)<<8; + + /* Leave Initialisation mode for the filter */ + CAN->FMR &= ~FMR_FINIT; +} + +/** + * @brief Enables or disables the DBG Freeze for CAN. + * @param CANx: where x can be 1 or 2 to to select the CAN peripheral. + * @param NewState: new state of the CAN peripheral. + * This parameter can be: ENABLE (CAN reception/transmission is frozen + * during debug. Reception FIFOs can still be accessed/controlled normally) + * or DISABLE (CAN is working during debug). + * @retval None + */ +void CAN_DBGFreeze(CAN_TypeDef* CANx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable Debug Freeze */ + CANx->MCR |= MCR_DBF; + } + else + { + /* Disable Debug Freeze */ + CANx->MCR &= ~MCR_DBF; + } +} + +/** + * @brief Enables or disables the CAN Time TriggerOperation communication mode. + * @note DLC must be programmed as 8 in order Time Stamp (2 bytes) to be + * sent over the CAN bus. + * @param CANx: where x can be 1 or 2 to to select the CAN peripheral. + * @param NewState: Mode new state. This parameter can be: ENABLE or DISABLE. + * When enabled, Time stamp (TIME[15:0]) value is sent in the last two + * data bytes of the 8-byte message: TIME[7:0] in data byte 6 and TIME[15:8] + * in data byte 7. + * @retval None + */ +void CAN_TTComModeCmd(CAN_TypeDef* CANx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + if (NewState != DISABLE) + { + /* Enable the TTCM mode */ + CANx->MCR |= CAN_MCR_TTCM; + + /* Set TGT bits */ + CANx->sTxMailBox[0].TDTR |= ((uint32_t)CAN_TDT0R_TGT); + CANx->sTxMailBox[1].TDTR |= ((uint32_t)CAN_TDT1R_TGT); + CANx->sTxMailBox[2].TDTR |= ((uint32_t)CAN_TDT2R_TGT); + } + else + { + /* Disable the TTCM mode */ + CANx->MCR &= (uint32_t)(~(uint32_t)CAN_MCR_TTCM); + + /* Reset TGT bits */ + CANx->sTxMailBox[0].TDTR &= ((uint32_t)~CAN_TDT0R_TGT); + CANx->sTxMailBox[1].TDTR &= ((uint32_t)~CAN_TDT1R_TGT); + CANx->sTxMailBox[2].TDTR &= ((uint32_t)~CAN_TDT2R_TGT); + } +} +/** + * @} + */ + + +/** @defgroup CAN_Group2 CAN Frames Transmission functions + * @brief CAN Frames Transmission functions + * +@verbatim + =============================================================================== + ##### CAN Frames Transmission functions ##### + =============================================================================== + [..] This section provides functions allowing to + (+) Initiate and transmit a CAN frame message (if there is an empty mailbox). + (+) Check the transmission status of a CAN Frame. + (+) Cancel a transmit request. + +@endverbatim + * @{ + */ + +/** + * @brief Initiates and transmits a CAN frame message. + * @param CANx: where x can be 1 or 2 to to select the CAN peripheral. + * @param TxMessage: pointer to a structure which contains CAN Id, CAN DLC and CAN data. + * @retval The number of the mailbox that is used for transmission or + * CAN_TxStatus_NoMailBox if there is no empty mailbox. + */ +uint8_t CAN_Transmit(CAN_TypeDef* CANx, CanTxMsg* TxMessage) +{ + uint8_t transmit_mailbox = 0; + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_IDTYPE(TxMessage->IDE)); + assert_param(IS_CAN_RTR(TxMessage->RTR)); + assert_param(IS_CAN_DLC(TxMessage->DLC)); + + /* Select one empty transmit mailbox */ + if ((CANx->TSR&CAN_TSR_TME0) == CAN_TSR_TME0) + { + transmit_mailbox = 0; + } + else if ((CANx->TSR&CAN_TSR_TME1) == CAN_TSR_TME1) + { + transmit_mailbox = 1; + } + else if ((CANx->TSR&CAN_TSR_TME2) == CAN_TSR_TME2) + { + transmit_mailbox = 2; + } + else + { + transmit_mailbox = CAN_TxStatus_NoMailBox; + } + + if (transmit_mailbox != CAN_TxStatus_NoMailBox) + { + /* Set up the Id */ + CANx->sTxMailBox[transmit_mailbox].TIR &= TMIDxR_TXRQ; + if (TxMessage->IDE == CAN_Id_Standard) + { + assert_param(IS_CAN_STDID(TxMessage->StdId)); + CANx->sTxMailBox[transmit_mailbox].TIR |= ((TxMessage->StdId << 21) | \ + TxMessage->RTR); + } + else + { + assert_param(IS_CAN_EXTID(TxMessage->ExtId)); + CANx->sTxMailBox[transmit_mailbox].TIR |= ((TxMessage->ExtId << 3) | \ + TxMessage->IDE | \ + TxMessage->RTR); + } + + /* Set up the DLC */ + TxMessage->DLC &= (uint8_t)0x0000000F; + CANx->sTxMailBox[transmit_mailbox].TDTR &= (uint32_t)0xFFFFFFF0; + CANx->sTxMailBox[transmit_mailbox].TDTR |= TxMessage->DLC; + + /* Set up the data field */ + CANx->sTxMailBox[transmit_mailbox].TDLR = (((uint32_t)TxMessage->Data[3] << 24) | + ((uint32_t)TxMessage->Data[2] << 16) | + ((uint32_t)TxMessage->Data[1] << 8) | + ((uint32_t)TxMessage->Data[0])); + CANx->sTxMailBox[transmit_mailbox].TDHR = (((uint32_t)TxMessage->Data[7] << 24) | + ((uint32_t)TxMessage->Data[6] << 16) | + ((uint32_t)TxMessage->Data[5] << 8) | + ((uint32_t)TxMessage->Data[4])); + /* Request transmission */ + CANx->sTxMailBox[transmit_mailbox].TIR |= TMIDxR_TXRQ; + } + return transmit_mailbox; +} + +/** + * @brief Checks the transmission status of a CAN Frame. + * @param CANx: where x can be 1 to select the CAN peripheral. + * @param TransmitMailbox: the number of the mailbox that is used for transmission. + * @retval CAN_TxStatus_Ok if the CAN driver transmits the message, + * CAN_TxStatus_Failed in an other case. + */ +uint8_t CAN_TransmitStatus(CAN_TypeDef* CANx, uint8_t TransmitMailbox) +{ + uint32_t state = 0; + + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_TRANSMITMAILBOX(TransmitMailbox)); + + switch (TransmitMailbox) + { + case (CAN_TXMAILBOX_0): + state = CANx->TSR & (CAN_TSR_RQCP0 | CAN_TSR_TXOK0 | CAN_TSR_TME0); + break; + case (CAN_TXMAILBOX_1): + state = CANx->TSR & (CAN_TSR_RQCP1 | CAN_TSR_TXOK1 | CAN_TSR_TME1); + break; + case (CAN_TXMAILBOX_2): + state = CANx->TSR & (CAN_TSR_RQCP2 | CAN_TSR_TXOK2 | CAN_TSR_TME2); + break; + default: + state = CAN_TxStatus_Failed; + break; + } + switch (state) + { + /* transmit pending */ + case (0x0): state = CAN_TxStatus_Pending; + break; + /* transmit failed */ + case (CAN_TSR_RQCP0 | CAN_TSR_TME0): state = CAN_TxStatus_Failed; + break; + case (CAN_TSR_RQCP1 | CAN_TSR_TME1): state = CAN_TxStatus_Failed; + break; + case (CAN_TSR_RQCP2 | CAN_TSR_TME2): state = CAN_TxStatus_Failed; + break; + /* transmit succeeded */ + case (CAN_TSR_RQCP0 | CAN_TSR_TXOK0 | CAN_TSR_TME0):state = CAN_TxStatus_Ok; + break; + case (CAN_TSR_RQCP1 | CAN_TSR_TXOK1 | CAN_TSR_TME1):state = CAN_TxStatus_Ok; + break; + case (CAN_TSR_RQCP2 | CAN_TSR_TXOK2 | CAN_TSR_TME2):state = CAN_TxStatus_Ok; + break; + default: state = CAN_TxStatus_Failed; + break; + } + return (uint8_t) state; +} + +/** + * @brief Cancels a transmit request. + * @param CANx: where x can be 1 to select the CAN peripheral. + * @param Mailbox: Mailbox number. + * @retval None + */ +void CAN_CancelTransmit(CAN_TypeDef* CANx, uint8_t Mailbox) +{ + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_TRANSMITMAILBOX(Mailbox)); + /* abort transmission */ + switch (Mailbox) + { + case (CAN_TXMAILBOX_0): CANx->TSR |= CAN_TSR_ABRQ0; + break; + case (CAN_TXMAILBOX_1): CANx->TSR |= CAN_TSR_ABRQ1; + break; + case (CAN_TXMAILBOX_2): CANx->TSR |= CAN_TSR_ABRQ2; + break; + default: + break; + } +} +/** + * @} + */ + + +/** @defgroup CAN_Group3 CAN Frames Reception functions + * @brief CAN Frames Reception functions + * +@verbatim + =============================================================================== + ##### CAN Frames Reception functions ##### + =============================================================================== + [..] This section provides functions allowing to + (+) Receive a correct CAN frame. + (+) Release a specified receive FIFO (2 FIFOs are available). + (+) Return the number of the pending received CAN frames. + +@endverbatim + * @{ + */ + +/** + * @brief Receives a correct CAN frame. + * @param CANx: where x can be 1 to select the CAN peripheral. + * @param FIFONumber: Receive FIFO number, CAN_FIFO0 or CAN_FIFO1. + * @param RxMessage: pointer to a structure receive frame which contains CAN Id, + * CAN DLC, CAN data and FMI number. + * @retval None + */ +void CAN_Receive(CAN_TypeDef* CANx, uint8_t FIFONumber, CanRxMsg* RxMessage) +{ + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_FIFO(FIFONumber)); + /* Get the Id */ + RxMessage->IDE = (uint8_t)0x04 & CANx->sFIFOMailBox[FIFONumber].RIR; + if (RxMessage->IDE == CAN_Id_Standard) + { + RxMessage->StdId = (uint32_t)0x000007FF & (CANx->sFIFOMailBox[FIFONumber].RIR >> 21); + } + else + { + RxMessage->ExtId = (uint32_t)0x1FFFFFFF & (CANx->sFIFOMailBox[FIFONumber].RIR >> 3); + } + + RxMessage->RTR = (uint8_t)0x02 & CANx->sFIFOMailBox[FIFONumber].RIR; + /* Get the DLC */ + RxMessage->DLC = (uint8_t)0x0F & CANx->sFIFOMailBox[FIFONumber].RDTR; + /* Get the FMI */ + RxMessage->FMI = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDTR >> 8); + /* Get the data field */ + RxMessage->Data[0] = (uint8_t)0xFF & CANx->sFIFOMailBox[FIFONumber].RDLR; + RxMessage->Data[1] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDLR >> 8); + RxMessage->Data[2] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDLR >> 16); + RxMessage->Data[3] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDLR >> 24); + RxMessage->Data[4] = (uint8_t)0xFF & CANx->sFIFOMailBox[FIFONumber].RDHR; + RxMessage->Data[5] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDHR >> 8); + RxMessage->Data[6] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDHR >> 16); + RxMessage->Data[7] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDHR >> 24); + /* Release the FIFO */ + /* Release FIFO0 */ + if (FIFONumber == CAN_FIFO0) + { + CANx->RF0R |= CAN_RF0R_RFOM0; + } + /* Release FIFO1 */ + else /* FIFONumber == CAN_FIFO1 */ + { + CANx->RF1R |= CAN_RF1R_RFOM1; + } +} + +/** + * @brief Releases the specified receive FIFO. + * @param CANx: where x can be 1 to select the CAN peripheral. + * @param FIFONumber: FIFO to release, CAN_FIFO0 or CAN_FIFO1. + * @retval None + */ +void CAN_FIFORelease(CAN_TypeDef* CANx, uint8_t FIFONumber) +{ + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_FIFO(FIFONumber)); + /* Release FIFO0 */ + if (FIFONumber == CAN_FIFO0) + { + CANx->RF0R |= CAN_RF0R_RFOM0; + } + /* Release FIFO1 */ + else /* FIFONumber == CAN_FIFO1 */ + { + CANx->RF1R |= CAN_RF1R_RFOM1; + } +} + +/** + * @brief Returns the number of pending received messages. + * @param CANx: where x can be 1 to select the CAN peripheral. + * @param FIFONumber: Receive FIFO number, CAN_FIFO0 or CAN_FIFO1. + * @retval NbMessage : which is the number of pending message. + */ +uint8_t CAN_MessagePending(CAN_TypeDef* CANx, uint8_t FIFONumber) +{ + uint8_t message_pending=0; + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_FIFO(FIFONumber)); + if (FIFONumber == CAN_FIFO0) + { + message_pending = (uint8_t)(CANx->RF0R&(uint32_t)0x03); + } + else if (FIFONumber == CAN_FIFO1) + { + message_pending = (uint8_t)(CANx->RF1R&(uint32_t)0x03); + } + else + { + message_pending = 0; + } + return message_pending; +} +/** + * @} + */ + + +/** @defgroup CAN_Group4 CAN Operation modes functions + * @brief CAN Operation modes functions + * +@verbatim + =============================================================================== + ##### CAN Operation modes functions ##### + =============================================================================== + [..] This section provides functions allowing to select the CAN Operation modes: + (+) sleep mode. + (+) normal mode. + (+) initialization mode. + +@endverbatim + * @{ + */ + + +/** + * @brief Selects the CAN Operation mode. + * @param CAN_OperatingMode: CAN Operating Mode. + * This parameter can be one of @ref CAN_OperatingMode_TypeDef enumeration. + * @retval status of the requested mode which can be: + * - CAN_ModeStatus_Failed: CAN failed entering the specific mode + * - CAN_ModeStatus_Success: CAN Succeed entering the specific mode + */ +uint8_t CAN_OperatingModeRequest(CAN_TypeDef* CANx, uint8_t CAN_OperatingMode) +{ + uint8_t status = CAN_ModeStatus_Failed; + + /* Timeout for INAK or also for SLAK bits*/ + uint32_t timeout = INAK_TIMEOUT; + + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_OPERATING_MODE(CAN_OperatingMode)); + + if (CAN_OperatingMode == CAN_OperatingMode_Initialization) + { + /* Request initialisation */ + CANx->MCR = (uint32_t)((CANx->MCR & (uint32_t)(~(uint32_t)CAN_MCR_SLEEP)) | CAN_MCR_INRQ); + + /* Wait the acknowledge */ + while (((CANx->MSR & CAN_MODE_MASK) != CAN_MSR_INAK) && (timeout != 0)) + { + timeout--; + } + if ((CANx->MSR & CAN_MODE_MASK) != CAN_MSR_INAK) + { + status = CAN_ModeStatus_Failed; + } + else + { + status = CAN_ModeStatus_Success; + } + } + else if (CAN_OperatingMode == CAN_OperatingMode_Normal) + { + /* Request leave initialisation and sleep mode and enter Normal mode */ + CANx->MCR &= (uint32_t)(~(CAN_MCR_SLEEP|CAN_MCR_INRQ)); + + /* Wait the acknowledge */ + while (((CANx->MSR & CAN_MODE_MASK) != 0) && (timeout!=0)) + { + timeout--; + } + if ((CANx->MSR & CAN_MODE_MASK) != 0) + { + status = CAN_ModeStatus_Failed; + } + else + { + status = CAN_ModeStatus_Success; + } + } + else if (CAN_OperatingMode == CAN_OperatingMode_Sleep) + { + /* Request Sleep mode */ + CANx->MCR = (uint32_t)((CANx->MCR & (uint32_t)(~(uint32_t)CAN_MCR_INRQ)) | CAN_MCR_SLEEP); + + /* Wait the acknowledge */ + while (((CANx->MSR & CAN_MODE_MASK) != CAN_MSR_SLAK) && (timeout!=0)) + { + timeout--; + } + if ((CANx->MSR & CAN_MODE_MASK) != CAN_MSR_SLAK) + { + status = CAN_ModeStatus_Failed; + } + else + { + status = CAN_ModeStatus_Success; + } + } + else + { + status = CAN_ModeStatus_Failed; + } + + return (uint8_t) status; +} + +/** + * @brief Enters the Sleep (low power) mode. + * @param CANx: where x can be 1 to select the CAN peripheral. + * @retval CAN_Sleep_Ok if sleep entered, CAN_Sleep_Failed otherwise. + */ +uint8_t CAN_Sleep(CAN_TypeDef* CANx) +{ + uint8_t sleepstatus = CAN_Sleep_Failed; + + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + + /* Request Sleep mode */ + CANx->MCR = (((CANx->MCR) & (uint32_t)(~(uint32_t)CAN_MCR_INRQ)) | CAN_MCR_SLEEP); + + /* Sleep mode status */ + if ((CANx->MSR & (CAN_MSR_SLAK|CAN_MSR_INAK)) == CAN_MSR_SLAK) + { + /* Sleep mode not entered */ + sleepstatus = CAN_Sleep_Ok; + } + /* return sleep mode status */ + return (uint8_t)sleepstatus; +} + +/** + * @brief Wakes up the CAN peripheral from sleep mode . + * @param CANx: where x can be 1 to select the CAN peripheral. + * @retval CAN_WakeUp_Ok if sleep mode left, CAN_WakeUp_Failed otherwise. + */ +uint8_t CAN_WakeUp(CAN_TypeDef* CANx) +{ + uint32_t wait_slak = SLAK_TIMEOUT; + uint8_t wakeupstatus = CAN_WakeUp_Failed; + + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + + /* Wake up request */ + CANx->MCR &= ~(uint32_t)CAN_MCR_SLEEP; + + /* Sleep mode status */ + while(((CANx->MSR & CAN_MSR_SLAK) == CAN_MSR_SLAK)&&(wait_slak!=0x00)) + { + wait_slak--; + } + if((CANx->MSR & CAN_MSR_SLAK) != CAN_MSR_SLAK) + { + /* wake up done : Sleep mode exited */ + wakeupstatus = CAN_WakeUp_Ok; + } + /* return wakeup status */ + return (uint8_t)wakeupstatus; +} +/** + * @} + */ + + +/** @defgroup CAN_Group5 CAN Bus Error management functions + * @brief CAN Bus Error management functions + * +@verbatim + =============================================================================== + ##### CAN Bus Error management functions ##### + =============================================================================== + [..] This section provides functions allowing to + (+) Return the CANx's last error code (LEC). + (+) Return the CANx Receive Error Counter (REC). + (+) Return the LSB of the 9-bit CANx Transmit Error Counter(TEC). + [..] + (@) If TEC is greater than 255, The CAN is in bus-off state. + (@) If REC or TEC are greater than 96, an Error warning flag occurs. + (@) If REC or TEC are greater than 127, an Error Passive Flag occurs. + +@endverbatim + * @{ + */ + +/** + * @brief Returns the CANx's last error code (LEC). + * @param CANx: where x can be 1 to select the CAN peripheral. + * @retval Error code: + * - CAN_ERRORCODE_NoErr: No Error + * - CAN_ERRORCODE_StuffErr: Stuff Error + * - CAN_ERRORCODE_FormErr: Form Error + * - CAN_ERRORCODE_ACKErr : Acknowledgment Error + * - CAN_ERRORCODE_BitRecessiveErr: Bit Recessive Error + * - CAN_ERRORCODE_BitDominantErr: Bit Dominant Error + * - CAN_ERRORCODE_CRCErr: CRC Error + * - CAN_ERRORCODE_SoftwareSetErr: Software Set Error + */ +uint8_t CAN_GetLastErrorCode(CAN_TypeDef* CANx) +{ + uint8_t errorcode=0; + + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + + /* Get the error code*/ + errorcode = (((uint8_t)CANx->ESR) & (uint8_t)CAN_ESR_LEC); + + /* Return the error code*/ + return errorcode; +} + +/** + * @brief Returns the CANx Receive Error Counter (REC). + * @note In case of an error during reception, this counter is incremented + * by 1 or by 8 depending on the error condition as defined by the CAN + * standard. After every successful reception, the counter is + * decremented by 1 or reset to 120 if its value was higher than 128. + * When the counter value exceeds 127, the CAN controller enters the + * error passive state. + * @param CANx: where x can be 1 or 2 to to select the CAN peripheral. + * @retval CAN Receive Error Counter. + */ +uint8_t CAN_GetReceiveErrorCounter(CAN_TypeDef* CANx) +{ + uint8_t counter=0; + + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + + /* Get the Receive Error Counter*/ + counter = (uint8_t)((CANx->ESR & CAN_ESR_REC)>> 24); + + /* Return the Receive Error Counter*/ + return counter; +} + + +/** + * @brief Returns the LSB of the 9-bit CANx Transmit Error Counter(TEC). + * @param CANx: where x can be 1 or 2 to to select the CAN peripheral. + * @retval LSB of the 9-bit CAN Transmit Error Counter. + */ +uint8_t CAN_GetLSBTransmitErrorCounter(CAN_TypeDef* CANx) +{ + uint8_t counter=0; + + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + + /* Get the LSB of the 9-bit CANx Transmit Error Counter(TEC) */ + counter = (uint8_t)((CANx->ESR & CAN_ESR_TEC)>> 16); + + /* Return the LSB of the 9-bit CANx Transmit Error Counter(TEC) */ + return counter; +} +/** + * @} + */ + +/** @defgroup CAN_Group6 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== + [..] This section provides functions allowing to configure the CAN Interrupts + and to get the status and clear flags and Interrupts pending bits. + [..] The CAN provides 14 Interrupts sources and 15 Flags: + + *** Flags *** + ============= + [..] The 15 flags can be divided on 4 groups: + (+) Transmit Flags: + (++) CAN_FLAG_RQCP0. + (++) CAN_FLAG_RQCP1. + (++) CAN_FLAG_RQCP2: Request completed MailBoxes 0, 1 and 2 Flags + Set when when the last request (transmit or abort) has + been performed. + (+) Receive Flags: + (++) CAN_FLAG_FMP0. + (++) CAN_FLAG_FMP1: FIFO 0 and 1 Message Pending Flags; + Set to signal that messages are pending in the receive FIFO. + These Flags are cleared only by hardware. + (++) CAN_FLAG_FF0. + (++) CAN_FLAG_FF1: FIFO 0 and 1 Full Flags; + Set when three messages are stored in the selected FIFO. + (++) CAN_FLAG_FOV0. + (++) CAN_FLAG_FOV1: FIFO 0 and 1 Overrun Flags; + Set when a new message has been received and passed the filter + while the FIFO was full. + (+) Operating Mode Flags: + (++) CAN_FLAG_WKU: Wake up Flag; + Set to signal that a SOF bit has been detected while the CAN + hardware was in Sleep mode. + (++) CAN_FLAG_SLAK: Sleep acknowledge Flag; + Set to signal that the CAN has entered Sleep Mode. + (+) Error Flags: + (++) CAN_FLAG_EWG: Error Warning Flag; + Set when the warning limit has been reached (Receive Error Counter + or Transmit Error Counter greater than 96). + This Flag is cleared only by hardware. + (++) CAN_FLAG_EPV: Error Passive Flag; + Set when the Error Passive limit has been reached (Receive Error + Counter or Transmit Error Counter greater than 127). + This Flag is cleared only by hardware. + (++) CAN_FLAG_BOF: Bus-Off Flag; + Set when CAN enters the bus-off state. The bus-off state is + entered on TEC overflow, greater than 255. + This Flag is cleared only by hardware. + (++) CAN_FLAG_LEC: Last error code Flag; + Set If a message has been transferred (reception or transmission) + with error, and the error code is hold. + + *** Interrupts *** + ================== + [..] The 14 interrupts can be divided on 4 groups: + (+) Transmit interrupt: + (++) CAN_IT_TME: Transmit mailbox empty Interrupt; + If enabled, this interrupt source is pending when no transmit + request are pending for Tx mailboxes. + (+) Receive Interrupts: + (++) CAN_IT_FMP0. + (++) CAN_IT_FMP1: FIFO 0 and FIFO1 message pending Interrupts; + If enabled, these interrupt sources are pending when messages + are pending in the receive FIFO. + The corresponding interrupt pending bits are cleared only by hardware. + (++) CAN_IT_FF0. + (++) CAN_IT_FF1: FIFO 0 and FIFO1 full Interrupts; + If enabled, these interrupt sources are pending when three messages + are stored in the selected FIFO. + (++) CAN_IT_FOV0. + (++) CAN_IT_FOV1: FIFO 0 and FIFO1 overrun Interrupts; + If enabled, these interrupt sources are pending when a new message + has been received and passed the filter while the FIFO was full. + (+) Operating Mode Interrupts: + (++) CAN_IT_WKU: Wake-up Interrupt; + If enabled, this interrupt source is pending when a SOF bit has + been detected while the CAN hardware was in Sleep mode. + (++) CAN_IT_SLK: Sleep acknowledge Interrupt: + If enabled, this interrupt source is pending when the CAN has + entered Sleep Mode. + (+) Error Interrupts: + (++) CAN_IT_EWG: Error warning Interrupt; + If enabled, this interrupt source is pending when the warning limit + has been reached (Receive Error Counter or Transmit Error Counter=96). + (++) CAN_IT_EPV: Error passive Interrupt; + If enabled, this interrupt source is pending when the Error Passive + limit has been reached (Receive Error Counter or Transmit Error Counter>127). + (++) CAN_IT_BOF: Bus-off Interrupt; + If enabled, this interrupt source is pending when CAN enters + the bus-off state. The bus-off state is entered on TEC overflow, + greater than 255. + This Flag is cleared only by hardware. + (++) CAN_IT_LEC: Last error code Interrupt; + If enabled, this interrupt source is pending when a message has + been transferred (reception or transmission) with error and the + error code is hold. + (++) CAN_IT_ERR: Error Interrupt; + If enabled, this interrupt source is pending when an error condition + is pending. + [..] Managing the CAN controller events: + The user should identify which mode will be used in his application to manage + the CAN controller events: Polling mode or Interrupt mode. + (+) In the Polling Mode it is advised to use the following functions: + (++) CAN_GetFlagStatus() : to check if flags events occur. + (++) CAN_ClearFlag() : to clear the flags events. + (+) In the Interrupt Mode it is advised to use the following functions: + (++) CAN_ITConfig() : to enable or disable the interrupt source. + (++) CAN_GetITStatus() : to check if Interrupt occurs. + (++) CAN_ClearITPendingBit() : to clear the Interrupt pending Bit + (corresponding Flag). + This function has no impact on CAN_IT_FMP0 and CAN_IT_FMP1 Interrupts + pending bits since there are cleared only by hardware. + +@endverbatim + * @{ + */ +/** + * @brief Enables or disables the specified CANx interrupts. + * @param CANx: where x can be 1 or 2 to to select the CAN peripheral. + * @param CAN_IT: specifies the CAN interrupt sources to be enabled or disabled. + * This parameter can be: + * @arg CAN_IT_TME: Transmit mailbox empty Interrupt + * @arg CAN_IT_FMP0: FIFO 0 message pending Interrupt + * @arg CAN_IT_FF0: FIFO 0 full Interrupt + * @arg CAN_IT_FOV0: FIFO 0 overrun Interrupt + * @arg CAN_IT_FMP1: FIFO 1 message pending Interrupt + * @arg CAN_IT_FF1: FIFO 1 full Interrupt + * @arg CAN_IT_FOV1: FIFO 1 overrun Interrupt + * @arg CAN_IT_WKU: Wake-up Interrupt + * @arg CAN_IT_SLK: Sleep acknowledge Interrupt + * @arg CAN_IT_EWG: Error warning Interrupt + * @arg CAN_IT_EPV: Error passive Interrupt + * @arg CAN_IT_BOF: Bus-off Interrupt + * @arg CAN_IT_LEC: Last error code Interrupt + * @arg CAN_IT_ERR: Error Interrupt + * @param NewState: new state of the CAN interrupts. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void CAN_ITConfig(CAN_TypeDef* CANx, uint32_t CAN_IT, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_IT(CAN_IT)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected CANx interrupt */ + CANx->IER |= CAN_IT; + } + else + { + /* Disable the selected CANx interrupt */ + CANx->IER &= ~CAN_IT; + } +} +/** + * @brief Checks whether the specified CAN flag is set or not. + * @param CANx: where x can be 1 or 2 to to select the CAN peripheral. + * @param CAN_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg CAN_FLAG_RQCP0: Request MailBox0 Flag + * @arg CAN_FLAG_RQCP1: Request MailBox1 Flag + * @arg CAN_FLAG_RQCP2: Request MailBox2 Flag + * @arg CAN_FLAG_FMP0: FIFO 0 Message Pending Flag + * @arg CAN_FLAG_FF0: FIFO 0 Full Flag + * @arg CAN_FLAG_FOV0: FIFO 0 Overrun Flag + * @arg CAN_FLAG_FMP1: FIFO 1 Message Pending Flag + * @arg CAN_FLAG_FF1: FIFO 1 Full Flag + * @arg CAN_FLAG_FOV1: FIFO 1 Overrun Flag + * @arg CAN_FLAG_WKU: Wake up Flag + * @arg CAN_FLAG_SLAK: Sleep acknowledge Flag + * @arg CAN_FLAG_EWG: Error Warning Flag + * @arg CAN_FLAG_EPV: Error Passive Flag + * @arg CAN_FLAG_BOF: Bus-Off Flag + * @arg CAN_FLAG_LEC: Last error code Flag + * @retval The new state of CAN_FLAG (SET or RESET). + */ +FlagStatus CAN_GetFlagStatus(CAN_TypeDef* CANx, uint32_t CAN_FLAG) +{ + FlagStatus bitstatus = RESET; + + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_GET_FLAG(CAN_FLAG)); + + + if((CAN_FLAG & CAN_FLAGS_ESR) != (uint32_t)RESET) + { + /* Check the status of the specified CAN flag */ + if ((CANx->ESR & (CAN_FLAG & 0x000FFFFF)) != (uint32_t)RESET) + { + /* CAN_FLAG is set */ + bitstatus = SET; + } + else + { + /* CAN_FLAG is reset */ + bitstatus = RESET; + } + } + else if((CAN_FLAG & CAN_FLAGS_MSR) != (uint32_t)RESET) + { + /* Check the status of the specified CAN flag */ + if ((CANx->MSR & (CAN_FLAG & 0x000FFFFF)) != (uint32_t)RESET) + { + /* CAN_FLAG is set */ + bitstatus = SET; + } + else + { + /* CAN_FLAG is reset */ + bitstatus = RESET; + } + } + else if((CAN_FLAG & CAN_FLAGS_TSR) != (uint32_t)RESET) + { + /* Check the status of the specified CAN flag */ + if ((CANx->TSR & (CAN_FLAG & 0x000FFFFF)) != (uint32_t)RESET) + { + /* CAN_FLAG is set */ + bitstatus = SET; + } + else + { + /* CAN_FLAG is reset */ + bitstatus = RESET; + } + } + else if((CAN_FLAG & CAN_FLAGS_RF0R) != (uint32_t)RESET) + { + /* Check the status of the specified CAN flag */ + if ((CANx->RF0R & (CAN_FLAG & 0x000FFFFF)) != (uint32_t)RESET) + { + /* CAN_FLAG is set */ + bitstatus = SET; + } + else + { + /* CAN_FLAG is reset */ + bitstatus = RESET; + } + } + else /* If(CAN_FLAG & CAN_FLAGS_RF1R != (uint32_t)RESET) */ + { + /* Check the status of the specified CAN flag */ + if ((uint32_t)(CANx->RF1R & (CAN_FLAG & 0x000FFFFF)) != (uint32_t)RESET) + { + /* CAN_FLAG is set */ + bitstatus = SET; + } + else + { + /* CAN_FLAG is reset */ + bitstatus = RESET; + } + } + /* Return the CAN_FLAG status */ + return bitstatus; +} + +/** + * @brief Clears the CAN's pending flags. + * @param CANx: where x can be 1 or 2 to to select the CAN peripheral. + * @param CAN_FLAG: specifies the flag to clear. + * This parameter can be one of the following values: + * @arg CAN_FLAG_RQCP0: Request MailBox0 Flag + * @arg CAN_FLAG_RQCP1: Request MailBox1 Flag + * @arg CAN_FLAG_RQCP2: Request MailBox2 Flag + * @arg CAN_FLAG_FF0: FIFO 0 Full Flag + * @arg CAN_FLAG_FOV0: FIFO 0 Overrun Flag + * @arg CAN_FLAG_FF1: FIFO 1 Full Flag + * @arg CAN_FLAG_FOV1: FIFO 1 Overrun Flag + * @arg CAN_FLAG_WKU: Wake up Flag + * @arg CAN_FLAG_SLAK: Sleep acknowledge Flag + * @arg CAN_FLAG_LEC: Last error code Flag + * @retval None + */ +void CAN_ClearFlag(CAN_TypeDef* CANx, uint32_t CAN_FLAG) +{ + uint32_t flagtmp=0; + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_CLEAR_FLAG(CAN_FLAG)); + + if (CAN_FLAG == CAN_FLAG_LEC) /* ESR register */ + { + /* Clear the selected CAN flags */ + CANx->ESR = (uint32_t)RESET; + } + else /* MSR or TSR or RF0R or RF1R */ + { + flagtmp = CAN_FLAG & 0x000FFFFF; + + if ((CAN_FLAG & CAN_FLAGS_RF0R)!=(uint32_t)RESET) + { + /* Receive Flags */ + CANx->RF0R = (uint32_t)(flagtmp); + } + else if ((CAN_FLAG & CAN_FLAGS_RF1R)!=(uint32_t)RESET) + { + /* Receive Flags */ + CANx->RF1R = (uint32_t)(flagtmp); + } + else if ((CAN_FLAG & CAN_FLAGS_TSR)!=(uint32_t)RESET) + { + /* Transmit Flags */ + CANx->TSR = (uint32_t)(flagtmp); + } + else /* If((CAN_FLAG & CAN_FLAGS_MSR)!=(uint32_t)RESET) */ + { + /* Operating mode Flags */ + CANx->MSR = (uint32_t)(flagtmp); + } + } +} + +/** + * @brief Checks whether the specified CANx interrupt has occurred or not. + * @param CANx: where x can be 1 or 2 to to select the CAN peripheral. + * @param CAN_IT: specifies the CAN interrupt source to check. + * This parameter can be one of the following values: + * @arg CAN_IT_TME: Transmit mailbox empty Interrupt + * @arg CAN_IT_FMP0: FIFO 0 message pending Interrupt + * @arg CAN_IT_FF0: FIFO 0 full Interrupt + * @arg CAN_IT_FOV0: FIFO 0 overrun Interrupt + * @arg CAN_IT_FMP1: FIFO 1 message pending Interrupt + * @arg CAN_IT_FF1: FIFO 1 full Interrupt + * @arg CAN_IT_FOV1: FIFO 1 overrun Interrupt + * @arg CAN_IT_WKU: Wake-up Interrupt + * @arg CAN_IT_SLK: Sleep acknowledge Interrupt + * @arg CAN_IT_EWG: Error warning Interrupt + * @arg CAN_IT_EPV: Error passive Interrupt + * @arg CAN_IT_BOF: Bus-off Interrupt + * @arg CAN_IT_LEC: Last error code Interrupt + * @arg CAN_IT_ERR: Error Interrupt + * @retval The current state of CAN_IT (SET or RESET). + */ +ITStatus CAN_GetITStatus(CAN_TypeDef* CANx, uint32_t CAN_IT) +{ + ITStatus itstatus = RESET; + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_IT(CAN_IT)); + + /* check the interrupt enable bit */ + if((CANx->IER & CAN_IT) != RESET) + { + /* in case the Interrupt is enabled, .... */ + switch (CAN_IT) + { + case CAN_IT_TME: + /* Check CAN_TSR_RQCPx bits */ + itstatus = CheckITStatus(CANx->TSR, CAN_TSR_RQCP0|CAN_TSR_RQCP1|CAN_TSR_RQCP2); + break; + case CAN_IT_FMP0: + /* Check CAN_RF0R_FMP0 bit */ + itstatus = CheckITStatus(CANx->RF0R, CAN_RF0R_FMP0); + break; + case CAN_IT_FF0: + /* Check CAN_RF0R_FULL0 bit */ + itstatus = CheckITStatus(CANx->RF0R, CAN_RF0R_FULL0); + break; + case CAN_IT_FOV0: + /* Check CAN_RF0R_FOVR0 bit */ + itstatus = CheckITStatus(CANx->RF0R, CAN_RF0R_FOVR0); + break; + case CAN_IT_FMP1: + /* Check CAN_RF1R_FMP1 bit */ + itstatus = CheckITStatus(CANx->RF1R, CAN_RF1R_FMP1); + break; + case CAN_IT_FF1: + /* Check CAN_RF1R_FULL1 bit */ + itstatus = CheckITStatus(CANx->RF1R, CAN_RF1R_FULL1); + break; + case CAN_IT_FOV1: + /* Check CAN_RF1R_FOVR1 bit */ + itstatus = CheckITStatus(CANx->RF1R, CAN_RF1R_FOVR1); + break; + case CAN_IT_WKU: + /* Check CAN_MSR_WKUI bit */ + itstatus = CheckITStatus(CANx->MSR, CAN_MSR_WKUI); + break; + case CAN_IT_SLK: + /* Check CAN_MSR_SLAKI bit */ + itstatus = CheckITStatus(CANx->MSR, CAN_MSR_SLAKI); + break; + case CAN_IT_EWG: + /* Check CAN_ESR_EWGF bit */ + itstatus = CheckITStatus(CANx->ESR, CAN_ESR_EWGF); + break; + case CAN_IT_EPV: + /* Check CAN_ESR_EPVF bit */ + itstatus = CheckITStatus(CANx->ESR, CAN_ESR_EPVF); + break; + case CAN_IT_BOF: + /* Check CAN_ESR_BOFF bit */ + itstatus = CheckITStatus(CANx->ESR, CAN_ESR_BOFF); + break; + case CAN_IT_LEC: + /* Check CAN_ESR_LEC bit */ + itstatus = CheckITStatus(CANx->ESR, CAN_ESR_LEC); + break; + case CAN_IT_ERR: + /* Check CAN_MSR_ERRI bit */ + itstatus = CheckITStatus(CANx->MSR, CAN_MSR_ERRI); + break; + default: + /* in case of error, return RESET */ + itstatus = RESET; + break; + } + } + else + { + /* in case the Interrupt is not enabled, return RESET */ + itstatus = RESET; + } + + /* Return the CAN_IT status */ + return itstatus; +} + +/** + * @brief Clears the CANx's interrupt pending bits. + * @param CANx: where x can be 1 or 2 to to select the CAN peripheral. + * @param CAN_IT: specifies the interrupt pending bit to clear. + * This parameter can be one of the following values: + * @arg CAN_IT_TME: Transmit mailbox empty Interrupt + * @arg CAN_IT_FF0: FIFO 0 full Interrupt + * @arg CAN_IT_FOV0: FIFO 0 overrun Interrupt + * @arg CAN_IT_FF1: FIFO 1 full Interrupt + * @arg CAN_IT_FOV1: FIFO 1 overrun Interrupt + * @arg CAN_IT_WKU: Wake-up Interrupt + * @arg CAN_IT_SLK: Sleep acknowledge Interrupt + * @arg CAN_IT_EWG: Error warning Interrupt + * @arg CAN_IT_EPV: Error passive Interrupt + * @arg CAN_IT_BOF: Bus-off Interrupt + * @arg CAN_IT_LEC: Last error code Interrupt + * @arg CAN_IT_ERR: Error Interrupt + * @retval None + */ +void CAN_ClearITPendingBit(CAN_TypeDef* CANx, uint32_t CAN_IT) +{ + /* Check the parameters */ + assert_param(IS_CAN_ALL_PERIPH(CANx)); + assert_param(IS_CAN_CLEAR_IT(CAN_IT)); + + switch (CAN_IT) + { + case CAN_IT_TME: + /* Clear CAN_TSR_RQCPx (rc_w1)*/ + CANx->TSR = CAN_TSR_RQCP0|CAN_TSR_RQCP1|CAN_TSR_RQCP2; + break; + case CAN_IT_FF0: + /* Clear CAN_RF0R_FULL0 (rc_w1)*/ + CANx->RF0R = CAN_RF0R_FULL0; + break; + case CAN_IT_FOV0: + /* Clear CAN_RF0R_FOVR0 (rc_w1)*/ + CANx->RF0R = CAN_RF0R_FOVR0; + break; + case CAN_IT_FF1: + /* Clear CAN_RF1R_FULL1 (rc_w1)*/ + CANx->RF1R = CAN_RF1R_FULL1; + break; + case CAN_IT_FOV1: + /* Clear CAN_RF1R_FOVR1 (rc_w1)*/ + CANx->RF1R = CAN_RF1R_FOVR1; + break; + case CAN_IT_WKU: + /* Clear CAN_MSR_WKUI (rc_w1)*/ + CANx->MSR = CAN_MSR_WKUI; + break; + case CAN_IT_SLK: + /* Clear CAN_MSR_SLAKI (rc_w1)*/ + CANx->MSR = CAN_MSR_SLAKI; + break; + case CAN_IT_EWG: + /* Clear CAN_MSR_ERRI (rc_w1) */ + CANx->MSR = CAN_MSR_ERRI; + /* @note the corresponding Flag is cleared by hardware depending on the CAN Bus status*/ + break; + case CAN_IT_EPV: + /* Clear CAN_MSR_ERRI (rc_w1) */ + CANx->MSR = CAN_MSR_ERRI; + /* @note the corresponding Flag is cleared by hardware depending on the CAN Bus status*/ + break; + case CAN_IT_BOF: + /* Clear CAN_MSR_ERRI (rc_w1) */ + CANx->MSR = CAN_MSR_ERRI; + /* @note the corresponding Flag is cleared by hardware depending on the CAN Bus status*/ + break; + case CAN_IT_LEC: + /* Clear LEC bits */ + CANx->ESR = RESET; + /* Clear CAN_MSR_ERRI (rc_w1) */ + CANx->MSR = CAN_MSR_ERRI; + break; + case CAN_IT_ERR: + /*Clear LEC bits */ + CANx->ESR = RESET; + /* Clear CAN_MSR_ERRI (rc_w1) */ + CANx->MSR = CAN_MSR_ERRI; + /* @note BOFF, EPVF and EWGF Flags are cleared by hardware depending on the CAN Bus status*/ + break; + default: + break; + } +} + /** + * @} + */ + +/** + * @brief Checks whether the CAN interrupt has occurred or not. + * @param CAN_Reg: specifies the CAN interrupt register to check. + * @param It_Bit: specifies the interrupt source bit to check. + * @retval The new state of the CAN Interrupt (SET or RESET). + */ +static ITStatus CheckITStatus(uint32_t CAN_Reg, uint32_t It_Bit) +{ + ITStatus pendingbitstatus = RESET; + + if ((CAN_Reg & It_Bit) != (uint32_t)RESET) + { + /* CAN_IT is set */ + pendingbitstatus = SET; + } + else + { + /* CAN_IT is reset */ + pendingbitstatus = RESET; + } + return pendingbitstatus; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_cec.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_cec.c new file mode 100644 index 00000000..f49e8b9d --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_cec.c @@ -0,0 +1,607 @@ +/** + ****************************************************************************** + * @file stm32f0xx_cec.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Consumer Electronics Control (CEC) peripheral + * applicable only on STM32F051, STM32F042 and STM32F072 devices: + * + Initialization and Configuration + * + Data transfers functions + * + Interrupts and flags management + * + * @verbatim + ============================================================================== + ##### CEC features ##### + ============================================================================== + [..] This device provides some features: + (#) Supports HDMI-CEC specification 1.4. + (#) Supports two source clocks(HSI/244 or LSE). + (#) Works in stop mode(without APB clock, but with CEC clock 32KHz). + It can genarate an interrupt in the CEC clock domain that the CPU + wakes up from the low power mode. + (#) Configurable Signal Free Time before of transmission start. The + number of nominal data bit periods waited before transmission can be + ruled by Hardware or Software. + (#) Configurable Peripheral Address (multi-addressing configuration). + (#) Supports listen mode.The CEC Messages addressed to different destination + can be received without interfering with CEC bus when Listen mode option is enabled. + (#) Configurable Rx-Tolerance(Standard and Extended tolerance margin). + (#) Error detection with configurable error bit generation. + (#) Arbitration lost error in the case of two CEC devices starting at the same time. + + ##### How to use this driver ##### + ============================================================================== + [..] This driver provides functions to configure and program the CEC device, + follow steps below: + (#) The source clock can be configured using: + (++) RCC_CECCLKConfig(RCC_CECCLK_HSI_Div244) for HSI(Default) + (++) RCC_CECCLKConfig(RCC_CECCLK_LSE) for LSE. + (#) Enable CEC peripheral clock using RCC_APBPeriphClockCmd(RCC_APBPeriph_CEC, ENABLE). + (#) Peripherals alternate function. + (++) Connect the pin to the desired peripherals' Alternate Function (AF) using + GPIO_PinAFConfig() function. + (++) Configure the desired pin in alternate function by: + GPIO_InitStruct->GPIO_Mode = GPIO_Mode_AF. + (++) Select the type open-drain and output speed via GPIO_OType + and GPIO_Speed members. + (++) Call GPIO_Init() function. + (#) Configure the Signal Free Time, Rx Tolerance, Stop reception generation + and Bit error generation using the CEC_Init() function. + The function CEC_Init() must be called when the CEC peripheral is disabled. + (#) Configure the CEC own address by calling the fuction CEC_OwnAddressConfig(). + (#) Optionally, you can configure the Listen mode using the function CEC_ListenModeCmd(). + (#) Enable the NVIC and the corresponding interrupt using the function + CEC_ITConfig() if you need to use interrupt mode. + CEC_ITConfig() must be called before enabling the CEC peripheral. + (#) Enable the CEC using the CEC_Cmd() function. + (#) Charge the first data byte in the TXDR register using CEC_SendDataByte(). + (#) Enable the transmission of the Byte of a CEC message using CEC_StartOfMessage() + (#) Transmit single data through the CEC peripheral using CEC_SendDataByte() + and Receive the last transmitted byte using CEC_ReceiveDataByte(). + (#) Enable the CEC_EndOfMessage() in order to indicate the last byte of the message. + [..] + (@) If the listen mode is enabled, Stop reception generation and Bit error generation + must be in reset state. + (@) If the CEC message consists of only 1 byte, the function CEC_EndOfMessage() + must be called before CEC_StartOfMessage(). + + @endverbatim + * + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_cec.h" +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup CEC + * @brief CEC driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +#define BROADCAST_ADDRESS ((uint32_t)0x0000F) +#define CFGR_CLEAR_MASK ((uint32_t)0x7000FE00) /* CFGR register Mask */ + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup CEC_Private_Functions + * @{ + */ + +/** @defgroup CEC_Group1 Initialization and Configuration functions + * @brief Initialization and Configuration functions + * +@verbatim + =============================================================================== + ##### Initialization and Configuration functions ##### + =============================================================================== + [..] This section provides functions allowing to initialize: + (+) CEC own addresses + (+) CEC Signal Free Time + (+) CEC Rx Tolerance + (+) CEC Stop Reception + (+) CEC Bit Rising Error + (+) CEC Long Bit Period Error + [..] This section provides also a function to configure the CEC peripheral in Listen Mode. + Messages addressed to different destination can be received when Listen mode is + enabled without interfering with CEC bus. +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the CEC peripheral registers to their default reset values. + * @param None + * @retval None + */ +void CEC_DeInit(void) +{ + RCC_APB1PeriphResetCmd(RCC_APB1Periph_CEC, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_CEC, DISABLE); +} + +/** + * @brief Initializes the CEC peripheral according to the specified parameters + * in the CEC_InitStruct. + * @note The CEC parameters must be configured before enabling the CEC peripheral. + * @param CEC_InitStruct: pointer to an CEC_InitTypeDef structure that contains + * the configuration information for the specified CEC peripheral. + * @retval None + */ +void CEC_Init(CEC_InitTypeDef* CEC_InitStruct) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_CEC_SIGNAL_FREE_TIME(CEC_InitStruct->CEC_SignalFreeTime)); + assert_param(IS_CEC_RX_TOLERANCE(CEC_InitStruct->CEC_RxTolerance)); + assert_param(IS_CEC_STOP_RECEPTION(CEC_InitStruct->CEC_StopReception)); + assert_param(IS_CEC_BIT_RISING_ERROR(CEC_InitStruct->CEC_BitRisingError)); + assert_param(IS_CEC_LONG_BIT_PERIOD_ERROR(CEC_InitStruct->CEC_LongBitPeriodError)); + assert_param(IS_CEC_BDR_NO_GEN_ERROR(CEC_InitStruct->CEC_BRDNoGen)); + assert_param(IS_CEC_SFT_OPTION(CEC_InitStruct->CEC_SFTOption)); + + /* Get the CEC CFGR value */ + tmpreg = CEC->CFGR; + + /* Clear CFGR bits */ + tmpreg &= CFGR_CLEAR_MASK; + + /* Configure the CEC peripheral */ + tmpreg |= (CEC_InitStruct->CEC_SignalFreeTime | CEC_InitStruct->CEC_RxTolerance | + CEC_InitStruct->CEC_StopReception | CEC_InitStruct->CEC_BitRisingError | + CEC_InitStruct->CEC_LongBitPeriodError| CEC_InitStruct->CEC_BRDNoGen | + CEC_InitStruct->CEC_SFTOption); + + /* Write to CEC CFGR register */ + CEC->CFGR = tmpreg; +} + +/** + * @brief Fills each CEC_InitStruct member with its default value. + * @param CEC_InitStruct: pointer to a CEC_InitTypeDef structure which will + * be initialized. + * @retval None + */ +void CEC_StructInit(CEC_InitTypeDef* CEC_InitStruct) +{ + CEC_InitStruct->CEC_SignalFreeTime = CEC_SignalFreeTime_Standard; + CEC_InitStruct->CEC_RxTolerance = CEC_RxTolerance_Standard; + CEC_InitStruct->CEC_StopReception = CEC_StopReception_Off; + CEC_InitStruct->CEC_BitRisingError = CEC_BitRisingError_Off; + CEC_InitStruct->CEC_LongBitPeriodError = CEC_LongBitPeriodError_Off; + CEC_InitStruct->CEC_BRDNoGen = CEC_BRDNoGen_Off; + CEC_InitStruct->CEC_SFTOption = CEC_SFTOption_Off; +} + +/** + * @brief Enables or disables the CEC peripheral. + * @param NewState: new state of the CEC peripheral. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void CEC_Cmd(FunctionalState NewState) +{ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the CEC peripheral */ + CEC->CR |= CEC_CR_CECEN; + } + else + { + /* Disable the CEC peripheral */ + CEC->CR &= ~CEC_CR_CECEN; + } +} + +/** + * @brief Enables or disables the CEC Listen Mode. + * @param NewState: new state of the Listen Mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void CEC_ListenModeCmd(FunctionalState NewState) +{ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the Listen Mode */ + CEC->CFGR |= CEC_CFGR_LSTN; + } + else + { + /* Disable the Listen Mode */ + CEC->CFGR &= ~CEC_CFGR_LSTN; + } +} + +/** + * @brief Defines the Own Address of the CEC device. + * @param CEC_OwnAddress: The CEC own address. + * @retval None + */ +void CEC_OwnAddressConfig(uint8_t CEC_OwnAddress) +{ + uint32_t tmp =0x00; + /* Check the parameters */ + assert_param(IS_CEC_ADDRESS(CEC_OwnAddress)); + tmp = 1 <<(CEC_OwnAddress + 16); + /* Set the CEC own address */ + CEC->CFGR |= tmp; +} + +/** + * @brief Clears the Own Address of the CEC device. + * @param CEC_OwnAddress: The CEC own address. + * @retval None + */ +void CEC_OwnAddressClear(void) +{ + /* Set the CEC own address */ + CEC->CFGR = 0x0; +} + +/** + * @} + */ + +/** @defgroup CEC_Group2 Data transfers functions + * @brief Data transfers functions + * +@verbatim + =============================================================================== + ##### Data transfers functions ##### + =============================================================================== + [..] This section provides functions allowing the CEC data transfers.The read + access of the CEC_RXDR register can be done using the CEC_ReceiveData()function + and returns the Rx buffered value. Whereas a write access to the CEC_TXDR can be + done using CEC_SendData() function. +@endverbatim + * @{ + */ + +/** + * @brief Transmits single data through the CEC peripheral. + * @param Data: the data to transmit. + * @retval None + */ +void CEC_SendData(uint8_t Data) +{ + /* Transmit Data */ + CEC->TXDR = Data; +} + +/** + * @brief Returns the most recent received data by the CEC peripheral. + * @param None + * @retval The received data. + */ +uint8_t CEC_ReceiveData(void) +{ + /* Receive Data */ + return (uint8_t)(CEC->RXDR); +} + +/** + * @brief Starts a new message. + * @param None + * @retval None + */ +void CEC_StartOfMessage(void) +{ + /* Starts of new message */ + CEC->CR |= CEC_CR_TXSOM; +} + +/** + * @brief Transmits message with an EOM bit. + * @param None + * @retval None + */ +void CEC_EndOfMessage(void) +{ + /* The data byte will be transmitted with an EOM bit */ + CEC->CR |= CEC_CR_TXEOM; +} + +/** + * @} + */ + +/** @defgroup CEC_Group3 Interrupts and flags management functions + * @brief Interrupts and flags management functions +* +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== + [..] This section provides functions allowing to configure the CEC Interrupts + sources and check or clear the flags or pending bits status. + [..] The user should identify which mode will be used in his application to manage + the communication: Polling mode or Interrupt mode. + + [..] In polling mode, the CEC can be managed by the following flags: + (+) CEC_FLAG_TXACKE : to indicate a missing acknowledge in transmission mode. + (+) CEC_FLAG_TXERR : to indicate an error occurs during transmission mode. + The initiator detects low impedance in the CEC line. + (+) CEC_FLAG_TXUDR : to indicate if an underrun error occurs in transmission mode. + The transmission is enabled while the software has not yet + loaded any value into the TXDR register. + (+) CEC_FLAG_TXEND : to indicate the end of successful transmission. + (+) CEC_FLAG_TXBR : to indicate the next transmission data has to be written to TXDR. + (+) CEC_FLAG_ARBLST : to indicate arbitration lost in the case of two CEC devices + starting at the same time. + (+) CEC_FLAG_RXACKE : to indicate a missing acknowledge in receive mode. + (+) CEC_FLAG_LBPE : to indicate a long bit period error generated during receive mode. + (+) CEC_FLAG_SBPE : to indicate a short bit period error generated during receive mode. + (+) CEC_FLAG_BRE : to indicate a bit rising error generated during receive mode. + (+) CEC_FLAG_RXOVR : to indicate if an overrun error occur while receiving a CEC message. + A byte is not yet received while a new byte is stored in the RXDR register. + (+) CEC_FLAG_RXEND : to indicate the end Of reception + (+) CEC_FLAG_RXBR : to indicate a new byte has been received from the CEC line and + stored into the RXDR buffer. + [..] + (@)In this Mode, it is advised to use the following functions: + FlagStatus CEC_GetFlagStatus(uint16_t CEC_FLAG); + void CEC_ClearFlag(uint16_t CEC_FLAG); + + [..] In Interrupt mode, the CEC can be managed by the following interrupt sources: + (+) CEC_IT_TXACKE : to indicate a TX Missing acknowledge + (+) CEC_IT_TXACKE : to indicate a missing acknowledge in transmission mode. + (+) CEC_IT_TXERR : to indicate an error occurs during transmission mode. + The initiator detects low impedance in the CEC line. + (+) CEC_IT_TXUDR : to indicate if an underrun error occurs in transmission mode. + The transmission is enabled while the software has not yet + loaded any value into the TXDR register. + (+) CEC_IT_TXEND : to indicate the end of successful transmission. + (+) CEC_IT_TXBR : to indicate the next transmission data has to be written to TXDR register. + (+) CEC_IT_ARBLST : to indicate arbitration lost in the case of two CEC devices + starting at the same time. + (+) CEC_IT_RXACKE : to indicate a missing acknowledge in receive mode. + (+) CEC_IT_LBPE : to indicate a long bit period error generated during receive mode. + (+) CEC_IT_SBPE : to indicate a short bit period error generated during receive mode. + (+) CEC_IT_BRE : to indicate a bit rising error generated during receive mode. + (+) CEC_IT_RXOVR : to indicate if an overrun error occur while receiving a CEC message. + A byte is not yet received while a new byte is stored in the RXDR register. + (+) CEC_IT_RXEND : to indicate the end Of reception + (+) CEC_IT_RXBR : to indicate a new byte has been received from the CEC line and + stored into the RXDR buffer. + [..] + (@)In this Mode it is advised to use the following functions: + void CEC_ITConfig( uint16_t CEC_IT, FunctionalState NewState); + ITStatus CEC_GetITStatus(uint16_t CEC_IT); + void CEC_ClearITPendingBit(uint16_t CEC_IT); + + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the selected CEC interrupts. + * @param CEC_IT: specifies the CEC interrupt source to be enabled. + * This parameter can be any combination of the following values: + * @arg CEC_IT_TXACKE: Tx Missing acknowledge Error + * @arg CEC_IT_TXERR: Tx Error. + * @arg CEC_IT_TXUDR: Tx-Buffer Underrun. + * @arg CEC_IT_TXEND: End of Transmission (successful transmission of the last byte). + * @arg CEC_IT_TXBR: Tx-Byte Request. + * @arg CEC_IT_ARBLST: Arbitration Lost + * @arg CEC_IT_RXACKE: Rx-Missing Acknowledge + * @arg CEC_IT_LBPE: Rx Long period Error + * @arg CEC_IT_SBPE: Rx Short period Error + * @arg CEC_IT_BRE: Rx Bit Rising Error + * @arg CEC_IT_RXOVR: Rx Overrun. + * @arg CEC_IT_RXEND: End Of Reception + * @arg CEC_IT_RXBR: Rx-Byte Received + * @param NewState: new state of the selected CEC interrupts. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void CEC_ITConfig(uint16_t CEC_IT, FunctionalState NewState) +{ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + assert_param(IS_CEC_IT(CEC_IT)); + + if (NewState != DISABLE) + { + /* Enable the selected CEC interrupt */ + CEC->IER |= CEC_IT; + } + else + { + CEC_IT =~CEC_IT; + /* Disable the selected CEC interrupt */ + CEC->IER &= CEC_IT; + } +} + +/** + * @brief Gets the CEC flag status. + * @param CEC_FLAG: specifies the CEC flag to check. + * This parameter can be one of the following values: + * @arg CEC_FLAG_TXACKE: Tx Missing acknowledge Error + * @arg CEC_FLAG_TXERR: Tx Error. + * @arg CEC_FLAG_TXUDR: Tx-Buffer Underrun. + * @arg CEC_FLAG_TXEND: End of transmission (successful transmission of the last byte). + * @arg CEC_FLAG_TXBR: Tx-Byte Request. + * @arg CEC_FLAG_ARBLST: Arbitration Lost + * @arg CEC_FLAG_RXACKE: Rx-Missing Acknowledge + * @arg CEC_FLAG_LBPE: Rx Long period Error + * @arg CEC_FLAG_SBPE: Rx Short period Error + * @arg CEC_FLAG_BRE: Rx Bit Rissing Error + * @arg CEC_FLAG_RXOVR: Rx Overrun. + * @arg CEC_FLAG_RXEND: End Of Reception. + * @arg CEC_FLAG_RXBR: Rx-Byte Received. + * @retval The new state of CEC_FLAG (SET or RESET) + */ +FlagStatus CEC_GetFlagStatus(uint16_t CEC_FLAG) +{ + FlagStatus bitstatus = RESET; + + assert_param(IS_CEC_GET_FLAG(CEC_FLAG)); + + /* Check the status of the specified CEC flag */ + if ((CEC->ISR & CEC_FLAG) != (uint16_t)RESET) + { + /* CEC flag is set */ + bitstatus = SET; + } + else + { + /* CEC flag is reset */ + bitstatus = RESET; + } + + /* Return the CEC flag status */ + return bitstatus; +} + +/** + * @brief Clears the CEC's pending flags. + * @param CEC_FLAG: specifies the flag to clear. + * This parameter can be any combination of the following values: + * @arg CEC_FLAG_TXACKE: Tx Missing acknowledge Error + * @arg CEC_FLAG_TXERR: Tx Error + * @arg CEC_FLAG_TXUDR: Tx-Buffer Underrun + * @arg CEC_FLAG_TXEND: End of transmission (successful transmission of the last byte). + * @arg CEC_FLAG_TXBR: Tx-Byte Request + * @arg CEC_FLAG_ARBLST: Arbitration Lost + * @arg CEC_FLAG_RXACKE: Rx Missing Acknowledge + * @arg CEC_FLAG_LBPE: Rx Long period Error + * @arg CEC_FLAG_SBPE: Rx Short period Error + * @arg CEC_FLAG_BRE: Rx Bit Rising Error + * @arg CEC_FLAG_RXOVR: Rx Overrun + * @arg CEC_FLAG_RXEND: End Of Reception + * @arg CEC_FLAG_RXBR: Rx-Byte Received + * @retval None + */ +void CEC_ClearFlag(uint32_t CEC_FLAG) +{ + assert_param(IS_CEC_CLEAR_FLAG(CEC_FLAG)); + + /* Clear the selected CEC flag */ + CEC->ISR = CEC_FLAG; +} + +/** + * @brief Checks whether the specified CEC interrupt has occurred or not. + * @param CEC_IT: specifies the CEC interrupt source to check. + * This parameter can be one of the following values: + * @arg CEC_IT_TXACKE: Tx Missing acknowledge Error + * @arg CEC_IT_TXERR: Tx Error. + * @arg CEC_IT_TXUDR: Tx-Buffer Underrun. + * @arg CEC_IT_TXEND: End of transmission (successful transmission of the last byte). + * @arg CEC_IT_TXBR: Tx-Byte Request. + * @arg CEC_IT_ARBLST: Arbitration Lost. + * @arg CEC_IT_RXACKE: Rx-Missing Acknowledge. + * @arg CEC_IT_LBPE: Rx Long period Error. + * @arg CEC_IT_SBPE: Rx Short period Error. + * @arg CEC_IT_BRE: Rx Bit Rising Error. + * @arg CEC_IT_RXOVR: Rx Overrun. + * @arg CEC_IT_RXEND: End Of Reception. + * @arg CEC_IT_RXBR: Rx-Byte Received + * @retval The new state of CEC_IT (SET or RESET). + */ +ITStatus CEC_GetITStatus(uint16_t CEC_IT) +{ + ITStatus bitstatus = RESET; + uint32_t enablestatus = 0; + + /* Check the parameters */ + assert_param(IS_CEC_GET_IT(CEC_IT)); + + /* Get the CEC IT enable bit status */ + enablestatus = (CEC->IER & CEC_IT); + + /* Check the status of the specified CEC interrupt */ + if (((CEC->ISR & CEC_IT) != (uint32_t)RESET) && enablestatus) + { + /* CEC interrupt is set */ + bitstatus = SET; + } + else + { + /* CEC interrupt is reset */ + bitstatus = RESET; + } + + /* Return the CEC interrupt status */ + return bitstatus; +} + +/** + * @brief Clears the CEC's interrupt pending bits. + * @param CEC_IT: specifies the CEC interrupt pending bit to clear. + * This parameter can be any combination of the following values: + * @arg CEC_IT_TXACKE: Tx Missing acknowledge Error + * @arg CEC_IT_TXERR: Tx Error + * @arg CEC_IT_TXUDR: Tx-Buffer Underrun + * @arg CEC_IT_TXEND: End of Transmission + * @arg CEC_IT_TXBR: Tx-Byte Request + * @arg CEC_IT_ARBLST: Arbitration Lost + * @arg CEC_IT_RXACKE: Rx-Missing Acknowledge + * @arg CEC_IT_LBPE: Rx Long period Error + * @arg CEC_IT_SBPE: Rx Short period Error + * @arg CEC_IT_BRE: Rx Bit Rising Error + * @arg CEC_IT_RXOVR: Rx Overrun + * @arg CEC_IT_RXEND: End Of Reception + * @arg CEC_IT_RXBR: Rx-Byte Received + * @retval None + */ +void CEC_ClearITPendingBit(uint16_t CEC_IT) +{ + assert_param(IS_CEC_IT(CEC_IT)); + + /* Clear the selected CEC interrupt pending bits */ + CEC->ISR = CEC_IT; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_comp.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_comp.c new file mode 100644 index 00000000..be7249e3 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_comp.c @@ -0,0 +1,408 @@ +/** + ****************************************************************************** + * @file stm32f0xx_comp.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the comparators (COMP1 and COMP2) peripheral + * applicable only on STM32F051 and STM32F072 devices: + * + Comparators configuration + * + Window mode control + * + * @verbatim + * + =============================================================================== + ##### How to use this driver ##### + =============================================================================== + [..] + + The device integrates two analog comparators COMP1 and COMP2: + (+) The non inverting input is set to PA1 for COMP1 and to PA3 + for COMP2. + + (+) The inverting input can be selected among: DAC1_OUT, DAC2_OUT + 1/4 VREFINT, 1/2 VERFINT, 3/4 VREFINT, VREFINT, + I/O (PA0 for COMP1 and PA2 for COMP2) + + (+) The COMP output is internally is available using COMP_GetOutputLevel() + and can be set on GPIO pins: PA0, PA6, PA11 for COMP1 + and PA2, PA7, PA12 for COMP2 + + (+) The COMP output can be redirected to embedded timers (TIM1, TIM2 + and TIM3) + + (+) The two comparators COMP1 and COMP2 can be combined in window + mode and only COMP1 non inverting (PA1) can be used as non- + inverting input. + + (+) The two comparators COMP1 and COMP2 have interrupt capability + with wake-up from Sleep and Stop modes (through the EXTI controller). + COMP1 and COMP2 outputs are internally connected to EXTI Line 21 + and EXTI Line 22 respectively. + + + ##### How to configure the comparator ##### + =============================================================================== + [..] + This driver provides functions to configure and program the Comparators + of all STM32F0xx devices. + + [..] To use the comparator, perform the following steps: + + (#) Enable the SYSCFG APB clock to get write access to comparator + register using RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE); + + (#) Configure the comparator input in analog mode using GPIO_Init() + + (#) Configure the comparator output in alternate function mode + using GPIO_Init() and use GPIO_PinAFConfig() function to map the + comparator output to the GPIO pin + + (#) Configure the comparator using COMP_Init() function: + (++) Select the inverting input + (++) Select the output polarity + (++) Select the output redirection + (++) Select the hysteresis level + (++) Select the power mode + + (#) Enable the comparator using COMP_Cmd() function + + (#) If required enable the COMP interrupt by configuring and enabling + EXTI line in Interrupt mode and selecting the desired sensitivity + level using EXTI_Init() function. After that enable the comparator + interrupt vector using NVIC_Init() function. + + @endverbatim + * + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_comp.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup COMP + * @brief COMP driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* CSR register Mask */ +#define COMP_CSR_CLEAR_MASK ((uint32_t)0x00003FFE) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup COMP_Private_Functions + * @{ + */ + +/** @defgroup COMP_Group1 Initialization and Configuration functions + * @brief Initialization and Configuration functions + * +@verbatim + =============================================================================== + ##### Initialization and Configuration functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes COMP peripheral registers to their default reset values. + * @note Deinitialization can't be performed if the COMP configuration is locked. + * To unlock the configuration, perform a system reset. + * @param None + * @retval None + */ +void COMP_DeInit(void) +{ + COMP->CSR = ((uint32_t)0x00000000); /*!< Set COMP_CSR register to reset value */ +} + +/** + * @brief Initializes the COMP peripheral according to the specified parameters + * in COMP_InitStruct + * @note If the selected comparator is locked, initialization can't be performed. + * To unlock the configuration, perform a system reset. + * @note By default, PA1 is selected as COMP1 non inverting input. + * To use PA4 as COMP1 non inverting input call COMP_SwitchCmd() after COMP_Init() + * @param COMP_Selection: the selected comparator. + * This parameter can be one of the following values: + * @arg COMP_Selection_COMP1: COMP1 selected + * @arg COMP_Selection_COMP2: COMP2 selected + * @param COMP_InitStruct: pointer to an COMP_InitTypeDef structure that contains + * the configuration information for the specified COMP peripheral. + * @retval None + */ +void COMP_Init(uint32_t COMP_Selection, COMP_InitTypeDef* COMP_InitStruct) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_COMP_ALL_PERIPH(COMP_Selection)); + assert_param(IS_COMP_INVERTING_INPUT(COMP_InitStruct->COMP_InvertingInput)); + assert_param(IS_COMP_OUTPUT(COMP_InitStruct->COMP_Output)); + assert_param(IS_COMP_OUTPUT_POL(COMP_InitStruct->COMP_OutputPol)); + assert_param(IS_COMP_HYSTERESIS(COMP_InitStruct->COMP_Hysteresis)); + assert_param(IS_COMP_MODE(COMP_InitStruct->COMP_Mode)); + + /*!< Get the COMP_CSR register value */ + tmpreg = COMP->CSR; + + /*!< Clear the COMP1SW1, COMPx_IN_SEL, COMPx_OUT_TIM_SEL, COMPx_POL, COMPx_HYST and COMPx_PWR_MODE bits */ + tmpreg &= (uint32_t) ~(COMP_CSR_CLEAR_MASK<COMP_InvertingInput value */ + /*!< Set COMPxOUTSEL bits according to COMP_InitStruct->COMP_Output value */ + /*!< Set COMPxPOL bit according to COMP_InitStruct->COMP_OutputPol value */ + /*!< Set COMPxHYST bits according to COMP_InitStruct->COMP_Hysteresis value */ + /*!< Set COMPxMODE bits according to COMP_InitStruct->COMP_Mode value */ + tmpreg |= (uint32_t)((COMP_InitStruct->COMP_InvertingInput | COMP_InitStruct->COMP_Output | + COMP_InitStruct->COMP_OutputPol | COMP_InitStruct->COMP_Hysteresis | + COMP_InitStruct->COMP_Mode)<CSR = tmpreg; +} + +/** + * @brief Fills each COMP_InitStruct member with its default value. + * @param COMP_InitStruct: pointer to an COMP_InitTypeDef structure which will + * be initialized. + * @retval None + */ +void COMP_StructInit(COMP_InitTypeDef* COMP_InitStruct) +{ + COMP_InitStruct->COMP_InvertingInput = COMP_InvertingInput_1_4VREFINT; + COMP_InitStruct->COMP_Output = COMP_Output_None; + COMP_InitStruct->COMP_OutputPol = COMP_OutputPol_NonInverted; + COMP_InitStruct->COMP_Hysteresis = COMP_Hysteresis_No; + COMP_InitStruct->COMP_Mode = COMP_Mode_UltraLowPower; +} + +/** + * @brief Enable or disable the COMP peripheral. + * @note If the selected comparator is locked, enable/disable can't be performed. + * To unlock the configuration, perform a system reset. + * @param COMP_Selection: the selected comparator. + * This parameter can be one of the following values: + * @arg COMP_Selection_COMP1: COMP1 selected + * @arg COMP_Selection_COMP2: COMP2 selected + * @param NewState: new state of the COMP peripheral. + * This parameter can be: ENABLE or DISABLE. + * @note When enabled, the comparator compares the non inverting input with + * the inverting input and the comparison result is available on comparator output. + * @note When disabled, the comparator doesn't perform comparison and the + * output level is low. + * @retval None + */ +void COMP_Cmd(uint32_t COMP_Selection, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_COMP_ALL_PERIPH(COMP_Selection)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected COMP peripheral */ + COMP->CSR |= (uint32_t) (1<CSR &= (uint32_t)(~((uint32_t)1<CSR |= (uint32_t) (COMP_CSR_COMP1SW1); + } + else + { + /* Open SW1 switch */ + COMP->CSR &= (uint32_t)(~COMP_CSR_COMP1SW1); + } +} + +/** + * @brief Return the output level (high or low) of the selected comparator. + * @note The output level depends on the selected polarity. + * @note If the polarity is not inverted: + * - Comparator output is low when the non-inverting input is at a lower + * voltage than the inverting input + * - Comparator output is high when the non-inverting input is at a higher + * voltage than the inverting input + * @note If the polarity is inverted: + * - Comparator output is high when the non-inverting input is at a lower + * voltage than the inverting input + * - Comparator output is low when the non-inverting input is at a higher + * voltage than the inverting input + * @param COMP_Selection: the selected comparator. + * This parameter can be one of the following values: + * @arg COMP_Selection_COMP1: COMP1 selected + * @arg COMP_Selection_COMP2: COMP2 selected + * @retval Returns the selected comparator output level: low or high. + * + */ +uint32_t COMP_GetOutputLevel(uint32_t COMP_Selection) +{ + uint32_t compout = 0x0; + + /* Check the parameters */ + assert_param(IS_COMP_ALL_PERIPH(COMP_Selection)); + + /* Check if selected comparator output is high */ + if ((COMP->CSR & (COMP_CSR_COMP1OUT<CSR |= (uint32_t) COMP_CSR_WNDWEN; + } + else + { + /* Disable the window mode */ + COMP->CSR &= (uint32_t)(~COMP_CSR_WNDWEN); + } +} + +/** + * @} + */ + +/** @defgroup COMP_Group3 COMP configuration locking function + * @brief COMP1 and COMP2 configuration locking function + * COMP1 and COMP2 configuration can be locked each separately. + * Unlocking is performed by system reset. + * +@verbatim + =============================================================================== + ##### Configuration Lock function ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Lock the selected comparator (COMP1/COMP2) configuration. + * @note Locking the configuration means that all control bits are read-only. + * To unlock the comparator configuration, perform a system reset. + * @param COMP_Selection: selects the comparator to be locked + * This parameter can be a value of the following values: + * @arg COMP_Selection_COMP1: COMP1 configuration is locked. + * @arg COMP_Selection_COMP2: COMP2 configuration is locked. + * @retval None + */ +void COMP_LockConfig(uint32_t COMP_Selection) +{ + /* Check the parameter */ + assert_param(IS_COMP_ALL_PERIPH(COMP_Selection)); + + /* Set the lock bit corresponding to selected comparator */ + COMP->CSR |= (uint32_t) (COMP_CSR_COMP1LOCK<
      © COPYRIGHT 2014 STMicroelectronics
      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_crc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup CRC + * @brief CRC driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup CRC_Private_Functions + * @{ + */ + +/** @defgroup CRC_Group1 Configuration of the CRC computation unit functions + * @brief Configuration of the CRC computation unit functions + * +@verbatim + =============================================================================== + ##### CRC configuration functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes CRC peripheral registers to their default reset values. + * @param None + * @retval None + */ +void CRC_DeInit(void) +{ + /* Set DR register to reset value */ + CRC->DR = 0xFFFFFFFF; + + /* Set the POL register to the reset value: 0x04C11DB7 */ + CRC->POL = 0x04C11DB7; + + /* Reset IDR register */ + CRC->IDR = 0x00; + + /* Set INIT register to reset value */ + CRC->INIT = 0xFFFFFFFF; + + /* Reset the CRC calculation unit */ + CRC->CR = CRC_CR_RESET; +} + +/** + * @brief Resets the CRC calculation unit and sets INIT register content in DR register. + * @param None + * @retval None + */ +void CRC_ResetDR(void) +{ + /* Reset CRC generator */ + CRC->CR |= CRC_CR_RESET; +} + +/** + * @brief Selects the polynomial size. This function is only applicable for + * STM32F072 devices. + * @param CRC_PolSize: Specifies the polynomial size. + * This parameter can be: + * @arg CRC_PolSize_7: 7-bit polynomial for CRC calculation + * @arg CRC_PolSize_8: 8-bit polynomial for CRC calculation + * @arg CRC_PolSize_16: 16-bit polynomial for CRC calculation + * @arg CRC_PolSize_32: 32-bit polynomial for CRC calculation + * @retval None + */ +void CRC_PolynomialSizeSelect(uint32_t CRC_PolSize) +{ + uint32_t tmpcr = 0; + + /* Check the parameter */ + assert_param(IS_CRC_POL_SIZE(CRC_PolSize)); + + /* Get CR register value */ + tmpcr = CRC->CR; + + /* Reset POL_SIZE bits */ + tmpcr &= (uint32_t)~((uint32_t)CRC_CR_POLSIZE); + /* Set the polynomial size */ + tmpcr |= (uint32_t)CRC_PolSize; + + /* Write to CR register */ + CRC->CR = (uint32_t)tmpcr; +} + +/** + * @brief Selects the reverse operation to be performed on input data. + * @param CRC_ReverseInputData: Specifies the reverse operation on input data. + * This parameter can be: + * @arg CRC_ReverseInputData_No: No reverse operation is performed + * @arg CRC_ReverseInputData_8bits: reverse operation performed on 8 bits + * @arg CRC_ReverseInputData_16bits: reverse operation performed on 16 bits + * @arg CRC_ReverseInputData_32bits: reverse operation performed on 32 bits + * @retval None + */ +void CRC_ReverseInputDataSelect(uint32_t CRC_ReverseInputData) +{ + uint32_t tmpcr = 0; + + /* Check the parameter */ + assert_param(IS_CRC_REVERSE_INPUT_DATA(CRC_ReverseInputData)); + + /* Get CR register value */ + tmpcr = CRC->CR; + + /* Reset REV_IN bits */ + tmpcr &= (uint32_t)~((uint32_t)CRC_CR_REV_IN); + /* Set the reverse operation */ + tmpcr |= (uint32_t)CRC_ReverseInputData; + + /* Write to CR register */ + CRC->CR = (uint32_t)tmpcr; +} + +/** + * @brief Enables or disable the reverse operation on output data. + * The reverse operation on output data is performed on 32-bit. + * @param NewState: new state of the reverse operation on output data. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void CRC_ReverseOutputDataCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable reverse operation on output data */ + CRC->CR |= CRC_CR_REV_OUT; + } + else + { + /* Disable reverse operation on output data */ + CRC->CR &= (uint32_t)~((uint32_t)CRC_CR_REV_OUT); + } +} + +/** + * @brief Initializes the INIT register. + * @note After resetting CRC calculation unit, CRC_InitValue is stored in DR register + * @param CRC_InitValue: Programmable initial CRC value + * @retval None + */ +void CRC_SetInitRegister(uint32_t CRC_InitValue) +{ + CRC->INIT = CRC_InitValue; +} + +/** + * @brief Initializes the polynomail coefficients. This function is only + * applicable for STM32F072 devices. + * @param CRC_Pol: Polynomial to be used for CRC calculation. + * @retval None + */ +void CRC_SetPolynomial(uint32_t CRC_Pol) +{ + CRC->POL = CRC_Pol; +} + +/** + * @} + */ + +/** @defgroup CRC_Group2 CRC computation of one/many 32-bit data functions + * @brief CRC computation of one/many 32-bit data functions + * +@verbatim + =============================================================================== + ##### CRC computation functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Computes the 32-bit CRC of a given data word(32-bit). + * @param CRC_Data: data word(32-bit) to compute its CRC + * @retval 32-bit CRC + */ +uint32_t CRC_CalcCRC(uint32_t CRC_Data) +{ + CRC->DR = CRC_Data; + + return (CRC->DR); +} + +/** + * @brief Computes the 16-bit CRC of a given 16-bit data. This function is only + * applicable for STM32F072 devices. + * @param CRC_Data: data half-word(16-bit) to compute its CRC + * @retval 16-bit CRC + */ +uint32_t CRC_CalcCRC16bits(uint16_t CRC_Data) +{ + *(uint16_t*)(CRC_BASE) = (uint16_t) CRC_Data; + + return (CRC->DR); +} + +/** + * @brief Computes the 8-bit CRC of a given 8-bit data. This function is only + * applicable for STM32F072 devices. + * @param CRC_Data: 8-bit data to compute its CRC + * @retval 8-bit CRC + */ +uint32_t CRC_CalcCRC8bits(uint8_t CRC_Data) +{ + *(uint8_t*)(CRC_BASE) = (uint8_t) CRC_Data; + + return (CRC->DR); +} + +/** + * @brief Computes the 32-bit CRC of a given buffer of data word(32-bit). + * @param pBuffer: pointer to the buffer containing the data to be computed + * @param BufferLength: length of the buffer to be computed + * @retval 32-bit CRC + */ +uint32_t CRC_CalcBlockCRC(uint32_t pBuffer[], uint32_t BufferLength) +{ + uint32_t index = 0; + + for(index = 0; index < BufferLength; index++) + { + CRC->DR = pBuffer[index]; + } + return (CRC->DR); +} + +/** + * @brief Returns the current CRC value. + * @param None + * @retval 32-bit CRC + */ +uint32_t CRC_GetCRC(void) +{ + return (CRC->DR); +} + +/** + * @} + */ + +/** @defgroup CRC_Group3 CRC Independent Register (IDR) access functions + * @brief CRC Independent Register (IDR) access (write/read) functions + * +@verbatim + =============================================================================== + ##### CRC Independent Register (IDR) access functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Stores an 8-bit data in the Independent Data(ID) register. + * @param CRC_IDValue: 8-bit value to be stored in the ID register + * @retval None + */ +void CRC_SetIDRegister(uint8_t CRC_IDValue) +{ + CRC->IDR = CRC_IDValue; +} + +/** + * @brief Returns the 8-bit data stored in the Independent Data(ID) register + * @param None + * @retval 8-bit value of the ID register + */ +uint8_t CRC_GetIDRegister(void) +{ + return (CRC->IDR); +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_crs.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_crs.c new file mode 100644 index 00000000..3bc10903 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_crs.c @@ -0,0 +1,466 @@ +/** + ****************************************************************************** + * @file stm32f0xx_crs.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of CRS peripheral applicable only on STM32F042 and + * STM32F072 devices: + * + Configuration of the CRS peripheral + * + Interrupts and flags management + * + * + * @verbatim + =============================================================================== + ##### How to use this driver ##### + =============================================================================== + [..] + + (+) Enable CRS AHB clock using RCC_APB1eriphClockCmd(RCC_APB1Periph_CRS, ENABLE) + function + + + @endverbatim + * + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_crs.h" +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup CRS + * @brief CRS driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* CRS Flag Mask */ +#define FLAG_MASK ((uint32_t)0x700) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup CRS_Private_Functions + * @{ + */ + +/** @defgroup CRS_Group1 Configuration of the CRS functions + * @brief Configuration of the CRS functions + * +@verbatim + =============================================================================== + ##### CRS configuration functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes CRS peripheral registers to their default reset values. + * @param None + * @retval None + */ +void CRS_DeInit(void) +{ + RCC_APB1PeriphResetCmd(RCC_APB1Periph_CRS, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_CRS, DISABLE); +} + +/** + * @brief Adjusts the Internal High Speed 48 oscillator (HSI 48) calibration value. + * @note The calibration is used to compensate for the variations in voltage + * and temperature that influence the frequency of the internal HSI48 RC. + * @note This function can be called only when the AUTOTRIMEN bit is reset. + * @param CRS_HSI48CalibrationValue: + * @retval None + */ +void CRS_AdjustHSI48CalibrationValue(uint8_t CRS_HSI48CalibrationValue) +{ + /* Clear TRIM[5:0] bits */ + CRS->CR &= ~CRS_CR_TRIM; + + /* Set the TRIM[5:0] bits according to CRS_HSI48CalibrationValue value */ + CRS->CR |= (uint32_t)((uint32_t)CRS_HSI48CalibrationValue << 8); + +} + +/** + * @brief Enables or disables the oscillator clock for frequency error counter. + * @note when the CEN bit is set the CRS_CFGR register becomes write-protected. + * @param NewState: new state of the frequency error counter. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void CRS_FrequencyErrorCounterCmd(FunctionalState NewState) +{ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + CRS->CR |= CRS_CR_CEN; + } + else + { + CRS->CR &= ~CRS_CR_CEN; + } +} + +/** + * @brief Enables or disables the automatic hardware adjustement of TRIM bits. + * @note When the AUTOTRIMEN bit is set the CRS_CFGR register becomes write-protected. + * @param NewState: new state of the automatic trimming. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void CRS_AutomaticCalibrationCmd(FunctionalState NewState) +{ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + CRS->CR |= CRS_CR_AUTOTRIMEN; + } +else + { + CRS->CR &= ~CRS_CR_AUTOTRIMEN; + } +} + +/** + * @brief Generate the software synchronization event + * @param None + * @retval None + */ +void CRS_SoftwareSynchronizationGenerate(void) +{ + CRS->CR |= CRS_CR_SWSYNC; +} + +/** + * @brief Adjusts the Internal High Speed 48 oscillator (HSI 48) calibration value. + * @note The calibration is used to compensate for the variations in voltage + * and temperature that influence the frequency of the internal HSI48 RC. + * @note This function can be called only when the CEN bit is reset. + * @param CRS_ReloadValue: specifies the HSI calibration trimming value. + * This parameter must be a number between 0 and . + * @retval None + */ +void CRS_FrequencyErrorCounterReload(uint32_t CRS_ReloadValue) +{ + + /* Clear RELOAD[15:0] bits */ + CRS->CFGR &= ~CRS_CFGR_RELOAD; + + /* Set the RELOAD[15:0] bits according to CRS_ReloadValue value */ + CRS->CFGR |= (uint32_t)CRS_ReloadValue; + +} + +/** + * @brief + * @note This function can be called only when the CEN bit is reset. + * @param CRS_ErrorLimitValue: specifies the HSI calibration trimming value. + * This parameter must be a number between 0 and . + * @retval None + */ +void CRS_FrequencyErrorLimitConfig(uint8_t CRS_ErrorLimitValue) +{ + /* Clear FELIM[7:0] bits */ + CRS->CFGR &= ~CRS_CFGR_FELIM; + + /* Set the FELIM[7:0] bits according to CRS_ErrorLimitValue value */ + CRS->CFGR |= (uint32_t)CRS_ErrorLimitValue; +} + +/** + * @brief + * @note This function can be called only when the CEN bit is reset. + * @param CRS_Prescaler: specifies the HSI calibration trimming value. + * This parameter can be one of the following values: + * @arg CRS_SYNC_Div1: + * @arg CRS_SYNC_Div2: + * @arg CRS_SYNC_Div4: + * @arg CRS_SYNC_Div8: + * @arg CRS_SYNC_Div16: + * @arg CRS_SYNC_Div32: + * @arg CRS_SYNC_Div64: + * @arg CRS_SYNC_Div128: + * @retval None + */ +void CRS_SynchronizationPrescalerConfig(uint32_t CRS_Prescaler) +{ + /* Check the parameters */ + assert_param(IS_CRS_SYNC_DIV(CRS_Prescaler)); + + /* Clear SYNCDIV[2:0] bits */ + CRS->CFGR &= ~CRS_CFGR_SYNCDIV; + + /* Set the CRS_CFGR_SYNCDIV[2:0] bits according to CRS_Prescaler value */ + CRS->CFGR |= CRS_Prescaler; +} + +/** + * @brief + * @note This function can be called only when the CEN bit is reset. + * @param CRS_Source: . + * This parameter can be one of the following values: + * @arg CRS_SYNCSource_GPIO: + * @arg CRS_SYNCSource_LSE: + * @arg CRS_SYNCSource_USB: + * @retval None + */ +void CRS_SynchronizationSourceConfig(uint32_t CRS_Source) +{ + /* Check the parameters */ + assert_param(IS_CRS_SYNC_SOURCE(CRS_Source)); + + /* Clear SYNCSRC[1:0] bits */ + CRS->CFGR &= ~CRS_CFGR_SYNCSRC; + + /* Set the SYNCSRC[1:0] bits according to CRS_Source value */ + CRS->CFGR |= CRS_Source; +} + +/** + * @brief + * @note This function can be called only when the CEN bit is reset. + * @param CRS_Polarity: . + * This parameter can be one of the following values: + * @arg CRS_SYNCPolarity_Rising: + * @arg CRS_SYNCPolarity_Falling: + * @retval None + */ +void CRS_SynchronizationPolarityConfig(uint32_t CRS_Polarity) +{ + /* Check the parameters */ + assert_param(IS_CRS_SYNC_POLARITY(CRS_Polarity)); + + /* Clear SYNCSPOL bit */ + CRS->CFGR &= ~CRS_CFGR_SYNCPOL; + + /* Set the SYNCSPOL bits according to CRS_Polarity value */ + CRS->CFGR |= CRS_Polarity; +} + +/** + * @brief Returns the Relaod value. + * @param None + * @retval The reload value + */ +uint32_t CRS_GetReloadValue(void) +{ + return ((uint32_t)(CRS->CFGR & CRS_CFGR_RELOAD)); +} + +/** + * @brief Returns the HSI48 Calibration value. + * @param None + * @retval The reload value + */ +uint32_t CRS_GetHSI48CalibrationValue(void) +{ + return (((uint32_t)(CRS->CR & CRS_CR_TRIM)) >> 8); +} + +/** + * @brief Returns the frequency error capture. + * @param None + * @retval The frequency error capture value + */ +uint32_t CRS_GetFrequencyErrorValue(void) +{ + return ((uint32_t)(CRS->ISR & CRS_ISR_FECAP)); +} + +/** + * @brief Returns the frequency error direction. + * @param None + * @retval The frequency error direction. The returned value can be one + * of the following values: + * - 0x00: Up counting + * - 0x8000: Down counting + */ +uint32_t CRS_GetFrequencyErrorDirection(void) +{ + return ((uint32_t)(CRS->ISR & CRS_ISR_FEDIR)); +} + +/** @defgroup CRS_Group2 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== +@endverbatim + * @{ + */ +/** + * @brief Enables or disables the specified CRS interrupts. + * @param CRS_IT: specifies the RCC interrupt sources to be enabled or disabled. + * This parameter can be any combination of the following values: + * @arg CRS_IT_SYNCOK: + * @arg CRS_IT_SYNCWARN: + * @arg CRS_IT_ERR: + * @arg CRS_IT_ESYNC: + * @param NewState: new state of the specified CRS interrupts. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void CRS_ITConfig(uint32_t CRS_IT, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_CRS_IT(CRS_IT)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + CRS->CR |= CRS_IT; + } + else + { + CRS->CR &= ~CRS_IT; + } +} + +/** + * @brief Checks whether the specified CRS flag is set or not. + * @param CRS_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg CRS_FLAG_SYNCOK: + * @arg CRS_FLAG_SYNCWARN: + * @arg CRS_FLAG_ERR: + * @arg CRS_FLAG_ESYNC: + * @arg CRS_FLAG_TRIMOVF: + * @arg CRS_FLAG_SYNCERR: + * @arg CRS_FLAG_SYNCMISS: + * @retval The new state of CRS_FLAG (SET or RESET). + */ +FlagStatus CRS_GetFlagStatus(uint32_t CRS_FLAG) +{ + /* Check the parameters */ + assert_param(IS_CRS_FLAG(CRS_FLAG)); + + return ((FlagStatus)(CRS->ISR & CRS_FLAG)); +} + +/** + * @brief Clears the CRS specified FLAG. + * @param CRS_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg CRS_FLAG_SYNCOK: + * @arg CRS_FLAG_SYNCWARN: + * @arg CRS_FLAG_ERR: + * @arg CRS_FLAG_ESYNC: + * @arg CRS_FLAG_TRIMOVF: + * @arg CRS_FLAG_SYNCERR: + * @arg CRS_FLAG_SYNCMISS: + * @retval None + */ +void CRS_ClearFlag(uint32_t CRS_FLAG) +{ + /* Check the parameters */ + assert_param(IS_CRS_FLAG(CRS_FLAG)); + + if ((CRS_FLAG & FLAG_MASK)!= 0) + { + CRS->ICR |= CRS_ICR_ERRC; + } + else + { + CRS->ICR |= CRS_FLAG; + } +} + +/** + * @brief Checks whether the specified CRS IT pending bit is set or not. + * @param CRS_IT: specifies the IT pending bit to check. + * This parameter can be one of the following values: + * @arg CRS_IT_SYNCOK: + * @arg CRS_IT_SYNCWARN: + * @arg CRS_IT_ERR: + * @arg CRS_IT_ESYNC: + * @arg CRS_IT_TRIMOVF: + * @arg CRS_IT_SYNCERR: + * @arg CRS_IT_SYNCMISS: + * @retval The new state of CRS_IT (SET or RESET). + */ +ITStatus CRS_GetITStatus(uint32_t CRS_IT) +{ + /* Check the parameters */ + assert_param(IS_CRS_GET_IT(CRS_IT)); + + return ((ITStatus)(CRS->ISR & CRS_IT)); +} + +/** + * @brief Clears the CRS specified IT pending bi. + * @param CRS_FLAG: specifies the IT pending bi to clear. + * This parameter can be one of the following values: + * @arg CRS_IT_SYNCOK: + * @arg CRS_IT_SYNCWARN: + * @arg CRS_IT_ERR: + * @arg CRS_IT_ESYNC: + * @arg CRS_IT_TRIMOVF: + * @arg CRS_IT_SYNCERR: + * @arg CRS_IT_SYNCMISS: + * @retval None + */ +void CRS_ClearITPendingBit(uint32_t CRS_IT) +{ + /* Check the parameters */ + assert_param(IS_CRS_CLEAR_IT(CRS_IT)); + + if ((CRS_IT & FLAG_MASK)!= 0) + { + CRS->ICR |= CRS_ICR_ERRC; + } + else + { + CRS->ICR |= CRS_IT; + } +} +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_dac.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_dac.c new file mode 100644 index 00000000..00527e65 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_dac.c @@ -0,0 +1,692 @@ +/** + ****************************************************************************** + * @file stm32f0xx_dac.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Digital-to-Analog Converter (DAC) peripheral + * applicable only on STM32F051 and STM32F072 devices: + * + DAC channel configuration: trigger, output buffer, data format + * + DMA management + * + Interrupts and flags management + * + * @verbatim + * + =============================================================================== + ##### DAC Peripheral features ##### + =============================================================================== + [..] The device integrates two 12-bit Digital Analog Converters refered as + DAC channel1 with DAC_OUT1 (PA4) and DAC_OUT2 (PA5) as outputs. + + [..] Digital to Analog conversion can be non-triggered using DAC_Trigger_None + and DAC_OUTx is available once writing to DHRx register using + DAC_SetChannel1Data() or DAC_SetChannel2Data() + + [..] Digital to Analog conversion can be triggered by: + (#) External event: EXTI Line 9 (any GPIOx_Pin9) using DAC_Trigger_Ext_IT9. + The used pin (GPIOx_Pin9) must be configured in input mode. + + (#) Timers TRGO: TIM2, TIM3,TIM7, TIM6 and TIM15 + (DAC_Trigger_T2_TRGO, DAC_Trigger_T3_TRGO...) + The timer TRGO event should be selected using TIM_SelectOutputTrigger() + + (#) Software using DAC_Trigger_Software + + [..] Each DAC integrates an output buffer that can be used to + reduce the output impedance, and to drive external loads directly + without having to add an external operational amplifier. + To enable the output buffer use + DAC_InitStructure.DAC_OutputBuffer = DAC_OutputBuffer_Enable; + + [..] Refer to the device datasheet for more details about output impedance + value with and without output buffer. + + [..] DAC wave generation feature + Both DAC channels can be used to generate + 1- Noise wave using DAC_WaveGeneration_Noise + 2- Triangle wave using DAC_WaveGeneration_Triangle + + [..] The DAC data format can be: + (#) 8-bit right alignment using DAC_Align_8b_R + (#) 12-bit left alignment using DAC_Align_12b_L + (#) 12-bit right alignment using DAC_Align_12b_R + + [..] The analog output voltage on each DAC channel pin is determined + by the following equation: DAC_OUTx = VREF+ * DOR / 4095 + with DOR is the Data Output Register + VEF+ is the input voltage reference (refer to the device datasheet) + e.g. To set DAC_OUT1 to 0.7V, use + DAC_SetChannel1Data(DAC_Align_12b_R, 868); + Assuming that VREF+ = 3.3, DAC_OUT1 = (3.3 * 868) / 4095 = 0.7V + + [..] A DMA1 request can be generated when an external trigger (but not + a software trigger) occurs if DMA1 requests are enabled using + DAC_DMACmd() + DMA1 requests are mapped as following: + (+) DAC channel1 is mapped on DMA1 channel3 which must be already + configured + (+) DAC channel2 is mapped on DMA1 channel4 which must be already + configured + + ##### How to use this driver ##### + =============================================================================== + [..] + (+) Enable DAC APB1 clock to get write access to DAC registers + using RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC, ENABLE) + + (+) Configure DAC_OUTx (DAC_OUT1: PA4, DAC_OUT2: PA5) in analog mode + using GPIO_Init() function + + (+) Configure the DAC channel using DAC_Init() + + (+) Enable the DAC channel using DAC_Cmd() + + @endverbatim + * + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_dac.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup DAC + * @brief DAC driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* CR register Mask */ +#define CR_CLEAR_MASK ((uint32_t)0x00000FFE) /* check the value of the mask */ + +/* DAC Dual Channels SWTRIG masks */ +#define DUAL_SWTRIG_SET ((uint32_t)0x00000003) /*!< Only applicable for STM32F072 devices */ +#define DUAL_SWTRIG_RESET ((uint32_t)0xFFFFFFFC) /*!< Only applicable for STM32F072 devices */ + +/* DHR registers offsets */ +#define DHR12R1_OFFSET ((uint32_t)0x00000008) +#define DHR12R2_OFFSET ((uint32_t)0x00000014) /*!< Only applicable for STM32F072 devices */ +#define DHR12RD_OFFSET ((uint32_t)0x00000020) /*!< Only applicable for STM32F072 devices */ + +/* DOR register offset */ +#define DOR_OFFSET ((uint32_t)0x0000002C) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup DAC_Private_Functions + * @{ + */ + +/** @defgroup DAC_Group1 DAC channels configuration + * @brief DAC channels configuration: trigger, output buffer, data format + * +@verbatim + =============================================================================== + ##### DAC channels configuration: trigger, output buffer, data format ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the DAC peripheral registers to their default reset values. + * @param None + * @retval None + */ +void DAC_DeInit(void) +{ + /* Enable DAC reset state */ + RCC_APB1PeriphResetCmd(RCC_APB1Periph_DAC, ENABLE); + /* Release DAC from reset state */ + RCC_APB1PeriphResetCmd(RCC_APB1Periph_DAC, DISABLE); +} + +/** + * @brief Initializes the DAC peripheral according to the specified parameters + * in the DAC_InitStruct. + * @param DAC_Channel: the selected DAC channel. + * This parameter can be: + * @arg DAC_Channel_1: DAC Channel1 selected + * @arg DAC_Channel_2: DAC Channel2 selected, applicable only for STM32F072 devices + * @param DAC_InitStruct: pointer to a DAC_InitTypeDef structure that contains + * the configuration information for the specified DAC channel. + * @retval None + */ +void DAC_Init(uint32_t DAC_Channel, DAC_InitTypeDef* DAC_InitStruct) +{ + uint32_t tmpreg1 = 0, tmpreg2 = 0; + + /* Check the DAC parameters */ + assert_param(IS_DAC_TRIGGER(DAC_InitStruct->DAC_Trigger)); + assert_param(IS_DAC_GENERATE_WAVE(DAC_InitStruct->DAC_WaveGeneration)); + assert_param(IS_DAC_LFSR_UNMASK_TRIANGLE_AMPLITUDE(DAC_InitStruct->DAC_LFSRUnmask_TriangleAmplitude)); + assert_param(IS_DAC_OUTPUT_BUFFER_STATE(DAC_InitStruct->DAC_OutputBuffer)); + +/*---------------------------- DAC CR Configuration --------------------------*/ + /* Get the DAC CR value */ + tmpreg1 = DAC->CR; + /* Clear BOFFx, TENx, TSELx, WAVEx and MAMPx bits */ + tmpreg1 &= ~(CR_CLEAR_MASK << DAC_Channel); + /* Configure for the selected DAC channel: buffer output, trigger, + wave generation, mask/amplitude for wave generation */ + /* Set TSELx and TENx bits according to DAC_Trigger value */ + /* Set WAVEx bits according to DAC_WaveGeneration value */ + /* Set MAMPx bits according to DAC_LFSRUnmask_TriangleAmplitude value */ + /* Set BOFFx bit according to DAC_OutputBuffer value */ + tmpreg2 = (DAC_InitStruct->DAC_Trigger | DAC_InitStruct->DAC_WaveGeneration | + DAC_InitStruct->DAC_LFSRUnmask_TriangleAmplitude | \ + DAC_InitStruct->DAC_OutputBuffer); + /* Calculate CR register value depending on DAC_Channel */ + tmpreg1 |= tmpreg2 << DAC_Channel; + /* Write to DAC CR */ + DAC->CR = tmpreg1; +} + +/** + * @brief Fills each DAC_InitStruct member with its default value. + * @param DAC_InitStruct: pointer to a DAC_InitTypeDef structure which will + * be initialized. + * @retval None + */ +void DAC_StructInit(DAC_InitTypeDef* DAC_InitStruct) +{ +/*--------------- Reset DAC init structure parameters values -----------------*/ + /* Initialize the DAC_Trigger member */ + DAC_InitStruct->DAC_Trigger = DAC_Trigger_None; + + /* Initialize the DAC_WaveGeneration member */ + DAC_InitStruct->DAC_WaveGeneration = DAC_WaveGeneration_None; + + /* Initialize the DAC_LFSRUnmask_TriangleAmplitude member */ + DAC_InitStruct->DAC_LFSRUnmask_TriangleAmplitude = DAC_LFSRUnmask_Bit0; + + /* Initialize the DAC_OutputBuffer member */ + DAC_InitStruct->DAC_OutputBuffer = DAC_OutputBuffer_Enable; +} + +/** + * @brief Enables or disables the specified DAC channel. + * @param DAC_Channel: The selected DAC channel. + * This parameter can be one of the following values: + * @arg DAC_Channel_1: DAC Channel1 selected + * @arg DAC_Channel_2: DAC Channel2 selected, applicable only for STM32F072 devices + * @param NewState: new state of the DAC channel. + * This parameter can be: ENABLE or DISABLE. + * @note When the DAC channel is enabled the trigger source can no more be modified. + * @retval None + */ +void DAC_Cmd(uint32_t DAC_Channel, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_DAC_CHANNEL(DAC_Channel)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected DAC channel */ + DAC->CR |= (DAC_CR_EN1 << DAC_Channel); + } + else + { + /* Disable the selected DAC channel */ + DAC->CR &= (~(DAC_CR_EN1 << DAC_Channel)); + } +} + +/** + * @brief Enables or disables the selected DAC channel software trigger. + * @param DAC_Channel: The selected DAC channel. + * This parameter can be one of the following values: + * @arg DAC_Channel_1: DAC Channel1 selected + * @arg DAC_Channel_2: DAC Channel2 selected, applicable only for STM32F072 devices + * @param NewState: new state of the selected DAC channel software trigger. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void DAC_SoftwareTriggerCmd(uint32_t DAC_Channel, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_DAC_CHANNEL(DAC_Channel)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable software trigger for the selected DAC channel */ + DAC->SWTRIGR |= (uint32_t)DAC_SWTRIGR_SWTRIG1 << (DAC_Channel >> 4); + } + else + { + /* Disable software trigger for the selected DAC channel */ + DAC->SWTRIGR &= ~((uint32_t)DAC_SWTRIGR_SWTRIG1 << (DAC_Channel >> 4)); + } +} + +/** + * @brief Enables or disables simultaneously the two DAC channels software triggers. + * This function is applicable only for STM32F072 devices. + * @param NewState: new state of the DAC channels software triggers. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void DAC_DualSoftwareTriggerCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable software trigger for both DAC channels */ + DAC->SWTRIGR |= DUAL_SWTRIG_SET; + } + else + { + /* Disable software trigger for both DAC channels */ + DAC->SWTRIGR &= DUAL_SWTRIG_RESET; + } +} + +/** + * @brief Enables or disables the selected DAC channel wave generation. + * This function is applicable only for STM32F072 devices. + * @param DAC_Channel: The selected DAC channel. + * This parameter can be: + * @arg DAC_Channel_1: DAC Channel1 selected + * @arg DAC_Channel_2: DAC Channel2 selected + * @param DAC_Wave: specifies the wave type to enable or disable. + * This parameter can be: + * @arg DAC_Wave_Noise: noise wave generation + * @arg DAC_Wave_Triangle: triangle wave generation + * @param NewState: new state of the selected DAC channel wave generation. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void DAC_WaveGenerationCmd(uint32_t DAC_Channel, uint32_t DAC_Wave, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_DAC_CHANNEL(DAC_Channel)); + assert_param(IS_DAC_WAVE(DAC_Wave)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected wave generation for the selected DAC channel */ + DAC->CR |= DAC_Wave << DAC_Channel; + } + else + { + /* Disable the selected wave generation for the selected DAC channel */ + DAC->CR &= ~(DAC_Wave << DAC_Channel); + } +} + +/** + * @brief Set the specified data holding register value for DAC channel1. + * @param DAC_Align: Specifies the data alignment for DAC channel1. + * This parameter can be one of the following values: + * @arg DAC_Align_8b_R: 8bit right data alignment selected + * @arg DAC_Align_12b_L: 12bit left data alignment selected + * @arg DAC_Align_12b_R: 12bit right data alignment selected + * @param Data: Data to be loaded in the selected data holding register. + * @retval None + */ +void DAC_SetChannel1Data(uint32_t DAC_Align, uint16_t Data) +{ + __IO uint32_t tmp = 0; + + /* Check the parameters */ + assert_param(IS_DAC_ALIGN(DAC_Align)); + assert_param(IS_DAC_DATA(Data)); + + tmp = (uint32_t)DAC_BASE; + tmp += DHR12R1_OFFSET + DAC_Align; + + /* Set the DAC channel1 selected data holding register */ + *(__IO uint32_t *) tmp = Data; +} + +/** + * @brief Sets the specified data holding register value for DAC channel2. + * This function is applicable only for STM32F072 devices. + * @param DAC_Align: Specifies the data alignment for DAC channel2. + * This parameter can be: + * @arg DAC_Align_8b_R: 8bit right data alignment selected + * @arg DAC_Align_12b_L: 12bit left data alignment selected + * @arg DAC_Align_12b_R: 12bit right data alignment selected + * @param Data: Data to be loaded in the selected data holding register. + * @retval None + */ +void DAC_SetChannel2Data(uint32_t DAC_Align, uint16_t Data) +{ + __IO uint32_t tmp = 0; + + /* Check the parameters */ + assert_param(IS_DAC_ALIGN(DAC_Align)); + assert_param(IS_DAC_DATA(Data)); + + tmp = (uint32_t)DAC_BASE; + tmp += DHR12R2_OFFSET + DAC_Align; + + /* Set the DAC channel2 selected data holding register */ + *(__IO uint32_t *)tmp = Data; +} + +/** + * @brief Sets the specified data holding register value for dual channel DAC. + * This function is applicable only for STM32F072 devices. + * @param DAC_Align: Specifies the data alignment for dual channel DAC. + * This parameter can be: + * @arg DAC_Align_8b_R: 8bit right data alignment selected + * @arg DAC_Align_12b_L: 12bit left data alignment selected + * @arg DAC_Align_12b_R: 12bit right data alignment selected + * @param Data2: Data for DAC Channel2 to be loaded in the selected data holding register. + * @param Data1: Data for DAC Channel1 to be loaded in the selected data holding register. + * @note In dual mode, a unique register access is required to write in both + * DAC channels at the same time. + * @retval None + */ +void DAC_SetDualChannelData(uint32_t DAC_Align, uint16_t Data2, uint16_t Data1) +{ + uint32_t data = 0, tmp = 0; + + /* Check the parameters */ + assert_param(IS_DAC_ALIGN(DAC_Align)); + assert_param(IS_DAC_DATA(Data1)); + assert_param(IS_DAC_DATA(Data2)); + + /* Calculate and set dual DAC data holding register value */ + if (DAC_Align == DAC_Align_8b_R) + { + data = ((uint32_t)Data2 << 8) | Data1; + } + else + { + data = ((uint32_t)Data2 << 16) | Data1; + } + + tmp = (uint32_t)DAC_BASE; + tmp += DHR12RD_OFFSET + DAC_Align; + + /* Set the dual DAC selected data holding register */ + *(__IO uint32_t *)tmp = data; +} + +/** + * @brief Returns the last data output value of the selected DAC channel. + * @param DAC_Channel: The selected DAC channel. + * This parameter can be one of the following values: + * @arg DAC_Channel_1: DAC Channel1 selected + * @arg DAC_Channel_2: DAC Channel2 selected, applicable only for STM32F072 devices + * @retval The selected DAC channel data output value. + */ +uint16_t DAC_GetDataOutputValue(uint32_t DAC_Channel) +{ + __IO uint32_t tmp = 0; + + /* Check the parameters */ + assert_param(IS_DAC_CHANNEL(DAC_Channel)); + + tmp = (uint32_t) DAC_BASE ; + tmp += DOR_OFFSET + ((uint32_t)DAC_Channel >> 2); + + /* Returns the DAC channel data output register value */ + return (uint16_t) (*(__IO uint32_t*) tmp); +} + +/** + * @} + */ + +/** @defgroup DAC_Group2 DMA management functions + * @brief DMA management functions + * +@verbatim + =============================================================================== + ##### DMA management functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified DAC channel DMA request. + * When enabled DMA1 is generated when an external trigger (EXTI Line9, + * TIM2, TIM3, TIM6 or TIM15 but not a software trigger) occurs + * @param DAC_Channel: the selected DAC channel. + * This parameter can be one of the following values: + * @arg DAC_Channel_1: DAC Channel1 selected + * @arg DAC_Channel_2: DAC Channel2 selected, applicable only for STM32F072 devices + * @param NewState: new state of the selected DAC channel DMA request. + * This parameter can be: ENABLE or DISABLE. + * @note The DAC channel1 is mapped on DMA1 channel3 which must be already configured. + * @note The DAC channel2 is mapped on DMA1 channel4 which must be already configured. + * @retval None + */ +void DAC_DMACmd(uint32_t DAC_Channel, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_DAC_CHANNEL(DAC_Channel)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected DAC channel DMA request */ + DAC->CR |= (DAC_CR_DMAEN1 << DAC_Channel); + } + else + { + /* Disable the selected DAC channel DMA request */ + DAC->CR &= (~(DAC_CR_DMAEN1 << DAC_Channel)); + } +} + +/** + * @} + */ + +/** @defgroup DAC_Group3 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified DAC interrupts. + * @param DAC_Channel: The selected DAC channel. + * This parameter can be: + * @arg DAC_Channel_1: DAC Channel1 selected + * @arg DAC_Channel_2: DAC Channel2 selected, applicable only for STM32F072 devices + * @param DAC_IT: specifies the DAC interrupt sources to be enabled or disabled. + * This parameter can be the following values: + * @arg DAC_IT_DMAUDR: DMA underrun interrupt mask + * @note The DMA underrun occurs when a second external trigger arrives before the + * acknowledgement for the first external trigger is received (first request). + * @param NewState: new state of the specified DAC interrupts. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void DAC_ITConfig(uint32_t DAC_Channel, uint32_t DAC_IT, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_DAC_CHANNEL(DAC_Channel)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + assert_param(IS_DAC_IT(DAC_IT)); + + if (NewState != DISABLE) + { + /* Enable the selected DAC interrupts */ + DAC->CR |= (DAC_IT << DAC_Channel); + } + else + { + /* Disable the selected DAC interrupts */ + DAC->CR &= (~(uint32_t)(DAC_IT << DAC_Channel)); + } +} + +/** + * @brief Checks whether the specified DAC flag is set or not. + * @param DAC_Channel: The selected DAC channel. + * This parameter can be one of the following values: + * @arg DAC_Channel_1: DAC Channel1 selected + * @arg DAC_Channel_2: DAC Channel2 selected, applicable only for STM32F072 devices + * @param DAC_FLAG: specifies the flag to check. + * This parameter can be only of the following value: + * @arg DAC_FLAG_DMAUDR: DMA underrun flag + * @note The DMA underrun occurs when a second external trigger arrives before the + * acknowledgement for the first external trigger is received (first request). + * @retval The new state of DAC_FLAG (SET or RESET). + */ +FlagStatus DAC_GetFlagStatus(uint32_t DAC_Channel, uint32_t DAC_FLAG) +{ + FlagStatus bitstatus = RESET; + /* Check the parameters */ + assert_param(IS_DAC_CHANNEL(DAC_Channel)); + assert_param(IS_DAC_FLAG(DAC_FLAG)); + + /* Check the status of the specified DAC flag */ + if ((DAC->SR & (DAC_FLAG << DAC_Channel)) != (uint8_t)RESET) + { + /* DAC_FLAG is set */ + bitstatus = SET; + } + else + { + /* DAC_FLAG is reset */ + bitstatus = RESET; + } + /* Return the DAC_FLAG status */ + return bitstatus; +} + +/** + * @brief Clears the DAC channel's pending flags. + * @param DAC_Channel: The selected DAC channel. + * This parameter can be one of the following values: + * @arg DAC_Channel_1: DAC Channel1 selected + * @arg DAC_Channel_2: DAC Channel2 selected, applicable only for STM32F072 devices + * @param DAC_FLAG: specifies the flag to clear. + * This parameter can be of the following value: + * @arg DAC_FLAG_DMAUDR: DMA underrun flag + * @retval None + */ +void DAC_ClearFlag(uint32_t DAC_Channel, uint32_t DAC_FLAG) +{ + /* Check the parameters */ + assert_param(IS_DAC_CHANNEL(DAC_Channel)); + assert_param(IS_DAC_FLAG(DAC_FLAG)); + + /* Clear the selected DAC flags */ + DAC->SR = (DAC_FLAG << DAC_Channel); +} + +/** + * @brief Checks whether the specified DAC interrupt has occurred or not. + * @param DAC_Channel: The selected DAC channel. + * This parameter can be one of the following values: + * @arg DAC_Channel_1: DAC Channel1 selected + * @arg DAC_Channel_2: DAC Channel2 selected, applicable only for STM32F072 devices + * @param DAC_IT: specifies the DAC interrupt source to check. + * This parameter can be the following values: + * @arg DAC_IT_DMAUDR: DMA underrun interrupt mask + * @note The DMA underrun occurs when a second external trigger arrives before the + * acknowledgement for the first external trigger is received (first request). + * @retval The new state of DAC_IT (SET or RESET). + */ +ITStatus DAC_GetITStatus(uint32_t DAC_Channel, uint32_t DAC_IT) +{ + ITStatus bitstatus = RESET; + uint32_t enablestatus = 0; + + /* Check the parameters */ + assert_param(IS_DAC_CHANNEL(DAC_Channel)); + assert_param(IS_DAC_IT(DAC_IT)); + + /* Get the DAC_IT enable bit status */ + enablestatus = (DAC->CR & (DAC_IT << DAC_Channel)) ; + + /* Check the status of the specified DAC interrupt */ + if (((DAC->SR & (DAC_IT << DAC_Channel)) != (uint32_t)RESET) && enablestatus) + { + /* DAC_IT is set */ + bitstatus = SET; + } + else + { + /* DAC_IT is reset */ + bitstatus = RESET; + } + /* Return the DAC_IT status */ + return bitstatus; +} + +/** + * @brief Clears the DAC channel's interrupt pending bits. + * @param DAC_Channel: The selected DAC channel. + * This parameter can be one of the following values: + * @arg DAC_Channel_1: DAC Channel1 selected + * @arg DAC_Channel_2: DAC Channel2 selected, applicable only for STM32F072 devices + * @param DAC_IT: specifies the DAC interrupt pending bit to clear. + * This parameter can be the following values: + * @arg DAC_IT_DMAUDR: DMA underrun interrupt mask + * @retval None + */ +void DAC_ClearITPendingBit(uint32_t DAC_Channel, uint32_t DAC_IT) +{ + /* Check the parameters */ + assert_param(IS_DAC_CHANNEL(DAC_Channel)); + assert_param(IS_DAC_IT(DAC_IT)); + + /* Clear the selected DAC interrupt pending bits */ + DAC->SR = (DAC_IT << DAC_Channel); +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_dbgmcu.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_dbgmcu.c new file mode 100644 index 00000000..bb456da5 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_dbgmcu.c @@ -0,0 +1,218 @@ +/** + ****************************************************************************** + * @file stm32f0xx_dbgmcu.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Debug MCU (DBGMCU) peripheral: + * + Device and Revision ID management + * + Peripherals Configuration + * @verbatim + * @endverbatim + * + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_dbgmcu.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup DBGMCU + * @brief DBGMCU driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +#define IDCODE_DEVID_MASK ((uint32_t)0x00000FFF) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup DBGMCU_Private_Functions + * @{ + */ + + +/** @defgroup DBGMCU_Group1 Device and Revision ID management functions + * @brief Device and Revision ID management functions + * +@verbatim + ============================================================================== + ##### Device and Revision ID management functions ##### + ============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Returns the device revision identifier. + * @param None + * @retval Device revision identifier + */ +uint32_t DBGMCU_GetREVID(void) +{ + return(DBGMCU->IDCODE >> 16); +} + +/** + * @brief Returns the device identifier. + * @param None + * @retval Device identifier + */ +uint32_t DBGMCU_GetDEVID(void) +{ + return(DBGMCU->IDCODE & IDCODE_DEVID_MASK); +} + +/** + * @} + */ + +/** @defgroup DBGMCU_Group2 Peripherals Configuration functions + * @brief Peripherals Configuration + * +@verbatim + ============================================================================== + ##### Peripherals Configuration functions ##### + ============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Configures low power mode behavior when the MCU is in Debug mode. + * @param DBGMCU_Periph: specifies the low power mode. + * This parameter can be any combination of the following values: + * @arg DBGMCU_STOP: Keep debugger connection during STOP mode + * @arg DBGMCU_STANDBY: Keep debugger connection during STANDBY mode + * @param NewState: new state of the specified low power mode in Debug mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void DBGMCU_Config(uint32_t DBGMCU_Periph, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_DBGMCU_PERIPH(DBGMCU_Periph)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + DBGMCU->CR |= DBGMCU_Periph; + } + else + { + DBGMCU->CR &= ~DBGMCU_Periph; + } +} + + +/** + * @brief Configures APB1 peripheral behavior when the MCU is in Debug mode. + * @param DBGMCU_Periph: specifies the APB1 peripheral. + * This parameter can be any combination of the following values: + * @arg DBGMCU_TIM2_STOP: TIM2 counter stopped when Core is halted, + * not applicable for STM32F030 devices + * @arg DBGMCU_TIM3_STOP: TIM3 counter stopped when Core is halted + * @arg DBGMCU_TIM6_STOP: TIM6 counter stopped when Core is halted + * @arg DBGMCU_TIM7_STOP: TIM7 counter stopped when Core is halted, + * applicable only for STM32F072 devices + * @arg DBGMCU_TIM14_STOP: TIM14 counter stopped when Core is halted + * @arg DBGMCU_RTC_STOP: RTC Calendar and Wakeup counter stopped + * when Core is halted. + * @arg DBGMCU_WWDG_STOP: Debug WWDG stopped when Core is halted + * @arg DBGMCU_IWDG_STOP: Debug IWDG stopped when Core is halted + * @arg DBGMCU_I2C1_SMBUS_TIMEOUT: I2C1 SMBUS timeout mode stopped + * when Core is halted + * @arg DBGMCU_CAN1_STOP: Debug CAN1 stopped when Core is halted, + * applicable only for STM32F042 and STM32F072 devices + * @param NewState: new state of the specified APB1 peripheral in Debug mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void DBGMCU_APB1PeriphConfig(uint32_t DBGMCU_Periph, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_DBGMCU_APB1PERIPH(DBGMCU_Periph)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + DBGMCU->APB1FZ |= DBGMCU_Periph; + } + else + { + DBGMCU->APB1FZ &= ~DBGMCU_Periph; + } +} + +/** + * @brief Configures APB2 peripheral behavior when the MCU is in Debug mode. + * @param DBGMCU_Periph: specifies the APB2 peripheral. + * This parameter can be any combination of the following values: + * @arg DBGMCU_TIM1_STOP: TIM1 counter stopped when Core is halted + * @arg DBGMCU_TIM15_STOP: TIM15 counter stopped when Core is halted + * @arg DBGMCU_TIM16_STOP: TIM16 counter stopped when Core is halted + * @arg DBGMCU_TIM17_STOP: TIM17 counter stopped when Core is halted + * @param NewState: new state of the specified APB2 peripheral in Debug mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void DBGMCU_APB2PeriphConfig(uint32_t DBGMCU_Periph, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_DBGMCU_APB2PERIPH(DBGMCU_Periph)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + DBGMCU->APB2FZ |= DBGMCU_Periph; + } + else + { + DBGMCU->APB2FZ &= ~DBGMCU_Periph; + } +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_dma.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_dma.c new file mode 100644 index 00000000..a6696f2c --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_dma.c @@ -0,0 +1,891 @@ +/** + ****************************************************************************** + * @file stm32f0xx_dma.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Direct Memory Access controller (DMA): + * + Initialization and Configuration + * + Data Counter + * + Interrupts and flags management + * + * @verbatim + ============================================================================== + ##### How to use this driver ##### + ============================================================================== + [..] + (#) Enable The DMA controller clock using + RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE) function for DMA1. + (#) Enable and configure the peripheral to be connected to the DMA channel + (except for internal SRAM / FLASH memories: no initialization is necessary). + (#) For a given Channel, program the Source and Destination addresses, + the transfer Direction, the Buffer Size, the Peripheral and Memory + Incrementation mode and Data Size, the Circular or Normal mode, + the channel transfer Priority and the Memory-to-Memory transfer + mode (if needed) using the DMA_Init() function. + (#) Enable the NVIC and the corresponding interrupt(s) using the function + DMA_ITConfig() if you need to use DMA interrupts. + (#) Enable the DMA channel using the DMA_Cmd() function. + (#) Activate the needed channel Request using PPP_DMACmd() function for + any PPP peripheral except internal SRAM and FLASH (ie. SPI, USART ...) + The function allowing this operation is provided in each PPP peripheral + driver (ie. SPI_DMACmd for SPI peripheral). + (#) Optionally, you can configure the number of data to be transferred + when the channel is disabled (ie. after each Transfer Complete event + or when a Transfer Error occurs) using the function DMA_SetCurrDataCounter(). + And you can get the number of remaining data to be transferred using + the function DMA_GetCurrDataCounter() at run time (when the DMA channel is + enabled and running). + (#) To control DMA events you can use one of the following two methods: + (##) Check on DMA channel flags using the function DMA_GetFlagStatus(). + (##) Use DMA interrupts through the function DMA_ITConfig() at initialization + phase and DMA_GetITStatus() function into interrupt routines in + communication phase. + After checking on a flag you should clear it using DMA_ClearFlag() + function. And after checking on an interrupt event you should + clear it using DMA_ClearITPendingBit() function. + @endverbatim + * + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_dma.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup DMA + * @brief DMA driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +#define CCR_CLEAR_MASK ((uint32_t)0xFFFF800F) /* DMA Channel config registers Masks */ +#define FLAG_Mask ((uint32_t)0x10000000) /* DMA2 FLAG mask */ + +/* DMA1 Channelx interrupt pending bit masks */ +#define DMA1_CHANNEL1_IT_MASK ((uint32_t)(DMA_ISR_GIF1 | DMA_ISR_TCIF1 | DMA_ISR_HTIF1 | DMA_ISR_TEIF1)) +#define DMA1_CHANNEL2_IT_MASK ((uint32_t)(DMA_ISR_GIF2 | DMA_ISR_TCIF2 | DMA_ISR_HTIF2 | DMA_ISR_TEIF2)) +#define DMA1_CHANNEL3_IT_MASK ((uint32_t)(DMA_ISR_GIF3 | DMA_ISR_TCIF3 | DMA_ISR_HTIF3 | DMA_ISR_TEIF3)) +#define DMA1_CHANNEL4_IT_MASK ((uint32_t)(DMA_ISR_GIF4 | DMA_ISR_TCIF4 | DMA_ISR_HTIF4 | DMA_ISR_TEIF4)) +#define DMA1_CHANNEL5_IT_MASK ((uint32_t)(DMA_ISR_GIF5 | DMA_ISR_TCIF5 | DMA_ISR_HTIF5 | DMA_ISR_TEIF5)) +#define DMA1_CHANNEL6_IT_MASK ((uint32_t)(DMA_ISR_GIF6 | DMA_ISR_TCIF6 | DMA_ISR_HTIF6 | DMA_ISR_TEIF6)) /*!< Only applicable for STM32F072 and STM32F091 devices */ +#define DMA1_CHANNEL7_IT_MASK ((uint32_t)(DMA_ISR_GIF7 | DMA_ISR_TCIF7 | DMA_ISR_HTIF7 | DMA_ISR_TEIF7)) /*!< Only applicable for STM32F072 and STM32F091 devices */ + +/* DMA2 Channelx interrupt pending bit masks: Only applicable for STM32F091 devices */ +#define DMA2_CHANNEL1_IT_MASK ((uint32_t)(DMA_ISR_GIF1 | DMA_ISR_TCIF1 | DMA_ISR_HTIF1 | DMA_ISR_TEIF1)) +#define DMA2_CHANNEL2_IT_MASK ((uint32_t)(DMA_ISR_GIF2 | DMA_ISR_TCIF2 | DMA_ISR_HTIF2 | DMA_ISR_TEIF2)) +#define DMA2_CHANNEL3_IT_MASK ((uint32_t)(DMA_ISR_GIF3 | DMA_ISR_TCIF3 | DMA_ISR_HTIF3 | DMA_ISR_TEIF3)) +#define DMA2_CHANNEL4_IT_MASK ((uint32_t)(DMA_ISR_GIF4 | DMA_ISR_TCIF4 | DMA_ISR_HTIF4 | DMA_ISR_TEIF4)) +#define DMA2_CHANNEL5_IT_MASK ((uint32_t)(DMA_ISR_GIF5 | DMA_ISR_TCIF5 | DMA_ISR_HTIF5 | DMA_ISR_TEIF5)) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup DMA_Private_Functions + * @{ + */ + +/** @defgroup DMA_Group1 Initialization and Configuration functions + * @brief Initialization and Configuration functions + * +@verbatim + =============================================================================== + ##### Initialization and Configuration functions ##### + =============================================================================== + [..] This subsection provides functions allowing to initialize the DMA channel + source and destination addresses, incrementation and data sizes, transfer + direction, buffer size, circular/normal mode selection, memory-to-memory + mode selection and channel priority value. + [..] The DMA_Init() function follows the DMA configuration procedures as described + in reference manual (RM0091). +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the DMAy Channelx registers to their default reset + * values. + * @param DMAy_Channelx: where y can be 1 to select the DMA and + * x can be 1 to 7 for DMA1 to select the DMA Channel. + * @note Channel 6 and 7 are available only for STM32F072 devices. + * @retval None + */ +void DMA_DeInit(DMA_Channel_TypeDef* DMAy_Channelx) +{ + /* Check the parameters */ + assert_param(IS_DMA_ALL_PERIPH(DMAy_Channelx)); + + /* Disable the selected DMAy Channelx */ + DMAy_Channelx->CCR &= (uint16_t)(~DMA_CCR_EN); + + /* Reset DMAy Channelx control register */ + DMAy_Channelx->CCR = 0; + + /* Reset DMAy Channelx remaining bytes register */ + DMAy_Channelx->CNDTR = 0; + + /* Reset DMAy Channelx peripheral address register */ + DMAy_Channelx->CPAR = 0; + + /* Reset DMAy Channelx memory address register */ + DMAy_Channelx->CMAR = 0; + + if (DMAy_Channelx == DMA1_Channel1) + { + /* Reset interrupt pending bits for DMA1 Channel1 */ + DMA1->IFCR |= DMA1_CHANNEL1_IT_MASK; + } + else if (DMAy_Channelx == DMA1_Channel2) + { + /* Reset interrupt pending bits for DMA1 Channel2 */ + DMA1->IFCR |= DMA1_CHANNEL2_IT_MASK; + } + else if (DMAy_Channelx == DMA1_Channel3) + { + /* Reset interrupt pending bits for DMA1 Channel3 */ + DMA1->IFCR |= DMA1_CHANNEL3_IT_MASK; + } + else if (DMAy_Channelx == DMA1_Channel4) + { + /* Reset interrupt pending bits for DMA1 Channel4 */ + DMA1->IFCR |= DMA1_CHANNEL4_IT_MASK; + } + else if (DMAy_Channelx == DMA1_Channel5) + { + /* Reset interrupt pending bits for DMA1 Channel5 */ + DMA1->IFCR |= DMA1_CHANNEL5_IT_MASK; + } + else if (DMAy_Channelx == DMA1_Channel6) + { + /* Reset interrupt pending bits for DMA1 Channel6 */ + DMA1->IFCR |= DMA1_CHANNEL6_IT_MASK; + } + else if (DMAy_Channelx == DMA1_Channel7) + { + /* Reset interrupt pending bits for DMA1 Channel7 */ + DMA1->IFCR |= DMA1_CHANNEL7_IT_MASK; + } + else if (DMAy_Channelx == DMA2_Channel1) + { + /* Reset interrupt pending bits for DMA2 Channel1 */ + DMA2->IFCR |= DMA2_CHANNEL1_IT_MASK; + } + else if (DMAy_Channelx == DMA2_Channel2) + { + /* Reset interrupt pending bits for DMA2 Channel2 */ + DMA2->IFCR |= DMA2_CHANNEL2_IT_MASK; + } + else if (DMAy_Channelx == DMA2_Channel3) + { + /* Reset interrupt pending bits for DMA2 Channel3 */ + DMA2->IFCR |= DMA2_CHANNEL3_IT_MASK; + } + else if (DMAy_Channelx == DMA2_Channel4) + { + /* Reset interrupt pending bits for DMA2 Channel4 */ + DMA2->IFCR |= DMA2_CHANNEL4_IT_MASK; + } + else + { + if (DMAy_Channelx == DMA2_Channel5) + { + /* Reset interrupt pending bits for DMA2 Channel5 */ + DMA2->IFCR |= DMA2_CHANNEL5_IT_MASK; + } + } +} + +/** + * @brief Initializes the DMAy Channelx according to the specified parameters + * in the DMA_InitStruct. + * @param DMAy_Channelx: where y can be 1 to select the DMA and x can be 1 to 7 + * for DMA1 to select the DMA Channel and 1 to 5 for DMA2 to select the DMA Channel. + * @note DMA1 Channel 6 and 7 are available only for STM32F072 and STM32F091 devices. + * @note DMA2 Channel 1 to 5 are available only for STM32F091 devices. + * @param DMA_InitStruct: pointer to a DMA_InitTypeDef structure that contains + * the configuration information for the specified DMA Channel. + * @retval None + */ +void DMA_Init(DMA_Channel_TypeDef* DMAy_Channelx, DMA_InitTypeDef* DMA_InitStruct) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_DMA_ALL_PERIPH(DMAy_Channelx)); + assert_param(IS_DMA_DIR(DMA_InitStruct->DMA_DIR)); + assert_param(IS_DMA_BUFFER_SIZE(DMA_InitStruct->DMA_BufferSize)); + assert_param(IS_DMA_PERIPHERAL_INC_STATE(DMA_InitStruct->DMA_PeripheralInc)); + assert_param(IS_DMA_MEMORY_INC_STATE(DMA_InitStruct->DMA_MemoryInc)); + assert_param(IS_DMA_PERIPHERAL_DATA_SIZE(DMA_InitStruct->DMA_PeripheralDataSize)); + assert_param(IS_DMA_MEMORY_DATA_SIZE(DMA_InitStruct->DMA_MemoryDataSize)); + assert_param(IS_DMA_MODE(DMA_InitStruct->DMA_Mode)); + assert_param(IS_DMA_PRIORITY(DMA_InitStruct->DMA_Priority)); + assert_param(IS_DMA_M2M_STATE(DMA_InitStruct->DMA_M2M)); + +/*--------------------------- DMAy Channelx CCR Configuration ----------------*/ + /* Get the DMAy_Channelx CCR value */ + tmpreg = DMAy_Channelx->CCR; + + /* Clear MEM2MEM, PL, MSIZE, PSIZE, MINC, PINC, CIRC and DIR bits */ + tmpreg &= CCR_CLEAR_MASK; + + /* Configure DMAy Channelx: data transfer, data size, priority level and mode */ + /* Set DIR bit according to DMA_DIR value */ + /* Set CIRC bit according to DMA_Mode value */ + /* Set PINC bit according to DMA_PeripheralInc value */ + /* Set MINC bit according to DMA_MemoryInc value */ + /* Set PSIZE bits according to DMA_PeripheralDataSize value */ + /* Set MSIZE bits according to DMA_MemoryDataSize value */ + /* Set PL bits according to DMA_Priority value */ + /* Set the MEM2MEM bit according to DMA_M2M value */ + tmpreg |= DMA_InitStruct->DMA_DIR | DMA_InitStruct->DMA_Mode | + DMA_InitStruct->DMA_PeripheralInc | DMA_InitStruct->DMA_MemoryInc | + DMA_InitStruct->DMA_PeripheralDataSize | DMA_InitStruct->DMA_MemoryDataSize | + DMA_InitStruct->DMA_Priority | DMA_InitStruct->DMA_M2M; + + /* Write to DMAy Channelx CCR */ + DMAy_Channelx->CCR = tmpreg; + +/*--------------------------- DMAy Channelx CNDTR Configuration --------------*/ + /* Write to DMAy Channelx CNDTR */ + DMAy_Channelx->CNDTR = DMA_InitStruct->DMA_BufferSize; + +/*--------------------------- DMAy Channelx CPAR Configuration ---------------*/ + /* Write to DMAy Channelx CPAR */ + DMAy_Channelx->CPAR = DMA_InitStruct->DMA_PeripheralBaseAddr; + +/*--------------------------- DMAy Channelx CMAR Configuration ---------------*/ + /* Write to DMAy Channelx CMAR */ + DMAy_Channelx->CMAR = DMA_InitStruct->DMA_MemoryBaseAddr; +} + +/** + * @brief Fills each DMA_InitStruct member with its default value. + * @param DMA_InitStruct: pointer to a DMA_InitTypeDef structure which will + * be initialized. + * @retval None + */ +void DMA_StructInit(DMA_InitTypeDef* DMA_InitStruct) +{ +/*-------------- Reset DMA init structure parameters values ------------------*/ + /* Initialize the DMA_PeripheralBaseAddr member */ + DMA_InitStruct->DMA_PeripheralBaseAddr = 0; + /* Initialize the DMA_MemoryBaseAddr member */ + DMA_InitStruct->DMA_MemoryBaseAddr = 0; + /* Initialize the DMA_DIR member */ + DMA_InitStruct->DMA_DIR = DMA_DIR_PeripheralSRC; + /* Initialize the DMA_BufferSize member */ + DMA_InitStruct->DMA_BufferSize = 0; + /* Initialize the DMA_PeripheralInc member */ + DMA_InitStruct->DMA_PeripheralInc = DMA_PeripheralInc_Disable; + /* Initialize the DMA_MemoryInc member */ + DMA_InitStruct->DMA_MemoryInc = DMA_MemoryInc_Disable; + /* Initialize the DMA_PeripheralDataSize member */ + DMA_InitStruct->DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; + /* Initialize the DMA_MemoryDataSize member */ + DMA_InitStruct->DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; + /* Initialize the DMA_Mode member */ + DMA_InitStruct->DMA_Mode = DMA_Mode_Normal; + /* Initialize the DMA_Priority member */ + DMA_InitStruct->DMA_Priority = DMA_Priority_Low; + /* Initialize the DMA_M2M member */ + DMA_InitStruct->DMA_M2M = DMA_M2M_Disable; +} + +/** + * @brief Enables or disables the specified DMAy Channelx. + * @param DMAy_Channelx: where y can be 1 to select the DMA and x can be 1 to 7 + * for DMA1 to select the DMA Channel and 1 to 5 for DMA2 to select the DMA Channel. + * @note DMA1 Channel 6 and 7 are available only for STM32F072 and STM32F091 devices. + * @note DMA2 Channel 1 to 5 are available only for STM32F091 devices. + * @param NewState: new state of the DMAy Channelx. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void DMA_Cmd(DMA_Channel_TypeDef* DMAy_Channelx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_DMA_ALL_PERIPH(DMAy_Channelx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected DMAy Channelx */ + DMAy_Channelx->CCR |= DMA_CCR_EN; + } + else + { + /* Disable the selected DMAy Channelx */ + DMAy_Channelx->CCR &= (uint16_t)(~DMA_CCR_EN); + } +} + +/** + * @brief Configure the DMAx channels remapping. + * @param DMAy: where x can be 1 or 2 to select the DMA peripheral. + * @param DMAy_CHx_RemapRequest: where y can be 1 or 2 to select the DMA and x can be 1 to 7 + * for DMA1 to select the DMA1 Channel and can be 1 to 5 for DMA2 to select the DMA2 Channel. + * @note This function is available only for STM32F091 devices. + * @retval None + */ +void DMA_RemapConfig(DMA_TypeDef* DMAy, uint32_t DMAx_CHy_RemapRequest) +{ + assert_param(IS_DMA_ALL_LIST(DMAy)); + + if (DMAy == DMA1) + { + assert_param(IS_DMA1_REMAP(DMAx_CHy_RemapRequest)); + } + else + { + assert_param(IS_DMA2_REMAP(DMAx_CHy_RemapRequest)); + } + + DMAy->RMPCR &= ~((uint32_t)0x0F << (uint32_t)((DMAx_CHy_RemapRequest >> 28) * 4)); + DMAy->RMPCR |= (uint32_t)(DMAx_CHy_RemapRequest & 0x0FFFFFFF); +} + +/** + * @} + */ + +/** @defgroup DMA_Group2 Data Counter functions + * @brief Data Counter functions + * +@verbatim + =============================================================================== + ##### Data Counter functions ##### + =============================================================================== + [..] This subsection provides function allowing to configure and read the buffer + size (number of data to be transferred).The DMA data counter can be written + only when the DMA channel is disabled (ie. after transfer complete event). + [..] The following function can be used to write the Channel data counter value: + (+) void DMA_SetCurrDataCounter(DMA_Channel_TypeDef* DMAy_Channelx, uint16_t + DataNumber). + -@- It is advised to use this function rather than DMA_Init() in situations + where only the Data buffer needs to be reloaded. + [..] The DMA data counter can be read to indicate the number of remaining transfers + for the relative DMA channel. This counter is decremented at the end of each + data transfer and when the transfer is complete: + (+) If Normal mode is selected: the counter is set to 0. + (+) If Circular mode is selected: the counter is reloaded with the initial + value(configured before enabling the DMA channel). + [..] The following function can be used to read the Channel data counter value: + (+) uint16_t DMA_GetCurrDataCounter(DMA_Channel_TypeDef* DMAy_Channelx). + +@endverbatim + * @{ + */ + +/** + * @brief Sets the number of data units in the current DMAy Channelx transfer. + * @param DMAy_Channelx: where y can be 1 to select the DMA and x can be 1 to 7 + * for DMA1 to select the DMA Channel and 1 to 5 for DMA2 to select the DMA Channel. + * @note DMA1 Channel 6 and 7 are available only for STM32F072 and STM32F091 devices. + * @note DMA2 Channel 1 to 5 are available only for STM32F091 devices. + * @param DataNumber: The number of data units in the current DMAy Channelx + * transfer. + * @note This function can only be used when the DMAy_Channelx is disabled. + * @retval None. + */ +void DMA_SetCurrDataCounter(DMA_Channel_TypeDef* DMAy_Channelx, uint16_t DataNumber) +{ + /* Check the parameters */ + assert_param(IS_DMA_ALL_PERIPH(DMAy_Channelx)); + +/*--------------------------- DMAy Channelx CNDTR Configuration --------------*/ + /* Write to DMAy Channelx CNDTR */ + DMAy_Channelx->CNDTR = DataNumber; +} + +/** + * @brief Returns the number of remaining data units in the current + * DMAy Channelx transfer. + * @param DMAy_Channelx: where y can be 1 to select the DMA and x can be 1 to 7 + * for DMA1 to select the DMA Channel and 1 to 5 for DMA2 to select the DMA Channel. + * @note DMA1 Channel 6 and 7 are available only for STM32F072 and STM32F091 devices. + * @note DMA2 Channel 1 to 5 are available only for STM32F091 devices. + * @retval The number of remaining data units in the current DMAy Channelx + * transfer. + */ +uint16_t DMA_GetCurrDataCounter(DMA_Channel_TypeDef* DMAy_Channelx) +{ + /* Check the parameters */ + assert_param(IS_DMA_ALL_PERIPH(DMAy_Channelx)); + /* Return the number of remaining data units for DMAy Channelx */ + return ((uint16_t)(DMAy_Channelx->CNDTR)); +} + +/** + * @} + */ + +/** @defgroup DMA_Group3 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== + [..] This subsection provides functions allowing to configure the DMA Interrupts + sources and check or clear the flags or pending bits status. + The user should identify which mode will be used in his application to manage + the DMA controller events: Polling mode or Interrupt mode. + *** Polling Mode *** + ==================== + [..] Each DMA channel can be managed through 4 event Flags:(y : DMA Controller + number x : DMA channel number ). + (#) DMAy_FLAG_TCx : to indicate that a Transfer Complete event occurred. + (#) DMAy_FLAG_HTx : to indicate that a Half-Transfer Complete event occurred. + (#) DMAy_FLAG_TEx : to indicate that a Transfer Error occurred. + (#) DMAy_FLAG_GLx : to indicate that at least one of the events described + above occurred. + -@- Clearing DMAy_FLAG_GLx results in clearing all other pending flags of the + same channel (DMAy_FLAG_TCx, DMAy_FLAG_HTx and DMAy_FLAG_TEx). + [..]In this Mode it is advised to use the following functions: + (+) FlagStatus DMA_GetFlagStatus(uint32_t DMA_FLAG); + (+) void DMA_ClearFlag(uint32_t DMA_FLAG); + + *** Interrupt Mode *** + ====================== + [..] Each DMA channel can be managed through 4 Interrupts: + (+) Interrupt Source + (##) DMA_IT_TC: specifies the interrupt source for the Transfer Complete + event. + (##) DMA_IT_HT : specifies the interrupt source for the Half-transfer Complete + event. + (##) DMA_IT_TE : specifies the interrupt source for the transfer errors event. + (##) DMA_IT_GL : to indicate that at least one of the interrupts described + above occurred. + -@@- Clearing DMA_IT_GL interrupt results in clearing all other interrupts of + the same channel (DMA_IT_TCx, DMA_IT_HT and DMA_IT_TE). + [..]In this Mode it is advised to use the following functions: + (+) void DMA_ITConfig(DMA_Channel_TypeDef* DMAy_Channelx, uint32_t DMA_IT, + FunctionalState NewState); + (+) ITStatus DMA_GetITStatus(uint32_t DMA_IT); + (+) void DMA_ClearITPendingBit(uint32_t DMA_IT); + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified DMAy Channelx interrupts. + * @param DMAy_Channelx: where y can be 1 to select the DMA and x can be 1 to 7 + * for DMA1 to select the DMA Channel and 1 to 5 for DMA2 to select the DMA Channel. + * @note DMA1 Channel 6 and 7 are available only for STM32F072 and STM32F091 devices. + * @note DMA2 Channel 1 to 5 are available only for STM32F091 devices. + * @param DMA_IT: specifies the DMA interrupts sources to be enabled + * or disabled. + * This parameter can be any combination of the following values: + * @arg DMA_IT_TC: Transfer complete interrupt mask + * @arg DMA_IT_HT: Half transfer interrupt mask + * @arg DMA_IT_TE: Transfer error interrupt mask + * @param NewState: new state of the specified DMA interrupts. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void DMA_ITConfig(DMA_Channel_TypeDef* DMAy_Channelx, uint32_t DMA_IT, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_DMA_ALL_PERIPH(DMAy_Channelx)); + assert_param(IS_DMA_CONFIG_IT(DMA_IT)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected DMA interrupts */ + DMAy_Channelx->CCR |= DMA_IT; + } + else + { + /* Disable the selected DMA interrupts */ + DMAy_Channelx->CCR &= ~DMA_IT; + } +} + +/** + * @brief Checks whether the specified DMAy Channelx flag is set or not. + * @param DMA_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg DMA1_FLAG_GL1: DMA1 Channel1 global flag. + * @arg DMA1_FLAG_TC1: DMA1 Channel1 transfer complete flag. + * @arg DMA1_FLAG_HT1: DMA1 Channel1 half transfer flag. + * @arg DMA1_FLAG_TE1: DMA1 Channel1 transfer error flag. + * @arg DMA1_FLAG_GL2: DMA1 Channel2 global flag. + * @arg DMA1_FLAG_TC2: DMA1 Channel2 transfer complete flag. + * @arg DMA1_FLAG_HT2: DMA1 Channel2 half transfer flag. + * @arg DMA1_FLAG_TE2: DMA1 Channel2 transfer error flag. + * @arg DMA1_FLAG_GL3: DMA1 Channel3 global flag. + * @arg DMA1_FLAG_TC3: DMA1 Channel3 transfer complete flag. + * @arg DMA1_FLAG_HT3: DMA1 Channel3 half transfer flag. + * @arg DMA1_FLAG_TE3: DMA1 Channel3 transfer error flag. + * @arg DMA1_FLAG_GL4: DMA1 Channel4 global flag. + * @arg DMA1_FLAG_TC4: DMA1 Channel4 transfer complete flag. + * @arg DMA1_FLAG_HT4: DMA1 Channel4 half transfer flag. + * @arg DMA1_FLAG_TE4: DMA1 Channel4 transfer error flag. + * @arg DMA1_FLAG_GL5: DMA1 Channel5 global flag. + * @arg DMA1_FLAG_TC5: DMA1 Channel5 transfer complete flag. + * @arg DMA1_FLAG_HT5: DMA1 Channel5 half transfer flag. + * @arg DMA1_FLAG_TE5: DMA1 Channel5 transfer error flag. + * @arg DMA1_FLAG_GL6: DMA1 Channel6 global flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_TC6: DMA1 Channel6 transfer complete flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_HT6: DMA1 Channel6 half transfer flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_TE6: DMA1 Channel6 transfer error flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_GL7: DMA1 Channel7 global flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_TC7: DMA1 Channel7 transfer complete flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_HT7: DMA1 Channel7 half transfer flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_TE7: DMA1 Channel7 transfer error flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA2_FLAG_GL1: DMA2 Channel1 global flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TC1: DMA2 Channel1 transfer complete flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_HT1: DMA2 Channel1 half transfer flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TE1: DMA2 Channel1 transfer error flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_GL2: DMA2 Channel2 global flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TC2: DMA2 Channel2 transfer complete flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_HT2: DMA2 Channel2 half transfer flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TE2: DMA2 Channel2 transfer error flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_GL3: DMA2 Channel3 global flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TC3: DMA2 Channel3 transfer complete flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_HT3: DMA2 Channel3 half transfer flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TE3: DMA2 Channel3 transfer error flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_GL4: DMA2 Channel4 global flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TC4: DMA2 Channel4 transfer complete flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_HT4: DMA2 Channel4 half transfer flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TE4: DMA2 Channel4 transfer error flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_GL5: DMA2 Channel5 global flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TC5: DMA2 Channel5 transfer complete flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_HT5: DMA2 Channel5 half transfer flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TE5: DMA2 Channel5 transfer error flag, applicable only for STM32FO91 devices. + * @note The Global flag (DMAy_FLAG_GLx) is set whenever any of the other flags + * relative to the same channel is set (Transfer Complete, Half-transfer + * Complete or Transfer Error flags: DMAy_FLAG_TCx, DMAy_FLAG_HTx or + * DMAy_FLAG_TEx). + * + * @retval The new state of DMA_FLAG (SET or RESET). + */ +FlagStatus DMA_GetFlagStatus(uint32_t DMAy_FLAG) +{ + FlagStatus bitstatus = RESET; + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_DMA_GET_FLAG(DMAy_FLAG)); + + /* Calculate the used DMAy */ + if ((DMAy_FLAG & FLAG_Mask) != (uint32_t)RESET) + { + /* Get DMA2 ISR register value */ + tmpreg = DMA2->ISR ; + } + else + { + /* Get DMA1 ISR register value */ + tmpreg = DMA1->ISR ; + } + + /* Check the status of the specified DMAy flag */ + if ((tmpreg & DMAy_FLAG) != (uint32_t)RESET) + { + /* DMAy_FLAG is set */ + bitstatus = SET; + } + else + { + /* DMAy_FLAG is reset */ + bitstatus = RESET; + } + + /* Return the DMAy_FLAG status */ + return bitstatus; +} + +/** + * @brief Clears the DMAy Channelx's pending flags. + * @param DMA_FLAG: specifies the flag to clear. + * This parameter can be any combination (for the same DMA) of the following values: + * @arg DMA1_FLAG_GL1: DMA1 Channel1 global flag. + * @arg DMA1_FLAG_TC1: DMA1 Channel1 transfer complete flag. + * @arg DMA1_FLAG_HT1: DMA1 Channel1 half transfer flag. + * @arg DMA1_FLAG_TE1: DMA1 Channel1 transfer error flag. + * @arg DMA1_FLAG_GL2: DMA1 Channel2 global flag. + * @arg DMA1_FLAG_TC2: DMA1 Channel2 transfer complete flag. + * @arg DMA1_FLAG_HT2: DMA1 Channel2 half transfer flag. + * @arg DMA1_FLAG_TE2: DMA1 Channel2 transfer error flag. + * @arg DMA1_FLAG_GL3: DMA1 Channel3 global flag. + * @arg DMA1_FLAG_TC3: DMA1 Channel3 transfer complete flag. + * @arg DMA1_FLAG_HT3: DMA1 Channel3 half transfer flag. + * @arg DMA1_FLAG_TE3: DMA1 Channel3 transfer error flag. + * @arg DMA1_FLAG_GL4: DMA1 Channel4 global flag. + * @arg DMA1_FLAG_TC4: DMA1 Channel4 transfer complete flag. + * @arg DMA1_FLAG_HT4: DMA1 Channel4 half transfer flag. + * @arg DMA1_FLAG_TE4: DMA1 Channel4 transfer error flag. + * @arg DMA1_FLAG_GL5: DMA1 Channel5 global flag. + * @arg DMA1_FLAG_TC5: DMA1 Channel5 transfer complete flag. + * @arg DMA1_FLAG_HT5: DMA1 Channel5 half transfer flag. + * @arg DMA1_FLAG_TE5: DMA1 Channel5 transfer error flag. + * @arg DMA1_FLAG_GL6: DMA1 Channel6 global flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_TC6: DMA1 Channel6 transfer complete flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_HT6: DMA1 Channel6 half transfer flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_TE6: DMA1 Channel6 transfer error flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_GL7: DMA1 Channel7 global flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_TC7: DMA1 Channel7 transfer complete flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_HT7: DMA1 Channel7 half transfer flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_FLAG_TE7: DMA1 Channel7 transfer error flag, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA2_FLAG_GL1: DMA2 Channel1 global flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TC1: DMA2 Channel1 transfer complete flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_HT1: DMA2 Channel1 half transfer flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TE1: DMA2 Channel1 transfer error flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_GL2: DMA2 Channel2 global flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TC2: DMA2 Channel2 transfer complete flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_HT2: DMA2 Channel2 half transfer flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TE2: DMA2 Channel2 transfer error flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_GL3: DMA2 Channel3 global flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TC3: DMA2 Channel3 transfer complete flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_HT3: DMA2 Channel3 half transfer flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TE3: DMA2 Channel3 transfer error flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_GL4: DMA2 Channel4 global flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TC4: DMA2 Channel4 transfer complete flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_HT4: DMA2 Channel4 half transfer flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TE4: DMA2 Channel4 transfer error flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_GL5: DMA2 Channel5 global flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TC5: DMA2 Channel5 transfer complete flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_HT5: DMA2 Channel5 half transfer flag, applicable only for STM32FO91 devices. + * @arg DMA2_FLAG_TE5: DMA2 Channel5 transfer error flag, applicable only for STM32FO91 devices. + * + * @note Clearing the Global flag (DMAy_FLAG_GLx) results in clearing all other flags + * relative to the same channel (Transfer Complete, Half-transfer Complete and + * Transfer Error flags: DMAy_FLAG_TCx, DMAy_FLAG_HTx and DMAy_FLAG_TEx). + * + * @retval None + */ +void DMA_ClearFlag(uint32_t DMAy_FLAG) +{ + /* Check the parameters */ + assert_param(IS_DMA_CLEAR_FLAG(DMAy_FLAG)); + +/* Calculate the used DMAy */ + if ((DMAy_FLAG & FLAG_Mask) != (uint32_t)RESET) + { + /* Clear the selected DMAy flags */ + DMA2->IFCR = DMAy_FLAG; + } + else + { + /* Clear the selected DMAy flags */ + DMA1->IFCR = DMAy_FLAG; + } +} + +/** + * @brief Checks whether the specified DMAy Channelx interrupt has occurred or not. + * @param DMA_IT: specifies the DMA interrupt source to check. + * This parameter can be one of the following values: + * @arg DMA1_IT_GL1: DMA1 Channel1 global interrupt. + * @arg DMA1_IT_TC1: DMA1 Channel1 transfer complete interrupt. + * @arg DMA1_IT_HT1: DMA1 Channel1 half transfer interrupt. + * @arg DMA1_IT_TE1: DMA1 Channel1 transfer error interrupt. + * @arg DMA1_IT_GL2: DMA1 Channel2 global interrupt. + * @arg DMA1_IT_TC2: DMA1 Channel2 transfer complete interrupt. + * @arg DMA1_IT_HT2: DMA1 Channel2 half transfer interrupt. + * @arg DMA1_IT_TE2: DMA1 Channel2 transfer error interrupt. + * @arg DMA1_IT_GL3: DMA1 Channel3 global interrupt. + * @arg DMA1_IT_TC3: DMA1 Channel3 transfer complete interrupt. + * @arg DMA1_IT_HT3: DMA1 Channel3 half transfer interrupt. + * @arg DMA1_IT_TE3: DMA1 Channel3 transfer error interrupt. + * @arg DMA1_IT_GL4: DMA1 Channel4 global interrupt. + * @arg DMA1_IT_TC4: DMA1 Channel4 transfer complete interrupt. + * @arg DMA1_IT_HT4: DMA1 Channel4 half transfer interrupt. + * @arg DMA1_IT_TE4: DMA1 Channel4 transfer error interrupt. + * @arg DMA1_IT_GL5: DMA1 Channel5 global interrupt. + * @arg DMA1_IT_TC5: DMA1 Channel5 transfer complete interrupt. + * @arg DMA1_IT_HT5: DMA1 Channel5 half transfer interrupt. + * @arg DMA1_IT_TE5: DMA1 Channel5 transfer error interrupt. + * @arg DMA1_IT_GL6: DMA1 Channel6 global interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_TC6: DMA1 Channel6 transfer complete interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_HT6: DMA1 Channel6 half transfer interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_TE6: DMA1 Channel6 transfer error interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_GL7: DMA1 Channel7 global interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_TC7: DMA1 Channel7 transfer complete interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_HT7: DMA1 Channel7 half transfer interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_TE7: DMA1 Channel7 transfer error interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA2_IT_GL1: DMA2 Channel1 global interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TC1: DMA2 Channel1 transfer complete interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_HT1: DMA2 Channel1 half transfer interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TE1: DMA2 Channel1 transfer error interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_GL2: DMA2 Channel2 global interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TC2: DMA2 Channel2 transfer complete interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_HT2: DMA2 Channel2 half transfer interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TE2: DMA2 Channel2 transfer error interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_GL3: DMA2 Channel3 global interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TC3: DMA2 Channel3 transfer complete interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_HT3: DMA2 Channel3 half transfer interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TE3: DMA2 Channel3 transfer error interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_GL4: DMA2 Channel4 global interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TC4: DMA2 Channel4 transfer complete interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_HT4: DMA2 Channel4 half transfer interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TE4: DMA2 Channel4 transfer error interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_GL5: DMA2 Channel5 global interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TC5: DMA2 Channel5 transfer complete interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_HT5: DMA2 Channel5 half transfer interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TE5: DMA2 Channel5 transfer error interrupt, applicable only for STM32FO91 devices. + * @note The Global interrupt (DMAy_FLAG_GLx) is set whenever any of the other + * interrupts relative to the same channel is set (Transfer Complete, + * Half-transfer Complete or Transfer Error interrupts: DMAy_IT_TCx, + * DMAy_IT_HTx or DMAy_IT_TEx). + * + * @retval The new state of DMA_IT (SET or RESET). + */ +ITStatus DMA_GetITStatus(uint32_t DMAy_IT) +{ + ITStatus bitstatus = RESET; + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_DMA_GET_IT(DMAy_IT)); + + /* Calculate the used DMA */ + if ((DMAy_IT & FLAG_Mask) != (uint32_t)RESET) + { + /* Get DMA2 ISR register value */ + tmpreg = DMA2->ISR; + } + else + { + /* Get DMA1 ISR register value */ + tmpreg = DMA1->ISR; + } + + /* Check the status of the specified DMAy interrupt */ + if ((tmpreg & DMAy_IT) != (uint32_t)RESET) + { + /* DMAy_IT is set */ + bitstatus = SET; + } + else + { + /* DMAy_IT is reset */ + bitstatus = RESET; + } + /* Return the DMAy_IT status */ + return bitstatus; +} + +/** + * @brief Clears the DMAy Channelx's interrupt pending bits. + * @param DMA_IT: specifies the DMA interrupt pending bit to clear. + * This parameter can be any combination (for the same DMA) of the following values: + * @arg DMA1_IT_GL1: DMA1 Channel1 global interrupt. + * @arg DMA1_IT_TC1: DMA1 Channel1 transfer complete interrupt. + * @arg DMA1_IT_HT1: DMA1 Channel1 half transfer interrupt. + * @arg DMA1_IT_TE1: DMA1 Channel1 transfer error interrupt. + * @arg DMA1_IT_GL2: DMA1 Channel2 global interrupt. + * @arg DMA1_IT_TC2: DMA1 Channel2 transfer complete interrupt. + * @arg DMA1_IT_HT2: DMA1 Channel2 half transfer interrupt. + * @arg DMA1_IT_TE2: DMA1 Channel2 transfer error interrupt. + * @arg DMA1_IT_GL3: DMA1 Channel3 global interrupt. + * @arg DMA1_IT_TC3: DMA1 Channel3 transfer complete interrupt. + * @arg DMA1_IT_HT3: DMA1 Channel3 half transfer interrupt. + * @arg DMA1_IT_TE3: DMA1 Channel3 transfer error interrupt. + * @arg DMA1_IT_GL4: DMA1 Channel4 global interrupt. + * @arg DMA1_IT_TC4: DMA1 Channel4 transfer complete interrupt. + * @arg DMA1_IT_HT4: DMA1 Channel4 half transfer interrupt. + * @arg DMA1_IT_TE4: DMA1 Channel4 transfer error interrupt. + * @arg DMA1_IT_GL5: DMA1 Channel5 global interrupt. + * @arg DMA1_IT_TC5: DMA1 Channel5 transfer complete interrupt. + * @arg DMA1_IT_HT5: DMA1 Channel5 half transfer interrupt. + * @arg DMA1_IT_TE5: DMA1 Channel5 transfer error interrupt. + * @arg DMA1_IT_GL6: DMA1 Channel6 global interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_TC6: DMA1 Channel6 transfer complete interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_HT6: DMA1 Channel6 half transfer interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_TE6: DMA1 Channel6 transfer error interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_GL7: DMA1 Channel7 global interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_TC7: DMA1 Channel7 transfer complete interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_HT7: DMA1 Channel7 half transfer interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA1_IT_TE7: DMA1 Channel7 transfer error interrupt, applicable only for STM32F072 and STM32FO91 devices. + * @arg DMA2_IT_GL1: DMA2 Channel1 global interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TC1: DMA2 Channel1 transfer complete interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_HT1: DMA2 Channel1 half transfer interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TE1: DMA2 Channel1 transfer error interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_GL2: DMA2 Channel2 global interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TC2: DMA2 Channel2 transfer complete interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_HT2: DMA2 Channel2 half transfer interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TE2: DMA2 Channel2 transfer error interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_GL3: DMA2 Channel3 global interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TC3: DMA2 Channel3 transfer complete interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_HT3: DMA2 Channel3 half transfer interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TE3: DMA2 Channel3 transfer error interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_GL4: DMA2 Channel4 global interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TC4: DMA2 Channel4 transfer complete interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_HT4: DMA2 Channel4 half transfer interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TE4: DMA2 Channel4 transfer error interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_GL5: DMA2 Channel5 global interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TC5: DMA2 Channel5 transfer complete interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_HT5: DMA2 Channel5 half transfer interrupt, applicable only for STM32FO91 devices. + * @arg DMA2_IT_TE5: DMA2 Channel5 transfer error interrupt, applicable only for STM32FO91 devices. + * + * @note Clearing the Global interrupt (DMAy_IT_GLx) results in clearing all other + * interrupts relative to the same channel (Transfer Complete, Half-transfer + * Complete and Transfer Error interrupts: DMAy_IT_TCx, DMAy_IT_HTx and + * DMAy_IT_TEx). + * + * @retval None + */ +void DMA_ClearITPendingBit(uint32_t DMAy_IT) +{ + /* Check the parameters */ + assert_param(IS_DMA_CLEAR_IT(DMAy_IT)); + + /* Calculate the used DMAy */ + if ((DMAy_IT & FLAG_Mask) != (uint32_t)RESET) + { + /* Clear the selected DMAy interrupt pending bits */ + DMA2->IFCR = DMAy_IT; + } + else + { + /* Clear the selected DMAy interrupt pending bits */ + DMA1->IFCR = DMAy_IT; + } +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_exti.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_exti.c new file mode 100644 index 00000000..5c0bd6a2 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_exti.c @@ -0,0 +1,314 @@ +/** + ****************************************************************************** + * @file stm32f0xx_exti.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the EXTI peripheral: + * + Initialization and Configuration + * + Interrupts and flags management + * + * @verbatim + ============================================================================== + ##### EXTI features ##### + ============================================================================== + [..] External interrupt/event lines are mapped as following: + (#) All available GPIO pins are connected to the 16 external + interrupt/event lines from EXTI0 to EXTI15. + (#) EXTI line 16 is connected to the PVD output, not applicable for STM32F030 devices. + (#) EXTI line 17 is connected to the RTC Alarm event. + (#) EXTI line 18 is connected to the RTC Alarm event, applicable only for STM32F072 devices. + (#) EXTI line 19 is connected to the RTC Tamper and TimeStamp events. + (#) EXTI line 20 is connected to the RTC wakeup event, applicable only for STM32F072 devices. + (#) EXTI line 21 is connected to the Comparator 1 wakeup event, applicable only for STM32F051 and STM32F072 devices. + (#) EXTI line 22 is connected to the Comparator 2 wakeup event, applicable only for STM32F051 and STM32F072 devices. + (#) EXTI line 23 is connected to the I2C1 wakeup event, not applicable for STM32F030 devices. + (#) EXTI line 25 is connected to the USART1 wakeup event, not applicable for STM32F030 devices. + (#) EXTI line 26 is connected to the USART2 wakeup event, applicable only for STM32F072 devices. + (#) EXTI line 27 is connected to the CEC wakeup event, applicable only for STM32F051 and STM32F072 devices. + (#) EXTI line 31 is connected to the VDD USB monitor event, applicable only for STM32F072 devices. + + ##### How to use this driver ##### + ============================================================================== + [..] In order to use an I/O pin as an external interrupt source, follow + steps below: + (#) Configure the I/O in input mode using GPIO_Init() + (#) Select the input source pin for the EXTI line using + SYSCFG_EXTILineConfig(). + (#) Select the mode(interrupt, event) and configure the trigger selection + (Rising, falling or both) using EXTI_Init(). For the internal interrupt, + the trigger selection is not needed( the active edge is always the rising one). + (#) Configure NVIC IRQ channel mapped to the EXTI line using NVIC_Init(). + (#) Optionally, you can generate a software interrupt using the function EXTI_GenerateSWInterrupt(). + [..] + (@) SYSCFG APB clock must be enabled to get write access to SYSCFG_EXTICRx + registers using RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE); + @endverbatim + * + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_exti.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup EXTI + * @brief EXTI driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +#define EXTI_LINENONE ((uint32_t)0x00000) /* No interrupt selected */ + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup EXTI_Private_Functions + * @{ + */ + +/** @defgroup EXTI_Group1 Initialization and Configuration functions + * @brief Initialization and Configuration functions + * +@verbatim + ============================================================================== + ##### Initialization and Configuration functions ##### + ============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the EXTI peripheral registers to their default reset + * values. + * @param None + * @retval None + */ +void EXTI_DeInit(void) +{ + EXTI->IMR = 0x0F940000; + EXTI->EMR = 0x00000000; + EXTI->RTSR = 0x00000000; + EXTI->FTSR = 0x00000000; + EXTI->PR = 0x006BFFFF; +} + +/** + * @brief Initializes the EXTI peripheral according to the specified + * parameters in the EXTI_InitStruct. + * @param EXTI_InitStruct: pointer to a EXTI_InitTypeDef structure that + * contains the configuration information for the EXTI peripheral. + * @retval None + */ +void EXTI_Init(EXTI_InitTypeDef* EXTI_InitStruct) +{ + uint32_t tmp = 0; + + /* Check the parameters */ + assert_param(IS_EXTI_MODE(EXTI_InitStruct->EXTI_Mode)); + assert_param(IS_EXTI_TRIGGER(EXTI_InitStruct->EXTI_Trigger)); + assert_param(IS_EXTI_LINE(EXTI_InitStruct->EXTI_Line)); + assert_param(IS_FUNCTIONAL_STATE(EXTI_InitStruct->EXTI_LineCmd)); + + tmp = (uint32_t)EXTI_BASE; + + if (EXTI_InitStruct->EXTI_LineCmd != DISABLE) + { + /* Clear EXTI line configuration */ + EXTI->IMR &= ~EXTI_InitStruct->EXTI_Line; + EXTI->EMR &= ~EXTI_InitStruct->EXTI_Line; + + tmp += EXTI_InitStruct->EXTI_Mode; + + *(__IO uint32_t *) tmp |= EXTI_InitStruct->EXTI_Line; + + /* Clear Rising Falling edge configuration */ + EXTI->RTSR &= ~EXTI_InitStruct->EXTI_Line; + EXTI->FTSR &= ~EXTI_InitStruct->EXTI_Line; + + /* Select the trigger for the selected interrupts */ + if (EXTI_InitStruct->EXTI_Trigger == EXTI_Trigger_Rising_Falling) + { + /* Rising Falling edge */ + EXTI->RTSR |= EXTI_InitStruct->EXTI_Line; + EXTI->FTSR |= EXTI_InitStruct->EXTI_Line; + } + else + { + tmp = (uint32_t)EXTI_BASE; + tmp += EXTI_InitStruct->EXTI_Trigger; + + *(__IO uint32_t *) tmp |= EXTI_InitStruct->EXTI_Line; + } + } + else + { + tmp += EXTI_InitStruct->EXTI_Mode; + + /* Disable the selected external lines */ + *(__IO uint32_t *) tmp &= ~EXTI_InitStruct->EXTI_Line; + } +} + +/** + * @brief Fills each EXTI_InitStruct member with its reset value. + * @param EXTI_InitStruct: pointer to a EXTI_InitTypeDef structure which will + * be initialized. + * @retval None + */ +void EXTI_StructInit(EXTI_InitTypeDef* EXTI_InitStruct) +{ + EXTI_InitStruct->EXTI_Line = EXTI_LINENONE; + EXTI_InitStruct->EXTI_Mode = EXTI_Mode_Interrupt; + EXTI_InitStruct->EXTI_Trigger = EXTI_Trigger_Falling; + EXTI_InitStruct->EXTI_LineCmd = DISABLE; +} + +/** + * @brief Generates a Software interrupt on selected EXTI line. + * @param EXTI_Line: specifies the EXTI line on which the software interrupt + * will be generated. + * This parameter can be any combination of EXTI_Linex where x can be (0..27). + * @retval None + */ +void EXTI_GenerateSWInterrupt(uint32_t EXTI_Line) +{ + /* Check the parameters */ + assert_param(IS_EXTI_LINE(EXTI_Line)); + + EXTI->SWIER |= EXTI_Line; +} + +/** + * @} + */ + +/** @defgroup EXTI_Group2 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + ============================================================================== + ##### Interrupts and flags management functions ##### + ============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Checks whether the specified EXTI line flag is set or not. + * @param EXTI_Line: specifies the EXTI line flag to check. + * This parameter can be EXTI_Linex where x can be (0..27). + * @retval The new state of EXTI_Line (SET or RESET). + */ +FlagStatus EXTI_GetFlagStatus(uint32_t EXTI_Line) +{ + FlagStatus bitstatus = RESET; + /* Check the parameters */ + assert_param(IS_GET_EXTI_LINE(EXTI_Line)); + + if ((EXTI->PR & EXTI_Line) != (uint32_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + return bitstatus; +} + +/** + * @brief Clears the EXTI's line pending flags. + * @param EXTI_Line: specifies the EXTI lines flags to clear. + * This parameter can be any combination of EXTI_Linex where x can be (0..27). + * @retval None + */ +void EXTI_ClearFlag(uint32_t EXTI_Line) +{ + /* Check the parameters */ + assert_param(IS_EXTI_LINE(EXTI_Line)); + + EXTI->PR = EXTI_Line; +} + +/** + * @brief Checks whether the specified EXTI line is asserted or not. + * @param EXTI_Line: specifies the EXTI line to check. + * This parameter can be EXTI_Linex where x can be (0..27). + * @retval The new state of EXTI_Line (SET or RESET). + */ +ITStatus EXTI_GetITStatus(uint32_t EXTI_Line) +{ + ITStatus bitstatus = RESET; + + /* Check the parameters */ + assert_param(IS_GET_EXTI_LINE(EXTI_Line)); + + if ((EXTI->PR & EXTI_Line) != (uint32_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + return bitstatus; +} + +/** + * @brief Clears the EXTI's line pending bits. + * @param EXTI_Line: specifies the EXTI lines to clear. + * This parameter can be any combination of EXTI_Linex where x can be (0..27). + * @retval None + */ +void EXTI_ClearITPendingBit(uint32_t EXTI_Line) +{ + /* Check the parameters */ + assert_param(IS_EXTI_LINE(EXTI_Line)); + + EXTI->PR = EXTI_Line; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_flash.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_flash.c new file mode 100644 index 00000000..98ff4aa8 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_flash.c @@ -0,0 +1,1256 @@ +/** + ****************************************************************************** + * @file stm32f0xx_flash.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the FLASH peripheral: + * - FLASH Interface configuration + * - FLASH Memory Programming + * - Option Bytes Programming + * - Interrupts and flags management + * + * @verbatim + =============================================================================== + ##### How to use this driver ##### + =============================================================================== + [..] This driver provides functions to configure and program the Flash + memory of all STM32F0xx devices. These functions are split in 4 groups + (#) FLASH Interface configuration functions: this group includes the + management of following features: + (++) Set the latency + (++) Enable/Disable the prefetch buffer + + (#) FLASH Memory Programming functions: this group includes all needed + functions to erase and program the main memory: + (++) Lock and Unlock the Flash interface. + (++) Erase function: Erase Page, erase all pages. + (++) Program functions: Half Word and Word write. + + (#) FLASH Option Bytes Programming functions: this group includes all + needed functions to: + (++) Lock and Unlock the Flash Option bytes. + (++) Launch the Option Bytes loader + (++) Erase the Option Bytes + (++)Set/Reset the write protection + (++) Set the Read protection Level + (++) Program the user option Bytes + (++) Set/Reset the BOOT1 bit + (++) Enable/Disable the VDDA Analog Monitoring + (++) Get the user option bytes + (++) Get the Write protection + (++) Get the read protection status + + (#) FLASH Interrupts and flag management functions: this group includes + all needed functions to: + (++) Enable/Disable the flash interrupt sources + (++) Get flags status + (++) Clear flags + (++) Get Flash operation status + (++) Wait for last flash operation + + @endverbatim + + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_flash.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup FLASH + * @brief FLASH driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup FLASH_Private_Functions + * @{ + */ + +/** @defgroup FLASH_Group1 FLASH Interface configuration functions + * @brief FLASH Interface configuration functions + * +@verbatim + =============================================================================== + ##### FLASH Interface configuration functions ##### + =============================================================================== + + [..] FLASH_Interface configuration_Functions, includes the following functions: + (+) void FLASH_SetLatency(uint32_t FLASH_Latency): + [..] To correctly read data from Flash memory, the number of wait states (LATENCY) + must be correctly programmed according to the frequency of the CPU clock (HCLK) + [..] + +--------------------------------------------- + + | Wait states | HCLK clock frequency (MHz) | + |---------------|------------------------------| + |0WS(1CPU cycle)| 0 < HCLK <= 24 | + |---------------|------------------------------| + |1WS(2CPU cycle)| 24 < HCLK <= 48 | + +----------------------------------------------+ + [..] + (+) void FLASH_PrefetchBufferCmd(FunctionalState NewState); + [..] + All these functions don't need the unlock sequence. + +@endverbatim + * @{ + */ + +/** + * @brief Sets the code latency value. + * @param FLASH_Latency: specifies the FLASH Latency value. + * This parameter can be one of the following values: + * @arg FLASH_Latency_0: FLASH Zero Latency cycle + * @arg FLASH_Latency_1: FLASH One Latency cycle + * @retval None + */ +void FLASH_SetLatency(uint32_t FLASH_Latency) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_FLASH_LATENCY(FLASH_Latency)); + + /* Read the ACR register */ + tmpreg = FLASH->ACR; + + /* Sets the Latency value */ + tmpreg &= (uint32_t) (~((uint32_t)FLASH_ACR_LATENCY)); + tmpreg |= FLASH_Latency; + + /* Write the ACR register */ + FLASH->ACR = tmpreg; +} + +/** + * @brief Enables or disables the Prefetch Buffer. + * @param NewState: new state of the FLASH prefetch buffer. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void FLASH_PrefetchBufferCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if(NewState != DISABLE) + { + FLASH->ACR |= FLASH_ACR_PRFTBE; + } + else + { + FLASH->ACR &= (uint32_t)(~((uint32_t)FLASH_ACR_PRFTBE)); + } +} + +/** + * @brief Checks whether the FLASH Prefetch Buffer status is set or not. + * @param None + * @retval FLASH Prefetch Buffer Status (SET or RESET). + */ +FlagStatus FLASH_GetPrefetchBufferStatus(void) +{ + FlagStatus bitstatus = RESET; + + if ((FLASH->ACR & FLASH_ACR_PRFTBS) != (uint32_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + /* Return the new state of FLASH Prefetch Buffer Status (SET or RESET) */ + return bitstatus; +} + +/** + * @} + */ + +/** @defgroup FLASH_Group2 FLASH Memory Programming functions + * @brief FLASH Memory Programming functions + * +@verbatim + =============================================================================== + ##### FLASH Memory Programming functions ##### + =============================================================================== + + [..] The FLASH Memory Programming functions, includes the following functions: + (+) void FLASH_Unlock(void); + (+) void FLASH_Lock(void); + (+) FLASH_Status FLASH_ErasePage(uint32_t Page_Address); + (+) FLASH_Status FLASH_EraseAllPages(void); + (+) FLASH_Status FLASH_ProgramWord(uint32_t Address, uint32_t Data); + (+) FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data); + + [..] Any operation of erase or program should follow these steps: + + (#) Call the FLASH_Unlock() function to enable the flash control register and + program memory access + (#) Call the desired function to erase page or program data + (#) Call the FLASH_Lock() to disable the flash program memory access + (recommended to protect the FLASH memory against possible unwanted operation) + +@endverbatim + * @{ + */ + +/** + * @brief Unlocks the FLASH control register and program memory access. + * @param None + * @retval None + */ +void FLASH_Unlock(void) +{ + if((FLASH->CR & FLASH_CR_LOCK) != RESET) + { + /* Unlocking the program memory access */ + FLASH->KEYR = FLASH_FKEY1; + FLASH->KEYR = FLASH_FKEY2; + } +} + +/** + * @brief Locks the Program memory access. + * @param None + * @retval None + */ +void FLASH_Lock(void) +{ + /* Set the LOCK Bit to lock the FLASH control register and program memory access */ + FLASH->CR |= FLASH_CR_LOCK; +} + +/** + * @brief Erases a specified page in program memory. + * @note To correctly run this function, the FLASH_Unlock() function must be called before. + * @note Call the FLASH_Lock() to disable the flash memory access (recommended + * to protect the FLASH memory against possible unwanted operation) + * @param Page_Address: The page address in program memory to be erased. + * @note A Page is erased in the Program memory only if the address to load + * is the start address of a page (multiple of 1024 bytes). + * @retval FLASH Status: The returned value can be: + * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT. + */ +FLASH_Status FLASH_ErasePage(uint32_t Page_Address) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Check the parameters */ + assert_param(IS_FLASH_PROGRAM_ADDRESS(Page_Address)); + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* If the previous operation is completed, proceed to erase the page */ + FLASH->CR |= FLASH_CR_PER; + FLASH->AR = Page_Address; + FLASH->CR |= FLASH_CR_STRT; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + /* Disable the PER Bit */ + FLASH->CR &= ~FLASH_CR_PER; + } + + /* Return the Erase Status */ + return status; +} + +/** + * @brief Erases all FLASH pages. + * @note To correctly run this function, the FLASH_Unlock() function must be called before. + * @note Call the FLASH_Lock() to disable the flash memory access (recommended + * to protect the FLASH memory against possible unwanted operation) + * @param None + * @retval FLASH Status: The returned value can be: FLASH_ERROR_PG, + * FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT. + */ +FLASH_Status FLASH_EraseAllPages(void) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* if the previous operation is completed, proceed to erase all pages */ + FLASH->CR |= FLASH_CR_MER; + FLASH->CR |= FLASH_CR_STRT; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + /* Disable the MER Bit */ + FLASH->CR &= ~FLASH_CR_MER; + } + + /* Return the Erase Status */ + return status; +} + +/** + * @brief Programs a word at a specified address. + * @note To correctly run this function, the FLASH_Unlock() function must be called before. + * @note Call the FLASH_Lock() to disable the flash memory access (recommended + * to protect the FLASH memory against possible unwanted operation) + * @param Address: specifies the address to be programmed. + * @param Data: specifies the data to be programmed. + * @retval FLASH Status: The returned value can be: FLASH_ERROR_PG, + * FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT. + */ +FLASH_Status FLASH_ProgramWord(uint32_t Address, uint32_t Data) +{ + FLASH_Status status = FLASH_COMPLETE; + __IO uint32_t tmp = 0; + + /* Check the parameters */ + assert_param(IS_FLASH_PROGRAM_ADDRESS(Address)); + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* If the previous operation is completed, proceed to program the new first + half word */ + FLASH->CR |= FLASH_CR_PG; + + *(__IO uint16_t*)Address = (uint16_t)Data; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* If the previous operation is completed, proceed to program the new second + half word */ + tmp = Address + 2; + + *(__IO uint16_t*) tmp = Data >> 16; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + /* Disable the PG Bit */ + FLASH->CR &= ~FLASH_CR_PG; + } + else + { + /* Disable the PG Bit */ + FLASH->CR &= ~FLASH_CR_PG; + } + } + + /* Return the Program Status */ + return status; +} + +/** + * @brief Programs a half word at a specified address. + * @note To correctly run this function, the FLASH_Unlock() function must be called before. + * @note Call the FLASH_Lock() to disable the flash memory access (recommended + * to protect the FLASH memory against possible unwanted operation) + * @param Address: specifies the address to be programmed. + * @param Data: specifies the data to be programmed. + * @retval FLASH Status: The returned value can be: FLASH_ERROR_PG, + * FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT. + */ +FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Check the parameters */ + assert_param(IS_FLASH_PROGRAM_ADDRESS(Address)); + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* If the previous operation is completed, proceed to program the new data */ + FLASH->CR |= FLASH_CR_PG; + + *(__IO uint16_t*)Address = Data; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + /* Disable the PG Bit */ + FLASH->CR &= ~FLASH_CR_PG; + } + + /* Return the Program Status */ + return status; +} + +/** + * @} + */ + +/** @defgroup FLASH_Group3 Option Bytes Programming functions + * @brief Option Bytes Programming functions + * +@verbatim + =============================================================================== + ##### Option Bytes Programming functions ##### + =============================================================================== + + [..] The FLASH_Option Bytes Programming_functions, includes the following functions: + (+) void FLASH_OB_Unlock(void); + (+) void FLASH_OB_Lock(void); + (+) void FLASH_OB_Launch(void); + (+) FLASH_Status FLASH_OB_Erase(void); + (+) FLASH_Status FLASH_OB_WRPConfig(uint32_t OB_WRP, FunctionalState NewState); + (+) FLASH_Status FLASH_OB_RDPConfig(uint8_t OB_RDP); + (+) FLASH_Status FLASH_OB_UserConfig(uint8_t OB_IWDG, uint8_t OB_STOP, uint8_t OB_STDBY); + (+) FLASH_Status FLASH_OB_BOOTConfig(uint8_t OB_BOOT1); + (+) FLASH_Status FLASH_OB_VDDAConfig(uint8_t OB_VDDA_ANALOG); + (+) FLASH_Status FLASH_OB_WriteUser(uint8_t OB_USER); + (+) FLASH_OB_ProgramData(uint32_t Address, uint8_t Data); + (+) uint8_t FLASH_OB_GetUser(void); + (+) uint32_t FLASH_OB_GetWRP(void); + (+) FlagStatus FLASH_OB_GetRDP(void); + + [..] Any operation of erase or program should follow these steps: + + (#) Call the FLASH_OB_Unlock() function to enable the Option Bytes registers access + + (#) Call one or several functions to program the desired option bytes + (++) FLASH_Status FLASH_OB_RDPConfig(uint8_t OB_RDP) => to set the desired read Protection Level + (++) FLASH_Status FLASH_OB_WRPConfig(uint32_t OB_WRP, FunctionalState NewState) + => to Enable/Disable the desired sector write protection + (++) FLASH_Status FLASH_OB_UserConfig(uint8_t OB_IWDG, uint8_t OB_STOP, uint8_t OB_STDBY) + => to configure the user option Bytes: IWDG, STOP and the Standby. + (++) FLASH_Status FLASH_OB_BOOTConfig(uint8_t OB_BOOT1) + => to set or reset BOOT1 + (++) FLASH_Status FLASH_OB_VDDAConfig(uint8_t OB_VDDA_ANALOG) + => to enable or disable the VDDA Analog Monitoring + (++) You can write all User Options bytes at once using a single function + by calling FLASH_Status FLASH_OB_WriteUser(uint8_t OB_USER) + (++) FLASH_OB_ProgramData(uint32_t Address, uint8_t Data) to program the + two half word in the option bytes + + (#) Once all needed option bytes to be programmed are correctly written, call the + FLASH_OB_Launch(void) function to launch the Option Bytes programming process. + + (#) Call the FLASH_OB_Lock() to disable the Option Bytes registers access (recommended + to protect the option Bytes against possible unwanted operations) + +@endverbatim + * @{ + */ + +/** + * @brief Unlocks the option bytes block access. + * @param None + * @retval None + */ +void FLASH_OB_Unlock(void) +{ + if((FLASH->CR & FLASH_CR_OPTWRE) == RESET) + { + /* Unlocking the option bytes block access */ + FLASH->OPTKEYR = FLASH_OPTKEY1; + FLASH->OPTKEYR = FLASH_OPTKEY2; + } +} + +/** + * @brief Locks the option bytes block access. + * @param None + * @retval None + */ +void FLASH_OB_Lock(void) +{ + /* Set the OPTWREN Bit to lock the option bytes block access */ + FLASH->CR &= ~FLASH_CR_OPTWRE; +} + +/** + * @brief Launch the option byte loading. + * @param None + * @retval None + */ +void FLASH_OB_Launch(void) +{ + /* Set the OBL_Launch bit to launch the option byte loading */ + FLASH->CR |= FLASH_CR_OBL_LAUNCH; +} + +/** + * @brief Erases the FLASH option bytes. + * @note To correctly run this function, the FLASH_OB_Unlock() function must be called before. + * @note Call the FLASH_OB_Lock() to disable the flash control register access and the option + * bytes (recommended to protect the FLASH memory against possible unwanted operation) + * @note This functions erases all option bytes except the Read protection (RDP). + * @param None + * @retval FLASH Status: The returned value can be: FLASH_ERROR_PG, + * FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT. + */ +FLASH_Status FLASH_OB_Erase(void) +{ + uint16_t rdptmp = OB_RDP_Level_0; + + FLASH_Status status = FLASH_COMPLETE; + + /* Get the actual read protection Option Byte value */ + if(FLASH_OB_GetRDP() != RESET) + { + rdptmp = 0x00; + } + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* If the previous operation is completed, proceed to erase the option bytes */ + FLASH->CR |= FLASH_CR_OPTER; + FLASH->CR |= FLASH_CR_STRT; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* If the erase operation is completed, disable the OPTER Bit */ + FLASH->CR &= ~FLASH_CR_OPTER; + + /* Enable the Option Bytes Programming operation */ + FLASH->CR |= FLASH_CR_OPTPG; + + /* Restore the last read protection Option Byte value */ + OB->RDP = (uint16_t)rdptmp; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status != FLASH_TIMEOUT) + { + /* if the program operation is completed, disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + else + { + if (status != FLASH_TIMEOUT) + { + /* Disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + } + /* Return the erase status */ + return status; +} + +/** + * @brief Write protects the desired pages + * @note To correctly run this function, the FLASH_OB_Unlock() function must be called before. + * @note Call the FLASH_OB_Lock() to disable the flash control register access and the option + * bytes (recommended to protect the FLASH memory against possible unwanted operation) + * @param OB_WRP: specifies the address of the pages to be write protected. + * This parameter can be: + * @arg OB_WRP_Pages0to3..OB_WRP_Pages60to63 + * @arg OB_WRP_AllPages + * @retval FLASH Status: The returned value can be: + * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT. + */ +FLASH_Status FLASH_OB_EnableWRP(uint32_t OB_WRP) +{ + uint16_t WRP0_Data = 0xFFFF, WRP1_Data = 0xFFFF, WRP2_Data = 0xFFFF, WRP3_Data = 0xFFFF; + + FLASH_Status status = FLASH_COMPLETE; + + /* Check the parameters */ + assert_param(IS_OB_WRP(OB_WRP)); + + OB_WRP = (uint32_t)(~OB_WRP); + WRP0_Data = (uint16_t)(OB_WRP & OB_WRP0_WRP0); + WRP1_Data = (uint16_t)((OB_WRP >> 8) & OB_WRP0_WRP0); + WRP2_Data = (uint16_t)((OB_WRP >> 16) & OB_WRP0_WRP0) ; + WRP3_Data = (uint16_t)((OB_WRP >> 24) & OB_WRP0_WRP0) ; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + FLASH->CR |= FLASH_CR_OPTPG; + + if(WRP0_Data != 0xFF) + { + OB->WRP0 = WRP0_Data; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + } + if((status == FLASH_COMPLETE) && (WRP1_Data != 0xFF)) + { + OB->WRP1 = WRP1_Data; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + } + if((status == FLASH_COMPLETE) && (WRP2_Data != 0xFF)) + { + OB->WRP2 = WRP2_Data; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + } + if((status == FLASH_COMPLETE) && (WRP3_Data != 0xFF)) + { + OB->WRP3 = WRP3_Data; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + } + if(status != FLASH_TIMEOUT) + { + /* if the program operation is completed, disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + /* Return the write protection operation Status */ + return status; +} + +/** + * @brief Enables or disables the read out protection. + * @note To correctly run this function, the FLASH_OB_Unlock() function must be called before. + * @note Call the FLASH_OB_Lock() to disable the flash control register access and the option + * bytes (recommended to protect the FLASH memory against possible unwanted operation) + * @param FLASH_ReadProtection_Level: specifies the read protection level. + * This parameter can be: + * @arg OB_RDP_Level_0: No protection + * @arg OB_RDP_Level_1: Read protection of the memory + * @arg OB_RDP_Level_2: Chip protection + * @note When enabling OB_RDP level 2 it's no more possible to go back to level 1 or 0 + * @retval FLASH Status: The returned value can be: + * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT. + */ +FLASH_Status FLASH_OB_RDPConfig(uint8_t OB_RDP) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Check the parameters */ + assert_param(IS_OB_RDP(OB_RDP)); + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + FLASH->CR |= FLASH_CR_OPTER; + FLASH->CR |= FLASH_CR_STRT; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* If the erase operation is completed, disable the OPTER Bit */ + FLASH->CR &= ~FLASH_CR_OPTER; + + /* Enable the Option Bytes Programming operation */ + FLASH->CR |= FLASH_CR_OPTPG; + + OB->RDP = OB_RDP; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status != FLASH_TIMEOUT) + { + /* if the program operation is completed, disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + else + { + if(status != FLASH_TIMEOUT) + { + /* Disable the OPTER Bit */ + FLASH->CR &= ~FLASH_CR_OPTER; + } + } + } + /* Return the protection operation Status */ + return status; +} + +/** + * @brief Programs the FLASH User Option Byte: IWDG_SW / RST_STOP / RST_STDBY. + * @note To correctly run this function, the FLASH_OB_Unlock() function must be called before. + * @note Call the FLASH_OB_Lock() to disable the flash control register access and the option + * bytes (recommended to protect the FLASH memory against possible unwanted operation) + * @param OB_IWDG: Selects the WDG mode + * This parameter can be one of the following values: + * @arg OB_IWDG_SW: Software WDG selected + * @arg OB_IWDG_HW: Hardware WDG selected + * @param OB_STOP: Reset event when entering STOP mode. + * This parameter can be one of the following values: + * @arg OB_STOP_NoRST: No reset generated when entering in STOP + * @arg OB_STOP_RST: Reset generated when entering in STOP + * @param OB_STDBY: Reset event when entering Standby mode. + * This parameter can be one of the following values: + * @arg OB_STDBY_NoRST: No reset generated when entering in STANDBY + * @arg OB_STDBY_RST: Reset generated when entering in STANDBY + * @retval FLASH Status: The returned value can be: + * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT. + */ +FLASH_Status FLASH_OB_UserConfig(uint8_t OB_IWDG, uint8_t OB_STOP, uint8_t OB_STDBY) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Check the parameters */ + assert_param(IS_OB_IWDG_SOURCE(OB_IWDG)); + assert_param(IS_OB_STOP_SOURCE(OB_STOP)); + assert_param(IS_OB_STDBY_SOURCE(OB_STDBY)); + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* Enable the Option Bytes Programming operation */ + FLASH->CR |= FLASH_CR_OPTPG; + + OB->USER = (uint16_t)((uint16_t)(OB_IWDG | OB_STOP) | (uint16_t)(OB_STDBY | 0xF8)); + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status != FLASH_TIMEOUT) + { + /* If the program operation is completed, disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + /* Return the Option Byte program Status */ + return status; +} + +/** + * @brief Sets or resets the BOOT1 option bit. + * @param OB_BOOT1: Set or Reset the BOOT1 option bit. + * This parameter can be one of the following values: + * @arg OB_BOOT1_RESET: BOOT1 option bit reset + * @arg OB_BOOT1_SET: BOOT1 option bit set + * @retval None + */ +FLASH_Status FLASH_OB_BOOTConfig(uint8_t OB_BOOT1) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Check the parameters */ + assert_param(IS_OB_BOOT1(OB_BOOT1)); + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* Enable the Option Bytes Programming operation */ + FLASH->CR |= FLASH_CR_OPTPG; + + OB->USER = OB_BOOT1 | 0xEF; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status != FLASH_TIMEOUT) + { + /* If the program operation is completed, disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + /* Return the Option Byte program Status */ + return status; +} + +/** + * @brief Sets or resets the BOOT0 option bit. + * @note This function is applicable only for the STM32F042 devices. + * @param OB_BOOT0: Set or Reset the BOOT0 option bit. + * This parameter can be one of the following values: + * @arg OB_BOOT0_RESET: BOOT0 option bit reset + * @arg OB_BOOT0_SET: BOOT0 option bit set + * @retval None + */ +FLASH_Status FLASH_OB_BOOT0Config(uint8_t OB_BOOT0) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Check the parameters */ + assert_param(IS_OB_BOOT0(OB_BOOT0)); + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* Enable the Option Bytes Programming operation */ + FLASH->CR |= FLASH_CR_OPTPG; + + OB->USER = OB_BOOT0 | 0xF7; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status != FLASH_TIMEOUT) + { + /* If the program operation is completed, disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + /* Return the Option Byte program Status */ + return status; +} + +/** + * @brief Sets or resets the BOOT0SW option bit. + * @note This function is applicable only for the STM32F042 devices. + * @param OB_BOOT0SW: Set or Reset the BOOT0_SW option bit. + * This parameter can be one of the following values: + * @arg OB_BOOT0_SW: BOOT0_SW option bit reset + * @arg OB_BOOT0_HW: BOOT0_SW option bit set + * @retval None + */ +FLASH_Status FLASH_OB_BOOT0SWConfig(uint8_t OB_BOOT0SW) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Check the parameters */ + assert_param(IS_OB_BOOT0SW(OB_BOOT0SW)); + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* Enable the Option Bytes Programming operation */ + FLASH->CR |= FLASH_CR_OPTPG; + + OB->USER = OB_BOOT0SW | 0x7F; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status != FLASH_TIMEOUT) + { + /* If the program operation is completed, disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + /* Return the Option Byte program Status */ + return status; +} + +/** + * @brief Sets or resets the analogue monitoring on VDDA Power source. + * @param OB_VDDA_ANALOG: Selects the analog monitoring on VDDA Power source. + * This parameter can be one of the following values: + * @arg OB_VDDA_ANALOG_ON: Analog monitoring on VDDA Power source ON + * @arg OB_VDDA_ANALOG_OFF: Analog monitoring on VDDA Power source OFF + * @retval None + */ +FLASH_Status FLASH_OB_VDDAConfig(uint8_t OB_VDDA_ANALOG) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Check the parameters */ + assert_param(IS_OB_VDDA_ANALOG(OB_VDDA_ANALOG)); + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* Enable the Option Bytes Programming operation */ + FLASH->CR |= FLASH_CR_OPTPG; + + OB->USER = OB_VDDA_ANALOG | 0xDF; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status != FLASH_TIMEOUT) + { + /* if the program operation is completed, disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + /* Return the Option Byte program Status */ + return status; +} + +/** + * @brief Sets or resets the SRAM parity. + * @param OB_SRAM_Parity: Set or Reset the SRAM parity enable bit. + * This parameter can be one of the following values: + * @arg OB_SRAM_PARITY_SET: Set SRAM parity. + * @arg OB_SRAM_PARITY_RESET: Reset SRAM parity. + * @retval None + */ +FLASH_Status FLASH_OB_SRAMParityConfig(uint8_t OB_SRAM_Parity) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Check the parameters */ + assert_param(IS_OB_SRAM_PARITY(OB_SRAM_Parity)); + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* Enable the Option Bytes Programming operation */ + FLASH->CR |= FLASH_CR_OPTPG; + + OB->USER = OB_SRAM_Parity | 0xBF; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status != FLASH_TIMEOUT) + { + /* if the program operation is completed, disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + /* Return the Option Byte program Status */ + return status; +} + +/** + * @brief Programs the FLASH User Option Byte: IWDG_SW, RST_STOP, RST_STDBY, + * BOOT1 and VDDA ANALOG monitoring. + * @note To correctly run this function, the FLASH_OB_Unlock() function must be called before. + * @note Call the FLASH_OB_Lock() to disable the flash control register access and the option + * bytes (recommended to protect the FLASH memory against possible unwanted operation) + * @param OB_USER: Selects all user option bytes + * This parameter is a combination of the following values: + * @arg OB_IWDG_SW / OB_IWDG_HW: Software / Hardware WDG selected + * @arg OB_STOP_NoRST / OB_STOP_RST: No reset / Reset generated when entering in STOP + * @arg OB_STDBY_NoRST / OB_STDBY_RST: No reset / Reset generated when entering in STANDBY + * @arg OB_BOOT1_RESET / OB_BOOT1_SET: BOOT1 Reset / Set + * @arg OB_VDDA_ANALOG_ON / OB_VDDA_ANALOG_OFF: Analog monitoring on VDDA Power source ON / OFF + * @arg OB_SRAM_PARITY_SET / OB_SRAM_PARITY_RESET: SRAM Parity SET / RESET + * @arg OB_BOOT0_RESET / OB_BOOT0_SET: BOOT0 Reset / Set + * @arg OB_BOOT0_SW / OB_BOOT0_SW: BOOT0 pin disabled / BOOT0 pin bonded with GPIO + * @retval FLASH Status: The returned value can be: + * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT. + */ +FLASH_Status FLASH_OB_WriteUser(uint8_t OB_USER) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* Enable the Option Bytes Programming operation */ + FLASH->CR |= FLASH_CR_OPTPG; + + OB->USER = OB_USER; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status != FLASH_TIMEOUT) + { + /* If the program operation is completed, disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + /* Return the Option Byte program Status */ + return status; + +} + +/** + * @brief Programs a half word at a specified Option Byte Data address. + * @note To correctly run this function, the FLASH_OB_Unlock() function must be called before. + * @note Call the FLASH_OB_Lock() to disable the flash control register access and the option + * bytes (recommended to protect the FLASH memory against possible unwanted operation) + * @param Address: specifies the address to be programmed. + * This parameter can be 0x1FFFF804 or 0x1FFFF806. + * @param Data: specifies the data to be programmed. + * @retval FLASH Status: The returned value can be: FLASH_ERROR_PG, + * FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT. + */ +FLASH_Status FLASH_OB_ProgramData(uint32_t Address, uint8_t Data) +{ + FLASH_Status status = FLASH_COMPLETE; + /* Check the parameters */ + assert_param(IS_OB_DATA_ADDRESS(Address)); + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status == FLASH_COMPLETE) + { + /* Enables the Option Bytes Programming operation */ + FLASH->CR |= FLASH_CR_OPTPG; + *(__IO uint16_t*)Address = Data; + + /* Wait for last operation to be completed */ + status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT); + + if(status != FLASH_TIMEOUT) + { + /* If the program operation is completed, disable the OPTPG Bit */ + FLASH->CR &= ~FLASH_CR_OPTPG; + } + } + /* Return the Option Byte Data Program Status */ + return status; +} + +/** + * @brief Returns the FLASH User Option Bytes values. + * @param None + * @retval The FLASH User Option Bytes . + */ +uint8_t FLASH_OB_GetUser(void) +{ + /* Return the User Option Byte */ + return (uint8_t)(FLASH->OBR >> 8); +} + +/** + * @brief Returns the FLASH Write Protection Option Bytes value. + * @param None + * @retval The FLASH Write Protection Option Bytes value + */ +uint32_t FLASH_OB_GetWRP(void) +{ + /* Return the FLASH write protection Register value */ + return (uint32_t)(FLASH->WRPR); +} + +/** + * @brief Checks whether the FLASH Read out Protection Status is set or not. + * @param None + * @retval FLASH ReadOut Protection Status(SET or RESET) + */ +FlagStatus FLASH_OB_GetRDP(void) +{ + FlagStatus readstatus = RESET; + + if ((uint8_t)(FLASH->OBR & (FLASH_OBR_RDPRT1 | FLASH_OBR_RDPRT2)) != RESET) + { + readstatus = SET; + } + else + { + readstatus = RESET; + } + return readstatus; +} + +/** + * @} + */ + +/** @defgroup FLASH_Group4 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified FLASH interrupts. + * @param FLASH_IT: specifies the FLASH interrupt sources to be enabled or + * disabled. + * This parameter can be any combination of the following values: + * @arg FLASH_IT_EOP: FLASH end of programming Interrupt + * @arg FLASH_IT_ERR: FLASH Error Interrupt + * @retval None + */ +void FLASH_ITConfig(uint32_t FLASH_IT, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FLASH_IT(FLASH_IT)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if(NewState != DISABLE) + { + /* Enable the interrupt sources */ + FLASH->CR |= FLASH_IT; + } + else + { + /* Disable the interrupt sources */ + FLASH->CR &= ~(uint32_t)FLASH_IT; + } +} + +/** + * @brief Checks whether the specified FLASH flag is set or not. + * @param FLASH_FLAG: specifies the FLASH flag to check. + * This parameter can be one of the following values: + * @arg FLASH_FLAG_BSY: FLASH write/erase operations in progress flag + * @arg FLASH_FLAG_PGERR: FLASH Programming error flag flag + * @arg FLASH_FLAG_WRPERR: FLASH Write protected error flag + * @arg FLASH_FLAG_EOP: FLASH End of Programming flag + * @retval The new state of FLASH_FLAG (SET or RESET). + */ +FlagStatus FLASH_GetFlagStatus(uint32_t FLASH_FLAG) +{ + FlagStatus bitstatus = RESET; + + /* Check the parameters */ + assert_param(IS_FLASH_GET_FLAG(FLASH_FLAG)); + + if((FLASH->SR & FLASH_FLAG) != (uint32_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + /* Return the new state of FLASH_FLAG (SET or RESET) */ + return bitstatus; +} + +/** + * @brief Clears the FLASH's pending flags. + * @param FLASH_FLAG: specifies the FLASH flags to clear. + * This parameter can be any combination of the following values: + * @arg FLASH_FLAG_PGERR: FLASH Programming error flag flag + * @arg FLASH_FLAG_WRPERR: FLASH Write protected error flag + * @arg FLASH_FLAG_EOP: FLASH End of Programming flag + * @retval None + */ +void FLASH_ClearFlag(uint32_t FLASH_FLAG) +{ + /* Check the parameters */ + assert_param(IS_FLASH_CLEAR_FLAG(FLASH_FLAG)); + + /* Clear the flags */ + FLASH->SR = FLASH_FLAG; +} + +/** + * @brief Returns the FLASH Status. + * @param None + * @retval FLASH Status: The returned value can be: + * FLASH_BUSY, FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP or FLASH_COMPLETE. + */ +FLASH_Status FLASH_GetStatus(void) +{ + FLASH_Status FLASHstatus = FLASH_COMPLETE; + + if((FLASH->SR & FLASH_FLAG_BSY) == FLASH_FLAG_BSY) + { + FLASHstatus = FLASH_BUSY; + } + else + { + if((FLASH->SR & (uint32_t)FLASH_FLAG_WRPERR)!= (uint32_t)0x00) + { + FLASHstatus = FLASH_ERROR_WRP; + } + else + { + if((FLASH->SR & (uint32_t)(FLASH_SR_PGERR)) != (uint32_t)0x00) + { + FLASHstatus = FLASH_ERROR_PROGRAM; + } + else + { + FLASHstatus = FLASH_COMPLETE; + } + } + } + /* Return the FLASH Status */ + return FLASHstatus; +} + + +/** + * @brief Waits for a FLASH operation to complete or a TIMEOUT to occur. + * @param Timeout: FLASH programming Timeout + * @retval FLASH Status: The returned value can be: FLASH_BUSY, + * FLASH_ERROR_PROGRAM, FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT. + */ +FLASH_Status FLASH_WaitForLastOperation(uint32_t Timeout) +{ + FLASH_Status status = FLASH_COMPLETE; + + /* Check for the FLASH Status */ + status = FLASH_GetStatus(); + + /* Wait for a FLASH operation to complete or a TIMEOUT to occur */ + while((status == FLASH_BUSY) && (Timeout != 0x00)) + { + status = FLASH_GetStatus(); + Timeout--; + } + + if(Timeout == 0x00 ) + { + status = FLASH_TIMEOUT; + } + /* Return the operation status */ + return status; +} + +/** + * @} + */ + +/** + * @} + */ + + /** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_gpio.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_gpio.c new file mode 100644 index 00000000..bb2978cd --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_gpio.c @@ -0,0 +1,542 @@ +/** + ****************************************************************************** + * @file stm32f0xx_gpio.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the GPIO peripheral: + * + Initialization and Configuration functions + * + GPIO Read and Write functions + * + GPIO Alternate functions configuration functions + * + * @verbatim + * + * + =========================================================================== + ##### How to use this driver ##### + =========================================================================== + [..] + (#) Enable the GPIO AHB clock using RCC_AHBPeriphClockCmd() + (#) Configure the GPIO pin(s) using GPIO_Init() + Four possible configuration are available for each pin: + (++) Input: Floating, Pull-up, Pull-down. + (++) Output: Push-Pull (Pull-up, Pull-down or no Pull) + Open Drain (Pull-up, Pull-down or no Pull). + In output mode, the speed is configurable: Low, Medium, Fast or High. + (++) Alternate Function: Push-Pull (Pull-up, Pull-down or no Pull) + Open Drain (Pull-up, Pull-down or no Pull). + (++) Analog: required mode when a pin is to be used as ADC channel, + DAC output or comparator input. + (#) Peripherals alternate function: + (++) For ADC, DAC and comparators, configure the desired pin in analog + mode using GPIO_InitStruct->GPIO_Mode = GPIO_Mode_AN + (++) For other peripherals (TIM, USART...): + (+++) Connect the pin to the desired peripherals' Alternate + Function (AF) using GPIO_PinAFConfig() function. For PortC, + PortD and PortF, no configuration is needed. + (+++) Configure the desired pin in alternate function mode using + GPIO_InitStruct->GPIO_Mode = GPIO_Mode_AF + (+++) Select the type, pull-up/pull-down and output speed via + GPIO_PuPd, GPIO_OType and GPIO_Speed members + (+++) Call GPIO_Init() function + (#) To get the level of a pin configured in input mode use GPIO_ReadInputDataBit() + (#) To set/reset the level of a pin configured in output mode use + GPIO_SetBits()/GPIO_ResetBits() + (#) During and just after reset, the alternate functions are not active and + the GPIO pins are configured in input floating mode (except JTAG pins). + (#) The LSE oscillator pins OSC32_IN and OSC32_OUT can be used as + general-purpose (PC14 and PC15, respectively) when the LSE oscillator + is off. The LSE has priority over the GPIO function. + (#) The HSE oscillator pins OSC_IN/OSC_OUT can be used as general-purpose + PD0 and PD1, respectively, when the HSE oscillator is off. The HSE has + priority over the GPIO function. + @endverbatim + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_gpio.h" +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup GPIO + * @brief GPIO driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup GPIO_Private_Functions + * @{ + */ + +/** @defgroup GPIO_Group1 Initialization and Configuration + * @brief Initialization and Configuration + * +@verbatim + =============================================================================== + ##### Initialization and Configuration ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the GPIOx peripheral registers to their default reset + * values. + * @param GPIOx: where x can be (A, B, C, D, E or F) to select the GPIO peripheral. + * @note GPIOE is available only for STM32F072. + * @note GPIOD is not available for STM32F031. + * @retval None + */ +void GPIO_DeInit(GPIO_TypeDef* GPIOx) +{ + /* Check the parameters */ + assert_param(IS_GPIO_ALL_PERIPH(GPIOx)); + + if(GPIOx == GPIOA) + { + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOA, ENABLE); + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOA, DISABLE); + } + else if(GPIOx == GPIOB) + { + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOB, ENABLE); + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOB, DISABLE); + } + else if(GPIOx == GPIOC) + { + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOC, ENABLE); + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOC, DISABLE); + } + else if(GPIOx == GPIOD) + { + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOD, ENABLE); + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOD, DISABLE); + } + else if(GPIOx == GPIOE) + { + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOE, ENABLE); + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOE, DISABLE); + } + else + { + if(GPIOx == GPIOF) + { + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOF, ENABLE); + RCC_AHBPeriphResetCmd(RCC_AHBPeriph_GPIOF, DISABLE); + } + } +} + +/** + * @brief Initializes the GPIOx peripheral according to the specified + * parameters in the GPIO_InitStruct. + * @param GPIOx: where x can be (A, B, C, D, E or F) to select the GPIO peripheral. + * @note GPIOE is available only for STM32F072. + * @note GPIOD is not available for STM32F031. + * @param GPIO_InitStruct: pointer to a GPIO_InitTypeDef structure that contains + * the configuration information for the specified GPIO peripheral. + * @retval None + */ +void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct) +{ + uint32_t pinpos = 0x00, pos = 0x00 , currentpin = 0x00; + + /* Check the parameters */ + assert_param(IS_GPIO_ALL_PERIPH(GPIOx)); + assert_param(IS_GPIO_PIN(GPIO_InitStruct->GPIO_Pin)); + assert_param(IS_GPIO_MODE(GPIO_InitStruct->GPIO_Mode)); + assert_param(IS_GPIO_PUPD(GPIO_InitStruct->GPIO_PuPd)); + + /*-------------------------- Configure the port pins -----------------------*/ + /*-- GPIO Mode Configuration --*/ + for (pinpos = 0x00; pinpos < 0x10; pinpos++) + { + pos = ((uint32_t)0x01) << pinpos; + + /* Get the port pins position */ + currentpin = (GPIO_InitStruct->GPIO_Pin) & pos; + + if (currentpin == pos) + { + if ((GPIO_InitStruct->GPIO_Mode == GPIO_Mode_OUT) || (GPIO_InitStruct->GPIO_Mode == GPIO_Mode_AF)) + { + /* Check Speed mode parameters */ + assert_param(IS_GPIO_SPEED(GPIO_InitStruct->GPIO_Speed)); + + /* Speed mode configuration */ + GPIOx->OSPEEDR &= ~(GPIO_OSPEEDER_OSPEEDR0 << (pinpos * 2)); + GPIOx->OSPEEDR |= ((uint32_t)(GPIO_InitStruct->GPIO_Speed) << (pinpos * 2)); + + /* Check Output mode parameters */ + assert_param(IS_GPIO_OTYPE(GPIO_InitStruct->GPIO_OType)); + + /* Output mode configuration */ + GPIOx->OTYPER &= ~((GPIO_OTYPER_OT_0) << ((uint16_t)pinpos)); + GPIOx->OTYPER |= (uint16_t)(((uint16_t)GPIO_InitStruct->GPIO_OType) << ((uint16_t)pinpos)); + } + + GPIOx->MODER &= ~(GPIO_MODER_MODER0 << (pinpos * 2)); + + GPIOx->MODER |= (((uint32_t)GPIO_InitStruct->GPIO_Mode) << (pinpos * 2)); + + /* Pull-up Pull down resistor configuration */ + GPIOx->PUPDR &= ~(GPIO_PUPDR_PUPDR0 << ((uint16_t)pinpos * 2)); + GPIOx->PUPDR |= (((uint32_t)GPIO_InitStruct->GPIO_PuPd) << (pinpos * 2)); + } + } +} + +/** + * @brief Fills each GPIO_InitStruct member with its default value. + * @param GPIO_InitStruct: pointer to a GPIO_InitTypeDef structure which will + * be initialized. + * @retval None + */ +void GPIO_StructInit(GPIO_InitTypeDef* GPIO_InitStruct) +{ + /* Reset GPIO init structure parameters values */ + GPIO_InitStruct->GPIO_Pin = GPIO_Pin_All; + GPIO_InitStruct->GPIO_Mode = GPIO_Mode_IN; + GPIO_InitStruct->GPIO_Speed = GPIO_Speed_Level_2; + GPIO_InitStruct->GPIO_OType = GPIO_OType_PP; + GPIO_InitStruct->GPIO_PuPd = GPIO_PuPd_NOPULL; +} + +/** + * @brief Locks GPIO Pins configuration registers. + * @note The locked registers are GPIOx_MODER, GPIOx_OTYPER, GPIOx_OSPEEDR, + * GPIOx_PUPDR, GPIOx_AFRL and GPIOx_AFRH. + * @note The configuration of the locked GPIO pins can no longer be modified + * until the next device reset. + * @param GPIOx: where x can be (A or B) to select the GPIO peripheral. + * @param GPIO_Pin: specifies the port bit to be written. + * This parameter can be any combination of GPIO_Pin_x where x can be (0..15). + * @retval None + */ +void GPIO_PinLockConfig(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin) +{ + __IO uint32_t tmp = 0x00010000; + + /* Check the parameters */ + assert_param(IS_GPIO_LIST_PERIPH(GPIOx)); + assert_param(IS_GPIO_PIN(GPIO_Pin)); + + tmp |= GPIO_Pin; + /* Set LCKK bit */ + GPIOx->LCKR = tmp; + /* Reset LCKK bit */ + GPIOx->LCKR = GPIO_Pin; + /* Set LCKK bit */ + GPIOx->LCKR = tmp; + /* Read LCKK bit */ + tmp = GPIOx->LCKR; + /* Read LCKK bit */ + tmp = GPIOx->LCKR; +} + +/** + * @} + */ + +/** @defgroup GPIO_Group2 GPIO Read and Write + * @brief GPIO Read and Write + * +@verbatim + =============================================================================== + ##### GPIO Read and Write ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Reads the specified input port pin. + * @param GPIOx: where x can be (A, B, C, D, E or F) to select the GPIO peripheral. + * @note GPIOE is available only for STM32F072. + * @note GPIOD is not available for STM32F031. + * @param GPIO_Pin: specifies the port bit to read. + * @note This parameter can be GPIO_Pin_x where x can be: + * For STM32F051 and STM32F030: (0..15) for GPIOA, GPIOB, GPIOC, (2) for GPIOD and (0..1, 4..7) for GIIOF. + * For STM32F072: (0..15) for GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, (0..10) for GPIOF. + * For STM32F031: (0..15) for GPIOA, GPIOB, (13..15) for GPIOC and (0..1, 6..7) for GPIOF. + * @retval The input port pin value. + */ +uint8_t GPIO_ReadInputDataBit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin) +{ + uint8_t bitstatus = 0x00; + + /* Check the parameters */ + assert_param(IS_GPIO_ALL_PERIPH(GPIOx)); + assert_param(IS_GET_GPIO_PIN(GPIO_Pin)); + + if ((GPIOx->IDR & GPIO_Pin) != (uint32_t)Bit_RESET) + { + bitstatus = (uint8_t)Bit_SET; + } + else + { + bitstatus = (uint8_t)Bit_RESET; + } + return bitstatus; +} + +/** + * @brief Reads the specified input port pin. + * @param GPIOx: where x can be (A, B, C, D, E or F) to select the GPIO peripheral. + * @note GPIOE is available only for STM32F072. + * @note GPIOD is not available for STM32F031. + * @retval The input port pin value. + */ +uint16_t GPIO_ReadInputData(GPIO_TypeDef* GPIOx) +{ + /* Check the parameters */ + assert_param(IS_GPIO_ALL_PERIPH(GPIOx)); + + return ((uint16_t)GPIOx->IDR); +} + +/** + * @brief Reads the specified output data port bit. + * @param GPIOx: where x can be (A, B, C, D, E or F) to select the GPIO peripheral. + * @note GPIOE is available only for STM32F072. + * @note GPIOD is not available for STM32F031. + * @param GPIO_Pin: Specifies the port bit to read. + * @note This parameter can be GPIO_Pin_x where x can be: + * For STM32F051 and STM32F030: (0..15) for GPIOA, GPIOB, GPIOC, (2) for GPIOD and (0..1, 4..7) for GIIOF. + * For STM32F072: (0..15) for GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, (0..10) for GPIOF. + * For STM32F031: (0..15) for GPIOA, GPIOB, (13..15) for GPIOC and (0..1, 6..7) for GPIOF. + * @retval The output port pin value. + */ +uint8_t GPIO_ReadOutputDataBit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin) +{ + uint8_t bitstatus = 0x00; + + /* Check the parameters */ + assert_param(IS_GPIO_ALL_PERIPH(GPIOx)); + assert_param(IS_GET_GPIO_PIN(GPIO_Pin)); + + if ((GPIOx->ODR & GPIO_Pin) != (uint32_t)Bit_RESET) + { + bitstatus = (uint8_t)Bit_SET; + } + else + { + bitstatus = (uint8_t)Bit_RESET; + } + return bitstatus; +} + +/** + * @brief Reads the specified GPIO output data port. + * @param GPIOx: where x can be (A, B, C, D, E or F) to select the GPIO peripheral. + * @note GPIOE is available only for STM32F072. + * @note GPIOD is not available for STM32F031. + * @retval GPIO output data port value. + */ +uint16_t GPIO_ReadOutputData(GPIO_TypeDef* GPIOx) +{ + /* Check the parameters */ + assert_param(IS_GPIO_ALL_PERIPH(GPIOx)); + + return ((uint16_t)GPIOx->ODR); +} + +/** + * @brief Sets the selected data port bits. + * @param GPIOx: where x can be (A, B, C, D, E or F) to select the GPIO peripheral. + * @note GPIOE is available only for STM32F072. + * @note GPIOD is not available for STM32F031. + * @param GPIO_Pin: specifies the port bits to be written. + * @note This parameter can be GPIO_Pin_x where x can be: + * For STM32F051 and STM32F030: (0..15) for GPIOA, GPIOB, GPIOC, (2) for GPIOD and (0..1, 4..7) for GIIOF. + * For STM32F072: (0..15) for GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, (0..10) for GPIOF. + * For STM32F031: (0..15) for GPIOA, GPIOB, (13..15) for GPIOC and (0..1, 6..7) for GPIOF. + * @retval None + */ +void GPIO_SetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin) +{ + /* Check the parameters */ + assert_param(IS_GPIO_ALL_PERIPH(GPIOx)); + assert_param(IS_GPIO_PIN(GPIO_Pin)); + + GPIOx->BSRR = GPIO_Pin; +} + +/** + * @brief Clears the selected data port bits. + * @param GPIOx: where x can be (A, B, C, D, E or F) to select the GPIO peripheral. + * @note GPIOE is available only for STM32F072. + * @note GPIOD is not available for STM32F031. + * @param GPIO_Pin: specifies the port bits to be written. + * @note This parameter can be GPIO_Pin_x where x can be: + * For STM32F051 and STM32F030: (0..15) for GPIOA, GPIOB, GPIOC, (2) for GPIOD and (0..1, 4..7) for GIIOF. + * For STM32F072: (0..15) for GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, (0..10) for GPIOF. + * For STM32F031: (0..15) for GPIOA, GPIOB, (13..15) for GPIOC and (0..1, 6..7) for GPIOF. + * @retval None + */ +void GPIO_ResetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin) +{ + /* Check the parameters */ + assert_param(IS_GPIO_ALL_PERIPH(GPIOx)); + assert_param(IS_GPIO_PIN(GPIO_Pin)); + + GPIOx->BRR = GPIO_Pin; +} + +/** + * @brief Sets or clears the selected data port bit. + * @param GPIOx: where x can be (A, B, C, D, E or F) to select the GPIO peripheral. + * @note GPIOE is available only for STM32F072. + * @note GPIOD is not available for STM32F031. + * @param GPIO_Pin: specifies the port bit to be written. + * @param BitVal: specifies the value to be written to the selected bit. + * This parameter can be one of the BitAction enumeration values: + * @arg Bit_RESET: to clear the port pin + * @arg Bit_SET: to set the port pin + * @note This parameter can be GPIO_Pin_x where x can be: + * For STM32F051 and STM32F030: (0..15) for GPIOA, GPIOB, GPIOC, (2) for GPIOD and (0..1, 4..7) for GIIOF. + * For STM32F072: (0..15) for GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, (0..10) for GPIOF. + * For STM32F031: (0..15) for GPIOA, GPIOB, (13..15) for GPIOC and (0..1, 6..7) for GPIOF. + * @retval None + */ +void GPIO_WriteBit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, BitAction BitVal) +{ + /* Check the parameters */ + assert_param(IS_GPIO_ALL_PERIPH(GPIOx)); + assert_param(IS_GET_GPIO_PIN(GPIO_Pin)); + assert_param(IS_GPIO_BIT_ACTION(BitVal)); + + if (BitVal != Bit_RESET) + { + GPIOx->BSRR = GPIO_Pin; + } + else + { + GPIOx->BRR = GPIO_Pin ; + } +} + +/** + * @brief Writes data to the specified GPIO data port. + * @param GPIOx: where x can be (A, B, C, D, E or F) to select the GPIO peripheral. + * @note GPIOE is available only for STM32F072. + * @note GPIOD is not available for STM32F031. + * @param PortVal: specifies the value to be written to the port output data register. + * @retval None + */ +void GPIO_Write(GPIO_TypeDef* GPIOx, uint16_t PortVal) +{ + /* Check the parameters */ + assert_param(IS_GPIO_ALL_PERIPH(GPIOx)); + + GPIOx->ODR = PortVal; +} + +/** + * @} + */ + +/** @defgroup GPIO_Group3 GPIO Alternate functions configuration functions + * @brief GPIO Alternate functions configuration functions + * +@verbatim + =============================================================================== + ##### GPIO Alternate functions configuration functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Writes data to the specified GPIO data port. + * @param GPIOx: where x can be (A, B, C, D, E or F) to select the GPIO peripheral. + * @note GPIOC, GPIOD, GPIOE and GPIOF are available only for STM32F072 and STM32F091. + * @param GPIO_PinSource: specifies the pin for the Alternate function. + * This parameter can be GPIO_PinSourcex where x can be (0..15) for GPIOA, GPIOB, GPIOD, GPIOE + * and (0..12) for GPIOC and (0, 2..5, 9..10) for GPIOF. + * @param GPIO_AF: selects the pin to used as Alternate function. + * This parameter can be one of the following value: + * @arg GPIO_AF_0: WKUP, EVENTOUT, TIM15, SPI1, TIM17, MCO, SWDAT, SWCLK, + * TIM14, BOOT, USART1, CEC, IR_OUT, SPI2, TIM3, USART4, + * CAN, USART2, CRS, TIM16, TIM1, TS, USART8 + * @arg GPIO_AF_1: USART2, CEC, TIM3, USART1, USART2, EVENTOUT, I2C1, + * I2C2, TIM15, SPI2, USART3, TS, SPI1, USART7, USART8 + * USART5, USART4, USART6, I2C1 + * @arg GPIO_AF_2: TIM2, TIM1, EVENTOUT, TIM16, TIM17, USB, USART6, USART5, + * USART8, USART7, USART6 + * @arg GPIO_AF_3: TS, I2C1, TIM15, EVENTOUT + * @arg GPIO_AF_4: TIM14, USART4, USART3, CRS, CAN, I2C1, USART5 + * @arg GPIO_AF_5: TIM16, TIM17, TIM15, SPI2, I2C2, USART6, MCO + * @arg GPIO_AF_6: EVENTOUT + * @arg GPIO_AF_7: COMP1 OUT, COMP2 OUT + * @note The pin should already been configured in Alternate Function mode(AF) + * using GPIO_InitStruct->GPIO_Mode = GPIO_Mode_AF + * @note Refer to the Alternate function mapping table in the device datasheet + * for the detailed mapping of the system and peripherals'alternate + * function I/O pins. + * @retval None + */ +void GPIO_PinAFConfig(GPIO_TypeDef* GPIOx, uint16_t GPIO_PinSource, uint8_t GPIO_AF) +{ + uint32_t temp = 0x00; + uint32_t temp_2 = 0x00; + + /* Check the parameters */ + assert_param(IS_GPIO_ALL_PERIPH(GPIOx)); + assert_param(IS_GPIO_PIN_SOURCE(GPIO_PinSource)); + assert_param(IS_GPIO_AF(GPIO_AF)); + + temp = ((uint32_t)(GPIO_AF) << ((uint32_t)((uint32_t)GPIO_PinSource & (uint32_t)0x07) * 4)); + GPIOx->AFR[GPIO_PinSource >> 0x03] &= ~((uint32_t)0xF << ((uint32_t)((uint32_t)GPIO_PinSource & (uint32_t)0x07) * 4)); + temp_2 = GPIOx->AFR[GPIO_PinSource >> 0x03] | temp; + GPIOx->AFR[GPIO_PinSource >> 0x03] = temp_2; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_i2c.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_i2c.c new file mode 100644 index 00000000..d4138e3c --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_i2c.c @@ -0,0 +1,1585 @@ +/** + ****************************************************************************** + * @file stm32f0xx_i2c.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Inter-Integrated circuit (I2C): + * + Initialization and Configuration + * + Communications handling + * + SMBUS management + * + I2C registers management + * + Data transfers management + * + DMA transfers management + * + Interrupts and flags management + * + * @verbatim + ============================================================================ + ##### How to use this driver ##### + ============================================================================ + [..] + (#) Enable peripheral clock using RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2Cx, ENABLE) + function for I2C1 or I2C2. + (#) Enable SDA, SCL and SMBA (when used) GPIO clocks using + RCC_AHBPeriphClockCmd() function. + (#) Peripherals alternate function: + (++) Connect the pin to the desired peripherals' Alternate + Function (AF) using GPIO_PinAFConfig() function. + (++) Configure the desired pin in alternate function by: + GPIO_InitStruct->GPIO_Mode = GPIO_Mode_AF + (++) Select the type, OpenDrain and speed via + GPIO_PuPd, GPIO_OType and GPIO_Speed members + (++) Call GPIO_Init() function. + (#) Program the Mode, Timing , Own address, Ack and Acknowledged Address + using the I2C_Init() function. + (#) Optionally you can enable/configure the following parameters without + re-initialization (i.e there is no need to call again I2C_Init() function): + (++) Enable the acknowledge feature using I2C_AcknowledgeConfig() function. + (++) Enable the dual addressing mode using I2C_DualAddressCmd() function. + (++) Enable the general call using the I2C_GeneralCallCmd() function. + (++) Enable the clock stretching using I2C_StretchClockCmd() function. + (++) Enable the PEC Calculation using I2C_CalculatePEC() function. + (++) For SMBus Mode: + (+++) Enable the SMBusAlert pin using I2C_SMBusAlertCmd() function. + (#) Enable the NVIC and the corresponding interrupt using the function + I2C_ITConfig() if you need to use interrupt mode. + (#) When using the DMA mode + (++) Configure the DMA using DMA_Init() function. + (++) Active the needed channel Request using I2C_DMACmd() function. + (#) Enable the I2C using the I2C_Cmd() function. + (#) Enable the DMA using the DMA_Cmd() function when using DMA mode in the + transfers. + [..] + (@) When using I2C in Fast Mode Plus, SCL and SDA pin 20mA current drive capability + must be enabled by setting the driving capability control bit in SYSCFG. + + @endverbatim + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_i2c.h" +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup I2C + * @brief I2C driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ + +#define CR1_CLEAR_MASK ((uint32_t)0x00CFE0FF) /*I2C_AnalogFilter)); + assert_param(IS_I2C_DIGITAL_FILTER(I2C_InitStruct->I2C_DigitalFilter)); + assert_param(IS_I2C_MODE(I2C_InitStruct->I2C_Mode)); + assert_param(IS_I2C_OWN_ADDRESS1(I2C_InitStruct->I2C_OwnAddress1)); + assert_param(IS_I2C_ACK(I2C_InitStruct->I2C_Ack)); + assert_param(IS_I2C_ACKNOWLEDGE_ADDRESS(I2C_InitStruct->I2C_AcknowledgedAddress)); + + /* Disable I2Cx Peripheral */ + I2Cx->CR1 &= (uint32_t)~((uint32_t)I2C_CR1_PE); + + /*---------------------------- I2Cx FILTERS Configuration ------------------*/ + /* Get the I2Cx CR1 value */ + tmpreg = I2Cx->CR1; + /* Clear I2Cx CR1 register */ + tmpreg &= CR1_CLEAR_MASK; + /* Configure I2Cx: analog and digital filter */ + /* Set ANFOFF bit according to I2C_AnalogFilter value */ + /* Set DFN bits according to I2C_DigitalFilter value */ + tmpreg |= (uint32_t)I2C_InitStruct->I2C_AnalogFilter |(I2C_InitStruct->I2C_DigitalFilter << 8); + + /* Write to I2Cx CR1 */ + I2Cx->CR1 = tmpreg; + + /*---------------------------- I2Cx TIMING Configuration -------------------*/ + /* Configure I2Cx: Timing */ + /* Set TIMINGR bits according to I2C_Timing */ + /* Write to I2Cx TIMING */ + I2Cx->TIMINGR = I2C_InitStruct->I2C_Timing & TIMING_CLEAR_MASK; + + /* Enable I2Cx Peripheral */ + I2Cx->CR1 |= I2C_CR1_PE; + + /*---------------------------- I2Cx OAR1 Configuration ---------------------*/ + /* Clear tmpreg local variable */ + tmpreg = 0; + /* Clear OAR1 register */ + I2Cx->OAR1 = (uint32_t)tmpreg; + /* Clear OAR2 register */ + I2Cx->OAR2 = (uint32_t)tmpreg; + /* Configure I2Cx: Own Address1 and acknowledged address */ + /* Set OA1MODE bit according to I2C_AcknowledgedAddress value */ + /* Set OA1 bits according to I2C_OwnAddress1 value */ + tmpreg = (uint32_t)((uint32_t)I2C_InitStruct->I2C_AcknowledgedAddress | \ + (uint32_t)I2C_InitStruct->I2C_OwnAddress1); + /* Write to I2Cx OAR1 */ + I2Cx->OAR1 = tmpreg; + /* Enable Own Address1 acknowledgement */ + I2Cx->OAR1 |= I2C_OAR1_OA1EN; + + /*---------------------------- I2Cx MODE Configuration ---------------------*/ + /* Configure I2Cx: mode */ + /* Set SMBDEN and SMBHEN bits according to I2C_Mode value */ + tmpreg = I2C_InitStruct->I2C_Mode; + /* Write to I2Cx CR1 */ + I2Cx->CR1 |= tmpreg; + + /*---------------------------- I2Cx ACK Configuration ----------------------*/ + /* Get the I2Cx CR2 value */ + tmpreg = I2Cx->CR2; + /* Clear I2Cx CR2 register */ + tmpreg &= CR2_CLEAR_MASK; + /* Configure I2Cx: acknowledgement */ + /* Set NACK bit according to I2C_Ack value */ + tmpreg |= I2C_InitStruct->I2C_Ack; + /* Write to I2Cx CR2 */ + I2Cx->CR2 = tmpreg; +} + +/** + * @brief Fills each I2C_InitStruct member with its default value. + * @param I2C_InitStruct: pointer to an I2C_InitTypeDef structure which will be initialized. + * @retval None + */ +void I2C_StructInit(I2C_InitTypeDef* I2C_InitStruct) +{ + /*---------------- Reset I2C init structure parameters values --------------*/ + /* Initialize the I2C_Timing member */ + I2C_InitStruct->I2C_Timing = 0; + /* Initialize the I2C_AnalogFilter member */ + I2C_InitStruct->I2C_AnalogFilter = I2C_AnalogFilter_Enable; + /* Initialize the I2C_DigitalFilter member */ + I2C_InitStruct->I2C_DigitalFilter = 0; + /* Initialize the I2C_Mode member */ + I2C_InitStruct->I2C_Mode = I2C_Mode_I2C; + /* Initialize the I2C_OwnAddress1 member */ + I2C_InitStruct->I2C_OwnAddress1 = 0; + /* Initialize the I2C_Ack member */ + I2C_InitStruct->I2C_Ack = I2C_Ack_Disable; + /* Initialize the I2C_AcknowledgedAddress member */ + I2C_InitStruct->I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit; +} + +/** + * @brief Enables or disables the specified I2C peripheral. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the I2Cx peripheral. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_Cmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + if (NewState != DISABLE) + { + /* Enable the selected I2C peripheral */ + I2Cx->CR1 |= I2C_CR1_PE; + } + else + { + /* Disable the selected I2C peripheral */ + I2Cx->CR1 &= (uint32_t)~((uint32_t)I2C_CR1_PE); + } +} + +/** + * @brief Enables or disables the specified I2C software reset. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @retval None + */ +void I2C_SoftwareResetCmd(I2C_TypeDef* I2Cx) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + + /* Disable peripheral */ + I2Cx->CR1 &= (uint32_t)~((uint32_t)I2C_CR1_PE); + + /* Perform a dummy read to delay the disable of peripheral for minimum + 3 APB clock cycles to perform the software reset functionality */ + *(__IO uint32_t *)(uint32_t)I2Cx; + + /* Enable peripheral */ + I2Cx->CR1 |= I2C_CR1_PE; +} + +/** + * @brief Enables or disables the specified I2C interrupts. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param I2C_IT: specifies the I2C interrupts sources to be enabled or disabled. + * This parameter can be any combination of the following values: + * @arg I2C_IT_ERRI: Error interrupt mask + * @arg I2C_IT_TCI: Transfer Complete interrupt mask + * @arg I2C_IT_STOPI: Stop Detection interrupt mask + * @arg I2C_IT_NACKI: Not Acknowledge received interrupt mask + * @arg I2C_IT_ADDRI: Address Match interrupt mask + * @arg I2C_IT_RXI: RX interrupt mask + * @arg I2C_IT_TXI: TX interrupt mask + * @param NewState: new state of the specified I2C interrupts. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_ITConfig(I2C_TypeDef* I2Cx, uint32_t I2C_IT, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + assert_param(IS_I2C_CONFIG_IT(I2C_IT)); + + if (NewState != DISABLE) + { + /* Enable the selected I2C interrupts */ + I2Cx->CR1 |= I2C_IT; + } + else + { + /* Disable the selected I2C interrupts */ + I2Cx->CR1 &= (uint32_t)~((uint32_t)I2C_IT); + } +} + +/** + * @brief Enables or disables the I2C Clock stretching. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the I2Cx Clock stretching. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_StretchClockCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable clock stretching */ + I2Cx->CR1 &= (uint32_t)~((uint32_t)I2C_CR1_NOSTRETCH); + } + else + { + /* Disable clock stretching */ + I2Cx->CR1 |= I2C_CR1_NOSTRETCH; + } +} + +/** + * @brief Enables or disables I2C wakeup from stop mode. + * This function is not applicable for STM32F030 devices. + * @param I2Cx: where x can be 1 to select the I2C peripheral. + * @param NewState: new state of the I2Cx stop mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_StopModeCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_1_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable wakeup from stop mode */ + I2Cx->CR1 |= I2C_CR1_WUPEN; + } + else + { + /* Disable wakeup from stop mode */ + I2Cx->CR1 &= (uint32_t)~((uint32_t)I2C_CR1_WUPEN); + } +} + +/** + * @brief Enables or disables the I2C own address 2. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the I2C own address 2. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_DualAddressCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable own address 2 */ + I2Cx->OAR2 |= I2C_OAR2_OA2EN; + } + else + { + /* Disable own address 2 */ + I2Cx->OAR2 &= (uint32_t)~((uint32_t)I2C_OAR2_OA2EN); + } +} + +/** + * @brief Configures the I2C slave own address 2 and mask. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param Address: specifies the slave address to be programmed. + * @param Mask: specifies own address 2 mask to be programmed. + * This parameter can be one of the following values: + * @arg I2C_OA2_NoMask: no mask. + * @arg I2C_OA2_Mask01: OA2[1] is masked and don't care. + * @arg I2C_OA2_Mask02: OA2[2:1] are masked and don't care. + * @arg I2C_OA2_Mask03: OA2[3:1] are masked and don't care. + * @arg I2C_OA2_Mask04: OA2[4:1] are masked and don't care. + * @arg I2C_OA2_Mask05: OA2[5:1] are masked and don't care. + * @arg I2C_OA2_Mask06: OA2[6:1] are masked and don't care. + * @arg I2C_OA2_Mask07: OA2[7:1] are masked and don't care. + * @retval None + */ +void I2C_OwnAddress2Config(I2C_TypeDef* I2Cx, uint16_t Address, uint8_t Mask) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_I2C_OWN_ADDRESS2(Address)); + assert_param(IS_I2C_OWN_ADDRESS2_MASK(Mask)); + + /* Get the old register value */ + tmpreg = I2Cx->OAR2; + + /* Reset I2Cx OA2 bit [7:1] and OA2MSK bit [1:0] */ + tmpreg &= (uint32_t)~((uint32_t)(I2C_OAR2_OA2 | I2C_OAR2_OA2MSK)); + + /* Set I2Cx SADD */ + tmpreg |= (uint32_t)(((uint32_t)Address & I2C_OAR2_OA2) | \ + (((uint32_t)Mask << 8) & I2C_OAR2_OA2MSK)) ; + + /* Store the new register value */ + I2Cx->OAR2 = tmpreg; +} + +/** + * @brief Enables or disables the I2C general call mode. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the I2C general call mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_GeneralCallCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable general call mode */ + I2Cx->CR1 |= I2C_CR1_GCEN; + } + else + { + /* Disable general call mode */ + I2Cx->CR1 &= (uint32_t)~((uint32_t)I2C_CR1_GCEN); + } +} + +/** + * @brief Enables or disables the I2C slave byte control. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the I2C slave byte control. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_SlaveByteControlCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable slave byte control */ + I2Cx->CR1 |= I2C_CR1_SBC; + } + else + { + /* Disable slave byte control */ + I2Cx->CR1 &= (uint32_t)~((uint32_t)I2C_CR1_SBC); + } +} + +/** + * @brief Configures the slave address to be transmitted after start generation. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param Address: specifies the slave address to be programmed. + * @note This function should be called before generating start condition. + * @retval None + */ +void I2C_SlaveAddressConfig(I2C_TypeDef* I2Cx, uint16_t Address) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_I2C_SLAVE_ADDRESS(Address)); + + /* Get the old register value */ + tmpreg = I2Cx->CR2; + + /* Reset I2Cx SADD bit [9:0] */ + tmpreg &= (uint32_t)~((uint32_t)I2C_CR2_SADD); + + /* Set I2Cx SADD */ + tmpreg |= (uint32_t)((uint32_t)Address & I2C_CR2_SADD); + + /* Store the new register value */ + I2Cx->CR2 = tmpreg; +} + +/** + * @brief Enables or disables the I2C 10-bit addressing mode for the master. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the I2C 10-bit addressing mode. + * This parameter can be: ENABLE or DISABLE. + * @note This function should be called before generating start condition. + * @retval None + */ +void I2C_10BitAddressingModeCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable 10-bit addressing mode */ + I2Cx->CR2 |= I2C_CR2_ADD10; + } + else + { + /* Disable 10-bit addressing mode */ + I2Cx->CR2 &= (uint32_t)~((uint32_t)I2C_CR2_ADD10); + } +} + +/** + * @} + */ + + +/** @defgroup I2C_Group2 Communications handling functions + * @brief Communications handling functions + * +@verbatim + =============================================================================== + ##### Communications handling functions ##### + =============================================================================== + [..] This section provides a set of functions that handles I2C communication. + + [..] Automatic End mode is enabled using I2C_AutoEndCmd() function. When Reload + mode is enabled via I2C_ReloadCmd() AutoEnd bit has no effect. + + [..] I2C_NumberOfBytesConfig() function set the number of bytes to be transferred, + this configuration should be done before generating start condition in master + mode. + + [..] When switching from master write operation to read operation in 10Bit addressing + mode, master can only sends the 1st 7 bits of the 10 bit address, followed by + Read direction by enabling HEADR bit using I2C_10BitAddressHeader() function. + + [..] In master mode, when transferring more than 255 bytes Reload mode should be used + to handle communication. In the first phase of transfer, Nbytes should be set to + 255. After transferring these bytes TCR flag is set and I2C_TransferHandling() + function should be called to handle remaining communication. + + [..] In master mode, when software end mode is selected when all data is transferred + TC flag is set I2C_TransferHandling() function should be called to generate STOP + or generate ReStart. + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the I2C automatic end mode (stop condition is + * automatically sent when nbytes data are transferred). + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the I2C automatic end mode. + * This parameter can be: ENABLE or DISABLE. + * @note This function has effect if Reload mode is disabled. + * @retval None + */ +void I2C_AutoEndCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable Auto end mode */ + I2Cx->CR2 |= I2C_CR2_AUTOEND; + } + else + { + /* Disable Auto end mode */ + I2Cx->CR2 &= (uint32_t)~((uint32_t)I2C_CR2_AUTOEND); + } +} + +/** + * @brief Enables or disables the I2C nbytes reload mode. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the nbytes reload mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_ReloadCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable Auto Reload mode */ + I2Cx->CR2 |= I2C_CR2_RELOAD; + } + else + { + /* Disable Auto Reload mode */ + I2Cx->CR2 &= (uint32_t)~((uint32_t)I2C_CR2_RELOAD); + } +} + +/** + * @brief Configures the number of bytes to be transmitted/received. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param Number_Bytes: specifies the number of bytes to be programmed. + * @retval None + */ +void I2C_NumberOfBytesConfig(I2C_TypeDef* I2Cx, uint8_t Number_Bytes) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + + /* Get the old register value */ + tmpreg = I2Cx->CR2; + + /* Reset I2Cx Nbytes bit [7:0] */ + tmpreg &= (uint32_t)~((uint32_t)I2C_CR2_NBYTES); + + /* Set I2Cx Nbytes */ + tmpreg |= (uint32_t)(((uint32_t)Number_Bytes << 16 ) & I2C_CR2_NBYTES); + + /* Store the new register value */ + I2Cx->CR2 = tmpreg; +} + +/** + * @brief Configures the type of transfer request for the master. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param I2C_Direction: specifies the transfer request direction to be programmed. + * This parameter can be one of the following values: + * @arg I2C_Direction_Transmitter: Master request a write transfer + * @arg I2C_Direction_Receiver: Master request a read transfer + * @retval None + */ +void I2C_MasterRequestConfig(I2C_TypeDef* I2Cx, uint16_t I2C_Direction) +{ +/* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_I2C_DIRECTION(I2C_Direction)); + + /* Test on the direction to set/reset the read/write bit */ + if (I2C_Direction == I2C_Direction_Transmitter) + { + /* Request a write Transfer */ + I2Cx->CR2 &= (uint32_t)~((uint32_t)I2C_CR2_RD_WRN); + } + else + { + /* Request a read Transfer */ + I2Cx->CR2 |= I2C_CR2_RD_WRN; + } +} + +/** + * @brief Generates I2Cx communication START condition. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the I2C START condition generation. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_GenerateSTART(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Generate a START condition */ + I2Cx->CR2 |= I2C_CR2_START; + } + else + { + /* Disable the START condition generation */ + I2Cx->CR2 &= (uint32_t)~((uint32_t)I2C_CR2_START); + } +} + +/** + * @brief Generates I2Cx communication STOP condition. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the I2C STOP condition generation. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_GenerateSTOP(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Generate a STOP condition */ + I2Cx->CR2 |= I2C_CR2_STOP; + } + else + { + /* Disable the STOP condition generation */ + I2Cx->CR2 &= (uint32_t)~((uint32_t)I2C_CR2_STOP); + } +} + +/** + * @brief Enables or disables the I2C 10-bit header only mode with read direction. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the I2C 10-bit header only mode. + * This parameter can be: ENABLE or DISABLE. + * @note This mode can be used only when switching from master transmitter mode + * to master receiver mode. + * @retval None + */ +void I2C_10BitAddressHeaderCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable 10-bit header only mode */ + I2Cx->CR2 |= I2C_CR2_HEAD10R; + } + else + { + /* Disable 10-bit header only mode */ + I2Cx->CR2 &= (uint32_t)~((uint32_t)I2C_CR2_HEAD10R); + } +} + +/** + * @brief Generates I2C communication Acknowledge. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param NewState: new state of the Acknowledge. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_AcknowledgeConfig(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable ACK generation */ + I2Cx->CR2 &= (uint32_t)~((uint32_t)I2C_CR2_NACK); + } + else + { + /* Enable NACK generation */ + I2Cx->CR2 |= I2C_CR2_NACK; + } +} + +/** + * @brief Returns the I2C slave matched address . + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @retval The value of the slave matched address . + */ +uint8_t I2C_GetAddressMatched(I2C_TypeDef* I2Cx) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + + /* Return the slave matched address in the SR1 register */ + return (uint8_t)(((uint32_t)I2Cx->ISR & I2C_ISR_ADDCODE) >> 16) ; +} + +/** + * @brief Returns the I2C slave received request. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @retval The value of the received request. + */ +uint16_t I2C_GetTransferDirection(I2C_TypeDef* I2Cx) +{ + uint32_t tmpreg = 0; + uint16_t direction = 0; + + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + + /* Return the slave matched address in the SR1 register */ + tmpreg = (uint32_t)(I2Cx->ISR & I2C_ISR_DIR); + + /* If write transfer is requested */ + if (tmpreg == 0) + { + /* write transfer is requested */ + direction = I2C_Direction_Transmitter; + } + else + { + /* Read transfer is requested */ + direction = I2C_Direction_Receiver; + } + return direction; +} + +/** + * @brief Handles I2Cx communication when starting transfer or during transfer (TC or TCR flag are set). + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param Address: specifies the slave address to be programmed. + * @param Number_Bytes: specifies the number of bytes to be programmed. + * This parameter must be a value between 0 and 255. + * @param ReloadEndMode: new state of the I2C START condition generation. + * This parameter can be one of the following values: + * @arg I2C_Reload_Mode: Enable Reload mode . + * @arg I2C_AutoEnd_Mode: Enable Automatic end mode. + * @arg I2C_SoftEnd_Mode: Enable Software end mode. + * @param StartStopMode: new state of the I2C START condition generation. + * This parameter can be one of the following values: + * @arg I2C_No_StartStop: Don't Generate stop and start condition. + * @arg I2C_Generate_Stop: Generate stop condition (Number_Bytes should be set to 0). + * @arg I2C_Generate_Start_Read: Generate Restart for read request. + * @arg I2C_Generate_Start_Write: Generate Restart for write request. + * @retval None + */ +void I2C_TransferHandling(I2C_TypeDef* I2Cx, uint16_t Address, uint8_t Number_Bytes, uint32_t ReloadEndMode, uint32_t StartStopMode) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_I2C_SLAVE_ADDRESS(Address)); + assert_param(IS_RELOAD_END_MODE(ReloadEndMode)); + assert_param(IS_START_STOP_MODE(StartStopMode)); + + /* Get the CR2 register value */ + tmpreg = I2Cx->CR2; + + /* clear tmpreg specific bits */ + tmpreg &= (uint32_t)~((uint32_t)(I2C_CR2_SADD | I2C_CR2_NBYTES | I2C_CR2_RELOAD | I2C_CR2_AUTOEND | I2C_CR2_RD_WRN | I2C_CR2_START | I2C_CR2_STOP)); + + /* update tmpreg */ + tmpreg |= (uint32_t)(((uint32_t)Address & I2C_CR2_SADD) | (((uint32_t)Number_Bytes << 16 ) & I2C_CR2_NBYTES) | \ + (uint32_t)ReloadEndMode | (uint32_t)StartStopMode); + + /* update CR2 register */ + I2Cx->CR2 = tmpreg; +} + +/** + * @} + */ + + +/** @defgroup I2C_Group3 SMBUS management functions + * @brief SMBUS management functions + * +@verbatim + =============================================================================== + ##### SMBUS management functions ##### + =============================================================================== + [..] This section provides a set of functions that handles SMBus communication + and timeouts detection. + + [..] The SMBus Device default address (0b1100 001) is enabled by calling I2C_Init() + function and setting I2C_Mode member of I2C_InitTypeDef() structure to + I2C_Mode_SMBusDevice. + + [..] The SMBus Host address (0b0001 000) is enabled by calling I2C_Init() + function and setting I2C_Mode member of I2C_InitTypeDef() structure to + I2C_Mode_SMBusHost. + + [..] The Alert Response Address (0b0001 100) is enabled using I2C_SMBusAlertCmd() + function. + + [..] To detect cumulative SCL stretch in master and slave mode, TIMEOUTB should be + configured (in accordance to SMBus specification) using I2C_TimeoutBConfig() + function then I2C_ExtendedClockTimeoutCmd() function should be called to enable + the detection. + + [..] SCL low timeout is detected by configuring TIMEOUTB using I2C_TimeoutBConfig() + function followed by the call of I2C_ClockTimeoutCmd(). When adding to this + procedure the call of I2C_IdleClockTimeoutCmd() function, Bus Idle condition + (both SCL and SDA high) is detected also. + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables I2C SMBus alert. + * @param I2Cx: where x can be 1 to select the I2C peripheral. + * @param NewState: new state of the I2Cx SMBus alert. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_SMBusAlertCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_1_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable SMBus alert */ + I2Cx->CR1 |= I2C_CR1_ALERTEN; + } + else + { + /* Disable SMBus alert */ + I2Cx->CR1 &= (uint32_t)~((uint32_t)I2C_CR1_ALERTEN); + } +} + +/** + * @brief Enables or disables I2C Clock Timeout (SCL Timeout detection). + * @param I2Cx: where x can be 1 to select the I2C peripheral. + * @param NewState: new state of the I2Cx clock Timeout. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_ClockTimeoutCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_1_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable Clock Timeout */ + I2Cx->TIMEOUTR |= I2C_TIMEOUTR_TIMOUTEN; + } + else + { + /* Disable Clock Timeout */ + I2Cx->TIMEOUTR &= (uint32_t)~((uint32_t)I2C_TIMEOUTR_TIMOUTEN); + } +} + +/** + * @brief Enables or disables I2C Extended Clock Timeout (SCL cumulative Timeout detection). + * @param I2Cx: where x can be 1 to select the I2C peripheral. + * @param NewState: new state of the I2Cx Extended clock Timeout. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_ExtendedClockTimeoutCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_1_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable Clock Timeout */ + I2Cx->TIMEOUTR |= I2C_TIMEOUTR_TEXTEN; + } + else + { + /* Disable Clock Timeout */ + I2Cx->TIMEOUTR &= (uint32_t)~((uint32_t)I2C_TIMEOUTR_TEXTEN); + } +} + +/** + * @brief Enables or disables I2C Idle Clock Timeout (Bus idle SCL and SDA + * high detection). + * @param I2Cx: where x can be 1 to select the I2C peripheral. + * @param NewState: new state of the I2Cx Idle clock Timeout. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_IdleClockTimeoutCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_1_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable Clock Timeout */ + I2Cx->TIMEOUTR |= I2C_TIMEOUTR_TIDLE; + } + else + { + /* Disable Clock Timeout */ + I2Cx->TIMEOUTR &= (uint32_t)~((uint32_t)I2C_TIMEOUTR_TIDLE); + } +} + +/** + * @brief Configures the I2C Bus Timeout A (SCL Timeout when TIDLE = 0 or Bus + * idle SCL and SDA high when TIDLE = 1). + * @param I2Cx: where x can be 1 to select the I2C peripheral. + * @param Timeout: specifies the TimeoutA to be programmed. + * @retval None + */ +void I2C_TimeoutAConfig(I2C_TypeDef* I2Cx, uint16_t Timeout) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_I2C_1_PERIPH(I2Cx)); + assert_param(IS_I2C_TIMEOUT(Timeout)); + + /* Get the old register value */ + tmpreg = I2Cx->TIMEOUTR; + + /* Reset I2Cx TIMEOUTA bit [11:0] */ + tmpreg &= (uint32_t)~((uint32_t)I2C_TIMEOUTR_TIMEOUTA); + + /* Set I2Cx TIMEOUTA */ + tmpreg |= (uint32_t)((uint32_t)Timeout & I2C_TIMEOUTR_TIMEOUTA) ; + + /* Store the new register value */ + I2Cx->TIMEOUTR = tmpreg; +} + +/** + * @brief Configures the I2C Bus Timeout B (SCL cumulative Timeout). + * @param I2Cx: where x can be 1 to select the I2C peripheral. + * @param Timeout: specifies the TimeoutB to be programmed. + * @retval None + */ +void I2C_TimeoutBConfig(I2C_TypeDef* I2Cx, uint16_t Timeout) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_I2C_1_PERIPH(I2Cx)); + assert_param(IS_I2C_TIMEOUT(Timeout)); + + /* Get the old register value */ + tmpreg = I2Cx->TIMEOUTR; + + /* Reset I2Cx TIMEOUTB bit [11:0] */ + tmpreg &= (uint32_t)~((uint32_t)I2C_TIMEOUTR_TIMEOUTB); + + /* Set I2Cx TIMEOUTB */ + tmpreg |= (uint32_t)(((uint32_t)Timeout << 16) & I2C_TIMEOUTR_TIMEOUTB) ; + + /* Store the new register value */ + I2Cx->TIMEOUTR = tmpreg; +} + +/** + * @brief Enables or disables I2C PEC calculation. + * @param I2Cx: where x can be 1 to select the I2C peripheral. + * @param NewState: new state of the I2Cx PEC calculation. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_CalculatePEC(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_1_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable PEC calculation */ + I2Cx->CR1 |= I2C_CR1_PECEN; + } + else + { + /* Disable PEC calculation */ + I2Cx->CR1 &= (uint32_t)~((uint32_t)I2C_CR1_PECEN); + } +} + +/** + * @brief Enables or disables I2C PEC transmission/reception request. + * @param I2Cx: where x can be 1 to select the I2C peripheral. + * @param NewState: new state of the I2Cx PEC request. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_PECRequestCmd(I2C_TypeDef* I2Cx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_1_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable PEC transmission/reception request */ + I2Cx->CR2 |= I2C_CR2_PECBYTE; + } + else + { + /* Disable PEC transmission/reception request */ + I2Cx->CR2 &= (uint32_t)~((uint32_t)I2C_CR2_PECBYTE); + } +} + +/** + * @brief Returns the I2C PEC. + * @param I2Cx: where x can be 1 to select the I2C peripheral. + * @retval The value of the PEC . + */ +uint8_t I2C_GetPEC(I2C_TypeDef* I2Cx) +{ + /* Check the parameters */ + assert_param(IS_I2C_1_PERIPH(I2Cx)); + + /* Return the slave matched address in the SR1 register */ + return (uint8_t)((uint32_t)I2Cx->PECR & I2C_PECR_PEC); +} + +/** + * @} + */ + + +/** @defgroup I2C_Group4 I2C registers management functions + * @brief I2C registers management functions + * +@verbatim + =============================================================================== + ##### I2C registers management functions ##### + =============================================================================== + [..] This section provides a functions that allow user the management of + I2C registers. + +@endverbatim + * @{ + */ + + /** + * @brief Reads the specified I2C register and returns its value. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param I2C_Register: specifies the register to read. + * This parameter can be one of the following values: + * @arg I2C_Register_CR1: CR1 register. + * @arg I2C_Register_CR2: CR2 register. + * @arg I2C_Register_OAR1: OAR1 register. + * @arg I2C_Register_OAR2: OAR2 register. + * @arg I2C_Register_TIMINGR: TIMING register. + * @arg I2C_Register_TIMEOUTR: TIMEOUTR register. + * @arg I2C_Register_ISR: ISR register. + * @arg I2C_Register_ICR: ICR register. + * @arg I2C_Register_PECR: PECR register. + * @arg I2C_Register_RXDR: RXDR register. + * @arg I2C_Register_TXDR: TXDR register. + * @retval The value of the read register. + */ +uint32_t I2C_ReadRegister(I2C_TypeDef* I2Cx, uint8_t I2C_Register) +{ + __IO uint32_t tmp = 0; + + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_I2C_REGISTER(I2C_Register)); + + tmp = (uint32_t)I2Cx; + tmp += I2C_Register; + + /* Return the selected register value */ + return (*(__IO uint32_t *) tmp); +} + +/** + * @} + */ + +/** @defgroup I2C_Group5 Data transfers management functions + * @brief Data transfers management functions + * +@verbatim + =============================================================================== + ##### Data transfers management functions ##### + =============================================================================== + [..] This subsection provides a set of functions allowing to manage + the I2C data transfers. + + [..] The read access of the I2C_RXDR register can be done using + the I2C_ReceiveData() function and returns the received value. + Whereas a write access to the I2C_TXDR can be done using I2C_SendData() + function and stores the written data into TXDR. +@endverbatim + * @{ + */ + +/** + * @brief Sends a data byte through the I2Cx peripheral. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param Data: Byte to be transmitted.. + * @retval None + */ +void I2C_SendData(I2C_TypeDef* I2Cx, uint8_t Data) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + + /* Write in the DR register the data to be sent */ + I2Cx->TXDR = (uint8_t)Data; +} + +/** + * @brief Returns the most recent received data by the I2Cx peripheral. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @retval The value of the received data. + */ +uint8_t I2C_ReceiveData(I2C_TypeDef* I2Cx) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + + /* Return the data in the DR register */ + return (uint8_t)I2Cx->RXDR; +} + +/** + * @} + */ + + +/** @defgroup I2C_Group6 DMA transfers management functions + * @brief DMA transfers management functions + * +@verbatim + =============================================================================== + ##### DMA transfers management functions ##### + =============================================================================== + [..] This section provides two functions that can be used only in DMA mode. + [..] In DMA Mode, the I2C communication can be managed by 2 DMA Channel + requests: + (#) I2C_DMAReq_Tx: specifies the Tx buffer DMA transfer request. + (#) I2C_DMAReq_Rx: specifies the Rx buffer DMA transfer request. + [..] In this Mode it is advised to use the following function: + (+) I2C_DMACmd(I2C_TypeDef* I2Cx, uint32_t I2C_DMAReq, FunctionalState NewState); +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the I2C DMA interface. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param I2C_DMAReq: specifies the I2C DMA transfer request to be enabled or disabled. + * This parameter can be any combination of the following values: + * @arg I2C_DMAReq_Tx: Tx DMA transfer request + * @arg I2C_DMAReq_Rx: Rx DMA transfer request + * @param NewState: new state of the selected I2C DMA transfer request. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2C_DMACmd(I2C_TypeDef* I2Cx, uint32_t I2C_DMAReq, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + assert_param(IS_I2C_DMA_REQ(I2C_DMAReq)); + + if (NewState != DISABLE) + { + /* Enable the selected I2C DMA requests */ + I2Cx->CR1 |= I2C_DMAReq; + } + else + { + /* Disable the selected I2C DMA requests */ + I2Cx->CR1 &= (uint32_t)~I2C_DMAReq; + } +} +/** + * @} + */ + + +/** @defgroup I2C_Group7 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== + [..] This section provides functions allowing to configure the I2C Interrupts + sources and check or clear the flags or pending bits status. + The user should identify which mode will be used in his application to manage + the communication: Polling mode, Interrupt mode or DMA mode(refer I2C_Group6). + + *** Polling Mode *** + ==================== + [..] In Polling Mode, the I2C communication can be managed by 15 flags: + (#) I2C_FLAG_TXE: to indicate the status of Transmit data register empty flag. + (#) I2C_FLAG_TXIS: to indicate the status of Transmit interrupt status flag . + (#) I2C_FLAG_RXNE: to indicate the status of Receive data register not empty flag. + (#) I2C_FLAG_ADDR: to indicate the status of Address matched flag (slave mode). + (#) I2C_FLAG_NACKF: to indicate the status of NACK received flag. + (#) I2C_FLAG_STOPF: to indicate the status of STOP detection flag. + (#) I2C_FLAG_TC: to indicate the status of Transfer complete flag(master mode). + (#) I2C_FLAG_TCR: to indicate the status of Transfer complete reload flag. + (#) I2C_FLAG_BERR: to indicate the status of Bus error flag. + (#) I2C_FLAG_ARLO: to indicate the status of Arbitration lost flag. + (#) I2C_FLAG_OVR: to indicate the status of Overrun/Underrun flag. + (#) I2C_FLAG_PECERR: to indicate the status of PEC error in reception flag. + (#) I2C_FLAG_TIMEOUT: to indicate the status of Timeout or Tlow detection flag. + (#) I2C_FLAG_ALERT: to indicate the status of SMBus Alert flag. + (#) I2C_FLAG_BUSY: to indicate the status of Bus busy flag. + + [..] In this Mode it is advised to use the following functions: + (+) FlagStatus I2C_GetFlagStatus(I2C_TypeDef* I2Cx, uint32_t I2C_FLAG); + (+) void I2C_ClearFlag(I2C_TypeDef* I2Cx, uint32_t I2C_FLAG); + + [..] + (@)Do not use the BUSY flag to handle each data transmission or reception.It is + better to use the TXIS and RXNE flags instead. + + *** Interrupt Mode *** + ====================== + [..] In Interrupt Mode, the I2C communication can be managed by 7 interrupt sources + and 15 pending bits: + [..] Interrupt Source: + (#) I2C_IT_ERRI: specifies the interrupt source for the Error interrupt. + (#) I2C_IT_TCI: specifies the interrupt source for the Transfer Complete interrupt. + (#) I2C_IT_STOPI: specifies the interrupt source for the Stop Detection interrupt. + (#) I2C_IT_NACKI: specifies the interrupt source for the Not Acknowledge received interrupt. + (#) I2C_IT_ADDRI: specifies the interrupt source for the Address Match interrupt. + (#) I2C_IT_RXI: specifies the interrupt source for the RX interrupt. + (#) I2C_IT_TXI: specifies the interrupt source for the TX interrupt. + + [..] Pending Bits: + (#) I2C_IT_TXIS: to indicate the status of Transmit interrupt status flag. + (#) I2C_IT_RXNE: to indicate the status of Receive data register not empty flag. + (#) I2C_IT_ADDR: to indicate the status of Address matched flag (slave mode). + (#) I2C_IT_NACKF: to indicate the status of NACK received flag. + (#) I2C_IT_STOPF: to indicate the status of STOP detection flag. + (#) I2C_IT_TC: to indicate the status of Transfer complete flag (master mode). + (#) I2C_IT_TCR: to indicate the status of Transfer complete reload flag. + (#) I2C_IT_BERR: to indicate the status of Bus error flag. + (#) I2C_IT_ARLO: to indicate the status of Arbitration lost flag. + (#) I2C_IT_OVR: to indicate the status of Overrun/Underrun flag. + (#) I2C_IT_PECERR: to indicate the status of PEC error in reception flag. + (#) I2C_IT_TIMEOUT: to indicate the status of Timeout or Tlow detection flag. + (#) I2C_IT_ALERT: to indicate the status of SMBus Alert flag. + + [..] In this Mode it is advised to use the following functions: + (+) void I2C_ClearITPendingBit(I2C_TypeDef* I2Cx, uint32_t I2C_IT); + (+) ITStatus I2C_GetITStatus(I2C_TypeDef* I2Cx, uint32_t I2C_IT); + +@endverbatim + * @{ + */ + +/** + * @brief Checks whether the specified I2C flag is set or not. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param I2C_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg I2C_FLAG_TXE: Transmit data register empty + * @arg I2C_FLAG_TXIS: Transmit interrupt status + * @arg I2C_FLAG_RXNE: Receive data register not empty + * @arg I2C_FLAG_ADDR: Address matched (slave mode) + * @arg I2C_FLAG_NACKF: NACK received flag + * @arg I2C_FLAG_STOPF: STOP detection flag + * @arg I2C_FLAG_TC: Transfer complete (master mode) + * @arg I2C_FLAG_TCR: Transfer complete reload + * @arg I2C_FLAG_BERR: Bus error + * @arg I2C_FLAG_ARLO: Arbitration lost + * @arg I2C_FLAG_OVR: Overrun/Underrun + * @arg I2C_FLAG_PECERR: PEC error in reception + * @arg I2C_FLAG_TIMEOUT: Timeout or Tlow detection flag + * @arg I2C_FLAG_ALERT: SMBus Alert + * @arg I2C_FLAG_BUSY: Bus busy + * @retval The new state of I2C_FLAG (SET or RESET). + */ +FlagStatus I2C_GetFlagStatus(I2C_TypeDef* I2Cx, uint32_t I2C_FLAG) +{ + uint32_t tmpreg = 0; + FlagStatus bitstatus = RESET; + + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_I2C_GET_FLAG(I2C_FLAG)); + + /* Get the ISR register value */ + tmpreg = I2Cx->ISR; + + /* Get flag status */ + tmpreg &= I2C_FLAG; + + if(tmpreg != 0) + { + /* I2C_FLAG is set */ + bitstatus = SET; + } + else + { + /* I2C_FLAG is reset */ + bitstatus = RESET; + } + return bitstatus; +} + +/** + * @brief Clears the I2Cx's pending flags. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param I2C_FLAG: specifies the flag to clear. + * This parameter can be any combination of the following values: + * @arg I2C_FLAG_ADDR: Address matched (slave mode) + * @arg I2C_FLAG_NACKF: NACK received flag + * @arg I2C_FLAG_STOPF: STOP detection flag + * @arg I2C_FLAG_BERR: Bus error + * @arg I2C_FLAG_ARLO: Arbitration lost + * @arg I2C_FLAG_OVR: Overrun/Underrun + * @arg I2C_FLAG_PECERR: PEC error in reception + * @arg I2C_FLAG_TIMEOUT: Timeout or Tlow detection flag + * @arg I2C_FLAG_ALERT: SMBus Alert + * @retval The new state of I2C_FLAG (SET or RESET). + */ +void I2C_ClearFlag(I2C_TypeDef* I2Cx, uint32_t I2C_FLAG) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_I2C_CLEAR_FLAG(I2C_FLAG)); + + /* Clear the selected flag */ + I2Cx->ICR = I2C_FLAG; + } + +/** + * @brief Checks whether the specified I2C interrupt has occurred or not. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param I2C_IT: specifies the interrupt source to check. + * This parameter can be one of the following values: + * @arg I2C_IT_TXIS: Transmit interrupt status + * @arg I2C_IT_RXNE: Receive data register not empty + * @arg I2C_IT_ADDR: Address matched (slave mode) + * @arg I2C_IT_NACKF: NACK received flag + * @arg I2C_IT_STOPF: STOP detection flag + * @arg I2C_IT_TC: Transfer complete (master mode) + * @arg I2C_IT_TCR: Transfer complete reload + * @arg I2C_IT_BERR: Bus error + * @arg I2C_IT_ARLO: Arbitration lost + * @arg I2C_IT_OVR: Overrun/Underrun + * @arg I2C_IT_PECERR: PEC error in reception + * @arg I2C_IT_TIMEOUT: Timeout or Tlow detection flag + * @arg I2C_IT_ALERT: SMBus Alert + * @retval The new state of I2C_IT (SET or RESET). + */ +ITStatus I2C_GetITStatus(I2C_TypeDef* I2Cx, uint32_t I2C_IT) +{ + uint32_t tmpreg = 0; + ITStatus bitstatus = RESET; + uint32_t enablestatus = 0; + + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_I2C_GET_IT(I2C_IT)); + + /* Check if the interrupt source is enabled or not */ + /* If Error interrupt */ + if ((uint32_t)(I2C_IT & ERROR_IT_MASK)) + { + enablestatus = (uint32_t)((I2C_CR1_ERRIE) & (I2Cx->CR1)); + } + /* If TC interrupt */ + else if ((uint32_t)(I2C_IT & TC_IT_MASK)) + { + enablestatus = (uint32_t)((I2C_CR1_TCIE) & (I2Cx->CR1)); + } + else + { + enablestatus = (uint32_t)((I2C_IT) & (I2Cx->CR1)); + } + + /* Get the ISR register value */ + tmpreg = I2Cx->ISR; + + /* Get flag status */ + tmpreg &= I2C_IT; + + /* Check the status of the specified I2C flag */ + if((tmpreg != RESET) && enablestatus) + { + /* I2C_IT is set */ + bitstatus = SET; + } + else + { + /* I2C_IT is reset */ + bitstatus = RESET; + } + + /* Return the I2C_IT status */ + return bitstatus; +} + +/** + * @brief Clears the I2Cx's interrupt pending bits. + * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral. + * @param I2C_IT: specifies the interrupt pending bit to clear. + * This parameter can be any combination of the following values: + * @arg I2C_IT_ADDR: Address matched (slave mode) + * @arg I2C_IT_NACKF: NACK received flag + * @arg I2C_IT_STOPF: STOP detection flag + * @arg I2C_IT_BERR: Bus error + * @arg I2C_IT_ARLO: Arbitration lost + * @arg I2C_IT_OVR: Overrun/Underrun + * @arg I2C_IT_PECERR: PEC error in reception + * @arg I2C_IT_TIMEOUT: Timeout or Tlow detection flag + * @arg I2C_IT_ALERT: SMBus Alert + * @retval The new state of I2C_IT (SET or RESET). + */ +void I2C_ClearITPendingBit(I2C_TypeDef* I2Cx, uint32_t I2C_IT) +{ + /* Check the parameters */ + assert_param(IS_I2C_ALL_PERIPH(I2Cx)); + assert_param(IS_I2C_CLEAR_IT(I2C_IT)); + + /* Clear the selected flag */ + I2Cx->ICR = I2C_IT; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_iwdg.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_iwdg.c new file mode 100644 index 00000000..7f00dd17 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_iwdg.c @@ -0,0 +1,293 @@ +/** + ****************************************************************************** + * @file stm32f0xx_iwdg.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Independent watchdog (IWDG) peripheral: + * + Prescaler and Counter configuration + * + IWDG activation + * + Flag management + * + * @verbatim + * + ============================================================================== + ##### IWDG features ##### + ============================================================================== + [..] The IWDG can be started by either software or hardware (configurable + through option byte). + + [..] The IWDG is clocked by its own dedicated low-speed clock (LSI) and + thus stays active even if the main clock fails. + Once the IWDG is started, the LSI is forced ON and cannot be disabled + (LSI cannot be disabled too), and the counter starts counting down from + the reset value of 0xFFF. When it reaches the end of count value (0x000) + a system reset is generated. + The IWDG counter should be reloaded at regular intervals to prevent + an MCU reset. + + [..] The IWDG is implemented in the VDD voltage domain that is still functional + in STOP and STANDBY mode (IWDG reset can wake-up from STANDBY). + + [..] IWDGRST flag in RCC_CSR register can be used to inform when a IWDG + reset occurs. + + [..] Min-max timeout value @40KHz (LSI): ~0.1ms / ~28.3s + The IWDG timeout may vary due to LSI frequency dispersion. STM32F0xx + devices provide the capability to measure the LSI frequency (LSI clock + should be seleted as RTC clock which is internally connected to TIM10 CH1 + input capture). The measured value can be used to have an IWDG timeout with + an acceptable accuracy. + For more information, please refer to the STM32F0xx Reference manual. + + ##### How to use this driver ##### + ============================================================================== + [..] This driver allows to use IWDG peripheral with either window option enabled + or disabled. To do so follow one of the two procedures below. + (#) Window option is enabled: + (++) Start the IWDG using IWDG_Enable() function, when the IWDG is used + in software mode (no need to enable the LSI, it will be enabled + by hardware). + (++) Enable write access to IWDG_PR and IWDG_RLR registers using + IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable) function. + (++) Configure the IWDG prescaler using IWDG_SetPrescaler() function. + (++) Configure the IWDG counter value using IWDG_SetReload() function. + This value will be loaded in the IWDG counter each time the counter + is reloaded, then the IWDG will start counting down from this value. + (++) Wait for the IWDG registers to be updated using IWDG_GetFlagStatus() function. + (++) Configure the IWDG refresh window using IWDG_SetWindowValue() function. + + (#) Window option is disabled: + (++) Enable write access to IWDG_PR and IWDG_RLR registers using + IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable) function. + (++) Configure the IWDG prescaler using IWDG_SetPrescaler() function. + (++) Configure the IWDG counter value using IWDG_SetReload() function. + This value will be loaded in the IWDG counter each time the counter + is reloaded, then the IWDG will start counting down from this value. + (++) Wait for the IWDG registers to be updated using IWDG_GetFlagStatus() function. + (++) reload the IWDG counter at regular intervals during normal operation + to prevent an MCU reset, using IWDG_ReloadCounter() function. + (++) Start the IWDG using IWDG_Enable() function, when the IWDG is used + in software mode (no need to enable the LSI, it will be enabled + by hardware). + + @endverbatim + * + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_iwdg.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup IWDG + * @brief IWDG driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* ---------------------- IWDG registers bit mask ----------------------------*/ +/* KR register bit mask */ +#define KR_KEY_RELOAD ((uint16_t)0xAAAA) +#define KR_KEY_ENABLE ((uint16_t)0xCCCC) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup IWDG_Private_Functions + * @{ + */ + +/** @defgroup IWDG_Group1 Prescaler and Counter configuration functions + * @brief Prescaler and Counter configuration functions + * +@verbatim + ============================================================================== + ##### Prescaler and Counter configuration functions ##### + ============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables write access to IWDG_PR and IWDG_RLR registers. + * @param IWDG_WriteAccess: new state of write access to IWDG_PR and IWDG_RLR registers. + * This parameter can be one of the following values: + * @arg IWDG_WriteAccess_Enable: Enable write access to IWDG_PR and IWDG_RLR registers + * @arg IWDG_WriteAccess_Disable: Disable write access to IWDG_PR and IWDG_RLR registers + * @retval None + */ +void IWDG_WriteAccessCmd(uint16_t IWDG_WriteAccess) +{ + /* Check the parameters */ + assert_param(IS_IWDG_WRITE_ACCESS(IWDG_WriteAccess)); + IWDG->KR = IWDG_WriteAccess; +} + +/** + * @brief Sets IWDG Prescaler value. + * @param IWDG_Prescaler: specifies the IWDG Prescaler value. + * This parameter can be one of the following values: + * @arg IWDG_Prescaler_4: IWDG prescaler set to 4 + * @arg IWDG_Prescaler_8: IWDG prescaler set to 8 + * @arg IWDG_Prescaler_16: IWDG prescaler set to 16 + * @arg IWDG_Prescaler_32: IWDG prescaler set to 32 + * @arg IWDG_Prescaler_64: IWDG prescaler set to 64 + * @arg IWDG_Prescaler_128: IWDG prescaler set to 128 + * @arg IWDG_Prescaler_256: IWDG prescaler set to 256 + * @retval None + */ +void IWDG_SetPrescaler(uint8_t IWDG_Prescaler) +{ + /* Check the parameters */ + assert_param(IS_IWDG_PRESCALER(IWDG_Prescaler)); + IWDG->PR = IWDG_Prescaler; +} + +/** + * @brief Sets IWDG Reload value. + * @param Reload: specifies the IWDG Reload value. + * This parameter must be a number between 0 and 0x0FFF. + * @retval None + */ +void IWDG_SetReload(uint16_t Reload) +{ + /* Check the parameters */ + assert_param(IS_IWDG_RELOAD(Reload)); + IWDG->RLR = Reload; +} + +/** + * @brief Reloads IWDG counter with value defined in the reload register + * (write access to IWDG_PR and IWDG_RLR registers disabled). + * @param None + * @retval None + */ +void IWDG_ReloadCounter(void) +{ + IWDG->KR = KR_KEY_RELOAD; +} + + +/** + * @brief Sets the IWDG window value. + * @param WindowValue: specifies the window value to be compared to the downcounter. + * @retval None + */ +void IWDG_SetWindowValue(uint16_t WindowValue) +{ + /* Check the parameters */ + assert_param(IS_IWDG_WINDOW_VALUE(WindowValue)); + IWDG->WINR = WindowValue; +} + +/** + * @} + */ + +/** @defgroup IWDG_Group2 IWDG activation function + * @brief IWDG activation function + * +@verbatim + ============================================================================== + ##### IWDG activation function ##### + ============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Enables IWDG (write access to IWDG_PR and IWDG_RLR registers disabled). + * @param None + * @retval None + */ +void IWDG_Enable(void) +{ + IWDG->KR = KR_KEY_ENABLE; +} + +/** + * @} + */ + +/** @defgroup IWDG_Group3 Flag management function + * @brief Flag management function + * +@verbatim + =============================================================================== + ##### Flag management function ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Checks whether the specified IWDG flag is set or not. + * @param IWDG_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg IWDG_FLAG_PVU: Prescaler Value Update on going + * @arg IWDG_FLAG_RVU: Reload Value Update on going + * @arg IWDG_FLAG_WVU: Counter Window Value Update on going + * @retval The new state of IWDG_FLAG (SET or RESET). + */ +FlagStatus IWDG_GetFlagStatus(uint16_t IWDG_FLAG) +{ + FlagStatus bitstatus = RESET; + /* Check the parameters */ + assert_param(IS_IWDG_FLAG(IWDG_FLAG)); + if ((IWDG->SR & IWDG_FLAG) != (uint32_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + /* Return the flag status */ + return bitstatus; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_misc.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_misc.c new file mode 100644 index 00000000..b3e0f2b3 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_misc.c @@ -0,0 +1,167 @@ +/** + ****************************************************************************** + * @file stm32f0xx_misc.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides all the miscellaneous firmware functions (add-on + * to CMSIS functions). + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_misc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup MISC + * @brief MISC driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup MISC_Private_Functions + * @{ + */ +/** + * +@verbatim + ******************************************************************************* + ##### Interrupts configuration functions ##### + ******************************************************************************* + [..] This section provide functions allowing to configure the NVIC interrupts + (IRQ). The Cortex-M0 exceptions are managed by CMSIS functions. + (#) Enable and Configure the priority of the selected IRQ Channels. + The priority can be 0..3. + + -@- Lower priority values gives higher priority. + -@- Priority Order: + (#@) Lowest priority. + (#@) Lowest hardware priority (IRQn position). + +@endverbatim +*/ + +/** + * @brief Initializes the NVIC peripheral according to the specified + * parameters in the NVIC_InitStruct. + * @param NVIC_InitStruct: pointer to a NVIC_InitTypeDef structure that contains + * the configuration information for the specified NVIC peripheral. + * @retval None + */ +void NVIC_Init(NVIC_InitTypeDef* NVIC_InitStruct) +{ + uint32_t tmppriority = 0x00; + + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NVIC_InitStruct->NVIC_IRQChannelCmd)); + assert_param(IS_NVIC_PRIORITY(NVIC_InitStruct->NVIC_IRQChannelPriority)); + + if (NVIC_InitStruct->NVIC_IRQChannelCmd != DISABLE) + { + /* Compute the Corresponding IRQ Priority --------------------------------*/ + tmppriority = NVIC->IP[NVIC_InitStruct->NVIC_IRQChannel >> 0x02]; + tmppriority &= (uint32_t)(~(((uint32_t)0xFF) << ((NVIC_InitStruct->NVIC_IRQChannel & 0x03) * 8))); + tmppriority |= (uint32_t)((((uint32_t)NVIC_InitStruct->NVIC_IRQChannelPriority << 6) & 0xFF) << ((NVIC_InitStruct->NVIC_IRQChannel & 0x03) * 8)); + + NVIC->IP[NVIC_InitStruct->NVIC_IRQChannel >> 0x02] = tmppriority; + + /* Enable the Selected IRQ Channels --------------------------------------*/ + NVIC->ISER[0] = (uint32_t)0x01 << (NVIC_InitStruct->NVIC_IRQChannel & (uint8_t)0x1F); + } + else + { + /* Disable the Selected IRQ Channels -------------------------------------*/ + NVIC->ICER[0] = (uint32_t)0x01 << (NVIC_InitStruct->NVIC_IRQChannel & (uint8_t)0x1F); + } +} + +/** + * @brief Selects the condition for the system to enter low power mode. + * @param LowPowerMode: Specifies the new mode for the system to enter low power mode. + * This parameter can be one of the following values: + * @arg NVIC_LP_SEVONPEND: Low Power SEV on Pend. + * @arg NVIC_LP_SLEEPDEEP: Low Power DEEPSLEEP request. + * @arg NVIC_LP_SLEEPONEXIT: Low Power Sleep on Exit. + * @param NewState: new state of LP condition. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void NVIC_SystemLPConfig(uint8_t LowPowerMode, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_NVIC_LP(LowPowerMode)); + + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + SCB->SCR |= LowPowerMode; + } + else + { + SCB->SCR &= (uint32_t)(~(uint32_t)LowPowerMode); + } +} + +/** + * @brief Configures the SysTick clock source. + * @param SysTick_CLKSource: specifies the SysTick clock source. + * This parameter can be one of the following values: + * @arg SysTick_CLKSource_HCLK_Div8: AHB clock divided by 8 selected as SysTick clock source. + * @arg SysTick_CLKSource_HCLK: AHB clock selected as SysTick clock source. + * @retval None + */ +void SysTick_CLKSourceConfig(uint32_t SysTick_CLKSource) +{ + /* Check the parameters */ + assert_param(IS_SYSTICK_CLK_SOURCE(SysTick_CLKSource)); + + if (SysTick_CLKSource == SysTick_CLKSource_HCLK) + { + SysTick->CTRL |= SysTick_CLKSource_HCLK; + } + else + { + SysTick->CTRL &= SysTick_CLKSource_HCLK_Div8; + } +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_pwr.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_pwr.c new file mode 100644 index 00000000..fe654dbf --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_pwr.c @@ -0,0 +1,566 @@ +/** + ****************************************************************************** + * @file stm32f0xx_pwr.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Power Controller (PWR) peripheral: + * + Backup Domain Access + * + PVD configuration + * + WakeUp pins configuration + * + Low Power modes configuration + * + Flags management + * + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_pwr.h" +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup PWR + * @brief PWR driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ + +/* ------------------ PWR registers bit mask ------------------------ */ + +/* CR register bit mask */ +#define CR_DS_MASK ((uint32_t)0xFFFFFFFC) +#define CR_PLS_MASK ((uint32_t)0xFFFFFF1F) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup PWR_Private_Functions + * @{ + */ + +/** @defgroup PWR_Group1 Backup Domain Access function + * @brief Backup Domain Access function + * +@verbatim + ============================================================================== + ##### Backup Domain Access function ##### + ============================================================================== + + [..] After reset, the Backup Domain Registers (RCC BDCR Register, RTC registers + and RTC backup registers) are protected against possible stray write accesses. + [..] To enable access to Backup domain use the PWR_BackupAccessCmd(ENABLE) function. + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the PWR peripheral registers to their default reset values. + * @param None + * @retval None + */ +void PWR_DeInit(void) +{ + RCC_APB1PeriphResetCmd(RCC_APB1Periph_PWR, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_PWR, DISABLE); +} + +/** + * @brief Enables or disables access to the Backup domain registers. + * @note If the HSE divided by 32 is used as the RTC clock, the + * Backup Domain Access should be kept enabled. + * @param NewState: new state of the access to the Backup domain registers. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void PWR_BackupAccessCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the Backup Domain Access */ + PWR->CR |= PWR_CR_DBP; + } + else + { + /* Disable the Backup Domain Access */ + PWR->CR &= (uint32_t)~((uint32_t)PWR_CR_DBP); + } +} + +/** + * @} + */ + +/** @defgroup PWR_Group2 PVD configuration functions + * @brief PVD configuration functions + * +@verbatim + ============================================================================== + ##### PVD configuration functions ##### + ============================================================================== + [..] + (+) The PVD is used to monitor the VDD power supply by comparing it to a threshold + selected by the PVD Level (PLS[2:0] bits in the PWR_CR). + (+) A PVDO flag is available to indicate if VDD/VDDA is higher or lower than the + PVD threshold. This event is internally connected to the EXTI line16 + and can generate an interrupt if enabled through the EXTI registers. + (+) The PVD is stopped in Standby mode. + +@endverbatim + * @{ + */ + +/** + * @brief Configures the voltage threshold detected by the Power Voltage Detector(PVD). + * @note This function is not applicable for STM32F030 devices. + * @param PWR_PVDLevel: specifies the PVD detection level + * This parameter can be one of the following values: + * @arg PWR_PVDLevel_0 + * @arg PWR_PVDLevel_1 + * @arg PWR_PVDLevel_2 + * @arg PWR_PVDLevel_3 + * @arg PWR_PVDLevel_4 + * @arg PWR_PVDLevel_5 + * @arg PWR_PVDLevel_6 + * @arg PWR_PVDLevel_7 + * @note Refer to the electrical characteristics of your device datasheet for + * more details about the voltage threshold corresponding to each + * detection level. + * @retval None + */ +void PWR_PVDLevelConfig(uint32_t PWR_PVDLevel) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_PWR_PVD_LEVEL(PWR_PVDLevel)); + + tmpreg = PWR->CR; + + /* Clear PLS[7:5] bits */ + tmpreg &= CR_PLS_MASK; + + /* Set PLS[7:5] bits according to PWR_PVDLevel value */ + tmpreg |= PWR_PVDLevel; + + /* Store the new value */ + PWR->CR = tmpreg; +} + +/** + * @brief Enables or disables the Power Voltage Detector(PVD). + * @note This function is not applicable for STM32F030 devices. + * @param NewState: new state of the PVD. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void PWR_PVDCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the PVD */ + PWR->CR |= PWR_CR_PVDE; + } + else + { + /* Disable the PVD */ + PWR->CR &= (uint32_t)~((uint32_t)PWR_CR_PVDE); + } +} + +/** + * @} + */ + +/** @defgroup PWR_Group3 WakeUp pins configuration functions + * @brief WakeUp pins configuration functions + * +@verbatim + ============================================================================== + ##### WakeUp pin configuration functions ##### + ============================================================================== + + (+) WakeUp pins are used to wakeup the system from Standby mode. These pins are + forced in input pull down configuration and are active on rising edges. + (+) There are eight WakeUp pins: WakeUp Pin 1 on PA.00 and WakeUp Pin 2 on PC.13. + The following WakeUp pins are only applicable for STM32F072 dvices: + WakeUp Pin 3 on PE.06, WakeUp Pin 4 on PA.02, WakeUp Pin 5 on PC.05, + WakeUp Pin 6 on PB.05, WakeUp Pin 7 on PB.15 and WakeUp Pin 8 on PF.02. + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the WakeUp Pin functionality. + * @param PWR_WakeUpPin: specifies the WakeUpPin. + * This parameter can be one of the following values + * @arg PWR_WakeUpPin_1 + * @arg PWR_WakeUpPin_2 + * @arg PWR_WakeUpPin_3, only applicable for STM32F072 devices + * @arg PWR_WakeUpPin_4, only applicable for STM32F072 devices + * @arg PWR_WakeUpPin_5, only applicable for STM32F072 devices + * @arg PWR_WakeUpPin_6, only applicable for STM32F072 devices + * @arg PWR_WakeUpPin_7, only applicable for STM32F072 devices + * @arg PWR_WakeUpPin_8, only applicable for STM32F072 devices + * @param NewState: new state of the WakeUp Pin functionality. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void PWR_WakeUpPinCmd(uint32_t PWR_WakeUpPin, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_PWR_WAKEUP_PIN(PWR_WakeUpPin)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the EWUPx pin */ + PWR->CSR |= PWR_WakeUpPin; + } + else + { + /* Disable the EWUPx pin */ + PWR->CSR &= ~PWR_WakeUpPin; + } +} + +/** + * @} + */ + + +/** @defgroup PWR_Group4 Low Power modes configuration functions + * @brief Low Power modes configuration functions + * +@verbatim + ============================================================================== + ##### Low Power modes configuration functions ##### + ============================================================================== + + [..] The devices feature three low-power modes: + (+) Sleep mode: Cortex-M0 core stopped, peripherals kept running. + (+) Stop mode: all clocks are stopped, regulator running, regulator in low power mode + (+) Standby mode: VCORE domain powered off + + *** Sleep mode *** + ================== + [..] + (+) Entry: + (++) The Sleep mode is entered by executing the WFE() or WFI() instructions. + (+) Exit: + (++) Any peripheral interrupt acknowledged by the nested vectored interrupt + controller (NVIC) can wake up the device from Sleep mode. + + *** Stop mode *** + ================= + [..] In Stop mode, all clocks in the VCORE domain are stopped, the PLL, the HSI, + the HSI14 and the HSE RC oscillators are disabled. Internal SRAM and register + contents are preserved. + The voltage regulator can be configured either in normal or low-power mode. + + (+) Entry: + (++) The Stop mode is entered using the PWR_EnterSTOPMode(PWR_Regulator_LowPower,) + function with regulator in LowPower or with Regulator ON. + (+) Exit: + (++) Any EXTI Line (Internal or External) configured in Interrupt/Event mode + or any internal IPs (I2C, UASRT or CEC) wakeup event. + + *** Standby mode *** + ==================== + [..] The Standby mode allows to achieve the lowest power consumption. It is based + on the Cortex-M0 deepsleep mode, with the voltage regulator disabled. + The VCORE domain is consequently powered off. The PLL, the HSI, the HSI14 + oscillator and the HSE oscillator are also switched off. SRAM and register + contents are lost except for the Backup domain (RTC registers, RTC backup + registers and Standby circuitry). + + [..] The voltage regulator is OFF. + + (+) Entry: + (++) The Standby mode is entered using the PWR_EnterSTANDBYMode() function. + (+) Exit: + (++) WKUP pin rising edge, RTC alarm (Alarm A and Alarm B), RTC wakeup, + tamper event, time-stamp event, external reset in NRST pin, IWDG reset. + + *** Auto-wakeup (AWU) from low-power mode *** + ============================================= + [..] The MCU can be woken up from low-power mode by an RTC Alarm event, a tamper + event, a time-stamp event, or a comparator event, without depending on an + external interrupt (Auto-wakeup mode). + + (+) RTC auto-wakeup (AWU) from the Stop mode + (++) To wake up from the Stop mode with an RTC alarm event, it is necessary to: + (+++) Configure the EXTI Line 17 to be sensitive to rising edges (Interrupt + or Event modes) using the EXTI_Init() function. + (+++) Enable the RTC Alarm Interrupt using the RTC_ITConfig() function + (+++) Configure the RTC to generate the RTC alarm using the RTC_SetAlarm() + and RTC_AlarmCmd() functions. + (++) To wake up from the Stop mode with an RTC Tamper or time stamp event, it + is necessary to: + (+++) Configure the EXTI Line 19 to be sensitive to rising edges (Interrupt + or Event modes) using the EXTI_Init() function. + (+++) Enable the RTC Tamper or time stamp Interrupt using the RTC_ITConfig() + function. + (+++) Configure the RTC to detect the tamper or time stamp event using the + RTC_TimeStampConfig(), RTC_TamperTriggerConfig() and RTC_TamperCmd() + functions. + + (+) RTC auto-wakeup (AWU) from the Standby mode + (++) To wake up from the Standby mode with an RTC alarm event, it is necessary to: + (+++) Enable the RTC Alarm Interrupt using the RTC_ITConfig() function. + (+++) Configure the RTC to generate the RTC alarm using the RTC_SetAlarm() + and RTC_AlarmCmd() functions. + (++) To wake up from the Standby mode with an RTC Tamper or time stamp event, it + is necessary to: + (+++) Enable the RTC Tamper or time stamp Interrupt using the RTC_ITConfig() + function. + (+++) Configure the RTC to detect the tamper or time stamp event using the + RTC_TimeStampConfig(), RTC_TamperTriggerConfig() and RTC_TamperCmd() + functions. + + (+) Comparator auto-wakeup (AWU) from the Stop mode + (++) To wake up from the Stop mode with an comparator 1 or comparator 2 wakeup + event, it is necessary to: + (+++) Configure the EXTI Line 21 for comparator 1 or EXTI Line 22 for comparator 2 + to be sensitive to to the selected edges (falling, rising or falling + and rising) (Interrupt or Event modes) using the EXTI_Init() function. + (+++) Configure the comparator to generate the event. + +@endverbatim + * @{ + */ + +/** + * @brief Enters Sleep mode. + * @note In Sleep mode, all I/O pins keep the same state as in Run mode. + * @param PWR_SLEEPEntry: specifies if SLEEP mode in entered with WFI or WFE instruction. + * This parameter can be one of the following values: + * @arg PWR_SLEEPEntry_WFI: enter SLEEP mode with WFI instruction + * @arg PWR_SLEEPEntry_WFE: enter SLEEP mode with WFE instruction + * @retval None + */ +void PWR_EnterSleepMode(uint8_t PWR_SLEEPEntry) +{ + /* Check the parameters */ + assert_param(IS_PWR_SLEEP_ENTRY(PWR_SLEEPEntry)); + + /* Clear SLEEPDEEP bit of Cortex-M0 System Control Register */ + SCB->SCR &= (uint32_t)~((uint32_t)SCB_SCR_SLEEPDEEP_Msk); + + /* Select SLEEP mode entry -------------------------------------------------*/ + if(PWR_SLEEPEntry == PWR_SLEEPEntry_WFI) + { + /* Request Wait For Interrupt */ + __WFI(); + } + else + { + /* Request Wait For Event */ + __SEV(); + __WFE(); + __WFE(); + } +} + +/** + * @brief Enters STOP mode. + * @note In Stop mode, all I/O pins keep the same state as in Run mode. + * @note When exiting Stop mode by issuing an interrupt or a wakeup event, + * the HSI RC oscillator is selected as system clock. + * @note When the voltage regulator operates in low power mode, an additional + * startup delay is incurred when waking up from Stop mode. + * By keeping the internal regulator ON during Stop mode, the consumption + * is higher although the startup time is reduced. + * @param PWR_Regulator: specifies the regulator state in STOP mode. + * This parameter can be one of the following values: + * @arg PWR_Regulator_ON: STOP mode with regulator ON + * @arg PWR_Regulator_LowPower: STOP mode with regulator in low power mode + * @param PWR_STOPEntry: specifies if STOP mode in entered with WFI or WFE instruction. + * This parameter can be one of the following values: + * @arg PWR_STOPEntry_WFI: enter STOP mode with WFI instruction + * @arg PWR_STOPEntry_WFE: enter STOP mode with WFE instruction + @arg PWR_STOPEntry_SLEEPONEXIT: enter STOP mode with SLEEPONEXIT instruction + * @retval None + */ +void PWR_EnterSTOPMode(uint32_t PWR_Regulator, uint8_t PWR_STOPEntry) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_PWR_REGULATOR(PWR_Regulator)); + assert_param(IS_PWR_STOP_ENTRY(PWR_STOPEntry)); + + /* Select the regulator state in STOP mode ---------------------------------*/ + tmpreg = PWR->CR; + /* Clear PDDS and LPDSR bits */ + tmpreg &= CR_DS_MASK; + + /* Set LPDSR bit according to PWR_Regulator value */ + tmpreg |= PWR_Regulator; + + /* Store the new value */ + PWR->CR = tmpreg; + + /* Set SLEEPDEEP bit of Cortex-M0 System Control Register */ + SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk; + + /* Select STOP mode entry --------------------------------------------------*/ + if(PWR_STOPEntry == PWR_STOPEntry_WFI) + { + /* Request Wait For Interrupt */ + __WFI(); + /* Reset SLEEPDEEP bit of Cortex System Control Register */ + SCB->SCR &= (uint32_t)~((uint32_t)SCB_SCR_SLEEPDEEP_Msk); + } + else if (PWR_STOPEntry == PWR_STOPEntry_WFE) + { + /* Request Wait For Event */ + __WFE(); + /* Reset SLEEPDEEP bit of Cortex System Control Register */ + SCB->SCR &= (uint32_t)~((uint32_t)SCB_SCR_SLEEPDEEP_Msk); + } + else + { + /* Set SLEEP on exit bit of Cortex-M0 System Control Register */ + SCB->SCR |= SCB_SCR_SLEEPONEXIT_Msk; + } +} + +/** + * @brief Enters STANDBY mode. + * @note In Standby mode, all I/O pins are high impedance except for: + * - Reset pad (still available) + * - RTC_AF1 pin (PC13) if configured for Wakeup pin 2 (WKUP2), tamper, + * time-stamp, RTC Alarm out, or RTC clock calibration out. + * - WKUP pin 1 (PA0) if enabled. + * @note The Wakeup flag (WUF) need to be cleared at application level before to call this function + * @param None + * @retval None + */ +void PWR_EnterSTANDBYMode(void) +{ + /* Select STANDBY mode */ + PWR->CR |= PWR_CR_PDDS; + + /* Set SLEEPDEEP bit of Cortex-M0 System Control Register */ + SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk; + + /* Request Wait For Interrupt */ + __WFI(); +} + +/** + * @} + */ + +/** @defgroup PWR_Group5 Flags management functions + * @brief Flags management functions + * +@verbatim + ============================================================================== + ##### Flags management functions ##### + ============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Checks whether the specified PWR flag is set or not. + * @param PWR_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg PWR_FLAG_WU: Wake Up flag. This flag indicates that a wakeup + * event was received from the WKUP pin or from the RTC alarm + * (Alarm A or Alarm B), RTC Tamper event or RTC TimeStamp event. + * @arg PWR_FLAG_SB: StandBy flag. This flag indicates that the + * system was resumed from StandBy mode. + * @arg PWR_FLAG_PVDO: PVD Output. This flag is valid only if PVD + * is enabled by the PWR_PVDCmd() function. + * @arg PWR_FLAG_VREFINTRDY: Internal Voltage Reference Ready flag. + * This flag indicates the state of the internal voltage + * reference, VREFINT. + * @retval The new state of PWR_FLAG (SET or RESET). + */ +FlagStatus PWR_GetFlagStatus(uint32_t PWR_FLAG) +{ + FlagStatus bitstatus = RESET; + /* Check the parameters */ + assert_param(IS_PWR_GET_FLAG(PWR_FLAG)); + + if ((PWR->CSR & PWR_FLAG) != (uint32_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + /* Return the flag status */ + return bitstatus; +} + +/** + * @brief Clears the PWR's pending flags. + * @param PWR_FLAG: specifies the flag to clear. + * This parameter can be one of the following values: + * @arg PWR_FLAG_WU: Wake Up flag + * @arg PWR_FLAG_SB: StandBy flag + * @retval None + */ +void PWR_ClearFlag(uint32_t PWR_FLAG) +{ + /* Check the parameters */ + assert_param(IS_PWR_CLEAR_FLAG(PWR_FLAG)); + + PWR->CR |= PWR_FLAG << 2; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_rcc.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_rcc.c new file mode 100644 index 00000000..f4f72c2a --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_rcc.c @@ -0,0 +1,1781 @@ +/** + ****************************************************************************** + * @file stm32f0xx_rcc.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Reset and clock control (RCC) peripheral: + * + Internal/external clocks, PLL, CSS and MCO configuration + * + System, AHB and APB busses clocks configuration + * + Peripheral clocks configuration + * + Interrupts and flags management + * + @verbatim + + =============================================================================== + ##### RCC specific features ##### + =============================================================================== + [..] After reset the device is running from HSI (8 MHz) with Flash 0 WS, + all peripherals are off except internal SRAM, Flash and SWD. + (#) There is no prescaler on High speed (AHB) and Low speed (APB) busses; + all peripherals mapped on these busses are running at HSI speed. + (#) The clock for all peripherals is switched off, except the SRAM and FLASH. + (#) All GPIOs are in input floating state, except the SWD pins which + are assigned to be used for debug purpose. + [..] Once the device started from reset, the user application has to: + (#) Configure the clock source to be used to drive the System clock + (if the application needs higher frequency/performance) + (#) Configure the System clock frequency and Flash settings + (#) Configure the AHB and APB busses prescalers + (#) Enable the clock for the peripheral(s) to be used + (#) Configure the clock source(s) for peripherals which clocks are not + derived from the System clock (ADC, CEC, I2C, USART, RTC and IWDG) + + @endverbatim + + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup RCC + * @brief RCC driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ + +/* ---------------------- RCC registers mask -------------------------------- */ +/* RCC Flag Mask */ +#define FLAG_MASK ((uint8_t)0x1F) + +/* CR register byte 2 (Bits[23:16]) base address */ +#define CR_BYTE2_ADDRESS ((uint32_t)0x40021002) + +/* CFGR register byte 3 (Bits[31:23]) base address */ +#define CFGR_BYTE3_ADDRESS ((uint32_t)0x40021007) + +/* CIR register byte 1 (Bits[15:8]) base address */ +#define CIR_BYTE1_ADDRESS ((uint32_t)0x40021009) + +/* CIR register byte 2 (Bits[23:16]) base address */ +#define CIR_BYTE2_ADDRESS ((uint32_t)0x4002100A) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +static __I uint8_t APBAHBPrescTable[16] = {0, 0, 0, 0, 1, 2, 3, 4, 1, 2, 3, 4, 6, 7, 8, 9}; + +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup RCC_Private_Functions + * @{ + */ + +/** @defgroup RCC_Group1 Internal and external clocks, PLL, CSS and MCO configuration functions + * @brief Internal and external clocks, PLL, CSS and MCO configuration functions + * +@verbatim + =============================================================================== + ##### Internal-external clocks, PLL, CSS and MCO configuration functions ##### + =============================================================================== + [..] This section provides functions allowing to configure the internal/external clocks, + PLL, CSS and MCO. + (#) HSI (high-speed internal), 8 MHz factory-trimmed RC used directly + or through the PLL as System clock source. + The HSI clock can be used also to clock the USART, I2C and CEC peripherals. + (#) HSI14 (high-speed internal for ADC), 14 MHz factory-trimmed RC used to clock + the ADC peripheral. + (#) LSI (low-speed internal), 40 KHz low consumption RC used as IWDG and/or RTC + clock source. + (#) HSE (high-speed external), 4 to 32 MHz crystal oscillator used directly or + through the PLL as System clock source. Can be used also as RTC clock source. + (#) LSE (low-speed external), 32 KHz oscillator used as RTC clock source. + LSE can be used also to clock the USART and CEC peripherals. + (#) PLL (clocked by HSI or HSE), for System clock. + (#) CSS (Clock security system), once enabled and if a HSE clock failure occurs + (HSE used directly or through PLL as System clock source), the System clock + is automatically switched to HSI and an interrupt is generated if enabled. + The interrupt is linked to the Cortex-M0 NMI (Non-Maskable Interrupt) + exception vector. + (#) MCO (microcontroller clock output), used to output SYSCLK, HSI, HSI14, LSI, + HSE, LSE or PLL (divided by 2) clock on PA8 pin. + +@endverbatim + * @{ + */ + +/** + * @brief Resets the RCC clock configuration to the default reset state. + * @note The default reset state of the clock configuration is given below: + * @note HSI ON and used as system clock source + * @note HSI14, HSE and PLL OFF + * @note AHB, APB prescaler set to 1. + * @note CSS and MCO OFF + * @note All interrupts disabled + * @note However, this function doesn't modify the configuration of the + * @note Peripheral clocks + * @note LSI, LSE and RTC clocks + * @param None + * @retval None + */ +void RCC_DeInit(void) +{ + /* Set HSION bit */ + RCC->CR |= (uint32_t)0x00000001; + +#if defined (STM32F051) + /* Reset SW[1:0], HPRE[3:0], PPRE[2:0] and MCOSEL[2:0] bits */ + RCC->CFGR &= (uint32_t)0xF8FFB80C; +#else + /* Reset SW[1:0], HPRE[3:0], PPRE[2:0], ADCPRE, MCOSEL[2:0], MCOPRE[2:0] and PLLNODIV bits */ + RCC->CFGR &= (uint32_t)0x08FFB80C; +#endif /* STM32F051 */ + + /* Reset HSEON, CSSON and PLLON bits */ + RCC->CR &= (uint32_t)0xFEF6FFFF; + + /* Reset HSEBYP bit */ + RCC->CR &= (uint32_t)0xFFFBFFFF; + + /* Reset PLLSRC, PLLXTPRE and PLLMUL[3:0] bits */ + RCC->CFGR &= (uint32_t)0xFFC0FFFF; + + /* Reset PREDIV1[3:0] bits */ + RCC->CFGR2 &= (uint32_t)0xFFFFFFF0; + + /* Reset USARTSW[1:0], I2CSW, CECSW and ADCSW bits */ + RCC->CFGR3 &= (uint32_t)0xFFF0FEAC; + + /* Reset HSI14 bit */ + RCC->CR2 &= (uint32_t)0xFFFFFFFE; + + /* Disable all interrupts */ + RCC->CIR = 0x00000000; +} + +/** + * @brief Configures the External High Speed oscillator (HSE). + * @note After enabling the HSE (RCC_HSE_ON or RCC_HSE_Bypass), the application + * software should wait on HSERDY flag to be set indicating that HSE clock + * is stable and can be used to clock the PLL and/or system clock. + * @note HSE state can not be changed if it is used directly or through the + * PLL as system clock. In this case, you have to select another source + * of the system clock then change the HSE state (ex. disable it). + * @note The HSE is stopped by hardware when entering STOP and STANDBY modes. + * @note This function resets the CSSON bit, so if the Clock security system(CSS) + * was previously enabled you have to enable it again after calling this + * function. + * @param RCC_HSE: specifies the new state of the HSE. + * This parameter can be one of the following values: + * @arg RCC_HSE_OFF: turn OFF the HSE oscillator, HSERDY flag goes low after + * 6 HSE oscillator clock cycles. + * @arg RCC_HSE_ON: turn ON the HSE oscillator + * @arg RCC_HSE_Bypass: HSE oscillator bypassed with external clock + * @retval None + */ +void RCC_HSEConfig(uint8_t RCC_HSE) +{ + /* Check the parameters */ + assert_param(IS_RCC_HSE(RCC_HSE)); + + /* Reset HSEON and HSEBYP bits before configuring the HSE ------------------*/ + *(__IO uint8_t *) CR_BYTE2_ADDRESS = RCC_HSE_OFF; + + /* Set the new HSE configuration -------------------------------------------*/ + *(__IO uint8_t *) CR_BYTE2_ADDRESS = RCC_HSE; + +} + +/** + * @brief Waits for HSE start-up. + * @note This function waits on HSERDY flag to be set and return SUCCESS if + * this flag is set, otherwise returns ERROR if the timeout is reached + * and this flag is not set. The timeout value is defined by the constant + * HSE_STARTUP_TIMEOUT in stm32f0xx.h file. You can tailor it depending + * on the HSE crystal used in your application. + * @note The HSE is stopped by hardware when entering STOP and STANDBY modes. + * @param None + * @retval An ErrorStatus enumeration value: + * - SUCCESS: HSE oscillator is stable and ready to use + * - ERROR: HSE oscillator not yet ready + */ +ErrorStatus RCC_WaitForHSEStartUp(void) +{ + __IO uint32_t StartUpCounter = 0; + ErrorStatus status = ERROR; + FlagStatus HSEStatus = RESET; + + /* Wait till HSE is ready and if timeout is reached exit */ + do + { + HSEStatus = RCC_GetFlagStatus(RCC_FLAG_HSERDY); + StartUpCounter++; + } while((StartUpCounter != HSE_STARTUP_TIMEOUT) && (HSEStatus == RESET)); + + if (RCC_GetFlagStatus(RCC_FLAG_HSERDY) != RESET) + { + status = SUCCESS; + } + else + { + status = ERROR; + } + return (status); +} + +/** + * @brief Adjusts the Internal High Speed oscillator (HSI) calibration value. + * @note The calibration is used to compensate for the variations in voltage + * and temperature that influence the frequency of the internal HSI RC. + * Refer to the Application Note AN4067 for more details on how to + * calibrate the HSI. + * @param HSICalibrationValue: specifies the HSI calibration trimming value. + * This parameter must be a number between 0 and 0x1F. + * @retval None + */ +void RCC_AdjustHSICalibrationValue(uint8_t HSICalibrationValue) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RCC_HSI_CALIBRATION_VALUE(HSICalibrationValue)); + + tmpreg = RCC->CR; + + /* Clear HSITRIM[4:0] bits */ + tmpreg &= ~RCC_CR_HSITRIM; + + /* Set the HSITRIM[4:0] bits according to HSICalibrationValue value */ + tmpreg |= (uint32_t)HSICalibrationValue << 3; + + /* Store the new value */ + RCC->CR = tmpreg; +} + +/** + * @brief Enables or disables the Internal High Speed oscillator (HSI). + * @note After enabling the HSI, the application software should wait on + * HSIRDY flag to be set indicating that HSI clock is stable and can + * be used to clock the PLL and/or system clock. + * @note HSI can not be stopped if it is used directly or through the PLL + * as system clock. In this case, you have to select another source + * of the system clock then stop the HSI. + * @note The HSI is stopped by hardware when entering STOP and STANDBY modes. + * @param NewState: new state of the HSI. + * This parameter can be: ENABLE or DISABLE. + * @note When the HSI is stopped, HSIRDY flag goes low after 6 HSI oscillator + * clock cycles. + * @retval None + */ +void RCC_HSICmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->CR |= RCC_CR_HSION; + } + else + { + RCC->CR &= ~RCC_CR_HSION; + } +} + +/** + * @brief Adjusts the Internal High Speed oscillator for ADC (HSI14) + * calibration value. + * @note The calibration is used to compensate for the variations in voltage + * and temperature that influence the frequency of the internal HSI RC. + * Refer to the Application Note AN4067 for more details on how to + * calibrate the HSI14. + * @param HSI14CalibrationValue: specifies the HSI14 calibration trimming value. + * This parameter must be a number between 0 and 0x1F. + * @retval None + */ +void RCC_AdjustHSI14CalibrationValue(uint8_t HSI14CalibrationValue) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RCC_HSI14_CALIBRATION_VALUE(HSI14CalibrationValue)); + + tmpreg = RCC->CR2; + + /* Clear HSI14TRIM[4:0] bits */ + tmpreg &= ~RCC_CR2_HSI14TRIM; + + /* Set the HSITRIM14[4:0] bits according to HSI14CalibrationValue value */ + tmpreg |= (uint32_t)HSI14CalibrationValue << 3; + + /* Store the new value */ + RCC->CR2 = tmpreg; +} + +/** + * @brief Enables or disables the Internal High Speed oscillator for ADC (HSI14). + * @note After enabling the HSI14, the application software should wait on + * HSIRDY flag to be set indicating that HSI clock is stable and can + * be used to clock the ADC. + * @note The HSI14 is stopped by hardware when entering STOP and STANDBY modes. + * @param NewState: new state of the HSI14. + * This parameter can be: ENABLE or DISABLE. + * @note When the HSI14 is stopped, HSI14RDY flag goes low after 6 HSI14 oscillator + * clock cycles. + * @retval None + */ +void RCC_HSI14Cmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->CR2 |= RCC_CR2_HSI14ON; + } + else + { + RCC->CR2 &= ~RCC_CR2_HSI14ON; + } +} + +/** + * @brief Enables or disables the Internal High Speed oscillator request from ADC. + * @param NewState: new state of the HSI14 ADC request. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_HSI14ADCRequestCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->CR2 &= ~RCC_CR2_HSI14DIS; + } + else + { + RCC->CR2 |= RCC_CR2_HSI14DIS; + } +} + +/** + * @brief Configures the External Low Speed oscillator (LSE). + * @note As the LSE is in the Backup domain and write access is denied to this + * domain after reset, you have to enable write access using + * PWR_BackupAccessCmd(ENABLE) function before to configure the LSE + * (to be done once after reset). + * @note After enabling the LSE (RCC_LSE_ON or RCC_LSE_Bypass), the application + * software should wait on LSERDY flag to be set indicating that LSE clock + * is stable and can be used to clock the RTC. + * @param RCC_LSE: specifies the new state of the LSE. + * This parameter can be one of the following values: + * @arg RCC_LSE_OFF: turn OFF the LSE oscillator, LSERDY flag goes low after + * 6 LSE oscillator clock cycles. + * @arg RCC_LSE_ON: turn ON the LSE oscillator + * @arg RCC_LSE_Bypass: LSE oscillator bypassed with external clock + * @retval None + */ +void RCC_LSEConfig(uint32_t RCC_LSE) +{ + /* Check the parameters */ + assert_param(IS_RCC_LSE(RCC_LSE)); + + /* Reset LSEON and LSEBYP bits before configuring the LSE ------------------*/ + /* Reset LSEON bit */ + RCC->BDCR &= ~(RCC_BDCR_LSEON); + + /* Reset LSEBYP bit */ + RCC->BDCR &= ~(RCC_BDCR_LSEBYP); + + /* Configure LSE */ + RCC->BDCR |= RCC_LSE; +} + +/** + * @brief Configures the External Low Speed oscillator (LSE) drive capability. + * @param RCC_LSEDrive: specifies the new state of the LSE drive capability. + * This parameter can be one of the following values: + * @arg RCC_LSEDrive_Low: LSE oscillator low drive capability. + * @arg RCC_LSEDrive_MediumLow: LSE oscillator medium low drive capability. + * @arg RCC_LSEDrive_MediumHigh: LSE oscillator medium high drive capability. + * @arg RCC_LSEDrive_High: LSE oscillator high drive capability. + * @retval None + */ +void RCC_LSEDriveConfig(uint32_t RCC_LSEDrive) +{ + /* Check the parameters */ + assert_param(IS_RCC_LSE_DRIVE(RCC_LSEDrive)); + + /* Clear LSEDRV[1:0] bits */ + RCC->BDCR &= ~(RCC_BDCR_LSEDRV); + + /* Set the LSE Drive */ + RCC->BDCR |= RCC_LSEDrive; +} + +/** + * @brief Enables or disables the Internal Low Speed oscillator (LSI). + * @note After enabling the LSI, the application software should wait on + * LSIRDY flag to be set indicating that LSI clock is stable and can + * be used to clock the IWDG and/or the RTC. + * @note LSI can not be disabled if the IWDG is running. + * @param NewState: new state of the LSI. + * This parameter can be: ENABLE or DISABLE. + * @note When the LSI is stopped, LSIRDY flag goes low after 6 LSI oscillator + * clock cycles. + * @retval None + */ +void RCC_LSICmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->CSR |= RCC_CSR_LSION; + } + else + { + RCC->CSR &= ~RCC_CSR_LSION; + } +} + +/** + * @brief Configures the PLL clock source and multiplication factor. + * @note This function must be used only when the PLL is disabled. + * + * @param RCC_PLLSource: specifies the PLL entry clock source. + * This parameter can be one of the following values: + * @arg RCC_PLLSource_HSI_Div2: HSI oscillator clock selected as PLL clock source + * @arg RCC_PLLSource_PREDIV1: PREDIV1 clock selected as PLL clock entry + * @arg RCC_PLLSource_HSI48 HSI48 oscillator clock selected as PLL clock source, applicable only for STM32F072 devices + * @arg RCC_PLLSource_HSI: HSI clock selected as PLL clock entry, applicable only for STM32F072 devices + * @note The minimum input clock frequency for PLL is 2 MHz (when using HSE as + * PLL source). + * + * @param RCC_PLLMul: specifies the PLL multiplication factor, which drive the PLLVCO clock + * This parameter can be RCC_PLLMul_x where x:[2,16] + * + * @retval None + */ +void RCC_PLLConfig(uint32_t RCC_PLLSource, uint32_t RCC_PLLMul) +{ + /* Check the parameters */ + assert_param(IS_RCC_PLL_SOURCE(RCC_PLLSource)); + assert_param(IS_RCC_PLL_MUL(RCC_PLLMul)); + + /* Clear PLL Source [16] and Multiplier [21:18] bits */ + RCC->CFGR &= ~(RCC_CFGR_PLLMULL | RCC_CFGR_PLLSRC); + + /* Set the PLL Source and Multiplier */ + RCC->CFGR |= (uint32_t)(RCC_PLLSource | RCC_PLLMul); +} + +/** + * @brief Enables or disables the PLL. + * @note After enabling the PLL, the application software should wait on + * PLLRDY flag to be set indicating that PLL clock is stable and can + * be used as system clock source. + * @note The PLL can not be disabled if it is used as system clock source + * @note The PLL is disabled by hardware when entering STOP and STANDBY modes. + * @param NewState: new state of the PLL. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_PLLCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->CR |= RCC_CR_PLLON; + } + else + { + RCC->CR &= ~RCC_CR_PLLON; + } +} + +/** + * @brief Enables or disables the Internal High Speed oscillator for USB (HSI48). + * This function is only applicable for STM32F072 devices. + * @note After enabling the HSI48, the application software should wait on + * HSI48RDY flag to be set indicating that HSI48 clock is stable and can + * be used to clock the USB. + * @note The HSI48 is stopped by hardware when entering STOP and STANDBY modes. + * @param NewState: new state of the HSI48. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_HSI48Cmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->CR2 |= RCC_CR2_HSI48ON; + } + else + { + RCC->CR2 &= ~RCC_CR2_HSI48ON; + } +} + +/** + * @brief Configures the PREDIV1 division factor. + * @note This function must be used only when the PLL is disabled. + * @param RCC_PREDIV1_Div: specifies the PREDIV1 clock division factor. + * This parameter can be RCC_PREDIV1_Divx where x:[1,16] + * @retval None + */ +void RCC_PREDIV1Config(uint32_t RCC_PREDIV1_Div) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RCC_PREDIV1(RCC_PREDIV1_Div)); + + tmpreg = RCC->CFGR2; + /* Clear PREDIV1[3:0] bits */ + tmpreg &= ~(RCC_CFGR2_PREDIV1); + /* Set the PREDIV1 division factor */ + tmpreg |= RCC_PREDIV1_Div; + /* Store the new value */ + RCC->CFGR2 = tmpreg; +} + +/** + * @brief Enables or disables the Clock Security System. + * @note If a failure is detected on the HSE oscillator clock, this oscillator + * is automatically disabled and an interrupt is generated to inform the + * software about the failure (Clock Security System Interrupt, CSSI), + * allowing the MCU to perform rescue operations. The CSSI is linked to + * the Cortex-M0 NMI (Non-Maskable Interrupt) exception vector. + * @param NewState: new state of the Clock Security System. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_ClockSecuritySystemCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->CR |= RCC_CR_CSSON; + } + else + { + RCC->CR &= ~RCC_CR_CSSON; + } +} + +#ifdef STM32F051 +/** + * @brief Selects the clock source to output on MCO pin (PA8). + * @note PA8 should be configured in alternate function mode. + * @param RCC_MCOSource: specifies the clock source to output. + * This parameter can be one of the following values: + * @arg RCC_MCOSource_NoClock: No clock selected. + * @arg RCC_MCOSource_HSI14: HSI14 oscillator clock selected. + * @arg RCC_MCOSource_LSI: LSI oscillator clock selected. + * @arg RCC_MCOSource_LSE: LSE oscillator clock selected. + * @arg RCC_MCOSource_SYSCLK: System clock selected. + * @arg RCC_MCOSource_HSI: HSI oscillator clock selected. + * @arg RCC_MCOSource_HSE: HSE oscillator clock selected. + * @arg RCC_MCOSource_PLLCLK_Div2: PLL clock divided by 2 selected. + * @retval None + */ +void RCC_MCOConfig(uint8_t RCC_MCOSource) +{ + /* Check the parameters */ + assert_param(IS_RCC_MCO_SOURCE(RCC_MCOSource)); + + /* Select MCO clock source and prescaler */ + *(__IO uint8_t *) CFGR_BYTE3_ADDRESS = RCC_MCOSource; +} +#else + +/** + * @brief Selects the clock source to output on MCO pin (PA8) and the corresponding + * prescsaler. + * @note PA8 should be configured in alternate function mode. + * @param RCC_MCOSource: specifies the clock source to output. + * This parameter can be one of the following values: + * @arg RCC_MCOSource_NoClock: No clock selected. + * @arg RCC_MCOSource_HSI14: HSI14 oscillator clock selected. + * @arg RCC_MCOSource_LSI: LSI oscillator clock selected. + * @arg RCC_MCOSource_LSE: LSE oscillator clock selected. + * @arg RCC_MCOSource_SYSCLK: System clock selected. + * @arg RCC_MCOSource_HSI: HSI oscillator clock selected. + * @arg RCC_MCOSource_HSE: HSE oscillator clock selected. + * @arg RCC_MCOSource_PLLCLK_Div2: PLL clock divided by 2 selected. + * @arg RCC_MCOSource_PLLCLK: PLL clock selected. + * @arg RCC_MCOSource_HSI48: HSI48 clock selected. + * @param RCC_MCOPrescaler: specifies the prescaler on MCO pin. + * This parameter can be one of the following values: + * @arg RCC_MCOPrescaler_1: MCO clock is divided by 1. + * @arg RCC_MCOPrescaler_2: MCO clock is divided by 2. + * @arg RCC_MCOPrescaler_4: MCO clock is divided by 4. + * @arg RCC_MCOPrescaler_8: MCO clock is divided by 8. + * @arg RCC_MCOPrescaler_16: MCO clock is divided by 16. + * @arg RCC_MCOPrescaler_32: MCO clock is divided by 32. + * @arg RCC_MCOPrescaler_64: MCO clock is divided by 64. + * @arg RCC_MCOPrescaler_128: MCO clock is divided by 128. + * @retval None + */ +void RCC_MCOConfig(uint8_t RCC_MCOSource, uint32_t RCC_MCOPrescaler) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RCC_MCO_SOURCE(RCC_MCOSource)); + assert_param(IS_RCC_MCO_PRESCALER(RCC_MCOPrescaler)); + + /* Get CFGR value */ + tmpreg = RCC->CFGR; + /* Clear MCOPRE[2:0] bits */ + tmpreg &= ~(RCC_CFGR_MCO_PRE | RCC_CFGR_MCO | RCC_CFGR_PLLNODIV); + /* Set the RCC_MCOSource and RCC_MCOPrescaler */ + tmpreg |= (RCC_MCOPrescaler | ((uint32_t)RCC_MCOSource<<24)); + /* Store the new value */ + RCC->CFGR = tmpreg; +} +#endif /* STM32F072 */ + +/** + * @} + */ + +/** @defgroup RCC_Group2 System AHB and APB busses clocks configuration functions + * @brief System, AHB and APB busses clocks configuration functions + * +@verbatim + =============================================================================== + ##### System, AHB and APB busses clocks configuration functions ##### + =============================================================================== + + [..] This section provide functions allowing to configure the System, AHB and + APB busses clocks. + (#) Several clock sources can be used to drive the System clock (SYSCLK): HSI, + HSE and PLL. + The AHB clock (HCLK) is derived from System clock through configurable prescaler + and used to clock the CPU, memory and peripherals mapped on AHB bus (DMA and GPIO). + and APB (PCLK) clocks are derived from AHB clock through + configurable prescalers and used to clock the peripherals mapped on these busses. + You can use "RCC_GetClocksFreq()" function to retrieve the frequencies of these clocks. + + -@- All the peripheral clocks are derived from the System clock (SYSCLK) except: + (+@) The ADC clock which is derived from HSI14 or APB (APB divided by a + programmable prescaler: 2 or 4). + (+@) The CEC clock which is derived from LSE or HSI divided by 244. + (+@) The I2C clock which is derived from HSI or system clock (SYSCLK). + (+@) The USART clock which is derived from HSI, system clock (SYSCLK), APB or LSE. + (+@) The RTC/LCD clock which is derived from the LSE, LSI or 2 MHz HSE_RTC (HSE + divided by a programmable prescaler). + The System clock (SYSCLK) frequency must be higher or equal to the RTC/LCD + clock frequency. + (+@) IWDG clock which is always the LSI clock. + + (#) The maximum frequency of the SYSCLK, HCLK and PCLK is 48 MHz. + Depending on the maximum frequency, the FLASH wait states (WS) should be + adapted accordingly: + +--------------------------------------------- + + | Wait states | HCLK clock frequency (MHz) | + |---------------|------------------------------| + |0WS(1CPU cycle)| 0 < HCLK <= 24 | + |---------------|------------------------------| + |1WS(2CPU cycle)| 24 < HCLK <= 48 | + +----------------------------------------------+ + + (#) After reset, the System clock source is the HSI (8 MHz) with 0 WS and + prefetch is disabled. + + [..] It is recommended to use the following software sequences to tune the number + of wait states needed to access the Flash memory with the CPU frequency (HCLK). + (+) Increasing the CPU frequency + (++) Program the Flash Prefetch buffer, using "FLASH_PrefetchBufferCmd(ENABLE)" + function + (++) Check that Flash Prefetch buffer activation is taken into account by + reading FLASH_ACR using the FLASH_GetPrefetchBufferStatus() function + (++) Program Flash WS to 1, using "FLASH_SetLatency(FLASH_Latency_1)" function + (++) Check that the new number of WS is taken into account by reading FLASH_ACR + (++) Modify the CPU clock source, using "RCC_SYSCLKConfig()" function + (++) If needed, modify the CPU clock prescaler by using "RCC_HCLKConfig()" function + (++) Check that the new CPU clock source is taken into account by reading + the clock source status, using "RCC_GetSYSCLKSource()" function + (+) Decreasing the CPU frequency + (++) Modify the CPU clock source, using "RCC_SYSCLKConfig()" function + (++) If needed, modify the CPU clock prescaler by using "RCC_HCLKConfig()" function + (++) Check that the new CPU clock source is taken into account by reading + the clock source status, using "RCC_GetSYSCLKSource()" function + (++) Program the new number of WS, using "FLASH_SetLatency()" function + (++) Check that the new number of WS is taken into account by reading FLASH_ACR + (++) Disable the Flash Prefetch buffer using "FLASH_PrefetchBufferCmd(DISABLE)" + function + (++) Check that Flash Prefetch buffer deactivation is taken into account by reading FLASH_ACR + using the FLASH_GetPrefetchBufferStatus() function. + +@endverbatim + * @{ + */ + +/** + * @brief Configures the system clock (SYSCLK). + * @note The HSI is used (enabled by hardware) as system clock source after + * startup from Reset, wake-up from STOP and STANDBY mode, or in case + * of failure of the HSE used directly or indirectly as system clock + * (if the Clock Security System CSS is enabled). + * @note A switch from one clock source to another occurs only if the target + * clock source is ready (clock stable after startup delay or PLL locked). + * If a clock source which is not yet ready is selected, the switch will + * occur when the clock source will be ready. + * You can use RCC_GetSYSCLKSource() function to know which clock is + * currently used as system clock source. + * @param RCC_SYSCLKSource: specifies the clock source used as system clock source + * This parameter can be one of the following values: + * @arg RCC_SYSCLKSource_HSI: HSI selected as system clock source + * @arg RCC_SYSCLKSource_HSE: HSE selected as system clock source + * @arg RCC_SYSCLKSource_PLLCLK: PLL selected as system clock source + * @arg RCC_SYSCLKSource_HSI48: HSI48 selected as system clock source, applicable only for STM32F072 devices + * @retval None + */ +void RCC_SYSCLKConfig(uint32_t RCC_SYSCLKSource) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RCC_SYSCLK_SOURCE(RCC_SYSCLKSource)); + + tmpreg = RCC->CFGR; + + /* Clear SW[1:0] bits */ + tmpreg &= ~RCC_CFGR_SW; + + /* Set SW[1:0] bits according to RCC_SYSCLKSource value */ + tmpreg |= RCC_SYSCLKSource; + + /* Store the new value */ + RCC->CFGR = tmpreg; +} + +/** + * @brief Returns the clock source used as system clock. + * @param None + * @retval The clock source used as system clock. The returned value can be one + * of the following values: + * - 0x00: HSI used as system clock + * - 0x04: HSE used as system clock + * - 0x08: PLL used as system clock + * - 0x0C: HSI48 used as system clock, applicable only for STM32F072 devices + */ +uint8_t RCC_GetSYSCLKSource(void) +{ + return ((uint8_t)(RCC->CFGR & RCC_CFGR_SWS)); +} + +/** + * @brief Configures the AHB clock (HCLK). + * @param RCC_SYSCLK: defines the AHB clock divider. This clock is derived from + * the system clock (SYSCLK). + * This parameter can be one of the following values: + * @arg RCC_SYSCLK_Div1: AHB clock = SYSCLK + * @arg RCC_SYSCLK_Div2: AHB clock = SYSCLK/2 + * @arg RCC_SYSCLK_Div4: AHB clock = SYSCLK/4 + * @arg RCC_SYSCLK_Div8: AHB clock = SYSCLK/8 + * @arg RCC_SYSCLK_Div16: AHB clock = SYSCLK/16 + * @arg RCC_SYSCLK_Div64: AHB clock = SYSCLK/64 + * @arg RCC_SYSCLK_Div128: AHB clock = SYSCLK/128 + * @arg RCC_SYSCLK_Div256: AHB clock = SYSCLK/256 + * @arg RCC_SYSCLK_Div512: AHB clock = SYSCLK/512 + * @retval None + */ +void RCC_HCLKConfig(uint32_t RCC_SYSCLK) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RCC_HCLK(RCC_SYSCLK)); + + tmpreg = RCC->CFGR; + + /* Clear HPRE[3:0] bits */ + tmpreg &= ~RCC_CFGR_HPRE; + + /* Set HPRE[3:0] bits according to RCC_SYSCLK value */ + tmpreg |= RCC_SYSCLK; + + /* Store the new value */ + RCC->CFGR = tmpreg; +} + +/** + * @brief Configures the APB clock (PCLK). + * @param RCC_HCLK: defines the APB clock divider. This clock is derived from + * the AHB clock (HCLK). + * This parameter can be one of the following values: + * @arg RCC_HCLK_Div1: APB clock = HCLK + * @arg RCC_HCLK_Div2: APB clock = HCLK/2 + * @arg RCC_HCLK_Div4: APB clock = HCLK/4 + * @arg RCC_HCLK_Div8: APB clock = HCLK/8 + * @arg RCC_HCLK_Div16: APB clock = HCLK/16 + * @retval None + */ +void RCC_PCLKConfig(uint32_t RCC_HCLK) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RCC_PCLK(RCC_HCLK)); + + tmpreg = RCC->CFGR; + + /* Clear PPRE[2:0] bits */ + tmpreg &= ~RCC_CFGR_PPRE; + + /* Set PPRE[2:0] bits according to RCC_HCLK value */ + tmpreg |= RCC_HCLK; + + /* Store the new value */ + RCC->CFGR = tmpreg; +} + +/** + * @brief Configures the ADC clock (ADCCLK). + * @note This function is obsolete. + * For proper ADC clock selection, refer to ADC_ClockModeConfig() in the ADC driver + * @param RCC_ADCCLK: defines the ADC clock source. This clock is derived + * from the HSI14 or APB clock (PCLK). + * This parameter can be one of the following values: + * @arg RCC_ADCCLK_HSI14: ADC clock = HSI14 (14MHz) + * @arg RCC_ADCCLK_PCLK_Div2: ADC clock = PCLK/2 + * @arg RCC_ADCCLK_PCLK_Div4: ADC clock = PCLK/4 + * @retval None + */ +void RCC_ADCCLKConfig(uint32_t RCC_ADCCLK) +{ + /* Check the parameters */ + assert_param(IS_RCC_ADCCLK(RCC_ADCCLK)); + + /* Clear ADCPRE bit */ + RCC->CFGR &= ~RCC_CFGR_ADCPRE; + /* Set ADCPRE bits according to RCC_PCLK value */ + RCC->CFGR |= RCC_ADCCLK & 0xFFFF; + + /* Clear ADCSW bit */ + RCC->CFGR3 &= ~RCC_CFGR3_ADCSW; + /* Set ADCSW bits according to RCC_ADCCLK value */ + RCC->CFGR3 |= RCC_ADCCLK >> 16; +} + +/** + * @brief Configures the CEC clock (CECCLK). + * @param RCC_CECCLK: defines the CEC clock source. This clock is derived + * from the HSI or LSE clock. + * This parameter can be one of the following values: + * @arg RCC_CECCLK_HSI_Div244: CEC clock = HSI/244 (32768Hz) + * @arg RCC_CECCLK_LSE: CEC clock = LSE + * @retval None + */ +void RCC_CECCLKConfig(uint32_t RCC_CECCLK) +{ + /* Check the parameters */ + assert_param(IS_RCC_CECCLK(RCC_CECCLK)); + + /* Clear CECSW bit */ + RCC->CFGR3 &= ~RCC_CFGR3_CECSW; + /* Set CECSW bits according to RCC_CECCLK value */ + RCC->CFGR3 |= RCC_CECCLK; +} + +/** + * @brief Configures the I2C1 clock (I2C1CLK). + * @param RCC_I2CCLK: defines the I2C1 clock source. This clock is derived + * from the HSI or System clock. + * This parameter can be one of the following values: + * @arg RCC_I2C1CLK_HSI: I2C1 clock = HSI + * @arg RCC_I2C1CLK_SYSCLK: I2C1 clock = System Clock + * @retval None + */ +void RCC_I2CCLKConfig(uint32_t RCC_I2CCLK) +{ + /* Check the parameters */ + assert_param(IS_RCC_I2CCLK(RCC_I2CCLK)); + + /* Clear I2CSW bit */ + RCC->CFGR3 &= ~RCC_CFGR3_I2C1SW; + /* Set I2CSW bits according to RCC_I2CCLK value */ + RCC->CFGR3 |= RCC_I2CCLK; +} + +/** + * @brief Configures the USART1 clock (USART1CLK). + * @param RCC_USARTCLK: defines the USART clock source. This clock is derived + * from the HSI or System clock. + * This parameter can be one of the following values: + * @arg RCC_USART1CLK_PCLK: USART1 clock = APB Clock (PCLK) + * @arg RCC_USART1CLK_SYSCLK: USART1 clock = System Clock + * @arg RCC_USART1CLK_LSE: USART1 clock = LSE Clock + * @arg RCC_USART1CLK_HSI: USART1 clock = HSI Clock + * @arg RCC_USART2CLK_PCLK: USART2 clock = APB Clock (PCLK), applicable only for STM32F072 and STM32F091 devices + * @arg RCC_USART2CLK_SYSCLK: USART2 clock = System Clock, applicable only for STM32F072 and STM32F091 devices + * @arg RCC_USART2CLK_LSE: USART2 clock = LSE Clock, applicable only for STM32F072 and STM32F091 devices + * @arg RCC_USART2CLK_HSI: USART2 clock = HSI Clock, applicable only for STM32F072 and STM32F091 devices + * @arg RCC_USART3CLK_PCLK: USART3 clock = APB Clock (PCLK), applicable only for STM32F091 devices + * @arg RCC_USART3CLK_SYSCLK: USART3 clock = System Clock, applicable only for STM32F091 devices + * @arg RCC_USART3CLK_LSE: USART3 clock = LSE Clock, applicable only for STM32F091 devices + * @arg RCC_USART3CLK_HSI: USART3 clock = HSI Clock, applicable only for STM32F091 devices + * @retval None + */ +void RCC_USARTCLKConfig(uint32_t RCC_USARTCLK) +{ + uint32_t tmp = 0; + + /* Check the parameters */ + assert_param(IS_RCC_USARTCLK(RCC_USARTCLK)); + + /* Get USART index */ + tmp = (RCC_USARTCLK >> 28); + + /* Clear USARTSW[1:0] bit */ + if (tmp == (uint32_t)0x00000001) + { + /* Clear USART1SW[1:0] bit */ + RCC->CFGR3 &= ~RCC_CFGR3_USART1SW; + } + else if (tmp == (uint32_t)0x00000002) + { + /* Clear USART2SW[1:0] bit */ + RCC->CFGR3 &= ~RCC_CFGR3_USART2SW; + } + else + { + /* Clear USART3SW[1:0] bit */ + RCC->CFGR3 &= ~RCC_CFGR3_USART3SW; + } + + /* Set USARTxSW bits according to RCC_USARTCLK value */ + RCC->CFGR3 |= RCC_USARTCLK; +} + +/** + * @brief Configures the USB clock (USBCLK). + * This function is only applicable for STM32F072 devices. + * @param RCC_USBCLK: defines the USB clock source. This clock is derived + * from the HSI48 or system clock. + * This parameter can be one of the following values: + * @arg RCC_USBCLK_HSI48: USB clock = HSI48 + * @arg RCC_USBCLK_PLLCLK: USB clock = PLL clock + * @retval None + */ +void RCC_USBCLKConfig(uint32_t RCC_USBCLK) +{ + /* Check the parameters */ + assert_param(IS_RCC_USBCLK(RCC_USBCLK)); + + /* Clear USBSW bit */ + RCC->CFGR3 &= ~RCC_CFGR3_USBSW; + /* Set USBSW bits according to RCC_USBCLK value */ + RCC->CFGR3 |= RCC_USBCLK; +} + +/** + * @brief Returns the frequencies of the System, AHB and APB busses clocks. + * @note The frequency returned by this function is not the real frequency + * in the chip. It is calculated based on the predefined constant and + * the source selected by RCC_SYSCLKConfig(): + * + * @note If SYSCLK source is HSI, function returns constant HSI_VALUE(*) + * + * @note If SYSCLK source is HSE, function returns constant HSE_VALUE(**) + * + * @note If SYSCLK source is PLL, function returns constant HSE_VALUE(**) + * or HSI_VALUE(*) multiplied by the PLL factors. + * + * @note If SYSCLK source is HSI48, function returns constant HSI48_VALUE(***) + * + * @note (*) HSI_VALUE is a constant defined in stm32f0xx.h file (default value + * 8 MHz) but the real value may vary depending on the variations + * in voltage and temperature, refer to RCC_AdjustHSICalibrationValue(). + * + * @note (**) HSE_VALUE is a constant defined in stm32f0xx.h file (default value + * 8 MHz), user has to ensure that HSE_VALUE is same as the real + * frequency of the crystal used. Otherwise, this function may + * return wrong result. + * + * @note (***) HSI48_VALUE is a constant defined in stm32f0xx.h file (default value + * 48 MHz) but the real value may vary depending on the variations + * in voltage and temperature. + * + * @note The result of this function could be not correct when using fractional + * value for HSE crystal. + * + * @param RCC_Clocks: pointer to a RCC_ClocksTypeDef structure which will hold + * the clocks frequencies. + * + * @note This function can be used by the user application to compute the + * baudrate for the communication peripherals or configure other parameters. + * @note Each time SYSCLK, HCLK and/or PCLK clock changes, this function + * must be called to update the structure's field. Otherwise, any + * configuration based on this function will be incorrect. + * + * @retval None + */ +void RCC_GetClocksFreq(RCC_ClocksTypeDef* RCC_Clocks) +{ + uint32_t tmp = 0, pllmull = 0, pllsource = 0, prediv1factor = 0, presc = 0, pllclk = 0; + + /* Get SYSCLK source -------------------------------------------------------*/ + tmp = RCC->CFGR & RCC_CFGR_SWS; + + switch (tmp) + { + case 0x00: /* HSI used as system clock */ + RCC_Clocks->SYSCLK_Frequency = HSI_VALUE; + break; + case 0x04: /* HSE used as system clock */ + RCC_Clocks->SYSCLK_Frequency = HSE_VALUE; + break; + case 0x08: /* PLL used as system clock */ + /* Get PLL clock source and multiplication factor ----------------------*/ + pllmull = RCC->CFGR & RCC_CFGR_PLLMULL; + pllsource = RCC->CFGR & RCC_CFGR_PLLSRC; + pllmull = ( pllmull >> 18) + 2; + + if (pllsource == 0x00) + { + /* HSI oscillator clock divided by 2 selected as PLL clock entry */ + pllclk = (HSI_VALUE >> 1) * pllmull; + } + else + { + prediv1factor = (RCC->CFGR2 & RCC_CFGR2_PREDIV1) + 1; + /* HSE oscillator clock selected as PREDIV1 clock entry */ + pllclk = (HSE_VALUE / prediv1factor) * pllmull; + } + RCC_Clocks->SYSCLK_Frequency = pllclk; + break; + case 0x0C: /* HSI48 used as system clock */ + RCC_Clocks->SYSCLK_Frequency = HSI48_VALUE; + break; + default: /* HSI used as system clock */ + RCC_Clocks->SYSCLK_Frequency = HSI_VALUE; + break; + } + /* Compute HCLK, PCLK clocks frequencies -----------------------------------*/ + /* Get HCLK prescaler */ + tmp = RCC->CFGR & RCC_CFGR_HPRE; + tmp = tmp >> 4; + presc = APBAHBPrescTable[tmp]; + /* HCLK clock frequency */ + RCC_Clocks->HCLK_Frequency = RCC_Clocks->SYSCLK_Frequency >> presc; + + /* Get PCLK prescaler */ + tmp = RCC->CFGR & RCC_CFGR_PPRE; + tmp = tmp >> 8; + presc = APBAHBPrescTable[tmp]; + /* PCLK clock frequency */ + RCC_Clocks->PCLK_Frequency = RCC_Clocks->HCLK_Frequency >> presc; + + /* ADCCLK clock frequency */ + if((RCC->CFGR3 & RCC_CFGR3_ADCSW) != RCC_CFGR3_ADCSW) + { + /* ADC Clock is HSI14 Osc. */ + RCC_Clocks->ADCCLK_Frequency = HSI14_VALUE; + } + else + { + if((RCC->CFGR & RCC_CFGR_ADCPRE) != RCC_CFGR_ADCPRE) + { + /* ADC Clock is derived from PCLK/2 */ + RCC_Clocks->ADCCLK_Frequency = RCC_Clocks->PCLK_Frequency >> 1; + } + else + { + /* ADC Clock is derived from PCLK/4 */ + RCC_Clocks->ADCCLK_Frequency = RCC_Clocks->PCLK_Frequency >> 2; + } + + } + + /* CECCLK clock frequency */ + if((RCC->CFGR3 & RCC_CFGR3_CECSW) != RCC_CFGR3_CECSW) + { + /* CEC Clock is HSI/244 */ + RCC_Clocks->CECCLK_Frequency = HSI_VALUE / 244; + } + else + { + /* CECC Clock is LSE Osc. */ + RCC_Clocks->CECCLK_Frequency = LSE_VALUE; + } + + /* I2C1CLK clock frequency */ + if((RCC->CFGR3 & RCC_CFGR3_I2C1SW) != RCC_CFGR3_I2C1SW) + { + /* I2C1 Clock is HSI Osc. */ + RCC_Clocks->I2C1CLK_Frequency = HSI_VALUE; + } + else + { + /* I2C1 Clock is System Clock */ + RCC_Clocks->I2C1CLK_Frequency = RCC_Clocks->SYSCLK_Frequency; + } + + /* USART1CLK clock frequency */ + if((RCC->CFGR3 & RCC_CFGR3_USART1SW) == 0x0) + { + /* USART1 Clock is PCLK */ + RCC_Clocks->USART1CLK_Frequency = RCC_Clocks->PCLK_Frequency; + } + else if((RCC->CFGR3 & RCC_CFGR3_USART1SW) == RCC_CFGR3_USART1SW_0) + { + /* USART1 Clock is System Clock */ + RCC_Clocks->USART1CLK_Frequency = RCC_Clocks->SYSCLK_Frequency; + } + else if((RCC->CFGR3 & RCC_CFGR3_USART1SW) == RCC_CFGR3_USART1SW_1) + { + /* USART1 Clock is LSE Osc. */ + RCC_Clocks->USART1CLK_Frequency = LSE_VALUE; + } + else if((RCC->CFGR3 & RCC_CFGR3_USART1SW) == RCC_CFGR3_USART1SW) + { + /* USART1 Clock is HSI Osc. */ + RCC_Clocks->USART1CLK_Frequency = HSI_VALUE; + } + + /* USART2CLK clock frequency */ + if((RCC->CFGR3 & RCC_CFGR3_USART2SW) == 0x0) + { + /* USART Clock is PCLK */ + RCC_Clocks->USART2CLK_Frequency = RCC_Clocks->PCLK_Frequency; + } + else if((RCC->CFGR3 & RCC_CFGR3_USART2SW) == RCC_CFGR3_USART2SW_0) + { + /* USART Clock is System Clock */ + RCC_Clocks->USART2CLK_Frequency = RCC_Clocks->SYSCLK_Frequency; + } + else if((RCC->CFGR3 & RCC_CFGR3_USART2SW) == RCC_CFGR3_USART2SW_1) + { + /* USART Clock is LSE Osc. */ + RCC_Clocks->USART2CLK_Frequency = LSE_VALUE; + } + else if((RCC->CFGR3 & RCC_CFGR3_USART2SW) == RCC_CFGR3_USART2SW) + { + /* USART Clock is HSI Osc. */ + RCC_Clocks->USART2CLK_Frequency = HSI_VALUE; + } + + /* USART3CLK clock frequency */ + if((RCC->CFGR3 & RCC_CFGR3_USART3SW) == 0x0) + { + /* USART Clock is PCLK */ + RCC_Clocks->USART3CLK_Frequency = RCC_Clocks->PCLK_Frequency; + } + else if((RCC->CFGR3 & RCC_CFGR3_USART3SW) == RCC_CFGR3_USART3SW_0) + { + /* USART Clock is System Clock */ + RCC_Clocks->USART3CLK_Frequency = RCC_Clocks->SYSCLK_Frequency; + } + else if((RCC->CFGR3 & RCC_CFGR3_USART3SW) == RCC_CFGR3_USART3SW_1) + { + /* USART Clock is LSE Osc. */ + RCC_Clocks->USART3CLK_Frequency = LSE_VALUE; + } + else if((RCC->CFGR3 & RCC_CFGR3_USART3SW) == RCC_CFGR3_USART3SW) + { + /* USART Clock is HSI Osc. */ + RCC_Clocks->USART3CLK_Frequency = HSI_VALUE; + } + + /* USBCLK clock frequency */ + if((RCC->CFGR3 & RCC_CFGR3_USBSW) != RCC_CFGR3_USBSW) + { + /* USB Clock is HSI48 */ + RCC_Clocks->USBCLK_Frequency = HSI48_VALUE; + } + else + { + /* USB Clock is PLL clock */ + RCC_Clocks->USBCLK_Frequency = pllclk; + } +} + +/** + * @} + */ + +/** @defgroup RCC_Group3 Peripheral clocks configuration functions + * @brief Peripheral clocks configuration functions + * +@verbatim + =============================================================================== + #####Peripheral clocks configuration functions ##### + =============================================================================== + + [..] This section provide functions allowing to configure the Peripheral clocks. + (#) The RTC clock which is derived from the LSE, LSI or HSE_Div32 (HSE + divided by 32). + (#) After restart from Reset or wakeup from STANDBY, all peripherals are off + except internal SRAM, Flash and SWD. Before to start using a peripheral you + have to enable its interface clock. You can do this using RCC_AHBPeriphClockCmd(), + RCC_APB2PeriphClockCmd() and RCC_APB1PeriphClockCmd() functions. + (#) To reset the peripherals configuration (to the default state after device reset) + you can use RCC_AHBPeriphResetCmd(), RCC_APB2PeriphResetCmd() and + RCC_APB1PeriphResetCmd() functions. + +@endverbatim + * @{ + */ + +/** + * @brief Configures the RTC clock (RTCCLK). + * @note As the RTC clock configuration bits are in the Backup domain and write + * access is denied to this domain after reset, you have to enable write + * access using PWR_BackupAccessCmd(ENABLE) function before to configure + * the RTC clock source (to be done once after reset). + * @note Once the RTC clock is configured it can't be changed unless the RTC + * is reset using RCC_BackupResetCmd function, or by a Power On Reset (POR) + * + * @param RCC_RTCCLKSource: specifies the RTC clock source. + * This parameter can be one of the following values: + * @arg RCC_RTCCLKSource_LSE: LSE selected as RTC clock + * @arg RCC_RTCCLKSource_LSI: LSI selected as RTC clock + * @arg RCC_RTCCLKSource_HSE_Div32: HSE divided by 32 selected as RTC clock + * + * @note If the LSE or LSI is used as RTC clock source, the RTC continues to + * work in STOP and STANDBY modes, and can be used as wakeup source. + * However, when the HSE clock is used as RTC clock source, the RTC + * cannot be used in STOP and STANDBY modes. + * + * @note The maximum input clock frequency for RTC is 2MHz (when using HSE as + * RTC clock source). + * + * @retval None + */ +void RCC_RTCCLKConfig(uint32_t RCC_RTCCLKSource) +{ + /* Check the parameters */ + assert_param(IS_RCC_RTCCLK_SOURCE(RCC_RTCCLKSource)); + + /* Select the RTC clock source */ + RCC->BDCR |= RCC_RTCCLKSource; +} + +/** + * @brief Enables or disables the RTC clock. + * @note This function must be used only after the RTC clock source was selected + * using the RCC_RTCCLKConfig function. + * @param NewState: new state of the RTC clock. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_RTCCLKCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->BDCR |= RCC_BDCR_RTCEN; + } + else + { + RCC->BDCR &= ~RCC_BDCR_RTCEN; + } +} + +/** + * @brief Forces or releases the Backup domain reset. + * @note This function resets the RTC peripheral (including the backup registers) + * and the RTC clock source selection in RCC_BDCR register. + * @param NewState: new state of the Backup domain reset. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_BackupResetCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->BDCR |= RCC_BDCR_BDRST; + } + else + { + RCC->BDCR &= ~RCC_BDCR_BDRST; + } +} + +/** + * @brief Enables or disables the AHB peripheral clock. + * @note After reset, the peripheral clock (used for registers read/write access) + * is disabled and the application software has to enable this clock before + * using it. + * @param RCC_AHBPeriph: specifies the AHB peripheral to gates its clock. + * This parameter can be any combination of the following values: + * @arg RCC_AHBPeriph_GPIOA: GPIOA clock + * @arg RCC_AHBPeriph_GPIOB: GPIOB clock + * @arg RCC_AHBPeriph_GPIOC: GPIOC clock + * @arg RCC_AHBPeriph_GPIOD: GPIOD clock + * @arg RCC_AHBPeriph_GPIOE: GPIOE clock, applicable only for STM32F072 devices + * @arg RCC_AHBPeriph_GPIOF: GPIOF clock + * @arg RCC_AHBPeriph_TS: TS clock + * @arg RCC_AHBPeriph_CRC: CRC clock + * @arg RCC_AHBPeriph_FLITF: (has effect only when the Flash memory is in power down mode) + * @arg RCC_AHBPeriph_SRAM: SRAM clock + * @arg RCC_AHBPeriph_DMA1: DMA1 clock + * @arg RCC_AHBPeriph_DMA2: DMA2 clock + * @param NewState: new state of the specified peripheral clock. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_AHBPeriphClockCmd(uint32_t RCC_AHBPeriph, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_RCC_AHB_PERIPH(RCC_AHBPeriph)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->AHBENR |= RCC_AHBPeriph; + } + else + { + RCC->AHBENR &= ~RCC_AHBPeriph; + } +} + +/** + * @brief Enables or disables the High Speed APB (APB2) peripheral clock. + * @note After reset, the peripheral clock (used for registers read/write access) + * is disabled and the application software has to enable this clock before + * using it. + * @param RCC_APB2Periph: specifies the APB2 peripheral to gates its clock. + * This parameter can be any combination of the following values: + * @arg RCC_APB2Periph_SYSCFG: SYSCFG clock + * @arg RCC_APB2Periph_USART6: USART6 clock + * @arg RCC_APB2Periph_USART7: USART7 clock + * @arg RCC_APB2Periph_USART8: USART8 clock + * @arg RCC_APB2Periph_ADC1: ADC1 clock + * @arg RCC_APB2Periph_TIM1: TIM1 clock + * @arg RCC_APB2Periph_SPI1: SPI1 clock + * @arg RCC_APB2Periph_USART1: USART1 clock + * @arg RCC_APB2Periph_TIM15: TIM15 clock + * @arg RCC_APB2Periph_TIM16: TIM16 clock + * @arg RCC_APB2Periph_TIM17: TIM17 clock + * @arg RCC_APB2Periph_DBGMCU: DBGMCU clock + * @param NewState: new state of the specified peripheral clock. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_APB2PeriphClockCmd(uint32_t RCC_APB2Periph, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_RCC_APB2_PERIPH(RCC_APB2Periph)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->APB2ENR |= RCC_APB2Periph; + } + else + { + RCC->APB2ENR &= ~RCC_APB2Periph; + } +} + +/** + * @brief Enables or disables the Low Speed APB (APB1) peripheral clock. + * @note After reset, the peripheral clock (used for registers read/write access) + * is disabled and the application software has to enable this clock before + * using it. + * @param RCC_APB1Periph: specifies the APB1 peripheral to gates its clock. + * This parameter can be any combination of the following values: + * @arg RCC_APB1Periph_TIM2: TIM2 clock, applicable only for STM32F051 and STM32F072 devices + * @arg RCC_APB1Periph_TIM3: TIM3 clock + * @arg RCC_APB1Periph_TIM6: TIM6 clock + * @arg RCC_APB1Periph_TIM7: TIM7 clock, applicable only for STM32F072 devices + * @arg RCC_APB1Periph_TIM14: TIM14 clock + * @arg RCC_APB1Periph_WWDG: WWDG clock + * @arg RCC_APB1Periph_SPI2: SPI2 clock + * @arg RCC_APB1Periph_USART2: USART2 clock + * @arg RCC_APB1Periph_USART3: USART3 clock, applicable only for STM32F072 and STM32F091 devices + * @arg RCC_APB1Periph_USART4: USART4 clock, applicable only for STM32F072 and STM32F091 devices + * @arg RCC_APB1Periph_USART5: USART5 clock, applicable only for STM32F091 devices + * @arg RCC_APB1Periph_I2C1: I2C1 clock + * @arg RCC_APB1Periph_I2C2: I2C2 clock + * @arg RCC_APB1Periph_USB: USB clock, applicable only for STM32F042 and STM32F072 devices + * @arg RCC_APB1Periph_CAN: CAN clock, applicable only for STM32F042 and STM32F072 devices + * @arg RCC_APB1Periph_CRS: CRS clock , applicable only for STM32F042 and STM32F072 devices + * @arg RCC_APB1Periph_PWR: PWR clock + * @arg RCC_APB1Periph_DAC: DAC clock, applicable only for STM32F051 and STM32F072 devices + * @arg RCC_APB1Periph_CEC: CEC clock, applicable only for STM32F051, STM32F042 and STM32F072 devices + * @param NewState: new state of the specified peripheral clock. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_APB1PeriphClockCmd(uint32_t RCC_APB1Periph, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_RCC_APB1_PERIPH(RCC_APB1Periph)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->APB1ENR |= RCC_APB1Periph; + } + else + { + RCC->APB1ENR &= ~RCC_APB1Periph; + } +} + +/** + * @brief Forces or releases AHB peripheral reset. + * @param RCC_AHBPeriph: specifies the AHB peripheral to reset. + * This parameter can be any combination of the following values: + * @arg RCC_AHBPeriph_GPIOA: GPIOA clock + * @arg RCC_AHBPeriph_GPIOB: GPIOB clock + * @arg RCC_AHBPeriph_GPIOC: GPIOC clock + * @arg RCC_AHBPeriph_GPIOD: GPIOD clock + * @arg RCC_AHBPeriph_GPIOE: GPIOE clock, applicable only for STM32F072 devices + * @arg RCC_AHBPeriph_GPIOF: GPIOF clock + * @arg RCC_AHBPeriph_TS: TS clock + * @param NewState: new state of the specified peripheral reset. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_AHBPeriphResetCmd(uint32_t RCC_AHBPeriph, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_RCC_AHB_RST_PERIPH(RCC_AHBPeriph)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->AHBRSTR |= RCC_AHBPeriph; + } + else + { + RCC->AHBRSTR &= ~RCC_AHBPeriph; + } +} + +/** + * @brief Forces or releases High Speed APB (APB2) peripheral reset. + * @param RCC_APB2Periph: specifies the APB2 peripheral to reset. + * This parameter can be any combination of the following values: + * @arg RCC_APB2Periph_SYSCFG: SYSCFG clock + * @arg RCC_APB2Periph_USART6: USART6 clock + * @arg RCC_APB2Periph_USART7: USART7 clock + * @arg RCC_APB2Periph_USART8: USART8 clock + * @arg RCC_APB2Periph_ADC1: ADC1 clock + * @arg RCC_APB2Periph_TIM1: TIM1 clock + * @arg RCC_APB2Periph_SPI1: SPI1 clock + * @arg RCC_APB2Periph_USART1: USART1 clock + * @arg RCC_APB2Periph_TIM15: TIM15 clock + * @arg RCC_APB2Periph_TIM16: TIM16 clock + * @arg RCC_APB2Periph_TIM17: TIM17 clock + * @arg RCC_APB2Periph_DBGMCU: DBGMCU clock + * @param NewState: new state of the specified peripheral reset. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_APB2PeriphResetCmd(uint32_t RCC_APB2Periph, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_RCC_APB2_PERIPH(RCC_APB2Periph)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->APB2RSTR |= RCC_APB2Periph; + } + else + { + RCC->APB2RSTR &= ~RCC_APB2Periph; + } +} + +/** + * @brief Forces or releases Low Speed APB (APB1) peripheral reset. + * @param RCC_APB1Periph: specifies the APB1 peripheral to reset. + * This parameter can be any combination of the following values: + * @arg RCC_APB1Periph_TIM2: TIM2 clock, applicable only for STM32F051 and STM32F072 devices + * @arg RCC_APB1Periph_TIM3: TIM3 clock + * @arg RCC_APB1Periph_TIM6: TIM6 clock + * @arg RCC_APB1Periph_TIM7: TIM7 clock, applicable only for STM32F072 devices + * @arg RCC_APB1Periph_TIM14: TIM14 clock + * @arg RCC_APB1Periph_WWDG: WWDG clock + * @arg RCC_APB1Periph_SPI2: SPI2 clock + * @arg RCC_APB1Periph_USART2: USART2 clock + * @arg RCC_APB1Periph_USART3: USART3 clock, applicable only for STM32F072 and STM32F091 devices + * @arg RCC_APB1Periph_USART4: USART4 clock, applicable only for STM32F072 and STM32F091 devices + * @arg RCC_APB1Periph_USART5: USART5 clock, applicable only for STM32F091 devices + * @arg RCC_APB1Periph_I2C1: I2C1 clock + * @arg RCC_APB1Periph_I2C2: I2C2 clock + * @arg RCC_APB1Periph_USB: USB clock, applicable only for STM32F042 and STM32F072 devices + * @arg RCC_APB1Periph_CAN: CAN clock, applicable only for STM32F042 and STM32F072 devices + * @arg RCC_APB1Periph_CRS: CRS clock , applicable only for STM32F042 and STM32F072 devices + * @arg RCC_APB1Periph_PWR: PWR clock + * @arg RCC_APB1Periph_DAC: DAC clock, applicable only for STM32F051 and STM32F072 devices + * @arg RCC_APB1Periph_CEC: CEC clock, applicable only for STM32F051, STM32F042 and STM32F072 devices + * @param NewState: new state of the specified peripheral clock. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_APB1PeriphResetCmd(uint32_t RCC_APB1Periph, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_RCC_APB1_PERIPH(RCC_APB1Periph)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + RCC->APB1RSTR |= RCC_APB1Periph; + } + else + { + RCC->APB1RSTR &= ~RCC_APB1Periph; + } +} + +/** + * @} + */ + +/** @defgroup RCC_Group4 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified RCC interrupts. + * @note The CSS interrupt doesn't have an enable bit; once the CSS is enabled + * and if the HSE clock fails, the CSS interrupt occurs and an NMI is + * automatically generated. The NMI will be executed indefinitely, and + * since NMI has higher priority than any other IRQ (and main program) + * the application will be stacked in the NMI ISR unless the CSS interrupt + * pending bit is cleared. + * @param RCC_IT: specifies the RCC interrupt sources to be enabled or disabled. + * This parameter can be any combination of the following values: + * @arg RCC_IT_LSIRDY: LSI ready interrupt + * @arg RCC_IT_LSERDY: LSE ready interrupt + * @arg RCC_IT_HSIRDY: HSI ready interrupt + * @arg RCC_IT_HSERDY: HSE ready interrupt + * @arg RCC_IT_PLLRDY: PLL ready interrupt + * @arg RCC_IT_HSI14RDY: HSI14 ready interrupt + * @arg RCC_IT_HSI48RDY: HSI48 ready interrupt, applicable only for STM32F072 devices + * @param NewState: new state of the specified RCC interrupts. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RCC_ITConfig(uint8_t RCC_IT, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_RCC_IT(RCC_IT)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Perform Byte access to RCC_CIR[13:8] bits to enable the selected interrupts */ + *(__IO uint8_t *) CIR_BYTE1_ADDRESS |= RCC_IT; + } + else + { + /* Perform Byte access to RCC_CIR[13:8] bits to disable the selected interrupts */ + *(__IO uint8_t *) CIR_BYTE1_ADDRESS &= (uint8_t)~RCC_IT; + } +} + +/** + * @brief Checks whether the specified RCC flag is set or not. + * @param RCC_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg RCC_FLAG_HSIRDY: HSI oscillator clock ready + * @arg RCC_FLAG_HSERDY: HSE oscillator clock ready + * @arg RCC_FLAG_PLLRDY: PLL clock ready + * @arg RCC_FLAG_LSERDY: LSE oscillator clock ready + * @arg RCC_FLAG_LSIRDY: LSI oscillator clock ready + * @arg RCC_FLAG_OBLRST: Option Byte Loader (OBL) reset + * @arg RCC_FLAG_PINRST: Pin reset + * @arg RCC_FLAG_V18PWRRSTF: V1.8 power domain reset + * @arg RCC_FLAG_PORRST: POR/PDR reset + * @arg RCC_FLAG_SFTRST: Software reset + * @arg RCC_FLAG_IWDGRST: Independent Watchdog reset + * @arg RCC_FLAG_WWDGRST: Window Watchdog reset + * @arg RCC_FLAG_LPWRRST: Low Power reset + * @arg RCC_FLAG_HSI14RDY: HSI14 oscillator clock ready + * @arg RCC_FLAG_HSI48RDY: HSI48 oscillator clock ready, applicable only for STM32F072 devices + * @retval The new state of RCC_FLAG (SET or RESET). + */ +FlagStatus RCC_GetFlagStatus(uint8_t RCC_FLAG) +{ + uint32_t tmp = 0; + uint32_t statusreg = 0; + FlagStatus bitstatus = RESET; + + /* Check the parameters */ + assert_param(IS_RCC_FLAG(RCC_FLAG)); + + /* Get the RCC register index */ + tmp = RCC_FLAG >> 5; + + if (tmp == 0) /* The flag to check is in CR register */ + { + statusreg = RCC->CR; + } + else if (tmp == 1) /* The flag to check is in BDCR register */ + { + statusreg = RCC->BDCR; + } + else if (tmp == 2) /* The flag to check is in CSR register */ + { + statusreg = RCC->CSR; + } + else /* The flag to check is in CR2 register */ + { + statusreg = RCC->CR2; + } + + /* Get the flag position */ + tmp = RCC_FLAG & FLAG_MASK; + + if ((statusreg & ((uint32_t)1 << tmp)) != (uint32_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + /* Return the flag status */ + return bitstatus; +} + +/** + * @brief Clears the RCC reset flags. + * The reset flags are: RCC_FLAG_OBLRST, RCC_FLAG_PINRST, RCC_FLAG_V18PWRRSTF, + * RCC_FLAG_PORRST, RCC_FLAG_SFTRST, RCC_FLAG_IWDGRST, RCC_FLAG_WWDGRST, + * RCC_FLAG_LPWRRST. + * @param None + * @retval None + */ +void RCC_ClearFlag(void) +{ + /* Set RMVF bit to clear the reset flags */ + RCC->CSR |= RCC_CSR_RMVF; +} + +/** + * @brief Checks whether the specified RCC interrupt has occurred or not. + * @param RCC_IT: specifies the RCC interrupt source to check. + * This parameter can be one of the following values: + * @arg RCC_IT_LSIRDY: LSI ready interrupt + * @arg RCC_IT_LSERDY: LSE ready interrupt + * @arg RCC_IT_HSIRDY: HSI ready interrupt + * @arg RCC_IT_HSERDY: HSE ready interrupt + * @arg RCC_IT_PLLRDY: PLL ready interrupt + * @arg RCC_IT_HSI14RDY: HSI14 ready interrupt + * @arg RCC_IT_HSI48RDY: HSI48 ready interrupt, applicable only for STM32F072 devices + * @arg RCC_IT_CSS: Clock Security System interrupt + * @retval The new state of RCC_IT (SET or RESET). + */ +ITStatus RCC_GetITStatus(uint8_t RCC_IT) +{ + ITStatus bitstatus = RESET; + + /* Check the parameters */ + assert_param(IS_RCC_GET_IT(RCC_IT)); + + /* Check the status of the specified RCC interrupt */ + if ((RCC->CIR & RCC_IT) != (uint32_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + /* Return the RCC_IT status */ + return bitstatus; +} + +/** + * @brief Clears the RCC's interrupt pending bits. + * @param RCC_IT: specifies the interrupt pending bit to clear. + * This parameter can be any combination of the following values: + * @arg RCC_IT_LSIRDY: LSI ready interrupt + * @arg RCC_IT_LSERDY: LSE ready interrupt + * @arg RCC_IT_HSIRDY: HSI ready interrupt + * @arg RCC_IT_HSERDY: HSE ready interrupt + * @arg RCC_IT_PLLRDY: PLL ready interrupt + * @arg RCC_IT_HSI48RDY: HSI48 ready interrupt, applicable only for STM32F072 devices + * @arg RCC_IT_HSI14RDY: HSI14 ready interrupt + * @arg RCC_IT_CSS: Clock Security System interrupt + * @retval None + */ +void RCC_ClearITPendingBit(uint8_t RCC_IT) +{ + /* Check the parameters */ + assert_param(IS_RCC_CLEAR_IT(RCC_IT)); + + /* Perform Byte access to RCC_CIR[23:16] bits to clear the selected interrupt + pending bits */ + *(__IO uint8_t *) CIR_BYTE2_ADDRESS = RCC_IT; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_rtc.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_rtc.c new file mode 100644 index 00000000..4a8e565a --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_rtc.c @@ -0,0 +1,2518 @@ +/** + ****************************************************************************** + * @file stm32f0xx_rtc.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Real-Time Clock (RTC) peripheral: + * + Initialization + * + Calendar (Time and Date) configuration + * + Alarms (Alarm A) configuration + * + Daylight Saving configuration + * + Output pin Configuration + * + Digital Calibration configuration + * + TimeStamp configuration + * + Tampers configuration + * + Backup Data Registers configuration + * + Output Type Config configuration + * + Shift control synchronisation + * + Interrupts and flags management + * + @verbatim + =============================================================================== + ##### Backup Domain Operating Condition ##### + =============================================================================== + [..] The real-time clock (RTC) and the RTC backup registers can be powered + from the VBAT voltage when the main VDD supply is powered off. + To retain the content of the RTC backup registers and supply the RTC + when VDD is turned off, VBAT pin can be connected to an optional + standby voltage supplied by a battery or by another source. + + [..] To allow the RTC to operate even when the main digital supply (VDD) + is turned off, the VBAT pin powers the following blocks: + (#) The RTC + (#) The LSE oscillator + (#) PC13 to PC15 I/Os I/Os (when available) + + [..] When the backup domain is supplied by VDD (analog switch connected + to VDD), the following functions are available: + (#) PC14 and PC15 can be used as either GPIO or LSE pins + (#) PC13 can be used as a GPIO or as the RTC_AF1 pin + + [..] When the backup domain is supplied by VBAT (analog switch connected + to VBAT because VDD is not present), the following functions are available: + (#) PC14 and PC15 can be used as LSE pins only + (#) PC13 can be used as the RTC_AF1 pin + + ##### Backup Domain Reset ##### + =============================================================================== + [..] The backup domain reset sets all RTC registers and the RCC_BDCR + register to their reset values. + A backup domain reset is generated when one of the following events + occurs: + (#) Software reset, triggered by setting the BDRST bit in the + RCC Backup domain control register (RCC_BDCR). You can use the + RCC_BackupResetCmd(). + (#) VDD or VBAT power on, if both supplies have previously been + powered off. + + ##### Backup Domain Access ##### + =============================================================================== + [..] After reset, the backup domain (RTC registers and RTC backup data + registers) is protected against possible unwanted write accesses. + [..] To enable access to the Backup Domain and RTC registers, proceed as follows: + (#) Enable the Power Controller (PWR) APB1 interface clock using the + RCC_APB1PeriphClockCmd() function. + (#) Enable access to Backup domain using the PWR_BackupAccessCmd() function. + (#) Select the RTC clock source using the RCC_RTCCLKConfig() function. + (#) Enable RTC Clock using the RCC_RTCCLKCmd() function. + + + ##### How to use this driver ##### + =============================================================================== + [..] + (+) Enable the backup domain access (see description in the section above) + (+) Configure the RTC Prescaler (Asynchronous and Synchronous) and + RTC hour format using the RTC_Init() function. + + ***Time and Date configuration *** + ================================== + [..] + (+) To configure the RTC Calendar (Time and Date) use the RTC_SetTime() + and RTC_SetDate() functions. + (+) To read the RTC Calendar, use the RTC_GetTime() and RTC_GetDate() + functions. + (+) To read the RTC subsecond, use the RTC_GetSubSecond() function. + (+) Use the RTC_DayLightSavingConfig() function to add or sub one + hour to the RTC Calendar. + + ***Alarm configuration *** + ========================== + [..] + (+) To configure the RTC Alarm use the RTC_SetAlarm() function. + (+) Enable the selected RTC Alarm using the RTC_AlarmCmd() function + (+) To read the RTC Alarm, use the RTC_GetAlarm() function. + (+) To read the RTC alarm SubSecond, use the RTC_GetAlarmSubSecond() function. + + ***RTC Wakeup configuration*** + ========================== + [..] + (+) Configure the RTC Wakeup Clock source use the RTC_WakeUpClockConfig() + function. + (+) Configure the RTC WakeUp Counter using the RTC_SetWakeUpCounter() + function + (+) Enable the RTC WakeUp using the RTC_WakeUpCmd() function + (+) To read the RTC WakeUp Counter register, use the RTC_GetWakeUpCounter() + function. + + ***Outputs configuration *** + ============================ + [..] The RTC has 2 different outputs: + (+) AFO_ALARM: this output is used to manage the RTC Alarm A. + To output the selected RTC signal on RTC_AF1 pin, use the + RTC_OutputConfig() function. + (+) AFO_CALIB: this output is 512Hz signal or 1Hz . + To output the RTC Clock on RTC_AF1 pin, use the RTC_CalibOutputCmd() + function. + + ***Original Digital Calibration configuration *** + ================================= + [..] Configure the RTC Original Digital Calibration Value and the corresponding + calibration cycle period (32s,16s and 8s) using the RTC_SmoothCalibConfig() + function. + + ***TimeStamp configuration *** + ============================== + [..] + (+) Configure the RTC_AF1 trigger and enables the RTC TimeStamp + using the RTC_TimeStampCmd() function. + (+) To read the RTC TimeStamp Time and Date register, use the + RTC_GetTimeStamp() function. + (+) To read the RTC TimeStamp SubSecond register, use the + RTC_GetTimeStampSubSecond() function. + + ***Tamper configuration *** + =========================== + [..] + (+) Configure the Tamper filter count using RTC_TamperFilterConfig() + function. + (+) Configure the RTC Tamper trigger Edge or Level according to the Tamper + filter (if equal to 0 Edge else Level) value using the RTC_TamperConfig() function + (+) Configure the Tamper sampling frequency using RTC_TamperSamplingFreqConfig() + function. + (+) Configure the Tamper precharge or discharge duration using + RTC_TamperPinsPrechargeDuration() function. + (+) Enable the Tamper Pull-UP using RTC_TamperPullUpDisableCmd() function. + (+) Enable the RTC Tamper using the RTC_TamperCmd() function. + (+) Enable the Time stamp on Tamper detection event using + RTC_TSOnTamperDetecCmd() function. + + ***Backup Data Registers configuration *** + ========================================== + [..] + (+) To write to the RTC Backup Data registers, use the RTC_WriteBackupRegister() + function. + (+) To read the RTC Backup Data registers, use the RTC_ReadBackupRegister() + function. + + ##### RTC and low power modes ##### + =============================================================================== + [..] The MCU can be woken up from a low power mode by an RTC alternate + function. + [..] The RTC alternate functions are the RTC alarm (Alarm A), RTC tamper + event detection and RTC time stamp event detection. + These RTC alternate functions can wake up the system from the Stop + and Standby lowpower modes. + The system can also wake up from low power modes without depending + on an external interrupt (Auto-wakeup mode), by using the RTC alarm events. + [..] The RTC provides a programmable time base for waking up from the + Stop or Standby mode at regular intervals. + Wakeup from STOP and Standby modes is possible only when the RTC + clock source is LSE or LSI. + + ##### Selection of RTC_AF1 alternate functions ##### + =============================================================================== + [..] The RTC_AF1 pin (PC13) can be used for the following purposes: + (+) AFO_ALARM output + (+) AFO_CALIB output + (+) AFI_TAMPER + (+) AFI_TIMESTAMP + + +------------------------------------------------------------------------------------------+ + | Pin |AFO_ALARM |AFO_CALIB |AFI_TAMPER |AFI_TIMESTAMP | WKUP2 |ALARMOUTTYPE | + | configuration | ENABLED | ENABLED | ENABLED | ENABLED |ENABLED | AFO_ALARM | + | and function | | | | | |Configuration | + |-----------------|----------|----------|-----------|--------------|--------|--------------| + | Alarm out | | | | | Don't | | + | output OD | 1 | 0 |Don't care | Don't care | care | 0 | + |-----------------|----------|----------|-----------|--------------|--------|--------------| + | Alarm out | | | | | Don't | | + | output PP | 1 | 0 |Don't care | Don't care | care | 1 | + |-----------------|----------|----------|-----------|--------------|--------|--------------| + | Calibration out | | | | | Don't | | + | output PP | 0 | 1 |Don't care | Don't care | care | Don't care | + |-----------------|----------|----------|-----------|--------------|--------|--------------| + | TAMPER input | | | | | Don't | | + | floating | 0 | 0 | 1 | 0 | care | Don't care | + |-----------------|----------|----------|-----------|--------------|--------|--------------| + | TIMESTAMP and | | | | | Don't | | + | TAMPER input | 0 | 0 | 1 | 1 | care | Don't care | + | floating | | | | | | | + |-----------------|----------|----------|-----------|--------------|--------|--------------| + | TIMESTAMP input | | | | | Don't | | + | floating | 0 | 0 | 0 | 1 | care | Don't care | + |-----------------|----------|----------|-----------|--------------|--------|--------------| + | Wakeup Pin 2 | 0 | 0 | 0 | 0 | 1 | Don't care | + |-----------------|----------|----------|-----------|--------------|--------|--------------| + | Standard GPIO | 0 | 0 | 0 | 0 | 0 | Don't care | + +------------------------------------------------------------------------------------------+ + + @endverbatim + + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_rtc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup RTC + * @brief RTC driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ + +/* Masks Definition */ +#define RTC_TR_RESERVED_MASK ((uint32_t)0x007F7F7F) +#define RTC_DR_RESERVED_MASK ((uint32_t)0x00FFFF3F) +#define RTC_INIT_MASK ((uint32_t)0xFFFFFFFF) +#define RTC_RSF_MASK ((uint32_t)0xFFFFFF5F) +#define RTC_FLAGS_MASK ((uint32_t)(RTC_FLAG_TSOVF | RTC_FLAG_TSF | RTC_FLAG_ALRAF | \ + RTC_FLAG_RSF | RTC_FLAG_INITS |RTC_FLAG_INITF | \ + RTC_FLAG_TAMP1F | RTC_FLAG_TAMP2F | RTC_FLAG_RECALPF | \ + RTC_FLAG_SHPF)) + +#define INITMODE_TIMEOUT ((uint32_t) 0x00004000) +#define SYNCHRO_TIMEOUT ((uint32_t) 0x00008000) +#define RECALPF_TIMEOUT ((uint32_t) 0x00001000) +#define SHPF_TIMEOUT ((uint32_t) 0x00001000) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +static uint8_t RTC_ByteToBcd2(uint8_t Value); +static uint8_t RTC_Bcd2ToByte(uint8_t Value); + +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup RTC_Private_Functions + * @{ + */ + +/** @defgroup RTC_Group1 Initialization and Configuration functions + * @brief Initialization and Configuration functions + * +@verbatim + =============================================================================== + ##### Initialization and Configuration functions ##### + =============================================================================== + + [..] This section provide functions allowing to initialize and configure the RTC + Prescaler (Synchronous and Asynchronous), RTC Hour format, disable RTC registers + Write protection, enter and exit the RTC initialization mode, RTC registers + synchronization check and reference clock detection enable. + + (#) The RTC Prescaler is programmed to generate the RTC 1Hz time base. + It is split into 2 programmable prescalers to minimize power consumption. + (++) A 7-bit asynchronous prescaler and A 13-bit synchronous prescaler. + (++) When both prescalers are used, it is recommended to configure the + asynchronous prescaler to a high value to minimize consumption. + (#) All RTC registers are Write protected. Writing to the RTC registers + is enabled by writing a key into the Write Protection register, RTC_WPR. + (#) To Configure the RTC Calendar, user application should enter + initialization mode. In this mode, the calendar counter is stopped + and its value can be updated. When the initialization sequence is + complete, the calendar restarts counting after 4 RTCCLK cycles. + (#) To read the calendar through the shadow registers after Calendar + initialization, calendar update or after wakeup from low power modes + the software must first clear the RSF flag. The software must then + wait until it is set again before reading the calendar, which means + that the calendar registers have been correctly copied into the + RTC_TR and RTC_DR shadow registers.The RTC_WaitForSynchro() function + implements the above software sequence (RSF clear and RSF check). + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the RTC registers to their default reset values. + * @note This function doesn't reset the RTC Clock source and RTC Backup Data + * registers. + * @param None + * @retval An ErrorStatus enumeration value: + * - SUCCESS: RTC registers are deinitialized + * - ERROR: RTC registers are not deinitialized + */ +ErrorStatus RTC_DeInit(void) +{ + ErrorStatus status = ERROR; + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Set Initialization mode */ + if (RTC_EnterInitMode() == ERROR) + { + status = ERROR; + } + else + { + /* Reset TR, DR and CR registers */ + RTC->TR = (uint32_t)0x00000000; + RTC->WUTR = (uint32_t)0x0000FFFF; + RTC->DR = (uint32_t)0x00002101; + RTC->CR &= (uint32_t)0x00000000; + RTC->PRER = (uint32_t)0x007F00FF; + RTC->ALRMAR = (uint32_t)0x00000000; + RTC->SHIFTR = (uint32_t)0x00000000; + RTC->CALR = (uint32_t)0x00000000; + RTC->ALRMASSR = (uint32_t)0x00000000; + + /* Reset ISR register and exit initialization mode */ + RTC->ISR = (uint32_t)0x00000000; + + /* Reset Tamper and alternate functions configuration register */ + RTC->TAFCR = 0x00000000; + + /* Wait till the RTC RSF flag is set */ + if (RTC_WaitForSynchro() == ERROR) + { + status = ERROR; + } + else + { + status = SUCCESS; + } + + } + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + + return status; +} + +/** + * @brief Initializes the RTC registers according to the specified parameters + * in RTC_InitStruct. + * @param RTC_InitStruct: pointer to a RTC_InitTypeDef structure that contains + * the configuration information for the RTC peripheral. + * @note The RTC Prescaler register is write protected and can be written in + * initialization mode only. + * @retval An ErrorStatus enumeration value: + * - SUCCESS: RTC registers are initialized + * - ERROR: RTC registers are not initialized + */ +ErrorStatus RTC_Init(RTC_InitTypeDef* RTC_InitStruct) +{ + ErrorStatus status = ERROR; + + /* Check the parameters */ + assert_param(IS_RTC_HOUR_FORMAT(RTC_InitStruct->RTC_HourFormat)); + assert_param(IS_RTC_ASYNCH_PREDIV(RTC_InitStruct->RTC_AsynchPrediv)); + assert_param(IS_RTC_SYNCH_PREDIV(RTC_InitStruct->RTC_SynchPrediv)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Set Initialization mode */ + if (RTC_EnterInitMode() == ERROR) + { + status = ERROR; + } + else + { + /* Clear RTC CR FMT Bit */ + RTC->CR &= ((uint32_t)~(RTC_CR_FMT)); + /* Set RTC_CR register */ + RTC->CR |= ((uint32_t)(RTC_InitStruct->RTC_HourFormat)); + + /* Configure the RTC PRER */ + RTC->PRER = (uint32_t)(RTC_InitStruct->RTC_SynchPrediv); + RTC->PRER |= (uint32_t)(RTC_InitStruct->RTC_AsynchPrediv << 16); + + /* Exit Initialization mode */ + RTC_ExitInitMode(); + + status = SUCCESS; + } + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + + return status; +} + +/** + * @brief Fills each RTC_InitStruct member with its default value. + * @param RTC_InitStruct: pointer to a RTC_InitTypeDef structure which will be + * initialized. + * @retval None + */ +void RTC_StructInit(RTC_InitTypeDef* RTC_InitStruct) +{ + /* Initialize the RTC_HourFormat member */ + RTC_InitStruct->RTC_HourFormat = RTC_HourFormat_24; + + /* Initialize the RTC_AsynchPrediv member */ + RTC_InitStruct->RTC_AsynchPrediv = (uint32_t)0x7F; + + /* Initialize the RTC_SynchPrediv member */ + RTC_InitStruct->RTC_SynchPrediv = (uint32_t)0xFF; +} + +/** + * @brief Enables or disables the RTC registers write protection. + * @note All the RTC registers are write protected except for RTC_ISR[13:8], + * RTC_TAFCR and RTC_BKPxR. + * @note Writing a wrong key reactivates the write protection. + * @note The protection mechanism is not affected by system reset. + * @param NewState: new state of the write protection. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RTC_WriteProtectionCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + } + else + { + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + } +} + +/** + * @brief Enters the RTC Initialization mode. + * @note The RTC Initialization mode is write protected, use the + * RTC_WriteProtectionCmd(DISABLE) before calling this function. + * @param None + * @retval An ErrorStatus enumeration value: + * - SUCCESS: RTC is in Init mode + * - ERROR: RTC is not in Init mode + */ +ErrorStatus RTC_EnterInitMode(void) +{ + __IO uint32_t initcounter = 0x00; + ErrorStatus status = ERROR; + uint32_t initstatus = 0x00; + + /* Check if the Initialization mode is set */ + if ((RTC->ISR & RTC_ISR_INITF) == (uint32_t)RESET) + { + /* Set the Initialization mode */ + RTC->ISR = (uint32_t)RTC_INIT_MASK; + + /* Wait till RTC is in INIT state and if Time out is reached exit */ + do + { + initstatus = RTC->ISR & RTC_ISR_INITF; + initcounter++; + } while((initcounter != INITMODE_TIMEOUT) && (initstatus == 0x00)); + + if ((RTC->ISR & RTC_ISR_INITF) != RESET) + { + status = SUCCESS; + } + else + { + status = ERROR; + } + } + else + { + status = SUCCESS; + } + + return (status); +} + +/** + * @brief Exits the RTC Initialization mode. + * @note When the initialization sequence is complete, the calendar restarts + * counting after 4 RTCCLK cycles. + * @note The RTC Initialization mode is write protected, use the + * RTC_WriteProtectionCmd(DISABLE) before calling this function. + * @param None + * @retval None + */ +void RTC_ExitInitMode(void) +{ + /* Exit Initialization mode */ + RTC->ISR &= (uint32_t)~RTC_ISR_INIT; +} + +/** + * @brief Waits until the RTC Time and Date registers (RTC_TR and RTC_DR) are + * synchronized with RTC APB clock. + * @note The RTC Resynchronization mode is write protected, use the + * RTC_WriteProtectionCmd(DISABLE) before calling this function. + * @note To read the calendar through the shadow registers after Calendar + * initialization, calendar update or after wakeup from low power modes + * the software must first clear the RSF flag. + * The software must then wait until it is set again before reading + * the calendar, which means that the calendar registers have been + * correctly copied into the RTC_TR and RTC_DR shadow registers. + * @param None + * @retval An ErrorStatus enumeration value: + * - SUCCESS: RTC registers are synchronised + * - ERROR: RTC registers are not synchronised + */ +ErrorStatus RTC_WaitForSynchro(void) +{ + __IO uint32_t synchrocounter = 0; + ErrorStatus status = ERROR; + uint32_t synchrostatus = 0x00; + + if ((RTC->CR & RTC_CR_BYPSHAD) != RESET) + { + /* Bypass shadow mode */ + status = SUCCESS; + } + else + { + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Clear RSF flag */ + RTC->ISR &= (uint32_t)RTC_RSF_MASK; + + /* Wait the registers to be synchronised */ + do + { + synchrostatus = RTC->ISR & RTC_ISR_RSF; + synchrocounter++; + } while((synchrocounter != SYNCHRO_TIMEOUT) && (synchrostatus == 0x00)); + + if ((RTC->ISR & RTC_ISR_RSF) != RESET) + { + status = SUCCESS; + } + else + { + status = ERROR; + } + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + } + + return (status); +} + +/** + * @brief Enables or disables the RTC reference clock detection. + * @param NewState: new state of the RTC reference clock. + * This parameter can be: ENABLE or DISABLE. + * @retval An ErrorStatus enumeration value: + * - SUCCESS: RTC reference clock detection is enabled + * - ERROR: RTC reference clock detection is disabled + */ +ErrorStatus RTC_RefClockCmd(FunctionalState NewState) +{ + ErrorStatus status = ERROR; + + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Set Initialization mode */ + if (RTC_EnterInitMode() == ERROR) + { + status = ERROR; + } + else + { + if (NewState != DISABLE) + { + /* Enable the RTC reference clock detection */ + RTC->CR |= RTC_CR_REFCKON; + } + else + { + /* Disable the RTC reference clock detection */ + RTC->CR &= ~RTC_CR_REFCKON; + } + /* Exit Initialization mode */ + RTC_ExitInitMode(); + + status = SUCCESS; + } + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + + return status; +} + +/** + * @brief Enables or Disables the Bypass Shadow feature. + * @note When the Bypass Shadow is enabled the calendar value are taken + * directly from the Calendar counter. + * @param NewState: new state of the Bypass Shadow feature. + * This parameter can be: ENABLE or DISABLE. + * @retval None +*/ +void RTC_BypassShadowCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + if (NewState != DISABLE) + { + /* Set the BYPSHAD bit */ + RTC->CR |= (uint8_t)RTC_CR_BYPSHAD; + } + else + { + /* Reset the BYPSHAD bit */ + RTC->CR &= (uint8_t)~RTC_CR_BYPSHAD; + } + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; +} + +/** + * @} + */ + +/** @defgroup RTC_Group2 Time and Date configuration functions + * @brief Time and Date configuration functions + * +@verbatim + =============================================================================== + ##### Time and Date configuration functions ##### + =============================================================================== + [..] This section provide functions allowing to program and read the RTC + Calendar (Time and Date). + +@endverbatim + * @{ + */ + +/** + * @brief Set the RTC current time. + * @param RTC_Format: specifies the format of the entered parameters. + * This parameter can be one of the following values: + * @arg RTC_Format_BIN: Binary data format + * @arg RTC_Format_BCD: BCD data format + * @param RTC_TimeStruct: pointer to a RTC_TimeTypeDef structure that contains + * the time configuration information for the RTC. + * @retval An ErrorStatus enumeration value: + * - SUCCESS: RTC Time register is configured + * - ERROR: RTC Time register is not configured + */ +ErrorStatus RTC_SetTime(uint32_t RTC_Format, RTC_TimeTypeDef* RTC_TimeStruct) +{ + uint32_t tmpreg = 0; + ErrorStatus status = ERROR; + + /* Check the parameters */ + assert_param(IS_RTC_FORMAT(RTC_Format)); + + if (RTC_Format == RTC_Format_BIN) + { + if ((RTC->CR & RTC_CR_FMT) != (uint32_t)RESET) + { + assert_param(IS_RTC_HOUR12(RTC_TimeStruct->RTC_Hours)); + assert_param(IS_RTC_H12(RTC_TimeStruct->RTC_H12)); + } + else + { + RTC_TimeStruct->RTC_H12 = 0x00; + assert_param(IS_RTC_HOUR24(RTC_TimeStruct->RTC_Hours)); + } + assert_param(IS_RTC_MINUTES(RTC_TimeStruct->RTC_Minutes)); + assert_param(IS_RTC_SECONDS(RTC_TimeStruct->RTC_Seconds)); + } + else + { + if ((RTC->CR & RTC_CR_FMT) != (uint32_t)RESET) + { + tmpreg = RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Hours); + assert_param(IS_RTC_HOUR12(tmpreg)); + assert_param(IS_RTC_H12(RTC_TimeStruct->RTC_H12)); + } + else + { + RTC_TimeStruct->RTC_H12 = 0x00; + assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Hours))); + } + assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Minutes))); + assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Seconds))); + } + + /* Check the input parameters format */ + if (RTC_Format != RTC_Format_BIN) + { + tmpreg = (((uint32_t)(RTC_TimeStruct->RTC_Hours) << 16) | \ + ((uint32_t)(RTC_TimeStruct->RTC_Minutes) << 8) | \ + ((uint32_t)RTC_TimeStruct->RTC_Seconds) | \ + ((uint32_t)(RTC_TimeStruct->RTC_H12) << 16)); + } + else + { + tmpreg = (uint32_t)(((uint32_t)RTC_ByteToBcd2(RTC_TimeStruct->RTC_Hours) << 16) | \ + ((uint32_t)RTC_ByteToBcd2(RTC_TimeStruct->RTC_Minutes) << 8) | \ + ((uint32_t)RTC_ByteToBcd2(RTC_TimeStruct->RTC_Seconds)) | \ + (((uint32_t)RTC_TimeStruct->RTC_H12) << 16)); + } + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Set Initialization mode */ + if (RTC_EnterInitMode() == ERROR) + { + status = ERROR; + } + else + { + /* Set the RTC_TR register */ + RTC->TR = (uint32_t)(tmpreg & RTC_TR_RESERVED_MASK); + + /* Exit Initialization mode */ + RTC_ExitInitMode(); + + /* If RTC_CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */ + if ((RTC->CR & RTC_CR_BYPSHAD) == RESET) + { + if (RTC_WaitForSynchro() == ERROR) + { + status = ERROR; + } + else + { + status = SUCCESS; + } + } + else + { + status = SUCCESS; + } + + } + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + + return status; +} + +/** + * @brief Fills each RTC_TimeStruct member with its default value + * (Time = 00h:00min:00sec). + * @param RTC_TimeStruct: pointer to a RTC_TimeTypeDef structure which will be + * initialized. + * @retval None + */ +void RTC_TimeStructInit(RTC_TimeTypeDef* RTC_TimeStruct) +{ + /* Time = 00h:00min:00sec */ + RTC_TimeStruct->RTC_H12 = RTC_H12_AM; + RTC_TimeStruct->RTC_Hours = 0; + RTC_TimeStruct->RTC_Minutes = 0; + RTC_TimeStruct->RTC_Seconds = 0; +} + +/** + * @brief Get the RTC current Time. + * @param RTC_Format: specifies the format of the returned parameters. + * This parameter can be one of the following values: + * @arg RTC_Format_BIN: Binary data format + * @arg RTC_Format_BCD: BCD data format + * @param RTC_TimeStruct: pointer to a RTC_TimeTypeDef structure that will + * contain the returned current time configuration. + * @retval None + */ +void RTC_GetTime(uint32_t RTC_Format, RTC_TimeTypeDef* RTC_TimeStruct) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RTC_FORMAT(RTC_Format)); + + /* Get the RTC_TR register */ + tmpreg = (uint32_t)(RTC->TR & RTC_TR_RESERVED_MASK); + + /* Fill the structure fields with the read parameters */ + RTC_TimeStruct->RTC_Hours = (uint8_t)((tmpreg & (RTC_TR_HT | RTC_TR_HU)) >> 16); + RTC_TimeStruct->RTC_Minutes = (uint8_t)((tmpreg & (RTC_TR_MNT | RTC_TR_MNU)) >>8); + RTC_TimeStruct->RTC_Seconds = (uint8_t)(tmpreg & (RTC_TR_ST | RTC_TR_SU)); + RTC_TimeStruct->RTC_H12 = (uint8_t)((tmpreg & (RTC_TR_PM)) >> 16); + + /* Check the input parameters format */ + if (RTC_Format == RTC_Format_BIN) + { + /* Convert the structure parameters to Binary format */ + RTC_TimeStruct->RTC_Hours = (uint8_t)RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Hours); + RTC_TimeStruct->RTC_Minutes = (uint8_t)RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Minutes); + RTC_TimeStruct->RTC_Seconds = (uint8_t)RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Seconds); + } +} + +/** + * @brief Gets the RTC current Calendar Subseconds value. + * @note This function freeze the Time and Date registers after reading the + * SSR register. + * @param None + * @retval RTC current Calendar Subseconds value. + */ +uint32_t RTC_GetSubSecond(void) +{ + uint32_t tmpreg = 0; + + /* Get subseconds values from the correspondent registers*/ + tmpreg = (uint32_t)(RTC->SSR); + + /* Read DR register to unfroze calendar registers */ + (void) (RTC->DR); + + return (tmpreg); +} + +/** + * @brief Set the RTC current date. + * @param RTC_Format: specifies the format of the entered parameters. + * This parameter can be one of the following values: + * @arg RTC_Format_BIN: Binary data format + * @arg RTC_Format_BCD: BCD data format + * @param RTC_DateStruct: pointer to a RTC_DateTypeDef structure that contains + * the date configuration information for the RTC. + * @retval An ErrorStatus enumeration value: + * - SUCCESS: RTC Date register is configured + * - ERROR: RTC Date register is not configured + */ +ErrorStatus RTC_SetDate(uint32_t RTC_Format, RTC_DateTypeDef* RTC_DateStruct) +{ + uint32_t tmpreg = 0; + ErrorStatus status = ERROR; + + /* Check the parameters */ + assert_param(IS_RTC_FORMAT(RTC_Format)); + + if ((RTC_Format == RTC_Format_BIN) && ((RTC_DateStruct->RTC_Month & 0x10) == 0x10)) + { + RTC_DateStruct->RTC_Month = (RTC_DateStruct->RTC_Month & (uint32_t)~(0x10)) + 0x0A; + } + if (RTC_Format == RTC_Format_BIN) + { + assert_param(IS_RTC_YEAR(RTC_DateStruct->RTC_Year)); + assert_param(IS_RTC_MONTH(RTC_DateStruct->RTC_Month)); + assert_param(IS_RTC_DATE(RTC_DateStruct->RTC_Date)); + } + else + { + assert_param(IS_RTC_YEAR(RTC_Bcd2ToByte(RTC_DateStruct->RTC_Year))); + tmpreg = RTC_Bcd2ToByte(RTC_DateStruct->RTC_Month); + assert_param(IS_RTC_MONTH(tmpreg)); + tmpreg = RTC_Bcd2ToByte(RTC_DateStruct->RTC_Date); + assert_param(IS_RTC_DATE(tmpreg)); + } + assert_param(IS_RTC_WEEKDAY(RTC_DateStruct->RTC_WeekDay)); + + /* Check the input parameters format */ + if (RTC_Format != RTC_Format_BIN) + { + tmpreg = ((((uint32_t)RTC_DateStruct->RTC_Year) << 16) | \ + (((uint32_t)RTC_DateStruct->RTC_Month) << 8) | \ + ((uint32_t)RTC_DateStruct->RTC_Date) | \ + (((uint32_t)RTC_DateStruct->RTC_WeekDay) << 13)); + } + else + { + tmpreg = (((uint32_t)RTC_ByteToBcd2(RTC_DateStruct->RTC_Year) << 16) | \ + ((uint32_t)RTC_ByteToBcd2(RTC_DateStruct->RTC_Month) << 8) | \ + ((uint32_t)RTC_ByteToBcd2(RTC_DateStruct->RTC_Date)) | \ + ((uint32_t)RTC_DateStruct->RTC_WeekDay << 13)); + } + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Set Initialization mode */ + if (RTC_EnterInitMode() == ERROR) + { + status = ERROR; + } + else + { + /* Set the RTC_DR register */ + RTC->DR = (uint32_t)(tmpreg & RTC_DR_RESERVED_MASK); + + /* Exit Initialization mode */ + RTC_ExitInitMode(); + + /* If RTC_CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */ + if ((RTC->CR & RTC_CR_BYPSHAD) == RESET) + { + if (RTC_WaitForSynchro() == ERROR) + { + status = ERROR; + } + else + { + status = SUCCESS; + } + } + else + { + status = SUCCESS; + } + } + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + + return status; +} + +/** + * @brief Fills each RTC_DateStruct member with its default value + * (Monday, January 01 xx00). + * @param RTC_DateStruct: pointer to a RTC_DateTypeDef structure which will be + * initialized. + * @retval None + */ +void RTC_DateStructInit(RTC_DateTypeDef* RTC_DateStruct) +{ + /* Monday, January 01 xx00 */ + RTC_DateStruct->RTC_WeekDay = RTC_Weekday_Monday; + RTC_DateStruct->RTC_Date = 1; + RTC_DateStruct->RTC_Month = RTC_Month_January; + RTC_DateStruct->RTC_Year = 0; +} + +/** + * @brief Get the RTC current date. + * @param RTC_Format: specifies the format of the returned parameters. + * This parameter can be one of the following values: + * @arg RTC_Format_BIN: Binary data format + * @arg RTC_Format_BCD: BCD data format + * @param RTC_DateStruct: pointer to a RTC_DateTypeDef structure that will + * contain the returned current date configuration. + * @retval None + */ +void RTC_GetDate(uint32_t RTC_Format, RTC_DateTypeDef* RTC_DateStruct) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RTC_FORMAT(RTC_Format)); + + /* Get the RTC_TR register */ + tmpreg = (uint32_t)(RTC->DR & RTC_DR_RESERVED_MASK); + + /* Fill the structure fields with the read parameters */ + RTC_DateStruct->RTC_Year = (uint8_t)((tmpreg & (RTC_DR_YT | RTC_DR_YU)) >> 16); + RTC_DateStruct->RTC_Month = (uint8_t)((tmpreg & (RTC_DR_MT | RTC_DR_MU)) >> 8); + RTC_DateStruct->RTC_Date = (uint8_t)(tmpreg & (RTC_DR_DT | RTC_DR_DU)); + RTC_DateStruct->RTC_WeekDay = (uint8_t)((tmpreg & (RTC_DR_WDU)) >> 13); + + /* Check the input parameters format */ + if (RTC_Format == RTC_Format_BIN) + { + /* Convert the structure parameters to Binary format */ + RTC_DateStruct->RTC_Year = (uint8_t)RTC_Bcd2ToByte(RTC_DateStruct->RTC_Year); + RTC_DateStruct->RTC_Month = (uint8_t)RTC_Bcd2ToByte(RTC_DateStruct->RTC_Month); + RTC_DateStruct->RTC_Date = (uint8_t)RTC_Bcd2ToByte(RTC_DateStruct->RTC_Date); + RTC_DateStruct->RTC_WeekDay = (uint8_t)(RTC_DateStruct->RTC_WeekDay); + } +} + +/** + * @} + */ + +/** @defgroup RTC_Group3 Alarms configuration functions + * @brief Alarms (Alarm A) configuration functions + * +@verbatim + =============================================================================== + ##### Alarms (Alarm A and Alarm B) configuration functions ##### + =============================================================================== + [..] This section provide functions allowing to program and read the RTC + Alarms. + +@endverbatim + * @{ + */ + +/** + * @brief Set the specified RTC Alarm. + * @note The Alarm register can only be written when the corresponding Alarm + * is disabled (Use the RTC_AlarmCmd(DISABLE)). + * @param RTC_Format: specifies the format of the returned parameters. + * This parameter can be one of the following values: + * @arg RTC_Format_BIN: Binary data format + * @arg RTC_Format_BCD: BCD data format + * @param RTC_Alarm: specifies the alarm to be configured. + * This parameter can be one of the following values: + * @arg RTC_Alarm_A: to select Alarm A + * @param RTC_AlarmStruct: pointer to a RTC_AlarmTypeDef structure that + * contains the alarm configuration parameters. + * @retval None + */ +void RTC_SetAlarm(uint32_t RTC_Format, uint32_t RTC_Alarm, RTC_AlarmTypeDef* RTC_AlarmStruct) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RTC_FORMAT(RTC_Format)); + assert_param(IS_RTC_ALARM(RTC_Alarm)); + assert_param(IS_RTC_ALARM_MASK(RTC_AlarmStruct->RTC_AlarmMask)); + assert_param(IS_RTC_ALARM_DATE_WEEKDAY_SEL(RTC_AlarmStruct->RTC_AlarmDateWeekDaySel)); + + if (RTC_Format == RTC_Format_BIN) + { + if ((RTC->CR & RTC_CR_FMT) != (uint32_t)RESET) + { + assert_param(IS_RTC_HOUR12(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours)); + assert_param(IS_RTC_H12(RTC_AlarmStruct->RTC_AlarmTime.RTC_H12)); + } + else + { + RTC_AlarmStruct->RTC_AlarmTime.RTC_H12 = 0x00; + assert_param(IS_RTC_HOUR24(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours)); + } + assert_param(IS_RTC_MINUTES(RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes)); + assert_param(IS_RTC_SECONDS(RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds)); + + if(RTC_AlarmStruct->RTC_AlarmDateWeekDaySel == RTC_AlarmDateWeekDaySel_Date) + { + assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(RTC_AlarmStruct->RTC_AlarmDateWeekDay)); + } + else + { + assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(RTC_AlarmStruct->RTC_AlarmDateWeekDay)); + } + } + else + { + if ((RTC->CR & RTC_CR_FMT) != (uint32_t)RESET) + { + tmpreg = RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours); + assert_param(IS_RTC_HOUR12(tmpreg)); + assert_param(IS_RTC_H12(RTC_AlarmStruct->RTC_AlarmTime.RTC_H12)); + } + else + { + RTC_AlarmStruct->RTC_AlarmTime.RTC_H12 = 0x00; + assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours))); + } + + assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes))); + assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds))); + + if(RTC_AlarmStruct->RTC_AlarmDateWeekDaySel == RTC_AlarmDateWeekDaySel_Date) + { + tmpreg = RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmDateWeekDay); + assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(tmpreg)); + } + else + { + tmpreg = RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmDateWeekDay); + assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(tmpreg)); + } + } + + /* Check the input parameters format */ + if (RTC_Format != RTC_Format_BIN) + { + tmpreg = (((uint32_t)(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours) << 16) | \ + ((uint32_t)(RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes) << 8) | \ + ((uint32_t)RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds) | \ + ((uint32_t)(RTC_AlarmStruct->RTC_AlarmTime.RTC_H12) << 16) | \ + ((uint32_t)(RTC_AlarmStruct->RTC_AlarmDateWeekDay) << 24) | \ + ((uint32_t)RTC_AlarmStruct->RTC_AlarmDateWeekDaySel) | \ + ((uint32_t)RTC_AlarmStruct->RTC_AlarmMask)); + } + else + { + tmpreg = (((uint32_t)RTC_ByteToBcd2(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours) << 16) | \ + ((uint32_t)RTC_ByteToBcd2(RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes) << 8) | \ + ((uint32_t)RTC_ByteToBcd2(RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds)) | \ + ((uint32_t)(RTC_AlarmStruct->RTC_AlarmTime.RTC_H12) << 16) | \ + ((uint32_t)RTC_ByteToBcd2(RTC_AlarmStruct->RTC_AlarmDateWeekDay) << 24) | \ + ((uint32_t)RTC_AlarmStruct->RTC_AlarmDateWeekDaySel) | \ + ((uint32_t)RTC_AlarmStruct->RTC_AlarmMask)); + } + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Configure the Alarm register */ + RTC->ALRMAR = (uint32_t)tmpreg; + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; +} + +/** + * @brief Fills each RTC_AlarmStruct member with its default value + * (Time = 00h:00mn:00sec / Date = 1st day of the month/Mask = + * all fields are masked). + * @param RTC_AlarmStruct: pointer to a @ref RTC_AlarmTypeDef structure which + * will be initialized. + * @retval None + */ +void RTC_AlarmStructInit(RTC_AlarmTypeDef* RTC_AlarmStruct) +{ + /* Alarm Time Settings : Time = 00h:00mn:00sec */ + RTC_AlarmStruct->RTC_AlarmTime.RTC_H12 = RTC_H12_AM; + RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours = 0; + RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes = 0; + RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds = 0; + + /* Alarm Date Settings : Date = 1st day of the month */ + RTC_AlarmStruct->RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date; + RTC_AlarmStruct->RTC_AlarmDateWeekDay = 1; + + /* Alarm Masks Settings : Mask = all fields are not masked */ + RTC_AlarmStruct->RTC_AlarmMask = RTC_AlarmMask_None; +} + +/** + * @brief Get the RTC Alarm value and masks. + * @param RTC_Format: specifies the format of the output parameters. + * This parameter can be one of the following values: + * @arg RTC_Format_BIN: Binary data format + * @arg RTC_Format_BCD: BCD data format + * @param RTC_Alarm: specifies the alarm to be read. + * This parameter can be one of the following values: + * @arg RTC_Alarm_A: to select Alarm A + * @param RTC_AlarmStruct: pointer to a RTC_AlarmTypeDef structure that will + * contains the output alarm configuration values. + * @retval None + */ +void RTC_GetAlarm(uint32_t RTC_Format, uint32_t RTC_Alarm, RTC_AlarmTypeDef* RTC_AlarmStruct) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RTC_FORMAT(RTC_Format)); + assert_param(IS_RTC_ALARM(RTC_Alarm)); + + /* Get the RTC_ALRMAR register */ + tmpreg = (uint32_t)(RTC->ALRMAR); + + /* Fill the structure with the read parameters */ + RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours = (uint32_t)((tmpreg & (RTC_ALRMAR_HT | \ + RTC_ALRMAR_HU)) >> 16); + RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes = (uint32_t)((tmpreg & (RTC_ALRMAR_MNT | \ + RTC_ALRMAR_MNU)) >> 8); + RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds = (uint32_t)(tmpreg & (RTC_ALRMAR_ST | \ + RTC_ALRMAR_SU)); + RTC_AlarmStruct->RTC_AlarmTime.RTC_H12 = (uint32_t)((tmpreg & RTC_ALRMAR_PM) >> 16); + RTC_AlarmStruct->RTC_AlarmDateWeekDay = (uint32_t)((tmpreg & (RTC_ALRMAR_DT | RTC_ALRMAR_DU)) >> 24); + RTC_AlarmStruct->RTC_AlarmDateWeekDaySel = (uint32_t)(tmpreg & RTC_ALRMAR_WDSEL); + RTC_AlarmStruct->RTC_AlarmMask = (uint32_t)(tmpreg & RTC_AlarmMask_All); + + if (RTC_Format == RTC_Format_BIN) + { + RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours = RTC_Bcd2ToByte(RTC_AlarmStruct-> \ + RTC_AlarmTime.RTC_Hours); + RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes = RTC_Bcd2ToByte(RTC_AlarmStruct-> \ + RTC_AlarmTime.RTC_Minutes); + RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds = RTC_Bcd2ToByte(RTC_AlarmStruct-> \ + RTC_AlarmTime.RTC_Seconds); + RTC_AlarmStruct->RTC_AlarmDateWeekDay = RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmDateWeekDay); + } +} + +/** + * @brief Enables or disables the specified RTC Alarm. + * @param RTC_Alarm: specifies the alarm to be configured. + * This parameter can be any combination of the following values: + * @arg RTC_Alarm_A: to select Alarm A + * @param NewState: new state of the specified alarm. + * This parameter can be: ENABLE or DISABLE. + * @retval An ErrorStatus enumeration value: + * - SUCCESS: RTC Alarm is enabled/disabled + * - ERROR: RTC Alarm is not enabled/disabled + */ +ErrorStatus RTC_AlarmCmd(uint32_t RTC_Alarm, FunctionalState NewState) +{ + __IO uint32_t alarmcounter = 0x00; + uint32_t alarmstatus = 0x00; + ErrorStatus status = ERROR; + + /* Check the parameters */ + assert_param(IS_RTC_CMD_ALARM(RTC_Alarm)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Configure the Alarm state */ + if (NewState != DISABLE) + { + RTC->CR |= (uint32_t)RTC_Alarm; + + status = SUCCESS; + } + else + { + /* Disable the Alarm in RTC_CR register */ + RTC->CR &= (uint32_t)~RTC_Alarm; + + /* Wait till RTC ALRxWF flag is set and if Time out is reached exit */ + do + { + alarmstatus = RTC->ISR & (RTC_Alarm >> 8); + alarmcounter++; + } while((alarmcounter != INITMODE_TIMEOUT) && (alarmstatus == 0x00)); + + if ((RTC->ISR & (RTC_Alarm >> 8)) == RESET) + { + status = ERROR; + } + else + { + status = SUCCESS; + } + } + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + + return status; +} + +/** + * @brief Configure the RTC AlarmA/B Subseconds value and mask. + * @note This function is performed only when the Alarm is disabled. + * @param RTC_Alarm: specifies the alarm to be configured. + * This parameter can be one of the following values: + * @arg RTC_Alarm_A: to select Alarm A + * @param RTC_AlarmSubSecondValue: specifies the Subseconds value. + * This parameter can be a value from 0 to 0x00007FFF. + * @param RTC_AlarmSubSecondMask: specifies the Subseconds Mask. + * This parameter can be any combination of the following values: + * @arg RTC_AlarmSubSecondMask_All: All Alarm SS fields are masked. + * There is no comparison on sub seconds for Alarm. + * @arg RTC_AlarmSubSecondMask_SS14_1: SS[14:1] are don't care in Alarm comparison. + * Only SS[0] is compared + * @arg RTC_AlarmSubSecondMask_SS14_2: SS[14:2] are don't care in Alarm comparison. + * Only SS[1:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14_3: SS[14:3] are don't care in Alarm comparison. + * Only SS[2:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14_4: SS[14:4] are don't care in Alarm comparison. + * Only SS[3:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14_5: SS[14:5] are don't care in Alarm comparison. + * Only SS[4:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14_6: SS[14:6] are don't care in Alarm comparison. + * Only SS[5:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14_7: SS[14:7] are don't care in Alarm comparison. + * Only SS[6:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14_8: SS[14:8] are don't care in Alarm comparison. + * Only SS[7:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14_9: SS[14:9] are don't care in Alarm comparison. + * Only SS[8:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14_10: SS[14:10] are don't care in Alarm comparison. + * Only SS[9:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14_11: SS[14:11] are don't care in Alarm comparison. + * Only SS[10:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14_12: SS[14:12] are don't care in Alarm comparison. + * Only SS[11:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14_13: SS[14:13] are don't care in Alarm comparison. + * Only SS[12:0] are compared + * @arg RTC_AlarmSubSecondMask_SS14: SS[14] is don't care in Alarm comparison. + * Only SS[13:0] are compared + * @arg RTC_AlarmSubSecondMask_None: SS[14:0] are compared and must match to activate alarm + * @retval None + */ +void RTC_AlarmSubSecondConfig(uint32_t RTC_Alarm, uint32_t RTC_AlarmSubSecondValue, uint8_t RTC_AlarmSubSecondMask) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RTC_ALARM(RTC_Alarm)); + assert_param(IS_RTC_ALARM_SUB_SECOND_VALUE(RTC_AlarmSubSecondValue)); + assert_param(IS_RTC_ALARM_SUB_SECOND_MASK(RTC_AlarmSubSecondMask)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Configure the Alarm A or Alarm B SubSecond registers */ + tmpreg = (uint32_t) (((uint32_t)(RTC_AlarmSubSecondValue)) | ((uint32_t)(RTC_AlarmSubSecondMask) << 24)); + + /* Configure the AlarmA SubSecond register */ + RTC->ALRMASSR = tmpreg; + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + +} + +/** + * @brief Gets the RTC Alarm Subseconds value. + * @param RTC_Alarm: specifies the alarm to be read. + * This parameter can be one of the following values: + * @arg RTC_Alarm_A: to select Alarm A + * @param None + * @retval RTC Alarm Subseconds value. + */ +uint32_t RTC_GetAlarmSubSecond(uint32_t RTC_Alarm) +{ + uint32_t tmpreg = 0; + + /* Get the RTC_ALRMAR register */ + tmpreg = (uint32_t)((RTC->ALRMASSR) & RTC_ALRMASSR_SS); + + return (tmpreg); +} + +/** + * @} + */ + +/** @defgroup RTC_Group4 WakeUp Timer configuration functions + * @brief WakeUp Timer configuration functions + * +@verbatim + =============================================================================== + ##### WakeUp Timer configuration functions ##### + =============================================================================== + + [..] This section provide functions allowing to program and read the RTC WakeUp. + +@endverbatim + * @{ + */ + +/** + * @brief Configures the RTC Wakeup clock source. + * This function is available for STM32F072 devices. + * @note The WakeUp Clock source can only be changed when the RTC WakeUp + * is disabled (Use the RTC_WakeUpCmd(DISABLE)). + * @param RTC_WakeUpClock: Wakeup Clock source. + * This parameter can be one of the following values: + * @arg RTC_WakeUpClock_RTCCLK_Div16 + * @arg RTC_WakeUpClock_RTCCLK_Div8 + * @arg RTC_WakeUpClock_RTCCLK_Div4 + * @arg RTC_WakeUpClock_RTCCLK_Div2 + * @arg RTC_WakeUpClock_CK_SPRE_16bits + * @arg RTC_WakeUpClock_CK_SPRE_17bits + * @retval None + */ +void RTC_WakeUpClockConfig(uint32_t RTC_WakeUpClock) +{ + /* Check the parameters */ + assert_param(IS_RTC_WAKEUP_CLOCK(RTC_WakeUpClock)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Clear the Wakeup Timer clock source bits in CR register */ + RTC->CR &= (uint32_t)~RTC_CR_WUCKSEL; + + /* Configure the clock source */ + RTC->CR |= (uint32_t)RTC_WakeUpClock; + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; +} + +/** + * @brief Configures the RTC Wakeup counter. + * This function is available for STM32F072 devices. + * @note The RTC WakeUp counter can only be written when the RTC WakeUp + * is disabled (Use the RTC_WakeUpCmd(DISABLE)). + * @param RTC_WakeUpCounter: specifies the WakeUp counter. + * This parameter can be a value from 0x0000 to 0xFFFF. + * @retval None + */ +void RTC_SetWakeUpCounter(uint32_t RTC_WakeUpCounter) +{ + /* Check the parameters */ + assert_param(IS_RTC_WAKEUP_COUNTER(RTC_WakeUpCounter)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Configure the Wakeup Timer counter */ + RTC->WUTR = (uint32_t)RTC_WakeUpCounter; + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; +} + +/** + * @brief Returns the RTC WakeUp timer counter value. + * This function is available for STM32F072 devices. + * @param None + * @retval The RTC WakeUp Counter value. + */ +uint32_t RTC_GetWakeUpCounter(void) +{ + /* Get the counter value */ + return ((uint32_t)(RTC->WUTR & RTC_WUTR_WUT)); +} + +/** + * @brief Enables or Disables the RTC WakeUp timer. + * This function is available for STM32F072 devices. + * @param NewState: new state of the WakeUp timer. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +ErrorStatus RTC_WakeUpCmd(FunctionalState NewState) +{ + __IO uint32_t wutcounter = 0x00; + uint32_t wutwfstatus = 0x00; + ErrorStatus status = ERROR; + + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + if (NewState != DISABLE) + { + /* Enable the Wakeup Timer */ + RTC->CR |= (uint32_t)RTC_CR_WUTE; + status = SUCCESS; + } + else + { + /* Disable the Wakeup Timer */ + RTC->CR &= (uint32_t)~RTC_CR_WUTE; + /* Wait till RTC WUTWF flag is set and if Time out is reached exit */ + do + { + wutwfstatus = RTC->ISR & RTC_ISR_WUTWF; + wutcounter++; + } while((wutcounter != INITMODE_TIMEOUT) && (wutwfstatus == 0x00)); + + if ((RTC->ISR & RTC_ISR_WUTWF) == RESET) + { + status = ERROR; + } + else + { + status = SUCCESS; + } + } + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + + return status; +} + +/** + * @} + */ + +/** @defgroup RTC_Group5 Daylight Saving configuration functions + * @brief Daylight Saving configuration functions + * +@verbatim + =============================================================================== + ##### WakeUp Timer configuration functions ##### + =============================================================================== + [..] This section provide functions allowing to program and read the RTC WakeUp. + + This section provide functions allowing to configure the RTC DayLight Saving. + +@endverbatim + * @{ + */ + +/** + * @brief Adds or substract one hour from the current time. + * @param RTC_DayLightSaveOperation: the value of hour adjustment. + * This parameter can be one of the following values: + * @arg RTC_DayLightSaving_SUB1H: Substract one hour (winter time) + * @arg RTC_DayLightSaving_ADD1H: Add one hour (summer time) + * @param RTC_StoreOperation: Specifies the value to be written in the BCK bit + * in CR register to store the operation. + * This parameter can be one of the following values: + * @arg RTC_StoreOperation_Reset: BCK Bit Reset + * @arg RTC_StoreOperation_Set: BCK Bit Set + * @retval None + */ +void RTC_DayLightSavingConfig(uint32_t RTC_DayLightSaving, uint32_t RTC_StoreOperation) +{ + /* Check the parameters */ + assert_param(IS_RTC_DAYLIGHT_SAVING(RTC_DayLightSaving)); + assert_param(IS_RTC_STORE_OPERATION(RTC_StoreOperation)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Clear the bits to be configured */ + RTC->CR &= (uint32_t)~(RTC_CR_BCK); + + /* Configure the RTC_CR register */ + RTC->CR |= (uint32_t)(RTC_DayLightSaving | RTC_StoreOperation); + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; +} + +/** + * @brief Returns the RTC Day Light Saving stored operation. + * @param None + * @retval RTC Day Light Saving stored operation. + * - RTC_StoreOperation_Reset + * - RTC_StoreOperation_Set + */ +uint32_t RTC_GetStoreOperation(void) +{ + return (RTC->CR & RTC_CR_BCK); +} + +/** + * @} + */ + +/** @defgroup RTC_Group6 Output pin Configuration function + * @brief Output pin Configuration function + * +@verbatim + =============================================================================== + ##### Output pin Configuration function ##### + =============================================================================== + [..] This section provide functions allowing to configure the RTC Output source. + +@endverbatim + * @{ + */ + +/** + * @brief Configures the RTC output source (AFO_ALARM). + * @param RTC_Output: Specifies which signal will be routed to the RTC output. + * This parameter can be one of the following values: + * @arg RTC_Output_Disable: No output selected + * @arg RTC_Output_AlarmA: signal of AlarmA mapped to output + * @arg RTC_Output_WakeUp: signal of WakeUp mapped to output, available only for STM32F072 devices + * @param RTC_OutputPolarity: Specifies the polarity of the output signal. + * This parameter can be one of the following: + * @arg RTC_OutputPolarity_High: The output pin is high when the + * ALRAF is high (depending on OSEL) + * @arg RTC_OutputPolarity_Low: The output pin is low when the + * ALRAF is high (depending on OSEL) + * @retval None + */ +void RTC_OutputConfig(uint32_t RTC_Output, uint32_t RTC_OutputPolarity) +{ + /* Check the parameters */ + assert_param(IS_RTC_OUTPUT(RTC_Output)); + assert_param(IS_RTC_OUTPUT_POL(RTC_OutputPolarity)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Clear the bits to be configured */ + RTC->CR &= (uint32_t)~(RTC_CR_OSEL | RTC_CR_POL); + + /* Configure the output selection and polarity */ + RTC->CR |= (uint32_t)(RTC_Output | RTC_OutputPolarity); + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; +} + +/** + * @} + */ + +/** @defgroup RTC_Group7 Digital Calibration configuration functions + * @brief Digital Calibration configuration functions + * +@verbatim + =============================================================================== + ##### Digital Calibration configuration functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the RTC clock to be output through the relative pin. + * @param NewState: new state of the digital calibration Output. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RTC_CalibOutputCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + if (NewState != DISABLE) + { + /* Enable the RTC clock output */ + RTC->CR |= (uint32_t)RTC_CR_COE; + } + else + { + /* Disable the RTC clock output */ + RTC->CR &= (uint32_t)~RTC_CR_COE; + } + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; +} + +/** + * @brief Configure the Calibration Pinout (RTC_CALIB) Selection (1Hz or 512Hz). + * @param RTC_CalibOutput: Select the Calibration output Selection . + * This parameter can be one of the following values: + * @arg RTC_CalibOutput_512Hz: A signal has a regular waveform at 512Hz. + * @arg RTC_CalibOutput_1Hz: A signal has a regular waveform at 1Hz. + * @retval None +*/ +void RTC_CalibOutputConfig(uint32_t RTC_CalibOutput) +{ + /* Check the parameters */ + assert_param(IS_RTC_CALIB_OUTPUT(RTC_CalibOutput)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /*clear flags before config*/ + RTC->CR &= (uint32_t)~(RTC_CR_CALSEL); + + /* Configure the RTC_CR register */ + RTC->CR |= (uint32_t)RTC_CalibOutput; + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; +} + +/** + * @brief Configures the Smooth Calibration Settings. + * @param RTC_SmoothCalibPeriod: Select the Smooth Calibration Period. + * This parameter can be can be one of the following values: + * @arg RTC_SmoothCalibPeriod_32sec: The smooth calibration periode is 32s. + * @arg RTC_SmoothCalibPeriod_16sec: The smooth calibration periode is 16s. + * @arg RTC_SmoothCalibPeriod_8sec: The smooth calibartion periode is 8s. + * @param RTC_SmoothCalibPlusPulses: Select to Set or reset the CALP bit. + * This parameter can be one of the following values: + * @arg RTC_SmoothCalibPlusPulses_Set: Add one RTCCLK puls every 2**11 pulses. + * @arg RTC_SmoothCalibPlusPulses_Reset: No RTCCLK pulses are added. + * @param RTC_SmouthCalibMinusPulsesValue: Select the value of CALM[8:0] bits. + * This parameter can be one any value from 0 to 0x000001FF. + * @retval An ErrorStatus enumeration value: + * - SUCCESS: RTC Calib registers are configured + * - ERROR: RTC Calib registers are not configured +*/ +ErrorStatus RTC_SmoothCalibConfig(uint32_t RTC_SmoothCalibPeriod, + uint32_t RTC_SmoothCalibPlusPulses, + uint32_t RTC_SmouthCalibMinusPulsesValue) +{ + ErrorStatus status = ERROR; + uint32_t recalpfcount = 0; + + /* Check the parameters */ + assert_param(IS_RTC_SMOOTH_CALIB_PERIOD(RTC_SmoothCalibPeriod)); + assert_param(IS_RTC_SMOOTH_CALIB_PLUS(RTC_SmoothCalibPlusPulses)); + assert_param(IS_RTC_SMOOTH_CALIB_MINUS(RTC_SmouthCalibMinusPulsesValue)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* check if a calibration is pending*/ + if ((RTC->ISR & RTC_ISR_RECALPF) != RESET) + { + /* wait until the Calibration is completed*/ + while (((RTC->ISR & RTC_ISR_RECALPF) != RESET) && (recalpfcount != RECALPF_TIMEOUT)) + { + recalpfcount++; + } + } + + /* check if the calibration pending is completed or if there is no calibration operation at all*/ + if ((RTC->ISR & RTC_ISR_RECALPF) == RESET) + { + /* Configure the Smooth calibration settings */ + RTC->CALR = (uint32_t)((uint32_t)RTC_SmoothCalibPeriod | (uint32_t)RTC_SmoothCalibPlusPulses | (uint32_t)RTC_SmouthCalibMinusPulsesValue); + + status = SUCCESS; + } + else + { + status = ERROR; + } + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + + return (ErrorStatus)(status); +} + +/** + * @} + */ + + +/** @defgroup RTC_Group8 TimeStamp configuration functions + * @brief TimeStamp configuration functions + * +@verbatim + =============================================================================== + ##### TimeStamp configuration functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Enables or Disables the RTC TimeStamp functionality with the + * specified time stamp pin stimulating edge. + * @param RTC_TimeStampEdge: Specifies the pin edge on which the TimeStamp is + * activated. + * This parameter can be one of the following: + * @arg RTC_TimeStampEdge_Rising: the Time stamp event occurs on the rising + * edge of the related pin. + * @arg RTC_TimeStampEdge_Falling: the Time stamp event occurs on the + * falling edge of the related pin. + * @param NewState: new state of the TimeStamp. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RTC_TimeStampCmd(uint32_t RTC_TimeStampEdge, FunctionalState NewState) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RTC_TIMESTAMP_EDGE(RTC_TimeStampEdge)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + /* Get the RTC_CR register and clear the bits to be configured */ + tmpreg = (uint32_t)(RTC->CR & (uint32_t)~(RTC_CR_TSEDGE | RTC_CR_TSE)); + + /* Get the new configuration */ + if (NewState != DISABLE) + { + tmpreg |= (uint32_t)(RTC_TimeStampEdge | RTC_CR_TSE); + } + else + { + tmpreg |= (uint32_t)(RTC_TimeStampEdge); + } + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Configure the Time Stamp TSEDGE and Enable bits */ + RTC->CR = (uint32_t)tmpreg; + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; +} + +/** + * @brief Get the RTC TimeStamp value and masks. + * @param RTC_Format: specifies the format of the output parameters. + * This parameter can be one of the following values: + * @arg RTC_Format_BIN: Binary data format + * @arg RTC_Format_BCD: BCD data format + * @param RTC_StampTimeStruct: pointer to a RTC_TimeTypeDef structure that will + * contains the TimeStamp time values. + * @param RTC_StampDateStruct: pointer to a RTC_DateTypeDef structure that will + * contains the TimeStamp date values. + * @retval None + */ +void RTC_GetTimeStamp(uint32_t RTC_Format, RTC_TimeTypeDef* RTC_StampTimeStruct, + RTC_DateTypeDef* RTC_StampDateStruct) +{ + uint32_t tmptime = 0, tmpdate = 0; + + /* Check the parameters */ + assert_param(IS_RTC_FORMAT(RTC_Format)); + + /* Get the TimeStamp time and date registers values */ + tmptime = (uint32_t)(RTC->TSTR & RTC_TR_RESERVED_MASK); + tmpdate = (uint32_t)(RTC->TSDR & RTC_DR_RESERVED_MASK); + + /* Fill the Time structure fields with the read parameters */ + RTC_StampTimeStruct->RTC_Hours = (uint8_t)((tmptime & (RTC_TR_HT | RTC_TR_HU)) >> 16); + RTC_StampTimeStruct->RTC_Minutes = (uint8_t)((tmptime & (RTC_TR_MNT | RTC_TR_MNU)) >> 8); + RTC_StampTimeStruct->RTC_Seconds = (uint8_t)(tmptime & (RTC_TR_ST | RTC_TR_SU)); + RTC_StampTimeStruct->RTC_H12 = (uint8_t)((tmptime & (RTC_TR_PM)) >> 16); + + /* Fill the Date structure fields with the read parameters */ + RTC_StampDateStruct->RTC_Year = 0; + RTC_StampDateStruct->RTC_Month = (uint8_t)((tmpdate & (RTC_DR_MT | RTC_DR_MU)) >> 8); + RTC_StampDateStruct->RTC_Date = (uint8_t)(tmpdate & (RTC_DR_DT | RTC_DR_DU)); + RTC_StampDateStruct->RTC_WeekDay = (uint8_t)((tmpdate & (RTC_DR_WDU)) >> 13); + + /* Check the input parameters format */ + if (RTC_Format == RTC_Format_BIN) + { + /* Convert the Time structure parameters to Binary format */ + RTC_StampTimeStruct->RTC_Hours = (uint8_t)RTC_Bcd2ToByte(RTC_StampTimeStruct->RTC_Hours); + RTC_StampTimeStruct->RTC_Minutes = (uint8_t)RTC_Bcd2ToByte(RTC_StampTimeStruct->RTC_Minutes); + RTC_StampTimeStruct->RTC_Seconds = (uint8_t)RTC_Bcd2ToByte(RTC_StampTimeStruct->RTC_Seconds); + + /* Convert the Date structure parameters to Binary format */ + RTC_StampDateStruct->RTC_Month = (uint8_t)RTC_Bcd2ToByte(RTC_StampDateStruct->RTC_Month); + RTC_StampDateStruct->RTC_Date = (uint8_t)RTC_Bcd2ToByte(RTC_StampDateStruct->RTC_Date); + RTC_StampDateStruct->RTC_WeekDay = (uint8_t)RTC_Bcd2ToByte(RTC_StampDateStruct->RTC_WeekDay); + } +} + +/** + * @brief Get the RTC timestamp Subseconds value. + * @param None + * @retval RTC current timestamp Subseconds value. + */ +uint32_t RTC_GetTimeStampSubSecond(void) +{ + /* Get timestamp subseconds values from the correspondent registers */ + return (uint32_t)(RTC->TSSSR); +} + +/** + * @} + */ + +/** @defgroup RTC_Group9 Tampers configuration functions + * @brief Tampers configuration functions + * +@verbatim + =============================================================================== + ##### Tampers configuration functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Configures the select Tamper pin edge. + * @param RTC_Tamper: Selected tamper pin. + * This parameter can be any combination of the following values: + * @arg RTC_Tamper_1: Select Tamper 1. + * @arg RTC_Tamper_2: Select Tamper 2. + * @param RTC_TamperTrigger: Specifies the trigger on the tamper pin that + * stimulates tamper event. + * This parameter can be one of the following values: + * @arg RTC_TamperTrigger_RisingEdge: Rising Edge of the tamper pin causes tamper event. + * @arg RTC_TamperTrigger_FallingEdge: Falling Edge of the tamper pin causes tamper event. + * @arg RTC_TamperTrigger_LowLevel: Low Level of the tamper pin causes tamper event. + * @arg RTC_TamperTrigger_HighLevel: High Level of the tamper pin causes tamper event. + * @retval None + */ +void RTC_TamperTriggerConfig(uint32_t RTC_Tamper, uint32_t RTC_TamperTrigger) +{ + /* Check the parameters */ + assert_param(IS_RTC_TAMPER(RTC_Tamper)); + assert_param(IS_RTC_TAMPER_TRIGGER(RTC_TamperTrigger)); + + if (RTC_TamperTrigger == RTC_TamperTrigger_RisingEdge) + { + /* Configure the RTC_TAFCR register */ + RTC->TAFCR &= (uint32_t)((uint32_t)~(RTC_Tamper << 1)); + } + else + { + /* Configure the RTC_TAFCR register */ + RTC->TAFCR |= (uint32_t)(RTC_Tamper << 1); + } +} + +/** + * @brief Enables or Disables the Tamper detection. + * @param RTC_Tamper: Selected tamper pin. + * This parameter can be any combination of the following values: + * @arg RTC_Tamper_1: Select Tamper 1. + * @arg RTC_Tamper_2: Select Tamper 2. + * @param NewState: new state of the tamper pin. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RTC_TamperCmd(uint32_t RTC_Tamper, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_RTC_TAMPER(RTC_Tamper)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected Tamper pin */ + RTC->TAFCR |= (uint32_t)RTC_Tamper; + } + else + { + /* Disable the selected Tamper pin */ + RTC->TAFCR &= (uint32_t)~RTC_Tamper; + } +} + +/** + * @brief Configures the Tampers Filter. + * @param RTC_TamperFilter: Specifies the tampers filter. + * This parameter can be one of the following values: + * @arg RTC_TamperFilter_Disable: Tamper filter is disabled. + * @arg RTC_TamperFilter_2Sample: Tamper is activated after 2 consecutive + * samples at the active level + * @arg RTC_TamperFilter_4Sample: Tamper is activated after 4 consecutive + * samples at the active level + * @arg RTC_TamperFilter_8Sample: Tamper is activated after 8 consecutive + * samples at the active level + * @retval None + */ +void RTC_TamperFilterConfig(uint32_t RTC_TamperFilter) +{ + /* Check the parameters */ + assert_param(IS_RTC_TAMPER_FILTER(RTC_TamperFilter)); + + /* Clear TAMPFLT[1:0] bits in the RTC_TAFCR register */ + RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_TAMPFLT); + + /* Configure the RTC_TAFCR register */ + RTC->TAFCR |= (uint32_t)RTC_TamperFilter; +} + +/** + * @brief Configures the Tampers Sampling Frequency. + * @param RTC_TamperSamplingFreq: Specifies the tampers Sampling Frequency. + * This parameter can be one of the following values: + * @arg RTC_TamperSamplingFreq_RTCCLK_Div32768: Each of the tamper inputs are sampled + * with a frequency = RTCCLK / 32768 + * @arg RTC_TamperSamplingFreq_RTCCLK_Div16384: Each of the tamper inputs are sampled + * with a frequency = RTCCLK / 16384 + * @arg RTC_TamperSamplingFreq_RTCCLK_Div8192: Each of the tamper inputs are sampled + * with a frequency = RTCCLK / 8192 + * @arg RTC_TamperSamplingFreq_RTCCLK_Div4096: Each of the tamper inputs are sampled + * with a frequency = RTCCLK / 4096 + * @arg RTC_TamperSamplingFreq_RTCCLK_Div2048: Each of the tamper inputs are sampled + * with a frequency = RTCCLK / 2048 + * @arg RTC_TamperSamplingFreq_RTCCLK_Div1024: Each of the tamper inputs are sampled + * with a frequency = RTCCLK / 1024 + * @arg RTC_TamperSamplingFreq_RTCCLK_Div512: Each of the tamper inputs are sampled + * with a frequency = RTCCLK / 512 + * @arg RTC_TamperSamplingFreq_RTCCLK_Div256: Each of the tamper inputs are sampled + * with a frequency = RTCCLK / 256 + * @retval None + */ +void RTC_TamperSamplingFreqConfig(uint32_t RTC_TamperSamplingFreq) +{ + /* Check the parameters */ + assert_param(IS_RTC_TAMPER_SAMPLING_FREQ(RTC_TamperSamplingFreq)); + + /* Clear TAMPFREQ[2:0] bits in the RTC_TAFCR register */ + RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_TAMPFREQ); + + /* Configure the RTC_TAFCR register */ + RTC->TAFCR |= (uint32_t)RTC_TamperSamplingFreq; +} + +/** + * @brief Configures the Tampers Pins input Precharge Duration. + * @param RTC_TamperPrechargeDuration: Specifies the Tampers Pins input + * Precharge Duration. + * This parameter can be one of the following values: + * @arg RTC_TamperPrechargeDuration_1RTCCLK: Tamper pins are pre-charged before sampling during 1 RTCCLK cycle + * @arg RTC_TamperPrechargeDuration_2RTCCLK: Tamper pins are pre-charged before sampling during 2 RTCCLK cycle + * @arg RTC_TamperPrechargeDuration_4RTCCLK: Tamper pins are pre-charged before sampling during 4 RTCCLK cycle + * @arg RTC_TamperPrechargeDuration_8RTCCLK: Tamper pins are pre-charged before sampling during 8 RTCCLK cycle + * @retval None + */ +void RTC_TamperPinsPrechargeDuration(uint32_t RTC_TamperPrechargeDuration) +{ + /* Check the parameters */ + assert_param(IS_RTC_TAMPER_PRECHARGE_DURATION(RTC_TamperPrechargeDuration)); + + /* Clear TAMPPRCH[1:0] bits in the RTC_TAFCR register */ + RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_TAMPPRCH); + + /* Configure the RTC_TAFCR register */ + RTC->TAFCR |= (uint32_t)RTC_TamperPrechargeDuration; +} + +/** + * @brief Enables or Disables the TimeStamp on Tamper Detection Event. + * @note The timestamp is valid even the TSE bit in tamper control register + * is reset. + * @param NewState: new state of the timestamp on tamper event. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RTC_TimeStampOnTamperDetectionCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Save timestamp on tamper detection event */ + RTC->TAFCR |= (uint32_t)RTC_TAFCR_TAMPTS; + } + else + { + /* Tamper detection does not cause a timestamp to be saved */ + RTC->TAFCR &= (uint32_t)~RTC_TAFCR_TAMPTS; + } +} + +/** + * @brief Enables or Disables the Precharge of Tamper pin. + * @param NewState: new state of tamper pull up. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RTC_TamperPullUpCmd(FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable precharge of the selected Tamper pin */ + RTC->TAFCR &= (uint32_t)~RTC_TAFCR_TAMPPUDIS; + } + else + { + /* Disable precharge of the selected Tamper pin */ + RTC->TAFCR |= (uint32_t)RTC_TAFCR_TAMPPUDIS; + } +} + +/** + * @} + */ + +/** @defgroup RTC_Group10 Backup Data Registers configuration functions + * @brief Backup Data Registers configuration functions + * +@verbatim + =============================================================================== + ##### Backup Data Registers configuration functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Writes a data in a specified RTC Backup data register. + * @param RTC_BKP_DR: RTC Backup data Register number. + * This parameter can be: RTC_BKP_DRx where x can be from 0 to 4 to + * specify the register. + * @param Data: Data to be written in the specified RTC Backup data register. + * @retval None + */ +void RTC_WriteBackupRegister(uint32_t RTC_BKP_DR, uint32_t Data) +{ + __IO uint32_t tmp = 0; + + /* Check the parameters */ + assert_param(IS_RTC_BKP(RTC_BKP_DR)); + + tmp = RTC_BASE + 0x50; + tmp += (RTC_BKP_DR * 4); + + /* Write the specified register */ + *(__IO uint32_t *)tmp = (uint32_t)Data; +} + +/** + * @brief Reads data from the specified RTC Backup data Register. + * @param RTC_BKP_DR: RTC Backup data Register number. + * This parameter can be: RTC_BKP_DRx where x can be from 0 to 19 to + * specify the register. + * @retval None + */ +uint32_t RTC_ReadBackupRegister(uint32_t RTC_BKP_DR) +{ + __IO uint32_t tmp = 0; + + /* Check the parameters */ + assert_param(IS_RTC_BKP(RTC_BKP_DR)); + + tmp = RTC_BASE + 0x50; + tmp += (RTC_BKP_DR * 4); + + /* Read the specified register */ + return (*(__IO uint32_t *)tmp); +} + +/** + * @} + */ + +/** @defgroup RTC_Group11 Output Type Config configuration functions + * @brief Output Type Config configuration functions + * +@verbatim + =============================================================================== + ##### Output Type Config configuration functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Configures the RTC Output Pin mode. + * @param RTC_OutputType: specifies the RTC Output (PC13) pin mode. + * This parameter can be one of the following values: + * @arg RTC_OutputType_OpenDrain: RTC Output (PC13) is configured in + * Open Drain mode. + * @arg RTC_OutputType_PushPull: RTC Output (PC13) is configured in + * Push Pull mode. + * @retval None + */ +void RTC_OutputTypeConfig(uint32_t RTC_OutputType) +{ + /* Check the parameters */ + assert_param(IS_RTC_OUTPUT_TYPE(RTC_OutputType)); + + RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_ALARMOUTTYPE); + RTC->TAFCR |= (uint32_t)(RTC_OutputType); +} + +/** + * @} + */ + +/** @defgroup RTC_Group12 Shift control synchronisation functions + * @brief Shift control synchronisation functions + * +@verbatim + =============================================================================== + ##### Shift control synchronisation functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Configures the Synchronization Shift Control Settings. + * @note When REFCKON is set, firmware must not write to Shift control register + * @param RTC_ShiftAdd1S: Select to add or not 1 second to the time Calendar. + * This parameter can be one of the following values : + * @arg RTC_ShiftAdd1S_Set: Add one second to the clock calendar. + * @arg RTC_ShiftAdd1S_Reset: No effect. + * @param RTC_ShiftSubFS: Select the number of Second Fractions to Substitute. + * This parameter can be one any value from 0 to 0x7FFF. + * @retval An ErrorStatus enumeration value: + * - SUCCESS: RTC Shift registers are configured + * - ERROR: RTC Shift registers are not configured +*/ +ErrorStatus RTC_SynchroShiftConfig(uint32_t RTC_ShiftAdd1S, uint32_t RTC_ShiftSubFS) +{ + ErrorStatus status = ERROR; + uint32_t shpfcount = 0; + + /* Check the parameters */ + assert_param(IS_RTC_SHIFT_ADD1S(RTC_ShiftAdd1S)); + assert_param(IS_RTC_SHIFT_SUBFS(RTC_ShiftSubFS)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + /* Check if a Shift is pending*/ + if ((RTC->ISR & RTC_ISR_SHPF) != RESET) + { + /* Wait until the shift is completed*/ + while (((RTC->ISR & RTC_ISR_SHPF) != RESET) && (shpfcount != SHPF_TIMEOUT)) + { + shpfcount++; + } + } + + /* Check if the Shift pending is completed or if there is no Shift operation at all*/ + if ((RTC->ISR & RTC_ISR_SHPF) == RESET) + { + /* check if the reference clock detection is disabled */ + if((RTC->CR & RTC_CR_REFCKON) == RESET) + { + /* Configure the Shift settings */ + RTC->SHIFTR = (uint32_t)(uint32_t)(RTC_ShiftSubFS) | (uint32_t)(RTC_ShiftAdd1S); + + if(RTC_WaitForSynchro() == ERROR) + { + status = ERROR; + } + else + { + status = SUCCESS; + } + } + else + { + status = ERROR; + } + } + else + { + status = ERROR; + } + + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; + + return (ErrorStatus)(status); +} + +/** + * @} + */ + +/** @defgroup RTC_Group13 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== + [..] All RTC interrupts are connected to the EXTI controller. + + (+) To enable the RTC Alarm interrupt, the following sequence is required: + (++) Configure and enable the EXTI Line 17 in interrupt mode and select the rising + edge sensitivity using the EXTI_Init() function. + (++) Configure and enable the RTC_Alarm IRQ channel in the NVIC using the NVIC_Init() + function. + (++) Configure the RTC to generate RTC alarms (Alarm A) using + the RTC_SetAlarm() and RTC_AlarmCmd() functions. + + (+) To enable the RTC Tamper interrupt, the following sequence is required: + (++) Configure and enable the EXTI Line 19 in interrupt mode and select the rising + edge sensitivity using the EXTI_Init() function. + (++) Configure and enable the TAMP_STAMP IRQ channel in the NVIC using the NVIC_Init() + function. + (++) Configure the RTC to detect the RTC tamper event using the + RTC_TamperTriggerConfig() and RTC_TamperCmd() functions. + + (+) To enable the RTC TimeStamp interrupt, the following sequence is required: + (++) Configure and enable the EXTI Line 19 in interrupt mode and select the rising + edge sensitivity using the EXTI_Init() function. + (++) Configure and enable the TAMP_STAMP IRQ channel in the NVIC using the NVIC_Init() + function. + (++) Configure the RTC to detect the RTC time-stamp event using the + RTC_TimeStampCmd() functions. + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified RTC interrupts. + * @param RTC_IT: specifies the RTC interrupt sources to be enabled or disabled. + * This parameter can be any combination of the following values: + * @arg RTC_IT_TS: Time Stamp interrupt mask + * @arg RTC_IT_WUT: WakeUp Timer interrupt mask, available only for STM32F072 devices + * @arg RTC_IT_ALRA: Alarm A interrupt mask + * @arg RTC_IT_TAMP: Tamper event interrupt mask + * @param NewState: new state of the specified RTC interrupts. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void RTC_ITConfig(uint32_t RTC_IT, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_RTC_CONFIG_IT(RTC_IT)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + /* Disable the write protection for RTC registers */ + RTC->WPR = 0xCA; + RTC->WPR = 0x53; + + if (NewState != DISABLE) + { + /* Configure the Interrupts in the RTC_CR register */ + RTC->CR |= (uint32_t)(RTC_IT & ~RTC_TAFCR_TAMPIE); + /* Configure the Tamper Interrupt in the RTC_TAFCR */ + RTC->TAFCR |= (uint32_t)(RTC_IT & RTC_TAFCR_TAMPIE); + } + else + { + /* Configure the Interrupts in the RTC_CR register */ + RTC->CR &= (uint32_t)~(RTC_IT & (uint32_t)~RTC_TAFCR_TAMPIE); + /* Configure the Tamper Interrupt in the RTC_TAFCR */ + RTC->TAFCR &= (uint32_t)~(RTC_IT & RTC_TAFCR_TAMPIE); + } + /* Enable the write protection for RTC registers */ + RTC->WPR = 0xFF; +} + +/** + * @brief Checks whether the specified RTC flag is set or not. + * @param RTC_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg RTC_FLAG_RECALPF: RECALPF event flag + * @arg RTC_FLAG_TAMP2F: Tamper 2 event flag + * @arg RTC_FLAG_TAMP1F: Tamper 1 event flag + * @arg RTC_FLAG_TSOVF: Time Stamp OverFlow flag + * @arg RTC_FLAG_TSF: Time Stamp event flag + * @arg RTC_FLAG_WUTF: WakeUp Timer flag, available only for STM32F072 devices + * @arg RTC_FLAG_ALRAF: Alarm A flag + * @arg RTC_FLAG_INITF: Initialization mode flag + * @arg RTC_FLAG_RSF: Registers Synchronized flag + * @arg RTC_FLAG_INITS: Registers Configured flag + * @retval The new state of RTC_FLAG (SET or RESET). + */ +FlagStatus RTC_GetFlagStatus(uint32_t RTC_FLAG) +{ + FlagStatus bitstatus = RESET; + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RTC_GET_FLAG(RTC_FLAG)); + + /* Get all the flags */ + tmpreg = (uint32_t)(RTC->ISR & RTC_FLAGS_MASK); + + /* Return the status of the flag */ + if ((tmpreg & RTC_FLAG) != (uint32_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + return bitstatus; +} + +/** + * @brief Clears the RTC's pending flags. + * @param RTC_FLAG: specifies the RTC flag to clear. + * This parameter can be any combination of the following values: + * @arg RTC_FLAG_TAMP2F: Tamper 2 event flag + * @arg RTC_FLAG_TAMP1F: Tamper 1 event flag + * @arg RTC_FLAG_TSOVF: Time Stamp Overflow flag + * @arg RTC_FLAG_TSF: Time Stamp event flag + * @arg RTC_FLAG_WUTF: WakeUp Timer flag, available only for STM32F072 devices + * @arg RTC_FLAG_ALRAF: Alarm A flag + * @arg RTC_FLAG_RSF: Registers Synchronized flag + * @retval None + */ +void RTC_ClearFlag(uint32_t RTC_FLAG) +{ + /* Check the parameters */ + assert_param(IS_RTC_CLEAR_FLAG(RTC_FLAG)); + + /* Clear the Flags in the RTC_ISR register */ + RTC->ISR = (uint32_t)((uint32_t)(~((RTC_FLAG | RTC_ISR_INIT)& 0x0001FFFF) | (uint32_t)(RTC->ISR & RTC_ISR_INIT))); +} + +/** + * @brief Checks whether the specified RTC interrupt has occurred or not. + * @param RTC_IT: specifies the RTC interrupt source to check. + * This parameter can be one of the following values: + * @arg RTC_IT_TS: Time Stamp interrupt + * @arg RTC_IT_WUT: WakeUp Timer interrupt, available only for STM32F072 devices + * @arg RTC_IT_ALRA: Alarm A interrupt + * @arg RTC_IT_TAMP1: Tamper1 event interrupt + * @arg RTC_IT_TAMP2: Tamper2 event interrupt + * @retval The new state of RTC_IT (SET or RESET). + */ +ITStatus RTC_GetITStatus(uint32_t RTC_IT) +{ + ITStatus bitstatus = RESET; + uint32_t tmpreg = 0, enablestatus = 0; + + /* Check the parameters */ + assert_param(IS_RTC_GET_IT(RTC_IT)); + + /* Get the TAMPER Interrupt enable bit and pending bit */ + tmpreg = (uint32_t)(RTC->TAFCR & (RTC_TAFCR_TAMPIE)); + + /* Get the Interrupt enable Status */ + enablestatus = (uint32_t)((RTC->CR & RTC_IT) | (tmpreg & ((RTC_IT >> (RTC_IT >> 18)) >> 15))); + + /* Get the Interrupt pending bit */ + tmpreg = (uint32_t)((RTC->ISR & (uint32_t)(RTC_IT >> 4))); + + /* Get the status of the Interrupt */ + if ((enablestatus != (uint32_t)RESET) && ((tmpreg & 0x0000FFFF) != (uint32_t)RESET)) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + return bitstatus; +} + +/** + * @brief Clears the RTC's interrupt pending bits. + * @param RTC_IT: specifies the RTC interrupt pending bit to clear. + * This parameter can be any combination of the following values: + * @arg RTC_IT_TS: Time Stamp interrupt + * @arg RTC_IT_WUT: WakeUp Timer interrupt, available only for STM32F072 devices + * @arg RTC_IT_ALRA: Alarm A interrupt + * @arg RTC_IT_TAMP1: Tamper1 event interrupt + * @arg RTC_IT_TAMP2: Tamper2 event interrupt + * @retval None + */ +void RTC_ClearITPendingBit(uint32_t RTC_IT) +{ + uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_RTC_CLEAR_IT(RTC_IT)); + + /* Get the RTC_ISR Interrupt pending bits mask */ + tmpreg = (uint32_t)(RTC_IT >> 4); + + /* Clear the interrupt pending bits in the RTC_ISR register */ + RTC->ISR = (uint32_t)((uint32_t)(~((tmpreg | RTC_ISR_INIT)& 0x0000FFFF) | (uint32_t)(RTC->ISR & RTC_ISR_INIT))); +} + +/** + * @} + */ + +/** + * @brief Converts a 2 digit decimal to BCD format. + * @param Value: Byte to be converted. + * @retval Converted byte + */ +static uint8_t RTC_ByteToBcd2(uint8_t Value) +{ + uint8_t bcdhigh = 0; + + while (Value >= 10) + { + bcdhigh++; + Value -= 10; + } + + return ((uint8_t)(bcdhigh << 4) | Value); +} + +/** + * @brief Convert from 2 digit BCD to Binary. + * @param Value: BCD value to be converted. + * @retval Converted word + */ +static uint8_t RTC_Bcd2ToByte(uint8_t Value) +{ + uint8_t tmp = 0; + tmp = ((uint8_t)(Value & (uint8_t)0xF0) >> (uint8_t)0x4) * 10; + return (tmp + (Value & (uint8_t)0x0F)); +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_spi.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_spi.c new file mode 100644 index 00000000..f57a82dc --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_spi.c @@ -0,0 +1,1334 @@ +/** + ****************************************************************************** + * @file stm32f0xx_spi.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Serial peripheral interface (SPI): + * + Initialization and Configuration + * + Data transfers functions + * + Hardware CRC Calculation + * + DMA transfers management + * + Interrupts and flags management + * + * @verbatim + + =============================================================================== + ##### How to use this driver ##### + =============================================================================== + [..] + (#) Enable peripheral clock using RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE) + function for SPI1 or using RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE) + function for SPI2. + + (#) Enable SCK, MOSI, MISO and NSS GPIO clocks using + RCC_AHBPeriphClockCmd() function. + + (#) Peripherals alternate function: + (++) Connect the pin to the desired peripherals' Alternate + Function (AF) using GPIO_PinAFConfig() function. + (++) Configure the desired pin in alternate function by: + GPIO_InitStruct->GPIO_Mode = GPIO_Mode_AF. + (++) Select the type, pull-up/pull-down and output speed via + GPIO_PuPd, GPIO_OType and GPIO_Speed members. + (++) Call GPIO_Init() function. + + (#) Program the Polarity, Phase, First Data, Baud Rate Prescaler, Slave + Management, Peripheral Mode and CRC Polynomial values using the SPI_Init() + function.In I2S mode, program the Mode, Standard, Data Format, MCLK + Output, Audio frequency and Polarity using I2S_Init() function. + + (#) Configure the FIFO threshold using SPI_RxFIFOThresholdConfig() to select + at which threshold the RXNE event is generated. + + (#) Enable the NVIC and the corresponding interrupt using the function + SPI_ITConfig() if you need to use interrupt mode. + + (#) When using the DMA mode + (++) Configure the DMA using DMA_Init() function. + (++) Active the needed channel Request using SPI_I2S_DMACmd() function. + + (#) Enable the SPI using the SPI_Cmd() function or enable the I2S using + I2S_Cmd(). + + (#) Enable the DMA using the DMA_Cmd() function when using DMA mode. + + (#) Optionally, you can enable/configure the following parameters without + re-initialization (i.e there is no need to call again SPI_Init() function): + (++) When bidirectional mode (SPI_Direction_1Line_Rx or SPI_Direction_1Line_Tx) + is programmed as Data direction parameter using the SPI_Init() + function it can be possible to switch between SPI_Direction_Tx + or SPI_Direction_Rx using the SPI_BiDirectionalLineConfig() function. + (++) When SPI_NSS_Soft is selected as Slave Select Management parameter + using the SPI_Init() function it can be possible to manage the + NSS internal signal using the SPI_NSSInternalSoftwareConfig() function. + (++) Reconfigure the data size using the SPI_DataSizeConfig() function. + (++) Enable or disable the SS output using the SPI_SSOutputCmd() function. + + (#) To use the CRC Hardware calculation feature refer to the Peripheral + CRC hardware Calculation subsection. + + @endverbatim + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_spi.h" +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup SPI + * @brief SPI driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* SPI registers Masks */ +#define CR1_CLEAR_MASK ((uint16_t)0x3040) +#define CR1_CLEAR_MASK2 ((uint16_t)0xFFFB) +#define CR2_LDMA_MASK ((uint16_t)0x9FFF) + +#define I2SCFGR_CLEAR_Mask ((uint16_t)0xF040) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup SPI_Private_Functions + * @{ + */ + +/** @defgroup SPI_Group1 Initialization and Configuration functions + * @brief Initialization and Configuration functions + * +@verbatim + =============================================================================== + ##### Initialization and Configuration functions ##### + =============================================================================== + [..] This section provides a set of functions allowing to initialize the SPI Direction, + SPI Mode, SPI Data Size, SPI Polarity, SPI Phase, SPI NSS Management, SPI Baud + Rate Prescaler, SPI First Bit and SPI CRC Polynomial. + + [..] The SPI_Init() function follows the SPI configuration procedures for Master mode + and Slave mode (details for these procedures are available in reference manual). + + [..] When the Software NSS management (SPI_InitStruct->SPI_NSS = SPI_NSS_Soft) is selected, + use the following function to manage the NSS bit: + void SPI_NSSInternalSoftwareConfig(SPI_TypeDef* SPIx, uint16_t SPI_NSSInternalSoft); + + [..] In Master mode, when the Hardware NSS management (SPI_InitStruct->SPI_NSS = SPI_NSS_Hard) + is selected, use the follwoing function to enable the NSS output feature. + void SPI_SSOutputCmd(SPI_TypeDef* SPIx, FunctionalState NewState); + + [..] The NSS pulse mode can be managed by the SPI TI mode when enabling it using the following function: + void SPI_TIModeCmd(SPI_TypeDef* SPIx, FunctionalState NewState); + And it can be managed by software in the SPI Motorola mode using this function: + void SPI_NSSPulseModeCmd(SPI_TypeDef* SPIx, FunctionalState NewState); + + [..] This section provides also functions to initialize the I2S Mode, Standard, + Data Format, MCLK Output, Audio frequency and Polarity. + + [..] The I2S_Init() function follows the I2S configuration procedures for Master mode + and Slave mode. + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the SPIx peripheral registers to their default + * reset values. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * I2S mode is not supported for STM32F030 devices. + * @retval None + */ +void SPI_I2S_DeInit(SPI_TypeDef* SPIx) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + + if (SPIx == SPI1) + { + /* Enable SPI1 reset state */ + RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1, ENABLE); + /* Release SPI1 from reset state */ + RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1, DISABLE); + } + else + { + if (SPIx == SPI2) + { + /* Enable SPI2 reset state */ + RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2, ENABLE); + /* Release SPI2 from reset state */ + RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2, DISABLE); + } + } +} + +/** + * @brief Fills each SPI_InitStruct member with its default value. + * @param SPI_InitStruct: pointer to a SPI_InitTypeDef structure which will be initialized. + * @retval None + */ +void SPI_StructInit(SPI_InitTypeDef* SPI_InitStruct) +{ +/*--------------- Reset SPI init structure parameters values -----------------*/ + /* Initialize the SPI_Direction member */ + SPI_InitStruct->SPI_Direction = SPI_Direction_2Lines_FullDuplex; + /* Initialize the SPI_Mode member */ + SPI_InitStruct->SPI_Mode = SPI_Mode_Slave; + /* Initialize the SPI_DataSize member */ + SPI_InitStruct->SPI_DataSize = SPI_DataSize_8b; + /* Initialize the SPI_CPOL member */ + SPI_InitStruct->SPI_CPOL = SPI_CPOL_Low; + /* Initialize the SPI_CPHA member */ + SPI_InitStruct->SPI_CPHA = SPI_CPHA_1Edge; + /* Initialize the SPI_NSS member */ + SPI_InitStruct->SPI_NSS = SPI_NSS_Hard; + /* Initialize the SPI_BaudRatePrescaler member */ + SPI_InitStruct->SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2; + /* Initialize the SPI_FirstBit member */ + SPI_InitStruct->SPI_FirstBit = SPI_FirstBit_MSB; + /* Initialize the SPI_CRCPolynomial member */ + SPI_InitStruct->SPI_CRCPolynomial = 7; +} + +/** + * @brief Initializes the SPIx peripheral according to the specified + * parameters in the SPI_InitStruct. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param SPI_InitStruct: pointer to a SPI_InitTypeDef structure that + * contains the configuration information for the specified SPI peripheral. + * @retval None + */ +void SPI_Init(SPI_TypeDef* SPIx, SPI_InitTypeDef* SPI_InitStruct) +{ + uint16_t tmpreg = 0; + + /* check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + + /* Check the SPI parameters */ + assert_param(IS_SPI_DIRECTION_MODE(SPI_InitStruct->SPI_Direction)); + assert_param(IS_SPI_MODE(SPI_InitStruct->SPI_Mode)); + assert_param(IS_SPI_DATA_SIZE(SPI_InitStruct->SPI_DataSize)); + assert_param(IS_SPI_CPOL(SPI_InitStruct->SPI_CPOL)); + assert_param(IS_SPI_CPHA(SPI_InitStruct->SPI_CPHA)); + assert_param(IS_SPI_NSS(SPI_InitStruct->SPI_NSS)); + assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_InitStruct->SPI_BaudRatePrescaler)); + assert_param(IS_SPI_FIRST_BIT(SPI_InitStruct->SPI_FirstBit)); + assert_param(IS_SPI_CRC_POLYNOMIAL(SPI_InitStruct->SPI_CRCPolynomial)); + + /*---------------------------- SPIx CR1 Configuration ------------------------*/ + /* Get the SPIx CR1 value */ + tmpreg = SPIx->CR1; + /* Clear BIDIMode, BIDIOE, RxONLY, SSM, SSI, LSBFirst, BR, CPOL and CPHA bits */ + tmpreg &= CR1_CLEAR_MASK; + /* Configure SPIx: direction, NSS management, first transmitted bit, BaudRate prescaler + master/slave mode, CPOL and CPHA */ + /* Set BIDImode, BIDIOE and RxONLY bits according to SPI_Direction value */ + /* Set SSM, SSI bit according to SPI_NSS values */ + /* Set LSBFirst bit according to SPI_FirstBit value */ + /* Set BR bits according to SPI_BaudRatePrescaler value */ + /* Set CPOL bit according to SPI_CPOL value */ + /* Set CPHA bit according to SPI_CPHA value */ + tmpreg |= (uint16_t)((uint32_t)SPI_InitStruct->SPI_Direction | SPI_InitStruct->SPI_FirstBit | + SPI_InitStruct->SPI_CPOL | SPI_InitStruct->SPI_CPHA | + SPI_InitStruct->SPI_NSS | SPI_InitStruct->SPI_BaudRatePrescaler); + /* Write to SPIx CR1 */ + SPIx->CR1 = tmpreg; + /*-------------------------Data Size Configuration -----------------------*/ + /* Get the SPIx CR2 value */ + tmpreg = SPIx->CR2; + /* Clear DS[3:0] bits */ + tmpreg &=(uint16_t)~SPI_CR2_DS; + /* Configure SPIx: Data Size */ + tmpreg |= (uint16_t)(SPI_InitStruct->SPI_DataSize); + /* Write to SPIx CR2 */ + SPIx->CR2 = tmpreg; + + /*---------------------------- SPIx CRCPOLY Configuration --------------------*/ + /* Write to SPIx CRCPOLY */ + SPIx->CRCPR = SPI_InitStruct->SPI_CRCPolynomial; + + /*---------------------------- SPIx CR1 Configuration ------------------------*/ + /* Get the SPIx CR1 value */ + tmpreg = SPIx->CR1; + /* Clear MSTR bit */ + tmpreg &= CR1_CLEAR_MASK2; + /* Configure SPIx: master/slave mode */ + /* Set MSTR bit according to SPI_Mode */ + tmpreg |= (uint16_t)((uint32_t)SPI_InitStruct->SPI_Mode); + /* Write to SPIx CR1 */ + SPIx->CR1 = tmpreg; + + /* Activate the SPI mode (Reset I2SMOD bit in I2SCFGR register) */ + SPIx->I2SCFGR &= (uint16_t)~((uint16_t)SPI_I2SCFGR_I2SMOD); +} + +/** + * @brief Fills each I2S_InitStruct member with its default value. + * @note This mode is not supported for STM32F030 devices. + * @param I2S_InitStruct: pointer to a I2S_InitTypeDef structure which will be initialized. + * @retval None + */ +void I2S_StructInit(I2S_InitTypeDef* I2S_InitStruct) +{ +/*--------------- Reset I2S init structure parameters values -----------------*/ + /* Initialize the I2S_Mode member */ + I2S_InitStruct->I2S_Mode = I2S_Mode_SlaveTx; + + /* Initialize the I2S_Standard member */ + I2S_InitStruct->I2S_Standard = I2S_Standard_Phillips; + + /* Initialize the I2S_DataFormat member */ + I2S_InitStruct->I2S_DataFormat = I2S_DataFormat_16b; + + /* Initialize the I2S_MCLKOutput member */ + I2S_InitStruct->I2S_MCLKOutput = I2S_MCLKOutput_Disable; + + /* Initialize the I2S_AudioFreq member */ + I2S_InitStruct->I2S_AudioFreq = I2S_AudioFreq_Default; + + /* Initialize the I2S_CPOL member */ + I2S_InitStruct->I2S_CPOL = I2S_CPOL_Low; +} + +/** + * @brief Initializes the SPIx peripheral according to the specified + * parameters in the I2S_InitStruct. + * @note This mode is not supported for STM32F030 devices. + * @param SPIx: where x can be 1 to select the SPI peripheral (configured in I2S mode). + * @param I2S_InitStruct: pointer to an I2S_InitTypeDef structure that + * contains the configuration information for the specified SPI peripheral + * configured in I2S mode. + * @note This function calculates the optimal prescaler needed to obtain the most + * accurate audio frequency (depending on the I2S clock source, the PLL values + * and the product configuration). But in case the prescaler value is greater + * than 511, the default value (0x02) will be configured instead. + * @retval None + */ +void I2S_Init(SPI_TypeDef* SPIx, I2S_InitTypeDef* I2S_InitStruct) +{ + uint16_t tmpreg = 0, i2sdiv = 2, i2sodd = 0, packetlength = 1; + uint32_t tmp = 0; + RCC_ClocksTypeDef RCC_Clocks; + uint32_t sourceclock = 0; + + /* Check the I2S parameters */ + assert_param(IS_SPI_1_PERIPH(SPIx)); + assert_param(IS_I2S_MODE(I2S_InitStruct->I2S_Mode)); + assert_param(IS_I2S_STANDARD(I2S_InitStruct->I2S_Standard)); + assert_param(IS_I2S_DATA_FORMAT(I2S_InitStruct->I2S_DataFormat)); + assert_param(IS_I2S_MCLK_OUTPUT(I2S_InitStruct->I2S_MCLKOutput)); + assert_param(IS_I2S_AUDIO_FREQ(I2S_InitStruct->I2S_AudioFreq)); + assert_param(IS_I2S_CPOL(I2S_InitStruct->I2S_CPOL)); + +/*----------------------- SPIx I2SCFGR & I2SPR Configuration -----------------*/ + /* Clear I2SMOD, I2SE, I2SCFG, PCMSYNC, I2SSTD, CKPOL, DATLEN and CHLEN bits */ + SPIx->I2SCFGR &= I2SCFGR_CLEAR_Mask; + SPIx->I2SPR = 0x0002; + + /* Get the I2SCFGR register value */ + tmpreg = SPIx->I2SCFGR; + + /* If the default value has to be written, reinitialize i2sdiv and i2sodd*/ + if(I2S_InitStruct->I2S_AudioFreq == I2S_AudioFreq_Default) + { + i2sodd = (uint16_t)0; + i2sdiv = (uint16_t)2; + } + /* If the requested audio frequency is not the default, compute the prescaler */ + else + { + /* Check the frame length (For the Prescaler computing) */ + if(I2S_InitStruct->I2S_DataFormat == I2S_DataFormat_16b) + { + /* Packet length is 16 bits */ + packetlength = 1; + } + else + { + /* Packet length is 32 bits */ + packetlength = 2; + } + + /* I2S Clock source is System clock: Get System Clock frequency */ + RCC_GetClocksFreq(&RCC_Clocks); + + /* Get the source clock value: based on System Clock value */ + sourceclock = RCC_Clocks.SYSCLK_Frequency; + + /* Compute the Real divider depending on the MCLK output state with a floating point */ + if(I2S_InitStruct->I2S_MCLKOutput == I2S_MCLKOutput_Enable) + { + /* MCLK output is enabled */ + tmp = (uint16_t)(((((sourceclock / 256) * 10) / I2S_InitStruct->I2S_AudioFreq)) + 5); + } + else + { + /* MCLK output is disabled */ + tmp = (uint16_t)(((((sourceclock / (32 * packetlength)) *10 ) / I2S_InitStruct->I2S_AudioFreq)) + 5); + } + + /* Remove the floating point */ + tmp = tmp / 10; + + /* Check the parity of the divider */ + i2sodd = (uint16_t)(tmp & (uint16_t)0x0001); + + /* Compute the i2sdiv prescaler */ + i2sdiv = (uint16_t)((tmp - i2sodd) / 2); + + /* Get the Mask for the Odd bit (SPI_I2SPR[8]) register */ + i2sodd = (uint16_t) (i2sodd << 8); + } + + /* Test if the divider is 1 or 0 or greater than 0xFF */ + if ((i2sdiv < 2) || (i2sdiv > 0xFF)) + { + /* Set the default values */ + i2sdiv = 2; + i2sodd = 0; + } + + /* Write to SPIx I2SPR register the computed value */ + SPIx->I2SPR = (uint16_t)(i2sdiv | (uint16_t)(i2sodd | (uint16_t)I2S_InitStruct->I2S_MCLKOutput)); + + /* Configure the I2S with the SPI_InitStruct values */ + tmpreg |= (uint16_t)(SPI_I2SCFGR_I2SMOD | (uint16_t)(I2S_InitStruct->I2S_Mode | \ + (uint16_t)(I2S_InitStruct->I2S_Standard | (uint16_t)(I2S_InitStruct->I2S_DataFormat | \ + (uint16_t)I2S_InitStruct->I2S_CPOL)))); + + /* Write to SPIx I2SCFGR */ + SPIx->I2SCFGR = tmpreg; +} + +/** + * @brief Enables or disables the specified SPI peripheral. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param NewState: new state of the SPIx peripheral. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void SPI_Cmd(SPI_TypeDef* SPIx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected SPI peripheral */ + SPIx->CR1 |= SPI_CR1_SPE; + } + else + { + /* Disable the selected SPI peripheral */ + SPIx->CR1 &= (uint16_t)~((uint16_t)SPI_CR1_SPE); + } +} + +/** + * @brief Enables or disables the TI Mode. + * + * @note This function can be called only after the SPI_Init() function has + * been called. + * @note When TI mode is selected, the control bits SSM, SSI, CPOL and CPHA + * are not taken into consideration and are configured by hardware + * respectively to the TI mode requirements. + * + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param NewState: new state of the selected SPI TI communication mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void SPI_TIModeCmd(SPI_TypeDef* SPIx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the TI mode for the selected SPI peripheral */ + SPIx->CR2 |= SPI_CR2_FRF; + } + else + { + /* Disable the TI mode for the selected SPI peripheral */ + SPIx->CR2 &= (uint16_t)~((uint16_t)SPI_CR2_FRF); + } +} + +/** + * @brief Enables or disables the specified SPI peripheral (in I2S mode). + * @note This mode is not supported for STM32F030 devices. + * @param SPIx: where x can be 1 to select the SPI peripheral. + * @param NewState: new state of the SPIx peripheral. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void I2S_Cmd(SPI_TypeDef* SPIx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_SPI_1_PERIPH(SPIx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + if (NewState != DISABLE) + { + /* Enable the selected SPI peripheral in I2S mode */ + SPIx->I2SCFGR |= SPI_I2SCFGR_I2SE; + } + else + { + /* Disable the selected SPI peripheral in I2S mode */ + SPIx->I2SCFGR &= (uint16_t)~((uint16_t)SPI_I2SCFGR_I2SE); + } +} + +/** + * @brief Configures the data size for the selected SPI. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param SPI_DataSize: specifies the SPI data size. + * For the SPIx peripheral this parameter can be one of the following values: + * @arg SPI_DataSize_4b: Set data size to 4 bits + * @arg SPI_DataSize_5b: Set data size to 5 bits + * @arg SPI_DataSize_6b: Set data size to 6 bits + * @arg SPI_DataSize_7b: Set data size to 7 bits + * @arg SPI_DataSize_8b: Set data size to 8 bits + * @arg SPI_DataSize_9b: Set data size to 9 bits + * @arg SPI_DataSize_10b: Set data size to 10 bits + * @arg SPI_DataSize_11b: Set data size to 11 bits + * @arg SPI_DataSize_12b: Set data size to 12 bits + * @arg SPI_DataSize_13b: Set data size to 13 bits + * @arg SPI_DataSize_14b: Set data size to 14 bits + * @arg SPI_DataSize_15b: Set data size to 15 bits + * @arg SPI_DataSize_16b: Set data size to 16 bits + * @retval None + */ +void SPI_DataSizeConfig(SPI_TypeDef* SPIx, uint16_t SPI_DataSize) +{ + uint16_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_SPI_DATA_SIZE(SPI_DataSize)); + /* Read the CR2 register */ + tmpreg = SPIx->CR2; + /* Clear DS[3:0] bits */ + tmpreg &= (uint16_t)~SPI_CR2_DS; + /* Set new DS[3:0] bits value */ + tmpreg |= SPI_DataSize; + SPIx->CR2 = tmpreg; +} + +/** + * @brief Configures the FIFO reception threshold for the selected SPI. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param SPI_RxFIFOThreshold: specifies the FIFO reception threshold. + * This parameter can be one of the following values: + * @arg SPI_RxFIFOThreshold_HF: RXNE event is generated if the FIFO + * level is greater or equal to 1/2. + * @arg SPI_RxFIFOThreshold_QF: RXNE event is generated if the FIFO + * level is greater or equal to 1/4. + * @retval None + */ +void SPI_RxFIFOThresholdConfig(SPI_TypeDef* SPIx, uint16_t SPI_RxFIFOThreshold) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_SPI_RX_FIFO_THRESHOLD(SPI_RxFIFOThreshold)); + + /* Clear FRXTH bit */ + SPIx->CR2 &= (uint16_t)~((uint16_t)SPI_CR2_FRXTH); + + /* Set new FRXTH bit value */ + SPIx->CR2 |= SPI_RxFIFOThreshold; +} + +/** + * @brief Selects the data transfer direction in bidirectional mode for the specified SPI. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param SPI_Direction: specifies the data transfer direction in bidirectional mode. + * This parameter can be one of the following values: + * @arg SPI_Direction_Tx: Selects Tx transmission direction + * @arg SPI_Direction_Rx: Selects Rx receive direction + * @retval None + */ +void SPI_BiDirectionalLineConfig(SPI_TypeDef* SPIx, uint16_t SPI_Direction) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_SPI_DIRECTION(SPI_Direction)); + if (SPI_Direction == SPI_Direction_Tx) + { + /* Set the Tx only mode */ + SPIx->CR1 |= SPI_Direction_Tx; + } + else + { + /* Set the Rx only mode */ + SPIx->CR1 &= SPI_Direction_Rx; + } +} + +/** + * @brief Configures internally by software the NSS pin for the selected SPI. + * @note This function can be called only after the SPI_Init() function has + * been called. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param SPI_NSSInternalSoft: specifies the SPI NSS internal state. + * This parameter can be one of the following values: + * @arg SPI_NSSInternalSoft_Set: Set NSS pin internally + * @arg SPI_NSSInternalSoft_Reset: Reset NSS pin internally + * @retval None + */ +void SPI_NSSInternalSoftwareConfig(SPI_TypeDef* SPIx, uint16_t SPI_NSSInternalSoft) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_SPI_NSS_INTERNAL(SPI_NSSInternalSoft)); + + if (SPI_NSSInternalSoft != SPI_NSSInternalSoft_Reset) + { + /* Set NSS pin internally by software */ + SPIx->CR1 |= SPI_NSSInternalSoft_Set; + } + else + { + /* Reset NSS pin internally by software */ + SPIx->CR1 &= SPI_NSSInternalSoft_Reset; + } +} + +/** + * @brief Enables or disables the SS output for the selected SPI. + * @note This function can be called only after the SPI_Init() function has + * been called and the NSS hardware management mode is selected. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param NewState: new state of the SPIx SS output. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void SPI_SSOutputCmd(SPI_TypeDef* SPIx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + if (NewState != DISABLE) + { + /* Enable the selected SPI SS output */ + SPIx->CR2 |= SPI_CR2_SSOE; + } + else + { + /* Disable the selected SPI SS output */ + SPIx->CR2 &= (uint16_t)~((uint16_t)SPI_CR2_SSOE); + } +} + +/** + * @brief Enables or disables the NSS pulse management mode. + * @note This function can be called only after the SPI_Init() function has + * been called. + * @note When TI mode is selected, the control bits NSSP is not taken into + * consideration and are configured by hardware respectively to the + * TI mode requirements. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param NewState: new state of the NSS pulse management mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void SPI_NSSPulseModeCmd(SPI_TypeDef* SPIx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the NSS pulse management mode */ + SPIx->CR2 |= SPI_CR2_NSSP; + } + else + { + /* Disable the NSS pulse management mode */ + SPIx->CR2 &= (uint16_t)~((uint16_t)SPI_CR2_NSSP); + } +} + +/** + * @} + */ + +/** @defgroup SPI_Group2 Data transfers functions + * @brief Data transfers functions + * +@verbatim + =============================================================================== + ##### Data transfers functions ##### + =============================================================================== + [..] This section provides a set of functions allowing to manage the SPI or I2S + data transfers. + + [..] In reception, data are received and then stored into an internal Rx buffer while + In transmission, data are first stored into an internal Tx buffer before being + transmitted. + + [..] The read access of the SPI_DR register can be done using + SPI_ReceiveData8() (when data size is equal or inferior than 8bits) and. + SPI_I2S_ReceiveData16() (when data size is superior than 8bits)function + and returns the Rx buffered value. Whereas a write access to the SPI_DR + can be done using SPI_SendData8() (when data size is equal or inferior than 8bits) + and SPI_I2S_SendData16() (when data size is superior than 8bits) function + and stores the written data into Tx buffer. + +@endverbatim + * @{ + */ + +/** + * @brief Transmits a Data through the SPIx/I2Sx peripheral. + * @param SPIx: where x can be 1 or 2 in SPI mode to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param Data: Data to be transmitted. + * @retval None + */ +void SPI_SendData8(SPI_TypeDef* SPIx, uint8_t Data) +{ + uint32_t spixbase = 0x00; + + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + + spixbase = (uint32_t)SPIx; + spixbase += 0x0C; + + *(__IO uint8_t *) spixbase = Data; +} + +/** + * @brief Transmits a Data through the SPIx/I2Sx peripheral. + * @param SPIx: where x can be 1 or 2 in SPI mode or 1 in I2S mode to select + * the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param Data: Data to be transmitted. + * @retval None + */ +void SPI_I2S_SendData16(SPI_TypeDef* SPIx, uint16_t Data) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + + SPIx->DR = (uint16_t)Data; +} + +/** + * @brief Returns the most recent received data by the SPIx/I2Sx peripheral. + * @param SPIx: where x can be 1 or 2 in SPI mode to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @retval The value of the received data. + */ +uint8_t SPI_ReceiveData8(SPI_TypeDef* SPIx) +{ + uint32_t spixbase = 0x00; + + spixbase = (uint32_t)SPIx; + spixbase += 0x0C; + + return *(__IO uint8_t *) spixbase; +} + +/** + * @brief Returns the most recent received data by the SPIx peripheral. + * @param SPIx: where x can be 1 or 2 in SPI mode or 1 in I2S mode to select + * @note SPI2 is not available for STM32F031 devices. + * the SPI peripheral. + * @retval The value of the received data. + */ +uint16_t SPI_I2S_ReceiveData16(SPI_TypeDef* SPIx) +{ + return SPIx->DR; +} +/** + * @} + */ + +/** @defgroup SPI_Group3 Hardware CRC Calculation functions + * @brief Hardware CRC Calculation functions + * +@verbatim + =============================================================================== + ##### Hardware CRC Calculation functions ##### + =============================================================================== + [..] This section provides a set of functions allowing to manage the SPI CRC hardware + calculation.SPI communication using CRC is possible through the following procedure: + + (#) Program the Data direction, Polarity, Phase, First Data, Baud Rate Prescaler, + Slave Management, Peripheral Mode and CRC Polynomial values using the SPI_Init() + function. + (#) Enable the CRC calculation using the SPI_CalculateCRC() function. + (#) Enable the SPI using the SPI_Cmd() function + (#) Before writing the last data to the TX buffer, set the CRCNext bit using the + SPI_TransmitCRC() function to indicate that after transmission of the last + data, the CRC should be transmitted. + (#) After transmitting the last data, the SPI transmits the CRC. The SPI_CR1_CRCNEXT + bit is reset. The CRC is also received and compared against the SPI_RXCRCR + value. + If the value does not match, the SPI_FLAG_CRCERR flag is set and an interrupt + can be generated when the SPI_I2S_IT_ERR interrupt is enabled. + + -@- + (+@) It is advised to don't read the calculate CRC values during the communication. + (+@) When the SPI is in slave mode, be careful to enable CRC calculation only + when the clock is stable, that is, when the clock is in the steady state. + If not, a wrong CRC calculation may be done. In fact, the CRC is sensitive + to the SCK slave input clock as soon as CRCEN is set, and this, whatever + the value of the SPE bit. + (+@) With high bitrate frequencies, be careful when transmitting the CRC. + As the number of used CPU cycles has to be as low as possible in the CRC + transfer phase, it is forbidden to call software functions in the CRC + transmission sequence to avoid errors in the last data and CRC reception. + In fact, CRCNEXT bit has to be written before the end of the transmission/reception + of the last data. + (+@) For high bit rate frequencies, it is advised to use the DMA mode to avoid the + degradation of the SPI speed performance due to CPU accesses impacting the + SPI bandwidth. + (+@) When the STM32F0xx are configured as slaves and the NSS hardware mode is + used, the NSS pin needs to be kept low between the data phase and the CRC + phase. + (+@) When the SPI is configured in slave mode with the CRC feature enabled, CRC + calculation takes place even if a high level is applied on the NSS pin. + This may happen for example in case of a multislave environment where the + communication master addresses slaves alternately. + (+@) Between a slave deselection (high level on NSS) and a new slave selection + (low level on NSS), the CRC value should be cleared on both master and slave + sides in order to resynchronize the master and slave for their respective + CRC calculation. + + -@- To clear the CRC, follow the procedure below: + (#@) Disable SPI using the SPI_Cmd() function + (#@) Disable the CRC calculation using the SPI_CalculateCRC() function. + (#@) Enable the CRC calculation using the SPI_CalculateCRC() function. + (#@) Enable SPI using the SPI_Cmd() function. + +@endverbatim + * @{ + */ + +/** + * @brief Configures the CRC calculation length for the selected SPI. + * @note This function can be called only after the SPI_Init() function has + * been called. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param SPI_CRCLength: specifies the SPI CRC calculation length. + * This parameter can be one of the following values: + * @arg SPI_CRCLength_8b: Set CRC Calculation to 8 bits + * @arg SPI_CRCLength_16b: Set CRC Calculation to 16 bits + * @retval None + */ +void SPI_CRCLengthConfig(SPI_TypeDef* SPIx, uint16_t SPI_CRCLength) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_SPI_CRC_LENGTH(SPI_CRCLength)); + + /* Clear CRCL bit */ + SPIx->CR1 &= (uint16_t)~((uint16_t)SPI_CR1_CRCL); + + /* Set new CRCL bit value */ + SPIx->CR1 |= SPI_CRCLength; +} + +/** + * @brief Enables or disables the CRC value calculation of the transferred bytes. + * @note This function can be called only after the SPI_Init() function has + * been called. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param NewState: new state of the SPIx CRC value calculation. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void SPI_CalculateCRC(SPI_TypeDef* SPIx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected SPI CRC calculation */ + SPIx->CR1 |= SPI_CR1_CRCEN; + } + else + { + /* Disable the selected SPI CRC calculation */ + SPIx->CR1 &= (uint16_t)~((uint16_t)SPI_CR1_CRCEN); + } +} + +/** + * @brief Transmit the SPIx CRC value. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @retval None + */ +void SPI_TransmitCRC(SPI_TypeDef* SPIx) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + + /* Enable the selected SPI CRC transmission */ + SPIx->CR1 |= SPI_CR1_CRCNEXT; +} + +/** + * @brief Returns the transmit or the receive CRC register value for the specified SPI. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param SPI_CRC: specifies the CRC register to be read. + * This parameter can be one of the following values: + * @arg SPI_CRC_Tx: Selects Tx CRC register + * @arg SPI_CRC_Rx: Selects Rx CRC register + * @retval The selected CRC register value.. + */ +uint16_t SPI_GetCRC(SPI_TypeDef* SPIx, uint8_t SPI_CRC) +{ + uint16_t crcreg = 0; + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_SPI_CRC(SPI_CRC)); + + if (SPI_CRC != SPI_CRC_Rx) + { + /* Get the Tx CRC register */ + crcreg = SPIx->TXCRCR; + } + else + { + /* Get the Rx CRC register */ + crcreg = SPIx->RXCRCR; + } + /* Return the selected CRC register */ + return crcreg; +} + +/** + * @brief Returns the CRC Polynomial register value for the specified SPI. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @retval The CRC Polynomial register value. + */ +uint16_t SPI_GetCRCPolynomial(SPI_TypeDef* SPIx) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + + /* Return the CRC polynomial register */ + return SPIx->CRCPR; +} + +/** + * @} + */ + +/** @defgroup SPI_Group4 DMA transfers management functions + * @brief DMA transfers management functions + * +@verbatim + =============================================================================== + ##### DMA transfers management functions ##### + =============================================================================== + [..] This section provides two functions that can be used only in DMA mode. + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the SPIx/I2Sx DMA interface. + * @param SPIx: where x can be 1 or 2 in SPI mode or 1 in I2S mode to select + * the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * I2S mode is not supported for STM32F030 devices. + * @param SPI_I2S_DMAReq: specifies the SPI DMA transfer request to be enabled or disabled. + * This parameter can be any combination of the following values: + * @arg SPI_I2S_DMAReq_Tx: Tx buffer DMA transfer request + * @arg SPI_I2S_DMAReq_Rx: Rx buffer DMA transfer request + * @param NewState: new state of the selected SPI DMA transfer request. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void SPI_I2S_DMACmd(SPI_TypeDef* SPIx, uint16_t SPI_I2S_DMAReq, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + assert_param(IS_SPI_I2S_DMA_REQ(SPI_I2S_DMAReq)); + + if (NewState != DISABLE) + { + /* Enable the selected SPI DMA requests */ + SPIx->CR2 |= SPI_I2S_DMAReq; + } + else + { + /* Disable the selected SPI DMA requests */ + SPIx->CR2 &= (uint16_t)~SPI_I2S_DMAReq; + } +} + +/** + * @brief Configures the number of data to transfer type(Even/Odd) for the DMA + * last transfers and for the selected SPI. + * @note This function have a meaning only if DMA mode is selected and if + * the packing mode is used (data length <= 8 and DMA transfer size halfword) + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @param SPI_LastDMATransfer: specifies the SPI last DMA transfers state. + * This parameter can be one of the following values: + * @arg SPI_LastDMATransfer_TxEvenRxEven: Number of data for transmission Even + * and number of data for reception Even. + * @arg SPI_LastDMATransfer_TxOddRxEven: Number of data for transmission Odd + * and number of data for reception Even. + * @arg SPI_LastDMATransfer_TxEvenRxOdd: Number of data for transmission Even + * and number of data for reception Odd. + * @arg SPI_LastDMATransfer_TxOddRxOdd: Number of data for transmission Odd + * and number of data for reception Odd. + * @retval None + */ +void SPI_LastDMATransferCmd(SPI_TypeDef* SPIx, uint16_t SPI_LastDMATransfer) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_SPI_LAST_DMA_TRANSFER(SPI_LastDMATransfer)); + + /* Clear LDMA_TX and LDMA_RX bits */ + SPIx->CR2 &= CR2_LDMA_MASK; + + /* Set new LDMA_TX and LDMA_RX bits value */ + SPIx->CR2 |= SPI_LastDMATransfer; +} + +/** + * @} + */ + +/** @defgroup SPI_Group5 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== + [..] This section provides a set of functions allowing to configure the SPI/I2S Interrupts + sources and check or clear the flags or pending bits status. + The user should identify which mode will be used in his application to manage + the communication: Polling mode, Interrupt mode or DMA mode. + + *** Polling Mode *** + ==================== + [..] In Polling Mode, the SPI/I2S communication can be managed by 9 flags: + (#) SPI_I2S_FLAG_TXE : to indicate the status of the transmit buffer register + (#) SPI_I2S_FLAG_RXNE : to indicate the status of the receive buffer register + (#) SPI_I2S_FLAG_BSY : to indicate the state of the communication layer of the SPI. + (#) SPI_FLAG_CRCERR : to indicate if a CRC Calculation error occur + (#) SPI_FLAG_MODF : to indicate if a Mode Fault error occur + (#) SPI_I2S_FLAG_OVR : to indicate if an Overrun error occur + (#) SPI_I2S_FLAG_FRE: to indicate a Frame Format error occurs. + (#) I2S_FLAG_UDR: to indicate an Underrun error occurs. + (#) I2S_FLAG_CHSIDE: to indicate Channel Side. + + [..] + (@)Do not use the BSY flag to handle each data transmission or reception. It is better + to use the TXE and RXNE flags instead. + + [..] In this Mode it is advised to use the following functions: + (+) FlagStatus SPI_I2S_GetFlagStatus(SPI_TypeDef* SPIx, uint16_t SPI_I2S_FLAG); + (+) void SPI_I2S_ClearFlag(SPI_TypeDef* SPIx, uint16_t SPI_I2S_FLAG); + + *** Interrupt Mode *** + ====================== + [..] In Interrupt Mode, the SPI/I2S communication can be managed by 3 interrupt sources + and 5 pending bits: + [..] Pending Bits: + (#) SPI_I2S_IT_TXE : to indicate the status of the transmit buffer register + (#) SPI_I2S_IT_RXNE : to indicate the status of the receive buffer register + (#) SPI_I2S_IT_OVR : to indicate if an Overrun error occur + (#) I2S_IT_UDR : to indicate an Underrun Error occurs. + (#) SPI_I2S_FLAG_FRE : to indicate a Frame Format error occurs. + + [..] Interrupt Source: + (#) SPI_I2S_IT_TXE: specifies the interrupt source for the Tx buffer empty + interrupt. + (#) SPI_I2S_IT_RXNE : specifies the interrupt source for the Rx buffer not + empty interrupt. + (#) SPI_I2S_IT_ERR : specifies the interrupt source for the errors interrupt. + + [..] In this Mode it is advised to use the following functions: + (+) void SPI_I2S_ITConfig(SPI_TypeDef* SPIx, uint8_t SPI_I2S_IT, FunctionalState NewState); + (+) ITStatus SPI_I2S_GetITStatus(SPI_TypeDef* SPIx, uint8_t SPI_I2S_IT); + + *** FIFO Status *** + =================== + [..] It is possible to monitor the FIFO status when a transfer is ongoing using the + following function: + (+) uint32_t SPI_GetFIFOStatus(uint8_t SPI_FIFO_Direction); + + *** DMA Mode *** + ================ + [..] In DMA Mode, the SPI communication can be managed by 2 DMA Channel + requests: + (#) SPI_I2S_DMAReq_Tx: specifies the Tx buffer DMA transfer request. + (#) SPI_I2S_DMAReq_Rx: specifies the Rx buffer DMA transfer request. + + [..] In this Mode it is advised to use the following function: + (+) void SPI_I2S_DMACmd(SPI_TypeDef* SPIx, uint16_t SPI_I2S_DMAReq, FunctionalState NewState). + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified SPI/I2S interrupts. + * @param SPIx: where x can be 1 or 2 in SPI mode or 1 in I2S mode to select + * the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * I2S mode is not supported for STM32F030 devices. + * @param SPI_I2S_IT: specifies the SPI interrupt source to be enabled or disabled. + * This parameter can be one of the following values: + * @arg SPI_I2S_IT_TXE: Tx buffer empty interrupt mask + * @arg SPI_I2S_IT_RXNE: Rx buffer not empty interrupt mask + * @arg SPI_I2S_IT_ERR: Error interrupt mask + * @param NewState: new state of the specified SPI interrupt. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void SPI_I2S_ITConfig(SPI_TypeDef* SPIx, uint8_t SPI_I2S_IT, FunctionalState NewState) +{ + uint16_t itpos = 0, itmask = 0 ; + + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + assert_param(IS_SPI_I2S_CONFIG_IT(SPI_I2S_IT)); + + /* Get the SPI IT index */ + itpos = SPI_I2S_IT >> 4; + + /* Set the IT mask */ + itmask = (uint16_t)1 << (uint16_t)itpos; + + if (NewState != DISABLE) + { + /* Enable the selected SPI interrupt */ + SPIx->CR2 |= itmask; + } + else + { + /* Disable the selected SPI interrupt */ + SPIx->CR2 &= (uint16_t)~itmask; + } +} + +/** + * @brief Returns the current SPIx Transmission FIFO filled level. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @retval The Transmission FIFO filling state. + * - SPI_TransmissionFIFOStatus_Empty: when FIFO is empty + * - SPI_TransmissionFIFOStatus_1QuarterFull: if more than 1 quarter-full. + * - SPI_TransmissionFIFOStatus_HalfFull: if more than 1 half-full. + * - SPI_TransmissionFIFOStatus_Full: when FIFO is full. + */ +uint16_t SPI_GetTransmissionFIFOStatus(SPI_TypeDef* SPIx) +{ + /* Get the SPIx Transmission FIFO level bits */ + return (uint16_t)((SPIx->SR & SPI_SR_FTLVL)); +} + +/** + * @brief Returns the current SPIx Reception FIFO filled level. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * @retval The Reception FIFO filling state. + * - SPI_ReceptionFIFOStatus_Empty: when FIFO is empty + * - SPI_ReceptionFIFOStatus_1QuarterFull: if more than 1 quarter-full. + * - SPI_ReceptionFIFOStatus_HalfFull: if more than 1 half-full. + * - SPI_ReceptionFIFOStatus_Full: when FIFO is full. + */ +uint16_t SPI_GetReceptionFIFOStatus(SPI_TypeDef* SPIx) +{ + /* Get the SPIx Reception FIFO level bits */ + return (uint16_t)((SPIx->SR & SPI_SR_FRLVL)); +} + +/** + * @brief Checks whether the specified SPI flag is set or not. + * @param SPIx: where x can be 1 or 2 in SPI mode or 1 in I2S mode to select + * the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * I2S mode is not supported for STM32F030 devices. + * @param SPI_I2S_FLAG: specifies the SPI flag to check. + * This parameter can be one of the following values: + * @arg SPI_I2S_FLAG_TXE: Transmit buffer empty flag. + * @arg SPI_I2S_FLAG_RXNE: Receive buffer not empty flag. + * @arg SPI_I2S_FLAG_BSY: Busy flag. + * @arg SPI_I2S_FLAG_OVR: Overrun flag. + * @arg SPI_FLAG_MODF: Mode Fault flag. + * @arg SPI_FLAG_CRCERR: CRC Error flag. + * @arg SPI_I2S_FLAG_FRE: TI frame format error flag. + * @arg I2S_FLAG_UDR: Underrun Error flag. + * @arg I2S_FLAG_CHSIDE: Channel Side flag. + * @retval The new state of SPI_I2S_FLAG (SET or RESET). + */ +FlagStatus SPI_I2S_GetFlagStatus(SPI_TypeDef* SPIx, uint16_t SPI_I2S_FLAG) +{ + FlagStatus bitstatus = RESET; + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_SPI_I2S_GET_FLAG(SPI_I2S_FLAG)); + + /* Check the status of the specified SPI flag */ + if ((SPIx->SR & SPI_I2S_FLAG) != (uint16_t)RESET) + { + /* SPI_I2S_FLAG is set */ + bitstatus = SET; + } + else + { + /* SPI_I2S_FLAG is reset */ + bitstatus = RESET; + } + /* Return the SPI_I2S_FLAG status */ + return bitstatus; +} + +/** + * @brief Clears the SPIx CRC Error (CRCERR) flag. + * @param SPIx: where x can be 1 or 2 to select the SPI peripheral. + * @note SPI2 is not available for STM32F031 devices. + * I2S mode is not supported for STM32F030 devices. + * @param SPI_I2S_FLAG: specifies the SPI flag to clear. + * This function clears only CRCERR flag. + * @note OVR (OverRun error) flag is cleared by software sequence: a read + * operation to SPI_DR register (SPI_I2S_ReceiveData()) followed by + * a read operation to SPI_SR register (SPI_I2S_GetFlagStatus()). + * @note MODF (Mode Fault) flag is cleared by software sequence: a read/write + * operation to SPI_SR register (SPI_I2S_GetFlagStatus()) followed by + * a write operation to SPI_CR1 register (SPI_Cmd() to enable the SPI). + * @retval None + */ +void SPI_I2S_ClearFlag(SPI_TypeDef* SPIx, uint16_t SPI_I2S_FLAG) +{ + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_SPI_CLEAR_FLAG(SPI_I2S_FLAG)); + + /* Clear the selected SPI CRC Error (CRCERR) flag */ + SPIx->SR = (uint16_t)~SPI_I2S_FLAG; +} + +/** + * @brief Checks whether the specified SPI/I2S interrupt has occurred or not. + * @param SPIx: where x can be 1 or 2 in SPI mode or 1 in I2S mode to select + * the SPI peripheral. + * @param SPI_I2S_IT: specifies the SPI interrupt source to check. + * This parameter can be one of the following values: + * @arg SPI_I2S_IT_TXE: Transmit buffer empty interrupt. + * @arg SPI_I2S_IT_RXNE: Receive buffer not empty interrupt. + * @arg SPI_IT_MODF: Mode Fault interrupt. + * @arg SPI_I2S_IT_OVR: Overrun interrupt. + * @arg I2S_IT_UDR: Underrun interrupt. + * @arg SPI_I2S_IT_FRE: Format Error interrupt. + * @retval The new state of SPI_I2S_IT (SET or RESET). + */ +ITStatus SPI_I2S_GetITStatus(SPI_TypeDef* SPIx, uint8_t SPI_I2S_IT) +{ + ITStatus bitstatus = RESET; + uint16_t itpos = 0, itmask = 0, enablestatus = 0; + + /* Check the parameters */ + assert_param(IS_SPI_ALL_PERIPH(SPIx)); + assert_param(IS_SPI_I2S_GET_IT(SPI_I2S_IT)); + + /* Get the SPI_I2S_IT index */ + itpos = 0x01 << (SPI_I2S_IT & 0x0F); + + /* Get the SPI_I2S_IT IT mask */ + itmask = SPI_I2S_IT >> 4; + + /* Set the IT mask */ + itmask = 0x01 << itmask; + + /* Get the SPI_I2S_IT enable bit status */ + enablestatus = (SPIx->CR2 & itmask) ; + + /* Check the status of the specified SPI interrupt */ + if (((SPIx->SR & itpos) != (uint16_t)RESET) && enablestatus) + { + /* SPI_I2S_IT is set */ + bitstatus = SET; + } + else + { + /* SPI_I2S_IT is reset */ + bitstatus = RESET; + } + /* Return the SPI_I2S_IT status */ + return bitstatus; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_syscfg.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_syscfg.c new file mode 100644 index 00000000..64a5cf32 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_syscfg.c @@ -0,0 +1,420 @@ +/** + ****************************************************************************** + * @file stm32f0xx_syscfg.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the SYSCFG peripheral: + * + Remapping the memory mapped at 0x00000000 + * + Remapping the DMA channels + * + Enabling I2C fast mode plus driving capability for I2C pins + * + Configuring the EXTI lines connection to the GPIO port + * + Configuring the CFGR2 features (Connecting some internal signal + * to the break input of TIM1) + * + * @verbatim + =============================================================================== + ##### How to use this driver ##### + =============================================================================== + [..] + The SYSCFG registers can be accessed only when the SYSCFG + interface APB clock is enabled. + To enable SYSCFG APB clock use: + RCC_APBPeriphClockCmd(RCC_APBPeriph_SYSCFG, ENABLE). + * @endverbatim + * + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_syscfg.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup SYSCFG + * @brief SYSCFG driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup SYSCFG_Private_Functions + * @{ + */ + +/** @defgroup SYSCFG_Group1 SYSCFG Initialization and Configuration functions + * @brief SYSCFG Initialization and Configuration functions + * +@verbatim + =============================================================================== + ##### SYSCFG Initialization and Configuration functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the SYSCFG registers to their default reset values. + * @param None + * @retval None + * @note MEM_MODE bits are not affected by APB reset. + * @note MEM_MODE bits took the value from the user option bytes. + * @note CFGR2 register is not affected by APB reset. + * @note CLABBB configuration bits are locked when set. + * @note To unlock the configuration, perform a system reset. + */ +void SYSCFG_DeInit(void) +{ + /* Set SYSCFG_CFGR1 register to reset value without affecting MEM_MODE bits */ + SYSCFG->CFGR1 &= SYSCFG_CFGR1_MEM_MODE; + /* Set EXTICRx registers to reset value */ + SYSCFG->EXTICR[0] = 0; + SYSCFG->EXTICR[1] = 0; + SYSCFG->EXTICR[2] = 0; + SYSCFG->EXTICR[3] = 0; + /* Set CFGR2 register to reset value: clear SRAM parity error flag */ + SYSCFG->CFGR2 |= (uint32_t) SYSCFG_CFGR2_SRAM_PE; +} + +/** + * @brief Configures the memory mapping at address 0x00000000. + * @param SYSCFG_MemoryRemap: selects the memory remapping. + * This parameter can be one of the following values: + * @arg SYSCFG_MemoryRemap_Flash: Main Flash memory mapped at 0x00000000 + * @arg SYSCFG_MemoryRemap_SystemMemory: System Flash memory mapped at 0x00000000 + * @arg SYSCFG_MemoryRemap_SRAM: Embedded SRAM mapped at 0x00000000 + * @retval None + */ +void SYSCFG_MemoryRemapConfig(uint32_t SYSCFG_MemoryRemap) +{ + uint32_t tmpctrl = 0; + + /* Check the parameter */ + assert_param(IS_SYSCFG_MEMORY_REMAP(SYSCFG_MemoryRemap)); + + /* Get CFGR1 register value */ + tmpctrl = SYSCFG->CFGR1; + + /* Clear MEM_MODE bits */ + tmpctrl &= (uint32_t) (~SYSCFG_CFGR1_MEM_MODE); + + /* Set the new MEM_MODE bits value */ + tmpctrl |= (uint32_t) SYSCFG_MemoryRemap; + + /* Set CFGR1 register with the new memory remap configuration */ + SYSCFG->CFGR1 = tmpctrl; +} + +/** + * @brief Configure the DMA channels remapping. + * @param SYSCFG_DMARemap: selects the DMA channels remap. + * This parameter can be one of the following values: + * @arg SYSCFG_DMARemap_TIM17: Remap TIM17 DMA requests from channel1 to channel2 + * @arg SYSCFG_DMARemap_TIM16: Remap TIM16 DMA requests from channel3 to channel4 + * @arg SYSCFG_DMARemap_USART1Rx: Remap USART1 Rx DMA requests from channel3 to channel5 + * @arg SYSCFG_DMARemap_USART1Tx: Remap USART1 Tx DMA requests from channel2 to channel4 + * @arg SYSCFG_DMARemap_ADC1: Remap ADC1 DMA requests from channel1 to channel2 + * @param NewState: new state of the DMA channel remapping. + * This parameter can be: ENABLE or DISABLE. + * @note When enabled, DMA channel of the selected peripheral is remapped + * @note When disabled, Default DMA channel is mapped to the selected peripheral + * @note By default TIM17 DMA requests is mapped to channel 1, + * use SYSCFG_DMAChannelRemapConfig(SYSCFG_DMARemap_TIM17, Enable) to remap + * TIM17 DMA requests to channel 2 and use + * SYSCFG_DMAChannelRemapConfig(SYSCFG_DMARemap_TIM17, Disable) to map + * TIM17 DMA requests to channel 1 (default mapping) + * @note This function is only used for STM32F030, STM32F031, STM32F042, STM32F072 and STM32F051 devices. + * @retval None + */ +void SYSCFG_DMAChannelRemapConfig(uint32_t SYSCFG_DMARemap, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_SYSCFG_DMA_REMAP(SYSCFG_DMARemap)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Remap the DMA channel */ + SYSCFG->CFGR1 |= (uint32_t)SYSCFG_DMARemap; + } + else + { + /* use the default DMA channel mapping */ + SYSCFG->CFGR1 &= (uint32_t)(~SYSCFG_DMARemap); + } +} + +/** + * @brief Configure the I2C fast mode plus driving capability. + * @param SYSCFG_I2CFastModePlus: selects the pin. + * This parameter can be one of the following values: + * @arg SYSCFG_I2CFastModePlus_PB6: Configure fast mode plus driving capability for PB6 + * @arg SYSCFG_I2CFastModePlus_PB7: Configure fast mode plus driving capability for PB7 + * @arg SYSCFG_I2CFastModePlus_PB8: Configure fast mode plus driving capability for PB8 + * @arg SYSCFG_I2CFastModePlus_PB9: Configure fast mode plus driving capability for PB9 + * @arg SYSCFG_I2CFastModePlus_PA9: Configure fast mode plus driving capability for PA9 (only for STM32F031 and STM32F030 devices) + * @arg SYSCFG_I2CFastModePlus_PA10: Configure fast mode plus driving capability for PA10 (only for STM32F031 and STM32F030 devices) + * @arg SYSCFG_I2CFastModePlus_I2C1: Configure fast mode plus driving capability for PB10, PB11, PF6 and PF7(only for STM32F031 and STM32F030 devices) + * @arg SYSCFG_I2CFastModePlus_I2C2: Configure fast mode plus driving capability for I2C2 pins, available only for STM32F072 devices + * + * @param NewState: new state of the DMA channel remapping. + * This parameter can be: ENABLE or DISABLE. + * @note ENABLE: Enable fast mode plus driving capability for selected I2C pin + * @note DISABLE: Disable fast mode plus driving capability for selected I2C pin + * @note For I2C1, fast mode plus driving capability can be enabled on all selected + * I2C1 pins using SYSCFG_I2CFastModePlus_I2C1 parameter or independently + * on each one of the following pins PB6, PB7, PB8 and PB9. + * @note For remaining I2C1 pins (PA14, PA15...) fast mode plus driving capability + * can be enabled only by using SYSCFG_I2CFastModePlus_I2C1 parameter. + * @note For all I2C2 pins fast mode plus driving capability can be enabled + * only by using SYSCFG_I2CFastModePlus_I2C2 parameter. + * @retval None + */ +void SYSCFG_I2CFastModePlusConfig(uint32_t SYSCFG_I2CFastModePlus, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_SYSCFG_I2C_FMP(SYSCFG_I2CFastModePlus)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable fast mode plus driving capability for selected pin */ + SYSCFG->CFGR1 |= (uint32_t)SYSCFG_I2CFastModePlus; + } + else + { + /* Disable fast mode plus driving capability for selected pin */ + SYSCFG->CFGR1 &= (uint32_t)(~SYSCFG_I2CFastModePlus); + } +} + +/** @brief select the modulation envelope source + * @param SYSCFG_IRDAEnv: select the envelope source. + * This parameter can be a value + * @arg SYSCFG_IRDA_ENV_SEL_TIM16 + * @arg SYSCFG_IRDA_ENV_SEL_USART1 + * @arg SYSCFG_IRDA_ENV_SEL_USART4 + * @retval None + */ +void SYSCFG_IRDAEnvSelection(uint32_t SYSCFG_IRDAEnv) +{ + /* Check the parameters */ + assert_param(IS_SYSCFG_IRDA_ENV(SYSCFG_IRDAEnv)); + + SYSCFG->CFGR1 &= ~(SYSCFG_CFGR1_IRDA_ENV_SEL); + SYSCFG->CFGR1 |= (SYSCFG_IRDAEnv); +} + +/** + * @brief Selects the GPIO pin used as EXTI Line. + * @param EXTI_PortSourceGPIOx: selects the GPIO port to be used as source + * for EXTI lines where x can be (A, B, C, D, E or F). + * @note GPIOE is available only for STM32F072. + * @note GPIOD is not available for STM32F031. + * @param EXTI_PinSourcex: specifies the EXTI line to be configured. + * @note This parameter can be EXTI_PinSourcex where x can be: + * For STM32F051 and STM32F030: (0..15) for GPIOA, GPIOB, GPIOC, (2) for GPIOD and (0..1, 4..7) for GIIOF. + * For STM32F072: (0..15) for GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, (0..10) for GPIOF. + * For STM32F031: (0..15) for GPIOA, GPIOB, (13..15) for GPIOC and (0..1, 6..7) for GPIOF. + * @retval None + */ +void SYSCFG_EXTILineConfig(uint8_t EXTI_PortSourceGPIOx, uint8_t EXTI_PinSourcex) +{ + uint32_t tmp = 0x00; + + /* Check the parameters */ + assert_param(IS_EXTI_PORT_SOURCE(EXTI_PortSourceGPIOx)); + assert_param(IS_EXTI_PIN_SOURCE(EXTI_PinSourcex)); + + tmp = ((uint32_t)0x0F) << (0x04 * (EXTI_PinSourcex & (uint8_t)0x03)); + SYSCFG->EXTICR[EXTI_PinSourcex >> 0x02] &= ~tmp; + SYSCFG->EXTICR[EXTI_PinSourcex >> 0x02] |= (((uint32_t)EXTI_PortSourceGPIOx) << (0x04 * (EXTI_PinSourcex & (uint8_t)0x03))); +} + +/** + * @brief check ISR wrapper: Allow to determine interrupt source per line . + * @param IT_Source: specifies the interrupt source to check. + * This parameter can be one of the following values: + * @arg ITLINE_EWDG EWDG has expired + * @arg ITLINE_PVDOUT Power voltage detection Interrupt + * @arg ITLINE_VDDIO2 VDDIO2 Interrupt + * @arg ITLINE_RTC_WAKEUP RTC WAKEUP -> exti[20] Interrupt + * @arg ITLINE_RTC_TSTAMP RTC Time Stamp -> exti[19] interrupt + * @arg ITLINE_RTC_ALRA RTC Alarm -> exti[17] interrupt + * @arg ITLINE_FLASH_ITF Flash ITF Interrupt + * @arg ITLINE_CRS CRS Interrupt + * @arg ITLINE_CLK_CTRL CLK Control Interrupt + * @arg ITLINE_EXTI0 External Interrupt 0 + * @arg ITLINE_EXTI1 External Interrupt 1 + * @arg ITLINE_EXTI2 External Interrupt 2 + * @arg ITLINE_EXTI3 External Interrupt 3 + * @arg ITLINE_EXTI4 External Interrupt 4 + * @arg ITLINE_EXTI5 External Interrupt 5 + * @arg ITLINE_EXTI6 External Interrupt 6 + * @arg ITLINE_EXTI7 External Interrupt 7 + * @arg ITLINE_EXTI8 External Interrupt 8 + * @arg ITLINE_EXTI9 External Interrupt 9 + * @arg ITLINE_EXTI10 External Interrupt 10 + * @arg ITLINE_EXTI11 External Interrupt 11 + * @arg ITLINE_EXTI12 External Interrupt 12 + * @arg ITLINE_EXTI13 External Interrupt 13 + * @arg ITLINE_EXTI14 External Interrupt 14 + * @arg ITLINE_EXTI15 External Interrupt 15 + * @arg ITLINE_TSC_EOA Touch control EOA Interrupt + * @arg ITLINE_TSC_MCE Touch control MCE Interrupt + * @arg ITLINE_DMA1_CH1 DMA1 Channel 1 Interrupt + * @arg ITLINE_DMA1_CH2 DMA1 Channel 2 Interrupt + * @arg ITLINE_DMA1_CH3 DMA1 Channel 3 Interrupt + * @arg ITLINE_DMA2_CH1 DMA2 Channel 1 Interrupt + * @arg ITLINE_DMA2_CH2 DMA2 Channel 2 Interrupt + * @arg ITLINE_DMA1_CH4 DMA1 Channel 4 Interrupt + * @arg ITLINE_DMA1_CH5 DMA1 Channel 5 Interrupt + * @arg ITLINE_DMA1_CH6 DMA1 Channel 6 Interrupt + * @arg ITLINE_DMA1_CH7 DMA1 Channel 7 Interrupt + * @arg ITLINE_DMA2_CH3 DMA2 Channel 3 Interrupt + * @arg ITLINE_DMA2_CH4 DMA2 Channel 4 Interrupt + * @arg ITLINE_DMA2_CH5 DMA2 Channel 5 Interrupt + * @arg ITLINE_ADC ADC Interrupt + * @arg ITLINE_COMP1 COMP1 Interrupt -> exti[21] + * @arg ITLINE_COMP2 COMP2 Interrupt -> exti[21] + * @arg ITLINE_TIM1_BRK TIM1 BRK Interrupt + * @arg ITLINE_TIM1_UPD TIM1 UPD Interrupt + * @arg ITLINE_TIM1_TRG TIM1 TRG Interrupt + * @arg ITLINE_TIM1_CCU TIM1 CCU Interrupt + * @arg ITLINE_TIM1_CC TIM1 CC Interrupt + * @arg ITLINE_TIM2 TIM2 Interrupt + * @arg ITLINE_TIM3 TIM3 Interrupt + * @arg ITLINE_DAC DAC Interrupt + * @arg ITLINE_TIM6 TIM6 Interrupt + * @arg ITLINE_TIM7 TIM7 Interrupt + * @arg ITLINE_TIM14 TIM14 Interrupt + * @arg ITLINE_TIM15 TIM15 Interrupt + * @arg ITLINE_TIM16 TIM16 Interrupt + * @arg ITLINE_TIM17 TIM17 Interrupt + * @arg ITLINE_I2C1 I2C1 Interrupt -> exti[23] + * @arg ITLINE_I2C2 I2C2 Interrupt + * @arg ITLINE_SPI1 I2C1 Interrupt -> exti[23] + * @arg ITLINE_SPI2 SPI1 Interrupt + * @arg ITLINE_USART1 USART1 GLB Interrupt -> exti[25] + * @arg ITLINE_USART2 USART2 GLB Interrupt -> exti[26] + * @arg ITLINE_USART3 USART3 Interrupt + * @arg ITLINE_USART4 USART4 Interrupt + * @arg ITLINE_USART5 USART5 Interrupt + * @arg ITLINE_USART6 USART6 Interrupt + * @arg ITLINE_USART7 USART7 Interrupt + * @arg ITLINE_USART8 USART8 Interrupt + * @arg ITLINE_CAN CAN Interrupt + * @arg ITLINE_CEC CEC Interrupt + * @retval The new state of IT_LINE_SR. + */ +uint32_t SYSCFG_GetPendingIT(uint32_t ITSourceLine) +{ + assert_param(IS_SYSCFG_ITLINE(ITSourceLine)); + return(SYSCFG->IT_LINE_SR[(ITSourceLine >> 0x18)] & (ITSourceLine & 0x00FFFFFF)); +} + +/** + * @brief Connect the selected parameter to the break input of TIM1. + * @note The selected configuration is locked and can be unlocked by system reset + * @param SYSCFG_Break: selects the configuration to be connected to break + * input of TIM1 + * This parameter can be any combination of the following values: + * @arg SYSCFG_Break_PVD: Connects the PVD event to the Break Input of TIM1,, not available for STM32F030 devices. + * @arg SYSCFG_Break_SRAMParity: Connects the SRAM_PARITY error signal to the Break Input of TIM1 . + * @arg SYSCFG_Break_Lockup: Connects Lockup output of CortexM0 to the break input of TIM1. + * @retval None + */ +void SYSCFG_BreakConfig(uint32_t SYSCFG_Break) +{ + /* Check the parameter */ + assert_param(IS_SYSCFG_LOCK_CONFIG(SYSCFG_Break)); + + SYSCFG->CFGR2 |= (uint32_t) SYSCFG_Break; +} + +/** + * @brief Checks whether the specified SYSCFG flag is set or not. + * @param SYSCFG_Flag: specifies the SYSCFG flag to check. + * This parameter can be one of the following values: + * @arg SYSCFG_FLAG_PE: SRAM parity error flag. + * @retval The new state of SYSCFG_Flag (SET or RESET). + */ +FlagStatus SYSCFG_GetFlagStatus(uint32_t SYSCFG_Flag) +{ + FlagStatus bitstatus = RESET; + + /* Check the parameter */ + assert_param(IS_SYSCFG_FLAG(SYSCFG_Flag)); + + /* Check the status of the specified SPI flag */ + if ((SYSCFG->CFGR2 & SYSCFG_CFGR2_SRAM_PE) != (uint32_t)RESET) + { + /* SYSCFG_Flag is set */ + bitstatus = SET; + } + else + { + /* SYSCFG_Flag is reset */ + bitstatus = RESET; + } + /* Return the SYSCFG_Flag status */ + return bitstatus; +} + +/** + * @brief Clear the selected SYSCFG flag. + * @param SYSCFG_Flag: selects the flag to be cleared. + * This parameter can be any combination of the following values: + * @arg SYSCFG_FLAG_PE: SRAM parity error flag. + * @retval None + */ +void SYSCFG_ClearFlag(uint32_t SYSCFG_Flag) +{ + /* Check the parameter */ + assert_param(IS_SYSCFG_FLAG(SYSCFG_Flag)); + + SYSCFG->CFGR2 |= (uint32_t) SYSCFG_Flag; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_tim.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_tim.c new file mode 100644 index 00000000..2f1d00ce --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_tim.c @@ -0,0 +1,3349 @@ +/** + ****************************************************************************** + * @file stm32f0xx_tim.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the TIM peripheral: + * + TimeBase management + * + Output Compare management + * + Input Capture management + * + Interrupts, DMA and flags management + * + Clocks management + * + Synchronization management + * + Specific interface management + * + Specific remapping management + * + * @verbatim + + =============================================================================== + ##### How to use this driver ##### + =============================================================================== + [..] This driver provides functions to configure and program the TIM + of all STM32F0xx devices These functions are split in 8 groups: + (#) TIM TimeBase management: this group includes all needed functions + to configure the TM Timebase unit: + (++) Set/Get Prescaler. + (++) Set/Get Autoreload. + (++) Counter modes configuration. + (++) Set Clock division. + (++) Select the One Pulse mode. + (++) Update Request Configuration. + (++) Update Disable Configuration. + (++) Auto-Preload Configuration. + (++) Enable/Disable the counter. + + (#) TIM Output Compare management: this group includes all needed + functions to configure the Capture/Compare unit used in Output + compare mode: + (++) Configure each channel, independently, in Output Compare mode. + (++) Select the output compare modes. + (++) Select the Polarities of each channel. + (++) Set/Get the Capture/Compare register values. + (++) Select the Output Compare Fast mode. + (++) Select the Output Compare Forced mode. + (++) Output Compare-Preload Configuration. + (++) Clear Output Compare Reference. + (++) Select the OCREF Clear signal. + (++) Enable/Disable the Capture/Compare Channels. + + (#) TIM Input Capture management: this group includes all needed + functions to configure the Capture/Compare unit used in + Input Capture mode: + (++) Configure each channel in input capture mode. + (++) Configure Channel1/2 in PWM Input mode. + (++) Set the Input Capture Prescaler. + (++) Get the Capture/Compare values. + + (#) Advanced-control timers (TIM1) specific features + (++) Configures the Break input, dead time, Lock level, the OSSI, + the OSSR State and the AOE(automatic output enable) + (++) Enable/Disable the TIM peripheral Main Outputs + (++) Select the Commutation event + (++) Set/Reset the Capture Compare Preload Control bit + + (#) TIM interrupts, DMA and flags management. + (++) Enable/Disable interrupt sources. + (++) Get flags status. + (++) Clear flags/ Pending bits. + (++) Enable/Disable DMA requests. + (++) Configure DMA burst mode. + (++) Select CaptureCompare DMA request. + + (#) TIM clocks management: this group includes all needed functions + to configure the clock controller unit: + (++) Select internal/External clock. + (++) Select the external clock mode: ETR(Mode1/Mode2), TIx or ITRx. + + (#) TIM synchronization management: this group includes all needed. + functions to configure the Synchronization unit: + (++) Select Input Trigger. + (++) Select Output Trigger. + (++) Select Master Slave Mode. + (++) ETR Configuration when used as external trigger. + + (#) TIM specific interface management, this group includes all + needed functions to use the specific TIM interface: + (++) Encoder Interface Configuration. + (++) Select Hall Sensor. + + (#) TIM specific remapping management includes the Remapping + configuration of specific timers + +@endverbatim + * + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_tim.h" +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup TIM + * @brief TIM driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ + +/* ---------------------- TIM registers bit mask ------------------------ */ +#define SMCR_ETR_MASK ((uint16_t)0x00FF) +#define CCMR_OFFSET ((uint16_t)0x0018) +#define CCER_CCE_SET ((uint16_t)0x0001) +#define CCER_CCNE_SET ((uint16_t)0x0004) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ + +static void TI1_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, + uint16_t TIM_ICFilter); +static void TI2_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, + uint16_t TIM_ICFilter); +static void TI3_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, + uint16_t TIM_ICFilter); +static void TI4_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, + uint16_t TIM_ICFilter); +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup TIM_Private_Functions + * @{ + */ + +/** @defgroup TIM_Group1 TimeBase management functions + * @brief TimeBase management functions + * +@verbatim + =============================================================================== + ##### TimeBase management functions ##### + =============================================================================== + + *** TIM Driver: how to use it in Timing(Time base) Mode *** + =============================================================================== + [..] To use the Timer in Timing(Time base) mode, the following steps are + mandatory: + (#) Enable TIM clock using + RCC_APBxPeriphClockCmd(RCC_APBxPeriph_TIMx, ENABLE) function. + (#) Fill the TIM_TimeBaseInitStruct with the desired parameters. + (#) Call TIM_TimeBaseInit(TIMx, &TIM_TimeBaseInitStruct) to configure + the Time Base unit with the corresponding configuration. + (#) Enable the NVIC if you need to generate the update interrupt. + (#) Enable the corresponding interrupt using the function + TIM_ITConfig(TIMx, TIM_IT_Update). + (#) Call the TIM_Cmd(ENABLE) function to enable the TIM counter. + [..] + (@) All other functions can be used seperatly to modify, if needed, + a specific feature of the Timer. + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the TIMx peripheral registers to their default reset values. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17 to select the TIM peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @retval None + * + */ +void TIM_DeInit(TIM_TypeDef* TIMx) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + + if (TIMx == TIM1) + { + RCC_APB2PeriphResetCmd(RCC_APB2Periph_TIM1, ENABLE); + RCC_APB2PeriphResetCmd(RCC_APB2Periph_TIM1, DISABLE); + } + else if (TIMx == TIM2) + { + RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM2, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM2, DISABLE); + } + else if (TIMx == TIM3) + { + RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM3, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM3, DISABLE); + } + else if (TIMx == TIM6) + { + RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM6, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM6, DISABLE); + } + else if (TIMx == TIM7) + { + RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM7, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM7, DISABLE); + } + else if (TIMx == TIM14) + { + RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM14, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM14, DISABLE); + } + else if (TIMx == TIM15) + { + RCC_APB2PeriphResetCmd(RCC_APB2Periph_TIM15, ENABLE); + RCC_APB2PeriphResetCmd(RCC_APB2Periph_TIM15, DISABLE); + } + else if (TIMx == TIM16) + { + RCC_APB2PeriphResetCmd(RCC_APB2Periph_TIM16, ENABLE); + RCC_APB2PeriphResetCmd(RCC_APB2Periph_TIM16, DISABLE); + } + else + { + if (TIMx == TIM17) + { + RCC_APB2PeriphResetCmd(RCC_APB2Periph_TIM17, ENABLE); + RCC_APB2PeriphResetCmd(RCC_APB2Periph_TIM17, DISABLE); + } + } + +} + +/** + * @brief Initializes the TIMx Time Base Unit peripheral according to + * the specified parameters in the TIM_TimeBaseInitStruct. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17 to select the TIM + * peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_TimeBaseInitStruct: pointer to a TIM_TimeBaseInitTypeDef + * structure that contains the configuration information for + * the specified TIM peripheral. + * @retval None + */ +void TIM_TimeBaseInit(TIM_TypeDef* TIMx, TIM_TimeBaseInitTypeDef* TIM_TimeBaseInitStruct) +{ + uint16_t tmpcr1 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_TIM_COUNTER_MODE(TIM_TimeBaseInitStruct->TIM_CounterMode)); + assert_param(IS_TIM_CKD_DIV(TIM_TimeBaseInitStruct->TIM_ClockDivision)); + + tmpcr1 = TIMx->CR1; + + if((TIMx == TIM1) || (TIMx == TIM2) || (TIMx == TIM3)) + { + /* Select the Counter Mode */ + tmpcr1 &= (uint16_t)(~((uint16_t)(TIM_CR1_DIR | TIM_CR1_CMS))); + tmpcr1 |= (uint32_t)TIM_TimeBaseInitStruct->TIM_CounterMode; + } + + if(TIMx != TIM6) + { + /* Set the clock division */ + tmpcr1 &= (uint16_t)(~((uint16_t)TIM_CR1_CKD)); + tmpcr1 |= (uint32_t)TIM_TimeBaseInitStruct->TIM_ClockDivision; + } + + TIMx->CR1 = tmpcr1; + + /* Set the Autoreload value */ + TIMx->ARR = TIM_TimeBaseInitStruct->TIM_Period ; + + /* Set the Prescaler value */ + TIMx->PSC = TIM_TimeBaseInitStruct->TIM_Prescaler; + + if ((TIMx == TIM1) || (TIMx == TIM15)|| (TIMx == TIM16) || (TIMx == TIM17)) + { + /* Set the Repetition Counter value */ + TIMx->RCR = TIM_TimeBaseInitStruct->TIM_RepetitionCounter; + } + + /* Generate an update event to reload the Prescaler and the Repetition counter + values immediately */ + TIMx->EGR = TIM_PSCReloadMode_Immediate; +} + +/** + * @brief Fills each TIM_TimeBaseInitStruct member with its default value. + * @param TIM_TimeBaseInitStruct: pointer to a TIM_TimeBaseInitTypeDef structure + * which will be initialized. + * @retval None + */ +void TIM_TimeBaseStructInit(TIM_TimeBaseInitTypeDef* TIM_TimeBaseInitStruct) +{ + /* Set the default configuration */ + TIM_TimeBaseInitStruct->TIM_Period = 0xFFFFFFFF; + TIM_TimeBaseInitStruct->TIM_Prescaler = 0x0000; + TIM_TimeBaseInitStruct->TIM_ClockDivision = TIM_CKD_DIV1; + TIM_TimeBaseInitStruct->TIM_CounterMode = TIM_CounterMode_Up; + TIM_TimeBaseInitStruct->TIM_RepetitionCounter = 0x0000; +} + +/** + * @brief Configures the TIMx Prescaler. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17 to select the TIM peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param Prescaler: specifies the Prescaler Register value + * @param TIM_PSCReloadMode: specifies the TIM Prescaler Reload mode + * This parameter can be one of the following values: + * @arg TIM_PSCReloadMode_Update: The Prescaler is loaded at the update event. + * @arg TIM_PSCReloadMode_Immediate: The Prescaler is loaded immediatly. + * @retval None + */ +void TIM_PrescalerConfig(TIM_TypeDef* TIMx, uint16_t Prescaler, uint16_t TIM_PSCReloadMode) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_TIM_PRESCALER_RELOAD(TIM_PSCReloadMode)); + + /* Set the Prescaler value */ + TIMx->PSC = Prescaler; + /* Set or reset the UG Bit */ + TIMx->EGR = TIM_PSCReloadMode; +} + +/** + * @brief Specifies the TIMx Counter Mode to be used. + * @param TIMx: where x can be 1, 2, or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_CounterMode: specifies the Counter Mode to be used + * This parameter can be one of the following values: + * @arg TIM_CounterMode_Up: TIM Up Counting Mode + * @arg TIM_CounterMode_Down: TIM Down Counting Mode + * @arg TIM_CounterMode_CenterAligned1: TIM Center Aligned Mode1 + * @arg TIM_CounterMode_CenterAligned2: TIM Center Aligned Mode2 + * @arg TIM_CounterMode_CenterAligned3: TIM Center Aligned Mode3 + * @retval None + */ +void TIM_CounterModeConfig(TIM_TypeDef* TIMx, uint16_t TIM_CounterMode) +{ + uint16_t tmpcr1 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_COUNTER_MODE(TIM_CounterMode)); + + tmpcr1 = TIMx->CR1; + /* Reset the CMS and DIR Bits */ + tmpcr1 &= (uint16_t)(~((uint16_t)(TIM_CR1_DIR | TIM_CR1_CMS))); + /* Set the Counter Mode */ + tmpcr1 |= TIM_CounterMode; + /* Write to TIMx CR1 register */ + TIMx->CR1 = tmpcr1; +} + +/** + * @brief Sets the TIMx Counter Register value + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17 to select the TIM + * peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param Counter: specifies the Counter register new value. + * @retval None + */ +void TIM_SetCounter(TIM_TypeDef* TIMx, uint32_t Counter) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + + /* Set the Counter Register value */ + TIMx->CNT = Counter; +} + +/** + * @brief Sets the TIMx Autoreload Register value + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17 to select the TIM peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param Autoreload: specifies the Autoreload register new value. + * @retval None + */ +void TIM_SetAutoreload(TIM_TypeDef* TIMx, uint32_t Autoreload) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + + /* Set the Autoreload Register value */ + TIMx->ARR = Autoreload; +} + +/** + * @brief Gets the TIMx Counter value. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17 to select the TIM + * peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @retval Counter Register value. + */ +uint32_t TIM_GetCounter(TIM_TypeDef* TIMx) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + + /* Get the Counter Register value */ + return TIMx->CNT; +} + +/** + * @brief Gets the TIMx Prescaler value. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17 to select the TIM + * peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @retval Prescaler Register value. + */ +uint16_t TIM_GetPrescaler(TIM_TypeDef* TIMx) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + + /* Get the Prescaler Register value */ + return TIMx->PSC; +} + +/** + * @brief Enables or Disables the TIMx Update event. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17 to select the TIM + * peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param NewState: new state of the TIMx UDIS bit + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void TIM_UpdateDisableConfig(TIM_TypeDef* TIMx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Set the Update Disable Bit */ + TIMx->CR1 |= TIM_CR1_UDIS; + } + else + { + /* Reset the Update Disable Bit */ + TIMx->CR1 &= (uint16_t)~((uint16_t)TIM_CR1_UDIS); + } +} + +/** + * @brief Configures the TIMx Update Request Interrupt source. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17 to select the TIM + * peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_UpdateSource: specifies the Update source. + * This parameter can be one of the following values: + * @arg TIM_UpdateSource_Regular: Source of update is the counter + * overflow/underflow or the setting of UG bit, or an update + * generation through the slave mode controller. + * @arg TIM_UpdateSource_Global: Source of update is counter overflow/underflow. + * @retval None + */ +void TIM_UpdateRequestConfig(TIM_TypeDef* TIMx, uint16_t TIM_UpdateSource) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_TIM_UPDATE_SOURCE(TIM_UpdateSource)); + + if (TIM_UpdateSource != TIM_UpdateSource_Global) + { + /* Set the URS Bit */ + TIMx->CR1 |= TIM_CR1_URS; + } + else + { + /* Reset the URS Bit */ + TIMx->CR1 &= (uint16_t)~((uint16_t)TIM_CR1_URS); + } +} + +/** + * @brief Enables or disables TIMx peripheral Preload register on ARR. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17 to select the TIM + * peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param NewState: new state of the TIMx peripheral Preload register + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void TIM_ARRPreloadConfig(TIM_TypeDef* TIMx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Set the ARR Preload Bit */ + TIMx->CR1 |= TIM_CR1_ARPE; + } + else + { + /* Reset the ARR Preload Bit */ + TIMx->CR1 &= (uint16_t)~((uint16_t)TIM_CR1_ARPE); + } +} + +/** + * @brief Selects the TIMx's One Pulse Mode. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17 to select the TIM + * peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OPMode: specifies the OPM Mode to be used. + * This parameter can be one of the following values: + * @arg TIM_OPMode_Single + * @arg TIM_OPMode_Repetitive + * @retval None + */ +void TIM_SelectOnePulseMode(TIM_TypeDef* TIMx, uint16_t TIM_OPMode) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_TIM_OPM_MODE(TIM_OPMode)); + + /* Reset the OPM Bit */ + TIMx->CR1 &= (uint16_t)~((uint16_t)TIM_CR1_OPM); + /* Configure the OPM Mode */ + TIMx->CR1 |= TIM_OPMode; +} + +/** + * @brief Sets the TIMx Clock Division value. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 and 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_CKD: specifies the clock division value. + * This parameter can be one of the following value: + * @arg TIM_CKD_DIV1: TDTS = Tck_tim + * @arg TIM_CKD_DIV2: TDTS = 2*Tck_tim + * @arg TIM_CKD_DIV4: TDTS = 4*Tck_tim + * @retval None + */ +void TIM_SetClockDivision(TIM_TypeDef* TIMx, uint16_t TIM_CKD) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_CKD_DIV(TIM_CKD)); + + /* Reset the CKD Bits */ + TIMx->CR1 &= (uint16_t)~((uint16_t)TIM_CR1_CKD); + /* Set the CKD value */ + TIMx->CR1 |= TIM_CKD; +} + +/** + * @brief Enables or disables the specified TIM peripheral. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 and 17to select the TIMx + * peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param NewState: new state of the TIMx peripheral. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void TIM_Cmd(TIM_TypeDef* TIMx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the TIM Counter */ + TIMx->CR1 |= TIM_CR1_CEN; + } + else + { + /* Disable the TIM Counter */ + TIMx->CR1 &= (uint16_t)(~((uint16_t)TIM_CR1_CEN)); + } +} + +/** + * @} + */ + +/** @defgroup TIM_Group2 Advanced-control timers (TIM1) specific features + * @brief Advanced-control timers (TIM1) specific features + * +@verbatim + =============================================================================== + ##### Advanced-control timers (TIM1) specific features ##### + =============================================================================== + + =================================================================== + *** TIM Driver: how to use the Break feature *** + =================================================================== + [..] After configuring the Timer channel(s) in the appropriate Output Compare mode: + + (#) Fill the TIM_BDTRInitStruct with the desired parameters for the Timer + Break Polarity, dead time, Lock level, the OSSI/OSSR State and the + AOE(automatic output enable). + + (#) Call TIM_BDTRConfig(TIMx, &TIM_BDTRInitStruct) to configure the Timer + + (#) Enable the Main Output using TIM_CtrlPWMOutputs(TIM1, ENABLE) + + (#) Once the break even occurs, the Timer's output signals are put in reset + state or in a known state (according to the configuration made in + TIM_BDTRConfig() function). + +@endverbatim + * @{ + */ +/** + * @brief Configures the: Break feature, dead time, Lock level, OSSI/OSSR State + * and the AOE(automatic output enable). + * @param TIMx: where x can be 1, 15, 16 or 17 to select the TIM + * @param TIM_BDTRInitStruct: pointer to a TIM_BDTRInitTypeDef structure that + * contains the BDTR Register configuration information for the TIM peripheral. + * @retval None + */ +void TIM_BDTRConfig(TIM_TypeDef* TIMx, TIM_BDTRInitTypeDef *TIM_BDTRInitStruct) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST2_PERIPH(TIMx)); + assert_param(IS_TIM_OSSR_STATE(TIM_BDTRInitStruct->TIM_OSSRState)); + assert_param(IS_TIM_OSSI_STATE(TIM_BDTRInitStruct->TIM_OSSIState)); + assert_param(IS_TIM_LOCK_LEVEL(TIM_BDTRInitStruct->TIM_LOCKLevel)); + assert_param(IS_TIM_BREAK_STATE(TIM_BDTRInitStruct->TIM_Break)); + assert_param(IS_TIM_BREAK_POLARITY(TIM_BDTRInitStruct->TIM_BreakPolarity)); + assert_param(IS_TIM_AUTOMATIC_OUTPUT_STATE(TIM_BDTRInitStruct->TIM_AutomaticOutput)); + /* Set the Lock level, the Break enable Bit and the Ploarity, the OSSR State, + the OSSI State, the dead time value and the Automatic Output Enable Bit */ + TIMx->BDTR = (uint32_t)TIM_BDTRInitStruct->TIM_OSSRState | TIM_BDTRInitStruct->TIM_OSSIState | + TIM_BDTRInitStruct->TIM_LOCKLevel | TIM_BDTRInitStruct->TIM_DeadTime | + TIM_BDTRInitStruct->TIM_Break | TIM_BDTRInitStruct->TIM_BreakPolarity | + TIM_BDTRInitStruct->TIM_AutomaticOutput; +} + +/** + * @brief Fills each TIM_BDTRInitStruct member with its default value. + * @param TIM_BDTRInitStruct: pointer to a TIM_BDTRInitTypeDef structure which + * will be initialized. + * @retval None + */ +void TIM_BDTRStructInit(TIM_BDTRInitTypeDef* TIM_BDTRInitStruct) +{ + /* Set the default configuration */ + TIM_BDTRInitStruct->TIM_OSSRState = TIM_OSSRState_Disable; + TIM_BDTRInitStruct->TIM_OSSIState = TIM_OSSIState_Disable; + TIM_BDTRInitStruct->TIM_LOCKLevel = TIM_LOCKLevel_OFF; + TIM_BDTRInitStruct->TIM_DeadTime = 0x00; + TIM_BDTRInitStruct->TIM_Break = TIM_Break_Disable; + TIM_BDTRInitStruct->TIM_BreakPolarity = TIM_BreakPolarity_Low; + TIM_BDTRInitStruct->TIM_AutomaticOutput = TIM_AutomaticOutput_Disable; +} + +/** + * @brief Enables or disables the TIM peripheral Main Outputs. + * @param TIMx: where x can be 1, 15, 16 or 17 to select the TIMx peripheral. + * @param NewState: new state of the TIM peripheral Main Outputs. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void TIM_CtrlPWMOutputs(TIM_TypeDef* TIMx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST2_PERIPH(TIMx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + if (NewState != DISABLE) + { + /* Enable the TIM Main Output */ + TIMx->BDTR |= TIM_BDTR_MOE; + } + else + { + /* Disable the TIM Main Output */ + TIMx->BDTR &= (uint16_t)(~((uint16_t)TIM_BDTR_MOE)); + } +} + +/** + * @} + */ + +/** @defgroup TIM_Group3 Output Compare management functions + * @brief Output Compare management functions + * +@verbatim + =============================================================================== + ##### Output Compare management functions ##### + =============================================================================== + *** TIM Driver: how to use it in Output Compare Mode *** + =============================================================================== + [..] To use the Timer in Output Compare mode, the following steps are mandatory: + (#) Enable TIM clock using + RCC_APBxPeriphClockCmd(RCC_APBxPeriph_TIMx, ENABLE) function. + (#) Configure the TIM pins by configuring the corresponding GPIO pins + (#) Configure the Time base unit as described in the first part of this + driver, if needed, else the Timer will run with the default + configuration: + (++) Autoreload value = 0xFFFF. + (++) Prescaler value = 0x0000. + (++) Counter mode = Up counting. + (++) Clock Division = TIM_CKD_DIV1. + (#) Fill the TIM_OCInitStruct with the desired parameters including: + (++) The TIM Output Compare mode: TIM_OCMode. + (++) TIM Output State: TIM_OutputState. + (++) TIM Pulse value: TIM_Pulse. + (++) TIM Output Compare Polarity : TIM_OCPolarity. + (#) Call TIM_OCxInit(TIMx, &TIM_OCInitStruct) to configure the desired + channel with the corresponding configuration. + (#) Call the TIM_Cmd(ENABLE) function to enable the TIM counter. + [..] + (@) All other functions can be used separately to modify, if needed, + a specific feature of the Timer. + (@) In case of PWM mode, this function is mandatory: + TIM_OCxPreloadConfig(TIMx, TIM_OCPreload_ENABLE). + (@) If the corresponding interrupt or DMA request are needed, the user should: + (#@) Enable the NVIC (or the DMA) to use the TIM interrupts (or DMA requests). + (#@) Enable the corresponding interrupt (or DMA request) using the function + TIM_ITConfig(TIMx, TIM_IT_CCx) (or TIM_DMA_Cmd(TIMx, TIM_DMA_CCx)). + +@endverbatim + * @{ + */ + +/** + * @brief Initializes the TIMx Channel1 according to the specified + * parameters in the TIM_OCInitStruct. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 and 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCInitStruct: pointer to a TIM_OCInitTypeDef structure + * that contains the configuration information for the specified TIM + * peripheral. + * @retval None + */ +void TIM_OC1Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct) +{ + uint16_t tmpccmrx = 0, tmpccer = 0, tmpcr2 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_OC_MODE(TIM_OCInitStruct->TIM_OCMode)); + assert_param(IS_TIM_OUTPUT_STATE(TIM_OCInitStruct->TIM_OutputState)); + assert_param(IS_TIM_OC_POLARITY(TIM_OCInitStruct->TIM_OCPolarity)); + /* Disable the Channel 1: Reset the CC1E Bit */ + TIMx->CCER &= (uint16_t)(~(uint16_t)TIM_CCER_CC1E); + /* Get the TIMx CCER register value */ + tmpccer = TIMx->CCER; + /* Get the TIMx CR2 register value */ + tmpcr2 = TIMx->CR2; + + /* Get the TIMx CCMR1 register value */ + tmpccmrx = TIMx->CCMR1; + + /* Reset the Output Compare Mode Bits */ + tmpccmrx &= (uint16_t)(~((uint16_t)TIM_CCMR1_OC1M)); + tmpccmrx &= (uint16_t)(~((uint16_t)TIM_CCMR1_CC1S)); + + /* Select the Output Compare Mode */ + tmpccmrx |= TIM_OCInitStruct->TIM_OCMode; + + /* Reset the Output Polarity level */ + tmpccer &= (uint16_t)(~((uint16_t)TIM_CCER_CC1P)); + /* Set the Output Compare Polarity */ + tmpccer |= TIM_OCInitStruct->TIM_OCPolarity; + + /* Set the Output State */ + tmpccer |= TIM_OCInitStruct->TIM_OutputState; + + if((TIMx == TIM1) || (TIMx == TIM15) || (TIMx == TIM16) || (TIMx == TIM17)) + { + assert_param(IS_TIM_OUTPUTN_STATE(TIM_OCInitStruct->TIM_OutputNState)); + assert_param(IS_TIM_OCN_POLARITY(TIM_OCInitStruct->TIM_OCNPolarity)); + assert_param(IS_TIM_OCNIDLE_STATE(TIM_OCInitStruct->TIM_OCNIdleState)); + assert_param(IS_TIM_OCIDLE_STATE(TIM_OCInitStruct->TIM_OCIdleState)); + + /* Reset the Output N Polarity level */ + tmpccer &= (uint16_t)(~((uint16_t)TIM_CCER_CC1NP)); + /* Set the Output N Polarity */ + tmpccer |= TIM_OCInitStruct->TIM_OCNPolarity; + + /* Reset the Output N State */ + tmpccer &= (uint16_t)(~((uint16_t)TIM_CCER_CC1NE)); + /* Set the Output N State */ + tmpccer |= TIM_OCInitStruct->TIM_OutputNState; + + /* Reset the Ouput Compare and Output Compare N IDLE State */ + tmpcr2 &= (uint16_t)(~((uint16_t)TIM_CR2_OIS1)); + tmpcr2 &= (uint16_t)(~((uint16_t)TIM_CR2_OIS1N)); + + /* Set the Output Idle state */ + tmpcr2 |= TIM_OCInitStruct->TIM_OCIdleState; + /* Set the Output N Idle state */ + tmpcr2 |= TIM_OCInitStruct->TIM_OCNIdleState; + } + /* Write to TIMx CR2 */ + TIMx->CR2 = tmpcr2; + + /* Write to TIMx CCMR1 */ + TIMx->CCMR1 = tmpccmrx; + + /* Set the Capture Compare Register value */ + TIMx->CCR1 = TIM_OCInitStruct->TIM_Pulse; + + /* Write to TIMx CCER */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Initializes the TIMx Channel2 according to the specified + * parameters in the TIM_OCInitStruct. + * @param TIMx: where x can be 1, 2, 3 or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCInitStruct: pointer to a TIM_OCInitTypeDef structure + * that contains the configuration information for the specified TIM + * peripheral. + * @retval None + */ +void TIM_OC2Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct) +{ + uint16_t tmpccmrx = 0, tmpccer = 0, tmpcr2 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_OC_MODE(TIM_OCInitStruct->TIM_OCMode)); + assert_param(IS_TIM_OUTPUT_STATE(TIM_OCInitStruct->TIM_OutputState)); + assert_param(IS_TIM_OC_POLARITY(TIM_OCInitStruct->TIM_OCPolarity)); + /* Disable the Channel 2: Reset the CC2E Bit */ + TIMx->CCER &= (uint16_t)(~((uint16_t)TIM_CCER_CC2E)); + + /* Get the TIMx CCER register value */ + tmpccer = TIMx->CCER; + /* Get the TIMx CR2 register value */ + tmpcr2 = TIMx->CR2; + + /* Get the TIMx CCMR1 register value */ + tmpccmrx = TIMx->CCMR1; + + /* Reset the Output Compare mode and Capture/Compare selection Bits */ + tmpccmrx &= (uint16_t)(~((uint16_t)TIM_CCMR1_OC2M)); + tmpccmrx &= (uint16_t)(~((uint16_t)TIM_CCMR1_CC2S)); + + /* Select the Output Compare Mode */ + tmpccmrx |= (uint16_t)(TIM_OCInitStruct->TIM_OCMode << 8); + + /* Reset the Output Polarity level */ + tmpccer &= (uint16_t)(~((uint16_t)TIM_CCER_CC2P)); + /* Set the Output Compare Polarity */ + tmpccer |= (uint16_t)(TIM_OCInitStruct->TIM_OCPolarity << 4); + + /* Set the Output State */ + tmpccer |= (uint16_t)(TIM_OCInitStruct->TIM_OutputState << 4); + + if((TIMx == TIM1) || (TIMx == TIM15)) + { + /* Check the parameters */ + assert_param(IS_TIM_OCIDLE_STATE(TIM_OCInitStruct->TIM_OCIdleState)); + + /* Reset the Ouput Compare State */ + tmpcr2 &= (uint16_t)(~((uint16_t)TIM_CR2_OIS2)); + + /* Set the Output Idle state */ + tmpcr2 |= (uint16_t)(TIM_OCInitStruct->TIM_OCIdleState << 2); + + if (TIMx == TIM1) + { + /* Check the parameters */ + assert_param(IS_TIM_OUTPUTN_STATE(TIM_OCInitStruct->TIM_OutputNState)); + assert_param(IS_TIM_OCN_POLARITY(TIM_OCInitStruct->TIM_OCNPolarity)); + assert_param(IS_TIM_OCNIDLE_STATE(TIM_OCInitStruct->TIM_OCNIdleState)); + + /* Reset the Output N Polarity level */ + tmpccer &= (uint16_t)(~((uint16_t)TIM_CCER_CC2NP)); + /* Set the Output N Polarity */ + tmpccer |= (uint16_t)(TIM_OCInitStruct->TIM_OCNPolarity << 4); + + /* Reset the Output N State */ + tmpccer &= (uint16_t)(~((uint16_t)TIM_CCER_CC2NE)); + /* Set the Output N State */ + tmpccer |= (uint16_t)(TIM_OCInitStruct->TIM_OutputNState << 4); + + /* Reset the Output Compare N IDLE State */ + tmpcr2 &= (uint16_t)(~((uint16_t)TIM_CR2_OIS2N)); + + /* Set the Output N Idle state */ + tmpcr2 |= (uint16_t)(TIM_OCInitStruct->TIM_OCNIdleState << 2); + } + } + /* Write to TIMx CR2 */ + TIMx->CR2 = tmpcr2; + + /* Write to TIMx CCMR1 */ + TIMx->CCMR1 = tmpccmrx; + + /* Set the Capture Compare Register value */ + TIMx->CCR2 = TIM_OCInitStruct->TIM_Pulse; + + /* Write to TIMx CCER */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Initializes the TIMx Channel3 according to the specified + * parameters in the TIM_OCInitStruct. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCInitStruct: pointer to a TIM_OCInitTypeDef structure + * that contains the configuration information for the specified TIM + * peripheral. + * @retval None + */ +void TIM_OC3Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct) +{ + uint16_t tmpccmrx = 0, tmpccer = 0, tmpcr2 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_OC_MODE(TIM_OCInitStruct->TIM_OCMode)); + assert_param(IS_TIM_OUTPUT_STATE(TIM_OCInitStruct->TIM_OutputState)); + assert_param(IS_TIM_OC_POLARITY(TIM_OCInitStruct->TIM_OCPolarity)); + /* Disable the Channel 2: Reset the CC2E Bit */ + TIMx->CCER &= (uint16_t)(~((uint16_t)TIM_CCER_CC3E)); + + /* Get the TIMx CCER register value */ + tmpccer = TIMx->CCER; + /* Get the TIMx CR2 register value */ + tmpcr2 = TIMx->CR2; + + /* Get the TIMx CCMR2 register value */ + tmpccmrx = TIMx->CCMR2; + + /* Reset the Output Compare mode and Capture/Compare selection Bits */ + tmpccmrx &= (uint16_t)(~((uint16_t)TIM_CCMR2_OC3M)); + tmpccmrx &= (uint16_t)(~((uint16_t)TIM_CCMR2_CC3S)); + /* Select the Output Compare Mode */ + tmpccmrx |= TIM_OCInitStruct->TIM_OCMode; + + /* Reset the Output Polarity level */ + tmpccer &= (uint16_t)(~((uint16_t)TIM_CCER_CC3P)); + /* Set the Output Compare Polarity */ + tmpccer |= (uint16_t)(TIM_OCInitStruct->TIM_OCPolarity << 8); + + /* Set the Output State */ + tmpccer |= (uint16_t)(TIM_OCInitStruct->TIM_OutputState << 8); + + if(TIMx == TIM1) + { + assert_param(IS_TIM_OUTPUTN_STATE(TIM_OCInitStruct->TIM_OutputNState)); + assert_param(IS_TIM_OCN_POLARITY(TIM_OCInitStruct->TIM_OCNPolarity)); + assert_param(IS_TIM_OCNIDLE_STATE(TIM_OCInitStruct->TIM_OCNIdleState)); + assert_param(IS_TIM_OCIDLE_STATE(TIM_OCInitStruct->TIM_OCIdleState)); + + /* Reset the Output N Polarity level */ + tmpccer &= (uint16_t)(~((uint16_t)TIM_CCER_CC3NP)); + /* Set the Output N Polarity */ + tmpccer |= (uint16_t)(TIM_OCInitStruct->TIM_OCNPolarity << 8); + /* Reset the Output N State */ + tmpccer &= (uint16_t)(~((uint16_t)TIM_CCER_CC3NE)); + + /* Set the Output N State */ + tmpccer |= (uint16_t)(TIM_OCInitStruct->TIM_OutputNState << 8); + /* Reset the Ouput Compare and Output Compare N IDLE State */ + tmpcr2 &= (uint16_t)(~((uint16_t)TIM_CR2_OIS3)); + tmpcr2 &= (uint16_t)(~((uint16_t)TIM_CR2_OIS3N)); + /* Set the Output Idle state */ + tmpcr2 |= (uint16_t)(TIM_OCInitStruct->TIM_OCIdleState << 4); + /* Set the Output N Idle state */ + tmpcr2 |= (uint16_t)(TIM_OCInitStruct->TIM_OCNIdleState << 4); + } + /* Write to TIMx CR2 */ + TIMx->CR2 = tmpcr2; + + /* Write to TIMx CCMR2 */ + TIMx->CCMR2 = tmpccmrx; + + /* Set the Capture Compare Register value */ + TIMx->CCR3 = TIM_OCInitStruct->TIM_Pulse; + + /* Write to TIMx CCER */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Initializes the TIMx Channel4 according to the specified + * parameters in the TIM_OCInitStruct. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCInitStruct: pointer to a TIM_OCInitTypeDef structure + * that contains the configuration information for the specified TIM + * peripheral. + * @retval None + */ +void TIM_OC4Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct) +{ + uint16_t tmpccmrx = 0, tmpccer = 0, tmpcr2 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_OC_MODE(TIM_OCInitStruct->TIM_OCMode)); + assert_param(IS_TIM_OUTPUT_STATE(TIM_OCInitStruct->TIM_OutputState)); + assert_param(IS_TIM_OC_POLARITY(TIM_OCInitStruct->TIM_OCPolarity)); + /* Disable the Channel 2: Reset the CC4E Bit */ + TIMx->CCER &= (uint16_t)(~((uint16_t)TIM_CCER_CC4E)); + + /* Get the TIMx CCER register value */ + tmpccer = TIMx->CCER; + /* Get the TIMx CR2 register value */ + tmpcr2 = TIMx->CR2; + + /* Get the TIMx CCMR2 register value */ + tmpccmrx = TIMx->CCMR2; + + /* Reset the Output Compare mode and Capture/Compare selection Bits */ + tmpccmrx &= (uint16_t)(~((uint16_t)TIM_CCMR2_OC4M)); + tmpccmrx &= (uint16_t)(~((uint16_t)TIM_CCMR2_CC4S)); + + /* Select the Output Compare Mode */ + tmpccmrx |= (uint16_t)(TIM_OCInitStruct->TIM_OCMode << 8); + + /* Reset the Output Polarity level */ + tmpccer &= (uint16_t)(~((uint16_t)TIM_CCER_CC4P)); + /* Set the Output Compare Polarity */ + tmpccer |= (uint16_t)(TIM_OCInitStruct->TIM_OCPolarity << 12); + + /* Set the Output State */ + tmpccer |= (uint16_t)(TIM_OCInitStruct->TIM_OutputState << 12); + + if(TIMx == TIM1) + { + assert_param(IS_TIM_OCIDLE_STATE(TIM_OCInitStruct->TIM_OCIdleState)); + /* Reset the Ouput Compare IDLE State */ + tmpcr2 &= (uint16_t)(~((uint16_t)TIM_CR2_OIS4)); + /* Set the Output Idle state */ + tmpcr2 |= (uint16_t)(TIM_OCInitStruct->TIM_OCIdleState << 6); + } + /* Write to TIMx CR2 */ + TIMx->CR2 = tmpcr2; + + /* Write to TIMx CCMR2 */ + TIMx->CCMR2 = tmpccmrx; + + /* Set the Capture Compare Register value */ + TIMx->CCR4 = TIM_OCInitStruct->TIM_Pulse; + + /* Write to TIMx CCER */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Fills each TIM_OCInitStruct member with its default value. + * @param TIM_OCInitStruct: pointer to a TIM_OCInitTypeDef structure which will + * be initialized. + * @retval None + */ +void TIM_OCStructInit(TIM_OCInitTypeDef* TIM_OCInitStruct) +{ + /* Set the default configuration */ + TIM_OCInitStruct->TIM_OCMode = TIM_OCMode_Timing; + TIM_OCInitStruct->TIM_OutputState = TIM_OutputState_Disable; + TIM_OCInitStruct->TIM_OutputNState = TIM_OutputNState_Disable; + TIM_OCInitStruct->TIM_Pulse = 0x0000000; + TIM_OCInitStruct->TIM_OCPolarity = TIM_OCPolarity_High; + TIM_OCInitStruct->TIM_OCNPolarity = TIM_OCPolarity_High; + TIM_OCInitStruct->TIM_OCIdleState = TIM_OCIdleState_Reset; + TIM_OCInitStruct->TIM_OCNIdleState = TIM_OCNIdleState_Reset; +} + +/** + * @brief Selects the TIM Output Compare Mode. + * @note This function disables the selected channel before changing the Output + * Compare Mode. + * User has to enable this channel using TIM_CCxCmd and TIM_CCxNCmd functions. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_Channel: specifies the TIM Channel + * This parameter can be one of the following values: + * @arg TIM_Channel_1: TIM Channel 1 + * @arg TIM_Channel_2: TIM Channel 2 + * @arg TIM_Channel_3: TIM Channel 3 + * @arg TIM_Channel_4: TIM Channel 4 + * @param TIM_OCMode: specifies the TIM Output Compare Mode. + * This parameter can be one of the following values: + * @arg TIM_OCMode_Timing + * @arg TIM_OCMode_Active + * @arg TIM_OCMode_Toggle + * @arg TIM_OCMode_PWM1 + * @arg TIM_OCMode_PWM2 + * @arg TIM_ForcedAction_Active + * @arg TIM_ForcedAction_InActive + * @retval None + */ +void TIM_SelectOCxM(TIM_TypeDef* TIMx, uint16_t TIM_Channel, uint16_t TIM_OCMode) +{ + uint32_t tmp = 0; + uint16_t tmp1 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_OCM(TIM_OCMode)); + + tmp = (uint32_t) TIMx; + tmp += CCMR_OFFSET; + + tmp1 = CCER_CCE_SET << (uint16_t)TIM_Channel; + + /* Disable the Channel: Reset the CCxE Bit */ + TIMx->CCER &= (uint16_t) ~tmp1; + + if((TIM_Channel == TIM_Channel_1) ||(TIM_Channel == TIM_Channel_3)) + { + tmp += (TIM_Channel>>1); + + /* Reset the OCxM bits in the CCMRx register */ + *(__IO uint32_t *) tmp &= (uint32_t)~((uint32_t)TIM_CCMR1_OC1M); + + /* Configure the OCxM bits in the CCMRx register */ + *(__IO uint32_t *) tmp |= TIM_OCMode; + } + else + { + tmp += (uint16_t)(TIM_Channel - (uint16_t)4)>> (uint16_t)1; + + /* Reset the OCxM bits in the CCMRx register */ + *(__IO uint32_t *) tmp &= (uint32_t)~((uint32_t)TIM_CCMR1_OC2M); + + /* Configure the OCxM bits in the CCMRx register */ + *(__IO uint32_t *) tmp |= (uint16_t)(TIM_OCMode << 8); + } +} + +/** + * @brief Sets the TIMx Capture Compare1 Register value + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param Compare1: specifies the Capture Compare1 register new value. + * @retval None + */ +void TIM_SetCompare1(TIM_TypeDef* TIMx, uint32_t Compare1) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + + /* Set the Capture Compare1 Register value */ + TIMx->CCR1 = Compare1; +} + +/** + * @brief Sets the TIMx Capture Compare2 Register value + * @param TIMx: where x can be 1, 2, 3 or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param Compare2: specifies the Capture Compare2 register new value. + * @retval None + */ +void TIM_SetCompare2(TIM_TypeDef* TIMx, uint32_t Compare2) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + + /* Set the Capture Compare2 Register value */ + TIMx->CCR2 = Compare2; +} + +/** + * @brief Sets the TIMx Capture Compare3 Register value + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @param Compare3: specifies the Capture Compare3 register new value. + * @retval None + */ +void TIM_SetCompare3(TIM_TypeDef* TIMx, uint32_t Compare3) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + + /* Set the Capture Compare3 Register value */ + TIMx->CCR3 = Compare3; +} + +/** + * @brief Sets the TIMx Capture Compare4 Register value + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param Compare4: specifies the Capture Compare4 register new value. + * @retval None + */ +void TIM_SetCompare4(TIM_TypeDef* TIMx, uint32_t Compare4) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + + /* Set the Capture Compare4 Register value */ + TIMx->CCR4 = Compare4; +} + +/** + * @brief Forces the TIMx output 1 waveform to active or inactive level. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ForcedAction: specifies the forced Action to be set to the output waveform. + * This parameter can be one of the following values: + * @arg TIM_ForcedAction_Active: Force active level on OC1REF + * @arg TIM_ForcedAction_InActive: Force inactive level on OC1REF. + * @retval None + */ +void TIM_ForcedOC1Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction) +{ + uint16_t tmpccmr1 = 0; + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_FORCED_ACTION(TIM_ForcedAction)); + tmpccmr1 = TIMx->CCMR1; + /* Reset the OC1M Bits */ + tmpccmr1 &= (uint16_t)~((uint16_t)TIM_CCMR1_OC1M); + /* Configure The Forced output Mode */ + tmpccmr1 |= TIM_ForcedAction; + /* Write to TIMx CCMR1 register */ + TIMx->CCMR1 = tmpccmr1; +} + +/** + * @brief Forces the TIMx output 2 waveform to active or inactive level. + * @param TIMx: where x can be 1, 2, 3, or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ForcedAction: specifies the forced Action to be set to the output waveform. + * This parameter can be one of the following values: + * @arg TIM_ForcedAction_Active: Force active level on OC2REF + * @arg TIM_ForcedAction_InActive: Force inactive level on OC2REF. + * @retval None + */ +void TIM_ForcedOC2Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction) +{ + uint16_t tmpccmr1 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_FORCED_ACTION(TIM_ForcedAction)); + + tmpccmr1 = TIMx->CCMR1; + /* Reset the OC2M Bits */ + tmpccmr1 &= (uint16_t)~((uint16_t)TIM_CCMR1_OC2M); + /* Configure The Forced output Mode */ + tmpccmr1 |= (uint16_t)(TIM_ForcedAction << 8); + /* Write to TIMx CCMR1 register */ + TIMx->CCMR1 = tmpccmr1; +} + +/** + * @brief Forces the TIMx output 3 waveform to active or inactive level. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ForcedAction: specifies the forced Action to be set to the output waveform. + * This parameter can be one of the following values: + * @arg TIM_ForcedAction_Active: Force active level on OC3REF + * @arg TIM_ForcedAction_InActive: Force inactive level on OC3REF. + * @retval None + */ +void TIM_ForcedOC3Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction) +{ + uint16_t tmpccmr2 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_FORCED_ACTION(TIM_ForcedAction)); + + tmpccmr2 = TIMx->CCMR2; + /* Reset the OC1M Bits */ + tmpccmr2 &= (uint16_t)~((uint16_t)TIM_CCMR2_OC3M); + /* Configure The Forced output Mode */ + tmpccmr2 |= TIM_ForcedAction; + /* Write to TIMx CCMR2 register */ + TIMx->CCMR2 = tmpccmr2; +} + +/** + * @brief Forces the TIMx output 4 waveform to active or inactive level. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ForcedAction: specifies the forced Action to be set to the output waveform. + * This parameter can be one of the following values: + * @arg TIM_ForcedAction_Active: Force active level on OC4REF + * @arg TIM_ForcedAction_InActive: Force inactive level on OC4REF. + * @retval None + */ +void TIM_ForcedOC4Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction) +{ + uint16_t tmpccmr2 = 0; + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_FORCED_ACTION(TIM_ForcedAction)); + + tmpccmr2 = TIMx->CCMR2; + /* Reset the OC2M Bits */ + tmpccmr2 &= (uint16_t)~((uint16_t)TIM_CCMR2_OC4M); + /* Configure The Forced output Mode */ + tmpccmr2 |= (uint16_t)(TIM_ForcedAction << 8); + /* Write to TIMx CCMR2 register */ + TIMx->CCMR2 = tmpccmr2; +} + +/** + * @brief Sets or Resets the TIM peripheral Capture Compare Preload Control bit. + * @param TIMx: where x can be 1, 2, 3 or 15 to select the TIMx peripheral + * @note TIM2 is not applicable for STM32F030 devices. + * @param NewState: new state of the Capture Compare Preload Control bit + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void TIM_CCPreloadControl(TIM_TypeDef* TIMx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + if (NewState != DISABLE) + { + /* Set the CCPC Bit */ + TIMx->CR2 |= TIM_CR2_CCPC; + } + else + { + /* Reset the CCPC Bit */ + TIMx->CR2 &= (uint16_t)~((uint16_t)TIM_CR2_CCPC); + } +} + + +/** + * @brief Enables or disables the TIMx peripheral Preload register on CCR1. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 and 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCPreload: new state of the TIMx peripheral Preload register + * This parameter can be one of the following values: + * @arg TIM_OCPreload_Enable + * @arg TIM_OCPreload_Disable + * @retval None + */ +void TIM_OC1PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload) +{ + uint16_t tmpccmr1 = 0; + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_OCPRELOAD_STATE(TIM_OCPreload)); + + tmpccmr1 = TIMx->CCMR1; + /* Reset the OC1PE Bit */ + tmpccmr1 &= (uint16_t)~((uint16_t)TIM_CCMR1_OC1PE); + /* Enable or Disable the Output Compare Preload feature */ + tmpccmr1 |= TIM_OCPreload; + /* Write to TIMx CCMR1 register */ + TIMx->CCMR1 = tmpccmr1; +} + +/** + * @brief Enables or disables the TIMx peripheral Preload register on CCR2. + * @param TIMx: where x can be 1, 2, 3 and 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCPreload: new state of the TIMx peripheral Preload register + * This parameter can be one of the following values: + * @arg TIM_OCPreload_Enable + * @arg TIM_OCPreload_Disable + * @retval None + */ +void TIM_OC2PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload) +{ + uint16_t tmpccmr1 = 0; + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_OCPRELOAD_STATE(TIM_OCPreload)); + + tmpccmr1 = TIMx->CCMR1; + /* Reset the OC2PE Bit */ + tmpccmr1 &= (uint16_t)~((uint16_t)TIM_CCMR1_OC2PE); + /* Enable or Disable the Output Compare Preload feature */ + tmpccmr1 |= (uint16_t)(TIM_OCPreload << 8); + /* Write to TIMx CCMR1 register */ + TIMx->CCMR1 = tmpccmr1; +} + +/** + * @brief Enables or disables the TIMx peripheral Preload register on CCR3. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCPreload: new state of the TIMx peripheral Preload register + * This parameter can be one of the following values: + * @arg TIM_OCPreload_Enable + * @arg TIM_OCPreload_Disable + * @retval None + */ +void TIM_OC3PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload) +{ + uint16_t tmpccmr2 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_OCPRELOAD_STATE(TIM_OCPreload)); + + tmpccmr2 = TIMx->CCMR2; + /* Reset the OC3PE Bit */ + tmpccmr2 &= (uint16_t)~((uint16_t)TIM_CCMR2_OC3PE); + /* Enable or Disable the Output Compare Preload feature */ + tmpccmr2 |= TIM_OCPreload; + /* Write to TIMx CCMR2 register */ + TIMx->CCMR2 = tmpccmr2; +} + +/** + * @brief Enables or disables the TIMx peripheral Preload register on CCR4. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCPreload: new state of the TIMx peripheral Preload register + * This parameter can be one of the following values: + * @arg TIM_OCPreload_Enable + * @arg TIM_OCPreload_Disable + * @retval None + */ +void TIM_OC4PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload) +{ + uint16_t tmpccmr2 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_OCPRELOAD_STATE(TIM_OCPreload)); + + tmpccmr2 = TIMx->CCMR2; + /* Reset the OC4PE Bit */ + tmpccmr2 &= (uint16_t)~((uint16_t)TIM_CCMR2_OC4PE); + /* Enable or Disable the Output Compare Preload feature */ + tmpccmr2 |= (uint16_t)(TIM_OCPreload << 8); + /* Write to TIMx CCMR2 register */ + TIMx->CCMR2 = tmpccmr2; +} + +/** + * @brief Configures the TIMx Output Compare 1 Fast feature. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCFast: new state of the Output Compare Fast Enable Bit. + * This parameter can be one of the following values: + * @arg TIM_OCFast_Enable: TIM output compare fast enable + * @arg TIM_OCFast_Disable: TIM output compare fast disable + * @retval None + */ +void TIM_OC1FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast) +{ + uint16_t tmpccmr1 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_OCFAST_STATE(TIM_OCFast)); + + /* Get the TIMx CCMR1 register value */ + tmpccmr1 = TIMx->CCMR1; + /* Reset the OC1FE Bit */ + tmpccmr1 &= (uint16_t)~((uint16_t)TIM_CCMR1_OC1FE); + /* Enable or Disable the Output Compare Fast Bit */ + tmpccmr1 |= TIM_OCFast; + /* Write to TIMx CCMR1 */ + TIMx->CCMR1 = tmpccmr1; +} + +/** + * @brief Configures the TIMx Output Compare 2 Fast feature. + * @param TIMx: where x can be 1, 2, 3 or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCFast: new state of the Output Compare Fast Enable Bit. + * This parameter can be one of the following values: + * @arg TIM_OCFast_Enable: TIM output compare fast enable + * @arg TIM_OCFast_Disable: TIM output compare fast disable + * @retval None + */ +void TIM_OC2FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast) +{ + uint16_t tmpccmr1 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_OCFAST_STATE(TIM_OCFast)); + + /* Get the TIMx CCMR1 register value */ + tmpccmr1 = TIMx->CCMR1; + /* Reset the OC2FE Bit */ + tmpccmr1 &= (uint16_t)~((uint16_t)TIM_CCMR1_OC2FE); + /* Enable or Disable the Output Compare Fast Bit */ + tmpccmr1 |= (uint16_t)(TIM_OCFast << 8); + /* Write to TIMx CCMR1 */ + TIMx->CCMR1 = tmpccmr1; +} + +/** + * @brief Configures the TIMx Output Compare 3 Fast feature. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCFast: new state of the Output Compare Fast Enable Bit. + * This parameter can be one of the following values: + * @arg TIM_OCFast_Enable: TIM output compare fast enable + * @arg TIM_OCFast_Disable: TIM output compare fast disable + * @retval None + */ +void TIM_OC3FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast) +{ + uint16_t tmpccmr2 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_OCFAST_STATE(TIM_OCFast)); + + /* Get the TIMx CCMR2 register value */ + tmpccmr2 = TIMx->CCMR2; + /* Reset the OC3FE Bit */ + tmpccmr2 &= (uint16_t)~((uint16_t)TIM_CCMR2_OC3FE); + /* Enable or Disable the Output Compare Fast Bit */ + tmpccmr2 |= TIM_OCFast; + /* Write to TIMx CCMR2 */ + TIMx->CCMR2 = tmpccmr2; +} + +/** + * @brief Configures the TIMx Output Compare 4 Fast feature. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCFast: new state of the Output Compare Fast Enable Bit. + * This parameter can be one of the following values: + * @arg TIM_OCFast_Enable: TIM output compare fast enable + * @arg TIM_OCFast_Disable: TIM output compare fast disable + * @retval None + */ +void TIM_OC4FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast) +{ + uint16_t tmpccmr2 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_OCFAST_STATE(TIM_OCFast)); + + /* Get the TIMx CCMR2 register value */ + tmpccmr2 = TIMx->CCMR2; + /* Reset the OC4FE Bit */ + tmpccmr2 &= (uint16_t)~((uint16_t)TIM_CCMR2_OC4FE); + /* Enable or Disable the Output Compare Fast Bit */ + tmpccmr2 |= (uint16_t)(TIM_OCFast << 8); + /* Write to TIMx CCMR2 */ + TIMx->CCMR2 = tmpccmr2; +} + +/** + * @brief Clears or safeguards the OCREF1 signal on an external event + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCClear: new state of the Output Compare Clear Enable Bit. + * This parameter can be one of the following values: + * @arg TIM_OCClear_Enable: TIM Output clear enable + * @arg TIM_OCClear_Disable: TIM Output clear disable + * @retval None + */ +void TIM_ClearOC1Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear) +{ + uint16_t tmpccmr1 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_OCCLEAR_STATE(TIM_OCClear)); + + tmpccmr1 = TIMx->CCMR1; + /* Reset the OC1CE Bit */ + tmpccmr1 &= (uint16_t)~((uint16_t)TIM_CCMR1_OC1CE); + /* Enable or Disable the Output Compare Clear Bit */ + tmpccmr1 |= TIM_OCClear; + /* Write to TIMx CCMR1 register */ + TIMx->CCMR1 = tmpccmr1; +} + +/** + * @brief Clears or safeguards the OCREF2 signal on an external event + * @param TIMx: where x can be 1, 2, 3 or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCClear: new state of the Output Compare Clear Enable Bit. + * This parameter can be one of the following values: + * @arg TIM_OCClear_Enable: TIM Output clear enable + * @arg TIM_OCClear_Disable: TIM Output clear disable + * @retval None + */ +void TIM_ClearOC2Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear) +{ + uint16_t tmpccmr1 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_OCCLEAR_STATE(TIM_OCClear)); + + tmpccmr1 = TIMx->CCMR1; + /* Reset the OC2CE Bit */ + tmpccmr1 &= (uint16_t)~((uint16_t)TIM_CCMR1_OC2CE); + /* Enable or Disable the Output Compare Clear Bit */ + tmpccmr1 |= (uint16_t)(TIM_OCClear << 8); + /* Write to TIMx CCMR1 register */ + TIMx->CCMR1 = tmpccmr1; +} + +/** + * @brief Clears or safeguards the OCREF3 signal on an external event + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCClear: new state of the Output Compare Clear Enable Bit. + * This parameter can be one of the following values: + * @arg TIM_OCClear_Enable: TIM Output clear enable + * @arg TIM_OCClear_Disable: TIM Output clear disable + * @retval None + */ +void TIM_ClearOC3Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear) +{ + uint16_t tmpccmr2 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_OCCLEAR_STATE(TIM_OCClear)); + + tmpccmr2 = TIMx->CCMR2; + /* Reset the OC3CE Bit */ + tmpccmr2 &= (uint16_t)~((uint16_t)TIM_CCMR2_OC3CE); + /* Enable or Disable the Output Compare Clear Bit */ + tmpccmr2 |= TIM_OCClear; + /* Write to TIMx CCMR2 register */ + TIMx->CCMR2 = tmpccmr2; +} + +/** + * @brief Clears or safeguards the OCREF4 signal on an external event + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCClear: new state of the Output Compare Clear Enable Bit. + * This parameter can be one of the following values: + * @arg TIM_OCClear_Enable: TIM Output clear enable + * @arg TIM_OCClear_Disable: TIM Output clear disable + * @retval None + */ +void TIM_ClearOC4Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear) +{ + uint16_t tmpccmr2 = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_OCCLEAR_STATE(TIM_OCClear)); + + tmpccmr2 = TIMx->CCMR2; + /* Reset the OC4CE Bit */ + tmpccmr2 &= (uint16_t)~((uint16_t)TIM_CCMR2_OC4CE); + /* Enable or Disable the Output Compare Clear Bit */ + tmpccmr2 |= (uint16_t)(TIM_OCClear << 8); + /* Write to TIMx CCMR2 register */ + TIMx->CCMR2 = tmpccmr2; +} + +/** + * @brief Configures the TIMx channel 1 polarity. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCPolarity: specifies the OC1 Polarity + * This parmeter can be one of the following values: + * @arg TIM_OCPolarity_High: Output Compare active high + * @arg TIM_OCPolarity_Low: Output Compare active low + * @retval None + */ +void TIM_OC1PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity) +{ + uint16_t tmpccer = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_OC_POLARITY(TIM_OCPolarity)); + + tmpccer = TIMx->CCER; + /* Set or Reset the CC1P Bit */ + tmpccer &= (uint16_t)~((uint16_t)TIM_CCER_CC1P); + tmpccer |= TIM_OCPolarity; + /* Write to TIMx CCER register */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Configures the TIMx Channel 1N polarity. + * @param TIMx: where x can be 1, 15, 16 or 17 to select the TIM peripheral. + * @param TIM_OCNPolarity: specifies the OC1N Polarity + * This parmeter can be one of the following values: + * @arg TIM_OCNPolarity_High: Output Compare active high + * @arg TIM_OCNPolarity_Low: Output Compare active low + * @retval None + */ +void TIM_OC1NPolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCNPolarity) +{ + uint16_t tmpccer = 0; + /* Check the parameters */ + assert_param(IS_TIM_LIST2_PERIPH(TIMx)); + assert_param(IS_TIM_OCN_POLARITY(TIM_OCNPolarity)); + + tmpccer = TIMx->CCER; + /* Set or Reset the CC1NP Bit */ + tmpccer &= (uint16_t)~((uint16_t)TIM_CCER_CC1NP); + tmpccer |= TIM_OCNPolarity; + /* Write to TIMx CCER register */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Configures the TIMx channel 2 polarity. + * @param TIMx: where x can be 1, 2, 3, or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCPolarity: specifies the OC2 Polarity + * This parmeter can be one of the following values: + * @arg TIM_OCPolarity_High: Output Compare active high + * @arg TIM_OCPolarity_Low: Output Compare active low + * @retval None + */ +void TIM_OC2PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity) +{ + uint16_t tmpccer = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_OC_POLARITY(TIM_OCPolarity)); + + tmpccer = TIMx->CCER; + /* Set or Reset the CC2P Bit */ + tmpccer &= (uint16_t)~((uint16_t)TIM_CCER_CC2P); + tmpccer |= (uint16_t)(TIM_OCPolarity << 4); + /* Write to TIMx CCER register */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Configures the TIMx Channel 2N polarity. + * @param TIMx: where x can be 1 to select the TIM peripheral. + * @param TIM_OCNPolarity: specifies the OC2N Polarity + * This parmeter can be one of the following values: + * @arg TIM_OCNPolarity_High: Output Compare active high + * @arg TIM_OCNPolarity_Low: Output Compare active low + * @retval None + */ +void TIM_OC2NPolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCNPolarity) +{ + uint16_t tmpccer = 0; + /* Check the parameters */ + assert_param(IS_TIM_LIST1_PERIPH(TIMx)); + assert_param(IS_TIM_OCN_POLARITY(TIM_OCNPolarity)); + + tmpccer = TIMx->CCER; + /* Set or Reset the CC2NP Bit */ + tmpccer &= (uint16_t)~((uint16_t)TIM_CCER_CC2NP); + tmpccer |= (uint16_t)(TIM_OCNPolarity << 4); + /* Write to TIMx CCER register */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Configures the TIMx channel 3 polarity. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCPolarity: specifies the OC3 Polarity + * This parmeter can be one of the following values: + * @arg TIM_OCPolarity_High: Output Compare active high + * @arg TIM_OCPolarity_Low: Output Compare active low + * @retval None + */ +void TIM_OC3PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity) +{ + uint16_t tmpccer = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_OC_POLARITY(TIM_OCPolarity)); + + tmpccer = TIMx->CCER; + /* Set or Reset the CC3P Bit */ + tmpccer &= (uint16_t)~((uint16_t)TIM_CCER_CC3P); + tmpccer |= (uint16_t)(TIM_OCPolarity << 8); + /* Write to TIMx CCER register */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Configures the TIMx Channel 3N polarity. + * @param TIMx: where x can be 1 to select the TIM peripheral. + * @param TIM_OCNPolarity: specifies the OC3N Polarity + * This parmeter can be one of the following values: + * @arg TIM_OCNPolarity_High: Output Compare active high + * @arg TIM_OCNPolarity_Low: Output Compare active low + * @retval None + */ +void TIM_OC3NPolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCNPolarity) +{ + uint16_t tmpccer = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST1_PERIPH(TIMx)); + assert_param(IS_TIM_OCN_POLARITY(TIM_OCNPolarity)); + + tmpccer = TIMx->CCER; + /* Set or Reset the CC3NP Bit */ + tmpccer &= (uint16_t)~((uint16_t)TIM_CCER_CC3NP); + tmpccer |= (uint16_t)(TIM_OCNPolarity << 8); + /* Write to TIMx CCER register */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Configures the TIMx channel 4 polarity. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCPolarity: specifies the OC4 Polarity + * This parmeter can be one of the following values: + * @arg TIM_OCPolarity_High: Output Compare active high + * @arg TIM_OCPolarity_Low: Output Compare active low + * @retval None + */ +void TIM_OC4PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity) +{ + uint16_t tmpccer = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_OC_POLARITY(TIM_OCPolarity)); + + tmpccer = TIMx->CCER; + /* Set or Reset the CC4P Bit */ + tmpccer &= (uint16_t)~((uint16_t)TIM_CCER_CC4P); + tmpccer |= (uint16_t)(TIM_OCPolarity << 12); + /* Write to TIMx CCER register */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Selects the OCReference Clear source. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_OCReferenceClear: specifies the OCReference Clear source. + * This parameter can be one of the following values: + * @arg TIM_OCReferenceClear_ETRF: The internal OCreference clear input is connected to ETRF. + * @arg TIM_OCReferenceClear_OCREFCLR: The internal OCreference clear input is connected to OCREF_CLR input. + * @retval None + */ +void TIM_SelectOCREFClear(TIM_TypeDef* TIMx, uint16_t TIM_OCReferenceClear) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(TIM_OCREFERENCECECLEAR_SOURCE(TIM_OCReferenceClear)); + + /* Set the TIM_OCReferenceClear source */ + TIMx->SMCR &= (uint16_t)~((uint16_t)TIM_SMCR_OCCS); + TIMx->SMCR |= TIM_OCReferenceClear; +} + +/** + * @brief Enables or disables the TIM Capture Compare Channel x. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_Channel: specifies the TIM Channel + * This parameter can be one of the following values: + * @arg TIM_Channel_1: TIM Channel 1 + * @arg TIM_Channel_2: TIM Channel 2 + * @arg TIM_Channel_3: TIM Channel 3 + * @arg TIM_Channel_4: TIM Channel 4 + * @param TIM_CCx: specifies the TIM Channel CCxE bit new state. + * This parameter can be: TIM_CCx_Enable or TIM_CCx_Disable. + * @retval None + */ +void TIM_CCxCmd(TIM_TypeDef* TIMx, uint16_t TIM_Channel, uint16_t TIM_CCx) +{ + uint16_t tmp = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_CCX(TIM_CCx)); + + tmp = CCER_CCE_SET << TIM_Channel; + + /* Reset the CCxE Bit */ + TIMx->CCER &= (uint16_t)~ tmp; + + /* Set or reset the CCxE Bit */ + TIMx->CCER |= (uint16_t)(TIM_CCx << TIM_Channel); +} + +/** + * @brief Enables or disables the TIM Capture Compare Channel xN. + * @param TIMx: where x can be 1, 15, 16 or 17 to select the TIM peripheral. + * @param TIM_Channel: specifies the TIM Channel + * This parmeter can be one of the following values: + * @arg TIM_Channel_1: TIM Channel 1 + * @arg TIM_Channel_2: TIM Channel 2 + * @arg TIM_Channel_3: TIM Channel 3 + * @param TIM_CCxN: specifies the TIM Channel CCxNE bit new state. + * This parameter can be: TIM_CCxN_Enable or TIM_CCxN_Disable. + * @retval None + */ +void TIM_CCxNCmd(TIM_TypeDef* TIMx, uint16_t TIM_Channel, uint16_t TIM_CCxN) +{ + uint16_t tmp = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST2_PERIPH(TIMx)); + assert_param(IS_TIM_COMPLEMENTARY_CHANNEL(TIM_Channel)); + assert_param(IS_TIM_CCXN(TIM_CCxN)); + + tmp = CCER_CCNE_SET << TIM_Channel; + + /* Reset the CCxNE Bit */ + TIMx->CCER &= (uint16_t) ~tmp; + + /* Set or reset the CCxNE Bit */ + TIMx->CCER |= (uint16_t)(TIM_CCxN << TIM_Channel); +} + +/** + * @brief Selects the TIM peripheral Commutation event. + * @param TIMx: where x can be 1, 15, 16 or 17 to select the TIMx peripheral + * @param NewState: new state of the Commutation event. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void TIM_SelectCOM(TIM_TypeDef* TIMx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST2_PERIPH(TIMx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + if (NewState != DISABLE) + { + /* Set the COM Bit */ + TIMx->CR2 |= TIM_CR2_CCUS; + } + else + { + /* Reset the COM Bit */ + TIMx->CR2 &= (uint16_t)~((uint16_t)TIM_CR2_CCUS); + } +} + +/** + * @} + */ + +/** @defgroup TIM_Group4 Input Capture management functions + * @brief Input Capture management functions + * +@verbatim + =============================================================================== + ##### Input Capture management functions ##### + =============================================================================== + + *** TIM Driver: how to use it in Input Capture Mode *** + =============================================================================== + [..] To use the Timer in Input Capture mode, the following steps are mandatory: + (#) Enable TIM clock using RCC_APBxPeriphClockCmd(RCC_APBxPeriph_TIMx, ENABLE) + function. + (#) Configure the TIM pins by configuring the corresponding GPIO pins. + (#) Configure the Time base unit as described in the first part of this + driver, if needed, else the Timer will run with the default configuration: + (++) Autoreload value = 0xFFFF. + (++) Prescaler value = 0x0000. + (++) Counter mode = Up counting. + (++) Clock Division = TIM_CKD_DIV1. + (#) Fill the TIM_ICInitStruct with the desired parameters including: + (++) TIM Channel: TIM_Channel. + (++) TIM Input Capture polarity: TIM_ICPolarity. + (++) TIM Input Capture selection: TIM_ICSelection. + (++) TIM Input Capture Prescaler: TIM_ICPrescaler. + (++) TIM Input CApture filter value: TIM_ICFilter. + (#) Call TIM_ICInit(TIMx, &TIM_ICInitStruct) to configure the desired + channel with the corresponding configuration and to measure only + frequency or duty cycle of the input signal,or, Call + TIM_PWMIConfig(TIMx, &TIM_ICInitStruct) to configure the desired + channels with the corresponding configuration and to measure the + frequency and the duty cycle of the input signal. + (#) Enable the NVIC or the DMA to read the measured frequency. + (#) Enable the corresponding interrupt (or DMA request) to read + the Captured value, using the function TIM_ITConfig(TIMx, TIM_IT_CCx) + (or TIM_DMA_Cmd(TIMx, TIM_DMA_CCx)). + (#) Call the TIM_Cmd(ENABLE) function to enable the TIM counter. + (#) Use TIM_GetCapturex(TIMx); to read the captured value. + [..] + (@) All other functions can be used separately to modify, if needed, + a specific feature of the Timer. + +@endverbatim + * @{ + */ + +/** + * @brief Initializes the TIM peripheral according to the specified + * parameters in the TIM_ICInitStruct. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ICInitStruct: pointer to a TIM_ICInitTypeDef structure + * that contains the configuration information for the specified TIM + * peripheral. + * @retval None + */ +void TIM_ICInit(TIM_TypeDef* TIMx, TIM_ICInitTypeDef* TIM_ICInitStruct) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_CHANNEL(TIM_ICInitStruct->TIM_Channel)); + assert_param(IS_TIM_IC_SELECTION(TIM_ICInitStruct->TIM_ICSelection)); + assert_param(IS_TIM_IC_PRESCALER(TIM_ICInitStruct->TIM_ICPrescaler)); + assert_param(IS_TIM_IC_FILTER(TIM_ICInitStruct->TIM_ICFilter)); + assert_param(IS_TIM_IC_POLARITY(TIM_ICInitStruct->TIM_ICPolarity)); + + if (TIM_ICInitStruct->TIM_Channel == TIM_Channel_1) + { + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + /* TI1 Configuration */ + TI1_Config(TIMx, TIM_ICInitStruct->TIM_ICPolarity, + TIM_ICInitStruct->TIM_ICSelection, + TIM_ICInitStruct->TIM_ICFilter); + /* Set the Input Capture Prescaler value */ + TIM_SetIC1Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler); + } + else if (TIM_ICInitStruct->TIM_Channel == TIM_Channel_2) + { + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + /* TI2 Configuration */ + TI2_Config(TIMx, TIM_ICInitStruct->TIM_ICPolarity, + TIM_ICInitStruct->TIM_ICSelection, + TIM_ICInitStruct->TIM_ICFilter); + /* Set the Input Capture Prescaler value */ + TIM_SetIC2Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler); + } + else if (TIM_ICInitStruct->TIM_Channel == TIM_Channel_3) + { + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + /* TI3 Configuration */ + TI3_Config(TIMx, TIM_ICInitStruct->TIM_ICPolarity, + TIM_ICInitStruct->TIM_ICSelection, + TIM_ICInitStruct->TIM_ICFilter); + /* Set the Input Capture Prescaler value */ + TIM_SetIC3Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler); + } + else + { + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + /* TI4 Configuration */ + TI4_Config(TIMx, TIM_ICInitStruct->TIM_ICPolarity, + TIM_ICInitStruct->TIM_ICSelection, + TIM_ICInitStruct->TIM_ICFilter); + /* Set the Input Capture Prescaler value */ + TIM_SetIC4Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler); + } +} + +/** + * @brief Fills each TIM_ICInitStruct member with its default value. + * @param TIM_ICInitStruct: pointer to a TIM_ICInitTypeDef structure which will + * be initialized. + * @retval None + */ +void TIM_ICStructInit(TIM_ICInitTypeDef* TIM_ICInitStruct) +{ + /* Set the default configuration */ + TIM_ICInitStruct->TIM_Channel = TIM_Channel_1; + TIM_ICInitStruct->TIM_ICPolarity = TIM_ICPolarity_Rising; + TIM_ICInitStruct->TIM_ICSelection = TIM_ICSelection_DirectTI; + TIM_ICInitStruct->TIM_ICPrescaler = TIM_ICPSC_DIV1; + TIM_ICInitStruct->TIM_ICFilter = 0x00; +} + +/** + * @brief Configures the TIM peripheral according to the specified + * parameters in the TIM_ICInitStruct to measure an external PWM signal. + * @param TIMx: where x can be 1, 2, 3 or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ICInitStruct: pointer to a TIM_ICInitTypeDef structure + * that contains the configuration information for the specified TIM + * peripheral. + * @retval None + */ +void TIM_PWMIConfig(TIM_TypeDef* TIMx, TIM_ICInitTypeDef* TIM_ICInitStruct) +{ + uint16_t icoppositepolarity = TIM_ICPolarity_Rising; + uint16_t icoppositeselection = TIM_ICSelection_DirectTI; + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + /* Select the Opposite Input Polarity */ + if (TIM_ICInitStruct->TIM_ICPolarity == TIM_ICPolarity_Rising) + { + icoppositepolarity = TIM_ICPolarity_Falling; + } + else + { + icoppositepolarity = TIM_ICPolarity_Rising; + } + /* Select the Opposite Input */ + if (TIM_ICInitStruct->TIM_ICSelection == TIM_ICSelection_DirectTI) + { + icoppositeselection = TIM_ICSelection_IndirectTI; + } + else + { + icoppositeselection = TIM_ICSelection_DirectTI; + } + if (TIM_ICInitStruct->TIM_Channel == TIM_Channel_1) + { + /* TI1 Configuration */ + TI1_Config(TIMx, TIM_ICInitStruct->TIM_ICPolarity, TIM_ICInitStruct->TIM_ICSelection, + TIM_ICInitStruct->TIM_ICFilter); + /* Set the Input Capture Prescaler value */ + TIM_SetIC1Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler); + /* TI2 Configuration */ + TI2_Config(TIMx, icoppositepolarity, icoppositeselection, TIM_ICInitStruct->TIM_ICFilter); + /* Set the Input Capture Prescaler value */ + TIM_SetIC2Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler); + } + else + { + /* TI2 Configuration */ + TI2_Config(TIMx, TIM_ICInitStruct->TIM_ICPolarity, TIM_ICInitStruct->TIM_ICSelection, + TIM_ICInitStruct->TIM_ICFilter); + /* Set the Input Capture Prescaler value */ + TIM_SetIC2Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler); + /* TI1 Configuration */ + TI1_Config(TIMx, icoppositepolarity, icoppositeselection, TIM_ICInitStruct->TIM_ICFilter); + /* Set the Input Capture Prescaler value */ + TIM_SetIC1Prescaler(TIMx, TIM_ICInitStruct->TIM_ICPrescaler); + } +} + +/** + * @brief Gets the TIMx Input Capture 1 value. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @retval Capture Compare 1 Register value. + */ +uint32_t TIM_GetCapture1(TIM_TypeDef* TIMx) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + + /* Get the Capture 1 Register value */ + return TIMx->CCR1; +} + +/** + * @brief Gets the TIMx Input Capture 2 value. + * @param TIMx: where x can be 1, 2, 3 or 15 to select the TIM peripheral. + * @retval Capture Compare 2 Register value. + */ +uint32_t TIM_GetCapture2(TIM_TypeDef* TIMx) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + + /* Get the Capture 2 Register value */ + return TIMx->CCR2; +} + +/** + * @brief Gets the TIMx Input Capture 3 value. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @retval Capture Compare 3 Register value. + */ +uint32_t TIM_GetCapture3(TIM_TypeDef* TIMx) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + + /* Get the Capture 3 Register value */ + return TIMx->CCR3; +} + +/** + * @brief Gets the TIMx Input Capture 4 value. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @retval Capture Compare 4 Register value. + */ +uint32_t TIM_GetCapture4(TIM_TypeDef* TIMx) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + + /* Get the Capture 4 Register value */ + return TIMx->CCR4; +} + +/** + * @brief Sets the TIMx Input Capture 1 prescaler. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ICPSC: specifies the Input Capture1 prescaler new value. + * This parameter can be one of the following values: + * @arg TIM_ICPSC_DIV1: no prescaler + * @arg TIM_ICPSC_DIV2: capture is done once every 2 events + * @arg TIM_ICPSC_DIV4: capture is done once every 4 events + * @arg TIM_ICPSC_DIV8: capture is done once every 8 events + * @retval None + */ +void TIM_SetIC1Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_IC_PRESCALER(TIM_ICPSC)); + + /* Reset the IC1PSC Bits */ + TIMx->CCMR1 &= (uint16_t)~((uint16_t)TIM_CCMR1_IC1PSC); + /* Set the IC1PSC value */ + TIMx->CCMR1 |= TIM_ICPSC; +} + +/** + * @brief Sets the TIMx Input Capture 2 prescaler. + * @param TIMx: where x can be 1, 2, 3 or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ICPSC: specifies the Input Capture2 prescaler new value. + * This parameter can be one of the following values: + * @arg TIM_ICPSC_DIV1: no prescaler + * @arg TIM_ICPSC_DIV2: capture is done once every 2 events + * @arg TIM_ICPSC_DIV4: capture is done once every 4 events + * @arg TIM_ICPSC_DIV8: capture is done once every 8 events + * @retval None + */ +void TIM_SetIC2Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_IC_PRESCALER(TIM_ICPSC)); + + /* Reset the IC2PSC Bits */ + TIMx->CCMR1 &= (uint16_t)~((uint16_t)TIM_CCMR1_IC2PSC); + /* Set the IC2PSC value */ + TIMx->CCMR1 |= (uint16_t)(TIM_ICPSC << 8); +} + +/** + * @brief Sets the TIMx Input Capture 3 prescaler. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ICPSC: specifies the Input Capture3 prescaler new value. + * This parameter can be one of the following values: + * @arg TIM_ICPSC_DIV1: no prescaler + * @arg TIM_ICPSC_DIV2: capture is done once every 2 events + * @arg TIM_ICPSC_DIV4: capture is done once every 4 events + * @arg TIM_ICPSC_DIV8: capture is done once every 8 events + * @retval None + */ +void TIM_SetIC3Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_IC_PRESCALER(TIM_ICPSC)); + + /* Reset the IC3PSC Bits */ + TIMx->CCMR2 &= (uint16_t)~((uint16_t)TIM_CCMR2_IC3PSC); + /* Set the IC3PSC value */ + TIMx->CCMR2 |= TIM_ICPSC; +} + +/** + * @brief Sets the TIMx Input Capture 4 prescaler. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ICPSC: specifies the Input Capture4 prescaler new value. + * This parameter can be one of the following values: + * @arg TIM_ICPSC_DIV1: no prescaler + * @arg TIM_ICPSC_DIV2: capture is done once every 2 events + * @arg TIM_ICPSC_DIV4: capture is done once every 4 events + * @arg TIM_ICPSC_DIV8: capture is done once every 8 events + * @retval None + */ +void TIM_SetIC4Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_IC_PRESCALER(TIM_ICPSC)); + + /* Reset the IC4PSC Bits */ + TIMx->CCMR2 &= (uint16_t)~((uint16_t)TIM_CCMR2_IC4PSC); + /* Set the IC4PSC value */ + TIMx->CCMR2 |= (uint16_t)(TIM_ICPSC << 8); +} + +/** + * @} + */ + +/** @defgroup TIM_Group5 Interrupts DMA and flags management functions + * @brief Interrupts, DMA and flags management functions + * +@verbatim + =============================================================================== + ##### Interrupts, DMA and flags management functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified TIM interrupts. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 or 17 to select the TIMx peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_IT: specifies the TIM interrupts sources to be enabled or disabled. + * This parameter can be any combination of the following values: + * @arg TIM_IT_Update: TIM update Interrupt source + * @arg TIM_IT_CC1: TIM Capture Compare 1 Interrupt source + * @arg TIM_IT_CC2: TIM Capture Compare 2 Interrupt source + * @arg TIM_IT_CC3: TIM Capture Compare 3 Interrupt source + * @arg TIM_IT_CC4: TIM Capture Compare 4 Interrupt source + * @arg TIM_IT_COM: TIM Commutation Interrupt source + * @arg TIM_IT_Trigger: TIM Trigger Interrupt source + * @arg TIM_IT_Break: TIM Break Interrupt source + * + * @note TIM6 and TIM7 can only generate an update interrupt. + * @note TIM15 can have only TIM_IT_Update, TIM_IT_CC1,TIM_IT_CC2 or TIM_IT_Trigger. + * @note TIM14, TIM16 and TIM17 can have TIM_IT_Update or TIM_IT_CC1. + * @note TIM_IT_Break is used only with TIM1 and TIM15. + * @note TIM_IT_COM is used only with TIM1, TIM15, TIM16 and TIM17. + * + * @param NewState: new state of the TIM interrupts. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void TIM_ITConfig(TIM_TypeDef* TIMx, uint16_t TIM_IT, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_TIM_IT(TIM_IT)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the Interrupt sources */ + TIMx->DIER |= TIM_IT; + } + else + { + /* Disable the Interrupt sources */ + TIMx->DIER &= (uint16_t)~TIM_IT; + } +} + +/** + * @brief Configures the TIMx event to be generate by software. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 or 17 to select the + * TIM peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_EventSource: specifies the event source. + * This parameter can be one or more of the following values: + * @arg TIM_EventSource_Update: Timer update Event source + * @arg TIM_EventSource_CC1: Timer Capture Compare 1 Event source + * @arg TIM_EventSource_CC2: Timer Capture Compare 2 Event source + * @arg TIM_EventSource_CC3: Timer Capture Compare 3 Event source + * @arg TIM_EventSource_CC4: Timer Capture Compare 4 Event source + * @arg TIM_EventSource_COM: Timer COM event source + * @arg TIM_EventSource_Trigger: Timer Trigger Event source + * @arg TIM_EventSource_Break: Timer Break event source + * + * @note TIM6 and TIM7 can only generate an update event. + * @note TIM_EventSource_COM and TIM_EventSource_Break are used only with TIM1. + * + * @retval None + */ +void TIM_GenerateEvent(TIM_TypeDef* TIMx, uint16_t TIM_EventSource) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_TIM_EVENT_SOURCE(TIM_EventSource)); + /* Set the event sources */ + TIMx->EGR = TIM_EventSource; +} + +/** + * @brief Checks whether the specified TIM flag is set or not. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg TIM_FLAG_Update: TIM update Flag + * @arg TIM_FLAG_CC1: TIM Capture Compare 1 Flag + * @arg TIM_FLAG_CC2: TIM Capture Compare 2 Flag + * @arg TIM_FLAG_CC3: TIM Capture Compare 3 Flag + * @arg TIM_FLAG_CC4: TIM Capture Compare 4 Flag + * @arg TIM_FLAG_COM: TIM Commutation Flag + * @arg TIM_FLAG_Trigger: TIM Trigger Flag + * @arg TIM_FLAG_Break: TIM Break Flag + * @arg TIM_FLAG_CC1OF: TIM Capture Compare 1 overcapture Flag + * @arg TIM_FLAG_CC2OF: TIM Capture Compare 2 overcapture Flag + * @arg TIM_FLAG_CC3OF: TIM Capture Compare 3 overcapture Flag + * @arg TIM_FLAG_CC4OF: TIM Capture Compare 4 overcapture Flag + * + * @note TIM6 and TIM7 can have only one update flag. + * @note TIM15 can have only TIM_FLAG_Update, TIM_FLAG_CC1, TIM_FLAG_CC2 or TIM_FLAG_Trigger. + * @note TIM14, TIM16 and TIM17 can have TIM_FLAG_Update or TIM_FLAG_CC1. + * @note TIM_FLAG_Break is used only with TIM1 and TIM15. + * @note TIM_FLAG_COM is used only with TIM1 TIM15, TIM16 and TIM17. + * + * @retval The new state of TIM_FLAG (SET or RESET). + */ +FlagStatus TIM_GetFlagStatus(TIM_TypeDef* TIMx, uint16_t TIM_FLAG) +{ + ITStatus bitstatus = RESET; + + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_TIM_GET_FLAG(TIM_FLAG)); + + if ((TIMx->SR & TIM_FLAG) != (uint16_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + return bitstatus; +} + +/** + * @brief Clears the TIMx's pending flags. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_FLAG: specifies the flag bit to clear. + * This parameter can be any combination of the following values: + * @arg TIM_FLAG_Update: TIM update Flag + * @arg TIM_FLAG_CC1: TIM Capture Compare 1 Flag + * @arg TIM_FLAG_CC2: TIM Capture Compare 2 Flag + * @arg TIM_FLAG_CC3: TIM Capture Compare 3 Flag + * @arg TIM_FLAG_CC4: TIM Capture Compare 4 Flag + * @arg TIM_FLAG_COM: TIM Commutation Flag + * @arg TIM_FLAG_Trigger: TIM Trigger Flag + * @arg TIM_FLAG_Break: TIM Break Flag + * @arg TIM_FLAG_CC1OF: TIM Capture Compare 1 overcapture Flag + * @arg TIM_FLAG_CC2OF: TIM Capture Compare 2 overcapture Flag + * @arg TIM_FLAG_CC3OF: TIM Capture Compare 3 overcapture Flag + * @arg TIM_FLAG_CC4OF: TIM Capture Compare 4 overcapture Flag + * + * @note TIM6 and TIM7 can have only one update flag. + * @note TIM15 can have only TIM_FLAG_Update, TIM_FLAG_CC1,TIM_FLAG_CC2 or + * TIM_FLAG_Trigger. + * @note TIM14, TIM16 and TIM17 can have TIM_FLAG_Update or TIM_FLAG_CC1. + * @note TIM_FLAG_Break is used only with TIM1 and TIM15. + * @note TIM_FLAG_COM is used only with TIM1, TIM15, TIM16 and TIM17. + * + * @retval None + */ +void TIM_ClearFlag(TIM_TypeDef* TIMx, uint16_t TIM_FLAG) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_TIM_CLEAR_FLAG(TIM_FLAG)); + + /* Clear the flags */ + TIMx->SR = (uint16_t)~TIM_FLAG; +} + +/** + * @brief Checks whether the TIM interrupt has occurred or not. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_IT: specifies the TIM interrupt source to check. + * This parameter can be one of the following values: + * @arg TIM_IT_Update: TIM update Interrupt source + * @arg TIM_IT_CC1: TIM Capture Compare 1 Interrupt source + * @arg TIM_IT_CC2: TIM Capture Compare 2 Interrupt source + * @arg TIM_IT_CC3: TIM Capture Compare 3 Interrupt source + * @arg TIM_IT_CC4: TIM Capture Compare 4 Interrupt source + * @arg TIM_IT_COM: TIM Commutation Interrupt source + * @arg TIM_IT_Trigger: TIM Trigger Interrupt source + * @arg TIM_IT_Break: TIM Break Interrupt source + * + * @note TIM6 and TIM7 can generate only an update interrupt. + * @note TIM15 can have only TIM_IT_Update, TIM_IT_CC1, TIM_IT_CC2 or TIM_IT_Trigger. + * @note TIM14, TIM16 and TIM17 can have TIM_IT_Update or TIM_IT_CC1. + * @note TIM_IT_Break is used only with TIM1 and TIM15. + * @note TIM_IT_COM is used only with TIM1, TIM15, TIM16 and TIM17. + * + * @retval The new state of the TIM_IT(SET or RESET). + */ +ITStatus TIM_GetITStatus(TIM_TypeDef* TIMx, uint16_t TIM_IT) +{ + ITStatus bitstatus = RESET; + uint16_t itstatus = 0x0, itenable = 0x0; + + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_TIM_GET_IT(TIM_IT)); + + itstatus = TIMx->SR & TIM_IT; + + itenable = TIMx->DIER & TIM_IT; + if ((itstatus != (uint16_t)RESET) && (itenable != (uint16_t)RESET)) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + return bitstatus; +} + +/** + * @brief Clears the TIMx's interrupt pending bits. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_IT: specifies the pending bit to clear. + * This parameter can be any combination of the following values: + * @arg TIM_IT_Update: TIM1 update Interrupt source + * @arg TIM_IT_CC1: TIM Capture Compare 1 Interrupt source + * @arg TIM_IT_CC2: TIM Capture Compare 2 Interrupt source + * @arg TIM_IT_CC3: TIM Capture Compare 3 Interrupt source + * @arg TIM_IT_CC4: TIM Capture Compare 4 Interrupt source + * @arg TIM_IT_COM: TIM Commutation Interrupt source + * @arg TIM_IT_Trigger: TIM Trigger Interrupt source + * @arg TIM_IT_Break: TIM Break Interrupt source + * + * @note TIM6 and TIM7 can generate only an update interrupt. + * @note TIM15 can have only TIM_IT_Update, TIM_IT_CC1, TIM_IT_CC2 or TIM_IT_Trigger. + * @note TIM14, TIM16 and TIM17 can have TIM_IT_Update or TIM_IT_CC1. + * @note TIM_IT_Break is used only with TIM1 and TIM15. + * @note TIM_IT_COM is used only with TIM1, TIM15, TIM16 and TIM17. + * + * @retval None + */ +void TIM_ClearITPendingBit(TIM_TypeDef* TIMx, uint16_t TIM_IT) +{ + /* Check the parameters */ + assert_param(IS_TIM_ALL_PERIPH(TIMx)); + assert_param(IS_TIM_IT(TIM_IT)); + + /* Clear the IT pending Bit */ + TIMx->SR = (uint16_t)~TIM_IT; +} + +/** + * @brief Configures the TIMx's DMA interface. + * @param TIMx: where x can be 1, 2, 3, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_DMABase: DMA Base address. + * This parameter can be one of the following values: + * @arg TIM_DMABase_CR1 + * @arg TIM_DMABase_CR2 + * @arg TIM_DMABase_SMCR + * @arg TIM_DMABase_DIER + * @arg TIM_DMABase_SR + * @arg TIM_DMABase_EGR + * @arg TIM_DMABase_CCMR1 + * @arg TIM_DMABase_CCMR2 + * @arg TIM_DMABase_CCER + * @arg TIM_DMABase_CNT + * @arg TIM_DMABase_PSC + * @arg TIM_DMABase_ARR + * @arg TIM_DMABase_CCR1 + * @arg TIM_DMABase_CCR2 + * @arg TIM_DMABase_CCR3 + * @arg TIM_DMABase_CCR4 + * @arg TIM_DMABase_DCR + * @arg TIM_DMABase_OR + * @param TIM_DMABurstLength: DMA Burst length. This parameter can be one value + * between: TIM_DMABurstLength_1Transfer and TIM_DMABurstLength_18Transfers. + * @retval None + */ +void TIM_DMAConfig(TIM_TypeDef* TIMx, uint16_t TIM_DMABase, uint16_t TIM_DMABurstLength) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST4_PERIPH(TIMx)); + assert_param(IS_TIM_DMA_BASE(TIM_DMABase)); + assert_param(IS_TIM_DMA_LENGTH(TIM_DMABurstLength)); + /* Set the DMA Base and the DMA Burst Length */ + TIMx->DCR = TIM_DMABase | TIM_DMABurstLength; +} + +/** + * @brief Enables or disables the TIMx's DMA Requests. + * @param TIMx: where x can be 1, 2, 3, 6, 7, 15, 16 or 17 to select the TIM peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_DMASource: specifies the DMA Request sources. + * This parameter can be any combination of the following values: + * @arg TIM_DMA_Update: TIM update Interrupt source + * @arg TIM_DMA_CC1: TIM Capture Compare 1 DMA source + * @arg TIM_DMA_CC2: TIM Capture Compare 2 DMA source + * @arg TIM_DMA_CC3: TIM Capture Compare 3 DMA source + * @arg TIM_DMA_CC4: TIM Capture Compare 4 DMA source + * @arg TIM_DMA_COM: TIM Commutation DMA source + * @arg TIM_DMA_Trigger: TIM Trigger DMA source + * @param NewState: new state of the DMA Request sources. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void TIM_DMACmd(TIM_TypeDef* TIMx, uint16_t TIM_DMASource, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST10_PERIPH(TIMx)); + assert_param(IS_TIM_DMA_SOURCE(TIM_DMASource)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the DMA sources */ + TIMx->DIER |= TIM_DMASource; + } + else + { + /* Disable the DMA sources */ + TIMx->DIER &= (uint16_t)~TIM_DMASource; + } +} + +/** + * @brief Selects the TIMx peripheral Capture Compare DMA source. + * @param TIMx: where x can be 1, 2, 3, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param NewState: new state of the Capture Compare DMA source + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void TIM_SelectCCDMA(TIM_TypeDef* TIMx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST5_PERIPH(TIMx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Set the CCDS Bit */ + TIMx->CR2 |= TIM_CR2_CCDS; + } + else + { + /* Reset the CCDS Bit */ + TIMx->CR2 &= (uint16_t)~((uint16_t)TIM_CR2_CCDS); + } +} + +/** + * @} + */ + +/** @defgroup TIM_Group6 Clocks management functions + * @brief Clocks management functions + * +@verbatim + =============================================================================== + ##### Clocks management functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Configures the TIMx internal Clock + * @param TIMx: where x can be 1, 2, 3, or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @retval None + */ +void TIM_InternalClockConfig(TIM_TypeDef* TIMx) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + /* Disable slave mode to clock the prescaler directly with the internal clock */ + TIMx->SMCR &= (uint16_t)(~((uint16_t)TIM_SMCR_SMS)); +} + +/** + * @brief Configures the TIMx Internal Trigger as External Clock + * @param TIMx: where x can be 1, 2, 3, or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ITRSource: Trigger source. + * This parameter can be one of the following values: + * @arg TIM_TS_ITR0: Internal Trigger 0 + * @arg TIM_TS_ITR1: Internal Trigger 1 + * @arg TIM_TS_ITR2: Internal Trigger 2 + * @arg TIM_TS_ITR3: Internal Trigger 3 + * @retval None + */ +void TIM_ITRxExternalClockConfig(TIM_TypeDef* TIMx, uint16_t TIM_InputTriggerSource) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_INTERNAL_TRIGGER_SELECTION(TIM_InputTriggerSource)); + /* Select the Internal Trigger */ + TIM_SelectInputTrigger(TIMx, TIM_InputTriggerSource); + /* Select the External clock mode1 */ + TIMx->SMCR |= TIM_SlaveMode_External1; +} + +/** + * @brief Configures the TIMx Trigger as External Clock + * @param TIMx: where x can be 1, 2, 3, or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_TIxExternalCLKSource: Trigger source. + * This parameter can be one of the following values: + * @arg TIM_TIxExternalCLK1Source_TI1ED: TI1 Edge Detector + * @arg TIM_TIxExternalCLK1Source_TI1: Filtered Timer Input 1 + * @arg TIM_TIxExternalCLK1Source_TI2: Filtered Timer Input 2 + * @param TIM_ICPolarity: specifies the TIx Polarity. + * This parameter can be one of the following values: + * @arg TIM_ICPolarity_Rising + * @arg TIM_ICPolarity_Falling + * @param ICFilter: specifies the filter value. + * This parameter must be a value between 0x0 and 0xF. + * @retval None + */ +void TIM_TIxExternalClockConfig(TIM_TypeDef* TIMx, uint16_t TIM_TIxExternalCLKSource, + uint16_t TIM_ICPolarity, uint16_t ICFilter) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_IC_POLARITY(TIM_ICPolarity)); + assert_param(IS_TIM_IC_FILTER(ICFilter)); + + /* Configure the Timer Input Clock Source */ + if (TIM_TIxExternalCLKSource == TIM_TIxExternalCLK1Source_TI2) + { + TI2_Config(TIMx, TIM_ICPolarity, TIM_ICSelection_DirectTI, ICFilter); + } + else + { + TI1_Config(TIMx, TIM_ICPolarity, TIM_ICSelection_DirectTI, ICFilter); + } + /* Select the Trigger source */ + TIM_SelectInputTrigger(TIMx, TIM_TIxExternalCLKSource); + /* Select the External clock mode1 */ + TIMx->SMCR |= TIM_SlaveMode_External1; +} + +/** + * @brief Configures the External clock Mode1 + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ExtTRGPrescaler: The external Trigger Prescaler. + * This parameter can be one of the following values: + * @arg TIM_ExtTRGPSC_OFF: ETRP Prescaler OFF. + * @arg TIM_ExtTRGPSC_DIV2: ETRP frequency divided by 2. + * @arg TIM_ExtTRGPSC_DIV4: ETRP frequency divided by 4. + * @arg TIM_ExtTRGPSC_DIV8: ETRP frequency divided by 8. + * @param TIM_ExtTRGPolarity: The external Trigger Polarity. + * This parameter can be one of the following values: + * @arg TIM_ExtTRGPolarity_Inverted: active low or falling edge active. + * @arg TIM_ExtTRGPolarity_NonInverted: active high or rising edge active. + * @param ExtTRGFilter: External Trigger Filter. + * This parameter must be a value between 0x00 and 0x0F + * @retval None + */ +void TIM_ETRClockMode1Config(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, uint16_t TIM_ExtTRGPolarity, + uint16_t ExtTRGFilter) +{ + uint16_t tmpsmcr = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_EXT_PRESCALER(TIM_ExtTRGPrescaler)); + assert_param(IS_TIM_EXT_POLARITY(TIM_ExtTRGPolarity)); + assert_param(IS_TIM_EXT_FILTER(ExtTRGFilter)); + + /* Configure the ETR Clock source */ + TIM_ETRConfig(TIMx, TIM_ExtTRGPrescaler, TIM_ExtTRGPolarity, ExtTRGFilter); + + /* Get the TIMx SMCR register value */ + tmpsmcr = TIMx->SMCR; + /* Reset the SMS Bits */ + tmpsmcr &= (uint16_t)(~((uint16_t)TIM_SMCR_SMS)); + /* Select the External clock mode1 */ + tmpsmcr |= TIM_SlaveMode_External1; + /* Select the Trigger selection : ETRF */ + tmpsmcr &= (uint16_t)(~((uint16_t)TIM_SMCR_TS)); + tmpsmcr |= TIM_TS_ETRF; + /* Write to TIMx SMCR */ + TIMx->SMCR = tmpsmcr; +} + +/** + * @brief Configures the External clock Mode2 + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ExtTRGPrescaler: The external Trigger Prescaler. + * This parameter can be one of the following values: + * @arg TIM_ExtTRGPSC_OFF: ETRP Prescaler OFF. + * @arg TIM_ExtTRGPSC_DIV2: ETRP frequency divided by 2. + * @arg TIM_ExtTRGPSC_DIV4: ETRP frequency divided by 4. + * @arg TIM_ExtTRGPSC_DIV8: ETRP frequency divided by 8. + * @param TIM_ExtTRGPolarity: The external Trigger Polarity. + * This parameter can be one of the following values: + * @arg TIM_ExtTRGPolarity_Inverted: active low or falling edge active. + * @arg TIM_ExtTRGPolarity_NonInverted: active high or rising edge active. + * @param ExtTRGFilter: External Trigger Filter. + * This parameter must be a value between 0x00 and 0x0F + * @retval None + */ +void TIM_ETRClockMode2Config(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, + uint16_t TIM_ExtTRGPolarity, uint16_t ExtTRGFilter) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_EXT_PRESCALER(TIM_ExtTRGPrescaler)); + assert_param(IS_TIM_EXT_POLARITY(TIM_ExtTRGPolarity)); + assert_param(IS_TIM_EXT_FILTER(ExtTRGFilter)); + + /* Configure the ETR Clock source */ + TIM_ETRConfig(TIMx, TIM_ExtTRGPrescaler, TIM_ExtTRGPolarity, ExtTRGFilter); + /* Enable the External clock mode2 */ + TIMx->SMCR |= TIM_SMCR_ECE; +} + +/** + * @} + */ + +/** @defgroup TIM_Group7 Synchronization management functions + * @brief Synchronization management functions + * +@verbatim + =============================================================================== + ##### Synchronization management functions ##### + =============================================================================== + *** TIM Driver: how to use it in synchronization Mode *** + =============================================================================== + [..] Case of two/several Timers + (#) Configure the Master Timers using the following functions: + (++) void TIM_SelectOutputTrigger(TIM_TypeDef* TIMx, + uint16_t TIM_TRGOSource). + (++) void TIM_SelectMasterSlaveMode(TIM_TypeDef* TIMx, + uint16_t TIM_MasterSlaveMode); + (#) Configure the Slave Timers using the following functions: + (++) void TIM_SelectInputTrigger(TIM_TypeDef* TIMx, + uint16_t TIM_InputTriggerSource); + (++) void TIM_SelectSlaveMode(TIM_TypeDef* TIMx, uint16_t TIM_SlaveMode); + [..] Case of Timers and external trigger(ETR pin) + (#) Configure the Etrenal trigger using this function: + (++) void TIM_ETRConfig(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, + uint16_t TIM_ExtTRGPolarity, uint16_t ExtTRGFilter); + (#) Configure the Slave Timers using the following functions: + (++) void TIM_SelectInputTrigger(TIM_TypeDef* TIMx, + uint16_t TIM_InputTriggerSource); + (++) void TIM_SelectSlaveMode(TIM_TypeDef* TIMx, uint16_t TIM_SlaveMode); + +@endverbatim + * @{ + */ +/** + * @brief Selects the Input Trigger source + * @param TIMx: where x can be 1, 2, 3 or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_InputTriggerSource: The Input Trigger source. + * This parameter can be one of the following values: + * @arg TIM_TS_ITR0: Internal Trigger 0 + * @arg TIM_TS_ITR1: Internal Trigger 1 + * @arg TIM_TS_ITR2: Internal Trigger 2 + * @arg TIM_TS_ITR3: Internal Trigger 3 + * @arg TIM_TS_TI1F_ED: TI1 Edge Detector + * @arg TIM_TS_TI1FP1: Filtered Timer Input 1 + * @arg TIM_TS_TI2FP2: Filtered Timer Input 2 + * @arg TIM_TS_ETRF: External Trigger input + * @retval None + */ +void TIM_SelectInputTrigger(TIM_TypeDef* TIMx, uint16_t TIM_InputTriggerSource) +{ + uint16_t tmpsmcr = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_TRIGGER_SELECTION(TIM_InputTriggerSource)); + + /* Get the TIMx SMCR register value */ + tmpsmcr = TIMx->SMCR; + /* Reset the TS Bits */ + tmpsmcr &= (uint16_t)(~((uint16_t)TIM_SMCR_TS)); + /* Set the Input Trigger source */ + tmpsmcr |= TIM_InputTriggerSource; + /* Write to TIMx SMCR */ + TIMx->SMCR = tmpsmcr; +} + +/** + * @brief Selects the TIMx Trigger Output Mode. + * @param TIMx: where x can be 1, 2, 3, 6, 7, or 15 to select the TIM peripheral. + * @note TIM7 is applicable only for STM32F072 devices + * @note TIM6 is not applivable for STM32F031 devices. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_TRGOSource: specifies the Trigger Output source. + * This parameter can be one of the following values: + * + * - For all TIMx + * @arg TIM_TRGOSource_Reset: The UG bit in the TIM_EGR register is used as the trigger output (TRGO). + * @arg TIM_TRGOSource_Enable: The Counter Enable CEN is used as the trigger output (TRGO). + * @arg TIM_TRGOSource_Update: The update event is selected as the trigger output (TRGO). + * + * - For all TIMx except TIM6 and TIM7 + * @arg TIM_TRGOSource_OC1: The trigger output sends a positive pulse when the CC1IF flag + * is to be set, as soon as a capture or compare match occurs (TRGO). + * @arg TIM_TRGOSource_OC1Ref: OC1REF signal is used as the trigger output (TRGO). + * @arg TIM_TRGOSource_OC2Ref: OC2REF signal is used as the trigger output (TRGO). + * @arg TIM_TRGOSource_OC3Ref: OC3REF signal is used as the trigger output (TRGO). + * @arg TIM_TRGOSource_OC4Ref: OC4REF signal is used as the trigger output (TRGO). + * + * @retval None + */ +void TIM_SelectOutputTrigger(TIM_TypeDef* TIMx, uint16_t TIM_TRGOSource) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST9_PERIPH(TIMx)); + assert_param(IS_TIM_TRGO_SOURCE(TIM_TRGOSource)); + + /* Reset the MMS Bits */ + TIMx->CR2 &= (uint16_t)~((uint16_t)TIM_CR2_MMS); + /* Select the TRGO source */ + TIMx->CR2 |= TIM_TRGOSource; +} + +/** + * @brief Selects the TIMx Slave Mode. + * @param TIMx: where x can be 1, 2, 3 or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_SlaveMode: specifies the Timer Slave Mode. + * This parameter can be one of the following values: + * @arg TIM_SlaveMode_Reset: Rising edge of the selected trigger signal (TRGI) re-initializes + * the counter and triggers an update of the registers. + * @arg TIM_SlaveMode_Gated: The counter clock is enabled when the trigger signal (TRGI) is high. + * @arg TIM_SlaveMode_Trigger: The counter starts at a rising edge of the trigger TRGI. + * @arg TIM_SlaveMode_External1: Rising edges of the selected trigger (TRGI) clock the counter. + * @retval None + */ +void TIM_SelectSlaveMode(TIM_TypeDef* TIMx, uint16_t TIM_SlaveMode) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_SLAVE_MODE(TIM_SlaveMode)); + + /* Reset the SMS Bits */ + TIMx->SMCR &= (uint16_t)~((uint16_t)TIM_SMCR_SMS); + /* Select the Slave Mode */ + TIMx->SMCR |= TIM_SlaveMode; +} + +/** + * @brief Sets or Resets the TIMx Master/Slave Mode. + * @param TIMx: where x can be 1, 2, 3, or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_MasterSlaveMode: specifies the Timer Master Slave Mode. + * This parameter can be one of the following values: + * @arg TIM_MasterSlaveMode_Enable: synchronization between the current timer + * and its slaves (through TRGO). + * @arg TIM_MasterSlaveMode_Disable: No action + * @retval None + */ +void TIM_SelectMasterSlaveMode(TIM_TypeDef* TIMx, uint16_t TIM_MasterSlaveMode) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST6_PERIPH(TIMx)); + assert_param(IS_TIM_MSM_STATE(TIM_MasterSlaveMode)); + + /* Reset the MSM Bit */ + TIMx->SMCR &= (uint16_t)~((uint16_t)TIM_SMCR_MSM); + + /* Set or Reset the MSM Bit */ + TIMx->SMCR |= TIM_MasterSlaveMode; +} + +/** + * @brief Configures the TIMx External Trigger (ETR). + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ExtTRGPrescaler: The external Trigger Prescaler. + * This parameter can be one of the following values: + * @arg TIM_ExtTRGPSC_OFF: ETRP Prescaler OFF. + * @arg TIM_ExtTRGPSC_DIV2: ETRP frequency divided by 2. + * @arg TIM_ExtTRGPSC_DIV4: ETRP frequency divided by 4. + * @arg TIM_ExtTRGPSC_DIV8: ETRP frequency divided by 8. + * @param TIM_ExtTRGPolarity: The external Trigger Polarity. + * This parameter can be one of the following values: + * @arg TIM_ExtTRGPolarity_Inverted: active low or falling edge active. + * @arg TIM_ExtTRGPolarity_NonInverted: active high or rising edge active. + * @param ExtTRGFilter: External Trigger Filter. + * This parameter must be a value between 0x00 and 0x0F + * @retval None + */ +void TIM_ETRConfig(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, uint16_t TIM_ExtTRGPolarity, + uint16_t ExtTRGFilter) +{ + uint16_t tmpsmcr = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_EXT_PRESCALER(TIM_ExtTRGPrescaler)); + assert_param(IS_TIM_EXT_POLARITY(TIM_ExtTRGPolarity)); + assert_param(IS_TIM_EXT_FILTER(ExtTRGFilter)); + + tmpsmcr = TIMx->SMCR; + /* Reset the ETR Bits */ + tmpsmcr &= SMCR_ETR_MASK; + /* Set the Prescaler, the Filter value and the Polarity */ + tmpsmcr |= (uint16_t)(TIM_ExtTRGPrescaler | (uint16_t)(TIM_ExtTRGPolarity | (uint16_t)(ExtTRGFilter << (uint16_t)8))); + /* Write to TIMx SMCR */ + TIMx->SMCR = tmpsmcr; +} + +/** + * @} + */ + +/** @defgroup TIM_Group8 Specific interface management functions + * @brief Specific interface management functions + * +@verbatim + =============================================================================== + ##### Specific interface management functions ##### + =============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Configures the TIMx Encoder Interface. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_EncoderMode: specifies the TIMx Encoder Mode. + * This parameter can be one of the following values: + * @arg TIM_EncoderMode_TI1: Counter counts on TI1FP1 edge depending on TI2FP2 level. + * @arg TIM_EncoderMode_TI2: Counter counts on TI2FP2 edge depending on TI1FP1 level. + * @arg TIM_EncoderMode_TI12: Counter counts on both TI1FP1 and TI2FP2 edges depending + * on the level of the other input. + * @param TIM_IC1Polarity: specifies the IC1 Polarity + * This parmeter can be one of the following values: + * @arg TIM_ICPolarity_Falling: IC Falling edge. + * @arg TIM_ICPolarity_Rising: IC Rising edge. + * @param TIM_IC2Polarity: specifies the IC2 Polarity + * This parmeter can be one of the following values: + * @arg TIM_ICPolarity_Falling: IC Falling edge. + * @arg TIM_ICPolarity_Rising: IC Rising edge. + * @retval None + */ +void TIM_EncoderInterfaceConfig(TIM_TypeDef* TIMx, uint16_t TIM_EncoderMode, + uint16_t TIM_IC1Polarity, uint16_t TIM_IC2Polarity) +{ + uint16_t tmpsmcr = 0; + uint16_t tmpccmr1 = 0; + uint16_t tmpccer = 0; + + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_TIM_ENCODER_MODE(TIM_EncoderMode)); + assert_param(IS_TIM_IC_POLARITY(TIM_IC1Polarity)); + assert_param(IS_TIM_IC_POLARITY(TIM_IC2Polarity)); + + /* Get the TIMx SMCR register value */ + tmpsmcr = TIMx->SMCR; + /* Get the TIMx CCMR1 register value */ + tmpccmr1 = TIMx->CCMR1; + /* Get the TIMx CCER register value */ + tmpccer = TIMx->CCER; + /* Set the encoder Mode */ + tmpsmcr &= (uint16_t)(~((uint16_t)TIM_SMCR_SMS)); + tmpsmcr |= TIM_EncoderMode; + /* Select the Capture Compare 1 and the Capture Compare 2 as input */ + tmpccmr1 &= (uint16_t)(((uint16_t)~((uint16_t)TIM_CCMR1_CC1S)) & (uint16_t)(~((uint16_t)TIM_CCMR1_CC2S))); + tmpccmr1 |= TIM_CCMR1_CC1S_0 | TIM_CCMR1_CC2S_0; + /* Set the TI1 and the TI2 Polarities */ + tmpccer &= (uint16_t)~((uint16_t)(TIM_CCER_CC1P | TIM_CCER_CC1NP)) & (uint16_t)~((uint16_t)(TIM_CCER_CC2P | TIM_CCER_CC2NP)); + tmpccer |= (uint16_t)(TIM_IC1Polarity | (uint16_t)(TIM_IC2Polarity << (uint16_t)4)); + /* Write to TIMx SMCR */ + TIMx->SMCR = tmpsmcr; + /* Write to TIMx CCMR1 */ + TIMx->CCMR1 = tmpccmr1; + /* Write to TIMx CCER */ + TIMx->CCER = tmpccer; +} + +/** + * @brief Enables or disables the TIMx's Hall sensor interface. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param NewState: new state of the TIMx Hall sensor interface. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void TIM_SelectHallSensor(TIM_TypeDef* TIMx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST3_PERIPH(TIMx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Set the TI1S Bit */ + TIMx->CR2 |= TIM_CR2_TI1S; + } + else + { + /* Reset the TI1S Bit */ + TIMx->CR2 &= (uint16_t)~((uint16_t)TIM_CR2_TI1S); + } +} + +/** + * @} + */ + +/** @defgroup TIM_Group9 Specific remapping management function + * @brief Specific remapping management function + * +@verbatim + =============================================================================== + ##### Specific remapping management function ##### + =============================================================================== + +@endverbatim + * @{ + */ +/** + * @brief Configures the TIM14 Remapping input Capabilities. + * @param TIMx: where x can be 14 to select the TIM peripheral. + * @param TIM_Remap: specifies the TIM input reampping source. + * This parameter can be one of the following values: + * @arg TIM14_GPIO: TIM14 Channel 1 is connected to GPIO. + * @arg TIM14_RTC_CLK: TIM14 Channel 1 is connected to RTC input clock. + * RTC input clock can be LSE, LSI or HSE/div128. + * @arg TIM14_HSE_DIV32: TIM14 Channel 1 is connected to HSE/32 clock. + * @arg TIM14_MCO: TIM14 Channel 1 is connected to MCO clock. + * MCO clock can be HSI14, SYSCLK, HSI, HSE or PLL/2. + * @retval None + */ +void TIM_RemapConfig(TIM_TypeDef* TIMx, uint16_t TIM_Remap) +{ + /* Check the parameters */ + assert_param(IS_TIM_LIST11_PERIPH(TIMx)); + assert_param(IS_TIM_REMAP(TIM_Remap)); + + /* Set the Timer remapping configuration */ + TIMx->OR = TIM_Remap; +} + +/** + * @} + */ + +/** + * @brief Configure the TI1 as Input. + * @param TIMx: where x can be 1, 2, 3, 14, 15, 16 or 17 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ICPolarity: The Input Polarity. + * This parameter can be one of the following values: + * @arg TIM_ICPolarity_Rising + * @arg TIM_ICPolarity_Falling + * @param TIM_ICSelection: specifies the input to be used. + * This parameter can be one of the following values: + * @arg TIM_ICSelection_DirectTI: TIM Input 1 is selected to be connected to IC1. + * @arg TIM_ICSelection_IndirectTI: TIM Input 1 is selected to be connected to IC2. + * @arg TIM_ICSelection_TRC: TIM Input 1 is selected to be connected to TRC. + * @param TIM_ICFilter: Specifies the Input Capture Filter. + * This parameter must be a value between 0x00 and 0x0F. + * @retval None + */ +static void TI1_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, + uint16_t TIM_ICFilter) +{ + uint16_t tmpccmr1 = 0, tmpccer = 0; + /* Disable the Channel 1: Reset the CC1E Bit */ + TIMx->CCER &= (uint16_t)~((uint16_t)TIM_CCER_CC1E); + tmpccmr1 = TIMx->CCMR1; + tmpccer = TIMx->CCER; + /* Select the Input and set the filter */ + tmpccmr1 &= (uint16_t)(((uint16_t)~((uint16_t)TIM_CCMR1_CC1S)) & ((uint16_t)~((uint16_t)TIM_CCMR1_IC1F))); + tmpccmr1 |= (uint16_t)(TIM_ICSelection | (uint16_t)(TIM_ICFilter << (uint16_t)4)); + + /* Select the Polarity and set the CC1E Bit */ + tmpccer &= (uint16_t)~((uint16_t)(TIM_CCER_CC1P | TIM_CCER_CC1NP)); + tmpccer |= (uint16_t)(TIM_ICPolarity | (uint16_t)TIM_CCER_CC1E); + /* Write to TIMx CCMR1 and CCER registers */ + TIMx->CCMR1 = tmpccmr1; + TIMx->CCER = tmpccer; +} + +/** + * @brief Configure the TI2 as Input. + * @param TIMx: where x can be 1, 2, 3, or 15 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ICPolarity: The Input Polarity. + * This parameter can be one of the following values: + * @arg TIM_ICPolarity_Rising + * @arg TIM_ICPolarity_Falling + * @param TIM_ICSelection: specifies the input to be used. + * This parameter can be one of the following values: + * @arg TIM_ICSelection_DirectTI: TIM Input 2 is selected to be connected to IC2. + * @arg TIM_ICSelection_IndirectTI: TIM Input 2 is selected to be connected to IC1. + * @arg TIM_ICSelection_TRC: TIM Input 2 is selected to be connected to TRC. + * @param TIM_ICFilter: Specifies the Input Capture Filter. + * This parameter must be a value between 0x00 and 0x0F. + * @retval None + */ +static void TI2_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, + uint16_t TIM_ICFilter) +{ + uint16_t tmpccmr1 = 0, tmpccer = 0, tmp = 0; + /* Disable the Channel 2: Reset the CC2E Bit */ + TIMx->CCER &= (uint16_t)~((uint16_t)TIM_CCER_CC2E); + tmpccmr1 = TIMx->CCMR1; + tmpccer = TIMx->CCER; + tmp = (uint16_t)(TIM_ICPolarity << 4); + /* Select the Input and set the filter */ + tmpccmr1 &= (uint16_t)(((uint16_t)~((uint16_t)TIM_CCMR1_CC2S)) & ((uint16_t)~((uint16_t)TIM_CCMR1_IC2F))); + tmpccmr1 |= (uint16_t)(TIM_ICFilter << 12); + tmpccmr1 |= (uint16_t)(TIM_ICSelection << 8); + /* Select the Polarity and set the CC2E Bit */ + tmpccer &= (uint16_t)~((uint16_t)(TIM_CCER_CC2P | TIM_CCER_CC2NP)); + tmpccer |= (uint16_t)(tmp | (uint16_t)TIM_CCER_CC2E); + /* Write to TIMx CCMR1 and CCER registers */ + TIMx->CCMR1 = tmpccmr1 ; + TIMx->CCER = tmpccer; +} + +/** + * @brief Configure the TI3 as Input. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ICPolarity: The Input Polarity. + * This parameter can be one of the following values: + * @arg TIM_ICPolarity_Rising + * @arg TIM_ICPolarity_Falling + * @param TIM_ICSelection: specifies the input to be used. + * This parameter can be one of the following values: + * @arg TIM_ICSelection_DirectTI: TIM Input 3 is selected to be connected to IC3. + * @arg TIM_ICSelection_IndirectTI: TIM Input 3 is selected to be connected to IC4. + * @arg TIM_ICSelection_TRC: TIM Input 3 is selected to be connected to TRC. + * @param TIM_ICFilter: Specifies the Input Capture Filter. + * This parameter must be a value between 0x00 and 0x0F. + * @retval None + */ +static void TI3_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, + uint16_t TIM_ICFilter) +{ + uint16_t tmpccmr2 = 0, tmpccer = 0, tmp = 0; + /* Disable the Channel 3: Reset the CC3E Bit */ + TIMx->CCER &= (uint16_t)~((uint16_t)TIM_CCER_CC3E); + tmpccmr2 = TIMx->CCMR2; + tmpccer = TIMx->CCER; + tmp = (uint16_t)(TIM_ICPolarity << 8); + /* Select the Input and set the filter */ + tmpccmr2 &= (uint16_t)(((uint16_t)~((uint16_t)TIM_CCMR2_CC3S)) & ((uint16_t)~((uint16_t)TIM_CCMR2_IC3F))); + tmpccmr2 |= (uint16_t)(TIM_ICSelection | (uint16_t)(TIM_ICFilter << (uint16_t)4)); + /* Select the Polarity and set the CC3E Bit */ + tmpccer &= (uint16_t)~((uint16_t)(TIM_CCER_CC3P | TIM_CCER_CC3NP)); + tmpccer |= (uint16_t)(tmp | (uint16_t)TIM_CCER_CC3E); + /* Write to TIMx CCMR2 and CCER registers */ + TIMx->CCMR2 = tmpccmr2; + TIMx->CCER = tmpccer; +} + +/** + * @brief Configure the TI4 as Input. + * @param TIMx: where x can be 1, 2 or 3 to select the TIM peripheral. + * @note TIM2 is not applicable for STM32F030 devices. + * @param TIM_ICPolarity: The Input Polarity. + * This parameter can be one of the following values: + * @arg TIM_ICPolarity_Rising + * @arg TIM_ICPolarity_Falling + * @param TIM_ICSelection: specifies the input to be used. + * This parameter can be one of the following values: + * @arg TIM_ICSelection_DirectTI: TIM Input 4 is selected to be connected to IC4. + * @arg TIM_ICSelection_IndirectTI: TIM Input 4 is selected to be connected to IC3. + * @arg TIM_ICSelection_TRC: TIM Input 4 is selected to be connected to TRC. + * @param TIM_ICFilter: Specifies the Input Capture Filter. + * This parameter must be a value between 0x00 and 0x0F. + * @retval None + */ +static void TI4_Config(TIM_TypeDef* TIMx, uint16_t TIM_ICPolarity, uint16_t TIM_ICSelection, + uint16_t TIM_ICFilter) +{ + uint16_t tmpccmr2 = 0, tmpccer = 0, tmp = 0; + + /* Disable the Channel 4: Reset the CC4E Bit */ + TIMx->CCER &= (uint16_t)~((uint16_t)TIM_CCER_CC4E); + tmpccmr2 = TIMx->CCMR2; + tmpccer = TIMx->CCER; + tmp = (uint16_t)(TIM_ICPolarity << 12); + /* Select the Input and set the filter */ + tmpccmr2 &= (uint16_t)((uint16_t)(~(uint16_t)TIM_CCMR2_CC4S) & ((uint16_t)~((uint16_t)TIM_CCMR2_IC4F))); + tmpccmr2 |= (uint16_t)(TIM_ICSelection << 8); + tmpccmr2 |= (uint16_t)(TIM_ICFilter << 12); + /* Select the Polarity and set the CC4E Bit */ + tmpccer &= (uint16_t)~((uint16_t)(TIM_CCER_CC4P | TIM_CCER_CC4NP)); + tmpccer |= (uint16_t)(tmp | (uint16_t)TIM_CCER_CC4E); + /* Write to TIMx CCMR2 and CCER registers */ + TIMx->CCMR2 = tmpccmr2; + TIMx->CCER = tmpccer; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_usart.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_usart.c new file mode 100644 index 00000000..4b81b700 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_usart.c @@ -0,0 +1,2168 @@ +/** + ****************************************************************************** + * @file stm32f0xx_usart.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Universal synchronous asynchronous receiver + * transmitter (USART): + * + Initialization and Configuration + * + STOP Mode + * + AutoBaudRate + * + Data transfers + * + Multi-Processor Communication + * + LIN mode + * + Half-duplex mode + * + Smartcard mode + * + IrDA mode + * + RS485 mode + * + DMA transfers management + * + Interrupts and flags management + * + * @verbatim + =============================================================================== + ##### How to use this driver ##### + =============================================================================== + [..] + (#) Enable peripheral clock using RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE) + function for USART1 or using RCC_APB1PeriphClockCmd(RCC_APB1Periph_USARTx, ENABLE) + function for USART2 and USART3. + (#) According to the USART mode, enable the GPIO clocks using + RCC_AHBPeriphClockCmd() function. (The I/O can be TX, RX, CTS, + or and SCLK). + (#) Peripheral's alternate function: + (++) Connect the pin to the desired peripherals' Alternate + Function (AF) using GPIO_PinAFConfig() function. + (++) Configure the desired pin in alternate function by: + GPIO_InitStruct->GPIO_Mode = GPIO_Mode_AF. + (++) Select the type, pull-up/pull-down and output speed via + GPIO_PuPd, GPIO_OType and GPIO_Speed members. + (++) Call GPIO_Init() function. + (#) Program the Baud Rate, Word Length , Stop Bit, Parity, Hardware + flow control and Mode(Receiver/Transmitter) using the SPI_Init() + function. + (#) For synchronous mode, enable the clock and program the polarity, + phase and last bit using the USART_ClockInit() function. + (#) Enable the NVIC and the corresponding interrupt using the function + USART_ITConfig() if you need to use interrupt mode. + (#) When using the DMA mode: + (++) Configure the DMA using DMA_Init() function. + (++) Active the needed channel Request using USART_DMACmd() function. + (#) Enable the USART using the USART_Cmd() function. + (#) Enable the DMA using the DMA_Cmd() function, when using DMA mode. + [..] + Refer to Multi-Processor, LIN, half-duplex, Smartcard, IrDA sub-sections + for more details. + +@endverbatim + + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_usart.h" +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup USART + * @brief USART driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ + +/*!< USART CR1 register clear Mask ((~(uint32_t)0xFFFFE6F3)) */ +#define CR1_CLEAR_MASK ((uint32_t)(USART_CR1_M | USART_CR1_PCE | \ + USART_CR1_PS | USART_CR1_TE | \ + USART_CR1_RE)) + +/*!< USART CR2 register clock bits clear Mask ((~(uint32_t)0xFFFFF0FF)) */ +#define CR2_CLOCK_CLEAR_MASK ((uint32_t)(USART_CR2_CLKEN | USART_CR2_CPOL | \ + USART_CR2_CPHA | USART_CR2_LBCL)) + +/*!< USART CR3 register clear Mask ((~(uint32_t)0xFFFFFCFF)) */ +#define CR3_CLEAR_MASK ((uint32_t)(USART_CR3_RTSE | USART_CR3_CTSE)) + +/*!< USART Interrupts mask */ +#define IT_MASK ((uint32_t)0x000000FF) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup USART_Private_Functions + * @{ + */ + +/** @defgroup USART_Group1 Initialization and Configuration functions + * @brief Initialization and Configuration functions + * +@verbatim + =============================================================================== + ##### Initialization and Configuration functions ##### + =============================================================================== + [..] + This subsection provides a set of functions allowing to initialize the USART + in asynchronous and in synchronous modes. + (+) For the asynchronous mode only these parameters can be configured: + (++) Baud Rate. + (++) Word Length. + (++) Stop Bit. + (++) Parity: If the parity is enabled, then the MSB bit of the data written + in the data register is transmitted but is changed by the parity bit. + Depending on the frame length defined by the M bit (8-bits or 9-bits), + the possible USART frame formats are as listed in the following table: + + +-------------------------------------------------------------+ + | M bit | PCE bit | USART frame | + |---------------------|---------------------------------------| + | 0 | 0 | | SB | 8 bit data | STB | | + |---------|-----------|---------------------------------------| + | 0 | 1 | | SB | 7 bit data | PB | STB | | + |---------|-----------|---------------------------------------| + | 1 | 0 | | SB | 9 bit data | STB | | + |---------|-----------|---------------------------------------| + | 1 | 1 | | SB | 8 bit data | PB | STB | | + +-------------------------------------------------------------+ + + (++) Hardware flow control. + (++) Receiver/transmitter modes. + [..] The USART_Init() function follows the USART asynchronous configuration + procedure(details for the procedure are available in reference manual. + (+) For the synchronous mode in addition to the asynchronous mode parameters + these parameters should be also configured: + (++) USART Clock Enabled. + (++) USART polarity. + (++) USART phase. + (++) USART LastBit. + [..] These parameters can be configured using the USART_ClockInit() function. + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the USARTx peripheral registers to their default reset values. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @retval None + */ +void USART_DeInit(USART_TypeDef* USARTx) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + + if (USARTx == USART1) + { + RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, ENABLE); + RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, DISABLE); + } + else if (USARTx == USART2) + { + RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, DISABLE); + } + else if (USARTx == USART3) + { + RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, DISABLE); + } + else if (USARTx == USART4) + { + RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART4, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART4, DISABLE); + } + else if (USARTx == USART5) + { + RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART5, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART5, DISABLE); + } + else if (USARTx == USART6) + { + RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART6, ENABLE); + RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART6, DISABLE); + } + else if (USARTx == USART7) + { + RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART7, ENABLE); + RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART7, DISABLE); + } + else + { + if (USARTx == USART8) + { + RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART8, ENABLE); + RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART8, DISABLE); + } + } +} + +/** + * @brief Initializes the USARTx peripheral according to the specified + * parameters in the USART_InitStruct . + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_InitStruct: pointer to a USART_InitTypeDef structure that contains + * the configuration information for the specified USART peripheral. + * @retval None + */ +void USART_Init(USART_TypeDef* USARTx, USART_InitTypeDef* USART_InitStruct) +{ + uint32_t divider = 0, apbclock = 0, tmpreg = 0; + RCC_ClocksTypeDef RCC_ClocksStatus; + + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_BAUDRATE(USART_InitStruct->USART_BaudRate)); + assert_param(IS_USART_WORD_LENGTH(USART_InitStruct->USART_WordLength)); + assert_param(IS_USART_STOPBITS(USART_InitStruct->USART_StopBits)); + assert_param(IS_USART_PARITY(USART_InitStruct->USART_Parity)); + assert_param(IS_USART_MODE(USART_InitStruct->USART_Mode)); + assert_param(IS_USART_HARDWARE_FLOW_CONTROL(USART_InitStruct->USART_HardwareFlowControl)); + + /* Disable USART */ + USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_UE); + + /*---------------------------- USART CR2 Configuration -----------------------*/ + tmpreg = USARTx->CR2; + /* Clear STOP[13:12] bits */ + tmpreg &= (uint32_t)~((uint32_t)USART_CR2_STOP); + + /* Configure the USART Stop Bits, Clock, CPOL, CPHA and LastBit ------------*/ + /* Set STOP[13:12] bits according to USART_StopBits value */ + tmpreg |= (uint32_t)USART_InitStruct->USART_StopBits; + + /* Write to USART CR2 */ + USARTx->CR2 = tmpreg; + + /*---------------------------- USART CR1 Configuration -----------------------*/ + tmpreg = USARTx->CR1; + /* Clear M, PCE, PS, TE and RE bits */ + tmpreg &= (uint32_t)~((uint32_t)CR1_CLEAR_MASK); + + /* Configure the USART Word Length, Parity and mode ----------------------- */ + /* Set the M bits according to USART_WordLength value */ + /* Set PCE and PS bits according to USART_Parity value */ + /* Set TE and RE bits according to USART_Mode value */ + tmpreg |= (uint32_t)USART_InitStruct->USART_WordLength | USART_InitStruct->USART_Parity | + USART_InitStruct->USART_Mode; + + /* Write to USART CR1 */ + USARTx->CR1 = tmpreg; + + /*---------------------------- USART CR3 Configuration -----------------------*/ + tmpreg = USARTx->CR3; + /* Clear CTSE and RTSE bits */ + tmpreg &= (uint32_t)~((uint32_t)CR3_CLEAR_MASK); + + /* Configure the USART HFC -------------------------------------------------*/ + /* Set CTSE and RTSE bits according to USART_HardwareFlowControl value */ + tmpreg |= USART_InitStruct->USART_HardwareFlowControl; + + /* Write to USART CR3 */ + USARTx->CR3 = tmpreg; + + /*---------------------------- USART BRR Configuration -----------------------*/ + /* Configure the USART Baud Rate -------------------------------------------*/ + RCC_GetClocksFreq(&RCC_ClocksStatus); + + if (USARTx == USART1) + { + apbclock = RCC_ClocksStatus.USART1CLK_Frequency; + } + else if (USARTx == USART2) + { + apbclock = RCC_ClocksStatus.USART2CLK_Frequency; + } + else if (USARTx == USART3) + { + apbclock = RCC_ClocksStatus.USART3CLK_Frequency; + } + else + { + apbclock = RCC_ClocksStatus.PCLK_Frequency; + } + + /* Determine the integer part */ + if ((USARTx->CR1 & USART_CR1_OVER8) != 0) + { + /* (divider * 10) computing in case Oversampling mode is 8 Samples */ + divider = (uint32_t)((2 * apbclock) / (USART_InitStruct->USART_BaudRate)); + tmpreg = (uint32_t)((2 * apbclock) % (USART_InitStruct->USART_BaudRate)); + } + else /* if ((USARTx->CR1 & CR1_OVER8_Set) == 0) */ + { + /* (divider * 10) computing in case Oversampling mode is 16 Samples */ + divider = (uint32_t)((apbclock) / (USART_InitStruct->USART_BaudRate)); + tmpreg = (uint32_t)((apbclock) % (USART_InitStruct->USART_BaudRate)); + } + + /* round the divider : if fractional part i greater than 0.5 increment divider */ + if (tmpreg >= (USART_InitStruct->USART_BaudRate) / 2) + { + divider++; + } + + /* Implement the divider in case Oversampling mode is 8 Samples */ + if ((USARTx->CR1 & USART_CR1_OVER8) != 0) + { + /* get the LSB of divider and shift it to the right by 1 bit */ + tmpreg = (divider & (uint16_t)0x000F) >> 1; + + /* update the divider value */ + divider = (divider & (uint16_t)0xFFF0) | tmpreg; + } + + /* Write to USART BRR */ + USARTx->BRR = (uint16_t)divider; +} + +/** + * @brief Fills each USART_InitStruct member with its default value. + * @param USART_InitStruct: pointer to a USART_InitTypeDef structure + * which will be initialized. + * @retval None + */ +void USART_StructInit(USART_InitTypeDef* USART_InitStruct) +{ + /* USART_InitStruct members default value */ + USART_InitStruct->USART_BaudRate = 9600; + USART_InitStruct->USART_WordLength = USART_WordLength_8b; + USART_InitStruct->USART_StopBits = USART_StopBits_1; + USART_InitStruct->USART_Parity = USART_Parity_No ; + USART_InitStruct->USART_Mode = USART_Mode_Rx | USART_Mode_Tx; + USART_InitStruct->USART_HardwareFlowControl = USART_HardwareFlowControl_None; +} + +/** + * @brief Initializes the USARTx peripheral Clock according to the + * specified parameters in the USART_ClockInitStruct. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_ClockInitStruct: pointer to a USART_ClockInitTypeDef + * structure that contains the configuration information for the specified + * USART peripheral. + * @retval None + */ +void USART_ClockInit(USART_TypeDef* USARTx, USART_ClockInitTypeDef* USART_ClockInitStruct) +{ + uint32_t tmpreg = 0; + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_CLOCK(USART_ClockInitStruct->USART_Clock)); + assert_param(IS_USART_CPOL(USART_ClockInitStruct->USART_CPOL)); + assert_param(IS_USART_CPHA(USART_ClockInitStruct->USART_CPHA)); + assert_param(IS_USART_LASTBIT(USART_ClockInitStruct->USART_LastBit)); +/*---------------------------- USART CR2 Configuration -----------------------*/ + tmpreg = USARTx->CR2; + /* Clear CLKEN, CPOL, CPHA, LBCL and SSM bits */ + tmpreg &= (uint32_t)~((uint32_t)CR2_CLOCK_CLEAR_MASK); + /* Configure the USART Clock, CPOL, CPHA, LastBit and SSM ------------*/ + /* Set CLKEN bit according to USART_Clock value */ + /* Set CPOL bit according to USART_CPOL value */ + /* Set CPHA bit according to USART_CPHA value */ + /* Set LBCL bit according to USART_LastBit value */ + tmpreg |= (uint32_t)(USART_ClockInitStruct->USART_Clock | USART_ClockInitStruct->USART_CPOL | + USART_ClockInitStruct->USART_CPHA | USART_ClockInitStruct->USART_LastBit); + /* Write to USART CR2 */ + USARTx->CR2 = tmpreg; +} + +/** + * @brief Fills each USART_ClockInitStruct member with its default value. + * @param USART_ClockInitStruct: pointer to a USART_ClockInitTypeDef + * structure which will be initialized. + * @retval None + */ +void USART_ClockStructInit(USART_ClockInitTypeDef* USART_ClockInitStruct) +{ + /* USART_ClockInitStruct members default value */ + USART_ClockInitStruct->USART_Clock = USART_Clock_Disable; + USART_ClockInitStruct->USART_CPOL = USART_CPOL_Low; + USART_ClockInitStruct->USART_CPHA = USART_CPHA_1Edge; + USART_ClockInitStruct->USART_LastBit = USART_LastBit_Disable; +} + +/** + * @brief Enables or disables the specified USART peripheral. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param NewState: new state of the USARTx peripheral. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_Cmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected USART by setting the UE bit in the CR1 register */ + USARTx->CR1 |= USART_CR1_UE; + } + else + { + /* Disable the selected USART by clearing the UE bit in the CR1 register */ + USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_UE); + } +} + +/** + * @brief Enables or disables the USART's transmitter or receiver. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_Direction: specifies the USART direction. + * This parameter can be any combination of the following values: + * @arg USART_Mode_Tx: USART Transmitter + * @arg USART_Mode_Rx: USART Receiver + * @param NewState: new state of the USART transfer direction. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_DirectionModeCmd(USART_TypeDef* USARTx, uint32_t USART_DirectionMode, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_MODE(USART_DirectionMode)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the USART's transfer interface by setting the TE and/or RE bits + in the USART CR1 register */ + USARTx->CR1 |= USART_DirectionMode; + } + else + { + /* Disable the USART's transfer interface by clearing the TE and/or RE bits + in the USART CR3 register */ + USARTx->CR1 &= (uint32_t)~USART_DirectionMode; + } +} + +/** + * @brief Enables or disables the USART's 8x oversampling mode. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param NewState: new state of the USART 8x oversampling mode. + * This parameter can be: ENABLE or DISABLE. + * @note This function has to be called before calling USART_Init() function + * in order to have correct baudrate Divider value. + * @retval None + */ +void USART_OverSampling8Cmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the 8x Oversampling mode by setting the OVER8 bit in the CR1 register */ + USARTx->CR1 |= USART_CR1_OVER8; + } + else + { + /* Disable the 8x Oversampling mode by clearing the OVER8 bit in the CR1 register */ + USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_OVER8); + } +} + +/** + * @brief Enables or disables the USART's one bit sampling method. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param NewState: new state of the USART one bit sampling method. + * This parameter can be: ENABLE or DISABLE. + * @note This function has to be called before calling USART_Cmd() function. + * @retval None + */ +void USART_OneBitMethodCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the one bit method by setting the ONEBITE bit in the CR3 register */ + USARTx->CR3 |= USART_CR3_ONEBIT; + } + else + { + /* Disable the one bit method by clearing the ONEBITE bit in the CR3 register */ + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_ONEBIT); + } +} + +/** + * @brief Enables or disables the USART's most significant bit first + * transmitted/received following the start bit. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param NewState: new state of the USART most significant bit first + * transmitted/received following the start bit. + * This parameter can be: ENABLE or DISABLE. + * @note This function has to be called before calling USART_Cmd() function. + * @retval None + */ +void USART_MSBFirstCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the most significant bit first transmitted/received following the + start bit by setting the MSBFIRST bit in the CR2 register */ + USARTx->CR2 |= USART_CR2_MSBFIRST; + } + else + { + /* Disable the most significant bit first transmitted/received following the + start bit by clearing the MSBFIRST bit in the CR2 register */ + USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_MSBFIRST); + } +} + +/** + * @brief Enables or disables the binary data inversion. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param NewState: new defined levels for the USART data. + * This parameter can be: + * @arg ENABLE: Logical data from the data register are send/received in negative + * logic (1=L, 0=H). The parity bit is also inverted. + * @arg DISABLE: Logical data from the data register are send/received in positive + * logic (1=H, 0=L) + * @note This function has to be called before calling USART_Cmd() function. + * @retval None + */ +void USART_DataInvCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the binary data inversion feature by setting the DATAINV bit in + the CR2 register */ + USARTx->CR2 |= USART_CR2_DATAINV; + } + else + { + /* Disable the binary data inversion feature by clearing the DATAINV bit in + the CR2 register */ + USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_DATAINV); + } +} + +/** + * @brief Enables or disables the Pin(s) active level inversion. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_InvPin: specifies the USART pin(s) to invert. + * This parameter can be any combination of the following values: + * @arg USART_InvPin_Tx: USART Tx pin active level inversion. + * @arg USART_InvPin_Rx: USART Rx pin active level inversion. + * @param NewState: new active level status for the USART pin(s). + * This parameter can be: + * @arg ENABLE: pin(s) signal values are inverted (Vdd =0, Gnd =1). + * @arg DISABLE: pin(s) signal works using the standard logic levels (Vdd =1, Gnd =0). + * @note This function has to be called before calling USART_Cmd() function. + * @retval None + */ +void USART_InvPinCmd(USART_TypeDef* USARTx, uint32_t USART_InvPin, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_INVERSTION_PIN(USART_InvPin)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the active level inversion for selected pins by setting the TXINV + and/or RXINV bits in the USART CR2 register */ + USARTx->CR2 |= USART_InvPin; + } + else + { + /* Disable the active level inversion for selected requests by clearing the + TXINV and/or RXINV bits in the USART CR2 register */ + USARTx->CR2 &= (uint32_t)~USART_InvPin; + } +} + +/** + * @brief Enables or disables the swap Tx/Rx pins. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param NewState: new state of the USARTx TX/RX pins pinout. + * This parameter can be: + * @arg ENABLE: The TX and RX pins functions are swapped. + * @arg DISABLE: TX/RX pins are used as defined in standard pinout + * @note This function has to be called before calling USART_Cmd() function. + * @retval None + */ +void USART_SWAPPinCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the SWAP feature by setting the SWAP bit in the CR2 register */ + USARTx->CR2 |= USART_CR2_SWAP; + } + else + { + /* Disable the SWAP feature by clearing the SWAP bit in the CR2 register */ + USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_SWAP); + } +} + +/** + * @brief Enables or disables the receiver Time Out feature. + * @param USARTx: where x can be 1, 2 or 3 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param NewState: new state of the USARTx receiver Time Out. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_ReceiverTimeOutCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the receiver time out feature by setting the RTOEN bit in the CR2 + register */ + USARTx->CR2 |= USART_CR2_RTOEN; + } + else + { + /* Disable the receiver time out feature by clearing the RTOEN bit in the CR2 + register */ + USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_RTOEN); + } +} + +/** + * @brief Sets the receiver Time Out value. + * @param USARTx: where x can be 1, 2 or 3 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param USART_ReceiverTimeOut: specifies the Receiver Time Out value. + * @retval None + */ +void USART_SetReceiverTimeOut(USART_TypeDef* USARTx, uint32_t USART_ReceiverTimeOut) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_USART_TIMEOUT(USART_ReceiverTimeOut)); + + /* Clear the receiver Time Out value by clearing the RTO[23:0] bits in the RTOR + register */ + USARTx->RTOR &= (uint32_t)~((uint32_t)USART_RTOR_RTO); + /* Set the receiver Time Out value by setting the RTO[23:0] bits in the RTOR + register */ + USARTx->RTOR |= USART_ReceiverTimeOut; +} + +/** + * @brief Sets the system clock prescaler. + * @note This function is not available for STM32F030 devices. + * @param USARTx: where x can be 1, 2 or 3 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param USART_Prescaler: specifies the prescaler clock. + * @note This function has to be called before calling USART_Cmd() function. + * @retval None + */ +void USART_SetPrescaler(USART_TypeDef* USARTx, uint8_t USART_Prescaler) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + + /* Clear the USART prescaler */ + USARTx->GTPR &= USART_GTPR_GT; + /* Set the USART prescaler */ + USARTx->GTPR |= USART_Prescaler; +} + +/** + * @} + */ + + +/** @defgroup USART_Group2 STOP Mode functions + * @brief STOP Mode functions + * +@verbatim + =============================================================================== + ##### STOP Mode functions ##### + =============================================================================== + [..] This subsection provides a set of functions allowing to manage + WakeUp from STOP mode. + + [..] The USART is able to WakeUp from Stop Mode if USART clock is set to HSI + or LSI. + + [..] The WakeUp source is configured by calling USART_StopModeWakeUpSourceConfig() + function. + + [..] After configuring the source of WakeUp and before entering in Stop Mode + USART_STOPModeCmd() function should be called to allow USART WakeUp. + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified USART peripheral in STOP Mode. + * @param USARTx: where x can be 1 or 2 or 3 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param NewState: new state of the USARTx peripheral state in stop mode. + * This parameter can be: ENABLE or DISABLE. + * @note This function has to be called when USART clock is set to HSI or LSE. + * @retval None + */ +void USART_STOPModeCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the selected USART in STOP mode by setting the UESM bit in the CR1 + register */ + USARTx->CR1 |= USART_CR1_UESM; + } + else + { + /* Disable the selected USART in STOP mode by clearing the UE bit in the CR1 + register */ + USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_UESM); + } +} + +/** + * @brief Selects the USART WakeUp method form stop mode. + * @note This function is not available for STM32F030 devices. + * @param USARTx: where x can be 1 or 2 or 3 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param USART_WakeUp: specifies the selected USART wakeup method. + * This parameter can be one of the following values: + * @arg USART_WakeUpSource_AddressMatch: WUF active on address match. + * @arg USART_WakeUpSource_StartBit: WUF active on Start bit detection. + * @arg USART_WakeUpSource_RXNE: WUF active on RXNE. + * @note This function has to be called before calling USART_Cmd() function. + * @retval None + */ +void USART_StopModeWakeUpSourceConfig(USART_TypeDef* USARTx, uint32_t USART_WakeUpSource) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_USART_STOPMODE_WAKEUPSOURCE(USART_WakeUpSource)); + + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_WUS); + USARTx->CR3 |= USART_WakeUpSource; +} + +/** + * @} + */ + + +/** @defgroup USART_Group3 AutoBaudRate functions + * @brief AutoBaudRate functions + * +@verbatim + =============================================================================== + ##### AutoBaudRate functions ##### + =============================================================================== + [..] This subsection provides a set of functions allowing to manage + the AutoBaudRate detections. + + [..] Before Enabling AutoBaudRate detection using USART_AutoBaudRateCmd () + The character patterns used to calculate baudrate must be chosen by calling + USART_AutoBaudRateConfig() function. These function take as parameter : + (#)USART_AutoBaudRate_StartBit : any character starting with a bit 1. + (#)USART_AutoBaudRate_FallingEdge : any character starting with a 10xx bit pattern. + + [..] At any later time, another request for AutoBaudRate detection can be performed + using USART_RequestCmd() function. + + [..] The AutoBaudRate detection is monitored by the status of ABRF flag which indicate + that the AutoBaudRate detection is completed. In addition to ABRF flag, the ABRE flag + indicate that this procedure is completed without success. USART_GetFlagStatus () + function should be used to monitor the status of these flags. + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the Auto Baud Rate. + * @param USARTx: where x can be 1or 2 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param NewState: new state of the USARTx auto baud rate. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_AutoBaudRateCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the auto baud rate feature by setting the ABREN bit in the CR2 + register */ + USARTx->CR2 |= USART_CR2_ABREN; + } + else + { + /* Disable the auto baud rate feature by clearing the ABREN bit in the CR2 + register */ + USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_ABREN); + } +} + +/** + * @brief Selects the USART auto baud rate method. + * @param USARTx: where x can be 1or 2 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param USART_AutoBaudRate: specifies the selected USART auto baud rate method. + * This parameter can be one of the following values: + * @arg USART_AutoBaudRate_StartBit: Start Bit duration measurement. + * @arg USART_AutoBaudRate_FallingEdge: Falling edge to falling edge measurement. + * @note This function has to be called before calling USART_Cmd() function. + * @retval None + */ +void USART_AutoBaudRateConfig(USART_TypeDef* USARTx, uint32_t USART_AutoBaudRate) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_USART_AUTOBAUDRATE_MODE(USART_AutoBaudRate)); + + USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_ABRMODE); + USARTx->CR2 |= USART_AutoBaudRate; +} + +/** + * @} + */ + + +/** @defgroup USART_Group4 Data transfers functions + * @brief Data transfers functions + * +@verbatim + =============================================================================== + ##### Data transfers functions ##### + =============================================================================== + [..] This subsection provides a set of functions allowing to manage + the USART data transfers. + [..] During an USART reception, data shifts in least significant bit first + through the RX pin. When a transmission is taking place, a write instruction to + the USART_TDR register stores the data in the shift register. + [..] The read access of the USART_RDR register can be done using + the USART_ReceiveData() function and returns the RDR value. + Whereas a write access to the USART_TDR can be done using USART_SendData() + function and stores the written data into TDR. + +@endverbatim + * @{ + */ + +/** + * @brief Transmits single data through the USARTx peripheral. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param Data: the data to transmit. + * @retval None + */ +void USART_SendData(USART_TypeDef* USARTx, uint16_t Data) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_DATA(Data)); + + /* Transmit Data */ + USARTx->TDR = (Data & (uint16_t)0x01FF); +} + +/** + * @brief Returns the most recent received data by the USARTx peripheral. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @retval The received data. + */ +uint16_t USART_ReceiveData(USART_TypeDef* USARTx) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + + /* Receive Data */ + return (uint16_t)(USARTx->RDR & (uint16_t)0x01FF); +} + +/** + * @} + */ + +/** @defgroup USART_Group5 MultiProcessor Communication functions + * @brief Multi-Processor Communication functions + * +@verbatim + =============================================================================== + ##### Multi-Processor Communication functions ##### + =============================================================================== + [..] This subsection provides a set of functions allowing to manage the USART + multiprocessor communication. + [..] For instance one of the USARTs can be the master, its TX output is + connected to the RX input of the other USART. The others are slaves, + their respective TX outputs are logically ANDed together and connected + to the RX input of the master. USART multiprocessor communication is + possible through the following procedure: + (#) Program the Baud rate, Word length = 9 bits, Stop bits, Parity, + Mode transmitter or Mode receiver and hardware flow control values + using the USART_Init() function. + (#) Configures the USART address using the USART_SetAddress() function. + (#) Configures the wake up methode (USART_WakeUp_IdleLine or + USART_WakeUp_AddressMark) using USART_WakeUpConfig() function only + for the slaves. + (#) Enable the USART using the USART_Cmd() function. + (#) Enter the USART slaves in mute mode using USART_ReceiverWakeUpCmd() + function. + [..] The USART Slave exit from mute mode when receive the wake up condition. + +@endverbatim + * @{ + */ + +/** + * @brief Sets the address of the USART node. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_Address: Indicates the address of the USART node. + * @retval None + */ +void USART_SetAddress(USART_TypeDef* USARTx, uint8_t USART_Address) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + + /* Clear the USART address */ + USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_ADD); + /* Set the USART address node */ + USARTx->CR2 |=((uint32_t)USART_Address << (uint32_t)0x18); +} + +/** + * @brief Enables or disables the USART's mute mode. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param NewState: new state of the USART mute mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_MuteModeCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the USART mute mode by setting the MME bit in the CR1 register */ + USARTx->CR1 |= USART_CR1_MME; + } + else + { + /* Disable the USART mute mode by clearing the MME bit in the CR1 register */ + USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_MME); + } +} + +/** + * @brief Selects the USART WakeUp method from mute mode. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_WakeUp: specifies the USART wakeup method. + * This parameter can be one of the following values: + * @arg USART_WakeUp_IdleLine: WakeUp by an idle line detection + * @arg USART_WakeUp_AddressMark: WakeUp by an address mark + * @retval None + */ +void USART_MuteModeWakeUpConfig(USART_TypeDef* USARTx, uint32_t USART_WakeUp) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_MUTEMODE_WAKEUP(USART_WakeUp)); + + USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_WAKE); + USARTx->CR1 |= USART_WakeUp; +} + +/** + * @brief Configure the the USART Address detection length. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_AddressLength: specifies the USART address length detection. + * This parameter can be one of the following values: + * @arg USART_AddressLength_4b: 4-bit address length detection + * @arg USART_AddressLength_7b: 7-bit address length detection + * @retval None + */ +void USART_AddressDetectionConfig(USART_TypeDef* USARTx, uint32_t USART_AddressLength) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_ADDRESS_DETECTION(USART_AddressLength)); + + USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_ADDM7); + USARTx->CR2 |= USART_AddressLength; +} + +/** + * @} + */ + +/** @defgroup USART_Group6 LIN mode functions + * @brief LIN mode functions + * +@verbatim + =============================================================================== + ##### LIN mode functions ##### + =============================================================================== + [..] This subsection provides a set of functions allowing to manage the USART + LIN Mode communication. + [..] In LIN mode, 8-bit data format with 1 stop bit is required in accordance + with the LIN standard. + [..] Only this LIN Feature is supported by the USART IP: + (+) LIN Master Synchronous Break send capability and LIN slave break + detection capability : 13-bit break generation and 10/11 bit break + detection. + [..] USART LIN Master transmitter communication is possible through the + following procedure: + (#) Program the Baud rate, Word length = 8bits, Stop bits = 1bit, Parity, + Mode transmitter or Mode receiver and hardware flow control values + using the USART_Init() function. + (#) Enable the LIN mode using the USART_LINCmd() function. + (#) Enable the USART using the USART_Cmd() function. + (#) Send the break character using USART_SendBreak() function. + [..] USART LIN Master receiver communication is possible through the + following procedure: + (#) Program the Baud rate, Word length = 8bits, Stop bits = 1bit, Parity, + Mode transmitter or Mode receiver and hardware flow control values + using the USART_Init() function. + (#) Configures the break detection length + using the USART_LINBreakDetectLengthConfig() function. + (#) Enable the LIN mode using the USART_LINCmd() function. + -@- In LIN mode, the following bits must be kept cleared: + (+@) CLKEN in the USART_CR2 register. + (+@) STOP[1:0], SCEN, HDSEL and IREN in the USART_CR3 register. + (#) Enable the USART using the USART_Cmd() function. + +@endverbatim + * @{ + */ + +/** + * @brief Sets the USART LIN Break detection length. + * @note This function is not available for STM32F030 devices. + * @param USARTx: where x can be 1or 2 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param USART_LINBreakDetectLength: specifies the LIN break detection length. + * This parameter can be one of the following values: + * @arg USART_LINBreakDetectLength_10b: 10-bit break detection + * @arg USART_LINBreakDetectLength_11b: 11-bit break detection + * @retval None + */ +void USART_LINBreakDetectLengthConfig(USART_TypeDef* USARTx, uint32_t USART_LINBreakDetectLength) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_USART_LIN_BREAK_DETECT_LENGTH(USART_LINBreakDetectLength)); + + USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_LBDL); + USARTx->CR2 |= USART_LINBreakDetectLength; +} + +/** + * @brief Enables or disables the USART's LIN mode. + * @note This function is not available for STM32F030 devices. + * @param USARTx: where x can be 1or 2 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param NewState: new state of the USART LIN mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_LINCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the LIN mode by setting the LINEN bit in the CR2 register */ + USARTx->CR2 |= USART_CR2_LINEN; + } + else + { + /* Disable the LIN mode by clearing the LINEN bit in the CR2 register */ + USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_LINEN); + } +} + +/** + * @} + */ + +/** @defgroup USART_Group7 Halfduplex mode function + * @brief Half-duplex mode function + * +@verbatim + =============================================================================== + ##### Half-duplex mode function ##### + =============================================================================== + [..] This subsection provides a set of functions allowing to manage the USART + Half-duplex communication. + [..] The USART can be configured to follow a single-wire half-duplex protocol + where the TX and RX lines are internally connected. + [..] USART Half duplex communication is possible through the following procedure: + (#) Program the Baud rate, Word length, Stop bits, Parity, Mode transmitter + or Mode receiver and hardware flow control values using the USART_Init() + function. + (#) Configures the USART address using the USART_SetAddress() function. + (#) Enable the half duplex mode using USART_HalfDuplexCmd() function. + (#) Enable the USART using the USART_Cmd() function. + -@- The RX pin is no longer used. + -@- In Half-duplex mode the following bits must be kept cleared: + (+@) LINEN and CLKEN bits in the USART_CR2 register. + (+@) SCEN and IREN bits in the USART_CR3 register. + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the USART's Half Duplex communication. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param NewState: new state of the USART Communication. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_HalfDuplexCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the Half-Duplex mode by setting the HDSEL bit in the CR3 register */ + USARTx->CR3 |= USART_CR3_HDSEL; + } + else + { + /* Disable the Half-Duplex mode by clearing the HDSEL bit in the CR3 register */ + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_HDSEL); + } +} + +/** + * @} + */ + + +/** @defgroup USART_Group8 Smartcard mode functions + * @brief Smartcard mode functions + * +@verbatim + =============================================================================== + ##### Smartcard mode functions ##### + =============================================================================== + [..] This subsection provides a set of functions allowing to manage the USART + Smartcard communication. + [..] The Smartcard interface is designed to support asynchronous protocol + Smartcards as defined in the ISO 7816-3 standard. The USART can provide + a clock to the smartcard through the SCLK output. In smartcard mode, + SCLK is not associated to the communication but is simply derived from + the internal peripheral input clock through a 5-bit prescaler. + [..] Smartcard communication is possible through the following procedure: + (#) Configures the Smartcard Prsecaler using the USART_SetPrescaler() + function. + (#) Configures the Smartcard Guard Time using the USART_SetGuardTime() + function. + (#) Program the USART clock using the USART_ClockInit() function as following: + (++) USART Clock enabled. + (++) USART CPOL Low. + (++) USART CPHA on first edge. + (++) USART Last Bit Clock Enabled. + (#) Program the Smartcard interface using the USART_Init() function as + following: + (++) Word Length = 9 Bits. + (++) 1.5 Stop Bit. + (++) Even parity. + (++) BaudRate = 12096 baud. + (++) Hardware flow control disabled (RTS and CTS signals). + (++) Tx and Rx enabled + (#) Optionally you can enable the parity error interrupt using + the USART_ITConfig() function. + (#) Enable the Smartcard NACK using the USART_SmartCardNACKCmd() function. + (#) Enable the Smartcard interface using the USART_SmartCardCmd() function. + (#) Enable the USART using the USART_Cmd() function. + [..] + Please refer to the ISO 7816-3 specification for more details. + [..] + (@) It is also possible to choose 0.5 stop bit for receiving but it is + recommended to use 1.5 stop bits for both transmitting and receiving + to avoid switching between the two configurations. + (@) In smartcard mode, the following bits must be kept cleared: + (+@) LINEN bit in the USART_CR2 register. + (+@) HDSEL and IREN bits in the USART_CR3 register. + +@endverbatim + * @{ + */ + +/** + * @brief Sets the specified USART guard time. + * @note This function is not available for STM32F030 devices. + * @param USARTx: where x can be 1or 2 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param USART_GuardTime: specifies the guard time. + * @retval None + */ +void USART_SetGuardTime(USART_TypeDef* USARTx, uint8_t USART_GuardTime) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + + /* Clear the USART Guard time */ + USARTx->GTPR &= USART_GTPR_PSC; + /* Set the USART guard time */ + USARTx->GTPR |= (uint16_t)((uint16_t)USART_GuardTime << 0x08); +} + +/** + * @brief Enables or disables the USART's Smart Card mode. + * @note This function is not available for STM32F030 devices. + * @param USARTx: where x can be 1or 2 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param NewState: new state of the Smart Card mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_SmartCardCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + if (NewState != DISABLE) + { + /* Enable the SC mode by setting the SCEN bit in the CR3 register */ + USARTx->CR3 |= USART_CR3_SCEN; + } + else + { + /* Disable the SC mode by clearing the SCEN bit in the CR3 register */ + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_SCEN); + } +} + +/** + * @brief Enables or disables NACK transmission. + * @note This function is not available for STM32F030 devices. + * @param USARTx: where x can be 1or 2 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param NewState: new state of the NACK transmission. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_SmartCardNACKCmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + if (NewState != DISABLE) + { + /* Enable the NACK transmission by setting the NACK bit in the CR3 register */ + USARTx->CR3 |= USART_CR3_NACK; + } + else + { + /* Disable the NACK transmission by clearing the NACK bit in the CR3 register */ + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_NACK); + } +} + +/** + * @brief Sets the Smart Card number of retries in transmit and receive. + * @note This function is not available for STM32F030 devices. + * @param USARTx: where x can be 1or 3 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param USART_AutoCount: specifies the Smart Card auto retry count. + * @retval None + */ +void USART_SetAutoRetryCount(USART_TypeDef* USARTx, uint8_t USART_AutoCount) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_USART_AUTO_RETRY_COUNTER(USART_AutoCount)); + /* Clear the USART auto retry count */ + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_SCARCNT); + /* Set the USART auto retry count*/ + USARTx->CR3 |= (uint32_t)((uint32_t)USART_AutoCount << 0x11); +} + +/** + * @brief Sets the Smart Card Block length. + * @note This function is not available for STM32F030 devices. + * @param USARTx: where x can be 1or 3 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param USART_BlockLength: specifies the Smart Card block length. + * @retval None + */ +void USART_SetBlockLength(USART_TypeDef* USARTx, uint8_t USART_BlockLength) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + + /* Clear the Smart card block length */ + USARTx->RTOR &= (uint32_t)~((uint32_t)USART_RTOR_BLEN); + /* Set the Smart Card block length */ + USARTx->RTOR |= (uint32_t)((uint32_t)USART_BlockLength << 0x18); +} + +/** + * @} + */ + +/** @defgroup USART_Group9 IrDA mode functions + * @brief IrDA mode functions + * +@verbatim + =============================================================================== + ##### IrDA mode functions ##### + =============================================================================== + [..] This subsection provides a set of functions allowing to manage the USART + IrDA communication. + [..] IrDA is a half duplex communication protocol. If the Transmitter is busy, + any data on the IrDA receive line will be ignored by the IrDA decoder + and if the Receiver is busy, data on the TX from the USART to IrDA will + not be encoded by IrDA. While receiving data, transmission should be + avoided as the data to be transmitted could be corrupted. + [..] IrDA communication is possible through the following procedure: + (#) Program the Baud rate, Word length = 8 bits, Stop bits, Parity, + Transmitter/Receiver modes and hardware flow control values using + the USART_Init() function. + (#) Configures the IrDA pulse width by configuring the prescaler using + the USART_SetPrescaler() function. + (#) Configures the IrDA USART_IrDAMode_LowPower or USART_IrDAMode_Normal + mode using the USART_IrDAConfig() function. + (#) Enable the IrDA using the USART_IrDACmd() function. + (#) Enable the USART using the USART_Cmd() function. + [..] + (@) A pulse of width less than two and greater than one PSC period(s) may or + may not be rejected. + (@) The receiver set up time should be managed by software. The IrDA physical + layer specification specifies a minimum of 10 ms delay between + transmission and reception (IrDA is a half duplex protocol). + (@) In IrDA mode, the following bits must be kept cleared: + (+@) LINEN, STOP and CLKEN bits in the USART_CR2 register. + (+@) SCEN and HDSEL bits in the USART_CR3 register. + +@endverbatim + * @{ + */ + +/** + * @brief Configures the USART's IrDA interface. + * @note This function is not available for STM32F030 devices. + * @param USARTx: where x can be 1or 2 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param USART_IrDAMode: specifies the IrDA mode. + * This parameter can be one of the following values: + * @arg USART_IrDAMode_LowPower + * @arg USART_IrDAMode_Normal + * @retval None + */ +void USART_IrDAConfig(USART_TypeDef* USARTx, uint32_t USART_IrDAMode) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_USART_IRDA_MODE(USART_IrDAMode)); + + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_IRLP); + USARTx->CR3 |= USART_IrDAMode; +} + +/** + * @brief Enables or disables the USART's IrDA interface. + * @note This function is not available for STM32F030 devices. + * @param USARTx: where x can be 1or 2 to select the USART peripheral. + * @note USART2 is available only for STM32F072 and STM32F091 devices. + * @note USART3 is available only for STM32F091 devices. + * @param NewState: new state of the IrDA mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_IrDACmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_123_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the IrDA mode by setting the IREN bit in the CR3 register */ + USARTx->CR3 |= USART_CR3_IREN; + } + else + { + /* Disable the IrDA mode by clearing the IREN bit in the CR3 register */ + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_IREN); + } +} +/** + * @} + */ + +/** @defgroup USART_Group10 RS485 mode function + * @brief RS485 mode function + * +@verbatim + =============================================================================== + ##### RS485 mode functions ##### + =============================================================================== + [..] This subsection provides a set of functions allowing to manage the USART + RS485 flow control. + [..] RS485 flow control (Driver enable feature) handling is possible through + the following procedure: + (#) Program the Baud rate, Word length = 8 bits, Stop bits, Parity, + Transmitter/Receiver modes and hardware flow control values using + the USART_Init() function. + (#) Enable the Driver Enable using the USART_DECmd() function. + (#) Configures the Driver Enable polarity using the USART_DEPolarityConfig() + function. + (#) Configures the Driver Enable assertion time using USART_SetDEAssertionTime() + function and deassertion time using the USART_SetDEDeassertionTime() + function. + (#) Enable the USART using the USART_Cmd() function. + -@- + (+@) The assertion and dessertion times are expressed in sample time units (1/8 or + 1/16 bit time, depending on the oversampling rate). + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the USART's DE functionality. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param NewState: new state of the driver enable mode. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_DECmd(USART_TypeDef* USARTx, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + if (NewState != DISABLE) + { + /* Enable the DE functionality by setting the DEM bit in the CR3 register */ + USARTx->CR3 |= USART_CR3_DEM; + } + else + { + /* Disable the DE functionality by clearing the DEM bit in the CR3 register */ + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_DEM); + } +} + +/** + * @brief Configures the USART's DE polarity + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_DEPolarity: specifies the DE polarity. + * This parameter can be one of the following values: + * @arg USART_DEPolarity_Low + * @arg USART_DEPolarity_High + * @retval None + */ +void USART_DEPolarityConfig(USART_TypeDef* USARTx, uint32_t USART_DEPolarity) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_DE_POLARITY(USART_DEPolarity)); + + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_DEP); + USARTx->CR3 |= USART_DEPolarity; +} + +/** + * @brief Sets the specified RS485 DE assertion time + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_DEAssertionTime: specifies the time between the activation of + * the DE signal and the beginning of the start bit + * @retval None + */ +void USART_SetDEAssertionTime(USART_TypeDef* USARTx, uint32_t USART_DEAssertionTime) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_DE_ASSERTION_DEASSERTION_TIME(USART_DEAssertionTime)); + + /* Clear the DE assertion time */ + USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_DEAT); + /* Set the new value for the DE assertion time */ + USARTx->CR1 |=((uint32_t)USART_DEAssertionTime << (uint32_t)0x15); +} + +/** + * @brief Sets the specified RS485 DE deassertion time + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_DeassertionTime: specifies the time between the middle of the last + * stop bit in a transmitted message and the de-activation of the DE signal + * @retval None + */ +void USART_SetDEDeassertionTime(USART_TypeDef* USARTx, uint32_t USART_DEDeassertionTime) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_DE_ASSERTION_DEASSERTION_TIME(USART_DEDeassertionTime)); + + /* Clear the DE deassertion time */ + USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_DEDT); + /* Set the new value for the DE deassertion time */ + USARTx->CR1 |=((uint32_t)USART_DEDeassertionTime << (uint32_t)0x10); +} + +/** + * @} + */ + +/** @defgroup USART_Group11 DMA transfers management functions + * @brief DMA transfers management functions + * +@verbatim + =============================================================================== + ##### DMA transfers management functions ##### + =============================================================================== + [..] This section provides two functions that can be used only in DMA mode. + [..] In DMA Mode, the USART communication can be managed by 2 DMA Channel + requests: + (#) USART_DMAReq_Tx: specifies the Tx buffer DMA transfer request. + (#) USART_DMAReq_Rx: specifies the Rx buffer DMA transfer request. + [..] In this Mode it is advised to use the following function: + (+) void USART_DMACmd(USART_TypeDef* USARTx, uint16_t USART_DMAReq, + FunctionalState NewState). +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the USART's DMA interface. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_DMAReq: specifies the DMA request. + * This parameter can be any combination of the following values: + * @arg USART_DMAReq_Tx: USART DMA transmit request + * @arg USART_DMAReq_Rx: USART DMA receive request + * @param NewState: new state of the DMA Request sources. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_DMACmd(USART_TypeDef* USARTx, uint32_t USART_DMAReq, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_DMAREQ(USART_DMAReq)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the DMA transfer for selected requests by setting the DMAT and/or + DMAR bits in the USART CR3 register */ + USARTx->CR3 |= USART_DMAReq; + } + else + { + /* Disable the DMA transfer for selected requests by clearing the DMAT and/or + DMAR bits in the USART CR3 register */ + USARTx->CR3 &= (uint32_t)~USART_DMAReq; + } +} + +/** + * @brief Enables or disables the USART's DMA interface when reception error occurs. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_DMAOnError: specifies the DMA status in case of reception error. + * This parameter can be any combination of the following values: + * @arg USART_DMAOnError_Enable: DMA receive request enabled when the USART DMA + * reception error is asserted. + * @arg USART_DMAOnError_Disable: DMA receive request disabled when the USART DMA + * reception error is asserted. + * @retval None + */ +void USART_DMAReceptionErrorConfig(USART_TypeDef* USARTx, uint32_t USART_DMAOnError) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_DMAONERROR(USART_DMAOnError)); + + /* Clear the DMA Reception error detection bit */ + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_DDRE); + /* Set the new value for the DMA Reception error detection bit */ + USARTx->CR3 |= USART_DMAOnError; +} + +/** + * @} + */ + +/** @defgroup USART_Group12 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + =============================================================================== + ##### Interrupts and flags management functions ##### + =============================================================================== + [..] This subsection provides a set of functions allowing to configure the + USART Interrupts sources, Requests and check or clear the flags or pending bits status. + The user should identify which mode will be used in his application to + manage the communication: Polling mode, Interrupt mode. + + *** Polling Mode *** + ==================== + [..] In Polling Mode, the SPI communication can be managed by these flags: + (#) USART_FLAG_REACK: to indicate the status of the Receive Enable + acknowledge flag + (#) USART_FLAG_TEACK: to indicate the status of the Transmit Enable + acknowledge flag. + (#) USART_FLAG_WU: to indicate the status of the Wake up flag. + (#) USART_FLAG_RWU: to indicate the status of the Receive Wake up flag. + (#) USART_FLAG_SBK: to indicate the status of the Send Break flag. + (#) USART_FLAG_CM: to indicate the status of the Character match flag. + (#) USART_FLAG_BUSY: to indicate the status of the Busy flag. + (#) USART_FLAG_ABRF: to indicate the status of the Auto baud rate flag. + (#) USART_FLAG_ABRE: to indicate the status of the Auto baud rate error flag. + (#) USART_FLAG_EOB: to indicate the status of the End of block flag. + (#) USART_FLAG_RTO: to indicate the status of the Receive time out flag. + (#) USART_FLAG_nCTSS: to indicate the status of the Inverted nCTS input + bit status. + (#) USART_FLAG_TXE: to indicate the status of the transmit buffer register. + (#) USART_FLAG_RXNE: to indicate the status of the receive buffer register. + (#) USART_FLAG_TC: to indicate the status of the transmit operation. + (#) USART_FLAG_IDLE: to indicate the status of the Idle Line. + (#) USART_FLAG_CTS: to indicate the status of the nCTS input. + (#) USART_FLAG_LBD: to indicate the status of the LIN break detection. + (#) USART_FLAG_NE: to indicate if a noise error occur. + (#) USART_FLAG_FE: to indicate if a frame error occur. + (#) USART_FLAG_PE: to indicate if a parity error occur. + (#) USART_FLAG_ORE: to indicate if an Overrun error occur. + [..] In this Mode it is advised to use the following functions: + (+) FlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, uint16_t USART_FLAG). + (+) void USART_ClearFlag(USART_TypeDef* USARTx, uint16_t USART_FLAG). + + *** Interrupt Mode *** + ====================== + [..] In Interrupt Mode, the USART communication can be managed by 8 interrupt + sources and 10 pending bits: + (+) Pending Bits: + (##) USART_IT_WU: to indicate the status of the Wake up interrupt. + (##) USART_IT_CM: to indicate the status of Character match interrupt. + (##) USART_IT_EOB: to indicate the status of End of block interrupt. + (##) USART_IT_RTO: to indicate the status of Receive time out interrupt. + (##) USART_IT_CTS: to indicate the status of CTS change interrupt. + (##) USART_IT_LBD: to indicate the status of LIN Break detection interrupt. + (##) USART_IT_TC: to indicate the status of Transmission complete interrupt. + (##) USART_IT_IDLE: to indicate the status of IDLE line detected interrupt. + (##) USART_IT_ORE: to indicate the status of OverRun Error interrupt. + (##) USART_IT_NE: to indicate the status of Noise Error interrupt. + (##) USART_IT_FE: to indicate the status of Framing Error interrupt. + (##) USART_IT_PE: to indicate the status of Parity Error interrupt. + + (+) Interrupt Source: + (##) USART_IT_WU: specifies the interrupt source for Wake up interrupt. + (##) USART_IT_CM: specifies the interrupt source for Character match + interrupt. + (##) USART_IT_EOB: specifies the interrupt source for End of block + interrupt. + (##) USART_IT_RTO: specifies the interrupt source for Receive time-out + interrupt. + (##) USART_IT_CTS: specifies the interrupt source for CTS change interrupt. + (##) USART_IT_LBD: specifies the interrupt source for LIN Break + detection interrupt. + (##) USART_IT_TXE: specifies the interrupt source for Tansmit Data + Register empty interrupt. + (##) USART_IT_TC: specifies the interrupt source for Transmission + complete interrupt. + (##) USART_IT_RXNE: specifies the interrupt source for Receive Data + register not empty interrupt. + (##) USART_IT_IDLE: specifies the interrupt source for Idle line + detection interrupt. + (##) USART_IT_PE: specifies the interrupt source for Parity Error interrupt. + (##) USART_IT_ERR: specifies the interrupt source for Error interrupt + (Frame error, noise error, overrun error) + -@@- Some parameters are coded in order to use them as interrupt + source or as pending bits. + [..] In this Mode it is advised to use the following functions: + (+) void USART_ITConfig(USART_TypeDef* USARTx, uint16_t USART_IT, FunctionalState NewState). + (+) ITStatus USART_GetITStatus(USART_TypeDef* USARTx, uint16_t USART_IT). + (+) void USART_ClearITPendingBit(USART_TypeDef* USARTx, uint16_t USART_IT). + +@endverbatim + * @{ + */ + +/** + * @brief Enables or disables the specified USART interrupts. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_IT: specifies the USART interrupt sources to be enabled or disabled. + * This parameter can be one of the following values: + * @arg USART_IT_WU: Wake up interrupt, not available for STM32F030 devices. + * @arg USART_IT_CM: Character match interrupt. + * @arg USART_IT_EOB: End of block interrupt, not available for STM32F030 devices. + * @arg USART_IT_RTO: Receive time out interrupt. + * @arg USART_IT_CTS: CTS change interrupt. + * @arg USART_IT_LBD: LIN Break detection interrupt, not available for STM32F030 devices. + * @arg USART_IT_TXE: Tansmit Data Register empty interrupt. + * @arg USART_IT_TC: Transmission complete interrupt. + * @arg USART_IT_RXNE: Receive Data register not empty interrupt. + * @arg USART_IT_IDLE: Idle line detection interrupt. + * @arg USART_IT_PE: Parity Error interrupt. + * @arg USART_IT_ERR: Error interrupt(Frame error, noise error, overrun error) + * @param NewState: new state of the specified USARTx interrupts. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_ITConfig(USART_TypeDef* USARTx, uint32_t USART_IT, FunctionalState NewState) +{ + uint32_t usartreg = 0, itpos = 0, itmask = 0; + uint32_t usartxbase = 0; + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_CONFIG_IT(USART_IT)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + usartxbase = (uint32_t)USARTx; + + /* Get the USART register index */ + usartreg = (((uint16_t)USART_IT) >> 0x08); + + /* Get the interrupt position */ + itpos = USART_IT & IT_MASK; + itmask = (((uint32_t)0x01) << itpos); + + if (usartreg == 0x02) /* The IT is in CR2 register */ + { + usartxbase += 0x04; + } + else if (usartreg == 0x03) /* The IT is in CR3 register */ + { + usartxbase += 0x08; + } + else /* The IT is in CR1 register */ + { + } + if (NewState != DISABLE) + { + *(__IO uint32_t*)usartxbase |= itmask; + } + else + { + *(__IO uint32_t*)usartxbase &= ~itmask; + } +} + +/** + * @brief Enables the specified USART's Request. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_Request: specifies the USART request. + * This parameter can be any combination of the following values: + * @arg USART_Request_TXFRQ: Transmit data flush ReQuest + * @arg USART_Request_RXFRQ: Receive data flush ReQuest + * @arg USART_Request_MMRQ: Mute Mode ReQuest + * @arg USART_Request_SBKRQ: Send Break ReQuest + * @arg USART_Request_ABRRQ: Auto Baud Rate ReQuest + * @param NewState: new state of the DMA interface when reception error occurs. + * This parameter can be: ENABLE or DISABLE. + * @retval None + */ +void USART_RequestCmd(USART_TypeDef* USARTx, uint32_t USART_Request, FunctionalState NewState) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_REQUEST(USART_Request)); + assert_param(IS_FUNCTIONAL_STATE(NewState)); + + if (NewState != DISABLE) + { + /* Enable the USART ReQuest by setting the dedicated request bit in the RQR + register.*/ + USARTx->RQR |= USART_Request; + } + else + { + /* Disable the USART ReQuest by clearing the dedicated request bit in the RQR + register.*/ + USARTx->RQR &= (uint32_t)~USART_Request; + } +} + +/** + * @brief Enables or disables the USART's Overrun detection. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_OVRDetection: specifies the OVR detection status in case of OVR error. + * This parameter can be any combination of the following values: + * @arg USART_OVRDetection_Enable: OVR error detection enabled when + * the USART OVR error is asserted. + * @arg USART_OVRDetection_Disable: OVR error detection disabled when + * the USART OVR error is asserted. + * @retval None + */ +void USART_OverrunDetectionConfig(USART_TypeDef* USARTx, uint32_t USART_OVRDetection) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_OVRDETECTION(USART_OVRDetection)); + + /* Clear the OVR detection bit */ + USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_OVRDIS); + /* Set the new value for the OVR detection bit */ + USARTx->CR3 |= USART_OVRDetection; +} + +/** + * @brief Checks whether the specified USART flag is set or not. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_FLAG: specifies the flag to check. + * This parameter can be one of the following values: + * @arg USART_FLAG_REACK: Receive Enable acknowledge flag. + * @arg USART_FLAG_TEACK: Transmit Enable acknowledge flag. + * @arg USART_FLAG_WU: Wake up flag, not available for STM32F030 devices. + * @arg USART_FLAG_RWU: Receive Wake up flag, not available for STM32F030 devices. + * @arg USART_FLAG_SBK: Send Break flag. + * @arg USART_FLAG_CM: Character match flag. + * @arg USART_FLAG_BUSY: Busy flag. + * @arg USART_FLAG_ABRF: Auto baud rate flag. + * @arg USART_FLAG_ABRE: Auto baud rate error flag. + * @arg USART_FLAG_EOB: End of block flag, not available for STM32F030 devices. + * @arg USART_FLAG_RTO: Receive time out flag. + * @arg USART_FLAG_nCTSS: Inverted nCTS input bit status. + * @arg USART_FLAG_CTS: CTS Change flag. + * @arg USART_FLAG_LBD: LIN Break detection flag, not available for STM32F030 devices. + * @arg USART_FLAG_TXE: Transmit data register empty flag. + * @arg USART_FLAG_TC: Transmission Complete flag. + * @arg USART_FLAG_RXNE: Receive data register not empty flag. + * @arg USART_FLAG_IDLE: Idle Line detection flag. + * @arg USART_FLAG_ORE: OverRun Error flag. + * @arg USART_FLAG_NE: Noise Error flag. + * @arg USART_FLAG_FE: Framing Error flag. + * @arg USART_FLAG_PE: Parity Error flag. + * @retval The new state of USART_FLAG (SET or RESET). + */ +FlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, uint32_t USART_FLAG) +{ + FlagStatus bitstatus = RESET; + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_FLAG(USART_FLAG)); + + if ((USARTx->ISR & USART_FLAG) != (uint16_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + return bitstatus; +} + +/** + * @brief Clears the USARTx's pending flags. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_FLAG: specifies the flag to clear. + * This parameter can be any combination of the following values: + * @arg USART_FLAG_WU: Wake up flag, not available for STM32F030 devices. + * @arg USART_FLAG_CM: Character match flag. + * @arg USART_FLAG_EOB: End of block flag, not available for STM32F030 devices. + * @arg USART_FLAG_RTO: Receive time out flag. + * @arg USART_FLAG_CTS: CTS Change flag. + * @arg USART_FLAG_LBD: LIN Break detection flag, not available for STM32F030 devices. + * @arg USART_FLAG_TC: Transmission Complete flag. + * @arg USART_FLAG_IDLE: IDLE line detected flag. + * @arg USART_FLAG_ORE: OverRun Error flag. + * @arg USART_FLAG_NE: Noise Error flag. + * @arg USART_FLAG_FE: Framing Error flag. + * @arg USART_FLAG_PE: Parity Errorflag. + * + * @note RXNE pending bit is cleared by a read to the USART_RDR register + * (USART_ReceiveData()) or by writing 1 to the RXFRQ in the register + * USART_RQR (USART_RequestCmd()). + * @note TC flag can be also cleared by software sequence: a read operation + * to USART_SR register (USART_GetFlagStatus()) followed by a write + * operation to USART_TDR register (USART_SendData()). + * @note TXE flag is cleared by a write to the USART_TDR register (USART_SendData()) + * or by writing 1 to the TXFRQ in the register USART_RQR (USART_RequestCmd()). + * @note SBKF flag is cleared by 1 to the SBKRQ in the register USART_RQR + * (USART_RequestCmd()). + * @retval None + */ +void USART_ClearFlag(USART_TypeDef* USARTx, uint32_t USART_FLAG) +{ + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_CLEAR_FLAG(USART_FLAG)); + + USARTx->ICR = USART_FLAG; +} + +/** + * @brief Checks whether the specified USART interrupt has occurred or not. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_IT: specifies the USART interrupt source to check. + * This parameter can be one of the following values: + * @arg USART_IT_WU: Wake up interrupt, not available for STM32F030 devices. + * @arg USART_IT_CM: Character match interrupt. + * @arg USART_IT_EOB: End of block interrupt, not available for STM32F030 devices. + * @arg USART_IT_RTO: Receive time out interrupt. + * @arg USART_IT_CTS: CTS change interrupt. + * @arg USART_IT_LBD: LIN Break detection interrupt, not available for STM32F030 devices. + * @arg USART_IT_TXE: Tansmit Data Register empty interrupt. + * @arg USART_IT_TC: Transmission complete interrupt. + * @arg USART_IT_RXNE: Receive Data register not empty interrupt. + * @arg USART_IT_IDLE: Idle line detection interrupt. + * @arg USART_IT_ORE: OverRun Error interrupt. + * @arg USART_IT_NE: Noise Error interrupt. + * @arg USART_IT_FE: Framing Error interrupt. + * @arg USART_IT_PE: Parity Error interrupt. + * @retval The new state of USART_IT (SET or RESET). + */ +ITStatus USART_GetITStatus(USART_TypeDef* USARTx, uint32_t USART_IT) +{ + uint32_t bitpos = 0, itmask = 0, usartreg = 0; + ITStatus bitstatus = RESET; + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_GET_IT(USART_IT)); + + /* Get the USART register index */ + usartreg = (((uint16_t)USART_IT) >> 0x08); + /* Get the interrupt position */ + itmask = USART_IT & IT_MASK; + itmask = (uint32_t)0x01 << itmask; + + if (usartreg == 0x01) /* The IT is in CR1 register */ + { + itmask &= USARTx->CR1; + } + else if (usartreg == 0x02) /* The IT is in CR2 register */ + { + itmask &= USARTx->CR2; + } + else /* The IT is in CR3 register */ + { + itmask &= USARTx->CR3; + } + + bitpos = USART_IT >> 0x10; + bitpos = (uint32_t)0x01 << bitpos; + bitpos &= USARTx->ISR; + if ((itmask != (uint16_t)RESET)&&(bitpos != (uint16_t)RESET)) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + + return bitstatus; +} + +/** + * @brief Clears the USARTx's interrupt pending bits. + * @param USARTx: where x can be from 1 to 8 to select the USART peripheral. + * @note USART3 and USART4 are available only for STM32F072 and STM32F091 devices. + * @note USART5, USART6, USART7 and USART8 are available only for STM32F091 devices. + * @note USART2 is not available for STM32F031 devices. + * @param USART_IT: specifies the interrupt pending bit to clear. + * This parameter can be one of the following values: + * @arg USART_IT_WU: Wake up interrupt, not available for STM32F030 devices. + * @arg USART_IT_CM: Character match interrupt. + * @arg USART_IT_EOB: End of block interrupt, not available for STM32F030 devices. + * @arg USART_IT_RTO: Receive time out interrupt. + * @arg USART_IT_CTS: CTS change interrupt. + * @arg USART_IT_LBD: LIN Break detection interrupt, not available for STM32F030 devices. + * @arg USART_IT_TC: Transmission complete interrupt. + * @arg USART_IT_IDLE: IDLE line detected interrupt. + * @arg USART_IT_ORE: OverRun Error interrupt. + * @arg USART_IT_NE: Noise Error interrupt. + * @arg USART_IT_FE: Framing Error interrupt. + * @arg USART_IT_PE: Parity Error interrupt. + * + * @note RXNE pending bit is cleared by a read to the USART_RDR register + * (USART_ReceiveData()) or by writing 1 to the RXFRQ in the register + * USART_RQR (USART_RequestCmd()). + * @note TC pending bit can be also cleared by software sequence: a read + * operation to USART_SR register (USART_GetITStatus()) followed by + * a write operation to USART_TDR register (USART_SendData()). + * @note TXE pending bit is cleared by a write to the USART_TDR register + * (USART_SendData()) or by writing 1 to the TXFRQ in the register + * USART_RQR (USART_RequestCmd()). + * @retval None + */ +void USART_ClearITPendingBit(USART_TypeDef* USARTx, uint32_t USART_IT) +{ + uint32_t bitpos = 0, itmask = 0; + /* Check the parameters */ + assert_param(IS_USART_ALL_PERIPH(USARTx)); + assert_param(IS_USART_CLEAR_IT(USART_IT)); + + bitpos = USART_IT >> 0x10; + itmask = ((uint32_t)0x01 << (uint32_t)bitpos); + USARTx->ICR = (uint32_t)itmask; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_wwdg.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_wwdg.c new file mode 100644 index 00000000..da69ed3e --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/SPL/src/stm32f0xx_wwdg.c @@ -0,0 +1,303 @@ +/** + ****************************************************************************** + * @file stm32f0xx_wwdg.c + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief This file provides firmware functions to manage the following + * functionalities of the Window watchdog (WWDG) peripheral: + * + Prescaler, Refresh window and Counter configuration + * + WWDG activation + * + Interrupts and flags management + * + * @verbatim + * + ============================================================================== + ##### WWDG features ##### + ============================================================================== + [..] Once enabled the WWDG generates a system reset on expiry of a programmed + time period, unless the program refreshes the counter (downcounter) + before to reach 0x3F value (i.e. a reset is generated when the counter + value rolls over from 0x40 to 0x3F). + [..] An MCU reset is also generated if the counter value is refreshed + before the counter has reached the refresh window value. This + implies that the counter must be refreshed in a limited window. + + [..] Once enabled the WWDG cannot be disabled except by a system reset. + + [..] WWDGRST flag in RCC_CSR register can be used to inform when a WWDG + reset occurs. + + [..] The WWDG counter input clock is derived from the APB clock divided + by a programmable prescaler. + + [..] WWDG counter clock = PCLK1 / Prescaler. + [..] WWDG timeout = (WWDG counter clock) * (counter value). + + [..] Min-max timeout value @32MHz (PCLK1): ~85us / ~43ms. + + ##### How to use this driver ##### + ============================================================================== + [..] + (#) Enable WWDG clock using RCC_APB1PeriphClockCmd(RCC_APB1Periph_WWDG, ENABLE) + function. + + (#) Configure the WWDG prescaler using WWDG_SetPrescaler() function. + + (#) Configure the WWDG refresh window using WWDG_SetWindowValue() function. + + (#) Set the WWDG counter value and start it using WWDG_Enable() function. + When the WWDG is enabled the counter value should be configured to + a value greater than 0x40 to prevent generating an immediate reset. + + (#) Optionally you can enable the Early wakeup interrupt which is + generated when the counter reach 0x40. + Once enabled this interrupt cannot be disabled except by a system reset. + + (#) Then the application program must refresh the WWDG counter at regular + intervals during normal operation to prevent an MCU reset, using + WWDG_SetCounter() function. This operation must occur only when + the counter value is lower than the refresh window value, + programmed using WWDG_SetWindowValue(). + + * @endverbatim + * + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f0xx_wwdg.h" +#include "stm32f0xx_rcc.h" + +/** @addtogroup STM32F0xx_StdPeriph_Driver + * @{ + */ + +/** @defgroup WWDG + * @brief WWDG driver modules + * @{ + */ + +/* Private typedef -----------------------------------------------------------*/ +/* Private define ------------------------------------------------------------*/ +/* --------------------- WWDG registers bit mask ---------------------------- */ +/* CFR register bit mask */ +#define CFR_WDGTB_MASK ((uint32_t)0xFFFFFE7F) +#define CFR_W_MASK ((uint32_t)0xFFFFFF80) +#define BIT_MASK ((uint8_t)0x7F) + +/* Private macro -------------------------------------------------------------*/ +/* Private variables ---------------------------------------------------------*/ +/* Private function prototypes -----------------------------------------------*/ +/* Private functions ---------------------------------------------------------*/ + +/** @defgroup WWDG_Private_Functions + * @{ + */ + +/** @defgroup WWDG_Group1 Prescaler, Refresh window and Counter configuration functions + * @brief Prescaler, Refresh window and Counter configuration functions + * +@verbatim + ============================================================================== + ##### Prescaler, Refresh window and Counter configuration functions ##### + ============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Deinitializes the WWDG peripheral registers to their default reset values. + * @param None + * @retval None + */ +void WWDG_DeInit(void) +{ + RCC_APB1PeriphResetCmd(RCC_APB1Periph_WWDG, ENABLE); + RCC_APB1PeriphResetCmd(RCC_APB1Periph_WWDG, DISABLE); +} + +/** + * @brief Sets the WWDG Prescaler. + * @param WWDG_Prescaler: specifies the WWDG Prescaler. + * This parameter can be one of the following values: + * @arg WWDG_Prescaler_1: WWDG counter clock = (PCLK1/4096)/1 + * @arg WWDG_Prescaler_2: WWDG counter clock = (PCLK1/4096)/2 + * @arg WWDG_Prescaler_4: WWDG counter clock = (PCLK1/4096)/4 + * @arg WWDG_Prescaler_8: WWDG counter clock = (PCLK1/4096)/8 + * @retval None + */ +void WWDG_SetPrescaler(uint32_t WWDG_Prescaler) +{ + uint32_t tmpreg = 0; + /* Check the parameters */ + assert_param(IS_WWDG_PRESCALER(WWDG_Prescaler)); + /* Clear WDGTB[1:0] bits */ + tmpreg = WWDG->CFR & CFR_WDGTB_MASK; + /* Set WDGTB[1:0] bits according to WWDG_Prescaler value */ + tmpreg |= WWDG_Prescaler; + /* Store the new value */ + WWDG->CFR = tmpreg; +} + +/** + * @brief Sets the WWDG window value. + * @param WindowValue: specifies the window value to be compared to the downcounter. + * This parameter value must be lower than 0x80. + * @retval None + */ +void WWDG_SetWindowValue(uint8_t WindowValue) +{ + __IO uint32_t tmpreg = 0; + + /* Check the parameters */ + assert_param(IS_WWDG_WINDOW_VALUE(WindowValue)); + /* Clear W[6:0] bits */ + + tmpreg = WWDG->CFR & CFR_W_MASK; + + /* Set W[6:0] bits according to WindowValue value */ + tmpreg |= WindowValue & (uint32_t) BIT_MASK; + + /* Store the new value */ + WWDG->CFR = tmpreg; +} + +/** + * @brief Enables the WWDG Early Wakeup interrupt(EWI). + * @note Once enabled this interrupt cannot be disabled except by a system reset. + * @param None + * @retval None + */ +void WWDG_EnableIT(void) +{ + WWDG->CFR |= WWDG_CFR_EWI; +} + +/** + * @brief Sets the WWDG counter value. + * @param Counter: specifies the watchdog counter value. + * This parameter must be a number between 0x40 and 0x7F (to prevent + * generating an immediate reset). + * @retval None + */ +void WWDG_SetCounter(uint8_t Counter) +{ + /* Check the parameters */ + assert_param(IS_WWDG_COUNTER(Counter)); + /* Write to T[6:0] bits to configure the counter value, no need to do + a read-modify-write; writing a 0 to WDGA bit does nothing */ + WWDG->CR = Counter & BIT_MASK; +} + +/** + * @} + */ + +/** @defgroup WWDG_Group2 WWDG activation functions + * @brief WWDG activation functions + * +@verbatim + ============================================================================== + ##### WWDG activation function ##### + ============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Enables WWDG and load the counter value. + * @param Counter: specifies the watchdog counter value. + * This parameter must be a number between 0x40 and 0x7F (to prevent + * generating an immediate reset). + * @retval None + */ +void WWDG_Enable(uint8_t Counter) +{ + /* Check the parameters */ + assert_param(IS_WWDG_COUNTER(Counter)); + WWDG->CR = WWDG_CR_WDGA | Counter; +} + +/** + * @} + */ + +/** @defgroup WWDG_Group3 Interrupts and flags management functions + * @brief Interrupts and flags management functions + * +@verbatim + ============================================================================== + ##### Interrupts and flags management functions ##### + ============================================================================== + +@endverbatim + * @{ + */ + +/** + * @brief Checks whether the Early Wakeup interrupt flag is set or not. + * @param None + * @retval The new state of the Early Wakeup interrupt flag (SET or RESET). + */ +FlagStatus WWDG_GetFlagStatus(void) +{ + FlagStatus bitstatus = RESET; + + if ((WWDG->SR) != (uint32_t)RESET) + { + bitstatus = SET; + } + else + { + bitstatus = RESET; + } + return bitstatus; +} + +/** + * @brief Clears Early Wakeup interrupt flag. + * @param None + * @retval None + */ +void WWDG_ClearFlag(void) +{ + WWDG->SR = (uint32_t)RESET; +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/arm_common_tables.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/arm_common_tables.h new file mode 100644 index 00000000..9c37ab4e --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/arm_common_tables.h @@ -0,0 +1,93 @@ +/* ---------------------------------------------------------------------- +* Copyright (C) 2010-2013 ARM Limited. All rights reserved. +* +* $Date: 17. January 2013 +* $Revision: V1.4.1 +* +* Project: CMSIS DSP Library +* Title: arm_common_tables.h +* +* Description: This file has extern declaration for common tables like Bitreverse, reciprocal etc which are used across different functions +* +* Target Processor: Cortex-M4/Cortex-M3 +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* - Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* - Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in +* the documentation and/or other materials provided with the +* distribution. +* - Neither the name of ARM LIMITED nor the names of its contributors +* may be used to endorse or promote products derived from this +* software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +* -------------------------------------------------------------------- */ + +#ifndef _ARM_COMMON_TABLES_H +#define _ARM_COMMON_TABLES_H + +#include "arm_math.h" + +extern const uint16_t armBitRevTable[1024]; +extern const q15_t armRecipTableQ15[64]; +extern const q31_t armRecipTableQ31[64]; +extern const q31_t realCoefAQ31[1024]; +extern const q31_t realCoefBQ31[1024]; +extern const float32_t twiddleCoef_16[32]; +extern const float32_t twiddleCoef_32[64]; +extern const float32_t twiddleCoef_64[128]; +extern const float32_t twiddleCoef_128[256]; +extern const float32_t twiddleCoef_256[512]; +extern const float32_t twiddleCoef_512[1024]; +extern const float32_t twiddleCoef_1024[2048]; +extern const float32_t twiddleCoef_2048[4096]; +extern const float32_t twiddleCoef_4096[8192]; +#define twiddleCoef twiddleCoef_4096 +extern const q31_t twiddleCoefQ31[6144]; +extern const q15_t twiddleCoefQ15[6144]; +extern const float32_t twiddleCoef_rfft_32[32]; +extern const float32_t twiddleCoef_rfft_64[64]; +extern const float32_t twiddleCoef_rfft_128[128]; +extern const float32_t twiddleCoef_rfft_256[256]; +extern const float32_t twiddleCoef_rfft_512[512]; +extern const float32_t twiddleCoef_rfft_1024[1024]; +extern const float32_t twiddleCoef_rfft_2048[2048]; +extern const float32_t twiddleCoef_rfft_4096[4096]; + + +#define ARMBITREVINDEXTABLE__16_TABLE_LENGTH ((uint16_t)20 ) +#define ARMBITREVINDEXTABLE__32_TABLE_LENGTH ((uint16_t)48 ) +#define ARMBITREVINDEXTABLE__64_TABLE_LENGTH ((uint16_t)56 ) +#define ARMBITREVINDEXTABLE_128_TABLE_LENGTH ((uint16_t)208 ) +#define ARMBITREVINDEXTABLE_256_TABLE_LENGTH ((uint16_t)440 ) +#define ARMBITREVINDEXTABLE_512_TABLE_LENGTH ((uint16_t)448 ) +#define ARMBITREVINDEXTABLE1024_TABLE_LENGTH ((uint16_t)1800) +#define ARMBITREVINDEXTABLE2048_TABLE_LENGTH ((uint16_t)3808) +#define ARMBITREVINDEXTABLE4096_TABLE_LENGTH ((uint16_t)4032) + +extern const uint16_t armBitRevIndexTable16[ARMBITREVINDEXTABLE__16_TABLE_LENGTH]; +extern const uint16_t armBitRevIndexTable32[ARMBITREVINDEXTABLE__32_TABLE_LENGTH]; +extern const uint16_t armBitRevIndexTable64[ARMBITREVINDEXTABLE__64_TABLE_LENGTH]; +extern const uint16_t armBitRevIndexTable128[ARMBITREVINDEXTABLE_128_TABLE_LENGTH]; +extern const uint16_t armBitRevIndexTable256[ARMBITREVINDEXTABLE_256_TABLE_LENGTH]; +extern const uint16_t armBitRevIndexTable512[ARMBITREVINDEXTABLE_512_TABLE_LENGTH]; +extern const uint16_t armBitRevIndexTable1024[ARMBITREVINDEXTABLE1024_TABLE_LENGTH]; +extern const uint16_t armBitRevIndexTable2048[ARMBITREVINDEXTABLE2048_TABLE_LENGTH]; +extern const uint16_t armBitRevIndexTable4096[ARMBITREVINDEXTABLE4096_TABLE_LENGTH]; + +#endif /* ARM_COMMON_TABLES_H */ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/arm_const_structs.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/arm_const_structs.h new file mode 100644 index 00000000..406f737d --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/arm_const_structs.h @@ -0,0 +1,85 @@ +/* ---------------------------------------------------------------------- +* Copyright (C) 2010-2013 ARM Limited. All rights reserved. +* +* $Date: 17. January 2013 +* $Revision: V1.4.1 +* +* Project: CMSIS DSP Library +* Title: arm_const_structs.h +* +* Description: This file has constant structs that are initialized for +* user convenience. For example, some can be given as +* arguments to the arm_cfft_f32() function. +* +* Target Processor: Cortex-M4/Cortex-M3 +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* - Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* - Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in +* the documentation and/or other materials provided with the +* distribution. +* - Neither the name of ARM LIMITED nor the names of its contributors +* may be used to endorse or promote products derived from this +* software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +* -------------------------------------------------------------------- */ + +#ifndef _ARM_CONST_STRUCTS_H +#define _ARM_CONST_STRUCTS_H + +#include "arm_math.h" +#include "arm_common_tables.h" + + const arm_cfft_instance_f32 arm_cfft_sR_f32_len16 = { + 16, twiddleCoef_16, armBitRevIndexTable16, ARMBITREVINDEXTABLE__16_TABLE_LENGTH + }; + + const arm_cfft_instance_f32 arm_cfft_sR_f32_len32 = { + 32, twiddleCoef_32, armBitRevIndexTable32, ARMBITREVINDEXTABLE__32_TABLE_LENGTH + }; + + const arm_cfft_instance_f32 arm_cfft_sR_f32_len64 = { + 64, twiddleCoef_64, armBitRevIndexTable64, ARMBITREVINDEXTABLE__64_TABLE_LENGTH + }; + + const arm_cfft_instance_f32 arm_cfft_sR_f32_len128 = { + 128, twiddleCoef_128, armBitRevIndexTable128, ARMBITREVINDEXTABLE_128_TABLE_LENGTH + }; + + const arm_cfft_instance_f32 arm_cfft_sR_f32_len256 = { + 256, twiddleCoef_256, armBitRevIndexTable256, ARMBITREVINDEXTABLE_256_TABLE_LENGTH + }; + + const arm_cfft_instance_f32 arm_cfft_sR_f32_len512 = { + 512, twiddleCoef_512, armBitRevIndexTable512, ARMBITREVINDEXTABLE_512_TABLE_LENGTH + }; + + const arm_cfft_instance_f32 arm_cfft_sR_f32_len1024 = { + 1024, twiddleCoef_1024, armBitRevIndexTable1024, ARMBITREVINDEXTABLE1024_TABLE_LENGTH + }; + + const arm_cfft_instance_f32 arm_cfft_sR_f32_len2048 = { + 2048, twiddleCoef_2048, armBitRevIndexTable2048, ARMBITREVINDEXTABLE2048_TABLE_LENGTH + }; + + const arm_cfft_instance_f32 arm_cfft_sR_f32_len4096 = { + 4096, twiddleCoef_4096, armBitRevIndexTable4096, ARMBITREVINDEXTABLE4096_TABLE_LENGTH + }; + +#endif diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/arm_math.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/arm_math.h new file mode 100644 index 00000000..59662ae1 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/arm_math.h @@ -0,0 +1,7306 @@ +/* ---------------------------------------------------------------------- +* Copyright (C) 2010-2013 ARM Limited. All rights reserved. +* +* $Date: 17. January 2013 +* $Revision: V1.4.1 +* +* Project: CMSIS DSP Library +* Title: arm_math.h +* +* Description: Public header file for CMSIS DSP Library +* +* Target Processor: Cortex-M4/Cortex-M3/Cortex-M0 +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* - Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* - Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in +* the documentation and/or other materials provided with the +* distribution. +* - Neither the name of ARM LIMITED nor the names of its contributors +* may be used to endorse or promote products derived from this +* software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. + * -------------------------------------------------------------------- */ + +/** + \mainpage CMSIS DSP Software Library + * + * Introduction + * + * This user manual describes the CMSIS DSP software library, + * a suite of common signal processing functions for use on Cortex-M processor based devices. + * + * The library is divided into a number of functions each covering a specific category: + * - Basic math functions + * - Fast math functions + * - Complex math functions + * - Filters + * - Matrix functions + * - Transforms + * - Motor control functions + * - Statistical functions + * - Support functions + * - Interpolation functions + * + * The library has separate functions for operating on 8-bit integers, 16-bit integers, + * 32-bit integer and 32-bit floating-point values. + * + * Using the Library + * + * The library installer contains prebuilt versions of the libraries in the Lib folder. + * - arm_cortexM4lf_math.lib (Little endian and Floating Point Unit on Cortex-M4) + * - arm_cortexM4bf_math.lib (Big endian and Floating Point Unit on Cortex-M4) + * - arm_cortexM4l_math.lib (Little endian on Cortex-M4) + * - arm_cortexM4b_math.lib (Big endian on Cortex-M4) + * - arm_cortexM3l_math.lib (Little endian on Cortex-M3) + * - arm_cortexM3b_math.lib (Big endian on Cortex-M3) + * - arm_cortexM0l_math.lib (Little endian on Cortex-M0) + * - arm_cortexM0b_math.lib (Big endian on Cortex-M3) + * + * The library functions are declared in the public file arm_math.h which is placed in the Include folder. + * Simply include this file and link the appropriate library in the application and begin calling the library functions. The Library supports single + * public header file arm_math.h for Cortex-M4/M3/M0 with little endian and big endian. Same header file will be used for floating point unit(FPU) variants. + * Define the appropriate pre processor MACRO ARM_MATH_CM4 or ARM_MATH_CM3 or + * ARM_MATH_CM0 or ARM_MATH_CM0PLUS depending on the target processor in the application. + * + * Examples + * + * The library ships with a number of examples which demonstrate how to use the library functions. + * + * Toolchain Support + * + * The library has been developed and tested with MDK-ARM version 4.60. + * The library is being tested in GCC and IAR toolchains and updates on this activity will be made available shortly. + * + * Building the Library + * + * The library installer contains project files to re build libraries on MDK Tool chain in the CMSIS\\DSP_Lib\\Source\\ARM folder. + * - arm_cortexM0b_math.uvproj + * - arm_cortexM0l_math.uvproj + * - arm_cortexM3b_math.uvproj + * - arm_cortexM3l_math.uvproj + * - arm_cortexM4b_math.uvproj + * - arm_cortexM4l_math.uvproj + * - arm_cortexM4bf_math.uvproj + * - arm_cortexM4lf_math.uvproj + * + * + * The project can be built by opening the appropriate project in MDK-ARM 4.60 chain and defining the optional pre processor MACROs detailed above. + * + * Pre-processor Macros + * + * Each library project have differant pre-processor macros. + * + * - UNALIGNED_SUPPORT_DISABLE: + * + * Define macro UNALIGNED_SUPPORT_DISABLE, If the silicon does not support unaligned memory access + * + * - ARM_MATH_BIG_ENDIAN: + * + * Define macro ARM_MATH_BIG_ENDIAN to build the library for big endian targets. By default library builds for little endian targets. + * + * - ARM_MATH_MATRIX_CHECK: + * + * Define macro ARM_MATH_MATRIX_CHECK for checking on the input and output sizes of matrices + * + * - ARM_MATH_ROUNDING: + * + * Define macro ARM_MATH_ROUNDING for rounding on support functions + * + * - ARM_MATH_CMx: + * + * Define macro ARM_MATH_CM4 for building the library on Cortex-M4 target, ARM_MATH_CM3 for building library on Cortex-M3 target + * and ARM_MATH_CM0 for building library on cortex-M0 target, ARM_MATH_CM0PLUS for building library on cortex-M0+ target. + * + * - __FPU_PRESENT: + * + * Initialize macro __FPU_PRESENT = 1 when building on FPU supported Targets. Enable this macro for M4bf and M4lf libraries + * + * Copyright Notice + * + * Copyright (C) 2010-2013 ARM Limited. All rights reserved. + */ + + +/** + * @defgroup groupMath Basic Math Functions + */ + +/** + * @defgroup groupFastMath Fast Math Functions + * This set of functions provides a fast approximation to sine, cosine, and square root. + * As compared to most of the other functions in the CMSIS math library, the fast math functions + * operate on individual values and not arrays. + * There are separate functions for Q15, Q31, and floating-point data. + * + */ + +/** + * @defgroup groupCmplxMath Complex Math Functions + * This set of functions operates on complex data vectors. + * The data in the complex arrays is stored in an interleaved fashion + * (real, imag, real, imag, ...). + * In the API functions, the number of samples in a complex array refers + * to the number of complex values; the array contains twice this number of + * real values. + */ + +/** + * @defgroup groupFilters Filtering Functions + */ + +/** + * @defgroup groupMatrix Matrix Functions + * + * This set of functions provides basic matrix math operations. + * The functions operate on matrix data structures. For example, + * the type + * definition for the floating-point matrix structure is shown + * below: + * 
      + *     typedef struct
+ *     {
+ *       uint16_t numRows;     // number of rows of the matrix.
+ *       uint16_t numCols;     // number of columns of the matrix.
+ *       float32_t *pData;     // points to the data of the matrix.
+ *     } arm_matrix_instance_f32;
+ *
      + * There are similar definitions for Q15 and Q31 data types. + * + * The structure specifies the size of the matrix and then points to + * an array of data. The array is of size numRows X numCols + * and the values are arranged in row order. That is, the + * matrix element (i, j) is stored at: + * 
      + *     pData[i*numCols + j]
+ *
      + * + * \par Init Functions + * There is an associated initialization function for each type of matrix + * data structure. + * The initialization function sets the values of the internal structure fields. + * Refer to the function arm_mat_init_f32(), arm_mat_init_q31() + * and arm_mat_init_q15() for floating-point, Q31 and Q15 types, respectively. + * + * \par + * Use of the initialization function is optional. However, if initialization function is used + * then the instance structure cannot be placed into a const data section. + * To place the instance structure in a const data + * section, manually initialize the data structure. For example: + * 
      + * arm_matrix_instance_f32 S = {nRows, nColumns, pData};
+ * arm_matrix_instance_q31 S = {nRows, nColumns, pData};
+ * arm_matrix_instance_q15 S = {nRows, nColumns, pData};
+ *
      + * where nRows specifies the number of rows, nColumns + * specifies the number of columns, and pData points to the + * data array. + * + * \par Size Checking + * By default all of the matrix functions perform size checking on the input and + * output matrices. For example, the matrix addition function verifies that the + * two input matrices and the output matrix all have the same number of rows and + * columns. If the size check fails the functions return: + * 
      + *     ARM_MATH_SIZE_MISMATCH
+ *
      + * Otherwise the functions return + * 
      + *     ARM_MATH_SUCCESS
+ *
      + * There is some overhead associated with this matrix size checking. + * The matrix size checking is enabled via the \#define + * 
      + *     ARM_MATH_MATRIX_CHECK
+ *
      + * within the library project settings. By default this macro is defined + * and size checking is enabled. By changing the project settings and + * undefining this macro size checking is eliminated and the functions + * run a bit faster. With size checking disabled the functions always + * return ARM_MATH_SUCCESS. + */ + +/** + * @defgroup groupTransforms Transform Functions + */ + +/** + * @defgroup groupController Controller Functions + */ + +/** + * @defgroup groupStats Statistics Functions + */ +/** + * @defgroup groupSupport Support Functions + */ + +/** + * @defgroup groupInterpolation Interpolation Functions + * These functions perform 1- and 2-dimensional interpolation of data. + * Linear interpolation is used for 1-dimensional data and + * bilinear interpolation is used for 2-dimensional data. + */ + +/** + * @defgroup groupExamples Examples + */ +#ifndef _ARM_MATH_H +#define _ARM_MATH_H + +#define __CMSIS_GENERIC /* disable NVIC and Systick functions */ + +#if defined (ARM_MATH_CM4) +#include "core_cm4.h" +#elif defined (ARM_MATH_CM3) +#include "core_cm3.h" +#elif defined (ARM_MATH_CM0) +#include "core_cm0.h" +#define ARM_MATH_CM0_FAMILY +#elif defined (ARM_MATH_CM0PLUS) +#include "core_cm0plus.h" +#define ARM_MATH_CM0_FAMILY +#else +#include "ARMCM4.h" +#warning "Define either ARM_MATH_CM4 OR ARM_MATH_CM3...By Default building on ARM_MATH_CM4....." +#endif + +#undef __CMSIS_GENERIC /* enable NVIC and Systick functions */ +#include "string.h" +#include "math.h" +#ifdef __cplusplus +extern "C" +{ +#endif + + + /** + * @brief Macros required for reciprocal calculation in Normalized LMS + */ + +#define DELTA_Q31 (0x100) +#define DELTA_Q15 0x5 +#define INDEX_MASK 0x0000003F +#ifndef PI +#define PI 3.14159265358979f +#endif + + /** + * @brief Macros required for SINE and COSINE Fast math approximations + */ + +#define TABLE_SIZE 256 +#define TABLE_SPACING_Q31 0x800000 +#define TABLE_SPACING_Q15 0x80 + + /** + * @brief Macros required for SINE and COSINE Controller functions + */ + /* 1.31(q31) Fixed value of 2/360 */ + /* -1 to +1 is divided into 360 values so total spacing is (2/360) */ +#define INPUT_SPACING 0xB60B61 + + /** + * @brief Macro for Unaligned Support + */ +#ifndef UNALIGNED_SUPPORT_DISABLE + #define ALIGN4 +#else + #if defined (__GNUC__) + #define ALIGN4 __attribute__((aligned(4))) + #else + #define ALIGN4 __align(4) + #endif +#endif /* #ifndef UNALIGNED_SUPPORT_DISABLE */ + + /** + * @brief Error status returned by some functions in the library. + */ + + typedef enum + { + ARM_MATH_SUCCESS = 0, /**< No error */ + ARM_MATH_ARGUMENT_ERROR = -1, /**< One or more arguments are incorrect */ + ARM_MATH_LENGTH_ERROR = -2, /**< Length of data buffer is incorrect */ + ARM_MATH_SIZE_MISMATCH = -3, /**< Size of matrices is not compatible with the operation. */ + ARM_MATH_NANINF = -4, /**< Not-a-number (NaN) or infinity is generated */ + ARM_MATH_SINGULAR = -5, /**< Generated by matrix inversion if the input matrix is singular and cannot be inverted. */ + ARM_MATH_TEST_FAILURE = -6 /**< Test Failed */ + } arm_status; + + /** + * @brief 8-bit fractional data type in 1.7 format. + */ + typedef int8_t q7_t; + + /** + * @brief 16-bit fractional data type in 1.15 format. + */ + typedef int16_t q15_t; + + /** + * @brief 32-bit fractional data type in 1.31 format. + */ + typedef int32_t q31_t; + + /** + * @brief 64-bit fractional data type in 1.63 format. + */ + typedef int64_t q63_t; + + /** + * @brief 32-bit floating-point type definition. + */ + typedef float float32_t; + + /** + * @brief 64-bit floating-point type definition. + */ + typedef double float64_t; + + /** + * @brief definition to read/write two 16 bit values. + */ +#if defined __CC_ARM +#define __SIMD32_TYPE int32_t __packed +#define CMSIS_UNUSED __attribute__((unused)) +#elif defined __ICCARM__ +#define CMSIS_UNUSED +#define __SIMD32_TYPE int32_t __packed +#elif defined __GNUC__ +#define __SIMD32_TYPE int32_t +#define CMSIS_UNUSED __attribute__((unused)) +#else +#error Unknown compiler +#endif + +#define __SIMD32(addr) (*(__SIMD32_TYPE **) & (addr)) +#define __SIMD32_CONST(addr) ((__SIMD32_TYPE *)(addr)) + +#define _SIMD32_OFFSET(addr) (*(__SIMD32_TYPE *) (addr)) + +#define __SIMD64(addr) (*(int64_t **) & (addr)) + +#if defined (ARM_MATH_CM3) || defined (ARM_MATH_CM0_FAMILY) + /** + * @brief definition to pack two 16 bit values. + */ +#define __PKHBT(ARG1, ARG2, ARG3) ( (((int32_t)(ARG1) << 0) & (int32_t)0x0000FFFF) | \ + (((int32_t)(ARG2) << ARG3) & (int32_t)0xFFFF0000) ) +#define __PKHTB(ARG1, ARG2, ARG3) ( (((int32_t)(ARG1) << 0) & (int32_t)0xFFFF0000) | \ + (((int32_t)(ARG2) >> ARG3) & (int32_t)0x0000FFFF) ) + +#endif + + + /** + * @brief definition to pack four 8 bit values. + */ +#ifndef ARM_MATH_BIG_ENDIAN + +#define __PACKq7(v0,v1,v2,v3) ( (((int32_t)(v0) << 0) & (int32_t)0x000000FF) | \ + (((int32_t)(v1) << 8) & (int32_t)0x0000FF00) | \ + (((int32_t)(v2) << 16) & (int32_t)0x00FF0000) | \ + (((int32_t)(v3) << 24) & (int32_t)0xFF000000) ) +#else + +#define __PACKq7(v0,v1,v2,v3) ( (((int32_t)(v3) << 0) & (int32_t)0x000000FF) | \ + (((int32_t)(v2) << 8) & (int32_t)0x0000FF00) | \ + (((int32_t)(v1) << 16) & (int32_t)0x00FF0000) | \ + (((int32_t)(v0) << 24) & (int32_t)0xFF000000) ) + +#endif + + + /** + * @brief Clips Q63 to Q31 values. + */ + static __INLINE q31_t clip_q63_to_q31( + q63_t x) + { + return ((q31_t) (x >> 32) != ((q31_t) x >> 31)) ? + ((0x7FFFFFFF ^ ((q31_t) (x >> 63)))) : (q31_t) x; + } + + /** + * @brief Clips Q63 to Q15 values. + */ + static __INLINE q15_t clip_q63_to_q15( + q63_t x) + { + return ((q31_t) (x >> 32) != ((q31_t) x >> 31)) ? + ((0x7FFF ^ ((q15_t) (x >> 63)))) : (q15_t) (x >> 15); + } + + /** + * @brief Clips Q31 to Q7 values. + */ + static __INLINE q7_t clip_q31_to_q7( + q31_t x) + { + return ((q31_t) (x >> 24) != ((q31_t) x >> 23)) ? + ((0x7F ^ ((q7_t) (x >> 31)))) : (q7_t) x; + } + + /** + * @brief Clips Q31 to Q15 values. + */ + static __INLINE q15_t clip_q31_to_q15( + q31_t x) + { + return ((q31_t) (x >> 16) != ((q31_t) x >> 15)) ? + ((0x7FFF ^ ((q15_t) (x >> 31)))) : (q15_t) x; + } + + /** + * @brief Multiplies 32 X 64 and returns 32 bit result in 2.30 format. + */ + + static __INLINE q63_t mult32x64( + q63_t x, + q31_t y) + { + return ((((q63_t) (x & 0x00000000FFFFFFFF) * y) >> 32) + + (((q63_t) (x >> 32) * y))); + } + + +#if defined (ARM_MATH_CM0_FAMILY) && defined ( __CC_ARM ) +#define __CLZ __clz +#endif + +#if defined (ARM_MATH_CM0_FAMILY) && ((defined (__ICCARM__)) ||(defined (__GNUC__)) || defined (__TASKING__) ) + + static __INLINE uint32_t __CLZ( + q31_t data); + + + static __INLINE uint32_t __CLZ( + q31_t data) + { + uint32_t count = 0; + uint32_t mask = 0x80000000; + + while((data & mask) == 0) + { + count += 1u; + mask = mask >> 1u; + } + + return (count); + + } + +#endif + + /** + * @brief Function to Calculates 1/in (reciprocal) value of Q31 Data type. + */ + + static __INLINE uint32_t arm_recip_q31( + q31_t in, + q31_t * dst, + q31_t * pRecipTable) + { + + uint32_t out, tempVal; + uint32_t index, i; + uint32_t signBits; + + if(in > 0) + { + signBits = __CLZ(in) - 1; + } + else + { + signBits = __CLZ(-in) - 1; + } + + /* Convert input sample to 1.31 format */ + in = in << signBits; + + /* calculation of index for initial approximated Val */ + index = (uint32_t) (in >> 24u); + index = (index & INDEX_MASK); + + /* 1.31 with exp 1 */ + out = pRecipTable[index]; + + /* calculation of reciprocal value */ + /* running approximation for two iterations */ + for (i = 0u; i < 2u; i++) + { + tempVal = (q31_t) (((q63_t) in * out) >> 31u); + tempVal = 0x7FFFFFFF - tempVal; + /* 1.31 with exp 1 */ + //out = (q31_t) (((q63_t) out * tempVal) >> 30u); + out = (q31_t) clip_q63_to_q31(((q63_t) out * tempVal) >> 30u); + } + + /* write output */ + *dst = out; + + /* return num of signbits of out = 1/in value */ + return (signBits + 1u); + + } + + /** + * @brief Function to Calculates 1/in (reciprocal) value of Q15 Data type. + */ + static __INLINE uint32_t arm_recip_q15( + q15_t in, + q15_t * dst, + q15_t * pRecipTable) + { + + uint32_t out = 0, tempVal = 0; + uint32_t index = 0, i = 0; + uint32_t signBits = 0; + + if(in > 0) + { + signBits = __CLZ(in) - 17; + } + else + { + signBits = __CLZ(-in) - 17; + } + + /* Convert input sample to 1.15 format */ + in = in << signBits; + + /* calculation of index for initial approximated Val */ + index = in >> 8; + index = (index & INDEX_MASK); + + /* 1.15 with exp 1 */ + out = pRecipTable[index]; + + /* calculation of reciprocal value */ + /* running approximation for two iterations */ + for (i = 0; i < 2; i++) + { + tempVal = (q15_t) (((q31_t) in * out) >> 15); + tempVal = 0x7FFF - tempVal; + /* 1.15 with exp 1 */ + out = (q15_t) (((q31_t) out * tempVal) >> 14); + } + + /* write output */ + *dst = out; + + /* return num of signbits of out = 1/in value */ + return (signBits + 1); + + } + + + /* + * @brief C custom defined intrinisic function for only M0 processors + */ +#if defined(ARM_MATH_CM0_FAMILY) + + static __INLINE q31_t __SSAT( + q31_t x, + uint32_t y) + { + int32_t posMax, negMin; + uint32_t i; + + posMax = 1; + for (i = 0; i < (y - 1); i++) + { + posMax = posMax * 2; + } + + if(x > 0) + { + posMax = (posMax - 1); + + if(x > posMax) + { + x = posMax; + } + } + else + { + negMin = -posMax; + + if(x < negMin) + { + x = negMin; + } + } + return (x); + + + } + +#endif /* end of ARM_MATH_CM0_FAMILY */ + + + + /* + * @brief C custom defined intrinsic function for M3 and M0 processors + */ +#if defined (ARM_MATH_CM3) || defined (ARM_MATH_CM0_FAMILY) + + /* + * @brief C custom defined QADD8 for M3 and M0 processors + */ + static __INLINE q31_t __QADD8( + q31_t x, + q31_t y) + { + + q31_t sum; + q7_t r, s, t, u; + + r = (q7_t) x; + s = (q7_t) y; + + r = __SSAT((q31_t) (r + s), 8); + s = __SSAT(((q31_t) (((x << 16) >> 24) + ((y << 16) >> 24))), 8); + t = __SSAT(((q31_t) (((x << 8) >> 24) + ((y << 8) >> 24))), 8); + u = __SSAT(((q31_t) ((x >> 24) + (y >> 24))), 8); + + sum = + (((q31_t) u << 24) & 0xFF000000) | (((q31_t) t << 16) & 0x00FF0000) | + (((q31_t) s << 8) & 0x0000FF00) | (r & 0x000000FF); + + return sum; + + } + + /* + * @brief C custom defined QSUB8 for M3 and M0 processors + */ + static __INLINE q31_t __QSUB8( + q31_t x, + q31_t y) + { + + q31_t sum; + q31_t r, s, t, u; + + r = (q7_t) x; + s = (q7_t) y; + + r = __SSAT((r - s), 8); + s = __SSAT(((q31_t) (((x << 16) >> 24) - ((y << 16) >> 24))), 8) << 8; + t = __SSAT(((q31_t) (((x << 8) >> 24) - ((y << 8) >> 24))), 8) << 16; + u = __SSAT(((q31_t) ((x >> 24) - (y >> 24))), 8) << 24; + + sum = + (u & 0xFF000000) | (t & 0x00FF0000) | (s & 0x0000FF00) | (r & + 0x000000FF); + + return sum; + } + + /* + * @brief C custom defined QADD16 for M3 and M0 processors + */ + + /* + * @brief C custom defined QADD16 for M3 and M0 processors + */ + static __INLINE q31_t __QADD16( + q31_t x, + q31_t y) + { + + q31_t sum; + q31_t r, s; + + r = (short) x; + s = (short) y; + + r = __SSAT(r + s, 16); + s = __SSAT(((q31_t) ((x >> 16) + (y >> 16))), 16) << 16; + + sum = (s & 0xFFFF0000) | (r & 0x0000FFFF); + + return sum; + + } + + /* + * @brief C custom defined SHADD16 for M3 and M0 processors + */ + static __INLINE q31_t __SHADD16( + q31_t x, + q31_t y) + { + + q31_t sum; + q31_t r, s; + + r = (short) x; + s = (short) y; + + r = ((r >> 1) + (s >> 1)); + s = ((q31_t) ((x >> 17) + (y >> 17))) << 16; + + sum = (s & 0xFFFF0000) | (r & 0x0000FFFF); + + return sum; + + } + + /* + * @brief C custom defined QSUB16 for M3 and M0 processors + */ + static __INLINE q31_t __QSUB16( + q31_t x, + q31_t y) + { + + q31_t sum; + q31_t r, s; + + r = (short) x; + s = (short) y; + + r = __SSAT(r - s, 16); + s = __SSAT(((q31_t) ((x >> 16) - (y >> 16))), 16) << 16; + + sum = (s & 0xFFFF0000) | (r & 0x0000FFFF); + + return sum; + } + + /* + * @brief C custom defined SHSUB16 for M3 and M0 processors + */ + static __INLINE q31_t __SHSUB16( + q31_t x, + q31_t y) + { + + q31_t diff; + q31_t r, s; + + r = (short) x; + s = (short) y; + + r = ((r >> 1) - (s >> 1)); + s = (((x >> 17) - (y >> 17)) << 16); + + diff = (s & 0xFFFF0000) | (r & 0x0000FFFF); + + return diff; + } + + /* + * @brief C custom defined QASX for M3 and M0 processors + */ + static __INLINE q31_t __QASX( + q31_t x, + q31_t y) + { + + q31_t sum = 0; + + sum = + ((sum + + clip_q31_to_q15((q31_t) ((short) (x >> 16) + (short) y))) << 16) + + clip_q31_to_q15((q31_t) ((short) x - (short) (y >> 16))); + + return sum; + } + + /* + * @brief C custom defined SHASX for M3 and M0 processors + */ + static __INLINE q31_t __SHASX( + q31_t x, + q31_t y) + { + + q31_t sum; + q31_t r, s; + + r = (short) x; + s = (short) y; + + r = ((r >> 1) - (y >> 17)); + s = (((x >> 17) + (s >> 1)) << 16); + + sum = (s & 0xFFFF0000) | (r & 0x0000FFFF); + + return sum; + } + + + /* + * @brief C custom defined QSAX for M3 and M0 processors + */ + static __INLINE q31_t __QSAX( + q31_t x, + q31_t y) + { + + q31_t sum = 0; + + sum = + ((sum + + clip_q31_to_q15((q31_t) ((short) (x >> 16) - (short) y))) << 16) + + clip_q31_to_q15((q31_t) ((short) x + (short) (y >> 16))); + + return sum; + } + + /* + * @brief C custom defined SHSAX for M3 and M0 processors + */ + static __INLINE q31_t __SHSAX( + q31_t x, + q31_t y) + { + + q31_t sum; + q31_t r, s; + + r = (short) x; + s = (short) y; + + r = ((r >> 1) + (y >> 17)); + s = (((x >> 17) - (s >> 1)) << 16); + + sum = (s & 0xFFFF0000) | (r & 0x0000FFFF); + + return sum; + } + + /* + * @brief C custom defined SMUSDX for M3 and M0 processors + */ + static __INLINE q31_t __SMUSDX( + q31_t x, + q31_t y) + { + + return ((q31_t) (((short) x * (short) (y >> 16)) - + ((short) (x >> 16) * (short) y))); + } + + /* + * @brief C custom defined SMUADX for M3 and M0 processors + */ + static __INLINE q31_t __SMUADX( + q31_t x, + q31_t y) + { + + return ((q31_t) (((short) x * (short) (y >> 16)) + + ((short) (x >> 16) * (short) y))); + } + + /* + * @brief C custom defined QADD for M3 and M0 processors + */ + static __INLINE q31_t __QADD( + q31_t x, + q31_t y) + { + return clip_q63_to_q31((q63_t) x + y); + } + + /* + * @brief C custom defined QSUB for M3 and M0 processors + */ + static __INLINE q31_t __QSUB( + q31_t x, + q31_t y) + { + return clip_q63_to_q31((q63_t) x - y); + } + + /* + * @brief C custom defined SMLAD for M3 and M0 processors + */ + static __INLINE q31_t __SMLAD( + q31_t x, + q31_t y, + q31_t sum) + { + + return (sum + ((short) (x >> 16) * (short) (y >> 16)) + + ((short) x * (short) y)); + } + + /* + * @brief C custom defined SMLADX for M3 and M0 processors + */ + static __INLINE q31_t __SMLADX( + q31_t x, + q31_t y, + q31_t sum) + { + + return (sum + ((short) (x >> 16) * (short) (y)) + + ((short) x * (short) (y >> 16))); + } + + /* + * @brief C custom defined SMLSDX for M3 and M0 processors + */ + static __INLINE q31_t __SMLSDX( + q31_t x, + q31_t y, + q31_t sum) + { + + return (sum - ((short) (x >> 16) * (short) (y)) + + ((short) x * (short) (y >> 16))); + } + + /* + * @brief C custom defined SMLALD for M3 and M0 processors + */ + static __INLINE q63_t __SMLALD( + q31_t x, + q31_t y, + q63_t sum) + { + + return (sum + ((short) (x >> 16) * (short) (y >> 16)) + + ((short) x * (short) y)); + } + + /* + * @brief C custom defined SMLALDX for M3 and M0 processors + */ + static __INLINE q63_t __SMLALDX( + q31_t x, + q31_t y, + q63_t sum) + { + + return (sum + ((short) (x >> 16) * (short) y)) + + ((short) x * (short) (y >> 16)); + } + + /* + * @brief C custom defined SMUAD for M3 and M0 processors + */ + static __INLINE q31_t __SMUAD( + q31_t x, + q31_t y) + { + + return (((x >> 16) * (y >> 16)) + + (((x << 16) >> 16) * ((y << 16) >> 16))); + } + + /* + * @brief C custom defined SMUSD for M3 and M0 processors + */ + static __INLINE q31_t __SMUSD( + q31_t x, + q31_t y) + { + + return (-((x >> 16) * (y >> 16)) + + (((x << 16) >> 16) * ((y << 16) >> 16))); + } + + + /* + * @brief C custom defined SXTB16 for M3 and M0 processors + */ + static __INLINE q31_t __SXTB16( + q31_t x) + { + + return ((((x << 24) >> 24) & 0x0000FFFF) | + (((x << 8) >> 8) & 0xFFFF0000)); + } + + +#endif /* defined (ARM_MATH_CM3) || defined (ARM_MATH_CM0_FAMILY) */ + + + /** + * @brief Instance structure for the Q7 FIR filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of filter coefficients in the filter. */ + q7_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + q7_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + } arm_fir_instance_q7; + + /** + * @brief Instance structure for the Q15 FIR filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of filter coefficients in the filter. */ + q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + } arm_fir_instance_q15; + + /** + * @brief Instance structure for the Q31 FIR filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of filter coefficients in the filter. */ + q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + } arm_fir_instance_q31; + + /** + * @brief Instance structure for the floating-point FIR filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of filter coefficients in the filter. */ + float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + } arm_fir_instance_f32; + + + /** + * @brief Processing function for the Q7 FIR filter. + * @param[in] *S points to an instance of the Q7 FIR filter structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + void arm_fir_q7( + const arm_fir_instance_q7 * S, + q7_t * pSrc, + q7_t * pDst, + uint32_t blockSize); + + + /** + * @brief Initialization function for the Q7 FIR filter. + * @param[in,out] *S points to an instance of the Q7 FIR structure. + * @param[in] numTaps Number of filter coefficients in the filter. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] blockSize number of samples that are processed. + * @return none + */ + void arm_fir_init_q7( + arm_fir_instance_q7 * S, + uint16_t numTaps, + q7_t * pCoeffs, + q7_t * pState, + uint32_t blockSize); + + + /** + * @brief Processing function for the Q15 FIR filter. + * @param[in] *S points to an instance of the Q15 FIR structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + void arm_fir_q15( + const arm_fir_instance_q15 * S, + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Processing function for the fast Q15 FIR filter for Cortex-M3 and Cortex-M4. + * @param[in] *S points to an instance of the Q15 FIR filter structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + void arm_fir_fast_q15( + const arm_fir_instance_q15 * S, + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the Q15 FIR filter. + * @param[in,out] *S points to an instance of the Q15 FIR filter structure. + * @param[in] numTaps Number of filter coefficients in the filter. Must be even and greater than or equal to 4. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] blockSize number of samples that are processed at a time. + * @return The function returns ARM_MATH_SUCCESS if initialization was successful or ARM_MATH_ARGUMENT_ERROR if + * numTaps is not a supported value. + */ + + arm_status arm_fir_init_q15( + arm_fir_instance_q15 * S, + uint16_t numTaps, + q15_t * pCoeffs, + q15_t * pState, + uint32_t blockSize); + + /** + * @brief Processing function for the Q31 FIR filter. + * @param[in] *S points to an instance of the Q31 FIR filter structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + void arm_fir_q31( + const arm_fir_instance_q31 * S, + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Processing function for the fast Q31 FIR filter for Cortex-M3 and Cortex-M4. + * @param[in] *S points to an instance of the Q31 FIR structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + void arm_fir_fast_q31( + const arm_fir_instance_q31 * S, + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the Q31 FIR filter. + * @param[in,out] *S points to an instance of the Q31 FIR structure. + * @param[in] numTaps Number of filter coefficients in the filter. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] blockSize number of samples that are processed at a time. + * @return none. + */ + void arm_fir_init_q31( + arm_fir_instance_q31 * S, + uint16_t numTaps, + q31_t * pCoeffs, + q31_t * pState, + uint32_t blockSize); + + /** + * @brief Processing function for the floating-point FIR filter. + * @param[in] *S points to an instance of the floating-point FIR structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + void arm_fir_f32( + const arm_fir_instance_f32 * S, + float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the floating-point FIR filter. + * @param[in,out] *S points to an instance of the floating-point FIR filter structure. + * @param[in] numTaps Number of filter coefficients in the filter. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] blockSize number of samples that are processed at a time. + * @return none. + */ + void arm_fir_init_f32( + arm_fir_instance_f32 * S, + uint16_t numTaps, + float32_t * pCoeffs, + float32_t * pState, + uint32_t blockSize); + + + /** + * @brief Instance structure for the Q15 Biquad cascade filter. + */ + typedef struct + { + int8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ + q15_t *pState; /**< Points to the array of state coefficients. The array is of length 4*numStages. */ + q15_t *pCoeffs; /**< Points to the array of coefficients. The array is of length 5*numStages. */ + int8_t postShift; /**< Additional shift, in bits, applied to each output sample. */ + + } arm_biquad_casd_df1_inst_q15; + + + /** + * @brief Instance structure for the Q31 Biquad cascade filter. + */ + typedef struct + { + uint32_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ + q31_t *pState; /**< Points to the array of state coefficients. The array is of length 4*numStages. */ + q31_t *pCoeffs; /**< Points to the array of coefficients. The array is of length 5*numStages. */ + uint8_t postShift; /**< Additional shift, in bits, applied to each output sample. */ + + } arm_biquad_casd_df1_inst_q31; + + /** + * @brief Instance structure for the floating-point Biquad cascade filter. + */ + typedef struct + { + uint32_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ + float32_t *pState; /**< Points to the array of state coefficients. The array is of length 4*numStages. */ + float32_t *pCoeffs; /**< Points to the array of coefficients. The array is of length 5*numStages. */ + + + } arm_biquad_casd_df1_inst_f32; + + + + /** + * @brief Processing function for the Q15 Biquad cascade filter. + * @param[in] *S points to an instance of the Q15 Biquad cascade structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_biquad_cascade_df1_q15( + const arm_biquad_casd_df1_inst_q15 * S, + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the Q15 Biquad cascade filter. + * @param[in,out] *S points to an instance of the Q15 Biquad cascade structure. + * @param[in] numStages number of 2nd order stages in the filter. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] postShift Shift to be applied to the output. Varies according to the coefficients format + * @return none + */ + + void arm_biquad_cascade_df1_init_q15( + arm_biquad_casd_df1_inst_q15 * S, + uint8_t numStages, + q15_t * pCoeffs, + q15_t * pState, + int8_t postShift); + + + /** + * @brief Fast but less precise processing function for the Q15 Biquad cascade filter for Cortex-M3 and Cortex-M4. + * @param[in] *S points to an instance of the Q15 Biquad cascade structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_biquad_cascade_df1_fast_q15( + const arm_biquad_casd_df1_inst_q15 * S, + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + + /** + * @brief Processing function for the Q31 Biquad cascade filter + * @param[in] *S points to an instance of the Q31 Biquad cascade structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_biquad_cascade_df1_q31( + const arm_biquad_casd_df1_inst_q31 * S, + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Fast but less precise processing function for the Q31 Biquad cascade filter for Cortex-M3 and Cortex-M4. + * @param[in] *S points to an instance of the Q31 Biquad cascade structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_biquad_cascade_df1_fast_q31( + const arm_biquad_casd_df1_inst_q31 * S, + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the Q31 Biquad cascade filter. + * @param[in,out] *S points to an instance of the Q31 Biquad cascade structure. + * @param[in] numStages number of 2nd order stages in the filter. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] postShift Shift to be applied to the output. Varies according to the coefficients format + * @return none + */ + + void arm_biquad_cascade_df1_init_q31( + arm_biquad_casd_df1_inst_q31 * S, + uint8_t numStages, + q31_t * pCoeffs, + q31_t * pState, + int8_t postShift); + + /** + * @brief Processing function for the floating-point Biquad cascade filter. + * @param[in] *S points to an instance of the floating-point Biquad cascade structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_biquad_cascade_df1_f32( + const arm_biquad_casd_df1_inst_f32 * S, + float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the floating-point Biquad cascade filter. + * @param[in,out] *S points to an instance of the floating-point Biquad cascade structure. + * @param[in] numStages number of 2nd order stages in the filter. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @return none + */ + + void arm_biquad_cascade_df1_init_f32( + arm_biquad_casd_df1_inst_f32 * S, + uint8_t numStages, + float32_t * pCoeffs, + float32_t * pState); + + + /** + * @brief Instance structure for the floating-point matrix structure. + */ + + typedef struct + { + uint16_t numRows; /**< number of rows of the matrix. */ + uint16_t numCols; /**< number of columns of the matrix. */ + float32_t *pData; /**< points to the data of the matrix. */ + } arm_matrix_instance_f32; + + /** + * @brief Instance structure for the Q15 matrix structure. + */ + + typedef struct + { + uint16_t numRows; /**< number of rows of the matrix. */ + uint16_t numCols; /**< number of columns of the matrix. */ + q15_t *pData; /**< points to the data of the matrix. */ + + } arm_matrix_instance_q15; + + /** + * @brief Instance structure for the Q31 matrix structure. + */ + + typedef struct + { + uint16_t numRows; /**< number of rows of the matrix. */ + uint16_t numCols; /**< number of columns of the matrix. */ + q31_t *pData; /**< points to the data of the matrix. */ + + } arm_matrix_instance_q31; + + + + /** + * @brief Floating-point matrix addition. + * @param[in] *pSrcA points to the first input matrix structure + * @param[in] *pSrcB points to the second input matrix structure + * @param[out] *pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_add_f32( + const arm_matrix_instance_f32 * pSrcA, + const arm_matrix_instance_f32 * pSrcB, + arm_matrix_instance_f32 * pDst); + + /** + * @brief Q15 matrix addition. + * @param[in] *pSrcA points to the first input matrix structure + * @param[in] *pSrcB points to the second input matrix structure + * @param[out] *pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_add_q15( + const arm_matrix_instance_q15 * pSrcA, + const arm_matrix_instance_q15 * pSrcB, + arm_matrix_instance_q15 * pDst); + + /** + * @brief Q31 matrix addition. + * @param[in] *pSrcA points to the first input matrix structure + * @param[in] *pSrcB points to the second input matrix structure + * @param[out] *pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_add_q31( + const arm_matrix_instance_q31 * pSrcA, + const arm_matrix_instance_q31 * pSrcB, + arm_matrix_instance_q31 * pDst); + + + /** + * @brief Floating-point matrix transpose. + * @param[in] *pSrc points to the input matrix + * @param[out] *pDst points to the output matrix + * @return The function returns either ARM_MATH_SIZE_MISMATCH + * or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_trans_f32( + const arm_matrix_instance_f32 * pSrc, + arm_matrix_instance_f32 * pDst); + + + /** + * @brief Q15 matrix transpose. + * @param[in] *pSrc points to the input matrix + * @param[out] *pDst points to the output matrix + * @return The function returns either ARM_MATH_SIZE_MISMATCH + * or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_trans_q15( + const arm_matrix_instance_q15 * pSrc, + arm_matrix_instance_q15 * pDst); + + /** + * @brief Q31 matrix transpose. + * @param[in] *pSrc points to the input matrix + * @param[out] *pDst points to the output matrix + * @return The function returns either ARM_MATH_SIZE_MISMATCH + * or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_trans_q31( + const arm_matrix_instance_q31 * pSrc, + arm_matrix_instance_q31 * pDst); + + + /** + * @brief Floating-point matrix multiplication + * @param[in] *pSrcA points to the first input matrix structure + * @param[in] *pSrcB points to the second input matrix structure + * @param[out] *pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_mult_f32( + const arm_matrix_instance_f32 * pSrcA, + const arm_matrix_instance_f32 * pSrcB, + arm_matrix_instance_f32 * pDst); + + /** + * @brief Q15 matrix multiplication + * @param[in] *pSrcA points to the first input matrix structure + * @param[in] *pSrcB points to the second input matrix structure + * @param[out] *pDst points to output matrix structure + * @param[in] *pState points to the array for storing intermediate results + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_mult_q15( + const arm_matrix_instance_q15 * pSrcA, + const arm_matrix_instance_q15 * pSrcB, + arm_matrix_instance_q15 * pDst, + q15_t * pState); + + /** + * @brief Q15 matrix multiplication (fast variant) for Cortex-M3 and Cortex-M4 + * @param[in] *pSrcA points to the first input matrix structure + * @param[in] *pSrcB points to the second input matrix structure + * @param[out] *pDst points to output matrix structure + * @param[in] *pState points to the array for storing intermediate results + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_mult_fast_q15( + const arm_matrix_instance_q15 * pSrcA, + const arm_matrix_instance_q15 * pSrcB, + arm_matrix_instance_q15 * pDst, + q15_t * pState); + + /** + * @brief Q31 matrix multiplication + * @param[in] *pSrcA points to the first input matrix structure + * @param[in] *pSrcB points to the second input matrix structure + * @param[out] *pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_mult_q31( + const arm_matrix_instance_q31 * pSrcA, + const arm_matrix_instance_q31 * pSrcB, + arm_matrix_instance_q31 * pDst); + + /** + * @brief Q31 matrix multiplication (fast variant) for Cortex-M3 and Cortex-M4 + * @param[in] *pSrcA points to the first input matrix structure + * @param[in] *pSrcB points to the second input matrix structure + * @param[out] *pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_mult_fast_q31( + const arm_matrix_instance_q31 * pSrcA, + const arm_matrix_instance_q31 * pSrcB, + arm_matrix_instance_q31 * pDst); + + + /** + * @brief Floating-point matrix subtraction + * @param[in] *pSrcA points to the first input matrix structure + * @param[in] *pSrcB points to the second input matrix structure + * @param[out] *pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_sub_f32( + const arm_matrix_instance_f32 * pSrcA, + const arm_matrix_instance_f32 * pSrcB, + arm_matrix_instance_f32 * pDst); + + /** + * @brief Q15 matrix subtraction + * @param[in] *pSrcA points to the first input matrix structure + * @param[in] *pSrcB points to the second input matrix structure + * @param[out] *pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_sub_q15( + const arm_matrix_instance_q15 * pSrcA, + const arm_matrix_instance_q15 * pSrcB, + arm_matrix_instance_q15 * pDst); + + /** + * @brief Q31 matrix subtraction + * @param[in] *pSrcA points to the first input matrix structure + * @param[in] *pSrcB points to the second input matrix structure + * @param[out] *pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_sub_q31( + const arm_matrix_instance_q31 * pSrcA, + const arm_matrix_instance_q31 * pSrcB, + arm_matrix_instance_q31 * pDst); + + /** + * @brief Floating-point matrix scaling. + * @param[in] *pSrc points to the input matrix + * @param[in] scale scale factor + * @param[out] *pDst points to the output matrix + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_scale_f32( + const arm_matrix_instance_f32 * pSrc, + float32_t scale, + arm_matrix_instance_f32 * pDst); + + /** + * @brief Q15 matrix scaling. + * @param[in] *pSrc points to input matrix + * @param[in] scaleFract fractional portion of the scale factor + * @param[in] shift number of bits to shift the result by + * @param[out] *pDst points to output matrix + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_scale_q15( + const arm_matrix_instance_q15 * pSrc, + q15_t scaleFract, + int32_t shift, + arm_matrix_instance_q15 * pDst); + + /** + * @brief Q31 matrix scaling. + * @param[in] *pSrc points to input matrix + * @param[in] scaleFract fractional portion of the scale factor + * @param[in] shift number of bits to shift the result by + * @param[out] *pDst points to output matrix structure + * @return The function returns either + * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking. + */ + + arm_status arm_mat_scale_q31( + const arm_matrix_instance_q31 * pSrc, + q31_t scaleFract, + int32_t shift, + arm_matrix_instance_q31 * pDst); + + + /** + * @brief Q31 matrix initialization. + * @param[in,out] *S points to an instance of the floating-point matrix structure. + * @param[in] nRows number of rows in the matrix. + * @param[in] nColumns number of columns in the matrix. + * @param[in] *pData points to the matrix data array. + * @return none + */ + + void arm_mat_init_q31( + arm_matrix_instance_q31 * S, + uint16_t nRows, + uint16_t nColumns, + q31_t * pData); + + /** + * @brief Q15 matrix initialization. + * @param[in,out] *S points to an instance of the floating-point matrix structure. + * @param[in] nRows number of rows in the matrix. + * @param[in] nColumns number of columns in the matrix. + * @param[in] *pData points to the matrix data array. + * @return none + */ + + void arm_mat_init_q15( + arm_matrix_instance_q15 * S, + uint16_t nRows, + uint16_t nColumns, + q15_t * pData); + + /** + * @brief Floating-point matrix initialization. + * @param[in,out] *S points to an instance of the floating-point matrix structure. + * @param[in] nRows number of rows in the matrix. + * @param[in] nColumns number of columns in the matrix. + * @param[in] *pData points to the matrix data array. + * @return none + */ + + void arm_mat_init_f32( + arm_matrix_instance_f32 * S, + uint16_t nRows, + uint16_t nColumns, + float32_t * pData); + + + + /** + * @brief Instance structure for the Q15 PID Control. + */ + typedef struct + { + q15_t A0; /**< The derived gain, A0 = Kp + Ki + Kd . */ +#ifdef ARM_MATH_CM0_FAMILY + q15_t A1; + q15_t A2; +#else + q31_t A1; /**< The derived gain A1 = -Kp - 2Kd | Kd.*/ +#endif + q15_t state[3]; /**< The state array of length 3. */ + q15_t Kp; /**< The proportional gain. */ + q15_t Ki; /**< The integral gain. */ + q15_t Kd; /**< The derivative gain. */ + } arm_pid_instance_q15; + + /** + * @brief Instance structure for the Q31 PID Control. + */ + typedef struct + { + q31_t A0; /**< The derived gain, A0 = Kp + Ki + Kd . */ + q31_t A1; /**< The derived gain, A1 = -Kp - 2Kd. */ + q31_t A2; /**< The derived gain, A2 = Kd . */ + q31_t state[3]; /**< The state array of length 3. */ + q31_t Kp; /**< The proportional gain. */ + q31_t Ki; /**< The integral gain. */ + q31_t Kd; /**< The derivative gain. */ + + } arm_pid_instance_q31; + + /** + * @brief Instance structure for the floating-point PID Control. + */ + typedef struct + { + float32_t A0; /**< The derived gain, A0 = Kp + Ki + Kd . */ + float32_t A1; /**< The derived gain, A1 = -Kp - 2Kd. */ + float32_t A2; /**< The derived gain, A2 = Kd . */ + float32_t state[3]; /**< The state array of length 3. */ + float32_t Kp; /**< The proportional gain. */ + float32_t Ki; /**< The integral gain. */ + float32_t Kd; /**< The derivative gain. */ + } arm_pid_instance_f32; + + + + /** + * @brief Initialization function for the floating-point PID Control. + * @param[in,out] *S points to an instance of the PID structure. + * @param[in] resetStateFlag flag to reset the state. 0 = no change in state 1 = reset the state. + * @return none. + */ + void arm_pid_init_f32( + arm_pid_instance_f32 * S, + int32_t resetStateFlag); + + /** + * @brief Reset function for the floating-point PID Control. + * @param[in,out] *S is an instance of the floating-point PID Control structure + * @return none + */ + void arm_pid_reset_f32( + arm_pid_instance_f32 * S); + + + /** + * @brief Initialization function for the Q31 PID Control. + * @param[in,out] *S points to an instance of the Q15 PID structure. + * @param[in] resetStateFlag flag to reset the state. 0 = no change in state 1 = reset the state. + * @return none. + */ + void arm_pid_init_q31( + arm_pid_instance_q31 * S, + int32_t resetStateFlag); + + + /** + * @brief Reset function for the Q31 PID Control. + * @param[in,out] *S points to an instance of the Q31 PID Control structure + * @return none + */ + + void arm_pid_reset_q31( + arm_pid_instance_q31 * S); + + /** + * @brief Initialization function for the Q15 PID Control. + * @param[in,out] *S points to an instance of the Q15 PID structure. + * @param[in] resetStateFlag flag to reset the state. 0 = no change in state 1 = reset the state. + * @return none. + */ + void arm_pid_init_q15( + arm_pid_instance_q15 * S, + int32_t resetStateFlag); + + /** + * @brief Reset function for the Q15 PID Control. + * @param[in,out] *S points to an instance of the q15 PID Control structure + * @return none + */ + void arm_pid_reset_q15( + arm_pid_instance_q15 * S); + + + /** + * @brief Instance structure for the floating-point Linear Interpolate function. + */ + typedef struct + { + uint32_t nValues; /**< nValues */ + float32_t x1; /**< x1 */ + float32_t xSpacing; /**< xSpacing */ + float32_t *pYData; /**< pointer to the table of Y values */ + } arm_linear_interp_instance_f32; + + /** + * @brief Instance structure for the floating-point bilinear interpolation function. + */ + + typedef struct + { + uint16_t numRows; /**< number of rows in the data table. */ + uint16_t numCols; /**< number of columns in the data table. */ + float32_t *pData; /**< points to the data table. */ + } arm_bilinear_interp_instance_f32; + + /** + * @brief Instance structure for the Q31 bilinear interpolation function. + */ + + typedef struct + { + uint16_t numRows; /**< number of rows in the data table. */ + uint16_t numCols; /**< number of columns in the data table. */ + q31_t *pData; /**< points to the data table. */ + } arm_bilinear_interp_instance_q31; + + /** + * @brief Instance structure for the Q15 bilinear interpolation function. + */ + + typedef struct + { + uint16_t numRows; /**< number of rows in the data table. */ + uint16_t numCols; /**< number of columns in the data table. */ + q15_t *pData; /**< points to the data table. */ + } arm_bilinear_interp_instance_q15; + + /** + * @brief Instance structure for the Q15 bilinear interpolation function. + */ + + typedef struct + { + uint16_t numRows; /**< number of rows in the data table. */ + uint16_t numCols; /**< number of columns in the data table. */ + q7_t *pData; /**< points to the data table. */ + } arm_bilinear_interp_instance_q7; + + + /** + * @brief Q7 vector multiplication. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_mult_q7( + q7_t * pSrcA, + q7_t * pSrcB, + q7_t * pDst, + uint32_t blockSize); + + /** + * @brief Q15 vector multiplication. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_mult_q15( + q15_t * pSrcA, + q15_t * pSrcB, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Q31 vector multiplication. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_mult_q31( + q31_t * pSrcA, + q31_t * pSrcB, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Floating-point vector multiplication. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_mult_f32( + float32_t * pSrcA, + float32_t * pSrcB, + float32_t * pDst, + uint32_t blockSize); + + + + + + + /** + * @brief Instance structure for the Q15 CFFT/CIFFT function. + */ + + typedef struct + { + uint16_t fftLen; /**< length of the FFT. */ + uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ + uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ + q15_t *pTwiddle; /**< points to the Sin twiddle factor table. */ + uint16_t *pBitRevTable; /**< points to the bit reversal table. */ + uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ + } arm_cfft_radix2_instance_q15; + + arm_status arm_cfft_radix2_init_q15( + arm_cfft_radix2_instance_q15 * S, + uint16_t fftLen, + uint8_t ifftFlag, + uint8_t bitReverseFlag); + + void arm_cfft_radix2_q15( + const arm_cfft_radix2_instance_q15 * S, + q15_t * pSrc); + + + + /** + * @brief Instance structure for the Q15 CFFT/CIFFT function. + */ + + typedef struct + { + uint16_t fftLen; /**< length of the FFT. */ + uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ + uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ + q15_t *pTwiddle; /**< points to the twiddle factor table. */ + uint16_t *pBitRevTable; /**< points to the bit reversal table. */ + uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ + } arm_cfft_radix4_instance_q15; + + arm_status arm_cfft_radix4_init_q15( + arm_cfft_radix4_instance_q15 * S, + uint16_t fftLen, + uint8_t ifftFlag, + uint8_t bitReverseFlag); + + void arm_cfft_radix4_q15( + const arm_cfft_radix4_instance_q15 * S, + q15_t * pSrc); + + /** + * @brief Instance structure for the Radix-2 Q31 CFFT/CIFFT function. + */ + + typedef struct + { + uint16_t fftLen; /**< length of the FFT. */ + uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ + uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ + q31_t *pTwiddle; /**< points to the Twiddle factor table. */ + uint16_t *pBitRevTable; /**< points to the bit reversal table. */ + uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ + } arm_cfft_radix2_instance_q31; + + arm_status arm_cfft_radix2_init_q31( + arm_cfft_radix2_instance_q31 * S, + uint16_t fftLen, + uint8_t ifftFlag, + uint8_t bitReverseFlag); + + void arm_cfft_radix2_q31( + const arm_cfft_radix2_instance_q31 * S, + q31_t * pSrc); + + /** + * @brief Instance structure for the Q31 CFFT/CIFFT function. + */ + + typedef struct + { + uint16_t fftLen; /**< length of the FFT. */ + uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ + uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ + q31_t *pTwiddle; /**< points to the twiddle factor table. */ + uint16_t *pBitRevTable; /**< points to the bit reversal table. */ + uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ + } arm_cfft_radix4_instance_q31; + + + void arm_cfft_radix4_q31( + const arm_cfft_radix4_instance_q31 * S, + q31_t * pSrc); + + arm_status arm_cfft_radix4_init_q31( + arm_cfft_radix4_instance_q31 * S, + uint16_t fftLen, + uint8_t ifftFlag, + uint8_t bitReverseFlag); + + /** + * @brief Instance structure for the floating-point CFFT/CIFFT function. + */ + + typedef struct + { + uint16_t fftLen; /**< length of the FFT. */ + uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ + uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ + float32_t *pTwiddle; /**< points to the Twiddle factor table. */ + uint16_t *pBitRevTable; /**< points to the bit reversal table. */ + uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ + float32_t onebyfftLen; /**< value of 1/fftLen. */ + } arm_cfft_radix2_instance_f32; + +/* Deprecated */ + arm_status arm_cfft_radix2_init_f32( + arm_cfft_radix2_instance_f32 * S, + uint16_t fftLen, + uint8_t ifftFlag, + uint8_t bitReverseFlag); + +/* Deprecated */ + void arm_cfft_radix2_f32( + const arm_cfft_radix2_instance_f32 * S, + float32_t * pSrc); + + /** + * @brief Instance structure for the floating-point CFFT/CIFFT function. + */ + + typedef struct + { + uint16_t fftLen; /**< length of the FFT. */ + uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ + uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ + float32_t *pTwiddle; /**< points to the Twiddle factor table. */ + uint16_t *pBitRevTable; /**< points to the bit reversal table. */ + uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ + float32_t onebyfftLen; /**< value of 1/fftLen. */ + } arm_cfft_radix4_instance_f32; + +/* Deprecated */ + arm_status arm_cfft_radix4_init_f32( + arm_cfft_radix4_instance_f32 * S, + uint16_t fftLen, + uint8_t ifftFlag, + uint8_t bitReverseFlag); + +/* Deprecated */ + void arm_cfft_radix4_f32( + const arm_cfft_radix4_instance_f32 * S, + float32_t * pSrc); + + /** + * @brief Instance structure for the floating-point CFFT/CIFFT function. + */ + + typedef struct + { + uint16_t fftLen; /**< length of the FFT. */ + const float32_t *pTwiddle; /**< points to the Twiddle factor table. */ + const uint16_t *pBitRevTable; /**< points to the bit reversal table. */ + uint16_t bitRevLength; /**< bit reversal table length. */ + } arm_cfft_instance_f32; + + void arm_cfft_f32( + const arm_cfft_instance_f32 * S, + float32_t * p1, + uint8_t ifftFlag, + uint8_t bitReverseFlag); + + /** + * @brief Instance structure for the Q15 RFFT/RIFFT function. + */ + + typedef struct + { + uint32_t fftLenReal; /**< length of the real FFT. */ + uint32_t fftLenBy2; /**< length of the complex FFT. */ + uint8_t ifftFlagR; /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */ + uint8_t bitReverseFlagR; /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */ + uint32_t twidCoefRModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + q15_t *pTwiddleAReal; /**< points to the real twiddle factor table. */ + q15_t *pTwiddleBReal; /**< points to the imag twiddle factor table. */ + arm_cfft_radix4_instance_q15 *pCfft; /**< points to the complex FFT instance. */ + } arm_rfft_instance_q15; + + arm_status arm_rfft_init_q15( + arm_rfft_instance_q15 * S, + arm_cfft_radix4_instance_q15 * S_CFFT, + uint32_t fftLenReal, + uint32_t ifftFlagR, + uint32_t bitReverseFlag); + + void arm_rfft_q15( + const arm_rfft_instance_q15 * S, + q15_t * pSrc, + q15_t * pDst); + + /** + * @brief Instance structure for the Q31 RFFT/RIFFT function. + */ + + typedef struct + { + uint32_t fftLenReal; /**< length of the real FFT. */ + uint32_t fftLenBy2; /**< length of the complex FFT. */ + uint8_t ifftFlagR; /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */ + uint8_t bitReverseFlagR; /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */ + uint32_t twidCoefRModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + q31_t *pTwiddleAReal; /**< points to the real twiddle factor table. */ + q31_t *pTwiddleBReal; /**< points to the imag twiddle factor table. */ + arm_cfft_radix4_instance_q31 *pCfft; /**< points to the complex FFT instance. */ + } arm_rfft_instance_q31; + + arm_status arm_rfft_init_q31( + arm_rfft_instance_q31 * S, + arm_cfft_radix4_instance_q31 * S_CFFT, + uint32_t fftLenReal, + uint32_t ifftFlagR, + uint32_t bitReverseFlag); + + void arm_rfft_q31( + const arm_rfft_instance_q31 * S, + q31_t * pSrc, + q31_t * pDst); + + /** + * @brief Instance structure for the floating-point RFFT/RIFFT function. + */ + + typedef struct + { + uint32_t fftLenReal; /**< length of the real FFT. */ + uint16_t fftLenBy2; /**< length of the complex FFT. */ + uint8_t ifftFlagR; /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */ + uint8_t bitReverseFlagR; /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */ + uint32_t twidCoefRModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ + float32_t *pTwiddleAReal; /**< points to the real twiddle factor table. */ + float32_t *pTwiddleBReal; /**< points to the imag twiddle factor table. */ + arm_cfft_radix4_instance_f32 *pCfft; /**< points to the complex FFT instance. */ + } arm_rfft_instance_f32; + + arm_status arm_rfft_init_f32( + arm_rfft_instance_f32 * S, + arm_cfft_radix4_instance_f32 * S_CFFT, + uint32_t fftLenReal, + uint32_t ifftFlagR, + uint32_t bitReverseFlag); + + void arm_rfft_f32( + const arm_rfft_instance_f32 * S, + float32_t * pSrc, + float32_t * pDst); + + /** + * @brief Instance structure for the floating-point RFFT/RIFFT function. + */ + +typedef struct + { + arm_cfft_instance_f32 Sint; /**< Internal CFFT structure. */ + uint16_t fftLenRFFT; /**< length of the real sequence */ + float32_t * pTwiddleRFFT; /**< Twiddle factors real stage */ + } arm_rfft_fast_instance_f32 ; + +arm_status arm_rfft_fast_init_f32 ( + arm_rfft_fast_instance_f32 * S, + uint16_t fftLen); + +void arm_rfft_fast_f32( + arm_rfft_fast_instance_f32 * S, + float32_t * p, float32_t * pOut, + uint8_t ifftFlag); + + /** + * @brief Instance structure for the floating-point DCT4/IDCT4 function. + */ + + typedef struct + { + uint16_t N; /**< length of the DCT4. */ + uint16_t Nby2; /**< half of the length of the DCT4. */ + float32_t normalize; /**< normalizing factor. */ + float32_t *pTwiddle; /**< points to the twiddle factor table. */ + float32_t *pCosFactor; /**< points to the cosFactor table. */ + arm_rfft_instance_f32 *pRfft; /**< points to the real FFT instance. */ + arm_cfft_radix4_instance_f32 *pCfft; /**< points to the complex FFT instance. */ + } arm_dct4_instance_f32; + + /** + * @brief Initialization function for the floating-point DCT4/IDCT4. + * @param[in,out] *S points to an instance of floating-point DCT4/IDCT4 structure. + * @param[in] *S_RFFT points to an instance of floating-point RFFT/RIFFT structure. + * @param[in] *S_CFFT points to an instance of floating-point CFFT/CIFFT structure. + * @param[in] N length of the DCT4. + * @param[in] Nby2 half of the length of the DCT4. + * @param[in] normalize normalizing factor. + * @return arm_status function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_ARGUMENT_ERROR if fftLenReal is not a supported transform length. + */ + + arm_status arm_dct4_init_f32( + arm_dct4_instance_f32 * S, + arm_rfft_instance_f32 * S_RFFT, + arm_cfft_radix4_instance_f32 * S_CFFT, + uint16_t N, + uint16_t Nby2, + float32_t normalize); + + /** + * @brief Processing function for the floating-point DCT4/IDCT4. + * @param[in] *S points to an instance of the floating-point DCT4/IDCT4 structure. + * @param[in] *pState points to state buffer. + * @param[in,out] *pInlineBuffer points to the in-place input and output buffer. + * @return none. + */ + + void arm_dct4_f32( + const arm_dct4_instance_f32 * S, + float32_t * pState, + float32_t * pInlineBuffer); + + /** + * @brief Instance structure for the Q31 DCT4/IDCT4 function. + */ + + typedef struct + { + uint16_t N; /**< length of the DCT4. */ + uint16_t Nby2; /**< half of the length of the DCT4. */ + q31_t normalize; /**< normalizing factor. */ + q31_t *pTwiddle; /**< points to the twiddle factor table. */ + q31_t *pCosFactor; /**< points to the cosFactor table. */ + arm_rfft_instance_q31 *pRfft; /**< points to the real FFT instance. */ + arm_cfft_radix4_instance_q31 *pCfft; /**< points to the complex FFT instance. */ + } arm_dct4_instance_q31; + + /** + * @brief Initialization function for the Q31 DCT4/IDCT4. + * @param[in,out] *S points to an instance of Q31 DCT4/IDCT4 structure. + * @param[in] *S_RFFT points to an instance of Q31 RFFT/RIFFT structure + * @param[in] *S_CFFT points to an instance of Q31 CFFT/CIFFT structure + * @param[in] N length of the DCT4. + * @param[in] Nby2 half of the length of the DCT4. + * @param[in] normalize normalizing factor. + * @return arm_status function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_ARGUMENT_ERROR if N is not a supported transform length. + */ + + arm_status arm_dct4_init_q31( + arm_dct4_instance_q31 * S, + arm_rfft_instance_q31 * S_RFFT, + arm_cfft_radix4_instance_q31 * S_CFFT, + uint16_t N, + uint16_t Nby2, + q31_t normalize); + + /** + * @brief Processing function for the Q31 DCT4/IDCT4. + * @param[in] *S points to an instance of the Q31 DCT4 structure. + * @param[in] *pState points to state buffer. + * @param[in,out] *pInlineBuffer points to the in-place input and output buffer. + * @return none. + */ + + void arm_dct4_q31( + const arm_dct4_instance_q31 * S, + q31_t * pState, + q31_t * pInlineBuffer); + + /** + * @brief Instance structure for the Q15 DCT4/IDCT4 function. + */ + + typedef struct + { + uint16_t N; /**< length of the DCT4. */ + uint16_t Nby2; /**< half of the length of the DCT4. */ + q15_t normalize; /**< normalizing factor. */ + q15_t *pTwiddle; /**< points to the twiddle factor table. */ + q15_t *pCosFactor; /**< points to the cosFactor table. */ + arm_rfft_instance_q15 *pRfft; /**< points to the real FFT instance. */ + arm_cfft_radix4_instance_q15 *pCfft; /**< points to the complex FFT instance. */ + } arm_dct4_instance_q15; + + /** + * @brief Initialization function for the Q15 DCT4/IDCT4. + * @param[in,out] *S points to an instance of Q15 DCT4/IDCT4 structure. + * @param[in] *S_RFFT points to an instance of Q15 RFFT/RIFFT structure. + * @param[in] *S_CFFT points to an instance of Q15 CFFT/CIFFT structure. + * @param[in] N length of the DCT4. + * @param[in] Nby2 half of the length of the DCT4. + * @param[in] normalize normalizing factor. + * @return arm_status function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_ARGUMENT_ERROR if N is not a supported transform length. + */ + + arm_status arm_dct4_init_q15( + arm_dct4_instance_q15 * S, + arm_rfft_instance_q15 * S_RFFT, + arm_cfft_radix4_instance_q15 * S_CFFT, + uint16_t N, + uint16_t Nby2, + q15_t normalize); + + /** + * @brief Processing function for the Q15 DCT4/IDCT4. + * @param[in] *S points to an instance of the Q15 DCT4 structure. + * @param[in] *pState points to state buffer. + * @param[in,out] *pInlineBuffer points to the in-place input and output buffer. + * @return none. + */ + + void arm_dct4_q15( + const arm_dct4_instance_q15 * S, + q15_t * pState, + q15_t * pInlineBuffer); + + /** + * @brief Floating-point vector addition. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_add_f32( + float32_t * pSrcA, + float32_t * pSrcB, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Q7 vector addition. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_add_q7( + q7_t * pSrcA, + q7_t * pSrcB, + q7_t * pDst, + uint32_t blockSize); + + /** + * @brief Q15 vector addition. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_add_q15( + q15_t * pSrcA, + q15_t * pSrcB, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Q31 vector addition. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_add_q31( + q31_t * pSrcA, + q31_t * pSrcB, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Floating-point vector subtraction. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_sub_f32( + float32_t * pSrcA, + float32_t * pSrcB, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Q7 vector subtraction. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_sub_q7( + q7_t * pSrcA, + q7_t * pSrcB, + q7_t * pDst, + uint32_t blockSize); + + /** + * @brief Q15 vector subtraction. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_sub_q15( + q15_t * pSrcA, + q15_t * pSrcB, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Q31 vector subtraction. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_sub_q31( + q31_t * pSrcA, + q31_t * pSrcB, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Multiplies a floating-point vector by a scalar. + * @param[in] *pSrc points to the input vector + * @param[in] scale scale factor to be applied + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_scale_f32( + float32_t * pSrc, + float32_t scale, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Multiplies a Q7 vector by a scalar. + * @param[in] *pSrc points to the input vector + * @param[in] scaleFract fractional portion of the scale value + * @param[in] shift number of bits to shift the result by + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_scale_q7( + q7_t * pSrc, + q7_t scaleFract, + int8_t shift, + q7_t * pDst, + uint32_t blockSize); + + /** + * @brief Multiplies a Q15 vector by a scalar. + * @param[in] *pSrc points to the input vector + * @param[in] scaleFract fractional portion of the scale value + * @param[in] shift number of bits to shift the result by + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_scale_q15( + q15_t * pSrc, + q15_t scaleFract, + int8_t shift, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Multiplies a Q31 vector by a scalar. + * @param[in] *pSrc points to the input vector + * @param[in] scaleFract fractional portion of the scale value + * @param[in] shift number of bits to shift the result by + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_scale_q31( + q31_t * pSrc, + q31_t scaleFract, + int8_t shift, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Q7 vector absolute value. + * @param[in] *pSrc points to the input buffer + * @param[out] *pDst points to the output buffer + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_abs_q7( + q7_t * pSrc, + q7_t * pDst, + uint32_t blockSize); + + /** + * @brief Floating-point vector absolute value. + * @param[in] *pSrc points to the input buffer + * @param[out] *pDst points to the output buffer + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_abs_f32( + float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Q15 vector absolute value. + * @param[in] *pSrc points to the input buffer + * @param[out] *pDst points to the output buffer + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_abs_q15( + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Q31 vector absolute value. + * @param[in] *pSrc points to the input buffer + * @param[out] *pDst points to the output buffer + * @param[in] blockSize number of samples in each vector + * @return none. + */ + + void arm_abs_q31( + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Dot product of floating-point vectors. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[in] blockSize number of samples in each vector + * @param[out] *result output result returned here + * @return none. + */ + + void arm_dot_prod_f32( + float32_t * pSrcA, + float32_t * pSrcB, + uint32_t blockSize, + float32_t * result); + + /** + * @brief Dot product of Q7 vectors. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[in] blockSize number of samples in each vector + * @param[out] *result output result returned here + * @return none. + */ + + void arm_dot_prod_q7( + q7_t * pSrcA, + q7_t * pSrcB, + uint32_t blockSize, + q31_t * result); + + /** + * @brief Dot product of Q15 vectors. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[in] blockSize number of samples in each vector + * @param[out] *result output result returned here + * @return none. + */ + + void arm_dot_prod_q15( + q15_t * pSrcA, + q15_t * pSrcB, + uint32_t blockSize, + q63_t * result); + + /** + * @brief Dot product of Q31 vectors. + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[in] blockSize number of samples in each vector + * @param[out] *result output result returned here + * @return none. + */ + + void arm_dot_prod_q31( + q31_t * pSrcA, + q31_t * pSrcB, + uint32_t blockSize, + q63_t * result); + + /** + * @brief Shifts the elements of a Q7 vector a specified number of bits. + * @param[in] *pSrc points to the input vector + * @param[in] shiftBits number of bits to shift. A positive value shifts left; a negative value shifts right. + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_shift_q7( + q7_t * pSrc, + int8_t shiftBits, + q7_t * pDst, + uint32_t blockSize); + + /** + * @brief Shifts the elements of a Q15 vector a specified number of bits. + * @param[in] *pSrc points to the input vector + * @param[in] shiftBits number of bits to shift. A positive value shifts left; a negative value shifts right. + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_shift_q15( + q15_t * pSrc, + int8_t shiftBits, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Shifts the elements of a Q31 vector a specified number of bits. + * @param[in] *pSrc points to the input vector + * @param[in] shiftBits number of bits to shift. A positive value shifts left; a negative value shifts right. + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_shift_q31( + q31_t * pSrc, + int8_t shiftBits, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Adds a constant offset to a floating-point vector. + * @param[in] *pSrc points to the input vector + * @param[in] offset is the offset to be added + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_offset_f32( + float32_t * pSrc, + float32_t offset, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Adds a constant offset to a Q7 vector. + * @param[in] *pSrc points to the input vector + * @param[in] offset is the offset to be added + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_offset_q7( + q7_t * pSrc, + q7_t offset, + q7_t * pDst, + uint32_t blockSize); + + /** + * @brief Adds a constant offset to a Q15 vector. + * @param[in] *pSrc points to the input vector + * @param[in] offset is the offset to be added + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_offset_q15( + q15_t * pSrc, + q15_t offset, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Adds a constant offset to a Q31 vector. + * @param[in] *pSrc points to the input vector + * @param[in] offset is the offset to be added + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_offset_q31( + q31_t * pSrc, + q31_t offset, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Negates the elements of a floating-point vector. + * @param[in] *pSrc points to the input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_negate_f32( + float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Negates the elements of a Q7 vector. + * @param[in] *pSrc points to the input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_negate_q7( + q7_t * pSrc, + q7_t * pDst, + uint32_t blockSize); + + /** + * @brief Negates the elements of a Q15 vector. + * @param[in] *pSrc points to the input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_negate_q15( + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Negates the elements of a Q31 vector. + * @param[in] *pSrc points to the input vector + * @param[out] *pDst points to the output vector + * @param[in] blockSize number of samples in the vector + * @return none. + */ + + void arm_negate_q31( + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + /** + * @brief Copies the elements of a floating-point vector. + * @param[in] *pSrc input pointer + * @param[out] *pDst output pointer + * @param[in] blockSize number of samples to process + * @return none. + */ + void arm_copy_f32( + float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Copies the elements of a Q7 vector. + * @param[in] *pSrc input pointer + * @param[out] *pDst output pointer + * @param[in] blockSize number of samples to process + * @return none. + */ + void arm_copy_q7( + q7_t * pSrc, + q7_t * pDst, + uint32_t blockSize); + + /** + * @brief Copies the elements of a Q15 vector. + * @param[in] *pSrc input pointer + * @param[out] *pDst output pointer + * @param[in] blockSize number of samples to process + * @return none. + */ + void arm_copy_q15( + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Copies the elements of a Q31 vector. + * @param[in] *pSrc input pointer + * @param[out] *pDst output pointer + * @param[in] blockSize number of samples to process + * @return none. + */ + void arm_copy_q31( + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + /** + * @brief Fills a constant value into a floating-point vector. + * @param[in] value input value to be filled + * @param[out] *pDst output pointer + * @param[in] blockSize number of samples to process + * @return none. + */ + void arm_fill_f32( + float32_t value, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Fills a constant value into a Q7 vector. + * @param[in] value input value to be filled + * @param[out] *pDst output pointer + * @param[in] blockSize number of samples to process + * @return none. + */ + void arm_fill_q7( + q7_t value, + q7_t * pDst, + uint32_t blockSize); + + /** + * @brief Fills a constant value into a Q15 vector. + * @param[in] value input value to be filled + * @param[out] *pDst output pointer + * @param[in] blockSize number of samples to process + * @return none. + */ + void arm_fill_q15( + q15_t value, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Fills a constant value into a Q31 vector. + * @param[in] value input value to be filled + * @param[out] *pDst output pointer + * @param[in] blockSize number of samples to process + * @return none. + */ + void arm_fill_q31( + q31_t value, + q31_t * pDst, + uint32_t blockSize); + +/** + * @brief Convolution of floating-point sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the location where the output result is written. Length srcALen+srcBLen-1. + * @return none. + */ + + void arm_conv_f32( + float32_t * pSrcA, + uint32_t srcALen, + float32_t * pSrcB, + uint32_t srcBLen, + float32_t * pDst); + + + /** + * @brief Convolution of Q15 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length srcALen+srcBLen-1. + * @param[in] *pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @param[in] *pScratch2 points to scratch buffer of size min(srcALen, srcBLen). + * @return none. + */ + + + void arm_conv_opt_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + q15_t * pScratch1, + q15_t * pScratch2); + + +/** + * @brief Convolution of Q15 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the location where the output result is written. Length srcALen+srcBLen-1. + * @return none. + */ + + void arm_conv_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst); + + /** + * @brief Convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4 + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length srcALen+srcBLen-1. + * @return none. + */ + + void arm_conv_fast_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst); + + /** + * @brief Convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4 + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length srcALen+srcBLen-1. + * @param[in] *pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @param[in] *pScratch2 points to scratch buffer of size min(srcALen, srcBLen). + * @return none. + */ + + void arm_conv_fast_opt_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + q15_t * pScratch1, + q15_t * pScratch2); + + + + /** + * @brief Convolution of Q31 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length srcALen+srcBLen-1. + * @return none. + */ + + void arm_conv_q31( + q31_t * pSrcA, + uint32_t srcALen, + q31_t * pSrcB, + uint32_t srcBLen, + q31_t * pDst); + + /** + * @brief Convolution of Q31 sequences (fast version) for Cortex-M3 and Cortex-M4 + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length srcALen+srcBLen-1. + * @return none. + */ + + void arm_conv_fast_q31( + q31_t * pSrcA, + uint32_t srcALen, + q31_t * pSrcB, + uint32_t srcBLen, + q31_t * pDst); + + + /** + * @brief Convolution of Q7 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length srcALen+srcBLen-1. + * @param[in] *pScratch1 points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @param[in] *pScratch2 points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen). + * @return none. + */ + + void arm_conv_opt_q7( + q7_t * pSrcA, + uint32_t srcALen, + q7_t * pSrcB, + uint32_t srcBLen, + q7_t * pDst, + q15_t * pScratch1, + q15_t * pScratch2); + + + + /** + * @brief Convolution of Q7 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length srcALen+srcBLen-1. + * @return none. + */ + + void arm_conv_q7( + q7_t * pSrcA, + uint32_t srcALen, + q7_t * pSrcB, + uint32_t srcBLen, + q7_t * pDst); + + + /** + * @brief Partial convolution of floating-point sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + + arm_status arm_conv_partial_f32( + float32_t * pSrcA, + uint32_t srcALen, + float32_t * pSrcB, + uint32_t srcBLen, + float32_t * pDst, + uint32_t firstIndex, + uint32_t numPoints); + + /** + * @brief Partial convolution of Q15 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @param[in] * pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @param[in] * pScratch2 points to scratch buffer of size min(srcALen, srcBLen). + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + + arm_status arm_conv_partial_opt_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + uint32_t firstIndex, + uint32_t numPoints, + q15_t * pScratch1, + q15_t * pScratch2); + + +/** + * @brief Partial convolution of Q15 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + + arm_status arm_conv_partial_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + uint32_t firstIndex, + uint32_t numPoints); + + /** + * @brief Partial convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4 + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + + arm_status arm_conv_partial_fast_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + uint32_t firstIndex, + uint32_t numPoints); + + + /** + * @brief Partial convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4 + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @param[in] * pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @param[in] * pScratch2 points to scratch buffer of size min(srcALen, srcBLen). + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + + arm_status arm_conv_partial_fast_opt_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + uint32_t firstIndex, + uint32_t numPoints, + q15_t * pScratch1, + q15_t * pScratch2); + + + /** + * @brief Partial convolution of Q31 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + + arm_status arm_conv_partial_q31( + q31_t * pSrcA, + uint32_t srcALen, + q31_t * pSrcB, + uint32_t srcBLen, + q31_t * pDst, + uint32_t firstIndex, + uint32_t numPoints); + + + /** + * @brief Partial convolution of Q31 sequences (fast version) for Cortex-M3 and Cortex-M4 + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + + arm_status arm_conv_partial_fast_q31( + q31_t * pSrcA, + uint32_t srcALen, + q31_t * pSrcB, + uint32_t srcBLen, + q31_t * pDst, + uint32_t firstIndex, + uint32_t numPoints); + + + /** + * @brief Partial convolution of Q7 sequences + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @param[in] *pScratch1 points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @param[in] *pScratch2 points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen). + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + + arm_status arm_conv_partial_opt_q7( + q7_t * pSrcA, + uint32_t srcALen, + q7_t * pSrcB, + uint32_t srcBLen, + q7_t * pDst, + uint32_t firstIndex, + uint32_t numPoints, + q15_t * pScratch1, + q15_t * pScratch2); + + +/** + * @brief Partial convolution of Q7 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data + * @param[in] firstIndex is the first output sample to start with. + * @param[in] numPoints is the number of output points to be computed. + * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2]. + */ + + arm_status arm_conv_partial_q7( + q7_t * pSrcA, + uint32_t srcALen, + q7_t * pSrcB, + uint32_t srcBLen, + q7_t * pDst, + uint32_t firstIndex, + uint32_t numPoints); + + + + /** + * @brief Instance structure for the Q15 FIR decimator. + */ + + typedef struct + { + uint8_t M; /**< decimation factor. */ + uint16_t numTaps; /**< number of coefficients in the filter. */ + q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + } arm_fir_decimate_instance_q15; + + /** + * @brief Instance structure for the Q31 FIR decimator. + */ + + typedef struct + { + uint8_t M; /**< decimation factor. */ + uint16_t numTaps; /**< number of coefficients in the filter. */ + q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + + } arm_fir_decimate_instance_q31; + + /** + * @brief Instance structure for the floating-point FIR decimator. + */ + + typedef struct + { + uint8_t M; /**< decimation factor. */ + uint16_t numTaps; /**< number of coefficients in the filter. */ + float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + + } arm_fir_decimate_instance_f32; + + + + /** + * @brief Processing function for the floating-point FIR decimator. + * @param[in] *S points to an instance of the floating-point FIR decimator structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] blockSize number of input samples to process per call. + * @return none + */ + + void arm_fir_decimate_f32( + const arm_fir_decimate_instance_f32 * S, + float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @brief Initialization function for the floating-point FIR decimator. + * @param[in,out] *S points to an instance of the floating-point FIR decimator structure. + * @param[in] numTaps number of coefficients in the filter. + * @param[in] M decimation factor. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] blockSize number of input samples to process per call. + * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if + * blockSize is not a multiple of M. + */ + + arm_status arm_fir_decimate_init_f32( + arm_fir_decimate_instance_f32 * S, + uint16_t numTaps, + uint8_t M, + float32_t * pCoeffs, + float32_t * pState, + uint32_t blockSize); + + /** + * @brief Processing function for the Q15 FIR decimator. + * @param[in] *S points to an instance of the Q15 FIR decimator structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] blockSize number of input samples to process per call. + * @return none + */ + + void arm_fir_decimate_q15( + const arm_fir_decimate_instance_q15 * S, + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Processing function for the Q15 FIR decimator (fast variant) for Cortex-M3 and Cortex-M4. + * @param[in] *S points to an instance of the Q15 FIR decimator structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] blockSize number of input samples to process per call. + * @return none + */ + + void arm_fir_decimate_fast_q15( + const arm_fir_decimate_instance_q15 * S, + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + + + /** + * @brief Initialization function for the Q15 FIR decimator. + * @param[in,out] *S points to an instance of the Q15 FIR decimator structure. + * @param[in] numTaps number of coefficients in the filter. + * @param[in] M decimation factor. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] blockSize number of input samples to process per call. + * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if + * blockSize is not a multiple of M. + */ + + arm_status arm_fir_decimate_init_q15( + arm_fir_decimate_instance_q15 * S, + uint16_t numTaps, + uint8_t M, + q15_t * pCoeffs, + q15_t * pState, + uint32_t blockSize); + + /** + * @brief Processing function for the Q31 FIR decimator. + * @param[in] *S points to an instance of the Q31 FIR decimator structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] blockSize number of input samples to process per call. + * @return none + */ + + void arm_fir_decimate_q31( + const arm_fir_decimate_instance_q31 * S, + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Processing function for the Q31 FIR decimator (fast variant) for Cortex-M3 and Cortex-M4. + * @param[in] *S points to an instance of the Q31 FIR decimator structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] blockSize number of input samples to process per call. + * @return none + */ + + void arm_fir_decimate_fast_q31( + arm_fir_decimate_instance_q31 * S, + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @brief Initialization function for the Q31 FIR decimator. + * @param[in,out] *S points to an instance of the Q31 FIR decimator structure. + * @param[in] numTaps number of coefficients in the filter. + * @param[in] M decimation factor. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] blockSize number of input samples to process per call. + * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if + * blockSize is not a multiple of M. + */ + + arm_status arm_fir_decimate_init_q31( + arm_fir_decimate_instance_q31 * S, + uint16_t numTaps, + uint8_t M, + q31_t * pCoeffs, + q31_t * pState, + uint32_t blockSize); + + + + /** + * @brief Instance structure for the Q15 FIR interpolator. + */ + + typedef struct + { + uint8_t L; /**< upsample factor. */ + uint16_t phaseLength; /**< length of each polyphase filter component. */ + q15_t *pCoeffs; /**< points to the coefficient array. The array is of length L*phaseLength. */ + q15_t *pState; /**< points to the state variable array. The array is of length blockSize+phaseLength-1. */ + } arm_fir_interpolate_instance_q15; + + /** + * @brief Instance structure for the Q31 FIR interpolator. + */ + + typedef struct + { + uint8_t L; /**< upsample factor. */ + uint16_t phaseLength; /**< length of each polyphase filter component. */ + q31_t *pCoeffs; /**< points to the coefficient array. The array is of length L*phaseLength. */ + q31_t *pState; /**< points to the state variable array. The array is of length blockSize+phaseLength-1. */ + } arm_fir_interpolate_instance_q31; + + /** + * @brief Instance structure for the floating-point FIR interpolator. + */ + + typedef struct + { + uint8_t L; /**< upsample factor. */ + uint16_t phaseLength; /**< length of each polyphase filter component. */ + float32_t *pCoeffs; /**< points to the coefficient array. The array is of length L*phaseLength. */ + float32_t *pState; /**< points to the state variable array. The array is of length phaseLength+numTaps-1. */ + } arm_fir_interpolate_instance_f32; + + + /** + * @brief Processing function for the Q15 FIR interpolator. + * @param[in] *S points to an instance of the Q15 FIR interpolator structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of input samples to process per call. + * @return none. + */ + + void arm_fir_interpolate_q15( + const arm_fir_interpolate_instance_q15 * S, + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + + /** + * @brief Initialization function for the Q15 FIR interpolator. + * @param[in,out] *S points to an instance of the Q15 FIR interpolator structure. + * @param[in] L upsample factor. + * @param[in] numTaps number of filter coefficients in the filter. + * @param[in] *pCoeffs points to the filter coefficient buffer. + * @param[in] *pState points to the state buffer. + * @param[in] blockSize number of input samples to process per call. + * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if + * the filter length numTaps is not a multiple of the interpolation factor L. + */ + + arm_status arm_fir_interpolate_init_q15( + arm_fir_interpolate_instance_q15 * S, + uint8_t L, + uint16_t numTaps, + q15_t * pCoeffs, + q15_t * pState, + uint32_t blockSize); + + /** + * @brief Processing function for the Q31 FIR interpolator. + * @param[in] *S points to an instance of the Q15 FIR interpolator structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of input samples to process per call. + * @return none. + */ + + void arm_fir_interpolate_q31( + const arm_fir_interpolate_instance_q31 * S, + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the Q31 FIR interpolator. + * @param[in,out] *S points to an instance of the Q31 FIR interpolator structure. + * @param[in] L upsample factor. + * @param[in] numTaps number of filter coefficients in the filter. + * @param[in] *pCoeffs points to the filter coefficient buffer. + * @param[in] *pState points to the state buffer. + * @param[in] blockSize number of input samples to process per call. + * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if + * the filter length numTaps is not a multiple of the interpolation factor L. + */ + + arm_status arm_fir_interpolate_init_q31( + arm_fir_interpolate_instance_q31 * S, + uint8_t L, + uint16_t numTaps, + q31_t * pCoeffs, + q31_t * pState, + uint32_t blockSize); + + + /** + * @brief Processing function for the floating-point FIR interpolator. + * @param[in] *S points to an instance of the floating-point FIR interpolator structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of input samples to process per call. + * @return none. + */ + + void arm_fir_interpolate_f32( + const arm_fir_interpolate_instance_f32 * S, + float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the floating-point FIR interpolator. + * @param[in,out] *S points to an instance of the floating-point FIR interpolator structure. + * @param[in] L upsample factor. + * @param[in] numTaps number of filter coefficients in the filter. + * @param[in] *pCoeffs points to the filter coefficient buffer. + * @param[in] *pState points to the state buffer. + * @param[in] blockSize number of input samples to process per call. + * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if + * the filter length numTaps is not a multiple of the interpolation factor L. + */ + + arm_status arm_fir_interpolate_init_f32( + arm_fir_interpolate_instance_f32 * S, + uint8_t L, + uint16_t numTaps, + float32_t * pCoeffs, + float32_t * pState, + uint32_t blockSize); + + /** + * @brief Instance structure for the high precision Q31 Biquad cascade filter. + */ + + typedef struct + { + uint8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ + q63_t *pState; /**< points to the array of state coefficients. The array is of length 4*numStages. */ + q31_t *pCoeffs; /**< points to the array of coefficients. The array is of length 5*numStages. */ + uint8_t postShift; /**< additional shift, in bits, applied to each output sample. */ + + } arm_biquad_cas_df1_32x64_ins_q31; + + + /** + * @param[in] *S points to an instance of the high precision Q31 Biquad cascade filter structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_biquad_cas_df1_32x64_q31( + const arm_biquad_cas_df1_32x64_ins_q31 * S, + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @param[in,out] *S points to an instance of the high precision Q31 Biquad cascade filter structure. + * @param[in] numStages number of 2nd order stages in the filter. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] postShift shift to be applied to the output. Varies according to the coefficients format + * @return none + */ + + void arm_biquad_cas_df1_32x64_init_q31( + arm_biquad_cas_df1_32x64_ins_q31 * S, + uint8_t numStages, + q31_t * pCoeffs, + q63_t * pState, + uint8_t postShift); + + + + /** + * @brief Instance structure for the floating-point transposed direct form II Biquad cascade filter. + */ + + typedef struct + { + uint8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ + float32_t *pState; /**< points to the array of state coefficients. The array is of length 2*numStages. */ + float32_t *pCoeffs; /**< points to the array of coefficients. The array is of length 5*numStages. */ + } arm_biquad_cascade_df2T_instance_f32; + + + /** + * @brief Processing function for the floating-point transposed direct form II Biquad cascade filter. + * @param[in] *S points to an instance of the filter data structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_biquad_cascade_df2T_f32( + const arm_biquad_cascade_df2T_instance_f32 * S, + float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @brief Initialization function for the floating-point transposed direct form II Biquad cascade filter. + * @param[in,out] *S points to an instance of the filter data structure. + * @param[in] numStages number of 2nd order stages in the filter. + * @param[in] *pCoeffs points to the filter coefficients. + * @param[in] *pState points to the state buffer. + * @return none + */ + + void arm_biquad_cascade_df2T_init_f32( + arm_biquad_cascade_df2T_instance_f32 * S, + uint8_t numStages, + float32_t * pCoeffs, + float32_t * pState); + + + + /** + * @brief Instance structure for the Q15 FIR lattice filter. + */ + + typedef struct + { + uint16_t numStages; /**< number of filter stages. */ + q15_t *pState; /**< points to the state variable array. The array is of length numStages. */ + q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numStages. */ + } arm_fir_lattice_instance_q15; + + /** + * @brief Instance structure for the Q31 FIR lattice filter. + */ + + typedef struct + { + uint16_t numStages; /**< number of filter stages. */ + q31_t *pState; /**< points to the state variable array. The array is of length numStages. */ + q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numStages. */ + } arm_fir_lattice_instance_q31; + + /** + * @brief Instance structure for the floating-point FIR lattice filter. + */ + + typedef struct + { + uint16_t numStages; /**< number of filter stages. */ + float32_t *pState; /**< points to the state variable array. The array is of length numStages. */ + float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numStages. */ + } arm_fir_lattice_instance_f32; + + /** + * @brief Initialization function for the Q15 FIR lattice filter. + * @param[in] *S points to an instance of the Q15 FIR lattice structure. + * @param[in] numStages number of filter stages. + * @param[in] *pCoeffs points to the coefficient buffer. The array is of length numStages. + * @param[in] *pState points to the state buffer. The array is of length numStages. + * @return none. + */ + + void arm_fir_lattice_init_q15( + arm_fir_lattice_instance_q15 * S, + uint16_t numStages, + q15_t * pCoeffs, + q15_t * pState); + + + /** + * @brief Processing function for the Q15 FIR lattice filter. + * @param[in] *S points to an instance of the Q15 FIR lattice structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + void arm_fir_lattice_q15( + const arm_fir_lattice_instance_q15 * S, + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the Q31 FIR lattice filter. + * @param[in] *S points to an instance of the Q31 FIR lattice structure. + * @param[in] numStages number of filter stages. + * @param[in] *pCoeffs points to the coefficient buffer. The array is of length numStages. + * @param[in] *pState points to the state buffer. The array is of length numStages. + * @return none. + */ + + void arm_fir_lattice_init_q31( + arm_fir_lattice_instance_q31 * S, + uint16_t numStages, + q31_t * pCoeffs, + q31_t * pState); + + + /** + * @brief Processing function for the Q31 FIR lattice filter. + * @param[in] *S points to an instance of the Q31 FIR lattice structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_fir_lattice_q31( + const arm_fir_lattice_instance_q31 * S, + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + +/** + * @brief Initialization function for the floating-point FIR lattice filter. + * @param[in] *S points to an instance of the floating-point FIR lattice structure. + * @param[in] numStages number of filter stages. + * @param[in] *pCoeffs points to the coefficient buffer. The array is of length numStages. + * @param[in] *pState points to the state buffer. The array is of length numStages. + * @return none. + */ + + void arm_fir_lattice_init_f32( + arm_fir_lattice_instance_f32 * S, + uint16_t numStages, + float32_t * pCoeffs, + float32_t * pState); + + /** + * @brief Processing function for the floating-point FIR lattice filter. + * @param[in] *S points to an instance of the floating-point FIR lattice structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_fir_lattice_f32( + const arm_fir_lattice_instance_f32 * S, + float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Instance structure for the Q15 IIR lattice filter. + */ + typedef struct + { + uint16_t numStages; /**< number of stages in the filter. */ + q15_t *pState; /**< points to the state variable array. The array is of length numStages+blockSize. */ + q15_t *pkCoeffs; /**< points to the reflection coefficient array. The array is of length numStages. */ + q15_t *pvCoeffs; /**< points to the ladder coefficient array. The array is of length numStages+1. */ + } arm_iir_lattice_instance_q15; + + /** + * @brief Instance structure for the Q31 IIR lattice filter. + */ + typedef struct + { + uint16_t numStages; /**< number of stages in the filter. */ + q31_t *pState; /**< points to the state variable array. The array is of length numStages+blockSize. */ + q31_t *pkCoeffs; /**< points to the reflection coefficient array. The array is of length numStages. */ + q31_t *pvCoeffs; /**< points to the ladder coefficient array. The array is of length numStages+1. */ + } arm_iir_lattice_instance_q31; + + /** + * @brief Instance structure for the floating-point IIR lattice filter. + */ + typedef struct + { + uint16_t numStages; /**< number of stages in the filter. */ + float32_t *pState; /**< points to the state variable array. The array is of length numStages+blockSize. */ + float32_t *pkCoeffs; /**< points to the reflection coefficient array. The array is of length numStages. */ + float32_t *pvCoeffs; /**< points to the ladder coefficient array. The array is of length numStages+1. */ + } arm_iir_lattice_instance_f32; + + /** + * @brief Processing function for the floating-point IIR lattice filter. + * @param[in] *S points to an instance of the floating-point IIR lattice structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_iir_lattice_f32( + const arm_iir_lattice_instance_f32 * S, + float32_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + /** + * @brief Initialization function for the floating-point IIR lattice filter. + * @param[in] *S points to an instance of the floating-point IIR lattice structure. + * @param[in] numStages number of stages in the filter. + * @param[in] *pkCoeffs points to the reflection coefficient buffer. The array is of length numStages. + * @param[in] *pvCoeffs points to the ladder coefficient buffer. The array is of length numStages+1. + * @param[in] *pState points to the state buffer. The array is of length numStages+blockSize-1. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_iir_lattice_init_f32( + arm_iir_lattice_instance_f32 * S, + uint16_t numStages, + float32_t * pkCoeffs, + float32_t * pvCoeffs, + float32_t * pState, + uint32_t blockSize); + + + /** + * @brief Processing function for the Q31 IIR lattice filter. + * @param[in] *S points to an instance of the Q31 IIR lattice structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_iir_lattice_q31( + const arm_iir_lattice_instance_q31 * S, + q31_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @brief Initialization function for the Q31 IIR lattice filter. + * @param[in] *S points to an instance of the Q31 IIR lattice structure. + * @param[in] numStages number of stages in the filter. + * @param[in] *pkCoeffs points to the reflection coefficient buffer. The array is of length numStages. + * @param[in] *pvCoeffs points to the ladder coefficient buffer. The array is of length numStages+1. + * @param[in] *pState points to the state buffer. The array is of length numStages+blockSize. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_iir_lattice_init_q31( + arm_iir_lattice_instance_q31 * S, + uint16_t numStages, + q31_t * pkCoeffs, + q31_t * pvCoeffs, + q31_t * pState, + uint32_t blockSize); + + + /** + * @brief Processing function for the Q15 IIR lattice filter. + * @param[in] *S points to an instance of the Q15 IIR lattice structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_iir_lattice_q15( + const arm_iir_lattice_instance_q15 * S, + q15_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + +/** + * @brief Initialization function for the Q15 IIR lattice filter. + * @param[in] *S points to an instance of the fixed-point Q15 IIR lattice structure. + * @param[in] numStages number of stages in the filter. + * @param[in] *pkCoeffs points to reflection coefficient buffer. The array is of length numStages. + * @param[in] *pvCoeffs points to ladder coefficient buffer. The array is of length numStages+1. + * @param[in] *pState points to state buffer. The array is of length numStages+blockSize. + * @param[in] blockSize number of samples to process per call. + * @return none. + */ + + void arm_iir_lattice_init_q15( + arm_iir_lattice_instance_q15 * S, + uint16_t numStages, + q15_t * pkCoeffs, + q15_t * pvCoeffs, + q15_t * pState, + uint32_t blockSize); + + /** + * @brief Instance structure for the floating-point LMS filter. + */ + + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + float32_t mu; /**< step size that controls filter coefficient updates. */ + } arm_lms_instance_f32; + + /** + * @brief Processing function for floating-point LMS filter. + * @param[in] *S points to an instance of the floating-point LMS filter structure. + * @param[in] *pSrc points to the block of input data. + * @param[in] *pRef points to the block of reference data. + * @param[out] *pOut points to the block of output data. + * @param[out] *pErr points to the block of error data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_lms_f32( + const arm_lms_instance_f32 * S, + float32_t * pSrc, + float32_t * pRef, + float32_t * pOut, + float32_t * pErr, + uint32_t blockSize); + + /** + * @brief Initialization function for floating-point LMS filter. + * @param[in] *S points to an instance of the floating-point LMS filter structure. + * @param[in] numTaps number of filter coefficients. + * @param[in] *pCoeffs points to the coefficient buffer. + * @param[in] *pState points to state buffer. + * @param[in] mu step size that controls filter coefficient updates. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_lms_init_f32( + arm_lms_instance_f32 * S, + uint16_t numTaps, + float32_t * pCoeffs, + float32_t * pState, + float32_t mu, + uint32_t blockSize); + + /** + * @brief Instance structure for the Q15 LMS filter. + */ + + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + q15_t mu; /**< step size that controls filter coefficient updates. */ + uint32_t postShift; /**< bit shift applied to coefficients. */ + } arm_lms_instance_q15; + + + /** + * @brief Initialization function for the Q15 LMS filter. + * @param[in] *S points to an instance of the Q15 LMS filter structure. + * @param[in] numTaps number of filter coefficients. + * @param[in] *pCoeffs points to the coefficient buffer. + * @param[in] *pState points to the state buffer. + * @param[in] mu step size that controls filter coefficient updates. + * @param[in] blockSize number of samples to process. + * @param[in] postShift bit shift applied to coefficients. + * @return none. + */ + + void arm_lms_init_q15( + arm_lms_instance_q15 * S, + uint16_t numTaps, + q15_t * pCoeffs, + q15_t * pState, + q15_t mu, + uint32_t blockSize, + uint32_t postShift); + + /** + * @brief Processing function for Q15 LMS filter. + * @param[in] *S points to an instance of the Q15 LMS filter structure. + * @param[in] *pSrc points to the block of input data. + * @param[in] *pRef points to the block of reference data. + * @param[out] *pOut points to the block of output data. + * @param[out] *pErr points to the block of error data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_lms_q15( + const arm_lms_instance_q15 * S, + q15_t * pSrc, + q15_t * pRef, + q15_t * pOut, + q15_t * pErr, + uint32_t blockSize); + + + /** + * @brief Instance structure for the Q31 LMS filter. + */ + + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + q31_t mu; /**< step size that controls filter coefficient updates. */ + uint32_t postShift; /**< bit shift applied to coefficients. */ + + } arm_lms_instance_q31; + + /** + * @brief Processing function for Q31 LMS filter. + * @param[in] *S points to an instance of the Q15 LMS filter structure. + * @param[in] *pSrc points to the block of input data. + * @param[in] *pRef points to the block of reference data. + * @param[out] *pOut points to the block of output data. + * @param[out] *pErr points to the block of error data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_lms_q31( + const arm_lms_instance_q31 * S, + q31_t * pSrc, + q31_t * pRef, + q31_t * pOut, + q31_t * pErr, + uint32_t blockSize); + + /** + * @brief Initialization function for Q31 LMS filter. + * @param[in] *S points to an instance of the Q31 LMS filter structure. + * @param[in] numTaps number of filter coefficients. + * @param[in] *pCoeffs points to coefficient buffer. + * @param[in] *pState points to state buffer. + * @param[in] mu step size that controls filter coefficient updates. + * @param[in] blockSize number of samples to process. + * @param[in] postShift bit shift applied to coefficients. + * @return none. + */ + + void arm_lms_init_q31( + arm_lms_instance_q31 * S, + uint16_t numTaps, + q31_t * pCoeffs, + q31_t * pState, + q31_t mu, + uint32_t blockSize, + uint32_t postShift); + + /** + * @brief Instance structure for the floating-point normalized LMS filter. + */ + + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + float32_t mu; /**< step size that control filter coefficient updates. */ + float32_t energy; /**< saves previous frame energy. */ + float32_t x0; /**< saves previous input sample. */ + } arm_lms_norm_instance_f32; + + /** + * @brief Processing function for floating-point normalized LMS filter. + * @param[in] *S points to an instance of the floating-point normalized LMS filter structure. + * @param[in] *pSrc points to the block of input data. + * @param[in] *pRef points to the block of reference data. + * @param[out] *pOut points to the block of output data. + * @param[out] *pErr points to the block of error data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_lms_norm_f32( + arm_lms_norm_instance_f32 * S, + float32_t * pSrc, + float32_t * pRef, + float32_t * pOut, + float32_t * pErr, + uint32_t blockSize); + + /** + * @brief Initialization function for floating-point normalized LMS filter. + * @param[in] *S points to an instance of the floating-point LMS filter structure. + * @param[in] numTaps number of filter coefficients. + * @param[in] *pCoeffs points to coefficient buffer. + * @param[in] *pState points to state buffer. + * @param[in] mu step size that controls filter coefficient updates. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_lms_norm_init_f32( + arm_lms_norm_instance_f32 * S, + uint16_t numTaps, + float32_t * pCoeffs, + float32_t * pState, + float32_t mu, + uint32_t blockSize); + + + /** + * @brief Instance structure for the Q31 normalized LMS filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + q31_t mu; /**< step size that controls filter coefficient updates. */ + uint8_t postShift; /**< bit shift applied to coefficients. */ + q31_t *recipTable; /**< points to the reciprocal initial value table. */ + q31_t energy; /**< saves previous frame energy. */ + q31_t x0; /**< saves previous input sample. */ + } arm_lms_norm_instance_q31; + + /** + * @brief Processing function for Q31 normalized LMS filter. + * @param[in] *S points to an instance of the Q31 normalized LMS filter structure. + * @param[in] *pSrc points to the block of input data. + * @param[in] *pRef points to the block of reference data. + * @param[out] *pOut points to the block of output data. + * @param[out] *pErr points to the block of error data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_lms_norm_q31( + arm_lms_norm_instance_q31 * S, + q31_t * pSrc, + q31_t * pRef, + q31_t * pOut, + q31_t * pErr, + uint32_t blockSize); + + /** + * @brief Initialization function for Q31 normalized LMS filter. + * @param[in] *S points to an instance of the Q31 normalized LMS filter structure. + * @param[in] numTaps number of filter coefficients. + * @param[in] *pCoeffs points to coefficient buffer. + * @param[in] *pState points to state buffer. + * @param[in] mu step size that controls filter coefficient updates. + * @param[in] blockSize number of samples to process. + * @param[in] postShift bit shift applied to coefficients. + * @return none. + */ + + void arm_lms_norm_init_q31( + arm_lms_norm_instance_q31 * S, + uint16_t numTaps, + q31_t * pCoeffs, + q31_t * pState, + q31_t mu, + uint32_t blockSize, + uint8_t postShift); + + /** + * @brief Instance structure for the Q15 normalized LMS filter. + */ + + typedef struct + { + uint16_t numTaps; /**< Number of coefficients in the filter. */ + q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ + q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ + q15_t mu; /**< step size that controls filter coefficient updates. */ + uint8_t postShift; /**< bit shift applied to coefficients. */ + q15_t *recipTable; /**< Points to the reciprocal initial value table. */ + q15_t energy; /**< saves previous frame energy. */ + q15_t x0; /**< saves previous input sample. */ + } arm_lms_norm_instance_q15; + + /** + * @brief Processing function for Q15 normalized LMS filter. + * @param[in] *S points to an instance of the Q15 normalized LMS filter structure. + * @param[in] *pSrc points to the block of input data. + * @param[in] *pRef points to the block of reference data. + * @param[out] *pOut points to the block of output data. + * @param[out] *pErr points to the block of error data. + * @param[in] blockSize number of samples to process. + * @return none. + */ + + void arm_lms_norm_q15( + arm_lms_norm_instance_q15 * S, + q15_t * pSrc, + q15_t * pRef, + q15_t * pOut, + q15_t * pErr, + uint32_t blockSize); + + + /** + * @brief Initialization function for Q15 normalized LMS filter. + * @param[in] *S points to an instance of the Q15 normalized LMS filter structure. + * @param[in] numTaps number of filter coefficients. + * @param[in] *pCoeffs points to coefficient buffer. + * @param[in] *pState points to state buffer. + * @param[in] mu step size that controls filter coefficient updates. + * @param[in] blockSize number of samples to process. + * @param[in] postShift bit shift applied to coefficients. + * @return none. + */ + + void arm_lms_norm_init_q15( + arm_lms_norm_instance_q15 * S, + uint16_t numTaps, + q15_t * pCoeffs, + q15_t * pState, + q15_t mu, + uint32_t blockSize, + uint8_t postShift); + + /** + * @brief Correlation of floating-point sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + * @return none. + */ + + void arm_correlate_f32( + float32_t * pSrcA, + uint32_t srcALen, + float32_t * pSrcB, + uint32_t srcBLen, + float32_t * pDst); + + + /** + * @brief Correlation of Q15 sequences + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + * @param[in] *pScratch points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @return none. + */ + void arm_correlate_opt_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + q15_t * pScratch); + + + /** + * @brief Correlation of Q15 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + * @return none. + */ + + void arm_correlate_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst); + + /** + * @brief Correlation of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + * @return none. + */ + + void arm_correlate_fast_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst); + + + + /** + * @brief Correlation of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + * @param[in] *pScratch points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @return none. + */ + + void arm_correlate_fast_opt_q15( + q15_t * pSrcA, + uint32_t srcALen, + q15_t * pSrcB, + uint32_t srcBLen, + q15_t * pDst, + q15_t * pScratch); + + /** + * @brief Correlation of Q31 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + * @return none. + */ + + void arm_correlate_q31( + q31_t * pSrcA, + uint32_t srcALen, + q31_t * pSrcB, + uint32_t srcBLen, + q31_t * pDst); + + /** + * @brief Correlation of Q31 sequences (fast version) for Cortex-M3 and Cortex-M4 + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + * @return none. + */ + + void arm_correlate_fast_q31( + q31_t * pSrcA, + uint32_t srcALen, + q31_t * pSrcB, + uint32_t srcBLen, + q31_t * pDst); + + + + /** + * @brief Correlation of Q7 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + * @param[in] *pScratch1 points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. + * @param[in] *pScratch2 points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen). + * @return none. + */ + + void arm_correlate_opt_q7( + q7_t * pSrcA, + uint32_t srcALen, + q7_t * pSrcB, + uint32_t srcBLen, + q7_t * pDst, + q15_t * pScratch1, + q15_t * pScratch2); + + + /** + * @brief Correlation of Q7 sequences. + * @param[in] *pSrcA points to the first input sequence. + * @param[in] srcALen length of the first input sequence. + * @param[in] *pSrcB points to the second input sequence. + * @param[in] srcBLen length of the second input sequence. + * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. + * @return none. + */ + + void arm_correlate_q7( + q7_t * pSrcA, + uint32_t srcALen, + q7_t * pSrcB, + uint32_t srcBLen, + q7_t * pDst); + + + /** + * @brief Instance structure for the floating-point sparse FIR filter. + */ + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */ + float32_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */ + float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */ + int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */ + } arm_fir_sparse_instance_f32; + + /** + * @brief Instance structure for the Q31 sparse FIR filter. + */ + + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */ + q31_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */ + q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */ + int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */ + } arm_fir_sparse_instance_q31; + + /** + * @brief Instance structure for the Q15 sparse FIR filter. + */ + + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */ + q15_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */ + q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */ + int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */ + } arm_fir_sparse_instance_q15; + + /** + * @brief Instance structure for the Q7 sparse FIR filter. + */ + + typedef struct + { + uint16_t numTaps; /**< number of coefficients in the filter. */ + uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */ + q7_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */ + q7_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ + uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */ + int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */ + } arm_fir_sparse_instance_q7; + + /** + * @brief Processing function for the floating-point sparse FIR filter. + * @param[in] *S points to an instance of the floating-point sparse FIR structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] *pScratchIn points to a temporary buffer of size blockSize. + * @param[in] blockSize number of input samples to process per call. + * @return none. + */ + + void arm_fir_sparse_f32( + arm_fir_sparse_instance_f32 * S, + float32_t * pSrc, + float32_t * pDst, + float32_t * pScratchIn, + uint32_t blockSize); + + /** + * @brief Initialization function for the floating-point sparse FIR filter. + * @param[in,out] *S points to an instance of the floating-point sparse FIR structure. + * @param[in] numTaps number of nonzero coefficients in the filter. + * @param[in] *pCoeffs points to the array of filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] *pTapDelay points to the array of offset times. + * @param[in] maxDelay maximum offset time supported. + * @param[in] blockSize number of samples that will be processed per block. + * @return none + */ + + void arm_fir_sparse_init_f32( + arm_fir_sparse_instance_f32 * S, + uint16_t numTaps, + float32_t * pCoeffs, + float32_t * pState, + int32_t * pTapDelay, + uint16_t maxDelay, + uint32_t blockSize); + + /** + * @brief Processing function for the Q31 sparse FIR filter. + * @param[in] *S points to an instance of the Q31 sparse FIR structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] *pScratchIn points to a temporary buffer of size blockSize. + * @param[in] blockSize number of input samples to process per call. + * @return none. + */ + + void arm_fir_sparse_q31( + arm_fir_sparse_instance_q31 * S, + q31_t * pSrc, + q31_t * pDst, + q31_t * pScratchIn, + uint32_t blockSize); + + /** + * @brief Initialization function for the Q31 sparse FIR filter. + * @param[in,out] *S points to an instance of the Q31 sparse FIR structure. + * @param[in] numTaps number of nonzero coefficients in the filter. + * @param[in] *pCoeffs points to the array of filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] *pTapDelay points to the array of offset times. + * @param[in] maxDelay maximum offset time supported. + * @param[in] blockSize number of samples that will be processed per block. + * @return none + */ + + void arm_fir_sparse_init_q31( + arm_fir_sparse_instance_q31 * S, + uint16_t numTaps, + q31_t * pCoeffs, + q31_t * pState, + int32_t * pTapDelay, + uint16_t maxDelay, + uint32_t blockSize); + + /** + * @brief Processing function for the Q15 sparse FIR filter. + * @param[in] *S points to an instance of the Q15 sparse FIR structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] *pScratchIn points to a temporary buffer of size blockSize. + * @param[in] *pScratchOut points to a temporary buffer of size blockSize. + * @param[in] blockSize number of input samples to process per call. + * @return none. + */ + + void arm_fir_sparse_q15( + arm_fir_sparse_instance_q15 * S, + q15_t * pSrc, + q15_t * pDst, + q15_t * pScratchIn, + q31_t * pScratchOut, + uint32_t blockSize); + + + /** + * @brief Initialization function for the Q15 sparse FIR filter. + * @param[in,out] *S points to an instance of the Q15 sparse FIR structure. + * @param[in] numTaps number of nonzero coefficients in the filter. + * @param[in] *pCoeffs points to the array of filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] *pTapDelay points to the array of offset times. + * @param[in] maxDelay maximum offset time supported. + * @param[in] blockSize number of samples that will be processed per block. + * @return none + */ + + void arm_fir_sparse_init_q15( + arm_fir_sparse_instance_q15 * S, + uint16_t numTaps, + q15_t * pCoeffs, + q15_t * pState, + int32_t * pTapDelay, + uint16_t maxDelay, + uint32_t blockSize); + + /** + * @brief Processing function for the Q7 sparse FIR filter. + * @param[in] *S points to an instance of the Q7 sparse FIR structure. + * @param[in] *pSrc points to the block of input data. + * @param[out] *pDst points to the block of output data + * @param[in] *pScratchIn points to a temporary buffer of size blockSize. + * @param[in] *pScratchOut points to a temporary buffer of size blockSize. + * @param[in] blockSize number of input samples to process per call. + * @return none. + */ + + void arm_fir_sparse_q7( + arm_fir_sparse_instance_q7 * S, + q7_t * pSrc, + q7_t * pDst, + q7_t * pScratchIn, + q31_t * pScratchOut, + uint32_t blockSize); + + /** + * @brief Initialization function for the Q7 sparse FIR filter. + * @param[in,out] *S points to an instance of the Q7 sparse FIR structure. + * @param[in] numTaps number of nonzero coefficients in the filter. + * @param[in] *pCoeffs points to the array of filter coefficients. + * @param[in] *pState points to the state buffer. + * @param[in] *pTapDelay points to the array of offset times. + * @param[in] maxDelay maximum offset time supported. + * @param[in] blockSize number of samples that will be processed per block. + * @return none + */ + + void arm_fir_sparse_init_q7( + arm_fir_sparse_instance_q7 * S, + uint16_t numTaps, + q7_t * pCoeffs, + q7_t * pState, + int32_t * pTapDelay, + uint16_t maxDelay, + uint32_t blockSize); + + + /* + * @brief Floating-point sin_cos function. + * @param[in] theta input value in degrees + * @param[out] *pSinVal points to the processed sine output. + * @param[out] *pCosVal points to the processed cos output. + * @return none. + */ + + void arm_sin_cos_f32( + float32_t theta, + float32_t * pSinVal, + float32_t * pCcosVal); + + /* + * @brief Q31 sin_cos function. + * @param[in] theta scaled input value in degrees + * @param[out] *pSinVal points to the processed sine output. + * @param[out] *pCosVal points to the processed cosine output. + * @return none. + */ + + void arm_sin_cos_q31( + q31_t theta, + q31_t * pSinVal, + q31_t * pCosVal); + + + /** + * @brief Floating-point complex conjugate. + * @param[in] *pSrc points to the input vector + * @param[out] *pDst points to the output vector + * @param[in] numSamples number of complex samples in each vector + * @return none. + */ + + void arm_cmplx_conj_f32( + float32_t * pSrc, + float32_t * pDst, + uint32_t numSamples); + + /** + * @brief Q31 complex conjugate. + * @param[in] *pSrc points to the input vector + * @param[out] *pDst points to the output vector + * @param[in] numSamples number of complex samples in each vector + * @return none. + */ + + void arm_cmplx_conj_q31( + q31_t * pSrc, + q31_t * pDst, + uint32_t numSamples); + + /** + * @brief Q15 complex conjugate. + * @param[in] *pSrc points to the input vector + * @param[out] *pDst points to the output vector + * @param[in] numSamples number of complex samples in each vector + * @return none. + */ + + void arm_cmplx_conj_q15( + q15_t * pSrc, + q15_t * pDst, + uint32_t numSamples); + + + + /** + * @brief Floating-point complex magnitude squared + * @param[in] *pSrc points to the complex input vector + * @param[out] *pDst points to the real output vector + * @param[in] numSamples number of complex samples in the input vector + * @return none. + */ + + void arm_cmplx_mag_squared_f32( + float32_t * pSrc, + float32_t * pDst, + uint32_t numSamples); + + /** + * @brief Q31 complex magnitude squared + * @param[in] *pSrc points to the complex input vector + * @param[out] *pDst points to the real output vector + * @param[in] numSamples number of complex samples in the input vector + * @return none. + */ + + void arm_cmplx_mag_squared_q31( + q31_t * pSrc, + q31_t * pDst, + uint32_t numSamples); + + /** + * @brief Q15 complex magnitude squared + * @param[in] *pSrc points to the complex input vector + * @param[out] *pDst points to the real output vector + * @param[in] numSamples number of complex samples in the input vector + * @return none. + */ + + void arm_cmplx_mag_squared_q15( + q15_t * pSrc, + q15_t * pDst, + uint32_t numSamples); + + + /** + * @ingroup groupController + */ + + /** + * @defgroup PID PID Motor Control + * + * A Proportional Integral Derivative (PID) controller is a generic feedback control + * loop mechanism widely used in industrial control systems. + * A PID controller is the most commonly used type of feedback controller. + * + * This set of functions implements (PID) controllers + * for Q15, Q31, and floating-point data types. The functions operate on a single sample + * of data and each call to the function returns a single processed value. + * S points to an instance of the PID control data structure. in + * is the input sample value. The functions return the output value. + * + * \par Algorithm: + * 
      +   *    y[n] = y[n-1] + A0 * x[n] + A1 * x[n-1] + A2 * x[n-2]
+   *    A0 = Kp + Ki + Kd
+   *    A1 = (-Kp ) - (2 * Kd )
+   *    A2 = Kd
      + * + * \par + * where \c Kp is proportional constant, \c Ki is Integral constant and \c Kd is Derivative constant + * + * \par + * \image html PID.gif "Proportional Integral Derivative Controller" + * + * \par + * The PID controller calculates an "error" value as the difference between + * the measured output and the reference input. + * The controller attempts to minimize the error by adjusting the process control inputs. + * The proportional value determines the reaction to the current error, + * the integral value determines the reaction based on the sum of recent errors, + * and the derivative value determines the reaction based on the rate at which the error has been changing. + * + * \par Instance Structure + * The Gains A0, A1, A2 and state variables for a PID controller are stored together in an instance data structure. + * A separate instance structure must be defined for each PID Controller. + * There are separate instance structure declarations for each of the 3 supported data types. + * + * \par Reset Functions + * There is also an associated reset function for each data type which clears the state array. + * + * \par Initialization Functions + * There is also an associated initialization function for each data type. + * The initialization function performs the following operations: + * - Initializes the Gains A0, A1, A2 from Kp,Ki, Kd gains. + * - Zeros out the values in the state buffer. + * + * \par + * Instance structure cannot be placed into a const data section and it is recommended to use the initialization function. + * + * \par Fixed-Point Behavior + * Care must be taken when using the fixed-point versions of the PID Controller functions. + * In particular, the overflow and saturation behavior of the accumulator used in each function must be considered. + * Refer to the function specific documentation below for usage guidelines. + */ + + /** + * @addtogroup PID + * @{ + */ + + /** + * @brief Process function for the floating-point PID Control. + * @param[in,out] *S is an instance of the floating-point PID Control structure + * @param[in] in input sample to process + * @return out processed output sample. + */ + + + static __INLINE float32_t arm_pid_f32( + arm_pid_instance_f32 * S, + float32_t in) + { + float32_t out; + + /* y[n] = y[n-1] + A0 * x[n] + A1 * x[n-1] + A2 * x[n-2] */ + out = (S->A0 * in) + + (S->A1 * S->state[0]) + (S->A2 * S->state[1]) + (S->state[2]); + + /* Update state */ + S->state[1] = S->state[0]; + S->state[0] = in; + S->state[2] = out; + + /* return to application */ + return (out); + + } + + /** + * @brief Process function for the Q31 PID Control. + * @param[in,out] *S points to an instance of the Q31 PID Control structure + * @param[in] in input sample to process + * @return out processed output sample. + * + * Scaling and Overflow Behavior: + * \par + * The function is implemented using an internal 64-bit accumulator. + * The accumulator has a 2.62 format and maintains full precision of the intermediate multiplication results but provides only a single guard bit. + * Thus, if the accumulator result overflows it wraps around rather than clip. + * In order to avoid overflows completely the input signal must be scaled down by 2 bits as there are four additions. + * After all multiply-accumulates are performed, the 2.62 accumulator is truncated to 1.32 format and then saturated to 1.31 format. + */ + + static __INLINE q31_t arm_pid_q31( + arm_pid_instance_q31 * S, + q31_t in) + { + q63_t acc; + q31_t out; + + /* acc = A0 * x[n] */ + acc = (q63_t) S->A0 * in; + + /* acc += A1 * x[n-1] */ + acc += (q63_t) S->A1 * S->state[0]; + + /* acc += A2 * x[n-2] */ + acc += (q63_t) S->A2 * S->state[1]; + + /* convert output to 1.31 format to add y[n-1] */ + out = (q31_t) (acc >> 31u); + + /* out += y[n-1] */ + out += S->state[2]; + + /* Update state */ + S->state[1] = S->state[0]; + S->state[0] = in; + S->state[2] = out; + + /* return to application */ + return (out); + + } + + /** + * @brief Process function for the Q15 PID Control. + * @param[in,out] *S points to an instance of the Q15 PID Control structure + * @param[in] in input sample to process + * @return out processed output sample. + * + * Scaling and Overflow Behavior: + * \par + * The function is implemented using a 64-bit internal accumulator. + * Both Gains and state variables are represented in 1.15 format and multiplications yield a 2.30 result. + * The 2.30 intermediate results are accumulated in a 64-bit accumulator in 34.30 format. + * There is no risk of internal overflow with this approach and the full precision of intermediate multiplications is preserved. + * After all additions have been performed, the accumulator is truncated to 34.15 format by discarding low 15 bits. + * Lastly, the accumulator is saturated to yield a result in 1.15 format. + */ + + static __INLINE q15_t arm_pid_q15( + arm_pid_instance_q15 * S, + q15_t in) + { + q63_t acc; + q15_t out; + +#ifndef ARM_MATH_CM0_FAMILY + __SIMD32_TYPE *vstate; + + /* Implementation of PID controller */ + + /* acc = A0 * x[n] */ + acc = (q31_t) __SMUAD(S->A0, in); + + /* acc += A1 * x[n-1] + A2 * x[n-2] */ + vstate = __SIMD32_CONST(S->state); + acc = __SMLALD(S->A1, (q31_t) *vstate, acc); + +#else + /* acc = A0 * x[n] */ + acc = ((q31_t) S->A0) * in; + + /* acc += A1 * x[n-1] + A2 * x[n-2] */ + acc += (q31_t) S->A1 * S->state[0]; + acc += (q31_t) S->A2 * S->state[1]; + +#endif + + /* acc += y[n-1] */ + acc += (q31_t) S->state[2] << 15; + + /* saturate the output */ + out = (q15_t) (__SSAT((acc >> 15), 16)); + + /* Update state */ + S->state[1] = S->state[0]; + S->state[0] = in; + S->state[2] = out; + + /* return to application */ + return (out); + + } + + /** + * @} end of PID group + */ + + + /** + * @brief Floating-point matrix inverse. + * @param[in] *src points to the instance of the input floating-point matrix structure. + * @param[out] *dst points to the instance of the output floating-point matrix structure. + * @return The function returns ARM_MATH_SIZE_MISMATCH, if the dimensions do not match. + * If the input matrix is singular (does not have an inverse), then the algorithm terminates and returns error status ARM_MATH_SINGULAR. + */ + + arm_status arm_mat_inverse_f32( + const arm_matrix_instance_f32 * src, + arm_matrix_instance_f32 * dst); + + + + /** + * @ingroup groupController + */ + + + /** + * @defgroup clarke Vector Clarke Transform + * Forward Clarke transform converts the instantaneous stator phases into a two-coordinate time invariant vector. + * Generally the Clarke transform uses three-phase currents Ia, Ib and Ic to calculate currents + * in the two-phase orthogonal stator axis Ialpha and Ibeta. + * When Ialpha is superposed with Ia as shown in the figure below + * \image html clarke.gif Stator current space vector and its components in (a,b). + * and Ia + Ib + Ic = 0, in this condition Ialpha and Ibeta + * can be calculated using only Ia and Ib. + * + * The function operates on a single sample of data and each call to the function returns the processed output. + * The library provides separate functions for Q31 and floating-point data types. + * \par Algorithm + * \image html clarkeFormula.gif + * where Ia and Ib are the instantaneous stator phases and + * pIalpha and pIbeta are the two coordinates of time invariant vector. + * \par Fixed-Point Behavior + * Care must be taken when using the Q31 version of the Clarke transform. + * In particular, the overflow and saturation behavior of the accumulator used must be considered. + * Refer to the function specific documentation below for usage guidelines. + */ + + /** + * @addtogroup clarke + * @{ + */ + + /** + * + * @brief Floating-point Clarke transform + * @param[in] Ia input three-phase coordinate a + * @param[in] Ib input three-phase coordinate b + * @param[out] *pIalpha points to output two-phase orthogonal vector axis alpha + * @param[out] *pIbeta points to output two-phase orthogonal vector axis beta + * @return none. + */ + + static __INLINE void arm_clarke_f32( + float32_t Ia, + float32_t Ib, + float32_t * pIalpha, + float32_t * pIbeta) + { + /* Calculate pIalpha using the equation, pIalpha = Ia */ + *pIalpha = Ia; + + /* Calculate pIbeta using the equation, pIbeta = (1/sqrt(3)) * Ia + (2/sqrt(3)) * Ib */ + *pIbeta = + ((float32_t) 0.57735026919 * Ia + (float32_t) 1.15470053838 * Ib); + + } + + /** + * @brief Clarke transform for Q31 version + * @param[in] Ia input three-phase coordinate a + * @param[in] Ib input three-phase coordinate b + * @param[out] *pIalpha points to output two-phase orthogonal vector axis alpha + * @param[out] *pIbeta points to output two-phase orthogonal vector axis beta + * @return none. + * + * Scaling and Overflow Behavior: + * \par + * The function is implemented using an internal 32-bit accumulator. + * The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format. + * There is saturation on the addition, hence there is no risk of overflow. + */ + + static __INLINE void arm_clarke_q31( + q31_t Ia, + q31_t Ib, + q31_t * pIalpha, + q31_t * pIbeta) + { + q31_t product1, product2; /* Temporary variables used to store intermediate results */ + + /* Calculating pIalpha from Ia by equation pIalpha = Ia */ + *pIalpha = Ia; + + /* Intermediate product is calculated by (1/(sqrt(3)) * Ia) */ + product1 = (q31_t) (((q63_t) Ia * 0x24F34E8B) >> 30); + + /* Intermediate product is calculated by (2/sqrt(3) * Ib) */ + product2 = (q31_t) (((q63_t) Ib * 0x49E69D16) >> 30); + + /* pIbeta is calculated by adding the intermediate products */ + *pIbeta = __QADD(product1, product2); + } + + /** + * @} end of clarke group + */ + + /** + * @brief Converts the elements of the Q7 vector to Q31 vector. + * @param[in] *pSrc input pointer + * @param[out] *pDst output pointer + * @param[in] blockSize number of samples to process + * @return none. + */ + void arm_q7_to_q31( + q7_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + + + + /** + * @ingroup groupController + */ + + /** + * @defgroup inv_clarke Vector Inverse Clarke Transform + * Inverse Clarke transform converts the two-coordinate time invariant vector into instantaneous stator phases. + * + * The function operates on a single sample of data and each call to the function returns the processed output. + * The library provides separate functions for Q31 and floating-point data types. + * \par Algorithm + * \image html clarkeInvFormula.gif + * where pIa and pIb are the instantaneous stator phases and + * Ialpha and Ibeta are the two coordinates of time invariant vector. + * \par Fixed-Point Behavior + * Care must be taken when using the Q31 version of the Clarke transform. + * In particular, the overflow and saturation behavior of the accumulator used must be considered. + * Refer to the function specific documentation below for usage guidelines. + */ + + /** + * @addtogroup inv_clarke + * @{ + */ + + /** + * @brief Floating-point Inverse Clarke transform + * @param[in] Ialpha input two-phase orthogonal vector axis alpha + * @param[in] Ibeta input two-phase orthogonal vector axis beta + * @param[out] *pIa points to output three-phase coordinate a + * @param[out] *pIb points to output three-phase coordinate b + * @return none. + */ + + + static __INLINE void arm_inv_clarke_f32( + float32_t Ialpha, + float32_t Ibeta, + float32_t * pIa, + float32_t * pIb) + { + /* Calculating pIa from Ialpha by equation pIa = Ialpha */ + *pIa = Ialpha; + + /* Calculating pIb from Ialpha and Ibeta by equation pIb = -(1/2) * Ialpha + (sqrt(3)/2) * Ibeta */ + *pIb = -0.5 * Ialpha + (float32_t) 0.8660254039 *Ibeta; + + } + + /** + * @brief Inverse Clarke transform for Q31 version + * @param[in] Ialpha input two-phase orthogonal vector axis alpha + * @param[in] Ibeta input two-phase orthogonal vector axis beta + * @param[out] *pIa points to output three-phase coordinate a + * @param[out] *pIb points to output three-phase coordinate b + * @return none. + * + * Scaling and Overflow Behavior: + * \par + * The function is implemented using an internal 32-bit accumulator. + * The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format. + * There is saturation on the subtraction, hence there is no risk of overflow. + */ + + static __INLINE void arm_inv_clarke_q31( + q31_t Ialpha, + q31_t Ibeta, + q31_t * pIa, + q31_t * pIb) + { + q31_t product1, product2; /* Temporary variables used to store intermediate results */ + + /* Calculating pIa from Ialpha by equation pIa = Ialpha */ + *pIa = Ialpha; + + /* Intermediate product is calculated by (1/(2*sqrt(3)) * Ia) */ + product1 = (q31_t) (((q63_t) (Ialpha) * (0x40000000)) >> 31); + + /* Intermediate product is calculated by (1/sqrt(3) * pIb) */ + product2 = (q31_t) (((q63_t) (Ibeta) * (0x6ED9EBA1)) >> 31); + + /* pIb is calculated by subtracting the products */ + *pIb = __QSUB(product2, product1); + + } + + /** + * @} end of inv_clarke group + */ + + /** + * @brief Converts the elements of the Q7 vector to Q15 vector. + * @param[in] *pSrc input pointer + * @param[out] *pDst output pointer + * @param[in] blockSize number of samples to process + * @return none. + */ + void arm_q7_to_q15( + q7_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + + + /** + * @ingroup groupController + */ + + /** + * @defgroup park Vector Park Transform + * + * Forward Park transform converts the input two-coordinate vector to flux and torque components. + * The Park transform can be used to realize the transformation of the Ialpha and the Ibeta currents + * from the stationary to the moving reference frame and control the spatial relationship between + * the stator vector current and rotor flux vector. + * If we consider the d axis aligned with the rotor flux, the diagram below shows the + * current vector and the relationship from the two reference frames: + * \image html park.gif "Stator current space vector and its component in (a,b) and in the d,q rotating reference frame" + * + * The function operates on a single sample of data and each call to the function returns the processed output. + * The library provides separate functions for Q31 and floating-point data types. + * \par Algorithm + * \image html parkFormula.gif + * where Ialpha and Ibeta are the stator vector components, + * pId and pIq are rotor vector components and cosVal and sinVal are the + * cosine and sine values of theta (rotor flux position). + * \par Fixed-Point Behavior + * Care must be taken when using the Q31 version of the Park transform. + * In particular, the overflow and saturation behavior of the accumulator used must be considered. + * Refer to the function specific documentation below for usage guidelines. + */ + + /** + * @addtogroup park + * @{ + */ + + /** + * @brief Floating-point Park transform + * @param[in] Ialpha input two-phase vector coordinate alpha + * @param[in] Ibeta input two-phase vector coordinate beta + * @param[out] *pId points to output rotor reference frame d + * @param[out] *pIq points to output rotor reference frame q + * @param[in] sinVal sine value of rotation angle theta + * @param[in] cosVal cosine value of rotation angle theta + * @return none. + * + * The function implements the forward Park transform. + * + */ + + static __INLINE void arm_park_f32( + float32_t Ialpha, + float32_t Ibeta, + float32_t * pId, + float32_t * pIq, + float32_t sinVal, + float32_t cosVal) + { + /* Calculate pId using the equation, pId = Ialpha * cosVal + Ibeta * sinVal */ + *pId = Ialpha * cosVal + Ibeta * sinVal; + + /* Calculate pIq using the equation, pIq = - Ialpha * sinVal + Ibeta * cosVal */ + *pIq = -Ialpha * sinVal + Ibeta * cosVal; + + } + + /** + * @brief Park transform for Q31 version + * @param[in] Ialpha input two-phase vector coordinate alpha + * @param[in] Ibeta input two-phase vector coordinate beta + * @param[out] *pId points to output rotor reference frame d + * @param[out] *pIq points to output rotor reference frame q + * @param[in] sinVal sine value of rotation angle theta + * @param[in] cosVal cosine value of rotation angle theta + * @return none. + * + * Scaling and Overflow Behavior: + * \par + * The function is implemented using an internal 32-bit accumulator. + * The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format. + * There is saturation on the addition and subtraction, hence there is no risk of overflow. + */ + + + static __INLINE void arm_park_q31( + q31_t Ialpha, + q31_t Ibeta, + q31_t * pId, + q31_t * pIq, + q31_t sinVal, + q31_t cosVal) + { + q31_t product1, product2; /* Temporary variables used to store intermediate results */ + q31_t product3, product4; /* Temporary variables used to store intermediate results */ + + /* Intermediate product is calculated by (Ialpha * cosVal) */ + product1 = (q31_t) (((q63_t) (Ialpha) * (cosVal)) >> 31); + + /* Intermediate product is calculated by (Ibeta * sinVal) */ + product2 = (q31_t) (((q63_t) (Ibeta) * (sinVal)) >> 31); + + + /* Intermediate product is calculated by (Ialpha * sinVal) */ + product3 = (q31_t) (((q63_t) (Ialpha) * (sinVal)) >> 31); + + /* Intermediate product is calculated by (Ibeta * cosVal) */ + product4 = (q31_t) (((q63_t) (Ibeta) * (cosVal)) >> 31); + + /* Calculate pId by adding the two intermediate products 1 and 2 */ + *pId = __QADD(product1, product2); + + /* Calculate pIq by subtracting the two intermediate products 3 from 4 */ + *pIq = __QSUB(product4, product3); + } + + /** + * @} end of park group + */ + + /** + * @brief Converts the elements of the Q7 vector to floating-point vector. + * @param[in] *pSrc is input pointer + * @param[out] *pDst is output pointer + * @param[in] blockSize is the number of samples to process + * @return none. + */ + void arm_q7_to_float( + q7_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @ingroup groupController + */ + + /** + * @defgroup inv_park Vector Inverse Park transform + * Inverse Park transform converts the input flux and torque components to two-coordinate vector. + * + * The function operates on a single sample of data and each call to the function returns the processed output. + * The library provides separate functions for Q31 and floating-point data types. + * \par Algorithm + * \image html parkInvFormula.gif + * where pIalpha and pIbeta are the stator vector components, + * Id and Iq are rotor vector components and cosVal and sinVal are the + * cosine and sine values of theta (rotor flux position). + * \par Fixed-Point Behavior + * Care must be taken when using the Q31 version of the Park transform. + * In particular, the overflow and saturation behavior of the accumulator used must be considered. + * Refer to the function specific documentation below for usage guidelines. + */ + + /** + * @addtogroup inv_park + * @{ + */ + + /** + * @brief Floating-point Inverse Park transform + * @param[in] Id input coordinate of rotor reference frame d + * @param[in] Iq input coordinate of rotor reference frame q + * @param[out] *pIalpha points to output two-phase orthogonal vector axis alpha + * @param[out] *pIbeta points to output two-phase orthogonal vector axis beta + * @param[in] sinVal sine value of rotation angle theta + * @param[in] cosVal cosine value of rotation angle theta + * @return none. + */ + + static __INLINE void arm_inv_park_f32( + float32_t Id, + float32_t Iq, + float32_t * pIalpha, + float32_t * pIbeta, + float32_t sinVal, + float32_t cosVal) + { + /* Calculate pIalpha using the equation, pIalpha = Id * cosVal - Iq * sinVal */ + *pIalpha = Id * cosVal - Iq * sinVal; + + /* Calculate pIbeta using the equation, pIbeta = Id * sinVal + Iq * cosVal */ + *pIbeta = Id * sinVal + Iq * cosVal; + + } + + + /** + * @brief Inverse Park transform for Q31 version + * @param[in] Id input coordinate of rotor reference frame d + * @param[in] Iq input coordinate of rotor reference frame q + * @param[out] *pIalpha points to output two-phase orthogonal vector axis alpha + * @param[out] *pIbeta points to output two-phase orthogonal vector axis beta + * @param[in] sinVal sine value of rotation angle theta + * @param[in] cosVal cosine value of rotation angle theta + * @return none. + * + * Scaling and Overflow Behavior: + * \par + * The function is implemented using an internal 32-bit accumulator. + * The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format. + * There is saturation on the addition, hence there is no risk of overflow. + */ + + + static __INLINE void arm_inv_park_q31( + q31_t Id, + q31_t Iq, + q31_t * pIalpha, + q31_t * pIbeta, + q31_t sinVal, + q31_t cosVal) + { + q31_t product1, product2; /* Temporary variables used to store intermediate results */ + q31_t product3, product4; /* Temporary variables used to store intermediate results */ + + /* Intermediate product is calculated by (Id * cosVal) */ + product1 = (q31_t) (((q63_t) (Id) * (cosVal)) >> 31); + + /* Intermediate product is calculated by (Iq * sinVal) */ + product2 = (q31_t) (((q63_t) (Iq) * (sinVal)) >> 31); + + + /* Intermediate product is calculated by (Id * sinVal) */ + product3 = (q31_t) (((q63_t) (Id) * (sinVal)) >> 31); + + /* Intermediate product is calculated by (Iq * cosVal) */ + product4 = (q31_t) (((q63_t) (Iq) * (cosVal)) >> 31); + + /* Calculate pIalpha by using the two intermediate products 1 and 2 */ + *pIalpha = __QSUB(product1, product2); + + /* Calculate pIbeta by using the two intermediate products 3 and 4 */ + *pIbeta = __QADD(product4, product3); + + } + + /** + * @} end of Inverse park group + */ + + + /** + * @brief Converts the elements of the Q31 vector to floating-point vector. + * @param[in] *pSrc is input pointer + * @param[out] *pDst is output pointer + * @param[in] blockSize is the number of samples to process + * @return none. + */ + void arm_q31_to_float( + q31_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + /** + * @ingroup groupInterpolation + */ + + /** + * @defgroup LinearInterpolate Linear Interpolation + * + * Linear interpolation is a method of curve fitting using linear polynomials. + * Linear interpolation works by effectively drawing a straight line between two neighboring samples and returning the appropriate point along that line + * + * \par + * \image html LinearInterp.gif "Linear interpolation" + * + * \par + * A Linear Interpolate function calculates an output value(y), for the input(x) + * using linear interpolation of the input values x0, x1( nearest input values) and the output values y0 and y1(nearest output values) + * + * \par Algorithm: + * 
      +   *       y = y0 + (x - x0) * ((y1 - y0)/(x1-x0))
+   *       where x0, x1 are nearest values of input x
+   *             y0, y1 are nearest values to output y
+   *
      + * + * \par + * This set of functions implements Linear interpolation process + * for Q7, Q15, Q31, and floating-point data types. The functions operate on a single + * sample of data and each call to the function returns a single processed value. + * S points to an instance of the Linear Interpolate function data structure. + * x is the input sample value. The functions returns the output value. + * + * \par + * if x is outside of the table boundary, Linear interpolation returns first value of the table + * if x is below input range and returns last value of table if x is above range. + */ + + /** + * @addtogroup LinearInterpolate + * @{ + */ + + /** + * @brief Process function for the floating-point Linear Interpolation Function. + * @param[in,out] *S is an instance of the floating-point Linear Interpolation structure + * @param[in] x input sample to process + * @return y processed output sample. + * + */ + + static __INLINE float32_t arm_linear_interp_f32( + arm_linear_interp_instance_f32 * S, + float32_t x) + { + + float32_t y; + float32_t x0, x1; /* Nearest input values */ + float32_t y0, y1; /* Nearest output values */ + float32_t xSpacing = S->xSpacing; /* spacing between input values */ + int32_t i; /* Index variable */ + float32_t *pYData = S->pYData; /* pointer to output table */ + + /* Calculation of index */ + i = (int32_t) ((x - S->x1) / xSpacing); + + if(i < 0) + { + /* Iniatilize output for below specified range as least output value of table */ + y = pYData[0]; + } + else if((uint32_t)i >= S->nValues) + { + /* Iniatilize output for above specified range as last output value of table */ + y = pYData[S->nValues - 1]; + } + else + { + /* Calculation of nearest input values */ + x0 = S->x1 + i * xSpacing; + x1 = S->x1 + (i + 1) * xSpacing; + + /* Read of nearest output values */ + y0 = pYData[i]; + y1 = pYData[i + 1]; + + /* Calculation of output */ + y = y0 + (x - x0) * ((y1 - y0) / (x1 - x0)); + + } + + /* returns output value */ + return (y); + } + + /** + * + * @brief Process function for the Q31 Linear Interpolation Function. + * @param[in] *pYData pointer to Q31 Linear Interpolation table + * @param[in] x input sample to process + * @param[in] nValues number of table values + * @return y processed output sample. + * + * \par + * Input sample x is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part. + * This function can support maximum of table size 2^12. + * + */ + + + static __INLINE q31_t arm_linear_interp_q31( + q31_t * pYData, + q31_t x, + uint32_t nValues) + { + q31_t y; /* output */ + q31_t y0, y1; /* Nearest output values */ + q31_t fract; /* fractional part */ + int32_t index; /* Index to read nearest output values */ + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + index = ((x & 0xFFF00000) >> 20); + + if(index >= (int32_t)(nValues - 1)) + { + return (pYData[nValues - 1]); + } + else if(index < 0) + { + return (pYData[0]); + } + else + { + + /* 20 bits for the fractional part */ + /* shift left by 11 to keep fract in 1.31 format */ + fract = (x & 0x000FFFFF) << 11; + + /* Read two nearest output values from the index in 1.31(q31) format */ + y0 = pYData[index]; + y1 = pYData[index + 1u]; + + /* Calculation of y0 * (1-fract) and y is in 2.30 format */ + y = ((q31_t) ((q63_t) y0 * (0x7FFFFFFF - fract) >> 32)); + + /* Calculation of y0 * (1-fract) + y1 *fract and y is in 2.30 format */ + y += ((q31_t) (((q63_t) y1 * fract) >> 32)); + + /* Convert y to 1.31 format */ + return (y << 1u); + + } + + } + + /** + * + * @brief Process function for the Q15 Linear Interpolation Function. + * @param[in] *pYData pointer to Q15 Linear Interpolation table + * @param[in] x input sample to process + * @param[in] nValues number of table values + * @return y processed output sample. + * + * \par + * Input sample x is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part. + * This function can support maximum of table size 2^12. + * + */ + + + static __INLINE q15_t arm_linear_interp_q15( + q15_t * pYData, + q31_t x, + uint32_t nValues) + { + q63_t y; /* output */ + q15_t y0, y1; /* Nearest output values */ + q31_t fract; /* fractional part */ + int32_t index; /* Index to read nearest output values */ + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + index = ((x & 0xFFF00000) >> 20u); + + if(index >= (int32_t)(nValues - 1)) + { + return (pYData[nValues - 1]); + } + else if(index < 0) + { + return (pYData[0]); + } + else + { + /* 20 bits for the fractional part */ + /* fract is in 12.20 format */ + fract = (x & 0x000FFFFF); + + /* Read two nearest output values from the index */ + y0 = pYData[index]; + y1 = pYData[index + 1u]; + + /* Calculation of y0 * (1-fract) and y is in 13.35 format */ + y = ((q63_t) y0 * (0xFFFFF - fract)); + + /* Calculation of (y0 * (1-fract) + y1 * fract) and y is in 13.35 format */ + y += ((q63_t) y1 * (fract)); + + /* convert y to 1.15 format */ + return (y >> 20); + } + + + } + + /** + * + * @brief Process function for the Q7 Linear Interpolation Function. + * @param[in] *pYData pointer to Q7 Linear Interpolation table + * @param[in] x input sample to process + * @param[in] nValues number of table values + * @return y processed output sample. + * + * \par + * Input sample x is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part. + * This function can support maximum of table size 2^12. + */ + + + static __INLINE q7_t arm_linear_interp_q7( + q7_t * pYData, + q31_t x, + uint32_t nValues) + { + q31_t y; /* output */ + q7_t y0, y1; /* Nearest output values */ + q31_t fract; /* fractional part */ + uint32_t index; /* Index to read nearest output values */ + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + if (x < 0) + { + return (pYData[0]); + } + index = (x >> 20) & 0xfff; + + + if(index >= (nValues - 1)) + { + return (pYData[nValues - 1]); + } + else + { + + /* 20 bits for the fractional part */ + /* fract is in 12.20 format */ + fract = (x & 0x000FFFFF); + + /* Read two nearest output values from the index and are in 1.7(q7) format */ + y0 = pYData[index]; + y1 = pYData[index + 1u]; + + /* Calculation of y0 * (1-fract ) and y is in 13.27(q27) format */ + y = ((y0 * (0xFFFFF - fract))); + + /* Calculation of y1 * fract + y0 * (1-fract) and y is in 13.27(q27) format */ + y += (y1 * fract); + + /* convert y to 1.7(q7) format */ + return (y >> 20u); + + } + + } + /** + * @} end of LinearInterpolate group + */ + + /** + * @brief Fast approximation to the trigonometric sine function for floating-point data. + * @param[in] x input value in radians. + * @return sin(x). + */ + + float32_t arm_sin_f32( + float32_t x); + + /** + * @brief Fast approximation to the trigonometric sine function for Q31 data. + * @param[in] x Scaled input value in radians. + * @return sin(x). + */ + + q31_t arm_sin_q31( + q31_t x); + + /** + * @brief Fast approximation to the trigonometric sine function for Q15 data. + * @param[in] x Scaled input value in radians. + * @return sin(x). + */ + + q15_t arm_sin_q15( + q15_t x); + + /** + * @brief Fast approximation to the trigonometric cosine function for floating-point data. + * @param[in] x input value in radians. + * @return cos(x). + */ + + float32_t arm_cos_f32( + float32_t x); + + /** + * @brief Fast approximation to the trigonometric cosine function for Q31 data. + * @param[in] x Scaled input value in radians. + * @return cos(x). + */ + + q31_t arm_cos_q31( + q31_t x); + + /** + * @brief Fast approximation to the trigonometric cosine function for Q15 data. + * @param[in] x Scaled input value in radians. + * @return cos(x). + */ + + q15_t arm_cos_q15( + q15_t x); + + + /** + * @ingroup groupFastMath + */ + + + /** + * @defgroup SQRT Square Root + * + * Computes the square root of a number. + * There are separate functions for Q15, Q31, and floating-point data types. + * The square root function is computed using the Newton-Raphson algorithm. + * This is an iterative algorithm of the form: + * 
      +   *      x1 = x0 - f(x0)/f'(x0)
+   *
      + * where x1 is the current estimate, + * x0 is the previous estimate, and + * f'(x0) is the derivative of f() evaluated at x0. + * For the square root function, the algorithm reduces to: + * 
      +   *     x0 = in/2                         [initial guess]
+   *     x1 = 1/2 * ( x0 + in / x0)        [each iteration]
+   *
      + */ + + + /** + * @addtogroup SQRT + * @{ + */ + + /** + * @brief Floating-point square root function. + * @param[in] in input value. + * @param[out] *pOut square root of input value. + * @return The function returns ARM_MATH_SUCCESS if input value is positive value or ARM_MATH_ARGUMENT_ERROR if + * in is negative value and returns zero output for negative values. + */ + + static __INLINE arm_status arm_sqrt_f32( + float32_t in, + float32_t * pOut) + { + if(in > 0) + { + +// #if __FPU_USED +#if (__FPU_USED == 1) && defined ( __CC_ARM ) + *pOut = __sqrtf(in); +#else + *pOut = sqrtf(in); +#endif + + return (ARM_MATH_SUCCESS); + } + else + { + *pOut = 0.0f; + return (ARM_MATH_ARGUMENT_ERROR); + } + + } + + + /** + * @brief Q31 square root function. + * @param[in] in input value. The range of the input value is [0 +1) or 0x00000000 to 0x7FFFFFFF. + * @param[out] *pOut square root of input value. + * @return The function returns ARM_MATH_SUCCESS if input value is positive value or ARM_MATH_ARGUMENT_ERROR if + * in is negative value and returns zero output for negative values. + */ + arm_status arm_sqrt_q31( + q31_t in, + q31_t * pOut); + + /** + * @brief Q15 square root function. + * @param[in] in input value. The range of the input value is [0 +1) or 0x0000 to 0x7FFF. + * @param[out] *pOut square root of input value. + * @return The function returns ARM_MATH_SUCCESS if input value is positive value or ARM_MATH_ARGUMENT_ERROR if + * in is negative value and returns zero output for negative values. + */ + arm_status arm_sqrt_q15( + q15_t in, + q15_t * pOut); + + /** + * @} end of SQRT group + */ + + + + + + + /** + * @brief floating-point Circular write function. + */ + + static __INLINE void arm_circularWrite_f32( + int32_t * circBuffer, + int32_t L, + uint16_t * writeOffset, + int32_t bufferInc, + const int32_t * src, + int32_t srcInc, + uint32_t blockSize) + { + uint32_t i = 0u; + int32_t wOffset; + + /* Copy the value of Index pointer that points + * to the current location where the input samples to be copied */ + wOffset = *writeOffset; + + /* Loop over the blockSize */ + i = blockSize; + + while(i > 0u) + { + /* copy the input sample to the circular buffer */ + circBuffer[wOffset] = *src; + + /* Update the input pointer */ + src += srcInc; + + /* Circularly update wOffset. Watch out for positive and negative value */ + wOffset += bufferInc; + if(wOffset >= L) + wOffset -= L; + + /* Decrement the loop counter */ + i--; + } + + /* Update the index pointer */ + *writeOffset = wOffset; + } + + + + /** + * @brief floating-point Circular Read function. + */ + static __INLINE void arm_circularRead_f32( + int32_t * circBuffer, + int32_t L, + int32_t * readOffset, + int32_t bufferInc, + int32_t * dst, + int32_t * dst_base, + int32_t dst_length, + int32_t dstInc, + uint32_t blockSize) + { + uint32_t i = 0u; + int32_t rOffset, dst_end; + + /* Copy the value of Index pointer that points + * to the current location from where the input samples to be read */ + rOffset = *readOffset; + dst_end = (int32_t) (dst_base + dst_length); + + /* Loop over the blockSize */ + i = blockSize; + + while(i > 0u) + { + /* copy the sample from the circular buffer to the destination buffer */ + *dst = circBuffer[rOffset]; + + /* Update the input pointer */ + dst += dstInc; + + if(dst == (int32_t *) dst_end) + { + dst = dst_base; + } + + /* Circularly update rOffset. Watch out for positive and negative value */ + rOffset += bufferInc; + + if(rOffset >= L) + { + rOffset -= L; + } + + /* Decrement the loop counter */ + i--; + } + + /* Update the index pointer */ + *readOffset = rOffset; + } + + /** + * @brief Q15 Circular write function. + */ + + static __INLINE void arm_circularWrite_q15( + q15_t * circBuffer, + int32_t L, + uint16_t * writeOffset, + int32_t bufferInc, + const q15_t * src, + int32_t srcInc, + uint32_t blockSize) + { + uint32_t i = 0u; + int32_t wOffset; + + /* Copy the value of Index pointer that points + * to the current location where the input samples to be copied */ + wOffset = *writeOffset; + + /* Loop over the blockSize */ + i = blockSize; + + while(i > 0u) + { + /* copy the input sample to the circular buffer */ + circBuffer[wOffset] = *src; + + /* Update the input pointer */ + src += srcInc; + + /* Circularly update wOffset. Watch out for positive and negative value */ + wOffset += bufferInc; + if(wOffset >= L) + wOffset -= L; + + /* Decrement the loop counter */ + i--; + } + + /* Update the index pointer */ + *writeOffset = wOffset; + } + + + + /** + * @brief Q15 Circular Read function. + */ + static __INLINE void arm_circularRead_q15( + q15_t * circBuffer, + int32_t L, + int32_t * readOffset, + int32_t bufferInc, + q15_t * dst, + q15_t * dst_base, + int32_t dst_length, + int32_t dstInc, + uint32_t blockSize) + { + uint32_t i = 0; + int32_t rOffset, dst_end; + + /* Copy the value of Index pointer that points + * to the current location from where the input samples to be read */ + rOffset = *readOffset; + + dst_end = (int32_t) (dst_base + dst_length); + + /* Loop over the blockSize */ + i = blockSize; + + while(i > 0u) + { + /* copy the sample from the circular buffer to the destination buffer */ + *dst = circBuffer[rOffset]; + + /* Update the input pointer */ + dst += dstInc; + + if(dst == (q15_t *) dst_end) + { + dst = dst_base; + } + + /* Circularly update wOffset. Watch out for positive and negative value */ + rOffset += bufferInc; + + if(rOffset >= L) + { + rOffset -= L; + } + + /* Decrement the loop counter */ + i--; + } + + /* Update the index pointer */ + *readOffset = rOffset; + } + + + /** + * @brief Q7 Circular write function. + */ + + static __INLINE void arm_circularWrite_q7( + q7_t * circBuffer, + int32_t L, + uint16_t * writeOffset, + int32_t bufferInc, + const q7_t * src, + int32_t srcInc, + uint32_t blockSize) + { + uint32_t i = 0u; + int32_t wOffset; + + /* Copy the value of Index pointer that points + * to the current location where the input samples to be copied */ + wOffset = *writeOffset; + + /* Loop over the blockSize */ + i = blockSize; + + while(i > 0u) + { + /* copy the input sample to the circular buffer */ + circBuffer[wOffset] = *src; + + /* Update the input pointer */ + src += srcInc; + + /* Circularly update wOffset. Watch out for positive and negative value */ + wOffset += bufferInc; + if(wOffset >= L) + wOffset -= L; + + /* Decrement the loop counter */ + i--; + } + + /* Update the index pointer */ + *writeOffset = wOffset; + } + + + + /** + * @brief Q7 Circular Read function. + */ + static __INLINE void arm_circularRead_q7( + q7_t * circBuffer, + int32_t L, + int32_t * readOffset, + int32_t bufferInc, + q7_t * dst, + q7_t * dst_base, + int32_t dst_length, + int32_t dstInc, + uint32_t blockSize) + { + uint32_t i = 0; + int32_t rOffset, dst_end; + + /* Copy the value of Index pointer that points + * to the current location from where the input samples to be read */ + rOffset = *readOffset; + + dst_end = (int32_t) (dst_base + dst_length); + + /* Loop over the blockSize */ + i = blockSize; + + while(i > 0u) + { + /* copy the sample from the circular buffer to the destination buffer */ + *dst = circBuffer[rOffset]; + + /* Update the input pointer */ + dst += dstInc; + + if(dst == (q7_t *) dst_end) + { + dst = dst_base; + } + + /* Circularly update rOffset. Watch out for positive and negative value */ + rOffset += bufferInc; + + if(rOffset >= L) + { + rOffset -= L; + } + + /* Decrement the loop counter */ + i--; + } + + /* Update the index pointer */ + *readOffset = rOffset; + } + + + /** + * @brief Sum of the squares of the elements of a Q31 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_power_q31( + q31_t * pSrc, + uint32_t blockSize, + q63_t * pResult); + + /** + * @brief Sum of the squares of the elements of a floating-point vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_power_f32( + float32_t * pSrc, + uint32_t blockSize, + float32_t * pResult); + + /** + * @brief Sum of the squares of the elements of a Q15 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_power_q15( + q15_t * pSrc, + uint32_t blockSize, + q63_t * pResult); + + /** + * @brief Sum of the squares of the elements of a Q7 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_power_q7( + q7_t * pSrc, + uint32_t blockSize, + q31_t * pResult); + + /** + * @brief Mean value of a Q7 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_mean_q7( + q7_t * pSrc, + uint32_t blockSize, + q7_t * pResult); + + /** + * @brief Mean value of a Q15 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + void arm_mean_q15( + q15_t * pSrc, + uint32_t blockSize, + q15_t * pResult); + + /** + * @brief Mean value of a Q31 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + void arm_mean_q31( + q31_t * pSrc, + uint32_t blockSize, + q31_t * pResult); + + /** + * @brief Mean value of a floating-point vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + void arm_mean_f32( + float32_t * pSrc, + uint32_t blockSize, + float32_t * pResult); + + /** + * @brief Variance of the elements of a floating-point vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_var_f32( + float32_t * pSrc, + uint32_t blockSize, + float32_t * pResult); + + /** + * @brief Variance of the elements of a Q31 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_var_q31( + q31_t * pSrc, + uint32_t blockSize, + q63_t * pResult); + + /** + * @brief Variance of the elements of a Q15 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_var_q15( + q15_t * pSrc, + uint32_t blockSize, + q31_t * pResult); + + /** + * @brief Root Mean Square of the elements of a floating-point vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_rms_f32( + float32_t * pSrc, + uint32_t blockSize, + float32_t * pResult); + + /** + * @brief Root Mean Square of the elements of a Q31 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_rms_q31( + q31_t * pSrc, + uint32_t blockSize, + q31_t * pResult); + + /** + * @brief Root Mean Square of the elements of a Q15 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_rms_q15( + q15_t * pSrc, + uint32_t blockSize, + q15_t * pResult); + + /** + * @brief Standard deviation of the elements of a floating-point vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_std_f32( + float32_t * pSrc, + uint32_t blockSize, + float32_t * pResult); + + /** + * @brief Standard deviation of the elements of a Q31 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_std_q31( + q31_t * pSrc, + uint32_t blockSize, + q31_t * pResult); + + /** + * @brief Standard deviation of the elements of a Q15 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output value. + * @return none. + */ + + void arm_std_q15( + q15_t * pSrc, + uint32_t blockSize, + q15_t * pResult); + + /** + * @brief Floating-point complex magnitude + * @param[in] *pSrc points to the complex input vector + * @param[out] *pDst points to the real output vector + * @param[in] numSamples number of complex samples in the input vector + * @return none. + */ + + void arm_cmplx_mag_f32( + float32_t * pSrc, + float32_t * pDst, + uint32_t numSamples); + + /** + * @brief Q31 complex magnitude + * @param[in] *pSrc points to the complex input vector + * @param[out] *pDst points to the real output vector + * @param[in] numSamples number of complex samples in the input vector + * @return none. + */ + + void arm_cmplx_mag_q31( + q31_t * pSrc, + q31_t * pDst, + uint32_t numSamples); + + /** + * @brief Q15 complex magnitude + * @param[in] *pSrc points to the complex input vector + * @param[out] *pDst points to the real output vector + * @param[in] numSamples number of complex samples in the input vector + * @return none. + */ + + void arm_cmplx_mag_q15( + q15_t * pSrc, + q15_t * pDst, + uint32_t numSamples); + + /** + * @brief Q15 complex dot product + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[in] numSamples number of complex samples in each vector + * @param[out] *realResult real part of the result returned here + * @param[out] *imagResult imaginary part of the result returned here + * @return none. + */ + + void arm_cmplx_dot_prod_q15( + q15_t * pSrcA, + q15_t * pSrcB, + uint32_t numSamples, + q31_t * realResult, + q31_t * imagResult); + + /** + * @brief Q31 complex dot product + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[in] numSamples number of complex samples in each vector + * @param[out] *realResult real part of the result returned here + * @param[out] *imagResult imaginary part of the result returned here + * @return none. + */ + + void arm_cmplx_dot_prod_q31( + q31_t * pSrcA, + q31_t * pSrcB, + uint32_t numSamples, + q63_t * realResult, + q63_t * imagResult); + + /** + * @brief Floating-point complex dot product + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[in] numSamples number of complex samples in each vector + * @param[out] *realResult real part of the result returned here + * @param[out] *imagResult imaginary part of the result returned here + * @return none. + */ + + void arm_cmplx_dot_prod_f32( + float32_t * pSrcA, + float32_t * pSrcB, + uint32_t numSamples, + float32_t * realResult, + float32_t * imagResult); + + /** + * @brief Q15 complex-by-real multiplication + * @param[in] *pSrcCmplx points to the complex input vector + * @param[in] *pSrcReal points to the real input vector + * @param[out] *pCmplxDst points to the complex output vector + * @param[in] numSamples number of samples in each vector + * @return none. + */ + + void arm_cmplx_mult_real_q15( + q15_t * pSrcCmplx, + q15_t * pSrcReal, + q15_t * pCmplxDst, + uint32_t numSamples); + + /** + * @brief Q31 complex-by-real multiplication + * @param[in] *pSrcCmplx points to the complex input vector + * @param[in] *pSrcReal points to the real input vector + * @param[out] *pCmplxDst points to the complex output vector + * @param[in] numSamples number of samples in each vector + * @return none. + */ + + void arm_cmplx_mult_real_q31( + q31_t * pSrcCmplx, + q31_t * pSrcReal, + q31_t * pCmplxDst, + uint32_t numSamples); + + /** + * @brief Floating-point complex-by-real multiplication + * @param[in] *pSrcCmplx points to the complex input vector + * @param[in] *pSrcReal points to the real input vector + * @param[out] *pCmplxDst points to the complex output vector + * @param[in] numSamples number of samples in each vector + * @return none. + */ + + void arm_cmplx_mult_real_f32( + float32_t * pSrcCmplx, + float32_t * pSrcReal, + float32_t * pCmplxDst, + uint32_t numSamples); + + /** + * @brief Minimum value of a Q7 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *result is output pointer + * @param[in] index is the array index of the minimum value in the input buffer. + * @return none. + */ + + void arm_min_q7( + q7_t * pSrc, + uint32_t blockSize, + q7_t * result, + uint32_t * index); + + /** + * @brief Minimum value of a Q15 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output pointer + * @param[in] *pIndex is the array index of the minimum value in the input buffer. + * @return none. + */ + + void arm_min_q15( + q15_t * pSrc, + uint32_t blockSize, + q15_t * pResult, + uint32_t * pIndex); + + /** + * @brief Minimum value of a Q31 vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output pointer + * @param[out] *pIndex is the array index of the minimum value in the input buffer. + * @return none. + */ + void arm_min_q31( + q31_t * pSrc, + uint32_t blockSize, + q31_t * pResult, + uint32_t * pIndex); + + /** + * @brief Minimum value of a floating-point vector. + * @param[in] *pSrc is input pointer + * @param[in] blockSize is the number of samples to process + * @param[out] *pResult is output pointer + * @param[out] *pIndex is the array index of the minimum value in the input buffer. + * @return none. + */ + + void arm_min_f32( + float32_t * pSrc, + uint32_t blockSize, + float32_t * pResult, + uint32_t * pIndex); + +/** + * @brief Maximum value of a Q7 vector. + * @param[in] *pSrc points to the input buffer + * @param[in] blockSize length of the input vector + * @param[out] *pResult maximum value returned here + * @param[out] *pIndex index of maximum value returned here + * @return none. + */ + + void arm_max_q7( + q7_t * pSrc, + uint32_t blockSize, + q7_t * pResult, + uint32_t * pIndex); + +/** + * @brief Maximum value of a Q15 vector. + * @param[in] *pSrc points to the input buffer + * @param[in] blockSize length of the input vector + * @param[out] *pResult maximum value returned here + * @param[out] *pIndex index of maximum value returned here + * @return none. + */ + + void arm_max_q15( + q15_t * pSrc, + uint32_t blockSize, + q15_t * pResult, + uint32_t * pIndex); + +/** + * @brief Maximum value of a Q31 vector. + * @param[in] *pSrc points to the input buffer + * @param[in] blockSize length of the input vector + * @param[out] *pResult maximum value returned here + * @param[out] *pIndex index of maximum value returned here + * @return none. + */ + + void arm_max_q31( + q31_t * pSrc, + uint32_t blockSize, + q31_t * pResult, + uint32_t * pIndex); + +/** + * @brief Maximum value of a floating-point vector. + * @param[in] *pSrc points to the input buffer + * @param[in] blockSize length of the input vector + * @param[out] *pResult maximum value returned here + * @param[out] *pIndex index of maximum value returned here + * @return none. + */ + + void arm_max_f32( + float32_t * pSrc, + uint32_t blockSize, + float32_t * pResult, + uint32_t * pIndex); + + /** + * @brief Q15 complex-by-complex multiplication + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] numSamples number of complex samples in each vector + * @return none. + */ + + void arm_cmplx_mult_cmplx_q15( + q15_t * pSrcA, + q15_t * pSrcB, + q15_t * pDst, + uint32_t numSamples); + + /** + * @brief Q31 complex-by-complex multiplication + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] numSamples number of complex samples in each vector + * @return none. + */ + + void arm_cmplx_mult_cmplx_q31( + q31_t * pSrcA, + q31_t * pSrcB, + q31_t * pDst, + uint32_t numSamples); + + /** + * @brief Floating-point complex-by-complex multiplication + * @param[in] *pSrcA points to the first input vector + * @param[in] *pSrcB points to the second input vector + * @param[out] *pDst points to the output vector + * @param[in] numSamples number of complex samples in each vector + * @return none. + */ + + void arm_cmplx_mult_cmplx_f32( + float32_t * pSrcA, + float32_t * pSrcB, + float32_t * pDst, + uint32_t numSamples); + + /** + * @brief Converts the elements of the floating-point vector to Q31 vector. + * @param[in] *pSrc points to the floating-point input vector + * @param[out] *pDst points to the Q31 output vector + * @param[in] blockSize length of the input vector + * @return none. + */ + void arm_float_to_q31( + float32_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + /** + * @brief Converts the elements of the floating-point vector to Q15 vector. + * @param[in] *pSrc points to the floating-point input vector + * @param[out] *pDst points to the Q15 output vector + * @param[in] blockSize length of the input vector + * @return none + */ + void arm_float_to_q15( + float32_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Converts the elements of the floating-point vector to Q7 vector. + * @param[in] *pSrc points to the floating-point input vector + * @param[out] *pDst points to the Q7 output vector + * @param[in] blockSize length of the input vector + * @return none + */ + void arm_float_to_q7( + float32_t * pSrc, + q7_t * pDst, + uint32_t blockSize); + + + /** + * @brief Converts the elements of the Q31 vector to Q15 vector. + * @param[in] *pSrc is input pointer + * @param[out] *pDst is output pointer + * @param[in] blockSize is the number of samples to process + * @return none. + */ + void arm_q31_to_q15( + q31_t * pSrc, + q15_t * pDst, + uint32_t blockSize); + + /** + * @brief Converts the elements of the Q31 vector to Q7 vector. + * @param[in] *pSrc is input pointer + * @param[out] *pDst is output pointer + * @param[in] blockSize is the number of samples to process + * @return none. + */ + void arm_q31_to_q7( + q31_t * pSrc, + q7_t * pDst, + uint32_t blockSize); + + /** + * @brief Converts the elements of the Q15 vector to floating-point vector. + * @param[in] *pSrc is input pointer + * @param[out] *pDst is output pointer + * @param[in] blockSize is the number of samples to process + * @return none. + */ + void arm_q15_to_float( + q15_t * pSrc, + float32_t * pDst, + uint32_t blockSize); + + + /** + * @brief Converts the elements of the Q15 vector to Q31 vector. + * @param[in] *pSrc is input pointer + * @param[out] *pDst is output pointer + * @param[in] blockSize is the number of samples to process + * @return none. + */ + void arm_q15_to_q31( + q15_t * pSrc, + q31_t * pDst, + uint32_t blockSize); + + + /** + * @brief Converts the elements of the Q15 vector to Q7 vector. + * @param[in] *pSrc is input pointer + * @param[out] *pDst is output pointer + * @param[in] blockSize is the number of samples to process + * @return none. + */ + void arm_q15_to_q7( + q15_t * pSrc, + q7_t * pDst, + uint32_t blockSize); + + + /** + * @ingroup groupInterpolation + */ + + /** + * @defgroup BilinearInterpolate Bilinear Interpolation + * + * Bilinear interpolation is an extension of linear interpolation applied to a two dimensional grid. + * The underlying function f(x, y) is sampled on a regular grid and the interpolation process + * determines values between the grid points. + * Bilinear interpolation is equivalent to two step linear interpolation, first in the x-dimension and then in the y-dimension. + * Bilinear interpolation is often used in image processing to rescale images. + * The CMSIS DSP library provides bilinear interpolation functions for Q7, Q15, Q31, and floating-point data types. + * + * Algorithm + * \par + * The instance structure used by the bilinear interpolation functions describes a two dimensional data table. + * For floating-point, the instance structure is defined as: + * 
      +   *   typedef struct
+   *   {
+   *     uint16_t numRows;
+   *     uint16_t numCols;
+   *     float32_t *pData;
+   * } arm_bilinear_interp_instance_f32;
+   *
      + * + * \par + * where numRows specifies the number of rows in the table; + * numCols specifies the number of columns in the table; + * and pData points to an array of size numRows*numCols values. + * The data table pTable is organized in row order and the supplied data values fall on integer indexes. + * That is, table element (x,y) is located at pTable[x + y*numCols] where x and y are integers. + * + * \par + * Let (x, y) specify the desired interpolation point. Then define: + * 
      +   *     XF = floor(x)
+   *     YF = floor(y)
+   *
      + * \par + * The interpolated output point is computed as: + * 
      +   *  f(x, y) = f(XF, YF) * (1-(x-XF)) * (1-(y-YF))
+   *           + f(XF+1, YF) * (x-XF)*(1-(y-YF))
+   *           + f(XF, YF+1) * (1-(x-XF))*(y-YF)
+   *           + f(XF+1, YF+1) * (x-XF)*(y-YF)
+   *
      + * Note that the coordinates (x, y) contain integer and fractional components. + * The integer components specify which portion of the table to use while the + * fractional components control the interpolation processor. + * + * \par + * if (x,y) are outside of the table boundary, Bilinear interpolation returns zero output. + */ + + /** + * @addtogroup BilinearInterpolate + * @{ + */ + + /** + * + * @brief Floating-point bilinear interpolation. + * @param[in,out] *S points to an instance of the interpolation structure. + * @param[in] X interpolation coordinate. + * @param[in] Y interpolation coordinate. + * @return out interpolated value. + */ + + + static __INLINE float32_t arm_bilinear_interp_f32( + const arm_bilinear_interp_instance_f32 * S, + float32_t X, + float32_t Y) + { + float32_t out; + float32_t f00, f01, f10, f11; + float32_t *pData = S->pData; + int32_t xIndex, yIndex, index; + float32_t xdiff, ydiff; + float32_t b1, b2, b3, b4; + + xIndex = (int32_t) X; + yIndex = (int32_t) Y; + + /* Care taken for table outside boundary */ + /* Returns zero output when values are outside table boundary */ + if(xIndex < 0 || xIndex > (S->numRows - 1) || yIndex < 0 + || yIndex > (S->numCols - 1)) + { + return (0); + } + + /* Calculation of index for two nearest points in X-direction */ + index = (xIndex - 1) + (yIndex - 1) * S->numCols; + + + /* Read two nearest points in X-direction */ + f00 = pData[index]; + f01 = pData[index + 1]; + + /* Calculation of index for two nearest points in Y-direction */ + index = (xIndex - 1) + (yIndex) * S->numCols; + + + /* Read two nearest points in Y-direction */ + f10 = pData[index]; + f11 = pData[index + 1]; + + /* Calculation of intermediate values */ + b1 = f00; + b2 = f01 - f00; + b3 = f10 - f00; + b4 = f00 - f01 - f10 + f11; + + /* Calculation of fractional part in X */ + xdiff = X - xIndex; + + /* Calculation of fractional part in Y */ + ydiff = Y - yIndex; + + /* Calculation of bi-linear interpolated output */ + out = b1 + b2 * xdiff + b3 * ydiff + b4 * xdiff * ydiff; + + /* return to application */ + return (out); + + } + + /** + * + * @brief Q31 bilinear interpolation. + * @param[in,out] *S points to an instance of the interpolation structure. + * @param[in] X interpolation coordinate in 12.20 format. + * @param[in] Y interpolation coordinate in 12.20 format. + * @return out interpolated value. + */ + + static __INLINE q31_t arm_bilinear_interp_q31( + arm_bilinear_interp_instance_q31 * S, + q31_t X, + q31_t Y) + { + q31_t out; /* Temporary output */ + q31_t acc = 0; /* output */ + q31_t xfract, yfract; /* X, Y fractional parts */ + q31_t x1, x2, y1, y2; /* Nearest output values */ + int32_t rI, cI; /* Row and column indices */ + q31_t *pYData = S->pData; /* pointer to output table values */ + uint32_t nCols = S->numCols; /* num of rows */ + + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + rI = ((X & 0xFFF00000) >> 20u); + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + cI = ((Y & 0xFFF00000) >> 20u); + + /* Care taken for table outside boundary */ + /* Returns zero output when values are outside table boundary */ + if(rI < 0 || rI > (S->numRows - 1) || cI < 0 || cI > (S->numCols - 1)) + { + return (0); + } + + /* 20 bits for the fractional part */ + /* shift left xfract by 11 to keep 1.31 format */ + xfract = (X & 0x000FFFFF) << 11u; + + /* Read two nearest output values from the index */ + x1 = pYData[(rI) + nCols * (cI)]; + x2 = pYData[(rI) + nCols * (cI) + 1u]; + + /* 20 bits for the fractional part */ + /* shift left yfract by 11 to keep 1.31 format */ + yfract = (Y & 0x000FFFFF) << 11u; + + /* Read two nearest output values from the index */ + y1 = pYData[(rI) + nCols * (cI + 1)]; + y2 = pYData[(rI) + nCols * (cI + 1) + 1u]; + + /* Calculation of x1 * (1-xfract ) * (1-yfract) and acc is in 3.29(q29) format */ + out = ((q31_t) (((q63_t) x1 * (0x7FFFFFFF - xfract)) >> 32)); + acc = ((q31_t) (((q63_t) out * (0x7FFFFFFF - yfract)) >> 32)); + + /* x2 * (xfract) * (1-yfract) in 3.29(q29) and adding to acc */ + out = ((q31_t) ((q63_t) x2 * (0x7FFFFFFF - yfract) >> 32)); + acc += ((q31_t) ((q63_t) out * (xfract) >> 32)); + + /* y1 * (1 - xfract) * (yfract) in 3.29(q29) and adding to acc */ + out = ((q31_t) ((q63_t) y1 * (0x7FFFFFFF - xfract) >> 32)); + acc += ((q31_t) ((q63_t) out * (yfract) >> 32)); + + /* y2 * (xfract) * (yfract) in 3.29(q29) and adding to acc */ + out = ((q31_t) ((q63_t) y2 * (xfract) >> 32)); + acc += ((q31_t) ((q63_t) out * (yfract) >> 32)); + + /* Convert acc to 1.31(q31) format */ + return (acc << 2u); + + } + + /** + * @brief Q15 bilinear interpolation. + * @param[in,out] *S points to an instance of the interpolation structure. + * @param[in] X interpolation coordinate in 12.20 format. + * @param[in] Y interpolation coordinate in 12.20 format. + * @return out interpolated value. + */ + + static __INLINE q15_t arm_bilinear_interp_q15( + arm_bilinear_interp_instance_q15 * S, + q31_t X, + q31_t Y) + { + q63_t acc = 0; /* output */ + q31_t out; /* Temporary output */ + q15_t x1, x2, y1, y2; /* Nearest output values */ + q31_t xfract, yfract; /* X, Y fractional parts */ + int32_t rI, cI; /* Row and column indices */ + q15_t *pYData = S->pData; /* pointer to output table values */ + uint32_t nCols = S->numCols; /* num of rows */ + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + rI = ((X & 0xFFF00000) >> 20); + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + cI = ((Y & 0xFFF00000) >> 20); + + /* Care taken for table outside boundary */ + /* Returns zero output when values are outside table boundary */ + if(rI < 0 || rI > (S->numRows - 1) || cI < 0 || cI > (S->numCols - 1)) + { + return (0); + } + + /* 20 bits for the fractional part */ + /* xfract should be in 12.20 format */ + xfract = (X & 0x000FFFFF); + + /* Read two nearest output values from the index */ + x1 = pYData[(rI) + nCols * (cI)]; + x2 = pYData[(rI) + nCols * (cI) + 1u]; + + + /* 20 bits for the fractional part */ + /* yfract should be in 12.20 format */ + yfract = (Y & 0x000FFFFF); + + /* Read two nearest output values from the index */ + y1 = pYData[(rI) + nCols * (cI + 1)]; + y2 = pYData[(rI) + nCols * (cI + 1) + 1u]; + + /* Calculation of x1 * (1-xfract ) * (1-yfract) and acc is in 13.51 format */ + + /* x1 is in 1.15(q15), xfract in 12.20 format and out is in 13.35 format */ + /* convert 13.35 to 13.31 by right shifting and out is in 1.31 */ + out = (q31_t) (((q63_t) x1 * (0xFFFFF - xfract)) >> 4u); + acc = ((q63_t) out * (0xFFFFF - yfract)); + + /* x2 * (xfract) * (1-yfract) in 1.51 and adding to acc */ + out = (q31_t) (((q63_t) x2 * (0xFFFFF - yfract)) >> 4u); + acc += ((q63_t) out * (xfract)); + + /* y1 * (1 - xfract) * (yfract) in 1.51 and adding to acc */ + out = (q31_t) (((q63_t) y1 * (0xFFFFF - xfract)) >> 4u); + acc += ((q63_t) out * (yfract)); + + /* y2 * (xfract) * (yfract) in 1.51 and adding to acc */ + out = (q31_t) (((q63_t) y2 * (xfract)) >> 4u); + acc += ((q63_t) out * (yfract)); + + /* acc is in 13.51 format and down shift acc by 36 times */ + /* Convert out to 1.15 format */ + return (acc >> 36); + + } + + /** + * @brief Q7 bilinear interpolation. + * @param[in,out] *S points to an instance of the interpolation structure. + * @param[in] X interpolation coordinate in 12.20 format. + * @param[in] Y interpolation coordinate in 12.20 format. + * @return out interpolated value. + */ + + static __INLINE q7_t arm_bilinear_interp_q7( + arm_bilinear_interp_instance_q7 * S, + q31_t X, + q31_t Y) + { + q63_t acc = 0; /* output */ + q31_t out; /* Temporary output */ + q31_t xfract, yfract; /* X, Y fractional parts */ + q7_t x1, x2, y1, y2; /* Nearest output values */ + int32_t rI, cI; /* Row and column indices */ + q7_t *pYData = S->pData; /* pointer to output table values */ + uint32_t nCols = S->numCols; /* num of rows */ + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + rI = ((X & 0xFFF00000) >> 20); + + /* Input is in 12.20 format */ + /* 12 bits for the table index */ + /* Index value calculation */ + cI = ((Y & 0xFFF00000) >> 20); + + /* Care taken for table outside boundary */ + /* Returns zero output when values are outside table boundary */ + if(rI < 0 || rI > (S->numRows - 1) || cI < 0 || cI > (S->numCols - 1)) + { + return (0); + } + + /* 20 bits for the fractional part */ + /* xfract should be in 12.20 format */ + xfract = (X & 0x000FFFFF); + + /* Read two nearest output values from the index */ + x1 = pYData[(rI) + nCols * (cI)]; + x2 = pYData[(rI) + nCols * (cI) + 1u]; + + + /* 20 bits for the fractional part */ + /* yfract should be in 12.20 format */ + yfract = (Y & 0x000FFFFF); + + /* Read two nearest output values from the index */ + y1 = pYData[(rI) + nCols * (cI + 1)]; + y2 = pYData[(rI) + nCols * (cI + 1) + 1u]; + + /* Calculation of x1 * (1-xfract ) * (1-yfract) and acc is in 16.47 format */ + out = ((x1 * (0xFFFFF - xfract))); + acc = (((q63_t) out * (0xFFFFF - yfract))); + + /* x2 * (xfract) * (1-yfract) in 2.22 and adding to acc */ + out = ((x2 * (0xFFFFF - yfract))); + acc += (((q63_t) out * (xfract))); + + /* y1 * (1 - xfract) * (yfract) in 2.22 and adding to acc */ + out = ((y1 * (0xFFFFF - xfract))); + acc += (((q63_t) out * (yfract))); + + /* y2 * (xfract) * (yfract) in 2.22 and adding to acc */ + out = ((y2 * (yfract))); + acc += (((q63_t) out * (xfract))); + + /* acc in 16.47 format and down shift by 40 to convert to 1.7 format */ + return (acc >> 40); + + } + + /** + * @} end of BilinearInterpolate group + */ + + +#if defined ( __CC_ARM ) //Keil +//SMMLAR + #define multAcc_32x32_keep32_R(a, x, y) \ + a = (q31_t) (((((q63_t) a) << 32) + ((q63_t) x * y) + 0x80000000LL ) >> 32) + +//SMMLSR + #define multSub_32x32_keep32_R(a, x, y) \ + a = (q31_t) (((((q63_t) a) << 32) - ((q63_t) x * y) + 0x80000000LL ) >> 32) + +//SMMULR + #define mult_32x32_keep32_R(a, x, y) \ + a = (q31_t) (((q63_t) x * y + 0x80000000LL ) >> 32) + +//Enter low optimization region - place directly above function definition + #define LOW_OPTIMIZATION_ENTER \ + _Pragma ("push") \ + _Pragma ("O1") + +//Exit low optimization region - place directly after end of function definition + #define LOW_OPTIMIZATION_EXIT \ + _Pragma ("pop") + +//Enter low optimization region - place directly above function definition + #define IAR_ONLY_LOW_OPTIMIZATION_ENTER + +//Exit low optimization region - place directly after end of function definition + #define IAR_ONLY_LOW_OPTIMIZATION_EXIT + +#elif defined(__ICCARM__) //IAR + //SMMLA + #define multAcc_32x32_keep32_R(a, x, y) \ + a += (q31_t) (((q63_t) x * y) >> 32) + + //SMMLS + #define multSub_32x32_keep32_R(a, x, y) \ + a -= (q31_t) (((q63_t) x * y) >> 32) + +//SMMUL + #define mult_32x32_keep32_R(a, x, y) \ + a = (q31_t) (((q63_t) x * y ) >> 32) + +//Enter low optimization region - place directly above function definition + #define LOW_OPTIMIZATION_ENTER \ + _Pragma ("optimize=low") + +//Exit low optimization region - place directly after end of function definition + #define LOW_OPTIMIZATION_EXIT + +//Enter low optimization region - place directly above function definition + #define IAR_ONLY_LOW_OPTIMIZATION_ENTER \ + _Pragma ("optimize=low") + +//Exit low optimization region - place directly after end of function definition + #define IAR_ONLY_LOW_OPTIMIZATION_EXIT + +#elif defined(__GNUC__) + //SMMLA + #define multAcc_32x32_keep32_R(a, x, y) \ + a += (q31_t) (((q63_t) x * y) >> 32) + + //SMMLS + #define multSub_32x32_keep32_R(a, x, y) \ + a -= (q31_t) (((q63_t) x * y) >> 32) + +//SMMUL + #define mult_32x32_keep32_R(a, x, y) \ + a = (q31_t) (((q63_t) x * y ) >> 32) + + #define LOW_OPTIMIZATION_ENTER __attribute__(( optimize("-O1") )) + + #define LOW_OPTIMIZATION_EXIT + + #define IAR_ONLY_LOW_OPTIMIZATION_ENTER + + #define IAR_ONLY_LOW_OPTIMIZATION_EXIT + +#endif + + + + + +#ifdef __cplusplus +} +#endif + + +#endif /* _ARM_MATH_H */ + + +/** + * + * End of file. + */ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/core_cm0.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/core_cm0.h new file mode 100644 index 00000000..1b6b54ef --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/core_cm0.h @@ -0,0 +1,682 @@ +/**************************************************************************//** + * @file core_cm0.h + * @brief CMSIS Cortex-M0 Core Peripheral Access Layer Header File + * @version V3.20 + * @date 25. February 2013 + * + * @note + * + ******************************************************************************/ +/* Copyright (c) 2009 - 2013 ARM LIMITED + + All rights reserved. + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + - Neither the name of ARM nor the names of its contributors may be used + to endorse or promote products derived from this software without + specific prior written permission. + * + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + ---------------------------------------------------------------------------*/ + + +#if defined ( __ICCARM__ ) + #pragma system_include /* treat file as system include file for MISRA check */ +#endif + +#ifdef __cplusplus + extern "C" { +#endif + +#ifndef __CORE_CM0_H_GENERIC +#define __CORE_CM0_H_GENERIC + +/** \page CMSIS_MISRA_Exceptions MISRA-C:2004 Compliance Exceptions + CMSIS violates the following MISRA-C:2004 rules: + + \li Required Rule 8.5, object/function definition in header file.
      + Function definitions in header files are used to allow 'inlining'. + + \li Required Rule 18.4, declaration of union type or object of union type: '{...}'.
      + Unions are used for effective representation of core registers. + + \li Advisory Rule 19.7, Function-like macro defined.
      + Function-like macros are used to allow more efficient code. + */ + + +/******************************************************************************* + * CMSIS definitions + ******************************************************************************/ +/** \ingroup Cortex_M0 + @{ + */ + +/* CMSIS CM0 definitions */ +#define __CM0_CMSIS_VERSION_MAIN (0x03) /*!< [31:16] CMSIS HAL main version */ +#define __CM0_CMSIS_VERSION_SUB (0x20) /*!< [15:0] CMSIS HAL sub version */ +#define __CM0_CMSIS_VERSION ((__CM0_CMSIS_VERSION_MAIN << 16) | \ + __CM0_CMSIS_VERSION_SUB ) /*!< CMSIS HAL version number */ + +#define __CORTEX_M (0x00) /*!< Cortex-M Core */ + + +#if defined ( __CC_ARM ) + #define __ASM __asm /*!< asm keyword for ARM Compiler */ + #define __INLINE __inline /*!< inline keyword for ARM Compiler */ + #define __STATIC_INLINE static __inline + +#elif defined ( __ICCARM__ ) + #define __ASM __asm /*!< asm keyword for IAR Compiler */ + #define __INLINE inline /*!< inline keyword for IAR Compiler. Only available in High optimization mode! */ + #define __STATIC_INLINE static inline + +#elif defined ( __GNUC__ ) + #define __ASM __asm /*!< asm keyword for GNU Compiler */ + #define __INLINE inline /*!< inline keyword for GNU Compiler */ + #define __STATIC_INLINE static inline + +#elif defined ( __TASKING__ ) + #define __ASM __asm /*!< asm keyword for TASKING Compiler */ + #define __INLINE inline /*!< inline keyword for TASKING Compiler */ + #define __STATIC_INLINE static inline + +#endif + +/** __FPU_USED indicates whether an FPU is used or not. This core does not support an FPU at all +*/ +#define __FPU_USED 0 + +#if defined ( __CC_ARM ) + #if defined __TARGET_FPU_VFP + #warning "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __ICCARM__ ) + #if defined __ARMVFP__ + #warning "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __GNUC__ ) + #if defined (__VFP_FP__) && !defined(__SOFTFP__) + #warning "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif + +#elif defined ( __TASKING__ ) + #if defined __FPU_VFP__ + #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" + #endif +#endif + +#include /* standard types definitions */ +#include /* Core Instruction Access */ +#include /* Core Function Access */ + +#endif /* __CORE_CM0_H_GENERIC */ + +#ifndef __CMSIS_GENERIC + +#ifndef __CORE_CM0_H_DEPENDANT +#define __CORE_CM0_H_DEPENDANT + +/* check device defines and use defaults */ +#if defined __CHECK_DEVICE_DEFINES + #ifndef __CM0_REV + #define __CM0_REV 0x0000 + #warning "__CM0_REV not defined in device header file; using default!" + #endif + + #ifndef __NVIC_PRIO_BITS + #define __NVIC_PRIO_BITS 2 + #warning "__NVIC_PRIO_BITS not defined in device header file; using default!" + #endif + + #ifndef __Vendor_SysTickConfig + #define __Vendor_SysTickConfig 0 + #warning "__Vendor_SysTickConfig not defined in device header file; using default!" + #endif +#endif + +/* IO definitions (access restrictions to peripheral registers) */ +/** + \defgroup CMSIS_glob_defs CMSIS Global Defines + + IO Type Qualifiers are used + \li to specify the access to peripheral variables. + \li for automatic generation of peripheral register debug information. +*/ +#ifdef __cplusplus + #define __I volatile /*!< Defines 'read only' permissions */ +#else + #define __I volatile const /*!< Defines 'read only' permissions */ +#endif +#define __O volatile /*!< Defines 'write only' permissions */ +#define __IO volatile /*!< Defines 'read / write' permissions */ + +/*@} end of group Cortex_M0 */ + + + +/******************************************************************************* + * Register Abstraction + Core Register contain: + - Core Register + - Core NVIC Register + - Core SCB Register + - Core SysTick Register + ******************************************************************************/ +/** \defgroup CMSIS_core_register Defines and Type Definitions + \brief Type definitions and defines for Cortex-M processor based devices. +*/ + +/** \ingroup CMSIS_core_register + \defgroup CMSIS_CORE Status and Control Registers + \brief Core Register type definitions. + @{ + */ + +/** \brief Union type to access the Application Program Status Register (APSR). + */ +typedef union +{ + struct + { +#if (__CORTEX_M != 0x04) + uint32_t _reserved0:27; /*!< bit: 0..26 Reserved */ +#else + uint32_t _reserved0:16; /*!< bit: 0..15 Reserved */ + uint32_t GE:4; /*!< bit: 16..19 Greater than or Equal flags */ + uint32_t _reserved1:7; /*!< bit: 20..26 Reserved */ +#endif + uint32_t Q:1; /*!< bit: 27 Saturation condition flag */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} APSR_Type; + + +/** \brief Union type to access the Interrupt Program Status Register (IPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ + uint32_t _reserved0:23; /*!< bit: 9..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} IPSR_Type; + + +/** \brief Union type to access the Special-Purpose Program Status Registers (xPSR). + */ +typedef union +{ + struct + { + uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */ +#if (__CORTEX_M != 0x04) + uint32_t _reserved0:15; /*!< bit: 9..23 Reserved */ +#else + uint32_t _reserved0:7; /*!< bit: 9..15 Reserved */ + uint32_t GE:4; /*!< bit: 16..19 Greater than or Equal flags */ + uint32_t _reserved1:4; /*!< bit: 20..23 Reserved */ +#endif + uint32_t T:1; /*!< bit: 24 Thumb bit (read 0) */ + uint32_t IT:2; /*!< bit: 25..26 saved IT state (read 0) */ + uint32_t Q:1; /*!< bit: 27 Saturation condition flag */ + uint32_t V:1; /*!< bit: 28 Overflow condition code flag */ + uint32_t C:1; /*!< bit: 29 Carry condition code flag */ + uint32_t Z:1; /*!< bit: 30 Zero condition code flag */ + uint32_t N:1; /*!< bit: 31 Negative condition code flag */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} xPSR_Type; + + +/** \brief Union type to access the Control Registers (CONTROL). + */ +typedef union +{ + struct + { + uint32_t nPRIV:1; /*!< bit: 0 Execution privilege in Thread mode */ + uint32_t SPSEL:1; /*!< bit: 1 Stack to be used */ + uint32_t FPCA:1; /*!< bit: 2 FP extension active flag */ + uint32_t _reserved0:29; /*!< bit: 3..31 Reserved */ + } b; /*!< Structure used for bit access */ + uint32_t w; /*!< Type used for word access */ +} CONTROL_Type; + +/*@} end of group CMSIS_CORE */ + + +/** \ingroup CMSIS_core_register + \defgroup CMSIS_NVIC Nested Vectored Interrupt Controller (NVIC) + \brief Type definitions for the NVIC Registers + @{ + */ + +/** \brief Structure type to access the Nested Vectored Interrupt Controller (NVIC). + */ +typedef struct +{ + __IO uint32_t ISER[1]; /*!< Offset: 0x000 (R/W) Interrupt Set Enable Register */ + uint32_t RESERVED0[31]; + __IO uint32_t ICER[1]; /*!< Offset: 0x080 (R/W) Interrupt Clear Enable Register */ + uint32_t RSERVED1[31]; + __IO uint32_t ISPR[1]; /*!< Offset: 0x100 (R/W) Interrupt Set Pending Register */ + uint32_t RESERVED2[31]; + __IO uint32_t ICPR[1]; /*!< Offset: 0x180 (R/W) Interrupt Clear Pending Register */ + uint32_t RESERVED3[31]; + uint32_t RESERVED4[64]; + __IO uint32_t IP[8]; /*!< Offset: 0x300 (R/W) Interrupt Priority Register */ +} NVIC_Type; + +/*@} end of group CMSIS_NVIC */ + + +/** \ingroup CMSIS_core_register + \defgroup CMSIS_SCB System Control Block (SCB) + \brief Type definitions for the System Control Block Registers + @{ + */ + +/** \brief Structure type to access the System Control Block (SCB). + */ +typedef struct +{ + __I uint32_t CPUID; /*!< Offset: 0x000 (R/ ) CPUID Base Register */ + __IO uint32_t ICSR; /*!< Offset: 0x004 (R/W) Interrupt Control and State Register */ + uint32_t RESERVED0; + __IO uint32_t AIRCR; /*!< Offset: 0x00C (R/W) Application Interrupt and Reset Control Register */ + __IO uint32_t SCR; /*!< Offset: 0x010 (R/W) System Control Register */ + __IO uint32_t CCR; /*!< Offset: 0x014 (R/W) Configuration Control Register */ + uint32_t RESERVED1; + __IO uint32_t SHP[2]; /*!< Offset: 0x01C (R/W) System Handlers Priority Registers. [0] is RESERVED */ + __IO uint32_t SHCSR; /*!< Offset: 0x024 (R/W) System Handler Control and State Register */ +} SCB_Type; + +/* SCB CPUID Register Definitions */ +#define SCB_CPUID_IMPLEMENTER_Pos 24 /*!< SCB CPUID: IMPLEMENTER Position */ +#define SCB_CPUID_IMPLEMENTER_Msk (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos) /*!< SCB CPUID: IMPLEMENTER Mask */ + +#define SCB_CPUID_VARIANT_Pos 20 /*!< SCB CPUID: VARIANT Position */ +#define SCB_CPUID_VARIANT_Msk (0xFUL << SCB_CPUID_VARIANT_Pos) /*!< SCB CPUID: VARIANT Mask */ + +#define SCB_CPUID_ARCHITECTURE_Pos 16 /*!< SCB CPUID: ARCHITECTURE Position */ +#define SCB_CPUID_ARCHITECTURE_Msk (0xFUL << SCB_CPUID_ARCHITECTURE_Pos) /*!< SCB CPUID: ARCHITECTURE Mask */ + +#define SCB_CPUID_PARTNO_Pos 4 /*!< SCB CPUID: PARTNO Position */ +#define SCB_CPUID_PARTNO_Msk (0xFFFUL << SCB_CPUID_PARTNO_Pos) /*!< SCB CPUID: PARTNO Mask */ + +#define SCB_CPUID_REVISION_Pos 0 /*!< SCB CPUID: REVISION Position */ +#define SCB_CPUID_REVISION_Msk (0xFUL << SCB_CPUID_REVISION_Pos) /*!< SCB CPUID: REVISION Mask */ + +/* SCB Interrupt Control State Register Definitions */ +#define SCB_ICSR_NMIPENDSET_Pos 31 /*!< SCB ICSR: NMIPENDSET Position */ +#define SCB_ICSR_NMIPENDSET_Msk (1UL << SCB_ICSR_NMIPENDSET_Pos) /*!< SCB ICSR: NMIPENDSET Mask */ + +#define SCB_ICSR_PENDSVSET_Pos 28 /*!< SCB ICSR: PENDSVSET Position */ +#define SCB_ICSR_PENDSVSET_Msk (1UL << SCB_ICSR_PENDSVSET_Pos) /*!< SCB ICSR: PENDSVSET Mask */ + +#define SCB_ICSR_PENDSVCLR_Pos 27 /*!< SCB ICSR: PENDSVCLR Position */ +#define SCB_ICSR_PENDSVCLR_Msk (1UL << SCB_ICSR_PENDSVCLR_Pos) /*!< SCB ICSR: PENDSVCLR Mask */ + +#define SCB_ICSR_PENDSTSET_Pos 26 /*!< SCB ICSR: PENDSTSET Position */ +#define SCB_ICSR_PENDSTSET_Msk (1UL << SCB_ICSR_PENDSTSET_Pos) /*!< SCB ICSR: PENDSTSET Mask */ + +#define SCB_ICSR_PENDSTCLR_Pos 25 /*!< SCB ICSR: PENDSTCLR Position */ +#define SCB_ICSR_PENDSTCLR_Msk (1UL << SCB_ICSR_PENDSTCLR_Pos) /*!< SCB ICSR: PENDSTCLR Mask */ + +#define SCB_ICSR_ISRPREEMPT_Pos 23 /*!< SCB ICSR: ISRPREEMPT Position */ +#define SCB_ICSR_ISRPREEMPT_Msk (1UL << SCB_ICSR_ISRPREEMPT_Pos) /*!< SCB ICSR: ISRPREEMPT Mask */ + +#define SCB_ICSR_ISRPENDING_Pos 22 /*!< SCB ICSR: ISRPENDING Position */ +#define SCB_ICSR_ISRPENDING_Msk (1UL << SCB_ICSR_ISRPENDING_Pos) /*!< SCB ICSR: ISRPENDING Mask */ + +#define SCB_ICSR_VECTPENDING_Pos 12 /*!< SCB ICSR: VECTPENDING Position */ +#define SCB_ICSR_VECTPENDING_Msk (0x1FFUL << SCB_ICSR_VECTPENDING_Pos) /*!< SCB ICSR: VECTPENDING Mask */ + +#define SCB_ICSR_VECTACTIVE_Pos 0 /*!< SCB ICSR: VECTACTIVE Position */ +#define SCB_ICSR_VECTACTIVE_Msk (0x1FFUL << SCB_ICSR_VECTACTIVE_Pos) /*!< SCB ICSR: VECTACTIVE Mask */ + +/* SCB Application Interrupt and Reset Control Register Definitions */ +#define SCB_AIRCR_VECTKEY_Pos 16 /*!< SCB AIRCR: VECTKEY Position */ +#define SCB_AIRCR_VECTKEY_Msk (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos) /*!< SCB AIRCR: VECTKEY Mask */ + +#define SCB_AIRCR_VECTKEYSTAT_Pos 16 /*!< SCB AIRCR: VECTKEYSTAT Position */ +#define SCB_AIRCR_VECTKEYSTAT_Msk (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos) /*!< SCB AIRCR: VECTKEYSTAT Mask */ + +#define SCB_AIRCR_ENDIANESS_Pos 15 /*!< SCB AIRCR: ENDIANESS Position */ +#define SCB_AIRCR_ENDIANESS_Msk (1UL << SCB_AIRCR_ENDIANESS_Pos) /*!< SCB AIRCR: ENDIANESS Mask */ + +#define SCB_AIRCR_SYSRESETREQ_Pos 2 /*!< SCB AIRCR: SYSRESETREQ Position */ +#define SCB_AIRCR_SYSRESETREQ_Msk (1UL << SCB_AIRCR_SYSRESETREQ_Pos) /*!< SCB AIRCR: SYSRESETREQ Mask */ + +#define SCB_AIRCR_VECTCLRACTIVE_Pos 1 /*!< SCB AIRCR: VECTCLRACTIVE Position */ +#define SCB_AIRCR_VECTCLRACTIVE_Msk (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos) /*!< SCB AIRCR: VECTCLRACTIVE Mask */ + +/* SCB System Control Register Definitions */ +#define SCB_SCR_SEVONPEND_Pos 4 /*!< SCB SCR: SEVONPEND Position */ +#define SCB_SCR_SEVONPEND_Msk (1UL << SCB_SCR_SEVONPEND_Pos) /*!< SCB SCR: SEVONPEND Mask */ + +#define SCB_SCR_SLEEPDEEP_Pos 2 /*!< SCB SCR: SLEEPDEEP Position */ +#define SCB_SCR_SLEEPDEEP_Msk (1UL << SCB_SCR_SLEEPDEEP_Pos) /*!< SCB SCR: SLEEPDEEP Mask */ + +#define SCB_SCR_SLEEPONEXIT_Pos 1 /*!< SCB SCR: SLEEPONEXIT Position */ +#define SCB_SCR_SLEEPONEXIT_Msk (1UL << SCB_SCR_SLEEPONEXIT_Pos) /*!< SCB SCR: SLEEPONEXIT Mask */ + +/* SCB Configuration Control Register Definitions */ +#define SCB_CCR_STKALIGN_Pos 9 /*!< SCB CCR: STKALIGN Position */ +#define SCB_CCR_STKALIGN_Msk (1UL << SCB_CCR_STKALIGN_Pos) /*!< SCB CCR: STKALIGN Mask */ + +#define SCB_CCR_UNALIGN_TRP_Pos 3 /*!< SCB CCR: UNALIGN_TRP Position */ +#define SCB_CCR_UNALIGN_TRP_Msk (1UL << SCB_CCR_UNALIGN_TRP_Pos) /*!< SCB CCR: UNALIGN_TRP Mask */ + +/* SCB System Handler Control and State Register Definitions */ +#define SCB_SHCSR_SVCALLPENDED_Pos 15 /*!< SCB SHCSR: SVCALLPENDED Position */ +#define SCB_SHCSR_SVCALLPENDED_Msk (1UL << SCB_SHCSR_SVCALLPENDED_Pos) /*!< SCB SHCSR: SVCALLPENDED Mask */ + +/*@} end of group CMSIS_SCB */ + + +/** \ingroup CMSIS_core_register + \defgroup CMSIS_SysTick System Tick Timer (SysTick) + \brief Type definitions for the System Timer Registers. + @{ + */ + +/** \brief Structure type to access the System Timer (SysTick). + */ +typedef struct +{ + __IO uint32_t CTRL; /*!< Offset: 0x000 (R/W) SysTick Control and Status Register */ + __IO uint32_t LOAD; /*!< Offset: 0x004 (R/W) SysTick Reload Value Register */ + __IO uint32_t VAL; /*!< Offset: 0x008 (R/W) SysTick Current Value Register */ + __I uint32_t CALIB; /*!< Offset: 0x00C (R/ ) SysTick Calibration Register */ +} SysTick_Type; + +/* SysTick Control / Status Register Definitions */ +#define SysTick_CTRL_COUNTFLAG_Pos 16 /*!< SysTick CTRL: COUNTFLAG Position */ +#define SysTick_CTRL_COUNTFLAG_Msk (1UL << SysTick_CTRL_COUNTFLAG_Pos) /*!< SysTick CTRL: COUNTFLAG Mask */ + +#define SysTick_CTRL_CLKSOURCE_Pos 2 /*!< SysTick CTRL: CLKSOURCE Position */ +#define SysTick_CTRL_CLKSOURCE_Msk (1UL << SysTick_CTRL_CLKSOURCE_Pos) /*!< SysTick CTRL: CLKSOURCE Mask */ + +#define SysTick_CTRL_TICKINT_Pos 1 /*!< SysTick CTRL: TICKINT Position */ +#define SysTick_CTRL_TICKINT_Msk (1UL << SysTick_CTRL_TICKINT_Pos) /*!< SysTick CTRL: TICKINT Mask */ + +#define SysTick_CTRL_ENABLE_Pos 0 /*!< SysTick CTRL: ENABLE Position */ +#define SysTick_CTRL_ENABLE_Msk (1UL << SysTick_CTRL_ENABLE_Pos) /*!< SysTick CTRL: ENABLE Mask */ + +/* SysTick Reload Register Definitions */ +#define SysTick_LOAD_RELOAD_Pos 0 /*!< SysTick LOAD: RELOAD Position */ +#define SysTick_LOAD_RELOAD_Msk (0xFFFFFFUL << SysTick_LOAD_RELOAD_Pos) /*!< SysTick LOAD: RELOAD Mask */ + +/* SysTick Current Register Definitions */ +#define SysTick_VAL_CURRENT_Pos 0 /*!< SysTick VAL: CURRENT Position */ +#define SysTick_VAL_CURRENT_Msk (0xFFFFFFUL << SysTick_VAL_CURRENT_Pos) /*!< SysTick VAL: CURRENT Mask */ + +/* SysTick Calibration Register Definitions */ +#define SysTick_CALIB_NOREF_Pos 31 /*!< SysTick CALIB: NOREF Position */ +#define SysTick_CALIB_NOREF_Msk (1UL << SysTick_CALIB_NOREF_Pos) /*!< SysTick CALIB: NOREF Mask */ + +#define SysTick_CALIB_SKEW_Pos 30 /*!< SysTick CALIB: SKEW Position */ +#define SysTick_CALIB_SKEW_Msk (1UL << SysTick_CALIB_SKEW_Pos) /*!< SysTick CALIB: SKEW Mask */ + +#define SysTick_CALIB_TENMS_Pos 0 /*!< SysTick CALIB: TENMS Position */ +#define SysTick_CALIB_TENMS_Msk (0xFFFFFFUL << SysTick_VAL_CURRENT_Pos) /*!< SysTick CALIB: TENMS Mask */ + +/*@} end of group CMSIS_SysTick */ + + +/** \ingroup CMSIS_core_register + \defgroup CMSIS_CoreDebug Core Debug Registers (CoreDebug) + \brief Cortex-M0 Core Debug Registers (DCB registers, SHCSR, and DFSR) + are only accessible over DAP and not via processor. Therefore + they are not covered by the Cortex-M0 header file. + @{ + */ +/*@} end of group CMSIS_CoreDebug */ + + +/** \ingroup CMSIS_core_register + \defgroup CMSIS_core_base Core Definitions + \brief Definitions for base addresses, unions, and structures. + @{ + */ + +/* Memory mapping of Cortex-M0 Hardware */ +#define SCS_BASE (0xE000E000UL) /*!< System Control Space Base Address */ +#define SysTick_BASE (SCS_BASE + 0x0010UL) /*!< SysTick Base Address */ +#define NVIC_BASE (SCS_BASE + 0x0100UL) /*!< NVIC Base Address */ +#define SCB_BASE (SCS_BASE + 0x0D00UL) /*!< System Control Block Base Address */ + +#define SCB ((SCB_Type *) SCB_BASE ) /*!< SCB configuration struct */ +#define SysTick ((SysTick_Type *) SysTick_BASE ) /*!< SysTick configuration struct */ +#define NVIC ((NVIC_Type *) NVIC_BASE ) /*!< NVIC configuration struct */ + + +/*@} */ + + + +/******************************************************************************* + * Hardware Abstraction Layer + Core Function Interface contains: + - Core NVIC Functions + - Core SysTick Functions + - Core Register Access Functions + ******************************************************************************/ +/** \defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference +*/ + + + +/* ########################## NVIC functions #################################### */ +/** \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_NVICFunctions NVIC Functions + \brief Functions that manage interrupts and exceptions via the NVIC. + @{ + */ + +/* Interrupt Priorities are WORD accessible only under ARMv6M */ +/* The following MACROS handle generation of the register offset and byte masks */ +#define _BIT_SHIFT(IRQn) ( (((uint32_t)(IRQn) ) & 0x03) * 8 ) +#define _SHP_IDX(IRQn) ( ((((uint32_t)(IRQn) & 0x0F)-8) >> 2) ) +#define _IP_IDX(IRQn) ( ((uint32_t)(IRQn) >> 2) ) + + +/** \brief Enable External Interrupt + + The function enables a device-specific interrupt in the NVIC interrupt controller. + + \param [in] IRQn External interrupt number. Value cannot be negative. + */ +__STATIC_INLINE void NVIC_EnableIRQ(IRQn_Type IRQn) +{ + NVIC->ISER[0] = (1 << ((uint32_t)(IRQn) & 0x1F)); +} + + +/** \brief Disable External Interrupt + + The function disables a device-specific interrupt in the NVIC interrupt controller. + + \param [in] IRQn External interrupt number. Value cannot be negative. + */ +__STATIC_INLINE void NVIC_DisableIRQ(IRQn_Type IRQn) +{ + NVIC->ICER[0] = (1 << ((uint32_t)(IRQn) & 0x1F)); +} + + +/** \brief Get Pending Interrupt + + The function reads the pending register in the NVIC and returns the pending bit + for the specified interrupt. + + \param [in] IRQn Interrupt number. + + \return 0 Interrupt status is not pending. + \return 1 Interrupt status is pending. + */ +__STATIC_INLINE uint32_t NVIC_GetPendingIRQ(IRQn_Type IRQn) +{ + return((uint32_t) ((NVIC->ISPR[0] & (1 << ((uint32_t)(IRQn) & 0x1F)))?1:0)); +} + + +/** \brief Set Pending Interrupt + + The function sets the pending bit of an external interrupt. + + \param [in] IRQn Interrupt number. Value cannot be negative. + */ +__STATIC_INLINE void NVIC_SetPendingIRQ(IRQn_Type IRQn) +{ + NVIC->ISPR[0] = (1 << ((uint32_t)(IRQn) & 0x1F)); +} + + +/** \brief Clear Pending Interrupt + + The function clears the pending bit of an external interrupt. + + \param [in] IRQn External interrupt number. Value cannot be negative. + */ +__STATIC_INLINE void NVIC_ClearPendingIRQ(IRQn_Type IRQn) +{ + NVIC->ICPR[0] = (1 << ((uint32_t)(IRQn) & 0x1F)); /* Clear pending interrupt */ +} + + +/** \brief Set Interrupt Priority + + The function sets the priority of an interrupt. + + \note The priority cannot be set for every core interrupt. + + \param [in] IRQn Interrupt number. + \param [in] priority Priority to set. + */ +__STATIC_INLINE void NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority) +{ + if(IRQn < 0) { + SCB->SHP[_SHP_IDX(IRQn)] = (SCB->SHP[_SHP_IDX(IRQn)] & ~(0xFF << _BIT_SHIFT(IRQn))) | + (((priority << (8 - __NVIC_PRIO_BITS)) & 0xFF) << _BIT_SHIFT(IRQn)); } + else { + NVIC->IP[_IP_IDX(IRQn)] = (NVIC->IP[_IP_IDX(IRQn)] & ~(0xFF << _BIT_SHIFT(IRQn))) | + (((priority << (8 - __NVIC_PRIO_BITS)) & 0xFF) << _BIT_SHIFT(IRQn)); } +} + + +/** \brief Get Interrupt Priority + + The function reads the priority of an interrupt. The interrupt + number can be positive to specify an external (device specific) + interrupt, or negative to specify an internal (core) interrupt. + + + \param [in] IRQn Interrupt number. + \return Interrupt Priority. Value is aligned automatically to the implemented + priority bits of the microcontroller. + */ +__STATIC_INLINE uint32_t NVIC_GetPriority(IRQn_Type IRQn) +{ + + if(IRQn < 0) { + return((uint32_t)(((SCB->SHP[_SHP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & 0xFF) >> (8 - __NVIC_PRIO_BITS))); } /* get priority for Cortex-M0 system interrupts */ + else { + return((uint32_t)(((NVIC->IP[ _IP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & 0xFF) >> (8 - __NVIC_PRIO_BITS))); } /* get priority for device specific interrupts */ +} + + +/** \brief System Reset + + The function initiates a system reset request to reset the MCU. + */ +__STATIC_INLINE void NVIC_SystemReset(void) +{ + __DSB(); /* Ensure all outstanding memory accesses included + buffered write are completed before reset */ + SCB->AIRCR = ((0x5FA << SCB_AIRCR_VECTKEY_Pos) | + SCB_AIRCR_SYSRESETREQ_Msk); + __DSB(); /* Ensure completion of memory access */ + while(1); /* wait until reset */ +} + +/*@} end of CMSIS_Core_NVICFunctions */ + + + +/* ################################## SysTick function ############################################ */ +/** \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_SysTickFunctions SysTick Functions + \brief Functions that configure the System. + @{ + */ + +#if (__Vendor_SysTickConfig == 0) + +/** \brief System Tick Configuration + + The function initializes the System Timer and its interrupt, and starts the System Tick Timer. + Counter is in free running mode to generate periodic interrupts. + + \param [in] ticks Number of ticks between two interrupts. + + \return 0 Function succeeded. + \return 1 Function failed. + + \note When the variable __Vendor_SysTickConfig is set to 1, then the + function SysTick_Config is not included. In this case, the file device.h + must contain a vendor-specific implementation of this function. + + */ +__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks) +{ + if ((ticks - 1) > SysTick_LOAD_RELOAD_Msk) return (1); /* Reload value impossible */ + + SysTick->LOAD = ticks - 1; /* set reload register */ + NVIC_SetPriority (SysTick_IRQn, (1<<__NVIC_PRIO_BITS) - 1); /* set Priority for Systick Interrupt */ + SysTick->VAL = 0; /* Load the SysTick Counter Value */ + SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk | + SysTick_CTRL_TICKINT_Msk | + SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */ + return (0); /* Function successful */ +} + +#endif + +/*@} end of CMSIS_Core_SysTickFunctions */ + + + + +#endif /* __CORE_CM0_H_DEPENDANT */ + +#endif /* __CMSIS_GENERIC */ + +#ifdef __cplusplus +} +#endif diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/core_cmFunc.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/core_cmFunc.h new file mode 100644 index 00000000..139bc3c5 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/core_cmFunc.h @@ -0,0 +1,636 @@ +/**************************************************************************//** + * @file core_cmFunc.h + * @brief CMSIS Cortex-M Core Function Access Header File + * @version V3.20 + * @date 25. February 2013 + * + * @note + * + ******************************************************************************/ +/* Copyright (c) 2009 - 2013 ARM LIMITED + + All rights reserved. + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + - Neither the name of ARM nor the names of its contributors may be used + to endorse or promote products derived from this software without + specific prior written permission. + * + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + ---------------------------------------------------------------------------*/ + + +#ifndef __CORE_CMFUNC_H +#define __CORE_CMFUNC_H + + +/* ########################### Core Function Access ########################### */ +/** \ingroup CMSIS_Core_FunctionInterface + \defgroup CMSIS_Core_RegAccFunctions CMSIS Core Register Access Functions + @{ + */ + +#if defined ( __CC_ARM ) /*------------------RealView Compiler -----------------*/ +/* ARM armcc specific functions */ + +#if (__ARMCC_VERSION < 400677) + #error "Please use ARM Compiler Toolchain V4.0.677 or later!" +#endif + +/* intrinsic void __enable_irq(); */ +/* intrinsic void __disable_irq(); */ + +/** \brief Get Control Register + + This function returns the content of the Control Register. + + \return Control Register value + */ +__STATIC_INLINE uint32_t __get_CONTROL(void) +{ + register uint32_t __regControl __ASM("control"); + return(__regControl); +} + + +/** \brief Set Control Register + + This function writes the given value to the Control Register. + + \param [in] control Control Register value to set + */ +__STATIC_INLINE void __set_CONTROL(uint32_t control) +{ + register uint32_t __regControl __ASM("control"); + __regControl = control; +} + + +/** \brief Get IPSR Register + + This function returns the content of the IPSR Register. + + \return IPSR Register value + */ +__STATIC_INLINE uint32_t __get_IPSR(void) +{ + register uint32_t __regIPSR __ASM("ipsr"); + return(__regIPSR); +} + + +/** \brief Get APSR Register + + This function returns the content of the APSR Register. + + \return APSR Register value + */ +__STATIC_INLINE uint32_t __get_APSR(void) +{ + register uint32_t __regAPSR __ASM("apsr"); + return(__regAPSR); +} + + +/** \brief Get xPSR Register + + This function returns the content of the xPSR Register. + + \return xPSR Register value + */ +__STATIC_INLINE uint32_t __get_xPSR(void) +{ + register uint32_t __regXPSR __ASM("xpsr"); + return(__regXPSR); +} + + +/** \brief Get Process Stack Pointer + + This function returns the current value of the Process Stack Pointer (PSP). + + \return PSP Register value + */ +__STATIC_INLINE uint32_t __get_PSP(void) +{ + register uint32_t __regProcessStackPointer __ASM("psp"); + return(__regProcessStackPointer); +} + + +/** \brief Set Process Stack Pointer + + This function assigns the given value to the Process Stack Pointer (PSP). + + \param [in] topOfProcStack Process Stack Pointer value to set + */ +__STATIC_INLINE void __set_PSP(uint32_t topOfProcStack) +{ + register uint32_t __regProcessStackPointer __ASM("psp"); + __regProcessStackPointer = topOfProcStack; +} + + +/** \brief Get Main Stack Pointer + + This function returns the current value of the Main Stack Pointer (MSP). + + \return MSP Register value + */ +__STATIC_INLINE uint32_t __get_MSP(void) +{ + register uint32_t __regMainStackPointer __ASM("msp"); + return(__regMainStackPointer); +} + + +/** \brief Set Main Stack Pointer + + This function assigns the given value to the Main Stack Pointer (MSP). + + \param [in] topOfMainStack Main Stack Pointer value to set + */ +__STATIC_INLINE void __set_MSP(uint32_t topOfMainStack) +{ + register uint32_t __regMainStackPointer __ASM("msp"); + __regMainStackPointer = topOfMainStack; +} + + +/** \brief Get Priority Mask + + This function returns the current state of the priority mask bit from the Priority Mask Register. + + \return Priority Mask value + */ +__STATIC_INLINE uint32_t __get_PRIMASK(void) +{ + register uint32_t __regPriMask __ASM("primask"); + return(__regPriMask); +} + + +/** \brief Set Priority Mask + + This function assigns the given value to the Priority Mask Register. + + \param [in] priMask Priority Mask + */ +__STATIC_INLINE void __set_PRIMASK(uint32_t priMask) +{ + register uint32_t __regPriMask __ASM("primask"); + __regPriMask = (priMask); +} + + +#if (__CORTEX_M >= 0x03) + +/** \brief Enable FIQ + + This function enables FIQ interrupts by clearing the F-bit in the CPSR. + Can only be executed in Privileged modes. + */ +#define __enable_fault_irq __enable_fiq + + +/** \brief Disable FIQ + + This function disables FIQ interrupts by setting the F-bit in the CPSR. + Can only be executed in Privileged modes. + */ +#define __disable_fault_irq __disable_fiq + + +/** \brief Get Base Priority + + This function returns the current value of the Base Priority register. + + \return Base Priority register value + */ +__STATIC_INLINE uint32_t __get_BASEPRI(void) +{ + register uint32_t __regBasePri __ASM("basepri"); + return(__regBasePri); +} + + +/** \brief Set Base Priority + + This function assigns the given value to the Base Priority register. + + \param [in] basePri Base Priority value to set + */ +__STATIC_INLINE void __set_BASEPRI(uint32_t basePri) +{ + register uint32_t __regBasePri __ASM("basepri"); + __regBasePri = (basePri & 0xff); +} + + +/** \brief Get Fault Mask + + This function returns the current value of the Fault Mask register. + + \return Fault Mask register value + */ +__STATIC_INLINE uint32_t __get_FAULTMASK(void) +{ + register uint32_t __regFaultMask __ASM("faultmask"); + return(__regFaultMask); +} + + +/** \brief Set Fault Mask + + This function assigns the given value to the Fault Mask register. + + \param [in] faultMask Fault Mask value to set + */ +__STATIC_INLINE void __set_FAULTMASK(uint32_t faultMask) +{ + register uint32_t __regFaultMask __ASM("faultmask"); + __regFaultMask = (faultMask & (uint32_t)1); +} + +#endif /* (__CORTEX_M >= 0x03) */ + + +#if (__CORTEX_M == 0x04) + +/** \brief Get FPSCR + + This function returns the current value of the Floating Point Status/Control register. + + \return Floating Point Status/Control register value + */ +__STATIC_INLINE uint32_t __get_FPSCR(void) +{ +#if (__FPU_PRESENT == 1) && (__FPU_USED == 1) + register uint32_t __regfpscr __ASM("fpscr"); + return(__regfpscr); +#else + return(0); +#endif +} + + +/** \brief Set FPSCR + + This function assigns the given value to the Floating Point Status/Control register. + + \param [in] fpscr Floating Point Status/Control value to set + */ +__STATIC_INLINE void __set_FPSCR(uint32_t fpscr) +{ +#if (__FPU_PRESENT == 1) && (__FPU_USED == 1) + register uint32_t __regfpscr __ASM("fpscr"); + __regfpscr = (fpscr); +#endif +} + +#endif /* (__CORTEX_M == 0x04) */ + + +#elif defined ( __ICCARM__ ) /*------------------ ICC Compiler -------------------*/ +/* IAR iccarm specific functions */ + +#include + + +#elif defined ( __TMS470__ ) /*---------------- TI CCS Compiler ------------------*/ +/* TI CCS specific functions */ + +#include + + +#elif defined ( __GNUC__ ) /*------------------ GNU Compiler ---------------------*/ +/* GNU gcc specific functions */ + +/** \brief Enable IRQ Interrupts + + This function enables IRQ interrupts by clearing the I-bit in the CPSR. + Can only be executed in Privileged modes. + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __enable_irq(void) +{ + __ASM volatile ("cpsie i" : : : "memory"); +} + + +/** \brief Disable IRQ Interrupts + + This function disables IRQ interrupts by setting the I-bit in the CPSR. + Can only be executed in Privileged modes. + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __disable_irq(void) +{ + __ASM volatile ("cpsid i" : : : "memory"); +} + + +/** \brief Get Control Register + + This function returns the content of the Control Register. + + \return Control Register value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_CONTROL(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, control" : "=r" (result) ); + return(result); +} + + +/** \brief Set Control Register + + This function writes the given value to the Control Register. + + \param [in] control Control Register value to set + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __set_CONTROL(uint32_t control) +{ + __ASM volatile ("MSR control, %0" : : "r" (control) : "memory"); +} + + +/** \brief Get IPSR Register + + This function returns the content of the IPSR Register. + + \return IPSR Register value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_IPSR(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, ipsr" : "=r" (result) ); + return(result); +} + + +/** \brief Get APSR Register + + This function returns the content of the APSR Register. + + \return APSR Register value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_APSR(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, apsr" : "=r" (result) ); + return(result); +} + + +/** \brief Get xPSR Register + + This function returns the content of the xPSR Register. + + \return xPSR Register value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_xPSR(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, xpsr" : "=r" (result) ); + return(result); +} + + +/** \brief Get Process Stack Pointer + + This function returns the current value of the Process Stack Pointer (PSP). + + \return PSP Register value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_PSP(void) +{ + register uint32_t result; + + __ASM volatile ("MRS %0, psp\n" : "=r" (result) ); + return(result); +} + + +/** \brief Set Process Stack Pointer + + This function assigns the given value to the Process Stack Pointer (PSP). + + \param [in] topOfProcStack Process Stack Pointer value to set + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __set_PSP(uint32_t topOfProcStack) +{ + __ASM volatile ("MSR psp, %0\n" : : "r" (topOfProcStack) : "sp"); +} + + +/** \brief Get Main Stack Pointer + + This function returns the current value of the Main Stack Pointer (MSP). + + \return MSP Register value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_MSP(void) +{ + register uint32_t result; + + __ASM volatile ("MRS %0, msp\n" : "=r" (result) ); + return(result); +} + + +/** \brief Set Main Stack Pointer + + This function assigns the given value to the Main Stack Pointer (MSP). + + \param [in] topOfMainStack Main Stack Pointer value to set + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __set_MSP(uint32_t topOfMainStack) +{ + __ASM volatile ("MSR msp, %0\n" : : "r" (topOfMainStack) : "sp"); +} + + +/** \brief Get Priority Mask + + This function returns the current state of the priority mask bit from the Priority Mask Register. + + \return Priority Mask value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_PRIMASK(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, primask" : "=r" (result) ); + return(result); +} + + +/** \brief Set Priority Mask + + This function assigns the given value to the Priority Mask Register. + + \param [in] priMask Priority Mask + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __set_PRIMASK(uint32_t priMask) +{ + __ASM volatile ("MSR primask, %0" : : "r" (priMask) : "memory"); +} + + +#if (__CORTEX_M >= 0x03) + +/** \brief Enable FIQ + + This function enables FIQ interrupts by clearing the F-bit in the CPSR. + Can only be executed in Privileged modes. + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __enable_fault_irq(void) +{ + __ASM volatile ("cpsie f" : : : "memory"); +} + + +/** \brief Disable FIQ + + This function disables FIQ interrupts by setting the F-bit in the CPSR. + Can only be executed in Privileged modes. + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __disable_fault_irq(void) +{ + __ASM volatile ("cpsid f" : : : "memory"); +} + + +/** \brief Get Base Priority + + This function returns the current value of the Base Priority register. + + \return Base Priority register value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_BASEPRI(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, basepri_max" : "=r" (result) ); + return(result); +} + + +/** \brief Set Base Priority + + This function assigns the given value to the Base Priority register. + + \param [in] basePri Base Priority value to set + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __set_BASEPRI(uint32_t value) +{ + __ASM volatile ("MSR basepri, %0" : : "r" (value) : "memory"); +} + + +/** \brief Get Fault Mask + + This function returns the current value of the Fault Mask register. + + \return Fault Mask register value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_FAULTMASK(void) +{ + uint32_t result; + + __ASM volatile ("MRS %0, faultmask" : "=r" (result) ); + return(result); +} + + +/** \brief Set Fault Mask + + This function assigns the given value to the Fault Mask register. + + \param [in] faultMask Fault Mask value to set + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __set_FAULTMASK(uint32_t faultMask) +{ + __ASM volatile ("MSR faultmask, %0" : : "r" (faultMask) : "memory"); +} + +#endif /* (__CORTEX_M >= 0x03) */ + + +#if (__CORTEX_M == 0x04) + +/** \brief Get FPSCR + + This function returns the current value of the Floating Point Status/Control register. + + \return Floating Point Status/Control register value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_FPSCR(void) +{ +#if (__FPU_PRESENT == 1) && (__FPU_USED == 1) + uint32_t result; + + /* Empty asm statement works as a scheduling barrier */ + __ASM volatile (""); + __ASM volatile ("VMRS %0, fpscr" : "=r" (result) ); + __ASM volatile (""); + return(result); +#else + return(0); +#endif +} + + +/** \brief Set FPSCR + + This function assigns the given value to the Floating Point Status/Control register. + + \param [in] fpscr Floating Point Status/Control value to set + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __set_FPSCR(uint32_t fpscr) +{ +#if (__FPU_PRESENT == 1) && (__FPU_USED == 1) + /* Empty asm statement works as a scheduling barrier */ + __ASM volatile (""); + __ASM volatile ("VMSR fpscr, %0" : : "r" (fpscr) : "vfpcc"); + __ASM volatile (""); +#endif +} + +#endif /* (__CORTEX_M == 0x04) */ + + +#elif defined ( __TASKING__ ) /*------------------ TASKING Compiler --------------*/ +/* TASKING carm specific functions */ + +/* + * The CMSIS functions have been implemented as intrinsics in the compiler. + * Please use "carm -?i" to get an up to date list of all instrinsics, + * Including the CMSIS ones. + */ + +#endif + +/*@} end of CMSIS_Core_RegAccFunctions */ + + +#endif /* __CORE_CMFUNC_H */ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/core_cmInstr.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/core_cmInstr.h new file mode 100644 index 00000000..8946c2c4 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/cmsis/core_cmInstr.h @@ -0,0 +1,688 @@ +/**************************************************************************//** + * @file core_cmInstr.h + * @brief CMSIS Cortex-M Core Instruction Access Header File + * @version V3.20 + * @date 05. March 2013 + * + * @note + * + ******************************************************************************/ +/* Copyright (c) 2009 - 2013 ARM LIMITED + + All rights reserved. + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + - Neither the name of ARM nor the names of its contributors may be used + to endorse or promote products derived from this software without + specific prior written permission. + * + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + ---------------------------------------------------------------------------*/ + + +#ifndef __CORE_CMINSTR_H +#define __CORE_CMINSTR_H + + +/* ########################## Core Instruction Access ######################### */ +/** \defgroup CMSIS_Core_InstructionInterface CMSIS Core Instruction Interface + Access to dedicated instructions + @{ +*/ + +#if defined ( __CC_ARM ) /*------------------RealView Compiler -----------------*/ +/* ARM armcc specific functions */ + +#if (__ARMCC_VERSION < 400677) + #error "Please use ARM Compiler Toolchain V4.0.677 or later!" +#endif + + +/** \brief No Operation + + No Operation does nothing. This instruction can be used for code alignment purposes. + */ +#define __NOP __nop + + +/** \brief Wait For Interrupt + + Wait For Interrupt is a hint instruction that suspends execution + until one of a number of events occurs. + */ +#define __WFI __wfi + + +/** \brief Wait For Event + + Wait For Event is a hint instruction that permits the processor to enter + a low-power state until one of a number of events occurs. + */ +#define __WFE __wfe + + +/** \brief Send Event + + Send Event is a hint instruction. It causes an event to be signaled to the CPU. + */ +#define __SEV __sev + + +/** \brief Instruction Synchronization Barrier + + Instruction Synchronization Barrier flushes the pipeline in the processor, + so that all instructions following the ISB are fetched from cache or + memory, after the instruction has been completed. + */ +#define __ISB() __isb(0xF) + + +/** \brief Data Synchronization Barrier + + This function acts as a special kind of Data Memory Barrier. + It completes when all explicit memory accesses before this instruction complete. + */ +#define __DSB() __dsb(0xF) + + +/** \brief Data Memory Barrier + + This function ensures the apparent order of the explicit memory operations before + and after the instruction, without ensuring their completion. + */ +#define __DMB() __dmb(0xF) + + +/** \brief Reverse byte order (32 bit) + + This function reverses the byte order in integer value. + + \param [in] value Value to reverse + \return Reversed value + */ +#define __REV __rev + + +/** \brief Reverse byte order (16 bit) + + This function reverses the byte order in two unsigned short values. + + \param [in] value Value to reverse + \return Reversed value + */ +#ifndef __NO_EMBEDDED_ASM +__attribute__((section(".rev16_text"))) __STATIC_INLINE __ASM uint32_t __REV16(uint32_t value) +{ + rev16 r0, r0 + bx lr +} +#endif + +/** \brief Reverse byte order in signed short value + + This function reverses the byte order in a signed short value with sign extension to integer. + + \param [in] value Value to reverse + \return Reversed value + */ +#ifndef __NO_EMBEDDED_ASM +__attribute__((section(".revsh_text"))) __STATIC_INLINE __ASM int32_t __REVSH(int32_t value) +{ + revsh r0, r0 + bx lr +} +#endif + + +/** \brief Rotate Right in unsigned value (32 bit) + + This function Rotate Right (immediate) provides the value of the contents of a register rotated by a variable number of bits. + + \param [in] value Value to rotate + \param [in] value Number of Bits to rotate + \return Rotated value + */ +#define __ROR __ror + + +/** \brief Breakpoint + + This function causes the processor to enter Debug state. + Debug tools can use this to investigate system state when the instruction at a particular address is reached. + + \param [in] value is ignored by the processor. + If required, a debugger can use it to store additional information about the breakpoint. + */ +#define __BKPT(value) __breakpoint(value) + + +#if (__CORTEX_M >= 0x03) + +/** \brief Reverse bit order of value + + This function reverses the bit order of the given value. + + \param [in] value Value to reverse + \return Reversed value + */ +#define __RBIT __rbit + + +/** \brief LDR Exclusive (8 bit) + + This function performs a exclusive LDR command for 8 bit value. + + \param [in] ptr Pointer to data + \return value of type uint8_t at (*ptr) + */ +#define __LDREXB(ptr) ((uint8_t ) __ldrex(ptr)) + + +/** \brief LDR Exclusive (16 bit) + + This function performs a exclusive LDR command for 16 bit values. + + \param [in] ptr Pointer to data + \return value of type uint16_t at (*ptr) + */ +#define __LDREXH(ptr) ((uint16_t) __ldrex(ptr)) + + +/** \brief LDR Exclusive (32 bit) + + This function performs a exclusive LDR command for 32 bit values. + + \param [in] ptr Pointer to data + \return value of type uint32_t at (*ptr) + */ +#define __LDREXW(ptr) ((uint32_t ) __ldrex(ptr)) + + +/** \brief STR Exclusive (8 bit) + + This function performs a exclusive STR command for 8 bit values. + + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +#define __STREXB(value, ptr) __strex(value, ptr) + + +/** \brief STR Exclusive (16 bit) + + This function performs a exclusive STR command for 16 bit values. + + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +#define __STREXH(value, ptr) __strex(value, ptr) + + +/** \brief STR Exclusive (32 bit) + + This function performs a exclusive STR command for 32 bit values. + + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +#define __STREXW(value, ptr) __strex(value, ptr) + + +/** \brief Remove the exclusive lock + + This function removes the exclusive lock which is created by LDREX. + + */ +#define __CLREX __clrex + + +/** \brief Signed Saturate + + This function saturates a signed value. + + \param [in] value Value to be saturated + \param [in] sat Bit position to saturate to (1..32) + \return Saturated value + */ +#define __SSAT __ssat + + +/** \brief Unsigned Saturate + + This function saturates an unsigned value. + + \param [in] value Value to be saturated + \param [in] sat Bit position to saturate to (0..31) + \return Saturated value + */ +#define __USAT __usat + + +/** \brief Count leading zeros + + This function counts the number of leading zeros of a data value. + + \param [in] value Value to count the leading zeros + \return number of leading zeros in value + */ +#define __CLZ __clz + +#endif /* (__CORTEX_M >= 0x03) */ + + + +#elif defined ( __ICCARM__ ) /*------------------ ICC Compiler -------------------*/ +/* IAR iccarm specific functions */ + +#include + + +#elif defined ( __TMS470__ ) /*---------------- TI CCS Compiler ------------------*/ +/* TI CCS specific functions */ + +#include + + +#elif defined ( __GNUC__ ) /*------------------ GNU Compiler ---------------------*/ +/* GNU gcc specific functions */ + +/* Define macros for porting to both thumb1 and thumb2. + * For thumb1, use low register (r0-r7), specified by constrant "l" + * Otherwise, use general registers, specified by constrant "r" */ +#if defined (__thumb__) && !defined (__thumb2__) +#define __CMSIS_GCC_OUT_REG(r) "=l" (r) +#define __CMSIS_GCC_USE_REG(r) "l" (r) +#else +#define __CMSIS_GCC_OUT_REG(r) "=r" (r) +#define __CMSIS_GCC_USE_REG(r) "r" (r) +#endif + +/** \brief No Operation + + No Operation does nothing. This instruction can be used for code alignment purposes. + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __NOP(void) +{ + __ASM volatile ("nop"); +} + + +/** \brief Wait For Interrupt + + Wait For Interrupt is a hint instruction that suspends execution + until one of a number of events occurs. + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __WFI(void) +{ + __ASM volatile ("wfi"); +} + + +/** \brief Wait For Event + + Wait For Event is a hint instruction that permits the processor to enter + a low-power state until one of a number of events occurs. + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __WFE(void) +{ + __ASM volatile ("wfe"); +} + + +/** \brief Send Event + + Send Event is a hint instruction. It causes an event to be signaled to the CPU. + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __SEV(void) +{ + __ASM volatile ("sev"); +} + + +/** \brief Instruction Synchronization Barrier + + Instruction Synchronization Barrier flushes the pipeline in the processor, + so that all instructions following the ISB are fetched from cache or + memory, after the instruction has been completed. + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __ISB(void) +{ + __ASM volatile ("isb"); +} + + +/** \brief Data Synchronization Barrier + + This function acts as a special kind of Data Memory Barrier. + It completes when all explicit memory accesses before this instruction complete. + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __DSB(void) +{ + __ASM volatile ("dsb"); +} + + +/** \brief Data Memory Barrier + + This function ensures the apparent order of the explicit memory operations before + and after the instruction, without ensuring their completion. + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __DMB(void) +{ + __ASM volatile ("dmb"); +} + + +/** \brief Reverse byte order (32 bit) + + This function reverses the byte order in integer value. + + \param [in] value Value to reverse + \return Reversed value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __REV(uint32_t value) +{ +#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5) + return __builtin_bswap32(value); +#else + uint32_t result; + + __ASM volatile ("rev %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) ); + return(result); +#endif +} + + +/** \brief Reverse byte order (16 bit) + + This function reverses the byte order in two unsigned short values. + + \param [in] value Value to reverse + \return Reversed value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __REV16(uint32_t value) +{ + uint32_t result; + + __ASM volatile ("rev16 %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) ); + return(result); +} + + +/** \brief Reverse byte order in signed short value + + This function reverses the byte order in a signed short value with sign extension to integer. + + \param [in] value Value to reverse + \return Reversed value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE int32_t __REVSH(int32_t value) +{ +#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8) + return (short)__builtin_bswap16(value); +#else + uint32_t result; + + __ASM volatile ("revsh %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) ); + return(result); +#endif +} + + +/** \brief Rotate Right in unsigned value (32 bit) + + This function Rotate Right (immediate) provides the value of the contents of a register rotated by a variable number of bits. + + \param [in] value Value to rotate + \param [in] value Number of Bits to rotate + \return Rotated value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __ROR(uint32_t op1, uint32_t op2) +{ + return (op1 >> op2) | (op1 << (32 - op2)); +} + + +/** \brief Breakpoint + + This function causes the processor to enter Debug state. + Debug tools can use this to investigate system state when the instruction at a particular address is reached. + + \param [in] value is ignored by the processor. + If required, a debugger can use it to store additional information about the breakpoint. + */ +#define __BKPT(value) __ASM volatile ("bkpt "#value) + + +#if (__CORTEX_M >= 0x03) + +/** \brief Reverse bit order of value + + This function reverses the bit order of the given value. + + \param [in] value Value to reverse + \return Reversed value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __RBIT(uint32_t value) +{ + uint32_t result; + + __ASM volatile ("rbit %0, %1" : "=r" (result) : "r" (value) ); + return(result); +} + + +/** \brief LDR Exclusive (8 bit) + + This function performs a exclusive LDR command for 8 bit value. + + \param [in] ptr Pointer to data + \return value of type uint8_t at (*ptr) + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint8_t __LDREXB(volatile uint8_t *addr) +{ + uint32_t result; + +#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8) + __ASM volatile ("ldrexb %0, %1" : "=r" (result) : "Q" (*addr) ); +#else + /* Prior to GCC 4.8, "Q" will be expanded to [rx, #0] which is not + accepted by assembler. So has to use following less efficient pattern. + */ + __ASM volatile ("ldrexb %0, [%1]" : "=r" (result) : "r" (addr) : "memory" ); +#endif + return(result); +} + + +/** \brief LDR Exclusive (16 bit) + + This function performs a exclusive LDR command for 16 bit values. + + \param [in] ptr Pointer to data + \return value of type uint16_t at (*ptr) + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint16_t __LDREXH(volatile uint16_t *addr) +{ + uint32_t result; + +#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8) + __ASM volatile ("ldrexh %0, %1" : "=r" (result) : "Q" (*addr) ); +#else + /* Prior to GCC 4.8, "Q" will be expanded to [rx, #0] which is not + accepted by assembler. So has to use following less efficient pattern. + */ + __ASM volatile ("ldrexh %0, [%1]" : "=r" (result) : "r" (addr) : "memory" ); +#endif + return(result); +} + + +/** \brief LDR Exclusive (32 bit) + + This function performs a exclusive LDR command for 32 bit values. + + \param [in] ptr Pointer to data + \return value of type uint32_t at (*ptr) + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __LDREXW(volatile uint32_t *addr) +{ + uint32_t result; + + __ASM volatile ("ldrex %0, %1" : "=r" (result) : "Q" (*addr) ); + return(result); +} + + +/** \brief STR Exclusive (8 bit) + + This function performs a exclusive STR command for 8 bit values. + + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __STREXB(uint8_t value, volatile uint8_t *addr) +{ + uint32_t result; + + __ASM volatile ("strexb %0, %2, %1" : "=&r" (result), "=Q" (*addr) : "r" (value) ); + return(result); +} + + +/** \brief STR Exclusive (16 bit) + + This function performs a exclusive STR command for 16 bit values. + + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __STREXH(uint16_t value, volatile uint16_t *addr) +{ + uint32_t result; + + __ASM volatile ("strexh %0, %2, %1" : "=&r" (result), "=Q" (*addr) : "r" (value) ); + return(result); +} + + +/** \brief STR Exclusive (32 bit) + + This function performs a exclusive STR command for 32 bit values. + + \param [in] value Value to store + \param [in] ptr Pointer to location + \return 0 Function succeeded + \return 1 Function failed + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __STREXW(uint32_t value, volatile uint32_t *addr) +{ + uint32_t result; + + __ASM volatile ("strex %0, %2, %1" : "=&r" (result), "=Q" (*addr) : "r" (value) ); + return(result); +} + + +/** \brief Remove the exclusive lock + + This function removes the exclusive lock which is created by LDREX. + + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE void __CLREX(void) +{ + __ASM volatile ("clrex" ::: "memory"); +} + + +/** \brief Signed Saturate + + This function saturates a signed value. + + \param [in] value Value to be saturated + \param [in] sat Bit position to saturate to (1..32) + \return Saturated value + */ +#define __SSAT(ARG1,ARG2) \ +({ \ + uint32_t __RES, __ARG1 = (ARG1); \ + __ASM ("ssat %0, %1, %2" : "=r" (__RES) : "I" (ARG2), "r" (__ARG1) ); \ + __RES; \ + }) + + +/** \brief Unsigned Saturate + + This function saturates an unsigned value. + + \param [in] value Value to be saturated + \param [in] sat Bit position to saturate to (0..31) + \return Saturated value + */ +#define __USAT(ARG1,ARG2) \ +({ \ + uint32_t __RES, __ARG1 = (ARG1); \ + __ASM ("usat %0, %1, %2" : "=r" (__RES) : "I" (ARG2), "r" (__ARG1) ); \ + __RES; \ + }) + + +/** \brief Count leading zeros + + This function counts the number of leading zeros of a data value. + + \param [in] value Value to count the leading zeros + \return number of leading zeros in value + */ +__attribute__( ( always_inline ) ) __STATIC_INLINE uint8_t __CLZ(uint32_t value) +{ + uint32_t result; + + __ASM volatile ("clz %0, %1" : "=r" (result) : "r" (value) ); + return(result); +} + +#endif /* (__CORTEX_M >= 0x03) */ + + + + +#elif defined ( __TASKING__ ) /*------------------ TASKING Compiler --------------*/ +/* TASKING carm specific functions */ + +/* + * The CMSIS functions have been implemented as intrinsics in the compiler. + * Please use "carm -?i" to get an up to date list of all intrinsics, + * Including the CMSIS ones. + */ + +#endif + +/*@}*/ /* end of group CMSIS_Core_InstructionInterface */ + +#endif /* __CORE_CMINSTR_H */ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/stm32f0xx.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/stm32f0xx.h new file mode 100644 index 00000000..b868a975 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/stm32f0xx.h @@ -0,0 +1,5707 @@ +/** + ****************************************************************************** + * @file stm32f0xx.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief CMSIS Cortex-M0 Device Peripheral Access Layer Header File. + * This file contains all the peripheral register's definitions, bits + * definitions and memory mapping for STM32F0xx devices. + * + * The file is the unique include file that the application programmer + * is using in the C source code, usually in main.c. This file contains: + * - Configuration section that allows to select: + * - The device used in the target application + * - To use or not the peripheral’s drivers in application code(i.e. + * code will be based on direct access to peripheral’s registers + * rather than drivers API), this option is controlled by + * "#define USE_STDPERIPH_DRIVER" + * - To change few application-specific parameters such as the HSE + * crystal frequency + * - Data structures and the address mapping for all peripherals + * - Peripheral's registers declarations and bits definition + * - Macros to access peripheral’s registers hardware + * + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/** @addtogroup CMSIS + * @{ + */ + +/** @addtogroup stm32f0xx + * @{ + */ + +#ifndef __STM32F0XX_H +#define __STM32F0XX_H + +#ifdef __cplusplus + extern "C" { +#endif + +/** @addtogroup Library_configuration_section + * @{ + */ + +/* Uncomment the line below according to the target STM32F0 device used in your + application + */ + +#if !defined (STM32F030) && !defined (STM32F031) && !defined (STM32F051) && \ + !defined (STM32F072) && !defined (STM32F042) && !defined (STM32F091) && \ + !defined (STM32F070xB) && !defined (STM32F070x6) && !defined (STM32F030xC) + /* #define STM32F030 */ + /* #define STM32F031 */ + /* #define STM32F051 */ + /* #define STM32F072 */ + /* #define STM32F070xB */ + /* #define STM32F042 */ + /* #define STM32F070x6 */ + /* #define STM32F091 */ + /* #define STM32F030xC */ +#endif /* STM32F030 || STM32F031 || STM32F051 || STM32F072 || STM32F042 || STM32F091 || + STM32F070xB || STM32F070x6 || STM32F030xC */ + +/* Tip: To avoid modifying this file each time you need to switch between these + devices, you can define the device in your toolchain compiler preprocessor. + */ + +/* Old STM32F0XX definition, maintained for legacy purpose */ +#if defined(STM32F0XX) || defined(STM32F0XX_MD) + #define STM32F051 +#endif /* STM32F0XX */ + +/* Old STM32F0XX_LD definition, maintained for legacy purpose */ +#ifdef STM32F0XX_LD + #define STM32F031 +#endif /* STM32F0XX_LD */ + +/* Old STM32F0XX_HD definition, maintained for legacy purpose */ +#ifdef STM32F0XX_HD + #define STM32F072 +#endif /* STM32F0XX_HD */ + +/* Old STM32F030X6/X8 definition, maintained for legacy purpose */ +#if defined (STM32F030X8) || defined (STM32F030X6) + #define STM32F030 +#endif /* STM32F030X8 or STM32F030X6 */ + + +#if !defined (STM32F030) && !defined (STM32F031) && !defined (STM32F051) && \ + !defined (STM32F072) && !defined (STM32F042) && !defined (STM32F091) && \ + !defined (STM32F070xB) && !defined (STM32F070x6) && !defined (STM32F030xC) + #error "Please select first the target STM32F0xx device used in your application (in stm32f0xx.h file)" +#endif /* STM32F030 || STM32F031 || STM32F051 || STM32F072 || STM32F042 || STM32F091 || + STM32F070xB || STM32F070x6 || STM32F030xC */ + +#if !defined USE_STDPERIPH_DRIVER +/** + * @brief Comment the line below if you will not use the peripherals drivers. + In this case, these drivers will not be included and the application code will + be based on direct access to peripherals registers + */ + /*#define USE_STDPERIPH_DRIVER*/ +#endif /* USE_STDPERIPH_DRIVER */ + +/** + * @brief In the following line adjust the value of External High Speed oscillator (HSE) + used in your application + + Tip: To avoid modifying this file each time you need to use different HSE, you + can define the HSE value in your toolchain compiler preprocessor. + */ +#if !defined (HSE_VALUE) +#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz*/ +#endif /* HSE_VALUE */ + +/** + * @brief In the following line adjust the External High Speed oscillator (HSE) Startup + Timeout value + */ +#if !defined (HSE_STARTUP_TIMEOUT) +#define HSE_STARTUP_TIMEOUT ((uint16_t)0x5000) /*!< Time out for HSE start up */ +#endif /* HSE_STARTUP_TIMEOUT */ + +/** + * @brief In the following line adjust the Internal High Speed oscillator (HSI) Startup + Timeout value + */ +#if !defined (HSI_STARTUP_TIMEOUT) +#define HSI_STARTUP_TIMEOUT ((uint16_t)0x5000) /*!< Time out for HSI start up */ +#endif /* HSI_STARTUP_TIMEOUT */ + +#if !defined (HSI_VALUE) +#define HSI_VALUE ((uint32_t)8000000) /*!< Value of the Internal High Speed oscillator in Hz. + The real value may vary depending on the variations + in voltage and temperature. */ +#endif /* HSI_VALUE */ + +#if !defined (HSI14_VALUE) +#define HSI14_VALUE ((uint32_t)14000000) /*!< Value of the Internal High Speed oscillator for ADC in Hz. + The real value may vary depending on the variations + in voltage and temperature. */ +#endif /* HSI14_VALUE */ + +#if !defined (HSI48_VALUE) +#define HSI48_VALUE ((uint32_t)48000000) /*!< Value of the Internal High Speed oscillator for USB in Hz. + The real value may vary depending on the variations + in voltage and temperature. */ +#endif /* HSI48_VALUE */ + +#if !defined (LSI_VALUE) +#define LSI_VALUE ((uint32_t)40000) /*!< Value of the Internal Low Speed oscillator in Hz + The real value may vary depending on the variations + in voltage and temperature. */ +#endif /* LSI_VALUE */ + +#if !defined (LSE_VALUE) +#define LSE_VALUE ((uint32_t)32768) /*!< Value of the External Low Speed oscillator in Hz */ +#endif /* LSE_VALUE */ + +/** + * @brief STM32F0xx Standard Peripheral Library version number V1.4.0 + */ +#define __STM32F0XX_STDPERIPH_VERSION_MAIN (0x01) /*!< [31:24] main version */ +#define __STM32F0XX_STDPERIPH_VERSION_SUB1 (0x05) /*!< [23:16] sub1 version */ +#define __STM32F0XX_STDPERIPH_VERSION_SUB2 (0x00) /*!< [15:8] sub2 version */ +#define __STM32F0XX_STDPERIPH_VERSION_RC (0x00) /*!< [7:0] release candidate */ +#define __STM32F0XX_STDPERIPH_VERSION ((__STM32F0XX_STDPERIPH_VERSION_MAIN << 24)\ + |(__STM32F0XX_STDPERIPH_VERSION_SUB1 << 16)\ + |(__STM32F0XX_STDPERIPH_VERSION_SUB2 << 8)\ + |(__STM32F0XX_STDPERIPH_VERSION_RC)) + +/** + * @} + */ + +/** @addtogroup Configuration_section_for_CMSIS + * @{ + */ + +/** + * @brief STM32F0xx Interrupt Number Definition, according to the selected device + * in @ref Library_configuration_section + */ +#define __CM0_REV 0 /*!< Core Revision r0p0 */ +#define __MPU_PRESENT 0 /*!< STM32F0xx do not provide MPU */ +#define __NVIC_PRIO_BITS 2 /*!< STM32F0xx uses 2 Bits for the Priority Levels */ +#define __Vendor_SysTickConfig 0 /*!< Set to 1 if different SysTick Config is used */ + +/*!< Interrupt Number Definition */ +typedef enum IRQn +{ +/****** Cortex-M0 Processor Exceptions Numbers ******************************************************/ + NonMaskableInt_IRQn = -14, /*!< 2 Non Maskable Interrupt */ + HardFault_IRQn = -13, /*!< 3 Cortex-M0 Hard Fault Interrupt */ + SVC_IRQn = -5, /*!< 11 Cortex-M0 SV Call Interrupt */ + PendSV_IRQn = -2, /*!< 14 Cortex-M0 Pend SV Interrupt */ + SysTick_IRQn = -1, /*!< 15 Cortex-M0 System Tick Interrupt */ + +#if defined (STM32F051) +/****** STM32F051 specific Interrupt Numbers *************************************/ + WWDG_IRQn = 0, /*!< Window WatchDog Interrupt */ + PVD_IRQn = 1, /*!< PVD through EXTI Line detect Interrupt */ + RTC_IRQn = 2, /*!< RTC through EXTI Line Interrupt */ + FLASH_IRQn = 3, /*!< FLASH Interrupt */ + RCC_IRQn = 4, /*!< RCC Interrupt */ + EXTI0_1_IRQn = 5, /*!< EXTI Line 0 and 1 Interrupts */ + EXTI2_3_IRQn = 6, /*!< EXTI Line 2 and 3 Interrupts */ + EXTI4_15_IRQn = 7, /*!< EXTI Line 4 to 15 Interrupts */ + TS_IRQn = 8, /*!< Touch sense controller Interrupt */ + DMA1_Channel1_IRQn = 9, /*!< DMA1 Channel 1 Interrupt */ + DMA1_Channel2_3_IRQn = 10, /*!< DMA1 Channel 2 and Channel 3 Interrupts */ + DMA1_Channel4_5_IRQn = 11, /*!< DMA1 Channel 4 and Channel 5 Interrupts */ + ADC1_COMP_IRQn = 12, /*!< ADC1, COMP1 and COMP2 Interrupts */ + TIM1_BRK_UP_TRG_COM_IRQn = 13, /*!< TIM1 Break, Update, Trigger and Commutation Interrupts */ + TIM1_CC_IRQn = 14, /*!< TIM1 Capture Compare Interrupt */ + TIM2_IRQn = 15, /*!< TIM2 Interrupt */ + TIM3_IRQn = 16, /*!< TIM3 Interrupt */ + TIM6_DAC_IRQn = 17, /*!< TIM6 and DAC Interrupts */ + TIM14_IRQn = 19, /*!< TIM14 Interrupt */ + TIM15_IRQn = 20, /*!< TIM15 Interrupt */ + TIM16_IRQn = 21, /*!< TIM16 Interrupt */ + TIM17_IRQn = 22, /*!< TIM17 Interrupt */ + I2C1_IRQn = 23, /*!< I2C1 Interrupt */ + I2C2_IRQn = 24, /*!< I2C2 Interrupt */ + SPI1_IRQn = 25, /*!< SPI1 Interrupt */ + SPI2_IRQn = 26, /*!< SPI2 Interrupt */ + USART1_IRQn = 27, /*!< USART1 Interrupt */ + USART2_IRQn = 28, /*!< USART2 Interrupt */ + CEC_IRQn = 30 /*!< CEC Interrupt */ +#elif defined (STM32F031) +/****** STM32F031 specific Interrupt Numbers *************************************/ + WWDG_IRQn = 0, /*!< Window WatchDog Interrupt */ + PVD_IRQn = 1, /*!< PVD through EXTI Line detect Interrupt */ + RTC_IRQn = 2, /*!< RTC through EXTI Line Interrupt */ + FLASH_IRQn = 3, /*!< FLASH Interrupt */ + RCC_IRQn = 4, /*!< RCC Interrupt */ + EXTI0_1_IRQn = 5, /*!< EXTI Line 0 and 1 Interrupts */ + EXTI2_3_IRQn = 6, /*!< EXTI Line 2 and 3 Interrupts */ + EXTI4_15_IRQn = 7, /*!< EXTI Line 4 to 15 Interrupts */ + DMA1_Channel1_IRQn = 9, /*!< DMA1 Channel 1 Interrupt */ + DMA1_Channel2_3_IRQn = 10, /*!< DMA1 Channel 2 and Channel 3 Interrupts */ + DMA1_Channel4_5_IRQn = 11, /*!< DMA1 Channel 4 and Channel 5 Interrupts */ + ADC1_IRQn = 12, /*!< ADC1 Interrupt */ + TIM1_BRK_UP_TRG_COM_IRQn = 13, /*!< TIM1 Break, Update, Trigger and Commutation Interrupts */ + TIM1_CC_IRQn = 14, /*!< TIM1 Capture Compare Interrupt */ + TIM2_IRQn = 15, /*!< TIM2 Interrupt */ + TIM3_IRQn = 16, /*!< TIM3 Interrupt */ + TIM14_IRQn = 19, /*!< TIM14 Interrupt */ + TIM16_IRQn = 21, /*!< TIM16 Interrupt */ + TIM17_IRQn = 22, /*!< TIM17 Interrupt */ + I2C1_IRQn = 23, /*!< I2C1 Interrupt */ + SPI1_IRQn = 25, /*!< SPI1 Interrupt */ + USART1_IRQn = 27 /*!< USART1 Interrupt */ +#elif defined (STM32F030) +/****** STM32F030 specific Interrupt Numbers *************************************/ + WWDG_IRQn = 0, /*!< Window WatchDog Interrupt */ + RTC_IRQn = 2, /*!< RTC through EXTI Line Interrupt */ + FLASH_IRQn = 3, /*!< FLASH Interrupt */ + RCC_IRQn = 4, /*!< RCC Interrupt */ + EXTI0_1_IRQn = 5, /*!< EXTI Line 0 and 1 Interrupts */ + EXTI2_3_IRQn = 6, /*!< EXTI Line 2 and 3 Interrupts */ + EXTI4_15_IRQn = 7, /*!< EXTI Line 4 to 15 Interrupts */ + DMA1_Channel1_IRQn = 9, /*!< DMA1 Channel 1 Interrupt */ + DMA1_Channel2_3_IRQn = 10, /*!< DMA1 Channel 2 and Channel 3 Interrupts */ + DMA1_Channel4_5_IRQn = 11, /*!< DMA1 Channel 4 and Channel 5 Interrupts */ + ADC1_IRQn = 12, /*!< ADC1 Interrupt */ + TIM1_BRK_UP_TRG_COM_IRQn = 13, /*!< TIM1 Break, Update, Trigger and Commutation Interrupts */ + TIM1_CC_IRQn = 14, /*!< TIM1 Capture Compare Interrupt */ + TIM3_IRQn = 16, /*!< TIM3 Interrupt */ + TIM14_IRQn = 19, /*!< TIM14 Interrupt */ + TIM15_IRQn = 20, /*!< TIM15 Interrupt */ + TIM16_IRQn = 21, /*!< TIM16 Interrupt */ + TIM17_IRQn = 22, /*!< TIM17 Interrupt */ + I2C1_IRQn = 23, /*!< I2C1 Interrupt */ + I2C2_IRQn = 24, /*!< I2C2 Interrupt */ + SPI1_IRQn = 25, /*!< SPI1 Interrupt */ + SPI2_IRQn = 26, /*!< SPI2 Interrupt */ + USART1_IRQn = 27, /*!< USART1 Interrupt */ + USART2_IRQn = 28 /*!< USART2 Interrupt */ +#elif defined (STM32F072) + WWDG_IRQn = 0, /*!< Window WatchDog Interrupt */ + PVD_VDDIO2_IRQn = 1, /*!< PVD and VDDIO2 supply comparator through EXTI Line detect Interrupt */ + RTC_IRQn = 2, /*!< RTC through EXTI Line Interrupt */ + FLASH_IRQn = 3, /*!< FLASH Interrupt */ + RCC_CRS_IRQn = 4, /*!< RCC and CRS Interrupts */ + EXTI0_1_IRQn = 5, /*!< EXTI Line 0 and 1 Interrupts */ + EXTI2_3_IRQn = 6, /*!< EXTI Line 2 and 3 Interrupts */ + EXTI4_15_IRQn = 7, /*!< EXTI Line 4 to 15 Interrupts */ + TSC_IRQn = 8, /*!< TSC Interrupt */ + DMA1_Channel1_IRQn = 9, /*!< DMA1 Channel 1 Interrupt */ + DMA1_Channel2_3_IRQn = 10, /*!< DMA1 Channel 2 and Channel 3 Interrupts */ + DMA1_Channel4_5_6_7_IRQn = 11, /*!< DMA1 Channel 4, Channel 5, Channel 6 and Channel 7 Interrupts */ + ADC1_COMP_IRQn = 12, /*!< ADC1, COMP1 and COMP2 Interrupts */ + TIM1_BRK_UP_TRG_COM_IRQn = 13, /*!< TIM1 Break, Update, Trigger and Commutation Interrupts */ + TIM1_CC_IRQn = 14, /*!< TIM1 Capture Compare Interrupt */ + TIM2_IRQn = 15, /*!< TIM2 Interrupt */ + TIM3_IRQn = 16, /*!< TIM3 Interrupt */ + TIM6_DAC_IRQn = 17, /*!< TIM6 and DAC Interrupts */ + TIM7_IRQn = 18, /*!< TIM7 Interrupts */ + TIM14_IRQn = 19, /*!< TIM14 Interrupt */ + TIM15_IRQn = 20, /*!< TIM15 Interrupt */ + TIM16_IRQn = 21, /*!< TIM16 Interrupt */ + TIM17_IRQn = 22, /*!< TIM17 Interrupt */ + I2C1_IRQn = 23, /*!< I2C1 Interrupt */ + I2C2_IRQn = 24, /*!< I2C2 Interrupt */ + SPI1_IRQn = 25, /*!< SPI1 Interrupt */ + SPI2_IRQn = 26, /*!< SPI2 Interrupt */ + USART1_IRQn = 27, /*!< USART1 Interrupt */ + USART2_IRQn = 28, /*!< USART2 Interrupt */ + USART3_4_IRQn = 29, /*!< USART3 and USART4 Interrupts */ + CEC_CAN_IRQn = 30, /*!< CEC and CAN Interrupts */ + USB_IRQn = 31 /*!< USB Low Priority global Interrupt */ +#elif defined (STM32F042) + WWDG_IRQn = 0, /*!< Window WatchDog Interrupt */ + PVD_VDDIO2_IRQn = 1, /*!< PVD and VDDIO2 supply comparator through EXTI Line detect Interrupt */ + RTC_IRQn = 2, /*!< RTC through EXTI Line Interrupt */ + FLASH_IRQn = 3, /*!< FLASH Interrupt */ + RCC_CRS_IRQn = 4, /*!< RCC and CRS Interrupts */ + EXTI0_1_IRQn = 5, /*!< EXTI Line 0 and 1 Interrupts */ + EXTI2_3_IRQn = 6, /*!< EXTI Line 2 and 3 Interrupts */ + EXTI4_15_IRQn = 7, /*!< EXTI Line 4 to 15 Interrupts */ + TSC_IRQn = 8, /*!< TSC Interrupt */ + DMA1_Channel1_IRQn = 9, /*!< DMA1 Channel 1 Interrupt */ + DMA1_Channel2_3_IRQn = 10, /*!< DMA1 Channel 2 and Channel 3 Interrupts */ + DMA1_Channel4_5_IRQn = 11, /*!< DMA1 Channel 4, Channel 5 Interrupts */ + ADC1_IRQn = 12, /*!< ADC1 Interrupts */ + TIM1_BRK_UP_TRG_COM_IRQn = 13, /*!< TIM1 Break, Update, Trigger and Commutation Interrupts */ + TIM1_CC_IRQn = 14, /*!< TIM1 Capture Compare Interrupt */ + TIM2_IRQn = 15, /*!< TIM2 Interrupt */ + TIM3_IRQn = 16, /*!< TIM3 Interrupt */ + TIM14_IRQn = 19, /*!< TIM14 Interrupt */ + TIM16_IRQn = 21, /*!< TIM16 Interrupt */ + TIM17_IRQn = 22, /*!< TIM17 Interrupt */ + I2C1_IRQn = 23, /*!< I2C1 Interrupt */ + SPI1_IRQn = 25, /*!< SPI1 Interrupt */ + SPI2_IRQn = 26, /*!< SPI2 Interrupt */ + USART1_IRQn = 27, /*!< USART1 Interrupt */ + USART2_IRQn = 28, /*!< USART2 Interrupt */ + CEC_CAN_IRQn = 30, /*!< CEC and CAN Interrupts */ + USB_IRQn = 31 /*!< USB Low Priority global Interrupt */ +#elif defined (STM32F091) + WWDG_IRQn = 0, /*!< Window WatchDog Interrupt */ + PVD_VDDIO2_IRQn = 1, /*!< PVD & VDDIO2 Interrupts through EXTI Lines 16 and 31 */ + RTC_IRQn = 2, /*!< RTC Interrupt through EXTI Lines 17, 19 and 20 */ + FLASH_IRQn = 3, /*!< FLASH global Interrupt */ + RCC_CRS_IRQn = 4, /*!< RCC & CRS Global Interrupts */ + EXTI0_1_IRQn = 5, /*!< EXTI Line 0 and 1 Interrupts */ + EXTI2_3_IRQn = 6, /*!< EXTI Line 2 and 3 Interrupts */ + EXTI4_15_IRQn = 7, /*!< EXTI Line 4 to 15 Interrupts */ + TSC_IRQn = 8, /*!< Touch Sensing Controller Interrupts */ + DMA1_Ch1_IRQn = 9, /*!< DMA1 Channel 1 Interrupt */ + DMA1_Ch2_3_DMA2_Ch1_2_IRQn = 10, /*!< DMA1 Channel 2 and 3 & DMA2 Channel 1 and 2 Interrupts */ + DMA1_Ch4_7_DMA2_Ch3_5_IRQn = 11, /*!< DMA1 Channel 4 to 7 & DMA2 Channel 3 to 5 Interrupts */ + ADC1_COMP_IRQn = 12, /*!< ADC, COMP1 and COMP2 Interrupts (EXTI Lines 21 and 22) */ + TIM1_BRK_UP_TRG_COM_IRQn = 13, /*!< TIM1 Break, Update, Trigger and Commutation Interrupts */ + TIM1_CC_IRQn = 14, /*!< TIM1 Capture Compare Interrupt */ + TIM2_IRQn = 15, /*!< TIM2 global Interrupt */ + TIM3_IRQn = 16, /*!< TIM3 global Interrupt */ + TIM6_DAC_IRQn = 17, /*!< TIM6 global and DAC channel underrun error Interrupts */ + TIM7_IRQn = 18, /*!< TIM7 global Interrupt */ + TIM14_IRQn = 19, /*!< TIM14 global Interrupt */ + TIM15_IRQn = 20, /*!< TIM15 global Interrupt */ + TIM16_IRQn = 21, /*!< TIM16 global Interrupt */ + TIM17_IRQn = 22, /*!< TIM17 global Interrupt */ + I2C1_IRQn = 23, /*!< I2C1 Event Interrupt & EXTI Line23 Interrupt (I2C1 wakeup) */ + I2C2_IRQn = 24, /*!< I2C2 Event Interrupt & EXTI Line24 Interrupt (I2C2 wakeup) */ + SPI1_IRQn = 25, /*!< SPI1 global Interrupt */ + SPI2_IRQn = 26, /*!< SPI2 global Interrupt */ + USART1_IRQn = 27, /*!< USART1 global Interrupt & EXTI Line25 Interrupt (USART1 wakeup) */ + USART2_IRQn = 28, /*!< USART2 global Interrupt & EXTI Line26 Interrupt (USART2 wakeup) */ + USART3_8_IRQn = 29, /*!< USART3 to USART8 global Interrupts */ + CEC_CAN_IRQn = 30 /*!< CEC and CAN global Interrupts & EXTI Line27 Interrupt */ +#elif defined (STM32F070xB) + WWDG_IRQn = 0, /*!< Window WatchDog Interrupt */ + RTC_IRQn = 2, /*!< RTC Interrupt through EXTI Lines 17, 19 and 20 */ + FLASH_IRQn = 3, /*!< FLASH global Interrupt */ + RCC_IRQn = 4, /*!< RCC Global Interrupts */ + EXTI0_1_IRQn = 5, /*!< EXTI Line 0 and 1 Interrupts */ + EXTI2_3_IRQn = 6, /*!< EXTI Line 2 and 3 Interrupts */ + EXTI4_15_IRQn = 7, /*!< EXTI Line 4 to 15 Interrupts */ + DMA1_Channel1_IRQn = 9, /*!< DMA1 Channel 1 Interrupt */ + DMA1_Channel2_3_IRQn = 10, /*!< DMA1 Channel 2 and Channel 3 Interrupts */ + DMA1_Channel4_5_IRQn = 11, /*!< DMA1 Channel 4 and Channel 5 Interrupts */ + ADC1_IRQn = 12, /*!< ADC1 interrupts (ADC interrupt combined with EXTI Lines 21 and 22 */ + TIM1_BRK_UP_TRG_COM_IRQn = 13, /*!< TIM1 Break, Update, Trigger and Commutation Interrupts */ + TIM1_CC_IRQn = 14, /*!< TIM1 Capture Compare Interrupt */ + TIM3_IRQn = 16, /*!< TIM3 global Interrupt */ + TIM6_IRQn = 17, /*!< TIM6 global Interrupts */ + TIM7_IRQn = 18, /*!< TIM7 global Interrupt */ + TIM14_IRQn = 19, /*!< TIM14 global Interrupt */ + TIM15_IRQn = 20, /*!< TIM15 global Interrupt */ + TIM16_IRQn = 21, /*!< TIM16 global Interrupt */ + TIM17_IRQn = 22, /*!< TIM17 global Interrupt */ + I2C1_IRQn = 23, /*!< I2C1 Event Interrupt & EXTI Line23 Interrupt (I2C1 wakeup) */ + I2C2_IRQn = 24, /*!< I2C2 Event Interrupt */ + SPI1_IRQn = 25, /*!< SPI1 global Interrupt */ + SPI2_IRQn = 26, /*!< SPI2 global Interrupt */ + USART1_IRQn = 27, /*!< USART1 global Interrupt */ + USART2_IRQn = 28, /*!< USART2 global Interrupt */ + USART3_4_IRQn = 29, /*!< USART3 and USART4 global Interrupts */ + USB_IRQn = 31 /*!< USB global Interrupts & EXTI Line18 Interrupt */ +#elif defined (STM32F070x6) + WWDG_IRQn = 0, /*!< Window WatchDog Interrupt */ + RTC_IRQn = 2, /*!< RTC Interrupt through EXTI Lines 17, 19 and 20 */ + FLASH_IRQn = 3, /*!< FLASH global Interrupt */ + RCC_IRQn = 4, /*!< RCC Global Interrupts */ + EXTI0_1_IRQn = 5, /*!< EXTI Line 0 and 1 Interrupts */ + EXTI2_3_IRQn = 6, /*!< EXTI Line 2 and 3 Interrupts */ + EXTI4_15_IRQn = 7, /*!< EXTI Line 4 to 15 Interrupts */ + DMA1_Channel1_IRQn = 9, /*!< DMA1 Channel 1 Interrupt */ + DMA1_Channel2_3_IRQn = 10, /*!< DMA1 Channel 2 and Channel 3 Interrupts */ + DMA1_Channel4_5_IRQn = 11, /*!< DMA1 Channel 4 and Channel 5 Interrupts */ + ADC1_IRQn = 12, /*!< ADC1 Interrupt */ + TIM1_BRK_UP_TRG_COM_IRQn = 13, /*!< TIM1 Break, Update, Trigger and Commutation Interrupts */ + TIM1_CC_IRQn = 14, /*!< TIM1 Capture Compare Interrupt */ + TIM3_IRQn = 16, /*!< TIM3 global Interrupt */ + TIM14_IRQn = 19, /*!< TIM14 global Interrupt */ + TIM16_IRQn = 21, /*!< TIM16 global Interrupt */ + TIM17_IRQn = 22, /*!< TIM17 global Interrupt */ + I2C1_IRQn = 23, /*!< I2C1 Event Interrupt & EXTI Line23 Interrupt (I2C1 wakeup) */ + SPI1_IRQn = 25, /*!< SPI1 global Interrupt */ + USART1_IRQn = 27, /*!< USART1 global Interrupt & EXTI Line25 Interrupt (USART1 wakeup) */ + USART2_IRQn = 28, /*!< USART2 global Interrupt */ + USB_IRQn = 31 /*!< USB global Interrupts & EXTI Line18 Interrupt */ +#elif defined (STM32F030xC) + WWDG_IRQn = 0, /*!< Window WatchDog Interrupt */ + RTC_IRQn = 2, /*!< RTC Interrupt through EXTI Lines 17, 19 and 20 */ + FLASH_IRQn = 3, /*!< FLASH global Interrupt */ + RCC_IRQn = 4, /*!< RCC Global Interrupts */ + EXTI0_1_IRQn = 5, /*!< EXTI Line 0 and 1 Interrupts */ + EXTI2_3_IRQn = 6, /*!< EXTI Line 2 and 3 Interrupts */ + EXTI4_15_IRQn = 7, /*!< EXTI Line 4 to 15 Interrupts */ + DMA1_Channel1_IRQn = 9, /*!< DMA1 Channel 1 Interrupt */ + DMA1_Channel2_3_IRQn = 10, /*!< DMA1 Channel 2 and Channel 3 Interrupts */ + DMA1_Channel4_5_IRQn = 11, /*!< DMA1 Channel 4 and Channel 5 Interrupts */ + ADC1_IRQn = 12, /*!< ADC Interrupts */ + TIM1_BRK_UP_TRG_COM_IRQn = 13, /*!< TIM1 Break, Update, Trigger and Commutation Interrupts */ + TIM1_CC_IRQn = 14, /*!< TIM1 Capture Compare Interrupt */ + TIM3_IRQn = 16, /*!< TIM3 global Interrupt */ + TIM6_IRQn = 17, /*!< TIM6 global Interrupts */ + TIM7_IRQn = 18, /*!< TIM7 global Interrupt */ + TIM14_IRQn = 19, /*!< TIM14 global Interrupt */ + TIM15_IRQn = 20, /*!< TIM15 global Interrupt */ + TIM16_IRQn = 21, /*!< TIM16 global Interrupt */ + TIM17_IRQn = 22, /*!< TIM17 global Interrupt */ + I2C1_IRQn = 23, /*!< I2C1 Event Interrupt & EXTI Line23 Interrupt (I2C1 wakeup) */ + I2C2_IRQn = 24, /*!< I2C2 Event Interrupt */ + SPI1_IRQn = 25, /*!< SPI1 global Interrupt */ + SPI2_IRQn = 26, /*!< SPI2 global Interrupt */ + USART1_IRQn = 27, /*!< USART1 global Interrupt & EXTI Line25 Interrupt (USART1 wakeup) */ + USART2_IRQn = 28, /*!< USART2 global Interrupt & EXTI Line26 Interrupt (USART2 wakeup) */ + USART3_6_IRQn = 29, /*!< USART3 to USART6 global Interrupts */ +#endif /* STM32F051 */ +}IRQn_Type; + +/** + * @} + */ + +#include "core_cm0.h" +#include "system_stm32f0xx.h" +#include + +/** @addtogroup Exported_types + * @{ + */ + +typedef enum {RESET = 0, SET = !RESET} FlagStatus, ITStatus; + +typedef enum {DISABLE = 0, ENABLE = !DISABLE} FunctionalState; +#define IS_FUNCTIONAL_STATE(STATE) (((STATE) == DISABLE) || ((STATE) == ENABLE)) + +typedef enum {ERROR = 0, SUCCESS = !ERROR} ErrorStatus; + +/** @addtogroup Peripheral_registers_structures + * @{ + */ + +/** + * @brief Analog to Digital Converter + */ + +typedef struct +{ + __IO uint32_t ISR; /*!< ADC Interrupt and Status register, Address offset:0x00 */ + __IO uint32_t IER; /*!< ADC Interrupt Enable register, Address offset:0x04 */ + __IO uint32_t CR; /*!< ADC Control register, Address offset:0x08 */ + __IO uint32_t CFGR1; /*!< ADC Configuration register 1, Address offset:0x0C */ + __IO uint32_t CFGR2; /*!< ADC Configuration register 2, Address offset:0x10 */ + __IO uint32_t SMPR; /*!< ADC Sampling time register, Address offset:0x14 */ + uint32_t RESERVED1; /*!< Reserved, 0x18 */ + uint32_t RESERVED2; /*!< Reserved, 0x1C */ + __IO uint32_t TR; /*!< ADC watchdog threshold register, Address offset:0x20 */ + uint32_t RESERVED3; /*!< Reserved, 0x24 */ + __IO uint32_t CHSELR; /*!< ADC channel selection register, Address offset:0x28 */ + uint32_t RESERVED4[5]; /*!< Reserved, 0x2C */ + __IO uint32_t DR; /*!< ADC data register, Address offset:0x40 */ +} ADC_TypeDef; + +typedef struct +{ + __IO uint32_t CCR; +} ADC_Common_TypeDef; + + +/** + * @brief Controller Area Network TxMailBox + */ +typedef struct +{ + __IO uint32_t TIR; /*!< CAN TX mailbox identifier register */ + __IO uint32_t TDTR; /*!< CAN mailbox data length control and time stamp register */ + __IO uint32_t TDLR; /*!< CAN mailbox data low register */ + __IO uint32_t TDHR; /*!< CAN mailbox data high register */ +} CAN_TxMailBox_TypeDef; + +/** + * @brief Controller Area Network FIFOMailBox + */ +typedef struct +{ + __IO uint32_t RIR; /*!< CAN receive FIFO mailbox identifier register */ + __IO uint32_t RDTR; /*!< CAN receive FIFO mailbox data length control and time stamp register */ + __IO uint32_t RDLR; /*!< CAN receive FIFO mailbox data low register */ + __IO uint32_t RDHR; /*!< CAN receive FIFO mailbox data high register */ +} CAN_FIFOMailBox_TypeDef; + +/** + * @brief Controller Area Network FilterRegister + */ +typedef struct +{ + __IO uint32_t FR1; /*!< CAN Filter bank register 1 */ + __IO uint32_t FR2; /*!< CAN Filter bank register 1 */ +} CAN_FilterRegister_TypeDef; + +/** + * @brief Controller Area Network + */ +typedef struct +{ + __IO uint32_t MCR; /*!< CAN master control register, Address offset: 0x00 */ + __IO uint32_t MSR; /*!< CAN master status register, Address offset: 0x04 */ + __IO uint32_t TSR; /*!< CAN transmit status register, Address offset: 0x08 */ + __IO uint32_t RF0R; /*!< CAN receive FIFO 0 register, Address offset: 0x0C */ + __IO uint32_t RF1R; /*!< CAN receive FIFO 1 register, Address offset: 0x10 */ + __IO uint32_t IER; /*!< CAN interrupt enable register, Address offset: 0x14 */ + __IO uint32_t ESR; /*!< CAN error status register, Address offset: 0x18 */ + __IO uint32_t BTR; /*!< CAN bit timing register, Address offset: 0x1C */ + uint32_t RESERVED0[88]; /*!< Reserved, 0x020 - 0x17F */ + CAN_TxMailBox_TypeDef sTxMailBox[3]; /*!< CAN Tx MailBox, Address offset: 0x180 - 0x1AC */ + CAN_FIFOMailBox_TypeDef sFIFOMailBox[2]; /*!< CAN FIFO MailBox, Address offset: 0x1B0 - 0x1CC */ + uint32_t RESERVED1[12]; /*!< Reserved, 0x1D0 - 0x1FF */ + __IO uint32_t FMR; /*!< CAN filter master register, Address offset: 0x200 */ + __IO uint32_t FM1R; /*!< CAN filter mode register, Address offset: 0x204 */ + uint32_t RESERVED2; /*!< Reserved, 0x208 */ + __IO uint32_t FS1R; /*!< CAN filter scale register, Address offset: 0x20C */ + uint32_t RESERVED3; /*!< Reserved, 0x210 */ + __IO uint32_t FFA1R; /*!< CAN filter FIFO assignment register, Address offset: 0x214 */ + uint32_t RESERVED4; /*!< Reserved, 0x218 */ + __IO uint32_t FA1R; /*!< CAN filter activation register, Address offset: 0x21C */ + uint32_t RESERVED5[8]; /*!< Reserved, 0x220-0x23F */ + CAN_FilterRegister_TypeDef sFilterRegister[28]; /*!< CAN Filter Register, Address offset: 0x240-0x31C */ +} CAN_TypeDef; + +/** + * @brief HDMI-CEC + */ + +typedef struct +{ + __IO uint32_t CR; /*!< CEC control register, Address offset:0x00 */ + __IO uint32_t CFGR; /*!< CEC configuration register, Address offset:0x04 */ + __IO uint32_t TXDR; /*!< CEC Tx data register , Address offset:0x08 */ + __IO uint32_t RXDR; /*!< CEC Rx Data Register, Address offset:0x0C */ + __IO uint32_t ISR; /*!< CEC Interrupt and Status Register, Address offset:0x10 */ + __IO uint32_t IER; /*!< CEC interrupt enable register, Address offset:0x14 */ +}CEC_TypeDef; + +/** + * @brief Comparator + */ + +typedef struct +{ + __IO uint32_t CSR; /*!< COMP comparator control and status register, Address offset: 0x1C */ +} COMP_TypeDef; + + +/** + * @brief CRC calculation unit + */ + +typedef struct +{ + __IO uint32_t DR; /*!< CRC Data register, Address offset: 0x00 */ + __IO uint8_t IDR; /*!< CRC Independent data register, Address offset: 0x04 */ + uint8_t RESERVED0; /*!< Reserved, 0x05 */ + uint16_t RESERVED1; /*!< Reserved, 0x06 */ + __IO uint32_t CR; /*!< CRC Control register, Address offset: 0x08 */ + uint32_t RESERVED2; /*!< Reserved, 0x0C */ + __IO uint32_t INIT; /*!< Initial CRC value register, Address offset: 0x10 */ + __IO uint32_t POL; /*!< CRC polynomial register, Address offset: 0x14 */ +} CRC_TypeDef; + +/** + * @brief Clock Recovery System + */ +typedef struct +{ +__IO uint32_t CR; /*!< CRS ccontrol register, Address offset: 0x00 */ +__IO uint32_t CFGR; /*!< CRS configuration register, Address offset: 0x04 */ +__IO uint32_t ISR; /*!< CRS interrupt and status register, Address offset: 0x08 */ +__IO uint32_t ICR; /*!< CRS interrupt flag clear register, Address offset: 0x0C */ +} CRS_TypeDef; + +/** + * @brief Digital to Analog Converter + */ + +typedef struct +{ + __IO uint32_t CR; /*!< DAC control register, Address offset: 0x00 */ + __IO uint32_t SWTRIGR; /*!< DAC software trigger register, Address offset: 0x04 */ + __IO uint32_t DHR12R1; /*!< DAC channel1 12-bit right-aligned data holding register, Address offset: 0x08 */ + __IO uint32_t DHR12L1; /*!< DAC channel1 12-bit left aligned data holding register, Address offset: 0x0C */ + __IO uint32_t DHR8R1; /*!< DAC channel1 8-bit right aligned data holding register, Address offset: 0x10 */ + __IO uint32_t DHR12R2; /*!< DAC channel2 12-bit right aligned data holding register, Address offset: 0x14 */ + __IO uint32_t DHR12L2; /*!< DAC channel2 12-bit left aligned data holding register, Address offset: 0x18 */ + __IO uint32_t DHR8R2; /*!< DAC channel2 8-bit right-aligned data holding register, Address offset: 0x1C */ + __IO uint32_t DHR12RD; /*!< Dual DAC 12-bit right-aligned data holding register, Address offset: 0x20 */ + __IO uint32_t DHR12LD; /*!< DUAL DAC 12-bit left aligned data holding register, Address offset: 0x24 */ + __IO uint32_t DHR8RD; /*!< DUAL DAC 8-bit right aligned data holding register, Address offset: 0x28 */ + __IO uint32_t DOR1; /*!< DAC channel1 data output register, Address offset: 0x2C */ + __IO uint32_t DOR2; /*!< DAC channel2 data output register, Address offset: 0x30 */ + __IO uint32_t SR; /*!< DAC status register, Address offset: 0x34 */ +} DAC_TypeDef; + +/** + * @brief Debug MCU + */ + +typedef struct +{ + __IO uint32_t IDCODE; /*!< MCU device ID code, Address offset: 0x00 */ + __IO uint32_t CR; /*!< Debug MCU configuration register, Address offset: 0x04 */ + __IO uint32_t APB1FZ; /*!< Debug MCU APB1 freeze register, Address offset: 0x08 */ + __IO uint32_t APB2FZ; /*!< Debug MCU APB2 freeze register, Address offset: 0x0C */ +}DBGMCU_TypeDef; + +/** + * @brief DMA Controller + */ + +typedef struct +{ + __IO uint32_t CCR; /*!< DMA channel x configuration register */ + __IO uint32_t CNDTR; /*!< DMA channel x number of data register */ + __IO uint32_t CPAR; /*!< DMA channel x peripheral address register */ + __IO uint32_t CMAR; /*!< DMA channel x memory address register */ +} DMA_Channel_TypeDef; + +typedef struct +{ + __IO uint32_t ISR; /*!< DMA interrupt status register, Address offset: 0x00 */ + __IO uint32_t IFCR; /*!< DMA interrupt flag clear register, Address offset: 0x04 */ + uint32_t RESERVED0[40];/*!< Reserved as declared by channel typedef 0x08 - 0xA4*/ + __IO uint32_t RMPCR; /*!< Remap control register, Address offset: 0xA8 */ +}DMA_TypeDef; + +/** + * @brief External Interrupt/Event Controller + */ + +typedef struct +{ + __IO uint32_t IMR; /*! exti[31] Interrupt */ +#define SYSCFG_ITLINE1_SR_VDDIO2 ((uint32_t)0x00000002) /*!< VDDIO2 -> exti[16] Interrupt */ +#define SYSCFG_ITLINE2_SR_RTC_WAKEUP ((uint32_t)0x00000001) /*!< RTC WAKEUP -> exti[20] Interrupt */ +#define SYSCFG_ITLINE2_SR_RTC_TSTAMP ((uint32_t)0x00000002) /*!< RTC Time Stamp -> exti[19] interrupt */ +#define SYSCFG_ITLINE2_SR_RTC_ALRA ((uint32_t)0x00000003) /*!< RTC Alarm -> exti[17] interrupt .... */ +#define SYSCFG_ITLINE3_SR_FLASH_ITF ((uint32_t)0x00000001) /*!< Flash ITF Interrupt */ +#define SYSCFG_ITLINE4_SR_CRS ((uint32_t)0x00000001) /*!< CRS interrupt */ +#define SYSCFG_ITLINE4_SR_CLK_CTRL ((uint32_t)0x00000002) /*!< CLK CTRL interrupt */ +#define SYSCFG_ITLINE5_SR_EXTI0 ((uint32_t)0x00000001) /*!< External Interrupt 0 */ +#define SYSCFG_ITLINE5_SR_EXTI1 ((uint32_t)0x00000002) /*!< External Interrupt 1 */ +#define SYSCFG_ITLINE6_SR_EXTI2 ((uint32_t)0x00000001) /*!< External Interrupt 2 */ +#define SYSCFG_ITLINE6_SR_EXTI3 ((uint32_t)0x00000002) /*!< External Interrupt 3 */ +#define SYSCFG_ITLINE7_SR_EXTI4 ((uint32_t)0x00000001) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE7_SR_EXTI5 ((uint32_t)0x00000002) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE7_SR_EXTI6 ((uint32_t)0x00000004) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE7_SR_EXTI7 ((uint32_t)0x00000008) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE7_SR_EXTI8 ((uint32_t)0x00000010) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE7_SR_EXTI9 ((uint32_t)0x00000020) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE7_SR_EXTI10 ((uint32_t)0x00000040) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE7_SR_EXTI11 ((uint32_t)0x00000080) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE7_SR_EXTI12 ((uint32_t)0x00000100) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE7_SR_EXTI13 ((uint32_t)0x00000200) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE7_SR_EXTI14 ((uint32_t)0x00000400) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE7_SR_EXTI15 ((uint32_t)0x00000800) /*!< External Interrupt 15 to 4 */ +#define SYSCFG_ITLINE8_SR_TSC_EOA ((uint32_t)0x00000001) /*!< Touch control EOA Interrupt */ +#define SYSCFG_ITLINE8_SR_TSC_MCE ((uint32_t)0x00000002) /*!< Touch control MCE Interrupt */ +#define SYSCFG_ITLINE9_SR_DMA1_CH1 ((uint32_t)0x00000001) /*!< DMA1 Channel 1 Interrupt */ +#define SYSCFG_ITLINE10_SR_DMA1_CH2 ((uint32_t)0x00000001) /*!< DMA1 Channel 2 Interrupt */ +#define SYSCFG_ITLINE10_SR_DMA1_CH3 ((uint32_t)0x00000002) /*!< DMA2 Channel 3 Interrupt */ +#define SYSCFG_ITLINE10_SR_DMA2_CH1 ((uint32_t)0x00000004) /*!< DMA2 Channel 1 Interrupt */ +#define SYSCFG_ITLINE10_SR_DMA2_CH2 ((uint32_t)0x00000008) /*!< DMA2 Channel 2 Interrupt */ +#define SYSCFG_ITLINE11_SR_DMA1_CH4 ((uint32_t)0x00000001) /*!< DMA1 Channel 4 Interrupt */ +#define SYSCFG_ITLINE11_SR_DMA1_CH5 ((uint32_t)0x00000002) /*!< DMA1 Channel 5 Interrupt */ +#define SYSCFG_ITLINE11_SR_DMA1_CH6 ((uint32_t)0x00000004) /*!< DMA1 Channel 6 Interrupt */ +#define SYSCFG_ITLINE11_SR_DMA1_CH7 ((uint32_t)0x00000008) /*!< DMA1 Channel 7 Interrupt */ +#define SYSCFG_ITLINE11_SR_DMA2_CH3 ((uint32_t)0x00000010) /*!< DMA2 Channel 3 Interrupt */ +#define SYSCFG_ITLINE11_SR_DMA2_CH4 ((uint32_t)0x00000020) /*!< DMA2 Channel 4 Interrupt */ +#define SYSCFG_ITLINE11_SR_DMA2_CH5 ((uint32_t)0x00000040) /*!< DMA2 Channel 5 Interrupt */ +#define SYSCFG_ITLINE12_SR_ADC ((uint32_t)0x00000001) /*!< ADC Interrupt */ +#define SYSCFG_ITLINE12_SR_COMP1 ((uint32_t)0x00000002) /*!< COMP1 Interrupt -> exti[21] */ +#define SYSCFG_ITLINE12_SR_COMP2 ((uint32_t)0x00000004) /*!< COMP2 Interrupt -> exti[22] */ +#define SYSCFG_ITLINE13_SR_TIM1_BRK ((uint32_t)0x00000001) /*!< TIM1 BRK Interrupt */ +#define SYSCFG_ITLINE13_SR_TIM1_UPD ((uint32_t)0x00000002) /*!< TIM1 UPD Interrupt */ +#define SYSCFG_ITLINE13_SR_TIM1_TRG ((uint32_t)0x00000004) /*!< TIM1 TRG Interrupt */ +#define SYSCFG_ITLINE13_SR_TIM1_CCU ((uint32_t)0x00000008) /*!< TIM1 CCU Interrupt */ +#define SYSCFG_ITLINE14_SR_TIM1_CC ((uint32_t)0x00000001) /*!< TIM1 CC Interrupt */ +#define SYSCFG_ITLINE15_SR_TIM2_GLB ((uint32_t)0x00000001) /*!< TIM2 GLB Interrupt */ +#define SYSCFG_ITLINE16_SR_TIM3_GLB ((uint32_t)0x00000001) /*!< TIM3 GLB Interrupt */ +#define SYSCFG_ITLINE17_SR_DAC ((uint32_t)0x00000001) /*!< DAC Interrupt */ +#define SYSCFG_ITLINE17_SR_TIM6_GLB ((uint32_t)0x00000002) /*!< TIM6 GLB Interrupt */ +#define SYSCFG_ITLINE18_SR_TIM7_GLB ((uint32_t)0x00000001) /*!< TIM7 GLB Interrupt */ +#define SYSCFG_ITLINE19_SR_TIM14_GLB ((uint32_t)0x00000001) /*!< TIM14 GLB Interrupt */ +#define SYSCFG_ITLINE20_SR_TIM15_GLB ((uint32_t)0x00000001) /*!< TIM15 GLB Interrupt */ +#define SYSCFG_ITLINE21_SR_TIM16_GLB ((uint32_t)0x00000001) /*!< TIM16 GLB Interrupt */ +#define SYSCFG_ITLINE22_SR_TIM17_GLB ((uint32_t)0x00000001) /*!< TIM17 GLB Interrupt */ +#define SYSCFG_ITLINE23_SR_I2C1_GLB ((uint32_t)0x00000001) /*!< I2C1 GLB Interrupt -> exti[23] */ +#define SYSCFG_ITLINE24_SR_I2C2_GLB ((uint32_t)0x00000001) /*!< I2C2 GLB Interrupt */ +#define SYSCFG_ITLINE25_SR_SPI1 ((uint32_t)0x00000001) /*!< SPI1 Interrupt */ +#define SYSCFG_ITLINE26_SR_SPI2 ((uint32_t)0x00000001) /*!< SPI2 Interrupt */ +#define SYSCFG_ITLINE27_SR_USART1_GLB ((uint32_t)0x00000001) /*!< USART1 GLB Interrupt -> exti[25] */ +#define SYSCFG_ITLINE28_SR_USART2_GLB ((uint32_t)0x00000001) /*!< USART2 GLB Interrupt -> exti[26] */ +#define SYSCFG_ITLINE29_SR_USART3_GLB ((uint32_t)0x00000001) /*!< USART3 GLB Interrupt -> exti[28] */ +#define SYSCFG_ITLINE29_SR_USART4_GLB ((uint32_t)0x00000002) /*!< USART4 GLB Interrupt */ +#define SYSCFG_ITLINE29_SR_USART5_GLB ((uint32_t)0x00000004) /*!< USART5 GLB Interrupt */ +#define SYSCFG_ITLINE29_SR_USART6_GLB ((uint32_t)0x00000008) /*!< USART6 GLB Interrupt */ +#define SYSCFG_ITLINE29_SR_USART7_GLB ((uint32_t)0x00000010) /*!< USART7 GLB Interrupt */ +#define SYSCFG_ITLINE29_SR_USART8_GLB ((uint32_t)0x00000020) /*!< USART8 GLB Interrupt */ +#define SYSCFG_ITLINE30_SR_CAN ((uint32_t)0x00000001) /*!< CAN Interrupt */ +#define SYSCFG_ITLINE30_SR_CEC ((uint32_t)0x00000002) /*!< CEC Interrupt */ + +/******************************************************************************/ +/* */ +/* Timers (TIM) */ +/* */ +/******************************************************************************/ +/******************* Bit definition for TIM_CR1 register ********************/ +#define TIM_CR1_CEN ((uint16_t)0x0001) /*!
      © COPYRIGHT 2014 STMicroelectronics
      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F0XX_CONF_H +#define __STM32F0XX_CONF_H + +/* Includes ------------------------------------------------------------------*/ +/* Comment the line below to disable peripheral header file inclusion */ +#include "stm32f0xx_adc.h" +#include "stm32f0xx_can.h" +#include "stm32f0xx_cec.h" +#include "stm32f0xx_comp.h" +#include "stm32f0xx_crc.h" +#include "stm32f0xx_crs.h" +#include "stm32f0xx_dac.h" +#include "stm32f0xx_dbgmcu.h" +#include "stm32f0xx_dma.h" +#include "stm32f0xx_exti.h" +#include "stm32f0xx_flash.h" +#include "stm32f0xx_gpio.h" +#include "stm32f0xx_i2c.h" +#include "stm32f0xx_iwdg.h" +#include "stm32f0xx_pwr.h" +#include "stm32f0xx_rcc.h" +#include "stm32f0xx_rtc.h" +#include "stm32f0xx_spi.h" +#include "stm32f0xx_syscfg.h" +#include "stm32f0xx_tim.h" +#include "stm32f0xx_usart.h" +#include "stm32f0xx_wwdg.h" +#include "stm32f0xx_misc.h" /* High level functions for NVIC and SysTick (add-on to CMSIS functions) */ + +/* Exported types ------------------------------------------------------------*/ +/* Exported constants --------------------------------------------------------*/ +/* Uncomment the line below to expanse the "assert_param" macro in the + Standard Peripheral Library drivers code */ +/* #define USE_FULL_ASSERT 1 */ + +/* Exported macro ------------------------------------------------------------*/ +#ifdef USE_FULL_ASSERT + +/** + * @brief The assert_param macro is used for function's parameters check. + * @param expr: If expr is false, it calls assert_failed function which reports + * the name of the source file and the source line number of the call + * that failed. If expr is true, it returns no value. + * @retval None + */ + #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__)) +/* Exported functions ------------------------------------------------------- */ + void assert_failed(uint8_t* file, uint32_t line); +#else + #define assert_param(expr) ((void)0) +#endif /* USE_FULL_ASSERT */ + +#endif /* __STM32F0XX_CONF_H */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/system_stm32f0xx.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/system_stm32f0xx.c new file mode 100644 index 00000000..a9aa42f7 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/system_stm32f0xx.c @@ -0,0 +1,331 @@ +/** + ****************************************************************************** + * @file system_stm32f0xx.c + * @author MCD Application Team + * @version V1.0.1 + * @date 17-August-2016 + * @brief CMSIS Cortex-M0 Device Peripheral Access Layer System Source File. + * This file contains the system clock configuration for STM32F0xx devices, + * and is generated by the clock configuration tool + * STM32f0xx_Clock_Configuration_V1.0.1.xls + * + * 1. This file provides two functions and one global variable to be called from + * user application: + * - SystemInit(): Setups the system clock (System clock source, PLL Multiplier + * and Divider factors, AHB/APBx prescalers and Flash settings), + * depending on the configuration made in the clock xls tool. + * This function is called at startup just after reset and + * before branch to main program. This call is made inside + * the "startup_stm32f0xx.s" file. + * + * - SystemCoreClock variable: Contains the core clock (HCLK), it can be used + * by the user application to setup the SysTick + * timer or configure other parameters. + * + * - SystemCoreClockUpdate(): Updates the variable SystemCoreClock and must + * be called whenever the core clock is changed + * during program execution. + * + * 2. After each device reset the HSI (8 MHz Range) is used as system clock source. + * Then SystemInit() function is called, in "startup_stm32f0xx.s" file, to + * configure the system clock before to branch to main program. + * + * 3. If the system clock source selected by user fails to startup, the SystemInit() + * function will do nothing and HSI still used as system clock source. User can + * add some code to deal with this issue inside the SetSysClock() function. + * + * 4. The default value of HSE crystal is set to 8MHz, refer to "HSE_VALUE" define + * in "stm32f0xx.h" file. When HSE is used as system clock source, directly or + * through PLL, and you are using different crystal you have to adapt the HSE + * value to your own configuration. + * + * 5. This file configures the system clock as follows: + *============================================================================= + *============================================================================= + * System Clock source | PLL(HSI) + *----------------------------------------------------------------------------- + * SYSCLK(Hz) | 48000000 + *----------------------------------------------------------------------------- + * HCLK(Hz) | 48000000 + *----------------------------------------------------------------------------- + * AHB Prescaler | 1 + *----------------------------------------------------------------------------- + * APB Prescaler | 1 + *----------------------------------------------------------------------------- + * HSE Frequency(Hz) | NA + *---------------------------------------------------------------------------- + * PLLMUL | 12 + *----------------------------------------------------------------------------- + * PREDIV | 2 + *----------------------------------------------------------------------------- + * Flash Latency(WS) | 1 + *----------------------------------------------------------------------------- + * Prefetch Buffer | ON + *----------------------------------------------------------------------------- + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2012 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/** @addtogroup CMSIS + * @{ + */ + +/** @addtogroup stm32f0xx_system + * @{ + */ + +/** @addtogroup STM32F0xx_System_Private_Includes + * @{ + */ + +#include "stm32f0xx.h" + +/** + * @} + */ + +/** @addtogroup STM32F0xx_System_Private_TypesDefinitions + * @{ + */ + +/** + * @} + */ + +/** @addtogroup STM32F0xx_System_Private_Defines + * @{ + */ +/** + * @} + */ + +/** @addtogroup STM32F0xx_System_Private_Macros + * @{ + */ + +/** + * @} + */ + +/** @addtogroup STM32F0xx_System_Private_Variables + * @{ + */ +uint32_t SystemCoreClock = 48000000; +__I uint8_t AHBPrescTable[16] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 6, 7, 8, 9}; + +/** + * @} + */ + +/** @addtogroup STM32F0xx_System_Private_FunctionPrototypes + * @{ + */ + +static void SetSysClock(void); + +/** + * @} + */ + +/** @addtogroup STM32F0xx_System_Private_Functions + * @{ + */ + +/** + * @brief Setup the microcontroller system. + * Initialize the Embedded Flash Interface, the PLL and update the + * SystemCoreClock variable. + * @param None + * @retval None + */ +void SystemInit (void) +{ + /* Set HSION bit */ + RCC->CR |= (uint32_t)0x00000001; + + /* Reset SW[1:0], HPRE[3:0], PPRE[2:0], ADCPRE and MCOSEL[2:0] bits */ + RCC->CFGR &= (uint32_t)0xF8FFB80C; + + /* Reset HSEON, CSSON and PLLON bits */ + RCC->CR &= (uint32_t)0xFEF6FFFF; + + /* Reset HSEBYP bit */ + RCC->CR &= (uint32_t)0xFFFBFFFF; + + /* Reset PLLSRC, PLLXTPRE and PLLMUL[3:0] bits */ + RCC->CFGR &= (uint32_t)0xFFC0FFFF; + + /* Reset PREDIV1[3:0] bits */ + RCC->CFGR2 &= (uint32_t)0xFFFFFFF0; + + /* Reset USARTSW[1:0], I2CSW, CECSW and ADCSW bits */ + RCC->CFGR3 &= (uint32_t)0xFFFFFEAC; + + /* Reset HSI14 bit */ + RCC->CR2 &= (uint32_t)0xFFFFFFFE; + + /* Disable all interrupts */ + RCC->CIR = 0x00000000; + + /* Configure the System clock frequency, AHB/APBx prescalers and Flash settings */ + SetSysClock(); +} + +/** + * @brief Update SystemCoreClock according to Clock Register Values + * The SystemCoreClock variable contains the core clock (HCLK), it can + * be used by the user application to setup the SysTick timer or configure + * other parameters. + * + * @note Each time the core clock (HCLK) changes, this function must be called + * to update SystemCoreClock variable value. Otherwise, any configuration + * based on this variable will be incorrect. + * + * @note - The system frequency computed by this function is not the real + * frequency in the chip. It is calculated based on the predefined + * constant and the selected clock source: + * + * - If SYSCLK source is HSI, SystemCoreClock will contain the HSI_VALUE(*) + * + * - If SYSCLK source is HSE, SystemCoreClock will contain the HSE_VALUE(**) + * + * - If SYSCLK source is PLL, SystemCoreClock will contain the HSE_VALUE(**) + * or HSI_VALUE(*) multiplied/divided by the PLL factors. + * + * (*) HSI_VALUE is a constant defined in stm32f0xx.h file (default value + * 8 MHz) but the real value may vary depending on the variations + * in voltage and temperature. + * + * (**) HSE_VALUE is a constant defined in stm32f0xx.h file (default value + * 8 MHz), user has to ensure that HSE_VALUE is same as the real + * frequency of the crystal used. Otherwise, this function may + * have wrong result. + * + * - The result of this function could be not correct when using fractional + * value for HSE crystal. + * @param None + * @retval None + */ +void SystemCoreClockUpdate (void) +{ + uint32_t tmp = 0, pllmull = 0, pllsource = 0, prediv1factor = 0; + + /* Get SYSCLK source -------------------------------------------------------*/ + tmp = RCC->CFGR & RCC_CFGR_SWS; + + switch (tmp) + { + case 0x00: /* HSI used as system clock */ + SystemCoreClock = HSI_VALUE; + break; + case 0x04: /* HSE used as system clock */ + SystemCoreClock = HSE_VALUE; + break; + case 0x08: /* PLL used as system clock */ + /* Get PLL clock source and multiplication factor ----------------------*/ + pllmull = RCC->CFGR & RCC_CFGR_PLLMULL; + pllsource = RCC->CFGR & RCC_CFGR_PLLSRC; + pllmull = ( pllmull >> 18) + 2; + + if (pllsource == 0x00) + { + /* HSI oscillator clock divided by 2 selected as PLL clock entry */ + SystemCoreClock = (HSI_VALUE >> 1) * pllmull; + } + else + { + prediv1factor = (RCC->CFGR2 & RCC_CFGR2_PREDIV1) + 1; + /* HSE oscillator clock selected as PREDIV1 clock entry */ + SystemCoreClock = (HSE_VALUE / prediv1factor) * pllmull; + } + break; + default: /* HSI used as system clock */ + SystemCoreClock = HSI_VALUE; + break; + } + /* Compute HCLK clock frequency ----------------*/ + /* Get HCLK prescaler */ + tmp = AHBPrescTable[((RCC->CFGR & RCC_CFGR_HPRE) >> 4)]; + /* HCLK clock frequency */ + SystemCoreClock >>= tmp; +} + +/** + * @brief Configures the System clock frequency, AHB/APBx prescalers and Flash + * settings. + * @note This function should be called only once the RCC clock configuration + * is reset to the default reset state (done in SystemInit() function). + * @param None + * @retval None + */ +static void SetSysClock(void) +{ +/******************************************************************************/ +/* PLL (clocked by HSI) used as System clock source */ +/******************************************************************************/ + + /* At this stage the HSI is already enabled and used as System clock source */ + + /* SYSCLK, HCLK, PCLK configuration ----------------------------------------*/ + + /* Enable Prefetch Buffer and set Flash Latency */ + FLASH->ACR = FLASH_ACR_PRFTBE | FLASH_ACR_LATENCY; + + /* HCLK = SYSCLK / 1 */ + RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1; + + /* PCLK = HCLK / 1 */ + RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE_DIV1; + + /* PLL configuration */ + RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLMULL)); + RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSI_Div2 | RCC_CFGR_PLLXTPRE_PREDIV1 | RCC_CFGR_PLLMULL12); + + /* Enable PLL */ + RCC->CR |= RCC_CR_PLLON; + + /* Wait till PLL is ready */ + while((RCC->CR & RCC_CR_PLLRDY) == 0) + { + } + + /* Select PLL as system clock source */ + RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW)); + RCC->CFGR |= (uint32_t)RCC_CFGR_SW_PLL; + + /* Wait till PLL is used as system clock source */ + while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)RCC_CFGR_SWS_PLL) + { + } +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ + diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/system_stm32f0xx.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/system_stm32f0xx.h new file mode 100644 index 00000000..619055de --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/lib/system_stm32f0xx.h @@ -0,0 +1,104 @@ +/** + ****************************************************************************** + * @file system_stm32f0xx.h + * @author MCD Application Team + * @version V1.5.0 + * @date 05-December-2014 + * @brief CMSIS Cortex-M0 Device Peripheral Access Layer System Header File. + ****************************************************************************** + * @attention + * + *

      © COPYRIGHT 2014 STMicroelectronics

      + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +/** @addtogroup CMSIS + * @{ + */ + +/** @addtogroup stm32f0xx_system + * @{ + */ + +/** + * @brief Define to prevent recursive inclusion + */ +#ifndef __SYSTEM_STM32F0XX_H +#define __SYSTEM_STM32F0XX_H + +#ifdef __cplusplus + extern "C" { +#endif + +/** @addtogroup STM32F0xx_System_Includes + * @{ + */ + +/** + * @} + */ + + +/** @addtogroup STM32F0xx_System_Exported_types + * @{ + */ + +extern uint32_t SystemCoreClock; /*!< System Clock Frequency (Core Clock) */ + +/** + * @} + */ + +/** @addtogroup STM32F0xx_System_Exported_Constants + * @{ + */ + +/** + * @} + */ + +/** @addtogroup STM32F0xx_System_Exported_Macros + * @{ + */ + +/** + * @} + */ + +/** @addtogroup STM32F0xx_System_Exported_Functions + * @{ + */ + +extern void SystemInit(void); +extern void SystemCoreClockUpdate(void); +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif /*__SYSTEM_STM32F0XX_H */ + +/** + * @} + */ + +/** + * @} + */ +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/main.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/main.c new file mode 100644 index 00000000..dcbb7f2e --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/main.c @@ -0,0 +1,81 @@ +/************************************************************************************//** +* \file Demo\ARMCM0_STM32F0_Nucleo_F091RC_GCC\Prog\main.c +* \brief Demo program application source file. +* \ingroup Prog_ARMCM0_STM32F0_Nucleo_F091RC_GCC +* \internal +*---------------------------------------------------------------------------------------- +* C O P Y R I G H T +*---------------------------------------------------------------------------------------- +* Copyright (c) 2016 by Feaser http://www.feaser.com All rights reserved +* +*---------------------------------------------------------------------------------------- +* L I C E N S E +*---------------------------------------------------------------------------------------- +* This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +* modify it under the terms of the GNU General Public License as published by the Free +* Software Foundation, either version 3 of the License, or (at your option) any later +* version. +* +* OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +* PURPOSE. See the GNU General Public License for more details. +* +* You have received a copy of the GNU General Public License along with OpenBLT. It +* should be located in ".\Doc\license.html". If not, contact Feaser to obtain a copy. +* +* \endinternal +****************************************************************************************/ + +/**************************************************************************************** +* Include files +****************************************************************************************/ +#include "header.h" /* generic header */ + + +/**************************************************************************************** +* Function prototypes +****************************************************************************************/ +static void Init(void); + + +/************************************************************************************//** +** \brief This is the entry point for the bootloader application and is called +** by the reset interrupt vector after the C-startup routines executed. +** \return none. +** +****************************************************************************************/ +int main(void) +{ + /* initialize the microcontroller */ + Init(); + /* initialize the bootloader interface */ + BootComInit(); + + /* start the infinite program loop */ + while (1) + { + /* toggle LED with a fixed frequency */ + LedToggle(); + /* check for bootloader activation request */ + BootComCheckActivationRequest(); + } + /* set program exit code. note that the program should never get here */ + return 0; +} /*** end of main ***/ + + +/************************************************************************************//** +** \brief Initializes the microcontroller. +** \return none. +** +****************************************************************************************/ +static void Init(void) +{ + /* init the led driver */ + LedInit(); + /* init the timer driver */ + TimerInit(); +} /*** end of Init ***/ + + +/*********************************** end of main.c *************************************/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/prog.dox b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/prog.dox new file mode 100644 index 00000000..084c9276 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/prog.dox @@ -0,0 +1,5 @@ +/** +\defgroup Prog_ARMCM0_STM32F0_Nucleo_F091RC_GCC User Program +\brief User Program. +\ingroup ARMCM0_STM32F0_Nucleo_F091RC_GCC +*/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/startup_stm32f0xx.S b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/startup_stm32f0xx.S new file mode 100644 index 00000000..d7a03ad3 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/startup_stm32f0xx.S @@ -0,0 +1,252 @@ +/* File: startup_ARMCM0.S + * Purpose: startup file for Cortex-M0 devices. Should use with + * GCC for ARM Embedded Processors + * Version: V1.3 + * Date: 08 Feb 2012 + * + * Copyright (c) 2012, ARM Limited + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of the ARM Limited nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ARM LIMITED BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + .syntax unified + .arch armv6-m + + .section .stack + .align 3 +#ifdef __STACK_SIZE + .equ Stack_Size, __STACK_SIZE +#else + .equ Stack_Size, 0x400 +#endif + .globl __StackTop + .globl __StackLimit +__StackLimit: + .space Stack_Size + .size __StackLimit, . - __StackLimit +__StackTop: + .size __StackTop, . - __StackTop + + .section .heap + .align 3 +#ifdef __HEAP_SIZE + .equ Heap_Size, __HEAP_SIZE +#else + .equ Heap_Size, 0xC00 +#endif + .globl __HeapBase + .globl __HeapLimit +__HeapBase: + .if Heap_Size + .space Heap_Size + .endif + .size __HeapBase, . - __HeapBase +__HeapLimit: + .size __HeapLimit, . - __HeapLimit + + .section .isr_vector + .align 2 + .globl __isr_vector +__isr_vector: + .long __StackTop /* Top of Stack */ + .long Reset_Handler /* Reset Handler */ + .long NMI_Handler /* NMI Handler */ + .long HardFault_Handler /* Hard Fault Handler */ + .long 0 /* Reserved */ + .long 0 /* Reserved */ + .long 0 /* Reserved */ + .long 0 /* Reserved */ + .long 0 /* Reserved */ + .long 0 /* Reserved */ + .long 0 /* Reserved */ + .long SVC_Handler /* SVCall Handler */ + .long 0 /* Reserved */ + .long 0 /* Reserved */ + .long PendSV_Handler /* PendSV Handler */ + .long SysTick_Handler /* SysTick Handler */ + + // External Interrupts + .long WWDG_IRQHandler // Window Watchdog + .long PVD_IRQHandler // PVD through EXTI Line detect + .long RTC_IRQHandler // RTC through EXTI Line + .long FLASH_IRQHandler // FLASH + .long RCC_IRQHandler // RCC + .long EXTI0_1_IRQHandler // EXTI Line 0 and 1 + .long EXTI2_3_IRQHandler // EXTI Line 2 and 3 + .long EXTI4_15_IRQHandler // EXTI Line 4 to 15 + .long TS_IRQHandler // TS + .long DMA1_Channel1_IRQHandler // DMA1 Channel 1 + .long DMA1_Channel2_3_IRQHandler // DMA1 Channel 2 and Channel 3 + .long DMA1_Channel4_5_IRQHandler // DMA1 Channel 4 and Channel 5 + .long ADC1_COMP_IRQHandler // ADC1, COMP1 and COMP2 + .long TIM1_BRK_UP_TRG_COM_IRQHandler // TIM1 Break, Update, Trigger and Commutation + .long TIM1_CC_IRQHandler // TIM1 Capture Compare + .long TIM2_IRQHandler // TIM2 + .long TIM3_IRQHandler // TIM3 + .long TIM6_DAC_IRQHandler // TIM6 and DAC + .long TIM7_IRQHandler // Not all devices!! + .long TIM14_IRQHandler // TIM14 + .long TIM15_IRQHandler // TIM15 + .long TIM16_IRQHandler // TIM16 + .long TIM17_IRQHandler // TIM17 + .long I2C1_IRQHandler // I2C1 + .long I2C2_IRQHandler // I2C2 + .long SPI1_IRQHandler // SPI1 + .long SPI2_IRQHandler // SPI2 + .long USART1_IRQHandler // USART1 + .long USART2_IRQHandler // USART2 + .long USART3_4_IRQHandler // Not all devices!! + .long CEC_IRQHandler // CEC + .long USB_IRQHandler // Not all devices!! + .long 0x55AA11EE // Reserved for OpenBLT checksum + + .size __isr_vector, . - __isr_vector + + .text + .thumb + .thumb_func + .align 2 + .globl Reset_Handler + .type Reset_Handler, %function +Reset_Handler: +/* Initialize the stackpointer. this is done automatically after a reset event, but + * this program is started by the bootloader and not a reset event. */ + ldr r1, =__StackTop + mov sp, r1 + +/* Loop to copy data from read only memory to RAM. The ranges + * of copy from/to are specified by following symbols evaluated in + * linker script. + * __etext: End of code section, i.e., begin of data sections to copy from. + * __data_start__/__data_end__: RAM address range that data should be + * copied to. Both must be aligned to 4 bytes boundary. */ + + ldr r1, =__etext + ldr r2, =__data_start__ + ldr r3, =__data_end__ + + subs r3, r2 + ble .flash_to_ram_loop_end + + movs r4, 0 +.flash_to_ram_loop: + ldr r0, [r1,r4] + str r0, [r2,r4] + adds r4, 4 + cmp r4, r3 + blt .flash_to_ram_loop +.flash_to_ram_loop_end: + +#ifndef __NO_SYSTEM_INIT + ldr r0, =SystemInit + blx r0 +#endif + + ldr r0, =_start + bx r0 + .pool + .size Reset_Handler, . - Reset_Handler + +/* Our weak _start alternative if we don't use the library _start + * The zero init section must be cleared, otherwise the librtary is + * doing that */ + .align 1 + .thumb_func + .weak _start + .type _start, %function +_start: + + /* Zero fill the bss segment. */ + ldr r1, = __bss_start__ + ldr r2, = __bss_end__ + movs r3, #0 + b .fill_zero_bss +.loop_zero_bss: + str r3, [r1] + adds r1, 4 + +.fill_zero_bss: + cmp r1, r2 + bcc .loop_zero_bss + + /* Jump to our main */ + bl main + b . + .size _start, . - _start + +/* Macro to define default handlers. Default handler + * will be weak symbol and just dead loops. They can be + * overwritten by other handlers */ + .macro def_irq_handler handler_name + .align 1 + .thumb_func + .weak \handler_name + .type \handler_name, %function +\handler_name : + b . + .size \handler_name, . - \handler_name + .endm + + def_irq_handler NMI_Handler + def_irq_handler HardFault_Handler + def_irq_handler SVC_Handler + def_irq_handler PendSV_Handler + def_irq_handler SysTick_Handler + def_irq_handler Default_Handler + + // External Interrupts + def_irq_handler WWDG_IRQHandler // Window Watchdog + def_irq_handler PVD_IRQHandler // PVD through EXTI Line detect + def_irq_handler RTC_IRQHandler // RTC through EXTI Line + def_irq_handler FLASH_IRQHandler // FLASH + def_irq_handler RCC_IRQHandler // RCC + def_irq_handler EXTI0_1_IRQHandler // EXTI Line 0 and 1 + def_irq_handler EXTI2_3_IRQHandler // EXTI Line 2 and 3 + def_irq_handler EXTI4_15_IRQHandler // EXTI Line 4 to 15 + def_irq_handler TS_IRQHandler // TS + def_irq_handler DMA1_Channel1_IRQHandler // DMA1 Channel 1 + def_irq_handler DMA1_Channel2_3_IRQHandler // DMA1 Channel 2 and Channel 3 + def_irq_handler DMA1_Channel4_5_IRQHandler // DMA1 Channel 4 and Channel 5 + def_irq_handler ADC1_COMP_IRQHandler // ADC1, COMP1 and COMP2 + def_irq_handler TIM1_BRK_UP_TRG_COM_IRQHandler // TIM1 Break, Update, Trigger and Commutation + def_irq_handler TIM1_CC_IRQHandler // TIM1 Capture Compare + def_irq_handler TIM2_IRQHandler // TIM2 + def_irq_handler TIM3_IRQHandler // TIM3 + def_irq_handler TIM6_DAC_IRQHandler // TIM6 and DAC + def_irq_handler TIM7_IRQHandler // Not all devices!! + def_irq_handler TIM14_IRQHandler // TIM14 + def_irq_handler TIM15_IRQHandler // TIM15 + def_irq_handler TIM16_IRQHandler // TIM16 + def_irq_handler TIM17_IRQHandler // TIM17 + def_irq_handler I2C1_IRQHandler // I2C1 + def_irq_handler I2C2_IRQHandler // I2C2 + def_irq_handler SPI1_IRQHandler // SPI1 + def_irq_handler SPI2_IRQHandler // SPI2 + def_irq_handler USART1_IRQHandler // USART1 + def_irq_handler USART2_IRQHandler // USART2 + def_irq_handler USART3_4_IRQHandler // Not all devices!! + def_irq_handler CEC_IRQHandler // CEC + def_irq_handler USB_IRQHandler // Not all devices!! + def_irq_handler BootRAM // Not all devices!! + + .end diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/timer.c b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/timer.c new file mode 100644 index 00000000..3b4ce433 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/timer.c @@ -0,0 +1,106 @@ +/************************************************************************************//** +* \file Demo\ARMCM0_STM32F0_Nucleo_F091RC_GCC\Prog\timer.c +* \brief Timer driver source file. +* \ingroup Prog_ARMCM0_STM32F0_Nucleo_F091RC_GCC +* \internal +*---------------------------------------------------------------------------------------- +* C O P Y R I G H T +*---------------------------------------------------------------------------------------- +* Copyright (c) 2016 by Feaser http://www.feaser.com All rights reserved +* +*---------------------------------------------------------------------------------------- +* L I C E N S E +*---------------------------------------------------------------------------------------- +* This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +* modify it under the terms of the GNU General Public License as published by the Free +* Software Foundation, either version 3 of the License, or (at your option) any later +* version. +* +* OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +* PURPOSE. See the GNU General Public License for more details. +* +* You have received a copy of the GNU General Public License along with OpenBLT. It +* should be located in ".\Doc\license.html". If not, contact Feaser to obtain a copy. +* +* \endinternal +****************************************************************************************/ + +/**************************************************************************************** +* Include files +****************************************************************************************/ +#include "header.h" /* generic header */ + + +/**************************************************************************************** +* Local data declarations +****************************************************************************************/ +/** \brief Local variable for storing the number of milliseconds that have elapsed since + * startup. + */ +static unsigned long millisecond_counter; + + +/************************************************************************************//** +** \brief Initializes the timer. +** \return none. +** +****************************************************************************************/ +void TimerInit(void) +{ + /* configure the SysTick timer for 1 ms period */ + SysTick_Config(SystemCoreClock / 1000); + /* reset the millisecond counter */ + TimerSet(0); +} /*** end of TimerInit ***/ + + +/************************************************************************************//** +** \brief Stops and disables the timer. +** \return none. +** +****************************************************************************************/ +void TimerDeinit(void) +{ + SysTick->CTRL = 0; +} /*** end of TimerDeinit ***/ + + +/************************************************************************************//** +** \brief Sets the initial counter value of the millisecond timer. +** \param timer_value initialize value of the millisecond timer. +** \return none. +** +****************************************************************************************/ +void TimerSet(unsigned long timer_value) +{ + /* set the millisecond counter */ + millisecond_counter = timer_value; +} /*** end of TimerSet ***/ + + +/************************************************************************************//** +** \brief Obtains the counter value of the millisecond timer. +** \return Current value of the millisecond timer. +** +****************************************************************************************/ +unsigned long TimerGet(void) +{ + /* read and return the millisecond counter value */ + return millisecond_counter; +} /*** end of TimerGet ***/ + + +/************************************************************************************//** +** \brief Interrupt service routine of the timer. +** \return none. +** +****************************************************************************************/ +void SysTick_Handler(void) +{ + /* increment the millisecond counter */ + millisecond_counter++; +} /*** end of SysTick_Handler ***/ + + +/*********************************** end of timer.c ************************************/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/timer.h b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/timer.h new file mode 100644 index 00000000..f6172200 --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/Prog/timer.h @@ -0,0 +1,40 @@ +/************************************************************************************//** +* \file Demo\ARMCM0_STM32F0_Nucleo_F091RC_GCC\Prog\timer.h +* \brief Timer driver header file. +* \ingroup Prog_ARMCM0_STM32F0_Nucleo_F091RC_GCC +* \internal +*---------------------------------------------------------------------------------------- +* C O P Y R I G H T +*---------------------------------------------------------------------------------------- +* Copyright (c) 2016 by Feaser http://www.feaser.com All rights reserved +* +*---------------------------------------------------------------------------------------- +* L I C E N S E +*---------------------------------------------------------------------------------------- +* This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +* modify it under the terms of the GNU General Public License as published by the Free +* Software Foundation, either version 3 of the License, or (at your option) any later +* version. +* +* OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +* PURPOSE. See the GNU General Public License for more details. +* +* You have received a copy of the GNU General Public License along with OpenBLT. It +* should be located in ".\Doc\license.html". If not, contact Feaser to obtain a copy. +* +* \endinternal +****************************************************************************************/ +#ifndef TIMER_H +#define TIMER_H + +/**************************************************************************************** +* Function prototypes +****************************************************************************************/ +void TimerInit(void); +void TimerDeinit(void); +void TimerSet(unsigned long timer_value); +unsigned long TimerGet(void); + +#endif /* TIMER_H */ +/*********************************** end of timer.h ************************************/ diff --git a/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/demo.dox b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/demo.dox new file mode 100644 index 00000000..1ff6c09e --- /dev/null +++ b/Target/Demo/ARMCM0_STM32F0_Nucleo_F091RC_GCC/demo.dox @@ -0,0 +1,8 @@ +/** +\defgroup ARMCM0_STM32F0_Nucleo_F091RC_GCC Demo for Nucleo-F091RC +\brief Preconfigured programs for the Nucleo-F091RC and the GNU ARM GCC compiler. +\details Refer to http://feaser.com/openblt/doku.php?id=manual:demos + for detailed getting started instructions. +*/ + + diff --git a/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_GCC/Boot/bin/openblt_stm32f303.elf b/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_GCC/Boot/bin/openblt_stm32f303.elf index 7cbe7c9715bc9f57f65af272acfde08d337aa7c5..c38e6a3d3b6e6a90fe1652692d65649cc1527bfa 100644 GIT binary patch delta 2312 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 SSN5$pO{hNuB_2pmKK}rOD<7Z$ diff --git a/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_GCC/Boot/bin/openblt_stm32f303.map b/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_GCC/Boot/bin/openblt_stm32f303.map index f49f45fe..436775d8 100644 --- a/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_GCC/Boot/bin/openblt_stm32f303.map +++ b/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_GCC/Boot/bin/openblt_stm32f303.map @@ -4343,7 +4343,7 @@ Discarded input sections .debug_macro 0x00000000 0x10 ..\obj\~#\~#\~#\source\file.o .debug_macro 0x00000000 0x35 ..\obj\~#\~#\~#\source\file.o .debug_macro 0x00000000 0xac ..\obj\~#\~#\~#\source\file.o - .debug_line 0x00000000 0x2ff ..\obj\~#\~#\~#\source\file.o + .debug_line 0x00000000 0x303 ..\obj\~#\~#\~#\source\file.o .debug_str 0x00000000 0x602f ..\obj\~#\~#\~#\source\file.o .comment 0x00000000 0x6f ..\obj\~#\~#\~#\source\file.o .ARM.attributes @@ -4374,7 +4374,7 @@ Discarded input sections .debug_macro 0x00000000 0x1c ..\obj\~#\~#\~#\source\net.o .debug_macro 0x00000000 0x9f ..\obj\~#\~#\~#\source\net.o .debug_macro 0x00000000 0x40 ..\obj\~#\~#\~#\source\net.o - .debug_line 0x00000000 0xf3 ..\obj\~#\~#\~#\source\net.o + .debug_line 0x00000000 0xf7 ..\obj\~#\~#\~#\source\net.o .debug_str 0x00000000 0x2e95 ..\obj\~#\~#\~#\source\net.o .comment 0x00000000 0x6f ..\obj\~#\~#\~#\source\net.o .ARM.attributes @@ -5272,29 +5272,29 @@ OUTPUT(..\bin\openblt_stm32f303.elf elf32-littlearm) .debug_macro 0x00014701 0x91 ..\obj\~#\~#\~#\source\cop.o .debug_macro 0x00014792 0x157 ..\obj\~#\~#\~#\source\xcp.o -.debug_line 0x00000000 0x542e - .debug_line 0x00000000 0x55d ..\obj\hooks.o - .debug_line 0x0000055d 0x55b ..\obj\led.o - .debug_line 0x00000ab8 0x71a ..\obj\lib\spl\src\stm32f30x_flash.o - .debug_line 0x000011d2 0x58f ..\obj\lib\spl\src\stm32f30x_gpio.o - .debug_line 0x00001761 0x84b ..\obj\lib\spl\src\stm32f30x_rcc.o - .debug_line 0x00001fac 0x848 ..\obj\lib\spl\src\stm32f30x_usart.o - .debug_line 0x000027f4 0x4c3 ..\obj\lib\system_stm32f30x.o - .debug_line 0x00002cb7 0x565 ..\obj\main.o - .debug_line 0x0000321c 0x1d4 ..\obj\~#\~#\~#\source\armcm4_stm32f3\can.o - .debug_line 0x000033f0 0x168 ..\obj\~#\~#\~#\source\armcm4_stm32f3\cpu.o - .debug_line 0x00003558 0x6c1 ..\obj\~#\~#\~#\source\armcm4_stm32f3\flash.o - .debug_line 0x00003c19 0x140 ..\obj\~#\~#\~#\source\armcm4_stm32f3\gcc\cpu_comp.o - .debug_line 0x00003d59 0xc2 ..\obj\~#\~#\~#\source\armcm4_stm32f3\gcc\cstart.o - .debug_line 0x00003e1b 0x195 ..\obj\~#\~#\~#\source\armcm4_stm32f3\nvm.o - .debug_line 0x00003fb0 0x583 ..\obj\~#\~#\~#\source\armcm4_stm32f3\timer.o - .debug_line 0x00004533 0x5ea ..\obj\~#\~#\~#\source\armcm4_stm32f3\uart.o - .debug_line 0x00004b1d 0x10a ..\obj\~#\~#\~#\source\assert.o - .debug_line 0x00004c27 0x126 ..\obj\~#\~#\~#\source\backdoor.o - .debug_line 0x00004d4d 0x11d ..\obj\~#\~#\~#\source\boot.o - .debug_line 0x00004e6a 0x1a2 ..\obj\~#\~#\~#\source\com.o - .debug_line 0x0000500c 0x113 ..\obj\~#\~#\~#\source\cop.o - .debug_line 0x0000511f 0x30f ..\obj\~#\~#\~#\source\xcp.o +.debug_line 0x00000000 0x538e + .debug_line 0x00000000 0x55f ..\obj\hooks.o + .debug_line 0x0000055f 0x55d ..\obj\led.o + .debug_line 0x00000abc 0x71a ..\obj\lib\spl\src\stm32f30x_flash.o + .debug_line 0x000011d6 0x58f ..\obj\lib\spl\src\stm32f30x_gpio.o + .debug_line 0x00001765 0x84b ..\obj\lib\spl\src\stm32f30x_rcc.o + .debug_line 0x00001fb0 0x848 ..\obj\lib\spl\src\stm32f30x_usart.o + .debug_line 0x000027f8 0x4c3 ..\obj\lib\system_stm32f30x.o + .debug_line 0x00002cbb 0x567 ..\obj\main.o + .debug_line 0x00003222 0x1b4 ..\obj\~#\~#\~#\source\armcm4_stm32f3\can.o + .debug_line 0x000033d6 0x148 ..\obj\~#\~#\~#\source\armcm4_stm32f3\cpu.o + .debug_line 0x0000351e 0x6a1 ..\obj\~#\~#\~#\source\armcm4_stm32f3\flash.o + .debug_line 0x00003bbf 0x142 ..\obj\~#\~#\~#\source\armcm4_stm32f3\gcc\cpu_comp.o + .debug_line 0x00003d01 0xc2 ..\obj\~#\~#\~#\source\armcm4_stm32f3\gcc\cstart.o + .debug_line 0x00003dc3 0x175 ..\obj\~#\~#\~#\source\armcm4_stm32f3\nvm.o + .debug_line 0x00003f38 0x563 ..\obj\~#\~#\~#\source\armcm4_stm32f3\timer.o + .debug_line 0x0000449b 0x5ca ..\obj\~#\~#\~#\source\armcm4_stm32f3\uart.o + .debug_line 0x00004a65 0x10e ..\obj\~#\~#\~#\source\assert.o + .debug_line 0x00004b73 0x12a ..\obj\~#\~#\~#\source\backdoor.o + .debug_line 0x00004c9d 0x121 ..\obj\~#\~#\~#\source\boot.o + .debug_line 0x00004dbe 0x1a6 ..\obj\~#\~#\~#\source\com.o + .debug_line 0x00004f64 0x117 ..\obj\~#\~#\~#\source\cop.o + .debug_line 0x0000507b 0x313 ..\obj\~#\~#\~#\source\xcp.o .debug_str 0x00000000 0x7ebab .debug_str 0x00000000 0x7bf27 ..\obj\hooks.o diff --git a/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_GCC/Boot/ide/stm32f303.ebp b/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_GCC/Boot/ide/stm32f303.ebp index 19a6abec..279b4896 100644 --- a/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_GCC/Boot/ide/stm32f303.ebp +++ b/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_GCC/Boot/ide/stm32f303.ebp @@ -42,13 +42,13 @@ - - - - + + + + diff --git a/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_GCC/Prog/ide/stm32f303.ebp b/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_GCC/Prog/ide/stm32f303.ebp index cce2fbc2..78e97d84 100644 --- a/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_GCC/Prog/ide/stm32f303.ebp +++ b/Target/Demo/ARMCM4_STM32F3_Nucleo_F303K8_GCC/Prog/ide/stm32f303.ebp @@ -42,13 +42,10 @@ - - - - + diff --git a/Target/Source/ARMCM0_STM32F0/can.c b/Target/Source/ARMCM0_STM32F0/can.c new file mode 100644 index 00000000..1fe8bbf3 --- /dev/null +++ b/Target/Source/ARMCM0_STM32F0/can.c @@ -0,0 +1,243 @@ +/************************************************************************************//** +* \file Source\ARMCM0_STM32F0\can.c +* \brief Bootloader CAN communication interface source file. +* \ingroup Target_ARMCM0_STM32F0 +* \internal +*---------------------------------------------------------------------------------------- +* C O P Y R I G H T +*---------------------------------------------------------------------------------------- +* Copyright (c) 2016 by Feaser http://www.feaser.com All rights reserved +* +*---------------------------------------------------------------------------------------- +* L I C E N S E +*---------------------------------------------------------------------------------------- +* This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or +* modify it under the terms of the GNU General Public License as published by the Free +* Software Foundation, either version 3 of the License, or (at your option) any later +* version. +* +* OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +* PURPOSE. See the GNU General Public License for more details. +* +* You have received a copy of the GNU General Public License along with OpenBLT. It +* should be located in ".\Doc\license.html". If not, contact Feaser to obtain a copy. +* +* \endinternal +****************************************************************************************/ + + +/**************************************************************************************** +* Include files +****************************************************************************************/ +#include "boot.h" /* bootloader generic header */ +#include "stm32f0xx.h" /* STM32 registers and drivers */ + + +#if (BOOT_COM_CAN_ENABLE > 0) +/**************************************************************************************** +* Type definitions +****************************************************************************************/ +/** \brief Structure type for grouping CAN bus timing related information. */ +typedef struct t_can_bus_timing +{ + blt_int8u tseg1; /**< CAN time segment 1 */ + blt_int8u tseg2; /**< CAN time segment 2 */ +} tCanBusTiming; + + +/**************************************************************************************** +* Local constant declarations +****************************************************************************************/ +/** \brief CAN bittiming table for dynamically calculating the bittiming settings. + * \details According to the CAN protocol 1 bit-time can be made up of between 8..25 + * time quanta (TQ). The total TQ in a bit is SYNC + TSEG1 + TSEG2 with SYNC + * always being 1. The sample point is (SYNC + TSEG1) / (SYNC + TSEG1 + SEG2) * + * 100%. This array contains possible and valid time quanta configurations with + * a sample point between 68..78%. + */ +static const tCanBusTiming canTiming[] = +{ + /* TQ | TSEG1 | TSEG2 | SP */ + /* ------------------------- */ + { 5, 2 }, /* 8 | 5 | 2 | 75% */ + { 6, 2 }, /* 9 | 6 | 2 | 78% */ + { 6, 3 }, /* 10 | 6 | 3 | 70% */ + { 7, 3 }, /* 11 | 7 | 3 | 73% */ + { 8, 3 }, /* 12 | 8 | 3 | 75% */ + { 9, 3 }, /* 13 | 9 | 3 | 77% */ + { 9, 4 }, /* 14 | 9 | 4 | 71% */ + { 10, 4 }, /* 15 | 10 | 4 | 73% */ + { 11, 4 }, /* 16 | 11 | 4 | 75% */ + { 12, 4 }, /* 17 | 12 | 4 | 76% */ + { 12, 5 }, /* 18 | 12 | 5 | 72% */ + { 13, 5 }, /* 19 | 13 | 5 | 74% */ + { 14, 5 }, /* 20 | 14 | 5 | 75% */ + { 15, 5 }, /* 21 | 15 | 5 | 76% */ + { 15, 6 }, /* 22 | 15 | 6 | 73% */ + { 16, 6 }, /* 23 | 16 | 6 | 74% */ + { 16, 7 }, /* 24 | 16 | 7 | 71% */ + { 16, 8 } /* 25 | 16 | 8 | 68% */ +}; + + +/************************************************************************************//** +** \brief Search algorithm to match the desired baudrate to a possible bus +** timing configuration. +** \param baud The desired baudrate in bps. Valid values are 10..1000kpbs. +** \param prescaler Pointer to where the value for the prescaler will be stored. +** \param bitTiming Pointer to where the values for TSEG1 and TSEG2 will be stored. +** \return TRUE if the CAN bustiming register values were found, FALSE otherwise. +** +****************************************************************************************/ +static blt_bool CanGetSpeedConfig(blt_int32u baud, blt_int16u *prescaler, tCanBusTiming *bitTiming) + +{ + blt_int8u cnt; + blt_int32u canClockFreqHz; + RCC_ClocksTypeDef rccClocks; + + /* get the speed of the CAN peripheral clock (fAPB) */ + RCC_GetClocksFreq(&rccClocks); + canClockFreqHz = rccClocks.PCLK_Frequency; + + /* loop through all possible time quanta configurations to find a match */ + for (cnt=0; cnt < sizeof(canTiming)/sizeof(canTiming[0]); cnt++) + { + if ((canClockFreqHz % (baud*(canTiming[cnt].tseg1+canTiming[cnt].tseg2+1))) == 0) + { + /* compute the prescaler that goes with this TQ configuration */ + *prescaler = canClockFreqHz/(baud*(canTiming[cnt].tseg1+canTiming[cnt].tseg2+1)); + + /* make sure the prescaler is valid */ + if ((*prescaler > 0) && (*prescaler <= 1024)) + { + /* store the bittiming configuration */ + bitTiming->tseg1 = canTiming[cnt].tseg1; + bitTiming->tseg2 = canTiming[cnt].tseg2; + /* found a good bus timing configuration */ + return BLT_TRUE; + } + } + } + /* could not find a good bus timing configuration */ + return BLT_FALSE; +} /*** end of CanGetSpeedConfig ***/ + + +/************************************************************************************//** +** \brief Initializes the CAN controller and synchronizes it to the CAN bus. +** \return none. +** +****************************************************************************************/ +void CanInit(void) +{ + CAN_InitTypeDef CAN_InitStructure; + CAN_FilterInitTypeDef CAN_FilterInitStructure; + blt_int16u prescaler = 1; + tCanBusTiming bitTiming = { 1, 1 }; + blt_bool result; + + /* the current implementation supports CAN1. throw an assertion error in case a + * different CAN channel is configured. + */ + ASSERT_CT(BOOT_COM_CAN_CHANNEL_INDEX == 0); + /* obtain bittiming configuration information */ + result = CanGetSpeedConfig(BOOT_COM_CAN_BAUDRATE, &prescaler, &bitTiming); + ASSERT_RT(result == BLT_TRUE); + + /* CAN register init */ + CAN_DeInit(CAN); + CAN_StructInit(&CAN_InitStructure); + /* CAN cell init */ + CAN_InitStructure.CAN_TTCM = DISABLE; + CAN_InitStructure.CAN_ABOM = DISABLE; + CAN_InitStructure.CAN_AWUM = DISABLE; + CAN_InitStructure.CAN_NART = DISABLE; + CAN_InitStructure.CAN_RFLM = DISABLE; + CAN_InitStructure.CAN_TXFP = DISABLE; + CAN_InitStructure.CAN_Mode = CAN_Mode_Normal; + CAN_InitStructure.CAN_SJW = CAN_SJW_1tq; + CAN_InitStructure.CAN_BS1 = bitTiming.tseg1 - 1; + CAN_InitStructure.CAN_BS2 = bitTiming.tseg2 - 1; + CAN_InitStructure.CAN_Prescaler = prescaler; + CAN_Init(CAN, &CAN_InitStructure); + /* CAN filter init - receive all messages */ + CAN_FilterInitStructure.CAN_FilterNumber = 0; + CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdMask; + CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit; + CAN_FilterInitStructure.CAN_FilterIdHigh = 0x0000; + CAN_FilterInitStructure.CAN_FilterIdLow = 0x0000; + CAN_FilterInitStructure.CAN_FilterMaskIdHigh = 0x0000; + CAN_FilterInitStructure.CAN_FilterMaskIdLow = 0x0000; + CAN_FilterInitStructure.CAN_FilterFIFOAssignment = 0; + CAN_FilterInitStructure.CAN_FilterActivation = ENABLE; + CAN_FilterInit(&CAN_FilterInitStructure); +} /*** end of CanInit ***/ + + +/************************************************************************************//** +** \brief Transmits a packet formatted for the communication interface. +** \param data Pointer to byte array with data that it to be transmitted. +** \param len Number of bytes that are to be transmitted. +** \return none. +** +****************************************************************************************/ +void CanTransmitPacket(blt_int8u *data, blt_int8u len) +{ + CanTxMsg txMsg; + uint8_t byteIdx; + uint8_t txMailbox; + + /* prepare message */ + txMsg.IDE = CAN_ID_STD; + txMsg.StdId = BOOT_COM_CAN_TX_MSG_ID; + txMsg.RTR = CAN_RTR_DATA; + txMsg.DLC = len; + for (byteIdx=0; byteIdx 0) + { + /* receive the message */ + CAN_Receive(CAN, CAN_FIFO0, &rxMsg); + /* check if this is the message we are looking for */ + if ( (rxMsg.IDE == CAN_ID_STD) && (rxMsg.StdId == BOOT_COM_CAN_RX_MSG_ID) ) + { + for (byteIdx=0; byteIdx 0 */ + + +/*********************************** end of can.c **************************************/