====>>> 文章汇总 <<<====
1. STM32程序升级方法
1.1 ST-Link / J-link下载
这个应该是最基本的方法,只要自己写过程序的应该都会,将编译生成的hex
文件使用ST-Link工具或者J-Link工具直接下载进 Flash 即可。Keil中点击下载也能一键下载。
下载时可以看到地址是从0x0800 0000,即 Flash 的起始地址开始下载的。
优点:简单,插上下载器直接下载即可。
缺点:在产品中嵌入式板卡封装起来之后,因为下载口没有实际功能,所以很多时候下不拆机是没办法插上下载器的。这时候就不方便。
简单补充一句,bin文件和hex文件的区别:
- bin文件不带地址信息,因此下载的时候需要指定下载地址。
- hex文件自带地址信息,直接点击下载自己会找到要下载到的地址(默认0x0800 0000)。
1.2 ISP(In System Programing)
我们常见的一键下载电路就是用的这种方式。这个是利用了 STM32 自带的 Bootloader 升级程序。
在用户参考手册中,可以看到下表,关于启动模式设置的。
中文版的如下:
程序运行时的启动过程:
一般在我们的程序运行的时候,BOOT0 是接地的,也就是BOOT0 = 0
。也就是程序是从主存储器Flash开始启动的,启动的地址为0x08000000
。
使用ISP下载时的启动过程:
- 首先,硬件上将 STM32 的 BOOT0 引脚拉高、BOOT1 引脚拉低,即
BOOT0 = 1
、BOOT1 = 0
。 - 此时,程序会从系统存储器中的程序启动,这段程序会接收串口数据(我们编译好的程序文件),并将这写数据放到主闪存存储器(Flash)当中。
- 最后,硬件上重新将 BOOT0 接地,也就是
BOOT0 = 0
,然后复位引脚拉低,程序复位重启,从 Flash 中开始运行程序。
可以这么理解:芯片出厂时,系统存储器中已经存储了一段程序,这段程序的功能是将串口1(固定的)收到的数据,放到主闪存存储器(Flash)中,从0x0800 0000地址处开始。
这样也就完成了我们的一键下载过程。
比如,正点原子的一键下载电路如下,左侧的三极管就是用来完成 BOOT引脚和复位引脚的操作的。
具体的硬件引脚电平如何变化百度搜一下,分析应该挺多的。我也没详细看过。
沁恒官网也有专门的一键下载芯片,原理上其实一样的。
链接:https://www.wch.cn/application/575.html
ISP的下载方式:
优点:提供了一种升级方式,无需代码支持。
缺点:需要相应的硬件支持,成本增加;使用的接口也是固定的,并且很多时候串口可能用于其他功能了已经。
1.3 IAP(In Applicating Programing)
IAP 和 ISP 其实基本上是一样的。
但是:ISP 是由厂商已经提供好的,因此接口固定;IAP可以自定义使用任何接口接收应用程序。也正是因为这一点,使得用户可以用多种不同的方式进行升级。
1.3.1 正常程序运行流程
在看IAP之前,要先看一下正常情况下,程序从Flash启动时的启动流程,如下图所示:
- 首先程序从Flash启动,根据中断向量表找到复位中断处理函数的地址(0x0800 0004处是中断向量表的起始地址,记录了复位中断处理函数的地址)。
- 执行复位中断处理函数,初始化系统环境之后,该函数最后会跳转到main函数继续运行。
- 在main函数的死循环中一直运行,直到有中断发生时(外设中断等等),重新跳转到中断向量表起始处。
- 在中断向量表中根据中断信号源来判断要执行的中断处理函数,然后跳转到相应的中断处理函数。
- 中断处理函数运行完成之后继续跳转到main函数处继续运行。
1.3.2 有IAP时程序运行流程
接下来看下有了IAP之后的启动流程,如下图所示,下图中可以看到,在Flash中存储了 两“套” 程序(套的意思是,不仅只有用户程序,配套的中断向量等也都有)。
其中第一套为:Bootloader程序,该程序的功能是,接收某个接口的数据,并把这些数据存储到Flash中。
这些数据其实就是后面的一套APP程序,这套应用程序可以通过Bootlaoder程序保存到Flash中,这样就不用再使用专门的下载器。
第二套才是我们真正的应用程序。
- 首先程序从Flash启动,根据中断向量表找到复位中断处理函数的地址(0x0800 0004处是中断向量表的起始地址,记录了复位中断处理函数的地址)。
- 执行复位中断处理函数,该函数最后会跳转到Bootloader的main函数继续运行。这个main函数的任务就是,判断是否接收新的APP程序,如果有,就把新的APP程序文件保存到Flash(就是第二套程序的位置)然后跳转到第二套程序中运行。如果无,就直接跳转到第二套程序中运行。
- 跳转之后的过程也是和正常程序运行的流程一样,一旦进入新的APP程序的起始地址,就会根据中断向量表找到复位中断处理函数,然后进入App程序的main函数运行。
- 但是如果发生中断,是强制跳转到Bootloader程序的中断向量表进行查询的,而我们需要的肯定是需要跳转到APP程序的中断处理函数处运行。所以,在进行到APP程序后,APP程序一定要修改中断向量表的偏移,让查找对应中断处理函数的时候偏移一段地址到App程序的中断处理函数处,否则APP程序中的中断发生时,就无法跳转到APP程序的中断处理函数了。
到这,我们就知道Bootloader程序是干啥的了。
这个分析过程,是2.1小节中的方式一。其他方式跟这种原理上基本是一样一样的。
对比:
ISP | IAP |
---|---|
在系统存储器中存储了一套接收串口1数据的程序 | IAP是将Flash分成了两份,在第一份中存储了一套接收某个接口的程序 |
使用硬件BOOT引脚设置进行跳转 | 使用软件(直接修改PC指针)进行跳转 |
仅能使用芯片厂商设置好的接口(串口1) | 用户自定义,理论上只要能接收数据的接口都可以用 |
2. STM32 Bootloader实现
开发板:STM32F401CCU6最小系统板(淘宝十几块钱),Flash大小:256KB,RAM大小:64KB。
TODO:这里记录一下,我看到的或者想到的所有形式。每实现一个会过来贴代码地址。
- Bootloader_App
- Bootloader_Setting_App
- Bootloader_App1_App2
- U盘拖拽
- 无线升级
- …
代码汇总地址:https://gitee.com/HzoZi/bootloader文章来源地址https://www.toymoban.com/news/detail-780745.html
2.1 方式一:Boot_App(已实现)
这应该是最常见、也是最简单的一种了。也就是上面1.3.2小节的分析的情况。
2.1.1 Bootloader
需要实现四个部分:
- 串口接收程序,用于接收App程序;
- STM32 Flash 写入接口,用于将App程序写入到 Flash;
- App跳转实现,用于跳转到App程序处开始运行。
- 设置 Keil 参数。
第一步:新建工程
调试口勾上,时钟设置最大,设置生成单独的.c文件。
- 勾选一个串口,参数默认即可。
- 串口中断也勾上
3. 设置一个按键
生成工程即可。
第二步:配置串口,实现串口接收功能
- 添加 printf 函数支持
我这里放到了 usart.c 的最后。
// 需要调用stdio.h文件
#include <stdio.h>
// 取消ARM的半主机工作模式
#pragma import(__use_no_semihosting)
struct __FILE
{
int handle;
};
FILE __stdout;
void _sys_exit(int x) // 定义_sys_exit()以避免使用半主机模式
{
x = x;
}
int fputc(int ch, FILE *f)
{
HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xffff);
return ch;
}
- 实现中断接收App程序
我这里放到了 main.c 的上面。
uint8_t single_buff[1]; // 按字节保存APP程序
uint8_t app_buff[40 * 1024] = {0}; // 保存接收到的APP程序(最大40K)
volatile uint32_t app_buff_len = 0; // APP程序的长度(字节)
void start_uart_rx(void)
{
while(HAL_UART_Receive_IT(&huart1, single_buff, sizeof(single_buff)) != HAL_OK);
}
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1)
{
// 把接收到的数据,放到缓冲区中
app_buff[app_buff_len] = single_buff[0];
app_buff_len++;
}
// 重新开启中断接收
start_uart_rx();
}
第三步:IAP实现
其中,STM32Flash读写部分 其实有现成的代码可以用。使用 RT_Thread Studio 创建一个一样芯片的工程就可以直接抄了。
我们新建一个文件,存放 IAP 实现的相关代码。
- 头文件:
注意,这里划分Flash的时候,尤其注意App程序起始地址,根据芯片不同起始地址倍数关系也不同
- STM32F1:地址必须是4的倍数,因为每次写入只能写入32位数据,即4个字节。
- STM32F4:地址可以从任意地址开始,因为每次写入可以写入8位数据,每个地址就是8位数据。
- STM32L4:地址必须是8的倍数,因为每次写入只能写入64位数据,即8个字节。
#ifndef __IAP_H
#define __IAP_H
#include "stm32f4xx_hal.h"
#include "stdint.h"
/* 以下宏定义名字尽量不要随便换 */
/* Flash定义,根据使用的芯片修改 */
#define ROM_START ((uint32_t)0x08000000)
#define ROM_SIZE (256 * 1024)
#define ROM_END ((uint32_t)(ROM_START + ROM_SIZE))
#define STM32_FLASH_START_ADRESS ROM_START
#define STM32_FLASH_SIZE ROM_SIZE
#define STM32_FLASH_END_ADDRESS ROM_END
/* Flash扇区定义,STM32F401CCU6:256KB,根据使用的芯片修改 */
#define ADDR_FLASH_SECTOR_0 ((uint32_t)0x08000000) /* Base @ of Sector 0, 16 Kbytes */
#define ADDR_FLASH_SECTOR_1 ((uint32_t)0x08004000) /* Base @ of Sector 1, 16 Kbytes */
#define ADDR_FLASH_SECTOR_2 ((uint32_t)0x08008000) /* Base @ of Sector 2, 16 Kbytes */
#define ADDR_FLASH_SECTOR_3 ((uint32_t)0x0800C000) /* Base @ of Sector 3, 16 Kbytes */
#define ADDR_FLASH_SECTOR_4 ((uint32_t)0x08010000) /* Base @ of Sector 4, 64 Kbytes */
#define ADDR_FLASH_SECTOR_5 ((uint32_t)0x08020000) /* Base @ of Sector 5, 128 Kbytes */
/* Bootloader、APP 分区定义,根据个人需求修改 */
#define BOOT_START_ADDR 0x08000000 // FLASH_START_ADDR
#define BOOT_FLASH_SIZE 0x4000 // 16K
#define APP_START_ADDR 0x08004000 // BOOT_START_ADDR + BOOT_FLASH_SIZE
#define APP_FLASH_SIZE 0x3C000 // 240K
/* 对外接口 */
void show_boot_info(void);
uint8_t jump_app(uint32_t app_addr);
/* 对外接口 */
int stm32_flash_read(uint32_t addr, uint8_t *buf, size_t size);
int stm32_flash_write(uint32_t addr, const uint8_t *buf, size_t size);
int stm32_flash_erase(uint32_t addr, size_t size);
#endif /* __IAP_H */
- 源文件:
我这里直接从RT-Thread的程序中抄的,要注意,不同系列芯片的读写函数略有差异,主要就是地址差异,App起始地址只要没问题,这里可以不用考虑,知道这回事就行。
抄过来之后如下图所示
#include "iap.h"
#include "stdio.h"
void show_boot_info(void)
{
printf("---------- Enter BootLoader ----------\r\n");
printf("\r\n");
printf("======== flash pration table =========\r\n");
printf("| name | offset | size |\r\n");
printf("--------------------------------------\r\n");
printf("| boot | 0x%08X | 0x%08X |\r\n", BOOT_START_ADDR, BOOT_FLASH_SIZE);
printf("| app | 0x%08X | 0x%08X |\r\n", APP_START_ADDR, APP_FLASH_SIZE);
printf("======================================\r\n");
}
typedef void (*jump_callback)(void);
/**
* @note 跳转至App运行
*
* @param App起始地址
*
* @return result
*/
uint8_t jump_app(uint32_t app_addr)
{
uint32_t jump_addr;
jump_callback cb;
if (((*(volatile uint32_t *)app_addr) & 0x2FFE0000 ) == 0x20000000)
{
// 复位向量位于程序起始地址+4处
jump_addr = *(volatile uint32_t*)(app_addr + 4);
cb = (jump_callback)jump_addr;
// 设置主堆栈指针指向 APP 程序起始地址
__set_MSP(*(volatile uint32_t*)app_addr);
cb();
return 1;
}
return 0;
}
/**
* @brief Gets the sector of a given address
* @param None
* @retval The sector of a given address
*/
static uint8_t GetSector(uint32_t Address)
{
if((Address < ADDR_FLASH_SECTOR_1) && (Address >= ADDR_FLASH_SECTOR_0))
{
return FLASH_SECTOR_0;
}
else if((Address < ADDR_FLASH_SECTOR_2) && (Address >= ADDR_FLASH_SECTOR_1))
{
return FLASH_SECTOR_1;
}
else if((Address < ADDR_FLASH_SECTOR_3) && (Address >= ADDR_FLASH_SECTOR_2))
{
return FLASH_SECTOR_2;
}
else if((Address < ADDR_FLASH_SECTOR_4) && (Address >= ADDR_FLASH_SECTOR_3))
{
return FLASH_SECTOR_3;
}
else if((Address < ADDR_FLASH_SECTOR_5) && (Address >= ADDR_FLASH_SECTOR_4))
{
return FLASH_SECTOR_4;
}
else
{
return FLASH_SECTOR_5;
}
}
/**
* Read data from flash.
* @note This operation's units is word.
*
* @param addr flash address
* @param buf buffer to store read data
* @param size read bytes size
*
* @return result
*/
int stm32_flash_read(uint32_t addr, uint8_t *buf, size_t size)
{
size_t i;
if ((addr + size) > STM32_FLASH_END_ADDRESS)
{
printf("read outrange flash size! addr is (0x%p)", (void*)(addr + size));
return -1;
}
for (i = 0; i < size; i++, buf++, addr++)
{
*buf = *(uint8_t *) addr;
}
return size;
}
/**
* Write data to flash.
* @note This operation's units is word.
* @note This operation must after erase. @see flash_erase.
*
* @param addr flash address
* @param buf the write data buffer
* @param size write bytes size
*
* @return result
*/
int stm32_flash_write(uint32_t addr, const uint8_t *buf, size_t size)
{
int8_t result = 0;
uint32_t end_addr = addr + size;
if ((end_addr) > STM32_FLASH_END_ADDRESS)
{
printf("write outrange flash size! addr is (0x%p)", (void*)(addr + size));
return -1;
}
if (size < 1)
{
return -1;
}
HAL_FLASH_Unlock();
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
for (size_t i = 0; i < size; i++, addr++, buf++)
{
/* write data to flash */
if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_BYTE, addr, (uint64_t)(*buf)) == HAL_OK)
{
if (*(uint8_t *)addr != *buf)
{
result = -1;
break;
}
}
else
{
result = -1;
break;
}
}
HAL_FLASH_Lock();
if (result != 0)
{
return result;
}
return size;
}
/**
* Erase data on flash.
* @note This operation is irreversible.
* @note This operation's units is different which on many chips.
*
* @param addr flash address
* @param size erase bytes size
*
* @return result
*/
int stm32_flash_erase(uint32_t addr, size_t size)
{
int8_t result = 0;
uint32_t FirstSector = 0, NbOfSectors = 0;
uint32_t SECTORError = 0;
if ((addr + size) > STM32_FLASH_END_ADDRESS)
{
printf("ERROR: erase outrange flash size! addr is (0x%p)\n", (void*)(addr + size));
return -1;
}
/*Variable used for Erase procedure*/
FLASH_EraseInitTypeDef EraseInitStruct;
/* Unlock the Flash to enable the flash control register access */
HAL_FLASH_Unlock();
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
/* Get the 1st sector to erase */
FirstSector = GetSector(addr);
/* Get the number of sector to erase from 1st sector*/
NbOfSectors = GetSector(addr + size - 1) - FirstSector + 1;
/* Fill EraseInit structure*/
EraseInitStruct.TypeErase = FLASH_TYPEERASE_SECTORS;
EraseInitStruct.VoltageRange = FLASH_VOLTAGE_RANGE_3;
EraseInitStruct.Sector = FirstSector;
EraseInitStruct.NbSectors = NbOfSectors;
if (HAL_FLASHEx_Erase(&EraseInitStruct, (uint32_t *)&SECTORError) != HAL_OK)
{
result = -1;
goto __exit;
}
__exit:
HAL_FLASH_Lock();
if (result != 0)
{
return result;
}
printf("erase done: addr (0x%p), size %d", (void*)addr, size);
return size;
}
- main函数:
#include "iap.h"
#include "stdio.h"
int main(void)
{
// 这里只是我自己写的部分,cubemx自动生成的这里没有,记得填上
start_uart_rx(); // 开始中断接收
show_boot_info(); // 输出分区信息
while (1)
{
printf("waitting input... \r\n");
// 判断是否需要更新程序(5s)
for(uint16_t i = 0; i < 5000; i++)
{
// 如果按键按下, 说明需要更新程序
if(0 == HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0))
{
HAL_Delay(20);
if(0 == HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0))
{
// 按键按下了,更新程序并跳转(先传程序,再按下按键)
// 擦除APP区域
printf("erase app... \r\n");
stm32_flash_erase(APP_START_ADDR, APP_FLASH_SIZE);
HAL_Delay(100);
// 写入APP程序
printf("write app... \r\n");
stm32_flash_write(APP_START_ADDR, app_buff, app_buff_len);//更新FLASH代码
break;
}
}
HAL_Delay(1);
}
// 跳转到APP
if(0 == jump_app(APP_START_ADDR))
{
printf("jump app failed... \r\n");
while(1);
}
}
}
- keil 配置:
这里 Bootloader程序给分配大小是 16KB(看 iap 头文件),不是默认的全部 Flash,因此在 Keil 中修改一下。
至此,Bootloader程序就完成了。
2.1.2 APP
App程序比较简单,创建一个LED闪烁工程 或 串口输出工程即可。
- 修改中断向量表偏移
// 设置中断向量偏移量
#define NVIC_VTOR_MASK 0x3FFFFF80
#define APP_PART_ADDR 0x08004000
SCB->VTOR = APP_PART_ADDR & NVIC_VTOR_MASK;
- 修改Flash起始地址和Flash大小
-
设置编译输出 bin 文件(App只能用 bin 文件,程序保存地址由 bootloader 程序指定)
fromelf --bin --output "$L@L.bin" "#L"
-
app程序
至此,App程序就写完了,编译完成之后可以在工程的输出文件夹中看到编译生成的 bin 文件。
使用同样的方法可以创建两个App,分别为app1、app2两个的效果可以不一样。
这里设置app1输出:app_1 run,app2输出:app_2 run。
2.1.3 测试
测试步骤
- 先把Bootloader程序烧录到芯片中
- 复位运行,可以看到bootloader程序的提示信息
- 使用串口助手传输app程序,传输完成之后按下按键,等待写入完成之后自动跳入app程序开始运行
- 如果一直没有按键按下,5秒之后直接跳入app开始运行
尝试更换两个app,查看不同效果。
文章来源:https://www.toymoban.com/news/detail-780745.html
代码汇总地址:https://gitee.com/HzoZi/bootloader
2.2 方式二:其他接口 / USB拖拽等(未完成)
到了这里,关于STM32深入系列02——BootLoader分析与实现的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!