0 D- @( F1 N1 z" o上次发过SD卡的Bootloader离线升级后，应大家的要求，这次就讲一下STM32的OTA远程升级。

  z  }$ {, d# Q6 x! POTA又叫空中下载技术，是通过移动通信的空中接口实现对移动终端设备数据进行远程管理的技术，还能提供移动化的新业务下载功能。
2 R# H% l, ]1 ?4 l  r' ~
要实现OTA功能，至少需要两块设备，分别是服务器与客户端。服务器只有一个，客户端可有多个。服务器通过串口与PC机连接，需要下载的镜像文件存放于PC机，命令执行器给服务器发命令及镜像文件。首先命令执行器控制服务器广播当前可用的镜像文件信息，客户端收到信息后进行对比，若有与自身相匹配的镜像，则向服务器请求数据。服务器收到请求后向命令执行器索取固定大小的块，再点对点传送给客户端。镜像传输完毕后，客户端进行校验，完成后发送终止信号。


一. 升级方式的对比
7 f! ]% {' G6 ]9 |; ]+ o! M

9 w4 a9 [  C' cOTA升级与平时用到的SD卡升级、串口升级等等大体原理上是一样的，都是对MCU的Flash进行操作而已。

  R/ @9 X: d( E$ m/ n! y
5 P" G' i8 ~  }* `& U收到升级指令——>MCU复位或者跳转到Boot程序区——>擦除对应的Flash区域——>获取APP数据——>写入FLASH数据——>校验——>跳转到APP应用程序区
* J+ ~# Y; B; i( r$ q

OTA与其他本地升级的区别就是：获取数据的方式不同。比如串口升级，就是通过上位机传输到MCU串口上的数据；SD卡升级，就是通过读取SD卡，把程序通过SPI传输到MCU上；而OTA升级，就是通过带无线传输的模块，把程序传输到MCU上。例如：蓝牙、Wifi、GSM等等。不过大部分的无线模块，通过串口把数据传输到MCU上的，只是服务端不再是PC端了，而是网络服务器。


二. 硬件选择
, f& [+ e+ X- |5 x) c: y( b
MCU我这里选用的是STM32F030F4P6的芯片，16K的Flash，应该是ST产品中Flash空间比较小的一种，为的就是体现一下小容量的单片机也可以进行OTA升级。

: A% d; q, a( b$ x+ D无线模块我使用的是ESP-8266，WIfi传输方式，应该也是比较大众化的一款模组。（TTL串口连接MCU）
2 z0 Q( B3 s7 _4 F2 S9 K
OTA相关的硬件没有了，剩下的无所谓，都是其他功能的，最好有个LED灯，可以明显的看出是否升级成功。
  k6 |% D/ q# K1 Q3 Q

三. 网络服务器的选择

网络服务器多种多样，常用的有阿里云、百度云、腾讯云、移动云等等，有条件的，还可以使用自己的服务器。总之需要实现：网络服务器可以与我们的无线模块进行大数据通信。
" o% H% x8 ~: C1 i% G# m) H
我这里选用的是OneNet移动云（OTA服务之前是免费，现在是前100个设备免费，之后每增加一个设备1元钱永久），我感觉OneNet相对于阿里云较为简单，没有阿里云那么繁琐，不过阿里云还是比OneNet更专业一点（个人见解），其他的没有用过，大家都可以去试试。


0 @' m+ E+ `' R( W四. 网络服务器的传输方式
, j* v7 l. T  E4 o8 I

我这里使用的是OneNet的服务器，它的OTA服务是通过Http协议进行传输的，有对应的API，我们可以通过OneNet释放的API去访问OTA服务。
5 D) Z  G, f2 j  |) y1 R8 c+ @
6 s& N# U7 d) x* ^: `9 V
/ f" k" x& R0 k6 q8 X4 c; N五. OTA升级流程

5 u7 w+ f1 y& F! hOneNet的OTA升级流程主要为6步：
5 A0 V. d. `; P( [
1. 上报版本号---客户端（MCU）上报当前的一个版本号
# O' M: V0 w& y2. 检测升级任务---检查服务器是否有待升级的版本
9 R9 A- f" |8 _$ N7 V3. 检测Token有效性---检查Token密钥，可省略
4 @) b& r) n- C7 c4. 下载固件---应用程序传输
5. 上报升级状态---上报服务端升级是否成功，不成功有对应的响应码

六. OneNet服务端配置
3 C' A  p# J* Q  J# |1 u
6 U$ A: s% i' Z, H3 a9 P  o
+ M+ y1 F' ]* [4 l; y, o+ j1.首先注册OneNet的账号，进入开发者中心，在导航栏选择全部产品->远程升级OTA板块。
  B6 \5 M+ f  O: `2 ?, o8 A5 q; N/ p

2.进入远程升级OTA界面，选择需要升级的模块；然后点击右上角的添加升级包按钮。FOTA升级：对设备中的模组进行升级。SOTA升级：对设备中的应用程序进行升级，我这里选用的是SOTA，因为我要对MCU的应用程序升级。
( p* S  [& Z1 i

3.在添加升级包对话框中，输入固件信息，上传固件包文件。产品选你要升级的设备，全部设备也可以；厂商名称选其他，主要是与之后发的对应上即可；模组型号同理；目标版本是你要更新到的版本号，比如你现在是V01，你这里添加的固件是V02的，这个版本号就要填V02；然后上传升级包，只支持Bin和压缩包格式的。

4.点击验证升级按钮，选择验证类型（完整包或者差分包），选择进行测试升级的设备，进行验证。一般跳过验证就行，我这里选的是整包，差分包原理一样。

5.单击升级设备列表，进入升级队列模块，在右上角单击添加升级设备按钮，新增设备升级任务。在添加待升级设备对话框中输入对应参数值。初始版本：就是升级前的版本，也是上次升级的版本；升级范围就是你需要给哪些设备升级；升级时机：就是立即升级或是定时在什么时段升级；重试策略：不重试就是如果升级失败就完事了，重试那就失败了还能重试；信号强度和剩余电量只是一个信息的接口，有需要的可以读取来用。

6.上述完成后，会出现“待升级”的设备，服务器这边就算配置完了，后续要我们M客户端进行操作了。
1 W. k( ]! e/ T( G9 d! \- z

七.客户端(MCU)API访问服务端进行OTA升级
8 `7 P/ W  a5 y6 \$ S; b9 n
无线模组用的是ESP8266，由于OneNet的OTA服务用的是HTTP协议，但是ESP8266没有HTTP协议，所以我使用TCP协议，封装成HTTP的报文格式。
+ h6 K: s/ m# d* a) l5 I
1.ESP8266初始化；连接Wifi，AP_SSID，AP_PASS是WiFi的账号和密码；SERVER_IP和SERVER_PORT是OneNet的Ip和端口号。
! w  F' Y( F6 x- \9 O9 z9 Q

1. 
   & c5 c9 V; ~; I
2. #define SERVER_IP "183.230.40.50"
   
3. #define SERVER_PORT 80
   
4. uint8_t pro = 0;
   
5. uint8_t ESP8266_Init(void)
     y1 |% P% H# C% G3 `, A+ o+ Y
6. {
   3 k0 A- {8 P) b" t0 H) d8 p
7.         switch(pro)
   
8.         {
   
9.                 case 0 :
   
10.                         //printf("+++");
    9 Y$ ^) f; j( F
11.                         Uart2_Send("+++");
    " p4 U" D6 T8 r$ ?* k8 v4 B
12.                         Delay_S(2);
    & \' O) u" A* g, z6 ~9 a
13.                         if(ESP8266_SoftReset(50) == 0)
    
14.                                 pro = 1;
    
15.                         break;
    8 s& J' J- U. n+ T3 _
16.                 case 1 :
    0 w) ]: y1 Q/ E2 I3 z8 l6 \/ t
17.                         if(ESP8266_AT_Send("ATE0\r\n",10) == 0)
    
18.                                 pro = 2;
    
19.                         break;
    ' |- z: J4 F/ M$ J; t0 Q
20.                 case 2 :
    , Z: a& [/ i/ W! B, m* r
21.                         if(ESP8266_AT_Send("AT+CWMODE=1\r\n",50) == 0)                //设置8266为STA模式
    
22.                                 pro = 3;
    . [  J( b% C' q8 ?
23.                         break;
    
24.                 case 3 :
    
25.                         if(ESP8266_ConnectionAP(AP_SSID,AP_PASS,200) == 0)                //8266连接AP
    
26.                                 pro = 4;
    1 E6 k3 ~  m  V/ `1 j# X
27.                         break;
    4 k& F: q6 f7 @$ F4 O  i. ^& ~
28.                 case 4 :
    
29.                         if(ESP8266_AT_Send("AT+CIPMODE=1\r\n",50) == 0)                //8266开启透传模式
    ) |. D' v+ x: g, b: L6 G7 h
30.                                 pro = 5;
    . h( e" G; ?/ E0 \4 Q2 a: K
31.                         break;
    
32.                 case 5 :
    
33.                         if(ESP8266_Connect_Server(SERVER_IP,SERVER_PORT,50) == 0)        //8266连接TCP服务器
    
34.                         {
    , }; u- s1 V  f' _( c* B/ W
35.                                 pro = 0;
    ( J8 E+ D- m4 H5 n: s, s
36.                                 //USART1_Clear();                        //清除串口数据
    
37.                                 return 1;
    
38.                         }                                
    
39.                         break;
    $ O/ B2 n% r- L4 y! d8 t
40.         }
    - F. j. `  e- m4 E) U! A! y
41.         return 0;
    
42. }
    

复制代码

2.上报版本号；dev_id是设备ID，authorization是鉴权参数，ver要上报的版本号，timeout发送超时时间。

1. 
   8 A% x- n, }: _) V3 }# V, `
2. //上报版本号
   
3. uint8_t Report_Version(char *dev_id,char *authorization,char *ver,uint16_t timeout)
   
4. {
   / @; b3 ^1 V$ E; u* R& y
5.         uint16_t time=0;
   4 ]+ V* d! C3 R
6.         char send_buf[296];
   
7.         USART1_Clear();                        //清除串口数据        
   . _6 V- [$ y2 u
8.         snprintf(send_buf, sizeof(send_buf), "POST /ota/device/version?dev_id=%s HTTP/1.1\r\n"
   
9.         "Authorization:%s\r\n"
   " M* ?7 i$ I. D& L/ K' W
10.         "Host:ota.heclouds.com\r\n"
    
11.         "Content-Type:application/json\r\n"
    5 f- V8 i1 C( M# I
12.         "Content-Length:%d\r\n\r\n"
    8 W3 b' M) }4 s3 g9 Y
13.         "{"s_version":"%s"}",
    
14.         dev_id, authorization, strlen(ver) + 16, ver);      
    
15.         Uart2_Send(send_buf);        
    - k" R' b- F) n5 m; w
16.         while(time<timeout)
    
17.         {
    
18.                 if(strstr( (const char *)usart_info.buf , (const char *)""errno":0"))
    - x: U+ V' C" M
19.                         break;
    
20.                 Delay_Ms(100);
    
21.                 time++;      
    
22.         }
    4 p  b5 L( B+ f( f1 t6 B
23.         if(time>=timeout)
    ( `" v$ U# \% ?. k: }+ s" v- L& c
24.                 return 1;               
    8 _  f0 m* m2 k; `. b2 _1 W
25.         else
    
26.                 return 0;            
    
27. }

复制代码

3.检查升级任务；dev_id是设备ID，authorization是鉴权参数，cur_version是当前的版本号，timeout发送超时时间
& b2 I0 b+ D8 p' I
9 \  P, J0 G0 @  [( o$ l

1. 
   
2. //检查升级任务
   
3. uint8_t Detect_Task(char *dev_id,char *cur_version,char *authorization,uint16_t timeout)
   ( \( S3 c7 V- `, E
4. {
   
5.         uint16_t time=0;
   
6.         char send_buf[280];
   9 K8 o; ^: k3 t8 W0 t  @
7.         USART1_Clear();                        //清除串口数据        
   
8.         snprintf(send_buf, sizeof(send_buf), "GET /ota/south/check?"
   
9.         "dev_id=%s&manuf=100&model=10001&type=2&version=%s&cdn=false HTTP/1.1\r\n"
   
10.         "Authorization:%s\r\n"
    
11.         "Host:ota.heclouds.com\r\n\r\n",
    0 D$ W$ X: W) w% f/ m& n
12.         dev_id, cur_version,authorization);     
    
13.         Uart2_Send(send_buf);
    
14.         while(time<timeout)
    
15.         {
    
16.                 if(strstr( (const char *)usart_info.buf , (const char *)""errno":0"))
    + s8 c" J5 |9 c( N" z# A$ l
17.                         break;
    ) R! s% H  p9 ?" y9 U+ k4 Z$ K/ }' r; ^
18.                 Delay_Ms(100);
    8 S6 A3 |0 N3 e, Y0 Q
19.                 time++;      
    / J  U7 V4 p8 a2 L# Y$ v; q
20.         }
    0 W  ?9 ]' w5 R
21.         if(time>=timeout)
    
22.                 return 1;               
    
23.         else
    % Z/ h, v$ O) g& Y
24.                 return 0;            
    ; K' H9 x; g3 t4 J' D4 H% ]
25. }
    
26. 
    3 G, s% y* P/ `. S  }2 X- P4 ~

复制代码

3.下载资源(我省略了"检查token有效"步骤)；ctoken是上一步“检查升级任务”返回的Token，这个每次请求都不一样，所以注意要记录；size：平台返回的固件大小(字节)；bytes_range：分片大小(字节)

1. /*
   5 K! Y8 r: U8 M& L' y5 {9 ]! q
2. ************************************************************
   ) d! E, P' i4 L
3. *        函数名称：        OTA_Download_Range
   
4. *
   
5. *        函数功能：        分片下载固件
   6 t) W, i8 q8 D6 I, p! r
6. *
   
7. *        入口参数：        token：平台返回的Token
   " I9 |) f& |1 O# j
8. *                                                size：平台返回的固件大小(字节)
   
9. *                                                bytes_range：分片大小(字节)
   / ?0 D7 f4 W9 X" F6 s; P% ~
10. *
    
11. *        返回参数：        0-成功        其他-失败
    2 Q, a" }, c7 d
12. *
    * @5 d1 |! t. |5 d
13. *        说明：               
    
14. ************************************************************
    " G. a, s# q1 b7 [4 e' t2 |1 ?/ {
15. */
    0 L4 M0 Z$ r  G- A: M
16. uint8_t Download_Task(char *ctoken,unsigned int size, const unsigned short bytes_range,uint16_t timeout)
    , b7 k7 b% n$ W5 ?
17. {
    7 u# q6 S& H, h8 m  \
18.         MD5_CTX md5_ctx;                                                                                        //MD5相关变量
    
19.         unsigned char md5_t[16];
    
20.         char md5_t1[16];
    ; M8 k! ?% i- I7 o
21.         char md5_result[40];
    
22.         uint16_t time=0;
    2 Z1 U+ g: C+ w4 |. p
23.         char *data_ptr = NULL;
    
24.         char send_buf[256];
    
25.         unsigned char flash_buf[OTA_BUFFER_SIZE];                        //flash读写缓存
    * M5 I, O- s# O/ ^6 s5 E  Z  ^$ e% r
26.         unsigned int bytes = 0;
    . u+ m. M; X, Y$ E" M
27.         MD5_Init(&md5_ctx);
    
28.         Flash_cashu();
    " d( ?. K2 B, ?$ \4 Z3 b( z
29.         while(bytes < size)
    
30.         {
    
31.                 time = 0;
    2 F" o4 Z" L; X  i
32.                 memset(send_buf, 0, sizeof(send_buf));
    ( Z* L7 c( g- g. H0 |8 B
33.                 USART1_Clear();                        //清除串口数据         
    
34.                 snprintf(send_buf, sizeof(send_buf), "GET /ota/south/download/"
    0 Y' Z- N6 ]1 P7 P8 r6 k9 w- L4 k
35.                 "%s HTTP/1.1\r\n"
    
36.                 "Range:bytes=%d-%d\r\n"
    " r1 I& {4 W/ |) w3 O" P( E/ G8 n1 T# M
37.                 "Host:ota.heclouds.com\r\n\r\n",
    
38.                 ctoken, bytes, bytes + bytes_range - 1);      
    
39.                 Uart2_Send(send_buf);
    
40.                 //----------------------------------------------------等待数据---------------------------------------------------------------------
    . S/ z) i. z( l# {* D8 r% X
41.                 while(time < 30)
    
42.                 {
    + [* X  D' {" W+ p1 g0 e+ ^
43.                         if(usart_info.buf[0] != 0)
    
44.                                 break;
    : e1 E. X% |( ]' @& \$ B9 U
45.                         Delay_Ms(100);
    0 Q% T4 D; `. ]4 h8 K
46.                         time++;
    
47.                 }
    $ E" j/ }( W; m  y" F6 T; n
48.                
    , J4 L0 l) R. i- n' t( b
49.                 if(time <= 29)
    # f4 G# ?0 a& W" a  S* w% Y
50.                 {
    8 }5 J2 w% l" t+ T+ _! q
51.                         Delay_Ms(500);
    ) Y! Y; ?! X8 Z6 ~9 I
52.                         //----------------------------------------------------跳过HTTP报文头、找到固件数据--------------------------------------------------
    5 n9 f, ]7 x  e& O3 {9 ~
53.                         data_ptr = strstr( (const char *)usart_info.buf, "Range");
    
54.                         data_ptr = strstr(data_ptr, "\r\n");
    9 W6 w; n0 z8 `; b! T# H$ `7 ]
55.                         data_ptr += 4;
    , U) ]  \8 m  J. d2 p1 h
56.                         
    1 J' n: y5 j2 N- S( Z
57.                         //----------------------------------------------------将固件数据写入缓存和闪存-----------------------------------------------------
      n: J' G: q: N7 [" {
58.                         if(data_ptr != NULL)
    " X  n4 A! `+ [
59.                         {
    
60.                                 if((size - bytes) >= OTA_BUFFER_SIZE)
    : u, L  n" ]6 B. A
61.                                 {
    7 E4 |- l$ R2 |
62.                                         memcpy(flash_buf + (bytes % OTA_BUFFER_SIZE), data_ptr, bytes_range);
    7 D& q, e$ N$ Y, G# r( s/ ?
63.                                         STMFLASH_Write_NoCheck(FLASH_APP1_ADDR + bytes,(uint16_t *)flash_buf,OTA_BUFFER_SIZE / 2);
    
64.                                         bytes = bytes + OTA_BUFFER_SIZE;
    
65.                                        
    
66.                                         MD5_Update(&md5_ctx, (unsigned char *)data_ptr, bytes_range);
    9 U1 y  k+ y! m# k5 x9 S2 Q
67.                                 }
    # v2 [2 q. s; V1 {" d& s
68.                                 else
    
69.                                 {
    
70.                                         memcpy(flash_buf + (bytes % OTA_BUFFER_SIZE), data_ptr, size - bytes);
    
71.                                         STMFLASH_Write_NoCheck(FLASH_APP1_ADDR + bytes , (uint16_t *)flash_buf , (size % OTA_BUFFER_SIZE) / 2);
    ' M4 n- j4 @3 y: V1 t
72.                                                         
    
73.                                         MD5_Update(&md5_ctx, (unsigned char *)data_ptr, size - bytes);
    
74.                                        
    
75.                                         bytes = size;
    ' N  v) i$ T4 o+ i! q4 A
76.                                 }
    
77.                         }
    3 N! s+ q4 K. I
78.                 }
    
79.         }
    9 _' e6 o' i! p: a/ `- D5 N
80.         //----------------------------------------------------MD校验比对------------------------------------------------------------------
    
81.         memset(md5_result, 0, sizeof(md5_result));
    
82.         MD5_Final(&md5_ctx, md5_t);
    
83.         for(int i = 0; i < 16; i++)
    
84.         {
    
85.                 if(md5_t[i] <= 0x0f)
    , C9 I1 v* [. N/ M' |6 t/ ~
86.                         sprintf(md5_t1, "0%x", md5_t[i]);
    & z6 o1 v3 L- e% S) P
87.                 else
    # L7 g( e8 D. g8 |- t' `
88.                         sprintf(md5_t1, "%x", md5_t[i]);
    3 U1 k+ S  ~! i3 [' |6 u0 ^
89.                
    0 S2 X0 t, R8 m! D) d
90.                 strcat(md5_result, md5_t1);
    9 g6 ]/ H8 s9 y$ k
91.         }
    ; y" o' u' S/ R$ n1 [
92.         if(strcmp(md5_result, ota_info.md5) == 0)        
    - o; ?7 L9 d7 Y7 M* E2 S, y# q
93.         
    5 S5 \1 X4 J* W( N. }4 Y
94.                 return 0;
    ' s  }8 d4 a8 J
95.         else
    " D" e* i8 o: o0 w
96.                 return 1;
    
97. }

复制代码

4.上报升级状态；这一步由于时间问题，我也省略了，总之程序已经下载到MCU上了，只是没有通知服务器而已，大家最好还是加上这一步。
3 G" Y' T7 o5 e5 v% y' B1 r4 g

5.main函数循环；

1. char rrr;
   3 v3 s6 ~9 |2 U" v
2.         
   8 U/ t& a+ c" E; y3 x& o9 b7 R
3.         char dev_id[] = {"640600857"};
   
4.         
   
5.   char Authorization[] = {"version=2018-10-31&res=products%2F378414&et=1735660800&method=sha1&sign=9EgY%2Bk4r%2BlvCooIGf1ghtQFC0%2Bc%3D"};
   8 x2 n. v3 `3 x4 k# _' ^& V
6. 
   
7.   char Version[] = {"V10"};

复制代码

1. 
   
2. while(1)
   5 e/ _" b( F$ _$ E. }
3.         {
   
4.                 switch(pro)
   
5.                 {
   6 \. a* B1 s: U% p3 N
6.                         case 1 :        //上报版本
   
7.                                 if(Report_Version(dev_id,Authorization,Version,10) == 0)
   
8.                                         pro++;
   
9.                                 break;
   
10.                         case 2 :        //检查任务
    
11.                                 if(Detect_Task(dev_id,Version,Authorization,50) == 0)
    
12.                                         pro++;
    
13.                                 break;
    ( D  l7 b! i4 W: y
14.                         case 3 :        //接收token、size、md5信息
    
15.                                 rrr = json_get_value((char *)usart_info.buf,"token",ota_info.token);
    
16.                                 rrr = json_get_value((char *)usart_info.buf,"size",ota_info.csize);                        
    + |& w" ?0 {$ E/ G9 {( A
17.                                 rrr = json_get_value((char *)usart_info.buf,"md5",ota_info.md5);
    
18.                                 ota_info.size = atoi(ota_info.csize);
    . u* {% @0 c4 |
19.                                         pro++;
    0 P# \+ A2 p2 X! ~) v: E
20.                         break;
    
21.                         case 4 :        //进行下载
    
22.                                 res = Download_Task(ota_info.token,ota_info.size,OTA_BUFFER_SIZE,10);
    
23.                                 if(res == 0)        //校验成功
    
24.                                 {
    ) P9 R& n5 p% S' v+ n; m
25.                                         pro++;
    
26.                                 }
    9 J' M2 D- A6 _- a  f, {( w! [
27.                                 else if(res == 1)                //校验失败
    4 z2 O3 c, e% U, g+ t8 {
28.                                 {
    
29.                                         pro = 1;
    
30.                                 }                        
    
31.                         break;
    + c% B" `9 W2 t/ e" M4 K
32.                         case 5 :        //Flash写入升级完成的标志位
    8 W* r/ @, ^1 N/ K: Q
33.                                 USART1_Clear();
    
34.                                 STMFLASH_Unlock();
    & Z: w" ]) u0 t! c% J1 C
35.                                 STMFLASH_WriteHalfWord(FLASH_APP1_ADDR - 0x64, 0xFF02);//写入数据
    
36.                                 STMFLASH_Lock();
    $ H7 A8 i0 H( M- l: O; _. ]
37.                                 pro++;
    
38.                         break;
    
39.                         case 6 :        //复位或者跳转到APP
      k5 K% a0 ?9 ?
40.                                 Sys_Soft_Reset();
    
41.                                 //iap_load_app(FLASH_APP1_ADDR);
    + X& N8 W8 A" h7 U" W+ J
42.                         break;
    - a% D4 f' W" y6 C& ^% ^
43.                 }
    / T* `8 I% H; q$ K: {6 N
44.         }

复制代码

下图是我升级的历史
$ y, h2 A% H! W8 a. n$ G  h

八.注意事项
5 n. f% Y8 x6 S7 j
1.鉴权参数是需要自己去算的

  D& P  i0 H$ V2 i/ ]0 o2.由于用的是STM32F030F4P6，RAM也非常小，所以局部变量和全局变量的数组不要超过4K，堆栈大小有改动。当前用内存管理的话就不用了。

3.OTA校验用的是MD5，需要把MD5的算法移植一下。
4.别的想不到了，太长时间了。
% e" o$ U% L7 H' f/ h& ?# U8 U

; f% g: \0 Q( T总结：
' Z* I# z/ T7 Q2 }OTA的方法只是我个人的理解，可能有的地方不正确，欢迎大家指点。BootLoader代码也是很早之前写过的一个Demo，最简化的，传输协议、加密、升级失败的操作、回滚等等都没有涉及，只是一个OTA演示的例子，代码水平有点差，大家将就的看，参考一下就可以了哈，感谢！

( m/ V4 W& Z3 Q8 C

: m' p& Z5 `. C1 r0 T

图文搭配，内容及其丰富，学习一哈

学习学习

SD卡的bootloader那个文章在哪里呢？我没有找到诶