STM32的OTA升级方案

于 2024-07-28 15:48:53 发布
阅读量697 收藏 6
点赞数 20
文章标签： stm32 嵌入式硬件 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Norgin_1/article/details/140749541
版权

简介

        本设计是基于STM32F103ZET6的HAL库的串口OTA升级方案，用的是Xmodem+串口的升级方案，代码部分有部分模块参考了别人写的，但整个项目框架是完完全全自己搭建的。接下来就开始分模块介绍本项目。

项目思路

        其实，实现OTA的方案很简单，就是把STM32的flash分成两个分区，一个分区叫BOOT分区（本项目由于是基于STM32实现，就叫SBOOT），另一个分区就是程序分区（APP），是你板子启动后运行的功能。有了这两个分区，想要实现OTA升级，就很好办了。用BOOT分区去擦写程序分区，便可实现对程序的更新。而程序分区则和我们正常写的单片机程序差别不大，主要是自己想实现的功能。所以实现整个OTA升级的关键是在BOOT分区的搭建上。

SBOOT分区的搭建

        此分区是单片机上电后运行的第一个分区，在这里我们要实现的功能有以下两点

        1、接收程序代码，烧录到APP分区。

        2、跳转到程序分区执行。

Xmodem协议接收

        先来介绍一下Xmodem协议

        通讯流程

        1、发送方等待接收方的C

        2、收到接收方的C后，发送第一包数据

        3、接收方收到数据后停止发C，在数据源校验无误后，发送ACK;校验有误，发送NACK；

        4、发送方收到ACK后发送下一包数据，收到NACK重复发送当前一包数据（在接收到ACK/NACK前发送方处在静默状态）。

        5、最后一包发送完，发送方发送EOT。

        6、接收方收到EOT回ACK.

以上便是完整一次Xmodem的传输。

        数据包

        数据包构成如下（本次采用的是128byte形式）

        帧头|第几包数据|255-第几包数据|[0-127]个数据|CRC校验高八位|CRC低八位

        帧头固定为0x01，而接收方只需要拿到数据后做一次CRC校验，便可以确定数据接收有无错误。

        ACK:发送十六进制06；

        NACK：发送十六进制15；

接收代码实现

        此处比较难的点就是对数据包的校验，和对数据包个数的处理。我在网上看很多人的代码接收了直接写入单片机的flash，我个人是非常不建议大家用这种写法的，首先对单片机的flash擦写本就有寿命，高频的擦写非常的不好。其次由于这是在中断回调函数中，涉及到Flash的擦除非常耗时，有可能会导致程序死锁（亲测），也不利于代码的编写。所以我建议大家还是在完整接收完一整个数据缓存好后，再统一的对flash进行擦写。

        norflash的驱动代码。由于我是正点原子的板子，所以就直接移植来用了，大家有其他缓存芯片也可以，不一定非要norflash。

//这里是截取自我代码中的串口DMA空闲中断回调函数
        else if(BootStructINFO.BootFlag==UPDATE)                                                    //如果是更新模式
        {
            if(rx_buf[0]==0x01&&data_leng==133)                                                     //如果包头是0x01，包长度为133，则一包数据初步认为正确
            {
                BootStructINFO.Event_bit&=~EVENT_C_BIT;                                             //把发C事件标志位给清零，停止发C
                BootStructINFO.XmodeCRC= Xmodem_crc16(&rx_buf[3],128);                              //对128字节数据校验
                if(BootStructINFO.XmodeCRC==(rx_buf[131]*256+rx_buf[132]))                          //如果我们的CRC和数据包给的CRC一致，可以确认这是一包完全正确的数据
                {
                    BootStructINFO.XmodeRecNum+=1;                                                  //接收数+1，这里的接收数是接收数据包的个数，方便后期统计接收数据量
                    memcpy(&Updatebuff[0+128*((BootStructINFO.XmodeRecNum-1)%16)],&rx_buf[3],128);  //把中间的数据段给复制到UpdaeBuff中（这里我设置的数组大小为2048,也就是说16包数据才能填满一个缓冲区）
                    if((BootStructINFO.XmodeRecNum)%16==0)                                          //如果接收到16包数据，即此刻缓冲区已经满了
                    {
                        BootStructINFO.XmodeRecPge+=1;                                              //接收到的页数+1，也是方便后期进行数据搬运
                        norflash_write(Updatebuff,(BootStructINFO.XmodeRecPge-1)*2048,2048);        //把接收到的数据写入Norflash里（外置Norflash）
                        
                    }
                    printf("\x06");                                                                 //发送ACK
                }
            else
                {
                    printf("\x15");                                                                 //如果不是数据正确的情况，就发送NACK   
                }
            }
            else if(data_leng==1&&rx_buf[0]==0x04)                                                  //如果接收到长度为1，且为0x04的数据，则表明已经完成一次协议通讯了
            {
                printf("\x06");                                                                     //发送一个ACK高职
                if(BootStructINFO.XmodeRecNum%16!=0)                                                //这里，由于我们接收到的数据量不可能是2048的整数倍，可能会多出几包数据这里进行一个判断
                {
                    BootStructINFO.XmodeRceLstPN = BootStructINFO.XmodeRecNum%16;                   //如果这里把多出来的数据包数量存起来，方便后期搬运
                    norflash_write(Updatebuff,BootStructINFO.XmodeRecPge*2048,(BootStructINFO.XmodeRceLstPN)*128);  //把多出来的数据写入Norflash
                    BootStructINFO.XmodeRecPge+=1;                                                  //因为我们是新开一页写的，这里不要忘记页数+1
                }
                BootStructINFO.Event_bit|=EVENT_FLASH_BIT;                                          //使能FLASH更新标志事件
            }
            else
            {
                printf("\x15");
            }
//CRC校验，没什么好讲的，大家感兴趣自己去学一下
uint16_t Xmodem_crc16(uint8_t *data,uint16_t datalen)
{
    uint8_t i;
    uint16_t Crcinit = 0x0000;
    uint16_t Crcipoly = 0x1021;//这个是通讯协议规定了的
    while(datalen--)
    {
        Crcinit = (*data<<8)^Crcinit;
        for(i=0;i<8;i++)
        {
            if(Crcinit&0x8000)
            {
                Crcinit = (Crcinit<<1)^Crcipoly;
            }
            else
            {
                Crcinit = (Crcinit<<1);
            }
        }
        data++;
    }
    return  Crcinit;
    
}

 Flash的写入

        在接收完一整包数据后，就开始写入单片机的flash了，这里补充一点前置知识。

关于单片机的Flash

        1、单片机的flash的数据只能从1变为0，不能从0变为1，所以在写入之前要先擦除

        2、单片机的flash只能按页擦除。

        3、stm32单片机的flash页大小分为两种情况，128k以下的一页1k，128k以上的2k一页。我的是zet6 512k以2k为一页有256页

        4、单片机flash寻找是从0x08000000开始的。

有了以上知识，大家看我这里关于flash空间操作的宏定义应该就不难了，这里我们分了20页flash给SBOOT用，合计20*2048byte（实际代码用不了这么多），剩余的全用作程序分区。

     else if(BootStructINFO.BootFlag==UPDATE)
     {
         if(BootStructINFO.Event_bit&EVENT_MSG_BIT)//这里是一个状态机的开始标志位，切换到UPdata模式后，先输出提示信息
         {
            printf("Warning:Cant quit before finished\r\n");
            printf("Please Use the XModem Dowload\r\n");
            BootStructINFO.Event_bit &= ~EVENT_MSG_BIT;
            BootStructINFO.Event_bit |= EVENT_C_BIT;
         }
         else if(BootStructINFO.Event_bit&EVENT_C_BIT)//跳转到发C状态
         {
             BootStructINFO.XmodeTimer++;
             if(BootStructINFO.XmodeTimer==2)
             {
                 BootStructINFO.XmodeTimer=0;
                 printf("C");
             }
         }
        else if(BootStructINFO.Event_bit&EVENT_FLASH_BIT)//如果接收完成使能了写入位开始写入数据
        {
            printf("ready write %d pack\r\n",BootStructINFO.XmodeRecNum);
            HAL_Delay(3000);
            eraseflash(SYS_START_PAG,SYS_PAGE);         //先对主程序部分的256-20页全部擦除
            printf("Erase Done\r\n");
            BootStructINFO.Event_bit&=~EVENT_FLASH_BIT; //把写入先失能，避免重复触发
            memset(Updatebuff,0,2048);                  //把updatebuf清零，后续要用这个做数据搬运桥梁
            for(uint16_t i=0;i<BootStructINFO.XmodeRecPge-1;i++)//这里我们先用一个for循环写入除最后一页外的其他页（因为最后一页有可能并不满2048个数据，所以要单独判断）
            {
                norflash_read(Updatebuff,0x00000000+i*PAGE_SIZE,PAGE_SIZE);
                writeflash(SYS_START_ADDR+i*PAGE_SIZE,(uint32_t *)Updatebuff,PAGE_SIZE);
            }
            if(BootStructINFO.XmodeRceLstPN==0)//如果接收的余出来的数据包为0即，恰好是放满整页的的（128byte的数据包）
            {
                norflash_read(Updatebuff,0x00000000+(BootStructINFO.XmodeRecPge-1)*PAGE_SIZE,PAGE_SIZE);//直接写一页
                writeflash(SYS_START_ADDR+(BootStructINFO.XmodeRecPge-1)*PAGE_SIZE,(uint32_t *)Updatebuff,PAGE_SIZE);
            }
            else//如果有余出来的
            {
                norflash_read(Updatebuff,0x00000000+(BootStructINFO.XmodeRecPge-1)*PAGE_SIZE,BootStructINFO.XmodeRceLstPN*128);//把余出来的单独读写
                writeflash(SYS_START_ADDR+(BootStructINFO.XmodeRecPge-1)*PAGE_SIZE,(uint32_t *)Updatebuff,BootStructINFO.XmodeRceLstPN*128);
            }
            printf("Write Finished\r\n");//写完以后打印
            HAL_Delay(2000);
            HAL_NVIC_SystemReset();//重启系统
        }
     }

flash写入和擦除的代码是经过封装的，现在把这些函数贴出来。

uint8_t eraseflash(uint16_t addr,uint16_t nbPages)
{
    unsigned int pageError = 0;
    uint32_t pageAddress = 0x08000000+addr*2048;
    FLASH_EraseInitTypeDef eraseInit;
    eraseInit.TypeErase = FLASH_TYPEERASE_PAGES;
    eraseInit.PageAddress = pageAddress;
    eraseInit.Banks = FLASH_BASE;
    eraseInit.NbPages = nbPages;
    HAL_FLASH_Unlock();
    if(HAL_FLASHEx_Erase(&eraseInit,&pageError) != HAL_OK)
    {
        HAL_FLASH_Lock();
        return 1;
    }
    HAL_FLASH_Lock();
    return 0;

}


void writeflash(uint32_t saddr,uint32_t *wdata,uint32_t wnum)
{
    HAL_FLASH_Unlock();
    while(wnum)
    {
        HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD,saddr,*wdata);
        wnum -=4;
        saddr+=4;
        wdata++;
    }
    HAL_FLASH_Lock();
}

系统完整性搭建

main函数（HAL库生成的）

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2024 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "dma.h"
#include "usart.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "oled.h"
#include "stdio.h"
#include "crc.h"
#include "flash_ctrl.h"
#include "boot.h"
#include "norflash.h"
#include "string.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
uint8_t rx_buf[270];
uint8_t Updatebuff[PAGE_SIZE];
struct BOOT_Struct {
    uint8_t BootFlag;
    uint8_t Event_bit;
    uint32_t XmodeTimer;
    uint32_t XmodeRecNum;
    uint32_t XmodeCRC;
    uint32_t XmodeRecPge;
    uint32_t XmodeRceLstPN;
}BootStructINFO;

struct Wait_struct{
    uint8_t Wait_Cmd;
    uint8_t Cmd_Count;
}WaitTimeCount;

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_USART1_UART_Init();
  /* USER CODE BEGIN 2 */
  HAL_UARTEx_ReceiveToIdle_DMA(&huart1,rx_buf,270);
  BootStructINFO.BootFlag = WAIT_CMD;
  norflash_init();
  printf("Press a within 3 seconds to enter sboot\r\n");
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
     HAL_Delay(100);
     if(BootStructINFO.BootFlag==WAIT_CMD)
     {
         WaitTimeCount.Wait_Cmd++;
         if(WaitTimeCount.Wait_Cmd%10==0)
         {
             printf("Press a within %1d seconds to enter sboot\r\n",3-(WaitTimeCount.Wait_Cmd/10));
         }
         if(WaitTimeCount.Wait_Cmd==30)//倒计时结束跳转到主分区
         {
             HAL_DeInit();
             __set_PRIMASK(1);
             Load_SYS_User(SYS_START_ADDR);
         }
     }
     else if(BootStructINFO.BootFlag==INTO_CMD)//输出命令行
     {
         WaitTimeCount.Cmd_Count++;
         if(WaitTimeCount.Cmd_Count%50==0)
         {
             WaitTimeCount.Cmd_Count=0;
             printf("/***********************************************************/\r\n");
             printf("[A] Update the System\r\n");
             printf("[B] Run into the MainSys\r\n");
             printf("[C] Restart the Sysyem\r\n");
             printf("\r\n\r\n\r\n\r\n");
         }

     }
     else if(BootStructINFO.BootFlag==UPDATE)
     {
         if(BootStructINFO.Event_bit&EVENT_MSG_BIT)//这里是一个状态机的开始标志位，切换到UPdata模式后，先输出提示信息
         {
            printf("Warning:Cant quit before finished\r\n");
            printf("Please Use the XModem Dowload\r\n");
            BootStructINFO.Event_bit &= ~EVENT_MSG_BIT;
            BootStructINFO.Event_bit |= EVENT_C_BIT;
         }
         else if(BootStructINFO.Event_bit&EVENT_C_BIT)//跳转到发C状态
         {
             BootStructINFO.XmodeTimer++;
             if(BootStructINFO.XmodeTimer==2)
             {
                 BootStructINFO.XmodeTimer=0;
                 printf("C");
             }
         }
        else if(BootStructINFO.Event_bit&EVENT_FLASH_BIT)//如果接收完成使能了写入位开始写入数据
        {
            printf("ready write %d pack\r\n",BootStructINFO.XmodeRecNum);
            HAL_Delay(3000);
            eraseflash(SYS_START_PAG,SYS_PAGE);         //先对主程序部分的256-20页全部擦除
            printf("Erase Done\r\n");
            BootStructINFO.Event_bit&=~EVENT_FLASH_BIT; //把写入先失能，避免重复触发
            memset(Updatebuff,0,2048);                  //把updatebuf清零，后续要用这个做数据搬运桥梁
            for(uint16_t i=0;i<BootStructINFO.XmodeRecPge-1;i++)//这里我们先用一个for循环写入除最后一页外的其他页（因为最后一页有可能并不满2048个数据，所以要单独判断）
            {
                norflash_read(Updatebuff,0x00000000+i*PAGE_SIZE,PAGE_SIZE);
                writeflash(SYS_START_ADDR+i*PAGE_SIZE,(uint32_t *)Updatebuff,PAGE_SIZE);
            }
            if(BootStructINFO.XmodeRceLstPN==0)//如果接收的余出来的数据包为0即，恰好是放满整页的的（128byte的数据包）
            {
                norflash_read(Updatebuff,0x00000000+(BootStructINFO.XmodeRecPge-1)*PAGE_SIZE,PAGE_SIZE);//直接写一页
                writeflash(SYS_START_ADDR+(BootStructINFO.XmodeRecPge-1)*PAGE_SIZE,(uint32_t *)Updatebuff,PAGE_SIZE);
            }
            else//如果有余出来的
            {
                norflash_read(Updatebuff,0x00000000+(BootStructINFO.XmodeRecPge-1)*PAGE_SIZE,BootStructINFO.XmodeRceLstPN*128);//把余出来的单独读写
                writeflash(SYS_START_ADDR+(BootStructINFO.XmodeRecPge-1)*PAGE_SIZE,(uint32_t *)Updatebuff,BootStructINFO.XmodeRceLstPN*128);
            }
            printf("Write Finished\r\n");//写完以后打印
            HAL_Delay(2000);
            HAL_NVIC_SystemReset();//重启系统
        }
     }
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */
void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
{
    if(huart->Instance==USART1)
    {
        uint8_t data_leng = 270-__HAL_DMA_GET_COUNTER(&hdma_usart1_rx);//计算本次接收到的字符串个数
        if(BootStructINFO.BootFlag==WAIT_CMD)//如果在等a模式下
        {
            if(data_leng==1&&rx_buf[0]=='a')//接收到a
            {
                BootStructINFO.BootFlag=INTO_CMD;//进入输出控制台模式
                WaitTimeCount.Cmd_Count=49;
            }
        }
        else if(BootStructINFO.BootFlag==INTO_CMD)//如果在控制台模式下
        {
            if(data_leng==1)
            {
                switch(rx_buf[0])//收到以下字符
                {
                    case 'A':{BootStructINFO.BootFlag=UPDATE;BootStructINFO.Event_bit |= EVENT_MSG_BIT;}break;
                    case 'B':Load_SYS_User(SYS_START_ADDR);break;
                    case 'C':HAL_NVIC_SystemReset();break;
                    default:printf("cmd erro\r\n");break;
                }
            }
            else
            {
                printf("cmd erro\r\n");
            }
        }
        else if(BootStructINFO.BootFlag==UPDATE)                                                    //如果是更新模式
        {
            if(rx_buf[0]==0x01&&data_leng==133)                                                     //如果包头是0x01，包长度为133，则一包数据初步认为正确
            {
                BootStructINFO.Event_bit&=~EVENT_C_BIT;                                             //把发C事件标志位给清零，停止发C
                BootStructINFO.XmodeCRC= Xmodem_crc16(&rx_buf[3],128);                              //对128字节数据校验
                if(BootStructINFO.XmodeCRC==(rx_buf[131]*256+rx_buf[132]))                          //如果我们的CRC和数据包给的CRC一致，可以确认这是一包完全正确的数据
                {
                    BootStructINFO.XmodeRecNum+=1;                                                  //接收数+1，这里的接收数是接收数据包的个数，方便后期统计接收数据量
                    memcpy(&Updatebuff[0+128*((BootStructINFO.XmodeRecNum-1)%16)],&rx_buf[3],128);  //把中间的数据段给复制到UpdaeBuff中（这里我设置的数组大小为2048,也就是说16包数据才能填满一个缓冲区）
                    if((BootStructINFO.XmodeRecNum)%16==0)                                          //如果接收到16包数据，即此刻缓冲区已经满了
                    {
                        BootStructINFO.XmodeRecPge+=1;                                              //接收到的页数+1，也是方便后期进行数据搬运
                        norflash_write(Updatebuff,(BootStructINFO.XmodeRecPge-1)*2048,2048);        //把接收到的数据写入Norflash里（外置Norflash）
                        
                    }
                    printf("\x06");                                                                 //发送ACK
                }
            else
                {
                    printf("\x15");                                                                 //如果不是数据正确的情况，就发送NACK   
                }
            }
            else if(data_leng==1&&rx_buf[0]==0x04)                                                  //如果接收到长度为1，且为0x04的数据，则表明已经完成一次协议通讯了
            {
                printf("\x06");                                                                     //发送一个ACK高职
                if(BootStructINFO.XmodeRecNum%16!=0)                                                //这里，由于我们接收到的数据量不可能是2048的整数倍，可能会多出几包数据这里进行一个判断
                {
                    BootStructINFO.XmodeRceLstPN = BootStructINFO.XmodeRecNum%16;                   //如果这里把多出来的数据包数量存起来，方便后期搬运
                    norflash_write(Updatebuff,BootStructINFO.XmodeRecPge*2048,(BootStructINFO.XmodeRceLstPN)*128);  //把多出来的数据写入Norflash
                    BootStructINFO.XmodeRecPge+=1;                                                  //因为我们是新开一页写的，这里不要忘记页数+1
                }
                BootStructINFO.Event_bit|=EVENT_FLASH_BIT;                                          //使能FLASH更新标志事件
            }
            else
            {
                printf("\x15");
            }
        }
        else
        {
            printf("\x15");
        }
        memset(rx_buf,0,270);
        HAL_UARTEx_ReceiveToIdle_DMA(&huart1,(uint8_t *)rx_buf,270);
    }
}


void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{
    printf("error now\r\n");
}


/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

最后就是跳转代码，这里用了点汇编，也是借鉴了一个大佬的写法。

typedef void (*load_sys)(void);



load_sys Load_SYS;




__ASM void MSR_SP(uint32_t addr)//汇编传参，addr是第一个变量，值直接给到r0寄存器
{
    MSR MSP,r0//设置sp指针
    BX r14  //恢复现场
}


void Load_SYS_User(uint32_t addr)
{
    if((*(uint32_t *)addr>0x20000000-1)&&((*(uint32_t *)addr<(0x20000000+0x10000))))//看看指针是否在合理区间（RAM中）
    {
        MSR_SP(*(uint32_t *)addr);//sp跳转
        Load_SYS = (load_sys)*(uint32_t *)(addr+4);//地址强转为函数，这里转的是(程序区)复位Reset_Handler回调函数
        BOOT_Clear();
        Load_SYS();//执行复位函数
    }
}

void BOOT_Clear(void)//初始化的清理
{
    HAL_UART_DeInit(&huart1);
    HAL_SPI_DeInit(&g_spi2_handler);
    HAL_DeInit();
}

基本上分区搭建的代码差不多就到这里了，后续还有一个细节要修改。

这里改为整片擦除，然后先烧录SBOOT程序再烧录APP

APP分区的搭建

         这部分没什么特别的，改一下程序的起始地址和中断向量表，设置一个脚本生成.bin文件就好了。

        修改程序起始地址，改成SBOOT分区之后

        设置中断向量表，hal库下设置中断向量表不在.s文件下，而是在system_stm32f1xx.c下，找到，把这里的注释去掉。

写上偏移量（注意，是偏移量，不是地址值）

        添加生成bin文件脚本：fromelf --bin -o ".\bin_file\@L.bin" "#L"

自此整一个OTA的环境就搭建完成了，现在开始测试烧录。

测试

上电提示：

3s无操作跳转到APP区：

按下a呼出控制台

准备烧录（换了个串口软件）：

重启后输出：

非常成功

项目踩坑点总结

        1、在DMA空闲回调函数里直接烧写flash没有norflash缓冲，程序直接跑飞不可取。

        2、在Load_SYS_User(SYS_START_ADDR);加载到APP分区之前，没对BOOT分区初始化的外设去初始化，导致进入到APP后出现各种异常。

        3、接收的数据包的数量换算，很容易算错。

工程共享

        Github:GitHub - Norginx/stm32f103_OTA

        Xmodem工具:链接: https://pan.baidu.com/s/1o4WoXOs3o4Xp21EhCHx6rQ

                                        提取码: u1mi 

Norgin_1
关注
  • 20
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
写一下stm32 ota升级
weixin_35756624的博客
01-03 343
STM32 OTA(Over-The-Air)升级是指通过无线网络更新STM32微控制器上的软件。 实现STM32 OTA升级的基本步骤如下： 在STM32开发板上安装无线网络模块(如Wi-Fi模块)，并使用相应的驱动程序进行配置。 在STM32开发板上运行HTTP服务器，提供文件下载服务。 在STM32开发板上实现软件升级功能。在这个过程中，STM32开发板会连接到HTTP服务器，下载新版...
STM32 OTA 升级
zhoukaiqili的博客
12-31 857
【代码】STM32 OTA 升级。
STM32 OTA升级原理分析
weixin_43482414的博客
03-08 5669
程序运行流程 正常程序运行流程 程序结构 正常程序从起始地址(0x08000000)开始写入 中断向量表(地址:0x08000004)用于存储中断处理程序向量。 中断处理函数(0x08000004+n)用于各种中断服务函数。 main函数(0x08000004+N)，一个死循环，存放用户处理程序 程序启动流程 系统复位启动，从中断向量表中取出复位中断向量 跳转到复位中断处理函数，执行复位中断函数完成启动，跳转到main函数入口。 执行main函数循环。 中断产生，STM32硬件强制将PC指针指向中断向
STM32 OTA远程升级
HuangB的博客
03-12 3428
OTA全称是over the air,主要应用于物联网设备作为更新代码使用，其原理在不同发芯片上相通，应用较为广泛。
STM32 IAP OTA升级 BootLoader 升级方案
GpsZiNdiGs的博客
11-29 716
我们提供了上位机源码（VS2019 NET4.5）和下位机源码（Keil5.25），可以方便地实现Bootloader升级。总之，本方案通过IAP技术实现芯片的升级功能，通过YMODEM 1K协议进行数据传输，支持多种芯片平台的移植，并提供了上位机和下位机的源码，方便用户进行二次开发。为了更好地实现OTA升级，我们开发了基于STM32芯片的Bootloader升级方案。通过以上步骤，我们可以实现基于STM32芯片的IAP OTA升级Bootloader升级方案。连接上位机（PC）并启动上位机程序。
STM32 OTA升级流程 内含其他通信例程
09-15
STM32 OTA升级流程涉及到多个步骤，包括固件打包、服务器部署、设备端接收和验证以及固件更新。 首先，固件打包：在进行OTA升级之前，开发人员需要将新的固件代码编译成二进制文件，并且通常会添加校验码（如MD5或...
STM32G071 OTA升级程序
07-21
总的来说，STM32G071的OTA升级程序是一个综合了Bootloader和IAP功能的解决方案，它使得在产品生命周期中远程更新固件成为可能，提高了产品的可维护性和安全性。对于开发人员来说，理解并掌握这些知识点是实现高效、...
stm32f4双区升级实例工程
07-05
总结来说，"STM32F4双区升级实例工程"提供了一个基于STM32F4的双区升级方案，利用IAP技术和一个标志位实现了在APP1和APP2之间的安全切换。虽然本实例未包含串口升级协议，但其核心思想对于理解STM32的在线升级机制...
STM32F103 USB OTA升级源码
08-26
综上所述，STM32F103 USB OTA升级源码涉及到的知识点广泛，包括USB协议、Bootloader设计、固件更新流程、安全性以及嵌入式系统开发工具和实践。理解并掌握这些知识点，对于开发安全、可靠的STM32设备更新机制至关...
stm32G070CBT6A，OTA, IAP升级
04-13
stm32G070CBT6A的OTA升级程序，采用IAP方案，数据用串口Ymodem协议传输bin文件，输入2开始等待下载并写入，输入3跳转到用户APP，跳转成功打印hello world. 从APP跳转到bootloader可通过按键方式。
STM32智能医疗监控系统教程
stm32d1219的博客
07-21 1211
本教程详细介绍了如何在STM32嵌入式系统中实现智能医疗监控系统，从硬件选择、软件实现到系统配置和应用场景都进行了全面的阐述。通过合理的技术选择和系统设计，可以构建一个高效且功能强大的智能医疗监控系统。
韦东山嵌入式linux系列-具体单板的按键驱动程序(查询方式)
StudyWinter的博客
07-24 904
button_operations 结 构 体 中 有 init 函 数 指 针 ， 它 指 向board_stm32mp157_button_init 函数，在里面将会初始化 LED 引脚：使能、设置为 GPIO 模式、设置为输出引脚。该寄存器共32位，涉及16个GPIO，每个GPIO对应 2 位。button_operations 结 构 体 中 还 有 有 read 函 数 指 针 ， 它 指 向board_stm32mp157_button_read 函数，在里面将会读取并返回按键引脚的电平。
STM32嵌入式人工智能边缘计算应用教程
2401_84204806的博客
07-23 786
本教程详细介绍了如何在STM32嵌入式系统中实现嵌入式人工智能边缘计算系统，从硬件选择、软件实现到系统配置和应用场景都进行了全面的阐述。通过合理的技术选择和系统设计，可以构建一个高效且功能强大的嵌入式人工智能边缘计算系统。
我在高职教STM32——串口通信（5）
gmc832002的博客
07-20 2109
本文是串口通信的第五部分，也是最后一部分，我们来详细解读一下串口收发的工程源码。
STM32智能城市交通管理系统教程
stm32d1219的博客
07-24 611
本教程详细介绍了如何在STM32嵌入式系统中实现智能城市交通管理系统，从硬件选择、软件实现到系统配置和应用场景都进行了全面的阐述。通过合理的技术选择和系统设计，可以构建一个高效且功能强大的智能城市交通管理系统。在未来的发展中，智能城市交通管理系统可以进一步结合人工智能和大数据分析技术，提升系统的智能化程度，为城市交通管理提供更强大的技术支持。希望本教程能够为读者提供有价值的参考和指导，助力智能城市交通管理系统的开发与实现。
【MSP430】MSP430是什么？与STM32对比哪个性能更佳？
最新发布
2201_75797484的博客
07-24 657
首先，MSP430F5529LP集成了一个16位RISC处理器，可以执行16位指令，提供更高的运行速度。它可以用于消费类电子产品如智能家居设备、智能安全设备、智能家电等，也可以支持多种接口，如USB、I2C、SPI等，以满足客户的需求。为了帮助开发者更好地利用MSP430F5529LP的特性，德州仪器提供了丰富的开发资源，包括开发套件、数据表和应用指南。综上所述，MSP430F5529LP不仅具有强大的硬件性能和广泛的应用领域，同时还得到了德州仪器全方位的技术支持。
我在高职教STM32——串口通信（4）
gmc832002的博客
07-20 991
本文是串口通信的第四部分，开始着手编写串口收发测试的工程，明确目标，并初步解读工程源码。
RT-Thread debug 卡死在Stm32_putc问题分析解决
qq_36720691的博客
07-24 899
RT-Thread debug 卡死在Stm32_putc问题分析解决
STM32自己从零开始实操10：PCB全过程
Xuexi_touteng的博客
07-15 864
铝电解电容走线必须正儿八经沿着电源电流方向走出来的粗走线。小电容可以不是正儿八经从电源处引出来的走线，可以采用就近原则，在电源走线后面一点处，而且是 0.3mm 的细走线。5V 的线在小器件处可以走细线。STM32 出来的信号线全部 0.25mm。（比其他的信号 0.3mm 细一点，不然布不下）每一个小模块周边的电阻电容等小器件，一要注意在位置足够的前提下布局不用太过紧凑，因为后期很可能需要经过走线。
stm32 ota 4g
10-23
STM32 OTA 4G是一种基于STM32微控制器和4G模组的OTA（Over-The-Air）升级方案。该方案通过使用4G网络连接到云平台，实现了远程升级设备的固件。在该方案中，STM32微控制器通过AT指令连接到MQTT平台，使用HTTP下载将要升级的BIN文件。同时，该方案还使用了状态机编程，以实现OTA升级业务。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值