devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

STM32F4 Boot升级例程_stm32刷boot

作者：菜鸟追梦旅行 | 2024-04-24 03:10:24

赞

踩

stm32刷boot

本文重点介绍代码实现，不介绍工程配置。

1.串口需要开启DMA接收数据，normal模式

 2.修改串口中断，

  1. /* USER CODE BEGIN 0 */
  2. __weak void uart_user_handle(void)
  3. {
  4.  
  5. }
  6. /* USER CODE END 0 */
  7.  
  8. void USART3_IRQHandler(void)
  9. {
  10.   /* USER CODE BEGIN USART3_IRQn 0 */
  11.  
  12.   /* USER CODE END USART3_IRQn 0 */
  13.   HAL_UART_IRQHandler(&huart3);
  14.   /* USER CODE BEGIN USART3_IRQn 1 */
  15.   if(0 != __HAL_UART_GET_FLAG(&huart3, UART_FLAG_IDLE))
  16.   {
  17. 	  __HAL_UART_CLEAR_IDLEFLAG(&huart3);
  18. 	  uart_user_handle();
  19.   }
  20.   /* USER CODE END USART3_IRQn 1 */
  21. }

3.创建串口操作源文件 uart.c

  1. /**
  2.  * @brief 串口应用层接口
  3.  * @author lj
  4.  * @date 2022/09/16
  5.  *
  6.  * ---------------------------------
  7.  */
  9. #include "uart.h"
  10. #include "usart.h"
  11. #include "stm32f4xx.h"
  12. #include "common/ringbuffer.h"
  13.  
  14. /* 串口接收最大 */
  15. #define RS485_RECV_MAX_SIZE		1024
  16.  
  17. #define UART_ASSERT(x) { \
  18. 	if (!(x))	\
  19. 	return 0;		\
  20. }
  21.  
  22. #pragma pack(1)
  23.  
  24. typedef struct {
  25. 	uint16_t size;		// 缓冲区大小
  26. 	uint8_t buf[0];		// 动态缓冲区
  27. }uart_fifo_t;
  28.  
  29. #pragma pack()
  30.  
  31. /**
  32.  * @brief 串口设备信息
  33.  */
  34. typedef struct {
  35. 	UART_HandleTypeDef *huart;	// 串口设备句柄
  36. 	uart_fifo_t *fifo;			// 串口缓冲接收缓冲区
  37. 	T_RingBuffer ring;			// 环形队列，用于数据存取
  38. 	uint16_t recv_cnt;			// 接收次数
  39. }Uart_info_t;
  40.  
  41.  
  42. // 串口缓冲区
  43. static uint8_t uart3_buf[sizeof(uart_fifo_t) + RS485_RECV_MAX_SIZE] = {0};
  44. // 串口DMA缓冲区
  45. static uint8_t uart3_dma_buf[RS485_RECV_MAX_SIZE] = {0};
  46. // 串口DMA句柄
  47. extern DMA_HandleTypeDef hdma_usart3_rx;
  48. // 串口设备
  49. static Uart_info_t g_uart_device = {0};
  50. //static uint8_t *uart3_p = uart3_buf;
  51.  
  52. /**
  53.  * @brief RS485串口初始化
  54.  * @param None
  55.  * @retval None
  56.  */
  57. void uart_init(void)
  58. {
  59. 	// 串口3初始化
  60. 	g_uart_device.huart = &huart3;
  61. 	g_uart_device.fifo = (uart_fifo_t *)uart3_buf;
  62. 	g_uart_device.fifo->size = RS485_RECV_MAX_SIZE;
  63. 	g_uart_device.recv_cnt = 0;
  64.  
  65. 	// 初始化环形队列
  66. 	ringbuf_init(&g_uart_device.ring, g_uart_device.fifo->buf, g_uart_device.fifo->size);
  67. 	//使能IDLE中断
  68. 	__HAL_UART_ENABLE_IT(g_uart_device.huart, UART_IT_IDLE);
  69. 	// 开启dma接收
  70. 	HAL_UART_Receive_DMA(g_uart_device.huart, uart3_dma_buf, RS485_RECV_MAX_SIZE);
  71. }
  72.  
  73. /**
  74.  * @brief 串口写
  75.  * @param buf:待发送数据
  76.  * @param len:待发送数据长度
  77.  * @retval 发送数据长度
  78.  */
  79. uint16_t uart_write(uint8_t *buf, uint16_t len)
  80. {
  81. 	UART_ASSERT(buf != NULL);
  82. 	UART_ASSERT(len != 0);
  83. 	UART_ASSERT(g_uart_device.huart != NULL);
  84.  
  85. 	HAL_GPIO_WritePin(GPIOG,GPIO_PIN_2,GPIO_PIN_SET);
  86. 	HAL_UART_Transmit(g_uart_device.huart, buf, len, 0xff);
  87. 	HAL_GPIO_WritePin(GPIOG,GPIO_PIN_2,GPIO_PIN_RESET);
  88.  
  89. 	return len;
  90. }
  91.  
  92. /**
  93.  * @brief 串口读
  94.  * @param buf:读取数据buf
  95.  * @param len:读取数据buf长度
  96.  * @retval 读取数据长度
  97.  */
  98. uint16_t uart_read(uint8_t *buf, uint16_t len)
  99. {
  100. 	uint16_t length = 0;
  101.  
  102. 	UART_ASSERT(buf != NULL);
  103. 	UART_ASSERT(len != 0);
  104. 	UART_ASSERT(g_uart_device.huart != NULL);
  105.  
  106. 	__disable_irq(); // 防止数据读取时进入中断导致fifo数据被更改
  107. 	length = ringbuf_get(&g_uart_device.ring, buf, len);
  108. 	__enable_irq();
  109.  
  110. 	return length;
  111. }
  112.  
  113. /**
  114.  * @brief 读取串口接收次数
  115.  * @param None
  116.  * @retval 串口接收次数
  117.  */
  118. uint16_t get_uart_recv_cnt(void)
  119. {
  120. 	return g_uart_device.recv_cnt;
  121. }
  122.  
  123. /**
  124.  * @brief 串口中断DMA保存数据
  125.  * @param None
  126.  * @retval None
  127.  */
  128. void uart_user_handle(void)
  129. {
  130. 	uint16_t rec_len = 0;
  131.  
  132. 	// 停止DMA
  133. 	HAL_UART_DMAStop(g_uart_device.huart);
  134. 	// 获取数据长度
  135. 	rec_len = (RS485_RECV_MAX_SIZE - __HAL_DMA_GET_COUNTER(&hdma_usart3_rx));
  136. 	if (0 == rec_len)
  137. 		return;
  138.  
  139. 	// 将数据放到fifo中
  140. 	__disable_irq();
  141. 	ringbuf_put(&g_uart_device.ring, uart3_dma_buf, rec_len);
  142. 	g_uart_device.recv_cnt++;
  143. 	__enable_irq();
  144. 	// 重新开启dma
  145. 	HAL_UART_Receive_DMA(g_uart_device.huart, uart3_dma_buf, RS485_RECV_MAX_SIZE);  //重新打开DMA接收
  146. }
  147.  
  148.  
  149. /**
  150.  * @brief 串口中断异常处理，清除ORE标志并重启中断
  151.  */
  152. void HAL_UART_ErrorCallback (UART_HandleTypeDef *huart)
  153. {
  154. 	__attribute((unused)) uint32_t data = 0;
  155.     __HAL_UNLOCK(huart);
  156.  
  157. 	if(__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET)
  158. 	{
  159. 		__HAL_UART_CLEAR_FLAG(huart, UART_FLAG_ORE);      		//清除溢出中断
  160. 		data = huart->Instance->SR;
  161. 		data = huart->Instance->DR;
  162. 		__HAL_UART_ENABLE_IT(huart, UART_IT_IDLE);
  163. 	}
  164. }
  165.

4.创建升级主文件 boot.c

  1.  
  2.  * boot.c
  3.  *
  4.  *  Created on: 2022年10月22日
  5.  *      Author: lj
  6.  */
  8. #include "boot.h"
  9. #include "uart.h"
  10. #include "flash.h"
  11. #include "common/crc.h"
  12.  
  13. #include <stdlib.h>
  14. #include <string.h>
  15.  
  16. #ifdef STM32F407xx
  17. #include "stm32f4xx_hal.h"
  18. #endif
  19.  
  20. typedef void (*jump_func)(void);
  21.  
  22. // 每一包数据大小
  23. #define SEND_SIZE_PER_SEND	256
  24. // 最大数据长度 = 每一包数据大小+1字节类型+2字节长度+除帧数据外的字节数
  25. #define BUF_MAX_LENGTH (SEND_SIZE_PER_SEND+3+7)
  26. // 最大读取长度
  27. #define BUF_MAX_READ_LEN	1024
  28. // 接收最小字节数 (3字节头+2字节数据长度+1字节命令字+1字节校验和)
  29. #define RECV_BYTES_MIN	7
  30. // 软件版本
  31. #define VERSION_INFO(main,sub,modify)	(((main) << 24) | ((sub) << 16) | ((modify) << 8))
  32. #define BOOT_VERSION	VERSION_INFO(1, 0, 0)
  33.  
  34.  
  35. //------------------flash操作状态---------------
  36. #define UPDATE_ACK_STATE_CHECK_ERROR 0x01 // 校验错误
  37. #define UPDATE_ACK_STATE_WRITE_RIGHT 0x02 // FLASH写入正确
  38. #define UPDATE_ACK_STATE_WRITE_ERROR 0x03 // FLASH写入错误
  39. #define UPDATE_ACK_STATE_ERASEING    0x04 // FLASH擦除中
  40. #define UPDATE_ACK_STATE_ERASE_DONE  0x05 // FLASH擦除完毕
  41.  
  42. // 返回升级boot命令字
  43. #define CMD_ACK_BOOTLOADER	0xE0
  44. // 返回升级app命令字
  45. #define CMD_ACK_APP			0xE1
  46. // 返回升级错误命令字
  47. #define CMD_ACK_ERR			0xE2
  48. // 升级过程中升级内容为boot
  49. #define CMD_UPDATE_BOOT		0xBC
  50. // 升级过程中升级内容为app
  51. #define CMD_UPDATE_APP		0xBD
  52.  
  53. /**
  54.  * @brief 接收一帧完成
  55.  */
  56. typedef enum
  57. {
  58. 	BOOT_NO,
  59. 	BOOT_YES
  60. }boot_recv_e;
  61.  
  62. /**
  63.  * @brief 升级过程中状态
  64.  */
  65. typedef enum
  66. {
  67. 	CMD_UPDATE_READY = 0xE0,
  68. 	CMD_UPDATE_FILE = 0xF0,
  69. 	CMD_UPDATE_FINISH = 0xFF
  70. }boot_update_e;
  71.  
  72. /**
  73.  * @brief 升级类型
  74.  */
  75. typedef enum
  76. {
  77. 	BOOT_TYPE_NONE,
  78. 	BOOT_TYPE_BOOTLOADER,
  79. 	BOOT_TYPE_APP
  80. }boot_type_e;
  81.  
  82. /**
  83.  * @brief 升级状态机
  84.  */
  85. typedef enum
  86. {
  87. 	BOOT_STATE_HEAD0,	// 接收帧头第一个字节
  88. 	BOOT_STATE_HEAD1,	// 接收帧头第二个字节
  89. 	BOOT_STATE_HEAD2,	// 接收帧头第三个字节
  90. 	BOOT_STATE_LEN,		// 接收帧长
  91. 	BOOT_STATE_PRO		// 接收至数据完成
  92. }boot_state_e;
  93.  
  94. #pragma pack(1)
  95. /**
  96.  * @brief 数据缓存buf
  97.  */
  98. typedef union
  99. {
  100. 	uint8_t buffer[BUF_MAX_LENGTH];
  101. 	struct
  102. 	{
  103. 		uint8_t head0;	// 头字节1
  104. 		uint8_t head1;	// 头字节2
  105. 		uint8_t head2;	// 头字节3
  106. 		uint16_t len;	// 数据长度
  107. 		uint8_t cmd;	// 指令
  108. 		uint8_t data[BUF_MAX_LENGTH - 6]; // 数据
  109. 	}data_t;
  110. }recv_buf_t;
  111.  
  112. /**
  113.  * @brief boot主结构体
  114.  */
  115. typedef struct
  116. {
  117. 	uint8_t state;			// 状态机标志
  118. 	uint16_t count;			// 接收数量
  119. 	uint8_t check_sum;		// 校验和
  120. 	uint8_t recv_flag;		// 接收标志
  121. 	recv_buf_t recv_buf;	// 接收缓冲区
  122. }boot_t;
  123.  
  124. /**
  125.  * @brief 升级参数
  126.  */
  127. typedef struct
  128. {
  129. 	uint32_t fw_flag;	// 升级标志位
  130. 	uint32_t page_num;	// 页数量
  131. 	uint32_t chksum;	// 校验和
  132. 	uint32_t size;		// 总大小
  133. 	uint16_t addsum;		// 累加和
  134. }boot_param_t;
  135.  
  136. /**
  137.  * @brief 升级过程中的参数
  138.  */
  139. typedef struct
  140. {
  141. 	uint8_t is_finish;// 升级类型 1:bootloader 2:app
  142. 	uint8_t boot_type;
  143. 	uint32_t addr;
  144. 	uint32_t flash_addr;
  145. }boot_pro_t;
  146. #pragma pack()
  147.  
  148.  
  149. // 头字节
  150. const uint8_t boot_head_bytes[] = {0xAA, 0x55, 0xAA};
  151. // 升级所需参数
  152. static boot_pro_t g_state = {0};
  153. // 升级参数
  154. static boot_param_t g_param_data = {0};
  155. // boot
  156. static boot_t g_boot_data = {0};
  157. // 解析出来的完整的数据
  158. static boot_t g_boot_data_entire = {0};
  159. // 软件版本信息
  160. static char soft_version[] = \
  161. "\r\n==============================================\r\n \
  162. ** CPU(stm32f4xx)  BootLoader\r\n \
  163. **Author	lj\r\n \
  164. **Date		20221022\r\n \
  165. **Version	V1.0.0\r\n \
  166. ===================================================\r\n\0";
  167.  
  168. /**
  169.  * @brief 计算校验和
  170.  * @param buff:待校验数据
  171.  * @param len:数据长度
  172.  * @retval 校验和
  173.  */
  174. static uint8_t calc_chksum(uint8_t* buff, uint16_t len)
  175. {
  176. 	uint8_t checkSum = 0;
  177. 	uint16_t i = 0;
  178.  
  179. 	if(buff == NULL || len == 0)
  180. 		return 0;
  181.  
  182. 	for(i=0; i<len; i++)
  183. 	{
  184. 		checkSum += buff[i];
  185. 	}
  186.  
  187. 	return checkSum;
  188. }
  189.  
  190. /**
  191.  * @brief boot发送数据
  192.  * @param cmd:命令子
  193.  * @param data:待发送数据
  194.  * @param len:发送数据长度
  195.  * @retval None
  196.  */
  198. static void boot_send_data(uint8_t cmd, uint8_t* data, uint16_t len)
  199. {
  200. 	recv_buf_t send_buf = {0};
  201. 	memcpy(send_buf.buffer, boot_head_bytes, sizeof(boot_head_bytes));
  202.  
  203. 	send_buf.data_t.cmd = cmd;
  204.  
  205. 	if((data == NULL) || (len == 0))
  206. 	{
  207. 		send_buf.data_t.len = RECV_BYTES_MIN;
  208. 	}
  209. 	else
  210. 	{
  211. 		memcpy(&send_buf.data_t.data[0], data, len);
  212. 		send_buf.data_t.len = len + RECV_BYTES_MIN;
  213. 	}
  214.  
  215. 	send_buf.data_t.data[len] = calc_chksum(&send_buf.buffer[3], 3+len);
  216.  
  217. 	// 发送数据
  218. 	uart_write(&send_buf.buffer[0], send_buf.data_t.len);
  219. }
  220.  
  221. /**
  222.  * @brief 保存升级参数
  223.  * @param None
  224.  * @retval None
  225.  */
  226. static void boot_save_param(void)
  227. {
  228. 	uint16_t i = 0;
  229. //	boot_param_t read ={0};
  230.  
  231. 	if(g_state.boot_type != BOOT_TYPE_APP)
  232. 		return;
  233.  
  234. 	// 擦除参数
  235. 	flash_erase_param();
  236.  
  237. 	g_param_data.fw_flag = PARAM_FLAG;
  238. 	g_param_data.addsum = 0;
  239. 	for(i=0; i<(sizeof(boot_param_t)-1); i++)
  240. 	{
  241. 		g_param_data.addsum += ((uint8_t*)&g_param_data)[i];
  242. 	}
  243.  
  244. 	flash_write(PARAM_START_ADDR, sizeof(boot_param_t), (uint8_t*)&g_param_data);
  245. //	memset(g_param_data, 0, sizeof(boot_param_t));
  246. //	flash_read(PARAM_START_ADDR, sizeof(boot_param_t), (uint8_t*)&read);
  247. //	i++;
  248. }
  249.  
  250. /**
  251.  * @brief 读取参数
  252.  * @param None
  253.  * @retval None
  254.  */
  255. __attribute((unused)) static void boot_read_param(void)
  256. {
  257. 	uint8_t sum = 0;
  258. 	uint16_t i = 0;
  259.  
  260. 	memset((uint8_t*)&g_param_data, 0, sizeof(boot_param_t));
  261. 	flash_read(PARAM_START_ADDR, sizeof(boot_param_t), (uint8_t*)&g_param_data);
  262.  
  263. 	for(i=0; i<(sizeof(boot_param_t)-1); i++)
  264. 	{
  265. 		sum += ((uint8_t*)&g_param_data)[i];
  266. 	}
  267.  
  268. 	if(sum != g_param_data.addsum)
  269. 	{
  270. 		memset((uint8_t*)&g_param_data, 0, sizeof(boot_param_t));
  271. 	}
  272. }
  273.  
  274. /**
  275.  * @brief 开始升级，初始化参数
  276.  * @param data:指令类型
  277.  * @retval None
  278.  */
  279. static void boot_init(uint8_t* data)
  280. {
  281. 	uint8_t cmd = 0;
  282.  
  283. 	if(data == NULL)
  284. 		return;
  285.  
  286. 	if(data[0] == 0x01)    // 升级BOOT
  287. 	{
  288. 		g_state.addr = BOOT_START_ADDR;
  289. 		g_state.boot_type = BOOT_TYPE_BOOTLOADER;
  290. 		g_state.is_finish = BOOT_NO;
  291. 		g_state.flash_addr = 0;
  292. 	//	EraseAddr = BOOT_ADDR;
  293. 	//	Flash_Erase_Num = BOOT_BLUK_NUM;
  294. 		cmd = CMD_ACK_BOOTLOADER;
  295. 	}
  296. 	else if(data[0] == 0x02) // 升级APP
  297. 	{
  298. 		g_state.addr = APP_START_ADDR;
  299. 		g_state.boot_type = BOOT_TYPE_APP;
  300. 		g_state.is_finish = BOOT_NO;
  301. 		g_state.flash_addr = 0;
  302. 		//Bin_Flash_Adr = 0;
  303. 	//	EraseAddr = APP_ADDR;
  304. 	//	Flash_Erase_Num = APP_ERASE_NUM;
  305. 		cmd = CMD_ACK_APP;
  306. 	}
  307. 	else
  308. 	{
  309. 		g_state.addr = APP_START_ADDR;
  310. 		g_state.boot_type = BOOT_TYPE_NONE;
  311. 		g_state.is_finish = BOOT_NO;
  312. 		g_state.flash_addr = 0;
  313.  
  314. 		cmd = CMD_ACK_ERR;
  315. 	}
  316.  
  317. 	boot_send_data(cmd, NULL, 0);
  318. }
  319.  
  320. #pragma pack(1)
  321.  
  322. typedef struct
  323. {
  324. 	uint8_t type;	// 类型
  325. 	uint16_t num;	// 程序页数量
  326. 	uint8_t content[SEND_SIZE_PER_SEND];// 程序内容
  327. }file_data_t;
  328. #pragma pack()
  329.  
  330. /**
  331.  * @brief 开始升级，初始化参数
  332.  * @param data:升级数据，为
  333.  * @retval None
  334.  */
  335. static void boot_update(uint8_t* data)
  336. {
  337. 	uint8_t ack_state = 0;
  338. 	uint8_t read_tmp[256] = {0};
  339. 	uint16_t i = 0;
  340. 	uint32_t check_sum = 0;
  341. 	uint32_t bin_write_addr = 0;
  342. 	file_data_t* file_data = NULL;
  343.  
  344. 	if(g_state.boot_type == BOOT_TYPE_NONE || data == NULL)
  345. 		return;
  346.  
  347. 	file_data = (file_data_t *)data;
  348.  
  349. 	if((file_data->type == CMD_UPDATE_BOOT && g_state.addr == BOOT_START_ADDR) ||
  350. 		(file_data->type == CMD_UPDATE_APP && g_state.addr == APP_START_ADDR))
  351. 	{
  352. 		bin_write_addr = g_state.addr + g_state.flash_addr;
  353. 	}
  354. 	else
  355. 	{
  356. 		ack_state = UPDATE_ACK_STATE_WRITE_ERROR;
  357. 		boot_send_data(CMD_UPDATE_FILE, &ack_state, 1);
  358. 	}
  359.  
  360.  
  361. 	if(g_state.flash_addr == file_data->num * SEND_SIZE_PER_SEND)
  362. 	{
  363. 		if(g_state.flash_addr == 0)
  364. 		{
  365. 			ack_state = UPDATE_ACK_STATE_ERASEING;			// FLASH 擦除中
  366. 			boot_send_data(CMD_UPDATE_FILE, &ack_state, 1);
  367.  
  368. 			flash_erase_app();
  369.  
  370. 			ack_state = UPDATE_ACK_STATE_ERASE_DONE;			// FLASH 擦除完毕
  371. 			boot_send_data(CMD_UPDATE_FILE, &ack_state, 1);
  372.  
  373. 		//	flash_erase_param();					// 参数擦除
  374. 		}
  375.  
  376. 		flash_write(bin_write_addr, SEND_SIZE_PER_SEND, &file_data->content[0]);
  377. 		flash_read(bin_write_addr, SEND_SIZE_PER_SEND, &read_tmp[0]);
  378.  
  379. 		for(i=0; i<SEND_SIZE_PER_SEND; i++)
  380. 		{
  381. 			check_sum += read_tmp[i];
  382. 			if(read_tmp[i] != file_data->content[i]) // 如果校验错误，需要重发
  383. 			{
  384. 				ack_state = UPDATE_ACK_STATE_CHECK_ERROR;
  385. 				boot_send_data(CMD_UPDATE_FILE, &ack_state, 1);
  386. 				return;
  387. 			}
  388. 		}
  389.  
  390. 		g_state.flash_addr += SEND_SIZE_PER_SEND;
  391. 		g_param_data.page_num = file_data->num + 1;
  392. 		g_param_data.chksum += check_sum;
  393.  
  394.  
  395. 		ack_state = UPDATE_ACK_STATE_WRITE_RIGHT;
  396. 		boot_send_data(CMD_UPDATE_FILE, &ack_state, 1);
  397. 	}
  398. 	else
  399. 	{
  400. 		ack_state = UPDATE_ACK_STATE_WRITE_RIGHT;
  401. 		boot_send_data(CMD_UPDATE_FILE, &ack_state, 1);
  402. 	}
  403.  
  404. }
  405.  
  406. /**
  407.  * @brief 获取当前时间
  408.  * @param None
  409.  * @retval 当前时间
  410.  */
  411. static uint32_t get_current_time(void)
  412. {
  413. #ifdef STM32F407xx
  414. 	return HAL_GetTick();
  415. #else
  416. 	return 0;
  417. #endif
  418. }
  419.  
  420. /**
  421.  * @brief 处理升级数据
  422.  * @param data:接收到的完整数据
  423.  * @retval None
  424.  */
  425. static void boot_handle_cmd(recv_buf_t *data )
  426. {
  427. 	uint8_t ack_state = 0;
  428. 	uint32_t sys_time = 0;
  429. 	static uint32_t pre_time = 0;
  430.  
  431. 	if(data == NULL)
  432. 		return;
  433.  
  434. 	switch(data->data_t.cmd)
  435. 	{
  436. 		// 固件升级使能
  437. 		case CMD_UPDATE_READY:
  438. 		{
  439. 			sys_time = get_current_time();
  440. 			// 500 ms内只响应一次
  441. 			if((pre_time != 0) && (sys_time-pre_time) < 500)
  442. 				return;
  443.  
  444. 			pre_time = sys_time;
  445.  
  446. 			boot_init(&data->data_t.data[0]);
  447. 		}
  448. 		break;
  449.  
  450. 		// 固件文件传输
  451. 		case CMD_UPDATE_FILE:
  452. 		{
  453. 			boot_update(&data->data_t.data[0]);
  454. 		}
  455. 		break;
  456.  
  457. 		// 固件升级完成
  458. 		case CMD_UPDATE_FINISH:
  459. 		{
  460. 			boot_save_param();
  461.  
  462. 			g_state.flash_addr = 0;
  463. 			g_state.boot_type = BOOT_TYPE_NONE;
  464. 			g_state.is_finish = BOOT_YES;
  465. 		}
  466. 		break;
  467.  
  468. 		default:
  469. 		{
  470. 			ack_state = UPDATE_ACK_STATE_CHECK_ERROR;
  471. 			boot_send_data(CMD_UPDATE_FILE, &ack_state, 1);
  472. 		}
  473. 		break;
  474. 	}
  475. }
  476.  
  477. /**
  478.  * @brief 返回升级成功标志
  479.  * @param None
  480.  * @retval 升级成功标志位
  481.  */
  482. uint8_t is_boot_finish(void)
  483. {
  484. 	return g_state.is_finish;
  485. }
  486.  
  487. /**
  488.  * @brief 返回升级状态
  489.  * @param None
  490.  * @retval 升级状态 ！0=升级中 0=没升级
  491.  */
  492. uint8_t get_boot_status(void)
  493. {
  494. 	return g_state.boot_type;
  495. }
  496.  
  497. /**
  498.  * @brief 发送软件版本信息
  499.  * @param None
  500.  * @retval None
  501.  */
  502. void send_boot_version(void)
  503. {
  504. 	uart_write((uint8_t *)soft_version, strlen(soft_version));
  505. }
  506.  
  507. /**
  508.  * @brief 接收解析串口数据
  509.  * @param None
  510.  * @retval None
  511.  */
  512. static void boot_recv_data(void)
  513. {
  514. 	uint8_t ch = 0;
  515. 	uint16_t i = 0;
  516. 	uint16_t date_len = 0;
  517. 	uint8_t buff[BUF_MAX_READ_LEN] = {0};
  518.  
  519. 	// 读取串口数据
  520. 	date_len = uart_read(buff, BUF_MAX_READ_LEN);
  521. 	if(date_len == 0)
  522. 		return;
  523.  
  524. 	for(i=0; i<date_len; i++)
  525. 	{
  526. 		ch = buff[i];
  527.  
  528. 		switch(g_boot_data.state)
  529. 		{
  530. 			// 找帧头
  531. 			case BOOT_STATE_HEAD0:
  532. 			{
  533. 				if(ch == boot_head_bytes[0])
  534. 				{
  535. 					g_boot_data.count = 0;
  536. 					g_boot_data.check_sum = 0;
  537. 					g_boot_data.recv_buf.buffer[g_boot_data.count++] = ch;
  538. 					g_boot_data.state = BOOT_STATE_HEAD1;
  539. 				}
  540. 			}
  541. 			break;
  542.  
  543. 			case BOOT_STATE_HEAD1:
  544. 			{
  545. 				if(ch == boot_head_bytes[1])	// 如果第二个字节为0x55，就找第三个字节
  546. 				{
  547. 					g_boot_data.recv_buf.buffer[g_boot_data.count++] = ch;
  548. 					g_boot_data.state = BOOT_STATE_HEAD2;
  549. 				}
  550. 				else if(ch == boot_head_bytes[0])	// 如果第二个字节为0xAA，则继续找第二个字节
  551. 				{
  552. 					g_boot_data.count = 0;
  553. 					g_boot_data.recv_buf.buffer[g_boot_data.count++] = ch;
  554. 					g_boot_data.state = BOOT_STATE_HEAD1;
  555. 				}
  556. 				else	// 否则丢掉当前字节，继续找第一个字节
  557. 				{
  558. 					g_boot_data.state = BOOT_STATE_HEAD0;
  559. 				}
  560. 			}
  561. 			break;
  562.  
  563. 			case BOOT_STATE_HEAD2:
  564. 			{
  565. 				if(ch == boot_head_bytes[2]) // 帧头正确，接收帧长度
  566. 				{
  567. 					g_boot_data.recv_buf.buffer[g_boot_data.count++] = ch;
  568. 					g_boot_data.state = BOOT_STATE_LEN;
  569. 				}
  570. 				else	// 否则重新接收
  571. 				{
  572. 					g_boot_data.state = BOOT_STATE_HEAD0;
  573. 				}
  574. 			}
  575. 			break;
  576.  
  577. 			case BOOT_STATE_LEN:	// 接收帧长
  578. 			{
  579. 				g_boot_data.recv_buf.buffer[g_boot_data.count++] = ch;
  580. 				g_boot_data.check_sum += ch;	// 此时开始计算校验和
  581. 				if(g_boot_data.count >= (sizeof(boot_head_bytes)+sizeof(uint16_t)))	// 确保已经接收到了帧长
  582. 				{
  583. 					if((g_boot_data.recv_buf.data_t.len >= RECV_BYTES_MIN)	// 判断帧长是否合法
  584. 							&& (g_boot_data.recv_buf.data_t.len <= BUF_MAX_LENGTH))
  585. 					{
  586. 						g_boot_data.state = BOOT_STATE_PRO;
  587. 					}
  588. 					else
  589. 					{
  590. 						g_boot_data.state = BOOT_STATE_HEAD0;
  591. 					}
  592. 				}
  593. 			}
  594. 			break;
  595.  
  596. 			case BOOT_STATE_PRO:
  597. 			{
  598. 				g_boot_data.recv_buf.buffer[g_boot_data.count++] = ch;
  599. 				if(g_boot_data.count >= g_boot_data.recv_buf.data_t.len)	// 接收完毕
  600. 				{
  601. 					// 校验和正确
  602. 					if(g_boot_data.check_sum == g_boot_data.recv_buf.buffer[g_boot_data.count-1])
  603. 					{
  604. 						// 数据解析完成
  605. 						memcpy(&g_boot_data_entire, &g_boot_data, sizeof(g_boot_data));
  606. 						g_boot_data_entire.recv_flag = BOOT_YES;
  607. 					}
  608. 					g_boot_data.state = BOOT_STATE_HEAD0;
  609. 				//	return;
  610. 				}
  611. 				else
  612. 				{
  613. 					g_boot_data.check_sum += ch;
  614. 				}
  615. 			}
  616. 			break;
  617.  
  618. 			default:
  619. 				g_boot_data.state = BOOT_STATE_HEAD0;
  620. 			break;
  621. 		}
  622. 	}
  623. }
  624.  
  625.  
  626. /**
  627.  * @brief 开始跳转
  628.  * @param None
  629.  * @param None
  630.  */
  631. void app_entry(void)
  632. {
  633. 	uint32_t *ptop;
  634. 	uint32_t stacktop;
  635. 	jump_func app;
  636.  
  637. 	HAL_DeInit();
  638. 	__disable_irq();
  639.  
  640. 	ptop = (uint32_t *)APP_START_ADDR;
  641.  
  642. 	stacktop = *ptop++;
  643. 	app = (jump_func)*ptop;
  644.  
  645. 	SCB->VTOR	= FLASH_ADDR_BASE | (BOOTLOADER_LEN + PARAM_LEN);
  646. 	__set_MSP(stacktop);
  647.  
  648. 	app();
  649.  
  650. 	while(1);
  651. }
  652.  
  653. /**
  654.  * @brief 程序校验和跳转到app执行
  655.  * @param None
  656.  * @retval None
  657.  */
  658. void boot_start_app(void)
  659. {
  660. 	uint32_t i = 0;
  661. 	uint8_t sum = 0;
  662.  
  663. 	boot_param_t app_param = {0};
  664.  
  665. 	flash_read(PARAM_START_ADDR, sizeof(boot_param_t), (uint8_t*)&app_param);
  666.  
  667. 	for(i=0; i<(sizeof(boot_param_t)-1); i++)
  668. 	{
  669. 		sum += ((uint8_t*)&app_param)[i];
  670. 	}
  671.  
  672. 	if(sum != app_param.addsum)
  673. 		return;
  674.  
  675. 	if(app_param.fw_flag != PARAM_FLAG)
  676. 		return;
  677.  
  678. 	// 启动APP
  679. 	app_entry();
  680. }
  681.  
  682. /**
  683.  * @brief 是否需要升级
  684.  * @param None
  685.  * @retval 1:需要升级 0：不需要
  686.  */
  687. uint8_t is_need_update(void)
  688. {
  689. 	boot_param_t app_param = {0};
  690.  
  691. 	flash_read(PARAM_START_ADDR, sizeof(boot_param_t), (uint8_t*)&app_param);
  692.  
  693. 	if(app_param.fw_flag != PARAM_FLAG)
  694. 		return 1;
  695. 	return 0;
  696. }
  697.  
  698. /**
  699.  * @brief 使用帧协议接收处理串口数据
  700.  * @param None
  701.  * @retval None
  702.  */
  703. void boot_event(void)
  704. {
  705. 	boot_recv_data();
  706.  
  707. 	if(g_boot_data_entire.recv_flag == BOOT_YES)
  708. 	{
  709. 		g_boot_data_entire.recv_flag = BOOT_NO;
  710. 		boot_handle_cmd(&g_boot_data_entire.recv_buf);
  711. 	}
  712. }

5.主任务调用如下，

  1. // 需要处理串口数据次数
  2. volatile uint16_t g_uart_deal_cnt = 0;
  3.  
  4. void system_reset(void)
  5. {
  6. 	__set_FAULTMASK(1);
  7. 	HAL_NVIC_SystemReset();
  8. }
  9.  
  10. /**
  11.  * @brief 主任务程序入口，由main调用
  12.  * @param None
  13.  * @retval 0
  14.  */
  15. int main_loop(void)
  16. {
  17. 	uint32_t i;
  18.  
  19. 	// 如果不需要升级则直接跳转
  20. 	if (!is_need_update())
  21. 	{
  22. 		app_entry();
  23. 	}
  24.  
  25. 	while(1)
  26. 	{
  27. 		// 如果串口接收完成数据则g_uart_deal_cnt+1
  28. 		// 如果不等就需要处理串口数据，等则意味这串口无数据来，同时记录串口数据接收次数
  29. 		if (get_uart_recv_cnt() != g_uart_deal_cnt)
  30. 		{
  31. 			g_uart_deal_cnt++;
  32.  
  33. 			boot_event();
  34.  
  35. 		}
  36.  
  37. 		// 如果升级完成
  38. 		if (is_boot_finish())
  39. 		{
  40. 			system_reset();
  41. 		}
  42. 	}
  43.  
  44. 	return 0;
  45. }

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

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

  

闽ICP备14008679号