diff --git a/chirp/uvk5_brnpocsag.py b/chirp/uvk5_brnpocsag.py new file mode 100644 index 0000000..70305e3 --- /dev/null +++ b/chirp/uvk5_brnpocsag.py @@ -0,0 +1,803 @@ +# Quansheng UV-K5 driver for the BRN-POCSAG firmware +# +# Based on the UV-K5 egzumer driver +# (c) 2023 Jacek Lipkowski , adapted by EGZUMER, JOC2 +# and template.py Copyright 2012 Dan Smith +# +# 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 . +# +# 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))