CHIRP driver for the BRN-POCSAG firmware

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>
This commit is contained in:
2026-11-15 01:43:05 +01:00
co-authored by Claude Opus 5.5
parent aabd0f4956
commit d7b5a679fa
+803
View File
@@ -0,0 +1,803 @@
# 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))