STM32的bootloader程序设计
3 K+ c* S9 _0 `( n4 z; y; ]0 r' R通常在使用MCU进行开发设计的电子产品中,只存在固件的概念,并没有所谓的 Boot Loader。其实在此类设备中,同样是可以存在 Bootloader的。正因为有Bootloader,所以不需要拆机就能对产品进行固件升级。万一产品固件有缺陷,那么利用 Bootloader进行升级非常方便,非常节省精力和成本,因此越来越多的基于
MCU的产品也开始使用 Bootloader.
2 c1 z; P5 j1 p) J" w7 o
8 _. D5 K5 g8 e" @要实现这种设计会用到IAP技术。IAP是 In Application Programming(在应用中编程)。一般情况下芯片的代码区只有一个用户程序。而在IAP方案下将代码区划分为两部分,各存放一个程序,一个为 Bootloader(引导加载程序),另一个为user application(用户应用程序)。 Bootloader在产品出厂时就固定下来了,当需要变更 user application I时,只需要通过触发 Bootloader对 user application的擦除和重新写入,就可完成对用户应用程序的升级

7 ?1 [: Z4 y8 h0 W' a! s6 M

实现的机制如下。
4 V( n* h' I7 W" T当复位发生时,开始执行 Bootloader。 Bootloader会检测一个特定的条件,比如
说按下组合键。当条件触发时, Bootloader会进行一个分支判断,以更新用户应用程
( M! s6 |4 Y  \8 k序或者直接执行用户应用程序。
6 k) Z8 b3 v6 t* |6 \0 U
用户应用程序需要和 Bootl oader分开。最常见的做法是将 Bootloader放置在存储 Flash中的最开始处,并将用户应用程序放置在其后的可用的存储 Flash中;这样就可以独立配置两块区域的内存保护。

9 X4 F$ u6 |; ?! s. S0 ?boot 工程配置截图如下

7 z/ a% O( N* q3 V* g; P: b7 a

2 f7 g. C& `& m# H# s程序流程图
' u! w* V: m& P6 f, X# d( Z7 A  ^

4 L8 @$ N. E# t: s/ l# N

1. int main(void)
   
2. {
   * o% [! f7 s( `( }% P# Z
3.     /* H7 V1.6.0版本 Hal库 2020-03-04更新 */
   
4.     HAL_Init();
   
5. 
   " g2 ^  }& c0 G# T" C( W. P$ k
6.     /* 系统时钟 */
   7 a- b, u/ q' b5 L# k
7.     SystemClock_Config();
   
8. 
   ) y4 o! p# L0 Z, w
9.     /* GPIO初始化 */
   
10.     MX_GPIO_Init();
    
11. 
    3 f4 f& e& _# a
12.     /* 打印串口LPUART */
    
13.     MX_LPUART1_UART_Init();   
    7 E6 x- h3 p$ s) z
14. 
    8 w$ B5 Q2 ~8 }  G6 e- z
15.     /* 读取应用程序 */
    
16.     ReadAppPro();
    + Y9 E# W! B0 F( l3 V% X7 t4 w; K
17. 
    7 }/ C) X" _% V; |, c
18.     /* 跳转到应用程序区 -> 0x08020000(512K) */
    
19.     Quit_IAP_Process();
    
20. 
    1 r. {3 [( {8 X& M& F  i  o
21. }

复制代码

ReadAppPro();
4 l7 J& d- P7 k/ G

1. void ReadAppPro(void)
   . [2 m0 V8 f( w$ V, N) E9 f
2. {
   
3.     updateInfo_TypeDef updateInfo;  /*升级信息参数*/
   3 Y; \6 R* P( @0 `
4.     uint32_t NbOfSectors = 0;      /*占用Flash扇区数*/
   
5.     uint32_t count = 0;                                /*分包写入个数*/
   * A* w: C' F* q
6.     uint32_t  i = 0;
   
7.     uint32_t calcCRC = 0;
   
8.     uint32_t programCRC = 0;
   ) v! n* H9 _& F: C+ q  {
9.     uint32_t fileLen = 0;
   
10.     uint8_t *papp_data = (uint8_t *)(0x24000000);/* 内存起始位置 */
    7 ]  }9 U4 y8 R0 n
11. 
    7 m# I. }6 `, w. r# b: v7 H" j# ^8 `
12.     /* Step1: 读取升级信息 */
    # ^) C0 Z& p3 B$ W$ y5 A  r0 X
13.     ReadUpdateInfo(&updateInfo);
    8 Y3 L. R' V% K5 F- n! U7 J+ u7 u
14. 
    
15.     /* Step2: 判断是否需要升级 */
    6 w/ t0 B: ]. k: Z8 Y
16.     if (1 == updateInfo.status)
    3 k1 g7 L7 o, ?  `2 I! ^/ m* \
17.     {
    + Z( f2 i, _: ^2 s  r1 B$ ^/ I5 f2 i0 l# E
18.         /* 获取升级文件信息长度 */
    7 F- P* [6 @$ f2 `
19.         fileLen = updateInfo.len;
    
20.         /* 占用Flash扇区数计算 */
    & `9 b$ o/ F; ~; Z8 n0 q
21.         if (0 == updateInfo.len % FLASH_ONE_SECTOR_BYTES)
    # n* L. }; N! S  f1 b& f" Y) H9 C
22.             {
    
23.             NbOfSectors = updateInfo.len / FLASH_ONE_SECTOR_BYTES;
    
24.         }
    ) l4 N! p) L$ |- P- ?
25.         else
    
26.         {
    . G$ M6 L2 K5 G( z
27.             NbOfSectors = updateInfo.len / FLASH_ONE_SECTOR_BYTES + 1;
    
28.         }
    
29. 
    
30.         /* Step3: 读取升级程序 */
    
31.         /* 分段段数计算 */
    
32.         count = (updateInfo.len%4096)?(updateInfo.len/4096+1):(updateInfo.len/4096);
    ' `" W  p3 c. a  [5 j5 |
33.         for(i = 0; i < count; i ++)
    
34.             {
    5 i2 {; N4 \- }8 ~. f: R8 V
35.             /* 程序数据从0x24000000开始，写入到APP_MAIN_ADDR 区域 */
    
36.                     (void)FlashDataRead(APP_MAIN_ADDR+i*4096,papp_data+i*4096,4096);
    6 F( R# S4 ]9 E' b- j
37.             }
    
38. 
    4 z+ a5 C4 J0 P+ p
39.         /* Step4: check crc */
    
40.         calcCRC = ComputeCRC32(papp_data,fileLen-4);
    
41.             programCRC = *(uint32_t *)(&papp_data[fileLen-4]);
    
42. 
    0 K3 \3 X7 N  Z& ^+ P
43.         /* 如果CRC计算通过 */
    
44.         if(programCRC == calcCRC)
      N' I) ^# C, k  A5 ]; ]
45.         {
    
46.                 /* Step5: 需要升级时，擦除APP区 */
    ; O+ A. {* E: v& x
47.                         (void)FlashErase(APPLICATION_ADDRESS , NbOfSectors);
    
48.             for(i = 0; i < count; i ++)
    
49.                     {
    1 U, R) y7 L4 i5 s( P5 o
50.                  /* 程序数据从0x24000000开始，写入APPLICATION_ADDRESS 区域 */
    
51.                 (void)FlashDataWrite(APPLICATION_ADDRESS+i*4096,papp_data+i*4096,4096);
    & G' C+ p0 m4 w0 n6 ?% Q1 p
52.             }
    1 }. v$ C1 f  j% z  I& a2 v/ x3 i- C
53.             /* check：写入程序之后，立即再校验，防止出差 */
    
54.             uint8_t *pflash_data = (uint8_t *)(APPLICATION_ADDRESS);
    
55.             calcCRC = ComputeCRC32(pflash_data, fileLen-4);
    . s0 h: K6 D; R7 H+ M
56.             if(programCRC != calcCRC){
    
57.                 printf("app flash data write err\r\n");
    
58.                 return;
    # J8 m5 \2 Z; p: m4 P
59.             }
    3 f/ Y( h$ \& D; l" w- P6 r5 ]4 h
60.         }
    
61.         else
    
62.         {
    
63.             printf("APP_MAIN_ADDR CRC err: programCRC 0x%x, calcCRC 0x%x\r\n", programCRC, calcCRC);
    / ~9 S# l9 u6 B/ }) m
64.         }
    
65. 
    
66.         /* Step5: 升级完成之后，改变升级信息 */   
    0 C; U1 e) w5 r3 o* j0 D
67.         memset(&updateInfo, 0 , sizeof(updateInfo_TypeDef))        ;        
    
68.         memcpy(gTempBuf, &updateInfo, sizeof(updateInfo_TypeDef));
    7 U8 L# G# `6 D! [+ d* A
69.         (void)FlashEraseAndWrite(APP_UPDATA_INFO_ADDR, 1, (uint8_t *)gTempBuf, sizeof(updateInfo_TypeDef));
    $ t! j$ k6 a, m% L
70.     }
    * m1 _" E; w9 R' b& c' O" B
71. 
    
72.     return;
    
73. 
    $ V3 u+ k% R  ^0 K% T; \/ h4 Z
74. }

复制代码

: g1 K8 m6 p0 o' ^( _) ~Quit_IAP_Process(); 跳转到应用程序区
7 K$ V2 S+ t. m  o# T4 O

1. void Quit_IAP_Process(void)
   
2. {
   
3.     /*
   
4.         * 把用户代码的首地址里面的数据拿出来，看看是不是以0x24000000开头。
   
5.         * (X & 0x2FFE0000 ) == 0x24000000意思是说X是不是在0x24000000与24080000之间，即栈顶是不是在以0x24000000开始的512K
   
6.         * 前面说了用户代码的首地址放的是堆栈指针，而堆栈应该指向RAM，而RAM的首地址是0x24000000，
   
7.         * 所以这句话用来判断是不是已经有一个正确的堆栈指针地址写在了用户代码的首地址，
   
8.         * 进一步可以推测是不是有一个正确的用户代码写在了用户代码区，如果已经写入了，就可以跳过去运行，如果没有写入，就不跳过去。
   
9.         */
   
10.         __disable_irq();        
    
11.         JumpAddress = *(__IO uint32_t*)APPLICATION_ADDRESS; /* APPLICATION_ADDRESS is  0x08020000,app 程序的跳转起始位置*/
    
12.         if ( ((JumpAddress&0x2FFE0000)==0x24000000) || ((JumpAddress&0x2FF80000)==0x24000000))
    
13.         {
    * V- I8 F! R+ ~2 c
14. #ifdef PRINT_DEBUG
    ' |, D& m" n% }5 {( A
15.                 printf("Start Jump IAP!\r\n");
    
16. #endif
    
17.         /* 是把用户代码的复位地址赋值给JumpAddress。 */
    
18.                 JumpAddress = *(__IO uint32_t*) (APPLICATION_ADDRESS + 4);
    
19.        /* 是把用户代码的堆栈地址写入堆栈指针 */
    . R: \2 e( }4 I8 B  C6 B0 L- |
20.                 Jump_To_Application = (pFunction) JumpAddress;
    
21.                 __set_MSP(*(__IO uint32_t*) APPLICATION_ADDRESS);
    
22.         /* 是把用户代码的复位地址付给PC指针 */
    " A6 y7 q! @1 B& l( P
23.                 Jump_To_Application();
    
24.         }
    
25. 
    
26.         file_size=0xFFFFFF;
    
27.         while(file_size--)
    
28.         {
    ) P8 k) K( x( E8 s: y1 S- H# B: O
29.                 __nop();
    
30.         }
    
31.         
    
32.         NVIC_SystemReset();
    + I/ F" C# ~: ^5 {* _3 Z
33. 
    
34. }

复制代码

问题1：
: [4 X) \, V% J5 |( A" v
JumpAddress 地址为什么指向 APPLICATION_ADDRESS + 4 ;
1 x! f* o* ]; Z3 U# V+ YMSP 主堆栈指针为什么指向 APPLICATION_ADDRESS ;
5 P+ U+ o; }( f4 I+ W9 p# [
从 startup_stm32fxxx.s 中的启动代码可以看出:程序开始第一条指令地址为 CSTACK，第二
. U  \/ Q5 r: a- y" x$ n条指令地址为复位指令 ,参考代码中的红色部分(蓝色为注释)；
3 E& n" w) H% Y5 @& ]
__Vectors DCD __initial_sp ; Top of Stack ( APPLICATION_ADDRESS )
9 }) v5 _" Q  [: dDCD Reset_Handler ; Reset Handler ( APPLICATION_ADDRESS + 4)
当程序启动时首先要执行复位程序，因此 JumpAddress 地址指向复位指令地址(即APPLICATION_ADDRESS + 4) ;
MSP 对应的是主堆栈指针，指向 __initial_sp 地址(即 APPLICATION_ADDRESS).
3 v% ]' P( e; y0 Y7 F5 Z
9 ^6 F" w) ?6 v( a# o问题2：

为什么需要做以下判断 :

if (((JumpAddress&0x2FFE0000)==0x24000000) || ((JumpAddress&0x2FF80000)==0x24000000)) {
​
}
ApplicationAddress 存放的是程序的主堆栈地址，__initial_sp堆栈地址指向 RAM，而 RAM 的
& w+ b# \' w3 W2 _# x( S9 f起始地址是 0x24000000；
因此上面的判断语句执行：判断用户代码的堆栈地址是否落在:0x24000000~0x24080000区间
中，这个区间的大小为 512K.
例程中使用芯片 RAM=512K，因此做上面的判断；如果芯片 RAM 比 512K 大的话，可以在
此判断语句做调整
7 v. b; h9 E3 j1 l5 J: r' g7 I  ~/ e4 m
( m& `. S3 P: X* B+ W4 G以上分析可以看出，程序跳转部分的设计与 APP 启动代码和芯片 RAM 的大小有关系;移植和
- S3 e  w- L& a5 `调试时需加以注意
& j9 u) c  e& ~% ]
+ ?" ~' S: ]+ E0 gAPP 程序.
. q( S, ^$ U/ V3 S" e- Q6 WAPP 程序起始地址设置方法

2 W4 @1 H7 s. f
中断向量表的偏移量设置方法
system_stm32h7xx.c

1. /** @addtogroup STM32H7xx_System_Private_Defines
   
2.   * @{
   ; H+ p1 ~5 D0 S) K/ X
3.   */
   
4. 
   
5. /************************* Miscellaneous Configuration ************************/
   
6. /*!< Uncomment the following line if you need to use initialized data in D2 domain SRAM (AHB SRAM) */
   
7. /* #define DATA_IN_D2_SRAM */
   
8. #define DATA_IN_D2_SRAM
   ; ]! v, ~% k% e. H
9. 
   0 |5 B7 `+ ?0 \8 u0 Z# t( k9 J8 O
10. /*!< Uncomment the following line if you need to relocate your vector Table in
    - f+ ~$ ]: L6 P. b' ]8 b6 D) L
11.      Internal SRAM. */
    8 h( b4 O8 x- w/ Q: c
12. /* #define VECT_TAB_SRAM */
    
13. #define VECT_TAB_OFFSET  0x20000UL /*!< Vector Table base offset field. This value must be a multiple of 0x200. */
    - p  c  k* H$ j) d0 l
14. 
    
15. //#define VECT_TAB_OFFSET  0x00000UL
    
16. /******************************************************************************/

复制代码

- Y" x2 {. _5 sSTM32H743 复位后，还是从 0X08000004 地址取出复位中断向量的地址，并跳转到复位中断服务程序在运行完复位中断服务程序之后跳转到 IAP 的 main 函数，在执行完 IAP 以后（即将新的 APP 代码写入 STM32H743 的 FLASH，新程序的复位中断向量起始地址为 0X08000004+N+M），跳转至新写入程序的复位向量表，取出新程序的复位中断向量的地址，并跳转执行新程序的复位中断服务程序，随后跳转至新程序的 main 函数，并且注意到此时 STM32H743 的 FLASH，在不同位置上，共有两个中断向量表

通过以上两个过程的分析，知道 IAP 程序必须满足两个要求：
' E' G9 G* w! P  o" A& y5 c1） 新程序必须在 IAP 程序之后的某个偏移量为 x 的地址开始；
2） 必须将新程序的中断向量表相应的移动，移动的偏移量为 x

! h4 b: W3 {$ Y) K
, m; j( J6 `, a" u# p2 o3 r