/** ****************************************************************************** * @file startup_stm32f4xx.s * @author Coocox * @version V1.0 * @date 03/05/2012 * @brief STM32F4xx Devices vector table for RIDE7 toolchain. * This module performs: * - Set the initial SP * - Set the initial PC == Reset_Handler, * - Set the vector table entries with the exceptions ISR address * - Configure the clock system and the external SRAM mounted on * STM324xG-EVAL board to be used as data memory (optional, * to be enabled by user) * - Branches to main in the C library (which eventually * calls main()). * After Reset the Cortex-M4 processor is in Thread mode, * priority is Privileged, and the Stack is set to Main. ****************************************************************************** */ /* Some modifications by Andy Uribe CA6JAU : - Added C++ global constructors support - Changed initial stack pointer - Changed support for STM32F767 */ /*----------Macro definition--------------------------------------------------*/ #define WEAK __attribute__ ((weak)) /*----------Declaration of the default fault handlers-------------------------*/ /* System exception vector handler */ __attribute__ ((used)) void WEAK Reset_Handler(void); void WEAK NMI_Handler(void); void WEAK HardFault_Handler(void); void WEAK MemManage_Handler(void); void WEAK BusFault_Handler(void); void WEAK UsageFault_Handler(void); void WEAK SVC_Handler(void); void WEAK DebugMon_Handler(void); void WEAK PendSV_Handler(void); void WEAK SysTick_Handler(void); /* External Interrupts */ void WEAK WWDG_IRQHandler(void); /* Window WatchDog */ void WEAK PVD_IRQHandler(void); /* PVD through EXTI Line detection */ void WEAK TAMP_STAMP_IRQHandler(void); /* Tamper and TimeStamps through the EXTI line */ void WEAK RTC_WKUP_IRQHandler(void); /* RTC Wakeup through the EXTI line */ void WEAK FLASH_IRQHandler(void); /* FLASH */ void WEAK RCC_IRQHandler(void); /* RCC */ void WEAK EXTI0_IRQHandler(void); /* EXTI Line0 */ void WEAK EXTI1_IRQHandler(void); /* EXTI Line1 */ void WEAK EXTI2_IRQHandler(void); /* EXTI Line2 */ void WEAK EXTI3_IRQHandler(void); /* EXTI Line3 */ void WEAK EXTI4_IRQHandler(void); /* EXTI Line4 */ void WEAK DMA1_Stream0_IRQHandler(void); /* DMA1 Stream 0 */ void WEAK DMA1_Stream1_IRQHandler(void); /* DMA1 Stream 1 */ void WEAK DMA1_Stream2_IRQHandler(void); /* DMA1 Stream 2 */ void WEAK DMA1_Stream3_IRQHandler(void); /* DMA1 Stream 3 */ void WEAK DMA1_Stream4_IRQHandler(void); /* DMA1 Stream 4 */ void WEAK DMA1_Stream5_IRQHandler(void); /* DMA1 Stream 5 */ void WEAK DMA1_Stream6_IRQHandler(void); /* DMA1 Stream 6 */ void WEAK ADC_IRQHandler(void); /* ADC1, ADC2 and ADC3s */ void WEAK CAN1_TX_IRQHandler(void); /* CAN1 TX */ void WEAK CAN1_RX0_IRQHandler(void); /* CAN1 RX0 */ void WEAK CAN1_RX1_IRQHandler(void); /* CAN1 RX1 */ void WEAK CAN1_SCE_IRQHandler(void); /* CAN1 SCE */ void WEAK EXTI9_5_IRQHandler(void); /* External Line[9:5]s */ void WEAK TIM1_BRK_TIM9_IRQHandler(void); /* TIM1 Break and TIM9 */ void WEAK TIM1_UP_TIM10_IRQHandler(void); /* TIM1 Update and TIM10 */ void WEAK TIM1_TRG_COM_TIM11_IRQHandler(void); /* TIM1 Trigger and Commutation and TIM11 */ void WEAK TIM1_CC_IRQHandler(void); /* TIM1 Capture Compare */ void WEAK TIM2_IRQHandler(void); /* TIM2 */ void WEAK TIM3_IRQHandler(void); /* TIM3 */ void WEAK TIM4_IRQHandler(void); /* TIM4 */ void WEAK I2C1_EV_IRQHandler(void); /* I2C1 Event */ void WEAK I2C1_ER_IRQHandler(void); /* I2C1 Error */ void WEAK I2C2_EV_IRQHandler(void); /* I2C2 Event */ void WEAK I2C2_ER_IRQHandler(void); /* I2C2 Error */ void WEAK SPI1_IRQHandler(void); /* SPI1 */ void WEAK SPI2_IRQHandler(void); /* SPI2 */ void WEAK USART1_IRQHandler(void); /* USART1 */ void WEAK USART2_IRQHandler(void); /* USART2 */ void WEAK USART3_IRQHandler(void); /* USART3 */ void WEAK EXTI15_10_IRQHandler(void); /* External Line[15:10]s */ void WEAK RTC_Alarm_IRQHandler(void); /* RTC Alarm (A and B) through EXTI Line */ void WEAK OTG_FS_WKUP_IRQHandler(void); /* USB OTG FS Wakeup through EXTI line */ void WEAK TIM8_BRK_TIM12_IRQHandler(void); /* TIM8 Break and TIM12 */ void WEAK TIM8_UP_TIM13_IRQHandler(void); /* TIM8 Update and TIM13 */ void WEAK TIM8_TRG_COM_TIM14_IRQHandler(void); /* TIM8 Trigger and Commutation and TIM14 */ void WEAK TIM8_CC_IRQHandler(void); /* TIM8 Capture Compare */ void WEAK DMA1_Stream7_IRQHandler(void); /* DMA1 Stream7 */ void WEAK FMC_IRQHandler(void); /* FMC */ void WEAK SDMMC1_IRQHandler(void); /* SDMMC1 */ void WEAK TIM5_IRQHandler(void); /* TIM5 */ void WEAK SPI3_IRQHandler(void); /* SPI3 */ void WEAK UART4_IRQHandler(void); /* UART4 */ void WEAK UART5_IRQHandler(void); /* UART5 */ void WEAK TIM6_DAC_IRQHandler(void); /* TIM6 and DAC1&2 underrun errors */ void WEAK TIM7_IRQHandler(void); /* TIM7 */ void WEAK DMA2_Stream0_IRQHandler(void); /* DMA2 Stream 0 */ void WEAK DMA2_Stream1_IRQHandler(void); /* DMA2 Stream 1 */ void WEAK DMA2_Stream2_IRQHandler(void); /* DMA2 Stream 2 */ void WEAK DMA2_Stream3_IRQHandler(void); /* DMA2 Stream 3 */ void WEAK DMA2_Stream4_IRQHandler(void); /* DMA2 Stream 4 */ void WEAK ETH_IRQHandler(void); /* Ethernet */ void WEAK ETH_WKUP_IRQHandler(void); /* Ethernet Wakeup through EXTI line */ void WEAK CAN2_TX_IRQHandler(void); /* CAN2 TX */ void WEAK CAN2_RX0_IRQHandler(void); /* CAN2 RX0 */ void WEAK CAN2_RX1_IRQHandler(void); /* CAN2 RX1 */ void WEAK CAN2_SCE_IRQHandler(void); /* CAN2 SCE */ void WEAK OTG_FS_IRQHandler(void); /* USB OTG FS */ void WEAK DMA2_Stream5_IRQHandler(void); /* DMA2 Stream 5 */ void WEAK DMA2_Stream6_IRQHandler(void); /* DMA2 Stream 6 */ void WEAK DMA2_Stream7_IRQHandler(void); /* DMA2 Stream 7 */ void WEAK USART6_IRQHandler(void); /* USART6 */ void WEAK I2C3_EV_IRQHandler(void); /* I2C3 event */ void WEAK I2C3_ER_IRQHandler(void); /* I2C3 error */ void WEAK OTG_HS_EP1_OUT_IRQHandler(void); /* USB OTG HS End Point 1 Out */ void WEAK OTG_HS_EP1_IN_IRQHandler(void); /* USB OTG HS End Point 1 In */ void WEAK OTG_HS_WKUP_IRQHandler(void); /* USB OTG HS Wakeup through EXTI */ void WEAK OTG_HS_IRQHandler(void); /* USB OTG HS */ void WEAK DCMI_IRQHandler(void); /* DCMI */ void WEAK RNG_IRQHandler(void); /* RNG */ void WEAK FPU_IRQHandler(void); /* FPU */ void WEAK UART7_IRQHandler(void); /* UART7 */ void WEAK UART8_IRQHandler(void); /* UART8 */ void WEAK SPI4_IRQHandler(void); /* SPI4 */ void WEAK SPI5_IRQHandler(void); /* SPI5 */ void WEAK SPI6_IRQHandler(void); /* SPI6 */ void WEAK SAI1_IRQHandler(void); /* SAI1 */ void WEAK LTDC_IRQHandler(void); /* LTDC */ void WEAK LTDC_ER_IRQHandler(void); /* LTDC error */ void WEAK DMA2D_IRQHandler(void); /* DMA2D */ void WEAK SAI2_IRQHandler(void); /* SAI2 */ void WEAK QUADSPI_IRQHandler(void); /* QUADSPI */ void WEAK LPTIM1_IRQHandler(void); /* LPTIM1 */ void WEAK CEC_IRQHandler(void); /* HDMI_CEC */ void WEAK I2C4_EV_IRQHandler(void); /* I2C4 Event */ void WEAK I2C4_ER_IRQHandler(void); /* I2C4 Error */ void WEAK SPDIF_RX_IRQHandler(void); /* SPDIF_RX */ void WEAK DFSDM1_FLT0_IRQHandler(void); /* DFSDM1 Filter 0 global Interrupt */ void WEAK DFSDM1_FLT1_IRQHandler(void); /* DFSDM1 Filter 1 global Interrupt */ void WEAK DFSDM1_FLT2_IRQHandler(void); /* DFSDM1 Filter 2 global Interrupt */ void WEAK DFSDM1_FLT3_IRQHandler(void); /* DFSDM1 Filter 3 global Interrupt */ void WEAK SDMMC2_IRQHandler(void); /* SDMMC2 */ void WEAK CAN3_TX_IRQHandler(void); /* CAN3 TX */ void WEAK CAN3_RX0_IRQHandler(void); /* CAN3 RX0 */ void WEAK CAN3_RX1_IRQHandler(void); /* CAN3 RX1 */ void WEAK CAN3_SCE_IRQHandler(void); /* CAN3 SCE */ void WEAK JPEG_IRQHandler(void); /* JPEG */ void WEAK MDIOS_IRQHandler(void); /* MDIOS */ /*----------Symbols defined in linker script----------------------------------*/ extern unsigned long _estack; /*!< The initial stack pointer */ extern unsigned long _sidata; /*!< Start address for the initialization values of the .data section. */ extern unsigned long _sdata; /*!< Start address for the .data section */ extern unsigned long _edata; /*!< End address for the .data section */ extern unsigned long _sbss; /*!< Start address for the .bss section */ extern unsigned long _ebss; /*!< End address for the .bss section */ /* C++ global constructors support */ extern unsigned long __preinit_array_start; extern unsigned long __preinit_array_end; extern unsigned long __init_array_start; extern unsigned long __init_array_end; /*----------Function prototypes-----------------------------------------------*/ extern int main(void); /*!< The entry point for the application. */ //extern void SystemInit(void); /*!< Setup the microcontroller system(CMSIS) */ void Default_Reset_Handler(void); /*!< Default reset handler */ static void Default_Handler(void); /*!< Default exception handler */ static void call_constructors(unsigned long *start, unsigned long *end) __attribute((noinline)); /** *@brief The minimal vector table for a Cortex M3. Note that the proper constructs * must be placed on this to ensure that it ends up at physical address * 0x00000000. */ __attribute__ ((used,section(".isr_vector"))) void (* const g_pfnVectors[])(void) = { /*----------Core Exceptions------------------------------------------------ */ (void *) &_estack, /*!< The initial stack pointer */ Reset_Handler, /*!< Reset Handler */ NMI_Handler, /*!< NMI Handler */ HardFault_Handler, /*!< Hard Fault Handler */ MemManage_Handler, /*!< MPU Fault Handler */ BusFault_Handler, /*!< Bus Fault Handler */ UsageFault_Handler, /*!< Usage Fault Handler */ 0,0,0,0, /*!< Reserved */ SVC_Handler, /*!< SVCall Handler */ DebugMon_Handler, /*!< Debug Monitor Handler */ 0, /*!< Reserved */ PendSV_Handler, /*!< PendSV Handler */ SysTick_Handler, /*!< SysTick Handler */ /*----------External Exceptions---------------------------------------------*/ WWDG_IRQHandler, /*!< 0: Window WatchDog */ PVD_IRQHandler, /*!< 1: PVD through EXTI Line detection */ TAMP_STAMP_IRQHandler, /*!< 2: Tamper and TimeStamps through the EXTI line*/ RTC_WKUP_IRQHandler, /*!< 3: RTC Wakeup through the EXTI line */ FLASH_IRQHandler, /*!< 4: FLASH */ RCC_IRQHandler , /*!< 5: RCC */ EXTI0_IRQHandler, /*!< 6: EXTI Line0 */ EXTI1_IRQHandler, /*!< 7: EXTI Line1 */ EXTI2_IRQHandler, /*!< 8: EXTI Line2 */ EXTI3_IRQHandler, /*!< 9: EXTI Line3 */ EXTI4_IRQHandler, /*!< 10: EXTI Line4 */ DMA1_Stream0_IRQHandler, /*!< 11: DMA1 Stream 0 */ DMA1_Stream1_IRQHandler, /*!< 12: DMA1 Stream 1 */ DMA1_Stream2_IRQHandler, /*!< 13: DMA1 Stream 2 */ DMA1_Stream3_IRQHandler, /*!< 14: DMA1 Stream 3 */ DMA1_Stream4_IRQHandler, /*!< 15: DMA1 Stream 4 */ DMA1_Stream5_IRQHandler, /*!< 16: DMA1 Stream 5 */ DMA1_Stream6_IRQHandler, /*!< 17: DMA1 Stream 6 */ ADC_IRQHandler, /*!< 18: ADC1, ADC2 and ADC3s */ CAN1_TX_IRQHandler, /*!< 19: CAN1 TX */ CAN1_RX0_IRQHandler, /*!< 20: CAN1 RX0 */ CAN1_RX1_IRQHandler, /*!< 21: CAN1 RX1 */ CAN1_SCE_IRQHandler, /*!< 22: CAN1 SCE */ EXTI9_5_IRQHandler, /*!< 23: External Line[9:5]s */ TIM1_BRK_TIM9_IRQHandler, /*!< 24: TIM1 Break and TIM9 */ TIM1_UP_TIM10_IRQHandler, /*!< 25: TIM1 Update and TIM10 */ TIM1_TRG_COM_TIM11_IRQHandler,/*!< 26: TIM1 Trigger and Commutation and TIM11*/ TIM1_CC_IRQHandler, /*!< 27: TIM1 Capture Compare */ TIM2_IRQHandler, /*!< 28: TIM2 */ TIM3_IRQHandler, /*!< 29: TIM3 */ TIM4_IRQHandler, /*!< 30: TIM4 */ I2C1_EV_IRQHandler, /*!< 31: I2C1 Event */ I2C1_ER_IRQHandler, /*!< 32: I2C1 Error */ I2C2_EV_IRQHandler, /*!< 33: I2C2 Event */ I2C2_ER_IRQHandler, /*!< 34: I2C2 Error */ SPI1_IRQHandler, /*!< 35: SPI1 */ SPI2_IRQHandler, /*!< 36: SPI2 */ USART1_IRQHandler, /*!< 37: USART1 */ USART2_IRQHandler, /*!< 38: USART2 */ USART3_IRQHandler, /*!< 39: USART3 */ EXTI15_10_IRQHandler, /*!< 40: External Line[15:10]s */ RTC_Alarm_IRQHandler, /*!< 41: RTC Alarm (A and B) through EXTI Line */ OTG_FS_WKUP_IRQHandler, /*!< 42: USB OTG FS Wakeup through EXTI line */ TIM8_BRK_TIM12_IRQHandler, /*!< 43: TIM8 Break and TIM12 */ TIM8_UP_TIM13_IRQHandler, /*!< 44: TIM8 Update and TIM13 */ TIM8_TRG_COM_TIM14_IRQHandler,/*!< 45:TIM8 Trigger and Commutation and TIM14*/ TIM8_CC_IRQHandler, /*!< 46: TIM8 Capture Compare */ DMA1_Stream7_IRQHandler, /*!< 47: DMA1 Stream7 */ FMC_IRQHandler, /*!< 48: FSMC */ SDMMC1_IRQHandler, /*!< 49: SDIO */ TIM5_IRQHandler, /*!< 50: TIM5 */ SPI3_IRQHandler, /*!< 51: SPI3 */ UART4_IRQHandler, /*!< 52: UART4 */ UART5_IRQHandler, /*!< 53: UART5 */ TIM6_DAC_IRQHandler, /*!< 54: TIM6 and DAC1&2 underrun errors */ TIM7_IRQHandler, /*!< 55: TIM7 */ DMA2_Stream0_IRQHandler, /*!< 56: DMA2 Stream 0 */ DMA2_Stream1_IRQHandler, /*!< 57: DMA2 Stream 1 */ DMA2_Stream2_IRQHandler, /*!< 58: DMA2 Stream 2 */ DMA2_Stream3_IRQHandler, /*!< 59: DMA2 Stream 3 */ DMA2_Stream4_IRQHandler, /*!< 60: DMA2 Stream 4 */ ETH_IRQHandler, /*!< 61: Ethernet */ ETH_WKUP_IRQHandler, /*!< 62: Ethernet Wakeup through EXTI line */ CAN2_TX_IRQHandler, /*!< 63: CAN2 TX */ CAN2_RX0_IRQHandler, /*!< 64: CAN2 RX0 */ CAN2_RX1_IRQHandler, /*!< 65: CAN2 RX1 */ CAN2_SCE_IRQHandler, /*!< 66: CAN2 SCE */ OTG_FS_IRQHandler, /*!< 67: USB OTG FS */ DMA2_Stream5_IRQHandler, /*!< 68: DMA2 Stream 5 */ DMA2_Stream6_IRQHandler, /*!< 69: DMA2 Stream 6 */ DMA2_Stream7_IRQHandler, /*!< 70: DMA2 Stream 7 */ USART6_IRQHandler, /*!< 71: USART6 */ I2C3_EV_IRQHandler, /*!< 72: I2C3 event */ I2C3_ER_IRQHandler, /*!< 73: I2C3 error */ OTG_HS_EP1_OUT_IRQHandler, /*!< 74: USB OTG HS End Point 1 Out */ OTG_HS_EP1_IN_IRQHandler, /*!< 75: USB OTG HS End Point 1 In */ OTG_HS_WKUP_IRQHandler, /*!< 76: USB OTG HS Wakeup through EXTI */ OTG_HS_IRQHandler, /*!< 77: USB OTG HS */ DCMI_IRQHandler, /*!< 53: DCMI */ 0, /*!< Reserved */ RNG_IRQHandler, /*!< 53: Rng */ FPU_IRQHandler, /*!< 53: FPU */ UART7_IRQHandler, /* UART7 */ UART8_IRQHandler, /* UART8 */ SPI4_IRQHandler, /* SPI4 */ SPI5_IRQHandler, /* SPI5 */ SPI6_IRQHandler, /* SPI6 */ SAI1_IRQHandler, /* SAI1 */ LTDC_IRQHandler, /* LTDC */ LTDC_ER_IRQHandler, /* LTDC error */ DMA2D_IRQHandler, /* DMA2D */ SAI2_IRQHandler, /* SAI2 */ QUADSPI_IRQHandler, /* QUADSPI */ LPTIM1_IRQHandler, /* LPTIM1 */ CEC_IRQHandler, /* HDMI_CEC */ I2C4_EV_IRQHandler, /* I2C4 Event */ I2C4_ER_IRQHandler, /* I2C4 Error */ SPDIF_RX_IRQHandler, /* SPDIF_RX */ 0, /* Reserved */ DFSDM1_FLT0_IRQHandler, /* DFSDM1 Filter 0 global Interrupt */ DFSDM1_FLT1_IRQHandler, /* DFSDM1 Filter 1 global Interrupt */ DFSDM1_FLT2_IRQHandler, /* DFSDM1 Filter 2 global Interrupt */ DFSDM1_FLT3_IRQHandler, /* DFSDM1 Filter 3 global Interrupt */ SDMMC2_IRQHandler, /* SDMMC2 */ CAN3_TX_IRQHandler, /* CAN3 TX */ CAN3_RX0_IRQHandler, /* CAN3 RX0 */ CAN3_RX1_IRQHandler, /* CAN3 RX1 */ CAN3_SCE_IRQHandler, /* CAN3 SCE */ JPEG_IRQHandler, /* JPEG */ MDIOS_IRQHandler /* MDIOS */ }; /* C++ global constructors support */ static void call_constructors(unsigned long *start, unsigned long *end) { unsigned long *i; void (*funcptr)(); for ( i = start; i < end; i++) { funcptr=(void (*)())(*i); funcptr(); } } /** * @brief This is the code that gets called when the processor first * starts execution following a reset event. Only the absolutely * necessary set is performed, after which the application * supplied main() routine is called. * @param None * @retval None */ void Default_Reset_Handler(void) { /* Initialize data and bss */ unsigned long *pulSrc, *pulDest; /* Copy the data segment initializers from flash to SRAM */ pulSrc = &_sidata; for(pulDest = &_sdata; pulDest < &_edata; ) { *(pulDest++) = *(pulSrc++); } /* Zero fill the bss segment. This is done with inline assembly since this will clear the value of pulDest if it is not kept in a register. */ __asm(" ldr r0, =_sbss\n" " ldr r1, =_ebss\n" " mov r2, #0\n" " .thumb_func\n" "zero_loop:\n" " cmp r0, r1\n" " it lt\n" " strlt r2, [r0], #4\n" " blt zero_loop"); #ifdef __FPU_USED /* Enable FPU.*/ __asm(" LDR.W R0, =0xE000ED88\n" " LDR R1, [R0]\n" " ORR R1, R1, #(0xF << 20)\n" " STR R1, [R0]"); #endif SystemInit(); //Call C++ global constructors call_constructors(&__preinit_array_start, &__preinit_array_end); call_constructors(&__init_array_start, &__init_array_end); /* Call the application's entry point.*/ main(); } /** *@brief Provide weak aliases for each Exception handler to the Default_Handler. * As they are weak aliases, any function with the same name will override * this definition. */ #pragma weak Reset_Handler = Default_Reset_Handler #pragma weak NMI_Handler = Default_Reset_Handler #pragma weak HardFault_Handler = Default_Reset_Handler #pragma weak MemManage_Handler = Default_Reset_Handler #pragma weak BusFault_Handler = Default_Reset_Handler #pragma weak UsageFault_Handler = Default_Reset_Handler #pragma weak SVC_Handler = Default_Reset_Handler #pragma weak DebugMon_Handler = Default_Reset_Handler #pragma weak PendSV_Handler = Default_Reset_Handler #pragma weak SysTick_Handler = Default_Reset_Handler /* External Interrupts */ #pragma weak WWDG_IRQHandler = Default_Reset_Handler /* Window WatchDog */ #pragma weak PVD_IRQHandler = Default_Reset_Handler /* PVD through EXTI Line detection */ #pragma weak TAMP_STAMP_IRQHandler = Default_Reset_Handler /* Tamper and TimeStamps through the EXTI line */ #pragma weak RTC_WKUP_IRQHandler = Default_Reset_Handler /* RTC Wakeup through the EXTI line */ #pragma weak FLASH_IRQHandler = Default_Reset_Handler /* FLASH */ #pragma weak RCC_IRQHandler = Default_Reset_Handler /* RCC */ #pragma weak EXTI0_IRQHandler = Default_Reset_Handler /* EXTI Line0 */ #pragma weak EXTI1_IRQHandler = Default_Reset_Handler /* EXTI Line1 */ #pragma weak EXTI2_IRQHandler = Default_Reset_Handler /* EXTI Line2 */ #pragma weak EXTI3_IRQHandler = Default_Reset_Handler /* EXTI Line3 */ #pragma weak EXTI4_IRQHandler = Default_Reset_Handler /* EXTI Line4 */ #pragma weak DMA1_Stream0_IRQHandler = Default_Reset_Handler /* DMA1 Stream 0 */ #pragma weak DMA1_Stream1_IRQHandler = Default_Reset_Handler /* DMA1 Stream 1 */ #pragma weak DMA1_Stream2_IRQHandler = Default_Reset_Handler /* DMA1 Stream 2 */ #pragma weak DMA1_Stream3_IRQHandler = Default_Reset_Handler /* DMA1 Stream 3 */ #pragma weak DMA1_Stream4_IRQHandler = Default_Reset_Handler /* DMA1 Stream 4 */ #pragma weak DMA1_Stream5_IRQHandler = Default_Reset_Handler /* DMA1 Stream 5 */ #pragma weak DMA1_Stream6_IRQHandler = Default_Reset_Handler /* DMA1 Stream 6 */ #pragma weak ADC_IRQHandler = Default_Reset_Handler /* ADC1, ADC2 and ADC3s */ #pragma weak CAN1_TX_IRQHandler = Default_Reset_Handler /* CAN1 TX */ #pragma weak CAN1_RX0_IRQHandler = Default_Reset_Handler /* CAN1 RX0 */ #pragma weak CAN1_RX1_IRQHandler = Default_Reset_Handler /* CAN1 RX1 */ #pragma weak CAN1_SCE_IRQHandler = Default_Reset_Handler /* CAN1 SCE */ #pragma weak EXTI9_5_IRQHandler = Default_Reset_Handler /* External Line[9:5]s */ #pragma weak TIM1_BRK_TIM9_IRQHandler = Default_Reset_Handler /* TIM1 Break and TIM9 */ #pragma weak TIM1_UP_TIM10_IRQHandler = Default_Reset_Handler /* TIM1 Update and TIM10 */ #pragma weak TIM1_TRG_COM_TIM11_IRQHandler = Default_Reset_Handler /* TIM1 Trigger and Commutation and TIM11 */ #pragma weak TIM1_CC_IRQHandler = Default_Reset_Handler /* TIM1 Capture Compare */ #pragma weak TIM2_IRQHandler = Default_Reset_Handler /* TIM2 */ #pragma weak TIM3_IRQHandler = Default_Reset_Handler /* TIM3 */ #pragma weak TIM4_IRQHandler = Default_Reset_Handler /* TIM4 */ #pragma weak I2C1_EV_IRQHandler = Default_Reset_Handler /* I2C1 Event */ #pragma weak I2C1_ER_IRQHandler = Default_Reset_Handler /* I2C1 Error */ #pragma weak I2C2_EV_IRQHandler = Default_Reset_Handler /* I2C2 Event */ #pragma weak I2C2_ER_IRQHandler = Default_Reset_Handler /* I2C2 Error */ #pragma weak SPI1_IRQHandler = Default_Reset_Handler /* SPI1 */ #pragma weak SPI2_IRQHandler = Default_Reset_Handler /* SPI2 */ #pragma weak USART1_IRQHandler = Default_Reset_Handler /* USART1 */ #pragma weak USART2_IRQHandler = Default_Reset_Handler /* USART2 */ #pragma weak USART3_IRQHandler = Default_Reset_Handler /* USART3 */ #pragma weak EXTI15_10_IRQHandler = Default_Reset_Handler /* External Line[15:10]s */ #pragma weak RTC_Alarm_IRQHandler = Default_Reset_Handler /* RTC Alarm (A and B) through EXTI Line */ #pragma weak OTG_FS_WKUP_IRQHandler = Default_Reset_Handler /* USB OTG FS Wakeup through EXTI line */ #pragma weak TIM8_BRK_TIM12_IRQHandler = Default_Reset_Handler /* TIM8 Break and TIM12 */ #pragma weak TIM8_UP_TIM13_IRQHandler = Default_Reset_Handler /* TIM8 Update and TIM13 */ #pragma weak TIM8_TRG_COM_TIM14_IRQHandler = Default_Reset_Handler /* TIM8 Trigger and Commutation and TIM14 */ #pragma weak TIM8_CC_IRQHandler = Default_Reset_Handler /* TIM8 Capture Compare */ #pragma weak DMA1_Stream7_IRQHandler = Default_Reset_Handler /* DMA1 Stream7 */ #pragma weak FMC_IRQHandler = Default_Reset_Handler /* FMC */ #pragma weak SDMMC1_IRQHandler = Default_Reset_Handler /* SDMMC1 */ #pragma weak TIM5_IRQHandler = Default_Reset_Handler /* TIM5 */ #pragma weak SPI3_IRQHandler = Default_Reset_Handler /* SPI3 */ #pragma weak UART4_IRQHandler = Default_Reset_Handler /* UART4 */ #pragma weak UART5_IRQHandler = Default_Reset_Handler /* UART5 */ #pragma weak TIM6_DAC_IRQHandler = Default_Reset_Handler /* TIM6 and DAC1&2 underrun errors */ #pragma weak TIM7_IRQHandler = Default_Reset_Handler /* TIM7 */ #pragma weak DMA2_Stream0_IRQHandler = Default_Reset_Handler /* DMA2 Stream 0 */ #pragma weak DMA2_Stream1_IRQHandler = Default_Reset_Handler /* DMA2 Stream 1 */ #pragma weak DMA2_Stream2_IRQHandler = Default_Reset_Handler /* DMA2 Stream 2 */ #pragma weak DMA2_Stream3_IRQHandler = Default_Reset_Handler /* DMA2 Stream 3 */ #pragma weak DMA2_Stream4_IRQHandler = Default_Reset_Handler /* DMA2 Stream 4 */ #pragma weak ETH_IRQHandler = Default_Reset_Handler /* Ethernet */ #pragma weak ETH_WKUP_IRQHandler = Default_Reset_Handler /* Ethernet Wakeup through EXTI line */ #pragma weak CAN2_TX_IRQHandler = Default_Reset_Handler /* CAN2 TX */ #pragma weak CAN2_RX0_IRQHandler = Default_Reset_Handler /* CAN2 RX0 */ #pragma weak CAN2_RX1_IRQHandler = Default_Reset_Handler /* CAN2 RX1 */ #pragma weak CAN2_SCE_IRQHandler = Default_Reset_Handler /* CAN2 SCE */ #pragma weak OTG_FS_IRQHandler = Default_Reset_Handler /* USB OTG FS */ #pragma weak DMA2_Stream5_IRQHandler = Default_Reset_Handler /* DMA2 Stream 5 */ #pragma weak DMA2_Stream6_IRQHandler = Default_Reset_Handler /* DMA2 Stream 6 */ #pragma weak DMA2_Stream7_IRQHandler = Default_Reset_Handler /* DMA2 Stream 7 */ #pragma weak USART6_IRQHandler = Default_Reset_Handler /* USART6 */ #pragma weak I2C3_EV_IRQHandler = Default_Reset_Handler /* I2C3 event */ #pragma weak I2C3_ER_IRQHandler = Default_Reset_Handler /* I2C3 error */ #pragma weak OTG_HS_EP1_OUT_IRQHandler = Default_Reset_Handler /* USB OTG HS End Point 1 Out */ #pragma weak OTG_HS_EP1_IN_IRQHandler = Default_Reset_Handler /* USB OTG HS End Point 1 In */ #pragma weak OTG_HS_WKUP_IRQHandler = Default_Reset_Handler /* USB OTG HS Wakeup through EXTI */ #pragma weak OTG_HS_IRQHandler = Default_Reset_Handler /* USB OTG HS */ #pragma weak DCMI_IRQHandler = Default_Reset_Handler /* DCMI */ #pragma weak RNG_IRQHandler = Default_Reset_Handler /* RNG */ #pragma weak FPU_IRQHandler = Default_Reset_Handler /* FPU */ #pragma weak UART7_IRQHandler = Default_Reset_Handler /* UART7 */ #pragma weak UART8_IRQHandler = Default_Reset_Handler /* UART8 */ #pragma weak SPI4_IRQHandler = Default_Reset_Handler /* SPI4 */ #pragma weak SPI5_IRQHandler = Default_Reset_Handler /* SPI5 */ #pragma weak SPI6_IRQHandler = Default_Reset_Handler /* SPI6 */ #pragma weak SAI1_IRQHandler = Default_Reset_Handler /* SAI1 */ #pragma weak LTDC_IRQHandler = Default_Reset_Handler /* LTDC */ #pragma weak LTDC_ER_IRQHandler = Default_Reset_Handler /* LTDC error */ #pragma weak DMA2D_IRQHandler = Default_Reset_Handler /* DMA2D */ #pragma weak SAI2_IRQHandler = Default_Reset_Handler /* SAI2 */ #pragma weak QUADSPI_IRQHandler = Default_Reset_Handler /* QUADSPI */ #pragma weak LPTIM1_IRQHandler = Default_Reset_Handler /* LPTIM1 */ #pragma weak CEC_IRQHandler = Default_Reset_Handler /* HDMI_CEC */ #pragma weak I2C4_EV_IRQHandler = Default_Reset_Handler /* I2C4 Event */ #pragma weak I2C4_ER_IRQHandler = Default_Reset_Handler /* I2C4 Error */ #pragma weak SPDIF_RX_IRQHandler = Default_Reset_Handler /* SPDIF_RX */ #pragma weak DFSDM1_FLT0_IRQHandler = Default_Reset_Handler /* DFSDM1 Filter 0 global Interrupt */ #pragma weak DFSDM1_FLT1_IRQHandler = Default_Reset_Handler /* DFSDM1 Filter 1 global Interrupt */ #pragma weak DFSDM1_FLT2_IRQHandler = Default_Reset_Handler /* DFSDM1 Filter 2 global Interrupt */ #pragma weak DFSDM1_FLT3_IRQHandler = Default_Reset_Handler /* DFSDM1 Filter 3 global Interrupt */ #pragma weak SDMMC2_IRQHandler = Default_Reset_Handler /* SDMMC2 */ #pragma weak CAN3_TX_IRQHandler = Default_Reset_Handler /* CAN3 TX */ #pragma weak CAN3_RX0_IRQHandler = Default_Reset_Handler /* CAN3 RX0 */ #pragma weak CAN3_RX1_IRQHandler = Default_Reset_Handler /* CAN3 RX1 */ #pragma weak CAN3_SCE_IRQHandler = Default_Reset_Handler /* CAN3 SCE */ #pragma weak JPEG_IRQHandler = Default_Reset_Handler /* JPEG */ #pragma weak MDIOS_IRQHandler = Default_Reset_Handler /* MDIOS */ /** * @brief This is the code that gets called when the processor receives an * unexpected interrupt. This simply enters an infinite loop, * preserving the system state for examination by a debugger. * @param None * @retval None */ static void Default_Handler(void) { /* Go into an infinite loop. */ while (1) { } } /*********************** (C) COPYRIGHT 2009 Coocox ************END OF FILE*****/