8 t4 d7 ]6 L3 M" V
之前做的一个小项目，因为刚开始没有考虑到以后会经常升级，而每次升级都要旋开4颗螺丝拆壳，然后烧程序，再装壳，如果只要更新几个倒没啥感觉，但是一下更新几百个，那工作量。。。。，正好板子上有SD卡，就想着写个Bootloader程序，通过读取SD卡中的Bin文件进行IAP升级，这样可以大大简化以后的升级。IAP升级原理就不多说了，网上相关的资料和帖子一大堆，这里简单介绍我做的IAP方案，欢迎大家批评指正！
& t9 ?) d; Z  y- p; E+ v- E: |, ~Bootloader程序设计
bootloader程序的设计思路很简单，流程图如下：
. ~, ]7 K0 O8 U! g* d/ V. G
" f) H# G/ Q& L$ b1 H8 q

初始化程序就不介绍了，比较简单。主要介绍下Bin文件检测以及IAP过程。我将IAP过程分为5个步骤，如下：
+ z, ~, ?6 T* N2 ?2 {3 kStep1：检查是否存在升级文件，若存在，打开后跳至Step2，若不存在或者打开失败，跳至Step5
Step2：擦除App程序对应的扇区，擦除成功后跳至Step3，若擦除失败，跳至Step5
# I. t5 s" }' K( B9 `Step3：使用f_read()函数读取Bin文件，每次读取2048个字节，并写入Flash。当文件全部被写入flash后跳至Step4，若中间出现写入错误，跳至Step5
+ P$ h6 H& d5 f; G% O. d1 k5 i% A2 k& sStep4：检查栈顶地址，跳转至App程序。若栈顶地址非法，跳至Step5
* J; E$ U. u) |2 G' @. jStep5：此步表示本次升级失败，死循环，同时LED提示升级失败，等待重新上电
查找升级文件时我固定从Update文件夹查找，所以只要将Bin文件拷贝至Update文件夹就行了。
! j6 q/ [& e0 r8 ?4 s/ f, [五个步骤的转换是通过switch函数实现的。代码如下：
1 M( o" ]4 i* [5 r' j7 W

1.         while(1)
   
2.         {
   4 f! M$ n7 {' P2 t3 Y3 V5 }) h
3.             switch(iap_step)
   6 [( c& j7 C: h2 X  U! R
4.             {
   # G2 R. o8 u7 ^4 y7 _- z
5.                 /* Step1:检查是否存在升级文件 */
   + \9 ~7 P3 ^0 b' ?
6.                 case 1:
   
7.                 {
   
8.                     /* 查找升级文件 */
   
9.                     result = f_findfirst(&dj, &fno, "0:/Update", "FDR_update*.bin");
   
10.                     
    ! m* ]; q7 ]/ W% [& s
11.                     /* 存在升级文件 */
    
12.                     if(result==FR_OK && fno.fname[0])
    4 T8 }) ^9 i& S1 U
13.                     {
    
14.                         /* 获取文件名字符串 */
    
15.                     #if _USE_LFN
    
16.                         fn_str = *fno.lfname ? fno.lfname : fno.fname;
    
17.                     #else
    
18.                         fn_str = fno.fname;
    
19.                     #endif
    
20.                         /* 得到完整的文件名路径 */
    6 N& o7 s- Y+ _' K
21.                         sprintf(fname_path,"/Update/%s",fn_str);   
    
22.                         
    & R! n" k, T, q  b1 z
23.                         /* 打开升级文件 */
    
24.                         result = f_open(&file_fdr,fname_path,FA_OPEN_EXISTING|FA_READ);
    
25.                        
    1 h* O7 c* K* B- O& j8 T2 \
26.                         if(result==FR_OK)
    , ~9 D8 ^* ?3 P1 j. ^+ r! r: V
27.                         {
    
28.                             /* 打开成功，准备升级 */
    + W" N% J  m9 j6 p
29.                             iap_step = 2;
    
30.                         }
    & D8 P6 i- }: k% @7 K3 }
31.                         else
    
32.                         {
    ; Q6 O: {2 U- {. \  Y/ K
33.                             /* 打开失败 */
    
34.                             f_close(&file_fdr);
    
35.                             f_closedir(&dj);
    
36.                             iap_step = 5;
    / e+ F( m5 {9 q( O( O
37.                         }
    " T: _* l; @+ T* p: N+ l
38.                         
    
39.                     }
    2 ?* Q; S' ^6 U2 H2 ^3 b
40.                     else
    - z9 R/ {+ j' I% x7 L6 N3 N( j) i4 S
41.                     {
    6 g' [5 G5 o  O$ ^5 m4 V/ B
42.                         
    
43.                         /* 不存在升级文件，直接跳转 */
    
44.                         f_closedir(&dj);
    
45.                         iap_step = 4;
    ' f$ T' q  H0 x
46.                         
    
47.                     }
    / @1 {7 v$ q( k/ B( y, S& U
48.                     break;
    2 o) f3 i& w% x7 I
49.                 }
    $ N0 E+ ~" A+ _% i
50.                
    
51.                 /* Step2:存在升级文件，先擦除扇区 */
    
52.                 case 2:
    
53.                 {
    
54.                     FLASH_Unlock();
    
55.                     res = IAP_FLASH_Erase(APPLICATION_ADDRESS);
    + K% H, R9 i/ t
56.                     FLASH_Lock();
    7 B% s& \! Z; [& S, w7 r0 L8 W
57.                     if( res )
    . |0 Y7 a; F. [
58.                     {
    
59.                         iap_step = 3;
    
60.                     }
    : _; t& V6 j1 t. d
61.                     else
    
62.                     {
    
63.                         f_close(&file_fdr);
    6 d! i: J  [+ z  }1 k% m
64.                         f_closedir(&dj);
    
65.                         iap_step = 5;
    
66.                     }
    
67.                     break;
    
68.                 }
    
69.                
    
70.                 /* Step3:扇区擦除成功，准备依次读取并写入 */
    
71.                 case 3:
    5 Z' `. Y- k* ~! s) @1 [
72.                 {
    
73.                     memset(appbuf,0xFF,2052);
    
74.                     f_read(&file_fdr,appbuf,2048,&br);
    
75.                     
    
76.                     FLASH_Unlock();
    
77.                     
    
78.                     res = IAP_FLASH_Write((u32*)appbuf,(u16)ceil(br/4.0f));
    
79.                     
    
80.                     FLASH_Lock();
    ) @. F! T# i* H% D8 m* C# C' \
81.                     
    
82.                     Toggle_LED_AP();
    ' T3 h5 l3 x" V/ e4 v
83.                     
    9 p3 l! K) k. R3 J- C) U) V
84.                     if(res == 0)
    
85.                     {
    , |' c, p/ I1 x
86.                         f_close(&file_fdr);
    ) D' a: i2 k& f' a) x+ l
87.                         f_closedir(&dj);
    
88.                         iap_step = 5;
    1 s$ L3 j. A% h
89.                         
    
90.                     }
    $ b; h8 {8 F5 p1 m, I. i
91.                     else
    
92.                     {
    
93.                         /* 文件读完了 */
    . x. N$ t0 A( h7 n! b1 I0 u# S% y8 j
94.                         if(br<2048)
    
95.                         {
    
96.                             f_close(&file_fdr);
    
97.                             f_closedir(&dj);
    ) \! d0 N' C# X+ U- W
98.                             f_unlink(fname_path);
    
99.                             iap_step = 4;   
    3 g1 _! u# e  T3 k
100.                            
     * G1 A6 W" v5 o/ Y
101.                         }
     
102.                         
     
103.                     }
     0 ]* h+ x4 y& _0 m7 @
104.                     break;
     , `, w. I4 _4 D
105.                 }
     
106.                
     + U8 s8 g% u. Z2 Z( \
107.                 /* Step4:跳转至App程序 */
     * [8 V* K% ?3 a0 k
108.                 case 4:
     
109.                 {  
     
110.                     /* Test if user code is programmed starting from address "APPLICATION_ADDRESS" */
     ; V8 s: _) h1 J* p, K: M5 G
111.                     if (((*(__IO uint32_t*)APPLICATION_ADDRESS) & 0x2FFE0000 ) == 0x20000000)
     
112.                     {
     - V9 O: d4 r/ D  s! \
113.                         /* Jump to user application */
     ( w0 _; k: w* d  p5 U8 s; x
114.                         JumpAddress = *(__IO uint32_t*) (APPLICATION_ADDRESS + 4);
     
115.                         Jump_To_Application = (pFunction) JumpAddress;
     
116.                         
     $ [( j: v' d- _# U( c
117.                         /* Initialize user application's Stack Pointer */
     : N* [7 Z6 |$ b: v+ A
118.                         __set_MSP(*(__IO uint32_t*) APPLICATION_ADDRESS);
     8 h) o: T# a& R( V1 ^7 H) Z5 W+ P4 L
119.                         
     
120.                         /* Jump to application */
     & q0 L2 j  U7 z) b, v
121.                         Jump_To_Application();
     
122.                     }
     * X  D% U" U9 Z0 p5 p
123.                     else
     
124.                     {
     / O5 [' j, T" o; w, ^
125.                         iap_step = 5;
     : g5 b9 E$ ^* o2 f+ W7 \
126.                     }
     
127.                     
     
128.                     break;
     % d2 i: v8 w) J5 B# e% g4 @% _( s
129.                 }
     
130.                
     8 B) v# [  B- U4 I8 u: `3 w! M2 X
131.                 /* Step5:升级失败，等待重新上电 */
     ! S+ T/ \2 [; r) @1 k( w
132.                 case 5:
     
133.                 {
     # N7 p1 L4 h8 _, s7 k% Y: S
134.                     if(GetFreqFlag(FREQ_0_5HZ))
     ' ?8 B% E; x5 @
135.                     {
     
136.                         Toggle_LED_AP();
     , j  d3 }3 p/ D( f& H1 G: w; n
137.                     }
     
138.                     break;
     
139.                 }
     & v5 o5 `$ X9 K! u  c4 g
140.                
     
141.                 default:
     
142.                 {
     
143.                     iap_step = 1;
     
144.                     break;
     
145.                 }
     & c3 T6 d) M. ?+ B" @5 ?0 i
146.                
     
147.                
     
148.             }//iap step switch
     
149.             
     5 l/ y6 d/ O5 _  C" [' V+ T/ _
150.         }//end of bootloader while(1)

复制代码

特别要注意形参uint16_t Datalength是指的字数，就是uint32_t类型变量的数量，而f_read读取的是字节数，要除以4进行转换，刚开始就是没有转换导致写的flash数据不正常，跳转后死机。
! m& Z0 c$ _/ ?' Z. a  T跳转程序也是参考的官方例程。我设置的App程序起始地址为：0x0800 A000
- B& x0 }; l5 `1 P1 H此外bootloader程序的IAR工程配置如图，flash地址范围：0x0800 0000 - 0x0800 9FFF，占用40K
8 O  V3 d0 L! G

$ v$ {# d% y3 W2 j& L3 V* LApp程序设计
1、App程序主要在原来的程序基础上修改flash起始和结束地址，以及中断向量偏移。Flash地址范围我设为：0x0800 A000 – 0x0801 FFFF，占用88K，IAR配置如下：

1 l: J2 j1 R/ K

% z7 x0 A6 }$ \! c& c3 Q
2、由于STM32F0没有像F1，F4那样的中断向量偏移寄存器，需要通过进行内存地址映射来实现，具体实现原理参见http://www.51hei.com/bbs/dpj-40938-1.html
所以在App程序main函数开始的地方加如下代码：（参考官方例程修改）

app设置

其实在官方例程中为 RCC_APB2PeriphResetCmd(RCC_APB2Periph_SYSCFG, ENABLE);这并没有打开系统配置时钟，应该改为RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);我也是看到网上其他帖子才发现并改正过来的，在这里感谢网友们的分享！
以上就是我做的STM32F0的IAP升级方案，实际测试感觉速度很快，可能我的App程序不大，50K左右，升级过程基本在3秒以内。

  L2 C9 K; h2 g* H+ Q

MrJiu 发表于 2017-9-16 09:23
6 ]% ?- G4 \& G4 Q3 B不过，支持一个！！！

* P1 e7 _3 ]" C# s, z谢谢版主，发现少了一幅图，重新编辑上传了

ts2000 发表于 2017-9-18 15:57
0 i- K8 v9 ]) l0 Y" ~$ W8 E做过类似的，顶一下楼主~

0 Q" y. e' y( o1 \9 L谢谢

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

支持一下

不过，支持一个！！！

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

谢谢分享！

谢谢分享

谢谢分享，支持一下！

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

谢谢分享

谢谢分享，支持..

谢谢分享！

多谢分享