def load(self):
if not isCmsisSvdAvailable:
return
if self.is_local:
self.device = SVDParser.for_xml_file(self.filename).get_device()
else:
self.device = SVDParser.for_packaged_svd(self.vendor, self.filename).get_device()
def get_parser(mcu, svd):
try:
if mcu:
return SVDParser.for_packaged_svd(mcu[0], "{}.svd".format(mcu[1]))
return SVDParser(ET.ElementTree(ET.fromstring(svd.read())))
except IOError:
print("No SVD file found")
sys.exit()
def load(self):
if not isCmsisSvdAvailable:
return
if self.is_local:
self.device = SVDParser.for_xml_file(self.filename).get_device()
else:
self.device = SVDParser.for_packaged_svd(self.vendor, self.filename).get_device()
def load(self):
if not IS_CMSIS_SVD_AVAILABLE:
return
if self.is_local:
self.device = SVDParser.for_xml_file(self.filename).get_device()
else:
self.device = SVDParser.for_packaged_svd(
self.vendor, self.filename).get_device()
def invoke(self, args, from_tty):
args = gdb.string_to_argv(args)
argc = len(args)
if argc == 1:
gdb.write("Loading SVD file {}...\n".format(args[0]))
parser = SVDParser.for_xml_file(svd_file)
elif argc == 2:
gdb.write("Loading SVD file {}/{}...\n".format(args[0], args[1]))
parser = SVDParser.for_packaged_svd(vendor, device)
self.dont_repeat()
def invoke(self, arg, from_tty):
args = gdb.string_to_argv(arg)
if len(args) >= 1:
if args[0] not in self.vendors:
raise gdb.GdbError("Invalid vendor name")
return
vendor_name = args[0]
vendor_filenames = self.vendors[vendor_name]
if len(args) == 1:
raise gdb.GdbError(
"Usage: svd_load <vendor-name> <filename.svd>")
elif len(args) >= 2:
filename = args[1]
try:
parser = SVDParser.for_packaged_svd(vendor_name, filename)
_svd_printer.set_device(parser.get_device())
except IOError:
raise gdb.GdbError("Failed to load SVD file")
else:
print("Loaded {}/{}".format(vendor_name, filename))
for peripheral in _svd_printer.device.peripherals:
print("%s @ 0x%08x" %
(peripheral.name, peripheral.base_address))
else:
raise gdb.GdbError("Usage: svd_load <vendor-name> <filename.svd>")
def monitor(self, arg):
if not self.svd_device:
try:
from cmsis_svd.parser import SVDParser
if os.path.isfile(SvdRegisters.FILE):
with open(SvdRegisters.FILE, 'r') as f:
lines = [l.strip() for l in f.readlines()]
parser = SVDParser.for_xml_file(lines[0])
self.svd_device = parser.get_device()
except:
raise Exception(
"Cannot open or parse SVD file. Check 'cmsis_svd' library installed"
)
if self.svd_device and arg:
args = arg.split()
name = args[0]
if name not in self.table:
r = self.find_register(name)
if r:
r.alias = args[1] if len(args) > 1 else "_"
with open(SvdRegisters.FILE, "a") as f:
f.write(str(r) + "\n")
else:
raise Exception("Register {} not found".format(name))
else:
raise Exception("Register {} already exists".format(name))
def data_from_svd(self, cmsis_svd_datapath, segment_size, vendor, chip):
if vendor == None:
self.vendors = os.listdir(cmsis_svd_datapath)
for v in self.vendors:
self.data_top_hash["vendors"][v] = {}
for f in glob.glob(os.path.join(cmsis_svd_datapath, v,
'*.svd')):
c = f.split(os.path.sep)[-1][:-4]
self.data_top_hash["vendors"][v][c] = {}
self.data_top_hash["vendors"][v][c]["file"] = f
self.data_top_hash["vendors"][v][c]["dirty"] = True
else:
self.vendors = [vendor]
self.data_top_hash["vendors"][vendor] = {}
if (chip):
self.data_top_hash["vendors"][vendor][chip] = {}
self.data_top_hash["vendors"][vendor][chip][
"file"] = os.path.join(cmsis_svd_datapath, vendor,
chip + '.svd')
self.data_top_hash["vendors"][vendor][chip]["dirty"] = True
else:
for f in glob.glob(
os.path.join(cmsis_svd_datapath, vendor, '*.svd')):
c = f.split(os.path.sep)[-1][:-4]
self.data_top_hash["vendors"][vendor][c] = {}
self.data_top_hash["vendors"][vendor][c]["file"] = f
self.data_top_hash["vendors"][vendor][c]["dirty"] = True
#print( self.data_top_hash)
for v in self.data_top_hash["vendors"].keys():
for c in sorted(self.data_top_hash["vendors"][v].keys()):
print(v, c)
self.parse_chip_svd(self.data_top_hash["vendors"][v][c],
SVDParser.for_packaged_svd(v, c + '.svd'))
def core_data_from_svd(self, core_svd_datapath, segment_size, core):
if core == None:
for f in sorted(glob.glob(os.path.join(core_svd_datapath,
'*.svd'))):
c = f.split(os.path.sep)[-1][:-4]
if (c.lower().find("cortex-") == 0):
c = c[7:]
if (c.lower().find("CM") == 0):
c = c[1:]
print(f, "\t", c)
self.data_top_hash["cores"][c] = {}
self.data_top_hash["cores"][c]["file"] = f
self.data_top_hash["cores"][c]["dirty"] = True
else:
f = os.path.join(core_svd_datapath, core) + ".svd"
if (core.lower().find("cortex-") > -1):
core = core[7:]
self.data_top_hash["cores"][core] = {}
self.data_top_hash["cores"][core]["file"] = f
self.data_top_hash["cores"][core]["dirty"] = True
for c in self.data_top_hash["cores"].keys():
#print("---------->",core_svd_datapath ,c + '.svd')
self.parse_chip_svd(
self.data_top_hash["cores"][c],
SVDParser.for_xml_file(self.data_top_hash["cores"][c]["file"]))
def parse_svd(svds_directory, family, cpu):
"""
Parse the SVD files (if available) and return the peripherals.
The data is returned from cache if available, to speedup the parsing
process.
"""
if not svds_directory:
return []
svd_file = os.path.join(svds_directory, family.upper(),
"%s.svd" % (cpu.upper()))
cache_key = hashlib.md5(svd_file.encode("ascii")).hexdigest()
cache_file = os.path.join("cache", cache_key)
if not os.path.isfile(svd_file):
return []
if not os.path.isfile(cache_file):
device = SVDParser.for_xml_file(svd_file).get_device()
with open(cache_file, "w") as fp:
json.dump(
[peripheral.to_dict() for peripheral in device.peripherals],
fp)
with open(cache_file, "r") as fp:
return json.load(fp)
def __init__(self, device_name):
pylink.JLink.__init__(
self,
lib=pylink.library.Library(dllpath=os.getcwd() + os.path.sep +
'JLinkARM.dll'))
if self.num_connected_emulators() == 0:
print('No emulator connected. Leaving...')
exit()
elif self.num_connected_emulators() == 1:
self.open()
else:
print('List of available emulators:')
print(self.connected_emulators())
print('Enter serial number of emulator which shall be connected:')
snum = input()
self.open(snum)
svd = SVDParser.for_mcu(device_name)
if svd is None:
print('SVD parser input parameters could not be determined')
exit()
# Store device rather than svd object, as parsing to device takes much time. So store this in ram.
self.svd_device = svd.get_device()
self.connect(device_name, verbose=True)
self.restart()
self.rtt_start()
def main(unused_argv):
del unused_argv
svd_path = os.path.abspath(FLAGS.svd_path)
if FLAGS.svd_yaml_patch:
patch_path = os.path.abspath(FLAGS.svd_yaml_patch)
with open(patch_path, "r") as f:
root = yaml.safe_load(f)
root["_path"] = patch_path
svd = ET.parse(svd_path)
svdtools.patch.yaml_includes(root)
svdtools.patch.process_device(svd, root)
_, svd_path = tempfile.mkstemp()
svd.write(svd_path)
parser = SVDParser.for_xml_file(svd_path)
peripheral = None
for p in parser.get_device().peripherals:
if p.name.lower() == FLAGS.peripheral.lower():
peripheral = p
break
formatter = Formatter(FLAGS.output_path)
Biffile(formatter).write_peripheral(peripheral)
formatter.finish()
if FLAGS.verify:
verify(FLAGS.output_path, peripheral)
def parse_cores(self, core_svd_datapath):
self.core_files = sorted(
glob.glob(os.path.join(core_svd_datapath, '*.svd')))
self.cores = {}
pp = pprint.PrettyPrinter(indent=4)
for c in self.core_files:
self.parse_core(c, SVDParser.for_xml_file(c))
def on_cmbSVD_currentIndexChanged(self, path):
if not os.path.exists(path): return
self.device = SVDParser.for_xml_file(path).get_device()
self.cmbPeriph.clear()
self.cmbPeriph.addItems(
sorted([periph.name for periph in self.device.peripherals]))
def verify_cmsis_output(self, filename):
filepath = 'test/sampleData/cmsis-svd/' + filename + '.svd'
print('Parsing ' + filepath)
parser = SVDParser.for_xml_file(filepath)
self.assertEqual(
filename,
parser.get_device().peripherals[0].name,
msg="{0} is not the provided name in the CMSIS SVD file")
def load_svd(self, vendor, file):
parser = SVDParser.for_packaged_svd(vendor, file)
for peripheral in parser.get_device().peripherals:
p_dict = peripheral.to_dict()
base_addr = p_dict['base_address']
size = int(p_dict['address_block']['size']) - 1 #hackhack
name = peripheral.name
self.add_memory_range(base_addr, size)
def get_parser(mcu, svd):
try:
if mcu:
return SVDParser.for_packaged_svd(mcu[0], "{}.svd".format(mcu[1]))
return SVDParser(ET.ElementTree(ET.fromstring(svd.read())))
except IOError:
print("No SVD file found")
sys.exit()
def main():
parser = SVDParser.for_packaged_svd('Nordic', 'nrf51.svd')
#dump_json(parser)
interrupts = get_peripheral_interrupts(parser)
dump_macros(interrupts,
open("src/chips/nrf51822/peripheral_interrupts.h", "w"))
peripherals = get_peripheral_registers(parser, ["GPIO"])
dump_registers(peripherals,
open("src/chips/nrf51822/peripheral_registers.rs", "w"))
def main():
parser = SVDParser.for_packaged_svd('STMicro', 'STM32F0xx.svd')
address2peripheral = {}
for peripheral in parser.get_device().peripherals:
address2peripheral[peripheral.base_address] = peripheral
for _, peripheral in sorted(address2peripheral.items()):
print(f'{peripheral.name: <16} @ 0x{peripheral.base_address:08x}')
svd_dict = parser.get_device().to_dict()
print(json.dumps(svd_dict, sort_keys=True, indent=4))
def LPC43xxTarget(device):
""" Factory function that creates a low-level LPC43xx target. """
from .. import find_greatfet_asset
svd_file = find_greatfet_asset('LPC43xx_43Sxx.svd')
svd = SVDParser.for_xml_file(svd_file)
return VirtualLPC43xxTarget.from_svd(svd.get_device(), device)
def invoke(self, arg, from_tty):
args = gdb.string_to_argv(arg)
if len(args) != 1:
raise gdb.GdbError("Usage: svd_load_file <filename.svd>")
path = args[0]
try:
parser = SVDParser.for_xml_file(path)
_svd_printer.set_device(parser.get_device())
except IOError:
raise gdb.GdbError("Failed to load SVD file")
else:
print("Loaded {}".format(path))
def main():
from jinja2 import Environment, FileSystemLoader
parser = SVDParser.for_packaged_svd('Nordic', 'nrf51.svd')
#dump_json(parser)
interrupts = get_peripheral_interrupts(parser)
dump_macros(interrupts,
open("src/chips/nrf51822/src/peripheral_interrupts.h", "w"))
peripherals = get_peripheral_registers(parser, ["GPIO"])
env = Environment(loader=FileSystemLoader('src/chips/nrf51822/src'))
template = env.get_template('peripheral_registers.rs.jinja')
template.stream(program=PROGRAM, peripherals=peripherals).dump(
'src/chips/nrf51822/src/peripheral_registers.rs')
def main():
from jinja2 import Environment, FileSystemLoader
parser = SVDParser.for_packaged_svd('Nordic', 'nrf51.svd')
#dump_json(parser)
interrupts = get_peripheral_interrupts(parser)
dump_macros(interrupts,
open("src/chips/nrf51822/peripheral_interrupts.h", "w"))
peripherals = get_peripheral_registers(parser, ["GPIO"])
env = Environment(loader=FileSystemLoader('src/chips/nrf51822'))
template = env.get_template('peripheral_registers.rs.jinja')
template.stream(program=PROGRAM, peripherals=peripherals).dump(
'src/chips/nrf51822/peripheral_registers.rs')
def parseFile(company, file):
print("Parsing %s,%s " % (company, file))
parser = SVDParser.for_packaged_svd(company, file + ".svd", 1)
extention = []
jsonPath = posixpath.join(posixpath.dirname(posixpath.abspath(__file__)),
"Extention", company, file + ".json")
#print(jsonPath)
device = parser.get_device()
if posixpath.isfile(jsonPath):
extFile = open(jsonPath, "r", encoding='utf-8')
extention = json.load(extFile)
subdir = Ft.formatCpuName(Ft.getKey(extention, ["device", "cpu", "name"]),
device)
chipDir = posixpath.join('..', '..', 'Lib', 'Chip')
subdir = posixpath.join(chipDir, subdir)
if not posixpath.exists(subdir):
os.makedirs(subdir)
subdir = posixpath.join(subdir, company)
if not posixpath.exists(subdir):
os.makedirs(subdir)
subdir = posixpath.join(subdir, file)
if not posixpath.exists(subdir):
os.makedirs(subdir)
chipText = "#pragma once \n"
chipText += "#include <cstdint>\n"
incDir = subdir[10:]
if Ft.getKey(extention, ["kvasir", "io"]):
parseIo(extention, device, subdir)
chipText += "#include <%s>\n" % (posixpath.join(incDir, "Io.hpp"))
for peripheral in device.peripherals:
if peripheral.name is not None:
chipText += "#include <%s>\n" % (posixpath.join(
incDir, peripheral.name + ".hpp"))
out = "#pragma once \n#include <Register/Utility.hpp>\n"
out += "namespace Kvasir {\n"
out += parsePeripheral(
peripheral, Ft.getKey(extention, ['.' + peripheral.name]))
out += "}\n"
outFile = open(posixpath.join(subdir, peripheral.name + ".hpp"),
'w',
encoding='utf-8')
outFile.write(out)
else:
print("error no name in %s" % (file))
outFile = open(posixpath.join(chipDir, file + ".hpp"),
'w',
encoding='utf-8')
outFile.write(chipText)
def main():
parser = SVDParser.for_packaged_svd(sys.argv[1], sys.argv[2] + '.svd')
device = parser.get_device()
zig_fmt = subprocess.Popen(('zig', 'fmt', '--stdin'),
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
encoding='utf8')
generator = MMIOFileGenerator(zig_fmt.stdin)
generator.generate_file(device)
zig_fmt.stdin.flush()
zig_fmt.stdin.close()
print(zig_fmt.stdout.read())
def main(mcu, mcu_peripheral=None):
"""Given a chip and peripheral, prints the registers.
"""
parser = SVDParser.for_packaged_svd(*MCU2VENDOR_FILE[mcu])
address2peripheral = {}
for peripheral in parser.get_device().peripherals:
address2peripheral[peripheral.base_address] = peripheral
for _, peripheral in sorted(address2peripheral.items()):
print(
f'{peripheral.name: <16} @ 0x{peripheral.base_address:08x} ({peripheral.address_block.size: >4})'
)
if mcu_peripheral:
for peripheral in parser.get_device().peripherals:
if peripheral.name == mcu_peripheral or mcu_peripheral == ALL:
show_peripheral(peripheral)
def main():
parser = argparse.ArgumentParser(description = 'Generate C++ project from CMSIS SVD XML file')
parser.add_argument('input', metavar='inputsvd', nargs=1, help='Input SVD file to generate BSP from')
parser.add_argument('project', metavar='project', nargs=1, help='Path to output project')
args = parser.parse_args()
if args.input:
file = args.input[0]
if args.project:
if os.path.exists(args.project[0]):
print("Path exists, exiting!")
exit(-1)
else:
os.mkdir(args.project[0])
os.mkdir(os.path.join(args.project[0], "inc"))
os.mkdir(os.path.join(args.project[0], "src"))
name = getProjName(args.project[0])
parser = SVDParser.for_xml_file(file)
dev = parser.get_device()
outfile = dev.name+".h"
f=open(os.path.join(args.project[0], "inc", outfile), "w+")
f.write("#pragma once\r\n")
f.write("#include <cstdint>\r\n")
f.write("#include <reg.h>\r\n")
f.write("\r\nnamespace %s {\r\n" % dev.name)
DeviceStartup(dev, args.project[0])
for peripheral in dev.peripherals:
p = PeripheralNamespace(peripheral)
p.dump(f)
f.write("};\r\n")
f.close()
shutil.copyfile("reg.h.template", os.path.join(os.path.join(args.project[0], "inc"),'reg.h'))
shutil.copyfile("load_target.sh.template", os.path.join(args.project[0],'load_target.sh'))
shutil.copyfile("target.cfg.template", os.path.join(args.project[0],'target.cfg'))
shutil.copyfile("linker.template", os.path.join(args.project[0],'linker.ld'))
subst_target('runme.gdb.template', os.path.join(args.project[0],'runme.gdb'), getProjName(args.project[0]))
subst_target('Makefile.template', os.path.join(args.project[0],'Makefile'), getProjName(args.project[0]))
targetMain = open(os.path.join(args.project[0],getProjName(args.project[0])+".cpp"), "w+")
targetMain.write("int main(void)\r\n{\r\n while(1);\r\n}\r\n");
targetMain.close()
def invoke(self, arg, from_tty):
args = gdb.string_to_argv(arg)
if len(args) != 1:
raise gdb.GdbError("Usage: svd_load_file <filename.svd>")
path = args[0]
try:
parser = SVDParser.for_xml_file(path)
_svd_printer.set_device(parser.get_device())
except IOError:
raise gdb.GdbError("Failed to load SVD file")
else:
print("Loaded {}".format(path))
for peripheral in _svd_printer.device.peripherals:
print("%s @ 0x%08x" %
(peripheral.name, peripheral.base_address))
def parseFile(company,file):
print("Parsing %s,%s " % (company,file))
parser = SVDParser.for_packaged_svd(company, file + ".svd",1,1)
extention = []
jsonPath = os.path.join(os.path.dirname(os.path.abspath(__file__)),"Extention",company,file+".json")
#print(jsonPath)
device = parser.get_device()
if os.path.isfile(jsonPath):
extFile = open(jsonPath,"r",encoding='utf-8')
extention = json.load(extFile)
subdir = Ft.formatCpuName(Ft.getKey(extention,["device","cpu","name"]),device)
chipDir = os.path.join('..','..','Lib','Chip')
subdir = os.path.join(chipDir, subdir)
if not os.path.exists(subdir):
os.makedirs(subdir)
subdir = os.path.join(subdir,company)
if not os.path.exists(subdir):
os.makedirs(subdir)
subdir = os.path.join(subdir,file)
if not os.path.exists(subdir):
os.makedirs(subdir)
chipText = "#pragma once \n"
incDir = subdir[10:]
if Ft.getKey(extention,["kvasir","io"]):
parseIo(extention,device,subdir)
chipText += "#include \"%s\"\n" % (os.path.join(incDir,"Io.hpp"))
for peripheral in device.peripherals:
if peripheral.name is not None:
chipText += "#include \"%s\"\n" % (os.path.join(incDir,peripheral.name+".hpp"))
out = "#pragma once \n#include \"Register/Utility.hpp\"\n"
out += "namespace Kvasir {\n"
out += parsePeripheral(peripheral,Ft.getKey(extention,['.'+peripheral.name]))
out += "}\n"
outFile = open(os.path.join(subdir,peripheral.name+".hpp"), 'w',encoding='utf-8')
outFile.write(out)
else:
print("error no name in %s" % (file))
outFile = open(os.path.join(chipDir,file + ".hpp"), 'w',encoding='utf-8')
outFile.write(chipText)
def __init__(self, path):
parser = [periph for periph in SVDParser.for_xml_file(path).get_device().peripherals]
# Read peripherals and their registers
self.device = []
for periph in parser:
self.device += [{"type": "periph",
"name": periph.name,
"description": periph.description,
"base_address": periph.base_address,
"group_name": periph.group_name,
"regs": periph.derived_from}] # regs value will be replaced with regs list
if (self.device[-1]["regs"] is not None):
self.device[-1]["regs"] = next(periph for periph in self.device if periph["name"] == self.device[-1]["regs"])["regs"].copy()
else:
self.device[-1]["regs"] = []
for reg in periph.registers:
self.device[-1]["regs"] += [{"type": "reg",
"name": reg.name,
"description": reg.description,
"address_offset": reg.address_offset,
"fields": []}]
for field in reg.fields:
self.device[-1]["regs"][-1]["fields"] += [{"type": "field",
"name": field.name,
"description": field.description,
"address_offset": reg.address_offset,
"lsb": field.bit_offset,
"msb": field.bit_offset + field.bit_width - 1,
"access": field.access,
"enums": None}]
if field.enumerated_values:
self.device[-1]["regs"][-1]["fields"][-1]["enums"] = []
for enum in field.enumerated_values:
self.device[-1]["regs"][-1]["fields"][-1]["enums"] += [{"name": enum.name,
"description": enum.description,
"value": enum.value}]
self.device = sorted(self.device, key=itemgetter('base_address'))
def invoke(self, arg, from_tty):
try:
argv = gdb.string_to_argv(arg)
if len(argv) != 1:
raise Exception("Invalide parameter")
pathfile = argv[0]
gdb.write("Svd Loading {} ".format(pathfile))
parser = SVDParser.for_xml_file(pathfile)
device = parser.get_device()
peripherals = dict((peripheral.name, peripheral)
for peripheral in device.peripherals)
GdbSvdGetCmd(device, peripherals)
GdbSvdSetCmd(device, peripherals)
GdbSvdInfoCmd(device, peripherals)
except Exception as inst:
gdb.write("\n{}\n".format(inst))
gdb.execute("help svd")
except IOError:
gdb.write("\nFailed to load SVD file\n")
else:
gdb.write("Done\n")
def test_packaged_xml(self):
parser = SVDParser.for_packaged_svd('Freescale', 'MK20D7.svd')
device = parser.get_device()
self.assertTrue(len(device.peripherals) > 0)
def load(self):
if self.is_local:
self.device = SVDParser.for_xml_file(self.filename).get_device()
else:
self.device = SVDParser.for_packaged_svd(self.vendor, self.filename).get_device()
#
# Copyright 2015 Paul Osborne <*****@*****.**>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
from cmsis_svd.parser import SVDParser
parser = SVDParser.for_packaged_svd('Freescale', 'MK20D7.xml')
for peripheral in parser.get_device().peripherals:
print("%s @ 0x%08x" % (peripheral.name, peripheral.base_address))
def load_svd_for_mcu(mcu):
vendor, filename = find_for_mcu(mcu)
if (vendor is None) or (filename is None):
return None
return SVDParser.for_packaged_svd(vendor, filename).get_device()
def setUpClass(cls):
svd = os.path.join(DATA_DIR, "Nordic", "nrf51.svd")
cls.parser = SVDParser.for_xml_file(svd)
cls.device = cls.parser.get_device()
# pip install -U cmsis-svd
# python3 nrf51.py >> nrf51.flags.r2
from cmsis_svd.parser import SVDParser
parser = SVDParser.for_packaged_svd('Nordic', 'nrf51.svd')
for peripheral in parser.get_device().peripherals:
print("f %s = 0x%08x" % (peripheral.name, peripheral.base_address))
for register in peripheral.registers:
print("f %s.%s = 0x%08x" %
(peripheral.name, register.name,
peripheral.base_address + register.address_offset))
def test_packaged_xml_for_mcu(self):
parser = SVDParser.for_mcu('STM32F103C8T6')
self.assertTrue(parser is not None)
device = parser.get_device()
self.assertTrue(len(device.peripherals) > 0)
print(comment_str(x))
def banner(x):
comment('==== {:=<55}'.format("%s " % x))
def caption(x):
print()
comment('---- {:-<55}'.format("%s " % x))
def comment(x):
print(comment_str(x))
# ------------------------------------
parser = SVDParser.for_packaged_svd('STMicro', svd_name)
device = parser.get_device()
print()
banner('%s PERIPHERALS' % device.name)
comment('')
comment('CTU Prague, FEL, Department of Measurement')
comment('')
comment('-' * 60)
comment('')
comment('Generated from "%s"' % svd_name)
comment('')
comment('SVD parsing library (c) Paul Osborne, 2015-2016')
comment(' https://github.com/posborne/cmsis-svd')
comment('ASM building script (c) Ondrej Hruska, 2016')
comment('')
import json
from cmsis_svd.parser import SVDParser
parser = SVDParser.for_packaged_svd('STMicro', 'STM32F042x.svd')
svd_dict = parser.get_device().to_dict()
print(json.dumps(svd_dict, sort_keys=True,
indent=4, separators=(',', ': ')))
def setUpClass(cls):
cls.svd_path = os.path.join(DATA_DIR, "Freescale", "MKL25Z4.svd")
cls.json_path = os.path.join(THIS_DIR, "MKL25Z4.json")
cls.parser = SVDParser.for_xml_file(cls.svd_path)
cls.device = cls.parser.get_device()
def verify_svd_validity():
parser = SVDParser.for_xml_file(svd_path)
device = parser.get_device()
assert device is not None
def setUp(self):
svd = os.path.join(DATA_DIR, "Freescale", "MKL25Z4.xml")
self.parser = SVDParser.for_xml_file(svd)
def setUpClass(cls):
cls.svd_path = os.path.join(DATA_DIR, "Freescale", "MKL25Z4.svd")
cls.json_path = os.path.join(THIS_DIR, "MKL25Z4.json")
cls.parser = SVDParser.for_xml_file(cls.svd_path)
cls.device = cls.parser.get_device()
