stm32串口IAP升级程序C代码

以下是基于STM32的串口IAP升级程序C代码，供参考：

#include "stm32f10x.h"
#include <stdio.h>

/* 以下为IAP升级相关参数 */
#define FLASH_APP1_ADDR     0x08004000  // APP1地址
#define FLASH_APP2_ADDR     0x08020000  // APP2地址
#define FLASH_PAGE_SIZE     0x400       // Flash页大小
#define FLASH_LAST_PAGE     127         // 最后一页
#define FLASH_APP1_FLAG     0x5A5A5A5A  // APP1标志位
#define FLASH_APP2_FLAG     0xA5A5A5A5  // APP2标志位

/* 以下为串口相关参数 */
#define USARTx              USART1
#define USARTx_IRQn         USART1_IRQn
#define USARTx_IRQHandler  USART1_IRQHandler
#define USARTx_CLK          RCC_APB2Periph_USART1
#define USARTx_GPIO_CLK     RCC_APB2Periph_GPIOA
#define USARTx_TX_GPIO_PIN  GPIO_Pin_9
#define USARTx_RX_GPIO_PIN  GPIO_Pin_10
#define USARTx_GPIO_PORT    GPIOA
#define USARTx_BAUDRATE     115200

/* 以下为函数声明 */
void USARTx_Config(void);
void USARTx_SendChar(uint8_t ch);
void USARTx_SendString(char *str);
void USARTx_SendData(uint8_t *pData, uint16_t len);
void USARTx_ReceiveData(uint8_t *pData, uint16_t len);
void USARTx_IRQHandler(void);
void Delay(uint32_t nCount);
void FLASH_ErasePage(uint32_t PageAddress);
void FLASH_WriteData(uint32_t Address, uint8_t *pData, uint16_t len);
void FLASH_WriteApp1Flag(void);
void FLASH_WriteApp2Flag(void);
void JumpToApp(uint32_t appAddr);

/* 以下为全局变量 */
uint8_t g_rxBuffer[512];
uint32_t g_rxLength = 0;

int main(void)
{
    /* 初始化串口 */
    USARTx_Config();

    /* 打印欢迎信息 */
    USARTx_SendString("\r\n\r\n");
    USARTx_SendString("----------------------------\r\n");
    USARTx_SendString("  STM32串口IAP升级程序\r\n");
    USARTx_SendString("  版权所有 (C) 2021\r\n");
    USARTx_SendString("  版本：V1.0\r\n");
    USARTx_SendString("----------------------------\r\n");

    /* 接收升级数据 */
    USARTx_SendString("等待升级数据...\r\n");
    while (1)
    {
        /* 接收数据 */
        USARTx_ReceiveData(g_rxBuffer + g_rxLength, 512 - g_rxLength);

        /* 判断是否接收完成 */
        if (g_rxLength >= 512 || g_rxBuffer[g_rxLength - 1] == 0x04)
        {
            break;
        }
    }

    /* 关闭串口 */
    USART_ITConfig(USARTx, USART_IT_RXNE, DISABLE);
    USART_Cmd(USARTx, DISABLE);
    RCC_APB2PeriphClockCmd(USARTx_CLK, DISABLE);
    RCC_APB2PeriphClockCmd(USARTx_GPIO_CLK, DISABLE);

    /* 擦除APP2 */
    FLASH_Unlock();
    FLASH_ErasePage(FLASH_APP2_ADDR);
    FLASH_Lock();

    /* 写入APP2 */
    FLASH_Unlock();
    FLASH_WriteData(FLASH_APP2_ADDR, g_rxBuffer, g_rxLength);
    FLASH_Lock();

    /* 写入APP1标志位 */
    FLASH_Unlock();
    FLASH_WriteApp1Flag();
    FLASH_Lock();

    /* 写入APP2标志位 */
    FLASH_Unlock();
    FLASH_WriteApp2Flag();
    FLASH_Lock();

    /* 跳转至APP2 */
    JumpToApp(FLASH_APP2_ADDR);

    return 0;
}

/* 串口配置 */
void USARTx_Config(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;

    /* 使能USARTx和GPIOA时钟 */
    RCC_APB2PeriphClockCmd(USARTx_CLK, ENABLE);
    RCC_APB2PeriphClockCmd(USARTx_GPIO_CLK, ENABLE);

    /* 配置USARTx的TX和RX引脚 */
    GPIO_InitStructure.GPIO_Pin = USARTx_TX_GPIO_PIN;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_Init(USARTx_GPIO_PORT, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = USARTx_RX_GPIO_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(USARTx_GPIO_PORT, &GPIO_InitStructure);

    /* 配置USARTx */
    USART_InitStructure.USART_BaudRate = USARTx_BAUDRATE;
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    USART_InitStructure.USART_StopBits = USART_StopBits_1;
    USART_InitStructure.USART_Parity = USART_Parity_No;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    USART_Init(USARTx, &USART_InitStructure);

    /* 配置USARTx中断 */
    NVIC_InitStructure.NVIC_IRQChannel = USARTx_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    /* 使能USARTx接收中断 */
    USART_ITConfig(USARTx, USART_IT_RXNE, ENABLE);

    /* 使能USARTx */
    USART_Cmd(USARTx, ENABLE);
}

/* 发送一个字符 */
void USARTx_SendChar(uint8_t ch)
{
    USART_SendData(USARTx, ch);
    while (USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET);
}

/* 发送一个字符串 */
void USARTx_SendString(char *str)
{
    while (*str != '\0')
    {
        USARTx_SendChar(*str++);
    }
}

/* 发送数据 */
void USARTx_SendData(uint8_t *pData, uint16_t len)
{
    while (len--)
    {
        USARTx_SendChar(*pData++);
    }
}

/* 接收数据 */
void USARTx_ReceiveData(uint8_t *pData, uint16_t len)
{
    uint32_t i;

    for (i = 0; i < len; i++)
    {
        /* 判断接收缓冲区是否为空 */
        if (USART_GetFlagStatus(USARTx, USART_FLAG_RXNE) == RESET)
        {
            break;
        }

        /* 读取接收数据 */
        *pData++ = USART_ReceiveData(USARTx);
        g_rxLength++;

        /* 判断是否接收完成 */
        if (g_rxLength >= 512 || g_rxBuffer[g_rxLength - 1] == 0x04)
        {
            break;
        }
    }
}

/* USARTx中断处理函数 */
void USARTx_IRQHandler(void)
{
    uint8_t ch;

    /* 判断是否接收到数据 */
    if (USART_GetITStatus(USARTx, USART_IT_RXNE) != RESET)
    {
        /* 读取接收数据 */
        ch = USART_ReceiveData(USARTx);

        /* 判断是否接收完成 */
        if (g_rxLength >= 512 || ch == 0x04)
        {
            USART_ITConfig(USARTx, USART_IT_RXNE, DISABLE);
        }
    }
}

/* 延时函数 */
void Delay(uint32_t nCount)
{
    for (; nCount != 0; nCount--);
}

/* 擦除一个Flash页 */
void FLASH_ErasePage(uint32_t PageAddress)
{
    FLASH_Status status = FLASH_COMPLETE;
    uint32_t addr = PageAddress;

    /* 禁止所有中断 */
    __disable_irq();

    /* 擦除页 */
    status = FLASH_ErasePage(addr);

    /* 使能所有中断 */
    __enable_irq();

    /* 判断是否擦除成功 */
    if (status != FLASH_COMPLETE)
    {
        USARTx_SendString("擦除Flash页失败！\r\n");
        while (1);
    }
}

/* 写入数据到Flash */
void FLASH_WriteData(uint32_t Address, uint8_t *pData, uint16_t len)
{
    FLASH_Status status = FLASH_COMPLETE;
    uint32_t i, j, addr;

    /* 禁止所有中断 */
    __disable_irq();

    /* 写入数据 */
    addr = Address;
    for (i = 0; i < len; i += 4)
    {
        status = FLASH_COMPLETE;

        /* 解锁Flash */
        FLASH_Unlock();

        /* 写入数据 */
        for (j = 0; j < 4; j++)
        {
            if (i + j < len)
            {
                status = FLASH_ProgramWord(addr + j, *(uint32_t *)(pData + i + j));
            }
        }

        /* 锁定Flash */
        FLASH_Lock();

        /* 判断是否写入成功 */
        if (status != FLASH_COMPLETE)
        {
            USARTx_SendString("写入Flash失败！\r\n");
            while (1);
        }

        /* 延时一段时间 */
        Delay(0x1000);
    }

    /* 使能所有中断 */
    __enable_irq();
}

/* 写入APP1标志位 */
void FLASH_WriteApp1Flag(void)
{
    FLASH_Status status = FLASH_COMPLETE;
    uint32_t addr = FLASH_APP1_ADDR - FLASH_PAGE_SIZE;

    /* 禁止所有中断 */
    __disable_irq();

    /* 写入标志位 */
    status = FLASH_ProgramWord(addr, FLASH_APP1_FLAG);

    /* 使能所有中断 */
    __enable_irq();

    /* 判断是否写入成功 */
    if (status != FLASH_COMPLETE)
    {
        USARTx_SendString("写入APP1标志位失败！\r\n");
        while (1);
    }
}

/* 写入APP2标志位 */
void FLASH_WriteApp2Flag(void)
{
    FLASH_Status status = FLASH_COMPLETE;
    uint32_t addr = FLASH_APP2_ADDR - FLASH_PAGE_SIZE;

    /* 禁止所有中断 */
    __disable_irq();

    /* 写入标志位 */
    status = FLASH_ProgramWord(addr, FLASH_APP2_FLAG);

    /* 使能所有中断 */
    __enable_irq();

    /* 判断是否写入成功 */
    if (status != FLASH_COMPLETE)
    {
        USARTx_SendString("写入APP2标志位失败！\r\n");
        while (1);
    }
}

/* 跳转至APP */
void JumpToApp(uint32_t appAddr)
{
    typedef void (*pFunction)(void);
    pFunction Jump_To_Application;
    uint32_t JumpAddress;

    /* 关闭所有中断 */
    __disable_irq();

    /* 获取跳转地址 */
    JumpAddress = *(volatile uint32_t *)(appAddr + 4);

    /* 转换为函数指针 */
    Jump_To_Application = (pFunction)JumpAddress;

    /* 设置堆栈指针 */
    __set_MSP(*(volatile uint32_t *)appAddr);

    /* 跳转至APP */
    Jump_To_Application();
}

注意：上述代码仅供参考，具体实现需要根据具体的硬件平台和需求进行修改。