1 前言
# s2 Y, [9 i5 t* b8 K本文根据 2017 年度广州 USB DFU 培训内容进行整理而成，主要目的是为了方便那些由于各种原因未到现场参加培训的碟粉们参阅学习。本文主要是介绍如何使用 CubeMx 这个工具，一步一步制作一个 BOOT(DFU)程序，并使用它来升级用户 APP程序，这种应用场合在产品开发中具有普遍性。
2 实验环境介绍
. w$ k. ^5 r" c! v2.1 实验目标
; R# f$ q3 D% W- E$ n

! r- o! Q' E. p6 u" f/ g' B2 H
如上图，本实验主要目的是制作 BOOT 程序，并通过 BOOT 来升级用户的 APP 程序，上图是 BOOT 和 APP 在 MCU 内部FLASH 的位置示意图。当然，我们也将简单的介绍这个用户 APP 需要注意哪些方面。
注：这里我们将使用 USB DFU 作为 IAP 的这个程序叫做 BOOT 程序，功能与内置 BootLoader 类似，主要负责升级 APP 或直接跳转到 APP 去运行(MCU 内置 BootLoader，为了与其区分，这里取名为 BOOT，后面不再解释)。

8 e) |  f( E( n9 R+ i% f2.2 实验环境及 STM32F072-Discovery 板简介
9 g8 y9 N' T+ f# |3 F硬件平台：
, |( ^5 p; O" u$ }8 y! D. J STM32F072 Discovery 板一块
* B% D# g7 X) P) K& ]' Z) |% s4 z Mini USB 线两根
 PC 一台
软件准备：
2 x! g# h, W7 e' Z IAR V6.7.0 或者以上版本
 STM32CubeF0 V1.7.0
8 p% U9 J* k- t. k1 f6 F  t STM32CubeMX V4.19
: I& z, Q$ Z, m$ k4 J DfuSeDemo(V3.0.5)
( x+ @6 F# {" O& K# `  ^
, A+ Y) @+ @( e% U' r$ [* Y# ^) l
5 k' f7 f% `* @+ h3 ?0 s: H9 O3 制作 BOOT 工程
3.1 了解 MCU 内部 FLASH 的组织结构

3 \$ X! G/ N) O4 Y
. F" M( {- K7 Y3 ~/ _3 q
8 ]  M- q8 z% D如上图，BOOT 程序位于内部 FLASH 的起始位置，其后跟着的 APP 程序假设放在 0x0800 7000 的位置。也就是说前面0x7000 的空间用来存放 BOOT。
3 y: r2 [; L0 I: f! }! m在制作 BOOT 程序之前，首先我们必须得先了解目标 MCU 的内部 FLASH 结构，这个是与我们的 BOOT 程序相关的，因为不同的 MCU 类型其内部 FLASH 组织结构不尽相同，尤其在擦除 FLASH 的时候，我们必须得知道擦除是以页为单位还是以扇区为单位，以及总共有多少个单元，每个单元多大等等。
这里我们实验的目标 MCU 为 STM32F072RBT6，打开其参考手册，得到其内部 FLASH 的组织结构如下图所示：


7 B% Q0 X; l# E9 n
从上图我们可以得到如下信息：
6 C1 }7 x, }: P0 A: r1> 内部 FLASH 起始位置 0x0800 0000,结束位置 0x0801 FFFF;
2> 总共有 64 个页(0~63),每页大小 2K,共 128K 大小;
/ Y' @% `- E1 P5 m5 ^$ S3> 擦除 FLASH 是以页为单位。

3.2 制作 CubeMx 工程
下面我们来从零开始为这个 BOOT 程序制作一个 CubeMx 工程，在选取 STM32F072RBx 作为目标 MCU 后，使能 USB_FS外设，并将 PA0 设为 GPIO_Input 模式，PA0 对应着 STM32F072-Discoery 板上的用户按键，我们将在程序中根据 PA0 管脚的电平状态来判断是否直接跳转到 APP 还是进入到 DFU 模式，准备升级用户 APP 程序。

4 k$ i* w1 w# b. s" E5 f3 W
3 ^/ J( J" k3 u) T0 @4 I5 f9 d  O
接下来是时钟树配置:
" q) j+ }8 a! v/ T, ^$ r

& z4 e+ P" ]( z& n* j- A' k7 z
9 ]: f1 I$ i1 |( _如上图，我们使用内置 HSI48RC 作为高速时钟源，主频配为 48MHz，另外需要注意的是，USB 外设必须给它提供固定的48M 时钟源。
& S! d7 \9 ]! l2 c- ?

7 h- T# t5 ~5 ?
如上图左边，为 USB Device 配置 DFU 子类。然后点击右侧中间件下的 USB_DEVICE 配置,弹出如下对话框:
7 f$ O9 v9 D- v' c# N0 i
" F8 d+ Z& W( a# t. I5 J

如上图红框中所示，USBD_DFU_APP_DEFAULT_ADD 为用户 APP 程序的默认起始位置，这里设置为 0x0800 7000, 即0x0800 0000~0x0800 7000 之间的空间，都可以用来放 BOOT 程序。USBD_DFU_MEDIA_Interface 为 DFU 媒介接口，也就是 MCU 内部 FLASH 的组织结构，这里用字符串表示，其值为: @Internal Flash /0x08000000/09*002Ka,55*002Kg;
) _/ M, `, o3 _1 d@Internal Flash: MCU 内部 FLASH 在 DfuSeDemo 这个 PC 软件中显示的字符串名，这里显示为”Internal Flash”；/0x08000000 : 内部 FLASH 的起始位置为 0x0800 0000 ;/09*002Ka : 9 个只读单元，每个单元大小为 2K,后缀 a 表示只读，一般用来放置 BOOT 程序 ;55*002Kg : 55 个可读写单元，每个单元大小为 2K，后缀 g 表示可读写，一般用来表示用户 APP 空间。
BOOT 程序通过这个一个带某种特殊格式的字符串来告诉 PC 端主机的上位机软件 DfuSeDemo，当前连接的 MCU 内部FLASH 的组织结构，这个字符串的表达方式，是通过 BOOT 程序与 PC 端软件 DfuSeDemo 预先约定好的。最终在DfuSeDemo 这个 PC 端软件可以显示当前连接 USB 设备 MCU 内置 FLASH 的结构，这个在后续将会介绍到。
, i# ^; ~. ]) Y0 f( N; g/ {3 a9 t最后生成代码时设置下堆栈大小：
& M3 E$ K: }) y2 X! Z
0 N) F8 I0 D4 S1 [8 R
  o, V0 ]+ {' ^% X- S4 B
如上图，我们设置 BOOT 程序的堆为 0x500,栈大小为:0x2000; 并生成 IAR 工程。
5 h+ s9 i6 k' d4 J- Y2 o9 Y
: ~/ X8 X3 a' \* }' m3 P3.3 完善 BOOT 工程
生成的 IAR 工程如下所示：



CubeMx 工具已经自动帮我们生成了大部分代码，绝大部分我们都不需要修改，我们主要是根据 STM32F072 这款 MCU 内部FLASH 本生的一些特性来修改 usbd_duf_if.c 源文件，其次，根据应用上的一些特点，我们稍微修改下 main 函数，使其达到我们需要的结果。这些我们都将逐步在后续介绍。

3.3.1 usbd_dfu_if.c 源文件的修改
: k/ x2 M4 j% yusbd_dfu_if.c 源文件主要是实现对 FLASH 的一些操作，主要有这些操作：
  G* k2 `- [  s! O2 h) M

1. __ALIGN_BEGIN USBD_DFU_MediaTypeDef USBD_DFU_fops_FS __ALIGN_END =
   
2. {
   
3. (uint8_t*)FLASH_DESC_STR,
   1 A" u& H: e  K  S% D$ |; N
4. MEM_If_Init_FS, //初始化
   ; Z9 U; F- ^8 B7 }8 B0 m2 Q; M
5. MEM_If_DeInit_FS, //反初始化
   
6. MEM_If_Erase_FS, //擦除 FLASH
   
7. MEM_If_Write_FS, //写 FLASH
   
8. MEM_If_Read_FS, //读 FLASH
   - `; c- |1 z/ J3 J
9. MEM_If_GetStatus_FS, //获取状态
   0 e2 l* k6 N1 @( v  W8 p# R
10. };

复制代码

CubeMx 自动生成的 usbd_dfu_if.c 源文件中对这些函数都已经生成了大概框架，用户只需要完成其具体实现内容即可，这好比做填空题一样。
5 s9 z7 C: C/ v( h6 z9 n 初始化：

1. uint16_t MEM_If_Init_FS(void)
   : B. h, n# R: Y( u, v: b  G9 [
2. {
   
3. /* USER CODE BEGIN 0 */
   4 W" T# H: k$ ^  M3 p- `
4. HAL_FLASH_Unlock();
   
5. return (USBD_OK);
   + V* Y/ `% i( T6 [$ v' W
6. /* USER CODE END 0 */
   
7. }

复制代码

* [. t2 d5 b/ C/ H. f在初始化函数中，完成对 FLASH 的解锁。
 反初始化：
4 Z  |3 T: L* J1 r

1. uint16_t MEM_If_DeInit_FS(void)
   
2. {
   
3. /* USER CODE BEGIN 1 */
   
4. HAL_FLASH_Lock();
   - @0 v4 s% i9 b6 A( z! p8 {! @
5. return (USBD_OK);
   ; T9 h; K$ ]/ c+ m# {* j5 m
6. /* USER CODE END 1 */
   
7. }

复制代码

对应的，在反初始化函数中，恢复 FLASH 的锁定状态。
$ j& _4 D: ^; g* z  ~) [ 擦除 FLASH
" U2 C9 z) M! j: {- h9 t5 Q

1. uint16_t MEM_If_Erase_FS(uint32_t Add)
   
2. {
   + c) x5 K: R! O/ G
3. /* USER CODE BEGIN 2 */
   " l: e" i8 W0 f+ o7 i7 O* E
4. uint32_t NbOfPages = 0;
   
5. uint32_t PageError = 0;
   4 a# W% c( g" p' v9 ?% S
6. /* Variable contains Flash operation status */
   " d" K" r+ ^3 @
7. HAL_StatusTypeDef status;
   7 L6 {! }# v! Q! I
8. FLASH_EraseInitTypeDef eraseinitstruct;
   
9. /* Get the number of sector to erase from 1st sector*/
   
10. NbOfPages = (USBD_DFU_APP_END_ADD - USBD_DFU_APP_DEFAULT_ADD) / FLASH_PAGE_SIZE;
    / M" Y: P8 L8 q" Z2 z
11. eraseinitstruct.TypeErase = FLASH_TYPEERASE_PAGES;
    
12. eraseinitstruct.PageAddress = USBD_DFU_APP_DEFAULT_ADD;
    ) D! i' O, J! q9 w, T8 m
13. eraseinitstruct.NbPages = NbOfPages;
    
14. status = HAL_FLASHEx_Erase(&eraseinitstruct, &PageError);
    
15. if (status != HAL_OK)
    
16. {
    
17. return USBD_FAIL;
    
18. }
    
19. return (USBD_OK);
    
20. /* USER CODE END 2 */
    
21. }

复制代码

- F+ w2 ]4 a+ Y8 A- A3 G* P需要注意地是，这里擦除的是指擦除整个 APP 所在的空间，因此，将会擦除掉 page8~63 的所有内容。
上述函数用到的一些宏定义如下：
  A: [" ^8 f5 J+ E

1. #define USBD_DFU_APP_END_ADD 0x0801F800 //ADDR_FLASH_PAGE_63, AP 程序结束位置
   2 a1 n( c8 C; p
2. #define USBD_DFU_APP_DEFAULT_ADD 0x08007000 //APP 程序起始位置
   
3. #define FLASH_PAGE_SIZE 0x800U //2K 大小/页

复制代码

; l& L# f" K5 Q) N! _ 写 FLASH
* x; v& a4 o) J* q1 ~7 \" F

1. uint16_t MEM_If_Write_FS(uint8_t *src, uint8_t *dest, uint32_t Len)
   
2. {
   
3. /* USER CODE BEGIN 3 */
   
4. uint32_t i = 0;
   - h# O* W; W+ O* ?; o
5. for(i = 0; i < Len; i+=4)
   
6. {
   1 s: b' T# ^4 M4 Q( J3 I
7. /* Device voltage range supposed to be [2.7V to 3.6V], the operation will
   7 w. @3 U9 t, O  z9 l
8. be done by byte */
   " w$ @5 `. Y/ N6 |0 C. ?
9. if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, (uint32_t)(dest+i), *(uint32_t*)(src+i))
   
10. == HAL_OK)
    
11. {
    1 v+ F) C+ \$ i" B$ x
12. /* Check the written value */
    
13. if(*(uint32_t *)(src + i) != *(uint32_t*)(dest+i))
    
14. {
    
15. /* Flash content doesn't match SRAM content */
    
16. return 2;
    
17. }
    % B- [4 ^3 L! M3 f! M
18. }
    / f2 E6 w# G1 @4 w4 B# T+ G! [
19. else
    
20. {
    # F6 F7 [' L4 t
21. /* Error occurred while writing data in Flash memory */
    
22. return 1;
    8 v" H9 c$ C$ o1 w
23. }
    
24. }
    4 y3 m1 `# k5 ^; S& S% E
25. return (USBD_OK);
    
26. /* USER CODE END 3 */
    & i  N  J1 s1 M$ g7 h: L9 ~
27. }

复制代码

 读 FLASH
8 W  @" x0 D0 P5 Z0 _  y; a

1. uint8_t *MEM_If_Read_FS (uint8_t *src, uint8_t *dest, uint32_t Len)
   
2. {
   3 t3 V2 \5 w. ?/ m4 s. e
3. /* Return a valid address to avoid HardFault */
   7 D4 r+ l: n& S2 o/ |
4. /* USER CODE BEGIN 4 */
   
5. uint32_t i = 0;
   
6. uint8_t *psrc = src;
   
7. for(i = 0; i < Len; i++)
   ( u  H6 z# G0 J& [& k
8. {
   , I* I$ `- ], Q; L& |
9. dest<i> = </i>*psrc++;
   
10. }
    
11. /* Return a valid address to avoid HardFault */
    + v  E9 _* v3 j  k4 N5 m
12. return (uint8_t*)(dest);
    
13. /* USER CODE END 4 */
    6 S( U+ g) Y8 ]+ Q+ A" B
14. }

复制代码

( f2 J: V0 i+ s# _" t# ~% c 获取状态
/ i0 e4 b$ s0 j) S: p: l4 J% r

1. uint16_t MEM_If_GetStatus_FS (uint32_t Add, uint8_t Cmd, uint8_t *buffer)
   
2. {
   : e( k  Z& y/ {& g: ~% L
3. /* USER CODE BEGIN 5 */
     u) m4 O; d5 x" \5 i* n
4. switch (Cmd)
   
5. {
   & R, U2 [3 r' N# s- x
6. case DFU_MEDIA_PROGRAM:
   
7. buffer[1] = (uint8_t)FLASH_PROGRAM_TIME;
   ( X7 c* I3 o5 N+ v+ Y$ x& r
8. buffer[2] = (uint8_t)(FLASH_PROGRAM_TIME << 8);
   + |3 t- F6 D0 `4 b% [4 Q! S
9. buffer[3] = 0;
   ! h$ K9 s8 z6 I, q  X8 M
10. break;
    6 \8 v  y. @+ k  ?1 x& D$ l6 W  a
11. case DFU_MEDIA_ERASE:
    $ @2 l1 Q! U9 H$ M0 B
12. default:
    # X/ D7 s) a2 D: H! ~# P
13. buffer[1] = (uint8_t)FLASH_ERASE_TIME;
    
14. buffer[2] = (uint8_t)(FLASH_ERASE_TIME << 8);
    
15. buffer[3] = 0;
    
16. break;
    
17. }
    ) r5 A/ Z5 m" c; Y3 X
18. return (USBD_OK);
    . t8 q: W, e" K+ i% ]8 O! l
19. /* USER CODE END 5 */
    9 c! Z2 n6 Z) s
20. }

复制代码

+ F: B$ X8 |# u2 \, o3 r9 b上面函数中用到的一些宏如下定义:
* h3 A7 V4 ?1 Q8 ?! d# X2 `

1. #define FLASH_ERASE_TIME (uint16_t)50
   ' E7 X: p) Q# ^5 l" [/ n
2. #define FLASH_PROGRAM_TIME (uint16_t)50

复制代码

1 L$ o3 M$ h4 D上述函数接口的具体实现是根据具体 MCU 的特点来实现的，若换成其他类型的 STM32，则需要根据当前的 STM32 型号做相应修改。如此，usbd_dfu_if.c 源文件就修改完了。
7 w0 L) q9 F1 K5 U0 V7 k3.3.2 main 源文件修改
1 X, M  j& q/ D5 J在 main 函数内，我们需要根据外部用户按键的状态来判断是否跳转到 APP 还是停留在 BOOT 程序内并准备对 APP 进行升级。
Main 函数修改如下：
1 L3 s" z$ v  ^$ C' ^9 x2 H

1. int main(void)
   
2. {
   & [  a; ~1 {! D0 E% l. h
3. /* USER CODE BEGIN 1 */
   
4. pFunction JumpToApplication;
   % X/ m; K2 h( K, ?! b$ ?
5. uint32_t JumpAddress;
   
6. /* USER CODE END 1 */
   
7. /* MCU Configuration----------------------------------------------------------*/
   
8. /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
   ' `% q# }9 n, v4 x; T
9. HAL_Init();
   
10. /* USER CODE BEGIN Init */
    
11. /* USER CODE END Init */
    * i5 J" K' [2 X* P9 O
12. /* Configure the system clock */
    
13. SystemClock_Config();
    % h) [1 a/ a* ]) l  ~
14. /* USER CODE BEGIN SysInit */
    ' A& }8 y" F9 S5 w' K+ D* {/ H! m
15. /* USER CODE END SysInit */
    * |* G4 t7 d* [1 }" t
16. /* Initialize all configured peripherals */
    : H1 S/ r1 y' E( Y- Z- b; z
17. MX_GPIO_Init();
    7 N' S  R8 O( f
18. //MX_USB_DEVICE_Init();
    
19. /* USER CODE BEGIN 2 */
    
20. if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) !=GPIO_PIN_SET)//如果用户没有按下按键
    4 [$ Q8 o6 ^! ^* p
21. {
    * u/ Q& X( \: L1 q2 [5 j( u
22. if (((*(__IO uint32_t*)USBD_DFU_APP_DEFAULT_ADD) & 0x2FFE0000 ) ==
    & R7 j& g. g. G. |) _* O: e/ L. Z) v
23. 0x20000000) //如果存在 APP，则跳转到 APP 执行
    
24. {
    ! F0 R5 F/ _& q; i( j
25. /* Jump to user application */
    
26. JumpAddress = *(__IO uint32_t*) (USBD_DFU_APP_DEFAULT_ADD + 4);
    : K3 [: u6 S$ [0 n3 h
27. JumpToApplication = (pFunction) JumpAddress;
    ( O$ l' G4 W4 m, |# ]( A) p
28. /* Initialize user application's Stack Pointer */
    
29. __set_MSP(*(__IO uint32_t*) USBD_DFU_APP_DEFAULT_ADD);
    2 \4 u& F& N- w4 r- ]
30. JumpToApplication();
    
31. }
    
32. }
    
33. MX_USB_DEVICE_Init(); //如果不存在 APP 或者用户按下了按键，则进入 DFU，并准备升级 APP
    
34. /* USER CODE END 2 */
    
35. /* Infinite loop */
    1 y2 z% j; O+ v( @
36. /* USER CODE BEGIN WHILE */
    ) ^% w" n$ ]2 q) K
37. while (1)
    5 f1 j4 |/ o: L
38. {
    
39. /* USER CODE END WHILE */
    ; U9 ~" |2 X( [' O% W
40. /* USER CODE BEGIN 3 */
    
41. }
    : ?' S8 ?4 _6 O  P7 _
42. }

复制代码

上述代码中：
! g" [2 w. t  j0 h/ H

1. if (((*(__IO uint32_t*)USBD_DFU_APP_DEFAULT_ADD) & 0x2FFE0000 ) == 0x20000000)

复制代码

这行代码是判断 FLASH 中是否存在 APP 程序。它的判断原理是这样的，若存在 APP，则
USBD_DFU_APP_DEFAULT_ADD 这个地址保存的是栈顶指针 MSP,栈指针肯定是指向内存的，而内存有效地址分为0x2000 0000 起始的 128K 范围内。
8 M2 |0 r. s3 @4 F* h. w2 ^& 0x2FFE0000 的意思是将 MSP 的值过滤掉低 17 位，17 位二进制刚好表示 128K 空间范围，也就是说，只有 MSP 的值指向SRAM 的 128K 有效范围内时，才是合法的，此时则表示 APP 存在，否则，APP 不存在。
' W4 |6 k, }6 U  B" [

1. JumpAddress = *(__IO uint32_t*) (USBD_DFU_APP_DEFAULT_ADD + 4);

复制代码

跳转地址为 APP 起始地址+4,因为前 4 个字节表示的是 MSP 的值。所以接下来有如下初始化 MSP 的操作:

1. __set_MSP(*(__IO uint32_t*) USBD_DFU_APP_DEFAULT_ADD);

复制代码

到此，BOOT 程序已经完成了。


: a- Q# ^6 C/ w$ m* j5 X4 制作 APP 工程
制作 APP 的过程我们也讲一下，因为有些地方还是需要注意下。
我们再次回顾下 BOOT 与 APP 在内部 FLASH 中的位置：


% ?  L- n, T5 W6 l
如上，用户 APP 是放在起始位置为 0x0800 7000 的位置，当然这个位置是示例，实际工程中用户得根据自己的情况来设置，比如 BOOT 实际大小多少，那么 APP 肯定得放在 BOOT 之后，绝对不能有重叠的地方，第二个，APP 的起始位置一定要放在 Page 起始的地方，因为 STM32F072 内部 FLASH 擦除是以 Page 为单位的，换做其他 MCU，比如 STM32F407，则擦除是以 SECTOR 为单位，且每个 Sector 的 SIZE 不尽相同，那么这个 APP 的起始位置一定要注意放在 Sector/Page 起始的位置。
下面我们一步一步详细介绍 APP 的创建过程，以一个简单的 LED 灯 Toggle 的例程向读者介绍用户 APP 的方方面面。


4.1 使用 STM32CubeMx 制作 APP 工程


' @8 l* [9 m' C; b0 F% D# o% T
如上图，在 Pinout 中设置 LED1~4 的四个管脚为 GPIO_Output 输出模式。
: u$ X! N" ^/ _
2 B4 A  S0 D  U7 x2 N: [

9 d' O# x$ X' O  ]+ d7 a  o时钟树设置还是配置内部 48M 专用晶振为时钟源。
* [6 l6 R' R2 L6 \2 h5 R0 E8 p
( l4 v& V  P+ F7 v
* S* F& E+ M3 q& w, U) ?1 R+ _5 b
然后直接点击生成代码。
0 U% m9 I0 p4 F" y) N/ M2 B7 G. j  O
- G: h% z2 L0 V6 I" m4 `- P1 i' V4.2 完善代码与工程配置
下面我们完善下代码：
在 main 函数中，我们让 LED 等闪烁起来:
6 ^5 \; m7 |  G- ~& y

1. while (1)
   
2. {
   
3. /* USER CODE END WHILE */
   
4. /* USER CODE BEGIN 3 */
   
5. HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_6);
   
6. HAL_Delay(200);
   / r% b6 T5 q; {4 ^9 Z0 g
7. HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_7);
   
8. HAL_Delay(200);
   
9. HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_8);
   0 s+ l; @6 R7 ?4 u8 Q% ?& @
10. HAL_Delay(200);
    
11. HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_9);
    
12. HAL_Delay(200);
    
13. }

复制代码

然后在 IAR 的链接选项内配置中断向量表的位置以及 APP 在内部 FLASH 的起始位置：
/ o( g& q' ?4 B' v, f1 u, C


然后我们得将中断向量表重映射到 SRAM 中：
' q& |) {- x8 u# U0 b

1. /* USER CODE BEGIN 0 */
   
2. #define APPLICATION_ADDRESS (uint32_t)0x08007000
   
3. #if (defined ( __CC_ARM ))
   5 w; O/ J) ]' }0 B
4. __IO uint32_t VectorTable[48] __attribute__((at(0x20000000)));
   
5. #elif (defined (__ICCARM__))
   
6. #pragma location = 0x20000000
   
7. __no_init __IO uint32_t VectorTable[48]; //定义 VectorTable 这么一个数组，位置放在
   0 {9 Q# j6 I4 L+ k2 Q. O5 B
8. 0x2000000 这个 SRAM 位置，用来存放重映射后的中断向量表
     E. a* A! ]9 _' z3 e! _5 t9 F
9. #elif defined ( __GNUC__ )
   $ r. e( c; q2 M4 W3 r( s
10. __IO uint32_t VectorTable[48] __attribute__((section(".RAMVectorTable")));
    / o5 y2 S2 U- T7 X1 w: u( _
11. #endif
    
12. /* USER CODE END 0 */

复制代码

在 main 函数中进行重映射：
2 f; J* e9 c; }+ x2 H" ?

1. int main(void)
   7 I% w6 X4 d9 _1 i" Q
2. {
   / v/ f7 r, v# w* g6 f6 l6 I
3. /* USER CODE BEGIN 1 */
     M' u" P, K' j
4. uint32_t i=0;
   
5. /* USER CODE END 1 */
   
6. /* MCU Configuration----------------------------------------------------------*/
   0 [1 R8 i- z8 _7 w; A% J. q
7. /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
   
8. HAL_Init();
   
9. /* USER CODE BEGIN Init */
   ' L/ t5 m* R9 m! ~1 [4 [+ n5 {
10. for(i = 0; i < 48; i++)//拷贝中断向量到 VectorTable 数组
    8 z6 b* J, u8 R; C  V
11. {
    , \4 H1 J7 j8 g9 E- [# M' w
12. <span style="font-style: italic;"><span style="font-style: normal;"> VectorTable = *(__IO uint32_t*)(APPLICATION_ADDRESS + (i<<2));
    7 ~7 W+ b  k: m4 [) W- A) J6 C
13. }
    
14. /* Enable the SYSCFG peripheral clock*/
    % V: q5 U0 m' g
15. __HAL_RCC_SYSCFG_CLK_ENABLE();
    
16. /* Remap SRAM at 0x00000000 */
    1 U$ U  h: v$ H. q8 P7 \
17. __HAL_SYSCFG_REMAPMEMORY_SRAM();//重映射到 SRAM
    
18. /* USER CODE END Init */
    
19. /* Configure the system clock */
      m+ g1 A+ v+ P  m/ @( X6 S
20. SystemClock_Config();
    
21. //…</span></span>

复制代码

) k5 a( Y1 Q# F! a7 t7 G讲到这里，相信很多读者可能存在疑问，为什么这里一定要这么重映射到 SRAM？这个是应为 M0 内核的 MCU 没有 VTOR这个寄存器，当存在 BOOT 时，APP 中原先本来应该位于 0x0800 0000 这个位置的中断向量表被 BOOT 占据了，那么 M0 内核在运行后怎么找到偏移到 0x0800 7000 位置的中断向量表的呢？
- u1 [; @1 q3 F7 ^/ E8 C在 M3/M4 内核的 MCU 中，是存在 VTOR 这个寄存器，M3/M4 内核启动后会根据 VTOR 寄存器的值来寻址中断入口，但 M0由于缺少这个寄存器，那么我们就将中断向量表整个搬到 SRAM 中，再重映射到 SRAM，这样一来，M0 内核在启动后将不再从内部 FLASH 寻址中断入口，转而从 SRAM 中寻址，这样 APP 的中断就能一样正常响应了。换句话说，如果 APP 不进行重映射，那么一旦中断产生，那么内核还会从内部 FLASH 0x0800 0000 的地址中去寻址中断入口，这不成了 APP 的中断在 BOOT 中执行么？很明显，会出现错误直接导致崩溃。这就是为什么要重映射的原因。

! {/ f7 [1 A" t# H

; R! {5 z/ Q9 S' B- I$ R% a/ g( M5 制作 DFU 文件
) i; t& Y' o: d后续我们将演示如何使用 BOOT 来对 APP 进行升级，我们将使用到一个 PC 端软件 DfuDemo 来实现这个过程，这个DfuDemo 软件只能识别固定了后缀名为 dfu 格式的文件，因此，首先我们需要将 APP 程序转化成 dfu 文件。
5.1 生成 HEX 文件
* |& h- d5 w, U% F我们先将 APP 程序生成 hex 格式文件:
  h+ Z, s6 F6 x! Y: x



如上图所示，在 IAR 中先设置生成 HEX 格式文件，最后我们将得到后缀名为 hex 的文件。
0 T+ y8 c; ]7 O& g5 A; w
5.2 将 HEX 文件转成 DFU 文件
然后使用 DFU File Manager 软件将 hex 文件转成 dfu 文件：


. g& ?7 y8 w( T5 V' q3 f; `

0 T# p& f* P+ k9 a) T最终转为 dfu 文件：


2 {6 A* s9 S5 s( {. i

6 使用 BOOT 烧录 APP
首先，我们预先将 BOOT 工程烧录进 STM32F072-Discovery 板。在连接 USB 线到 PC，打开 DfuDemo 这个软件，在导入APP.dfu 这个转化好的 dfu 文件并开始烧录。

1 `& ]) \8 \* k5 q

$ T  c" ^3 f! g9 e5 {: r
# J/ N1 [% y; V


! Z2 d$ \+ h) A8 {* _/ C

) j3 T: B+ e# s* u0 q; z2 z+ N如上图所示，原先在 CubeMx 中对 USBD_DFU_MEDIA_Interface 的字符串设备将在 DfuSe Demo 这个 PC 端软件的 Flash结构中显示出来，字符串与显示结构的对应关系如上图标志。
烧录完后进行验证 :




如上图，烧录 APP 完成后验证是通过的，LED 能正常闪烁。

4 S. y  ~$ q+ o
# W+ W6 m( a8 j! R6 d& |* A
) N! {$ q2 n$ H( g4 r  \" K" R7 注意事项
* c  x! v( b$ |' {: \2 t1. BOOT 本身实际所占 FLASH 空间不能与 APP 空间有重叠，即 BOOT 不能超过 USBD_DFU_APP_DEFAULT_ADD 所表示的地址；
" W/ a, ]( y/ u$ {: c( I9 g( o( q2. BOOT 本身实际所占 FLASH 空间必须在 string 所表示的只读地址范围内；而 APP 也必须在 string 所表示的可读写地址范围内；
3 J: p$ i3 Q2 j/ L3. USBD_DFU_APP_DEFAULT_ADD 必须向 Page/Sector 的位置对齐，即向可擦除单元块对齐。
+ P* }: C& J7 }9 C7 {4. 对于 Coretex-M0 核的 MCU，由于没有 VTOR 这个寄存器，APP 若不在默认地址 0x0800 0000，则必须将中断向量表重映射到 SRAM，APP 才能正常工作，对于 M3/M4/M7 核的 MCU，在 APP 内则修改 VTOR 这个寄存器即可。
5. 有些 MCU 内置 BootLoader 也是支持 DFU 模式，也是可以通过 DfuSeDemo 这个软件配合升级用户程序，它的通信协议与本文所述并没有太大差异，只不过本文所述内容为 IAP 方式，而那个是属于 BootLoader 方式，这个读者注意区分下，读者可以通过参考应用笔记 AN2606 了解详情。
* r  D7 y2 A9 e- O
3 s3 e( s3 n; X! D

* q7 ]7 N2 R6 O' Z4 N4 h
' f, K# U" e& I, t) u- y