STM32F051 Bootload IAP远程升级

最新推荐文章于 2024-08-07 16:58:37 发布
最新推荐文章于 2024-08-07 16:58:37 发布
阅读量1.1k 收藏 16
点赞数 2
分类专栏： 项目分享 文章标签： java c语言 单片机 stm32 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L_e_c/article/details/110423909
版权

功能描述：

使用官方STM32F0-Discovery开发板，通过板载UART直连自制4G_DTU，4G_DTU连接服务器，在服务器上设计需要升级的软件，升级程序可通过服务器上的软件加载。主要使用：STM32、串口、内部flash操作、画4G Cat.1的原理图及PCB，编写远程服务器后台程序（Java    socket）。

硬件设计：

硬件开发板资料：https://www.stmcu.org.cn/document/list/index/category-622

4G_DTU资料：后面可能会开放原理图、PCB以及使用方法。

4G_DTU购买链接：https://item.taobao.com/item.htm?id=632028079844

软件设计：

1）：单片机软件：

在写单片机程序之前，我们先给单片机做一个flash区分，这样就能知道我们升级的IAP程序是在哪个区域运行了。我看了一下我的Bootload占的空间应该是12K不到，嫌大的可以删除一些程序代码，我也没有做这个精简版，有兴趣的可以尝试一下。下图是STM32F051R8T6的flash区分，讲一下bootload的设计思路。我是使用keil MDK开发，keil支持程序运行地址偏移，可以设置程序运行跳转地址，SRAM从哪里开始使用，在bootload程序里面并没有体现出来，但是在写应用程序的时候一定要区分。程序从启动文件进0x8000000开始运行，进入主函数判断是否有可升级的文件，需要升级的话就会初始化外设，比如串口IO口，延时函数。然后执行一系列的接收指令和数据的操作，在源码下载链接里面有单片机和上位机的数据协议，整理了一份。下面是主函数的代码，能看出来大致的流程，感兴趣的同仁下载源码看其他的程序吧，不一一描述了。

int main(void)
{
//	SystemInit(); //内部RC震荡
	uint16_t Cnt_200ms=0;
	uint16_t WriteBuf[1] = {0xAAAA};
	LED_Init();
//	memcpy((void*)0x20000000,(void*)0x08000000,VECTOR_SIZE);
//	SYSCFG_MemoryRemapConfig(SYSCFG_MemoryRemap_SRAM);
	//检查如果发现有可升级版本则进入升级
	if (FLASH_OB_GetRDP()!=SET)  
    { 
//        FLASH_Unlock();                          
        FLASH_OB_RDPConfig(OB_RDP_Level_1);          
    }
	
	if( *(vu16 *)FLAG_NEW_APP_ADDER == FLAG_NEW_APP_SET )
	{	
		GPIO_SetBits(GPIOC, GPIO_Pin_9);
		delay_init();
		Usart_Init(115200);
		if(FLASH_OB_GetRDP() != RESET)
		{
			FLASH_OB_RDPConfig(OB_RDP_Level_0);
		}
		//向上位机发送Bootlander程序段已准备好
		USART1SendRespondToServer(SERIAL_CODE_STM32_UPDATE_PREPAR_BOOT_OK);
		//检查上位机指令
		ReceiveCmd();
		
		//向上位机请求固件数据
		USART1SendRespondToServer(SERIAL_CODE_STM32_UPDATE_PREPAR_OK);
		//检查上位机发送的固件并写入到BackupFlash处
		ReceiveCode();
		
		//将 BackupApp 处的程序拷贝到 App处
		//注意若此处发生错误将会导致程序死亡
		Iap_BackupApp_WriteTo_App();  //

		//清除升级标志位 并 跳转到App运行
		Go_App();
	}
	else
	{
		if(((*(vu32*)(SYS_APP_ADDER + 4)) & 0xFF000000) == 0x08000000)//判断是否为0X08XXXXXX.
		{
			Iap_Load_App(SYS_APP_ADDER);
		}
	}
	TIM2_Init();
	Usart_Init(115200);
	while(1)
	{
		if(Usart1_Rx_Finish_Flag==1)
		{
			Usart1_Rx_Finish_Flag=0;
			STMFLASH_Write(FLASH_ADDR_FLAG,(uint16_t*)&WriteBuf, 1);
			SW_RESET();
		}
		if(System1Ms==1)
		{
			System1Ms=0;
			if(++Cnt_200ms>=100)
			{
				Cnt_200ms=0;					  
			}
		}
		if(system500ms==1)
		{
			system500ms=0;
			LED1_Toggle();
		}
	}
}

我再贴一下应用程序的main函数和keil设置。可以看出应用程序中SRAM地址也有偏移  主要是复制中断向量表。应用程序也许遵循协议，接收到程序升级指令，写flash升级标志，然后软重启。

#include "stm32f0xx.h"
#include "led.h"
#include "time.h"
#include "Time1_PWM.h"
#include "ADC1.h"
#include "Usart1.h"
#include <string.h>
#include <stdio.h>
#include "flash.h"

#define VECTOR_SIZE  0xC0

#define  SW_RESET()	       NVIC_SystemReset() 

#define FLASH_ADDR_FLAG           0x08003400     



int main(void)
{
//	uint32_t i = 0;
//	SystemInit(); //ÄÚ²¿RCÕ
	uint16_t Cnt_200ms=0;
	uint16_t WriteBuf[1] = {0xAAAA};
	memcpy((void*)0x20000000,(void*)0x08003800,VECTOR_SIZE);
	SYSCFG_MemoryRemapConfig(SYSCFG_MemoryRemap_SRAM);
	if (FLASH_OB_GetRDP()!=SET)  
    { 
//        FLASH_Unlock();                          
        FLASH_OB_RDPConfig(OB_RDP_Level_1);          
    }
	TIM2_Init();
//	Adc_Init();
	LED_Init();
//	Realy_Init();
	GPIO_ResetBits(GPIOB, GPIO_Pin_4);
//	TIM1_PWM_Init();
	Uart1_Init();; 
	Usart1_Printf(Send_char,8);
//	Send_char[0] = 0XAA;
//	Send_char[1] = 0X55;
	while(1)
	{
		if(System1Ms==1)
		{
			System1Ms=0;
			if(++Cnt_200ms>=100)
			{
				Cnt_200ms=0;
				LED1_Toggle();
			}
		}
		if(Usart1_Rx_Finish_Flag==1)
		{
			Usart1_Rx_Finish_Flag=0;
			FLASH_WriteNWord((uint16_t*)&WriteBuf, FLASH_ADDR_FLAG, 1);
			SW_RESET();
		}
//		if(system500ms==1)
//		{
//			system500ms=0;
//			LED1_Toggle();
//		}
	}
}

2）服务器程序

用Java写了一个GUI界面，丑不丑的能看就行。。。主要使用SWT和Socket，也是初学的时候写的，肯定会有不足，懒得改了。数据处理的代码贴出来，界面的程序链接中下载。

package Net.Port;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.security.MessageDigest;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

import com.ibm.icu.util.BytesTrie.Entry;

import comm.Port.SerialListner;
import comm.Port.SerialTool;
import comm.Port.SerialUI;


public class ServerDataDeal {

//	private static int port_num = 0;
	// 存储所有注册的客户端
//	private static byte[] pushHead = new byte[2];
//	private static byte[] exitbyte = new byte[8];
	private static byte[] bytes = new byte[16];
	public static byte[] data_bytes = new byte[1031];
	
//	private static volatile Map<Socket, String> clientMap = new ConcurrentHashMap<Socket, String>();
	private static ExecutorService executorService;
	private static ServerSocket serverSocket;
	private static byte SumNumber;
	public static volatile int UpdataFlag=0;
	public static int Page_Cont=0;	//接收包计数
	public static volatile int Page_Val=0;	//总包数
	public static byte UpdataLength=0;

	// 具体处理与每个客户端通信的内部类
	private static class ExecuteClient implements Runnable {
		private Socket client;
//		private String exitDriveName; // 设备退出变量
//		private String[] exitDriveName01; // 设备退出变量数组
//		private int exitDriveNum; // 需要移除的设备计数

		public ExecuteClient(Socket client) {
			this.client = client;
		}

		@Override
		public void run() {
			try {
				InputStream ins = client.getInputStream();
				while (true) {
					byte[] bys = new byte[1024];
					int len = ins.read(bys);
					String strFormClient = new String(bys, 0, len);
					System.out.println(strFormClient);
					// 解析数据
					if ((bys[0] == 0x55) && (bys[1] == (-86)) && (bys[2] == 0x01)) { 
						try {
							switch (bys[4]) {
								case 0: {
									UpdataLength=(byte)bys[3];
									UpdataFlag=1;
								}
								break;
								case 1: {
									UpdataLength=(byte)bys[3];
									UpdataFlag=2;
								}
								break;
								case 2: {
//									UpdataLength=(byte)data[3];
//									Page_Cont++;
									UpdataFlag=2;
								}
								break;
								default: {
									UpdataFlag=0;
								}
									break;
							}
							// 更新界面Label值

						} catch (ArrayIndexOutOfBoundsException e) {
							MessageDialog.openInformation(new Shell(), "Error", "数据解析过程出错，更新界面数据失败！请检查设备或程序！");
							System.exit(0);
						}
					}
					else
					{
						Display.getDefault().syncExec(() -> {
							DataViewUINet.Debugtext.append(strFormClient+"\n");
						});
					}
					
				}
			} catch (Exception e) {
//				System.err.println("服务器通信异常，错误" + e);
				MessageDialog.openInformation(new Shell(), "Error", "服务器通信异常，错误");
			}
		}
	
	}

	// 具体处理与每个客户端通信的内部类
	private static class DealChatGUI extends Thread {
		@Override
		public void run() {
			DataViewUINet window = new DataViewUINet();
			window.open();
		}
	}
	public static void main(String[] args) throws Exception {
		executorService = Executors.newFixedThreadPool(200);
//		executorService.submit(new DealChatGUI());
		new DealChatGUI().start();
		serverSocket = null;
		int[] port_num = { 0 };
		int total_con = 0;
		try {
			while (true) {
				Thread.sleep(200);
				if (DataViewUINet.Connect_Flag != 1)
					continue;
				Display.getDefault().syncExec(() -> {
					port_num[0] = Integer.parseInt(DataViewUINet.textID.getText());
				});
				if (serverSocket != null) {
					try {
						serverSocket.close();
						serverSocket = null;
					} catch (Exception e) {
						// TODO: handle exception
					}
				}
				serverSocket = new ServerSocket(port_num[0]);
				System.out.println("等待客户端连接。。\n");
				Display.getDefault().syncExec(() -> {
					DataViewUINet.text_Msg.append("等待客户端连接...\n");
				});
				Socket client = serverSocket.accept();
				System.out.println(
						"有新的客户端连接，" + "IP为：" + client.getInetAddress() + "  端口号为：" + client.getPort() + "\n");
				Display.getDefault().syncExec(() -> {
					DataViewUINet.text_Msg.append("有新的客户端连接，" + "IP为：" + client.getInetAddress() + "  端口号为："
							+ client.getPort() + "\n");
				});
				executorService.submit(new ExecuteClient(client));
				while (total_con < 20) {
					Thread.sleep(200);
					if (DataViewUINet.data_UpdataFlag == 1) {
						try {
							OutputStream out = client.getOutputStream();
							bytes[0] = (byte) 0x55;
							bytes[1] = (byte) 0xAA;
							bytes[2] = 0x01;
							data_bytes[0] = (byte) 0x55;
							data_bytes[1] = (byte) 0xAA;
							data_bytes[2] = 0x01;
							switch (UpdataFlag) {
								case 0: {
									UpdataFlag = 10;
									bytes[3] = 0x10;
									bytes[4] = 0x00;
									bytes[5] = 0x00;
									bytes[6] = 0x00;
									bytes[7] = 0x00;
									bytes[8] = 0x00;
									bytes[9] = 0x00;
									bytes[10] = 0x00;
									bytes[11] = 0x00;
									bytes[12] = 0x00;
									bytes[13] = 0x00;
									bytes[14] = 0x00;
									for (int x = 0; x < 15; x++) {
										SumNumber = (byte) (SumNumber + bytes[x]);
									}
									bytes[15] = (byte) (0 - SumNumber);
									out.write(bytes);
									out.flush();
									SumNumber = 0;
	
								}
								break;
								case 1: {
									UpdataFlag = 10;
									bytes[3] = UpdataLength;
									bytes[4] = 0x01;
									bytes[5] = (byte) ((DataViewUINet.filelength / 1024) + 1);
									bytes[6] = 0x00;
									bytes[7] = 0x00;
									bytes[8] = 0x00;
									bytes[9] = 0x00;
									bytes[10] = 0x00;
									bytes[11] = 0x00;
									bytes[12] = 0x00;
									bytes[13] = 0x00;
									bytes[14] = 0x00;
									for (int x = 0; x < 15; x++) {
										SumNumber = (byte) (SumNumber + bytes[x]);
									}
									bytes[15] = (byte) (0 - SumNumber);
									out.write(bytes);
									out.flush();
									SumNumber = 0;
								}
									break;
								case 2: {
//									if (SerialListner.Page_Cont == 0) {
//										dataall_bytes = Bsubcontent.getBytes();
//									}
									if (Page_Cont < (Page_Val - 1)) {
										UpdataFlag = 10;
										data_bytes[3] = (byte) Page_Cont;
										data_bytes[4] = 0x02;
										data_bytes[5] = (byte) 0xff;
										for (int x = 0; x < 1024; x++) {
											data_bytes[6 + x] = (byte) DataViewUINet.dataall_bytes[x + Page_Cont * 1024];
										}
										for (int y = 0; y < 1031; y++) {
											SumNumber = (byte) (SumNumber + data_bytes[y]);
										}
										data_bytes[1030] = (byte) (0 - SumNumber);
//										SerialTool.sendToPort(SerialUI.getSerialPort(), data_bytes);
										out.write(data_bytes);
										out.flush();
//										System.out.println(data_bytes.length + "..." + Arrays.toString(data_bytes));
										SumNumber = 0;
										for (int x = 0; x < 1024; x++) {
											data_bytes[6 + x] = 0;
										}
										Page_Cont++;
										Display.getDefault().syncExec(() -> {
											DataViewUINet.progressBar.setSelection((int)(100/(Page_Val-1)*Page_Cont)); //DataViewUI.progressBar.getSelection() + 
										});
//										
										
									} else {

//										byte[] dataall_bytes = Bsubcontent.getBytes();
										UpdataFlag = 10;
										data_bytes[3] = (byte) Page_Cont;
										data_bytes[4] = 0x02;
										data_bytes[5] = (byte) 0xff;
										for (int x = 0; x < ((DataViewUINet.filelength) - ((Page_Cont) * 1024)); x++) {
											data_bytes[6 + x] = (byte) DataViewUINet.dataall_bytes[x + Page_Cont * 1024];
										}
										for (int y = 0; y < 1031; y++) {
											SumNumber = (byte) (SumNumber + data_bytes[y]);
										}
										data_bytes[1030] = (byte) (0 - SumNumber);
//										SerialTool.sendToPort(SerialUI.getSerialPort(), data_bytes);
										out.write(data_bytes);
										out.flush();
//										System.out.println(data_bytes.length + "..." + Arrays.toString(data_bytes));
										SumNumber = 0;
//										SerialListner.Page_Cont = 0;
										DataViewUINet.data_UpdataFlag = 0;
										
										Display.getDefault().syncExec(() -> {
											DataViewUINet.progressBar.setSelection((int)(100/(Page_Val-2)*Page_Cont));
//											if(DataViewUI.progressBar.getSelection()==100) {
												MessageDialog.openInformation(new Shell(), "Success", "File Updata Successful");
//											}
										});
									}

								}
									break;

								default: {

								}
									break;
								}

						} catch (IOException e) {
							MessageDialog.openInformation(new Shell(), "Error", "私发信息错误。");
						}
					}
//					try {
//						System.out.println("等待客户端连接。。\n");
//						Display.getDefault().syncExec(() -> {
//							DataViewUI.text_Msg.append("等待客户端连接...\n");
//						});
//						Socket client = serverSocket.accept();
//						System.out.println(
//								"有新的客户端连接，" + "IP为：" + client.getInetAddress() + "  端口号为：" + client.getPort() + "\n");
//						Display.getDefault().syncExec(() -> {
//							DataViewUI.text_Msg.append("有新的客户端连接，" + "IP为：" + client.getInetAddress() + "  端口号为："
//									+ client.getPort() + "\n");
//						});
//						executorService.submit(new ExecuteClient(client));
//					} catch (IOException e) {
//						// TODO 自动生成的 catch 块
//						e.printStackTrace();
//						break;
//					}

				}
//				serverSocket.close();
//				
			}
		} finally {
			executorService.shutdown();
		}
	}
}

调试结果：

总结：

博客就只是分享了原理图和部分程序，一些注释也不全。有需要的可以下载源码。

单片机源码链接：单片机源码

Java源码链接：.class文件 不是源码

 

L_e_c
关注
专栏目录
STM32F051 IAP源码分享
MetalSeed
11-07 1万+
STM32F051 IAP源码分享   如果不懂IAP的请自动脑补或者怒戳这里 http://www.openedv.com/posts/list/11494.htm   然后STM32F051的IAP有一点区别也请自动脑补 ^_^   其实我只是来分享源码的：   事情是介个样子滴：   IAP需要有两个工程，第一个是Bootloader，第二个是Application
STM32的IAP升级笔记
qq_38368415的博客
06-30 438
STM32 读写内部FLASH，IAP升级
STM32F051 IAP远程升级
03-15
利用STM32F051IAP功能做远程升级，程序内包含BootLoader和App程序。程序的整体思路，会在我的一个博客中写道，欢迎浏览。如果有想进行服务器连接升级的小伙伴可以给我私信，愿意提供源码及PCB。
将iap的接收升级数据部分移植到freertos系统中
最新发布
qq_33983114的博客
08-07 925
在完成基于TCP服务器的iap裸机程序后得到一个新的任务，该任务让我把iap中通过TCP接收数据的代码移植到一个带有freertos系统的项目中，因为暂时完成故而有了本篇对移植过程的记录文章。一、移植思路对于移植设想了下面三个思路来进行。1.在freertos系统中开启一个新的任务用以处理数据接收。在使用这个方法尝试了一段时间后得知，本项目的栈空间已被项目原来的两个任务占满，无法开启新的任务而放弃。2.在系统初始化之前添加lwip初始化以及接收数据相关的TCP代码。
STM32F051学习- GPIO
zidigua的博客
11-18 4385
stm32F051 GPIO 有  电源引脚（三根），复位引脚（两根boot0,boot1,配置选择三种不同的启动模式，从主闪存存储器，系统存储器或者内置SRAM启动，代码可以放到三个不同的地方），GPIOF0~1（两根，可用于外接晶振，本例中外接8MHz的HSE晶振），GPIOA0~15（16根），GPIOB1~7（8根）。 引脚顺序：在芯片上四个角的某一个角上会有标志，从标志位置开始逆时针旋转...
STM32--STM32F051 IAP的实现
zwb_578209160的博客
05-26 3674
一、IAP原理及过程 《正点原子--STM32F10x串口IAP实验》 《stm32f030 IAP》 《STM32F051 IAP源码分享》 二、遇到的问题 1、中断向量表的充定向问题 （1）与M3核的单片机由区别 1）、STM32F0系列没有void NVIC_SetVectorTable(u32 NVIC_VectTab, u32 Offset)这个函数，所以不能像其他系列的那样设置中断向量表； 2）、M0核中需要把APP部分中的中断向量表重定向到SRAM中（在...
STM32 IAP(Bootloader)
qq_22329595的博客
01-24 4894
想给STM32做串口升级功能，研究STM32程序执行步骤。 1.STM32程序下载起始地址0x08000000,0x08000004这个地址是中断地址 2.先自己设计一个bootloader程序 ，然后再设计一个应用程序 3.给stm32 bootloader分配下载程序的空间，我用的是STM32F407ZGT6，具有1m的flash  （1）bootloader：0x0800 0000 ...
GD32远程升级程序源码含有iap和应用程序两个工程 stm32远程升级也可以参考此工程
05-30
在GD32和STM32远程升级程序中，有两个关键工程：iap和app。这两个术语分别代表： 1. IAP（In-Application Programming）：这是一种在应用运行时对闪存进行编程的技术。在GD32和STM32中，IAP通常用于实现固件的更新...
STM32F103基于Ymodem协议的串口IAP升级---STM32CUBEIDE开发
03-06
总之，通过STM32CUBEIDE开发基于Ymodem协议的串口IAP升级，不仅实现了远程固件更新，也增强了系统的灵活性和可维护性。这个过程涉及了嵌入式系统开发的多个方面，包括硬件接口配置、协议解析、中断处理和固件设计等...
stm32f4x官方bootload
02-15
在STM32F4x官方bootloader中，串口IAP允许开发者通过UART（通用异步收发传输器）接口远程更新MCU的闪存内容，而无需额外的编程设备。这种功能在产品维护、错误修复和固件升级等方面非常实用，减少了对硬件的物理接触...
STM32F03x IAP 串口升级 boot app 上位机全套
12-17
STM32F03x系列是意法半导体...总之，STM32F03x的IAP串口升级方案为开发者提供了灵活的固件更新途径，结合配套的Bootloader和上位机软件，可以实现安全、可靠的远程升级，极大地便利了产品的维护和更新。
51单片机IAP在线升级
10-29
爱矽半导体E85F3325,51单片机IAP在线升级,包含升级说明，BootLoader程序，ECOMV280串口助手
STM32F051 串口 在线升级
05-23
STM32F051 在线升级 串口 Y-modem 可以通过SecureCRT.exe或者超级终端的Ymodem协议直接升级，便于开发调试。代码核心功能主要参考官方提供的在线升级程序修改而来。如需进一步讨论，可邮件guanjq@sina.cn
STM32F0 IAP Demo
08-21
STM32F0的IAP测试。使用官方的开发板STM32F030_DISCOVERY板进行测试。IAP程序是在官方的例子上修改了一个按键。使用超级终端进行下载。操作和STM32F1一样。只是STM32F0的IAP需要在写用户程序时要自己添加中断向量表到RAM.
基于STM32的充电桩系统远程升级设计.pdf
06-27
本方案使用了具有1024KB Flash容量的STM32F207微控制器，并将Flash分为12个扇区，各个扇区的大小不尽相同，以便于存储不同部分的代码和数据。 接下来，文章详细阐述了在应用中编程（In-Application Programming, ...
STM32 Bootloader设计（IAP）
weixin_44460113的博客
08-11 1468
STM32 Bootloader设计（IAP） 用于单片机的IAP更新 传输协议使用YMOEDEM IAPSTM32 Bootloader设计（IAP）前言一、IAP原理二、配置1、FLASH程序区域 最少要分为两个区域：2、APP重设中断向量表三、bootloader设计1.接收包2.写FLASH3.跳转APP 前言 因设备进入使用阶段后，不适合使用jtag等方式擦写程序，故增加bootloader，以便对程序进行更新。 细节可以参考正点原子的IAP设计方式，但是正点原子使用的是整包传输的办法，如现
51单片机IAP升级
weixin_42417602的博客
12-05 1098
在嵌入式产品发布后，难免需要有更新的操作，那么在IAP的基础上配合某种无线通讯手段就可以开发出具有无线升级即OTA升级。本文也讲解下升级的基本思路
嵌入式处理器中Bootloader程序是什么以及IAP设备固件更新原理
biao2488890051的博客
04-27 1222
Bootloader程序也是一个单片机程序,编译后也是一个hex文件，然后下载到内部flash的前面区域 1.选择启动处在内部flash后面区域1的app1还是区域2的app2，然后把cpu运行指针加载到对应app的第一行代码那儿 2.假如用户选择了读app2，但是cpu不断从flash（这里的flash应该是指外部flash，读取速度比较慢，就比如电脑的硬盘）那儿读取指令然后译码执行可能速度...
stm32f030 IAP
10-21
STM32F030的IAP方法是指在应用编程（In Application Programming）中，通过Bootload引导单片机自己往程序存储器里写数据或修改程序。与STM32F1系列不同，F0没有中断向量偏移寄存器，因此在APP程序的开头需要添加特定的代码。通过IAP方法，可以实现远程更新配置细节，而不需要使用串口或者仿真器更新程序。同时，STM32平台也提供了用于IAP下载的程序模板，方便开发者编写应用程序。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值