STM32 bootload设计及思路，从理解到实施

已于 2024-05-31 10:05:35 修改
阅读量385 收藏 1
点赞数 3
文章标签： stm32 嵌入式硬件 单片机
于 2024-05-29 17:02:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43173102/article/details/139298261
版权

连载教程，保姆级教学

设计思路

闲来无事，博文好酒也没更新了。
思来想去，还是觉得写个小文章。
stm32也接触那么多年了，期间也做了很多的小玩意，不过大都是一些以学习为目的的DIY。
博主本身的话还是比较喜欢一些精细小巧的东西，在画电路板的时候，体积往往是尽可能的小一些，导致很多时候电路板的空间并不富裕，甚至于连stm32的烧录接口都没有留，于是就有了IAP的需求。

设计步骤

一般的IAP，分为三个部分。
1 上位机：负责发送新的固件給单片机
2 bootload： 负责固件的版本检测和更新，app程序的跳转和备份
3 app：负责程序的运行

bootload的设计

bootload的设计，一般都是通过通讯接口来接受bin文件，包括但不限于uart，spi，iic。本期教程采用uart来做讲解
教程开始前，请完成一下功能的验证
1 串口数据的收发
2 flash的读写和擦除
3 默认以上两点都已学会并熟练掌握
4 没有了
开个玩笑，现在开始正式讲解
bootload在上文中已经提及过具体的内容，分别是固件的检测和更新，在程序运行的时候检测固件是否需要更新，方法有很多种，在这里笔者推荐2种方式
1 程序初始化后，在一定的时间内，循环向上位机发送数据，可将当前固件版本号发送给上位机，然后上位机进行版本对比，若需要升级，则下发命令，单片机进入接收数据的状态
2 板载按钮，程序初始化后，在一定的时间内，若检测到按钮被按下，则单片机进入接收数据的状态
以上方法皆可，包括也不限于这两种方法，笔者这里自己设计的板子，带有触摸显示屏，单片机开始的时候刷屏，提示是否进入固件接收状态，点击屏幕即可进入接收状态。
以下是程序逻辑

	HAL_Init();				//hal init
	SystemClock_Config();	//system init
  	MX_GPIO_Init();			//gpio init	初始化按键
  	MX_DMA_Init();			//dma init	spi dma 初始化	刷屏使用
  	MX_SPI1_Init();			//spi init	spi 初始化	刷屏使用
  	MX_USART1_UART_Init();	//uart init	uart 初始化	用于和上位机通讯
 	MX_ADC2_Init();			//adc init	电池电量检测
  	MX_TIM2_Init();			//tim init	定时器
	HAL_UART_Receive_IT(&huart1,&UART1struct.RX_Tmp,1);	//开启串口接收中断
	if(HAL_GPIO_ReadPin(PWR_BTN_GPIO_Port,PWR_BTN_Pin)== GPIO_PIN_SET)
	{
		//开机检测，判断是插电开机还是按键开机，并锁存供电按钮
		HAL_GPIO_WritePin(PWR_CTRL_GPIO_Port,PWR_CTRL_Pin,GPIO_PIN_SET);
		while(check_pwr_btn());
	}
	//lcd init
	LCD_Init();		
	LCD_Fill(0,0,LCD_W,LCD_H,BLACK);
	LCD_BLK_Set();
	CST816T_Init();
	
	UI_Init();	//重点，在此处进行判断，刷屏询问是否要升级固件，如果不需要升级，则进行app加载(判断bootflag的状态)
	if(bootflag == 0)	//不需要升级
	{
		JumpToApp();	//则进行程序跳转
	}
	UI_Upgrade();		//刷屏，显示程序进行升级中
  	while (1)
  	{
		//在开始传输数据之前，每500ms向上位机发送一次数据，获取固件的信息
		if(check_fw_flag == 0)
		{
			//ymodem协议，循环向上位机发送C，告诉上位机，自己已进入数据接收状态
			HAL_UART_Transmit(&huart1,&C,1,100);
			HAL_Delay(1000);
		}
		//关机
		if(HAL_GPIO_ReadPin(PWR_BTN_GPIO_Port,PWR_BTN_Pin)== GPIO_PIN_SET)
		{
			while(check_pwr_btn());
			HAL_GPIO_WritePin(PWR_CTRL_GPIO_Port,PWR_CTRL_Pin,GPIO_PIN_RESET);
			__set_FAULTMASK(1);
			HAL_NVIC_SystemReset();
			HAL_Delay(5000);
		}
  }

主程序大概的逻辑就是这样子了

bootload数据的接收处理函数

在学习接收数据的方法之前，要了解一个协议，Ymodem协议，网上有很多详细的讲解，笔者在这里简单的介绍一下，着重讲解一下实现

//符号       数值      含义
//SOH       0X01        128字节数据包
//STX       0X02        1024字节数据包
//EOT       0X04        结束传输
//ACK       0X06        回应
//NAK       0X15        不回应
//CA        0X18        传输终止
//C         0X43        请求数据包

在主函数的代码片里面可以看到

	//ymodem协议，循环向上位机发送C，告诉上位机，自己已进入数据接收状态
	HAL_UART_Transmit(&huart1,&C,1,100);
	HAL_Delay(1000);

这里就是在上位机发送数据之前，每隔1ms向上位机发送一个0x43 的数据，告诉上位机自己进入等待数据接收的状态

然后我们看接收数据的实现，数据接收分为两部分，第一部分是不定长数据的接收，第二部分是不定长数据接收的判断

串口不定长接收处理

这里采用的是hal库，因此在串口接收到数据后，会进入串口接收回调函数里，在这里重写数据接收逻辑。笔者这里初始化了一个定时器，当串口在定时器计时时间内收到数据，定时器被重置，继续计时，当计时超时，则进行数据处理

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    UNUSED(huart);
	UART1struct.RX_TempBuff[UART1struct.RX_TempLen] = UART1struct.RX_Tmp;	//将接收到的数据放到缓存数组中
	UART1struct.RX_TempLen++;							//缓存下标+1
	HAL_UART_Receive_IT(&huart1,&UART1struct.RX_Tmp,1);	//开启串口接收中断
	HAL_TIM_Base_Start_IT(&htim2);						//开启定时器
	__HAL_TIM_SET_COUNTER(&htim2,0);					//定时器计时清零
}

定时器回调函数

//符号       数值      含义
//SOH       0X01        128字节数据包
//STX       0X02        1024字节数据包
//EOT       0X04        结束传输
//ACK       0X06        回应
//NAK       0X15        不回应
//CA        0X18        传输终止
//C         0X43        请求数据包
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{   
	char file_name[64] = {0};						//接收到的文件名
	int file_len = 0;								//接收到的文件长度
	int i = 0,j = 0;								//临时变量
	uint8_t number = 0;								//临时变量
	uint32_t write_addr = 0;						//写入的地址
	if(htim == &htim2)  //判断中断是否来自于定时器2
	{
		HAL_TIM_Base_Stop_IT(&htim2);				//关闭定时器
		HAL_GPIO_TogglePin(LED_GPIO_Port,LED_Pin);	//反转指示灯状态
		switch(UART1struct.RX_TempBuff[0])			//判断帧头数据
		{
			case 0x01:	//握手完成，上位机发送启示帧，协议开始传输，协议格式
			{			//SOH  | 0X00 0XFF | FileName+0x00  | FileSize+0x00 | NULL(0X00)
						//0x01 | 0x00 0xff | watch.bin 0x00 | 123456 0x00   | 0x00...
				check_fw_flag = 1;			//将向上位机发送请求数据的标志位置1，之后单片机将被不会继续上上位机发送数据请求标识符
				for(i = 0; i <UART1struct.RX_TempLen-3;i++)			//拷贝数组
				{
					UART1struct.RX_Buff[i] = UART1struct.RX_TempBuff[i+3];
				}
				sscanf((const char*)UART1struct.RX_Buff,"%s",file_name);	//解析文件名
				j = strlen(file_name);										
				for(i = 0; i <UART1struct.RX_TempLen-3;i++)
				{
					UART1struct.RX_Buff[i] = UART1struct.RX_Buff[i+j+1];
				}
				sscanf((const char*)UART1struct.RX_Buff,"%d",&file_len);	//解析文件大小
				i = EraseFlash(APP_STAR_ADDR,APP_STOP_ADDR);				//擦除flash
				if(i == 2)													//判断擦除是否成功
				{
					EraseFlash(APP_STAR_ADDR,APP_STOP_ADDR);
				}
				HAL_UART_Transmit(&huart1,&ACK,1,100);						//向上位机发送应答信号
			}break;
			case 0x02:	//数据接收函数处理
			{
				if(UART1struct.RX_TempBuff[1]+UART1struct.RX_TempBuff[2] == 0xff)	//校验帧头数据的合法性
				{
					write_addr = UART1struct.RX_TempBuff[1]*1024;	//flash写入数据的地址，等于帧头(包号*1024)
					for(i = 0; i <UART1struct.RX_TempLen-3;i++)		//将数据拷贝出来
					{
						UART1struct.RX_Buff[i] = UART1struct.RX_TempBuff[i+3];
					}
					UART1struct.RX_Len = UART1struct.RX_TempLen-3;
					FlashWriteAPP(APP_STAR_ADDR+write_addr,UART1struct.RX_Buff,UART1struct.RX_Len);		//将数据写入flash
					HAL_UART_Transmit(&huart1,&ACK,1,100);			//向上位机发送应答信号
				}
			}break;
			case 0x04:	//结束传输，程序重启
			{
				if(UART1struct.RX_TempBuff[1]+UART1struct.RX_TempBuff[2] == 0xff)
				{
					HAL_GPIO_WritePin(PWR_CTRL_GPIO_Port,PWR_CTRL_Pin,GPIO_PIN_RESET);
					__set_FAULTMASK(1);
					HAL_NVIC_SystemReset();
					HAL_Delay(5000);
//					JumpToApp();
				}
			}
			default:
				break;
		}
		
//		FlashWriteAPP(APP_STAR_ADDR,UART1struct.RX_TempBuff,UART1struct.RX_TempLen);
		for(i = 0; i < 1033; i++)		//数组里面的数据处理后，将数据全部清0，以免数据出现意外
		{
			UART1struct.RX_TempBuff[i] = 0;
			UART1struct.RX_Buff[i] = 0;
		}
		UART1struct.RX_TempLen= 0;
		UART1struct.RX_Len = 0;
	}
}

程序的跳转

将程序跳转也是分为两部分
第一部分是将程序跳转至app的地址，实现如下

__IO uint32_t BootAddr = 0x08010000;

void (*SysMemBootJump)(void);

static void JumpToApp(void)
{
	uint32_t i = 0;
	//关闭全局中断
	DISABLE_INT();
	//关闭滴答定时器,复位到默认值
	SysTick->CTRL = 0;
	SysTick->LOAD = 0;
	SysTick->VAL  = 0;
	//关闭所有中断,清除中断挂起标志
	for(i = 0; i < 8; i++)
	{
		NVIC->ICER[i] = 0xffffffff;
		NVIC->ICPR[i] = 0xffffffff;
	}
	//使能全局中断
	ENABLE_INT();
	//跳转到系统bootload,首地址时MSP, 地址+4是复位中断服务程序地址
	SysMemBootJump = (void (*)(void)) (*((uint32_t *) (BootAddr + 4)));
	/* 设置主堆栈指针 */
	__set_MSP(*(uint32_t *)BootAddr);
	/* 在RTOS工程，这条语句很重要，设置为特权级模式，使用MSP指针 */
	__set_CONTROL(0);
	/* 跳转到系统BootLoader */
	SysMemBootJump(); 
	/* 跳转成功的话，不会执行到这里，用户可以在这里添加代码 */
	while (1)
	{
		HAL_GPIO_TogglePin(LED_GPIO_Port,LED_Pin);
		HAL_Delay(100);
	}
}

第二部分是在app中实现的，因为app的起始地址和bootload的起始地址不一样，跳转完成后，中断向量映射的地址也不同，因此需要在app中重新设置中断向量映射地址，这里简单说一下
修改system_stm32xxx.h文件中的VECT_TAB_OFFSET地址，这里就是设置偏移地址的值，在函数SystemInit这里可看出具体的实现，这里就不多说了

void SystemInit(void)
{
	/* FPU settings ------------------------------------------------------------*/
	#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
	SCB->CPACR |= ((3UL << (10*2))|(3UL << (11*2)));  /* set CP10 and CP11 Full Access */
	  #endif
	
	  /* Configure the Vector Table location add offset address ------------------*/
	#if defined(USER_VECT_TAB_ADDRESS)
	  SCB->VTOR = VECT_TAB_BASE_ADDRESS |  VECT_TAB_OFFSET

; /* Vector Table Relocation in Internal SRAM */
	#endif /* USER_VECT_TAB_ADDRESS */
}

上位机的实现

上位机还是老一套，实现的功能为当打开程序时，自动检测串口，当识别为ch340的设备后打开该设备的com口，然后打开bin文件和下发文件，在这里只贴出效果和简单的串口命令下发的代码。如果需要源码，则可以自行下载
下图分别为未插入ch340设备的界面，插入ch340后打开的界面，以及选择bin文件后的界面
在这里插入图片描述

/// <summary>
        /// 打开可用的串口
        /// </summary>
        private void OpenUseSerialPort()
        {
            if (ConnectState.BackColor != Color.Lime)
            {
                //"0403", "6001" USB转232
                //"067B", "2303" USB转485
                //"0986", "0320" PLC端口
                //"1a86", "7523" CH340
                //portName = FormMain.GetPortNameFormVidPid("0986", "0320");
                List<string> availport;
                availport = GetPortNameFormVidPid("1a86", "7523");
                //portName = GetPortNameFormVidPid("067B", "2303");
                if (availport != null)
                {
                    string[] port = availport.ToArray();
                    CBVarPort.Items.AddRange(port);

                    //timer1.Enabled = true;
                }
                else
                {
                    CBVarPort.Items.AddRange(System.IO.Ports.SerialPort.GetPortNames());  //获取所有串口设备
                    DisplayLog(1, "NO find Correspond port!");
                    return;
                }
                if (CBVarPort.Items.Count > 0)
                {
                    CBVarPort.SelectedIndex = 0;

                    if (mc.IsOpen == false)
                    {
                        try
                        {
                            portName = CBVarPort.Items[0].ToString();
                            Debug.WriteLine("Use port:" + portName);

                            // bool isOpen = mc.Open(portName, Baudrate, System.IO.Ports.Parity.None, 8, System.IO.Ports.StopBits.One, 200, 200);
                            mc.PortName = portName;
                            mc.BaudRate = Baudrate;
                            mc.Parity = Parity.None;
                            mc.StopBits = StopBits.One;
                            mc.DataBits = 8;
                            mc.Open();

                            if (!mc.IsOpen)
                            {
                                //MessageBox.Show("串口打开失败");
                                Console.ForegroundColor = ConsoleColor.Red;
                                DisplayLog(1, "* Open port fail");
                                Console.ForegroundColor = ConsoleColor.Green;

                            }
                            else
                            {
                                //串口打开成功，modbus协议初始化成功,打开定时器
                                //MessageBox.Show("串口打开成功");
                                ConnectState.Text = "Connect";
                                ConnectState.BackColor = Color.Lime;
                                DisplayLog(1, "* Open port ok");
                                mc.Write("data\r\n");
                            }

                        }
                        catch (Exception ex)
                        {
                            MessageBox.Show("Open port error" + ex, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                            ConnectState.Text = "NULL";
                            ConnectState.BackColor = Color.Yellow;
                            Console.ForegroundColor = ConsoleColor.Red;
                            DisplayLog(1, "* Open port error");
                            Console.ForegroundColor = ConsoleColor.Green;
                        }
                    }
                }
                else
                {
                    MessageBox.Show("NO Use Serialport", "Waring", MessageBoxButtons.OK, MessageBoxIcon.Question);
                    Console.ForegroundColor = ConsoleColor.Red;
                    DisplayLog(1, "* No available port");
                    Console.ForegroundColor = ConsoleColor.Green;
                }
            }
            else
            {
                mc.Close();
                ConnectState.Text = "NULL";
                ConnectState.BackColor = Color.Yellow;
                DisplayLog(1, "* Port close");
            }

            //mc.ReadTimeout = 50;
            mc.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);
        }
      

//Ymodem传输协议
        //符号       数值      含义
        //SOH       0X01        128字节数据包
        //STX       0X02        1024字节数据包
        //EOT       0X04        结束传输
        //ACK       0X06        回应
        //NAK       0X15        不回应
        //CA        0X18        传输终止
        //C         0X43        请求数据包
        byte SOH = 0x01;
        byte STX = 0X02;
        byte EOT = 0X04;
        byte ACK = 0X06;
        byte NAK = 0X15;
        byte CA = 0X18;
        byte C = 0X43;
        static byte[] sendData= new byte[1033];
        private void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
        {
            SerialPort sp = (SerialPort)sender;
            Thread.Sleep(100);
            try
            {
                string indata = sp.ReadExisting();
                try
                {
                    if (sendFlag == true)
                    {
                        if (indata[0] == C)     //请求数据传输
                        {
                            DisplayLog(1, "handshake");
                            int len1 = 0;
                            int len2 = 0;
                            sendData[0] = SOH;      //帧头
                            sendData[1] = 0x00;     //包号
                            sendData[2] = 0xff;     //包号反码
                            byte[] decBytes = System.Text.Encoding.UTF8.GetBytes(label1.Text);
                            decBytes.CopyTo(sendData, 3);//将文件名追加到sendData中
                            len1 = label1.Text.Length;
                            sendData[3 + len1] = 0x00;
                            byte[] decBytes1 = System.Text.Encoding.UTF8.GetBytes(label4.Text);
                            decBytes1.CopyTo(sendData, 4 + len1);
                            len2 = label4.Text.Length;
                            for (int i = (4 + len1 + len2); i < 131; i++)
                            {
                                sendData[i] = 0x00;
                            }
                            mc.Write(sendData, 0, 131);
                        }
                        if (indata[0] == ACK)
                        {
                            if (number < point)
                            {
                                sendData = lists[number].ToArray();
                                mc.Write(sendData, 0, 1027);
                                number++;
                                progressBar1.PerformStep();
                                int j = (int)(((float)number / (float)point)*100);
                                label5.Text = j.ToString() + "%";
                                DisplayLog(1, point.ToString()+" -> "+number);
                            }
                            else
                            {
                                sendData[0] = EOT;
                                sendData[1] = 0x00;
                                sendData[2] = 0xff;
                                for (int i = 3; i < 133; i++)
                                {
                                    sendData[i] = 0x00;
                                }
                                mc.Write(sendData, 0, 131);
                                DisplayLog(1, "Send Over!");
                                point = 0;
                                number = 0;
                                sendFlag = false;
                            }
                        }
                    }
                }
                catch (Exception ex)
                {

                }
            }
            catch (Exception ex)
            {

            }

        }

/// <summary>
        /// 通过vid，pid获得串口设备号
        /// </summary>
        /// <param name="vid">vid</param>
        /// <param name="pid">pid</param>
        /// <returns>串口号</returns>
        public static List<string> GetPortNameFormVidPid(string vid, string pid)
        {
            Guid myGUID = Guid.Empty;

            string enumerator = "USB";
            //string enumerator = "CH340";
            List<string> AvailPort = new List<string>(16);
            try
            {
                IntPtr hDevInfo = HardWareLib.SetupDiGetClassDevs(ref myGUID, enumerator, IntPtr.Zero, HardWareLib.DIGCF_ALLCLASSES | HardWareLib.DIGCF_PRESENT);
                if (hDevInfo.ToInt32() == HardWareLib.INVALID_HANDLE_VALUE)
                {
                    throw new Exception("没有该类设备");
                }
                HardWareLib.SP_DEVINFO_DATA deviceInfoData;//想避免在api中使用ref，就把structure映射成类
                deviceInfoData = new HardWareLib.SP_DEVINFO_DATA();
                deviceInfoData.cbSize = 28;//如果要使用SP_DEVINFO_DATA，一定要给该项赋值28=16+4+4+4
                deviceInfoData.devInst = 0;
                deviceInfoData.classGuid = System.Guid.Empty;
                deviceInfoData.reserved = 0;
                UInt32 i;
                StringBuilder property = new StringBuilder(HardWareLib.MAX_DEV_LEN);

                for (i = 0; HardWareLib.SetupDiEnumDeviceInfo(hDevInfo, i, deviceInfoData); i++)
                {
                    //       Console.Write(deviceInfoData.classGuid.ToString());
                    //       HardWareOperation.SetupDiGetDeviceInstanceId(hDevInfo, deviceInfoData, porperty, (uint)porperty.Capacity, 0);
                    HardWareLib.SetupDiGetDeviceRegistryProperty(hDevInfo, deviceInfoData, (uint)HardWareLib.SPDRP_.SPDRP_CLASS, 0, property, (uint)property.Capacity, IntPtr.Zero);

                    if (property.ToString().ToLower() != "ports") continue;//首先看看是不是串口设备（有些USB设备不是串口设备）

                    HardWareLib.SetupDiGetDeviceRegistryProperty(hDevInfo, deviceInfoData, (uint)HardWareLib.SPDRP_.SPDRP_HARDWAREID, 0, property, (uint)property.Capacity, IntPtr.Zero);

                    if (!(property.ToString().ToLower().Contains(vid.ToLower()) && property.ToString().ToLower().Contains(pid.ToLower()))) continue;//找到对应于vid&pid的设备

                    HardWareLib.SetupDiGetDeviceRegistryProperty(hDevInfo, deviceInfoData, (uint)HardWareLib.SPDRP_.SPDRP_FRIENDLYNAME, 0, property, (uint)property.Capacity, IntPtr.Zero);
                    //                     break;     //查询到一个就退出
                    string friendlyName = property.ToString();
                    char[] separatorMark = { '(', ')' };
                    string[] strList1 = friendlyName.Split(separatorMark);
                    if (strList1[1].Substring(0, 3) == "COM")
                    {
                        AvailPort.Add(strList1[1]);
                    }
                }

                HardWareLib.SetupDiDestroyDeviceInfoList(hDevInfo);//记得用完释放相关内存

                if (AvailPort.Count > 0)
                {
                    return AvailPort;
                }
                else

                    return null;

            }
            catch (Exception ex)
            {
                //        MessageBox.Show(ex.Message);
                return null;
            }
        }

/// <summary>
        /// 打开BIN文件得到路径，读取其中的二进制内容
        /// </summary>
        /// <returns>返回二进制数字符串</returns>
        /// 
        public static int OpenBinFile()
        {
            //string bin_str = "";
            //byte[] binchar = new byte[] { };
            int file_len;
            //打开文件类
            
            OpenFileDialog dialog = new OpenFileDialog();
            //使用当前目录作为初始目录
            dialog.InitialDirectory = System.AppDomain.CurrentDomain.BaseDirectory;
            //文件过滤，仅打开bin
            dialog.Filter = "bin文件(*.bin)|*.bin";
            //关闭选择多文件
            dialog.Multiselect = false;
            if (dialog.ShowDialog() == DialogResult.OK)
            {
                //文件流类//用于文件的读写与关闭//来自于System.IO 
                FileStream fileStream = new FileStream(dialog.FileName, FileMode.Open);
                //读二进制文件类
                BinaryReader br = new BinaryReader(fileStream, Encoding.UTF8);
                //获取bin文件长度
                file_len = (int)fileStream.Length;
                //得到所有字节
                //binchar = br.ReadBytes(file_len);
                dddd = br.ReadBytes(file_len);
                file_name = fileStream.Name;
                file_name = Path.GetFileName(file_name);
                fileStream.Close();
                return file_len;
            }

            //返回字符串
            
            return 0;
        }

/// <summary>
        /// start/stop按钮单击事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        //private List<byte> list = new List<byte>();
        private List<byte> list = null;
        private List<List<byte>> lists = new List<List<byte>>();
        private void button2_Click(object sender, EventArgs e)
        {
            int len = OpenBinFile();
            int leng = len % 1024;
            open_file_len = len;
            label4.Text = len.ToString();
            label1.Text = file_name;

            var index = 0;
            //list = null;
            foreach (var item in dddd)
            {
                if(list == null)
                {
                    list = new List<byte>();
                }
                if (list.Count == 0)
                {
                    list.Add(STX);
                    list.Add(((byte)point));
                    list.Add((byte)~point);
                }

                list.Add(item);
                if (++index == 1024)
                {
                    lists.Add(list);
                    list =null;
                    index = 0;
                    point++;
                }
            }
            for (int i = 0; i < (1024-leng); i++)
            {
                list.Add(0x1A);
            }
            lists.Add(list);
            point++;
            progressBar1.Visible = true;
            progressBar1.Style = ProgressBarStyle.Blocks;
            progressBar1.Maximum = (int)point;
            progressBar1.Minimum = 0;
            progressBar1.MarqueeAnimationSpeed = 0;
            progressBar1.Step = 1;
            label5.Text = "0%";
            label5.Visible = true;
        }

各位看官记得收藏关注，后续将上位机源码上传

小小樱桃我最爱
关注
分享一个stm32 最精简的bootload程序
weixin_57010826的博客
04-24 466
/ 处理接收到的数据，例如检查数据包头、计算校验和等 // ... // 将数据写入闪存。#define BOOTLOADER_ADDRESS 0x08000000 // Bootloader的起始地址。{ // 编程半个字的闪存 FLASH_ProgramHalfWord(Address, Data);{ // 串口配置代码，例如设置波特率、数据位、停止位等 // ... }{ // 解锁闪存，以便进行编程操作 FLASH_Unlock();// 系统初始化代码，例如设置时钟、GPIO等 // ...
STM32F103系列Bootloader
12-29
STM32F103系列bootloader,便于更新项目固件。有什么不懂的可以私信我，顺便赚点积分下载东西。。。(QAQ!!!)
STM32H7之系统bootLoader一章搞定
yybyg的博客
07-25 1229
STM32 的系统存储区自带 bootloader，此程序是 ST 在芯片出厂时烧录进去的，主要用于将用户应用程序下载到芯片内部 Flash。支持 USB，SPI，I2C，CAN，UART 等接口方式下载。如果大家的应用程序打算采用这种接口方式进行升级，可以考虑采用系统 bootloader，简单易用，无需用户自己写bootLoader 了。但是该方式的局限性还是比较大，无法自己对bootLoader进行更多的操作，仅仅是能够通过STM32自己的方式进行升级而已。
stm32CubeMX配置通过bootload升级的问题总结
最新发布
qq_37233830的博客
08-12 329
stm32MCU开发总结
STM32_使用Bootloade升级程序（IAP方式）
qq_26043945的博客
03-01 1万+
引言 在我们把产品封装到了机器里面之后，当需要升级代码就变得很麻烦了，就要拆外壳，连接烧写器才能进行代码的升级，比如是买出去的产品，那更新就变得更加麻烦了，所以造成代码升级就变得非常麻烦。所以就有了一种新的更新程序的方法（IAP）。使用了该方式的单片机产品，只要在最开始预留了“SD卡”或者“串口接口”就能简单的进行程序的升级更新了。这里我们使用对“串口”更新程序的方式进行步骤讲解。 一、思路简介 首先我们理出一条思路，就如手机一样，我们在开机的时候长按某个键就能进行系统的升级一样，这里我们就按着这个思路，做
14.Bootloader设计思路
ashe9657的博客
02-14 374
14.Bootloader设计思路 在前面，已经了解了很多裸机的知识，也建立了一个测试汇编代码的工程。这些工作其实是为这里来学习Bootloader做铺垫的。 这一节的索引：图1-1： 图1-1 一个嵌入式的存储设备通过通常包括四个分区： 第一分区：存放的当然是u-boot 第二个分区：存放着u-boot要传给系统内核的参数 第三个分区：是系统内核（kernel） ...
【STM32标准库】制作一个bootloader
热门推荐
目标：MVP
06-09 1万+
/#endif /``关于地址跳转部分，可以参考STM32 Bootloader程序中Jump2App函数分析。
stm32的bootloader思考
三人行的博客
08-16 892
stm32的bootloader思考stm32的bootloader思考1. stm32的启动流程2.keil生成rom的映射表3.ram的映射表4.VTOR详解5.编写app6.编写bootloader stm32的bootloader思考 本文章主要是关于自己在尝试编写stm32的bootloader时候，对遇到的问题，查阅的资料，设计代码测试的一些感想。 1. stm32的启动流程 stm32在上电的时候，首先需要选择上电后，代码起始的执行位置，以stm32f103为例，根据boot0，boot1的选
STM32 简易Bootloader
m0_46489657的博客
05-10 3456
主要实现bootloader串口读取app程序 ，将app程序拷贝到对应运行的flash区域，跳转到对应的区域执行代码。本文没有复杂的显示，app只点亮一个灯做测试用。
stm32f4x官方bootload
02-15
这个官方bootloader是针对STM32F4系列芯片设计的，用于固件升级和应用程序的引导加载。在嵌入式系统开发中，bootloader扮演着至关重要的角色，它是系统上电或复位后执行的第一段程序，负责初始化硬件、设置内存映射...
stm32f10x官方bootload
02-15
1.stm32官方串口IAP。
STM32+485+ymodem协议的bootload
10-27
STM32通过485通讯升级程序，加入ymodem协议的bootload
Stm32BootLoader参考
03-03
1.Bootloader程序 2.userApplication程序 3.官方IAP程序。 4.官方IAP协议解析文档（Ymodem）
stm32 BootLoader简单跳转
08-18
BootLoader简单的跳转功能，理解基本原理，BootLoader简单的跳转功能，理解基本原理
STM32F103工程bootload
04-24
编写一个针对STM32F103的Bootloader例程涉及到几个关键步骤：初始化硬件、配置串口通信（通常用于调试和接收固件更新指令）、实现Flash编程算法以及处理固件更新流程。以下是一个简化的Bootloader例程框架，用于STM...
STM32使用QT上位机下载程序，exe+stm32-bootload+stm32-app
05-27
在本场景中，`stm32-bootload`指的是自定义或预装在STM32上的Bootloader，它支持通过串口、USB或网络等接口接收新的应用程序，并将其烧录到Flash中。 2. **QT上位机软件**： `exe`文件通常是指Windows平台下的可...
stm32_bootloader-master_stm32bootloader_Bootloader_stm32bootload
09-29
这个压缩包文件"stm32_bootloader-master_stm32bootloader_Bootloader_stm32bootload"包含了一个STM32 Bootloader的源代码库，用于理解和开发自己的STM32 Bootloader。 STM32是意法半导体（STMicroelectronics）...
stm32 bootloader(一)
daoshengtianxia的博客
08-22 1332
现在工作一直做的汇编，不想把以前学的c和stm32丢了。于是决定利用下班的时间写个bootloader。整天思路：从串口接收数据，可以利用ESP8266等透传模块和stm32串口连接。在应用层即APP里接受串口来的数据，把数据写到外部spi flash，并且写入相关需要升级的标志。在mcu重启时检测标志位，如果需要升级就读取升级数据，写到内部flash里。升级成功后将需要升级的标志去除。 flas...
stm32 bootload
05-30
STM32 Bootloader是一种特殊的程序，用于初始化STM32芯片并加载应用程序。在STM32芯片中，Bootloader位于系统存储器的起始地址处，其大小一般为8KB。当芯片处于系统引导启动模式时，它将从Bootloader中读取并执行代码。 在STM32芯片中，Bootloader主要有两种实现方式：一种是通过UART/USB等外部接口进行通信，实现固件升级和应用程序加载；另一种是通过IAP（In Application Programming）方式，在应用程序中调用Bootloader进行固件升级和应用程序加载。 通过UART/USB等外部接口进行通信的Bootloader需要在芯片上电或复位时，按照一定的规则进入Bootloader模式，通过UART/USB等外部接口与上位机进行通信，实现固件升级和应用程序加载。 通过IAP方式进行固件升级和应用程序加载，需要在应用程序中调用Bootloader进行升级和加载。在应用程序中调用Bootloader时，需要进行一些特殊的设置，如关闭中断、关闭全局变量等，以确保升级和加载的安全性和正确性。 总之，STM32 Bootloader是一种非常重要的程序，它为STM32芯片的固件升级和应用程序加载提供了可靠的解决方案。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值