之前做的一个小项目，因为刚开始没有考虑到以后会经常升级，而每次升级都要旋开4颗螺丝拆壳，然后烧程序，再装壳，如果只要更新几个倒没啥感觉，但是一下更新几百个，那工作量。。。。，正好板子上有SD卡，就想着写个Bootloader程序，通过读取SD卡中的Bin文件进行IAP升级，这样可以大大简化以后的升级。IAP升级原理就不多说了，网上相关的资料和帖子一大堆，这里简单介绍我做的IAP方案，欢迎大家批评指正！
/ X8 M# M$ ^( m( p2 h! ZBootloader程序设计
bootloader程序的设计思路很简单，流程图如下：
8 e. N5 y+ {: Z7 B! J( |) i1 Q- r
1 F8 s. D3 r7 r3 A( \

: J8 ?0 J0 _2 L

初始化程序就不介绍了，比较简单。主要介绍下Bin文件检测以及IAP过程。我将IAP过程分为5个步骤，如下：
Step1：检查是否存在升级文件，若存在，打开后跳至Step2，若不存在或者打开失败，跳至Step5
Step2：擦除App程序对应的扇区，擦除成功后跳至Step3，若擦除失败，跳至Step5
: C5 [* J* Z. J- }' z+ @% s. qStep3：使用f_read()函数读取Bin文件，每次读取2048个字节，并写入Flash。当文件全部被写入flash后跳至Step4，若中间出现写入错误，跳至Step5
Step4：检查栈顶地址，跳转至App程序。若栈顶地址非法，跳至Step5
& A* N& y1 ]6 G. R5 D: vStep5：此步表示本次升级失败，死循环，同时LED提示升级失败，等待重新上电
查找升级文件时我固定从Update文件夹查找，所以只要将Bin文件拷贝至Update文件夹就行了。
五个步骤的转换是通过switch函数实现的。代码如下：

1.         while(1)
   : Z0 M6 F  a/ C' R) K% S, J
2.         {
   
3.             switch(iap_step)
   
4.             {
   ) g/ m% e) i* `5 E& s
5.                 /* Step1:检查是否存在升级文件 */
     P+ h; M+ [. D" P
6.                 case 1:
   
7.                 {
   % g5 \# a2 l& O; x7 i% t; _
8.                     /* 查找升级文件 */
   : x8 t0 m2 x7 o, w, [
9.                     result = f_findfirst(&dj, &fno, "0:/Update", "FDR_update*.bin");
   - h' u; \: P2 C/ ]
10.                     
    + l; {) p9 j2 T% c- ~# B! D# `
11.                     /* 存在升级文件 */
    8 i* B% W6 z! T9 P3 p' P
12.                     if(result==FR_OK && fno.fname[0])
    
13.                     {
    
14.                         /* 获取文件名字符串 */
    
15.                     #if _USE_LFN
    
16.                         fn_str = *fno.lfname ? fno.lfname : fno.fname;
    
17.                     #else
    
18.                         fn_str = fno.fname;
    ) G+ w; m, \4 D  m: V; a8 E  O
19.                     #endif
    
20.                         /* 得到完整的文件名路径 */
    
21.                         sprintf(fname_path,"/Update/%s",fn_str);   
    # P! K/ Q; T, f0 s! X
22.                         
    # ~- ?( ^; C4 o. `0 N: G! H
23.                         /* 打开升级文件 */
    3 a( }' }2 b( d  _# k5 l3 Q$ `3 Y, C* R
24.                         result = f_open(&file_fdr,fname_path,FA_OPEN_EXISTING|FA_READ);
    
25.                        
    ; O% f7 j3 k9 ?* z
26.                         if(result==FR_OK)
    
27.                         {
    
28.                             /* 打开成功，准备升级 */
    2 q8 G& K( b; U( |5 D5 @% U  L
29.                             iap_step = 2;
    
30.                         }
    
31.                         else
    ! p" m8 Q' z: h# T+ x# p2 W. \
32.                         {
    4 o3 d% S: U) h% ^
33.                             /* 打开失败 */
    
34.                             f_close(&file_fdr);
    
35.                             f_closedir(&dj);
    ' o- {, i8 F5 J5 L
36.                             iap_step = 5;
    - O9 q" Y* m' A1 C% D4 t7 T/ e
37.                         }
    
38.                         
    
39.                     }
    9 {; D# r( h: _+ n+ w$ N/ I
40.                     else
    
41.                     {
    9 P6 b3 ]2 `0 q1 K, |+ ]  @+ e
42.                         
    
43.                         /* 不存在升级文件，直接跳转 */
    ' \: v" v" B! b
44.                         f_closedir(&dj);
    2 c* T* F" e2 Z" Y# [
45.                         iap_step = 4;
    : V3 H. p% ?# F9 K6 i9 J
46.                         
    
47.                     }
    2 F! s& G$ C! j: x+ |% o7 y
48.                     break;
    2 m! e3 K( R& v- U! t. Z
49.                 }
    ( y8 H6 v% W/ e
50.                
    
51.                 /* Step2:存在升级文件，先擦除扇区 */
    + v- ^, U1 w5 U/ k' H( a
52.                 case 2:
    
53.                 {
    + d; P0 P+ t) B. V
54.                     FLASH_Unlock();
    
55.                     res = IAP_FLASH_Erase(APPLICATION_ADDRESS);
    $ h! ~; m% o. [6 p* a$ i
56.                     FLASH_Lock();
    
57.                     if( res )
    
58.                     {
    
59.                         iap_step = 3;
    
60.                     }
    5 {- s7 x' S1 p% A
61.                     else
    4 g! V9 b+ o1 v/ K; s) `7 T6 r
62.                     {
    ! A! a1 Z# x- c6 p5 f
63.                         f_close(&file_fdr);
    # Z& A8 B0 z& [2 g1 ~. |0 s
64.                         f_closedir(&dj);
    6 Q, r1 G# X! h9 [3 E5 D
65.                         iap_step = 5;
    
66.                     }
    % a8 k; d7 ?) `9 w1 c- d6 A
67.                     break;
    ! ]7 P! o& t7 l2 i
68.                 }
    # o7 I5 p1 e& v. z5 C. H
69.                
    
70.                 /* Step3:扇区擦除成功，准备依次读取并写入 */
    
71.                 case 3:
    
72.                 {
    
73.                     memset(appbuf,0xFF,2052);
    ; E  Q( a% R/ O# o+ K( q
74.                     f_read(&file_fdr,appbuf,2048,&br);
    6 g; B0 x* Y+ d
75.                     
    ( T6 c' `' g* h/ F5 _
76.                     FLASH_Unlock();
    
77.                     
    
78.                     res = IAP_FLASH_Write((u32*)appbuf,(u16)ceil(br/4.0f));
    3 t; U: x, E0 V1 U8 i. s; {. Q* a
79.                     
    ! O2 }1 l9 d" m
80.                     FLASH_Lock();
    ( m4 K9 y- y5 u
81.                     
    # A) `: Y: H( o% ^
82.                     Toggle_LED_AP();
    
83.                     
    
84.                     if(res == 0)
    
85.                     {
    
86.                         f_close(&file_fdr);
    ( ~' G) Z/ q, N. S! u( }- p9 D
87.                         f_closedir(&dj);
    6 s; r, o' o$ i& O, M4 j6 Y% P
88.                         iap_step = 5;
    
89.                         
    . n3 p, O' P1 U' u
90.                     }
    ) |1 Z+ n, a& t4 M
91.                     else
    0 }, z( ]- N/ n) o% U/ T" ?
92.                     {
    0 {( \  }! V( _) F+ j" u( K
93.                         /* 文件读完了 */
    
94.                         if(br<2048)
    
95.                         {
    
96.                             f_close(&file_fdr);
    : A# }" c' g. C% D; l( h# u0 x
97.                             f_closedir(&dj);
    
98.                             f_unlink(fname_path);
    
99.                             iap_step = 4;   
    * F* v: J! e6 B- O$ T
100.                            
     
101.                         }
     
102.                         
     ( {: B* i, W$ M, e: X( p, k
103.                     }
     8 z3 m% R' E$ I* t7 @, @$ c
104.                     break;
     
105.                 }
     9 d, {) s- Y# x' ?4 v" T* r
106.                
     
107.                 /* Step4:跳转至App程序 */
     
108.                 case 4:
     # i1 t* Q2 U1 K0 J4 G
109.                 {  
     ' u7 |. B5 U/ g, l
110.                     /* Test if user code is programmed starting from address "APPLICATION_ADDRESS" */
     - N: t( \. h; h0 n
111.                     if (((*(__IO uint32_t*)APPLICATION_ADDRESS) & 0x2FFE0000 ) == 0x20000000)
     * Y5 X. N( |4 v* P0 p
112.                     {
     ; F* G, k1 p0 n8 ?# ^! ?! n
113.                         /* Jump to user application */
     
114.                         JumpAddress = *(__IO uint32_t*) (APPLICATION_ADDRESS + 4);
     2 p: }9 U' i' R* J
115.                         Jump_To_Application = (pFunction) JumpAddress;
     3 H: H& n1 e- j6 J& s
116.                         
     
117.                         /* Initialize user application's Stack Pointer */
     
118.                         __set_MSP(*(__IO uint32_t*) APPLICATION_ADDRESS);
     8 G6 N; s2 @- B- U) [
119.                         
     
120.                         /* Jump to application */
     4 X9 ?. @* D, w* `) Y2 H) S  b0 F) b! B, ^
121.                         Jump_To_Application();
     3 K& o  H- `: k, T* e3 N
122.                     }
     5 J$ I: x7 o; o% o
123.                     else
     
124.                     {
     
125.                         iap_step = 5;
     7 ^- j# u+ a! G) T! M, Y
126.                     }
     * V/ m* j* [! ?0 A. H% O6 A! F
127.                     
     
128.                     break;
     
129.                 }
     
130.                
     
131.                 /* Step5:升级失败，等待重新上电 */
     
132.                 case 5:
     ' L" K! Z9 R, F0 z$ |
133.                 {
     
134.                     if(GetFreqFlag(FREQ_0_5HZ))
     
135.                     {
     6 [% ^+ p/ h* r" _
136.                         Toggle_LED_AP();
     : M9 X& M* o# A& t4 _; Q
137.                     }
     , p0 n9 @7 X" t2 }; g! e: T
138.                     break;
     
139.                 }
     ! A, p1 X. P' I6 Z0 P
140.                
     7 j9 g9 ^. A4 k$ M4 P! R
141.                 default:
     9 X) m5 _* W; s" _6 I6 Y
142.                 {
     
143.                     iap_step = 1;
     
144.                     break;
     
145.                 }
     
146.                
     
147.                
     8 e* I0 O  M$ d
148.             }//iap step switch
     
149.             
     * n3 H% h; }5 s4 F' `' M- b
150.         }//end of bootloader while(1)

复制代码

特别要注意形参uint16_t Datalength是指的字数，就是uint32_t类型变量的数量，而f_read读取的是字节数，要除以4进行转换，刚开始就是没有转换导致写的flash数据不正常，跳转后死机。
跳转程序也是参考的官方例程。我设置的App程序起始地址为：0x0800 A000
4 Y- Y( a( D  `此外bootloader程序的IAR工程配置如图，flash地址范围：0x0800 0000 - 0x0800 9FFF，占用40K

; k/ s  M$ a2 q7 n( z0 |* [8 L9 \App程序设计
1、App程序主要在原来的程序基础上修改flash起始和结束地址，以及中断向量偏移。Flash地址范围我设为：0x0800 A000 – 0x0801 FFFF，占用88K，IAR配置如下：

5 w  Z  o* ^% P5 g) S+ f

! N$ ?' G! l$ s8 \* K: F
) G7 ~6 ?( i& q$ i/ T$ \

3 G) ^/ L. i- I+ l; o2、由于STM32F0没有像F1，F4那样的中断向量偏移寄存器，需要通过进行内存地址映射来实现，具体实现原理参见http://www.51hei.com/bbs/dpj-40938-1.html
所以在App程序main函数开始的地方加如下代码：（参考官方例程修改）

app设置

7 k. u6 Z& ]- I: @( { 其实在官方例程中为 RCC_APB2PeriphResetCmd(RCC_APB2Periph_SYSCFG, ENABLE);这并没有打开系统配置时钟，应该改为RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);我也是看到网上其他帖子才发现并改正过来的，在这里感谢网友们的分享！
以上就是我做的STM32F0的IAP升级方案，实际测试感觉速度很快，可能我的App程序不大，50K左右，升级过程基本在3秒以内。
4 [) H2 B' c  P. |3 P7 b5 C3 ]0 ?


( \; W! M3 [2 Q8 b. I

MrJiu 发表于 2017-9-16 09:23
不过，支持一个！！！

谢谢版主，发现少了一幅图，重新编辑上传了

ts2000 发表于 2017-9-18 15:57
5 p( A; g3 E0 U0 _; a) C做过类似的，顶一下楼主~

谢谢

谢谢分享，很实用的教程。

支持一下

不过，支持一个！！！

做过类似的，顶一下楼主~

谢谢分享！

谢谢分享

谢谢分享，支持一下！

谢谢分享，很实用的教程。

谢谢分享

谢谢分享，支持..

谢谢分享！

多谢分享