STM32 IAP在线升级在项目中的应用

• IAP即在线应用编程，平时我们写好的程序都是通过下载器去下载的，但是对于组装好的产品在想更新底层硬件代码是很麻烦的事情，如果在公司情况还没那么糟糕，要是发出去的产品出现bug，你不可能要用户给你下载程序的。IAP这种技术，我们就可以像软件一样，可以实现远程更新了。我们需要做的就是，写FLASH读写接口，程序可以通过串口，网口等进行下发，然后内部调用FLASH写函数，把代码写到对于区域即可。
• 当然这只是一个大概思路，具体实现还是要注意很多细节的东西。网上也有好多关于这方面的教程，但是能用到项目中的却很少，我写这边文章就是想和大家分享我在项目中实际应用。
• 想了想，就以我实际开发过程来写吧，这里对新人来说也可以当作一篇教程来学习。

一、FLASH读写接口的实现

• 这里大家可以参考原子哥的FLASH模拟EEPROM实验来写。因为我们做写的是程序，数据流很大，需要做一些改动，这样写入速度会快很多。
• 首先我们来了解一下STM32F1的FLASH，如下图，我们要看的只有主存储区，可以看到单片机内部FLASH是按2K一页来区分的，而且对其读写是有如下几点要求：

1. 每次写入必须为2个字节。
2. 写入地址为2的倍数。
3. 写入之前必须是被擦除的（即其值为0xFFFF），也可以理解为，写入数据只能把位写0，不能置1。
4. 写入速度≤24MHz。
5. 擦除方式：页擦除和正片擦除（这个要注意，如果你是做数据保存，就必须先把这一页的数据读取到缓存中，然后修改缓存里的值，再整页写入）。

• FLASH写入过程如下：

1. 解锁
2. 读页数据到缓存
3. 页擦除
4. 修改缓存数据
5. 把缓存数据页写入
6. 上锁

• 首先我们都有一下基本的读写函数，写函数官方库已经为我们提供，我们要写的就是读函数，代码如下：

//读1个字节
uint8_t FLASH_ReadByte(uint32_t Addr)
{
    return *(vu8 *)Addr;
}
//读2个字节
uint16_t FLASH_ReadHalfWord(uint32_t Addr)
{
    return *(vu16 *)Addr;
}
//读N个字节
void FLASH_ReadNByte(uint32_t Addr,uint8_t *pBuff,uint32_t Len)
{
    uint32_t i;
    
    for(i = 0;i < Len;i++)
    {
        pBuff[i] = FLASH_ReadByte(Addr);
        Addr += 1;
    }
}

• 然后就是在基本函数的基础上面扩展我们需要的函数，因为升级过程中，我们需要保存一些标志，需要用到读某一页的函数。

#define STM32_SECTOR_SIZE   2048    //页大小
#define STM32_SECTOR_NUM    255     //页数

//STM32 FLASH的起始地址
#define STM32_FLASH_BASE 0x08000000

void FLASH_ReadPage(uint8_t Page_Num,uint8_t *pBuff)
{
    uint16_t i;
    uint32_t Buff;
    uint32_t Addr;
    
    //是否超出范围
    if(Page_Num > STM32_SECTOR_NUM)
        return;
    //先计算页首地址
    Addr = Page_Num * STM32_SECTOR_SIZE + STM32_FLASH_BASE;
    
    for(i = 0;i < STM32_SECTOR_SIZE;i += 4)
    {
        Buff = FLASH_ReadWord(Addr);
        
        pBuff[i]   = Buff;
        pBuff[i+1] = Buff >> 8;
        pBuff[i+2] = Buff >> 16;
        pBuff[i+3] = Buff >> 24;
        
        Addr += 4;
    }
}

• 需要读写就需要写页，再来写一个写页函数，由于一次只能写2字节，所有我们调用的是官方库函数FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data)。

void FLASH_WritePage(uint8_t Page_Num,uint8_t *pBuff)
{
    uint16_t i;
    uint16_t Buff;
    uint32_t Addr;
    
    //是否超出范围
    if(Page_Num > STM32_SECTOR_NUM)
        return;
    //解锁
    FLASH_Unlock();
    //先计算页首地址
    Addr = Page_Num * STM32_SECTOR_SIZE + STM32_FLASH_BASE;
    
    for(i = 0;i < STM32_SECTOR_SIZE ;i += 2)
    {
        Buff = ((uint16_t)pBuff[i+1] << 8) | pBuff[i];
        FLASH_ProgramHalfWord(Addr,Buff);
        Addr += 2;
    }
    //上锁
    FLASH_Lock();
}

• 然后我们还要写两个重要的函数，他们都是写N字节函数，区别是一个要先把页数据读到缓存中，再写入，这个函数用来保存一些标志等等，另一个函数我们不负责扇区数据擦除保存等处理，我们只管往某个地址写入数据，这个函数用来做升级用，这样速度会快一些。下来就来实现这两个函数。

void FLASH_WriteNData(uint32_t Addr,uint8_t *pBuff,uint32_t Len)
{
    uint32_t Offset;
    uint8_t  Page_Num;
    uint16_t Page_Offset;
    uint16_t Free_Space;
    uint16_t i;
    
    if((Addr < STM32_FLASH_BASE) || (Addr > STM32_FLASH_END))
        return;
    
    Offset = Addr - STM32_FLASH_BASE;//偏移地址
    Page_Num = Offset / STM32_SECTOR_SIZE;//得到地址所在页
    Page_Offset = Offset % STM32_SECTOR_SIZE;//在页内的偏移地址
    Free_Space = STM32_SECTOR_SIZE -  Page_Offset;//页区剩余空间
    //要写入的数据是否大于剩余空间
    if(Len <= Free_Space)
        Free_Space = Len;
    
    FLASH_Unlock();//解锁
    
    while(1)
    {
        FLASH_ReadPage(Page_Num,STM32_FLASH_BUFF);//先把数据读到缓存中
        FLASH_ErasePage(Page_Num * STM32_SECTOR_SIZE + STM32_FLASH_BASE);//页擦除
        //修改缓存数据
        for(i = 0;i < Free_Space;i++)
        {
            STM32_FLASH_BUFF[i+Page_Offset] = pBuff[i];
        }
        FLASH_WritePage(Page_Num,STM32_FLASH_BUFF);//把缓存数据写入
        //判断是否超出当前页，超出进入下一页
        if(Len == Free_Space)
            break;
        else
        {
            Page_Num++;//下一页
            Page_Offset = 0;
            pBuff += Free_Space;
            
            Len -= Free_Space;
            if(Len > STM32_SECTOR_SIZE)
                Free_Space = STM32_SECTOR_SIZE;
            else
                Free_Space = Len;
        }
    }
    FLASH_Lock();
}
void FLASH_WriteNByte(uint32_t Addr,uint8_t *pBuff,uint32_t Len)
{
    uint16_t i;
    uint16_t temp = 0;
    
    if((Addr < STM32_FLASH_BASE) || (Addr > STM32_FLASH_END))
        return;
    
    FLASH_Unlock();//解锁
    
    for(i = 0;i < Len;i += 2)
    {
        temp = pBuff[i];
        temp |= (uint16_t)pBuff[i+1] << 8;
        
        FLASH_ProgramHalfWord(Addr,temp);
        Addr += 2;
        if(Addr > STM32_FLASH_END)
        {
            FLASH_Lock();
            return;
        }
    }
    FLASH_Lock();
}

• 因为我们程序可能会占用多页，所以我们需要写一个擦除指定页的函数，代码如下。

void Flash_EraseSector(uint8_t Start_Page,uint8_t End_Page)
{
    uint8_t i;
    uint8_t num = 0;
    
    if(Start_Page > End_Page)
        return;
    
    FLASH_Unlock();//解锁
    
    num = End_Page - Start_Page;//擦除页数
    
    for(i = 0;i <= num;i++)
    {
        FLASH_ErasePage((Start_Page + i) * STM32_SECTOR_SIZE + STM32_FLASH_BASE);//页擦除
    }
    
    FLASH_Lock();
}

• 我们写了几个接口，我们要测试一下是否好用，开发就是要稳扎稳打，保证每个功能稳定。测试嘛，给它们搭一个小舞台，让它们上去表演一下，哈哈。我们要的就是往某页写入数据，再读出来，看看是否相同，注意你程序的大小不要把当前运行的代码覆盖咯。

void Test_Flash_WR(uint8_t Page_Num)
{
    uint16_t i = 0;
    uint8_t j = 0;
    
    //是否超出范围
    if(Page_Num > STM32_SECTOR_NUM)
        return;
    
    for(i = 0;i < STM32_SECTOR_SIZE;i++)
    {
        buff[i] = j++;
    }
    //页擦除
//  Flash_EraseSector(Page_Num,Page_Num);
    //写入
//  FLASH_WritePage(Page_Num,buff);
    //写入
//  FLASH_WriteNByte(Page_Num * STM32_SECTOR_SIZE + STM32_FLASH_BASE,buff,STM32_SECTOR_SIZE);
    //写入
    FLASH_WriteNData(Page_Num * STM32_SECTOR_SIZE + STM32_FLASH_BASE + 4,buff,10);
    //清零
    memset(buff,0,STM32_SECTOR_SIZE);
    //读出
    FLASH_ReadPage(Page_Num,buff);
    
    for(i = 0;i < STM32_SECTOR_SIZE;i++)
    {
        printf("%02X ",buff[i]);
    }
    printf("\r\n");
}

二、分区规划

• 写完FLASH接口函数，下来就是进行对我们的FLASH进行分区了，这样才知道我们的数据到底应该写到哪里。下面是我自己使用的分区方式。
• 首先是Bootloader分区，放置我们的引导程序，主要负责判断标志来决定是跳转到app分区运行，还是进行程序更新，又或者是需要恢复出厂程序。
• 其次是APP分区，这里存放的是我们的主程序。
• 下来是Download分区，负责存储我们下发的更新代码，这样做是保证代码完整再进行更新，保证更新成功率。
• 最后是Flag分区，存放一些标志性数据。

分区	大小	扇区	备注
Bootloader	12K	0 - 5	引导程序
APP	100K	6 - 55	存储App
Download	100K	56 - 105	下载缓存
Flag	2K	255	升级标志

三、Bootloader程序实现

• 说一下Bootloader程序设计思路吧，单片机上电进入Bootloader程序，先判断升级标志是否需要升级固件，需要就把Download分区拷贝到app分区，然后清空升级标志；下来判断是否右APP分区中断向量表是否正确，正确说明有app可以跑，直接跳转到app运行；如果没有在bootloader里循环等待接收app固件。下面是我程序的整体框架：

#define FLASH_APP_ADDR                STM32_SECTOR6_ADDR
#define FLASH_DOWNLOAD_ADDR     STM32_SECTOR56_ADDR
#define FLASH_APP_FLAG                 STM32_SECTOR255_ADDR
#define FLASH_UPDATA_FLAG           FLASH_APP_FLAG + 2

int main(void)
{
    SystemInit();
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
    Delay_Init();
    
    LED_Init();
    KEY_Init();
    USART1_Init(115200);
    
    //判断是否需要升级固件
    if(FLASH_ReadHalfWord(FLASH_UPDATA_FLAG) == 0xAA55)
    {
        printf("Updata App...\r\n");
        
        IAP_Copy_App();//拷贝到app分区
        
        printf("Updata App Succeed...\r\n");
    }
    //判断是否有APP程序
    //中断向量表判断
    if(((*(vu32*)(FLASH_APP_ADDR + 4))&0xFF000000) == 0x08000000)
    {
        printf("Run App...\r\n\r\n");
        
        Delay_ms(10);
        IAP_Load_App(FLASH_APP_ADDR);//转到app
    }
    
    printf("No App\r\n");
    
    TIM3_Init(1000,72);//定时0.001s
    
    while(1)
    {
        Task_Process();
        
        if(USART1_RX_CNT > 0)
        {
            IAP_WriteBin(FLASH_DOWNLOAD_ADDR,USART1_RxBuff,USART1_RX_CNT);
            USART1_RX_CNT = 0;
        }
    }
}

• 这里我们需要实现的函数有IAP_Copy_App()和IAP_Load_App()，代码如下：

typedef void (*IAP_Fun)(void);
IAP_Fun JumpApp;

uint8_t STM32_FLASH_BUFF[STM32_SECTOR_SIZE] = {0};

void IAP_Copy_App(void)
{
    uint8_t i;
    uint8_t buf[2] = {0x00,0x00};
    //擦除App扇区
    Flash_EraseSector(6,55);
    
    for(i = 0;i < 50;i++)
    {
        FLASH_ReadPage(56 + i,STM32_FLASH_BUFF);
        FLASH_WritePage(6 + i,STM32_FLASH_BUFF);
        LED3 = !LED3;
    }
    
    FLASH_WriteNData(FLASH_UPDATA_FLAG,buf,2);
}

void IAP_Load_App(uint32_t Addr)
{
    //检查栈顶地址是否合法
    if(((*(vu32*)Addr) & 0x2FFE0000) == 0x20000000)
    {
        __disable_irq();
        JumpApp = (IAP_Fun)*(vu32 *)(Addr + 4);
        MSR_MSP(*(vu32 *)Addr);
        JumpApp();
    }
}

• 然后我们还要写一个关于下载程序的函数IAP_WriteBin()，一般我们数据会通过串口或网口下发过来，下发的数据要保存到下载分区，所以需要一个写数据到下载分区的函数。

void IAP_WriteBin(uint32_t Addr,uint8_t *pBuff,uint32_t Len)
{
    uint8_t buf[2] = {0xAA,0x55};
    //擦除App扇区
    Flash_EraseSector(6,55);
    //写入程序
    FLASH_WriteNByte(Addr,pBuff,Len);
    //更新标记
    FLASH_WriteNData(FLASH_UPDATA_FLAG,buf,2);
    //复位单片机
    NVIC_SystemReset();
}

来源：https://www.cnblogs.com/ZzJan/p/11564060.html