chirp/uvk5_brnpocsag.py, derived from the egzumer UV-K5 driver (GPL): 171 channels and 14 VFOs in the 32 byte record layout, 7 power levels, 4 bandwidths incl. FSKQ, all demodulations, 16 bit scrambler in Hz, compander and scan lists 1-3; all settings incl. FSKMod / FSKSRC / PocMon, F4HWN settings at 0x1FF0 (written after the main upload), FM presets and the message store (read, edit, delete all). Only accepts "BRN-POCSAG". Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
804 lines
29 KiB
Python
804 lines
29 KiB
Python
# Quansheng UV-K5 driver for the BRN-POCSAG firmware
|
|
#
|
|
# Based on the UV-K5 egzumer driver
|
|
# (c) 2023 Jacek Lipkowski <sq5bpf@lipkowski.org>, adapted by EGZUMER, JOC2
|
|
# and template.py Copyright 2012 Dan Smith <dsmith@danplanet.com>
|
|
#
|
|
# 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/>.
|
|
#
|
|
# The EEPROM layout is defined in settings.h / app/messages.h of the
|
|
# firmware. Keep this file in sync with it:
|
|
# 0x0000 channels 1..114, 32 bytes each (name and 16 bit scrambler inside)
|
|
# 0x0E40 settings
|
|
# 0x0F50 channel attributes [207]
|
|
# 0x1020 VFOs (7 bands x A/B), 32 bytes each
|
|
# 0x11E0 channels 115..171
|
|
# 0x1900 message counters, 0x1908 26 messages x 48 bytes
|
|
# 0x1E00 calibration (only written with "upload calibration")
|
|
# 0x1FF0 F4HWN settings (written after every upload)
|
|
|
|
import logging
|
|
|
|
from chirp import chirp_common, directory, bitwise
|
|
from chirp.drivers import uvk5
|
|
from chirp.settings import RadioSetting, RadioSettingGroup, \
|
|
RadioSettingValueBoolean, RadioSettingValueList, \
|
|
RadioSettingValueInteger, RadioSettingValueString, \
|
|
RadioSettings
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
CHANNELS = 171
|
|
CHANNELS_A = 114 # channels in the first area (0x0000 .. 0x0E3F)
|
|
MESSAGES = 26
|
|
MESSAGE_TEXT = 40
|
|
SETTINGS_F4HWN = 0x1FF0 # 16 bytes, inside the calibration area
|
|
|
|
MEM_FORMAT = """
|
|
struct chan {
|
|
ul32 freq;
|
|
ul32 offset;
|
|
u8 rxcode;
|
|
u8 txcode;
|
|
u8 txcodeflag:4,
|
|
rxcodeflag:4;
|
|
u8 modulation:4,
|
|
shift:4;
|
|
u8 __unused1:1,
|
|
bclo:1,
|
|
txpower:3,
|
|
bandwidth:2,
|
|
freq_reverse:1;
|
|
u8 __unused2:4,
|
|
dtmf_pttid:3,
|
|
__unused3:1;
|
|
u8 step;
|
|
u8 __unused4;
|
|
char name[10];
|
|
ul16 scrambler;
|
|
u8 __unused5[4];
|
|
};
|
|
|
|
#seekto 0x0000;
|
|
struct chan channel_a[114];
|
|
|
|
#seekto 0x0E40;
|
|
ul16 fmfreq[20];
|
|
|
|
#seekto 0x0E70;
|
|
u8 call_channel;
|
|
u8 squelch;
|
|
u8 max_talk_time;
|
|
u8 noaa_autoscan;
|
|
u8 key_lock;
|
|
u8 vox_switch;
|
|
u8 vox_level;
|
|
u8 mic_gain;
|
|
u8 backlight_min:4,
|
|
backlight_max:4;
|
|
u8 channel_display_mode;
|
|
u8 crossband;
|
|
u8 battery_save;
|
|
u8 dual_watch;
|
|
u8 backlight_time;
|
|
u8 ste;
|
|
u8 __unused6:1,
|
|
current_list:3,
|
|
current_state:3,
|
|
vfo_open:1;
|
|
|
|
#seekto 0x0E80;
|
|
u8 ScreenChannel_A;
|
|
u8 MrChannel_A;
|
|
u8 FreqChannel_A;
|
|
u8 ScreenChannel_B;
|
|
u8 MrChannel_B;
|
|
u8 FreqChannel_B;
|
|
u8 NoaaChannel_A;
|
|
u8 NoaaChannel_B;
|
|
|
|
ul16 fm_selfreq;
|
|
u8 fm_selchn;
|
|
u8 __unused7:5,
|
|
fm_band:2,
|
|
fm_ismrmode:1;
|
|
|
|
#seekto 0x0E90;
|
|
u8 keyM_longpress_action:7,
|
|
button_beep:1;
|
|
u8 key1_shortpress_action;
|
|
u8 key1_longpress_action;
|
|
u8 key2_shortpress_action;
|
|
u8 key2_longpress_action;
|
|
u8 scan_resume_mode;
|
|
u8 auto_keypad_lock;
|
|
u8 fsk_mode;
|
|
|
|
#seekto 0x0EA8;
|
|
u8 alarm_mode;
|
|
u8 roger_beep;
|
|
u8 rp_ste;
|
|
u8 TX_VFO;
|
|
u8 battery_type;
|
|
|
|
#seekto 0x0ED0;
|
|
u8 dtmf_side_tone;
|
|
u8 __unused8[4];
|
|
u8 dtmf_preload_time;
|
|
|
|
#seekto 0x0EF8;
|
|
char dtmf_up_code[16];
|
|
char dtmf_down_code[16];
|
|
|
|
#seekto 0x0F18;
|
|
u8 slDef;
|
|
u8 sl_enabled;
|
|
u8 sl1PriorCh1;
|
|
u8 sl1PriorCh2;
|
|
u8 sl2PriorCh1;
|
|
u8 sl2PriorCh2;
|
|
u8 sl3PriorCh1;
|
|
u8 sl3PriorCh2;
|
|
|
|
ul32 fsk_src;
|
|
u8 __unused9:3,
|
|
fm_deemphasis:2,
|
|
fm_blend:2,
|
|
fm_agc:1;
|
|
u8 pocsag_monitor;
|
|
|
|
#seekto 0x0F40;
|
|
u8 int_flock;
|
|
u8 __unused10[6];
|
|
u8 backlight_on_TX_RX:2,
|
|
__unused11:1,
|
|
mic_bar:1,
|
|
battery_text:2,
|
|
live_DTMF_decoder:1,
|
|
__unused12:1;
|
|
|
|
#seekto 0x0F50;
|
|
struct {
|
|
u8 scanlist3:1,
|
|
scanlist2:1,
|
|
scanlist1:1,
|
|
compander:2,
|
|
band:3;
|
|
} channel_attributes[207];
|
|
|
|
#seekto 0x1020;
|
|
struct chan vfo[14];
|
|
|
|
#seekto 0x11E0;
|
|
struct chan channel_b[57];
|
|
|
|
#seekto 0x1900;
|
|
u8 msg_seq;
|
|
u8 msg_latest;
|
|
u8 __unused13[6];
|
|
struct {
|
|
ul32 src;
|
|
u8 seq;
|
|
u8 ttl;
|
|
u8 flags;
|
|
char text[41];
|
|
} message[26];
|
|
|
|
#seekto 0x1F8E;
|
|
u8 volume_gain;
|
|
|
|
#seekto 0x1FF4;
|
|
u8 set_off:7,
|
|
set_tmr:1;
|
|
u8 __unused14:3,
|
|
set_inv:1,
|
|
__unused15:4;
|
|
u8 __unused16;
|
|
u8 __unused17:4,
|
|
set_ptt:4;
|
|
"""
|
|
|
|
POWER_LEVELS = [chirp_common.PowerLevel("Low1", watts=0.02),
|
|
chirp_common.PowerLevel("Low2", watts=0.125),
|
|
chirp_common.PowerLevel("Low3", watts=0.25),
|
|
chirp_common.PowerLevel("Low4", watts=0.5),
|
|
chirp_common.PowerLevel("Low5", watts=1.0),
|
|
chirp_common.PowerLevel("Mid", watts=2.0),
|
|
chirp_common.PowerLevel("High", watts=5.0)]
|
|
|
|
STEPS = [2.5, 5, 6.25, 10, 12.5, 25, 8.33, 0.01, 0.05, 0.1, 0.25, 0.5, 1,
|
|
1.25, 9, 15, 20, 30, 50, 100, 125, 200, 250, 500]
|
|
|
|
# frequencyBandTable with ENABLE_WIDE_RX, lower edges in Hz
|
|
BAND_LOWER = [18000000, 108000000, 137000000, 174000000, 350000000,
|
|
400000000, 470000000]
|
|
BAND_UPPER = 1300000000
|
|
BAND_NAMES = ["18M-108M", "108M-137M", "137M-174M", "174M-350M",
|
|
"350M-400M", "400M-470M", "470M-1300M"]
|
|
|
|
DEMODULATIONS = ["FM", "AM", "USB", "BYP", "RAW", "ALM", "BEE", "CTC",
|
|
"FSA", "UN4", "UN5", "UN6", "UN7", "UN8", "UN9"]
|
|
BANDWIDTHS = ["Wide", "Narrow", "Narrower", "FSKQ (FSK width)"]
|
|
COMPANDER_LIST = ["Off", "TX", "RX", "TX/RX"]
|
|
PTTID_LIST = ["Off", "Up code", "Down code", "Up+Down code",
|
|
"Apollo Quindar"]
|
|
|
|
FSK_MODES = ["FSK 450", "FSK 700", "FSK 1200", "FSK 2400", "AFSK 1200",
|
|
"AFSK 2400", "NOAA SAME", "POCSAG 1200", "POCSAG 512",
|
|
"POCSAG 2400"]
|
|
POCSAG_MODES = (7, 8, 9)
|
|
POCSAG_MAX_RIC = 2097151
|
|
POCSAG_MONITOR_ON = 0x5A
|
|
MESSAGE_FLAG_POCSAG = 0x20
|
|
|
|
# ACTION_OPT_* values of the actions this build offers
|
|
KEY_ACTIONS = [("None", 0), ("Flashlight", 1), ("TX power", 2),
|
|
("Monitor", 3), ("Scan", 4), ("FM radio", 7),
|
|
("Keypad lock", 9), ("Switch VFO A/B", 10),
|
|
("VFO / memory", 11), ("Switch demodulation", 12),
|
|
("RX mode", 14), ("PTT mode", 15), ("Wide / narrow", 16),
|
|
("Mute", 18)]
|
|
|
|
RXMODE_LIST = ["Main only", "Dual RX, respond", "Crossband",
|
|
"Dual RX, TX on main"]
|
|
CHANNELDISP_LIST = ["Frequency", "Channel number", "Name", "Name + Frequency"]
|
|
BATSAVE_LIST = ["Off", "1:1", "1:2", "1:3", "1:4", "1:5"]
|
|
BATTYPE_LIST = ["1600 mAh", "2200 mAh", "3500 mAh"]
|
|
BAT_TXT_LIST = ["None", "Voltage", "Percentage"]
|
|
BACKLIGHT_TX_RX_LIST = ["Off", "TX", "RX", "TX/RX"]
|
|
ROGER_LIST = ["Off", "Roger beep", "MDC data burst"]
|
|
RP_STE_LIST = ["Off"] + ["%d ms" % (i * 100) for i in range(1, 11)]
|
|
FLOCK_LIST = ["Default (137-174, 400-470)", "Disable all TX",
|
|
"Unlock all TX"]
|
|
SLIST_LIST = ["No list", "List 1", "List 2", "List 3", "Lists 1+2+3", "All"]
|
|
MIC_GAIN_LIST = ["+1.1dB", "+4.0dB", "+8.0dB", "+12.0dB", "+15.1dB"]
|
|
SET_PTT_LIST = ["Hold", "Toggle"]
|
|
FM_BANDS = ["76-108 MHz", "65-76 MHz", "76-90 MHz", "64-76 MHz"]
|
|
FM_BLEND = ["0", "1", "2", "3"]
|
|
FM_DEEMPHASIS = ["0", "1", "2", "3"]
|
|
DTMF_CHARS = "0123456789ABCDabcd#* "
|
|
|
|
|
|
def _minsec(seconds):
|
|
return "%d:%02d" % (seconds // 60, seconds % 60)
|
|
|
|
|
|
# menu value <-> text, same formulas as the firmware menu
|
|
TOT_VALUES = list(range(5, 180))
|
|
TOT_LIST = [_minsec((v + 1) * 5) for v in TOT_VALUES]
|
|
KEYLOCK_LIST = ["Off"] + [_minsec(v * 15) for v in range(1, 41)]
|
|
BACKLIGHT_LIST = ["Off"] + [_minsec(v * 5) for v in range(1, 61)] + ["On"]
|
|
SCANREV_LIST = (["Stop"] +
|
|
["Carrier %d.%02ds" % (v * 250 // 1000, v * 250 % 1000 // 10)
|
|
for v in range(1, 81)] +
|
|
["Timeout " + _minsec((v - 80) * 5) for v in range(81, 105)])
|
|
SET_OFF_LIST = ["Off"] + ["%dh:%02dm" % (v // 60, v % 60)
|
|
for v in range(1, 121)]
|
|
|
|
|
|
def scr_to_hz(raw):
|
|
"""BK4819 scrambler register value -> Hz (inverse_scale_freq)"""
|
|
return 0 if raw in (0, 0xFFFF) else ((raw << 17) - (1 << 16)) // 1353245
|
|
|
|
|
|
def hz_to_scr(hz):
|
|
"""Hz -> BK4819 scrambler register value (scale_freq)"""
|
|
return 0 if hz <= 0 else min(0xFFFF, (hz * 1353245 + (1 << 16)) >> 17)
|
|
|
|
|
|
def find_band(hz):
|
|
"""FREQUENCY_GetBand(): highest band whose lower edge is <= hz"""
|
|
for band in range(len(BAND_LOWER) - 1, -1, -1):
|
|
if hz >= BAND_LOWER[band]:
|
|
return band
|
|
return 0
|
|
|
|
|
|
def list_index(value, lst, default=0):
|
|
return value if 0 <= value < len(lst) else default
|
|
|
|
|
|
@directory.register
|
|
@directory.detected_by(uvk5.UVK5Radio)
|
|
class UVK5RadioBrnPocsag(uvk5.UVK5RadioBase):
|
|
"""Quansheng UV-K5 (BRN-POCSAG)"""
|
|
VENDOR = "Quansheng"
|
|
MODEL = "UV-K5"
|
|
VARIANT = "BRN-POCSAG"
|
|
BAUD_RATE = 38400
|
|
NEEDS_COMPAT_SERIAL = False
|
|
_cal_start = 0x1E00
|
|
prog_size = 0x1E00 # channels, settings and the message store
|
|
_steps = STEPS
|
|
_pttid_list = PTTID_LIST
|
|
|
|
@classmethod
|
|
def k5_approve_firmware(cls, firmware):
|
|
return firmware.startswith("BRN-POCSAG")
|
|
|
|
# ---------------------------------------------------------- upload
|
|
|
|
def _write_mem_block(self, serport, data, offset):
|
|
result = super()._write_mem_block(serport, data, offset)
|
|
# The F4HWN settings live in the calibration area, which a normal
|
|
# upload skips. Write that one block (no calibration in it) last.
|
|
if not self._upload_calibration and \
|
|
offset + len(data) >= self.prog_size:
|
|
block = self.get_mmap()[SETTINGS_F4HWN:SETTINGS_F4HWN + 16]
|
|
super()._write_mem_block(serport, block, SETTINGS_F4HWN)
|
|
return result
|
|
|
|
# ---------------------------------------------------------- memories
|
|
|
|
def _vfo_names(self):
|
|
names = []
|
|
for band, name in enumerate(BAND_NAMES):
|
|
names.append("F%d(%s)A" % (band + 1, name))
|
|
names.append("F%d(%s)B" % (band + 1, name))
|
|
return names
|
|
|
|
def get_features(self):
|
|
rf = super().get_features()
|
|
rf.memory_bounds = (1, CHANNELS)
|
|
rf.valid_special_chans = self._vfo_names()
|
|
rf.valid_modes = ["FM", "NFM", "AM", "NAM", "USB"]
|
|
rf.valid_power_levels = POWER_LEVELS
|
|
rf.valid_tuning_steps = list(STEPS)
|
|
rf.valid_bands = [(BAND_LOWER[0], BAND_UPPER)]
|
|
rf.valid_name_length = 10
|
|
return rf
|
|
|
|
def process_mmap(self):
|
|
self._check_firmware_at_load()
|
|
self._memobj = bitwise.parse(MEM_FORMAT, self._mmap)
|
|
|
|
def _find_band(self, hz):
|
|
return find_band(hz) if BAND_LOWER[0] <= hz <= BAND_UPPER else False
|
|
|
|
def _slot(self, number):
|
|
"""number (1-based, or a VFO name) -> (record, attributes or None,
|
|
is_vfo, chirp number)"""
|
|
names = self._vfo_names()
|
|
if isinstance(number, str):
|
|
idx = names.index(number)
|
|
return self._memobj.vfo[idx], None, True, CHANNELS + 1 + idx
|
|
if number > CHANNELS:
|
|
idx = number - CHANNELS - 1
|
|
return self._memobj.vfo[idx], None, True, number
|
|
index = number - 1
|
|
if index < CHANNELS_A:
|
|
rec = self._memobj.channel_a[index]
|
|
else:
|
|
rec = self._memobj.channel_b[index - CHANNELS_A]
|
|
return rec, self._memobj.channel_attributes[index], False, number
|
|
|
|
def get_raw_memory(self, number):
|
|
rec, attr, _, _ = self._slot(number)
|
|
return repr(rec) + ("\n" + repr(attr) if attr is not None else "")
|
|
|
|
def get_memory(self, number):
|
|
_mem, _attr, is_vfo, chirp_number = self._slot(number)
|
|
mem = chirp_common.Memory()
|
|
mem.number = chirp_number
|
|
if isinstance(number, str):
|
|
mem.extd_number = number
|
|
elif is_vfo:
|
|
mem.extd_number = self._vfo_names()[chirp_number - CHANNELS - 1]
|
|
|
|
raw = _mem.get_raw()
|
|
mem.empty = (int(_mem.freq) in (0, 0xFFFFFFFF) or
|
|
(_attr is not None and _attr.get_raw()[0] == 0xFF))
|
|
|
|
mem.extra = RadioSettingGroup("Extra", "extra")
|
|
valid = not mem.empty
|
|
bw = int(_mem.bandwidth) if valid else 0
|
|
demod = int(_mem.modulation) if valid else 0
|
|
mem.extra.append(RadioSetting(
|
|
"bandwidth", "Bandwidth",
|
|
RadioSettingValueList(BANDWIDTHS, current_index=bw)))
|
|
mem.extra.append(RadioSetting(
|
|
"demod", "Demodulation",
|
|
RadioSettingValueList(DEMODULATIONS,
|
|
current_index=list_index(demod,
|
|
DEMODULATIONS))))
|
|
mem.extra.append(RadioSetting(
|
|
"bclo", "Busy channel lockout",
|
|
RadioSettingValueBoolean(valid and bool(_mem.bclo))))
|
|
mem.extra.append(RadioSetting(
|
|
"frev", "Frequency reverse",
|
|
RadioSettingValueBoolean(valid and bool(_mem.freq_reverse))))
|
|
mem.extra.append(RadioSetting(
|
|
"pttid", "PTT ID", RadioSettingValueList(
|
|
PTTID_LIST, current_index=list_index(
|
|
int(_mem.dtmf_pttid) if valid else 0, PTTID_LIST))))
|
|
mem.extra.append(RadioSetting(
|
|
"scrambler", "Scrambler (Hz, 0 = off)",
|
|
RadioSettingValueInteger(0, scr_to_hz(0xFFFE),
|
|
scr_to_hz(int(_mem.scrambler))
|
|
if valid else 0)))
|
|
if _attr is not None:
|
|
mem.extra.append(RadioSetting(
|
|
"compander", "Compander", RadioSettingValueList(
|
|
COMPANDER_LIST, current_index=int(_attr.compander)
|
|
if valid else 0)))
|
|
for n in (1, 2, 3):
|
|
on = valid and bool(getattr(_attr, "scanlist%d" % n))
|
|
mem.extra.append(RadioSetting(
|
|
"scanlist%d" % n, "Scan list %d" % n,
|
|
RadioSettingValueBoolean(on)))
|
|
|
|
if mem.empty:
|
|
return mem
|
|
|
|
if is_vfo:
|
|
mem.immutable = ["name"]
|
|
else:
|
|
mem.name = self._decode_name(bytes(raw[16:26]))
|
|
|
|
mem.freq = int(_mem.freq) * 10
|
|
mem.offset = int(_mem.offset) * 10
|
|
if mem.offset == 0:
|
|
mem.duplex = ""
|
|
elif _mem.shift == uvk5.FLAGS1_OFFSET_MINUS:
|
|
if _mem.freq == _mem.offset:
|
|
mem.duplex, mem.offset = "off", 0 # TX disabled
|
|
else:
|
|
mem.duplex = "-"
|
|
elif _mem.shift == uvk5.FLAGS1_OFFSET_PLUS:
|
|
mem.duplex = "+"
|
|
else:
|
|
mem.duplex = ""
|
|
|
|
self._get_tone(mem, _mem)
|
|
|
|
if demod == 1:
|
|
mem.mode = "NAM" if bw else "AM"
|
|
elif demod == 2:
|
|
mem.mode = "USB"
|
|
else:
|
|
mem.mode = "NFM" if bw else "FM"
|
|
|
|
mem.tuning_step = STEPS[_mem.step] if _mem.step < len(STEPS) else 2.5
|
|
mem.power = POWER_LEVELS[min(int(_mem.txpower), len(POWER_LEVELS) - 1)]
|
|
return mem
|
|
|
|
def set_memory(self, mem):
|
|
_mem, _attr, is_vfo, _ = self._slot(
|
|
mem.extd_number if mem.extd_number else mem.number)
|
|
|
|
if mem.empty:
|
|
_mem.set_raw(b"\xFF" * 32)
|
|
if _attr is not None:
|
|
_attr.set_raw(b"\xFF")
|
|
return mem
|
|
|
|
raw = bytearray(_mem.get_raw())
|
|
if raw[0] == 0xFF:
|
|
raw = bytearray(32) # was empty
|
|
else:
|
|
raw[0:16] = bytes(16) # rebuilt below; name / scrambler kept
|
|
_mem.set_raw(bytes(raw))
|
|
|
|
_mem.freq = mem.freq // 10
|
|
_mem.offset = mem.offset // 10
|
|
if mem.duplex == "":
|
|
_mem.offset = 0
|
|
_mem.shift = 0
|
|
elif mem.duplex == "-":
|
|
_mem.shift = uvk5.FLAGS1_OFFSET_MINUS
|
|
elif mem.duplex == "+":
|
|
_mem.shift = uvk5.FLAGS1_OFFSET_PLUS
|
|
elif mem.duplex == "off":
|
|
_mem.shift = uvk5.FLAGS1_OFFSET_MINUS # TX disabled
|
|
_mem.offset = _mem.freq
|
|
|
|
demod = {"AM": 1, "NAM": 1, "USB": 2}.get(mem.mode, 0)
|
|
bw = 1 if mem.mode in ("NFM", "NAM", "USB") else 0
|
|
self._set_tone(mem, _mem)
|
|
_mem.step = STEPS.index(mem.tuning_step) \
|
|
if mem.tuning_step in STEPS else 0
|
|
_mem.txpower = POWER_LEVELS.index(mem.power) \
|
|
if mem.power in POWER_LEVELS else 0
|
|
|
|
scanlists = [False, False, False]
|
|
compander = 0
|
|
for setting in mem.extra:
|
|
name = setting.get_name()
|
|
value = setting.value.get_value()
|
|
if name == "bandwidth" and BANDWIDTHS.index(value) >= 2:
|
|
bw = BANDWIDTHS.index(value) # narrower / FSKQ
|
|
elif name == "demod" and DEMODULATIONS.index(value) >= 3:
|
|
demod = DEMODULATIONS.index(value) # experimental modes
|
|
elif name == "bclo":
|
|
_mem.bclo = 1 if value else 0
|
|
elif name == "frev":
|
|
_mem.freq_reverse = 1 if value else 0
|
|
elif name == "pttid":
|
|
_mem.dtmf_pttid = PTTID_LIST.index(value)
|
|
elif name == "scrambler":
|
|
hz = int(value)
|
|
if hz != scr_to_hz(int(_mem.scrambler)):
|
|
_mem.scrambler = hz_to_scr(hz)
|
|
elif name == "compander":
|
|
compander = COMPANDER_LIST.index(value)
|
|
elif name.startswith("scanlist"):
|
|
scanlists[int(name[-1]) - 1] = bool(value)
|
|
_mem.modulation = demod
|
|
_mem.bandwidth = bw
|
|
|
|
if not is_vfo:
|
|
name = mem.name.encode("latin-1", "replace")[:10]
|
|
raw = bytearray(_mem.get_raw())
|
|
raw[16:26] = name.ljust(10, b"\x00")
|
|
_mem.set_raw(bytes(raw))
|
|
_attr.band = find_band(mem.freq)
|
|
_attr.compander = compander
|
|
_attr.scanlist1, _attr.scanlist2, _attr.scanlist3 = scanlists
|
|
return mem
|
|
|
|
# ---------------------------------------------------------- settings
|
|
|
|
def _messages(self):
|
|
"""message slots, newest first"""
|
|
latest = int(self._memobj.msg_latest)
|
|
if latest >= MESSAGES:
|
|
latest = MESSAGES - 1
|
|
return [(latest - k) % MESSAGES for k in range(MESSAGES)]
|
|
|
|
def get_settings(self):
|
|
_mem = self._memobj
|
|
top = RadioSettings()
|
|
|
|
def group(name, label):
|
|
grp = RadioSettingGroup(name, label)
|
|
top.append(grp)
|
|
return grp
|
|
|
|
def add(grp, name, label, value):
|
|
grp.append(RadioSetting(name, label, value))
|
|
|
|
def lst(options, index):
|
|
return RadioSettingValueList(
|
|
options, current_index=list_index(int(index), options))
|
|
|
|
def boolean(value):
|
|
return RadioSettingValueBoolean(bool(value))
|
|
|
|
actions = [a[0] for a in KEY_ACTIONS]
|
|
|
|
def action(value):
|
|
values = [a[1] for a in KEY_ACTIONS]
|
|
index = values.index(int(value)) if int(value) in values else 0
|
|
return RadioSettingValueList(actions, current_index=index)
|
|
|
|
basic = group("basic", "Basic settings")
|
|
add(basic, "squelch", "Squelch (Sql)",
|
|
RadioSettingValueInteger(0, 9, min(int(_mem.squelch), 9)))
|
|
tot = int(_mem.max_talk_time)
|
|
add(basic, "tot", "TX timeout (TXTime)", RadioSettingValueList(
|
|
TOT_LIST, current_index=TOT_VALUES.index(tot)
|
|
if tot in TOT_VALUES else TOT_VALUES.index(11)))
|
|
add(basic, "mic_gain", "Mic gain (Mic)", lst(MIC_GAIN_LIST,
|
|
_mem.mic_gain))
|
|
rxmode = (bool(_mem.crossband) << 1) | bool(_mem.dual_watch)
|
|
add(basic, "rx_mode", "RX mode (RxMode)", lst(RXMODE_LIST, rxmode))
|
|
add(basic, "TX_VFO", "Main VFO", lst(["A", "B"], _mem.TX_VFO))
|
|
add(basic, "battery_save", "Battery save (BatSav)",
|
|
lst(BATSAVE_LIST, _mem.battery_save))
|
|
add(basic, "roger_beep", "Roger", lst(ROGER_LIST, _mem.roger_beep))
|
|
add(basic, "ste", "Squelch tail elimination (STE)", boolean(_mem.ste))
|
|
add(basic, "rp_ste", "Repeater STE (RP STE)",
|
|
lst(RP_STE_LIST, _mem.rp_ste))
|
|
add(basic, "button_beep", "Key beep (Beep)", boolean(_mem.button_beep))
|
|
call = int(_mem.call_channel)
|
|
add(basic, "call_channel", "1 Call channel",
|
|
RadioSettingValueInteger(1, CHANNELS,
|
|
call + 1 if call < CHANNELS else 1))
|
|
add(basic, "int_flock", "TX band lock (F Lock)",
|
|
lst(FLOCK_LIST, _mem.int_flock))
|
|
|
|
disp = group("display", "Display")
|
|
add(disp, "channel_display_mode", "Channel display (ChDisp)",
|
|
lst(CHANNELDISP_LIST, _mem.channel_display_mode))
|
|
add(disp, "backlight_time", "Backlight time (BLTime)",
|
|
lst(BACKLIGHT_LIST, _mem.backlight_time))
|
|
add(disp, "backlight_min", "Backlight min (BLMin)",
|
|
RadioSettingValueInteger(0, 9, min(int(_mem.backlight_min), 9)))
|
|
add(disp, "backlight_max", "Backlight max (BLMax)",
|
|
RadioSettingValueInteger(1, 10, max(1, min(
|
|
int(_mem.backlight_max), 10))))
|
|
add(disp, "backlight_on_TX_RX", "Backlight on TX/RX (BLTxRx)",
|
|
lst(BACKLIGHT_TX_RX_LIST, _mem.backlight_on_TX_RX))
|
|
add(disp, "battery_text", "Battery text (BatTxt)",
|
|
lst(BAT_TXT_LIST, _mem.battery_text))
|
|
add(disp, "mic_bar", "Mic bar (MicBar)", boolean(_mem.mic_bar))
|
|
add(disp, "set_inv", "Inverted display (SInv)", boolean(_mem.set_inv))
|
|
add(disp, "set_tmr", "RX/TX timer (STmr)", boolean(_mem.set_tmr))
|
|
|
|
keys = group("keys", "Keys")
|
|
add(keys, "key1_shortpress_action", "Side key 1 short (F1S)",
|
|
action(_mem.key1_shortpress_action))
|
|
add(keys, "key1_longpress_action", "Side key 1 long (F1L)",
|
|
action(_mem.key1_longpress_action))
|
|
add(keys, "key2_shortpress_action", "Side key 2 short (F2S)",
|
|
action(_mem.key2_shortpress_action))
|
|
add(keys, "key2_longpress_action", "Side key 2 long (F2L)",
|
|
action(_mem.key2_longpress_action))
|
|
add(keys, "keyM_longpress_action", "M long (ML)",
|
|
action(_mem.keyM_longpress_action))
|
|
add(keys, "key_lock", "Keypad locked", boolean(_mem.key_lock))
|
|
add(keys, "auto_keypad_lock", "Auto keypad lock (KeyLck)",
|
|
lst(KEYLOCK_LIST, _mem.auto_keypad_lock))
|
|
add(keys, "set_ptt", "PTT mode (SPTT)", lst(SET_PTT_LIST,
|
|
_mem.set_ptt))
|
|
|
|
scan = group("scan", "Scan")
|
|
add(scan, "slDef", "Scan list (SList)", lst(SLIST_LIST, _mem.slDef))
|
|
add(scan, "scan_resume_mode", "Scan resume (ScnRev)",
|
|
lst(SCANREV_LIST, _mem.scan_resume_mode))
|
|
|
|
power = group("power", "Power")
|
|
add(power, "battery_type", "Battery type (BatTyp)",
|
|
lst(BATTYPE_LIST, _mem.battery_type))
|
|
add(power, "set_off", "Auto power off (SOff)",
|
|
lst(SET_OFF_LIST, _mem.set_off))
|
|
vol = RadioSettingValueInteger(0, 63, min(int(_mem.volume_gain), 63))
|
|
vol.set_mutable(False)
|
|
add(power, "volume_gain", "Volume gain (SVol, set on the radio)", vol)
|
|
|
|
dtmf = group("dtmf", "DTMF")
|
|
add(dtmf, "dtmf_side_tone", "DTMF side tone (L DTMF)",
|
|
boolean(_mem.dtmf_side_tone == 1))
|
|
add(dtmf, "dtmf_preload_time", "Preload time x10 ms (D Prel)",
|
|
RadioSettingValueInteger(3, 99, max(3, min(
|
|
int(_mem.dtmf_preload_time), 99))))
|
|
add(dtmf, "live_DTMF_decoder", "Live DTMF decoder (D Live)",
|
|
boolean(_mem.live_DTMF_decoder))
|
|
for name, label in (("dtmf_up_code", "Up code (UPCode)"),
|
|
("dtmf_down_code", "Down code (DNCode)")):
|
|
code = str(getattr(_mem, name)).split("\x00")[0] \
|
|
.replace("\xff", "").rstrip()
|
|
add(dtmf, name, label, RadioSettingValueString(
|
|
0, 16, code, False, DTMF_CHARS))
|
|
|
|
data = group("data", "POCSAG / SMS")
|
|
add(data, "fsk_mode", "Modem (FSKMod)", lst(FSK_MODES, _mem.fsk_mode))
|
|
src = int(_mem.fsk_src)
|
|
add(data, "fsk_src", "Own address / RIC (FSKSRC)",
|
|
RadioSettingValueInteger(0, 99999999,
|
|
src if src <= 99999999 else 0))
|
|
add(data, "pocsag_monitor", "POCSAG monitor, all RICs (PocMon)",
|
|
boolean(_mem.pocsag_monitor == POCSAG_MONITOR_ON))
|
|
|
|
fm = group("fm", "FM radio")
|
|
add(fm, "fm_band", "Band", lst(FM_BANDS, _mem.fm_band))
|
|
add(fm, "fm_agc", "AGC", boolean(_mem.fm_agc))
|
|
add(fm, "fm_blend", "Stereo blend", lst(FM_BLEND, _mem.fm_blend))
|
|
add(fm, "fm_deemphasis", "De-emphasis",
|
|
lst(FM_DEEMPHASIS, _mem.fm_deemphasis))
|
|
for i in range(20):
|
|
freq = int(_mem.fmfreq[i])
|
|
text = "%.1f" % (freq / 10.0) if 640 <= freq <= 1080 else ""
|
|
add(fm, "fmfreq%d" % i, "Preset %d (MHz)" % (i + 1),
|
|
RadioSettingValueString(0, 5, text, False, "0123456789. "))
|
|
|
|
msgs = group("messages", "Messages")
|
|
add(msgs, "msg_clear", "Delete all messages on upload",
|
|
boolean(False))
|
|
for rank, slot in enumerate(self._messages()):
|
|
msg = _mem.message[slot]
|
|
raw = bytes(msg.get_raw())
|
|
text = raw[7:7 + MESSAGE_TEXT].split(b"\x00")[0]
|
|
empty = raw[0:4] == b"\xff" * 4 or text[:1] in (b"", b"\xff")
|
|
text = "" if empty else "".join(
|
|
chr(c) if 32 <= c < 127 else "?" for c in text)
|
|
kind = "POCSAG RIC" if int(msg.flags) & MESSAGE_FLAG_POCSAG \
|
|
else "SMS from"
|
|
label = "#%d %s" % (rank + 1, "(empty)" if empty else
|
|
"%s %d" % (kind, int(msg.src)))
|
|
value = RadioSettingValueString(0, MESSAGE_TEXT, text, False)
|
|
add(msgs, "msg%d" % slot, label, value)
|
|
|
|
return top
|
|
|
|
def set_settings(self, settings):
|
|
_mem = self._memobj
|
|
actions = dict(KEY_ACTIONS)
|
|
index_lists = {
|
|
"mic_gain": MIC_GAIN_LIST, "battery_save": BATSAVE_LIST,
|
|
"roger_beep": ROGER_LIST, "rp_ste": RP_STE_LIST,
|
|
"int_flock": FLOCK_LIST,
|
|
"channel_display_mode": CHANNELDISP_LIST,
|
|
"backlight_time": BACKLIGHT_LIST,
|
|
"backlight_on_TX_RX": BACKLIGHT_TX_RX_LIST,
|
|
"battery_text": BAT_TXT_LIST, "auto_keypad_lock": KEYLOCK_LIST,
|
|
"set_ptt": SET_PTT_LIST, "slDef": SLIST_LIST,
|
|
"scan_resume_mode": SCANREV_LIST, "battery_type": BATTYPE_LIST,
|
|
"set_off": SET_OFF_LIST, "fsk_mode": FSK_MODES,
|
|
"fm_band": FM_BANDS, "fm_blend": FM_BLEND,
|
|
"fm_deemphasis": FM_DEEMPHASIS, "TX_VFO": ["A", "B"],
|
|
}
|
|
plain = ("squelch", "backlight_min", "backlight_max", "ste",
|
|
"button_beep", "mic_bar", "set_inv", "set_tmr", "key_lock",
|
|
"live_DTMF_decoder", "fm_agc", "dtmf_preload_time")
|
|
clear_messages = False
|
|
|
|
for element in settings:
|
|
if not isinstance(element, RadioSetting):
|
|
self.set_settings(element)
|
|
continue
|
|
if not element.value.get_mutable():
|
|
continue
|
|
name = element.get_name()
|
|
value = element.value.get_value()
|
|
|
|
if name in index_lists:
|
|
setattr(_mem, name, index_lists[name].index(value))
|
|
elif name in plain:
|
|
setattr(_mem, name, int(value))
|
|
elif name == "tot":
|
|
_mem.max_talk_time = TOT_VALUES[TOT_LIST.index(value)]
|
|
elif name == "rx_mode":
|
|
mode = RXMODE_LIST.index(value)
|
|
main = int(_mem.TX_VFO) + 1
|
|
_mem.crossband = main if mode & 0b10 else 0
|
|
_mem.dual_watch = main if mode & 0b01 else 0
|
|
elif name == "call_channel":
|
|
_mem.call_channel = int(value) - 1
|
|
elif name.endswith("press_action"):
|
|
setattr(_mem, name, actions[value])
|
|
elif name == "dtmf_side_tone":
|
|
_mem.dtmf_side_tone = 1 if value else 0
|
|
elif name in ("dtmf_up_code", "dtmf_down_code"):
|
|
setattr(_mem, name,
|
|
str(value).rstrip().ljust(16, "\x00")[:16])
|
|
elif name == "fsk_src":
|
|
src = int(value)
|
|
if _mem.fsk_mode in POCSAG_MODES:
|
|
src = min(src, POCSAG_MAX_RIC)
|
|
_mem.fsk_src = src
|
|
elif name == "pocsag_monitor":
|
|
_mem.pocsag_monitor = POCSAG_MONITOR_ON if value else 0
|
|
elif name.startswith("fmfreq"):
|
|
text = str(value).strip()
|
|
try:
|
|
freq = int(round(float(text) * 10)) if text else 0xFFFF
|
|
except ValueError:
|
|
freq = 0xFFFF
|
|
if freq != 0xFFFF and not 640 <= freq <= 1080:
|
|
freq = 0xFFFF
|
|
_mem.fmfreq[int(name[6:])] = freq
|
|
elif name == "msg_clear":
|
|
clear_messages = bool(value)
|
|
elif name.startswith("msg"):
|
|
self._set_message(int(name[3:]), str(value))
|
|
|
|
if clear_messages:
|
|
for slot in range(MESSAGES):
|
|
_mem.message[slot].set_raw(b"\xFF" * 48)
|
|
_mem.msg_latest = MESSAGES - 1
|
|
|
|
def _set_message(self, slot, text):
|
|
msg = self._memobj.message[slot]
|
|
raw = bytearray(msg.get_raw())
|
|
old = bytes(raw[7:7 + MESSAGE_TEXT]).split(b"\x00")[0]
|
|
new = "".join(c if 32 <= ord(c) < 127 else "?"
|
|
for c in text.rstrip())[:MESSAGE_TEXT].encode("ascii")
|
|
if new == old or (not new and old[:1] in (b"", b"\xff")):
|
|
return
|
|
if raw[0:4] == b"\xff" * 4: # empty slot: a local message
|
|
raw[0:7] = bytes(7)
|
|
raw[7:48] = new.ljust(41, b"\x00")
|
|
msg.set_raw(bytes(raw))
|