开源SWD脱机烧录器-第二章 SWD协议移植

最新推荐文章于 2024-05-22 18:59:17 发布
置顶 最新推荐文章于 2024-05-22 18:59:17 发布
阅读量9.4k 收藏 63
点赞数 9
文章标签： SWD源码 脱机烧录器 脱机烧写器 STM32 SWD
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012918754/article/details/102900552
版权

/********************2020.03.02更新********************/

感谢博友的提醒我忘记上传Qt源码了，这就补上

https://gitee.com/airtech/offline_Qt

/**********************************************2020.01.20*****************************************/

开源地址：https://gitee.com/airtech/offline_burner

/**********************************************2019.12.31******************************************/

部分代码参考了https://github.com/wuxx/nanoDAP

将上一章提到文件加入工程中“DPA.c/error.c/SW_DP.c/target_flash.c/swd_host.c/flash_blob.c”

这是我的，SWD_FLASH.c对应的是target_flash.c

先打开#include "DAP_config.h"配置文件，在这里面配置SWD的引脚和相关参数

按照下面配置，直接复制就好了

SWD引脚IO定义：

SWD引脚IO操作定义

 /***********************DAP_config.h end**********************/

SW_DP.C文件移植：

最主要的改动都在SW-DP和SWD_host两个文件。

奇偶校验数组：

将SWJ_Sequence的内容改成：

将SWD_Transfer_Buff内容改成：

uint8_t	SWD_Transfer_Buff(uint32_t request, uint32_t *data)
{
	uint8_t ack=0;                                                                 
  uint32_t bit;                                                                 
  uint32_t val;                                                                 
  uint32_t parity=0U;                                                           
  uint8_t	req_buf=0U;
	uint8_t	Start[8];	
  uint32_t n;      
	uint8_t vall[5];
	uint8_t val_TX[4]={0xFF,0xFF,0xFF,0xFF};
	uint32_t val_buf;
  /* Packet Request */ 

	SPI_Switch(1);
	parity = 0U;
	Start[0]=1U;
	bit=request >> 0;
	Start[1]=bit&0x01;
	parity += bit;
	bit= request >> 1;
	Start[2]=bit&0x01;
	parity += bit;
	bit= request >> 2;
	Start[3]=bit&0x01;
	parity += bit;
	bit= request >> 3;
	Start[4]=bit&0x01;
	parity += bit;
	Start[5]=parity&0x01;
	Start[6]=0U;
	Start[7]=1U;
	
	req_buf=(Start[0]<<0)	|	(Start[1]<<1)	|	(Start[2]<<2)	|	(Start[3]<<3)	|	(Start[4]<<4)	|	(Start[5]<<5)	|	(Start[6]<<6)	|	(Start[7]<<7);	
	SPI1_ReadWriteByte(req_buf);                                                         
	SPI_Switch(0);

	/* Turnaround */
  for (n = DAP_Data.swd_conf.turnaround; n; n--) {                              
    SW_CLOCK_CYCLE();     		
  }                                                                             

  /* Acknowledge response */                                                    
  SW_READ_BIT(bit);                                                             
  ack  = bit << 0;                                                              
  SW_READ_BIT(bit);                                                             
  ack |= bit << 1;                                                              
  SW_READ_BIT(bit);                                                             
  ack |= bit << 2; 

  if (ack == DAP_TRANSFER_OK) 
	{  /* OK response */                       
    /* Data transfer */                                                         
    if (request & DAP_TRANSFER_RnW) 
		{
			SPI_Switch(1); 			
      /* Read data */                                                           
      val = 0U;                                                                 
      parity = 0U;

			SPI_TXRX(val_TX,vall,4);
			val=vall[0]<<0	|	vall[1]<<8	|	vall[2]<<16	|	vall[3]<<24;
			val_buf^=val_buf>>16;
			val_buf^=val_buf>>8;
			parity=ParityTable256[val_buf & 0xff]&0x01;
			
			SPI_Switch(0);
			SW_READ_BIT(bit);
//      if ((parity ^ bit) & 1U) 
//			{                                                
//        ack = DAP_TRANSFER_ERROR;                                               
//      }                                                                         
      if (data) { *data = (val); }                                                
      /* Turnaround */ 
			
			val = 0U;                                                                 
      parity = 0U;			
      for (n = DAP_Data.swd_conf.turnaround; n; n--) {                          
        SW_CLOCK_CYCLE();     
      }                                                                                                                        
    } 
		else 
		{                                                                    
      /* Turnaround */                                                          
      for (n = DAP_Data.swd_conf.turnaround; n; n--) {                          
        SW_CLOCK_CYCLE();                                                       
      }                                                                         
      SPI_Switch(1);                                                   
      /* Write data */                                                          
      val = *data;                                                              
      parity = 0U;
			
			vall[0]=val&0xFF;
			vall[1]=val>>8&0xFF;
			vall[2]=val>>16&0xFF;
			vall[3]=val>>24&0xFF;
			
			val_buf=vall[0]<<0	|	vall[1]<<8	|	vall[2]<<16	|	vall[3]<<24;
			val_buf^=val_buf>>16;
			val_buf^=val_buf>>8;
			parity=ParityTable256[val_buf & 0xff];
			
			SPI_TX4(vall);/* Write WDATA[0:31] */
			SPI_Switch(0);                                                             
      SW_WRITE_BIT(parity);             /* Write Parity Bit */                  
    } 
		
    /* Idle cycles */ 
    n = DAP_Data.transfer.idle_cycles; 
    if (n) {                                                                    
      PIN_SWDIO_OUT(0U);                                                        
      for (; n; n--) {                                                          
        SW_CLOCK_CYCLE();                                                       
      }                                                                         
    }                                                                           
    PIN_SWDIO_OUT(1U);
    return ack;                                                     
  }                                                                             
                                                                                
  if ((ack == DAP_TRANSFER_WAIT) || (ack == DAP_TRANSFER_FAULT)) 
	{ 
		SPI_Switch(0);
    /* WAIT or FAULT response */                                                
    if (DAP_Data.swd_conf.data_phase && ((request & DAP_TRANSFER_RnW) != 0U)) 
		{ 
      for (n = 32U+1U; n; n--) 
			{                                                
        SW_CLOCK_CYCLE();               /* Dummy Read RDATA[0:31] + Parity */   
			}                                                                         
    }		
    /* Turnaround */                                                            
    for (n = DAP_Data.swd_conf.turnaround; n; n--) {                            
      SW_CLOCK_CYCLE();                                                         
    }                                                                           
                                                         
    if (DAP_Data.swd_conf.data_phase && ((request & DAP_TRANSFER_RnW) == 0U)) 
		{ 
			printf("(DAP_Data.swd_conf.data_phase && ((request & DAP_TRANSFER_RnW) == 0U))\r\n");
      PIN_SWDIO_OUT(0U);                                                        
      for (n = 32U+1U; n; n--) 
			{                                                
        SW_CLOCK_CYCLE();               /* Dummy Write WDATA[0:31] + Parity */  
      }                                                                         
    }		
    PIN_SWDIO_OUT(1U);  		
    return ack;                                                      
  }                                                                             
                                  
  /* Protocol error */                                                          
  for (n = DAP_Data.swd_conf.turnaround + 32U + 1U; n; n--) {                   
    SW_CLOCK_CYCLE();                   /* Back off data phase */               
  }                                                                             
                                                         
  PIN_SWDIO_OUT(1U);   

  return ack;   
}

剩下的几个函数改成：

/************************SW_DP END************************/

 

移植swd_host：

将JTAG2SWD函数内容改成

static uint8_t JTAG2SWD()
{
  uint32_t tmp = 0;
	uint8_t LineRst[7]={0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
	uint8_t	swd_switch1[2]={0x9E,0xE7};
	uint8_t	swd_switch2[2]={0x6D,0xB7};

	
	SPI_TX7(LineRst);
	SPI_TX2(swd_switch1);
	SPI_TX7(LineRst);
	SPI_TX2(swd_switch2);
	SPI_TX7(LineRst);

    if (!swd_read_idcode(&tmp)) {
			printf("Read IDCODE Fault 0x%.4X\r\n",tmp);
        return 0;
    }
//		printf("IDCODE : 0x%.4X\r\n",tmp);
    return 1;
}

软件复位：

//-----Soft reset + Hard reset-------------------------------------------------
#define PIN_SWCLK_SET PIN_SWCLK_TCK_SET
#define PIN_SWCLK_CLR PIN_SWCLK_TCK_CLR

#define RST_CLOCK_CYCLE()                \
  PIN_SWCLK_CLR();                       \
  PIN_DELAY();                           \
  PIN_SWCLK_SET();                       \
  PIN_DELAY()

#define RST_WRITE_BIT(bit)               \
  PIN_SWDIO_OUT(bit);                    \
  PIN_SWCLK_CLR();                       \
  PIN_DELAY();                           \
  PIN_SWCLK_SET();                       \
  PIN_DELAY()

#define RST_READ_BIT(bit)                \
  PIN_SWCLK_CLR();                       \
  PIN_DELAY();                           \
  bit = PIN_SWDIO_IN();                  \
  PIN_SWCLK_SET();                       \
  PIN_DELAY()

//#define PIN_DELAY() PIN_DELAY_SLOW(DAP_Data.clock_delay)
#define PIN_DELAY() PIN_DELAY_FAST()

uint8_t RST_Transfer(uint32_t request, uint32_t data)
{
  uint32_t ack;                                                                 \
  uint32_t bit;                                                                 \
  uint32_t val;                                                                 \
  uint32_t parity;                                                              \
  uint32_t n;                                                                   \
  \
  /* Packet Request */                                                          \
  parity = 0U;                                                                  \
  RST_WRITE_BIT(1U);                     /* Start Bit */                        \
  bit = request >> 0;                                                           \
  RST_WRITE_BIT(bit);                    /* APnDP Bit */                        \
  parity += bit;                                                                \
  bit = request >> 1;                                                           \
  RST_WRITE_BIT(bit);                    /* RnW Bit */                          \
  parity += bit;                                                                \
  bit = request >> 2;                                                           \
  RST_WRITE_BIT(bit);                    /* A2 Bit */                           \
  parity += bit;                                                                \
  bit = request >> 3;                                                           \
  RST_WRITE_BIT(bit);                    /* A3 Bit */                           \
  parity += bit;                                                                \
  RST_WRITE_BIT(parity);                 /* Parity Bit */                       \
  RST_WRITE_BIT(0U);                     /* Stop Bit */                         \
  RST_WRITE_BIT(1U);                     /* Park Bit */                         \
  \
  /* Turnaround */                                                              \
  PIN_SWDIO_OUT_DISABLE();                                                      \
  for (n = DAP_Data.swd_conf.turnaround; n; n--) {                              \
    RST_CLOCK_CYCLE();                                                          \
  }                                                                             \
  \
  /* Acknowledge response */                                                    \
  RST_READ_BIT(bit);                                                            \
  ack  = bit << 0;                                                              \
  RST_READ_BIT(bit);                                                            \
  ack |= bit << 1;                                                              \
  RST_READ_BIT(bit);                                                            \
  ack |= bit << 2;                                                              \
  \
  /* Data transfer */                                                           \
  /* Turnaround */                                                              \
  for (n = DAP_Data.swd_conf.turnaround; n; n--) {                              \
    RST_CLOCK_CYCLE();                                                          \
  }                                                                             \
                                                         \
  /* Write data */                                                              \
  val = data;                                                                   \
  parity = 0U;                                                                  \
  for (n = 32U; n; n--) {                                                       \
    RST_WRITE_BIT(val);              /* Write WDATA[0:31] */                    \
    parity += val;                                                              \
    val >>= 1;                                                                  \
  }                                                                             \
  RST_WRITE_BIT(parity);             /* Write Parity Bit */                     \
                                                         \
  PIN_SWDIO_OUT(1U);                                                            \
  return ((uint8_t)ack);                                                        \
}

void vResetTarget(uint8_t bit)
{
  uint32_t i;
  //soft-reset for Cortex-M
  RST_Transfer(0x00000CC5, 0xE000ED0C); //set AIRCR address
  for (i=0; i<100; i++);
  RST_Transfer(0x00000CDD, 0x05FA0007); //set RESET data
  for (i=0; i<100; i++);
  RST_Transfer(0x00000CC5, 0xE000ED0C); //repeat
  for (i=0; i<100; i++);
  RST_Transfer(0x00000CDD, 0x05FA0007);
  
  if (bit & 1)  PIN_nRESET_HIGH();
  else          PIN_nRESET_LOW();
}
/* 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 */

  /* USER CODE END Error_Handler_Debug */
}

SWD的部分移植完成了。

 

SPI配置：

SWD_SPI操作函数

u8 SPI1_ReadWriteByte(u8 TxData)
{		
	u16 retry=0;				 
	while((SPI1->SR&1<<1)==0)		//µÈ´ý·¢ËÍÇø¿Õ	
	{
		retry++;
		if(retry>=0XFFFE)return 0; 	//³¬Ê±Í˳ö
	}			  
	SPI1->DR=TxData;	 	  		//·¢ËÍÒ»¸öbyte 
	retry=0;
	while((SPI1->SR&1<<0)==0) 		//µÈ´ý½ÓÊÕÍêÒ»¸öbyte  
	{
		retry++;
		if(retry>=0XFFFE)return 0;	//³¬Ê±Í˳ö
	}	  						    
	return SPI1->DR;          		//·µ»ØÊÕµ½µÄÊý¾Ý				    
}



uint8_t SPI_TXRX(uint8_t *TXBuff,uint8_t *RXBuff,uint8_t cnt)
{
	uint8_t cnt_buff;
	
	for(cnt_buff=0;cnt_buff<cnt;cnt_buff++)
	{
		RXBuff[cnt_buff]=SPI1_ReadWriteByte(TXBuff[cnt_buff]);
	}
	return 1;
}

uint8_t SPI_TX(uint8_t *TXBuff,uint8_t cnt)
{
	uint8_t cnt_buff;
	for(cnt_buff=0;cnt_buff<cnt;cnt_buff++)
	{
		SPI1_ReadWriteByte(TXBuff[cnt_buff]);
	}
	return 1;
}

uint8_t SPI_TX7(uint8_t *TXBuff)
{
	SPI1_ReadWriteByte(TXBuff[0]);
	SPI1_ReadWriteByte(TXBuff[1]);
	SPI1_ReadWriteByte(TXBuff[2]);
	SPI1_ReadWriteByte(TXBuff[3]);
	SPI1_ReadWriteByte(TXBuff[4]);
	SPI1_ReadWriteByte(TXBuff[5]);
	SPI1_ReadWriteByte(TXBuff[6]);
	return 1;
}

uint8_t SPI_TX4(uint8_t *TXBuff)
{
	SPI1_ReadWriteByte(TXBuff[0]);
	SPI1_ReadWriteByte(TXBuff[1]);
	SPI1_ReadWriteByte(TXBuff[2]);
	SPI1_ReadWriteByte(TXBuff[3]);
	return 1;
}

uint8_t SPI_TX2(uint8_t *TXBuff)
{
	SPI1_ReadWriteByte(TXBuff[0]);
	SPI1_ReadWriteByte(TXBuff[1]);
	return 1;
}

SPI初始化和SPI/模拟IO切换

/**
  * @brief SPI1 Initialization Function
  * @param None
  * @retval None
  */

static void DeInit_SPI(void)
{
	SPI1->CR1	|=0<<6;
	RCC->APB2ENR	|=0<<12;
	RCC->APB2ENR	|=0;

	
	GPIOB->CRL	&=0xF0000FFF;
	GPIOB->CRL	|=0x03743000;
	
	GPIOB->BRR=GPIO_PIN_3;
	GPIOB->BSRR=GPIO_PIN_5;
}

static void SPI_ON(void)
{
	RCC->APB2ENR |=1<<12;
	RCC->APB2ENR |=1<<0;
	
	
	GPIOB->CRL	&=0xF0000FFF;//GPIO INIT
	GPIOB->CRL	|=0x03F4B000;//GPIO INIT
	
	SPI1->CR1	|=1<<6;//EN SPI
}

void SPI_Switch(uint8_t ONOFF)
{
	if(ONOFF==1) SPI_ON();
	else DeInit_SPI();
}

static void MX_SPI1_Init(void)
{
  /* USER CODE BEGIN SPI1_Init 0 */
	RCC->APB2ENR |=1<<12;//SPI CK EN
	RCC->APB2ENR |=1<<3;//GPIO CK EN

	GPIOB->CRL	&=0xF0000FFF;//GPIO INIT
	GPIOB->CRL	|=0x03F4B000;//GPIO INIT
	
	SPI1->CR1	|=0<<10;//DOUBULE
	SPI1->CR1	|=1<<9;
	SPI1->CR1	|=1<<8;
	SPI1->CR1	|=1<<7;//LSB
	SPI1->CR1	|=0<<11;//8BIT
	SPI1->CR1	|=1<<2;//HOST
	SPI1->CR1	|=0<<1;//CPOL LOW
	SPI1->CR1	|=0<<0;//CPHA 1EDGE
	SPI1->CR1	|=2<<3;//F/8
	
	SPI1->CR1	|=1<<6;//EN SPI
	
	
	/* USER CODE END SPI1_Init 0 */
}

到此移植基本上完成了，再解决一下编译的error就OK了

注意我的硬件是SPI中MISO和MOSI是接在一起的，所以MOSI引脚要设置为OD，MISO设置为input。切换成普通GPIO时也要这样配置。

airtech
关注
  • 9
    点赞
  • 踩
  • 63
    收藏
    觉得还不错? 一键收藏
  • 32
    评论
开源ST-LINKV2脱机烧录器-加上STD和USB库
02-02
标题中的“开源ST-LINKV2脱机烧录器-加上STD和USB库”指的是一个基于开源设计的ST-LINKV2编程器，它被优化以支持STM8S系列微控制器的离线烧录功能，并且整合了STD库和USB库。这个项目允许开发者在没有连接到计算机的...
SWD-脱机烧录器源码.7z
11-25
标题中的"SWD-脱机烧录器源码.7z"表明这是一个关于SWD（Serial Wire Debug）接口的脱机编程器的源代码压缩包。这个编程器主要用于STM32F1、F2、F3和F4系列的微控制器（MCU），并且根据描述，有可能通过后期扩展来...
SWD离线烧写器（完全开源）
热门推荐
Bronson's Blog
10-10 2万+
SWD离线烧写器 本项目使用STM32F103RBT6作为主控，基于ST官方CMSIS-DAP项目进行修改，实现可脱机、可去读保护烧写。 GitHub项目地址: OfflineSWD 外观 项目功能 1.使用8M FLASH，可使用虚拟U盘向FLASH放置HEX文件或BIN文件进行烧写（BIN较快） 2.可去除目标板的读保护，直接烧写（烧写后可能需要手动重启） 3.支持手动切换模式，使离线烧写器支持DAP仿真 4.安装驱动后可支持虚拟USB转TTL 5.可离线使用串口调试功能（仅支持英文及常用数字符
开源SWD脱机烧录器-第一章 软硬件配置及其初始化
sinat_26528193的专栏
07-08 2128
，
使用STLINK烧录STM32教程
最新发布
qq_44016222的博客
05-22 2400
STM32的下载方式有很多种，包括STLINK、DAP、JLINK、串口下载等等，STLINK由于其体积小、功能强、有极强的便利性，因此被用作STM32的常用烧录器，本教程教大家如何使用STLINK来给STM32单片机烧录程序。
调试备忘录-SWD协议解析
打工人的天堂
04-11 9634
SWD的全称应该是The Serial Wire Debug Port(SW-DP),也就是串行调试端口，是ARM目前支持的两种调试端口之一，另一个调试端口叫做JTAG Debug Port，也就是我们常用的J-link上面的调试端口（JTAG模式下）。 基于ARM CoreSight调试构架，SWD可以通过传输数据包来读写芯片的寄存器。
开源SWD脱机烧录器-第二章 SWD协议移植
sinat_26528193的专栏
07-08 2096
，，
开源SWD脱机烧录器-第三章 基于QT的上位机
u012918754的博客
11-04 4284
开源地址：https://gitee.com/airtech/offline_burner 基于Qt的上位机，有了上位机这个烧录器才算是完整。 主界面 镜像注释：会现在是OLED最上面一行的“名字” 例如下图这个成品显示"STM32F103RB-128K" 帮助信息： 使用说明 关于程序： 因为这个脱机烧录器是基于CMSIS-DAP的，为了做到支持所有芯片所以采用...
SWD脱机烧录器源码.rar
06-30
SWD脱机烧录器是一种独立于计算机的设备，能够通过SWD接口对嵌入式系统中的MCU进行程序烧录。这种烧录器的核心优势在于它不需要计算机的持续连接，提高了烧录效率并降低了调试过程中的依赖性。 本压缩包“SWD脱机...
SWD脱机烧录器源码.7z
11-04
这种脱机烧录器通常使用USB或串行通信与电脑连接，然后通过特定的协议将编译好的二进制代码传输到目标MCU。SWD接口使得这种过程更为简便且高效，因为它只需要两根线（数据线和时钟线）就能完成编程任务，而且速度...
SWD脱机烧录器及上位机源码.7z
12-31
开发者可以研究这些源码来理解如何实现SWD通信协议，如何设计用户友好的界面，以及如何实现脱机烧录器的控制逻辑。 最后，“脱机烧录器原理图.pdf”是硬件设计的重要组成部分。原理图展示了电路板上的各个元器件、...
自制脱机烧录器（一）
m0_57801302的博客
07-18 2242
自己想做一个脱机烧录器已经很久了，网上开源的脱机烧录器很多，但是大多数都比较复杂，奈何网上大神们都不出手，自己又想做一个简便的脱机烧录，所以就自己尝试了做了下，经过几天不懈的努力下做了一个简陋版的脱机下载器。提示：以下是本篇文章正文内容，下面案例可供参考通过Xmodem协议将大文件能够发送给我们的单片机，单片机通过双缓冲区，来接受发送的数据，最后单片机通过SPI写到W25Q32里面进行保存，这样就实现了文件的传输，下一章讲解SWD协议的移植。
开源SWD脱机烧录器-前言
sinat_26528193的专栏
07-08 1454
，
stm32自制离线烧录器--前序
weixin_45652444的博客
02-24 6837
文章目录前言一、硬件主控：stm32f103c8t6外部flash：w25q128(16M)液晶显示：待定二、原理1、主控 + 外部flash 实现U盘功能，把bin文件直接保存，很方便；2、主控 + 外部flash 实现fatfs文件操作，烧录就得调用保存号的bin文件；3、实现SWD协议，将固件烧录到MCU里；待更新。。。 前言 因工作需要，准备自制离线烧录器，用于生产批量烧录。目前支持烧录STM32F1\STM32F4，和灵动的MM32F0010。最基本的烧录功能已经实现，还需要时间整理和优化
自制脱机烧录器（二）
m0_57801302的博客
07-19 2094
IO口模拟的SWD时序，我参考的是这位大神的文章。基于CMSIS-DAP，实现通过DAP读写目标芯片的内存、内核寄存器，这部分功能已经由ARM公司的CMSIS-DAP代码实现。我把主要移植到STM32G070RB上，把标准库改成了HAL库。
swd脱机烧录器及上位机源码_打造廉价axidraw写字机（3D打印版）
weixin_39552768的博客
12-04 643
本文转载至DF创客社区原文链接：打造廉价axidraw写字机（3D打印版）-Arduino论坛-DF创客社区 -下载文件：固件，打印件都可以在原文下方找到网上看到一款叫做axidraw的写字机后欲罢不能啊，就是封面上的那张图，看了一下价格还是算了吧，于是利用3D打印机自制了一个axidraw，然后我在论坛里也看到一位大佬做了what？全CNC的铝支架（或者是铁）？？在下搞不到那个啊！！！来个3D打...
STM32 HAL SWD下载与串口通信
weixin_45657215的博客
03-31 1万+
STM32的SWD下载与串口通信
[STM32]开源多功能DAP 脱机烧录器 DAPLink仿真下载器
Kevincoooool
11-22 1万+
网上已经有很多开源脱机烧录器的了，XVIN1987的很小巧，很有参考价值，杰明的很庞大，源码较多较复杂，于是自己在无线DAP的基础上，添加了脱机烧录功能，usb部分用的TeenyUSB，有虚拟u盘，虚拟串口，有文件系统，正在重新绘制pcb，需要的人可以关注一下 可以选择下载算法和下载文件，在有线模式下， 连接电脑打开mdk选中CMSIS-DAP Debugger后有提示，可进行有线下载和仿真，同时电脑上还会有一个W25Q虚拟出来的U盘，直接将固件拖入U盘后进入脱机仿真模式下即可进行下载。 开源地址：htt
swd脱机烧录器及上位机源码
11-14
SWD脱机烧录器是一种用于单片机固件烧录的设备，通过SWD接口与单片机连接，可以在不连接电脑的情况下对单片机进行烧录。而上位机源码则是用于控制SWD脱机烧录器的软件源代码。 SWD脱机烧录器可通过上位机源码来实现烧录操作的控制和监控。上位机源码通常包括了操作界面的设计、烧录算法的实现、数据传输的处理等功能。用户可以通过上位机源码来自定义烧录器的功能，比如增加批量烧录、自动化测试等特性。 对于SWD脱机烧录器及上位机源码的开发和应用，需要具备一定的嵌入式系统开发和单片机编程知识。开发者可以通过研究SWD协议、单片机的存储器结构和编程技巧等来实现具有高效率和稳定性的烧录器及上位机源码。 同时，对于工程师和开发者来说，研究和掌握SWD脱机烧录器及上位机源码的原理和应用，可以帮助他们更好地进行单片机固件的开发和调试工作。这对于提高工程开发效率、保证产品质量和提升竞争力都具有重要的意义。因此，SWD脱机烧录器及上位机源码的学习和应用具有非常重要的价值。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值