Slan 士兰微SC32F5664 通过串口IAP，实现OTA

最新推荐文章于 2024-05-19 01:17:04 发布
最新推荐文章于 2024-05-19 01:17:04 发布
阅读量888 收藏 1
点赞数 1
分类专栏： 项目分享 学习 文章标签： 单片机 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L_e_c/article/details/125614303
版权

Slan 士兰微SC32F5664 通过串口IAP，实现OTA

前言

越来越多的设备在出厂的时候，自带boot，以便在出现问题不拆壳的情况下实现对设备的软件升级。士兰微的IAP在线更新程序因为资料比较少，做的过程中原厂给的资料也是模糊其词，所以我在做这个项目的过程中就想着做完的时候整理一下发出来，供需要的人参考。

一、整体思路

1.单片机

程序上电运行boot程序（注意：士兰微的芯片和ST的不太一样的地方是boot的启动地址不一样，从最后1K开始运行boot的程序大小是依次往前排，flash的地址也不一样，真正从0x0开始），看得懂的看下图，在boot程序里面会判断是否需要升级，需要升级会接收升级指令并作出应答，升级结束会校验app的完整性，然后校验通过才会跳转至APP程序运行；不需要升级的时候会直接校验APP完整性然后跳转至APP程序运行，在APP程序里面会接收升级指令，然后软重启至boot运行，重复上面的升级流程。单片机的实现流程很简单，要是有不太理解的朋友，可以先看一下我之前的一篇博客，关于STM32F051R8T6的远程升级的文章，链接: 点我查看
使用脱机烧录器读出来的boot程序

2. 上位机（c#）

因为我们使用的芯片IAP功能，考虑到升级过程中对flash擦写错误造成的不可控因素，所以会对整个app进行加密，在boot里面校验APP的完整性，这个就不描述了，因为加密的方式有很多，只说一下这个思路。加密的软件是一个独立的，不会共享出来。还有一个就是升级的软件，界面如下，操作起来也比较简单，因为项目上使用的升级是双驱的，所以增加了升级设备地址选择项，正常打开串口后，选择地址，没有问题就点击开始升级，上面有进度条提示，下面会一直刷新发送的升级数据和收到的单片机设备返回的数据。
升级界面

二、整体流程

1.单片机

boot程序下载地址：链接 点我下载

1.1 boot程序

使用keil_mdk，先安装pack主持包，在boot程序里面选择带boot的芯片，如下图，在APP的程序里只需要选择不带boot的芯片，然后flashDownLoad的位置根据提示选择64K就可以了。
在这里插入图片描述

boot 代码如下（示例）：

u8 dat=0;
	u16 FileCRCNum=0;
	uint8_t Erase_Cnt_8u = 0;
	uint8_t FlashSendBuff[8]={0};  
	
	ReadAddr = 0x0000CC00;
//	uint16_t i=0,j = 0;
	System_init();
//	MotorFile_Par_Set();
//	MAX_485_Send_Launch = 0;
	IRQ_Init();
	FlashUpdata=ReadFlashWord(0xcc00,8,FlashSendBuff);
	FlashUpdata=FlashSendBuff[0]+FlashSendBuff[1]*256;
	Updata_PackSize=FlashSendBuff[4]+FlashSendBuff[5]*256+(FlashSendBuff[6]+FlashSendBuff[7]*256)*65536;
	if(FlashUpdata==0xaa55)
	{
		Databit.Bit.SendDataReadyFlag = 1;
		Databit.Bit.EraseFlashFlag = 1;
		Program_Addr = APP_ADDR;
		MAX_485_TX_BUF[0]=0xa9;
		MAX_485_TX_BUF[1]=0x20;
		MAX_485_TX_BUF[2]=Slave_ID;
		MAX_485_TX_BUF[3]=0xfd;
		MAX_485_TX_BUF[4]=0x00;
		MAX_485_TX_BUF[5]=0x03;
		MAX_485_TX_BUF[6]=0x00;
		MAX_485_TX_BUF[7]=0x00;
		MAX_485_TX_BUF[8]=0x80;
		SendCRC_Value=crc16(&MAX_485_TX_BUF[2],7);
		MAX_485_TX_BUF[9]=SendCRC_Value%256;
		MAX_485_TX_BUF[10]=SendCRC_Value/256;
		MAX_485_Send_Launch=1;
		G_Send_Len=11;
		TimeStopFlag=1;
	}	
		while(1)
		{
			if(TimeBase_100ms==1)
			{
				TimeBase_100ms=0;
				TGLBit(LED_ALARM_PORT_ABBR->OUTTGL,LED_ALARM_PIN);
			}
			#if 1
			if(TimeStopFlag == 0)
			{
				if(L_TimeOutCnt_32u < 200*5000) L_TimeOutCnt_32u++;	//
				else
				{
					CheckApp();
					if(AppCheckPass)	//检查栈顶地址是否合法&APP是否完整正确
					{
						EraseFlashSector(0xcc00);
						CHIPCTL->CHIP_KEY =0x05fa659aul;
						CHIPCTL->REMAP_CTRL =0xa05f0000;			//REMAP清零，切换到从0地址开始运行
						SCB->AIRCR=((0x05FA0000ul)|(1<<2));   //系统软件复位
					}
					else
					{
						TimeStopFlag = 1;
						L_TimeOutCnt_32u = 0;
					}
				}		
			}	
			
			if(MAX_485_Receive_Sucess)
			{
				if(MAX_485_RX_BUF[2]==Slave_ID)
				{
					if(MAX_485_RX_BUF[3]==0xfd)
					{
						if((MAX_485_RX_BUF[4]==0x00)&&(MAX_485_RX_BUF[5]==0x07))
						{
							Soft_Version=(MAX_485_RX_BUF[6]<<16)+(MAX_485_RX_BUF[7]<<8)+(MAX_485_RX_BUF[8]);
							Updata_PackSize=(MAX_485_RX_BUF[9]<<24)+(MAX_485_RX_BUF[10]<<16)+(MAX_485_RX_BUF[11]<<8)+(MAX_485_RX_BUF[12]);
							Databit.Bit.SendDataReadyFlag = 1;
							Databit.Bit.EraseFlashFlag = 1;
							Program_Addr = APP_ADDR;
							MAX_485_TX_BUF[0]=0xa9;
							MAX_485_TX_BUF[1]=0x20;
							MAX_485_TX_BUF[2]=Slave_ID;
							MAX_485_TX_BUF[3]=0xfd;
							MAX_485_TX_BUF[4]=0x00;
							MAX_485_TX_BUF[5]=0x03;
							MAX_485_TX_BUF[6]=0x00;
							MAX_485_TX_BUF[7]=0x00;
							MAX_485_TX_BUF[8]=0x80;
							SendCRC_Value=crc16(&MAX_485_TX_BUF[2],7);
							MAX_485_TX_BUF[9]=SendCRC_Value%256;
							MAX_485_TX_BUF[10]=SendCRC_Value/256;
							MAX_485_Send_Launch=1;
							G_Send_Len=11;
							EraseFlashSector(0xcc00);
							WriteFlashWord(0xcc00,0xaa55);
//							CHIPCTL->CHIP_KEY =0x05fa659aul;
//							CHIPCTL->REMAP_CTRL =0xa05f0001;			//REMAP清零，切换到从0地址开始运行
//							SCB->AIRCR=((0x05FA0000ul)|(1<<2));   //系统软件复位
						}
					}
					else if(MAX_485_RX_BUF[3]==0xef)
					{
						Databit.Bit.SendDataReadyFlag = 1;
						Uart0_Data.FlashWriteCnt++;
						if((Uart0_Data.FlashWriteCnt - 8) == 0) 
						{
							Uart0_Data.FlashWriteCnt = 0;
							Databit.Bit.EraseFlashFlag = 1;
						}
						Uart0_Data.G_Offset_32u = (MAX_485_RX_BUF[6]<<24)+(MAX_485_RX_BUF[7]<<16)+(MAX_485_RX_BUF[8]<<8)+MAX_485_RX_BUF[9];
						if((Program_Addr == (APP_ADDR + (Uart0_Data.G_Offset_32u-1)*128))&&(Program_Addr <= 0x0000CC00))
						{
							Databit.Bit.WriteErrFlag=0;
							for(Uart0_Data.FlashWriteCnt_16u = 0;Uart0_Data.FlashWriteCnt_16u < (Uart0_Data.U0Data_Length-4);Uart0_Data.FlashWriteCnt_16u+=4)				//(ModbusRegAmount-1)
							{
								if(Uart0_Data.U0Data_Length<132)
								{
									if((Uart0_Data.U0Data_Length-4-Uart0_Data.FlashWriteCnt_16u)<4)
									{
										if((Uart0_Data.U0Data_Length-4-Uart0_Data.FlashWriteCnt_16u)==3)
										{
											Byte_Word=((MAX_485_RX_BUF[12+Uart0_Data.FlashWriteCnt_16u])*65536+MAX_485_RX_BUF[11+Uart0_Data.FlashWriteCnt_16u]*256+MAX_485_RX_BUF[10+Uart0_Data.FlashWriteCnt_16u])&(0x00ffffff);
								
											WriteFlashWord(Program_Addr,Byte_Word);
											Program_Addr += 3;
											dat = (FileCRCNum >> 8); 
											FileCRCNum <<= 8;
											FileCRCNum ^= crc16tab[dat^MAX_485_RX_BUF[10+Uart0_Data.FlashWriteCnt_16u]];
											dat = (FileCRCNum >> 8); 
											FileCRCNum <<= 8;
											FileCRCNum ^= crc16tab[dat^MAX_485_RX_BUF[11+Uart0_Data.FlashWriteCnt_16u]];
											dat = (FileCRCNum >> 8); 
											FileCRCNum <<= 8;
											FileCRCNum ^= crc16tab[dat^MAX_485_RX_BUF[12+Uart0_Data.FlashWriteCnt_16u]];
										}
										else if((Uart0_Data.U0Data_Length-4-Uart0_Data.FlashWriteCnt_16u)==2)
										{
											Byte_Word=(MAX_485_RX_BUF[11+Uart0_Data.FlashWriteCnt_16u]*256+MAX_485_RX_BUF[10+Uart0_Data.FlashWriteCnt_16u])&(0x0000ffff);
								
											WriteFlashWord(Program_Addr,Byte_Word);
											Program_Addr +=2;
											dat = (FileCRCNum >> 8); 
											FileCRCNum <<= 8;
											FileCRCNum ^= crc16tab[dat^MAX_485_RX_BUF[10+Uart0_Data.FlashWriteCnt_16u]];
											dat = (FileCRCNum >> 8); 
											FileCRCNum <<= 8;
											FileCRCNum ^= crc16tab[dat^MAX_485_RX_BUF[11+Uart0_Data.FlashWriteCnt_16u]];
										}
										else if((Uart0_Data.U0Data_Length-4-Uart0_Data.FlashWriteCnt_16u)==1)
										{
											Byte_Word=(MAX_485_RX_BUF[10+Uart0_Data.FlashWriteCnt_16u])&(0x000000ff);
								
											WriteFlashWord(Program_Addr,Byte_Word);
											Program_Addr += 1;
											dat = (FileCRCNum >> 8); 
											FileCRCNum <<= 8;
											FileCRCNum ^= crc16tab[dat^MAX_485_RX_BUF[10+Uart0_Data.FlashWriteCnt_16u]];
										}
										
									}
									else 
									{
										Byte_Word=(MAX_485_RX_BUF[13+Uart0_Data.FlashWriteCnt_16u]*256+MAX_485_RX_BUF[12+Uart0_Data.FlashWriteCnt_16u])*65536+MAX_485_RX_BUF[11+Uart0_Data.FlashWriteCnt_16u]*256+MAX_485_RX_BUF[10+Uart0_Data.FlashWriteCnt_16u];
								
										WriteFlashWord(Program_Addr,Byte_Word);
										Program_Addr += 4;
										dat = (FileCRCNum >> 8); 
										FileCRCNum <<= 8;
										FileCRCNum ^= crc16tab[dat^MAX_485_RX_BUF[10+Uart0_Data.FlashWriteCnt_16u]];
										dat = (FileCRCNum >> 8); 
										FileCRCNum <<= 8;
										FileCRCNum ^= crc16tab[dat^MAX_485_RX_BUF[11+Uart0_Data.FlashWriteCnt_16u]];
										dat = (FileCRCNum >> 8); 
										FileCRCNum <<= 8;
										FileCRCNum ^= crc16tab[dat^MAX_485_RX_BUF[12+Uart0_Data.FlashWriteCnt_16u]];
										dat = (FileCRCNum >> 8); 
										FileCRCNum <<= 8;
										FileCRCNum ^= crc16tab[dat^MAX_485_RX_BUF[13+Uart0_Data.FlashWriteCnt_16u]];
									}
									
								}
								else  if(Uart0_Data.U0Data_Length==132)
								{
									Byte_Word=(MAX_485_RX_BUF[13+Uart0_Data.FlashWriteCnt_16u]*256+MAX_485_RX_BUF[12+Uart0_Data.FlashWriteCnt_16u])*65536+MAX_485_RX_BUF[11+Uart0_Data.FlashWriteCnt_16u]*256+MAX_485_RX_BUF[10+Uart0_Data.FlashWriteCnt_16u];
								
									WriteFlashWord(Program_Addr,Byte_Word);
									Program_Addr += 4;
									dat = (FileCRCNum >> 8); 
									FileCRCNum <<= 8;
									FileCRCNum ^= crc16tab[dat^MAX_485_RX_BUF[10+Uart0_Data.FlashWriteCnt_16u]];
									dat = (FileCRCNum >> 8); 
									FileCRCNum <<= 8;
									FileCRCNum ^= crc16tab[dat^MAX_485_RX_BUF[11+Uart0_Data.FlashWriteCnt_16u]];
									dat = (FileCRCNum >> 8); 
									FileCRCNum <<= 8;
									FileCRCNum ^= crc16tab[dat^MAX_485_RX_BUF[12+Uart0_Data.FlashWriteCnt_16u]];
									dat = (FileCRCNum >> 8); 
									FileCRCNum <<= 8;
									FileCRCNum ^= crc16tab[dat^MAX_485_RX_BUF[13+Uart0_Data.FlashWriteCnt_16u]];
								}
								
							}
						}
						else
						{
							Databit.Bit.WriteErrFlag =1;
						}
						if(Databit.Bit.WriteErrFlag==0)
						{
							MAX_485_TX_BUF[0]=0xa9;
							MAX_485_TX_BUF[1]=0x20;
							MAX_485_TX_BUF[2]=Slave_ID;
							MAX_485_TX_BUF[3]=0xef;
							MAX_485_TX_BUF[4]=0x00;
							MAX_485_TX_BUF[5]=0x04;
							MAX_485_TX_BUF[6]=(Uart0_Data.G_Offset_32u&0xff000000)>>24;
							MAX_485_TX_BUF[7]=(Uart0_Data.G_Offset_32u&0x00ff0000)>>16;
							MAX_485_TX_BUF[8]=(Uart0_Data.G_Offset_32u&0x0000ff00)>>8;
							MAX_485_TX_BUF[9]=(Uart0_Data.G_Offset_32u&0x000000ff)>>0;
							SendCRC_Value=crc16(&MAX_485_TX_BUF[2],8);
							MAX_485_TX_BUF[10]=SendCRC_Value%256;
							MAX_485_TX_BUF[11]=SendCRC_Value/256;
						}
						else  //错误，返回0，关闭升级
						{
							MAX_485_TX_BUF[0]=0xa9;
							MAX_485_TX_BUF[1]=0x20;
							MAX_485_TX_BUF[2]=Slave_ID;
							MAX_485_TX_BUF[3]=0xef;
							MAX_485_TX_BUF[4]=0x00;
							MAX_485_TX_BUF[5]=0x04;
							MAX_485_TX_BUF[6]=0;
							MAX_485_TX_BUF[7]=0;
							MAX_485_TX_BUF[8]=0;
							MAX_485_TX_BUF[9]=0;
							SendCRC_Value=crc16(&MAX_485_TX_BUF[2],8);
							MAX_485_TX_BUF[10]=SendCRC_Value%256;
							MAX_485_TX_BUF[11]=SendCRC_Value/256;
						}
						G_Send_Len=12;MAX_485_Send_Launch=1;
					}
					else if(MAX_485_RX_BUF[3]==0xff)
					{
						Databit.Bit.SendDataReadyFlag = 1;
						Uart0_Data.FileCRC_Num_16u= (MAX_485_RX_BUF[8]<<8)+MAX_485_RX_BUF[9];
						if(FileCRCNum==Uart0_Data.FileCRC_Num_16u)
						{
							CheckApp();
							if(AppCheckPass)
							{
								Databit.Bit.UpdataSussFlag=1;
								MAX_485_TX_BUF[0]=0xa9;
								MAX_485_TX_BUF[1]=0x20;
								MAX_485_TX_BUF[2]=Slave_ID;
								MAX_485_TX_BUF[3]=0xff;
								MAX_485_TX_BUF[4]=0x00;
								MAX_485_TX_BUF[5]=0x01;
								MAX_485_TX_BUF[6]=0;
								SendCRC_Value=crc16(&MAX_485_TX_BUF[2],5);
								MAX_485_TX_BUF[7]=SendCRC_Value%256;
								MAX_485_TX_BUF[8]=SendCRC_Value/256;
							}
							else
							{
								MAX_485_TX_BUF[0]=0xa9;
								MAX_485_TX_BUF[1]=0x20;
								MAX_485_TX_BUF[2]=Slave_ID;
								MAX_485_TX_BUF[3]=0xff;
								MAX_485_TX_BUF[4]=0x00;
								MAX_485_TX_BUF[5]=0x01;
								MAX_485_TX_BUF[6]=2;
								SendCRC_Value=crc16(&MAX_485_TX_BUF[2],5);
								MAX_485_TX_BUF[7]=SendCRC_Value%256;
								MAX_485_TX_BUF[8]=SendCRC_Value/256;
							}
							
						}
						else 
						{
							MAX_485_TX_BUF[0]=0xa9;
							MAX_485_TX_BUF[1]=0x20;
							MAX_485_TX_BUF[2]=Slave_ID;
							MAX_485_TX_BUF[3]=0xff;
							MAX_485_TX_BUF[4]=0x00;
							MAX_485_TX_BUF[5]=0x01;
							MAX_485_TX_BUF[6]=1;
							SendCRC_Value=crc16(&MAX_485_TX_BUF[2],5);
							MAX_485_TX_BUF[7]=SendCRC_Value%256;
							MAX_485_TX_BUF[8]=SendCRC_Value/256;
						}
						
						G_Send_Len=9;MAX_485_Send_Launch=1;
					}
				}
				MAX_485_Receive_Sucess = 0;
			}
			if(Databit.Bit.SendDataReadyFlag)
			{
				if(Databit.Bit.EraseFlashFlag)
				{
					Databit.Bit.EraseFlashFlag = 0;
					if(Erase_Cnt_8u < 102)		//51K=102/2
					{
						EraseFlashSector(APP_ADDR+(Erase_Cnt_8u*512)); 					//擦51K
						Erase_Cnt_8u++;
						EraseFlashSector(APP_ADDR+(Erase_Cnt_8u*512));
						Erase_Cnt_8u++;
					}
				}
				Uart0_Data.U0SendDelayTime=300;
				Databit.Bit.SendDataReadyFlag =0;
				
			}
			#endif
		}
	
}

1.1 APP程序

app程序牵扯到工程项目比较多，不方便外发，说一下具体的ota实现，正常运行程序，接收升级指令后会写升级标志位到flash，然后实现软重启至boot程序区运行。

2.c#

主要功能：串口通信，bin文件或者hex文件读取，数据重组等等，软件链接: 上位机软件下载

总结

以上是对文章的描述，希望可以帮助到需要的人，谢谢。

L_e_c
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SILan 士兰微 SC32F5664 OTA功能源码（串口IAP）
07-06
资源使用串口+IAP，配合上位机实现OTA，源码。看博客（Slan 士兰微SC32F5664 通过串口IAP，实现OTA）有文章介绍。想要了解更多，可以发私信，看到会回复。
STM32 W5500（http） 使用IAP 实现OTA空中升级
11-26
硬件是STM32+W5500 ，使用http通信协议时间iap OTA 空中升级，文档讲的比较详细，也是我见过的比较好以及比较详细的IAP讲解了。我这边顺便说说为什么要用http 通信协议，因为http通讯协议协议头里面有个body 长度字段，这样就可以采用断点续传的方式，这一点很重要。
stm32的OTA(IAP)设计
最新发布
So_shine的博客
05-19 1781
stm32f10x的ota功能
STM32 IAP升级 OTA远程升级方案及自建FTP服务器实现多App备份与切换，防止单片机变砖
yoiugCgZU的博客
04-03 1106
其中，主程序A是出厂前烧录的程序，用于升级失败后的应急使用，保证设备不变砖。本文介绍了一种基于STM32芯片的IAP和OTA升级方案，可以实现对野外设备的远程升级。通过自建FTP服务器和4G模块的应用，使得野外设备的远程升级成为可能。单片机通过4G模块远程下载服务器上的BIN文件，通过BIN文件数据自动判断程序应该烧录的flash位置进行升级，升级成功后自动跳转到新程序。无论你想要通过什么方式升级，只需要自己修改数据的接收方式，搭配我的固件处理代码，可有效保证系统稳定运行。主程序B 日常运行，可升级替换。
IAP烧写和OTA程序跳转总结
mhj258258的博客
11-27 3032
IAP没接触的时候感觉挺高大上的，还有对flash也是模模糊糊，做完IAP例程后才知道好简单，下面总结下自己遇到的几个问题，分享给大家。 1.固定法则 1）设置APP程序的起始地址和存储空间大小 分配好，bootloader的的起始地址0x08000000（M3），size的大小，然后分配好APP的起始地址，size大小，注意分配的不要去重叠两个的空间。 2）设置中断向量表的偏移量 设置SCB-&...
单Bank 串口OTA升级：STM32G071 APP (二)
dailin2012的博客
07-21 633
单Bank 串口OTA升级：STM32G071 IAP (二)
CD_SLAN_24P_8.2.2.90103.zip
10-21
【CD_SLAN_24P_8.2.2.90103.zip】是一个包含宏石SLAN分析软件的压缩包，主要用于定量聚合酶链反应（Quantitative Polymerase Chain Reaction, QPCR）的数据分析。QPCR是一种高度灵敏且准确的分子生物学技术，广泛...
slan PFC芯片
11-25
### SLAN PFC芯片知识点详解 #### 一、概述 SLAN PFC芯片，特别是型号为SA7527的芯片，是一种专为提升功率因数校正（Power Factor Correction, PFC）性能而设计的控制器。该芯片适用于升压型PFC应用，并在临界导通...
SUNIX SLAN嵌入式设备联网模块.pdf
10-22
SUNIX SLAN嵌入式设备联网模块pdf,SUNIX SLAN嵌入式设备联网模块
士兰微MCU产品资料
10-26
士兰微部分MCU的规格书，对应不同使用场景的芯片的规格书，及其手册
DS_AT32F421_V1.00.pdf
11-20
AT32F421的规格书！ 需要雅特力MCU可以站内联系我，全线产品支持。雅特力MCU可以pintopSTM32
STM32_IAP_UPDATA带C#上位机
11-26
大家好，我也是菜鸟一只，给大家分享些我自己写的东西。谢谢大家。此文档包括C#上位机（可注册，也可点击版本号直接进入）、STM32的IAP以及APP程序。大家都可以成套学习。也欢迎大家找出bug。特别感谢正点原子，STM32的程序的库大部分采用原子哥的程序。
cubeF407USB-IAP_sadmml_bootloard_STM32F407usbiap程序_
10-03
SMT32F407 BOOTLOARD USB升级程序
MPC5744P_Bootloader_CAN_上位机+下位机.rar
06-29
MPC5744P CAN Bootloader上位机源码，文章地址：https://blog.csdn.net/u010875635/article/details/85316570。可以配合下位机一同使用，下位机源码地址：https://download.csdn.net/download/u010875635/10882172
STM32 IAP升级OTA升级野外设备远程升级自建FTP服务器升级多App备份切换，防变砖
pyehzbi的博客
08-23 395
本文将为大家介绍基于STM32F103系列芯片和EC200T 4G模块实现远程升级的方案，包括IAP升级、OTA升级、自建FTP服务器升级等多种升级方式，以及防止设备变砖的保障措施。本文介绍了基于STM32F103芯片和EC200T 4G模块实现远程升级的方案，包括IAP升级、OTA升级、自建FTP服务器升级等多种升级方式，以及对设备变砖的保障措施。（3）单片机通过判断升级区域是否有数据来判断是否需要进行IAP升级，如果升级区域有数据，单片机将从该区域读取数据进行升级，升级完成后重启系统。
【genius_platform软件平台开发】第七十四讲：IAP在线升级OTA原理
随意的风的专栏
10-09 487
IAP（）即在线应用编程，也就是说用户可以使用自己的程序对单片机的user flash区域进行烧写。目的是为了在产品发布后可以方便地通过预留的通信接口对产品进行功能升级或者程序上的修复。只要保留预先的通信接口即可(USART, 网口等)，避免了要进行拆机使用下载器进行烧录。OTA升级(firmware update)是模组必备的功能，OTA升级就是通过GPRS、3G、无线网络下载升级补丁升级，不用通过有线连接来下载升级，直接通过无线环境下载、升级，比较方便。
ota升级就是iap的无线版本吗
dianqicyuyan的博客
12-14 1083
OTA是Over-the-Air的简写，即空中下载技术，通过网络远程给用户进行系统更新和升级。IAP是In Application Programming的简写，IAP是用户自己的程序在运行过程中对User Flash的部分区域进行烧写，目的是为了在产品发布后可以方便地通过预留的通信口对产品中的固件程序进行更新升级。IAP主要包括BootLoader和应用程序两部分，基于IAP的OTA设计思路是先通过OTA接收升级固件，再利用IAP进行固件搬移、校验和程序跳转，实现空中升级的目的。
CNakeFiles/ORB_SLAw3.dir/build.nake:62: recipe for target 'CNakeFiles/ORB_SLAN3.dir/src/Systen.cc.o' failed 在对orbslam3进行安装时，报错如上
05-01
这个错误提示并不够具体，可能是由多种原因引起的。以下是一些可能的解决方案： 1. 检查依赖项是否正确安装。ORB-SLAM3有很多依赖项，如Eigen、OpenCV、DBoW2、g2o等，需要确保它们都正确安装。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值