|
# -*- coding: utf-8 -*-
|
|
# Copyright 2022 Masen Furer <kf7hvm@0x26.net>
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
# Lanchonlh HG-UV98 driver written by
|
|
# Masen Furer <kf7hvm@0x26.net>
|
|
# With assistance from
|
|
# KG7KMV and Bartłomiej Zieliński
|
|
# Based on the implementation of Kenwood TK-8102
|
|
|
|
import logging
|
|
import struct
|
|
|
|
from chirp import chirp_common, directory, memmap, errors, util
|
|
from chirp import bitwise
|
|
from chirp.settings import RadioSettingGroup, RadioSetting
|
|
from chirp.settings import RadioSettingValueBoolean, RadioSettingValueList
|
|
from chirp.settings import RadioSettings
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
MEM_FORMAT = """
|
|
struct {
|
|
lbcd rx_freq[4];
|
|
lbcd tx_freq[4];
|
|
ul16 rx_tone;
|
|
ul16 tx_tone;
|
|
u8 unknown1:6,
|
|
wide:1,
|
|
highpower:1;
|
|
u8 unknown2:5,
|
|
bcl:1,
|
|
scan:1,
|
|
unknown3:1;
|
|
u8 unknown4[2];
|
|
} memory[130];
|
|
|
|
#seekto 0x0a00;
|
|
struct {
|
|
u8 abr; // 0x0a00
|
|
u8 save;
|
|
u8 ch_a_step;
|
|
u8 ch_b_step;
|
|
u8 vox_grd;
|
|
u8 ch_a_sql;
|
|
u8 ch_b_sql;
|
|
u8 roger;
|
|
u8 ch_a_v_m;
|
|
u8 ch_b_v_m;
|
|
u8 ch_a_ch_mdf;
|
|
u8 ch_b_ch_mdf;
|
|
u8 tdr;
|
|
u8 unknown5[3];
|
|
u8 unknown6[5]; // 0x0a10
|
|
u8 english;
|
|
u8 beep;
|
|
u8 voice;
|
|
u8 night_mode;
|
|
u8 abr_lv; // backlight level
|
|
u8 tot;
|
|
u8 toa;
|
|
u8 vox_dly;
|
|
u8 sc_rev;
|
|
u8 lockmode;
|
|
u8 autolock;
|
|
u8 unknown7; // 0x0a20
|
|
u8 pf1_short;
|
|
u8 pf1_long;
|
|
u8 pf2_short;
|
|
u8 pf2_long;
|
|
u8 top_short;
|
|
u8 top_long;
|
|
u8 rpt_rct;
|
|
u8 sc_qt;
|
|
u8 pri_ch;
|
|
u8 pri_scn;
|
|
u8 unknown8;
|
|
u8 aprs_rx_band;
|
|
u8 ch_a_mute;
|
|
u8 ch_b_mute;
|
|
u8 unknown9[7]; // 0x0a30
|
|
u8 tx_priority;
|
|
u8 aprs_rx_popup;
|
|
u8 aprs_rx_tone;
|
|
u8 aprs_tx_tone;
|
|
u8 unknown10;
|
|
u8 auto_lock_dly;
|
|
u8 menu_dly;
|
|
u8 beacon_exit_dly;
|
|
u8 unknown11;
|
|
u8 unknown12[2]; // 0x0a40
|
|
u8 ch_a_mem_ch;
|
|
u8 ch_b_mem_ch;
|
|
u8 unknown13[12];
|
|
} settings;
|
|
|
|
#seekto 0x1000;
|
|
struct {
|
|
char name[11];
|
|
u8 unknown[5];
|
|
} name[128];
|
|
|
|
struct {
|
|
char callsign[9];
|
|
u8 null;
|
|
} aprs;
|
|
|
|
#seekto 0x1f80;
|
|
struct {
|
|
ul32 unknown[8];
|
|
} unknown_settings;
|
|
|
|
"""
|
|
|
|
BOUNDS = [(136000000, 174000000), (400000000, 500000000)]
|
|
OFFSETS = [600000, 5000000]
|
|
MAX_CHANNELS = 128
|
|
MAX_NAME = 8
|
|
NAME_FIELD_SIZE = 11
|
|
CHUNK_SIZE = 64
|
|
MAX_ADDR = 0x2000
|
|
POWER_LEVELS = [chirp_common.PowerLevel("Low", watts=1),
|
|
chirp_common.PowerLevel("High", watts=5)]
|
|
MODES = ["FM", "NFM"]
|
|
SPECIAL_CHANNELS = ['VFO-A', 'VFO-B']
|
|
|
|
# Settings maps
|
|
ABR_LIST = [str(v) for v in range(0, 151, 5)]
|
|
STEP_LIST = ["5.0", "6.25", "10.0", "12.5", "25.0", "50.0", "100.0"]
|
|
VOX_LIST = ["OFF", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
|
|
SQL_LIST = [str(v) for v in range(0, 10)]
|
|
ROGER_LIST = ["OFF", "BEGIN", "END", "BOTH"]
|
|
MDF_LIST = ["NUM+FREQ", "NUMBER", "NAME"]
|
|
VM_LIST = ["VFO", "MEMORY"]
|
|
LANG_LIST = ["CHINESE", "ENGLISH"]
|
|
ABR_LV_LIST = [str(v) for v in range(1, 11)]
|
|
TOT_LIST = [str(v) for v in range(0, 601, 15)]
|
|
TOA_LIST = ["OFF"] + ["{} S".format(v) for v in range(1, 11)]
|
|
VOX_DLY_LIST = [str(v) for v in range(1, 11)]
|
|
SC_REV_LIST = ["TIME", "BUSY", "HOLD"]
|
|
LOCKMODE_LIST = ["KEY", "KEY+DIAL", "KEY+DIAL+PTT"]
|
|
AUTOLOCK_LIST = ["AUTO", "Manual"]
|
|
PF1_LIST = ["BACK LIGHT", "SCAN", "SQUELCH", "TORCH", "BAND A/B"]
|
|
PF2_LIST = ["BEACON", "LIST", "TORCH", "BACK LIGHT"]
|
|
TOP_LIST = ["ALERT", "REMOTE ALERT", "TORCH", "TXP", "CH MDF", "OFF_NET_KEY"]
|
|
SC_QT_LIST = ["Decode", "Encode", "Decode+Encode"]
|
|
APRS_RX_LIST = ["OFF", "BAND A", "BAND B"]
|
|
TX_PRIORITY_LIST = ["VOICE", "APRS"]
|
|
AUTOLOCK_DLY_LIST = ["{} S".format(v) for v in range(5, 31)]
|
|
BEACON_EXIT_DLY_LIST = MENU_DLY_LIST = AUTOLOCK_DLY_LIST
|
|
|
|
|
|
def make_frame(cmd, addr, length, data=b""):
|
|
if not isinstance(data, bytes):
|
|
data = data.decode("ascii")
|
|
return struct.pack(">BHB", ord(cmd), addr, length) + data
|
|
|
|
|
|
def send(radio, frame):
|
|
LOG.debug("%04i P>R: %s" % (len(frame), util.hexprint(frame)))
|
|
radio.pipe.write(frame)
|
|
|
|
|
|
def recv(radio, readdata=True):
|
|
hdr = radio.pipe.read(4)
|
|
cmd, addr, length = struct.unpack(">BHB", hdr)
|
|
if readdata:
|
|
data = radio.pipe.read(length)
|
|
LOG.debug(" P<R: %s" % util.hexprint(hdr + data))
|
|
if len(data) != length:
|
|
raise errors.RadioError("Radio sent %i bytes (expected %i)" % (
|
|
len(data), length))
|
|
else:
|
|
data = b""
|
|
radio.pipe.write(b"\x06")
|
|
ack = radio.pipe.read(1)
|
|
if ack != b"\x06":
|
|
raise errors.RadioError("Radio didn't ack our read ack")
|
|
return addr, bytes(data)
|
|
|
|
|
|
def do_ident(radio):
|
|
send(radio, b"NiNHSG0N")
|
|
ack = radio.pipe.read(1)
|
|
if ack != b"\x06":
|
|
raise errors.RadioError("Radio refused program mode: {}".format(ack))
|
|
radio.pipe.write(b"\x02")
|
|
ident = radio.pipe.read(8)
|
|
LOG.debug('ident string was %r' % ident)
|
|
if ident != radio.IDENT:
|
|
raise errors.RadioError(
|
|
"Incorrect model: %s, expected %r" % (
|
|
util.hexprint(ident), radio.IDENT))
|
|
LOG.info("Model: %s (%s)" % (radio.MODEL, util.hexprint(ident)))
|
|
radio.pipe.write(b"\x06")
|
|
ack = radio.pipe.read(1)
|
|
if ack != b"\x06":
|
|
raise errors.RadioError("Radio entered program mode, but didn't ack our ack")
|
|
|
|
|
|
def do_download(radio):
|
|
radio.pipe.parity = "E"
|
|
radio.pipe.timeout = 1
|
|
do_ident(radio)
|
|
|
|
data = bytes(b"")
|
|
for addr in range(0, MAX_ADDR, CHUNK_SIZE):
|
|
send(radio, make_frame(bytes(b"R"), addr, CHUNK_SIZE))
|
|
_addr, _data = recv(radio)
|
|
if _addr != addr:
|
|
raise errors.RadioError("Radio sent unexpected address")
|
|
data += _data
|
|
radio.pipe.write(b"\x06")
|
|
ack = radio.pipe.read(1)
|
|
if ack != b"\x06":
|
|
raise errors.RadioError("Radio refused block at %04x" % addr)
|
|
|
|
status = chirp_common.Status()
|
|
status.cur = addr
|
|
status.max = MAX_ADDR
|
|
status.msg = "Cloning from radio"
|
|
radio.status_fn(status)
|
|
|
|
radio.pipe.write(b"\x45")
|
|
return memmap.MemoryMapBytes(data)
|
|
|
|
|
|
def do_upload(radio):
|
|
radio.pipe.parity = "E"
|
|
radio.pipe.timeout = 1
|
|
do_ident(radio)
|
|
|
|
mmap = radio._mmap
|
|
for addr in range(0, MAX_ADDR, CHUNK_SIZE):
|
|
send(radio, make_frame(b"W", addr, CHUNK_SIZE, mmap[addr:addr + CHUNK_SIZE]))
|
|
ack = radio.pipe.read(1)
|
|
if ack != b"\x06":
|
|
raise errors.RadioError("Radio refused block at %04x" % addr)
|
|
radio.pipe.write(b"\x06")
|
|
ack = radio.pipe.read(1)
|
|
if ack != b"\x06":
|
|
raise errors.RadioError("Radio didn't ack our read ack")
|
|
|
|
status = chirp_common.Status()
|
|
status.cur = addr
|
|
status.max = MAX_ADDR
|
|
status.msg = "Cloning to radio"
|
|
radio.status_fn(status)
|
|
|
|
radio.pipe.write(b"\x45")
|
|
|
|
|
|
def offset_for(freq):
|
|
for bounds, offset in zip(BOUNDS, OFFSETS):
|
|
if bounds[0] <= freq <= bounds[1]:
|
|
return offset
|
|
return 0
|
|
|
|
|
|
class RadioSettingValueChannel(RadioSettingValueList):
|
|
"""A setting that points to a defined channel."""
|
|
def __init__(self, radio, current_raw):
|
|
current = int(current_raw)
|
|
current_mem = radio.get_memory(current)
|
|
lo, hi = radio.get_features().memory_bounds
|
|
options = [
|
|
self._format_memory(mem)
|
|
for mem in [radio.get_memory(n)
|
|
for n in range(lo, hi + 1)]]
|
|
RadioSettingValueList.__init__(self, options,
|
|
self._format_memory(current_mem))
|
|
|
|
@staticmethod
|
|
def _format_memory(m):
|
|
if m.empty:
|
|
return str(int(m.number))
|
|
return "%i %.4f %s" % (m.number, m.freq / 1e6, m.name)
|
|
|
|
def __int__(self):
|
|
return int(self.get_value().partition(" ")[0])
|
|
|
|
|
|
@directory.register
|
|
class LanchonlhHG_UV98(chirp_common.CloneModeRadio, chirp_common.ExperimentalRadio):
|
|
"""
|
|
Lanchonlh HG-UV98
|
|
|
|
Memory map decoding by KG7KMV
|
|
Chirp integration by KF7HVM
|
|
"""
|
|
VENDOR = "Lanchonlh"
|
|
MODEL = "HG-UV98"
|
|
IDENT = b"P3LL\x13\x10\x08\xF8"
|
|
BAUD_RATE = 9600
|
|
NEEDS_COMPAT_SERIAL = False
|
|
|
|
_upper = MAX_CHANNELS
|
|
|
|
@classmethod
|
|
def get_prompts(cls):
|
|
rp = chirp_common.RadioPrompts()
|
|
rp.experimental = (
|
|
"This Lanchonlh HG-UV98 driver is an alpha version. "
|
|
"Proceed with Caution and backup your data. "
|
|
"Always confirm the correctness of your settings with the "
|
|
"official programming tool.")
|
|
return rp
|
|
|
|
def get_features(self):
|
|
rf = chirp_common.RadioFeatures()
|
|
rf.has_settings = True
|
|
rf.has_cross = False
|
|
rf.has_bank = False
|
|
rf.has_tuning_step = False
|
|
rf.has_name = True
|
|
rf.has_rx_dtcs = True
|
|
rf.valid_characters = chirp_common.CHARSET_ALPHANUMERIC
|
|
rf.valid_tuning_steps = [5.0, 6.25, 10.0, 12.5, 20.0, 25.0, 50.0, 100.0]
|
|
rf.valid_tmodes = ['', 'Tone', 'TSQL', 'DTCS', 'Cross']
|
|
rf.valid_modes = MODES
|
|
rf.valid_cross_modes = [
|
|
"Tone->Tone",
|
|
"DTCS->",
|
|
"->DTCS",
|
|
"Tone->DTCS",
|
|
"DTCS->Tone",
|
|
"->Tone",
|
|
"DTCS->DTCS"]
|
|
rf.valid_power_levels = POWER_LEVELS
|
|
rf.valid_skips = ["", "S"]
|
|
rf.valid_bands = [(136000000, 174000000), (400000000, 500000000)]
|
|
rf.valid_name_length = 8
|
|
rf.valid_special_chans = SPECIAL_CHANNELS
|
|
rf.memory_bounds = (1, self._upper)
|
|
return rf
|
|
|
|
def sync_in(self):
|
|
try:
|
|
self._mmap = do_download(self)
|
|
except errors.RadioError:
|
|
self.pipe.write(b"\x45")
|
|
raise
|
|
except Exception as e:
|
|
raise errors.RadioError("Failed to download from radio: %s" % e)
|
|
self.process_mmap()
|
|
|
|
def process_mmap(self):
|
|
self._memobj = bitwise.parse(MEM_FORMAT, self._mmap)
|
|
|
|
def sync_out(self):
|
|
try:
|
|
do_upload(self)
|
|
except errors.RadioError:
|
|
self.pipe.write(b"\x45")
|
|
raise
|
|
except Exception as e:
|
|
raise errors.RadioError("Failed to upload to radio: %s" % e)
|
|
|
|
def get_raw_memory(self, number):
|
|
return repr(self._memobj.memory[number - 1])
|
|
|
|
def _get_tone(self, _mem, mem):
|
|
def _get_dcs(val):
|
|
code = int("%03o" % (val & 0x07FF))
|
|
pol = (val & 0x8000) and "R" or "N"
|
|
return code, pol
|
|
|
|
if _mem.tx_tone != 0xFFFF and _mem.tx_tone > 0x2800:
|
|
tcode, tpol = _get_dcs(_mem.tx_tone)
|
|
mem.dtcs = tcode
|
|
txmode = "DTCS"
|
|
elif _mem.tx_tone != 0xFFFF:
|
|
mem.rtone = _mem.tx_tone / 10.0
|
|
txmode = "Tone"
|
|
else:
|
|
txmode = ""
|
|
|
|
if _mem.rx_tone != 0xFFFF and _mem.rx_tone > 0x2800:
|
|
rcode, rpol = _get_dcs(_mem.rx_tone)
|
|
mem.rx_dtcs = rcode
|
|
rxmode = "DTCS"
|
|
elif _mem.rx_tone != 0xFFFF:
|
|
mem.ctone = _mem.rx_tone / 10.0
|
|
rxmode = "Tone"
|
|
else:
|
|
rxmode = ""
|
|
|
|
if txmode == "Tone" and not rxmode:
|
|
mem.tmode = "Tone"
|
|
elif txmode == rxmode and txmode == "Tone" and mem.rtone == mem.ctone:
|
|
mem.tmode = "TSQL"
|
|
elif txmode == rxmode and txmode == "DTCS" and mem.dtcs == mem.rx_dtcs:
|
|
mem.tmode = "DTCS"
|
|
elif rxmode or txmode:
|
|
mem.tmode = "Cross"
|
|
mem.cross_mode = "%s->%s" % (txmode, rxmode)
|
|
|
|
if mem.tmode == "DTCS":
|
|
mem.dtcs_polarity = "%s%s" % (tpol, rpol)
|
|
|
|
def get_memory(self, number):
|
|
|
|
mem = chirp_common.Memory()
|
|
|
|
if isinstance(number, str):
|
|
mem.number = MAX_CHANNELS + SPECIAL_CHANNELS.index(number) + 1
|
|
mem.extd_number = number
|
|
elif number > MAX_CHANNELS:
|
|
mem.number = number
|
|
else:
|
|
mem.number = number
|
|
_name = self._memobj.name[mem.number - 1]
|
|
|
|
_mem = self._memobj.memory[mem.number - 1]
|
|
|
|
if mem.number > MAX_CHANNELS:
|
|
mem.immutable = ['name']
|
|
else:
|
|
mem.name, _, _ = _name.name.get_raw().partition(b"\xFF")
|
|
mem.name = mem.name.decode('ascii').rstrip()
|
|
|
|
if _mem.get_raw()[:4] == b"\xFF\xFF\xFF\xFF":
|
|
mem.empty = True
|
|
return mem
|
|
|
|
mem.freq = int(_mem.rx_freq) * 10
|
|
offset = (int(_mem.tx_freq) * 10) - mem.freq
|
|
if offset < 0:
|
|
mem.offset = abs(offset)
|
|
mem.duplex = "-"
|
|
elif offset > 0:
|
|
mem.offset = offset
|
|
mem.duplex = "+"
|
|
else:
|
|
mem.offset = 0
|
|
|
|
self._get_tone(_mem, mem)
|
|
mem.power = POWER_LEVELS[_mem.highpower]
|
|
mem.mode = MODES[_mem.wide]
|
|
mem.skip = not _mem.scan and "S" or ""
|
|
|
|
mem.extra = RadioSettingGroup("all", "All Settings")
|
|
|
|
bcl = RadioSetting("bcl", "Busy Channel Lockout",
|
|
RadioSettingValueBoolean(bool(_mem.bcl)))
|
|
mem.extra.append(bcl)
|
|
|
|
return mem
|
|
|
|
def _set_tone(self, mem, _mem):
|
|
def _set_dcs(code, pol):
|
|
val = int("%i" % code, 8) + 0x2800
|
|
if pol == "R":
|
|
val += 0xA000
|
|
return val
|
|
|
|
rx_mode = tx_mode = None
|
|
rx_tone = tx_tone = 0xFFFF
|
|
|
|
if mem.tmode == "Tone":
|
|
tx_mode = "Tone"
|
|
rx_mode = None
|
|
tx_tone = int(mem.rtone * 10)
|
|
elif mem.tmode == "TSQL":
|
|
rx_mode = tx_mode = "Tone"
|
|
rx_tone = tx_tone = int(mem.ctone * 10)
|
|
elif mem.tmode == "DTCS":
|
|
tx_mode = rx_mode = "DTCS"
|
|
tx_tone = _set_dcs(mem.dtcs, mem.dtcs_polarity[0])
|
|
rx_tone = _set_dcs(mem.dtcs, mem.dtcs_polarity[1])
|
|
elif mem.tmode == "Cross":
|
|
tx_mode, rx_mode = mem.cross_mode.split("->")
|
|
if tx_mode == "DTCS":
|
|
tx_tone = _set_dcs(mem.dtcs, mem.dtcs_polarity[0])
|
|
elif tx_mode == "Tone":
|
|
tx_tone = int(mem.rtone * 10)
|
|
if rx_mode == "DTCS":
|
|
rx_tone = _set_dcs(mem.rx_dtcs, mem.dtcs_polarity[1])
|
|
elif rx_mode == "Tone":
|
|
rx_tone = int(mem.ctone * 10)
|
|
|
|
_mem.rx_tone = rx_tone
|
|
_mem.tx_tone = tx_tone
|
|
|
|
LOG.debug("Set TX %s (%i) RX %s (%i)" %
|
|
(tx_mode, _mem.tx_tone, rx_mode, _mem.rx_tone))
|
|
|
|
def set_memory(self, mem):
|
|
_mem = self._memobj.memory[mem.number - 1]
|
|
|
|
if mem.empty:
|
|
_mem.set_raw(b"\xFF" * 16)
|
|
return
|
|
|
|
if mem.number < 129:
|
|
_name = self._memobj.name[mem.number - 1]
|
|
_namelength = self.get_features().valid_name_length
|
|
for i in range(NAME_FIELD_SIZE):
|
|
try:
|
|
_name.name[i] = mem.name[i]
|
|
except IndexError:
|
|
_name.name[i] = "\xFF"
|
|
|
|
# clear reserved fields
|
|
_mem.unknown1 = 0xFF
|
|
_mem.unknown2 = 0xFF
|
|
_mem.unknown3 = 0xFF
|
|
_mem.unknown4 = (0xFF, 0xFF)
|
|
_mem.rx_freq = mem.freq / 10
|
|
mem_offset = mem.offset or offset_for(mem.freq)
|
|
if mem.duplex == "+":
|
|
_mem.tx_freq = (mem.freq + mem_offset) / 10
|
|
elif mem.duplex == "-":
|
|
_mem.tx_freq = (mem.freq - mem_offset) / 10
|
|
else:
|
|
_mem.tx_freq = mem.freq / 10
|
|
|
|
self._set_tone(mem, _mem)
|
|
|
|
_mem.highpower = mem.power == POWER_LEVELS[1]
|
|
_mem.wide = mem.mode == "NFM"
|
|
_mem.scan = mem.skip != "S"
|
|
|
|
for setting in mem.extra:
|
|
setattr(_mem, setting.get_name(), setting.value)
|
|
|
|
def get_settings(self):
|
|
_mem = self._memobj
|
|
_settings = _mem.settings
|
|
basic = RadioSettingGroup("basic", "Basic")
|
|
display = RadioSettingGroup("display", "Display")
|
|
scan = RadioSettingGroup("scan", "Scan")
|
|
buttons = RadioSettingGroup("buttons", "Buttons")
|
|
vfo = RadioSettingGroup("vfo", "VFO")
|
|
advanced = RadioSettingGroup("advanced", "Advanced")
|
|
aprs = RadioSettingGroup("aprs", "APRS")
|
|
top = RadioSettings(basic, display, scan, buttons, vfo, advanced, aprs)
|
|
|
|
basic.append(
|
|
RadioSetting("save", "Power Save",
|
|
RadioSettingValueBoolean(_settings.save)))
|
|
basic.append(
|
|
RadioSetting("roger", "Roger Beep",
|
|
RadioSettingValueList(ROGER_LIST,
|
|
ROGER_LIST[_settings.roger])))
|
|
basic.append(
|
|
RadioSetting("beep", "System Beep",
|
|
RadioSettingValueBoolean(_settings.beep)))
|
|
basic.append(
|
|
RadioSetting("tot", "Timeout Timer (sec)",
|
|
RadioSettingValueList(TOT_LIST,
|
|
TOT_LIST[_settings.tot])))
|
|
basic.append(
|
|
RadioSetting("toa", "Timeout Timer Alarm",
|
|
RadioSettingValueList(TOA_LIST,
|
|
TOA_LIST[_settings.toa])))
|
|
basic.append(
|
|
RadioSetting("lockmode", "Lock Mode",
|
|
RadioSettingValueList(
|
|
LOCKMODE_LIST,
|
|
LOCKMODE_LIST[_settings.lockmode])))
|
|
basic.append(
|
|
RadioSetting("autolock", "Auto Lock",
|
|
RadioSettingValueList(
|
|
AUTOLOCK_LIST,
|
|
AUTOLOCK_LIST[_settings.autolock])))
|
|
basic.append(
|
|
RadioSetting("auto_lock_dly", "Auto Lock Delay",
|
|
RadioSettingValueList(
|
|
AUTOLOCK_DLY_LIST,
|
|
AUTOLOCK_DLY_LIST[_settings.auto_lock_dly])))
|
|
display.append(
|
|
RadioSetting("abr", "Screen Save",
|
|
RadioSettingValueList(ABR_LIST,
|
|
ABR_LIST[_settings.abr])))
|
|
display.append(
|
|
RadioSetting("abr_lv", "Back Light Brightness",
|
|
RadioSettingValueList(ABR_LV_LIST,
|
|
ABR_LV_LIST[_settings.abr_lv])))
|
|
display.append(
|
|
RadioSetting("night_mode", "Night Mode (Light on Dark)",
|
|
RadioSettingValueBoolean(_settings.night_mode)))
|
|
display.append(
|
|
RadioSetting("menu_dly", "Menu Delay",
|
|
RadioSettingValueList(
|
|
MENU_DLY_LIST,
|
|
MENU_DLY_LIST[_settings.menu_dly])))
|
|
display.append(
|
|
RadioSetting("english", "Language",
|
|
RadioSettingValueList(LANG_LIST,
|
|
LANG_LIST[_settings.english])))
|
|
scan.append(
|
|
RadioSetting("pri_scn", "Priority Scan",
|
|
RadioSettingValueBoolean(_settings.pri_scn)))
|
|
scan.append(
|
|
RadioSetting("pri_ch", "Priority Channel",
|
|
RadioSettingValueChannel(self, _settings.pri_ch)))
|
|
scan.append(
|
|
RadioSetting("sc_rev", "Scan Resume",
|
|
RadioSettingValueList(SC_REV_LIST,
|
|
SC_REV_LIST[_settings.sc_rev])))
|
|
scan.append(
|
|
RadioSetting("sc_qt", "Code Save",
|
|
RadioSettingValueList(SC_QT_LIST,
|
|
SC_QT_LIST[_settings.sc_qt])))
|
|
buttons.append(
|
|
RadioSetting("pf1_short", "PF1 (Side, Upper) Button Short Press",
|
|
RadioSettingValueList(PF1_LIST,
|
|
PF1_LIST[_settings.pf1_short])))
|
|
buttons.append(
|
|
RadioSetting("pf1_long", "PF1 (Side, Upper) Button Long Press",
|
|
RadioSettingValueList(PF1_LIST,
|
|
PF1_LIST[_settings.pf1_long])))
|
|
buttons.append(
|
|
RadioSetting("pf2_short", "PF2 (Side, Lower) Button Short Press",
|
|
RadioSettingValueList(PF2_LIST,
|
|
PF2_LIST[_settings.pf2_short])))
|
|
buttons.append(
|
|
RadioSetting("pf2_long", "PF2 (Side, Lower) Button Long Press",
|
|
RadioSettingValueList(PF2_LIST,
|
|
PF2_LIST[_settings.pf2_long])))
|
|
buttons.append(
|
|
RadioSetting("top_short", "Top Button Short Press",
|
|
RadioSettingValueList(TOP_LIST,
|
|
TOP_LIST[_settings.top_short])))
|
|
buttons.append(
|
|
RadioSetting("top_long", "Top Button Long Press",
|
|
RadioSettingValueList(TOP_LIST,
|
|
TOP_LIST[_settings.top_long])))
|
|
vfo.append(
|
|
RadioSetting("tdr", "VFO B Enabled",
|
|
RadioSettingValueBoolean(_settings.tdr)))
|
|
vfo.append(
|
|
RadioSetting("ch_a_step", "VFO Frequency Step (A)",
|
|
RadioSettingValueList(
|
|
STEP_LIST,
|
|
STEP_LIST[_settings.ch_a_step])))
|
|
vfo.append(
|
|
RadioSetting("ch_b_step", "VFO Frequency Step (B)",
|
|
RadioSettingValueList(
|
|
STEP_LIST,
|
|
STEP_LIST[_settings.ch_b_step])))
|
|
vfo.append(
|
|
RadioSetting("ch_a_sql", "Squelch (A)",
|
|
RadioSettingValueList(SQL_LIST,
|
|
SQL_LIST[_settings.ch_a_sql])))
|
|
vfo.append(
|
|
RadioSetting("ch_b_sql", "Squelch (B)",
|
|
RadioSettingValueList(SQL_LIST,
|
|
SQL_LIST[_settings.ch_b_sql])))
|
|
vfo.append(
|
|
RadioSetting("ch_a_mem_ch", "Memory Channel (A)",
|
|
RadioSettingValueChannel(self,
|
|
_settings.ch_a_mem_ch)))
|
|
vfo.append(
|
|
RadioSetting("ch_b_mem_ch", "Memory Channel (B)",
|
|
RadioSettingValueChannel(self,
|
|
_settings.ch_b_mem_ch)))
|
|
vfo.append(
|
|
RadioSetting("ch_a_ch_mdf", "Memory Display Format (A)",
|
|
RadioSettingValueList(
|
|
MDF_LIST,
|
|
MDF_LIST[_settings.ch_a_ch_mdf])))
|
|
vfo.append(
|
|
RadioSetting("ch_b_ch_mdf", "Memory Display Format (B)",
|
|
RadioSettingValueList(
|
|
MDF_LIST,
|
|
MDF_LIST[_settings.ch_b_ch_mdf])))
|
|
vfo.append(
|
|
RadioSetting("ch_a_v_m", "VFO/MEM (A)",
|
|
RadioSettingValueList(
|
|
VM_LIST, VM_LIST[_settings.ch_a_v_m])))
|
|
vfo.append(
|
|
RadioSetting("ch_b_v_m", "VFO/MEM (B)",
|
|
RadioSettingValueList(
|
|
VM_LIST, VM_LIST[_settings.ch_b_v_m])))
|
|
advanced.append(
|
|
RadioSetting("vox_grd", "VOX Sensitivity",
|
|
RadioSettingValueList(
|
|
VOX_LIST, VOX_LIST[_settings.vox_grd])))
|
|
advanced.append(
|
|
RadioSetting("vox_dly", "VOX Delay",
|
|
RadioSettingValueList(
|
|
VOX_DLY_LIST, VOX_DLY_LIST[_settings.vox_dly])))
|
|
advanced.append(
|
|
RadioSetting("voice", "Voice Assist",
|
|
RadioSettingValueBoolean(_settings.voice)))
|
|
advanced.append(
|
|
RadioSetting("rpt_rct", "RPT Roger",
|
|
RadioSettingValueBoolean(_settings.rpt_rct)))
|
|
aprs.append(
|
|
RadioSetting("aprs_rx_band", "RX Band",
|
|
RadioSettingValueList(
|
|
APRS_RX_LIST,
|
|
APRS_RX_LIST[_settings.aprs_rx_band])))
|
|
aprs.append(
|
|
RadioSetting("ch_a_mute", "Band A Mute",
|
|
RadioSettingValueBoolean(_settings.ch_a_mute)))
|
|
aprs.append(
|
|
RadioSetting("ch_b_mute", "Band B Mute",
|
|
RadioSettingValueBoolean(_settings.ch_b_mute)))
|
|
aprs.append(
|
|
RadioSetting("tx_priority", "TX Priority",
|
|
RadioSettingValueList(
|
|
TX_PRIORITY_LIST,
|
|
TX_PRIORITY_LIST[_settings.tx_priority])))
|
|
aprs.append(
|
|
RadioSetting("aprs_rx_popup", "APRS Popup",
|
|
RadioSettingValueBoolean(_settings.aprs_rx_popup)))
|
|
aprs.append(
|
|
RadioSetting("aprs_rx_tone", "RX Tone",
|
|
RadioSettingValueBoolean(_settings.aprs_rx_tone)))
|
|
aprs.append(
|
|
RadioSetting("aprs_tx_tone", "TX Tone",
|
|
RadioSettingValueBoolean(_settings.aprs_tx_tone)))
|
|
aprs.append(
|
|
RadioSetting("beacon_exit_dly", "Beacon Message Delay",
|
|
RadioSettingValueList(
|
|
BEACON_EXIT_DLY_LIST,
|
|
BEACON_EXIT_DLY_LIST[_settings.beacon_exit_dly])))
|
|
|
|
return top
|
|
|
|
def set_settings(self, settings):
|
|
_mem = self._memobj
|
|
_settings = _mem.settings
|
|
|
|
for element in settings:
|
|
if not isinstance(element, RadioSetting):
|
|
self.set_settings(element)
|
|
continue
|
|
name = element.get_name()
|
|
value = element.value
|
|
|
|
if hasattr(_settings, name):
|
|
setattr(_settings, name, value)
|