SVD文件转换工具

最新推荐文章于 2024-05-15 09:54:24 发布
最新推荐文章于 2024-05-15 09:54:24 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： D语言学习 单片机应用 文章标签： d语言 stm32 arm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sdv/article/details/113758875
版权

SVD文件转换工具

用途

转换现有svd文件到 mculib4d 的芯片声明工具

代码查阅

代码

module svd;

import std.stdio;

import std.file;

import std.xml;
import std.string;
import std.regex;

struct tys
{
	union{
		uint		i1;
		ushort[2]	s1;
		ubyte[4]	b1;
	}
}

int main()
{
	string svdfile = "STM32F401.svd";

	if(!isFile(svdfile)){
		return 0;
	}
	
    Etsvd(svdfile);
    return 0;
}

struct mcuinfo
{
    string name;
    string mversion;
    string description;
    string addressUnitBits;
    string width;
    string size;
    string resetValue;
    string resetMask;

    cpuinfo   cpu;
}

struct cpuinfo
{
    string name;
    string revision;
    string endian;
    string mpuPresent;
    string fpuPresent;
    string nvicPrioBits;
    string vendorSystickConfig;
}

struct peripheral
{
    string name;
    string desc;
    string group;
    string    address;
    addressBlock ablock;
    interrupt[] inp;
    register[]  regs;

    string ttext;
    string derivedFrom;
}


struct addressBlock
{
    string offs;
    string ssize;
    string usage;
}

struct interrupt
{
    string name;
    string description;
    string val;
}

struct register
{
    string name;
    string display;
    string description;
    string addressOffset;
    string msize;
    string access;
    string resetValue;
    field[] fields;
}

struct field
{
    string name;
    string description;
    string bitOffset;
    string bitWidth;
    string access;

}



void Etsvd(string fname)
{
    string s = cast(string) std.file.read(fname);
    //
    try{
        //check(s);
	}catch (CheckException e)
	{
        writefln(e.msg);

	}

    peripheral[] pres;
    mcuinfo info;
    
	DocumentParser svdxml = new DocumentParser(s);
    
    svdxml.onEndTag["name"]       = (in Element e) { info.name      = e.text(); };
	svdxml.onEndTag["version"]       = (in Element e) { info.mversion      = e.text(); };
	svdxml.onEndTag["description"]       = (in Element e) { info.description      = e.text(); };
	svdxml.onStartTag["cpu"] = (ElementParser cp){
		cpuinfo mcup;
		cp.onEndTag["name"]  = (in Element e) { mcup.name      = e.text(); };
		cp.onEndTag["revision"]  = (in Element e) { mcup.revision      = e.text(); };
		cp.onEndTag["endian"]  = (in Element e) { mcup.endian      = e.text(); };
		cp.onEndTag["mpuPresent"]  = (in Element e) { mcup.mpuPresent      = e.text(); };
		cp.onEndTag["fpuPresent"]  = (in Element e) { mcup.fpuPresent      = e.text(); };
		cp.onEndTag["nvicPrioBits"]  = (in Element e) { mcup.nvicPrioBits      = e.text(); };
		cp.onEndTag["vendorSystickConfig"]  = (in Element e) { mcup.vendorSystickConfig      = e.text(); };
		cp.parse();
		info.cpu = mcup;
	};
	svdxml.onEndTag["addressUnitBits"]       = (in Element e) { info.addressUnitBits      = e.text(); };
	svdxml.onEndTag["width"]       = (in Element e) { info.width      = e.text(); };
	svdxml.onEndTag["size"]       = (in Element e) { info.size      = e.text(); };
	svdxml.onEndTag["resetValue"]       = (in Element e) { 
		info.resetValue      = e.text(); 
	};
	svdxml.onEndTag["resetMask"]       = (in Element e) { info.resetMask      = e.text(); };

	svdxml.onStartTag["peripheral"] = (ElementParser xml)
	{
		peripheral pb;

		auto df = ("derivedFrom" in xml.tag.attr);
		if(df){
			pb.derivedFrom = *df;
		}

		xml.onEndTag["name"]       = (in Element e) { pb.name      = e.text(); };
		xml.onEndTag["description"]  = (in Element e) { pb.desc = e.text(); };
		xml.onEndTag["groupName"]        = (in Element e) { pb.group       = e.text(); };
		xml.onEndTag["baseAddress"]        = (in Element e) { pb.address       = e.text(); };

		//xml.onEndTag["addressBlock"]        = (in Element e) { 	pb.ttext       = e.text();	};
		xml.onStartTag["addressBlock"] = (ElementParser ap){
			addressBlock ab;
			ap.onEndTag["offset"] = (in Element e){ab.offs = e.text();};
			ap.onEndTag["size"] = (in Element e){ab.ssize = e.text();};
			ap.onEndTag["usage"] = (in Element e){ab.usage = e.text();};

			ap.parse();
			pb.ablock = ab;
		};
		xml.onStartTag["interrupt"] = (ElementParser p){
			interrupt ip;
			p.onEndTag["name"] = (in Element e){ip.name = e.text();};
			p.onEndTag["description"] = (in Element e){ip.description = e.text();};
			p.onEndTag["value"] = (in Element e){ip.val = e.text();};

			p.parse();
			pb.inp ~= ip;
		};

		xml.onStartTag["register"] = (ElementParser ep){
			register reg;
			ep.onEndTag["name"] = (in Element e){reg.name = e.text();};
			ep.onEndTag["displayName"] = (in Element e){reg.display = e.text();};
			ep.onEndTag["description"] = (in Element e){reg.description = e.text();};
			ep.onEndTag["addressOffset"] = (in Element e){reg.addressOffset = e.text();};
			ep.onEndTag["size"] = (in Element e){reg.msize = e.text();};
			ep.onEndTag["access"] = (in Element e){reg.access = e.text();};
			ep.onEndTag["resetValue"] = (in Element e){reg.resetValue = e.text();};

			ep.onStartTag["field"] = (ElementParser fp){
				field fid;
				fp.onEndTag["name"] = (in Element e){fid.name = e.text();};
				fp.onEndTag["description"] = (in Element e){fid.description = e.text();};
				fp.onEndTag["bitOffset"] = (in Element e){fid.bitOffset = e.text();};
				fp.onEndTag["bitWidth"] = (in Element e){fid.bitWidth = e.text();};
				fp.onEndTag["access"] = (in Element e){fid.access = e.text();};

				fp.parse();
				reg.fields ~= fid;
			};

			ep.parse();
			pb.regs ~= reg;
		};

		xml.parse();
		pres ~= pb;
	};

    svdxml.parse();
    //---
    peripheral scan4name(string n)
	{
        foreach(v;pres)
		{
            if(v.name == n) return v;
		}
		writefln("no found [%s]",n);
        return peripheral.init;
	}

    //--
	/// 模板统计

    foreach(ref v;pres)
	{
        if(v.derivedFrom.length > 0){
            auto vf = scan4name(v.derivedFrom);
            vf.name = v.name;
            vf.address = v.address;
			vf.derivedFrom = v.derivedFrom;
			vf.inp = v.inp;
            v = vf;
		}
	}

    //--
    
	//-- 模板

    //-- 组
    string code;
    
    
    //-- 组函数
	
    //-- 常量
	
    if(info.description){
        code ~= maker_description(info.description,0,90);
	}
    code ~= "struct Conf {\n";

	code ~= "\tenum string SVDName                  = `"~info.name~"`;\n";
	code ~= "\tenum string SVDVersion               = `"~info.mversion~"`;\n";
	code ~= "\tenum size_t SVDUnitBits              = "~info.addressUnitBits~";\n";
	code ~= "\tenum size_t SVDWidth                 = "~info.width~";\n";
	code ~= "\tenum size_t SVDSize                  = "~info.size~";\n";
	code ~= "\tenum size_t SVDresetValue            = "~info.resetValue~";\n";
	code ~= "\tenum size_t SVDresetMask             = "~info.resetMask~";\n";

	code ~= "\tenum string SVDCpuName               = `"~info.cpu.name~"`;\n";
	code ~= "\tenum string SVDCpuRevision           = `"~info.cpu.revision~"`;\n";
	code ~= "\tenum string SVDCpuEndian             = `"~info.cpu.endian~"`;\n";
	code ~= "\tenum bool SVDCpuMpuPresent           = "~info.cpu.mpuPresent~";\n";
	code ~= "\tenum bool SVDCpuFpuPresent           = "~info.cpu.fpuPresent~";\n";
	code ~= "\tenum size_t SVDCpuNvicPrioBits       = "~info.cpu.nvicPrioBits~";\n";
	code ~= "\tenum bool SVDCpuVendorSystickConfig  = "~info.cpu.vendorSystickConfig~";\n";

    code ~= "}\n";

	code ~= maker_group(pres);

	writeln(code);

}

void maker_group1(peripheral[] src)
{
	import std.algorithm;
	void maker_group_sin(string gname)
	{
	}
	//uint[string] groups;
	string[]	groups;
	uint[string]	tgroup;
	string code;

	bool pmcheck(string n)
	{
		foreach(v;groups)
		{
			if(v == n) return true;
		}
		return false;
	}

	peripheral[]	pmSumGroup(string n)
	{
		peripheral[] r;
		foreach(v;src){
			if(v.group == n) r ~= v;
		}
		return r;
	}

	uint pmCount(string n)
	{

		return pmSumGroup(n).length;
	}

	string pmMakeTname(string v1,string v2)
	{
		string r;
		auto msize = (v1.length <= v2.length) ?v1.length:v2.length;
		for(auto i = 0;i<msize;i++)
		{
			if(v1[i] is v2[i]){
				r ~=v1[i];
			}else{
				break;
			}
		}
		return r;
	}

	uint pmCountTP(peripheral[] g)
	{
		uint[string] count;
		auto tg = g.dup;

		while(tg.length){
			auto cv = tg[0];
			tg = tg[1..$];
			peripheral[] t;
			
			foreach(v;tg){
				
				if(cv.name.indexOf("GPIO") >= 0)
				{
					auto b1 = cv.regs is v.regs;
					auto b2 = v.regs == cv.regs;
					writeln(b1);
					writeln(b2);
					writeln(cv.name);
					writeln(v.name);
				}
				
				if(cv.regs is v.regs){
					count[pmMakeTname(v.name,cv.name)]++;
				}else{
					t ~= v;
				}
				
			}
			tg = t;
		}

		writeln(count);

		return 0;
	}

	peripheral[]	pmSumderivedFrom(string n)
	{
		peripheral[] r;
		foreach(v;src){
			if(v.derivedFrom == n) r ~= v;
		}
		return r;
	}
	//组
    foreach(v;src){
		if(!pmcheck(v.group)) groups ~= v.group;
	}
	// 模板组
	foreach(v;src)
	{
		if(v.derivedFrom.length > 0)
		{
			tgroup[v.derivedFrom]++;
		}
	}
	// 建立模板
	foreach(v,v2;tgroup){
		if(v){
			auto tp = pmSumderivedFrom(v);
			auto tname = "";

			foreach(k,vn;v)
			{
				foreach(tv;tp)
				{
					if(!(tv.name[k] == vn)){
						goto enddd;
					}
				}
				tname ~= vn;
			}
			enddd:
			if(tname.length==0){
				tname = v;
			}

			//writeln();
			code ~= "\n/****************************************************************************************\n";
			code ~= "*\t package template: "~ tname ~ "\n";
			code ~= "*/\n";
		}
		//if(!pmcheck(v.group)) groups ~= v.group;
	}

	/+


	foreach(k;groups)
	{
		//pmCountTP(pmSumGroup(k));
		//writefln("Key[%s],count[%s]",k,pmCount(k));
		code ~= "\n/****************************************************************************************\n";
		code ~= "*\t Group: "~ k ~ "\n";
        code ~= "*/\n";

	}
	+/
	//writeln(code);
	//writeln(maker_description("ccccaaa",8));
	writeln(maker_Peripheral(src[0]));
}
/*
	Group > Temp > Const
*/
string maker_group(peripheral[] src)
{
	peripheral[][string] tgroups;
	string code;
	foreach(v;src)
	{
		if(v.derivedFrom.length > 0)
		{
			tgroups[v.derivedFrom] ~= v;
		}
	}
	// 整理
	foreach(k,v;tgroups)
	{
		foreach(ref dv;src){
			if(dv.name == k){
				dv.derivedFrom = k;
				tgroups[k] ~= dv;
				break;
			}
		}
	}


	/*
	foreach(dv;src)
	{
	if(dv.name == v.derivedFrom ) 
	{
	tgroups[v.derivedFrom] ~= dv;
	break;
	}
	}
	*/
	
	//模板目标
	foreach(dfname,pv;tgroups)
	{
		auto tname="";
		//foreach()
		foreach(i,s;dfname)
		{
			foreach(tv;pv){
				if(!(tv.name[i] == s))
				{
					goto endddd;
				}
			}
			tname ~= s;
		}
		endddd:
		if(tname.length == 0){
			tname = dfname;
		}

		code ~= maker_desc1(0,90);
		//模板声明
		foreach(v;pv)
		{
			code ~= format("/// %s\n",ClearRN(v.desc));
			//code ~= format("alias %s = %sTemplate!(%s);\n",v.name,dfname,v.address);
			code ~= format("final abstract class %s : %sTemplate!(%s) {\n",v.name,dfname,v.address);

			// 中断
			if(v.inp ){
				code ~= maker_tab(4) ~ "///";
				foreach(iv;v.inp)
				{
					code ~= iv.name;
					code ~= ",";
				}
				code ~= "\n";
				code ~= maker_tab(4) ~ "enum interrupts=[";
				foreach(iv;v.inp)
				{
					code ~= iv.val;
					code ~= ",";
				}
				code ~= "];\n";
			}
			

			code ~= "}\n";

		}
		//模板建立
		auto tpv = pv[0];
		tpv.name = dfname;
		code ~= maker_Peripheral(tpv,true);
	}

	foreach(v;src)
	{
		if(v.derivedFrom) continue;
		code ~= maker_Peripheral(v,false);
	}

	return code;
}

string maker_Peripheral(in peripheral src,bool istemplate=false)
{
	string code;

	//code ~= "final abstract class SPI4 : Peripheral!(0x40013400,Conf) \n";
	if(istemplate){
		code ~= maker_description(ClearRN(src.name));
		code ~= format("private abstract class %sTemplate(size_t pBase) : Peripheral!(pBase,Conf) {\n",src.name);
	}else{
		code ~= maker_description(ClearRN(src.desc));
		code ~= format("final abstract class %s : Peripheral!(%s,Conf) {\n",src.name,src.address);
	}
	// 中断
	if(src.inp && !(istemplate)){
		code ~= maker_tab(4) ~ "///";
		foreach(iv;src.inp)
		{
			code ~= iv.name;
			code ~= ",";
		}
		code ~= "\n";
		code ~= maker_tab(4) ~ "enum interrupts=[";
		foreach(iv;src.inp)
		{
			code ~= iv.val;
			code ~= ",";
		}
		code ~= "];\n";
	}
	foreach(rv;src.regs){
		//code ~= maker_description(ClearRN(rv.description),4);
		code ~= maker_tab(4);
		code ~= format("/// %s\n",ClearRN(rv.description));
		code ~= maker_tab(4);
		code ~= format("final abstract class %s : Register!(%s,Access.%s){\n",rv.name,rv.addressOffset,checkAccess(rv.access));
		
		
		//bit
		foreach(fv;rv.fields)
		{
			//code ~= maker_description(ClearRN(fv.description),8);
			code ~= maker_tab(8);
			code ~= format("/// %s\n",ClearRN(fv.description));

			code ~= maker_tab(8);
			code ~= format("alias %s=Bits!(%s,%s,Access.%s);\n",fv.name,fv.bitOffset,fv.bitWidth,checkAccess(fv.access));
		}

		code ~= maker_tab(4);
		code ~= "}\n";
	}
	code ~= "}\n";
	


	return code;
}

enum tabwidth = 0xff;
string maker_tab(in uint start)
{
	string stab;

	for(auto i=(start / tabwidth);i>0;i--) stab ~= "\t";

	for(auto i=(start % tabwidth);i>0;i--) stab ~= " ";

	return stab;
}
string maker_desc1(in uint start,in uint end)
{
	string ret;
	ret ~= maker_tab(start);
	ret ~= "//";
	for(auto i=(end - start - 2);i>0;i--) ret ~= "-";

	ret ~= "\n";

	return ret;
}
string maker_description(string desc,in uint start = 0,in uint end=90)
{
	string ret;
	string stab;
	string ssp;

	stab = maker_tab(start);


	
	ssp ~= stab ~ "/";
	for(auto i=(end - start - 1);i>0;i--) ssp ~= "*";
	ssp ~= "\n";
	

	//
	ret ~= ssp;
	
	ret ~= stab;
	ret ~= "*\t" ~ desc;
	ret ~= "\n"~stab~"*/\n";

	return ret;
}

string ClearRN(string s)
{
	string r;
	foreach(string line; splitter(s, regex("[\r\n]+") )){
		r ~= line.stripLeft(" ");
	}
	return r;
}

string checkAccess(string s)
{  
	switch(s.toLower()){
		case "read-only": return "ro";
		case "read-write": return "rw";
		case "write-only": return "wo";
		default:break;
	}
	if(s.length) writefln("no:%s",s);
	return "rwa";
}
sdvcn
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
stm32 SVD文件合集
10-30
包含：STM32F756.svd STM32H723.svd STM32L476.svd STM32F0x0.svd STM32F7x2.svd STM32H725.svd STM32L496.svd STM32F0x1.svd STM32F7x3.svd STM32H73x.svd STM32L4P5.svd STM32F0x2.svd STM32F7x5.svd STM32H742x.svd STM32L4Q5.svd STM32F0x8.svd STM32F7x7.svd STM32H743.svd STM32L4R5.svd STM32F100.svd STM32F7x8.svd STM32H745_CM4.svd STM32L4R7.svd STM32F101.svd STM32F7x9.svd STM32H745_CM7.svd STM32L4R9.svd STM32F102.svd STM32G030.svd 等
修改.svd仿真文件
dew_gao的博客
01-19 3161
修改.svd仿真文件仿真寄存器描述svd文件dac监控问题修改 仿真寄存器描述svd文件 在用vs code做stm32f072开发时遇到了仿真文件与手册描述不一致问题，简单提供一下修改方法。 dac监控问题 stm32f072x.svd的dac描述沿用了f051的，只描述了一个dac外设。然而072具有两个dac，可以实现双路的dac输出。而仿真文件便于我们观察dac的工作状态，iar中我并没有找到相关的文件无法修改。 修改 <peripheral> <name>DAC
CMSIS-SVD 解析器：构建高效ARM平台开发的利器
最新发布
gitblog_00086的博客
05-15 418
CMSIS-SVD 解析器：构建高效ARM平台开发的利器 项目地址:https://gitcode.com/cmsis-svd/cmsis-svd 项目介绍 CMSIS-SVD解析器是一个开源项目，旨在为针对ARM平台的开发者提供便利。这个项目包含了多种语言的解析器，可以将系统视图描述（System View Description，简称SVD）文件转化为更易于使用的数据结构。通过这种方式，它简化...
svd2zig:将系统视图描述（svd）文件转换为Zig标头以进行裸机开发
05-16
svd2Zig 从文件生成头文件，以访问MMIO寄存器。 尚未完全支持整个规范。 需要并提示该存储库的头文件用于STM32F767ZG，该文件已完全转换为Zig。 随意发送拉取请求，以充实项目中缺少的规范部分。 输出被有意地格式化为通常的C样式，以便可以使用简单的文本完成功能来快速查找正确的寄存器值和字段。 这消除了对语言服务器协议扩展的需求，但以不遵循Zig样式指南为代价。 建造： zig build -Drelease-safe 用法： ./zig-cache/bin/svd2zig path/to/svd/file > path/to/output.zig zig fmt path/to/output.zig # to prettify 查找SVD文件的建议位置： 示例输出（通过zig fmt运行之后）： /// Access control pub cons
Clion配置STM32开发环境
weixin_46940469的博客
05-19 3146
Base就是直接在项目根目录下生成Inc和Src目录和.s文件，而Advanced是多了一个Core目录，将.s文件放在Startup目录里面，本质上没有区别。GDB服务器实参填 -f interface/cmsis-dap.cfg -f target/stm32f1x.cfg。STM32F103野火霸道V2开发板，野火daplite调试器，cmsis-dap。4、新建好项目后，双击项目根目录下的.ioc文件，配置STM32cubemx。目标和可执行的二进制文件均为项目的elf文件，调试器采用默认的即可。
TIH64 之一 编写 TIH64Vx690 的 SVD 文件及使用 SVD 辅助调试
技术干货
10-04 3458
TIH64Vx690 是方寸微电子研发的高安全、高可靠的 RISC-V 架构的微处理器系列芯片，重点面向网络安全领域，提供安全的单芯片解决方案。TIH64Vx690 提供了 Linux SDK 和 BareMetal SDK，使用芯来的 NucleiStudio 作为集成开发环境。在使用中发现，相比于 ARM 架构，RISC-V 架构的相关基础设施要差了不少，在代码调试时尤为明显！类比于 ARM，突然想到了 SVD 文件用于 RISC-V 是否可行
tixml2svd：一个小的python脚本，用于将TI targetdb（XML）文件解析为SVD文件，以便可以将其输入svd2rust工具
02-13
3. 应用svd2rust工具：将生成的SVD文件作为输入传递给svd2rust，该工具会生成Rust代码，这个代码可以被包含在项目中，提供对硬件的直接访问。 在实际应用中，tixml2svd可能需要根据不同的TI XML文件格式进行一些...
svd2rust：从SVD文件生成Rust寄存器映射（`struct`s）
02-05
`svd2rust`工具就是为了解决这个问题而诞生的，它能够将SVD文件转换成Rust编程语言中的结构体（`struct`s），使得在Rust中操作这些寄存器变得简洁且类型安全。 首先，我们需要理解SVD文件的内容。SVD文件包含了关于...
Question 5.rar_svd compression
09-24
在这个项目中，我们将深入探讨SVD在MATLAB中的应用，以及如何利用这种线性代数工具实现图像的高效压缩。 **奇异值分解（SVD）** SVD是一种强大的数学工具，广泛应用于数据分析、机器学习和图像处理等领域。对于一个...
1_SVD_pca_python_图像压缩_
10-02
综上所述，PCA和SVD是强大的工具，它们在图像压缩中扮演着重要角色。通过Python实现，我们可以直观地理解这两种方法的工作原理，并在实际项目中灵活运用。理解并掌握这些技术对于提升数据处理能力具有重要意义。
svd数字水印加密
08-08
SVD（奇异值分解，Singular Value Decomposition）作为线性代数中的一个重要工具，被广泛应用于图像处理和信号处理中，包括数字水印的实现。本文将详细介绍如何使用SVD进行数字水印加密，并探讨在彩色图像上的应用。...
RISC-V SVD 文件生成工具
10-03
RISC-V SVD 文件生成工具。详细说明见博文 RISC-V 之一 使用 ARM CMSIS 的 SVD 文件辅助调试 https://itexp.blog.csdn.net/article/details/127144450
奇异值分解(svd)的c++程序
03-14
此文件来源于世界著名的Numerical Recipes，用于奇异值分解的计算
SVD快速教程
07-31
特征值分解和奇异值分解在机器学习领域都是属于满地可见的方法。两者有着很紧密的关系，我在接下来会谈到，特征值分解和奇异值分解的目的都是一样，就是提取出一个矩阵最重要的特征。先谈谈特征值分解吧
SVD分解的由来、原理和应用简介
07-05
介绍SVD的由来、原理和应用，最后还有一个应用的实例
芯片svd文件生成
weixin_43673603的博客
02-14 976
【代码】芯片svd文件生成。
使用VSCODE搭建32位MCU开发环境
easy_Ye的博客
08-09 3175
使用VSCODE+ARM_GCC+ARMGDB开发32位MCU搭建环境
使用sdk-npi-enablement-tool生成SVD文件和芯片头文件
suyong_yq的专栏
01-19 2718
本文详细说明了如何使用灵动软件与系统工程组自主开发的`sdk-npi-enablement-tool`工具包，完成SVD文件局部更新的操作过程。
Vscode搭建开发调试STM32/RISC-V环境IDE(最全面)
热门推荐
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
06-02 1万+
单片机开发IDE环境如KeilMDK，虽然操作简单，容易上手，方便调试。但就是代码编辑和风格很老套，中文符号乱码还是常有的事，论代码编辑来说Keil就像老古董一样。而如今流行的vscode编辑器很不错，免费且相当轻量级，用来代码开发体验很好。Clion IDE要说更好，但是它不免费且体积较大，Stm32cubeIDE生成工程模板和配置方便，但自动补全还是太烂了，总之各有优劣吧。这里介绍下vscode搭建开发调试STM32的IDE，分享给有需要的朋友。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值