STM32F4 IAP跳转APP问题及STM32基于Ymodem协议IAP升级笔记

已于 2024-04-10 12:03:26 修改
阅读量807 收藏 27
点赞数 28
分类专栏： STM32 物联网 文章标签： stm32 嵌入式硬件 单片机
于 2024-04-10 10:51:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46577050/article/details/137587359
版权

STM32F4 IAP 跳转 APP问题

ST官网IAP例程

STM32 + IAP + Ymodem完美结合

ST官网提供的IAP例程有很多很多，比如：

库：有使用标准外设库（SPL）的、有使用硬件抽象层库（HAL）的；

通信口：有使用USART的，有使用I2C的，有使用ETH的等。

MCU型号：STM8S、STM32F1、F4、L1等几乎全系列都有。

ST官网提供的各种IAP，其方法和原理其实都类似：就是将程序文件（二进制文件）写入FLASH。

本文以最简单的基于（STM32F10x）利用SPL库+UART的IAP为例来给大家讲述一下。（复杂都是从基础开始，后续逐步为大家更新更高级的IAP功能）

STM32F10xxx in-application programming using the USART官方地址：

https://www.stmicroelectronics.com.cn/content/st_com/en/products/embedded-software/mcus-embedded-software/stm32-embedded-software/stm32-standard-peripheral-library-expansion/stsw-stm32008.html
在这里插入图片描述

Chapter1 STM32F4 IAP 跳转 APP问题

原文链接：https://blog.csdn.net/qinbo1234567890/article/details/128318895

1. 概念

IAP 的作用，网上其他资料已经有很多介绍了，这里放一个链接，不进行深入的介绍。本文的关注重点是Bootloader在跳转APP程序中出现的问题。
IAP的实现原理讲解以及中断向量表的偏移

2. 程序

本人主要做应用层的开发，所有Bootloader和APP程序使用的是STM32CubeMX工具生成代码后，然后进行修改。

2.1 Bootloader 程序

1. CubeMX 配置
  步骤1：使用的芯片为STM32F407ZGT6

在这里插入图片描述
步骤2：选择时钟源（根据自己的板子进行选择）
在这里插入图片描述
步骤3：时钟配置
在这里插入图片描述
步骤4：项目配置
在这里插入图片描述
2. 代码（只介绍跳转函数）

完整代码

void IAP_ExecuteApp ( uint32_t ulAddr_App )
{
	int i = 0;
	pIapFun_TypeDef pJump2App; 

	
	if ( ( ( * ( __IO uint32_t * ) ulAddr_App ) & 0x2FFE0000 ) == 0x20000000 )	 //@1 //检查栈顶地址是否合法.
	{ 
		
		HAL_SPI_MspDeInit(&hspi1);	//@2
		__HAL_RCC_GPIOB_CLK_DISABLE();
		__HAL_RCC_GPIOG_CLK_DISABLE();
		
		
		 /* 设置所有时钟到默认状态，使用HSI时钟 */
		HAL_RCC_DeInit();		//@3
		
		__set_BASEPRI(0x20);		//@4
		__set_PRIMASK(1);
        __set_FAULTMASK(1);
		
		/* 关闭所有中断，清除所有中断挂起标志 */
		for (i = 0; i < 8; i++)		//@5
		{
			NVIC->ICER[i]=0xFFFFFFFF;
			NVIC->ICPR[i]=0xFFFFFFFF;
		}
		
		SysTick->CTRL = 0;		//@6
		SysTick->LOAD = 0;
		SysTick->VAL = 0;

		__set_BASEPRI(0);		//@7
		__set_PRIMASK(0);
		__set_FAULTMASK(0);
 		
 		//@8
        /*
        1）不使用OS时： 只用到MSP（中断和非中断都使用MSP）；
        2）使用OS时（如UCOSII）： main函数和中断使用MSP； 各个Task（线程）使用PSP（即任务栈）；
        */
        __set_MSP(*(uint32_t*)ulAddr_App);//当带操作系统从APP区跳转到BOOT区的时候需要将SP设置为MSP，否则在BOOT区中使用中断将会引发硬件错误！
        __set_PSP(*(uint32_t*)ulAddr_App);
        __set_CONTROL(0);  /* 在RTOS工程，这条语句很重要，设置为特权级模式，使用MSP指针 */
        __ISB();//指令同步隔离。最严格：它会清洗流水线，以保证所有它前面的指令都执行完毕之后，才执行它后面的指令。
		//@9
		pJump2App = ( pIapFun_TypeDef ) * ( __IO uint32_t * ) ( ulAddr_App + 4 );	//用户代码区第二个字为程序开始地址(复位地址)		
		pJump2App ();								                                    	//跳转到APP.
	}
}

@1 代码作用：检查栈顶地址是否合法.0x20000000是sram的起始地址,也是程序的栈顶地址；

if ( ( ( * ( __IO uint32_t * ) ulAddr_App ) & 0x2FFE0000 ) == 0x20000000 )

@2 代码作用：下面这几个关闭的是在Bootloader中初始化过的外设，如果没有初始化过其他外设，则不需要；

HAL_SPI_MspDeInit(&hspi1);	
__HAL_RCC_GPIOB_CLK_DISABLE();
__HAL_RCC_GPIOG_CLK_DISABLE();

@3 代码作用：PLL在Bootloader中已经配置启动了，在APP程序中如果想再进行配置启动的话会返回错误。

问题现象

将Bootloader和APP程序分别下载到板子上，Bootlader程序可以正常运行，而APP程序会死在Error_Handler()的while(1)循环中。具体调试发现程序是在执行HAL_RCC_OscConfig()函数的PLL 配置部分检测到当前PLL已经被配置为了系统时钟而返回了HAL_ERROR的返回值导致进入了Error_Handler()。
 方案一： 网上有人的建议是不使用PLL，使用HSI作为系统的时钟源，经过测试可以正常运行；但是这样会有个问题是，使用STM32F4的HSI是16M，这显然和通过PLL倍频之后使用的168M不在一个数量级上。
 方案二： 通过查找资料发现，可以在Bootloader启动的时候配置PLL倍频到168M，然后在跳转程序之前将RCC的配置反初始化为默认设置（使用HSI时钟）。

HAL_RCC_DeInit();

@4 代码作用：关闭所有的中断；此处的特殊寄存器设置值，可以看如下链接: 嵌入式–Keil5–调试状态下Registers界面解析（nrf52832–Cortex-M4内核）

__set_BASEPRI(0x20);
__set_PRIMASK(1);
__set_FAULTMASK(1);

@5 代码作用：清除所有中断挂起标志，防止在APP中触发该中断，导致运行错误；

	/* 关闭所有中断，清除所有中断挂起标志 */
		for (i = 0; i < 8; i++)		//@5
		{
			NVIC->ICER[i]=0xFFFFFFFF;
			NVIC->ICPR[i]=0xFFFFFFFF;
		}

@6 代码作用：关闭掉系统滴答定时器，该定时器会在APP的程序中重新启动，调用HAL_Init();函数会启动；
 注意:@6 的代码一定要放到@3 之后，因为HAL_RCC_DeInit();函数会再次开启滴答定时器。

SysTick->CTRL = 0;
SysTick->LOAD = 0;
SysTick->VAL = 0;

@7 代码作用：重新启动中断开关；

	__set_BASEPRI(0);
	__set_PRIMASK(0);
	__set_FAULTMASK(0);

注意:必须重新启动中断的开关，本人调试过程中没有开启__set_FAULTMASK(0) ;的中断，导致滴答定时器（SysTick）无法正常运行，执行HAL_Delay();，死循环在了延时中，耽误了一天的时间查找问题。

@8 和@9 代码都有详细的注释；

注意: __set_PSP((uint32_t)ulAddr_App); 和 __set_CONTROL(0); 函数是使用RTOS（实时操作系统的读者必须要添加的）

2.2. APP程序

CubeMX 配置基本和Bootloader 基本相同，不赘述。本人使用的FreeRTOS的实时操作系统。

1. Keil 配置
    步骤1：配置程序的起始位置（根据自己的需要修改），配置的时候发现只配置这块没用，需要配置步骤2才行；
在这里插入图片描述
步骤2：Linker 中修改ScatterFile 文件；
在这里插入图片描述
这是本人的配置，每个人的可能都不一样，本人是需要用ccmram，所以使用自己的ScatterFile 文件，修改的内容如下图。
在这里插入图片描述
步骤2：设置APP的中断向量表的位置；
  首先找到 startup_stm32f407xx.s 文件中调用 SystemInit 函数的地方，找到SystemInit 函数的实现，然后 找到 USER_VECT_TAB_ADDRESS 的宏定义的地方，取消注释。先修改下图 1的位置，然后修改 2的位置，2的位置根据自己的APP偏移位置来修改。
在这里插入图片描述

3. 代码

在main 函数的一开始添加如下代码。

  /* USER CODE BEGIN 1 */
	HAL_DeInit();
	HAL_RCC_DeInit();
  /* USER CODE END 1 */

在这里插入图片描述
HAL_DeInit(); HAL库反初始化；
HAL_RCC_DeInit(); RCC配置反初始化；

注意: 如果直接查找HAL_RCC_DeInit() 的实现，发现是个空函数，实际这是HAL库的一个机制，实际编译使用的另外一个文件中的，如下图1和2
在这里插入图片描述
在这里插入图片描述

4. 其他问题

4.1 可能导致APP死机的原因
Bootloader启动的外设比APP的多，导致死机，需要在跳转到APP时清理不需要的外设配置；
Bootloader开启了某个终端，在APP中没有配置相应的处理函数，导致死机；该问题可通过Bootloader程序的@4 @5 @7来解决；

Chapter2 STM32-IAP基本原理及应用 | ICP、IAP程序下载流程 | 程序执行流程 | 配置IAP到STM32F4xxx

原文链接

Chapter3 STM32基于Ymodem协议IAP升级笔记

原文链接：https://blog.csdn.net/weixin_43940932/article/details/128918183

1.YMODEM 协议说明

YMODEM它分为YMODEM-1K与YMODEM-g,平时说的YMODEM传输指是YMODEM-1K传输。
YMODEM-1K可以一次传输1024字节的信息块，同时支持传输多个文件。数据的发送会使用CRC校验，保证数据传输的正确性。它每传输一个信息块数据时，就会等待接收端回应ACK信号，接收到回应后才会继续传输下一个信息块，保证数据已经全部接收。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
2.升级代码分析
代码是用ST官方代码修改的，此处只讲升级API部分,调用的就是Ymodem_Receive函数（只需要ymodem.c & common.c两个文件），上传API实际中用的少,就忽略了。


#define APP_FLASH_START_ADDR (0x08002800U)   //APP程序跳转运行地址
#define IMAGE_UPDATA_FLASH_SIZE (MCU_FLASH_APP_MAIN_AREA_SIZE) //
unsigned char recv_buff[PACKET_1K_SIZE] ={0};//开辟数据包缓存区
unsigned char FileName[] = {0}; //文件名缓存区
/*
**app跳转引导函数
*/
void iap_load_app(const unsigned int app_addr)
{
   //app_addr为新程序的起始地址，检查栈顶地址是否合法，即栈顶地址是否为0x2000xxxx（内置SRAM）
    if (0x20000000 == ((*(volatile unsigned int*)app_addr) & 0x2FFE0000)) 
    {
        //__set_PRIMASK(1);//有中断，需要先关闭所有中断
        const unsigned int jump_addr = *(volatile unsigned int*)(app_addr + 4); 
        __set_MSP(*(volatile unsigned int*)app_addr);
        ((void (*)(void))jump_addr)();// 设置PC指针为新程序复位中断函数的地址
    }
}

/*
** Ymodem OTA升级执行函数
*/
void ymodem_ota_task(void)
{
  //在执行的过程中，随时都可以按下 `A`按键主动结束升级动作。
  printf(">> IAP already,you can pressed `A` key to end ota....\r\n");

 //返回值携带升级信息
  const int file_sz = Ymodem_Receive(&recv_buff[0],APP_FLASH_START_ADDR);//API改造了一下，增加APP跳转地址形参，便于全局维护。

    if (0 < file_sz)
    {
    printf("\r\n--------- updata sucess --------\r\n");
    printf("file name: %s\r\n", FileName);
    printf("file size: %d bytes\r\n",file_sz);
    printf("--------------------------------\r\n");
        iap_load_app(APP_FLASH_START_ADDR);
    }
    else
    {
        printf("ota failed ...\r\n\r\n");
        if (-1 == file_sz)//升级文件大于分配的FLASH大小
        {
                printf("\r\n alloc flash size is small ...\r\n");
        }
        else if (-2 == file_sz)//升级文件校验出错
        {
                printf("\r\n verif failed ...\r\n");
        }
        else if  (-3 == file_sz)//用户主动结束升级(即按下了`A`按键)
        {
                printf("\r\n aborted by user ...\r\n");
        }
        else//升级超时或者其它
        {
                printf("\r\n receive failed ....\r\n");
        }	
       //NVIC_SystemReset();
     }
}

/*
**
*/
int Ymodem_Receive(unsigned char *buf, unsigned int app_addr)
{
    unsigned char packet_data[PACKET_1K_SIZE + PACKET_OVERHEAD] , 
    file_size[FILE_SIZE_LENGTH] ,
    *file_ptr, //
    *buf_ptr;
    int i, 
    packet_length, 
    session_done, 
    file_done, 
    packets_received, 
    errors, 
    session_begin, 
    image_size = 0;

    volatile unsigned int flash_dst_addr, bin_data;
    flash_dst_addr = app_addr;
 
//双循环
    for (session_done = 0, errors = 0, session_begin = 0;;)//等价 while(1)
    {
        for (packets_received = 0, file_done = 0, buf_ptr = buf;;)//等价 while(1)
        {
                /* 0x00: 正常返回 | -1:时间溢出或数据包错误 | 0x01:用户终止*/
    //分类处理接收包数据
                switch (Receive_Packet(packet_data, &packet_length, NAK_TIMEOUT))
                {
                        case 0://收到完整协议包
                        errors = 0;//清除累计错误
                        switch (packet_length)//判断包长
                        {
                        case -1:/* 连续的两个CA信号终止传输 */
                                Send_Byte(ACK);
                                return 0;
                        case 0:/*正常返回*/
                                Send_Byte(ACK);
                                file_done = 1;
                                break;
                        default:/* 数据区长度 */
                                if ((packet_data[PACKET_SEQNO_INDEX] & 0xff) != (packets_received & 0xff))//检验包序号
                                {
                                        Send_Byte(NAK);//包序号不一致
                                }
                                else//包序号一致
                                {
                                        if (packets_received == 0)//起始帧
                                        {
                                                if (packet_data[PACKET_HEADER] != 0)
                                                {
                        //注:file_ptr = packet_data + PACKET_HEADER 等价 file_ptr = &packet_data[PACKET_HEADER],即从第PACKET_HEADER字节开始取数据指针
                                                        for (i = 0, file_ptr = packet_data + PACKET_HEADER; (*file_ptr != 0) && (i < FILE_NAME_LENGTH);)
                                                        {
                                                                FileName[i++] = *file_ptr++;//获取文件名
                                                        }
                                                        FileName[i++] = '\0';//补\0字符串结束符操作。
                                                        for (i = 0, file_ptr++; (*file_ptr != ' ') && (i < FILE_SIZE_LENGTH);)
                                                        {
                                                                file_size[i++] = *file_ptr++;//获取文件大小
                                                        }
                                                        file_size[i++] = '\0';//补\0字符串结束符操作。

                                                        Str2Int(file_size, &image_size);//将字符串转为hex数据

                                                        if (IMAGE_UPDATA_FLASH_SIZE < image_size )//判断将要升级的文件是否超过预留的FALSH升级空间大小
                                                        {
                                                                /* End session */
                                                                Send_Byte(CA);//超过FALSH升级空间大小，发送传输中止应答符'CA'，结束升级
                                                                Send_Byte(CA);
                                                                return -1; //返回错误码
                                                        }

                                                        /* Erase the needed pages where the user application will be loaded */
                                                        /* Define the number of page to be erased */
                                                        const unsigned int nbr_of_pg = mcu_flash_page_alloc(image_size);//计算当前文件大小要擦除的页数
                                                        /* Erase the FLASH pages */
                                                        const unsigned int erase_pgn = mcu_flash_page_num_calc(flash_dst_addr);//计算APP起始地址所在的页序号（因为后面擦除FALSH的API是按页序号来操作的）
                                                        //#define SIMLATE_DEBUG
                                                        #ifdef SIMLATE_DEBUG //仿真接收数据信息
                                                        printf("image size:%uBytes |erase page num :%d | erase page nbr:%d\r\n",image_size,erase_pgn,nbr_of_pg);
                                                        #else
                                                        mcu_flash_page_erase_cc_num(erase_pgn,nbr_of_pg);//按页序号来擦除FALSH的API
                                                        #endif
                                                        Send_Byte(ACK);
                                                        Send_Byte(CRC16);//发送正常应答符  + CRC校验
                                                }
                                                else //结束帧
                                                {
                                                        Send_Byte(ACK);
                                                        file_done = 1; //
                                                        session_done = 1;//传输完毕
                                                        break;
                                                }
                                        }
                                        else //数据帧
                                        {
                    //注同样:packet_data + PACKET_HEADER 等价 &packet_data[PACKET_HEADER]
                                                memcpy(buf_ptr,packet_data + PACKET_HEADER,packet_length);//取有效程序数据(去掉前三个帧头)
                                                bin_data = (volatile unsigned int )buf;	

                    //注：packet_length/4：表示下面写FLASH函数是按照4字节(字长度)
                    //若是按2字节写入，则用packet_length/2
                    //1字节则按packet_length
                                                for (unsigned int j = 0; (j < packet_length/4);j++)
                                                {
                                                        #ifdef SIMLATE_DEBUG //先仿真交互信息
                                                        printf("image dating addr :0x%08X | image data:%08X\r\n",flash_dst_addr,*(unsigned int *)bin_data);
                                                        #else
                                                        /* Program the data received into STM32F10x Flash */
                                                        mcu_flash_word_write(flash_dst_addr,*(volatile unsigned int *)bin_data);//每次按4字节写入(1包则按packet_length/4次写完)
                                                        if (*(volatile unsigned int *)flash_dst_addr != *(volatile unsigned int *)bin_data)//每次写入后再读取出来进行对比。
                                                        {
                                                                /* End session */
                                                                Send_Byte(CA);
                                                                Send_Byte(CA);
                                                                return -2;   //写入出错（校验失败）
                                                        }
                                                        #endif
                                                        flash_dst_addr += 4;//每次地址按写入的字节长度偏移，当前API是4字节。
                                                        bin_data +=4;//同样数据源(来自包数据)一起同步偏移。
                                                }										
                                                Send_Byte(ACK);//写完后一包发送ACK.
                                        }
                                        packets_received++;//升级包数目计数
                                        session_begin = 1;//接收一包标记
    //						printf("received packets :%d\r\n",packets_received);
                                }
                        }
                        break;
                case 1:/*用户终止*/
                        Send_Byte(CA);
                        Send_Byte(CA);
                        return -3;
                default:/*时间溢出或数据包错误*/
                        if (session_begin > 0) //
                        {
                                errors++;
                        }
                        if (errors > MAX_ERRORS)//允许出错最大次数
                        {
                                Send_Byte(CA);
                                Send_Byte(CA);
                                return 0;
                        }
                        Send_Byte(CRC16);
                        break;
                }//end Receive_Packet...
                if (file_done != 0)
                {
                        break;
                }
        }//end 接收while(1);
            if (session_done != 0)
            {
                    break;
            }
    }

	return (int)image_size;
}

/*
**获取输入\接收单字节数据
*/
unsigned int SerialKeyPressed(unsigned char *key)
{
  //串口查询方式接收数据
  if (RESET!=USART_GetFlagStatus(USART1,USART_FLAG_RXNE))
  {
    *key = (uint8_t)USART_ReceiveData(USART1);
    return 1;
  }
  return 0;
}

/*
** 接收字节函数
*/
static int Receive_Byte(unsigned char *c, unsigned int timeout)
{
	volatile unsigned int count = timeout;

	while (count-- > 0)
	{
        //收到数据立马退出
		if (SerialKeyPressed(c) == 1)
		{
			return 0;
		}
	}
	return -1;
}

/*
** 接收包数据函数
*/
int Receive_Packet(unsigned char *data, int *length, unsigned int timeout)
{
	unsigned short int i, packet_size;
	unsigned char c;
	unsigned short int crc;

	*length = 0;

	/* 接收一个字符 */
	if (Receive_Byte(&c, timeout) != 0) //没有收到数据，退出
	{
		return -1;
	}

	switch (c)
	{
	/* SOH表示数据区有128字节 */
	case SOH:
		packet_size = PACKET_SIZE;
		break;
	/* STX表示数据区有1k字节 */
	case STX:
		packet_size = PACKET_1K_SIZE;
		break;
	/* 传输结束 end of transmission */
	case EOT:
		return 0;
	/* 连续的两个CA信号终止传输 */
	case CA:
		/* 收到两个连续的CA信号 */
		if ((Receive_Byte(&c, timeout) == 0) && (c == CA))
		{
			*length = -1;
			return 0;
		}
		else/* 只收到一个CA信号 */
		{
			return -1;
		}
	/* 用户终止传输 */
	case ABORT1:
	case ABORT2:
		return 1;
	default:
		return -1;
	}

	*data = c;
	for (i = 1; i < (packet_size + PACKET_OVERHEAD); i++)
	{
        //data + i 等价 &data[i]
		if (Receive_Byte(data + i, timeout) != 0)//没有收到数据，退出
		{
			return -1;
		}
	}
	/* 第PACKET_SEQNO_COMP_INDEX（数字2）字节是PACKET_SEQNO_INDEX（数字1）字节的反码 */
	if (data[PACKET_SEQNO_INDEX] != ((data[PACKET_SEQNO_COMP_INDEX] ^ 0xff) & 0xff))//正反帧序号校验不通过
	{
		return -1;
	}

	/* 计算CRC */
	crc = data[packet_size + PACKET_HEADER] << 8;
	crc += data[packet_size + PACKET_HEADER + 1];

	if (Cal_CRC16(&data[PACKET_HEADER], packet_size) != crc)//数据包校验不通过
	{
		return -1;
	}

	/* 取数据区长度 */
	*length = packet_size;
	return 0;
}

//FLASH擦写函数API参考
/*
** 根据提供的文件大小，计算所需要的FLASH页数。
*/
unsigned int  mcu_flash_page_alloc(volatile unsigned int img_size)
{
  unsigned int pg_num = 0x0;
  unsigned int img_sz = img_size;

  if ((img_sz % MCU_FLASH_PAGE_SIZE) != 0)
  {
    pg_num = (img_sz / MCU_FLASH_PAGE_SIZE) + 1;
  }
  else
  {
    pg_num = img_sz / MCU_FLASH_PAGE_SIZE;
  }
	
  return pg_num;
}

/*
**页所在的FLASH地址计算当前页序号
*/
unsigned int mcu_flash_page_num_calc(const unsigned int flash_addr)
{
     /* calculate the number of page to be programmed/erased */
    return (flash_addr - MCU_FLASH_START_ADDR) / MCU_FLASH_PAGE_SIZE;
}

/*
**(按序号)连擦除FLASH函数
*/
void mcu_flash_page_erase_cc_num(const unsigned int erase_pgn,unsigned int erase_pg_nbr)
{
    unsigned int erase_pgaddr_ofs=mcu_flash_page_addr_calc(erase_pgn);/*计算当前页所在FLASH地址*/
    /* Unlocks the FLASH Program Erase Controller */
    FLASH_Unlock();
    /* clear all pending flags */
    FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_WRPRTERR | FLASH_FLAG_PGERR);

    /* erase the flash pages */
    for(unsigned int i=0;i<erase_pg_nbr;i++)
    {
       while(FLASH_COMPLETE != FLASH_ErasePage(erase_pgaddr_ofs));//擦除当前FLASH地址所在页
	   FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_WRPRTERR | FLASH_FLAG_PGERR);
	   erase_pgaddr_ofs+=MCU_FLASH_PAGE_SIZE;
    }
    /* Locks the FLASH Program Erase Controller */
    FLASH_Lock();
}

3.Ymodem升级工具

1.网上大多推荐的是SecureCRT终端工具，我用的是Tera Term这款终端工具，里面有支持Xmodem,Ymodem,Zmodem等多协议文件发送功能，

2.Ymodem升级文件使用: 打开终端

2.1 首先设置串口:点击"设置"-> “串口”，选择相应串口号以及波特率。
2.2 加载并升级文件:点击"文件"-> “传输” -> “YMODEM” -> “发送” ，选择app升级bin文件即可。
注意:貌似调试发现，其发送的包大小是1KB的。
在这里插入图片描述
3.后来在gitee上找到了作者biglu制作的专门用于Ymodem升级的上位机Ymodem_tool，其支持发送包大小是128B/1024B的，界面简洁好用。
在这里插入图片描述
4.两款工具升级界面
在这里插入图片描述
在这里插入图片描述

Chapter4 基于Ymodem协议的stm32f405rgt6+CubeMx+IAP在线升级

原文链接

准备工作

1.STM32F4开发板

2.USB转串口工具

3.MDK Keil5

4.CubeMX

5.secureCRT上位机软件

6.en.stsw-stm32067官方固件库

工程下载地址(0积分下载)：

Ymodem_IAP_F405_CubeMx+secureCRT上位机软件

一、CubeMX的配置

需要配置IAP和APP两个工程，这两个工程的配置都比较简单

1.IAP

打开CubeMX软件，选好芯片型号，这里我的芯片型号是STM32F405RGT6

配置时钟

配置主时钟，我配置的是内部时钟，主频为168MHz

在这里插入图片描述
配置串口

我这里配置的是串口1，对应引脚为PA9和PA10，波特率为115200，串口采用轮询的方式通讯，不采用中断的方式，故不配置串口中断，其他默认。
在这里插入图片描述
生成代码

H和C文件分开，配置完成后，生成代码，为后续IAP移植修改作准备
在这里插入图片描述

2.APP

需要再配置一个APP工程，做一个简单的APP，就是让一个LED灯不断闪烁。

这里简单的配置了PB12口为输出，作为LED灯，其他配置过程这里就省略了。
在这里插入图片描述

二、移植Ymodem官方代码

1.文件移植

打开之前生成好的IAP工程目录，在该目录下新建一个Ymodem的文件夹
在这里插入图片描述
打开我们从官网下载好en.stsw-stm32067官方固件库，将en.stsw-stm32067->STM32F4xx_AN3965_V1.0.0->Project->STM32F4xx_IAP下的inc和src文件夹中的部分文件复制到新建的Ymodem的文件夹中
在这里插入图片描述
复制完的Ymodem的文件夹内容如下，一共8个文件
在这里插入图片描述

2.MDK文件、路径添加

打开IAP的MDK工程，添加一个Ymodem组，将Ymodem文件夹中的.c文件添加进去
在这里插入图片描述
添加Ymodem文件夹中的.H文件的路径
在这里插入图片描述

3.修改代码

完成1和2步后编译工程会报很多错误，需要修改代码
（1）删除不必要的代码
打开common.h文件，删除#include “stm324xg_eval.h” ，这个头文件是官方用在一个官方的开发板上的，我们用不到，故删之
在这里插入图片描述
（2）修改IAP代码
common.c文件
打开common.c文件，在193行有报错，这里官方用的不是HAL库，而且官方用的开发板的接口有不同的定义，因此，我们根据自己的实际情况修改下面的代码
在这里插入图片描述
我们将这个函数修改如下，并且要添加一个头文件，从这个函数的内容可知，主要实现接收一个字节

/** @addtogroup STM32F4xx_IAP
  * @{
  */
 
/* Includes ------------------------------------------------------------------*/
#include "common.h"
#include "usart.h"   //添加的头文件
/* Private typedef -----------------------------------------------------------*/

/**
  * @brief  Test to see if a key has been pressed on the HyperTerminal
  * @param  key: The key pressed
  * @retval 1: Correct
  *         0: Error
  */
uint32_t SerialKeyPressed(uint8_t *key)
{
  if (__HAL_UART_GET_FLAG(&huart1, UART_FLAG_RXNE) != RESET)
  {
    *key = (uint16_t)((&huart1)->Instance->DR & (uint16_t)0x01FF);	  
     return 1;
  }
  else
  {
    return 0;
  }
}

同样，修改下面的代码
在这里插入图片描述
修改成这样

/**
  * @brief  Print a character on the HyperTerminal
  * @param  c: The character to be printed
  * @retval None
  */
void SerialPutChar(uint8_t c)
{
  USART_SendData(USART1, c);
  while (__HAL_UART_GET_FLAG(&huart1, UART_FLAG_TXE) == RESET)
  {
  }
}

在common.c末尾添加代码，添加void USART_SendData(USART_TypeDef* USARTx, uint16_t Data)函数

//添加代码
void USART_SendData(USART_TypeDef* USARTx, uint16_t Data)
{
  /* Check the parameters */
  assert_param(IS_USART_ALL_PERIPH(USARTx));
  assert_param(IS_USART_DATA(Data)); 
    
  /* Transmit Data */
  USARTx->DR = (Data & (uint16_t)0x01FF);
}

在common.h添加声明void USART_SendData(USART_TypeDef* USARTx, uint16_t Data);

/* Exported functions ------------------------------------------------------- */
void Int2Str(uint8_t* str,int32_t intnum);
uint32_t Str2Int(uint8_t *inputstr,int32_t *intnum);
uint32_t GetIntegerInput(int32_t * num);
uint32_t SerialKeyPressed(uint8_t *key);
uint8_t GetKey(void);
void SerialPutChar(uint8_t c);
void Serial_PutString(uint8_t *s);
void GetInputString(uint8_t * buffP);
 
//添加声明
void USART_SendData(USART_TypeDef* USARTx, uint16_t Data);

flash_if.c文件
修改FLASH_If_Init(void)
在这里插入图片描述
修改如下

void FLASH_If_Init(void)
{ 
   HAL_FLASH_Unlock();
 
  /* Clear pending flags (if any) */  
   __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | 
                  FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);
  
}

修改FLASH_If_Erase(uint32_t StartSector)函数
在这里插入图片描述
修改成HAL库的方式，修改如下：

/**
  * @brief  This function does an erase of all user flash area
  * @param  StartSector: start of user flash area
  * @retval 0: user flash area successfully erased
  *         1: error occurred
  */
uint32_t FLASH_If_Erase(uint32_t StartSector)
{
    uint32_t UserStartSector;
    uint32_t SectorError;
    FLASH_EraseInitTypeDef pEraseInit;
 
    /* Unlock the Flash to enable the flash control register access *************/
 
    /* Get the sector where start the user flash area */
    UserStartSector = GetSector(APPLICATION_ADDRESS);
 
    pEraseInit.TypeErase = TYPEERASE_SECTORS;
    pEraseInit.Sector = UserStartSector;
    pEraseInit.NbSectors = GetSector(USER_FLASH_END_ADDRESS)-UserStartSector+1 ;
    pEraseInit.VoltageRange = VOLTAGE_RANGE_3;
 
    if (HAL_FLASHEx_Erase(&pEraseInit, &SectorError) != HAL_OK)
    {
        /* Error occurred while page erase */
        return (1);
    }
    return (0);
 
}

修改FLASH_If_Write(__IO uint32_t* FlashAddress, uint32_t* Data ,uint32_t DataLength)函数
在这里插入图片描述
修改成如下：

/**
  * @brief  This function writes a data buffer in flash (data are 32-bit aligned).
  * @note   After writing data buffer, the flash content is checked.
  * @param  FlashAddress: start address for writing data buffer
  * @param  Data: pointer on data buffer
  * @param  DataLength: length of data buffer (unit is 32-bit word)   
  * @retval 0: Data successfully written to Flash memory
  *         1: Error occurred while writing data in Flash memory
  *         2: Written Data in flash memory is different from expected one
  */
uint32_t FLASH_If_Write(__IO uint32_t* FlashAddress, uint32_t* Data ,uint32_t DataLength)
{
  uint32_t i = 0;
 
  for (i = 0; (i < DataLength) && (*FlashAddress <= (USER_FLASH_END_ADDRESS-4)); i++)
  {
    /* Device voltage range supposed to be [2.7V to 3.6V], the operation will
       be done by word */ 
    FLASH_ProgramWord(*FlashAddress, *(uint32_t*)(Data+i));  
     /* Check the written value */
      if (*(uint32_t*)*FlashAddress != *(uint32_t*)(Data+i))
      {
        /* Flash content doesn't match SRAM content */
        return(2);
      }
      /* Increment FLASH destination address */
      *FlashAddress += 4;
  }
 
  return (0);
}

在flash_if.c末尾添加如下函数

void FLASH_ProgramWord(uint32_t Address, uint32_t Data)
{
  /* Check the parameters */
  assert_param(IS_FLASH_ADDRESS(Address));
  
  /* If the previous operation is completed, proceed to program the new data */
  CLEAR_BIT(FLASH->CR, FLASH_CR_PSIZE);
  FLASH->CR |= FLASH_PSIZE_WORD;
  FLASH->CR |= FLASH_CR_PG;
 
  *(__IO uint32_t*)Address = Data;
}

在flash_if.h添加void FLASH_ProgramWord(uint32_t Address, uint32_t Data)声明

/* Exported functions ------------------------------------------------------- */
void FLASH_If_Init(void);
uint32_t FLASH_If_Erase(uint32_t StartSector);
uint32_t FLASH_If_Write(__IO uint32_t* FlashAddress, uint32_t* Data, uint32_t DataLength);
uint16_t FLASH_If_GetWriteProtectionStatus(void);
uint32_t FLASH_If_DisableWriteProtection(void);
 
//添加声明
void FLASH_ProgramWord(uint32_t Address, uint32_t Data);
#endif  /* __FLASH_IF_H */

修改 FLASH_If_GetWriteProtectionStatus(void)函数
在这里插入图片描述
修改如下

/**
  * @brief  Returns the write protection status of user flash area.
  * @param  None
  * @retval 0: No write protected sectors inside the user flash area
  *         1: Some sectors inside the user flash area are write protected
  */
uint16_t FLASH_If_GetWriteProtectionStatus(void)
{
  uint32_t UserStartSector = FLASH_SECTOR_1;
 
  /* Get the sector where start the user flash area */
  UserStartSector = GetSector(APPLICATION_ADDRESS);
 
  /* Check if there are write protected sectors inside the user flash area */
  if ((*(__IO uint16_t *)(OPTCR_BYTE2_ADDRESS) >> (UserStartSector/8)) == (0xFFF >> (UserStartSector/8)))
  { /* No write protected sectors inside the user flash area */
    return 1;
  }
  else
  { /* Some sectors inside the user flash area are write protected */
    return 0;
  }
}

修改FLASH_If_DisableWriteProtection(void)函数
在这里插入图片描述
修改如下

/**
  * @brief  Disables the write protection of user flash area.
  * @param  None
  * @retval 1: Write Protection successfully disabled
  *         2: Error: Flash write unprotection failed
  */
uint32_t FLASH_If_DisableWriteProtection(void)
{
  __IO uint32_t UserStartSector = FLASH_SECTOR_1, UserWrpSectors = OB_WRP_SECTOR_1;
 
  /* Get the sector where start the user flash area */
  UserStartSector = GetSector(APPLICATION_ADDRESS);
 
  /* Mark all sectors inside the user flash area as non protected */  
  UserWrpSectors = 0xFFF-((1 << (UserStartSector/8))-1);
   
  /* Unlock the Option Bytes */
 
  HAL_FLASH_Unlock();
  /* Disable the write protection for all sectors inside the user flash area */
  FLASH_OB_DisableWRP(UserWrpSectors, FLASH_BANK_1);
 
  /* Start the Option Bytes programming process. */  
  if (HAL_FLASH_OB_Launch( ) != HAL_OK)
  {
    /* Error: Flash write unprotection failed */
    return (2);
  }
 
  /* Write Protection successfully disabled */
  return (1);
}

需在末尾处添加 FLASH_OB_DisableWRP(uint32_t WRPSector, uint32_t Banks)函数

HAL_StatusTypeDef FLASH_OB_DisableWRP(uint32_t WRPSector, uint32_t Banks)
{
  HAL_StatusTypeDef status = HAL_OK;
  
  /* Check the parameters */
  assert_param(IS_OB_WRP_SECTOR(WRPSector));
  assert_param(IS_FLASH_BANK(Banks));
    
  /* Wait for last operation to be completed */
  status = FLASH_WaitForLastOperation(50000);
 
  if(status == HAL_OK)
  { 
    *(__IO uint16_t*)OPTCR_BYTE2_ADDRESS |= (uint16_t)WRPSector; 
  }
  
  return status;
}

并在flash_if.h添加函数声明HAL_StatusTypeDef FLASH_OB_DisableWRP(uint32_t WRPSector, uint32_t Banks)；

/* Exported functions ------------------------------------------------------- */
void FLASH_If_Init(void);
uint32_t FLASH_If_Erase(uint32_t StartSector);
uint32_t FLASH_If_Write(__IO uint32_t* FlashAddress, uint32_t* Data, uint32_t DataLength);
uint16_t FLASH_If_GetWriteProtectionStatus(void);
uint32_t FLASH_If_DisableWriteProtection(void);
 
//添加声明
void FLASH_ProgramWord(uint32_t Address, uint32_t Data);
HAL_StatusTypeDef FLASH_OB_DisableWRP(uint32_t WRPSector, uint32_t Banks);
 
#endif  /* __FLASH_IF_H */

修改GetSector(uint32_t Address)函数
在这里插入图片描述
修改如下：

/**
 * @brief  Gets the sector of a given address
 * @param  Address: Flash address
 * @retval The sector of a given address
  */
static uint32_t GetSector(uint32_t Address)
{
  uint32_t sector = 0;
  
  if((Address < ADDR_FLASH_SECTOR_1) && (Address >= ADDR_FLASH_SECTOR_0))
  {
    sector = FLASH_SECTOR_0;  
  }
  else if((Address < ADDR_FLASH_SECTOR_2) && (Address >= ADDR_FLASH_SECTOR_1))
  {
    sector = FLASH_SECTOR_1;  
  }
  else if((Address < ADDR_FLASH_SECTOR_3) && (Address >= ADDR_FLASH_SECTOR_2))
  {
    sector = FLASH_SECTOR_2;  
  }
  else if((Address < ADDR_FLASH_SECTOR_4) && (Address >= ADDR_FLASH_SECTOR_3))
  {
    sector = FLASH_SECTOR_3;  
  }
  else if((Address < ADDR_FLASH_SECTOR_5) && (Address >= ADDR_FLASH_SECTOR_4))
  {
    sector = FLASH_SECTOR_4;  
  }
  else if((Address < ADDR_FLASH_SECTOR_6) && (Address >= ADDR_FLASH_SECTOR_5))
  {
    sector = FLASH_SECTOR_5;  
  }
  else if((Address < ADDR_FLASH_SECTOR_7) && (Address >= ADDR_FLASH_SECTOR_6))
  {
    sector = FLASH_SECTOR_6;  
  }
  else if((Address < ADDR_FLASH_SECTOR_8) && (Address >= ADDR_FLASH_SECTOR_7))
  {
    sector = FLASH_SECTOR_7;  
  }
  else if((Address < ADDR_FLASH_SECTOR_9) && (Address >= ADDR_FLASH_SECTOR_8))
  {
    sector = FLASH_SECTOR_8;  
  }
  else if((Address < ADDR_FLASH_SECTOR_10) && (Address >= ADDR_FLASH_SECTOR_9))
  {
    sector = FLASH_SECTOR_9;  
  }
  else if((Address < ADDR_FLASH_SECTOR_11) && (Address >= ADDR_FLASH_SECTOR_10))
  {
    sector = FLASH_SECTOR_10;  
  }
  else/*(Address < FLASH_END_ADDR) && (Address >= ADDR_FLASH_SECTOR_11))*/
  {
    sector = FLASH_SECTOR_11;  
  }
    return sector;
}
  • ymodem.h

在ymodem.h文件添加头文件#include “stdint.h”

#include "stdint.h"
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __YMODEM_H_
#define __YMODEM_H_
  • main.c文件

在main.c文件添加头文件#include “menu.h”

/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "usart.h"
#include "gpio.h"
 
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "menu.h"

main()函数添加 FLASH_If_Init()和 Main_Menu ()函数

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_USART1_UART_Init();
  /* USER CODE BEGIN 2 */
  FLASH_If_Init();
  Main_Menu ();
  /* USER CODE END 2 */
 
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */
 
    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

编译一下，已经没有错误了
在这里插入图片描述
（3）修改APP代码
打开APP工程，while（1）添加如下函数

int main(void)
{
  /* USER CODE BEGIN 1 */
 SCB->VTOR = FLASH_BASE | 0x4000; //中断向量表偏移
  /* 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();
  /* USER CODE BEGIN 2 */
 
  /* USER CODE END 2 */
 
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */
 
    /* USER CODE BEGIN 3 */
    HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_12);
    HAL_Delay(1000);
  }
  /* USER CODE END 3 */
}

从IAP的flash_if.h的宏定义可以看出，这里的APP起始地址为0x08004000
在这里插入图片描述
在这里插入图片描述
生成bin文件，复制

fromelf.exe --bin -o "$L@L.bin" "#L

在这里插入图片描述
修改FLASH烧录地址
在这里插入图片描述
设置完成后编译一下，生成bin文件
在这里插入图片描述

三、烧录、测试

打开secureCRT上位机软件，选好端口，设置好波特率，去掉RTS/CTS的勾，点击连接，如下图
在这里插入图片描述
点击选项，选择会话选项，弹出如下窗口，按下图设置好，点击确定
在这里插入图片描述将IAP代烧录到开发板，代码开始执行后，如下图
在这里插入图片描述

在下方窗口输入1，此时串口不断接受到’C’,如下图所示
在这里插入图片描述
选择传输，点击发送Ymodem
在这里插入图片描述
选择添加好APP生成的bin文件，点击确定
在这里插入图片描述
等待一段时间，等待擦除flash，就会完成传输，此时，在下方窗口输入3，即可运行APP
在这里插入图片描述
至此，全部工作已结束

其他待更新。。。。。。

宁静致远2021
关注
  • 28
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STM32F0 IAP与APP相互跳转程序
12-07
亲自开发测试，简单有效，有配套教程，无需第三方上位机，测试简单，移植性高，可靠性强。不吹牛逼，用来自己保存使用的。
stm32专题二十九：Flash 读写保护
dingyc_ee的博客
10-14 6176
Flash 读写保护
基于STM32的Flash擦除方式
热门推荐
05-31 1万+
本文主要介绍STM32的内部Flash擦除方式和擦除长文件的功能函数怎样编写。并且介绍一些注意事项，如只想擦除当前地址，却发现上下地址都出现了擦除等问题。阅读完本文可以使你能够正常的完成Flash擦除。并对擦除时会影响的地址大小有一个深入的认识，并在对页擦除时，页的起始地址和大小有所了解。...
STM32基于Ymodem协议IAP升级笔记
我的博客
02-07 1482
Ymodem升级
调试笔记-stm32的OTA/IAP 通过485升级固件
追逐火焰的飞蛾
06-13 2856
背景：最近需要在stm32上实现通过rs485升级固件功能。目标：使用cubeIDE实现stm32F407VGT6，通过RS485升级固件。调试方法，可以用仿真器debug查看memory内容，确认目标地址下内容正确。栈顶地址科普见上面，具体解决办法为：将RAM地址大小调小些。确认app烧录地址和跳转地址一致，或者程序烧录没问题。现象3：卡死在SystemClock_Config()问题3：跳转后，程序不运行，卡死。问题1：栈顶地址不合规，导致报错。问题2：跳转后中断有问题。
STM32F4 IAP升级 Bootloader程序+上位机下载程序源码
01-05
STM32F4 IAP升级 Bootloader程序+上位机下载程序源码。。。。STM32F4 IAP升级 Bootloader程序+上位机下载程序源码。。。。STM32F4 IAP升级 Bootloader程序+上位机下载程序源码。。。。STM32F4 IAP升级 Bootloader...
STM32使用YModem协议进行IAP串口升级
08-28
通过使用STM32F103C8T6串口1，采用YModem协议对固件进行IAP升级，手工编写，测试有效。IAP程序大小12K，因此APP程序其实地址为0x8003000，同时中断偏移量也需要修改。
STM32F4 IAP 分包升级
08-10
STM32F4这个是蓝牙无线升级的，分包发送，逐次写入，每次发包相互都有应答
探索者STM32F4开发板IAP与APP学习（C程序）.rar
06-12
探索者STM32F4开发板IAP与APP学习，MDK环境，U盘有些兼容性问题。上电时不能完成升级的，按复位键后，就可完成APP的升级。用MDK生成BIN文件的设置在User中（D:\Keil_v5\ARM\ARMCC\bin\fromelf.exe --bin -o E:\APP_...
基于Ymodem的STM32F4串口IAP
08-07
基于Ymodem的STM32F4串口IAP,已测试成功。
STM32F103 bootloader和IAP源码 ymodem协议
06-23
STM32 IAP功能代码，包含bootloader和IAP两个工程代码，已经在STM32F103C8...上位机用超级终端或者SecureCRT发送二进制代码文件， 使用ymodem协议，调通后可以把IAP代码移植到自己的正式程序中，实现在线升级代码功能。
(STM32F103C8T6&STM32F407ZGT6)Ymodem串口IAP远程升级
11-08
该文件包括两份代码 ，一份是STM32F103C8T6的远程升级代码， 包含两个点灯APP程序简单测试 分别是呼吸灯和亮暗灯。一份是STM32F407ZGT6远程升级代码，包含一个点灯APP程序简单测试。均已通过secureCRT上位机发送文件...
IAP+APP 模式下不能启动 RTOS_IAP_stm32_APP_rtos_
09-29
stm32f4在iap时程序无法跳转问题解析
基于STM32F4系列的ETH IAP在线升级程序
最新发布
04-24
博客地址：...此bootloader程序可以通过http或tftp方式更新STm32应用程序,是否进入BOOTLOADER程序可以根据读取板载外接存储器中的字节判断，能够做到做到了现场快速更改程序，省时省力！
STM32在线升级IAP，包含APP，上位机软件，亲测可用
07-23
STM32在线升级IAP，包含APP，上位机软件，亲测可用
STM32_IAP升级资料（包括文档、例程、官方笔记、FLASH跳转）
10-17
STM32_IAP升级资料（包括文档、例程、官方笔记、FLASH跳转），作为参考资料使用！
STM32F103基于Ymodem协议的串口IAP升级---STM32CUBEIDE开发
03-06
STM32F103 基于Ymodem协议的串口IAP升级---STM32CUBEIDE开发
STM32_IAP_APP参数配置_向量表映射.doc
02-09
详细介绍STM32 IAP 的应用程序向量表的配置问题。
基于ymodem协议的stm32串口iap的实现(iap + app + 上位机)
11-23
基于Ymodem协议的STM32串口IAP（In-Application Programming）的实现是通过串口通信的方式，实现在设备中对应用程序（APP）进行更新或升级。 在实现过程中，需要涉及三个主要组件：IAP、APP以及上位机。 IAP是指在设备中运行的固件，用于实现应用程序的更新。它需要能够接收上位机传输的数据，并将其写入设备的存储器中，以完成应用程序的更新。 APP是指设备中当前正在运行的应用程序，它需要检测到IAP的存在，并与上位机进行通信。APP需要具备与上位机进行数据交换的能力，并能够接收来自上位机的命令，以控制IAP的运行。 上位机是用于控制设备中IAP和APP的计算机。它通过串口与设备进行通信，并将应用程序的更新数据传输给设备。上位机需要发送命令给设备，控制设备中IAP和APP的运行，并在传输过程中与设备进行数据交换。 在实际操作中，上位机首先向设备发送一个请求，请求设备启动IAP模式。设备在接收到请求后，会进入IAP模式，并向上位机发送确认信息。之后，上位机会将待更新的应用程序数据通过串口传输给设备。设备会根据Ymodem协议对数据进行校验，并将数据写入存储器中。传输完成后，上位机与设备进行数据交换，以确认更新的完成情况。 总结来说，基于Ymodem协议的STM32串口IAP的实现包括IAP、APP和上位机三个主要组件，通过串口通信实现应用程序的更新。以上是对该实现过程的简要描述。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值