[chirp_devel] Fwd: [PATCH] [RT98] Add support for Retevis RT98 Single Band Mini Mobile Radios
Jim Unroe
Sat Jul 3 12:45:10 PDT 2021
Second try...
---------- Forwarded message ---------
From: Jim Unroe <kc9hi at comcast.net>
Date: Sat, Jul 3, 2021 at 2:25 PM
Subject: [PATCH] [RT98] Add support for Retevis RT98 Single Band Mini
Mobile Radios
To: <Rock.Unroe at gmail.com>
# HG changeset patch
# User Jim Unroe <rock.unroe at gmail.com>
# Date 1625336015 14400
# Sat Jul 03 14:13:35 2021 -0400
# Node ID 0eab8146b294ef686ca4a49c17ea38abde54c7ab
# Parent f586574bc8786fd6bef1e5d54d08d381c81edd47
[RT98] Add support for Retevis RT98 Single Band Mini Mobile Radios
This patch adds support for the various Retevis RT98 mobile radio
models/modes.
VHF FreeNet
VHF COM
VHF COMII
UHF PMR
UHF COM
UHF COMII
#9181
diff -r f586574bc878 -r 0eab8146b294 chirp/drivers/retevis_rt98.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/chirp/drivers/retevis_rt98.py Sat Jul 03 14:13:35 2021 -0400
@@ -0,0 +1,1364 @@
+# Copyright 2021 Jim Unroe <rock.unroe at gmail.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/>.
+
+import os
+import struct
+import time
+import logging
+
+from chirp import bitwise
+from chirp import chirp_common
+from chirp import directory
+from chirp import errors
+from chirp import memmap
+from chirp import util
+from chirp.settings import RadioSettingGroup, RadioSetting, RadioSettings,
\
+ RadioSettingValueList, RadioSettingValueString,
RadioSettingValueBoolean, \
+ RadioSettingValueInteger, RadioSettingValueString, \
+ RadioSettingValueFloat, InvalidValueError
+
+LOG = logging.getLogger(__name__)
+
+#
+# Chirp Driver for Retevis RT98 models: RT98V (136-174 Mhz)
+# RT98U (400-490 Mhz)
+#
+#
+#
+# Global Parameters
+#
+TONES = [62.5] + list(chirp_common.TONES)
+TMODES = ['', 'Tone', 'DTCS']
+DUPLEXES = ['', '+', '-']
+
+TXPOWER_LOW = 0x00
+TXPOWER_MED = 0x01
+TXPOWER_HIGH = 0x02
+
+DUPLEX_NOSPLIT = 0x00
+DUPLEX_POSSPLIT = 0x01
+DUPLEX_NEGSPLIT = 0x02
+
+CHANNEL_WIDTH_12d5kHz = 0x00
+CHANNEL_WIDTH_20kHz = 0x01
+CHANNEL_WIDTH_25kHz = 0x02
+
+TUNING_STEPS = [2.5, 5.0, 6.25, 10.0, 12.5, 20.0, 25.0, 30.0, 50.0]
+
+POWER_LEVELS = [chirp_common.PowerLevel("Low", watts=5),
+ chirp_common.PowerLevel("Mid", watts=10),
+ chirp_common.PowerLevel("High", watts=15)]
+
+PMR_POWER_LEVELS = [chirp_common.PowerLevel("Low", watts=0.5), ]
+
+FREENET_POWER_LEVELS = [chirp_common.PowerLevel("Low", watts=1), ]
+
+PMR_FREQS = [446.00625, 446.01875, 446.03125, 446.04375,
+ 446.05625, 446.06875, 446.08125, 446.09375,
+ 446.10625, 446.11875, 446.13125, 446.14375,
+ 446.15625, 446.16875, 446.18125, 446.19375]
+
+FREENET_FREQS = [149.02500, 149.03750, 149.05000,
+ 149.08750, 149.10000, 149.11250]
+
+CROSS_MODES = ["Tone->Tone", "DTCS->", "->DTCS", "Tone->DTCS",
"DTCS->Tone",
+ "->Tone", "DTCS->DTCS"]
+
+LIST_STEP = [str(x) for x in TUNING_STEPS]
+LIST_TIMEOUT = ["Off"] + ["%s min" % x for x in range(1, 31)]
+LIST_APO = ["Off", "30 min", "1 hr", "2 hrs"]
+LIST_SQUELCH = ["Off"] + ["Level %s" % x for x in range(1, 10)]
+LIST_DISPLAY_MODE = ["Channel", "Frequency", "Name"]
+LIST_AOP = ["Manual", "Auto"]
+LIST_STE_TYPE = ["Off", "Silent", "120 Degree", "180 Degree", "240 Degree"]
+LIST_STE_FREQ = ["Off", "55.2 Hz", "259.2 Hz"]
+
+LIST_PRIORITY_CH = ["Off", "Priority Channel 1", "Priority Channel 2",
+ "Priority Channel 1 + Priority Channel 2"]
+
+LIST_REVERT_CH = ["Selected", "Selected + TalkBack", "Priority Channel 1",
+ "Priority Channel 2", "Last Called", "Last Used",
+ "Priority Channel 1 + TalkBack",
+ "Priority Channel 2 + TalkBack"]
+
+LIST_TIME50 = ["0.1", "0.2", "0.3", "0.4", "0.5",
+ "0.6", "0.7", "0.8", "0.9", "1.0",
+ "1.1", "1.2", "1.3", "1.4", "1.5",
+ "1.6", "1.7", "1.8", "1.9", "2.0",
+ "2.1", "3.2", "2.3", "2.4", "2.5",
+ "2.6", "2.7", "2.8", "2.9", "3.0",
+ "3.1", "3.2", "3.3", "3.4", "3.5",
+ "3.6", "3.7", "3.8", "3.9", "4.0",
+ "4.1", "4.2", "4.3", "4.4", "4.5",
+ "4.6", "4.7", "4.8", "4.9", "5.0"]
+LIST_TIME46 = LIST_TIME50[4:]
+
+LIST_RT98V_MODES = ["FreeNet", "COM", "COMII"]
+LIST_RT98U_MODES = ["PMR", "COM", "COMII"]
+
+LIST_RT98V_FREQS = ["Rx(149 - 149.2 MHz) Tx(149 - 149.2 MHz)",
+ "Rx(136 - 174 MHz) Tx(136 - 174 MHz)",
+ "Rx(147 - 174 MHz) Tx(147 - 174 MHz)"]
+
+LIST_RT98U_FREQS = ["Rx(446 - 446.2 MHz) Tx(446 - 446.2 MHz)",
+ "Rx(400 - 470 MHz) Tx(400 - 470 MHz)",
+ "Rx(450 - 470 MHz) Tx(450 - 470 MHz)"]
+
+SETTING_LISTS = {
+ "tuning_step": LIST_STEP,
+ "timeout_timer": LIST_TIMEOUT,
+ "auto_power_off": LIST_APO,
+ "squelch": LIST_SQUELCH,
+ "display_mode": LIST_DISPLAY_MODE,
+ "auto_power_on": LIST_AOP,
+ "ste_type": LIST_STE_TYPE,
+ "ste_frequency": LIST_STE_FREQ,
+ "priority_ch": LIST_PRIORITY_CH,
+ "revert_ch": LIST_REVERT_CH,
+ "settings2.dropout_delay_time": LIST_TIME50,
+ "settings2.dwell_time": LIST_TIME50,
+ "settings2.look_back_time_a": LIST_TIME46,
+ "settings2.look_back_time_b": LIST_TIME46
+}
+
+# RT98 memory map
+# section: 1 Channel Bank
+# description of channel bank (199 channels , range 1-199)
+# Each 32 Byte (0x20 hex) record:
+# bytes:bit type description
+#
---------------------------------------------------------------------------
+# 4 bbcd freq[4] receive frequency in packed binary coded
+# decimal
+# 4 bbcd offset[4] transceive offset in packed binary coded
+# decimal (note: +/- direction set by
+# 'duplex' field)
+# 1 u8 unknown0
+# 1 u8
+# :1 reverse:1 reverse flag, 0=off, 1=on (reverses
+# transmit and receive freqencies)
+# :1 txoff:1 transmitt off flag, 0=transmit, 1=do not
+# transmit
+# :2 power:2 transmit power setting, value range 0-2,
+# 0=low, 1=middle, 2=high
+# :2 duplex:2 duplex settings, 0=simplex, 1=plus (+)
+# offset, 2=minus(-) offset (see offset
field)
+# :2 channel_width:2 channel spacing, 0=12.5kHz, 1=20kHz,
2=25kHz
+# 1 u8
+# :2 unknown1:2
+# :1 talkaround:1 talkaround flag, 0=off, 1=on
+# (bypasses repeater)
+# :1 squelch_mode:1 squelch mode flag, 0=carrier,
1=ctcss/dcs
+# :1 rxdcsextra:1 use with rxcode for index of rx DCS to
use
+# :1 rxinv:1 inverse DCS rx polarity flag, 0=N, 1=I
+# :1 txdcsextra:1 use with txcode for index of tx DCS to
use
+# :1 txinv:1 inverse DCS tx polarity flag, 0=N, 1=I
+# 1 u8
+# :4 unknown2:4
+# :2 rxtmode:2 rx tone mode, value range 0-2, 0=none,
+# 1=CTCSS, 2=DCS (ctcss tone in field
rxtone)
+# :2 txtmode:2 tx tone mode, value range 0-2, 0=none,
+# 1=CTCSS, 3=DCS (ctcss tone in field
txtone)
+# 1 u8
+# :2 unknown3:2
+# :6 txtone:6 tx ctcss tone, menu index
+# 1 u8
+# :2 unknown4:2
+# :6 rxtone:6 rx ctcss tone, menu index
+# 1 u8 txcode ?, not used for ctcss
+# 1 u8 rxcode ?, not used for ctcss
+# 1 u8
+# :6 unknown5:6
+# :1 busychannellockout:1 busy channel lockout flag, 0=off,
1=enabled
+# :1 unknown6:1
+# 6 char name[6] 6 byte char string for channel name
+# 9 u8 unknown7[9]
+#
+MEM_FORMAT = """
+#seekto 0x0000;
+struct {
+ bbcd freq[4];
+ bbcd offset[4];
+ u8 unknown0;
+ u8 reverse:1,
+ tx_off:1,
+ txpower:2,
+ duplex:2,
+ channel_width:2;
+ u8 unknown1:2,
+ talkaround:1,
+ squelch_mode:1,
+ rxdcsextra:1,
+ rxinv:1,
+ txdcsextra:1,
+ txinv:1;
+ u8 unknown2:4,
+ rxtmode:2,
+ txtmode:2;
+ u8 unknown3:2,
+ txtone:6;
+ u8 unknown4:2,
+ rxtone:6;
+ u8 txcode;
+ u8 rxcode;
+ u8 unknown5:6,
+ busychannellockout:1,
+ unknown6:1;
+ char name[6];
+ u8 unknown7[9];
+} memory[199];
+"""
+
+# RT98 memory map
+# section: 2 and 3 Channel Set/Skip Flags
+#
+# Channel Set (starts 0x3240) : Channel Set bit is value 0 if a memory
+# location in the channel bank is active.
+# Channel Skip (starts 0x3260): Channel Skip bit is value 0 if a memory
+# location in the channel bank is active.
+#
+# Both flag maps are a total 24 bytes in length, aligned on 32 byte
records.
+# bit = 0 channel not set/skip, 1 is channel set/no skip
+#
+# to index a channel:
+# cbyte = channel / 8 ;
+# cbit = channel % 8 ;
+# setflag = csetflag[cbyte].c[cbit] ;
+# skipflag = cskipflag[cbyte].c[cbit] ;
+#
+# channel range is 1-199, range is 32 bytes (last 7 unknown)
+#
+MEM_FORMAT = MEM_FORMAT + """
+#seekto 0x3240;
+struct {
+ bit c[8];
+} csetflag[32];
+
+#seekto 0x3260;
+struct {
+ bit c[8];
+} cskipflag[32];
+
+"""
+
+# RT98 memory map
+# section: 4 Startup Label
+#
+# bytes:bit type description
+#
---------------------------------------------------------------------------
+# 6 char start_label[6] label displayed at startup (usually
+# your call sign)
+#
+MEM_FORMAT = MEM_FORMAT + """
+#seekto 0x3300;
+struct {
+ char startname[6];
+} slabel;
+"""
+
+# RT98 memory map
+# section: 5, 6 and 7 Radio Options
+# used to set a number of radio options
+#
+# description of function setup options, starting at 0x3310 (settings3)
+#
+# bytes:bit type description
+#
---------------------------------------------------------------------------
+# 1 u8
+# :6 unknown:6
+# :2 bandlimit_3310:2 frequency ranges, range 0-2,
+# 0=freenet(vhf) or pmr(uhf), 1=com,
2=comii
+# rt98v - 00 FreeNet Rx(149 - 149.2 MHz) Tx(149 - 149.2
MHz)
+# 01 COM Rx(136 - 174 MHz) Tx(136 - 174 MHz)
+# 02 COMII Rx(147 - 174 MHz) Tx(147 - 174 MHz)
+# rt98u - 00 PMR Rx(446 - 446.2 MHz) Tx(446 - 446.2
MHz)
+# 01 COM Rx(400 - 470 MHz) Tx(400 - 470 MHz)
+# 02 COMII Rx(450 - 470 MHz) Tx(450 - 470 MHz)
+# 1 u8 ch_number; channel number, range 1-199
+#
+# description of function setup options, starting at 0x3340 (settings)
+#
+# bytes:bit type description
+#
---------------------------------------------------------------------------
+# 1 u8
+# :4 unknown_3340:4
+# :4 tuning_step:4 tuning step, menu index value from 0-8
+# 2.5, 5, 6.25, 10, 12.5, 20, 25, 30, 50
+# 1 u8
+# :7 unknown_3341:7
+# :1 beep:1 beep mode, range 0-1, 0=off, 1=on
+# 1 u8
+# :3 unknown_3342:3
+# :5 timeout_timer:5 timeout timer, range off (no timeout),
+# 1-30 minutes
+# 1 u8
+# :6 unknown_3343:6
+# :2 auto_power_off:2 auto power off, range 0-3, off, 30min,
+# 1hr, 2hr
+# 1 u8
+# :4 unknown_3344:4
+# :4 squelch:4 squelch level, range off, 1-9
+# 1 u8
+# :3 unknown_3345:3
+# :5 volume:5 volume level, range 1-30 (no zero)
+# 1 u8 unknown_3346
+# 1 u8 unknown_3347
+# 1 u8 0x3348 [12]
+# :6 unknown_3348:6
+# :2 display_mode display mode, range 0-2, 0=channel,
+# 1=frequency, 2=name
+# 1 u8
+# :7 unknown_3349:7
+# :1 auto_power_on:1 auto power on, range 0-1, 0=manual,
+# 1=auto
+# 1 u8
+# :3 unknown_334A:3
+# :5 mic_gain:5 mic gain, range 1-30 (no zero)
+# 1 u8
+# :5 unknown_334C:5
+# :3 ste_type:3 ste type, range 0-4, 0=off, 1=silent,
+# 2=120degree, 3=180degree, 4=240degree
+# 1 u8
+# :7 unknown_334D:7
+# :1 ste_frequency:1 ste frequency, range 0-2, 0=off,
+# 1=55.2Hz, 2=259.2Hz
+# 1 u8
+# :2 unknown_0x334E:2
+# :1 forbid_setting:1 forbid setting(optional function),
+# range 0-1, 0=disabled, 1=enabled
+# :1 forbid_initialize:1 forbid initialize operate, range 0-1,
+# 0=enabled, 1=disabled (inverted)
+# :1 save_chan_param:1 save channel parameters, range 0-1,
+# 0=disabled, 1=enabled
+# :1 forbid_chan_menu:1 forbid channel menu, range 0-1,
+# 0=disabled, 1=enabled
+# :1 sql_key_function:1 sql key function, range 0-1,
+# 0=squelch off momentary, 1=squelch off
+# :1 unknown:1
+#
+# description of function setup options, starting at 0x3380 (settings2)
+#
+# bytes:bit type description
+#
---------------------------------------------------------------------------
+# 1 u8
+# :7 unknown_3380:7
+# :1 scan_mode:1 scan mode, range 0-1, 0=off, 1=on
+# 1 u8
+# :6 unknown_3381:6
+# :2 priority_ch:2 priority channel, range 0-3, 0=off,
+# 1=priority channel 1,
+# 2=priority channel 2,
+# 3=priority channel 1 + priority
channel 2
+# 1 u8 priority_ch1 priority channel 1 number, range 1-199
+# 1 u8 priority_ch2 priority channel 2 number, range 1-199
+# 1 u8
+# :4 unknown_3384:4
+# :4 revert_ch:4 revert channel, range 0-3, 0=selected,
+# 1=selected + talkback, 2=last called,
+# 3=last used
+# 1 u8 look_back_time_a look back time a, range 0-45
+# 1 u8 look_back_time_b look back time b, range 0-45
+# 1 u8 dropout_delay_time dropout delay time, range 0-49
+# 1 u8 dwell_time dwell time, range 0-49
+#
+MEM_FORMAT = MEM_FORMAT + """
+#seekto 0x3310;
+struct {
+ u8 bandlimit;
+ u8 ch_number;
+} settings3;
+"""
+
+MEM_FORMAT = MEM_FORMAT + """
+#seekto 0x3340;
+struct {
+ u8 unknown_3340:4,
+ tuning_step:4;
+ u8 unknown_3341:7,
+ beep:1;
+ u8 unknown_3342:3,
+ timeout_timer:5;
+ u8 unknown_3343:6,
+ auto_power_off:2;
+ u8 unknown_3344:4,
+ squelch:4;
+ u8 unknown_3345:3,
+ volume:5;
+ u8 unknown_3346;
+ u8 unknown_3347;
+ u8 unknown_3348:6,
+ display_mode:2;
+ u8 unknown_3349:7,
+ auto_power_on:1;
+ u8 unknown_334A:3,
+ mic_gain:5;
+ u8 unknown_334B;
+ u8 unknown_334C:5,
+ ste_type:3;
+ u8 unknown_334D:6,
+ ste_frequency:2;
+ u8 unknown_334E:1,
+ forbid_setting:1,
+ unknown1:1,
+ forbid_initialize:1,
+ save_chan_param:1,
+ forbid_chan_menu:1,
+ sql_key_function:1,
+ unknown2:1;
+} settings;
+"""
+
+MEM_FORMAT = MEM_FORMAT + """
+#seekto 0x3380;
+struct {
+ u8 unknown_3380:7,
+ scan_mode:1;
+ u8 unknown_3381:6,
+ priority_ch:2;
+ u8 priority_ch1;
+ u8 priority_ch2;
+ u8 unknown_3384:4,
+ revert_ch:4;
+ u8 look_back_time_a;
+ u8 look_back_time_b;
+ u8 dropout_delay_time;
+ u8 dwell_time;
+} settings2;
+"""
+
+# RT98 memory map
+# section: 8 Embedded Messages
+#
+# bytes:bit type description
+#
---------------------------------------------------------------------------
+# 6 char radio_type[5] radio type, vhf=rt98v, uhf=rt98u
+# 2 u8 unknown1[2]
+# 4 char mcu_version[4] mcu version, [x.xx]
+# 2 u8 unknown2[2]
+# 1 u8 mode rt98u mode: 0=pmr, 1=com, 2=comii
+# rt98v mode: 0=freenet, 1=com, 2=comii
+# 1 u8 unknown3
+# 10 u8 unused1[10]
+# 4 u8 unknown4[4]
+# 3 u8 unused2[3]
+# 16 u8 unknown5[16]
+# 10 char date_mfg[16] date manufactured, [yyyy-mm-dd]
+#
+MEM_FORMAT = MEM_FORMAT + """
+#seekto 0x3D00;
+struct {
+char radio_type[5];
+u8 unknown1[2];
+char mcu_version[4];
+u8 unknown2[2];
+u8 mode;
+u8 unknown3;
+u8 unused1[10];
+u8 unknown4[4];
+u8 unused2[3];
+u8 unknown5[16];
+char date_mfg[10];
+} embedded_msg;
+"""
+
+
+# Format for the version messages returned by the radio
+VER_FORMAT = '''
+u8 hdr;
+char model[5];
+u8 unknown[2];
+u8 bandlimit;
+char version[6];
+u8 ack;
+'''
+
+
+# Radio supports upper case and symbols
+CHARSET_ASCII_PLUS = chirp_common.CHARSET_UPPER_NUMERIC + '- '
+
+# Band limits as defined by the band byte in ver_response, defined in Hz,
for
+# VHF and UHF, used for RX and TX.
+RT98V_BAND_LIMITS = {0x00: [(149000000, 149200000)],
+ 0x01: [(136000000, 174000000)],
+ 0x02: [(147000000, 174000000)]}
+
+RT98U_BAND_LIMITS = {0x00: [(446000000, 446200000)],
+ 0x01: [(400000000, 470000000)],
+ 0x02: [(450000000, 470000000)]}
+
+
+# Get band limits from a band limit value
+def get_band_limits_Hz(radio_type, limit_value):
+ if radio_type == "RT98U":
+ if limit_value not in RT98U_BAND_LIMITS:
+ limit_value = 0x01
+ LOG.warning('Unknown band limit value 0x%02x, default to 0x01')
+ bandlimitfrequencies = RT98U_BAND_LIMITS[limit_value]
+ elif radio_type == "RT98V":
+ if limit_value not in RT98V_BAND_LIMITS:
+ limit_value = 0x01
+ LOG.warning('Unknown band limit value 0x%02x, default to 0x01')
+ bandlimitfrequencies = RT98V_BAND_LIMITS[limit_value]
+ return bandlimitfrequencies
+
+
+def _echo_write(radio, data):
+ try:
+ radio.pipe.write(data)
+ radio.pipe.read(len(data))
+ except Exception, e:
+ LOG.error("Error writing to radio: %s" % e)
+ raise errors.RadioError("Unable to write to radio")
+
+
+def _checksum(data):
+ cs = 0
+ for byte in data:
+ cs += ord(byte)
+ return cs % 256
+
+
+def _read(radio, length):
+ try:
+ data = radio.pipe.read(length)
+ except Exception, e:
+ _finish(radio)
+ LOG.error("Error reading from radio: %s" % e)
+ raise errors.RadioError("Unable to read from radio")
+
+ if len(data) != length:
+ _finish(radio)
+ LOG.error("Short read from radio (%i, expected %i)" %
+ (len(data), length))
+ LOG.debug(util.hexprint(data))
+ raise errors.RadioError("Short read from radio")
+ return data
+
+
+# strip trailing 0x00 to convert a string returned by bitwise.parse into a
+# python string
+def cstring_to_py_string(cstring):
+ return "".join(c for c in cstring if c != '\x00')
+
+
+# Check the radio version reported to see if it's one we support,
+# returns bool version supported, and the band index
+def check_ver(ver_response, allowed_types):
+ ''' Check the returned radio version is one we approve of '''
+
+ LOG.debug('ver_response = ')
+ LOG.debug(util.hexprint(ver_response))
+
+ resp = bitwise.parse(VER_FORMAT, ver_response)
+ verok = False
+
+ if resp.hdr == 0x49 and resp.ack == 0x06:
+ model, version =
[cstring_to_py_string(bitwise.get_string(s)).strip()
+ for s in (resp.model, resp.version)]
+ LOG.debug('radio model: \'%s\' version: \'%s\'' %
+ (model, version))
+ LOG.debug('allowed_types = %s' % allowed_types)
+
+ if model in allowed_types:
+ LOG.debug('model in allowed_types')
+
+ if version in allowed_types[model]:
+ LOG.debug('version in allowed_types[model]')
+ verok = True
+ else:
+ _finish(radio)
+ raise errors.RadioError('Failed to parse version response')
+
+ return verok, str(resp.model), int(resp.bandlimit)
+
+
+def _ident(radio):
+ radio.pipe.timeout = 1
+ _echo_write(radio, "PROGRAM")
+ response = radio.pipe.read(3)
+ if response != "QX\06":
+ _finish(radio)
+ LOG.debug("Response was :\n%s" % util.hexprint(response))
+ raise errors.RadioError("Radio did not respond. Check connection.")
+ _echo_write(radio, "\x02")
+ ver_response = radio.pipe.read(16)
+ LOG.debug(util.hexprint(ver_response))
+
+ verok, model, bandlimit = check_ver(ver_response,
+ radio.ALLOWED_RADIO_TYPES)
+ if not verok:
+ _finish(radio)
+ raise errors.RadioError(
+ 'Radio version not in allowed list for %s-%s: %s' %
+ (radio.VENDOR, radio.MODEL, util.hexprint(ver_response)))
+
+ return model, bandlimit
+
+
+def _send(radio, cmd, addr, length, data=None):
+ frame = struct.pack(">cHb", cmd, addr, length)
+ if data:
+ frame += data
+ frame += chr(_checksum(frame[1:]))
+ frame += "\x06"
+ _echo_write(radio, frame)
+ LOG.debug("Sent:\n%s" % util.hexprint(frame))
+ if data:
+ result = radio.pipe.read(1)
+ if result != "\x06":
+ _finish(radio)
+ LOG.debug("Ack was: %s" % repr(result))
+ raise errors.RadioError("Radio did not accept block at %04x"
+ % addr)
+ return
+ result = _read(radio, length + 6)
+ LOG.debug("Got:\n%s" % util.hexprint(result))
+ header = result[0:4]
+ data = result[4:-2]
+ ack = result[-1]
+ if ack != "\x06":
+ _finish(radio)
+ LOG.debug("Ack was: %s" % repr(ack))
+ raise errors.RadioError("Radio NAK'd block at %04x" % addr)
+ _cmd, _addr, _length = struct.unpack(">cHb", header)
+ if _addr != addr or _length != _length:
+ _finish(radio)
+ LOG.debug("Expected/Received:")
+ LOG.debug(" Length: %02x/%02x" % (length, _length))
+ LOG.debug(" Addr: %04x/%04x" % (addr, _addr))
+ raise errors.RadioError("Radio send unexpected block")
+ cs = _checksum(result[1:-2])
+ if cs != ord(result[-2]):
+ _finish(radio)
+ LOG.debug("Calculated: %02x" % cs)
+ LOG.debug("Actual: %02x" % ord(result[-2]))
+ raise errors.RadioError("Block at 0x%04x failed checksum" % addr)
+ return data
+
+
+def _finish(radio):
+ endframe = "\x45\x4E\x44"
+ _echo_write(radio, endframe)
+ result = radio.pipe.read(1)
+ if result != "\x06":
+ LOG.error("Got:\n%s" % util.hexprint(result))
+ raise errors.RadioError("Radio did not finish cleanly")
+
+
+def do_download(radio):
+
+ _ident(radio)
+
+ _memobj = None
+ data = ""
+
+ for addr in range(0, radio._memsize, 0x10):
+ block = _send(radio, 'R', addr, 0x10)
+ data += block
+ status = chirp_common.Status()
+ status.cur = len(data)
+ status.max = radio._memsize
+ status.msg = "Downloading from radio"
+ radio.status_fn(status)
+
+ _finish(radio)
+
+ return memmap.MemoryMap(data)
+
+
+def do_upload(radio):
+ model, bandlimit = _ident(radio)
+ _embedded = radio._memobj.embedded_msg
+
+ if model != str(_embedded.radio_type):
+ LOG.warning('radio and image model types differ')
+ LOG.warning('model type (radio): %s' % str(model))
+ LOG.warning('model type (image): %s' % str(_embedded.radio_type))
+
+ _finish(radio)
+
+ msg = ("The upload was stopped because the radio type "
+ "of the image (%s) does not match that "
+ "of the radio (%s).")
+ raise errors.RadioError(msg % (str(_embedded.radio_type),
str(model)))
+
+ if bandlimit != int(_embedded.mode):
+ if str(_embedded.radio_type) == "RT98U":
+ image_band_limits = LIST_RT98U_FREQS[int(_embedded.mode)]
+ if str(_embedded.radio_type) == "RT98V":
+ image_band_limits = LIST_RT98V_FREQS[int(_embedded.mode)]
+ if model == "RT98U":
+ radio_band_limits = LIST_RT98U_FREQS[int(bandlimit)]
+ if model == "RT98V":
+ radio_band_limits = LIST_RT98V_FREQS[int(bandlimit)]
+
+ LOG.warning('radio and image band limits differ')
+ LOG.warning('image band limits: %s' % image_band_limits)
+ LOG.warning('radio band limits: %s' % radio_band_limits)
+
+ _finish(radio)
+
+ msg = ("The upload was stopped because the band limits "
+ "of the image (%s) does not match that "
+ "of the radio (%s).")
+ raise errors.RadioError(msg % (image_band_limits,
radio_band_limits))
+
+ try:
+ for start, end in radio._ranges:
+ for addr in range(start, end, 0x10):
+ block = radio._mmap[addr:addr+0x10]
+ _send(radio, 'W', addr, len(block), block)
+ status = chirp_common.Status()
+ status.cur = addr
+ status.max = end
+ status.msg = "Uploading to Radio"
+ radio.status_fn(status)
+ _finish(radio)
+ except errors.RadioError:
+ raise
+ except Exception as e:
+ _finish(radio)
+ raise errors.RadioError('Failed to upload to radio: %s' % e)
+
+
+#
+# The base class, extended for use with other models
+#
+class Rt98BaseRadio(chirp_common.CloneModeRadio,
+ chirp_common.ExperimentalRadio):
+ """Retevis RT98 Base"""
+ VENDOR = "Retevis"
+ MODEL = "RT98 Base"
+ BAUD_RATE = 9600
+
+ _memsize = 0x3E00
+ _ranges = [(0x0000, 0x3310),
+ (0x3320, 0x3390)]
+
+ @classmethod
+ def get_prompts(cls):
+ rp = chirp_common.RadioPrompts()
+ rp.experimental = ("The Retevis RT98 driver is an beta version."
+ "Proceed with Caution and backup your data")
+ return rp
+
+ def get_features(self):
+ _embedded = self._memobj.embedded_msg
+ rf = chirp_common.RadioFeatures()
+ rf.has_settings = True
+ rf.has_bank = False
+ rf.can_odd_split = True
+ rf.has_name = True
+ if _embedded.mode == 0: # PMR or FreeNet
+ rf.has_offset = False
+ else:
+ rf.has_offset = True
+ rf.has_ctone = True
+ rf.has_cross = True
+ rf.has_tuning_step = False
+ rf.has_dtcs = True
+ rf.has_rx_dtcs = True
+ rf.has_dtcs_polarity = True
+ rf.valid_skips = ["", "S"]
+ rf.memory_bounds = (1, 199)
+ rf.valid_name_length = 6
+ if _embedded.mode == 0: # PMR or FreeNet
+ rf.valid_duplexes = ['']
+ else:
+ rf.valid_duplexes = DUPLEXES + ['split', 'off']
+ rf.valid_characters = chirp_common.CHARSET_UPPER_NUMERIC + "- "
+ if _embedded.mode == 0: # PMR or FreeNet
+ rf.valid_modes = ['NFM']
+ else:
+ rf.valid_modes = ['FM', 'NFM']
+ rf.valid_tmodes = ['', 'Tone', 'TSQL', 'DTCS', 'Cross']
+ rf.valid_cross_modes = CROSS_MODES
+ if _embedded.mode == 0: # PMR or FreeNet
+ if str(_embedded.radio_type) == "RT98U":
+ rf.valid_power_levels = PMR_POWER_LEVELS
+ if str(_embedded.radio_type) == "RT98V":
+ rf.valid_power_levels = FREENET_POWER_LEVELS
+ else:
+ rf.valid_power_levels = POWER_LEVELS
+ rf.valid_dtcs_codes = chirp_common.ALL_DTCS_CODES
+
+ try:
+ rf.valid_bands = get_band_limits_Hz(
+ str(_embedded.radio_type),
+ int(_embedded.mode))
+ except TypeError as e:
+ # If we're asked without memory loaded, assume the most
permissive
+ rf.valid_bands = get_band_limits_Hz(str(_embedded.radio_type),
1)
+ except Exception as e:
+ LOG.error('Failed to get band limits for RT98: %s' % e)
+ rf.valid_bands = get_band_limits_Hz(str(_embedded.radio_type),
1)
+
+ rf.valid_tuning_steps = TUNING_STEPS
+ return rf
+
+ def validate_memory(self, mem):
+ _embedded = self._memobj.embedded_msg
+ msgs = ""
+ msgs = chirp_common.CloneModeRadio.validate_memory(self, mem)
+
+ # FreeNet and PMR radio types
+ if _embedded.mode == 0: # PMR or FreeNet
+ freq = float(mem.freq) / 1000000
+
+ # FreeNet
+ if str(_embedded.radio_type) == "RT98V":
+ if freq not in FREENET_FREQS:
+ _msg_freq = 'Memory location not a valid FreeNet
frequency'
+ # warn user invalid frequency
+ msgs.append(chirp_common.ValidationError(_msg_freq))
+
+ # PMR
+ if str(_embedded.radio_type) == "RT98U":
+ if freq not in PMR_FREQS:
+ _msg_freq = 'Memory location not a valid PMR frequency'
+ # warn user invalid frequency
+ msgs.append(chirp_common.ValidationError(_msg_freq))
+
+ return msgs
+
+ # Do a download of the radio from the serial port
+ def sync_in(self):
+ self._mmap = do_download(self)
+ self.process_mmap()
+
+ # Do an upload of the radio to the serial port
+ def sync_out(self):
+ do_upload(self)
+
+ def process_mmap(self):
+ self._memobj = bitwise.parse(MEM_FORMAT, self._mmap)
+
+ # Return a raw representation of the memory object, which
+ # is very helpful for development
+ def get_raw_memory(self, number):
+ return repr(self._memobj.memory[number - 1])
+
+ def _get_dcs_index(self, _mem, which):
+ base = getattr(_mem, '%scode' % which)
+ extra = getattr(_mem, '%sdcsextra' % which)
+ return (int(extra) << 8) | int(base)
+
+ def _set_dcs_index(self, _mem, which, index):
+ base = getattr(_mem, '%scode' % which)
+ extra = getattr(_mem, '%sdcsextra' % which)
+ base.set_value(index & 0xFF)
+ extra.set_value(index >> 8)
+
+ # Extract a high-level memory object from the low-level memory map
+ # This is called to populate a memory in the UI
+ def get_memory(self, number):
+ _embedded = self._memobj.embedded_msg
+ # Get a low-level memory object mapped to the image
+ _mem = self._memobj.memory[number - 1]
+
+ # get flag info
+ cbyte = (number - 1) / 8
+ cbit = 7 - ((number - 1) % 8)
+ setflag = self._memobj.csetflag[cbyte].c[cbit]
+ skipflag = self._memobj.cskipflag[cbyte].c[cbit]
+
+ mem = chirp_common.Memory()
+
+ mem.number = number # Set the memory number
+
+ # We'll consider any blank (i.e. 0MHz frequency) to be empty
+ if _mem.freq == 0:
+ mem.empty = True
+ return mem
+
+ if setflag == 0:
+ mem.empty = True
+ return mem
+
+ if _mem.get_raw()[0] == "\xFF":
+ mem.empty = True
+ return mem
+
+ # set the name
+ mem.name = str(_mem.name).rstrip() # Set the alpha tag
+
+ # Convert your low-level frequency and offset to Hertz
+ mem.freq = int(_mem.freq) * 10
+ mem.offset = int(_mem.offset) * 10
+
+ # Set the duplex flags
+ if _mem.duplex == DUPLEX_POSSPLIT:
+ mem.duplex = '+'
+ elif _mem.duplex == DUPLEX_NEGSPLIT:
+ mem.duplex = '-'
+ elif _mem.duplex == DUPLEX_NOSPLIT:
+ mem.duplex = ''
+ elif _mem.duplex == DUPLEX_ODDSPLIT:
+ mem.duplex = 'split'
+ else:
+ LOG.error('%s: get_mem: unhandled duplex: %02x' %
+ (mem.name, _mem.duplex))
+
+ # handle tx off
+ if _mem.tx_off:
+ mem.duplex = 'off'
+
+ # Set the channel width
+ if _mem.channel_width == CHANNEL_WIDTH_12d5kHz:
+ mem.mode = 'NFM'
+ elif _embedded.mode == 0: # PMR or FreeNet
+ LOG.info('PMR and FreeNet channels must be Channel Width
12.5kHz')
+ mem.mode = 'NFM'
+ elif _mem.channel_width == CHANNEL_WIDTH_25kHz:
+ mem.mode = 'FM'
+ elif _mem.channel_width == CHANNEL_WIDTH_20kHz:
+ LOG.info(
+ '%s: get_mem: promoting 20kHz channel width to 25kHz' %
+ mem.name)
+ mem.mode = 'FM'
+ else:
+ LOG.error('%s: get_mem: unhandled channel width: 0x%02x' %
+ (mem.name, _mem.channel_width))
+
+ # set the power level
+ if _embedded.mode == 0: # PMR or FreeNet
+ if str(_embedded.radio_type) == "RT98U":
+ LOG.info('using PMR power levels')
+ _levels = PMR_POWER_LEVELS
+ if str(_embedded.radio_type) == "RT98V":
+ LOG.info('using FreeNet power levels')
+ _levels = FREENET_POWER_LEVELS
+ else: # COM or COMII
+ LOG.info('using general power levels')
+ _levels = POWER_LEVELS
+
+ if _mem.txpower == TXPOWER_LOW:
+ mem.power = _levels[0]
+ elif _embedded.mode == 0: # PMR or FreeNet
+ LOG.info('FreeNet or PMR channel is not set to TX Power Low')
+ LOG.info('Setting channel to TX Power Low')
+ mem.power = _levels[0]
+ elif _mem.txpower == TXPOWER_MED:
+ mem.power = _levels[1]
+ elif _mem.txpower == TXPOWER_HIGH:
+ mem.power = _levels[2]
+ else:
+ LOG.error('%s: get_mem: unhandled power level: 0x%02x' %
+ (mem.name, _mem.txpower))
+
+ # CTCSS Tones and DTCS Codes
+ rxtone = txtone = None
+
+ rxmode = TMODES[_mem.rxtmode]
+ txmode = TMODES[_mem.txtmode]
+
+ if rxmode == "Tone":
+ rxtone = TONES[_mem.rxtone]
+ elif rxmode == "DTCS":
+ rxtone = chirp_common.ALL_DTCS_CODES[self._get_dcs_index(
+ _mem, 'rx')]
+
+ if txmode == "Tone":
+ txtone = TONES[_mem.txtone]
+ elif txmode == "DTCS":
+ txtone = chirp_common.ALL_DTCS_CODES[self._get_dcs_index(
+ _mem, 'tx')]
+
+ rxpol = _mem.rxinv and "R" or "N"
+ txpol = _mem.txinv and "R" or "N"
+
+ chirp_common.split_tone_decode(mem,
+ (txmode, txtone, txpol),
+ (rxmode, rxtone, rxpol))
+
+ # Check if this memory is in the scan enabled list
+ mem.skip = "S" if skipflag == 0 else ""
+
+ # Extra
+ mem.extra = RadioSettingGroup("extra", "Extra")
+
+ rs = RadioSettingValueBoolean(bool(_mem.busychannellockout))
+ rset = RadioSetting("busychannellockout", "Busy channel lockout",
rs)
+ mem.extra.append(rset)
+
+ rs = RadioSettingValueBoolean(bool(_mem.reverse))
+ rset = RadioSetting("reverse", "Reverse", rs)
+ mem.extra.append(rset)
+
+ rs = RadioSettingValueBoolean(bool(_mem.talkaround))
+ rset = RadioSetting("talkaround", "Talk around", rs)
+ mem.extra.append(rset)
+
+ rs = RadioSettingValueBoolean(bool(_mem.squelch_mode))
+ rset = RadioSetting("squelch_mode", "Squelch mode", rs)
+ mem.extra.append(rset)
+
+ return mem
+
+ # Store details about a high-level memory to the memory map
+ # This is called when a user edits a memory in the UI
+ def set_memory(self, mem):
+ _embedded = self._memobj.embedded_msg
+ # Get a low-level memory object mapped to the image
+
+ _mem = self._memobj.memory[mem.number - 1]
+
+ cbyte = (mem.number - 1) / 8
+ cbit = 7 - ((mem.number - 1) % 8)
+
+ if mem.empty:
+ self._memobj.csetflag[cbyte].c[cbit] = 0
+ self._memobj.cskipflag[cbyte].c[cbit] = 0
+ _mem.set_raw('\xff' * (_mem.size() / 8))
+ return
+
+ _mem.set_raw('\x00' * (_mem.size() / 8))
+
+ # set the occupied bitfield
+ self._memobj.csetflag[cbyte].c[cbit] = 1
+ # set the scan add bitfield
+ self._memobj.cskipflag[cbyte].c[cbit] = 0 if (mem.skip == "S")
else 1
+
+ _mem.freq = mem.freq / 10 # Convert to low-level
frequency
+ _mem.offset = mem.offset / 10 # Convert to low-level
frequency
+
+ # Store the alpha tag
+ _mem.name = mem.name.ljust(6)[:6] # Store the alpha tag
+
+ # Set duplex bitfields
+ if mem.duplex == '+':
+ _mem.duplex = DUPLEX_POSSPLIT
+ elif mem.duplex == '-':
+ _mem.duplex = DUPLEX_NEGSPLIT
+ elif mem.duplex == '':
+ _mem.duplex = DUPLEX_NOSPLIT
+ elif mem.duplex == 'split':
+ diff = mem.offset - mem.freq
+ _mem.duplex = DUPLEXES.index("-") \
+ if diff < 0 else DUPLEXES.index("+")
+ _mem.offset = abs(diff) / 10
+ else:
+ LOG.error('%s: set_mem: unhandled duplex: %s' %
+ (mem.name, mem.duplex))
+
+ # handle tx off
+ _mem.tx_off = 0
+ if mem.duplex == 'off':
+ _mem.tx_off = 1
+
+ # Set the channel width - remember we promote 20kHz channels to FM
+ # on import, so don't handle them here
+ if mem.mode == 'FM':
+ _mem.channel_width = CHANNEL_WIDTH_25kHz
+ elif mem.mode == 'NFM':
+ _mem.channel_width = CHANNEL_WIDTH_12d5kHz
+ else:
+ LOG.error('%s: set_mem: unhandled mode: %s' % (
+ mem.name, mem.mode))
+
+ # CTCSS Tones and DTCS Codes
+ ((txmode, txtone, txpol),
+ (rxmode, rxtone, rxpol)) = chirp_common.split_tone_encode(mem)
+
+ _mem.txtmode = TMODES.index(txmode)
+
+ _mem.rxtmode = TMODES.index(rxmode)
+
+ if txmode == "Tone":
+ _mem.txtone = TONES.index(txtone)
+ elif txmode == "DTCS":
+ self._set_dcs_index(_mem, 'tx',
+ chirp_common.ALL_DTCS_CODES.index(txtone))
+
+ _mem.squelch_mode = False
+ if rxmode == "Tone":
+ _mem.rxtone = TONES.index(rxtone)
+ _mem.squelch_mode = True
+ elif rxmode == "DTCS":
+ self._set_dcs_index(_mem, 'rx',
+ chirp_common.ALL_DTCS_CODES.index(rxtone))
+ _mem.squelch_mode = True
+
+ _mem.txinv = txpol == "R"
+ _mem.rxinv = rxpol == "R"
+
+ # set the power level
+ if mem.power == POWER_LEVELS[0]:
+ _mem.txpower = TXPOWER_LOW
+ elif mem.power == POWER_LEVELS[1]:
+ _mem.txpower = TXPOWER_MED
+ elif mem.power == POWER_LEVELS[2]:
+ _mem.txpower = TXPOWER_HIGH
+ else:
+ LOG.error('%s: set_mem: unhandled power level: %s' %
+ (mem.name, mem.power))
+
+ # extra settings
+ for setting in mem.extra:
+ setattr(_mem, setting.get_name(), setting.value)
+
+ def _get_settings(self):
+ _embedded = self._memobj.embedded_msg
+ _settings = self._memobj.settings
+ _settings2 = self._memobj.settings2
+ _settings3 = self._memobj.settings3
+ _slabel = self._memobj.slabel
+
+ function = RadioSettingGroup("function", "Function Setup")
+ group = RadioSettings(function)
+
+ # Function Setup
+ # MODE SET
+ rs = RadioSettingValueList(LIST_DISPLAY_MODE,
+
LIST_DISPLAY_MODE[_settings.display_mode])
+ rset = RadioSetting("display_mode", "Display Mode", rs)
+ function.append(rset)
+
+ rs = RadioSettingValueInteger(1, 199, _settings3.ch_number + 1)
+ rset = RadioSetting("settings3.ch_number", "Channel Number", rs)
+ function.append(rset)
+
+ # DISPLAY SET
+ def _filter(name):
+ filtered = ""
+ for char in str(name):
+ if char in chirp_common.CHARSET_ASCII:
+ filtered += char
+ else:
+ filtered += " "
+ return filtered
+
+ val = RadioSettingValueString(0, 6, _filter(_slabel.startname))
+ rs = RadioSetting("slabel.startname", "Startup Label", val)
+ function.append(rs)
+
+ # VOL SET
+ rs = RadioSettingValueBoolean(bool(_settings.beep))
+ rset = RadioSetting("beep", "Beep Prompt", rs)
+ function.append(rset)
+
+ rs = RadioSettingValueInteger(1, 30, _settings.volume)
+ rset = RadioSetting("volume", "Volume Level", rs)
+ function.append(rset)
+
+ rs = RadioSettingValueInteger(1, 16, _settings.mic_gain)
+ rset = RadioSetting("mic_gain", "Mic Gain", rs)
+ function.append(rset)
+
+ # ON/OFF SET
+ rs = RadioSettingValueList(LIST_APO,
+ LIST_APO[_settings.auto_power_off])
+ rset = RadioSetting("auto_power_off", "Auto Power Off", rs)
+ function.append(rset)
+
+ rs = RadioSettingValueList(LIST_AOP,
LIST_AOP[_settings.auto_power_on])
+ rset = RadioSetting("auto_power_on", "Power On Method", rs)
+ function.append(rset)
+
+ # STE SET
+ rs = RadioSettingValueList(LIST_STE_FREQ,
+ LIST_STE_FREQ[_settings.ste_frequency])
+ rset = RadioSetting("ste_frequency", "STE Frequency", rs)
+ function.append(rset)
+
+ rs = RadioSettingValueList(LIST_STE_TYPE,
+ LIST_STE_TYPE[_settings.ste_type])
+ rset = RadioSetting("ste_type", "STE Type", rs)
+ function.append(rset)
+
+ # FUNCTION SET
+ rs = RadioSettingValueList(LIST_STEP,
LIST_STEP[_settings.tuning_step])
+ rset = RadioSetting("tuning_step", "Tuning Step", rs)
+ function.append(rset)
+
+ rs = RadioSettingValueList(LIST_SQUELCH,
+ LIST_SQUELCH[_settings.squelch])
+ rset = RadioSetting("squelch", "Squelch Level", rs)
+ function.append(rset)
+
+ rs = RadioSettingValueBoolean(bool(_settings.sql_key_function))
+ rset = RadioSetting("sql_key_function", "SQL Key Function", rs)
+ function.append(rset)
+
+ rs = RadioSettingValueList(LIST_TIMEOUT,
+ LIST_TIMEOUT[_settings.timeout_timer])
+ rset = RadioSetting("timeout_timer", "Timeout Timer", rs)
+ function.append(rset)
+
+ # uncategorized
+ rs = RadioSettingValueBoolean(bool(_settings.save_chan_param))
+ rset = RadioSetting("save_chan_param", "Save Channel Parameters",
rs)
+ function.append(rset)
+
+ rs = RadioSettingValueBoolean(bool(_settings.forbid_chan_menu))
+ rset = RadioSetting("forbid_chan_menu", "Forbid Channel Menu", rs)
+ function.append(rset)
+
+ rs = RadioSettingValueBoolean(bool(not
_settings.forbid_initialize))
+ rset = RadioSetting("forbid_initialize", "Forbid Initialize", rs)
+ function.append(rset)
+
+ rs = RadioSettingValueBoolean(bool(_settings.forbid_setting))
+ rset = RadioSetting("forbid_setting", "Forbid Setting", rs)
+ function.append(rset)
+
+ # Information Of Scanning Channel
+ scanning = RadioSettingGroup("scanning", "Scanning Setup")
+ group.append(scanning)
+
+ rs = RadioSettingValueBoolean(bool(_settings2.scan_mode))
+ rset = RadioSetting("settings2.scan_mode", "Scan Mode", rs)
+ scanning.append(rset)
+
+ rs = RadioSettingValueList(LIST_PRIORITY_CH,
+
LIST_PRIORITY_CH[_settings2.priority_ch])
+ rset = RadioSetting("settings2.priority_ch", "Priority Channel",
rs)
+ scanning.append(rset)
+
+ rs = RadioSettingValueInteger(1, 199, _settings2.priority_ch1 + 1)
+ rset = RadioSetting("settings2.priority_ch1", "Priority Channel
1", rs)
+ scanning.append(rset)
+
+ rs = RadioSettingValueInteger(1, 199, _settings2.priority_ch2 + 1)
+ rset = RadioSetting("settings2.priority_ch2", "Priority Channel
2", rs)
+ scanning.append(rset)
+
+ rs = RadioSettingValueList(LIST_REVERT_CH,
+ LIST_REVERT_CH[_settings2.revert_ch])
+ rset = RadioSetting("settings2.revert_ch", "Revert Channel", rs)
+ scanning.append(rset)
+
+ rs = RadioSettingValueList(LIST_TIME46,
+
LIST_TIME46[_settings2.look_back_time_a])
+ rset = RadioSetting("settings2.look_back_time_a",
+ "Look Back Time A", rs)
+ scanning.append(rset)
+
+ rs = RadioSettingValueList(LIST_TIME46,
+
LIST_TIME46[_settings2.look_back_time_b])
+ rset = RadioSetting("settings2.look_back_time_b",
+ "Look Back Time B", rs)
+ scanning.append(rset)
+
+ rs = RadioSettingValueList(LIST_TIME50,
+
LIST_TIME50[_settings2.dropout_delay_time])
+ rset = RadioSetting("settings2.dropout_delay_time",
+ "Dropout Delay Time", rs)
+ scanning.append(rset)
+
+ rs = RadioSettingValueList(LIST_TIME50,
+ LIST_TIME50[_settings2.dwell_time])
+ rset = RadioSetting("settings2.dwell_time", "Dwell Time", rs)
+ scanning.append(rset)
+
+ # Embedded Message
+ embedded = RadioSettingGroup("embedded", "Embedded Message")
+ group.append(embedded)
+
+ rs = RadioSettingValueString(0, 5, _filter(_embedded.radio_type))
+ rs.set_mutable(False)
+ rset = RadioSetting("embedded_msg.radio_type", "Radio Type", rs)
+ embedded.append(rset)
+
+ if str(_embedded.radio_type) == "RT98V":
+ options = LIST_RT98V_MODES
+ else:
+ options = LIST_RT98U_MODES
+ rs = RadioSettingValueList(options, options[_embedded.mode])
+ rs.set_mutable(False)
+ rset = RadioSetting("embedded_msg.mode", "Mode", rs)
+ embedded.append(rset)
+
+ # frequency
+ if str(_embedded.radio_type) == "RT98V":
+ options = LIST_RT98V_FREQS
+ else:
+ options = LIST_RT98U_FREQS
+ rs = RadioSettingValueList(options, options[_settings3.bandlimit])
+ rs.set_mutable(False)
+ rset = RadioSetting("settings3.bandlimit", "Frequency", rs)
+ embedded.append(rset)
+
+ rs = RadioSettingValueString(0, 10, _filter(_embedded.date_mfg))
+ rs.set_mutable(False)
+ rset = RadioSetting("embedded_msg.date_mfg", "Production Date", rs)
+ embedded.append(rset)
+
+ rs = RadioSettingValueString(0, 4, _filter(_embedded.mcu_version))
+ rs.set_mutable(False)
+ rset = RadioSetting("embedded_msg.mcu_version", "MCU Version", rs)
+ embedded.append(rset)
+
+ return group
+
+ def get_settings(self):
+ try:
+ return self._get_settings()
+ except:
+ import traceback
+ LOG.error("failed to parse settings")
+ traceback.print_exc()
+ return None
+
+ def set_settings(self, settings):
+ for element in settings:
+ if not isinstance(element, RadioSetting):
+ self.set_settings(element)
+ continue
+ else:
+ try:
+ if "." in element.get_name():
+ bits = element.get_name().split(".")
+ obj = self._memobj
+ for bit in bits[:-1]:
+ obj = getattr(obj, bit)
+ setting = bits[-1]
+ else:
+ obj = self._memobj.settings
+ setting = element.get_name()
+
+ if element.has_apply_callback():
+ LOG.debug("using apply callback")
+ element.run_apply_callback()
+ elif setting == "ch_number":
+ setattr(obj, setting, int(element.value) - 1)
+ elif setting == "forbid_initialize":
+ setattr(obj, setting, not int(element.value))
+ elif setting == "priority_ch1":
+ setattr(obj, setting, int(element.value) - 1)
+ elif setting == "priority_ch2":
+ setattr(obj, setting, int(element.value) - 1)
+ elif element.value.get_mutable():
+ LOG.debug("Setting %s = %s" % (setting,
element.value))
+ setattr(obj, setting, element.value)
+ except Exception, e:
+ LOG.debug(element.get_name())
+ raise
+
+ @classmethod
+ def match_model(cls, filedata, filename):
+ # This radio has always been post-metadata, so never do
+ # old-school detection
+ return False
+
+
+ at directory.register
+class Rt98Radio(Rt98BaseRadio):
+ """Retevis RT98"""
+ VENDOR = "Retevis"
+ MODEL = "RT98"
+ # Allowed radio types is a dict keyed by model of a list of version
+ # strings
+ ALLOWED_RADIO_TYPES = {'RT98V': ['V100'],
+ 'RT98U': ['V100']}
diff -r f586574bc878 -r 0eab8146b294 tools/cpep8.manifest
--- a/tools/cpep8.manifest Thu Jun 17 21:57:05 2021 -0400
+++ b/tools/cpep8.manifest Sat Jul 03 14:13:35 2021 -0400
@@ -83,6 +83,7 @@
./chirp/drivers/retevis_rt23.py
./chirp/drivers/retevis_rt26.py
./chirp/drivers/retevis_rt76p.py
+./chirp/drivers/retevis_rt98.py
./chirp/drivers/rfinder.py
./chirp/drivers/tdxone_tdq8a.py
./chirp/drivers/template.py
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://intrepid.danplanet.com/pipermail/chirp_devel/attachments/20210703/8b31906f/attachment-0001.html
More information about the chirp_devel
mailing list