关于IAP升级的方法和原理，网上已经有很多资料了，这块就不再说了，现在就将bootloader和app配置方法整理如下：
; f9 W! {) `( [8 K$ h/ \" y: tAPP程序就是一个简单的LED闪烁。
APP设置为从FLASH中启动：


+ O7 O+ G$ f( m6 }' P- @STM32F103C8T6单片机flash有64K，前20K空间留给bootloader，从20K之后开始存放APP程序。所以IROM1开始地址设置为 0x8005000，大小为20K。如果APP程序比较大的话，可以修改这个大小值。
然后在程序开始位置设置重新映射复位向量表。让程序从0x8005000位置开始执行。
APP设置为从SRAM中启动：
# L0 D' Z! k+ \* I. o- P* n
5 _! O' O& D, N% D7 i

APP要从SRAM中运行，那么就要重新映射SRAM中的复位向量表。
" D- C8 F# O: p2 s% J, V7 _由于在bootloader程序中设置的是接收数据代码存储从0x20001000位置开始。所以此处也要设置为程序直接从0x20001000位置处开始运行。如要要改变SRAM中的复位向量位置，那么必须要和bootloader代码同时修改，只修改其中一个的话，程序运行时可能会出错。
此处设置SRAM中起始位置为0x20001000，程序大小为10K，也就是0x2800。IRAM1的起始位置就是 0x20001000 + 0x2800 =0x20003800,大小为6k。刚好将STM32F103C8T6单片机的SRAM 20k空间分配完。由于STM32F103C8T6的SRAM空间比较小，所以设置APP从SRAM中启动时，APP代码不能太大。
( [2 ?0 V% {3 m0 @; a$ b( Z; [
1 F2 q: n2 s4 ~/ u( UAPP代码要注意两个地方：一是程序开始时重新映射复位向量表起始位置。二是在选项中设置程序运行起始位置和空间大小。

下来开始配置bootloader代码，通过按键来选择接收APP程序的bin文件，然后通过按键选择从flash中启动代码。
0 v4 K" N' ]* @0 E3 D7 p2 _, J

1. int main ( void )
   
2. {
   
3.     u8 key;
   & D% h3 @# j  y. T. a! t( s
4.     u16 oldcount = 0;                                //老的串口接收数据值
   
5.     u16 applenth = 0;                                //接收到的app代码长度
   
6.     SystemInit();
   
7.     NVIC_PriorityGroupConfig ( NVIC_PriorityGroup_2 ); //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
   
8.     uart_init ( 115200 );        //串口初始化为115200
   9 S: ]' w# C) @% F: P# A
9.     delay_init();                            //延时初始化
   1 z9 b9 r, C( h  \
10. 
    5 O: S+ k2 y/ Y; h+ S5 Y* C, j& C
11.     LED_Init();                                          //初始化与LED连接的硬件接口
    
12.     KEY_Init();                                        //初始化按键
    # ?$ T# }& i( N% Y4 Y6 ?7 t
13. 
    
14.     while ( 1 )
    . ]1 p- `! j, g7 T: u! w
15.     {
    
16.         GPIO_SetBits ( GPIOC, GPIO_Pin_13 );                                                  //PE.5 输出高
    
17.         delay_ms ( 1000 );
    
18.         GPIO_ResetBits ( GPIOC, GPIO_Pin_13 );                                                  //PE.5 输出高
    ) i/ O* D+ C8 M
19.         delay_ms ( 1000 );
    
20.         if ( USART_RX_CNT )
    5 y1 ~4 s0 Z7 A
21.         {
    
22.             if ( oldcount == USART_RX_CNT ) //新周期内,没有收到任何数据,认为本次数据接收完成.
    
23.             {
    
24.                 applenth = USART_RX_CNT;
      E, N9 _' h0 {2 J! `2 o
25.                 oldcount = 0;
    
26.                 USART_RX_CNT = 0;
    9 i6 I* M$ \- _+ d9 ]  s+ }/ D. C1 }
27.                 printf ( "用户程序接收完成!\r\n" );
    
28.                 printf ( "代码长度:%dBytes\r\n", applenth );
    6 ]  \/ b( o! z8 z2 ~  V! F
29.             }
    1 W# q6 k+ u3 f4 L! _: u
30.             else oldcount = USART_RX_CNT;
    
31.         }
    
32.         key = KEY_Scan ( 0 );
    3 {# k7 P1 k: f3 \
33.         if ( key == WKUP_PRES )
    
34.         {
    
35.             if ( applenth )
    ( W- I1 S5 ^- @8 \& A
36.             {
    
37.                 printf ( "开始更新固件...\r\n" );
    5 K+ }6 s8 o; B/ c$ }1 q: k
38.                 if ( ( ( * ( vu32* ) ( 0X20001000 + 4 ) ) & 0xFF000000 ) == 0x08000000 ) //判断是否为0X08XXXXXX.
    1 k! Q( p; {+ `6 A3 P. z1 g
39.                 {
    $ t. a3 E! L- A& v# O3 U
40.                     iap_write_appbin ( FLASH_APP1_ADDR, USART_RX_BUF, applenth ); //更新FLASH代码
    
41. 
    
42.                     printf ( "固件更新完成!\r\n" );
    
43.                 }
    3 ~$ h/ W* V% f6 d
44.                 else
    
45.                 {
    
46.                     printf ( "非FLASH应用程序!\r\n" );
    
47.                 }
    8 \- g% c* D4 j/ h+ P
48.             }
    
49.             else
    ( y& m% ]" m: S+ N9 R$ K
50.             {
    : ^2 X5 I, p7 z- {+ I
51.                 printf ( "没有可以更新的固件!\r\n" );
    
52.             }
    
53.         }
    * S- e* U1 I6 g0 K- y, V
54.         if ( key == KEY2_PRES )
    9 X/ j7 m' t0 |
55.         {
    
56.             if ( applenth )
    
57.             {
    & R7 S7 e: E9 h2 T
58.                 printf ( "固件清除完成!\r\n" );
    
59.                 applenth = 0;
    
60.             }
    3 \  K( R7 [" Q, g
61.             else
    
62.             {
    
63.                 printf ( "没有可以清除的固件!\r\n" );
    
64.             }
    
65.         }
    
66.         if ( key == KEY1_PRES )
    
67.         {
    5 B9 F2 @/ K2 w1 k  i9 h0 l" i
68.             printf ( "开始执行FLASH用户代码!!\r\n" );
    
69.             if ( ( ( * ( vu32* ) ( FLASH_APP1_ADDR + 4 ) ) & 0xFF000000 ) == 0x08000000 ) //判断是否为0X08XXXXXX.
    2 Q1 S. N! V$ d* L1 g, V" ]
70.             {
    # G3 S, q9 T+ @4 k; B; {
71.                 iap_load_app ( FLASH_APP1_ADDR ); //执行FLASH APP代码
    3 s4 r: Y4 Z9 n- m' x
72.             }
    5 m$ S4 l0 _: @- i& q
73.             else
    
74.             {
    
75.                 printf ( "非FLASH应用程序,无法执行!\r\n" );
    + I- y5 p! X9 W# d
76.             }
    5 |3 B( T& d7 v3 n8 j% o1 K, M% m
77.         }
    
78.     }
    3 n% _4 w; L* ]  I8 Y& R1 I
79. }
    

复制代码

8 ?3 {# L. S# _7 t- U通过串口将接收到的数据存到SRAM中，然后通过按键将数据从SRAM复制到FLASH中，然后再通过按键选择从FLASH中启动。
# V+ t" ]/ S( H5 a( j( S3 z) U此处要注意设置数据在SRAM中的存储起始位置和在FLASH中的存储起始位置。
% Z& i9 r. V$ I9 h& {4 F+ p


将串口接收缓冲区的起始位置设置为 SRAM中的0X20001000位置处，如果APP从SRAM中启动的话，那么这个位置也是程序开始运行的位置。

0 O, O# v" A  s1 z) y; V# k" T2 T
, R( S% `6 p1 c: ]( Q/ x
将FLASH中复位向量表的偏移位置设置为0x08005000，如果程序从FLASH中启动时，那么这个位置也是程序开始运行的位置。
- S7 I' c0 B6 w6 T5 U( J( i* O

" P% s4 c8 C9 L& x3 d, y# ?+ T: l) |7 [: L
1 f; l  w9 L2 l/ [" T下来设置bootloader程序存储地址



bootloader程序运行开始位置设置为0x8000000开始，大小为20K，也就是说FLASH中前面20K位置存储bootloader代码，20k–64k位置存储APP代码。

8 x) J* [2 ~: K1 T" M主程序中的代码比较简单，就是从串口接收数据，存储到SRAM中从0X20001000位置开始处，然后通过按键将程序拷贝到FLASH中从0x08005000位置开始处。然后通过按键选择设置程序从FLASH中0x08005000位置处开始执行。
代码中有几处判断不太好理解，这里说说自己的理解。
+ }8 {0 @! L) x8 f/ P
3 N, Q" K, {2 e4 I* b6 N  A4 n
4 _: s1 A, Y2 _  k0 K' j$ R
6 L/ t0 c/ t; u' i* e. J0X20001000+4 是一个数字，前面加上一级指针 ( vu32* ) ( 0X20001000 + 4 )此时将这个数字变成了地址，也就是 0X20001004这个地址，然后前面再加上二级指针 ( * ( vu32* ) ( 0X20001000 + 4 ) 此时表示的是 取 0X20001004 这个地址中存储的数值。
此时先看看内存分布图。
0 f$ X+ x6 Q, ^+ E. M. i. b
; L0 v9 p# p  S
* e: \8 ]0 [  t4 |
; j! g; p# B& O/ K2 n/ Z串口将程序存储到了0X20001000位置开始处，而程序开始执行时首先要复位向量表位置。也就是说0X20001004位置开始就是程序复位向量表的位置，那么这个位置存储的就是要跳转的地址。而所有程序执行都是从0x08000000位置处开始。
7 E" z9 t7 F- X5 q0 y9 ^也就是说如果0X20001004这个地址存储的数值时程序开始执行的起始地址，就说明APP程序在SRAM中存储完成了。下来就可以开始拷贝数据了。

2 y/ H# o& J# s" O# s/ [7 n0 m

同理如果FLASH中存储代码开始位置+4处的值刚好是程序开始执行的地址，也就是说程序已经被拷贝到了FLASH中 FLASH中从_APP1_ADDR 位置开始处。
$ ?/ S$ t/ R8 P
: [0 C/ Q/ A* C通过对比内存中指定位置存储的数据，是不是程序复位后的起始地址，就可以判断出数据是否拷贝完成。
8 Q; s4 N! _0 S* z5 ^% @2 Q1 e下来在看第二种方法，通过串口发送指令来控制bin文件接收和APP运行。

1. int main ( void )
   2 \. C2 Q: `4 g2 }2 ?
2. {
   
3.     u16 oldcount = 0;                                //老的串口接收数据值
   & q0 H. R: T4 F: p: o' [5 p, s
4.     u16 applenth = 0;                                //接收到的app代码长度
   + o0 |2 Y6 e  x; P
5.         u16 app_bin = 0;
   
6.         u16 app_enter = 0;
   
7.     SystemInit();
   6 ^0 P, P9 `& k4 s8 s& V
8.     NVIC_PriorityGroupConfig ( NVIC_PriorityGroup_2 ); //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
   7 u. T* N5 `4 f, Q; F9 w4 a
9.     uart_init ( 115200 );        //串口初始化为115200
   , P: t- O/ ^: s) u
10.     delay_init();                            //延时初始化
    - d+ A! _! F7 n% S1 h
11.     while ( 1 )
    
12.     {
    $ q, ^' p" [+ o8 S, y* z
13.                 //         首先判断app代码的首地址是否为0x0800 000，是则进入app，否的话进行引导区。
    * F) I8 e) u- t
14.         if ( ( ( * ( vu32* ) ( FLASH_APP1_ADDR + 4 ) ) & 0xFF000000 ) == 0x08000000 ) //判断是否为0X08XXXXXX.
    
15.         {
    
16.             iap_load_app ( FLASH_APP1_ADDR ); //执行FLASH APP代码
    & W& y2 w# H% \
17.         }
    
18.                 //   判断app代码栈顶是否为0x2000 000,不是则进入升级模式，代码如下，其中 FLASH_APP1_ADDR=0x8005000;
    
19.         if ( ( ( ( * ( vu32* ) FLASH_APP1_ADDR ) & 0x2FFE0000 ) != 0x20000000 ) )
      C- `1 i" m# K5 X) P8 l
20.         {
    : {; H) R2 z' L/ d# [( q0 a
21.             printf ( "/***** No APP! *****/ \r\n" );
    ( U  Q. [9 H) ~$ s" D8 y
22.             printf ( "stm32f103c8t6在线升级  \r\n" );
    . L1 I& I1 G: R5 a
23.             printf ( "选择对应的app bin文件 \r\n" );
    % _, y( C, l3 h3 L. Z! I$ ]
24.             printf ( "输入 A 发送bin文件 \r\n" );
    ) ^1 D3 @7 R! g0 S5 {# Q" i. u
25.             printf ( "输入 E 进入app \r\n" );
    5 m- N( b* Y! Y$ F) a  i7 Y/ g1 E
26.             while ( 1 )
    
27.             {
    , B; d0 z  ]/ f) |& F* o0 ^) B
28.                 if ( USART_RX_CNT )
    
29.                 {
    7 X( ?* @$ ]: a' c, Z8 r! ^8 P
30.                     if ( oldcount == USART_RX_CNT ) //新周期内,没有收到任何数据,认为本次数据接收完成.
    6 M+ L  K5 y$ ^: x( P1 Y$ z% |
31.                     {
    / A; z! ]$ A5 S" q8 P" R
32.                         applenth = USART_RX_CNT;
    
33.                         oldcount = 0;
    
34.                         USART_RX_CNT = 0;
    ( Z% E/ p4 f* q8 u/ a/ @
35.                         if ( applenth > 100 )
    
36.                         {
    ! D4 b2 X3 ?7 R- o
37.                             printf ( "用户程序接收完成!\r\n" );
    # h$ w% P1 h9 J" c- ]. O9 t* d
38.                             printf ( "代码长度:%dBytes\r\n", applenth );
    
39.                         }
    ( G4 ]* I3 _  }6 C& F8 v/ ?
40.                     }
    8 a! [+ G3 A' N2 L0 I& W; t
41.                     else
    
42.                         oldcount = USART_RX_CNT;
    ( B+ \- o/ }- Y5 O' K4 F4 u
43.                 }
    
44.                 delay_ms ( 10 );
    & X# a% u- y  J  ~, o
45. 
    3 Z( F) P# T' T8 U9 `, a
46.                 if ( USART_RX_BUF[0] == 'A' )
    ; P( q# r4 C% _
47.                 {
    
48.                     if ( applenth )
    + i; P( A. r# W- ~8 {, `
49.                         printf ( "\r\n 请发送bin文件 \r\n" );
    
50.                     app_bin = 1;
    ' N- X: W0 [# D2 g. ~' u7 P1 f
51.                     applenth = 0;
    
52.                 }
    
53.                 else if ( app_bin )
    ! C7 w5 b: d/ ~, J3 i2 h7 C
54.                 {
    * ?1 g( I; q# |
55.                     if ( applenth )
    
56.                     {
    
57.                         printf ( "开始更新固件...\r\n" );
    
58.                         printf ( "Copying APP2FLASH..." );
    
59.                                                 //此处 0X20001000 地址为串口缓冲区开始接收数据地址
    
60.                         if ( ( ( * ( vu32* ) ( 0X20001000 + 4 ) ) & 0xFF000000 ) == 0x08000000 ) //判断是否为0X08XXXXXX. 串口是否接收到数据
    . k4 W$ ~: t7 c: K$ S% x
61.                         {                        
    
62.                             iap_write_appbin ( FLASH_APP1_ADDR, USART_RX_BUF, applenth ); //更新FLASH代码
    
63.                             printf ( "Copy APP Successed!!" );
    
64.                             printf ( "固件更新完成!\r\n" );
    
65.                             applenth = 0;
    
66.                             app_bin = 0;
    
67.                         }
    ! r  E* k7 o  E$ A! w
68.                     }
      T2 Y5 }' b  A1 Q- o' n) ^# Z  I, `0 P
69.                 }
    ( x. \, e  ~! \; x6 D% v5 Q
70.                 if ( USART_RX_BUF[0] == 'E' )
    - v( V: z! s' O- T/ m5 K. H; D
71.                 {
    
72.                     if ( applenth )
    - Z) t1 D* O$ e; l) G- z
73.                         printf ( "\r\n 将要执行APP \r\n" );
    
74.                     app_enter = 1;
    
75.                     applenth = 0;
    
76.                 }
    7 B5 @8 d  ^. k% b9 z" K
77.                 if ( app_enter )
    
78.                 {
    . A5 e/ y- X, J8 d1 @: A5 I! f
79.                     printf ( "开始执行FLASH用户代码!!\r\n" );
    6 `% c" |% A$ U7 h. [
80.                     if ( ( ( * ( vu32* ) ( FLASH_APP1_ADDR + 4 ) ) & 0xFF000000 ) == 0x08000000 ) //判断是否为0X08XXXXXX.
    7 O6 m/ \8 ?  ^( i
81.                     {                       
    
82.                         iap_load_app ( FLASH_APP1_ADDR ); //执行FLASH APP代码
    5 v1 u4 S# b/ `' {% n# s
83.                     }
    
84.                     else
    9 P. n/ j( s" Q6 k. x8 n
85.                         {
      y. P+ e6 c# V# I# T
86.                             printf ( "非FLASH应用程序,无法执行!\r\n" );
    
87.                             printf ( "Illegal FLASH APP!" );                           
    
88.                         }
    
89.                     }
    
90.             }
    
91.         }
    
92.     }
    
93. }

复制代码

bootloader代码开始运行后，通过串口的指令来选择要执行什么动作，如果发送的是字符"A"，那么就开始接收bin文件，然后将接收到的文件拷贝的FLASH中。如果发送的字符是"E"，那么就开始从FLASH中运行程序。
/ R. l+ `' Z( A% S
下来在看第三种方法，自动判断串口是否接收到bin文件，如果接收到了文件就将bin文件拷贝到FLASH中，然后开始自动执行FLASH的中APP程序。

1. int main ( void )
   
2. {
   # x+ a6 e2 ~* I
3.     u8 bit_new = 0;                                        //接收到程序标志
   
4.     u8 bit_10s = 0;
   
5.     u16 oldcount = 0;                                //老的串口接收数据值
   
6.     u16 applenth = 0;                                //接收到的app代码长度
   - m- j" ^8 Q& a7 k' _1 Q* i
7.     u8 t = 0, clearflag = 0;
   8 t) \4 d8 `2 @% d3 M
8. 
   + x! S8 {! e$ \; T
9.     SystemInit();
   8 V" {; a" B+ k" q
10.     NVIC_PriorityGroupConfig ( NVIC_PriorityGroup_2 ); //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
    # {. h- l& ^1 M3 M& g3 h
11.     uart_init ( 115200 );        //串口初始化为115200
    
12.     delay_init();                            //延时初始化
    
13.     while ( 1 )
    $ b$ ?; C- M1 |/ _0 Z( u5 F
14.     {
    
15.         if ( USART_RX_CNT )
    + r+ {! b2 p% S
16.         {
    $ z+ u6 U! k" ]- x; w
17.             if ( oldcount == USART_RX_CNT ) //新周期内,没有收到任何数据,认为本次数据接收完成.
    
18.             {
    ' X" z' z; i  S) r$ x: q
19.                 applenth = USART_RX_CNT;
    ) B$ |( `0 H. [: l! l6 r
20.                 oldcount = 0;
    % |, ~/ K. W1 K( H' Y* _- h  R
21.                 USART_RX_CNT = 0;
    
22.                 printf ( "用户程序接收完成!\r\n" );
    - Z3 @, q- a( Z1 D5 Y( w
23.                 printf ( "代码长度:%dBytes\r\n", applenth );
    
24.             }
    
25.             else oldcount = USART_RX_CNT;
    
26.         }
    / B  F- F9 K7 V- H2 i) Z  W
27.         if ( applenth != 0 )
    
28.         {
    & `" T7 [( T( O; O  e
29.             if ( ( ( * ( vu32* ) ( 0X20001000 + 4 ) ) & 0xFF000000 ) == 0x08000000 ) //判断是否为0X08XXXXXX.
    
30.             {
    # h; f: `. p+ {  \2 y8 |# D& G( |
31.                 iap_write_appbin ( FLASH_APP1_ADDR, USART_RX_BUF, applenth ); //更新FLASH代码
    
32.                 printf ( "固件更新完成!\r\n" );
    
33.                 bit_new = 1;
    
34.             }
    
35.             applenth = 0;
    : b5 [( @. e2 m* f& r: Y
36.         }
    & ]7 i+ t: U# }% Z$ {3 z/ B
37.         if ( ( bit_10s == 30 ) || ( bit_new == 1 ) )
    
38.         {
    8 _" i3 `) Z- s4 L/ I) w
39.             bit_10s = 0;
    6 A  B" s. f# f$ l' R; a9 p
40.             bit_new = 0;
    
41.             //执行FLASH中的代码
    ( o  h/ K9 \( E# ~& ?
42. 
    - {! U" d1 ^9 ]+ N
43. //            if ( ( ( * ( vu32* ) ( FLASH_APP1_ADDR + 4 ) ) & 0xFF000000 ) == 0x08000000 ) //判断是否为0X08XXXXXX.
    
44. //            {
    
45. //                printf ( "开始执行FLASH用户代码!!\r\n" );
    $ B5 l! T' T8 m" g& U
46. //                iap_load_app ( FLASH_APP1_ADDR ); //执行FLASH APP代码
    
47. //            }
      N0 ]- c' F: y7 S: e9 b( _
48.             //执行SRAM中的代码
    * ~& n7 U  V# G# v+ q: \
49.             if(((*(vu32 *)(0X20001000 + 4)) & 0xFF000000) == 0x20000000) //判断是否为0X20XXXXXX.
    : R7 J! Q  y4 b
50.             {
    
51.                 printf("开始执行SRAM用户代码!!\r\n");
    / r0 _- T( u. C+ _: k; v& c1 {& k
52.                 iap_load_app(0X20001000);//SRAM地址
    
53.             }
    # W5 @7 B  L6 |0 n4 P5 W
54.         }
    ; Q0 [$ U/ B* i6 a/ D- _* C
55.         t++;
    
56.         delay_ms ( 10 );
    ; H5 L% P  \" Q3 @7 a  Z7 r' s6 ~
57.         if ( t == 20 )
    
58.         {
    
59.             bit_10s++;           
    
60.         }
    " e9 `5 }( h% I4 A; i* K, j. v+ A
61.     }
    
62. }
    

复制代码

; u' a+ \. l  T% q& k程序开始运行时，串口一直等待接收bin文件，如果收到了数据，就将数据拷贝到FLASH中，然后开始执行。如果未收到数据，等待一段时间后，自动从FLASH中或者SRAM中开始运行。这块可以自己设置程序在从FLASH中运行还是在SRAM中开始运行。

IAP升级主要是要搞清楚bootloader和app的地址范围，只要将地址设置正确，IAP功能编写起来还是比较简单的。

& M: @* o# s4 g* M. b