guangzong/stm32-data
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

switch chip files from yaml to json. remove OrderedDict.

Browse Source
This commit is contained in:
Dario Nieuwenhuis 2022-02-07 01:53:58 +01:00
parent 7b368b0035
commit 00fc25453d
4 changed files with 68 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
merge_regs.py
View File

@ -6,15 +6,17 @@ import re
import json import json
import sys import sys
import os import os
from collections import OrderedDict
from glob import glob from glob import glob
def item_key(a): def item_key(a):
return int(a["byte_offset"]) return int(a["byte_offset"])
def field_key(a): def field_key(a):
return int(a["bit_offset"]) return int(a["bit_offset"])
def merge_block(origin, new): def merge_block(origin, new):
for newval in new: for newval in new:
found = False found = False
@ -25,6 +27,7 @@ def merge_block(origin, new):
origin.append(newval) origin.append(newval)
origin.sort(key=item_key) origin.sort(key=item_key)
def merge_fields(origin, new): def merge_fields(origin, new):
for newval in new: for newval in new:
found = False found = False
@ -35,6 +38,7 @@ def merge_fields(origin, new):
origin.append(newval) origin.append(newval)
origin.sort(key=field_key) origin.sort(key=field_key)
def merge_dicts(origin, new): def merge_dicts(origin, new):
for k, v in new.items(): for k, v in new.items():
if k in origin: if k in origin:
@ -50,8 +54,9 @@ def merge_dicts(origin, new):
else: else:
origin[k] = v origin[k] = v
first=True
reg_map={} first = True
reg_map = {}
for regfile in sys.argv[1:]: for regfile in sys.argv[1:]:
print("Loading", regfile) print("Loading", regfile)
with open(regfile, 'r') as f: with open(regfile, 'r') as f:

99
stm32data/__main__.py
View File

@ -6,11 +6,9 @@ import xmltodict
import re import re
import json import json
import os import os
from collections import OrderedDict
from glob import glob from glob import glob
from stm32data import yaml, header, interrupts, memory from stm32data import yaml, header, interrupts, memory
from stm32data.yaml import DecimalInt, HexInt
from stm32data.util import * from stm32data.util import *
@ -345,12 +343,12 @@ def parse_documentations():
for file in files['Files']: for file in files['Files']:
file_id = file['id_file'] file_id = file['id_file']
if file_id not in all_mcu_files: if file_id not in all_mcu_files:
all_mcu_files[file_id] = OrderedDict({ all_mcu_files[file_id] = {
'name': file['name'], 'name': file['name'],
'title': file['title'], 'title': file['title'],
'url': file['URL'], 'url': file['URL'],
'type': file['type'], 'type': file['type'],
}) }
with open('sources/mcufinder/mcus.json', 'r', encoding='utf-8') as j: with open('sources/mcufinder/mcus.json', 'r', encoding='utf-8') as j:
mcus = json.load(j) mcus = json.load(j)
@ -383,13 +381,13 @@ def documents_for(chip_name):
if file := all_mcu_files.get(id): if file := all_mcu_files.get(id):
file = all_mcu_files[id] file = all_mcu_files[id]
order, doc_type = parse_document_type(file['type']) order, doc_type = parse_document_type(file['type'])
docs.append(OrderedDict({ docs.append({
'order': order, 'order': order,
'type': doc_type, 'type': doc_type,
'title': file['title'], 'title': file['title'],
'name': file['name'], 'name': file['name'],
'url': file['url'], 'url': file['url'],
})) })
docs.sort(key=lambda x: (x['order'], x['name'])) docs.sort(key=lambda x: (x['order'], x['name']))
for doc in docs: for doc in docs:
del doc['order'] del doc['order']
@ -554,10 +552,10 @@ def parse_chips():
'group_idx': group_idx, 'group_idx': group_idx,
'packages': [], 'packages': [],
} }
chips[chip_name]['packages'].append(OrderedDict({ chips[chip_name]['packages'].append({
'name': package_name, 'name': package_name,
'package': r['@Package'], 'package': r['@Package'],
})) })
# Some packages have some peripehrals removed because the package had to # Some packages have some peripehrals removed because the package had to
# remove GPIOs useful for that peripheral. So we merge all peripherals from all packages. # remove GPIOs useful for that peripheral. So we merge all peripherals from all packages.
@ -610,10 +608,10 @@ def parse_chips():
cores = [] cores = []
for core_xml in children(chip['xml'], 'Core'): for core_xml in children(chip['xml'], 'Core'):
core_name = corename(core_xml) core_name = corename(core_xml)
core = OrderedDict({ core = {
'name': core_name, 'name': core_name,
'peripherals': [], 'peripherals': [],
}) }
cores.append(core) cores.append(core)
if not core_name in h['interrupts'] or not core_name in h['defines']: if not core_name in h['interrupts'] or not core_name in h['defines']:
@ -668,7 +666,7 @@ def parse_chips():
# but we actually need to use it because of F1 line # but we actually need to use it because of F1 line
# which doesn't include non-remappable peripherals in GPIO xml # which doesn't include non-remappable peripherals in GPIO xml
# and some weird edge cases like STM32F030C6 (see merge_periph_pins_info) # and some weird edge cases like STM32F030C6 (see merge_periph_pins_info)
periph_pins = OrderedDict() periph_pins = {}
for pin_name, pin in chip['pins'].items(): for pin_name, pin in chip['pins'].items():
for signal in pin['Signal']: for signal in pin['Signal']:
signal = signal['@Name'] signal = signal['@Name']
@ -682,7 +680,10 @@ def parse_chips():
if signal.startswith(periph + '_'): if signal.startswith(periph + '_'):
signal = removeprefix(signal, periph + '_') signal = removeprefix(signal, periph + '_')
pins = periph_pins.setdefault(periph, []) pins = periph_pins.setdefault(periph, [])
pins.append(OrderedDict(pin=pin_name, signal=signal)) pins.append({
'pin': pin_name,
'signal': signal,
})
break break
for periph, pins in periph_pins.items(): for periph, pins in periph_pins.items():
pins = remove_duplicates(pins) pins = remove_duplicates(pins)
@ -695,10 +696,10 @@ def parse_chips():
if addr is None: if addr is None:
continue continue
p = OrderedDict({ p = {
'name': pname, 'name': pname,
'address': addr, 'address': addr,
}) }
if rcc_info := match_peri_clock(rcc_block, pname): if rcc_info := match_peri_clock(rcc_block, pname):
p['rcc'] = rcc_info p['rcc'] = rcc_info
@ -763,14 +764,14 @@ def parse_chips():
for chip_name in group['chip_names']: for chip_name in group['chip_names']:
chip = chips[chip_name] chip = chips[chip_name]
flash = OrderedDict({ flash = {
'bytes': DecimalInt(int(chip['flash']) * 1024), 'bytes': int(chip['flash']) * 1024,
'regions': {}, 'regions': {},
}) }
ram = OrderedDict({ ram = {
'bytes': DecimalInt(int(chip['ram']) * 1024), 'bytes': int(chip['ram']) * 1024,
'regions': {}, 'regions': {},
}) }
found = [] found = []
for each in memories_map['flash']: for each in memories_map['flash']:
@ -787,15 +788,15 @@ def parse_chips():
if key in found: if key in found:
continue continue
found.append(key) found.append(key)
flash['regions'][key] = OrderedDict({ flash['regions'][key] = {
'base': HexInt(h['defines']['all'][each + '_BASE']) 'base': h['defines']['all'][each + '_BASE']
}) }
if key == 'BANK_1' or key == 'BANK_2': if key == 'BANK_1' or key == 'BANK_2':
flash_size = memory.determine_flash_size(chip_name) flash_size = memory.determine_flash_size(chip_name)
if flash_size is not None: if flash_size is not None:
if flash_size > flash['bytes'].val: if flash_size > flash['bytes']:
flash_size = flash['bytes'].val flash_size = flash['bytes']
flash['regions'][key]['bytes'] = DecimalInt(flash_size) flash['regions'][key]['bytes'] = flash_size
found = [] found = []
for each in memories_map['ram']: for each in memories_map['ram']:
if each + '_BASE' in h['defines']['all']: if each + '_BASE' in h['defines']['all']:
@ -808,21 +809,19 @@ def parse_chips():
if key in found: if key in found:
continue continue
found.append(key) found.append(key)
ram['regions'][key] = OrderedDict({ ram['regions'][key] = {
'base': HexInt(h['defines']['all'][each + '_BASE']) 'base': h['defines']['all'][each + '_BASE']
}) }
if key == 'SRAM': if key == 'SRAM':
ram_size = memory.determine_ram_size(chip_name) ram_size = memory.determine_ram_size(chip_name)
if ram_size is not None: if ram_size is not None:
ram['regions'][key]['bytes'] = DecimalInt(ram_size) ram['regions'][key]['bytes'] = ram_size
docs = documents_for(chip_name) docs = documents_for(chip_name)
device_id = memory.determine_device_id(chip_name) device_id = memory.determine_device_id(chip_name)
if device_id is not None:
device_id = HexInt(device_id)
chip = OrderedDict({ chip = {
'name': chip_name, 'name': chip_name,
'family': group['family'], 'family': group['family'],
'line': group['line'], 'line': group['line'],
@ -833,10 +832,10 @@ def parse_chips():
'ram': ram, 'ram': ram,
'docs': docs, 'docs': docs,
'cores': cores, 'cores': cores,
}) }
with open('data/chips/' + chip_name + '.yaml', 'w') as f: with open('data/chips/' + chip_name + '.json', 'w') as f:
f.write(yaml.dump(chip, width=500)) json.dump(chip, f, indent=4)
SIGNAL_REMAP = { SIGNAL_REMAP = {
@ -930,10 +929,10 @@ def parse_gpio_af_f1(xml):
if peri_name not in peris: if peri_name not in peris:
peris[peri_name] = [] peris[peri_name] = []
peris[peri_name].append(OrderedDict({ peris[peri_name].append({
'pin': pin_name, 'pin': pin_name,
'signal': signal_name, 'signal': signal_name,
})) })
for pname, p in peris.items(): for pname, p in peris.items():
p = remove_duplicates(p) p = remove_duplicates(p)
@ -965,11 +964,11 @@ def parse_gpio_af_nonf1(xml):
if peri_name not in peris: if peri_name not in peris:
peris[peri_name] = [] peris[peri_name] = []
peris[peri_name].append(OrderedDict({ peris[peri_name].append({
'pin': pin_name, 'pin': pin_name,
'signal': signal_name, 'signal': signal_name,
'af': afn, 'af': afn,
})) })
for pname, p in peris.items(): for pname, p in peris.items():
p = remove_duplicates(p) p = remove_duplicates(p)
@ -1049,13 +1048,13 @@ def parse_dma():
low -= 1 low -= 1
high -= 1 high -= 1
for i in range(low, high + 1): for i in range(low, high + 1):
chip_dma['channels'].append(OrderedDict({ chip_dma['channels'].append({
'name': n + '_CH' + str(i), 'name': n + '_CH' + str(i),
'dma': n, 'dma': n,
'channel': i, 'channel': i,
'dmamux': dmamux, 'dmamux': dmamux,
'dmamux_channel': dmamux_channel, 'dmamux_channel': dmamux_channel,
})) })
dmamux_channel += 1 dmamux_channel += 1
else: else:
@ -1083,11 +1082,11 @@ def parse_dma():
channel_name = removeprefix(channel_name, "Stream") channel_name = removeprefix(channel_name, "Stream")
channel_names.append(channel_name) channel_names.append(channel_name)
chip_dma['channels'].append(OrderedDict({ chip_dma['channels'].append({
'name': dma_peri_name + '_CH' + channel_name, 'name': dma_peri_name + '_CH' + channel_name,
'dma': dma_peri_name, 'dma': dma_peri_name,
'channel': int(channel_name), 'channel': int(channel_name),
})) })
for target in channel['ModeLogicOperator']['Mode']: for target in channel['ModeLogicOperator']['Mode']:
target_name = target['@Name'] target_name = target['@Name']
original_target_name = target_name original_target_name = target_name
@ -1105,10 +1104,10 @@ def parse_dma():
for request in target_requests: for request in target_requests:
if ':' in request: if ':' in request:
request = request.split(':')[0] request = request.split(':')[0]
entry = OrderedDict({ entry = {
'signal': request, 'signal': request,
'channel': dma_peri_name + '_CH' + channel_name, 'channel': dma_peri_name + '_CH' + channel_name,
}) }
if original_target_name in requests: if original_target_name in requests:
entry['request'] = requests[original_target_name] entry['request'] = requests[original_target_name]
chip_dma['peripherals'].setdefault(target_peri_name, []).append(entry) chip_dma['peripherals'].setdefault(target_peri_name, []).append(entry)
@ -1145,17 +1144,17 @@ def parse_rcc_regs():
if field['name'].endswith('EN'): if field['name'].endswith('EN'):
peri = removesuffix(field['name'], 'EN') peri = removesuffix(field['name'], 'EN')
regs = { regs = {
'enable': OrderedDict({ 'enable': {
'register': reg, 'register': reg,
'field': field['name'], 'field': field['name'],
}) }
} }
if rstr := y[key.replace('ENR', 'RSTR')]: if rstr := y[key.replace('ENR', 'RSTR')]:
if field := next(filter(lambda f: f['name'] == f'{peri}RST', rstr['fields']), None): if field := next(filter(lambda f: f['name'] == f'{peri}RST', rstr['fields']), None):
regs['reset'] = OrderedDict({ regs['reset'] = {
'register': reg.replace('ENR', 'RSTR'), 'register': reg.replace('ENR', 'RSTR'),
'field': f'{peri}RST', 'field': f'{peri}RST',
}) }
family_clocks[peri] = { family_clocks[peri] = {
'clock': clock, 'clock': clock,
'registers': regs 'registers': regs

13
stm32data/memory.py
View File

@ -1,7 +1,6 @@
import sys import sys
import re import re
import xmltodict import xmltodict
from collections import OrderedDict
from glob import glob from glob import glob
from stm32data.util import * from stm32data.util import *
@ -72,22 +71,22 @@ def parse():
flash_size = int(configs[0]['Parameters']['@size'], 16) flash_size = int(configs[0]['Parameters']['@size'], 16)
#print( f'flash {addr} {size}') #print( f'flash {addr} {size}')
chunk = OrderedDict({ chunk = {
'device-id': int(device_id, 16), 'device-id': int(device_id, 16),
'names': names, 'names': names,
}) }
if ram_size is not None: if ram_size is not None:
chunk['ram'] = OrderedDict({ chunk['ram'] = {
'address': ram_addr, 'address': ram_addr,
'bytes': ram_size, 'bytes': ram_size,
}) }
if flash_size is not None: if flash_size is not None:
chunk['flash'] = OrderedDict({ chunk['flash'] = {
'address': flash_addr, 'address': flash_addr,
'bytes': flash_size, 'bytes': flash_size,
}) }
memories.append(chunk) memories.append(chunk)

49
stm32data/yaml.py
View File

@ -1,53 +1,14 @@
import yaml import yaml
from collections import OrderedDict
try: try:
from yaml import CSafeLoader as SafeLoader from yaml import CSafeLoader as SafeLoader
except ImportError: except ImportError:
from yaml import SafeLoader from yaml import SafeLoader
try:
class DecimalInt: from yaml import CDumper as Dumper
def __init__(self, val): except ImportError:
self.val = val from yaml import Dumper
def represent_decimalint(dumper, data):
return dumper.represent_int(data.val)
class HexInt:
def __init__(self, val):
self.val = val
def represent_hexint(dumper, data):
return dumper.represent_int(hex(data.val))
def represent_int(dumper, data):
if data > 0x10000:
return dumper.represent_int(hex(data))
else:
return dumper.represent_int(data)
def represent_ordereddict(dumper, data):
value = []
for item_key, item_value in data.items():
node_key = dumper.represent_data(item_key)
node_value = dumper.represent_data(item_value)
value.append((node_key, node_value))
return yaml.nodes.MappingNode(u'tag:yaml.org,2002:map', value)
yaml.add_representer(DecimalInt, represent_decimalint)
yaml.add_representer(HexInt, represent_hexint)
yaml.add_representer(int, represent_int)
yaml.add_representer(OrderedDict, represent_ordereddict)
def load(*args, **kwargs): def load(*args, **kwargs):
@ -55,4 +16,4 @@ def load(*args, **kwargs):
def dump(*args, **kwargs): def dump(*args, **kwargs):
return yaml.dump(*args, **kwargs) return yaml.dump(*args, Dumper=Dumper, sort_keys=False, **kwargs)