ESP32-S2 Linux串口OTA升级

已于 2023-06-27 14:44:34 修改
阅读量2.5k 收藏 23
点赞数
分类专栏： ESP32 文章标签： stm32 linux arm 嵌入式硬件 单片机
于 2022-09-29 16:44:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/maomaochong666/article/details/126646135
版权

一、简介

         OTA(Over-the-Air Technology )空中下载技术，通过远程网络为设备更新或者升级，本质就是把固件通过WiFi、蓝牙、4G、5G、网线等写到MCU flash里面，最终实现升级。

二、原理

        1.终端设备发送需要升级的固件；

        2.MCU接收来自终端设备的固件，并写到flash里面；

        3.修改引导程序，下次复位启动当前更新的程序。

三、需要配置

        ESP32 OTA升级需要配置分区表，可以自定义分区表也可以使用官方配置的分区表。

        本文使用官方配置的分区表，操作步骤如下（ESP-IDF 4.4 PowerShell）： 

        1.进入工程目录

         2.执行idf.py menucofig命令

        3.配置一下芯片flash大小（根据对应的芯片选择） 

         4.改成4MB

        5.选择分区表

         6.选择，一个出厂程序，两个ota程序

         7.q退出y保存，配置完成。

四、程序编写

        ESP32-OTA源文件

#include "bsp_ota.h"
#include "crc16.h"
#include "esp_log.h"
#include <stdlib.h>
#include <string.h>

static const char *TAG = "uart_ota";

uint8_t ota_table[2] = {0x0a,0x0a};
static void UART_OTA_Task(void *arg);

void UART_Init(uint32_t baud)
{
    const uart_config_t uart_config = {
        .baud_rate = baud,
        .data_bits = UART_DATA_8_BITS,
        .parity    = UART_PARITY_DISABLE,
        .stop_bits = UART_STOP_BITS_1,
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
        .source_clk = UART_SCLK_APB,
    };
    uart_driver_install(UART_NUM,UART_BUFFER_SIZE,UART_BUFFER_SIZE,0,NULL,0);
    uart_param_config(UART_NUM,&uart_config);
    uart_set_pin(UART_NUM,UART_TX,UART_RX,UART_PIN_NO_CHANGE,UART_PIN_NO_CHANGE);
}

void UART_OTA_Init(void)
{
    UART_Init(460800);
    xTaskCreate(UART_OTA_Task,"UART_OTA_Task",1024 * 6,NULL,3,NULL);
}

static void OTA_Ack(uint8_t ota_ack)
{
   ota_table[0] = ota_ack;
   uart_write_bytes(UART_NUM,ota_table,2);
}

static void UART_OTA_Task(void *arg)
{
    uint8_t  ota_state = 0;
    uint32_t rx_len = 0;
    uint16_t crc_value = 0;
    uint32_t ota_timeout = 0;
    uint32_t binary_file_length = 0;
    uint8_t* uart_rx_buf = (uint8_t*) malloc(UART_BUFFER_SIZE);

    esp_err_t err = ESP_OK;
    esp_ota_handle_t update_handle = 0;
    const esp_partition_t *update_partition = NULL;
    update_partition = esp_ota_get_next_update_partition(NULL);                                         //获取下一个OTA更新的区域
    err = esp_ota_begin(update_partition,OTA_SIZE_UNKNOWN, &update_handle);                             //安装OTA升级
    if(err != ESP_OK)
    {
        ESP_LOGE(TAG, "esp_ota_begin failed!");
    }
    bzero(uart_rx_buf,UART_BUFFER_SIZE); 
    ESP_LOGI(TAG, "esp_ota_begin ok!");

    while(1)
    {
        rx_len = uart_read_bytes(UART_NUM,uart_rx_buf,UART_BUFFER_SIZE,1000 / portTICK_RATE_MS);        //接收数据
        if(rx_len > 0) 
        {
            if(ota_state == OTA_UPGRADE_READY)                                                          
            {
                if(uart_rx_buf[0] == 0x55 && uart_rx_buf[1] == 0x66)
                {
                    crc_value = crc16(uart_rx_buf,rx_len - 2);    
                    if((crc_value & 0xff) == uart_rx_buf[rx_len - 2]  && (crc_value >> 8) == uart_rx_buf[rx_len - 1])
                    {
                        OTA_Ack(OTA_DATA_CRC_OK);
                        err  = esp_ota_write(update_handle, (const void *)uart_rx_buf + 2,rx_len - 4);  //往flash写入数据
                        if (err != ESP_OK) 
                        {
                            ESP_LOGE(TAG,"Error: esp_ota_write failed! err = 0x%x", err);
                            esp_restart();
                        }
                        binary_file_length += rx_len - 4;
                        ota_timeout = 0;
                    }
                    else
                    {
                        OTA_Ack(OTA_DATA_CRC_ERR);
                    }      
                }
                else if(strstr((char*)uart_rx_buf,"finish") != NULL)                           //OTA写结束
                {   
                    if(esp_ota_end(update_handle) != ESP_OK) 
                    {
                        OTA_Ack(OTA_DATA_CRC_ERR);
                        ESP_LOGE(TAG,"esp_ota_end failed!");
                    }
                    else
                    {
                        OTA_Ack(OTA_WRITE_FINISH);
                        err = esp_ota_set_boot_partition(update_partition);
                        if(err != ESP_OK) 
                        {
                            ESP_LOGE(TAG,"esp_ota_set_boot_partition failed! err=0x%x",err);
                        }
                    }
                    esp_restart();
                }            
            }
            else if(strstr((char*)uart_rx_buf,"download:") != NULL)                 //收到下载命令，开始进入下载状态
			{
                OTA_Ack(OTA_UPGRADE_READY);
                ota_state = OTA_UPGRADE_READY;
			}
            uart_flush_input(UART_NUM);
            bzero(uart_rx_buf,UART_BUFFER_SIZE); 
        }
        else if(ota_state == OTA_UPGRADE_READY)
        {
            ota_timeout++;
            if(ota_timeout >= 60)                                                   //下载超时，复位单片机
            {
                OTA_Ack(OTA_WRITE_TIMEOUT);
                ESP_LOGI(TAG,"uart ota timeout\n");  
                esp_restart();
            }
        }
    }
    free(uart_rx_buf);                                                               //释放内存
}

        ESP32-OTA头文件

#ifndef _BSP_OTA_H_
#define _BSP_OTA_H_

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_ota_ops.h"
#include "driver/uart.h"
#include "driver/gpio.h"

#define UART_BUFFER_SIZE               (1024 * 4 + 4)

#define UART_NUM                       UART_NUM_1
#define UART_TX                        GPIO_NUM_6
#define UART_RX                        GPIO_NUM_7

#define OTA_UPGRADE_READY              0x05
#define OTA_DATA_CRC_ERR               0x06
#define OTA_DATA_CRC_OK                0x07
#define OTA_WRITE_TIMEOUT              0x08
#define OTA_WRITE_FINISH       	       0x09

void UART_OTA_Init(void);
#endif

        LINUX串口应用程序

#include <stdio.h>
#include <netdb.h>
#include <unistd.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <termios.h>
#include <pthread.h>
#include <dirent.h>
#include <arpa/inet.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#include <dirent.h>
#include <semaphore.h>

// gcc download.c -o download -pthread			//编译
// ./download /dev/ttyUSB0 app_main.bin			//执行
// aarch64-linux-gnu-gcc espdownload.c -o espdownload -pthread

#define MAX 					(1024 * 2 + 4)
int firmware_size;
static sem_t sem_handler; 

#define OTA_UPGRADE_READY              0x05
#define OTA_DATA_CRC_ERR               0x06
#define OTA_DATA_CRC_OK                0x07
#define OTA_WRITE_TIMEOUT              0x08
#define OTA_WRITE_FINISH       	   	   0x09

static unsigned short const crc16_table[] = {
	0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
	0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
	0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
	0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841,
	0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40,
	0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41,
	0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641,
	0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040,
	0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240,
	0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441,
	0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41,
	0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840,
	0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41,
	0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40,
	0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640,
	0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041,
	0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240,
	0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441,
	0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41,
	0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840,
	0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41,
	0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40,
	0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640,
	0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041,
	0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241,
	0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440,
	0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40,
	0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841,
	0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40,
	0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41,
	0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
	0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
};

//查表法,低位在前
unsigned short crc16(unsigned char *pBuffer, unsigned short usDataLen)
{
	unsigned short i = 0;
	unsigned short uIndex = 0;
	unsigned short uCRC16  = 0xffff;

	for(i = 0;i < usDataLen;i++)
	{
		uIndex = ((uCRC16 & 0xff) ^ (pBuffer[i] & 0xff));

		uCRC16 = ((uCRC16 >> 8) & 0xff) ^ crc16_table[uIndex];
	}

	return (uCRC16 >> 8)|(uCRC16 << 8);
}

int uart_init(const char *dev_path)
 {
	int ret;
	int tty_fd;
	struct termios options;
	
	tty_fd = open(dev_path,O_RDWR | O_NOCTTY | O_NDELAY) ; 				//打开串口
    if(tty_fd < 0)
    {
		//perror("open error");
		return -1;
    }

	memset(&options,0,sizeof(options)) ;
    ret = tcgetattr(tty_fd,&options); 								//获取原有的串口属性的配置
    if(ret != 0)
    {
        perror("tcgetattr error") ;
        return -1;
    }
	
    options.c_cflag |= (CLOCAL|CREAD );   								//CREAD 开启串行数据接收，CLOCAL并打开本地连接模式
    options.c_cflag &= ~CSIZE;											//先使用CSIZE做位屏蔽  
    options.c_cflag |= CS8; 											//设置8位数据位
    options.c_cflag &= ~PARENB; 										//无校验位
	options.c_cflag &= ~CSTOPB;											//设置一位停止位
	options.c_oflag &= ~OPOST;											//解决发送数据中有OA = 0D 0A的问题
    options.c_cc[VMIN] = 0; 											//非规范模式读取时的最小字符数
	
    cfsetispeed(&options,B460800);										//设置波特率
    cfsetospeed(&options,B460800);
 
    tcflush(tty_fd,TCIOFLUSH);   										//清空输入输出缓存
    tcsetattr(tty_fd,TCSANOW,&options);   								//设置终端控制属性,TCSANOW：不等数据传输完毕就立即改变属性
	if((tcsetattr(tty_fd,TCSANOW,&options)) != 0)
    {
        perror("tcsetattr error");
        return -1;
    }
	
	return tty_fd;
}

int uart_write(int tty_fd,char *wbuf,int wbuf_size)
{
	//printf("write:%s size:%d\n",wbuf,wbuf_size);
	int len = write(tty_fd,wbuf,wbuf_size);
	if(len < 0)
	{
		//perror("write serial fail\n");
		return -1;
	}
	return 0;
}

int uart_read(int tty_fd,char *rbuf,int rbuf_size)
{
	int len = read(tty_fd,rbuf,rbuf_size);
	if(len < 0)
	{
		//perror("read serial fail\n");
		return -1;
	}
}
	
void *read_usart_pthread(void *arg)
{
	int  rx_len = 0;
	int  timeout = 0;
	char rx_buff[MAX] = {0};
	
	float bar_value = 0;									//进度值
	int send_count = firmware_size / (MAX -  4);			//需要发送次数
	float value = 1.0 / send_count * 100 ;					//进度条比例，发送一次的值
	
	while(1)
	{
		rx_len = read(*(int*)arg,rx_buff,sizeof(rx_buff));
		if(rx_len > 0)
		{
			switch(rx_buff[0])
			{
				case OTA_UPGRADE_READY:
				{
					timeout = 0;
					bar_value = 0;
					printf("\nesp32 ota ready\n");
					printf(">>>"); 
					sem_post(&sem_handler);  
				}break;
				
				case OTA_DATA_CRC_ERR:
				{
					printf("\ndata crc error!\n");
					printf("esp32 firmware write error!\n");
					return (void*)0;
				}break;
				
				case OTA_DATA_CRC_OK:
				{
					timeout = 0;
					bar_value += value;
					if(bar_value <= 99.9)
					{
						printf("\b\b\b>>>>>");   		//'\b'把前面输出的覆盖
						printf("%.0f%%",bar_value);
					}
					fflush(stdout);						//清空缓冲区
				}break;
				
				case OTA_WRITE_FINISH:
				{
					printf("\b\b\b\b>>>>>");   			//'\b'把前面输出的覆盖
					printf("100%%\n");
					return (void*)0;
				}break;
				
				case OTA_WRITE_TIMEOUT:
				{
					printf("esp32 firmware write timeout\n");
					return (void*)0;
				}break;
				
				default:
				{
					printf(".");
					fflush(stdout);						//把数据从缓冲区输出到窗口
				}break;
			}
		}
		else
		{
			timeout++;
			if(timeout >= 1000 * 30)
			{
				printf("\nconnect espdownload timeout!\n");
				system("killall download");
			}
			usleep(1000);
		}
		
		memset(rx_buff,0,sizeof(rx_buff));
	}
	return (void*)0;
}

void printf_help_info(char *argv[])
{
	printf ("\t%s -h: Print this help message\n", argv[0]);
	printf ("\t%s <serial port> <firmware bin>\n", argv[0]);
}

int main(int argc,char *argv[])
{
	int ret;
	int file_fd;
	int tty_fd;
	struct stat stat_buf;
	char buff[MAX] = {0};
	char temp[20] = {0};
	char file_path[80] = {0};
	char dev_path[30] = "/dev/ttyS0";
	unsigned short crc;
	pthread_t tid;
	sem_init(&sem_handler,0,0);											//创建一个线程间的信号量
	
	if(argc > 2)
	{
		strcpy(dev_path,argv[1]);
		strcpy(file_path,argv[2]);
	}
	else
	{
		printf_help_info(argv);
	}
	
	printf("esp32 firmware version：%s\n",argv[2]);
	
	file_fd = open(file_path,O_RDONLY);								//以只读的方式打开文件
	if(file_fd < 0)
	{
		perror("open file error");
		return file_fd;
	}
	
	memset(&stat_buf,0,sizeof(stat_buf));
	ret = fstat(file_fd, &stat_buf);									//获取文件信息
	if(ret < 0)
	{
		perror("fstat file error");
		goto clean;
	}
	
	printf("esp32 firmware size：%ld bytes\n",stat_buf.st_size);
	
	firmware_size = stat_buf.st_size;
	if(stat_buf.st_size <= 0)
	{
		perror("file szie error");
		goto clean;
	}
	
	tty_fd = uart_init(dev_path);
    if(tty_fd < 0)
    {
		printf("open %s error\n",dev_path);
		goto clean;
    }
	
	ret = pthread_create(&tid,NULL,read_usart_pthread,(void*)&tty_fd);
	if(ret) 
	{
		perror("pthread_create error");
		goto clean;
	}
	
	printf("wait esp32 connecting\n");
	
	sprintf(temp,"download:%ld",stat_buf.st_size);
	write(tty_fd,temp,sizeof(temp));									//发送下载请求 + 固件大小	
	
	sem_wait(&sem_handler);  											//堵塞等待信号量

	tcflush(tty_fd,TCIOFLUSH);   									
	usleep(1000 * 1500);
	
	uart_read(tty_fd,buff,sizeof(buff));
	memset(buff,0,MAX);
	
	while(1)
	{
		buff[0] = 0x55;
		buff[1] = 0x66;
		
		ret = read(file_fd,buff + 2,MAX - 4);
		if(ret <= 0)
		{
			break;
		}
		
		crc = crc16(buff,ret + 2);
		buff[ret + 2] = crc & 0xff;
		buff[ret + 3] = crc >> 8;
		
		ret = write(tty_fd,buff,ret + 4);
		
		memset(buff,0,MAX);
		usleep(1000 * 200);
	}
	sleep(1);
	write(tty_fd,"finish",sizeof("finish"));
	pthread_join(tid,NULL);
	sem_destroy(&sem_handler);
	
	printf("esp32 firmware programming to %s completed\n",dev_path);
	
	clean:
		close(file_fd);
		close(tty_fd);
		return 0;
}

五、验证

        1.接线：CH340-TX 接 ESP32-S2 RX(GPIO7)    CH340-RX 接 ESP32-S2 TX(GPIO6)；

        2.编译下载

3.把文件放到虚拟机

 4.编译、执行

六、总结

        下载验证都很稳定，代码中的应答还可以优化一下。

        工程源码，提取码：0j9d：https://pan.baidu.com/s/1_YzpTuUPCYcDhP1rWgeHlQ?pwd=0j9dhttps://pan.baidu.com/s/1_YzpTuUPCYcDhP1rWgeHlQ?pwd=0j9d

李法师_
关注
  • 0
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
ESP32网络编程-OTA方式升级固件（基于Web浏览器）
视觉与物联智能
12-10 1752
在前面的文章中，我们在Arduino IDE的网络端口中，实现了OTA方式升级固件。在本文中，将详细介绍ESP32的另外一种OTA升级方式，即基于Web浏览器方式升级固件。
STM32F103串口升级程序IAP.rar
08-26
STM32F103串口升级程序IAP.rar
【ESP32】通过本地服务器实现OTA功能
weixin_41920367的博客
07-25 954
1.创建示例项目ota_example_mqtt：VSCODE中->“查看”->”命令面板“->输入：Show Examples projects->选择Use current ESP-IDF(C:\Espressif\frameworks\esp-idf-v5.1)->弹出示例ESP-IDF Examples，选择system->ota->simple_ota_example->Create project using example simple_ota_example->选择示例保存的路径。
ESP32通过USB/UART/ble/其他协议OTA报错解决
最新发布
weixin_38137947的博客
03-21 240
ESP32使用USB、UART、BLE OTA 失败分析
【IoT】如何实现 ESP32 固件的 OTA 在线升级更新
热门推荐
产品线负责人
07-15 2万+
1、背景 在实际产品开发过程中，在线升级可以远程解决产品软件开发引入的问题，更好地满足用户需求。 2、OTA 简介 OTA（空中）更新是使用 Wi-Fi 连接而不是串行端口将固件加载到 ESP 模块的过程。 2.1、ESP32 的 OTA 升级有三种方式： Arduino IDE：主要用于软件开发阶段，实现不接线固件烧写 Web Browser：通过 Web 浏览器手动提供应用程序更新...
ESP32 OTA空中升级步骤详细说明.pdf
07-29
这只是http本地空中升级,能让刚接触OTA升级的了解流程,熟悉了http,再去看https就很容易了
ES32中OTA空中升级
cat_eat_fish
03-06 1814
ESP32的空中升级测试及问题分析
ESP32 OTA升级
朽木自雕i的博客
05-13 3929
本文主要介绍了ESP32如何实现OTA升级，包括代码示例、代码讲解以及注意事项等等。读者可以通过学习本文，了解ESP32 OTA升级的原理和实现方式，并可以应用到实际项目中。同时，也需要注意OTA升级期间的一些注意事项，以保证升级成功。
Tina_Linux_OTA_开发指南
韦东山嵌入式专栏
02-24 1704
此文档主要介绍如何在OTA 时升级boot0/uboot。升级工具包含两个方面内容：OTA 命令升级boot0 和uboot。OTA 升级boot0 和uboot 的C/C++ APIs。SWUpdate 是一个开源的OTA 框架，提供了一种灵活可靠的方式来更新嵌入式系统上的软件。官方源码：官方文档：非官方翻译的中文文档：源码自带文档：解压tina/dl/swupdate-xxx.tar.xz ，解压后的doc 目录下即为此版本源码附带的文档。
Linux应用之OTA升级
chengwei_peng
09-26 1643
swupdate OTA升级介绍
linux ota升级
qq_41170580的博客
07-14 738
ota又名空中下载技术，即通过网络获新的软件版本来完成固件的更新替换，最终做到系统自己更新自己。这一过程分为两个大的步骤：第一步：从网络获取固件；这种方法有很多，如果是本地局域网的话，可以通过tftp，scp完成；如果是远程服务器的话，可以通过http服务实现。第二步：更新替换固件；在linux系统中，把获取到的新的固件替换老的固件，要完成此步，不得不讲一下linux的磁盘分区。
ESP32-S2 快速入门（一）：使用 git 更新自己的 esp-idf 并编译烧录程序至 ESP32-S2
01-06
今天来尝试使用 esp-idf 编译并烧录固件至 ESP32-S2。官方教程如下：ESP32-S2 快速入门。本文将基于旧版 esp-idf 来进行 git 更新，环境配置等操作后再编译烧录程序至 ESP32-S2。 1. 使用 git 更新 esp-idf 至最新...
esp32-ota-update-mqtt
05-02
通过MQTT启动ESP32 OTA更新 此源允许通过MQTT触发ESP OTA更新。 您只需提供主机名/ binfile，ESP就会解析URL。 之后，更新将自动开始。 目前，这仅在端口80上有效！ 触发更新的示例MQTT消息（不要向主机名添加任何...
ESP32-OTA.zip 学习ESP32串口ota样例程序
11-05
ESP32_OTA.zip 学习ESP32串口ota样例程序
esp-ota-server：ESP8266 ESP32 HTTP OTA服务器
02-05
ESP-OTA-服务器非常简单的OTA固件服务器，适用于内置和 。 主要目的是提供固件文件并传递MD5哈希值-以验证闪存。 选项： -s --bind监听地址（默认值:8092 ） -d --data-dir数据存储位置。 <data>/<project>/<file> ...
esp32芯片平台的http-web-ota的demo程序源码
08-18
该demo程序源码，实现在esp32平台上的http web ota升级功能，通过该功能可以实现esp32通过wifi方式的ota升级功能，可以将该demo移植到自己的工程中，从而实现后期的ota更新固件的功能，非常方便
【ESP32】ESP32 OTA 功能
weixin_45880295的博客
02-02 564
ESP32 空中升级
ESP32cam系列教程003：ESP32cam实现远程 HTTP_OTA 自动升级
qiaoyurensheng的博客
07-31 1270
ESP32cam实现远程 HTTP_OTA 自动升级
ESP32 IDF开发 应用篇⑲ 空中升级OTA
lu330274924的博客
11-15 1043
在实际产品开发过程中，在线升级可以远程解决产品软件开发引入的问题，更好地满足用户需求。OTA（空中）更新是使用 Wi-Fi 连接而不是串行端口将固件加载到 ESP 模块的过程。（1）、ESP32 的 OTA 升级有三种方式：·Arduino IDE：主要用于软件开发阶段，实现不接线固件烧写·Web Browser：通过 Web 浏览器手动提供应用程序更新模块·HTTP Server：自动使用http服务器 - 针对产品应用在三种升级情况下，必须通过串行端口完成第一个固件上传。
stm32+esp8266(esp-12f)实现在线ota升级
06-07
STM32和ESP8266是常用的嵌入式开发板，其中ESP8266是常用的Wi-Fi模块，可用于实现物联网应用程序的在线OTA升级。实现在线OTA升级的主要步骤如下： 1. 配置ESP8266 Wi-Fi模块，并连接到指定Wi-Fi网络。可使用ESP8266 AT指令集或ESP8266库进行配置和连接。 2. 在STM32上实现HTTP客户端功能，可以使用STM32 HAL库中的网络套接字功能或HTTP客户端库进行实现。通过HTTP客户端，可以请求获取最新的固件升级包并下载。 3. 在STM32上实现OTA固件更新功能。STM32通常有两个区域，一个是应用程序区，一个是升级区。在固件更新过程中，先将新固件升级到升级区，然后在重启后再进行切换。可使用MCUBoot或其它固件更新库进行实现。 4. 在STM32应用程序中实现控制逻辑，判断是否需要进行OTA更新，并发起HTTP请求下载。下载完成后，通知OTA更新模块进行升级。升级完成后，进行重启并切换到新固件。 总的来说，STM32和ESP8266实现OTA升级需要涉及到Wi-Fi模块的配置、HTTP客户端的实现、固件更新的实现和控制逻辑的处理。具体的实现可参考ESP8266和STM32的各自文档和库函数。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值