chore(radio): remove hardware definitions present in JSON (#6437)

Co-authored-by: philmoz <phil.a.mitchell@gmail.com>
This commit is contained in:
Raphael Coeffic
2026-03-14 20:36:37 +10:00
committed by GitHub
co-authored by philmoz
parent 2ca8e3e7b6
commit df981597c6
114 changed files with 20023 additions and 5277 deletions
+11 -36
View File
@@ -1,43 +1,18 @@
# Hardware Definitions
The Python scripts in this directory are responsible for 2 different tasks:
- generating a JSON definition file for each target,
- and generating different include files used to describe the hardware to the software.
The Python scripts in this directory are responsible for generating different
include files used to describe the hardware to the software.
While the exact format is still moving, the goal of this file is to replace the various
hardware definitions used in EdgeTx at various places and offer a simpler way to define
new targets.
## Data model
At the end of the process, the JSON definition will be the *master copy* used by:
- radio firmware,
- radio simlator,
- and Companion.
The data model supported is described `models.py`. A script
(`json_validator.py`) is available that validates the JSON files based on this
model.
## JSON Definition
## Code generator
Currently, the JSON definition file is still generated during the build process using
the target's `hal.h` and various Python scripts:
The various include files are generated based on Jinja2 templates and `generator.py`
provided with a JSON target definition.
- `generate_hw_def.py`: command line to generate JSON file as well as process
the JSON file into include files.
- `hal_json.py`: reads the `#define ...` definitions coming from `hal.h` into a dictionary (AVPs).
- `hal_adc.py`: parse ADC definitions and related analog inputs.
- `legacy_names.py`: hard-coded definitions providing additional information not present in `hal.h`
related to analog inputs (by target; mostly names and labels).
- `pot_config.py`: provides default configuration of pots and sliders for each target.
- `hal_keys.py`: parse keys & trims.
- `hal_switches.py`: parse switches.
- `switch_config.py`: default switch configuration (all targets) as well as display positions
(only `stdlcd` targets).
Once the format is stable enough and does not require editing each target separately
to add or rename each attribute, the JSON definition for each target will be generated
and added to version control. Then the Python scripts will obsoleted and removed. The
target's `hal.h` should be cleaned-up as well with the definitions present in JSON removed.
`legacy_names.py` contains some hard-coded definitions providing additional
information related to analog inputs (by target; mostly names and labels).
+36 -60
View File
@@ -1,101 +1,77 @@
import json
import jinja2
import legacy_names
import json_index
from models import KeyEnum
MAIN_CONTROL_LUT = {
# 2 Gimbal radios
"LH": { "str": "Rud", "local": "STR_STICK_NAMES0" },
"LV": { "str": "Ele", "local": "STR_STICK_NAMES1" },
"RV": { "str": "Thr", "local": "STR_STICK_NAMES2" },
"RH": { "str": "Ail", "local": "STR_STICK_NAMES3" },
"LH": {"str": "Rud", "local": "STR_STICK_NAMES0"},
"LV": {"str": "Ele", "local": "STR_STICK_NAMES1"},
"RV": {"str": "Thr", "local": "STR_STICK_NAMES2"},
"RH": {"str": "Ail", "local": "STR_STICK_NAMES3"},
# Surface radios
"ST": { "str": "ST", "local": "STR_SURFACE_NAMES0" },
"TH": { "str": "TH", "local": "STR_SURFACE_NAMES1" },
"ST": {"str": "ST", "local": "STR_SURFACE_NAMES0"},
"TH": {"str": "TH", "local": "STR_SURFACE_NAMES1"},
}
# MUST be the same order as 'EnumKeys'
KEYS_LUT = [
"KEY_MENU",
"KEY_EXIT",
"KEY_ENTER",
"KEY_PAGEUP",
"KEY_PAGEDN",
"KEY_UP",
"KEY_DOWN",
"KEY_LEFT",
"KEY_RIGHT",
"KEY_PLUS",
"KEY_MINUS",
"KEY_MODEL",
"KEY_TELE",
"KEY_SYS",
"KEY_SHIFT",
"KEY_BIND",
]
# def eprint(*args, **kwargs):
# from sys import stderr
# print(*args, file=stderr, **kwargs)
def is_ext_input(input):
if input.get('type') != 'FLEX':
def is_ext_input(input):
if input.get("type") != "FLEX":
return False
name = input.get('name')
if name and name.startswith('EXT'):
name = input.get("name")
if name and name.startswith("EXT"):
return True
return False
def generate_from_template(json_filename, template_filename, target):
with open(json_filename) as json_file:
with open(template_filename) as template_file:
root_obj = json.load(json_file)
adc_inputs = root_obj.get('adc_inputs')
adc_inputs = root_obj.get("adc_inputs")
adc_index = json_index.build_adc_index(adc_inputs)
adc_gpios = json_index.build_adc_gpio_port_index(adc_inputs)
switches = root_obj.get('switches')
switches = root_obj.get("switches")
switch_gpios = json_index.build_switch_gpio_port_index(switches)
keys = root_obj.get('keys')
keys = root_obj.get("keys")
key_gpios = json_index.build_key_gpio_port_index(keys)
trims = root_obj.get('trims')
trims = root_obj.get("trims")
trim_gpios = json_index.build_trim_gpio_port_index(trims)
legacy_inputs = legacy_names.inputs_by_target(target)
env = jinja2.Environment(
lstrip_blocks=True,
trim_blocks=True
)
env.tests['ext_input'] = is_ext_input
legacy_inputs = legacy_names.inputs_by_target(target)
env = jinja2.Environment(lstrip_blocks=True, trim_blocks=True)
env.tests["ext_input"] = is_ext_input
template_str = template_file.read()
template = env.from_string(template_str)
print(template.render(root_obj,
adc_index=adc_index,
adc_gpios=adc_gpios,
switch_gpios=switch_gpios,
key_gpios=key_gpios,
trim_gpios=trim_gpios,
legacy_inputs=legacy_inputs,
main_labels=MAIN_CONTROL_LUT,
key_index=KEYS_LUT))
key_index = list([str(i) for i in KeyEnum])
print(
template.render(
root_obj,
adc_index=adc_index,
adc_gpios=adc_gpios,
switch_gpios=switch_gpios,
key_gpios=key_gpios,
trim_gpios=trim_gpios,
legacy_inputs=legacy_inputs,
main_labels=MAIN_CONTROL_LUT,
key_index=key_index,
)
)
-291
View File
@@ -1,291 +0,0 @@
from pot_config import pot_cfg_by_target
MAX_POTS = 4
MAX_SLIDERS = 4
MAX_EXTS = 4
MAX_RAWS = 4
def eprint(*args, **kwargs):
from sys import stderr
print(*args, file=stderr, **kwargs)
class ADCInput:
TYPE_STICK = 'STICK'
TYPE_FLEX = 'FLEX'
TYPE_SWITCH = 'SWITCH'
TYPE_RAW = 'RAW'
# TYPE_BATT = 'BATT'
def __init__(self, name, adc_input_type, adc, gpio, pin, channel):
self.name = name
self.type = adc_input_type
self.adc = adc
self.gpio = gpio
self.pin = pin
self.channel = channel
class SPI_ADCInput:
def __init__(self, name, adc_input_type, channel):
self.name = name
self.type = adc_input_type
self.adc = 'SPI'
self.channel = channel
class ADC:
def __init__(self, name, adc):
self.name = name
self.adc = adc
class MouseName:
AXIS = ['x','y']
def format(self, idx):
axis = self.AXIS[idx - 1]
return f'JS{axis}'
def AZ_seq():
return [chr(i) for i in range(ord('A'), ord('Z') + 1)]
class ADCInputParser:
ADC_MAIN = 'MAIN'
ADC_EXT = 'EXT'
ADC_INPUTS = [
{
'range': ['LH','LV','RV','RH','ST','TH'],
'type': ADCInput.TYPE_STICK,
'suffix': 'STICK_{}',
'name': '{}',
},
{
'range': range(1, MAX_POTS + 1),
'type': ADCInput.TYPE_FLEX,
'suffix': 'POT{}',
'name': 'P{}',
},
{
'range': range(1, MAX_SLIDERS + 1),
'type': ADCInput.TYPE_FLEX,
'suffix': 'SLIDER{}',
'name': 'SL{}',
},
{
'range': range(1, MAX_EXTS + 1),
'type': ADCInput.TYPE_FLEX,
'suffix': 'EXT{}',
'name': 'EXT{}',
},
{
'range': range(1, MAX_RAWS + 1),
'type': ADCInput.TYPE_RAW,
'suffix': 'RAW{}',
'name': 'RAW{}',
},
{
'range': range(1, 2 + 1),
'type': ADCInput.TYPE_FLEX,
'suffix': 'MOUSE{}',
'name': MouseName(),
},
{
'type': 'VBAT',
'name': 'VBAT',
'suffix': 'BATT',
},
{
'type': 'RTC_BAT',
'name': 'RTC_BAT',
'suffix': 'RTC_BAT',
},
{
'type': 'LUX',
'name': 'LUX',
'suffix': 'LUX',
},
{
'range': AZ_seq(),
'type': ADCInput.TYPE_SWITCH,
'suffix': 'SW{}',
'name': 'SW{}',
},
]
def __init__(self, target, hw_defs, labels):
self.target = target
self.hw_defs = hw_defs
self.labels = labels
self.regs = self._parse_regs()
self.dirs = self._parse_dirs()
self.adcs = []
def _parse_regs(self):
regs = {}
for reg in AZ_seq():
reg = f'GPIO{reg}'
pins_def = f'ADC_{reg}_PINS'
if pins_def in self.hw_defs:
regs[reg] = self.hw_defs[pins_def]
return regs
def _parse_dirs(self):
ret = []
dirs = self.hw_defs.get('ADC_DIRECTION') or ''
if dirs:
dirs = dirs.strip('{} ').split(',')
# eprint(dirs)
for i in dirs:
ret.append(int(i))
return ret
def _find_adc(self, channel_def):
if (self.ext_list is None) or (channel_def not in self.ext_list):
return self.ADC_MAIN
else:
return self.ADC_EXT
def _find_gpio(self, pin):
gpio = None
for reg, pins_def in self.regs.items():
if pins_def and (pin in pins_def):
gpio = reg
return gpio
def _parse_adc(self, name, periph, prefix):
adc_periph = self.hw_defs.get(periph)
if not adc_periph:
return None
adc = ADC(name, adc_periph)
adc.dma = self.hw_defs.get(f'{prefix}_DMA')
if adc.dma:
adc.dma_channel = self.hw_defs[f'{prefix}_DMA_CHANNEL']
adc.dma_stream = self.hw_defs[f'{prefix}_DMA_STREAM']
adc.dma_stream_irq = self.hw_defs[f'{prefix}_DMA_STREAM_IRQ']
adc.dma_stream_irq_handler = self.hw_defs[f'{prefix}_DMA_STREAM_IRQHandler']
adc.sample_time = self.hw_defs[f'{prefix}_SAMPTIME']
return adc
def _parse_adcs(self):
adcs = []
adc_spi = self.hw_defs.get('ADC_SPI')
if adc_spi:
#eprint('## Found SPI ADC')
adc = ADC('SPI', adc_spi)
adc.gpio_pin_miso = self.hw_defs['ADC_SPI_GPIO_PIN_MISO']
adc.gpio_pin_mosi = self.hw_defs['ADC_SPI_GPIO_PIN_MOSI']
adc.gpio_pin_sck = self.hw_defs['ADC_SPI_GPIO_PIN_SCK']
adc.gpio_pin_cs = self.hw_defs['ADC_SPI_GPIO_PIN_CS']
adcs.append(adc)
adc_main = self._parse_adc('MAIN', 'ADC_MAIN', 'ADC')
if adc_main:
adcs.append(adc_main)
self.ext_list = None
adc_ext = self._parse_adc('EXT', 'ADC_EXT', 'ADC_EXT')
if adc_ext:
self.ext_list = self.hw_defs['ADC_EXT_CHANNELS']
adcs.append(adc_ext)
return adcs
def _parse_input_type(self, input_type, name, suffix):
gpio = None
pin = None
d = 1 # non-inverted
# search for SPI input first
spi_def = f'ADC_SPI_{suffix}'
if spi_def in self.hw_defs:
#eprint('## Found SPI ADC Input:', spi_def)
channel = self.hw_defs[spi_def]
return SPI_ADCInput(name, input_type, channel)
if name != 'RTC_BAT':
pin_def = f'ADC_GPIO_PIN_{suffix}'
pin = self.hw_defs[pin_def]
gpio = self._find_gpio(pin_def)
# check if 'pin' is maybe an alias
alias = self.hw_defs.get(pin)
if alias is not None:
alias_gpio = self._find_gpio(pin)
gpio = alias_gpio if alias_gpio else gpio
pin = alias
channel_def = f'ADC_CHANNEL_{suffix}'
channel = self.hw_defs[channel_def]
adc = self._find_adc(channel_def)
return ADCInput(name, input_type, adc, gpio, pin, channel)
def _add_input(self, adc_input):
if adc_input is not None:
idx = len(self.inputs)
if adc_input.type == 'STICK':
if 'PWM_STICKS' in self.hw_defs:
ch = self.hw_defs.get(f'STICK_PWM_CHANNEL_{adc_input.name}')
adc_input.pwm_channel = idx if ch is None else ch
if adc_input.type != 'VBAT' and adc_input.type != 'RTC_BAT' and adc_input.type != 'LUX':
d = self.dirs[idx]
if d < 0:
adc_input.inverted = True
if adc_input.type == 'FLEX':
input_labels = self.labels[adc_input.name]
adc_input.label = input_labels.get('label')
adc_input.short_label = input_labels.get('short_label')
cfg = pot_cfg_by_target(self.target,adc_input.name)
if cfg:
adc_input.default = cfg.get('default')
self.inputs.append(adc_input)
def parse_inputs(self):
self.adcs = self._parse_adcs()
self.inputs = []
for adc_input in self.ADC_INPUTS:
input_type = adc_input['type']
input_range = adc_input.get('range')
if input_range is not None:
for i in input_range:
name = adc_input['name'].format(i)
suffix = adc_input['suffix'].format(i)
try:
self._add_input(self._parse_input_type(input_type, name, suffix))
except KeyError:
pass
else:
# type, name, suffix
name = adc_input['name']
suffix = adc_input['suffix']
try:
self._add_input(self._parse_input_type(input_type, name, suffix))
except KeyError:
pass
return { 'adcs': self.adcs, 'inputs': self.inputs }
def find_input(self, name):
for adc_input in self.inputs:
if adc_input.name == name:
return adc_input
return None
+40 -73
View File
@@ -1,47 +1,38 @@
import re
import sys
import json
from hal_switches import Switch, parse_switches
from hal_adc import ADCInput, SPI_ADCInput, ADC, ADCInputParser
from hal_keys import Key, Trim, parse_trims, parse_keys
from hal_lcd import Display, parse_lcd
from hal_cfs import CFS, parse_cfs
from hal_misc import Misc, parse_misc
import legacy_names
#
# Return a file handle or STDIN
#
def open_file(filename):
if filename and not filename == '-':
if filename and not filename == "-":
return open(filename)
else:
return sys.stdin
#
# Read lines of defines into a dictionary
#
def parse_hw_defs(filename):
hw_defs = {}
with open_file(filename) as file:
for line in file.readlines():
m = re.match(r'#define ([^\s]*)\s*(.*)', line.rstrip())
name = m.group(1)
value = m.group(2)
if value.isnumeric():
value = int(value)
elif not value:
value = None
hw_defs[name] = value
m = re.match(r"#define ([^\s]*)\s*(.*)", line.rstrip())
if m:
name = m.group(1)
value = m.group(2)
if value.isnumeric():
value = int(value)
elif not value:
value = None
hw_defs[name] = value
return hw_defs
def prune_dict(d):
# ret = {}
# for k, v in d.items():
@@ -50,62 +41,38 @@ def prune_dict(d):
# return ret
return d
class DictEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, Switch):
return prune_dict(obj.__dict__)
if isinstance(obj, ADCInput):
return prune_dict(obj.__dict__)
if isinstance(obj, SPI_ADCInput):
return prune_dict(obj.__dict__)
if isinstance(obj, ADC):
return prune_dict(obj.__dict__)
if isinstance(obj, Trim):
return prune_dict(obj.__dict__)
if isinstance(obj, Key):
return prune_dict(obj.__dict__)
if isinstance(obj, Display):
return prune_dict(obj.__dict__)
if isinstance(obj, CFS):
return prune_dict(obj.__dict__)
if isinstance(obj, Misc):
return prune_dict(obj.__dict__)
# class DictEncoder(json.JSONEncoder):
# def default(self, o):
# if isinstance(o, Switch):
# return prune_dict(o.__dict__)
# if isinstance(o, ADCInput):
# return prune_dict(o.__dict__)
# if isinstance(o, SPI_ADCInput):
# return prune_dict(o.__dict__)
# if isinstance(o, ADC):
# return prune_dict(o.__dict__)
# if isinstance(o, Trim):
# return prune_dict(o.__dict__)
# if isinstance(o, Key):
# return prune_dict(o.__dict__)
# if isinstance(o, Display):
# return prune_dict(o.__dict__)
# if isinstance(o, CFS):
# return prune_dict(o.__dict__)
# if isinstance(o, Misc):
# return prune_dict(o.__dict__)
# # Let the base class default method raise the TypeError
# return json.JSONEncoder.default(self, o)
# Let the base class default method raise the TypeError
return json.JSONEncoder.default(self, obj)
#
# Parse HAL defines into JSON
#
def parse_defines(filename, target):
hw_defs = parse_hw_defs(filename)
out_defs = {}
# parse ADC first, we might have switches using ADC
legacy_inputs = legacy_names.inputs_by_target(target)
adc_parser = ADCInputParser(target,hw_defs,legacy_inputs)
adc_inputs = adc_parser.parse_inputs()
out_defs["adc_inputs"] = adc_inputs
switches = parse_switches(target, hw_defs, adc_parser)
out_defs["switches"] = switches
keys = parse_keys(target, hw_defs)
out_defs["keys"] = keys
trims = parse_trims(hw_defs)
out_defs["trims"] = trims
display = parse_lcd(hw_defs)
out_defs["display"] = display
cfs = parse_cfs(hw_defs)
out_defs["custom_switches"] = cfs
misc = parse_misc(hw_defs)
out_defs["hardware"] = misc
print(json.dumps(out_defs, cls=DictEncoder, indent=2))
# hw_defs = LoggingDict(parse_hw_defs(filename))
# out_defs = {}
#
# print(json.dumps(out_defs, cls=DictEncoder, indent=2))
pass
-226
View File
@@ -1,226 +0,0 @@
# Trims:
# TRIMS_GPIO_REG_[trim]
# TRIMS_GPIO_PIN_[trim]
#
# where 'trim' is one of:
#
# (-) (+)
# 'LHL', 'LHR',
# 'LVD', 'LVU',
# 'RVD', 'RVU',
# 'RHL', 'RHR',
# 'LSD', 'LSU', T4
# 'RSD', 'RSU', T5
TRIMS = [
# Air
{ "name": "T1", "dec": "LHL", "inc": "LHR", "input": "LH" },
{ "name": "T2", "dec": "LVD", "inc": "LVU", "input": "LV" },
{ "name": "T3", "dec": "RVD", "inc": "RVU", "input": "RV" },
{ "name": "T4", "dec": "RHL", "inc": "RHR", "input": "RH" },
{ "name": "T5", "dec": "LSD", "inc": "LSU" },
{ "name": "T6", "dec": "RSD", "inc": "RSU" },
{ "name": "T7", "dec": "T7L", "inc": "T7R" },
{ "name": "T8", "dec": "T8D", "inc": "T8U" },
# Surface
{ "name": "T1", "dec": "T1L", "inc": "T1R", "input": "ST" },
{ "name": "T2", "dec": "T2L", "inc": "T2R", "input": "TH" },
{ "name": "T3", "dec": "T3L", "inc": "T3R"},
{ "name": "T4", "dec": "T4L", "inc": "T4R"},
{ "name": "T5", "dec": "T5L", "inc": "T5R" },
{ "name": "T6", "dec": "T6D", "inc": "T6U" },
]
KEYS = [
{ "name": "MENU", "key": "KEY_MENU", "label": "MENU" },
{ "name": "EXIT", "key": "KEY_EXIT", "label": "EXIT" },
{ "name": "ENTER", "key": "KEY_ENTER", "label": "Enter" },
{ "name": "PAGEUP", "key": "KEY_PAGEUP", "label": "PAGE<" },
{ "name": "PAGEDN", "key": "KEY_PAGEDN", "label": "PAGE>" },
{ "name": "UP", "key": "KEY_UP", "label": "Up" },
{ "name": "DOWN", "key": "KEY_DOWN", "label": "Down" },
{ "name": "LEFT", "key": "KEY_LEFT", "label": "Left" },
{ "name": "RIGHT", "key": "KEY_RIGHT", "label": "Right" },
{ "name": "PLUS", "key": "KEY_PLUS", "label": "(+)" },
{ "name": "MINUS", "key": "KEY_MINUS", "label": "(-)" },
{ "name": "MDL", "key": "KEY_MODEL", "label": "MDL" },
{ "name": "TELE", "key": "KEY_TELE", "label": "TELE" },
{ "name": "SYS", "key": "KEY_SYS", "label": "SYS" },
{ "name": "SHIFT", "key": "KEY_SHIFT", "label": "Shift" }
]
KEY_LABELS = [
{
"targets": {"boxer", "f16", "mt12", "gx12", "pocket", "tx12", "tx12mk2", "tx16s", "tx16smk3","v16", "zorro"},
"keys": {
"EXIT": { "label": "RTN" }
}
},
{
"targets": {"bumblebee", "t12max", "t14", "t15", "t20", "t20v2", "tpro", "tpros", "tprov2"},
"keys": {
"PAGEDN": { "label": "</>" },
}
},
{
"targets": {"x7", "x7access", "x9e"},
"keys": {
"PAGEDN": { "label": "PAGE" },
}
},
{
"targets": {"t16", "t18"},
"keys": {
"EXIT": { "label": "RTN" },
"PAGEDN": {"label": "PAGE" }
}
},
{
"targets": {"x9d", "x9d+", "x9d+2019"},
"keys": {
"ENTER": { "label": "ENT" },
"PAGEDN": { "label": "PAGE" }
}
},
{
"targets": {"x10", "x10express"},
"keys": {
"EXIT": { "label": "RTN" },
"PAGEDN": { "label": "PgUp/Dn" }
}
},
{
"targets": {"x12s"},
"keys": {
"EXIT": { "label": "RTN" },
"PAGEUP": { "label": "PgUp" },
"PAGEDN": { "label": "PgDn" }
}
},
{
"targets": {"t8"},
"keys": {
"EXIT": { "label": "RTN" },
"ENTER": { "label": "ENT" }
}
},
{
"targets": {"tlite"},
"keys": {
"EXIT": { "label": "RTN" },
"ENTER": { "label": "ENT" },
"LEFT": { "label": "Left/SYS" },
"RIGHT": { "label": "Right/MDL" }
}
},
{
"targets": {"commando8"},
"keys": {
"EXIT": { "label": "BCK" },
"PAGEUP": { "label": "Left" },
"PAGEDN": { "label": "Right" },
"PLUS": { "label": "Up" },
"MINUS": { "label": "Down" },
"MENU": { "label": "Menu" }
}
},
{
"targets": {"st16"},
"keys": {
"PAGEDN": { "label": "MENU" }
}
},
]
class Key:
def __init__(self, gpio, pin):
self.gpio = gpio
self.pin = pin
self.active_low = True
class Trim:
def __init__(self, name, dec, inc):
self.name = name
if dec and dec.gpio and inc and inc.gpio:
self.dec = dec
self.inc = inc
self.active_low = True
def get_trim_switch(hw_defs, tag):
gpio = f'TRIMS_GPIO_REG_{tag}'
pin = f'TRIMS_GPIO_PIN_{tag}'
if (gpio in hw_defs) and (pin in hw_defs):
key = Key(hw_defs[gpio], hw_defs[pin])
if 'TRIMS_GPIO_ACTIVE_HIGH' in hw_defs:
key.active_low = False
return key
return None
def parse_trims(hw_defs):
trims = []
for t in TRIMS:
name = t['name']
dec = get_trim_switch(hw_defs, t['dec'])
inc = get_trim_switch(hw_defs, t['inc'])
if dec and inc:
trims.append(Trim(name, dec, inc))
elif t.get('input'):
input = t['input']
if f'TRIMS_VIRTUAL_{input}' in hw_defs:
trims.append(Trim(name, None, None))
return trims
def key_label(target, name):
for d in KEY_LABELS:
if target in d['targets']:
keys = d.get('keys')
key = keys.get(name)
if key:
return key['label']
return None
def parse_keys(target, hw_defs):
keys = []
for k in KEYS:
name = k['name']
gpio = f'KEYS_GPIO_REG_{name}'
pin = f'KEYS_GPIO_PIN_{name}'
if (gpio in hw_defs) and (pin in hw_defs):
key = Key(hw_defs[gpio], hw_defs[pin])
key.key = k['key']
key.name = name
label = key_label(target, name)
if label:
key.label = label
else:
key.label = k['label']
if 'KEYS_GPIO_ACTIVE_HIGH' in hw_defs:
key.active_low = False
keys.append(key)
return keys
-140
View File
@@ -1,140 +0,0 @@
from switch_config import switch_cfg_by_target
class Switch:
TYPE_2POS = "2POS"
TYPE_3POS = "3POS"
TYPE_ADC = "ADC"
def __init__(self, name, sw_type, flags):
self.name = name
self.type = sw_type
self.flags = flags
self.inverted = False
self.default = None
self.display = None
class Switch2POS(Switch):
def __init__(self, name, gpio, pin, flags=0):
super(Switch2POS, self).__init__(name, Switch.TYPE_2POS, flags)
self.gpio = gpio
self.pin = pin
class Switch3POS(Switch):
def __init__(self, name, gpio_high, pin_high, gpio_low, pin_low, flags=0):
super(Switch3POS, self).__init__(name, Switch.TYPE_3POS, flags)
self.gpio_high = gpio_high
self.pin_high = pin_high
self.gpio_low = gpio_low
self.pin_low = pin_low
class SwitchADC(Switch):
def __init__(self, name, adc_input, flags=0):
super(SwitchADC, self).__init__(name, Switch.TYPE_ADC, flags)
self.adc_input = adc_input
class SwitchCustom(Switch):
def __init__(self, name, type, flags=0):
super(SwitchCustom, self).__init__(name, type, flags)
def AZ_seq():
return [chr(i) for i in range(ord("A"), ord("Z") + 1)]
def eprint(*args, **kwargs):
from sys import stderr
print(*args, file=stderr, **kwargs)
def prefixsearch(dictionary, prefix):
for k in dictionary.keys():
if k.startswith(prefix):
return k[len(prefix) :]
return None
# switches from A to Z
def parse_switches(target, hw_defs, adc_parser):
switches = []
def find_switch(name):
for sw in switches:
if name == sw.name:
return sw
return None
for s in AZ_seq():
name = f"S{s}"
reg = f"SWITCHES_GPIO_REG_{s}"
reg_high = f"{reg}_H"
reg_low = f"{reg}_L"
pin = f"SWITCHES_GPIO_PIN_{s}"
pin_high = f"{pin}_H"
pin_low = f"{pin}_L"
inverted = f"SWITCHES_{s}_INVERTED"
adc_input_name = f"SW{s}"
custom = f"SWITCHES_{s}_"
cfs_idx = f"SWITCHES_{s}_CFS_IDX"
switch = None
if reg in hw_defs:
# 2POS switch
reg = hw_defs[reg]
pin = hw_defs[pin]
switch = Switch2POS(name, reg, pin)
elif (reg_high in hw_defs) and (reg_low in hw_defs):
# 3POS switch
reg_high = hw_defs[reg_high]
pin_high = hw_defs[pin_high]
reg_low = hw_defs[reg_low]
pin_low = hw_defs[pin_low]
switch = Switch3POS(name, reg_high, pin_high, reg_low, pin_low)
elif adc_parser.find_input(adc_input_name):
# ADC switch
switch = SwitchADC(name, adc_input_name)
else:
type = prefixsearch(hw_defs, custom)
if type is not None:
switch = SwitchCustom(name, type)
if switch:
if inverted in hw_defs:
switch.inverted = True
if cfs_idx in hw_defs:
switch.is_cfs = True
switch.cfs_idx = hw_defs[cfs_idx]
else:
switch.is_cfs = False
cfg = switch_cfg_by_target(target, name)
if cfg:
switch.default = cfg.get("default")
switch.display = cfg.get("display")
else:
switch.default = "NONE"
switches.append(switch)
for i in range(1, 6 + 1):
f_sw_marker = f"FUNCTION_SWITCH_{i}"
if f_sw_marker in hw_defs:
switch = find_switch(hw_defs[f_sw_marker])
if switch:
switch.name = f"SW{i}"
else:
switch = SwitchCustom(f"SW{i}", Switch.TYPE_2POS)
switches.append(switch)
return switches
+116
View File
@@ -0,0 +1,116 @@
from json import JSONDecodeError
from pathlib import Path
from typing import List, Tuple
from typing_extensions import Type
from pydantic import BaseModel, ValidationError
def validate_json_files(
directory: str, model_class: Type[BaseModel]
) -> Tuple[List[str], List[Tuple[str, str]]]:
"""
Validate all JSON files in a directory against a Pydantic model.
Args:
directory: Path to the directory containing JSON files
model_class: Pydantic model class to validate against
Returns:
Tuple of (valid_files, invalid_files_with_errors)
"""
directory_path = Path(directory)
if not directory_path.exists():
raise FileNotFoundError(f"Directory {directory} does not exist")
valid_files = []
invalid_files = []
# Find all JSON files in the directory
json_files = list(directory_path.glob("*.json"))
if not json_files:
print(f"No JSON files found in {directory}")
return valid_files, invalid_files
print(f"Found {len(json_files)} JSON files to validate")
for json_file in json_files:
try:
# Read the JSON file
with open(json_file, "r", encoding="utf-8") as f:
json_data = f.read()
# Validate against given model
model_class.model_validate_json(json_data)
valid_files.append(str(json_file))
print(f"✓ {json_file.name} - Valid")
except ValidationError as e:
error_msg = str(e)
invalid_files.append((str(json_file), error_msg))
print(f"✗ {json_file.name} - Validation Error:")
print(f" {error_msg}")
except JSONDecodeError as e:
error_msg = f"Invalid JSON syntax: {e}"
invalid_files.append((str(json_file), error_msg))
print(f"✗ {json_file.name} - JSON Decode Error:")
print(f" {error_msg}")
except Exception as e:
error_msg = f"Unexpected error: {e}"
invalid_files.append((str(json_file), error_msg))
print(f"✗ {json_file.name} - Unexpected Error:")
print(f" {error_msg}")
return valid_files, invalid_files
def main():
"""Main function to run the validation"""
import argparse
parser = argparse.ArgumentParser(
description="Validate JSON files against HardwareDefinition model"
)
parser.add_argument(
"-v", "--verbose", action="store_true", help="Show detailed error messages"
)
parser.add_argument(
"directory", help="Path to directory containing JSON files to validate"
)
args = parser.parse_args()
try:
from models import HardwareDefinition
valid_files, invalid_files = validate_json_files(
args.directory, HardwareDefinition
)
print("\n=== Validation Summary ===")
print(f"Total files processed: {len(valid_files) + len(invalid_files)}")
print(f"Valid files: {len(valid_files)}")
print(f"Invalid files: {len(invalid_files)}")
if invalid_files:
print("\nInvalid files:")
for file_path, error in invalid_files:
if args.verbose:
print(f" - {Path(file_path).name}: {error}")
else:
print(f" - {Path(file_path).name}")
return 0 if not invalid_files else 1
except Exception as e:
print(f"Error during validation: {e}")
return 1
if __name__ == "__main__":
exit(main())
+1 -1
View File
@@ -551,7 +551,7 @@ LEGACY_NAMES = [
"lr3pro",
"nv14", "el18",
"t8", "t12",
"tlite", "tlitef4", "tpro", "tprov2", "tpros", "bumblebee",
"tlite", "tpro", "tprov2", "tpros", "bumblebee",
"tx12", "tx12mk2",
"x7", "x7access",
"xlite", "xlites",
+98
View File
@@ -0,0 +1,98 @@
import sys
from typing import Any, Dict, Iterator, KeysView, Optional, ValuesView, ItemsView
class LoggingDict:
"""A dictionary wrapper that logs all lookups to stderr."""
def __init__(self, data: Optional[Dict[Any, Any]] = None):
self._data = data if data is not None else {}
def __getitem__(self, key: Any) -> Any:
"""Log the lookup and return the value."""
print(f"{str(key)}", file=sys.stderr)
return self._data[key]
def __setitem__(self, key: Any, value: Any) -> None:
"""Set an item in the dictionary."""
self._data[key] = value
def __delitem__(self, key: Any) -> None:
"""Delete an item from the dictionary."""
del self._data[key]
def __contains__(self, key: Any) -> bool:
"""Check if key exists (this is also a lookup, so log it)."""
print(f"{str(key)}", file=sys.stderr)
return key in self._data
def __len__(self) -> int:
"""Return the length of the dictionary."""
return len(self._data)
def __iter__(self) -> Iterator:
"""Return an iterator over the keys."""
return iter(self._data)
def __repr__(self) -> str:
"""Return a string representation."""
return f"LoggingDict({self._data})"
def get(self, key: Any, default: Any = None) -> Any:
"""Get a value with optional default (logs the lookup)."""
print(f"{str(key)}", file=sys.stderr)
return self._data.get(key, default)
def keys(self) -> KeysView:
"""Return dictionary keys."""
return self._data.keys()
def values(self) -> ValuesView:
"""Return dictionary values."""
return self._data.values()
def items(self) -> ItemsView:
"""Return dictionary items."""
return self._data.items()
def update(self, other: Dict[Any, Any]) -> None:
"""Update the dictionary with another dictionary."""
self._data.update(other)
def clear(self) -> None:
"""Clear all items from the dictionary."""
self._data.clear()
def pop(self, key: Any, default: Any = None) -> Any:
"""Remove and return a value (logs the lookup)."""
print(f"{str(key)}", file=sys.stderr)
if default is None:
return self._data.pop(key)
return self._data.pop(key, default)
def setdefault(self, key: Any, default: Any = None) -> Any:
"""Get a value or set/return default (logs the lookup)."""
print(f"{str(key)}", file=sys.stderr)
return self._data.setdefault(key, default)
# Example usage
if __name__ == "__main__":
# Create a logging dictionary
d = LoggingDict({"a": 1, "b": 2, "c": 3})
# These operations will be logged to stderr
print("Value of 'a':", d["a"])
print("Value of 'b':", d.get("b"))
print("Does 'c' exist?", "c" in d)
print("Does 'd' exist?", "d" in d)
# Add new items
d["d"] = 4
d["e"] = 5
# More logged lookups
print("Value of 'd':", d["d"])
print("Popped 'e':", d.pop("e"))
print("Final dictionary:", d)
+297
View File
@@ -0,0 +1,297 @@
from enum import Enum
from typing_extensions import List, Literal, Optional, Tuple, Union
from pydantic import BaseModel, model_validator
from pydantic_core import from_json, PydanticCustomError
class StrEnum(str, Enum):
@staticmethod
def _generate_next_value_(name, start, count, last_values):
return name
def __str__(self) -> str:
return self.value
ADCNameType = Literal["MAIN", "EXT", "SPI"]
class ADC(BaseModel):
name: ADCNameType
adc: str
sample_time: Optional[str] = None
dma: Optional[str] = None
dma_channel: Optional[str] = None
dma_stream: Optional[str] = None
dma_stream_irq: Optional[str] = None
dma_stream_irq_handler: Optional[str] = None
StickEnum = StrEnum(
"StickEnum",
(
# 2 Gimbal radios
"LH",
"LV",
"RV",
"RH",
# Surface radios
"ST",
"TH",
),
)
MAX_POTS = 8
MAX_SLIDERS = 8
MAX_EXT = 16
MAX_RAW = 8
FlexInputEnum = StrEnum(
"FlexInputEnum",
(
[f"P{i}" for i in range(1, MAX_POTS)]
+ [f"SL{i}" for i in range(1, MAX_SLIDERS)]
+ [f"EXT{i}" for i in range(1, MAX_EXT)]
+ ["JSx", "JSy"]
),
)
SwitchInputEnum = StrEnum(
"SwitchInputEnum",
list([f"SW{chr(i)}" for i in range(ord("A"), ord("Z") + 1)]),
)
RawInputEnum = StrEnum("RawInputEnum", list([f"RAW{i}" for i in range(1, MAX_RAW)]))
InputNameType = Union[StickEnum, FlexInputEnum, SwitchInputEnum, RawInputEnum]
InputType = StrEnum(
"InputType",
(
"STICK",
"FLEX",
"SWITCH",
"VBAT",
"RTC_BAT",
"RAW",
),
)
FlexType = StrEnum(
"FlexType",
(
"NONE",
"POT",
"POT_CENTER",
"SLIDER",
"MULTIPOS",
"AXIS_X",
"AXIS_Y",
),
)
class StickInput(BaseModel):
name: StickEnum
type: Literal["STICK"]
adc: Optional[ADCNameType] = None
gpio: Optional[str] = None
pin: Optional[str] = None
channel: Optional[Union[str, int]] = None
inverted: Optional[bool] = False
class FlexInput(BaseModel):
name: FlexInputEnum
type: Literal["FLEX"]
adc: ADCNameType
gpio: Optional[str] = None
pin: Optional[str] = None
channel: Optional[Union[str, int]] = None
inverted: Optional[bool] = False
default: Optional[FlexType] = FlexType.NONE
label: Optional[str] = None
short_label: Optional[str] = None
class SwitchInput(BaseModel):
name: SwitchInputEnum
type: Literal["SWITCH"]
adc: ADCNameType
gpio: Optional[str] = None
pin: Optional[str] = None
channel: Optional[Union[str, int]] = None
inverted: Optional[bool] = False
class RawInput(BaseModel):
name: RawInputEnum
type: Literal["RAW"]
adc: ADCNameType
gpio: Optional[str] = None
pin: Optional[str] = None
channel: Optional[Union[str, int]] = None
class VBatInput(BaseModel):
name: Literal["VBAT"]
type: Literal["VBAT"]
adc: ADCNameType
gpio: Optional[str] = None
pin: Optional[str] = None
channel: Optional[Union[str, int]] = None
class RTCBatInput(BaseModel):
name: Literal["RTC_BAT"]
type: Literal["RTC_BAT"]
adc: Literal["MAIN", "EXT"]
channel: str
Input = Union[StickInput, FlexInput, SwitchInput, RawInput, VBatInput, RTCBatInput]
class ADCInputs(BaseModel):
adcs: List[ADC]
inputs: List[Input]
# MUST be the same order as 'EnumKeys'
KeyEnum = StrEnum(
"KeyEnum",
(
"KEY_MENU",
"KEY_EXIT",
"KEY_ENTER",
"KEY_PAGEUP",
"KEY_PAGEDN",
"KEY_UP",
"KEY_DOWN",
"KEY_LEFT",
"KEY_RIGHT",
"KEY_PLUS",
"KEY_MINUS",
"KEY_MODEL",
"KEY_TELE",
"KEY_SYS",
"KEY_SHIFT",
"KEY_BIND",
),
)
class Key(BaseModel):
name: str
label: str
key: KeyEnum
active_low: Optional[bool] = False
gpio: Optional[str] = None
pin: Optional[str] = None
@model_validator(mode="after")
def check_hardware(self: "Key") -> "Key":
if bool(self.gpio) != bool(self.pin):
raise PydanticCustomError(
"KeyHardwareError",
"Key missing either 'gpio' or 'pin'",
)
return self
SwitchHardwareTypeEnum = StrEnum(
"SwitchTypeEnum",
(
"2POS",
"3POS",
"ADC",
"FSWITCH",
),
)
SwitchTypeEnum = StrEnum(
"SwitchTypeEnum",
(
"2POS",
"3POS",
"TOGGLE",
"NONE",
),
)
SwitchDisplayType = Union[Tuple[int, int], Tuple]
class Switch(BaseModel):
name: str
type: SwitchHardwareTypeEnum
default: Optional[SwitchTypeEnum] = SwitchTypeEnum.NONE
flags: Optional[int] = 0
inverted: Optional[bool] = False
adc_input: Optional[str] = None
gpio: Optional[str] = None
pin: Optional[str] = None
gpio_high: Optional[str] = None
pin_high: Optional[str] = None
gpio_low: Optional[str] = None
pin_low: Optional[str] = None
display: Optional[SwitchDisplayType] = None
def _uses_single_gpio(self: "Switch") -> bool:
return bool(self.pin)
def _uses_two_gpios(self: "Switch") -> bool:
return bool(self.pin_high or self.pin_low)
def _uses_gpio(self: "Switch") -> bool:
return bool(self.gpio_high or self.gpio_low or self.gpio)
@model_validator(mode="after")
def check_hardware(self: "Switch") -> "Switch":
if bool(self.adc_input) == self._uses_gpio():
if self.adc_input:
raise PydanticCustomError(
"SwitchHardwareError",
"A switch is either using ADC or it's own GPIO pin(s)",
)
if self._uses_gpio() and (self._uses_single_gpio() == self._uses_two_gpios()):
raise PydanticCustomError(
"SwitchHardwareError",
"A switch based on GPIO pin(s) uses either a single or two GPIOs",
)
if self._uses_single_gpio():
if str(self.type) not in ["2POS", "FSWITCH"]:
raise PydanticCustomError(
"SwitchHardwareError",
"Single GPIO switch type is either '2POS' or 'FSWITCH'",
)
# TODO: check 'default' as well?
if self._uses_two_gpios():
if not self.pin_high or not self.pin_low:
raise PydanticCustomError(
"SwitchHardwareError",
"Switch missing 'pin_high' or 'pin_low'",
)
if str(self.type) != "3POS":
raise PydanticCustomError(
"SwitchHardwareError",
"Dual GPIO switch type is always '3POS",
)
# TODO: check 'default' as well?
return self
class HardwareDefinition(BaseModel):
adc_inputs: ADCInputs
switches: List[Switch]
keys: List[Key]
@staticmethod
def from_json(data: Union[str, bytes, bytearray]) -> "HardwareDefinition":
return HardwareDefinition.model_validate(from_json(data))
-292
View File
@@ -1,292 +0,0 @@
"""Default configuration of pots and sliders for each target."""
POT_CONFIG = {
"boxer": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT_CENTER"},
"P3": {"default": "MULTIPOS"}
},
"gx12": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT_CENTER"},
"SL1": {"default": "SLIDER"},
"SL2": {"default": "SLIDER"}
},
"el18": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT_CENTER"}
},
"nv14": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT_CENTER"}
},
"pl18": {
"P1": {"default": "POT"},
"P2": {"default": "POT"},
"P3": {"default": "POT"},
"SL1": {"default": "SLIDER"},
"SL2": {"default": "SLIDER"}
},
"pl18ev": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT"},
"P3": {"default": "POT_CENTER"},
"SL1": {"default": "SLIDER"},
"SL2": {"default": "SLIDER"},
"EXT1": {"default": "POT_CENTER"},
"EXT2": {"default": "POT_CENTER"},
"EXT3": {"default": "MULTIPOS"},
"EXT4": {"default": "MULTIPOS"}
},
"pl18u": {
"P1": {"default": "POT"},
"P2": {"default": "POT"},
"P3": {"default": "POT_CENTER"},
"SL1": {"default": "SLIDER"},
"SL2": {"default": "SLIDER"}
},
"nb4p": {
"P1": {"default": "POT"},
"P2": {"default": "POT"}
},
"v12": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT_CENTER"},
"P3": {"default": "MULTIPOS"},
},
"v14": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT_CENTER"},
"P3": {"default": "MULTIPOS"},
},
"v16": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "MULTIPOS"},
"P3": {"default": "POT_CENTER"},
"SL1": {"default": "SLIDER"},
"SL2": {"default": "SLIDER"}
},
"mt12": {
"P1": {"default": "POT"},
"P2": {"default": "POT"},
"P3": {"default": "NONE"},
"P4": {"default": "NONE"}
},
"tpro": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT_CENTER"}
},
"tprov2": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT_CENTER"}
},
"tpros": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT_CENTER"}
},
"bumblebee": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT_CENTER"}
},
"t20": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT_CENTER"},
"SL1": {"default": "SLIDER"},
"SL2": {"default": "SLIDER"},
"SL3": {"default": "SLIDER"},
"SL4": {"default": "SLIDER"},
},
"t20v2": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT_CENTER"},
"SL1": {"default": "SLIDER"},
"SL2": {"default": "SLIDER"},
"SL3": {"default": "SLIDER"},
"SL4": {"default": "SLIDER"},
},
"t12": {
"P1": {"default": "POT"},
"P2": {"default": "POT"}
},
"t12max": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT_CENTER"}
},
"t14": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT_CENTER"}
},
"tx12": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT_CENTER"}
},
"tx12mk2": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT_CENTER"}
},
"t15": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT_CENTER"},
},
"t16": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "MULTIPOS"},
"P3": {"default": "POT_CENTER"},
"SL1": {"default": "SLIDER"},
"SL2": {"default": "SLIDER"}
},
"t18": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "MULTIPOS"},
"P3": {"default": "POT_CENTER"},
"SL1": {"default": "SLIDER"},
"SL2": {"default": "SLIDER"}
},
"tx15": {
"P1": {"default": "POT"},
"P2": {"default": "POT"},
},
"t15pro": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT_CENTER"},
},
"tx16s": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "MULTIPOS"},
"P3": {"default": "POT_CENTER"},
"SL1": {"default": "SLIDER"},
"SL2": {"default": "SLIDER"}
},
"tx16smk3": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT_CENTER"},
"SL1": {"default": "SLIDER"},
"SL2": {"default": "SLIDER"},
"EXT1": {"default": "NONE"},
"EXT2": {"default": "NONE"},
},
"f16": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "MULTIPOS"},
"P3": {"default": "POT_CENTER"},
"SL1": {"default": "SLIDER"},
"SL2": {"default": "SLIDER"}
},
"x7": {
"P1": {"default": "POT"},
"P2": {"default": "POT_CENTER"}
},
"x7access": {
"P1": {"default": "POT"},
"P2": {"default": "POT_CENTER"}
},
"x9d": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT_CENTER"},
"SL1": {"default": "SLIDER"},
"SL2": {"default": "SLIDER"}
},
"x9d+": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT_CENTER"},
"SL1": {"default": "SLIDER"},
"SL2": {"default": "SLIDER"}
},
"x9d+2019": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT_CENTER"},
"SL1": {"default": "SLIDER"},
"SL2": {"default": "SLIDER"}
},
"x9e": {
"P1": {"default": "POT_CENTER"},
"P2": {"default": "POT_CENTER"},
"P3": {"default": "NONE"},
"P4": {"default": "NONE"},
"SL1": {"default": "SLIDER"},
"SL2": {"default": "SLIDER"},
"SL3": {"default": "SLIDER"},
"SL4": {"default": "SLIDER"}
},
"x10": {
"P1": {"default": "POT"},
"P2": {"default": "MULTIPOS"},
"P3": {"default": "POT_CENTER"},
"SL1": {"default": "SLIDER"},
"SL2": {"default": "SLIDER"}
},
"x10express": {
"P1": {"default": "POT"},
"P2": {"default": "MULTIPOS"},
"P3": {"default": "POT_CENTER"},
"SL1": {"default": "SLIDER"},
"SL2": {"default": "SLIDER"}
},
"x12s": {
"P1": {"default": "POT"},
"P2": {"default": "MULTIPOS"},
"P3": {"default": "POT_CENTER"},
"SL1": {"default": "SLIDER"},
"SL2": {"default": "SLIDER"},
"SL3": {"default": "SLIDER"},
"SL4": {"default": "SLIDER"},
"JSx": {"default": "AXIS_X"},
"JSy": {"default": "AXIS_Y"}
},
"xlite": {
"P1": {"default": "POT"},
"P2": {"default": "POT"}
},
"xlites": {
"P1": {"default": "POT"},
"P2": {"default": "POT"}
},
"x9lite": {
"P1": {"default": "POT_CENTER"},
},
"x9lites": {
"P1": {"default": "POT_CENTER"},
},
"zorro": {
"P1": {"default": "POT"},
"P2": {"default": "POT"}
},
"pocket": {
"P1": {"default": "POT"}
},
"st16": {
"P1": {"default": "POT"},
"P2": {"default": "POT"},
"SL1": {"default": "SLIDER"},
"SL2": {"default": "SLIDER"},
},
"pa01": {
"SL1": {"default": "SLIDER"},
"SL2": {"default": "SLIDER"},
},
}
def pot_cfg_by_target(target, name):
"""Retrieve default pot config.
Parameters
----------
target: str
Name of the target
name: str
Canonical name of the pot (Px where 'x' is a number)
or slider (SLx where 'x' is a number)
Returns
-------
dict
a dictionary with one key for each pot or slider that mapped
to another dictionary with a single attribute ("default") containing
the default configuration for a pot or slider
"""
sw = POT_CONFIG.get(target)
if sw:
return sw.get(name)
return None
-669
View File
@@ -1,669 +0,0 @@
"""Default switches configurations and display positions."""
SWITCH_CONFIG = {
"boxer": {
# left side
"SA": {"default": "2POS", "display": [0, 0]},
"SB": {"default": "3POS", "display": [0, 1]},
"SE": {"default": "2POS", "display": [0, 2]},
# right side
"SC": {"default": "3POS", "display": [1, 0]},
"SD": {"default": "2POS", "display": [1, 1]},
"SF": {"default": "TOGGLE", "display": [1, 2]},
},
"gx12": {
# left side
"SA": {"default": "TOGGLE"},
"SB": {"default": "3POS", "display": [0, 0]},
"SE": {"default": "3POS", "display": [0, 1]},
"SG": {"default": "TOGGLE", "display": [0, 2]},
# right side
"SC": {"default": "3POS", "display": [1, 0]},
"SD": {"default": "TOGGLE"},
"SF": {"default": "3POS", "display": [1, 1]},
"SH": {"default": "TOGGLE", "display": [1, 2]},
# custom switches
"SI": {"default": "2POS"},
"SJ": {"default": "2POS"},
"SK": {"default": "2POS"},
"SL": {"default": "2POS"},
"SM": {"default": "2POS"},
"SN": {"default": "2POS"},
},
"commando8": {
# left side
"SA": {"default": "2POS", "display": [0, 0]},
"SC": {"default": "3POS", "display": [0, 1]},
# right side
"SB": {"default": "3POS", "display": [1, 0]},
"SD": {"default": "2POS", "display": [1, 1]}
},
"el18": {
"SA": { "default": "2POS" },
"SB": { "default": "3POS" },
"SC": { "default": "3POS" },
"SD": { "default": "2POS" },
"SE": { "default": "2POS" },
"SF": { "default": "3POS" },
"SG": { "default": "3POS" },
"SH": { "default": "TOGGLE" }
},
"pl18": {
"SA": { "default": "2POS" },
"SB": { "default": "3POS" },
"SC": { "default": "2POS" },
"SD": { "default": "3POS" },
"SE": { "default": "3POS" },
"SF": { "default": "2POS" },
"SG": { "default": "3POS" },
"SH": { "default": "TOGGLE" }
},
"pl18ev": {
"SA": { "default": "2POS" },
"SB": { "default": "3POS" },
"SC": { "default": "2POS" },
"SD": { "default": "3POS" },
"SE": { "default": "3POS" },
"SF": { "default": "2POS" },
"SG": { "default": "3POS" },
"SH": { "default": "3POS" },
"SI": { "default": "3POS" },
"SJ": { "default": "3POS" }
},
"pl18u": {
"SA": { "default": "3POS" },
"SB": { "default": "3POS" },
"SC": { "default": "3POS" },
"SD": { "default": "3POS" },
"SE": { "default": "3POS" },
"SF": { "default": "3POS" },
"SG": { "default": "3POS" },
"SH": { "default": "TOGGLE" }
},
"nb4p": {
"SA" : { "default": "TOGGLE" },
"SB" : { "default": "TOGGLE" }
},
"st16": {
"SA": { "default": "2POS" },
"SB": { "default": "3POS" },
"SC": { "default": "3POS" },
"SD": { "default": "2POS" },
"SE": { "default": "2POS" },
"SF": { "default": "2POS" },
"SG": { "default": "TOGGLE" },
"SH": { "default": "TOGGLE" },
"SI": { "default": "TOGGLE" },
"SJ": { "default": "TOGGLE" },
# custom switches
"SK": {"default": "2POS"},
"SL": {"default": "2POS"},
"SM": {"default": "2POS"},
"SN": {"default": "2POS"},
"SO": {"default": "2POS"},
"SP": {"default": "2POS"},
},
"pa01": {
"SA": { "default": "2POS" },
"SB": { "default": "3POS" },
"SC": { "default": "3POS" },
"SD": { "default": "TOGGLE" },
"SE": { "default": "TOGGLE" },
"SF": { "default": "TOGGLE" },
# custom switches
"SK": {"default": "2POS"},
"SL": {"default": "2POS"},
"SM": {"default": "2POS"},
"SN": {"default": "2POS"},
},
"lr3pro": {
# left side
"SA": {"default": "3POS", "display": [0, 0]},
"SC": {"default": "3POS", "display": [0, 1]},
# right side
"SB": {"default": "2POS", "display": [1, 0]},
"SD": {"default": "2POS", "display": [1, 1]}
},
"nv14": {
"SA": {"default": "2POS"},
"SB": {"default": "3POS"},
"SC": {"default": "TOGGLE"},
"SD": {"default": "2POS"},
"SE": {"default": "TOGGLE"},
"SF": {"default": "3POS"},
"SG": {"default": "3POS"},
"SH": {"default": "TOGGLE"}
},
"v12": {
# left side
"SA": {"default": "3POS", "display": [0, 0]},
"SB": {"default": "3POS", "display": [0, 1]},
"SE": {"default": "2POS", "display": [0, 2]},
# right side
"SC": {"default": "3POS", "display": [1, 0]},
"SD": {"default": "3POS", "display": [1, 1]},
"SF": {"default": "TOGGLE", "display": [1, 2]},
},
"v14": {
# left side
"SA": {"default": "TOGGLE", "display": [0, 0]},
"SB": {"default": "3POS", "display": [0, 1]},
"SE": {"default": "2POS", "display": [0, 2]},
# right side
"SC": {"default": "3POS", "display": [1, 0]},
"SD": {"default": "TOGGLE", "display": [1, 1]},
"SF": {"default": "TOGGLE", "display": [1, 2]},
},
"v16": {
"SA": {"default": "3POS"},
"SB": {"default": "3POS"},
"SC": {"default": "3POS"},
"SD": {"default": "3POS"},
"SE": {"default": "3POS"},
"SF": {"default": "2POS"},
"SG": {"default": "3POS"},
"SH": {"default": "TOGGLE"}
},
"mt12": {
# left side
"SA": { "default": "3POS", "display": [ 0, 0 ] },
"SB": { "default": "TOGGLE", "display": [ 0, 1 ] },
# right side
"SC": { "default": "TOGGLE", "display": [ 1, 0 ] },
"SD": { "default": "TOGGLE", "display": [ 1, 1 ] },
},
"t8": {
# left side
"SA": {"default": "2POS", "display": [0, 0]},
"SC": {"default": "3POS", "display": [0, 1]},
# right side
"SB": {"default": "3POS", "display": [1, 0]},
"SD": {"default": "2POS", "display": [1, 1]}
},
"t12": {
# left side
"SA": {"default": "3POS", "display": [0, 0]},
"SB": {"default": "3POS", "display": [0, 1]},
"SG": {"default": "2POS", "display": [0, 2]},
# right side
"SC": {"default": "3POS", "display": [1, 0]},
"SD": {"default": "3POS", "display": [1, 1]},
"SH": {"default": "2POS", "display": [1, 2]}
},
"t12max": {
# left side
"SA": {"default": "2POS", "display": [0, 0]},
"SC": {"default": "3POS", "display": [0, 1]},
"SE": {"default": "2POS", "display": [0, 2]},
# right side
"SB": {"default": "2POS", "display": [1, 0]},
"SD": {"default": "3POS", "display": [1, 1]},
"SF": {"default": "2POS", "display": [1, 2]}
},
"t14": {
# left side
"SA": {"default": "2POS", "display": [0, 0]},
"SC": {"default": "3POS", "display": [0, 1]},
"SE": {"default": "2POS", "display": [0, 2]},
# right side
"SB": {"default": "2POS", "display": [1, 0]},
"SD": {"default": "3POS", "display": [1, 1]},
"SF": {"default": "TOGGLE", "display": [1, 2]}
},
"t15": {
"SA": {"default": "3POS"},
"SB": {"default": "3POS"},
"SC": {"default": "3POS"},
"SD": {"default": "3POS"},
"SE": {"default": "2POS"},
"SF": {"default": "2POS"},
# custom switches
"SG": {"default": "2POS"},
"SH": {"default": "2POS"},
"SI": {"default": "2POS"},
"SJ": {"default": "2POS"},
"SK": {"default": "2POS"},
"SL": {"default": "2POS"},
},
"t16": {
"SA": {"default": "3POS"},
"SB": {"default": "3POS"},
"SC": {"default": "3POS"},
"SD": {"default": "3POS"},
"SE": {"default": "3POS"},
"SF": {"default": "2POS"},
"SG": {"default": "3POS"},
"SH": {"default": "TOGGLE"}
},
"t18": {
"SA": {"default": "3POS"},
"SB": {"default": "3POS"},
"SC": {"default": "3POS"},
"SD": {"default": "3POS"},
"SE": {"default": "3POS"},
"SF": {"default": "2POS"},
"SG": {"default": "3POS"},
"SH": {"default": "TOGGLE"}
},
"tlite": {
# left side
"SA": {"default": "3POS", "display": [0, 0]},
"SC": {"default": "2POS", "display": [0, 1]},
# right side
"SB": {"default": "3POS", "display": [1, 0]},
"SD": {"default": "2POS", "display": [1, 1]}
},
"tlitef4": {
# left side
"SA": {"default": "3POS", "display": [0, 0]},
"SC": {"default": "2POS", "display": [0, 1]},
# right side
"SB": {"default": "3POS", "display": [1, 0]},
"SD": {"default": "2POS", "display": [1, 1]}
},
"tpro": {
# left side
"SA": {"default": "3POS", "display": [0, 0]},
"SC": {"default": "TOGGLE", "display": [0, 1]},
"SE": {"default": "NONE", "display": [0, 2]},
# right side
"SB": {"default": "3POS", "display": [1, 0]},
"SD": {"default": "TOGGLE", "display": [1, 1]},
"SF": {"default": "NONE", "display": [1, 2]},
# custom switches
"SG": {"default": "2POS"},
"SH": {"default": "2POS"},
"SI": {"default": "2POS"},
"SJ": {"default": "2POS"},
"SK": {"default": "2POS"},
"SL": {"default": "2POS"},
},
"tprov2": {
# left side
"SA": {"default": "3POS", "display": [0, 0]},
"SC": {"default": "TOGGLE", "display": [0, 1]},
"SE": {"default": "2POS", "display": [0, 2]},
"SG": {"default": "NONE", "display": [0, 3]},
# right side
"SB": {"default": "3POS", "display": [1, 0]},
"SD": {"default": "TOGGLE", "display": [1, 1]},
"SF": {"default": "2POS", "display": [1, 2]},
"SH": {"default": "NONE", "display": [1, 3]},
# custom switches
"SI": {"default": "2POS"},
"SJ": {"default": "2POS"},
"SK": {"default": "2POS"},
"SL": {"default": "2POS"},
"SM": {"default": "2POS"},
"SN": {"default": "2POS"},
},
"tpros": {
# left side
"SA": {"default": "3POS", "display": [0, 0]},
"SC": {"default": "TOGGLE", "display": [0, 1]},
"SE": {"default": "2POS", "display": [0, 2]},
# right side
"SB": {"default": "3POS", "display": [1, 0]},
"SD": {"default": "TOGGLE", "display": [1, 1]},
"SF": {"default": "2POS", "display": [1, 2]},
},
"bumblebee": {
# left side
"SA": {"default": "3POS", "display": [0, 0]},
"SC": {"default": "TOGGLE", "display": [0, 1]},
"SE": {"default": "2POS", "display": [0, 2]},
"SG": {"default": "TOGGLE", "display": [0, 3]},
# right side
"SB": {"default": "3POS", "display": [1, 0]},
"SD": {"default": "TOGGLE", "display": [1, 1]},
"SF": {"default": "2POS", "display": [1, 2]},
"SH": {"default": "TOGGLE", "display": [1, 3]},
# custom switches
"SJ": {"default": "2POS"},
"SK": {"default": "2POS"},
"SL": {"default": "2POS"},
"SM": {"default": "2POS"},
"SO": {"default": "2POS"},
"SP": {"default": "2POS"},
},
"t20": {
# left side
"SA": {"default": "2POS", "display": [0, 0]},
"SC": {"default": "3POS", "display": [0, 1]},
"SE": {"default": "2POS", "display": [0, 2]},
"SG": {"default": "TOGGLE", "display": [0, 3]},
"SI": {"default": "TOGGLE", "display": [0, 4]},
# right side
"SB": {"default": "2POS", "display": [1, 0]},
"SD": {"default": "3POS", "display": [1, 1]},
"SF": {"default": "2POS", "display": [1, 2]},
"SH": {"default": "TOGGLE", "display": [1, 3]},
"SJ": {"default": "TOGGLE", "display": [1, 4]},
# custom switches
"SK": {"default": "2POS"},
"SL": {"default": "2POS"},
"SM": {"default": "2POS"},
"SN": {"default": "2POS"},
"SO": {"default": "2POS"},
"SP": {"default": "2POS"},
},
"t20v2": {
# left side
"SA": {"default": "2POS", "display": [0, 0]},
"SC": {"default": "3POS", "display": [0, 1]},
"SE": {"default": "2POS", "display": [0, 2]},
"SG": {"default": "TOGGLE", "display": [0, 3]},
"SI": {"default": "TOGGLE", "display": [0, 4]},
# right side
"SB": {"default": "2POS", "display": [1, 0]},
"SD": {"default": "3POS", "display": [1, 1]},
"SF": {"default": "2POS", "display": [1, 2]},
"SH": {"default": "TOGGLE", "display": [1, 3]},
"SJ": {"default": "TOGGLE", "display": [1, 4]},
# custom switches
"SK": {"default": "2POS"},
"SL": {"default": "2POS"},
"SM": {"default": "2POS"},
"SN": {"default": "2POS"},
"SO": {"default": "2POS"},
"SP": {"default": "2POS"},
},
"tx12": {
# left side
"SA": {"default": "TOGGLE", "display": [0, 0]},
"SB": {"default": "3POS", "display": [0, 1]},
"SE": {"default": "3POS", "display": [0, 2]},
"SG": {"default": "NONE", "display": [0, 3]},
# right side
"SC": {"default": "3POS", "display": [1, 0]},
"SD": {"default": "TOGGLE", "display": [1, 1]},
"SF": {"default": "3POS", "display": [1, 2]},
"SH": {"default": "NONE", "display": [1, 3]}
},
"t15pro": {
"SA": {"default": "3POS"},
"SB": {"default": "3POS"},
"SC": {"default": "3POS"},
"SD": {"default": "3POS"},
"SE": {"default": "2POS"},
"SF": {"default": "2POS"},
# custom switches
"SG": {"default": "2POS"},
"SH": {"default": "2POS"},
"SI": {"default": "2POS"},
"SJ": {"default": "2POS"},
"SK": {"default": "2POS"},
"SL": {"default": "2POS"},
},
"tx15": {
"SA": {"default": "3POS"},
"SB": {"default": "3POS"},
"SC": {"default": "3POS"},
"SD": {"default": "3POS"},
"SE": {"default": "2POS"},
"SF": {"default": "TOGGLE"},
# custom switches
"SG": {"default": "2POS"},
"SH": {"default": "2POS"},
"SI": {"default": "2POS"},
"SJ": {"default": "2POS"},
"SK": {"default": "2POS"},
"SL": {"default": "2POS"},
},
"tx16s": {
"SA": {"default": "3POS"},
"SB": {"default": "3POS"},
"SC": {"default": "3POS"},
"SD": {"default": "3POS"},
"SE": {"default": "3POS"},
"SF": {"default": "2POS"},
"SG": {"default": "3POS"},
"SH": {"default": "TOGGLE"}
},
"tx16smk3": {
"SA": {"default": "3POS"},
"SB": {"default": "3POS"},
"SC": {"default": "3POS"},
"SD": {"default": "3POS"},
"SE": {"default": "3POS"},
"SF": {"default": "2POS"},
"SG": {"default": "3POS"},
"SH": {"default": "2POS"},
#optional
"SI": {"default": "NONE"},
"SJ": {"default": "NONE"},
# custom switches
"SK": {"default": "2POS"},
"SL": {"default": "2POS"},
"SM": {"default": "2POS"},
"SN": {"default": "2POS"},
"SO": {"default": "2POS"},
"SP": {"default": "2POS"},
},
"f16": {
"SA": {"default": "3POS"},
"SB": {"default": "3POS"},
"SC": {"default": "3POS"},
"SD": {"default": "3POS"},
"SE": {"default": "3POS"},
"SF": {"default": "2POS"},
"SG": {"default": "3POS"},
"SH": {"default": "TOGGLE"}
},
"tx12mk2": {
# left side
"SA": {"default": "TOGGLE", "display": [0, 0]},
"SB": {"default": "3POS", "display": [0, 1]},
"SE": {"default": "3POS", "display": [0, 2]},
# right side
"SC": {"default": "3POS", "display": [1, 0]},
"SD": {"default": "TOGGLE", "display": [1, 1]},
"SF": {"default": "3POS", "display": [1, 2]},
},
"x7": {
# left side
"SA": {"default": "3POS", "display": [0, 0]},
"SB": {"default": "3POS", "display": [0, 1]},
"SF": {"default": "2POS", "display": [0, 2]},
# right side
"SC": {"default": "3POS", "display": [1, 0]},
"SD": {"default": "3POS", "display": [1, 1]},
"SH": {"default": "TOGGLE", "display": [1, 2]},
# optional
"SI": {"default": "NONE", "display": [0, 3]},
"SJ": {"default": "NONE", "display": [0, 3]},
},
"x7access": {
# left side
"SA": {"default": "3POS", "display": [0, 0]},
"SB": {"default": "3POS", "display": [0, 1]},
"SF": {"default": "2POS", "display": [0, 2]},
# right side
"SC": {"default": "3POS", "display": [1, 0]},
"SD": {"default": "3POS", "display": [1, 1]},
"SH": {"default": "TOGGLE", "display": [1, 2]},
# optional
"SI": {"default": "NONE", "display": [0, 3]},
"SJ": {"default": "NONE", "display": [0, 3]},
},
"x9d": {
# left side
"SA": {"default": "3POS", "display": [0, 0]},
"SB": {"default": "3POS", "display": [0, 1]},
"SE": {"default": "3POS", "display": [0, 2]},
"SF": {"default": "2POS", "display": [0, 3]},
# right side
"SC": {"default": "3POS", "display": [1, 0]},
"SD": {"default": "3POS", "display": [1, 1]},
"SG": {"default": "3POS", "display": [1, 2]},
"SH": {"default": "TOGGLE", "display": [1, 3]}
},
"x9d+": {
# left side
"SA": {"default": "3POS", "display": [0, 0]},
"SB": {"default": "3POS", "display": [0, 1]},
"SE": {"default": "3POS", "display": [0, 2]},
"SF": {"default": "2POS", "display": [0, 3]},
# right side
"SC": {"default": "3POS", "display": [1, 0]},
"SD": {"default": "3POS", "display": [1, 1]},
"SG": {"default": "3POS", "display": [1, 2]},
"SH": {"default": "TOGGLE", "display": [1, 3]}
},
"x9d+2019": {
# left side
"SA": {"default": "3POS", "display": [0, 0]},
"SB": {"default": "3POS", "display": [0, 1]},
"SE": {"default": "3POS", "display": [0, 2]},
"SF": {"default": "2POS", "display": [0, 3]},
"SI": {"default": "TOGGLE", "display": [0, 4]},
# right side
"SC": {"default": "3POS", "display": [1, 0]},
"SD": {"default": "3POS", "display": [1, 1]},
"SG": {"default": "3POS", "display": [1, 2]},
"SH": {"default": "TOGGLE", "display": [1, 3]}
},
"x9e": {
# left side
"SA": {"default": "3POS", "display": [0, 0]},
"SB": {"default": "3POS", "display": [0, 1]},
"SE": {"default": "3POS", "display": [0, 2]},
"SF": {"default": "2POS", "display": [0, 3]},
# extra
"SI": {"default": "NONE", "display": [0, 4]},
"SK": {"default": "NONE", "display": [0, 5]},
"SM": {"default": "NONE", "display": [0, 6]},
"SO": {"default": "NONE", "display": [0, 7]},
"SQ": {"default": "NONE", "display": [0, 8]},
# right side
"SC": {"default": "3POS", "display": [1, 0]},
"SD": {"default": "3POS", "display": [1, 1]},
"SH": {"default": "3POS", "display": [1, 2]},
"SG": {"default": "TOGGLE", "display": [1, 3]},
# extra
"SJ": {"default": "NONE", "display": [1, 4]},
"SL": {"default": "NONE", "display": [1, 5]},
"SN": {"default": "NONE", "display": [1, 6]},
"SP": {"default": "NONE", "display": [1, 7]},
"SR": {"default": "NONE", "display": [1, 8]}
},
"xlite": {
# left side
"SA": {"default": "3POS", "display": [0, 0]},
"SC": {"default": "3POS", "display": [0, 1]},
# right side
"SB": {"default": "2POS", "display": [1, 0]},
"SD": {"default": "2POS", "display": [1, 1]}
},
"xlites": {
# left side
"SA": {"default": "3POS", "display": [0, 0]},
"SC": {"default": "3POS", "display": [0, 1]},
"SE": {"default": "TOGGLE", "display": [0, 2]},
# right side
"SB": {"default": "2POS", "display": [1, 0]},
"SD": {"default": "2POS", "display": [1, 1]},
"SF": {"default": "TOGGLE", "display": [1, 2]}
},
"x9lite": {
# left side
"SA": {"default": "3POS", "display": [0, 0]},
"SB": {"default": "3POS", "display": [0, 1]},
"SD": {"default": "2POS", "display": [0, 2]},
# right side
"SC": {"default": "3POS", "display": [1, 0]},
"SE": {"default": "TOGGLE", "display": [1, 1]}
},
"x9lites": {
# left side
"SA": {"default": "3POS", "display": [0, 0]},
"SB": {"default": "3POS", "display": [0, 1]},
"SD": {"default": "2POS", "display": [0, 2]},
"SF": {"default": "TOGGLE", "display": [0, 3]},
# right side
"SC": {"default": "3POS", "display": [1, 1]},
"SE": {"default": "TOGGLE", "display": [1, 2]},
"SG": {"default": "TOGGLE", "display": [1, 3]}
},
"x10": {
"SA": {"default": "3POS"},
"SB": {"default": "3POS"},
"SC": {"default": "3POS"},
"SD": {"default": "3POS"},
"SE": {"default": "3POS"},
"SF": {"default": "2POS"},
"SG": {"default": "3POS"},
"SH": {"default": "TOGGLE"},
"SI": {"default": "NONE"},
"SJ": {"default": "NONE"}
},
"x12s": {
"SA": {"default": "3POS"},
"SB": {"default": "3POS"},
"SC": {"default": "3POS"},
"SD": {"default": "3POS"},
"SE": {"default": "3POS"},
"SF": {"default": "2POS"},
"SG": {"default": "3POS"},
"SH": {"default": "TOGGLE"},
"SI": {"default": "NONE"},
"SJ": {"default": "NONE"}
},
"x10express": {
"SA": {"default": "3POS"},
"SB": {"default": "3POS"},
"SC": {"default": "3POS"},
"SD": {"default": "3POS"},
"SE": {"default": "3POS"},
"SF": {"default": "2POS"},
"SG": {"default": "3POS"},
"SH": {"default": "TOGGLE"}
},
"zorro": {
# left side
"SB": {"default": "3POS", "display": [0, 0]},
"SA": {"default": "TOGGLE", "display": [0, 1]},
"SE": {"default": "2POS", "display": [0, 2]},
"SG": {"default": "TOGGLE", "display": [0, 3]},
# right side
"SC": {"default": "3POS", "display": [1, 0]},
"SD": {"default": "TOGGLE", "display": [1, 1]},
"SF": {"default": "2POS", "display": [1, 2]},
"SH": {"default": "TOGGLE", "display": [1, 3]},
},
"pocket": {
# left side
"SA": { "default": "2POS", "display": [ 0, 0 ] },
"SB": { "default": "3POS", "display": [ 0, 1 ] },
"SE": { "default": "TOGGLE", "display": [ 0, 2 ] },
# right side
"SD": { "default": "2POS", "display": [ 1, 0 ] },
"SC": { "default": "3POS", "display": [ 1, 1 ] },
},
}
def switch_cfg_by_target(target, name):
"""Retrieve default switches config.
Parameters
----------
target: str
Name of the target
name: str
Canonical switch name (Sx where 'x' is a capital letter)
Returns
-------
dict
a dictionary with one key for each pot or slider that mapped
to another dictionary with a "default" attribute containing
the default switches configuration. On 'stdlcd' targets, a
'display' 2 dimensional array defining the switch's position
on screen.
"""
sw = SWITCH_CONFIG.get(target)
if sw:
return sw.get(name)
return None