代码收藏家技术教程 2024-01-19

深入理解STM32 BootLoader的分析与实现

文章目录

1. STM32程序升级方法

1.1 ST-Link / J-link下载

1.2 ISP（In System Programing）

1.3 IAP（In Applicating Programing）

1.3.1 正常程序运行流程

1.3.2 有IAP时程序运行流程

2. STM32 Bootloader实现

2.1 方式一：Boot_App（已实现）

2.1.1 Bootloader

2.1.2 APP

2.1.3 测试

2.2 方式二：其他接口 / USB拖拽等（未完成）

====>>> 文章汇总 <<<====

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

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://gitee.com/HzoZi/bootloader

2.2 方式二：其他接口 / USB拖拽等（未完成）

stm32 单片机嵌入式硬件

物联沃分享整理
物联沃-IOTWORD物联网 » 深入理解STM32 BootLoader的分析与实现

代码收藏家普通

分享到：

文章目录

1. STM32程序升级方法

1.1 ST-Link / J-link下载

1.2 ISP（In System Programing）

1.3 IAP（In Applicating Programing）

1.3.1 正常程序运行流程

1.3.2 有IAP时程序运行流程

2. STM32 Bootloader实现

2.1 方式一：Boot_App（已实现）

2.1.1 Bootloader

2.1.2 APP

2.1.3 测试

2.2 方式二：其他接口 / USB拖拽等（未完成）

您可能感兴趣的内容:

代码收藏家 普通

相关推荐

发表评论 取消回复

代码收藏家普通

发表评论取消回复