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

STM32 TCP实现OTA

作者：花生_TL007 | 2024-02-26 04:06:00

赞

踩

STM32 TCP实现OTA

芯片：stm32f407

开发平台：stm32cubeide

上位机开发平台：visual studio 2017

1. FLASH分配

将flash划分为四个部分：

        bootloader:        0x8000000-0x800ffff

        app1:                0x8010000-0x805ffff

        app2:                0x8060000-0x80affff

        parameters:      0x80e0000-0x80fffff

        其中，bootloader程序为启动程序，app1是当前运行程序，app2为准备升级程序，parameters存储程序相关参数。

2. BOOTLOADER

        在app2中用最后一段flash地址0x80dfff0来存储升级标志Upgrade_Flag，比如有新程序下载到app2中，则0x80dfff0中数据为0xaaaaaa，如果为其他则表示没有新程序，开机后bootloader首先运行，启动后检测Upgrade_Flag是否为0xaaaaaa：

        如果是，则将app2中的程序拷贝到app1中，然后重置标志位Upgrade_Flag为0xffffffff且跳转到app1起始地址0x8010000开始执行新的程序；

        如果否，则直接跳转到app1起始地址0x8010000开始运行程序；

        bootloader主要代码如下：

  1. #define IAP_ADDRESS			0x8000000		//
  2. #define APP1_ADDRESS			0x8010000		//
  3. #define APP1_ADDRESS_END		0x805FFFF		//
  4. #define APP2_ADDRESS			0x8060000		//
  5. #define APP2_ADDRESS_END		0x80AFFFF		//
  6. #define PARA_ADDRESS			0x80E0000		//
  7. #define UPGRADE_ADDRESS			0x80DFFF0		//
  8.  
  9.  
  10. pFunction Jump_To_Application;
  11. uint32_t JumpAddress;
  12.  
  13. pFunction Jump_To_Application;
  14. void Jump_To_APP()
  15. {
  16. 	uint32_t JumpAddress;
  17. 	printf("jump to app: %#x\r\n", APP1_ADDRESS);
  18. 	//HAL_DeInit();
  19. 	__disable_irq();
  20. 	if(((*(__IO uint32_t*)APP1_ADDRESS)&0x2ffe0000)==0x20020000)
  21. 	{
  22. 		/* Jump to user application */
  23. 		JumpAddress = *(__IO uint32_t*) (APP1_ADDRESS + 4);
  24. 		Jump_To_Application = (pFunction) JumpAddress;
  25. 		//printf("jump %#x success \r\n",APP1_ADDRESS);
  26.  
  27. 		/* Initialize user application's Stack Pointer */
  28. 		  __set_MSP(*(__IO uint32_t*) APP1_ADDRESS);
  29. 		  Jump_To_Application();
  30. 	}
  31. 	else
  32. 	{
  33. 		printf("error [0x%08x]\r\n",(*(volatile uint32_t*)APP1_ADDRESS));
  34. 	}
  35. }
  36. uint8_t u8_Code_Buff[2048];//2k
  37. uint16_t Num=0;
  38. uint8_t NotUpgrade[4]={0xff,0xff,0xff,0xff};
  39. uint8_t Upgrade[4]={0xaa,0xaa,0xaa,0xaa};
  40. uint32_t Upgrade_Flag;
  41.  
  42. void Copy_APP2_to_APP1(void)
  43. {
  44.  
  45. 	if(((*(__IO uint32_t*)APP2_ADDRESS)&0x2ffe0000)!=0x20020000)
  46. 	{
  47. 		printf("invalid app in address [0x%08x]\r\n",APP2_ADDRESS);
  48. 		return;
  49. 	}
  50. 	MEM_IF_IniT();
  51. 	uint32_t APP1_Addr;
  52. 	uint32_t APP2_Addr;
  53. 	APP1_Addr=APP1_ADDRESS;
  54. 	APP2_Addr=APP2_ADDRESS;
  55. 	MEM_If_Erase(APP1_ADDRESS,APP1_ADDRESS_END);
  56. 	printf("Erase app1 flash\r\n");
  57. 	for(int i=0;i<150;i++)//copy 150*2k=300k, max size of app is 300k
  58. 	{
  59. 		printf("APP1_Addr = %x\r\n",APP1_Addr);
  60. 		printf("APP2_Addr = %x\r\n",APP2_Addr);
  61. 		MEM_If_Read(u8_Code_Buff,APP2_Addr,2048);
  62. 		HAL_Delay(10);
  63. 		MEM_If_Write_Byte(u8_Code_Buff,APP1_Addr,2048);
  64. 		HAL_Delay(10);
  65. 		APP1_Addr+=0x800;
  66. 		APP2_Addr+=0x800;
  67. 		memset(u8_Code_Buff,0,sizeof(u8_Code_Buff));
  68. 		Num=i;
  69. 		if(1)
  70. 		{
  71. 			printf("Successfully copied page %d\r\n",Num);
  72. 		}
  73. 		else
  74. 		{
  75. 			printf("Copy failed page %d\r\n",Num);
  76. 		}
  77.  
  78. 	}
  79. 	MEM_If_Erase(UPGRADE_ADDRESS,UPGRADE_ADDRESS);
  80. 	MEM_If_Write_Byte(NotUpgrade,UPGRADE_ADDRESS,sizeof(NotUpgrade));
  81. 	MEM_IF_DeInit();
  82. }
  83.  
  84. int main(void)
  85. {
  86.   /* USER CODE BEGIN 1 */
  87. 	
  88. 	//SCB->VTOR = FLASH_BASE | 0x40000;
  89.  
  90.   /* USER CODE END 1 */
  91.  
  92.   /* MCU Configuration--------------------------------------------------------*/
  93.  
  94.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  95.   HAL_Init();
  96.  
  97.   /* USER CODE BEGIN Init */
  98.   /* USER CODE END Init */
  99.  
  100.   /* Configure the system clock */
  101.   SystemClock_Config();
  102.  
  103.   /* USER CODE BEGIN SysInit */
  104.  
  105.   /* USER CODE END SysInit */
  106.  
  107.   /* Initialize all configured peripherals */
  108.   MX_GPIO_Init();
  109.   MX_USART1_UART_Init();
  110.   /* USER CODE BEGIN 2 */
  111.   printf("\r\n");
  112.   printf("*****************************************\r\n");
  113.   printf("*         luckyzjian's ISP              *\r\n");
  114.   printf("*                                       *\r\n");
  115.   printf("*          www.cdxcjc.com               *\r\n");
  116.   printf("*                                       *\r\n");
  117.   printf("*       Version: v%d.%d.%d            *\r\n",version_board,version_year,version_no);
  118.   printf("*                                       *\r\n");
  119.   printf("*           026-82598116                *\r\n");
  120.   printf("*****************************************\r\n");
  121.   printf("************ flash table  ***************\r\n");
  122.   printf("*bootloader  : %#x -------- %#x******\r\n",IAP_ADDRESS,APP1_ADDRESS-1);
  123.   printf("*APP1        : %#x -------- %#x******\r\n",APP1_ADDRESS,APP1_ADDRESS_END);
  124.   printf("*APP2        : %#x -------- %#x******\r\n",APP2_ADDRESS,APP2_ADDRESS_END);
  125.   printf("*PRIVATE PARA: %#x -------- %#x******\r\n",PARA_ADDRESS,PARA_ADDRESS+0X1FFFF);
  126.   printf("*****************************************\r\n");
  127.  
  128.  
  129. 	TM1629_init();
  130. 	Upgrade_Flag=*(__IO uint32_t*)(UPGRADE_ADDRESS);
  131. 	printf("Upgrade_Flag = 0x%x\r\n",Upgrade_Flag);
  132.  
  133. 	if(0xaaaaaaaa==Upgrade_Flag)
  134. 	{
  135. 		printf("there is new app in address: %x\r\n",APP2_ADDRESS);
  136. 		printf("copy new app in address: %x to address: %x\r\n",APP2_ADDRESS,APP1_ADDRESS);
  137. 		TM1629_printRow1("-----",ShowType_Right);
  138. 		TM1629_printRow2("-ISP-",ShowType_Right);
  139. 		TM1629_DISPLAY();
  140. 		Copy_APP2_to_APP1();
  141. 		printf("copy finished\r\n",APP2_ADDRESS,APP1_ADDRESS);
  142. 		printf("------%#x\r\n",(APP1_ADDRESS+4)&0XFF000000);
  143. 		if(((APP1_ADDRESS+4)&0xff000000)==0x08000000)
  144. 		{
  145. 			printf("jump APP1 running");
  146. 			Jump_To_APP(APP1_ADDRESS);
  147. 		}
  148. 	}
  149. 	else
  150. 	{
  151. 		printf("there is no new app in address: %x\r\n",APP2_ADDRESS);
  152. 		printf("------%#x\r\n",(APP1_ADDRESS+4)&0xff000000);
  153. 		if(((APP1_ADDRESS+4)&0xff000000)==0x08000000)
  154. 		{
  155. 			printf("jump APP1 running\r\n");
  156. 			Jump_To_APP(APP1_ADDRESS);
  157. 		}
  158. 	}
  159. 	
  160. 	
  161.   /* USER CODE END 2 */
  162.  
  163.   /* Infinite loop */
  164.   /* USER CODE BEGIN WHILE */
  165. 	while (1)
  166. 	{
  167.     /* USER CODE END WHILE */
  168.  
  169.     /* USER CODE BEGIN 3 */
  170. 	}
  171.  
  172.   /* USER CODE END 3 */
  173. }

3. APP

APP程序因为是从0x08010000开始运行的，要注意修改如下两个地方

  1. /Core/Src/system_stm32f4xx.c中：
  2.  
  3. #define VECT_TAB_OFFSET         0x00010000U     /*!< Vector Table base offset field.
  4.                                                      This value must be a multiple of 0x200. */
  5.  
  6. STM32F407ZGTX_FLASH.ld:
  7.  
  8. MEMORY
  9. {
  10.   CCMRAM    (xrw)    : ORIGIN = 0x10000000,   LENGTH = 64K
  11.   RAM    (xrw)    : ORIGIN = 0x20000000,   LENGTH = 128K
  12.   FLASH    (rx)    : ORIGIN = 0x8010000,   LENGTH = 320K
  13. }

程序通过TCP下载，因为我项目中已经有一套TCP的通讯接口，为了方便，便在原来的自定义接口协议中增加了下载程序的协议

通讯格式定义如下：

发送：
0x02起始码1
ADD地址1控制仪地址 0X80~0X8F 代表0~15号地址
CMD命令字节1
LB数据[DF]长度1
[DF]数据LB
CS校验码1=NOT(0x02+ADD+CMD+LB+[DF])+1
0X03结束码1
响应：
0x06起始码1
ADD地址1控制仪地址 0X80~0X8F 代表0~15号地址
CMD命令字节1
LB数据[DF]长度1
[DF]数据LB
CS校验码1=NOT(0x06+ADD+CMD+LB+[DF])+1
0X03结束码1

涉及下载的命令定义如下：

命令命令代码命令格式响应说明
开始下载固件0x510x02 ADD 0x51 0x02 [分包数量] CS  0x030x06 ADD 0x51  0x01 <STATUS> CS 0x03[分包数量]，固件数据包按1000字节一个包进行分包，最后一包不足1000字节时，用0x00填充到1000字节，将总的分包数量在开始升级固件指令时写入
返回STATUS:
0X06 成功；
0x15 失败
写入固件0x520x02 ADD 0x52 [分包顺序][数据长度]{数据} CS 0x030x02 ADD 0x52 0x03 [分包顺序] <STATUS> CS 0x03[分包顺序][数据长度]《数据》三部分固定长度为1004个字节，其中：
[分包顺序]为两字节，代表该帧数据为整个固件包的第几包数据，从0开始计数；
[数据长度]为两字节，代表该包数据字节长度，应固定为1000字节；
《数据》为固件内容，当最后一包不足1000字节时，用0x00填充到1000字节
返回STATUS:
0X06 成功；
0x15 失败；
写入固件结束0x530x02 ADD 0x53 0x02 <CRCH>  <CRCL> CS 0x030x06 ADD 0x53 0x01 <STATUS> CS 0x03CRCH,CHRL组成固件全部数据的CRC16校验，下位机收到结束指令后，对整包数据进行CRC16校验，与该指令CRC校准字比对，如果比对成功，则标记为升级成功(向地址0x80DFFF0写入0xaaaaaa)
返回STATUS:
0X06 升级成功；
0x15 升级失败；
放弃写入固件0x5f0x02 ADD 0x5f 0x00 CS 0x030x06 ADD 0x5f 0x00 CS 0x03
  1.  
  2. #define CLIENTMAX 5
  3. typedef struct
  4. {
  5. 	struct netconn *conn;
  6. 	uint8_t num;
  7. }tcp_client;
  8. typedef struct{
  9. 	struct netconn *client[CLIENTMAX+2];
  10. 	uint8_t state[CLIENTMAX+2];
  11. 	osThreadId client_taskid[CLIENTMAX+2];
  12. 	Controller_StatusDef realdatastatus[CLIENTMAX+2];
  13. }client_ad;
  14. client_ad clientad;
  15.  
  16.  
  17. uint8_t isIAPStart=0;
  18. uint16_t IAP_frameTotalCount=0;
  19. uint16_t IAP_frameCount=0;
  20. uint16_t IAP_frameSeq=0;
  21. uint16_t IAP_frameLength=0;
  22. uint16_t IAP_frameCRC=0x0000;
  23. uint8_t isIAPFinish=0;
  24. uint8_t isIAPSuccess=0;
  25.  
  26. uint8_t NotUpgrade[4]={0xff,0xff,0xff,0xff};
  27. uint8_t Upgrade[4]={0xaa,0xaa,0xaa,0xaa};
  28.  
  29. void svr_task(void const *arg);
  30. void processCmd(Controller_AckDataDef frame,Controller_AckDataDef* ackframe,uint8_t clientindex);
  31. osThreadDef(myTaskClient, tcp_server_thread, osPriorityNormal, CLIENTMAX, 1400);
  32.  
  33. void MX_FREERTOS_Init(void) {
  34.   
  35.   osThreadDef(defaultTask, StartDefaultTask, osPriorityNormal, 0, 1024);
  36.   defaultTaskHandle = osThreadCreate(osThread(defaultTask), NULL);
  37.  
  38.   osThreadDef(tcpmultiTask, svr_task, osPriorityNormal, 0, 1024);
  39.   osThreadCreate(osThread(tcpmultiTask), NULL);
  40.   clientad.state[CLIENTMAX]=1;
  41.   clientad.realdatastatus[CLIENTMAX]=RealPass_Stop;
  42.   comackframe.originaldata_data=comackdata;	
  43.   isCOMHasACK=0;
  44. 	
  45.  
  46. }
  47. err_t client_init(void *arg,uint8_t* clientnumindex)
  48. {
  49. 	uint8_t          clientnum;                             //?????? TCP client ????
  50. 	err_t          err;                             //????(UCOSIII)
  51. 	uint8_t ifreceiveclient=0;
  52. 	for(clientnum=0;clientnum<CLIENTMAX;clientnum++)   //???????????(????20????)
  53. 	{
  54. 		if(clientad.state[clientnum]==0)                 //???? clientnum ?????????0(???)
  55. 		{			
  56. 			
  57. 			ifreceiveclient=1;
  58. 			break;                                         //???? ????  ????????
  59. 		}
  60. 	}		
  61. 	if(ifreceiveclient==0)
  62. 	{
  63. 		UsrLog("This no space to accept client");
  64. 		return 1;
  65. 	}
  66. 	*clientnumindex=clientnum;
  67. 	return ERR_OK;                                     //??????
  68. }
  69.  
  70. void svr_task(void const *arg)
  71. {
  72. 	err_t         oserr;                       
  73. 	struct netconn *conn,*newconn;             
  74. 	while(!isLWIPInitSuccess)
  75. 		osDelay(100);
  76.  
  77.  
  78. 	for(int i=0;i<CLIENTMAX;i++)   
  79. 	{
  80. 		clientad.state[i]=0;
  81. 		clientad.realdatastatus[i]=RealPass_Stop;
  82. 		//clientad.iapstatus[i]=IAPStatus_app;
  83. 	}	
  84. 	conn = netconn_new(NETCONN_TCP);            
  85. 	netconn_bind(conn,IP_ADDR_ANY,sysParameterStruct._Para_ControlIP_PORT); 
  86. 	netconn_listen(conn);  		                
  87. 	sprintf((char*)iptxt, "%d", sysParameterStruct._Para_ControlIP_PORT);  
  88. 	UsrLog("tcp start listen on port: %s",iptxt);
  89.  
  90. 	while(1)
  91. 	{
  92. 			uint8_t clientnumindex=0;
  93. 			//if(get_clientindex(&clientnumindex) != ERR_OK)
  94. 			//	osDelay(100);				
  95. 			if(netconn_accept(conn,&newconn) == ERR_OK) 
  96. 			{		
  97. 				if(client_init((void *)newconn,&clientnumindex) != ERR_OK)
  98. 				{                                         
  99. 					netconn_close(newconn);                 
  100. 					netconn_delete(newconn);                
  101. 				}
  102. 				else
  103. 				{
  104. 					
  105. 					clientad.client[clientnumindex]=newconn;             			
  106. 					clientad.state[clientnumindex]=1;                       
  107. 					clientad.client_taskid[clientnumindex] = osThreadCreate(osThread(myTaskClient),  (void *)clientnumindex);
  108. 					osDelay(100);
  109. 					if(clientad.client_taskid[clientnumindex]==NULL)
  110. 					{
  111. 						UsrLog("Failed to create the recv thread with id: %d",clientnumindex);
  112. 					}
  113. 					else
  114. 					{
  115. 						UsrLog("create the recv thread with id: %x",(int)(clientad.client_taskid[clientnumindex]));
  116. 					}
  117. 					
  118. 				}
  119. 			}
  120. 			osDelay(100);
  121. 	}
  122. }
  123. void tcp_server_thread(void const *arg)
  124. {
  125. 	err_t err;
  126. 	struct netbuf *clientrecvbuf;
  127. 	Controller_AckDataDef recvframe;
  128. 	Controller_AckDataDef ackframe;
  129. 	uint8_t recvdata[40];
  130. 	uint8_t ackdata[80];
  131. 	/*recv tcp data buf*/
  132. 	ackframe.originaldata_head=0x06;
  133. 	ackframe.originaldata_address=sysParameterStruct._Para_ControlEquiAddress;
  134. 	ackframe.originaldata_end=0x03;
  135. 	ackframe.originaldata_data=ackdata;
  136. 	ip_addr_t addr; u16_t port;
  137. 	uint8_t *app_flash_buf;
  138. 	/* get remote IP address and port*/
  139. 	uint8_t clientindex=(uint8_t)arg;	
  140. 	if((err=netconn_getaddr(clientad.client[clientindex],&addr, &port, 0))==ERR_OK)
  141. 	{
  142. 		sprintf((char*)iptxt, "%d.%d.%d.%d:%d", (uint8_t)(addr.addr),(uint8_t)(addr.addr>>8),(uint8_t)(addr.addr>>16),(uint8_t)(addr.addr>>24),port);  
  143. 		UsrLog("one client is connected:%s",iptxt);
  144. 	}
  145. 	uint8_t *data;
  146. 	u16_t len;
  147. 	while(1)
  148. 	{		
  149. 		if((err=netconn_recv(clientad.client[clientindex],&clientrecvbuf))==ERR_OK)
  150. 		{
  151. 			do{
  152. 				netbuf_data(clientrecvbuf,&data,&len);
  153. 				//printf("recevie one frame: length=%d, data=0x%x--0x%x\r\n",len,data[0],data[len-1]);
  154. 				if(len>=6)
  155. 				{
  156. 					if(data[0]==0x02&&data[len-1]==0x03)
  157. 					{
  158. 						recvframe.originaldata_head=data[0];
  159. 						recvframe.originaldata_address=data[1];
  160. 						recvframe.originaldata_cmd=data[2];
  161. 						if(recvframe.originaldata_cmd==0x52)//app upload data frame:0x02 add 0x52 [frame seq] [frame len] {app data} cs 0x03
  162. 						{
  163. 							IAP_frameSeq=(uint16_t)((data[3]<<8)|data[4]);
  164. 							IAP_frameLength=(uint16_t)((data[5]<<8)|data[6]);
  165. 							app_flash_buf=data+7;
  166. 							printf("recevie one frame data: frame seq=%d, frame data length=%d\r\n",IAP_frameSeq,IAP_frameLength);
  167. 							uint8_t frameRight=1;
  168. 							if(isIAPStart)
  169. 							{
  170. 								if(IAP_frameSeq==IAP_frameCount&&IAP_frameSeq<IAP_frameTotalCount)
  171. 								{
  172. 									if(IAP_frameLength!=500)
  173. 									{
  174. 										printf("wrong frame length(%d), length should be 1000\r\n",IAP_frameLength);
  175. 										frameRight=0;
  176. 									}
  177. 									if(frameRight)
  178. 									{
  179. 										printf("valid frame data\r\n");
  180. 										uint32_t flashdestination=APP2_ADDRESS+500*IAP_frameSeq;
  181. 										MEM_IF_IniT();
  182. 										if (MEM_If_Write_Word(app_flash_buf,flashdestination,IAP_frameLength)  == HAL_OK)
  183. 										{
  184. 											printf("write frame data seq(%d)(data:0x%x..) to flash(addr:0x%08x) success\r\n",IAP_frameSeq,*app_flash_buf,flashdestination);
  185. 											IAP_frameCount++;
  186. 										}
  187. 										else /* An error occurred while writing to Flash memory */
  188. 										{
  189. 											printf("write frame data seq(%d) to flash fail\r\n",IAP_frameSeq);
  190. 					                    	frameRight=0;
  191. 										}
  192. 										MEM_IF_DeInit();
  193. 									}
  194. 								}
  195. 								else
  196. 								{
  197. 									frameRight=0;
  198. 								}
  199.  
  200. 							}
  201. 							else
  202. 							{
  203. 								frameRight=0;
  204. 							}
  205. 							if(!frameRight)
  206. 							{
  207. 								printf("invalid frame data or process data fail\r\n");
  208. 							}
  209. 							uint8_t realdatalength=0;
  210. 							ackframe.originaldata_head=0x06;
  211. 							ackframe.originaldata_address=sysParameterStruct._Para_ControlEquiAddress;
  212. 							ackframe.originaldata_end=0x03;
  213. 							ackframe.originaldata_cmd=recvframe.originaldata_cmd;
  214. 							*(ackframe.originaldata_data+realdatalength)=IAP_frameSeq>>8;
  215. 							realdatalength++;
  216. 							*(ackframe.originaldata_data+realdatalength)=IAP_frameSeq;
  217. 							realdatalength++;
  218. 							*(ackframe.originaldata_data+realdatalength)=frameRight?0x06:0x15;
  219. 							realdatalength++;
  220. 							ackframe.originaldata_length=realdatalength;
  221. 							netconn_ack(&ackframe,clientad.client[clientindex]);
  222.  
  223. 						}
  224. 						else
  225. 						{
  226. 							recvframe.originaldata_length=data[3];
  227. 							recvframe.originaldata_cs=data[len-2];
  228. 							recvframe.originaldata_end=data[len-1];
  229. 							if(recvframe.originaldata_length+6==len)
  230. 							{
  231. 								for(int i=0;i<recvframe.originaldata_length;i++)
  232. 								{
  233. 									recvdata[i]=data[4+i];
  234. 								}
  235. 								recvframe.originaldata_data=recvdata;
  236. 								processCmd(recvframe,&ackframe,clientindex);
  237. 								netconn_ack(&ackframe,clientad.client[clientindex]);
  238. 								continue;
  239. 							}
  240. 						}
  241. 					}
  242. 				}
  243. 				ackframe.originaldata_cmd=0xf3;
  244. 				ackframe.originaldata_length=0;
  245. 				netconn_ack(&ackframe,clientad.client[clientindex]);				
  246. 			}
  247. 			while(netbuf_next(clientrecvbuf)>=0);
  248. 			netbuf_delete(clientrecvbuf);
  249. 		}
  250. 		else if(err==ERR_CLSD||err==ERR_RST)
  251. 			break;	
  252. 	}
  253. 	if(clientad.state[clientindex]==1)
  254. 	{
  255. 		if((err=netconn_getaddr(clientad.client[clientindex],&addr, &port, 0))==ERR_OK)
  256. 		{
  257. 			sprintf((char*)iptxt, "%d.%d.%d.%d:%d", (uint8_t)(addr.addr),(uint8_t)(addr.addr>>8),(uint8_t)(addr.addr>>16),(uint8_t)(addr.addr>>24),port);  
  258. 			UsrLog("one ramote is closed:%s",iptxt); 
  259. 		}
  260. 		clientad.state[clientindex]=0;
  261. 		netconn_close(clientad.client[clientindex]);
  262. 		netconn_delete(clientad.client[clientindex]);			
  263. 		vTaskDelete(clientad.client_taskid[clientindex]);
  264. 	}
  265. }
  266.  
  267. void processCmd(Controller_AckDataDef frame,Controller_AckDataDef* ackframe,uint8_t clientindex)
  268. {
  269. 	//Controller_AckDataDef ackframe;
  270. 	ackframe->originaldata_head=0x06;
  271. 	ackframe->originaldata_address=sysParameterStruct._Para_ControlEquiAddress;
  272. 	ackframe->originaldata_end=0x03;
  273. 	ackframe->originaldata_cmd=frame.originaldata_cmd;
  274. 	ackframe->originaldata_length=0;
  275. 	uint8_t *databuf=ackframe->originaldata_data;
  276. 	uint8_t realdatalength=0;
  277. 	switch(frame.originaldata_cmd)
  278. 	{
  279. 	case 0x51://start download app
  280. 		printf("start download app\r\n");
  281. 		IAP_frameTotalCount=(uint16_t)(frame.originaldata_data[0] << 8 | frame.originaldata_data[1]);
  282. 		printf("app frames total count is %d\r\n",IAP_frameTotalCount);
  283. 		MEM_IF_IniT();
  284. 		if(MEM_If_Erase(APP2_ADDRESS,APP2_ADDRESS_END)!=HAL_OK)
  285. 		{
  286. 			printf("erase flash fail, abort app downloading\r\n");
  287. 			isIAPStart=false;
  288. 			*(databuf+realdatalength)=0x15;
  289. 			realdatalength++;
  290. 			ackframe->originaldata_length=realdatalength;
  291. 		}
  292. 		else
  293. 		{
  294. 			printf("erase flash from %#x to %#x, wait for frame transmitting\r\n",APP2_ADDRESS,APP2_ADDRESS_END);
  295. 			IAP_frameCount=0;
  296. 			isIAPStart=true;
  297. 			*(databuf+realdatalength)=0x06;
  298. 			realdatalength++;
  299. 			ackframe->originaldata_length=realdatalength;
  300. 		}
  301. 		MEM_IF_DeInit();
  302. 		break;
  303. 	case 0x53://finish download app
  304. 		printf("finish download app\r\n");
  305. 		uint16_t IAP_crc16=(uint16_t)(frame.originaldata_data[0] << 8 | frame.originaldata_data[1]);
  306. 		printf("receive app crc16 is %x\r\n",IAP_crc16);
  307.  
  308. 		if(1)//(IAP_crc16==IAP_frameCRC)
  309. 		{
  310. 			printf("pass crc check, finish download app\r\n");
  311. 			MEM_IF_IniT();
  312. 			MEM_If_Erase(UPGRADE_ADDRESS,UPGRADE_ADDRESS);
  313. 			MEM_If_Write_Byte(Upgrade,UPGRADE_ADDRESS,sizeof(Upgrade));
  314. 			MEM_IF_DeInit();
  315.  
  316. 			*(databuf+realdatalength)=0x06;
  317. 			realdatalength++;
  318. 			ackframe->originaldata_length=realdatalength;
  319. 			isIAPStart=false;
  320. 		}
  321. 		else
  322. 		{
  323. 			printf("crc check fail, finish download app\r\n");
  324. 			*(databuf+realdatalength)=0x15;
  325. 			realdatalength++;
  326. 			ackframe->originaldata_length=realdatalength;
  327. 			isIAPStart=false;
  328. 		}
  329. 		break;
  330. 	case 0x5f:
  331. 		printf("receive abort download app command\r\n");
  332. 		isIAPStart=false;
  333. 		IAP_frameCount=0;
  334. 		break;
  335.     /*
  336. other cmd process...
  337.     */
  338.     default:break;
  339.     }
  340. }

3. 上位机实现升级工具（C# winform）

    

 4. 实现效果

升级工具通过TCP与板卡进行通讯，之前版本是V20.2024.3

打开升级程序包bin文件

点击下载

开始下载，显示整片程序被分成399个包

下载完成，提示重启板卡完成升级

重启后，开始将程序从APP2拷贝到APP1

拷贝完成，跳转到APP1运行，程序已经更新成V20.2024.4

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

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

  

闽ICP备14008679号