piątek, 22 kwietnia 2022

STM32 - Startup File w C

Ten post jest kontynuacją poprzedniego dotyczącego pliku startup w mikrokontrolerze STM32F4. W tym poście przygotuję ten plik w języku C. 


[Źródło: http://www.st.com/en/evaluation-tools/stm32f4discovery.html]

Poniżej przejdę przez poszczególne elementy jakie musiały zostać przygotowane aby plik startup w języku C działał poprawnie.

Na samym początku należy dołączyć biblioteki jakie będą obsługiwane przez ten plik:

  1. #include "stdint.h"
  2. #include "system_stm32f4xx.h"
  3. #include "stm32f4xx.h"

Następnie informujemy o adresach danych w pamięci mikrokontrolera. Musi być ona zdefiniowana jako extern. Ponieważ wszystkie adresy w pamięci zostały opisane w pliku STM32f407vgtx_flash.ld:

  1. /* start address for the initialization values of the .data section. defined in linker script */
  2. extern uint32_t _sidata;
  3. /* start address for the .data section. defined in linker script */  
  4. extern uint32_t _sdata;
  5. /* end address for the .data section. defined in linker script */
  6. extern uint32_t _edata;
  7. /* start address for the .bss section. defined in linker script */
  8. extern uint32_t _sbss;
  9. /* end address for the .bss section. defined in linker script */
  10. extern uint32_t _ebss;
  11. /* stack used for SystemInit_ExtMemCtl; always internal RAM used */
  12. extern uint32_t _estack;

Dalej należy umieścić deklarację zewnętrznych funkcji:

  1. extern void __libc_init_array();
  2. extern int main();

Kolejnym elementem jest zdefiniowanie funkcji Reset_Handler() oraz Default_Handler().

Druga z nich jest prosta w implementacji, wymaga jedynie umieszczenia pętli nieskończonej tak aby w przypadku wygenerowania nieobsługiwanego przerwania program zakończył w niej działanie. 

  1. void Default_Handler(void) {
  2.     while(1) {
  3.     }
  4. }

W przypadku pierwszej z wymienionych funkcji należy się nieco bardziej wysilić. 

  1.     .section  .text.Reset_Handler
  2.   .weak  Reset_Handler
  3.   .type  Reset_Handler, %function
  4. Reset_Handler:  
  5.   ldr   sp, =_estack     /* set stack pointer */
  6.  
  7. /* Copy the data segment initializers from flash to SRAM */  
  8.   ldr r0, =_sdata
  9.   ldr r1, =_edata
  10.   ldr r2, =_sidata
  11.   movs r3, #0
  12.   b LoopCopyDataInit
  13.  
  14. CopyDataInit:
  15.   ldr r4, [r2, r3]
  16.   str r4, [r0, r3]
  17.   adds r3, r3, #4
  18.  
  19. LoopCopyDataInit:
  20.   adds r4, r0, r3
  21.   cmp r4, r1
  22.   bcc CopyDataInit
  23.  
  24. /* Zero fill the bss segment. */
  25.   ldr r2, =_sbss
  26.   ldr r4, =_ebss
  27.   movs r3, #0
  28.   b LoopFillZerobss
  29.  
  30. FillZerobss:
  31.   str  r3, [r2]
  32.   adds r2, r2, #4
  33.  
  34. LoopFillZerobss:
  35.   cmp r2, r4
  36.   bcc FillZerobss
  37.  
  38. /* Call the clock system intitialization function.*/
  39.   bl  SystemInit  
  40. /* Call static constructors */
  41.     bl __libc_init_array
  42. /* Call the application's entry point.*/
  43.   bl  main
  44.   bx  lr    
  45. .size  Reset_Handler, .-Reset_Handler

Powyższa funkcja wykonuje następujące elementy:

  • ustawia wskaźnik pamięci na adres stosu,
  • kopiuje dane z flash do SRAM,
  • wprowadza wartości 0 do segmentu bss,
  • wywołanie funkcji inicjalizującej FPU, dane w pamięci zewnętrznej (DataInExtSRAM / SDRAM) czy tablicę wektorów (USER_VECT_TAB_ADDRESS). W zależności od konfiguracji.
  • wywołanie funkcji __libc_init_array(), która pozwala na inicjalizację podstawowych bibliotek języka C.
  • ostatnim elementem jest wywołanie funkcji main(), czyli początku aplikacji.

Poniżej implementacja funkcji Reset_Handler() w języku C:

  1. void Reset_Handler() {
  2.     __asm("ldr   sp, =_estack");
  3.  
  4.     // Initialize data segment
  5.     volatile uint32_t *dataInit = &_sidata;
  6.     volatile uint32_t *data = &_sdata;
  7.  
  8.     /* Copy the data segment initializers from flash to SRAM */
  9.     while(data < &_edata) {
  10.         *data++ = *dataInit++;
  11.     }
  12.  
  13.     /* Zero fill the bss segment. */
  14.     volatile uint32_t *bss = &_sbss;
  15.     while(bss < &_ebss) {
  16.         *bss++ = 0;
  17.     }
  18.  
  19.     /* Call the clock system intitialization function.*/
  20.     SystemInit();
  21.  
  22.     /* Call static constructors */
  23.     __libc_init_array();
  24.  
  25.     /* Call the application's entry point.*/
  26.     main();
  27. }
  28.  

Następnie należy wprowadzić deklarację funkcji obsługującej przerwania. Są one zdefiniowane jako __weak, czyli w przypadku wpisaniu innej funkcji zostanie ona nadpisana. Jeśli nie zostanie ona zastąpiona inną obsługą przerwania to wywołanie zostanie wykonane przez funkcję Default_Hander();

  1. __weak void NMI_Handler(void)                   { Default_Handler(); }
  2. __weak void HardFault_Handler(void)             { Default_Handler(); }
  3. __weak void MemManage_Handler(void)             { Default_Handler(); }
  4. __weak void BusFault_Handler(void)              { Default_Handler(); }
  5. __weak void UsageFault_Handler(void)            { Default_Handler(); }
  6. __weak void SVC_Handler(void)                   { Default_Handler(); }
  7. __weak void DebugMon_Handler(void)              { Default_Handler(); }
  8. __weak void PendSV_Handler(void)                { Default_Handler(); }
  9. __weak void SysTick_Handler(void)               { Default_Handler(); }
  10. __weak void WWDG_IRQHandler(void)               { Default_Handler(); }
  11. __weak void PVD_IRQHandler(void)                { Default_Handler(); }
  12. __weak void TAMP_STAMP_IRQHandler(void)         { Default_Handler(); }
  13. __weak void RTC_WKUP_IRQHandler(void)           { Default_Handler(); }
  14. __weak void FLASH_IRQHandler(void)              { Default_Handler(); }
  15. __weak void RCC_IRQHandler(void)                { Default_Handler(); }
  16. __weak void EXTI0_IRQHandler(void)              { Default_Handler(); }
  17. __weak void EXTI1_IRQHandler(void)              { Default_Handler(); }
  18. __weak void EXTI2_IRQHandler(void)              { Default_Handler(); }
  19. __weak void EXTI3_IRQHandler(void)              { Default_Handler(); }
  20. __weak void EXTI4_IRQHandler(void)              { Default_Handler(); }
  21. __weak void DMA1_Stream0_IRQHandler(void)       { Default_Handler(); }
  22. __weak void DMA1_Stream1_IRQHandler(void)       { Default_Handler(); }
  23. __weak void DMA1_Stream2_IRQHandler(void)       { Default_Handler(); }
  24. __weak void DMA1_Stream3_IRQHandler(void)       { Default_Handler(); }
  25. __weak void DMA1_Stream4_IRQHandler(void)       { Default_Handler(); }
  26. __weak void DMA1_Stream5_IRQHandler(void)       { Default_Handler(); }
  27. __weak void DMA1_Stream6_IRQHandler(void)       { Default_Handler(); }
  28. __weak void ADC_IRQHandler(void)                { Default_Handler(); }
  29. __weak void CAN1_TX_IRQHandler(void)            { Default_Handler(); }
  30. __weak void CAN1_RX0_IRQHandler(void)           { Default_Handler(); }
  31. __weak void CAN1_RX1_IRQHandler(void)           { Default_Handler(); }
  32. __weak void CAN1_SCE_IRQHandler(void)           { Default_Handler(); }
  33. __weak void EXTI9_5_IRQHandler(void)            { Default_Handler(); }
  34. __weak void TIM1_BRK_TIM9_IRQHandler(void)      { Default_Handler(); }
  35. __weak void TIM1_UP_TIM10_IRQHandler(void)      { Default_Handler(); }
  36. __weak void TIM1_TRG_COM_TIM11_IRQHandler(void) { Default_Handler(); }
  37. __weak void TIM1_CC_IRQHandler(void)            { Default_Handler(); }
  38. __weak void TIM2_IRQHandler(void)               { Default_Handler(); }
  39. __weak void TIM3_IRQHandler(void)               { Default_Handler(); }
  40. __weak void TIM4_IRQHandler(void)               { Default_Handler(); }
  41. __weak void I2C1_EV_IRQHandler(void)            { Default_Handler(); }
  42. __weak void I2C1_ER_IRQHandler(void)            { Default_Handler(); }
  43. __weak void I2C2_EV_IRQHandler(void)            { Default_Handler(); }
  44. __weak void I2C2_ER_IRQHandler(void)            { Default_Handler(); }
  45. __weak void SPI1_IRQHandler(void)               { Default_Handler(); }
  46. __weak void SPI2_IRQHandler(void)               { Default_Handler(); }
  47. __weak void USART1_IRQHandler(void)             { Default_Handler(); }
  48. __weak void USART2_IRQHandler(void)             { Default_Handler(); }
  49. __weak void USART3_IRQHandler(void)             { Default_Handler(); }
  50. __weak void EXTI15_10_IRQHandler(void)          { Default_Handler(); }
  51. __weak void RTC_Alarm_IRQHandler(void)          { Default_Handler(); }
  52. __weak void OTG_FS_WKUP_IRQHandler(void)        { Default_Handler(); }
  53. __weak void TIM8_BRK_TIM12_IRQHandler(void)     { Default_Handler(); }
  54. __weak void TIM8_UP_TIM13_IRQHandler(void)      { Default_Handler(); }
  55. __weak void TIM8_TRG_COM_TIM14_IRQHandler(void) { Default_Handler(); }
  56. __weak void TIM8_CC_IRQHandler(void)            { Default_Handler(); }
  57. __weak void DMA1_Stream7_IRQHandler(void)       { Default_Handler(); }
  58. __weak void FSMC_IRQHandler(void)               { Default_Handler(); }
  59. __weak void SDIO_IRQHandler(void)               { Default_Handler(); }
  60. __weak void TIM5_IRQHandler(void)               { Default_Handler(); }
  61. __weak void SPI3_IRQHandler(void)               { Default_Handler(); }
  62. __weak void UART4_IRQHandler(void)              { Default_Handler(); }
  63. __weak void UART5_IRQHandler(void)              { Default_Handler(); }
  64. __weak void TIM6_DAC_IRQHandler(void)           { Default_Handler(); }
  65. __weak void TIM7_IRQHandler(void)               { Default_Handler(); }
  66. __weak void DMA2_Stream0_IRQHandler(void)       { Default_Handler(); }
  67. __weak void DMA2_Stream1_IRQHandler(void)       { Default_Handler(); }
  68. __weak void DMA2_Stream2_IRQHandler(void)       { Default_Handler(); }
  69. __weak void DMA2_Stream3_IRQHandler(void)       { Default_Handler(); }
  70. __weak void DMA2_Stream4_IRQHandler(void)       { Default_Handler(); }
  71. __weak void ETH_IRQHandler(void)                { Default_Handler(); }
  72. __weak void ETH_WKUP_IRQHandler(void)           { Default_Handler(); }
  73. __weak void CAN2_TX_IRQHandler(void)            { Default_Handler(); }
  74. __weak void CAN2_RX0_IRQHandler(void)           { Default_Handler(); }
  75. __weak void CAN2_RX1_IRQHandler(void)           { Default_Handler(); }
  76. __weak void CAN2_SCE_IRQHandler(void)           { Default_Handler(); }
  77. __weak void OTG_FS_IRQHandler(void)             { Default_Handler(); }
  78. __weak void DMA2_Stream5_IRQHandler(void)       { Default_Handler(); }
  79. __weak void DMA2_Stream6_IRQHandler(void)       { Default_Handler(); }
  80. __weak void DMA2_Stream7_IRQHandler(void)       { Default_Handler(); }
  81. __weak void USART6_IRQHandler(void)             { Default_Handler(); }
  82. __weak void I2C3_EV_IRQHandler(void)            { Default_Handler(); }
  83. __weak void I2C3_ER_IRQHandler(void)            { Default_Handler(); }
  84. __weak void OTG_HS_EP1_OUT_IRQHandler(void)     { Default_Handler(); }
  85. __weak void OTG_HS_EP1_IN_IRQHandler(void)      { Default_Handler(); }
  86. __weak void OTG_HS_WKUP_IRQHandler(void)        { Default_Handler(); }
  87. __weak void OTG_HS_IRQHandler(void)             { Default_Handler(); }
  88. __weak void DCMI_IRQHandler(void)               { Default_Handler(); }
  89. __weak void CRYP_IRQHandler(void)               { Default_Handler(); }
  90. __weak void HASH_RNG_IRQHandler(void)           { Default_Handler(); }
  91. __weak void FPU_IRQHandler(void)                { Default_Handler(); }

Podstawowe funkcje obsługujące przerwania systemowe została zdefiniowana w pliku stm32f4xx_it.c. Do niej trafiają także wygenerowane przez CubeMx funkcje obsługujące przerwania zewnętrzne:

  1. void NMI_Handler(void) { while (1) {  } }
  2. void HardFault_Handler(void) { while (1) {  } }
  3. void MemManage_Handler(void)  { while (1) {  } }
  4. void BusFault_Handler(void)  { while (1) {  } }
  5. void UsageFault_Handler(void)  { while (1) {  } }
  6. void SVC_Handler(void)  { while (1) {  } }
  7. void DebugMon_Handler(void)  { while (1) {  } }
  8. void PendSV_Handler(void)  { while (1) {  } }
  9. void SysTick_Handler(void)  { while (1) {  } }

Ostatnim elementem w pliku jest tablica wektorów zawierająca informację z wartością początkową wskaźnika stosu, adresem startowym oraz wektorami przerwań dla wszystkich funkcji obsługi przerwania:

  1. __attribute__((section(".isr_vector")))
  2. const void (*VectorTable[])(void) = {
  3.     (const void (*)(void))&_estack,
  4.     Reset_Handler,
  5.     NMI_Handler,
  6.     HardFault_Handler,
  7.     MemManage_Handler,
  8.     BusFault_Handler,
  9.     UsageFault_Handler,
  10.     0, 0, 0, 0, //Reserved
  11.     SVC_Handler,
  12.     DebugMon_Handler,
  13.     0,
  14.     PendSV_Handler,
  15.     SysTick_Handler,
  16.  
  17.     /* External Interrupts */
  18.     WWDG_IRQHandler,                   /* Window WatchDog              */
  19.     PVD_IRQHandler,                    /* PVD through EXTI Line detection */
  20.     TAMP_STAMP_IRQHandler,             /* Tamper and TimeStamps through the EXTI line */
  21.     RTC_WKUP_IRQHandler,               /* RTC Wakeup through the EXTI line */
  22.     FLASH_IRQHandler,                  /* FLASH                        */
  23.     RCC_IRQHandler,                    /* RCC                          */
  24.     EXTI0_IRQHandler,                  /* EXTI Line0                   */
  25.     EXTI1_IRQHandler ,                 /* EXTI Line1                   */
  26.     EXTI2_IRQHandler,                  /* EXTI Line2                   */
  27.     EXTI3_IRQHandler,                  /* EXTI Line3                   */
  28.     EXTI4_IRQHandler,                  /* EXTI Line4                   */
  29.     DMA1_Stream0_IRQHandler,           /* DMA1 Stream 0                */
  30.     DMA1_Stream1_IRQHandler,           /* DMA1 Stream 1                */
  31.     DMA1_Stream2_IRQHandler,           /* DMA1 Stream 2                */
  32.     DMA1_Stream3_IRQHandler,           /* DMA1 Stream 3                */
  33.     DMA1_Stream4_IRQHandler,           /* DMA1 Stream 4                */
  34.     DMA1_Stream5_IRQHandler,           /* DMA1 Stream 5                */
  35.     DMA1_Stream6_IRQHandler,           /* DMA1 Stream 6                */
  36.     ADC_IRQHandler,                    /* ADC1, ADC2 and ADC3s         */
  37.     CAN1_TX_IRQHandler,               /* CAN1 TX                      */
  38.     CAN1_RX0_IRQHandler,              /* CAN1 RX0                     */
  39.     CAN1_RX1_IRQHandler,               /* CAN1 RX1                     */
  40.     CAN1_SCE_IRQHandler,              /* CAN1 SCE                     */
  41.     EXTI9_5_IRQHandler,                /* External Line[9:5]s          */
  42.     TIM1_BRK_TIM9_IRQHandler,          /* TIM1 Break and TIM9          */
  43.     TIM1_UP_TIM10_IRQHandler,          /* TIM1 Update and TIM10        */
  44.     TIM1_TRG_COM_TIM11_IRQHandler,     /* TIM1 Trigger and Commutation and TIM11 */
  45.     TIM1_CC_IRQHandler,                /* TIM1 Capture Compare         */
  46.     TIM2_IRQHandler,                   /* TIM2                         */
  47.     TIM3_IRQHandler,                   /* TIM3                         */
  48.     TIM4_IRQHandler,                   /* TIM4                         */
  49.     I2C1_EV_IRQHandler,                /* I2C1 Event                   */
  50.     I2C1_ER_IRQHandler,                /* I2C1 Error                   */
  51.     I2C2_EV_IRQHandler,                /* I2C2 Event                   */
  52.     I2C2_ER_IRQHandler,                /* I2C2 Error                   */
  53.     SPI1_IRQHandler,                  /* SPI1                         */
  54.     SPI2_IRQHandler,                  /* SPI2                         */
  55.     USART1_IRQHandler,                 /* USART1                       */
  56.     USART2_IRQHandler,                 /* USART2                       */
  57.     USART3_IRQHandler,                 /* USART3                       */
  58.     EXTI15_10_IRQHandler,              /* External Line[15:10]s        */
  59.     RTC_Alarm_IRQHandler,              /* RTC Alarm (A and B) through EXTI Line */
  60.     OTG_FS_WKUP_IRQHandler,            /* USB OTG FS Wakeup through EXTI line */
  61.     TIM8_BRK_TIM12_IRQHandler,         /* TIM8 Break and TIM12         */
  62.     TIM8_UP_TIM13_IRQHandler,          /* TIM8 Update and TIM13        */
  63.     TIM8_TRG_COM_TIM14_IRQHandler,     /* TIM8 Trigger and Commutation and TIM14 */
  64.     TIM8_CC_IRQHandler,                /* TIM8 Capture Compare         */
  65.     DMA1_Stream7_IRQHandler,           /* DMA1 Stream7                 */
  66.     FSMC_IRQHandler,                   /* FSMC                         */
  67.     SDIO_IRQHandler,                   /* SDIO                         */
  68.     TIM5_IRQHandler,                   /* TIM5                         */
  69.     SPI3_IRQHandler,                   /* SPI3                         */
  70.     UART4_IRQHandler,                  /* UART4                        */
  71.     UART5_IRQHandler,                  /* UART5                        */
  72.     TIM6_DAC_IRQHandler,               /* TIM6 and DAC1&2 underrun errors */
  73.     TIM7_IRQHandler,                   /* TIM7                         */
  74.     DMA2_Stream0_IRQHandler,           /* DMA2 Stream 0                */
  75.     DMA2_Stream1_IRQHandler,           /* DMA2 Stream 1                */
  76.     DMA2_Stream2_IRQHandler,           /* DMA2 Stream 2                */
  77.     DMA2_Stream3_IRQHandler,           /* DMA2 Stream 3                */
  78.     DMA2_Stream4_IRQHandler,           /* DMA2 Stream 4                */
  79.     ETH_IRQHandler,                    /* Ethernet                     */
  80.     ETH_WKUP_IRQHandler,               /* Ethernet Wakeup through EXTI line */
  81.     CAN2_TX_IRQHandler,               /* CAN2 TX                      */
  82.     CAN2_RX0_IRQHandler,               /* CAN2 RX0                     */
  83.     CAN2_RX1_IRQHandler,               /* CAN2 RX1                     */
  84.     CAN2_SCE_IRQHandler,               /* CAN2 SCE                     */
  85.     OTG_FS_IRQHandler,                 /* USB OTG FS                   */
  86.     DMA2_Stream5_IRQHandler,           /* DMA2 Stream 5                */
  87.     DMA2_Stream6_IRQHandler,           /* DMA2 Stream 6                */
  88.     DMA2_Stream7_IRQHandler,           /* DMA2 Stream 7                */
  89.     USART6_IRQHandler,                 /* USART6                       */
  90.     I2C3_EV_IRQHandler,                /* I2C3 event                   */
  91.     I2C3_ER_IRQHandler,                /* I2C3 error                   */
  92.     OTG_HS_EP1_OUT_IRQHandler,         /* USB OTG HS End Point 1 Out   */
  93.     OTG_HS_EP1_IN_IRQHandler,          /* USB OTG HS End Point 1 In    */
  94.     OTG_HS_WKUP_IRQHandler,            /* USB OTG HS Wakeup through EXTI */
  95.     OTG_HS_IRQHandler,                 /* USB OTG HS                   */
  96.     DCMI_IRQHandler,                   /* DCMI                         */
  97.     CRYP_IRQHandler,                   /* CRYP crypto                  */
  98.     HASH_RNG_IRQHandler,               /* Hash and Rng                 */
  99.     FPU_IRQHandler                     /* FPU                          */
  100. };

Plik startup do pobrania z dysku Google pod tym linkiem.
Autor: o
Etykiety: , ,