devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

ESP8266/ESP32 SDK3 OTA升级

作者：从前慢现在也慢 | 2024-05-21 03:44:05

赞

踩

ESP8266/ESP32 SDK3 OTA升级

1、本示例适合于ESP8266和ESP32的OTA升级，使用官方的RTOS SDK3的框架编程，用户只要给出URL，代码自动解析出域名、IP、端口、文件路径等信息，然后通过HTTP请求下载固件。

2、本人测试固件放到阿里云对象存储OSS中，可以参考以下链接说明。或者自己搭建局域网服务器。

阿里云对象存储上传文件_dear_Wally的博客-CSDN博客

3、user_fota.c

  1.  
  2. #include "user_fota.h"
  3.  
  4. //===================================================================
  5. //							变量定义
  6. //===================================================================
  7. static const char *TAG = "user_fota";
  8. static bool ota_fail_flag;
  9. static bool ota_runing_flag = false;
  10.  
  11.  
  12.  
  13. /********************************************************************
  14.  *@brief	    复制src到新内存
  15.  *@param[in]    src  
  16.  *@return       返回字符串指针,指针不为NULL时，用完之后需要释放内存
  17.  *******************************************************************/
  18. char *user_copy_new_memory(const char *src)
  19. {
  20.     char *dec = NULL;
  21.  
  22.     int len = strlen(src);
  23.     dec = (char *)malloc(len+1); 
  24.  
  25.     if(dec == NULL)
  26.     {
  27.         ESP_LOGE(TAG, "user_copy_new_memory malloc fail");
  28.         return NULL;  
  29.     }
  30.  
  31.     int i;
  32.     for(i=0;i<len;i++)
  33.     {
  34.         dec[i] = src[i];
  35.     }
  36.  
  37.     dec[i] = '\0';  
  38.  
  39.     return dec;
  40. }
  41.  
  42.  
  43. /********************************************************************
  44.  *@brief	    获取url的字符串
  45.  *@param[in]    url  完整的url
  46.  *@param[in]    puri 调用http_parser_parse_url解析之后的值
  47.  *@param[in]    uf   需要获取url字符串的类型
  48.  *@return       返回字符串指针,指针不为NULL时，用完之后需要释放内存
  49.  *******************************************************************/
  50. char *user_url_parser_get_str(const char *url,const struct http_parser_url *puri,uint8_t uf)
  51. {
  52.     char *data = NULL;
  53.     int len = puri->field_data[uf].len;         //获取字符长度
  54.     int off = puri->field_data[uf].off;         //获取字符偏移
  55.  
  56.     if(len && (puri->field_set&(0x01<<uf)))     //字符有效并且长度不为0
  57.     {
  58.         data = (char *)malloc(len+1);           //申请内存，最后一个字节需要填入'\0'，所有加1
  59.  
  60.         if(data != NULL)
  61.         {
  62.             int i;
  63.             for(i=0;i<len;i++)
  64.             {
  65.                 data[i] = url[off+i];           //复制字符串到返回内存空间
  66.             }
  67.             data[i] = '\0';                     //最后一个字节需要填入'\0'
  68.         }
  69.     }
  70.     return data;
  71. }
  72.  
  73.  
  74. /********************************************************************
  75.  *@brief	    获取OTA是否正在运行
  76.  *@param[in]     
  77.  *@return       true：正在OTA
  78.  *******************************************************************/
  79. bool fota_is_runing()
  80. {
  81.     return ota_runing_flag;
  82. }
  83.  
  84. /*read buffer by byte still delim ,return read bytes counts*/
  85. static int read_until(const char *buffer, char delim, int len)
  86. {
  87.     int i = 0;
  88.     while (buffer[i] != delim && i < len) {
  89.         ++i;
  90.     }
  91.     return i + 1;
  92. }
  93.  
  94. bool _esp_ota_firm_parse_http(esp_ota_firm_t *ota_firm, const char *text, size_t total_len, size_t *parse_len)
  95. {
  96.     /* i means current position */
  97.     int i = 0, i_read_len = 0;
  98.     char *ptr = NULL, *ptr2 = NULL;
  99.     char length_str[32];
  100.  
  101.     while (text[i] != 0 && i < total_len) {
  102.         if (ota_firm->content_len == 0 && (ptr = (char *)strstr(text, "Content-Length")) != NULL) {
  103.             ptr += 16;
  104.             ptr2 = (char *)strstr(ptr, "\r\n");
  105.             memset(length_str, 0, sizeof(length_str));
  106.             memcpy(length_str, ptr, ptr2 - ptr);
  107.             ota_firm->content_len = atoi(length_str);
  108.             ota_firm->ota_size = ota_firm->content_len;
  109.             ota_firm->ota_offset = 0;
  110.             ESP_LOGI(TAG, "parse Content-Length:%d, ota_size %d", ota_firm->content_len, ota_firm->ota_size);
  111.         }
  112.  
  113.         i_read_len = read_until(&text[i], '\n', total_len - i);
  114.  
  115.         if (i_read_len > total_len - i) {
  116.             ESP_LOGE(TAG, "recv malformed http header");
  117.             ota_fail_flag = true;
  118.             return false;
  119.         }
  120.  
  121.         // if resolve \r\n line, http header is finished
  122.         if (i_read_len == 2) {
  123.             if (ota_firm->content_len == 0) {
  124.                 ESP_LOGE(TAG, "did not parse Content-Length item");
  125.                 ota_fail_flag = true;
  126.                 return false;
  127.             }
  128.  
  129.             *parse_len = i + 2;
  130.  
  131.             return true;
  132.         }
  133.  
  134.         i += i_read_len;
  135.     }
  136.  
  137.     return false;
  138. }
  139.  
  140. static size_t esp_ota_firm_do_parse_msg(esp_ota_firm_t *ota_firm, const char *in_buf, size_t in_len)
  141. {
  142.     size_t tmp;
  143.     size_t parsed_bytes = in_len; 
  144.  
  145.     switch (ota_firm->state) {
  146.         case ESP_OTA_INIT:
  147.             if (_esp_ota_firm_parse_http(ota_firm, in_buf, in_len, &tmp)) {
  148.                 ota_firm->state = ESP_OTA_PREPARE;
  149.                 ESP_LOGD(TAG, "Http parse %d bytes", tmp);
  150.                 parsed_bytes = tmp;
  151.             }
  152.             break;
  153.         case ESP_OTA_PREPARE:
  154.             ota_firm->read_bytes += in_len;
  155.  
  156.             if (ota_firm->read_bytes >= ota_firm->ota_offset) {
  157.                 ota_firm->buf = &in_buf[in_len - (ota_firm->read_bytes - ota_firm->ota_offset)];
  158.                 ota_firm->bytes = ota_firm->read_bytes - ota_firm->ota_offset;
  159.                 ota_firm->write_bytes += ota_firm->read_bytes - ota_firm->ota_offset;
  160.                 ota_firm->state = ESP_OTA_START;
  161.                 ESP_LOGD(TAG, "Receive %d bytes and start to update", ota_firm->read_bytes);
  162.                 ESP_LOGD(TAG, "Write %d total %d", ota_firm->bytes, ota_firm->write_bytes);
  163.             }
  164.  
  165.             break;
  166.         case ESP_OTA_START:
  167.             if (ota_firm->write_bytes + in_len > ota_firm->ota_size) {
  168.                 ota_firm->bytes = ota_firm->ota_size - ota_firm->write_bytes;
  169.                 ota_firm->state = ESP_OTA_RECVED;
  170.             } else
  171.                 ota_firm->bytes = in_len;
  172.  
  173.             ota_firm->buf = in_buf;
  174.  
  175.             ota_firm->write_bytes += ota_firm->bytes;
  176.  
  177.             ESP_LOGD(TAG, "Write %d total %d", ota_firm->bytes, ota_firm->write_bytes);
  178.  
  179.             break;
  180.         case ESP_OTA_RECVED:
  181.             parsed_bytes = 0;
  182.             ota_firm->state = ESP_OTA_FINISH;
  183.             break;
  184.         default:
  185.             parsed_bytes = 0;
  186.             ESP_LOGD(TAG, "State is %d", ota_firm->state);
  187.             break;
  188.     }
  189.  
  190.     return parsed_bytes;
  191. }
  192.  
  193. static void esp_ota_firm_parse_msg(esp_ota_firm_t *ota_firm, const char *in_buf, size_t in_len)
  194. {
  195.     size_t parse_bytes = 0;
  196.  
  197.     ESP_LOGD(TAG, "Input %d bytes", in_len);
  198.  
  199.     do {
  200.         size_t bytes = esp_ota_firm_do_parse_msg(ota_firm, in_buf + parse_bytes, in_len - parse_bytes);
  201.         ESP_LOGD(TAG, "Parse %d bytes", bytes);
  202.         
  203.         if(ota_fail_flag)
  204.         {
  205.             return;
  206.         }
  207.         
  208.         if (bytes)
  209.             parse_bytes += bytes;
  210.     } while (parse_bytes != in_len);
  211. }
  212.  
  213. static inline int esp_ota_firm_is_finished(esp_ota_firm_t *ota_firm)
  214. {
  215.     return (ota_firm->state == ESP_OTA_FINISH || ota_firm->state == ESP_OTA_RECVED);
  216. }
  217.  
  218. static inline int esp_ota_firm_can_write(esp_ota_firm_t *ota_firm)
  219. {
  220.     return (ota_firm->state == ESP_OTA_START || ota_firm->state == ESP_OTA_RECVED);
  221. }
  222.  
  223. static inline const char* esp_ota_firm_get_write_buf(esp_ota_firm_t *ota_firm)
  224. {
  225.     return ota_firm->buf;
  226. }
  227.  
  228. static inline size_t esp_ota_firm_get_write_bytes(esp_ota_firm_t *ota_firm)
  229. {
  230.     return ota_firm->bytes;
  231. }
  232.  
  233. static void esp_ota_firm_init(esp_ota_firm_t *ota_firm, const esp_partition_t *update_partition)
  234. {
  235.     memset(ota_firm, 0, sizeof(esp_ota_firm_t));
  236.     ota_firm->state = ESP_OTA_INIT;
  237.     ota_firm->ota_num = get_ota_partition_count();
  238.     ota_firm->update_ota_num = update_partition->subtype - ESP_PARTITION_SUBTYPE_APP_OTA_0;
  239.  
  240.     ESP_LOGI(TAG, "Totoal OTA number %d update to %d part", ota_firm->ota_num, ota_firm->update_ota_num);
  241.  
  242. }
  243.  
  244.  
  245.  
  246. /********************************************************************
  247.  *@brief	释放HTTP信息内存
  248.  *@param[in]
  249.  *@return   <0失败 
  250.  *******************************************************************/
  251. void user_free_http_info(user_http_info_t *user_http_info)
  252. {
  253.     if(user_http_info->url_buff != NULL)
  254.     {
  255.         free(user_http_info->url_buff);
  256.         user_http_info->url_buff = NULL;
  257.     }
  258.  
  259.     if(user_http_info->url_type_buff != NULL)
  260.     {
  261.         free(user_http_info->url_type_buff);
  262.         user_http_info->url_type_buff = NULL;
  263.     }
  264.  
  265.     if(user_http_info->url_host_buff != NULL)
  266.     {
  267.         free(user_http_info->url_host_buff);
  268.         user_http_info->url_host_buff = NULL;
  269.     }
  270.  
  271.     if(user_http_info->url_port_buff != NULL)
  272.     {
  273.         free(user_http_info->url_port_buff);
  274.         user_http_info->url_port_buff = NULL;
  275.     }
  276.  
  277.     if(user_http_info->url_path_buff != NULL)
  278.     {
  279.         free(user_http_info->url_path_buff);
  280.         user_http_info->url_path_buff = NULL;
  281.     }
  282. }
  283.  
  284.  
  285.  
  286. /********************************************************************
  287.  *@brief	连接到HTTP服务器
  288.  *@param[in]
  289.  *@return   <0失败 
  290.  *******************************************************************/
  291. int user_connect_http_server(const char *url,user_http_info_t *user_http_info)
  292. {
  293.     user_http_info->url_buff      = NULL;
  294.     user_http_info->url_type_buff = NULL;
  295.     user_http_info->url_host_buff = NULL;
  296.     user_http_info->url_port_buff = NULL;
  297.     user_http_info->url_path_buff = NULL;
  298.     user_http_info->http_socket   = -1;
  299.  
  300.     //复制URL到新内存空间
  301.     user_http_info->url_buff = user_copy_new_memory(url); 
  302.     if(user_http_info->url_buff == NULL)
  303.     {
  304.         ESP_LOGE(TAG, "http url malloc fail");
  305.         return -1;  
  306.     }
  307.  
  308.     ESP_LOGD(TAG, "http url parser = %s", user_http_info->url_buff);
  309.  
  310.     struct http_parser_url puri;
  311.     http_parser_url_init(&puri);
  312.  
  313.     int ret = http_parser_parse_url(user_http_info->url_buff, strlen(user_http_info->url_buff), 0, &puri);
  314.     if (ret != 0) {
  315.         ESP_LOGE(TAG, "http url parser fail: %d",ret);
  316.         return -1;  
  317.     }
  318.  
  319.     //获取协议类型
  320.     user_http_info->url_type_buff = user_url_parser_get_str(user_http_info->url_buff,&puri,UF_SCHEMA);
  321.  
  322.     //获取主机域名
  323.     user_http_info->url_host_buff = user_url_parser_get_str(user_http_info->url_buff,&puri,UF_HOST);
  324.     if(user_http_info->url_host_buff == NULL)
  325.     {
  326.         ESP_LOGE(TAG, "http url host parser fail");
  327.         return -1;  
  328.     }       
  329.  
  330.     //获取主机端口
  331.     user_http_info->url_port_buff = user_url_parser_get_str(user_http_info->url_buff,&puri,UF_PORT);
  332.     if(user_http_info->url_port_buff == NULL)
  333.     {
  334.         //端口没有给出时默认为80
  335.         user_http_info->url_port_buff = user_copy_new_memory("80");
  336.         if(user_http_info->url_port_buff == NULL)
  337.         {
  338.             ESP_LOGE(TAG, "http port_buff user_copy_new_memory fail");
  339.             return -1;  
  340.         }
  341.     } 
  342.  
  343.     //获取文件路径
  344.     user_http_info->url_path_buff = user_url_parser_get_str(user_http_info->url_buff,&puri,UF_PATH);
  345.     if(user_http_info->url_path_buff == NULL)
  346.     {
  347.         ESP_LOGE(TAG, "http url path parser fail");
  348.         return -1;  
  349.     } 
  350.  
  351.     const struct addrinfo hints = {
  352.         .ai_family   = AF_INET,
  353.         .ai_socktype = SOCK_STREAM,
  354.     };
  355.  
  356.     struct  addrinfo *http_addrinfo = NULL;
  357.     struct  in_addr  *ip_addr;
  358.  
  359.     //域名转换为IP
  360.     ret = getaddrinfo(user_http_info->url_host_buff, user_http_info->url_port_buff, &hints, &http_addrinfo);
  361.     if(ret != 0 || http_addrinfo == NULL) {
  362.         ESP_LOGE(TAG, "http DNS failed ret=%d http_addrinfo=%p", ret, http_addrinfo);
  363.         return -1;  
  364.     }
  365.  
  366.     //获取IP地址
  367.     ip_addr = &((struct sockaddr_in *)http_addrinfo->ai_addr)->sin_addr;
  368.     ESP_LOGI(TAG, "http DNS succeeded. IP=%s", inet_ntoa(*ip_addr));
  369.  
  370.     //创建TCP socket
  371.     user_http_info->http_socket = socket(http_addrinfo->ai_family, http_addrinfo->ai_socktype, 0);
  372.     if(user_http_info->http_socket < 0) {
  373.         ESP_LOGE(TAG, "http allocate socket failed.");
  374.         return -1;  
  375.     }
  376.     ESP_LOGI(TAG, "http socket success");
  377.  
  378.     //通过TCP连接到服务器
  379.     ret = connect(user_http_info->http_socket, http_addrinfo->ai_addr, http_addrinfo->ai_addrlen);
  380.  
  381.     freeaddrinfo(http_addrinfo);
  382.  
  383.     if(ret != 0)
  384.     {
  385.         close(user_http_info->http_socket);
  386.         return -1;  
  387.     }
  388.  
  389.     ESP_LOGI(TAG, "http connect success");
  390.  
  391.     return 0;
  392. }
  393.  
  394.  
  395. /********************************************************************
  396.  *@brief	FOTA任务函数
  397.  *@param[in]
  398.  *@return
  399.  *******************************************************************/
  400. static void user_fota_task(void *pvParameters)
  401. {
  402.  
  403.     ESP_LOGD(TAG, "starting fota. flash: %s", CONFIG_ESPTOOLPY_FLASHSIZE);
  404.     ota_runing_flag = true;
  405.     ota_fail_flag   = false;
  406.  
  407.     esp_err_t err;
  408.     esp_ota_handle_t       update_handle    = 0;
  409.     const esp_partition_t *update_partition = NULL;
  410.  
  411.     const esp_partition_t *configured = esp_ota_get_boot_partition();
  412.     const esp_partition_t *running    = esp_ota_get_running_partition();
  413.  
  414.     if (configured != running) {
  415.         ESP_LOGW(TAG, "Configured OTA boot partition at offset 0x%08x, but running from offset 0x%08x",
  416.                  configured->address, running->address);
  417.         ESP_LOGW(TAG, "(This can happen if either the OTA boot data or preferred boot image become corrupted somehow.)");
  418.     }
  419.     ESP_LOGI(TAG, "Running partition type %d subtype %d (offset 0x%08x)",
  420.              running->type, running->subtype, running->address);
  421.  
  422.  
  423.     user_http_info_t user_http_info;
  424.     int ret;
  425.     
  426.     //OTA0固件地址为0x10000，OTA1固件地址为0x110000
  427.     if(running->address == 0x10000)
  428.     {
  429.         //升级版本为1.0.1的固件
  430.         ret = user_connect_http_server(USER_FOTA_URL1,&user_http_info);
  431.     }
  432.     else
  433.     {
  434.         //升级版本为1.0.0的固件
  435.         ret = user_connect_http_server(USER_FOTA_URL0,&user_http_info);
  436.     }
  437.  
  438.     if(ret < 0)
  439.     {
  440.         goto fail1;
  441.     }
  442.  
  443.     //GET请求
  444.     const char *GET_FORMAT =
  445.             "GET %s HTTP/1.0\r\n"
  446.             "Host: %s:%s\r\n"
  447.             "Accept: application/octet-stream\r\n"
  448.             "Accept-Encoding: identity\r\n"
  449.             "User-Agent: esp8266\r\n\r\n";
  450.  
  451.     char *http_request = NULL;
  452.     int request_len = asprintf(&http_request, GET_FORMAT, user_http_info.url_path_buff, user_http_info.url_host_buff , user_http_info.url_port_buff);
  453.     //是否分配内存失败
  454.     if (request_len < 0) 
  455.     {
  456.         ESP_LOGE(TAG, "http request asprintf failed");
  457.         goto fail2;
  458.     }
  459.  
  460.     //打印请求内容
  461.     printf("http_request:\r\n%s",http_request);
  462.  
  463.  
  464.     char *http_recv_buff = NULL;
  465.     char *http_text_buff = NULL;
  466.     if((http_recv_buff = (char *)malloc(USER_FOTA_RECV_BUFFSIZE+1)) == NULL)
  467.     {
  468.         ESP_LOGE(TAG, "http http_recv_buff malloc fail");
  469.         goto fail3; 
  470.     }
  471.     if((http_text_buff = (char *)malloc(USER_FOTA_TEXT_BUFFSIZE+1)) == NULL)
  472.     {
  473.         ESP_LOGE(TAG, "http http_text_buff malloc fail");
  474.         goto fail3; 
  475.     }
  476.  
  477.  
  478.     //发送请求
  479.     if(send(user_http_info.http_socket, http_request, request_len, 0) < 0)
  480.     {
  481.          ESP_LOGE(TAG, "http send failed"); 
  482.          goto fail3;
  483.     }
  484.  
  485.     ESP_LOGI(TAG, "http send success");
  486.  
  487.  
  488.     //可以释放内存，后面没有使用该变量
  489.     free(http_request);
  490.     http_request = NULL;
  491.     user_free_http_info(&user_http_info);
  492.  
  493.  
  494.     //获取下一个更新分区
  495.     update_partition = esp_ota_get_next_update_partition(NULL);
  496.     ESP_LOGD(TAG, "writing to partition subtype %d at offset 0x%x",
  497.              update_partition->subtype, update_partition->address);
  498.     assert(update_partition != NULL);
  499.  
  500.  
  501.     ESP_LOGD(TAG, "esp_ota_begin ........");
  502.  
  503.     //擦除OTA区域FLASH,这里等待时间较长
  504.     err = esp_ota_begin(update_partition, OTA_SIZE_UNKNOWN, &update_handle);
  505.     if (err != ESP_OK) {
  506.         ESP_LOGE(TAG, "esp_ota_begin failed, error=%d", err);
  507.         goto fail3;
  508.     }
  509.     ESP_LOGD(TAG, "esp_ota_begin succeeded");
  510.  
  511.     int binary_file_length = 0;
  512.     bool flag = true;
  513.     esp_ota_firm_t ota_firm;
  514.  
  515.     esp_ota_firm_init(&ota_firm, update_partition);
  516.  
  517.  
  518.     while (flag) {
  519.         memset(http_recv_buff, 0, USER_FOTA_RECV_BUFFSIZE);
  520.         memset(http_text_buff, 0, USER_FOTA_TEXT_BUFFSIZE);
  521.  
  522.         int buff_len = recv(user_http_info.http_socket, http_recv_buff, USER_FOTA_RECV_BUFFSIZE, 0);
  523.  
  524.         //接收错误
  525.         if (buff_len < 0) 
  526.         {
  527.             ESP_LOGE(TAG, "Error: receive data error! errno=%d", errno);
  528.             goto fail3;
  529.         } 
  530.         //接收数据
  531.         else if (buff_len > 0) 
  532.         { 
  533.             esp_ota_firm_parse_msg(&ota_firm, http_recv_buff, buff_len);
  534.             if(ota_fail_flag)
  535.             {
  536.                 goto fail3;
  537.             }
  538.  
  539.             if (!esp_ota_firm_can_write(&ota_firm))
  540.                 continue;
  541.  
  542.             memcpy(http_text_buff, esp_ota_firm_get_write_buf(&ota_firm), esp_ota_firm_get_write_bytes(&ota_firm));
  543.             buff_len = esp_ota_firm_get_write_bytes(&ota_firm);
  544.  
  545.             err = esp_ota_write( update_handle, (const void *)http_text_buff, buff_len);
  546.             if (err != ESP_OK) {
  547.                 ESP_LOGE(TAG, "Error: esp_ota_write failed! err=0x%x", err);
  548.                 goto fail3;
  549.             }
  550.             binary_file_length += buff_len;
  551.             ESP_LOGI(TAG, "Have written image length %d", binary_file_length);
  552.         } 
  553.         //接收完成
  554.         else if (buff_len == 0) 
  555.         {  
  556.             flag = false;
  557.             ESP_LOGI(TAG, "ota all packets received");
  558.         } else {
  559.             ESP_LOGE(TAG, "Unexpected recv result");
  560.         }
  561.  
  562.         if (esp_ota_firm_is_finished(&ota_firm))
  563.             break;
  564.     }
  565.  
  566.     ESP_LOGI(TAG, "Total Write binary data length : %d", binary_file_length);
  567.  
  568.     //校验固件
  569.     if (esp_ota_end(update_handle) != ESP_OK) {
  570.         ESP_LOGE(TAG, "esp_ota_end failed!");
  571.         goto fail3;
  572.     }
  573.  
  574.     //设在启动分区
  575.     err = esp_ota_set_boot_partition(update_partition);
  576.     if (err != ESP_OK) {
  577.         ESP_LOGE(TAG, "esp_ota_set_boot_partition failed! err=0x%x", err);
  578.         goto fail3;
  579.     }
  580.  
  581.     ESP_LOGI(TAG, "ota success restart system!");
  582.  
  583.     //关闭TCP连接
  584.     close(user_http_info.http_socket);
  585.  
  586.     vTaskDelay(100/portTICK_RATE_MS);
  587.  
  588.     //重启设备
  589.     esp_restart();
  590.  
  591.  
  592. fail3:
  593.     if(http_recv_buff != NULL)
  594.     {
  595.         free(http_recv_buff);
  596.     }
  597.     if(http_text_buff != NULL)
  598.     {
  599.         free(http_text_buff);
  600.     }
  601.  
  602. fail2:
  603.     if(http_request != NULL)
  604.     {
  605.         free(http_request);
  606.     }
  607.  
  608.     close(user_http_info.http_socket);
  609.  
  610. fail1:
  611.     user_free_http_info(&user_http_info);      
  612.  
  613.  
  614.     ESP_LOGE(TAG, "ota failed!");
  615.  
  616.     ota_runing_flag = false;
  617.  
  618.     vTaskDelete(NULL);
  619. }
  620.  
  621.  
  622.  
  623. /********************************************************************
  624.  *@brief	FOTA初始化函数
  625.  *@param[in]
  626.  *@return
  627.  *******************************************************************/
  628. void user_fota_init()
  629. {
  630.     xTaskCreate(user_fota_task, "user_fota_task", 8192, NULL, 5, NULL);
  631. }
  632.

4、user_fota.h

  1. #ifndef _USER_FOTA_H_
  2. #define _USER_FOTA_H_
  3.  
  4. #include <stdio.h> 
  5. #include <string.h>  
  6. #include "sdkconfig.h" 
  7. #include "freertos/FreeRTOS.h" 
  8. #include "freertos/task.h" 
  9. #include "freertos/event_groups.h" 
  10. #include "esp_system.h" 
  11. #include "esp_spi_flash.h" 
  12. #include "nvs_flash.h" 
  13. #include "esp_log.h"  
  14. #include "esp_netif.h" 
  15. #include "esp_event.h" 
  16. #include "esp_wifi.h"  
  17. #include "lwip/sockets.h" 
  18. #include "lwip/dns.h" 
  19. #include "lwip/netdb.h"  
  20. #include "esp_log.h"  
  21.  
  22. #include "nvs.h" 
  23. #include "nvs_flash.h" 
  24. #include "esp_ota_ops.h" 
  25. #include "esp_http_client.h" 
  26. #include "esp_https_ota.h" 
  27. #include "esp_ota_ops.h" 
  28. #include "esp_netif.h"
  29.  
  30.  
  31.  
  32.  
  33. //===================================================================
  34. //							常量定义
  35. //===================================================================
  36. //固件版本为1.0.0的URL
  37. #define USER_FOTA_URL0              "http://xxxx.oss-cn-shenzhen.aliyuncs.com/esp8266/fota_v1.0.0.bin"
  38.  
  39. //固件版本为1.0.1的URL
  40. #define USER_FOTA_URL1              "http://xxxx.oss-cn-shenzhen.aliyuncs.com/esp8266/fota_v1.0.1.bin"
  41.  
  42.  
  43. #define USER_FOTA_RECV_BUFFSIZE     1024
  44. #define USER_FOTA_TEXT_BUFFSIZE     1500
  45.  
  46.  
  47.  
  48.  
  49.  
  50. //===================================================================
  51. //							定义结构体
  52. //===================================================================
  53. typedef enum esp_ota_firm_state {
  54.     ESP_OTA_INIT = 0,
  55.     ESP_OTA_PREPARE,
  56.     ESP_OTA_START,
  57.     ESP_OTA_RECVED,
  58.     ESP_OTA_FINISH,
  59. } esp_ota_firm_state_t;
  60.  
  61. typedef struct esp_ota_firm {
  62.     uint8_t ota_num;
  63.     uint8_t update_ota_num;
  64.  
  65.     esp_ota_firm_state_t state;
  66.  
  67.     size_t content_len;
  68.  
  69.     size_t read_bytes;
  70.     size_t write_bytes;
  71.  
  72.     size_t ota_size;
  73.     size_t ota_offset;
  74.  
  75.     const char *buf;
  76.     size_t bytes;
  77. } esp_ota_firm_t;
  78.  
  79.  
  80. typedef struct {
  81.     char *url_buff;            
  82.     char *url_type_buff;        //解析后的url协议类型字符串缓存
  83.     char *url_host_buff;        //解析后的url主机域名字符串缓存
  84.     char *url_port_buff;        //解析后的url主机端口字符串缓存
  85.     char *url_path_buff;        //解析后的url文件路径字符串缓存
  86.  
  87.     int  http_socket;           //当前连接http的套接字 
  88. }user_http_info_t;
  89.  
  90.  
  91.  
  92. //===================================================================
  93. //							函数声明
  94. //===================================================================
  95. void user_fota_init();
  96. bool fota_is_runing();
  97.  
  98.  
  99. #endif

5、使用说明

  更改头文件的URL为你服务器固件的URL，这里我们放两个固件fota_v1.0.0.bin和fota_v1.0.1.bin，执行OTA时会循环升级这两个固件

  1. //固件版本为1.0.0的URL
  2. #define USER_FOTA_URL0              "http://xxxx.oss-cn-shenzhen.aliyuncs.com/esp8266/fota_v1.0.0.bin"
  3.  
  4. //固件版本为1.0.1的URL
  5. #define USER_FOTA_URL1              "http://xxxx.oss-cn-shenzhen.aliyuncs.com/esp8266/fota_v1.0.1.bin"

WIFI连接成功之后，执行以下代码开始OTA

  1. //当前没有运行OTA，才能进行OTA
  2. if(!fota_is_runing())
  3. {
  4.     user_fota_init();
  5. }

6、本人写了个自动OTA demo，每次上电连接WIFI之后进行OTA，目前升级1000+以上，未发现异常，中途未出现过失败、中断。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/600679
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号