前言
+ S' S' X" v+ r$ Q! N6 |众所周知，使用 STM32 时，当需要使用 System Memory 中的 Bootloader 进行代码升级的时候，需要将 BOOT0 脚拉高，复位后才能进入 Bootloader 程序，使用 Flash Loader Demonstrator 等工具进行串口烧写升级。这就需要在 BOOT0 这个引脚上留出按键或者是跳线脚。但是，STM32F09x 具有一项新的特性，使不必使用 BOOT 脚而进行串口升级成为可能。我们来共同探讨一下。
问题
某客户在其产品的设计中，使用了 STM32F091RCT6，产品在出厂后将来可能由于功能的升级需要升级代码。由于外观的需要，客户不希望留一个用于升级的按键或是跳线槽在外边。希望能够是通过接收串口命令来实现启动升级，又希望能够直接使用 System Memory 中的 Bootloader 进行代码升级。
/ _- L1 |# {) Z6 X! L
( b. n  z) Y7 W: `# c. B6 w9 k# g: {调研
1.认识一下 STMF09x 和 STM32F04x 在 Boot Configuration 中的新特性
  d; e8 }% v6 P打开参考手册 RM0091，翻到 Boot Configuration 那一节，我们可以看到 Table 3 中对 Boot Mode 进行了描述，如下：
8 A+ B5 K5 N. H


) u6 s, L# r; B0 d7 P, }5 x6 @2 V从表格中，我们先来看一下第 1 条注释：
5 W; o) L/ {' j  ^' N1 [- A“Grey options are available on STM32F04x and STM32F09x devices only.”
, q% K$ L, y, ]" ], D2 w意思是说，灰色部分对 STM32F04x 和 STM32F09x 是有效的。也就是说，除了 BOOT1 是在 Option Byte 中的 nBOOT1 配置之外，STM32F04x 和 STM32F09x 甚至可以将 BOOT0 通过 Option Byte 中的 nBOOT0 来配置，只要将 Option Byte 中的BOOT_SEL 位配置为 0。这使得纯粹使用软件来实现进入 System Memory 中的 Bootloader 来进行串口升级成为可能。
  P: N0 k. X3 B
: P+ w: T4 ^3 U( I# e2.方案设计
既然 STM32F04x 和 STM32F09x 甚至可以将 BOOT0 通过 Option Byte 中的 nBOOT0 来配置，那么基本的思路就是：

1) 在用户代码中，设置进入串口升级的条件（比如说使用复合按键，或者接收到串口发来的一串命令，等等）；一旦条件成立，就将 Option Byte 中关于 BOOT 的配置设置为：BOOT_SEL=0（BOOT0 信号由 nBOOT0 选项位定义），nBOOT1=1 & nBOOT0=0。然后进行复位，重载 Option Byte，这个时候系统就会进入 System Memory 中去运行Bootloader。

2) 此时，打开 Flash Loader Demonstrator，可以进行下载，在下载之前我们要设置在烧写完程序后从 Bootloader 跳转到用户代码，因为我们需要在用户代码中去将 BOOT 的配置修改为从 Main Flash memory 启动。如果不这么做，那么每次复位后都将从 System memory 启动。
8 G: q: O: k  U' i9 s
3) 从第二步可以看到，我们还需要在用户代码的最前面加入判断，如果 BOOT 的配置不是从 Main Flash memory 启动的话，必须对 Option Byte 进行改写，将 BOOT 的配置设置为从 Main Flash memory 启动：BOOT_SEL=0（BOOT0 信号由 nBOOT0 选项位定义），nBOOT1=1 & nBOOT0=1。
" o5 T# ?$ L; ]1 R# H+ b" C  _   从这个思路出发，我们可以得到需要设计的流程图。
% V: T& U/ i9 T# ^: D; c/ k" S( K8 }   主程序的流程图如下：


+ N8 J$ J' i) K: r# V2 T! @. \7 h  o6 b
( u9 e/ e, @- _. R   当进入串口升级的条件成立时，其流程如下：
$ d# t  \1 V0 S4 y9 O  T2 s" F
' x- Q* Q2 Q5 b, O

6 ^9 @) ^" o4 W) J$ e. P- e% r   实验
" `; q0 U$ T1 p6 a2 {   1.设计目标
   使用 NUCLEO-F091RC 来实现此实验。空片进行第一次烧写时使用 SWD 进行烧写，之后所有的.hex 文件再次烧写都将使用Flash Loader Demonstrator 进行下载。不使用 BOOT0 脚。由于只是实验，这里用按下 USER 按键来代表进入串口烧写的条件，用户代码运行 LD2 闪烁的功能。
1 }7 y8 S$ t2 Y$ ^
   2.程序设计
   main()主程序如下：

1.    int main(void)
   
2.    {
   
3.    /*!APB2ENR |= RCC_APB2ENR_SYSCFGEN;
     s! o; c; u) z4 b9 o4 b4 K
4.    SYSCFG->CFGR1 = (uint32_t)0x00000000;
   
5.    /* 此处调用子程序，用来判断 BOOT 的配置是否从 Main Flash memory 启动，如果不是，将
   
6.    Option Bytes 中的 BOOT 配置设置为从 Main Flash memory 启动 */
   
7.    BOOTCONF_User();
   
8.    /* 配置 LED 灯 LD2 的初始化 */
   4 u0 F4 B/ }5 K! x7 z
9.    STM_NUCLEO_LD2Init();
   
10.    /* 配置 USER 按键的初始化，设置为中断口 */
    9 i" A- p3 p" v4 z" v5 l2 g0 r
11.    STM_EVAL_PBInit(BUTTON_USER, BUTTON_MODE_EXTI);
    
12.    /* 主循环进行闪灯，随时等待按键中断以启动串口烧写 */
    1 P' G, X! F: r9 a% c9 D- w; Q5 {
13.    while (1)
    
14.    {
    ( h7 ]. E& J& `0 a1 M3 Y! V% a
15.    /* Toggle LD2 */
    
16.    STM_NUCLEO_LD2Toggle();
    
17.    /* Inset delay */
    7 N8 t, D2 S1 D) l: W
18.    Delay(0xAFFFF);
    
19.    }
    8 x# W5 E  [, y1 k8 f% t( w+ @
20.    }

复制代码

6 N2 H3 t6 u' E   BOOTCONF_User()就是我们思路中的第 3)步，也是我们所关心的，我们来仔细看代码：

1.    void BOOTCONF_User(void)
   
2.    {
   
3.    FLASH_Status status = FLASH_COMPLETE;
   
4.    /* 定义一个 8 个半字的数组用来存放 option bytes 的数据 */
   + C8 V6 A' b2 O$ ]
5.    uint16_t ob[8];
   . U) @/ w' Q0 i- W) n3 c" E
6.    /* 读取 Option Bytes 的数据 */
   
7.    ob[0] = *(uint16_t*)(0x1FFFF800); //RDP
   
8.    ob[1] = *(uint16_t*)(0x1FFFF802); //USER
   
9.    ob[2] = *(uint16_t*)(0x1FFFF804); //DATA0
   5 S9 H2 F) Q3 m9 [1 J
10.    ob[3] = *(uint16_t*)(0x1FFFF806); //DATA1
    
11.    ob[4] = *(uint16_t*)(0x1FFFF808); //WRP0
    
12.    ob[5] = *(uint16_t*)(0x1FFFF80A); //WRP1
    
13.    ob[6] = *(uint16_t*)(0x1FFFF80C); //WRP2
    
14.    ob[7] = *(uint16_t*)(0x1FFFF80E); //WPR3
    
15.    /* 判断 BOOT 配置是否正确并更新 */
    
16.    /* 当从串口烧写完代码之后，从 Bootloader 跳转到用户代码，我们需要将 BOOT 配置设置回来，
    , I- T* X3 X( m
17.    修改为从 Main Flash memory 启动；平时已经是此设置的时候，就不需要修改了 */
    
18.    if((ob[1] & 0x0098) != 0x0018) //判断是否是“BOOT_SEL=0 且 nBOOT1=1 且 nBOOT0=1”, 否则更新
    
19.    {
    : V% }& @+ M; G, [
20.    /* 先解锁 */
    $ I3 `$ o, K$ D* f6 z
21.    FLASH_Unlock();
    0 ^4 x3 a* P9 M  M; u. B
22.    FLASH_OB_Unlock();
    # g, {2 h3 U$ e3 _- c5 ^5 x
23.    /* 再擦除，擦除完成后对 option bytes 进行修改更新*/
    # l8 J# o* D& F3 f/ Z% J3 |8 g
24.    /* Wait for last operation to be completed */
    1 H. v& B+ k: G1 K
25.    status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT);
    
26.    if(status == FLASH_COMPLETE)
    
27.    {
    
28.    /* 擦除 */
    
29.    /* If the previous operation is completed, proceed to erase the option bytes */
    9 W) U. x+ E: Q) `+ \& X' n
30.    FLASH->CR |= FLASH_CR_OPTER;
    % r! T5 J; v1 b; @) i! I/ p
31.    FLASH->CR |= FLASH_CR_STRT;
    
32.    /* Wait for last operation to be completed */
    6 M. W! `3 @4 b
33.    status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT);
    
34.    /* If the erase operation is completed, disable the OPTER Bit */
    
35.    FLASH->CR &= ~FLASH_CR_OPTER;
    9 t6 K9 r$ u, `; R. v- v1 C+ y4 q
36.    /* 更新 option Bytes */
    
37.    /* ob[1]对应的是 USER，里边包含了 BOOT_SEL, nBOOT1, nBOOT0，所以我们对 ob[1]中的这三个位
    0 K( l3 O& X. s- s- A2 w
38.    进行修改 */
    
39.    ob[1] = (ob[1] & 0x6767) | 0x8018;
    ' E) [7 Q1 c. R7 g* x' L9 [+ F
40. 
    
41. /* 写回 option bytes */
    
42. /* Enable the Option Bytes Programming operation */
    4 P/ M4 G6 m& K& G( G5 C6 z
43. FLASH->CR |= FLASH_CR_OPTPG;
    
44. /* Restore the last read protection Option Byte value */
    ' |! l  K! N: L3 V1 C3 T
45. OB->RDP = ob[0];
    
46. status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT);
    ! Q4 \5 l! f4 ?3 K% z
47. if(status == FLASH_TIMEOUT)
    
48. while(1) ; //ERROR
    
49. FLASH->CR &= ~FLASH_CR_OPTPG;
    
50. FLASH->CR |= FLASH_CR_OPTPG;
    
51. OB->USER = ob[1];
    
52. status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT);
    " B8 ?8 l. A" J5 K
53. if(status == FLASH_TIMEOUT)
    $ P2 e  @" I" P: Q5 E; }+ k9 h9 x" w
54. while(1) ; //ERROR
    
55. FLASH->CR &= ~FLASH_CR_OPTPG;
    
56. FLASH->CR |= FLASH_CR_OPTPG;
    ' I9 {' a: s% |# C
57. OB->DATA0 = ob[2];
    ) Y# N" a$ X, e
58. status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT);
    4 g6 G  W) `* [- n# z4 B0 L
59. if(status == FLASH_TIMEOUT)
    7 y: Q0 F* ]! B4 v8 A
60. while(1) ; //ERROR
    
61. FLASH->CR &= ~FLASH_CR_OPTPG;
    
62. FLASH->CR |= FLASH_CR_OPTPG;
    
63. OB->DATA1 = ob[3];
    
64. status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT);
    1 E1 }( e2 D3 Q% p% L
65. if(status == FLASH_TIMEOUT)
    
66. while(1) ; //ERROR
    . L5 m1 T6 s: g- @
67. FLASH->CR &= ~FLASH_CR_OPTPG;
    
68. FLASH->CR |= FLASH_CR_OPTPG;
    
69. OB->WRP0 = ob[4];
    8 |/ R# O  E; f9 S7 D- m3 K! f
70. status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT);
    
71. if(status == FLASH_TIMEOUT)
    
72. while(1) ; //ERROR
    ( X  |& X# [2 |$ P, ~% W& `* O
73. FLASH->CR &= ~FLASH_CR_OPTPG;
    / f. y# B4 S- p7 O
74. FLASH->CR |= FLASH_CR_OPTPG;
    
75. OB->WRP1 = ob[5];
    4 @! B+ x) n: d4 i1 K4 N7 G
76. status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT);
    ) \; R0 o7 `/ d; b* ^
77. if(status == FLASH_TIMEOUT)
    
78. while(1) ; //ERROR
    
79. FLASH->CR &= ~FLASH_CR_OPTPG;
    
80. FLASH->CR |= FLASH_CR_OPTPG;
    
81. OB->WRP2 = ob[6];
    ' U  _& c) W4 n- ?$ o9 {& J
82. status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT);
    
83. if(status == FLASH_TIMEOUT)
    , k* f( R9 l5 j+ ~, A
84. while(1) ; //ERROR
    
85. FLASH->CR &= ~FLASH_CR_OPTPG;
    2 k) \7 ?% D( J: j4 R* U8 G
86. FLASH->CR |= FLASH_CR_OPTPG;
    - a& {" X' E; K! d  \! Z  |
87. OB->WRP3 = ob[7];
    6 J6 t8 B. {$ [. R# {, f
88. status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT);
    
89. if(status == FLASH_TIMEOUT)
    
90. while(1) ; //ERROR
    
91. FLASH->CR &= ~FLASH_CR_OPTPG;
    
92. }
    
93. else
    3 m. @# M: |1 [  A+ [
94. {
    & }% t2 j8 _; ^+ M: ]7 B6 s
95. if (status != FLASH_TIMEOUT)
    
96. {
    
97. /* Disable the OPTPG Bit */
    1 C7 Y9 t1 R& m" |: e! S
98. FLASH->CR &= ~FLASH_CR_OPTPG;
    
99. }
    
100. }
     
101. /* 写完，重新锁止 */
     
102. FLASH_OB_Lock();
     + u1 j2 c) T7 T! Q& C
103. FLASH_Lock();
     
104. /* 验证 option bytes 数据被正确写入 */
     
105. if((*(uint16_t*)(0x1FFFF800)) != ob[0])
     
106. while(1) ; //ERROR
     ; W9 Q4 [& X- O$ I  A7 Z
107. if((*(uint16_t*)(0x1FFFF802)) != ob[1])
     
108. while(1) ; //ERROR
     
109. if((*(uint16_t*)(0x1FFFF804)) != ob[2])
     
110. while(1) ; //ERROR
     ! O. f" l/ L1 t
111. if((*(uint16_t*)(0x1FFFF806)) != ob[3])
     
112. while(1) ; //ERROR
     
113. if((*(uint16_t*)(0x1FFFF808)) != ob[4])
     
114. while(1) ; //ERROR
     
115. if((*(uint16_t*)(0x1FFFF80A)) != ob[5])
     
116. while(1) ; //ERROR
     
117. if((*(uint16_t*)(0x1FFFF80C)) != ob[6])
     
118. while(1) ; //ERROR
     
119. if((*(uint16_t*)(0x1FFFF80E)) != ob[7])
     
120. while(1) ; //ERROR
     
121. 
     0 n# |: z5 x& ?& [
122. /* 将 FLASH_CR 的 OBL_LAUNCH 位置 1，产生一个可以重新载入 option bytes 的复位
     ( L& }6 U, ]7 Q6 M4 r
123. 其目的在于避免此复位和 Power On 的复位以外的其他复位产生时不能正常工作。
     0 ~2 U7 E) i% Y7 L) V! H7 z( S
124. 例如，使用串口烧写完代码，从 Bootloader 跳入用户代码，此时如果按下 RESET 按键
     9 i7 X9 z- |6 C
125. 产生复位，则又重新进入 System Memory 中。所以加此复位，以避免此现象产生。 */
     ' t* a5 L' F* f. D; m
126. FLASH_OB_Launch();
     
127. }
     9 I$ p4 {  I" y6 i. A  |0 I
128. }

复制代码

1 j, W( T6 o- T1 V, Q) F我们再来看按键中断的程序：

1. void EXTI4_15_IRQHandler(void)
   
2. {
   
3. if(EXTI_GetITStatus(EXTI_Line13) != RESET)
     N: C- `2 e3 k4 P8 ^$ Z9 ?
4. {
   
5. EXTI_ClearITPendingBit(USER_BUTTON_EXTI_LINE);
   
6. BOOTCONF_System();
   ! n( l" C0 [6 n' p7 s; G, _
7. FLASH_OB_Launch();
   
8. }
   
9. }

复制代码

这个代码很简单，就是清除一下中断标志位，然后将 Option Bytes 中的 BOOT 配置设置为从 System memory 启动，然后再调用 FLASH_OB_Launch()来产生一个可以重新载入 option bytes 的复位，这个复位将导致复位后进入的是 System memory，而不是 Main Flash memory 了。
其中关键的代码是 BOOTCONF_System()，我们来看一下：
( ]7 N3 _1 k/ S& J( |! L

1. void BOOTCONF_System(void)
   
2. {
   * k9 e. T9 o- I( _4 S
3. FLASH_Status status = FLASH_COMPLETE;
   : K) i) H' ^7 ^0 c
4. uint16_t ob[8];
   
5. /* Get opiton bytes data */
   
6. ob[0] = *(uint16_t*)(0x1FFFF800); //RDP
   - }. ~1 h+ h2 n! G4 G
7. ob[1] = *(uint16_t*)(0x1FFFF802); //USER
   
8. ob[2] = *(uint16_t*)(0x1FFFF804); //DATA0
   
9. ob[3] = *(uint16_t*)(0x1FFFF806); //DATA1
   8 A/ i7 \! v4 x& [! C8 W. T/ O
10. ob[4] = *(uint16_t*)(0x1FFFF808); //WRP0
    
11. ob[5] = *(uint16_t*)(0x1FFFF80A); //WRP1
    ! |: m& ~  h* Z
12. ob[6] = *(uint16_t*)(0x1FFFF80C); //WRP2
    + F4 y3 T7 H* L- B6 H
13. ob[7] = *(uint16_t*)(0x1FFFF80E); //WPR3
    
14. /* Unlock */
    
15. FLASH_Unlock();
    5 |0 B) |1 c; }8 J2 m5 y
16. FLASH_OB_Unlock();
    & M2 P* G. H6 K3 k" \
17. /* Erase and update Option bytes*/
    * ~) w8 P. a' U% z
18. /* Wait for last operation to be completed */
    ! M: [( W7 Q% o( }4 G
19. status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT);
    : u/ \4 l, E0 a; C+ a
20. if(status == FLASH_COMPLETE)
    # c1 p6 q, P! G: N, H; R) S* g
21. {
    
22. /* If the previous operation is completed, proceed to erase the option bytes */
    ' f6 }3 l3 i! n* F7 [
23. FLASH->CR |= FLASH_CR_OPTER;
    
24. FLASH->CR |= FLASH_CR_STRT;
    4 s# U5 _4 }8 |- a* w
25. /* Wait for last operation to be completed */
    , C% K, Y+ d# U0 @' K
26. status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT);
    % I6 h4 W  Y7 e$ t) C, _2 r6 P4 s' B/ \3 g
27. /* If the erase operation is completed, disable the OPTER Bit */
    , t9 W6 n) d0 @( H" r
28. FLASH->CR &= ~FLASH_CR_OPTER;
    
29. /* Update option bytes */
    , A0 U# v2 z( Y: W1 \
30. ob[1] = (ob[1] & 0xFFF7) | 0x0800;
    
31. /* Enable the Option Bytes Programming operation */
    " e0 R9 \1 V% C4 ]. a1 F1 ~4 [
32. FLASH->CR |= FLASH_CR_OPTPG;
    9 j1 c2 e& I/ ~( ~- Y; w) Z
33. /* Restore the last read protection Option Byte value */
    
34. OB->RDP = ob[0];
    + {% l$ Y' U* ]* p" P  v9 K, ^
35. status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT);
    , O. w/ d6 D: _9 Y9 U5 f, L
36. if(status == FLASH_TIMEOUT)
    3 i% P# [) r4 C: G5 Z4 s0 @3 S
37. while(1) ; //ERROR
    
38. FLASH->CR &= ~FLASH_CR_OPTPG;
    
39. FLASH->CR |= FLASH_CR_OPTPG;
    
40. OB->USER = ob[1];
    : i( x6 t! l0 v) N0 Z
41. status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT);
    
42. if(status == FLASH_TIMEOUT)
    " m4 R# m" }0 Q/ J
43. while(1) ; //ERROR
    $ W' }8 u( F% K% i" k  `
44. FLASH->CR &= ~FLASH_CR_OPTPG;
    
45. FLASH->CR |= FLASH_CR_OPTPG;
    ' Y; @$ y, K5 A' d
46. OB->DATA0 = ob[2];
    
47. status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT);
    - B& o- b1 K# {, e/ q
48. if(status == FLASH_TIMEOUT)
    : }3 m5 y: @/ B( V0 d
49. while(1) ; //ERROR
    # R9 @/ ^9 b" O) G+ W( U7 T
50. FLASH->CR &= ~FLASH_CR_OPTPG;
    5 N" p% C1 W& Q: E( J6 E4 R8 y! a
51. FLASH->CR |= FLASH_CR_OPTPG;
    3 o! j" w) |# V$ k. q$ Y: V
52. OB->DATA1 = ob[3];
    7 `- y+ Y; m* u; h3 a6 r6 o' ?
53. status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT);
    
54. if(status == FLASH_TIMEOUT)
    
55. while(1) ; //ERROR
    1 m3 C( \, U4 J4 I% E" n: w
56. FLASH->CR &= ~FLASH_CR_OPTPG;
    
57. FLASH->CR |= FLASH_CR_OPTPG;
    + z( o: o% E3 U$ W4 x
58. OB->WRP0 = ob[4];
    
59. status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT);
    
60. if(status == FLASH_TIMEOUT)
    ( q2 S# m) x8 Y# j
61. while(1) ; //ERROR
    0 k+ o; z" B. }7 c$ E
62. FLASH->CR &= ~FLASH_CR_OPTPG;
    
63. FLASH->CR |= FLASH_CR_OPTPG;
    
64. OB->WRP1 = ob[5];
    
65. status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT);
    
66. if(status == FLASH_TIMEOUT)
    
67. while(1) ; //ERROR
      Y8 n( ~1 U1 P  y/ w! R: c: |
68. FLASH->CR &= ~FLASH_CR_OPTPG;
    
69. FLASH->CR |= FLASH_CR_OPTPG;
    
70. OB->WRP2 = ob[6];
    # a" ?2 x# y$ o6 v1 X. o
71. status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT);
    
72. if(status == FLASH_TIMEOUT)
    
73. while(1) ; //ERROR
    
74. FLASH->CR &= ~FLASH_CR_OPTPG;
    ( Q7 X4 _) `. v" o# C# Z
75. FLASH->CR |= FLASH_CR_OPTPG;
    8 c7 Y( O6 U5 P: U% {% f2 T; _
76. OB->WRP3 = ob[7];
    
77. status = FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT);
    
78. if(status == FLASH_TIMEOUT)
    , }! x, U  L! i7 s
79. while(1) ; //ERROR
    ) l# O/ r/ O  t3 @! O
80. FLASH->CR &= ~FLASH_CR_OPTPG;
    
81. }
    9 ~4 Y! l$ L: M: m
82. else
    
83. {
    ' k" ]8 A2 v# e& b& b
84. if (status != FLASH_TIMEOUT)
    ! {. d- `/ D& J$ f/ f
85. {
    
86. /* Disable the OPTPG Bit */
    
87. FLASH->CR &= ~FLASH_CR_OPTPG;
    
88. }
    . u+ f9 u  v. X! R8 O# y
89. }
    ) ~! m0 C: ?6 d1 {/ {/ x
90. /* Lock */
    7 [% A' b% s. ~1 Z* v
91. FLASH_OB_Lock();
    * N( h8 }2 g; K! \
92. FLASH_Lock();
    . ^( d, Y+ Z& b4 z+ V) ?: V- w' S
93. /* Verify */
    
94. if((*(uint16_t*)(0x1FFFF800)) != ob[0])
    ; k1 w+ i' G' i+ F) }4 _# Y4 A" T
95. while(1) ; //ERROR
    
96. if((*(uint16_t*)(0x1FFFF802)) != ob[1])
    
97. while(1) ; //ERROR
    # @2 `$ [4 j* h- w
98. if((*(uint16_t*)(0x1FFFF804)) != ob[2])
    ' O0 V% q2 q, x2 T* O
99. while(1) ; //ERROR
    
100. if((*(uint16_t*)(0x1FFFF806)) != ob[3])
     
101. while(1) ; //ERROR
     " J- [0 P' L% x9 ~! d/ r2 ^/ g
102. if((*(uint16_t*)(0x1FFFF808)) != ob[4])
     
103. while(1) ; //ERROR
     
104. if((*(uint16_t*)(0x1FFFF80A)) != ob[5])
     2 b- d) v  _! J; B6 ~( y5 u
105. while(1) ; //ERROR
     & Z# d+ s! g; o' [+ T! J
106. if((*(uint16_t*)(0x1FFFF80C)) != ob[6])
     
107. while(1) ; //ERROR
     
108. if((*(uint16_t*)(0x1FFFF80E)) != ob[7])
     
109. while(1) ; //ERROR
     
110. }

复制代码

我们可以看到，其实其整个过程与 BOOTCONF_User()非常地像，唯独有两个区别：

1) 没有判断当前的 BOOT 配置，并且在更新 USER 时只是将 nBOOT0 清零而已。因为在用户代码的最开始，我们已经保证了，BOOT 的配置一定是从 Main Flash memory 启动，所以要切换到从 System memory 启动，仅需要将nBOOT0 清零。
( w2 ?- U% }# ~
2) Option Bytes 更新并验证后，并没有调用 FLASH_OB_Launch()。因为我们把它放在中断程序里头了。

程序要点到这里就已经很清楚了。此程序仅为实验用，所以对于出错处理和代码优化，可根据实际应用自行处理。

   3.实验步骤
5 J, [& M# l/ w3 l: ^4 R   下面我们来进行实验：
7 J7 _. Q) R; v. o% K3 @) x1) 我们将程序编译生成的的.hex（我们将其命名为 1.hex）通过 SWD 接口，使用 STM32 ST-LINK Utility 烧写到
0 P6 P! Z- b  N0 B# c   NUCLEO_F091RC 后，可以看到 STM32F091RC 正在欢快地运行 1.hex，闪烁着 LD2。关闭 STM32 ST-LINK
, p4 c  J7 h0 Y) [# m4 R   Utility。
   注：1.hex 是慢闪烁现象
/ c. z# ~0 T8 l0 L


. `: h* H. R: B& F2 U9 o2 d6 c2) 回到程序中，将 main()函数中主循环的“Delay(0xAFFFF);”修改为“Delay(0xFFFF);”，重新编译生成.hex 文件，我们将其命名为 2.hex。
; m* ~, _9 X6 ~# v3 {% V- }   注：2.hex 是快闪烁现象
# D1 u1 t6 ]$ ~6 c. c0 _" S5 _0 Y# P3) 现在我们要开始进行串口升级了。按下 USER 按键，发现 LD2 不再闪烁了，程序已经进入 System memory 运行Bootloader 了。
+ \8 a+ ?- ]2 ]: c6 Z- C4) 打开 Flash Loader Demonstrator，做以下的配置：



6 ^  h! J6 g. }; z5) 点“Next”进入下一个界面，再点“Next ”再进入下一个界面，再点“Next ”进入下一个界面，我们在这个页面中选择下载代码“Download to device”，导入刚才编译生成的 2.hex，选中“Jump to the user program ”，意思就是通过串口烧写完毕后，直接跳到用户代码去运行。如图：
* A; R% i; r+ ], c! A- S) i$ Z


6) 点击“Next”进行代码烧写。烧写成功后，我们就可以看到 LD2 更加欢快地闪烁了，证明我们的烧写是成功的。按下 RESET 按键，也能正常运行代码；断电后再上电，也正常运行。
, Y7 K+ x6 J# M7 q  `' \( O


5 g, t2 |" f1 \& U0 v7 @9 w   到这里，我们的实验成功了，我们可以重复 3)~6)步骤来反复烧写 1.hex 和 2.hex，体验这个串口升级的方便性，再也不用去拔跳线插跳线了。
- O. ^% U: X/ o, L, A! `
" g: O% i6 ?9 @, i1 |, f7 T   结论
* a# V' V3 G2 o6 Z; D   由于 STM32F04x 和 STM32F09x 可以将 BOOT0 通过 Option Byte 中的 nBOOT0 来配置，这个新特性决定了我们可以很方便地实现不使用 BOOT 脚就直接从 System memory 中的 Bootloader 进行代码升级。非常地方便。
/ |* p. u, B2 {9 M
   处理
   此实验证明了“STM32F04x 和 STM32F09x 不使用 BOOT 脚实现 System Bootloader 升级代码”的可行性。但只是实验，客户可自行处理错误情况和代码优化。此外，此实验用按下 USER 按键来激活串口烧写，客户可自行根据应用来修改激活条件，比如从串口接到到一串固定的数据作为激活条件。
. g4 P7 W1 @7 n/ @  z5 D, y( M
   后续
   其实我们在看参考手册时，还看到这么一句话：
   “For STM32F04x and STM32F09x devices, see also Empty check description.”
3 y% F/ Q$ H$ k   也就是说，空片也是可以通过串口进行烧写的，我们后续继续讨论。