class RB17ARadio(RT21Radio):
"""RETEVIS RB17A"""
VENDOR = "Retevis"
MODEL = "RB17A"
BAUD_RATE = 9600
BLOCK_SIZE = 0x40
BLOCK_SIZE_UP = 0x10
POWER_LEVELS = [chirp_common.PowerLevel("Low", watts=0.50),
chirp_common.PowerLevel("High", watts=5.00)]
_magic = "PROA8US"
_fingerprint = "P3217s\xF8\xFF"
_upper = 30
_skipflags = True
_reserved = False
_gmrs = True
_ranges = [
(0x0000, 0x0300),
]
_memsize = 0x0300
def process_mmap(self):
self._memobj = bitwise.parse(MEM_FORMAT_RB17A, self._mmap)
class JetstreamJT270MHRadio(LeixenVV898Radio):
"""Jetstream JT270MH"""
VENDOR = "Jetstream"
MODEL = "JT270MH"
_file_ident = "Leixen"
_model_ident = 'LX-\x89\x85\x85'
_ranges = [(0x0C00, 0x2000)]
_mem_formatter = {'unknownormode': 'mode:1',
'modeorpower': 'power:2',
'chanstart': 0x0C00,
'namestart': 0x1900,
'defaults': 6}
_power_levels = [chirp_common.PowerLevel("Low", watts=5),
chirp_common.PowerLevel("Mid", watts=10),
chirp_common.PowerLevel("High", watts=25)]
def get_features(self):
rf = super(JetstreamJT270MHRadio, self).get_features()
rf.has_sub_devices = self.VARIANT == ''
rf.memory_bounds = (1, 99)
return rf
def get_sub_devices(self):
return [JetstreamJT270MHRadioA(self._mmap),
JetstreamJT270MHRadioB(self._mmap)]
def _get_memobjs(self, number):
number = number * 2 - self._offset
_mem = self._memobj.memory[number]
_name = self._memobj.name[number]
return _mem, _name
class RT76Radio(RT21Radio):
"""RETEVIS RT76"""
VENDOR = "Retevis"
MODEL = "RT76"
BAUD_RATE = 9600
BLOCK_SIZE = 0x20
BLOCK_SIZE_UP = 0x10
POWER_LEVELS = [chirp_common.PowerLevel("Low", watts=0.50),
chirp_common.PowerLevel("High", watts=5.00)]
_magic = "PHOGR\x14\xD4"
_fingerprint = "P32073" + "\x02\xFF"
_upper = 30
_skipflags = False
_reserved = True
_gmrs = True
_ranges = [
(0x0000, 0x01E0),
]
_memsize = 0x01E0
def process_mmap(self):
self._memobj = bitwise.parse(MEM_FORMAT_RT76, self._mmap)
def __init__(self, arg):
self.POWER_LEVELS = list([chirp_common.PowerLevel('lo', watts=5),
chirp_common.PowerLevel('hi', watts=50)])
self.TMODES = list(['', 'Tone', 'TSQL'])
self.HAS_CTONE = True
self.HAS_RX_DTCS = False
self.MODES = list(['FM', 'AM', 'DV'])
self.DUPLEXES = list(['', '-', '+'])
class DJ175Radio(DRx35Radio):
"""Alinco DJ175"""
VENDOR = "Alinco"
MODEL = "DJ175"
_model = "DJ175"
_memsize = 6896
_range = [(136000000, 174000000), (400000000, 511000000)]
_power_levels = [
chirp_common.PowerLevel("Low", watts=0.50),
chirp_common.PowerLevel("Mid", watts=2.00),
chirp_common.PowerLevel("High", watts=5.00),
]
@classmethod
def match_model(cls, filedata, filename):
return len(filedata) == cls._memsize
def _get_used(self, number):
return self._memobj.memory[number].new_used
def _set_used(self, number, is_used):
self._memobj.memory[number].new_used = is_used
def _get_power(self, _mem):
return self._power_levels[_mem.power]
def _set_power(self, _mem, mem):
if mem.power in self._power_levels:
_mem.power = self._power_levels.index(mem.power)
def _download_chunk(self, addr):
if addr % 16:
raise Exception("Addr 0x%04x not on 16-byte boundary" % addr)
cmd = "AL~F%04XR\r\n" % addr
self._send(cmd)
_data = self._read(34).strip()
if len(_data) == 0:
raise errors.RadioError("No response from radio")
data = ""
for i in range(0, len(_data), 2):
data += chr(int(_data[i:i + 2], 16))
if len(data) != 16:
LOG.debug("Response was:")
LOG.debug("|%s|")
LOG.debug("Which I converted to:")
LOG.debug(util.hexprint(data))
raise Exception("Radio returned less than 16 bytes")
return data
def test_import_power_closest(self):
radio = FakeRadio(None)
src_rf = chirp_common.RadioFeatures()
src_rf.valid_power_levels = [
chirp_common.PowerLevel('foo', watts=7),
chirp_common.PowerLevel('bar', watts=51),
chirp_common.PowerLevel('baz', watts=1),
]
mem = chirp_common.Memory()
mem.power = src_rf.valid_power_levels[0]
import_logic._import_power(radio, src_rf, mem)
self.assertEqual(mem.power, radio.POWER_LEVELS[0])
class VX170Radio(ft7800.FTx800Radio):
"""Yaesu VX-170"""
MODEL = "VX-170"
_model = "AH022"
_memsize = 6057
_block_lengths = [8, 6048, 1]
_block_size = 32
POWER_LEVELS_VHF = [chirp_common.PowerLevel("Hi", watts=5.00),
chirp_common.PowerLevel("Med", watts=2.00),
chirp_common.PowerLevel("Lo", watts=0.50)]
MODES = ["FM", "NFM"]
TMODES = ["", "Tone", "TSQL", "DTCS"]
@classmethod
def get_prompts(cls):
rp = chirp_common.RadioPrompts()
rp.pre_download = _(dedent("""\
1. Turn radio off.
2. Connect cable to MIC/SP jack.
3. Press and hold in the [moni] key while turning the radio on.
4. Select CLONE in menu, then press F. Radio restarts in clone mode.
("CLONE" will appear on the display).
5. <b>After clicking OK</b>, breifly hold [PTT] key to send image.
("-TX-" will appear on the LCD). """))
rp.pre_upload = _(dedent("""\
1. Turn radio off.
3. Press and hold in the [moni] key while turning the radio on.
4. Select CLONE in menu, then press F. Radio restarts in clone mode.
("CLONE" will appear on the display).
5. Press the [moni] key ("-RX-" will appear on the LCD)."""))
return rp
def _checksums(self):
return [yaesu_clone.YaesuChecksum(0x0000, self._memsize - 2)]
def process_mmap(self):
self._memobj = bitwise.parse(MEM_FORMAT, self._mmap)
def get_features(self):
rf = super(VX170Radio, self).get_features()
rf.has_bank = False
rf.has_bank_names = False
rf.valid_modes = self.MODES
rf.memory_bounds = (1, 200)
rf.valid_bands = [(137000000, 174000000)]
return rf
class LeixenVV898SRadio(LeixenVV898Radio):
"""Leixen VV-898S, also VV-898E which is identical"""
VENDOR = "Leixen"
MODEL = "VV-898S"
ALIASES = [VV898E, ]
_model_ident = 'LX-\x89\x85\x75'
_mem_formatter = {'unknownormode': 'mode:1',
'modeorpower': 'power:2',
'chanstart': 0x0D00,
'namestart': 0x19B0,
'defaults': 3}
_power_levels = [chirp_common.PowerLevel("Low", watts=5),
chirp_common.PowerLevel("Med", watts=10),
chirp_common.PowerLevel("High", watts=25)]
class DJ596Radio(DRx35Radio):
"""Alinco DJ596"""
VENDOR = "Alinco"
MODEL = "DJ596"
_model = "DJ596"
_memsize = 4096
_range = [(136000000, 174000000), (400000000, 511000000)]
_power_levels = [
chirp_common.PowerLevel("Low", watts=1.00),
chirp_common.PowerLevel("High", watts=5.00)
]
@classmethod
def match_model(cls, filedata, filename):
return len(filedata) == cls._memsize and \
filedata[0x64] == chr(0x45) and filedata[0x65] == chr(0x01)
class KGUV8ERadio(chirp_common.CloneModeRadio,
chirp_common.ExperimentalRadio):
"""Wouxun KG-UV8E"""
VENDOR = "Wouxun"
MODEL = "KG-UV8E"
_model = "KG-UV8D-A"
_file_ident = "kguv8e" # lowercase
BAUD_RATE = 19200
POWER_LEVELS = [chirp_common.PowerLevel("L", watts=1),
chirp_common.PowerLevel("H", watts=5)]
_mmap = ""
def _checksum(self, data):
cs = 0
for byte in data:
cs += ord(byte)
return chr(cs % 256)
def _write_record(self, cmd, payload = None):
# build the packet
_header = '\x7b' + chr(cmd) + '\xff'
_length = 0
if payload:
_length = len(payload)
# update the length field
_header += chr(_length)
if payload:
# calculate checksum then add it with the payload to the packet and encrypt
crc = self._checksum(_header[1:] + payload)
payload += crc
_header += self.encrypt(payload)
else:
# calculate and add encrypted checksum to the packet
crc = self._checksum(_header[1:])
_header += self.strxor(crc, '\x57')
try:
self.pipe.write(_header)
except Exception, e:
raise errors.RadioError("Failed to communicate with radio: %s" % e)
CMD_ACK = "\x06"
WRITE_BLOCK_SIZE = 0x10
READ_BLOCK_SIZE = 0x40
CHAR_LENGTH_MAX = 6
OFF_ON_LIST = ["OFF", "ON"]
ON_OFF_LIST = ["ON", "OFF"]
NO_YES_LIST = ["NO", "YES"]
STEP_LIST = ["5.0", "6.25", "10.0", "12.5", "25.0"]
BAT_SAVE_LIST = ["OFF", "0.2 Sec", "0.4 Sec", "0.6 Sec", "0.8 Sec", "1.0 Sec"]
SHIFT_LIST = ["", "-", "+"]
SCANM_LIST = ["Time", "Carrier wave", "Search"]
ENDBEEP_LIST = ["OFF", "Begin", "End", "Begin/End"]
POWER_LEVELS = [
chirp_common.PowerLevel("Low", watts=1.00),
chirp_common.PowerLevel("Medium", watts=2.50),
chirp_common.PowerLevel("High", watts=5.00)
]
TIMEOUT_LIST = ["OFF", "1 Min", "3 Min", "10 Min"]
TOTALERT_LIST = ["", "OFF"] + ["%s seconds" % x for x in range(1, 11)]
VOX_LIST = ["OFF"] + ["%s" % x for x in range(1, 17)]
VOXDELAY_LIST = [
"0.3 Sec", "0.5 Sec", "1.0 Sec", "1.5 Sec", "2.0 Sec", "3.0 Sec",
"4.0 Sec", "5.0 Sec"
]
PRI_NUM = [3, 5, 8, 10]
PRI_NUM_LIST = [str(x) for x in PRI_NUM]
CH_FLAG_LIST = ["Channel+Freq", "Channel+Name"]
BACKLIGHT_LIST = ["Always Off", "Auto", "Always On"]
BUSYLOCK_LIST = ["NO", "Carrier", "SM"]
LIST_TTAUTORST = ["Off"] + ["%s s" % x for x in range(1, 16)]
LIST_TTGRPCODE = ["Off"] + list("ABCD*#")
LIST_TTINTCODE = DTMF_CHARS
LIST_TTALERT = [
"Off", "Alert tone", "Transpond", "Transpond-ID code",
"Transpond-transpond code"
]
LIST_TTAUTOD = ["%s" % x for x in range(1, 10)]
# valid chars on the LCD
VALID_CHARS = chirp_common.CHARSET_ALPHANUMERIC + \
"`{|}!\"#$%&'()*+,-./:;<=>?@[]^_"
# Power Levels
POWER_LEVELS = [
chirp_common.PowerLevel("Low", watts=5),
chirp_common.PowerLevel("Mid", watts=20),
chirp_common.PowerLevel("High", watts=50)
]
# B-TECH UV-50X3 id string
UV50X3_id = "VGC6600MD"
def _clean_buffer(radio):
radio.pipe.timeout = 0.005
junk = radio.pipe.read(256)
radio.pipe.timeout = STIMEOUT
if junk:
Log.debug("Got %i bytes of junk before starting" % len(junk))
tmode:2;
u8 tone;
u8 dtcs;
} memory[200];
#seekto 0x0E00;
struct {
char name[6];
} names[200];
"""
MODES = ["FM", "NFM"]
TMODES = ["", "Tone", "TSQL", "DTCS"]
DUPLEX = ["", "-", "+", ""]
POWER_LEVELS = [
chirp_common.PowerLevel("Hi", watts=65),
chirp_common.PowerLevel("Mid", watts=25),
chirp_common.PowerLevel("Low2", watts=10),
chirp_common.PowerLevel("Low1", watts=5),
]
CHARSET = chirp_common.CHARSET_UPPER_NUMERIC + "()+-=*/???|_"
@directory.register
class FT2800Radio(YaesuCloneModeRadio):
"""Yaesu FT-2800"""
VENDOR = "Yaesu"
MODEL = "FT-2800M"
_block_sizes = [8, 7680]
_memsize = 7680
# 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 logging
from textwrap import dedent
from chirp.drivers import yaesu_clone, ft1d
from chirp import chirp_common, directory, bitwise
from chirp.settings import RadioSettings
LOG = logging.getLogger(__name__)
POWER_LEVELS = [chirp_common.PowerLevel("Low", watts=5),
chirp_common.PowerLevel("Mid", watts=30),
chirp_common.PowerLevel("Hi", watts=65)]
TMODES = ["", "Tone", "TSQL", "DTCS", "TSQL-R", None, None, "Pager", "Cross"]
CROSS_MODES = [None, "DTCS->", "Tone->DTCS", "DTCS->Tone"]
MODES = ["FM", "NFM"]
STEPS = [0, 5, 6.25, 10, 12.5, 15, 20, 25, 50, 100] # 0 = auto
RFSQUELCH = ["OFF", "S1", "S2", "S3", "S4", "S5", "S6", "S7", "S8"]
# Charset is subset of ASCII + some unknown chars \x80-\x86
VALID_CHARS = ["%i" % int(x) for x in range(0, 10)] + \
list(":>=<?@") + \
[chr(x) for x in range(ord("A"), ord("Z") + 1)] + \
list("[\\]_") + \
class FT817Radio(yaesu_clone.YaesuCloneModeRadio):
"""Yaesu FT-817"""
BAUD_RATE = 9600
MODEL = "FT-817"
_model = ""
_US_model = False
DUPLEX = ["", "-", "+", "split"]
# narrow modes has to be at end
MODES = ["LSB", "USB", "CW", "CWR", "AM", "FM", "DIG", "PKT", "NCW",
"NCWR", "NFM"]
TMODES = ["", "Tone", "TSQL", "DTCS"]
STEPSFM = [5.0, 6.25, 10.0, 12.5, 15.0, 20.0, 25.0, 50.0]
STEPSAM = [2.5, 5.0, 9.0, 10.0, 12.5, 25.0]
STEPSSSB = [1.0, 2.5, 5.0]
# warning ranges has to be in this exact order
VALID_BANDS = [(100000, 33000000), (33000000, 56000000),
(76000000, 108000000), (108000000, 137000000),
(137000000, 154000000), (420000000, 470000000)]
CHARSET = list(chirp_common.CHARSET_ASCII)
CHARSET.remove("\\")
# Hi not used in memory
POWER_LEVELS = [chirp_common.PowerLevel("Hi", watts=5.00),
chirp_common.PowerLevel("L3", watts=2.50),
chirp_common.PowerLevel("L2", watts=1.00),
chirp_common.PowerLevel("L1", watts=0.5)]
_memsize = 6509
# block 9 (130 Bytes long) is to be repeted 40 times
_block_lengths = [ 2, 40, 208, 182, 208, 182, 198, 53, 130, 118, 118]
MEM_FORMAT = """
struct mem_struct {
u8 tag_on_off:1,
tag_default:1,
unknown1:3,
mode:3;
u8 duplex:2,
is_duplex:1,
is_cwdig_narrow:1,
is_fm_narrow:1,
freq_range:3;
u8 skip:1,
unknown2:1,
ipo:1,
att:1,
unknown3:4;
u8 ssb_step:2,
am_step:3,
fm_step:3;
u8 unknown4:6,
tmode:2;
u8 unknown5:2,
tx_mode:3,
tx_freq_range:3;
u8 unknown6:1,
unknown_toneflag:1,
tone:6;
u8 unknown7:1,
dcs:7;
ul16 rit;
u32 freq;
u32 offset;
u8 name[8];
};
#seekto 0x4;
struct {
u8 fst:1,
lock:1,
nb:1,
pbt:1,
unknownb:1,
dsp:1,
agc:2;
u8 vox:1,
vlt:1,
bk:1,
kyr:1,
unknown5:1,
cw_paddle:1,
pwr_meter_mode:2;
u8 vfob_band_select:4,
vfoa_band_select:4;
u8 unknowna;
u8 backlight:2,
color:2,
contrast:4;
u8 beep_freq:1,
beep_volume:7;
u8 arts_beep:2,
main_step:1,
cw_id:1,
scope:1,
pkt_rate:1,
resume_scan:2;
u8 op_filter:2,
lock_mode:2,
cw_pitch:4;
u8 sql_rf_gain:1,
ars_144:1,
ars_430:1,
cw_weight:5;
u8 cw_delay;
u8 unknown8:1,
sidetone:7;
u8 batt_chg:2,
cw_speed:6;
u8 disable_amfm_dial:1,
vox_gain:7;
u8 cat_rate:2,
emergency:1,
vox_delay:5;
u8 dig_mode:3,
mem_group:1,
unknown9:1,
apo_time:3;
u8 dcs_inv:2,
unknown10:1,
tot_time:5;
u8 mic_scan:1,
ssb_mic:7;
u8 mic_key:1,
am_mic:7;
u8 unknown11:1,
fm_mic:7;
u8 unknown12:1,
dig_mic:7;
u8 extended_menu:1,
pkt_mic:7;
u8 unknown14:1,
pkt9600_mic:7;
il16 dig_shift;
il16 dig_disp;
i8 r_lsb_car;
i8 r_usb_car;
i8 t_lsb_car;
i8 t_usb_car;
u8 unknown15:2,
menu_item:6;
u8 unknown16:4,
menu_sel:4;
u16 unknown17;
u8 art:1,
scn_mode:2,
dw:1,
pri:1,
unknown18:1,
tx_power:2;
u8 spl:1,
unknown:1,
uhf_antenna:1,
vhf_antenna:1,
air_antenna:1,
bc_antenna:1,
sixm_antenna:1,
hf_antenna:1;
} settings;
#seekto 0x2A;
struct mem_struct vfoa[15];
struct mem_struct vfob[15];
struct mem_struct home[4];
struct mem_struct qmb;
struct mem_struct mtqmb;
struct mem_struct mtune;
#seekto 0x3FD;
u8 visible[25];
u8 pmsvisible;
#seekto 0x417;
u8 filled[25];
u8 pmsfilled;
#seekto 0x431;
struct mem_struct memory[200];
struct mem_struct pms[2];
#seekto 0x18cf;
u8 callsign[7];
#seekto 0x1979;
struct mem_struct sixtymeterchannels[5];
"""
_CALLSIGN_CHARSET = [chr(x) for x in range(ord("0"), ord("9")+1) +
range(ord("A"), ord("Z")+1) +
[ord(" ")]]
_CALLSIGN_CHARSET_REV = dict(zip(_CALLSIGN_CHARSET,
range(0,len(_CALLSIGN_CHARSET))))
# WARNING Index are hard wired in memory management code !!!
SPECIAL_MEMORIES = {
"VFOa-1.8M" : -35,
"VFOa-3.5M" : -34,
"VFOa-7M" : -33,
"VFOa-10M" : -32,
"VFOa-14M" : -31,
"VFOa-18M" : -30,
"VFOa-21M" : -29,
"VFOa-24M" : -28,
"VFOa-28M" : -27,
"VFOa-50M" : -26,
"VFOa-FM" : -25,
"VFOa-AIR" : -24,
"VFOa-144" : -23,
"VFOa-430" : -22,
"VFOa-HF" : -21,
"VFOb-1.8M" : -20,
"VFOb-3.5M" : -19,
"VFOb-7M" : -18,
"VFOb-10M" : -17,
"VFOb-14M" : -16,
"VFOb-18M" : -15,
"VFOb-21M" : -14,
"VFOb-24M" : -13,
"VFOb-28M" : -12,
"VFOb-50M" : -11,
"VFOb-FM" : -10,
"VFOb-AIR" : -9,
"VFOb-144M" : -8,
"VFOb-430M" : -7,
"VFOb-HF" : -6,
"HOME HF" : -5,
"HOME 50M" : -4,
"HOME 144M" : -3,
"HOME 430M" : -2,
"QMB" : -1,
}
FIRST_VFOB_INDEX = -6
LAST_VFOB_INDEX = -20
FIRST_VFOA_INDEX = -21
LAST_VFOA_INDEX = -35
SPECIAL_PMS = {
"PMS-L" : -37,
"PMS-U" : -36,
}
LAST_PMS_INDEX = -37
SPECIAL_MEMORIES.update(SPECIAL_PMS)
SPECIAL_MEMORIES_REV = dict(zip(SPECIAL_MEMORIES.values(),
SPECIAL_MEMORIES.keys()))
@classmethod
def get_prompts(cls):
rp = chirp_common.RadioPrompts()
rp.pre_download = _(dedent("""\
1. Turn radio off.
2. Connect cable to ACC jack.
3. Press and hold in the [MODE <] and [MODE >] keys while
turning the radio on ("CLONE MODE" will appear on the
display).
4. <b>After clicking OK</b>, press the [A] key to send image."""))
rp.pre_upload = _(dedent("""\
1. Turn radio off.
2. Connect cable to ACC jack.
3. Press and hold in the [MODE <] and [MODE >] keys while
turning the radio on ("CLONE MODE" will appear on the
display).
4. Press the [C] key ("RX" will appear on the LCD)."""))
return rp
def _read(self, block, blocknum, lastblock):
# be very patient at first block
if blocknum == 0:
attempts = 60
else:
attempts = 5
for _i in range(0, attempts):
data = self.pipe.read(block+2)
if data:
break
time.sleep(0.5)
if len(data) == block+2 and data[0] == chr(blocknum):
checksum = yaesu_clone.YaesuChecksum(1, block)
if checksum.get_existing(data) != \
checksum.get_calculated(data):
raise Exception("Checksum Failed [%02X<>%02X] block %02X" %
(checksum.get_existing(data),
checksum.get_calculated(data), blocknum))
data = data[1:block+1] # Chew away the block number and the checksum
else:
if lastblock and self._US_model:
raise Exception(_("Unable to read last block. "
"This often happens when the selected model is US "
"but the radio is a non-US one (or widebanded). "
"Please choose the correct model and try again."))
else:
raise Exception("Unable to read block %02X expected %i got %i" %
(blocknum, block+2, len(data)))
if os.getenv("CHIRP_DEBUG"):
print "Read %i" % len(data)
return data
def _clone_in(self):
# Be very patient with the radio
self.pipe.setTimeout(2)
start = time.time()
data = ""
blocks = 0
status = chirp_common.Status()
status.msg = _("Cloning from radio")
nblocks = len(self._block_lengths) + 39
status.max = nblocks
for block in self._block_lengths:
if blocks == 8:
# repeated read of 40 block same size (memory area)
repeat = 40
else:
repeat = 1
for _i in range(0, repeat):
data += self._read(block, blocks, blocks == nblocks-1)
self.pipe.write(chr(CMD_ACK))
blocks += 1
status.cur = blocks
self.status_fn(status)
if not self._US_model:
status.msg = _("Clone completed, checking for spurious bytes")
self.status_fn(status)
moredata = self.pipe.read(2)
if moredata:
raise Exception(_("Radio sent data after the last awaited block, "
"this happens when the selected model is a non-US "
"but the radio is a US one. "
"Please choose the correct model and try again."))
print "Clone completed in %i seconds" % (time.time() - start)
return memmap.MemoryMap(data)
def _clone_out(self):
delay = 0.5
start = time.time()
blocks = 0
pos = 0
status = chirp_common.Status()
status.msg = _("Cloning to radio")
status.max = len(self._block_lengths) + 39
for block in self._block_lengths:
if blocks == 8:
# repeated read of 40 block same size (memory area)
repeat = 40
else:
repeat = 1
for _i in range(0, repeat):
time.sleep(0.01)
checksum = yaesu_clone.YaesuChecksum(pos, pos+block-1)
if os.getenv("CHIRP_DEBUG"):
print "Block %i - will send from %i to %i byte " % \
(blocks,
pos,
pos + block)
print util.hexprint(chr(blocks))
print util.hexprint(self.get_mmap()[pos:pos+block])
print util.hexprint(chr(checksum.get_calculated(
self.get_mmap())))
self.pipe.write(chr(blocks))
self.pipe.write(self.get_mmap()[pos:pos+block])
self.pipe.write(chr(checksum.get_calculated(self.get_mmap())))
buf = self.pipe.read(1)
if not buf or buf[0] != chr(CMD_ACK):
time.sleep(delay)
buf = self.pipe.read(1)
if not buf or buf[0] != chr(CMD_ACK):
if os.getenv("CHIRP_DEBUG"):
print util.hexprint(buf)
raise Exception(_("Radio did not ack block %i") % blocks)
pos += block
blocks += 1
status.cur = blocks
self.status_fn(status)
print "Clone completed in %i seconds" % (time.time() - start)
def sync_in(self):
try:
self._mmap = self._clone_in()
except errors.RadioError:
raise
except Exception, e:
raise errors.RadioError("Failed to communicate with radio: %s" % e)
self.process_mmap()
DUPLEX = ["", "-", "+", "split"]
MODES = ["FM", "AM", "WFM", "FM"] # last is auto
TMODES = ["", "Tone", "TSQL", "DTCS"]
DTMFCHARSET = list("0123456789ABCD*#-")
STEPS = [5.0, 10.0, 12.5, 15.0, 20.0, 25.0, 50.0, 100.0,
9.0, 200.0, 5.0] # last is auto, 9.0k and 200.0k are unadvertised
CHARSET = ["%i" % int(x) for x in range(10)] + \
[chr(x) for x in range(ord("A"), ord("Z")+1)] + \
list(" +-/\x00[]__" + ("\x00" * 9) + "$%%\x00**.|=\\\x00@") + \
list("\x00" * 100)
PASS_CHARSET = list("0123456789ABCDEF")
POWER_LEVELS = [chirp_common.PowerLevel("Hi", watts=5.00),
chirp_common.PowerLevel("L3", watts=2.50),
chirp_common.PowerLevel("L2", watts=1.00),
chirp_common.PowerLevel("L1", watts=0.30)]
POWER_LEVELS_220 = [chirp_common.PowerLevel("Hi", watts=1.50),
chirp_common.PowerLevel("L3", watts=1.00),
chirp_common.PowerLevel("L2", watts=0.50),
chirp_common.PowerLevel("L1", watts=0.20)]
class VX6Bank(chirp_common.NamedBank):
"""A VX6 Bank"""
def get_name(self):
_bank = self._model._radio._memobj.bank_names[self.index]
name = ""
for i in _bank.name:
char call[8];
} urcalls[6];
struct {
char call[8];
} rptcalls[6];
"""
TMODES = ["", "Tone", "TSQL", "DTCS"]
DUPLEX = ["", "-", "+"]
DTCSP = ["NN", "NR", "RN", "RR"]
STEPS = [5.0, 10.0, 12.5, 15.0, 20.0, 25.0, 30.0, 50.0]
POWER_LEVELS = [
chirp_common.PowerLevel("High", watts=65),
chirp_common.PowerLevel("Mid", watts=25),
chirp_common.PowerLevel("MidLow", watts=10),
chirp_common.PowerLevel("Low", watts=5)
]
def _get_special():
special = {"C": 206}
for i in range(0, 3):
ida = "%iA" % (i + 1)
idb = "%iB" % (i + 1)
num = 200 + i * 2
special[ida] = num
special[idb] = num + 1
'Current': 0xFF})
VOLUMES_REV = {v: k for k, v in VOLUMES.items()}
MIN_VOL_PRESET = {'Preset': 0x30,
'Lowest Limit': 0x31}
MIN_VOL_PRESET_REV = {v: k for k, v in MIN_VOL_PRESET.items()}
SUBLCD = ['Zone Number', 'CH/GID Number', 'OSD List Number']
CLOCKFMT = ['12H', '24H']
DATEFMT = ['Day/Month', 'Month/Day']
MICSENSE = ['On']
ONLY_MOBILE_SETTINGS = ['power_switch_memory', 'off_hook_decode',
'ignition_sense', 'mvp', 'it', 'ignition_mode']
POWER_LEVELS = [chirp_common.PowerLevel("Low", watts=5),
chirp_common.PowerLevel("High", watts=50)]
def set_choice(setting, obj, key, choices, default='Off'):
settingstr = str(setting.value)
if settingstr == default:
val = 0xFF
else:
val = choices.index(settingstr) + 0x30
setattr(obj, key, val)
def get_choice(obj, key, choices, default='Off'):
val = getattr(obj, key)
if val == 0xFF:
u8 code[5];
u8 unused[11];
} pttid[15];
struct {
u8 code[5];
u8 group_code;
u8 aniid;
u8 dtmfon;
u8 dtmfoff;
} ani;
"""
SHX8800_POWER_LEVELS = [
chirp_common.PowerLevel("High", watts=5.00),
chirp_common.PowerLevel("Low", watts=1.00)
]
SHX8800_DTCS = sorted(chirp_common.DTCS_CODES + [645])
AUTOBL_LIST = [
"OFF", "5 sec", "10 sec", "15 sec", "20 sec", "30 sec", "1 min", "2 min",
"3 min"
]
TOT_LIST = ["OFF"] + ["%s sec" % x for x in range(30, 270, 30)]
VOX_LIST = ["OFF"] + ["%s" % x for x in range(1, 4)]
BANDWIDTH_LIST = ["Wide", "Narrow"]
LANGUAGE_LIST = ["English", "Chinese"]
DTMFST_LIST = ["OFF", "DT-ST", "ANI-ST", "DT+ANI"]
SCAN_MODE_LIST = ["TO", "CO", "SE"]
lbcd lorx[4];
lbcd hirx[4];
lbcd lotx[4];
lbcd hitx[4];
} bandlimits[9];
"""
BLANK_MEMORY = "\xFF" * 8 + "\x00\x10\x23\x00\xC0\x08\x06\x00" \
"\x00\x00\x76\x00\x00\x00" + "\xFF" * 10
DTCS_POLARITY = ["NN", "RN", "NR", "RR"]
SCAN_MODES = ["", "S", "P"]
MODES = ["WFM", "FM", "NFM"]
TMODES = ["", "Tone", "TSQL", "DTCS"]
POWER_LEVELS = [chirp_common.PowerLevel("Low", watts=5.00),
chirp_common.PowerLevel("Mid2", watts=10.00),
chirp_common.PowerLevel("Mid1", watts=20.00),
chirp_common.PowerLevel("High", watts=50.00)]
BUSY_LOCK = ["off", "Carrier", "2 tone"]
MICKEYFUNC = ["None", "SCAN", "SQL.OFF", "TCALL", "PPTR", "PRI", "LOW", "TONE",
"MHz", "REV", "HOME", "BAND", "VFO/MR"]
SQLPRESET = ["Off", "2", "5", "9", "Full"]
BANDS = ["30MHz", "50MHz", "60MHz", "108MHz", "150MHz", "250MHz", "350MHz",
"450MHz", "850MHz"]
STEPS = [2.5, 5.0, 6.25, 7.5, 8.33, 10.0, 12.5,
15.0, 20.0, 25.0, 30.0, 50.0, 100.0]
class TYTTH9800Base(chirp_common.Radio):
"""Base class for TYT TH-9800"""
class MURSV1(baofeng_common.BaofengCommonHT):
"""BTech MURS-V1"""
VENDOR = "BTECH"
MODEL = "MURS-V1"
_fileid = [
MURSV1_fp1,
]
_magic = [
MSTRING_MURSV1,
]
_magic_response_length = 8
_fw_ver_start = 0x1EF0
_recv_block_size = 0x40
_mem_size = 0x2000
_ack_block = True
_ranges = [(0x0000, 0x0DF0), (0x0E00, 0x1800), (0x1EE0, 0x1EF0),
(0x1F60, 0x1F70), (0x1F80, 0x1F90), (0x1FC0, 0x1FD0)]
_send_block_size = 0x10
MODES = ["NFM", "FM"]
VALID_CHARS = chirp_common.CHARSET_ALPHANUMERIC + \
"!@#$%^&*()+-=[]:\";'<>?,./"
LENGTH_NAME = 7
SKIP_VALUES = ["", "S"]
DTCS_CODES = sorted(chirp_common.DTCS_CODES + [645])
POWER_LEVELS = [
chirp_common.PowerLevel("High", watts=2.00),
chirp_common.PowerLevel("Low", watts=.50)
]
VALID_BANDS = [(151820000, 154600250)]
PTTID_LIST = LIST_PTTID
SCODE_LIST = LIST_SCODE
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.has_settings = True
rf.has_bank = False
rf.has_tuning_step = False
rf.can_odd_split = False
rf.has_name = True
rf.has_offset = False
rf.has_mode = True
rf.has_dtcs = True
rf.has_rx_dtcs = True
rf.has_dtcs_polarity = True
rf.has_ctone = True
rf.has_cross = True
rf.valid_modes = self.MODES
rf.valid_characters = self.VALID_CHARS
rf.valid_name_length = self.LENGTH_NAME
rf.valid_duplexes = []
rf.valid_tmodes = ['', 'Tone', 'TSQL', 'DTCS', 'Cross']
rf.valid_cross_modes = [
"Tone->Tone", "DTCS->", "->DTCS", "Tone->DTCS", "DTCS->Tone",
"->Tone", "DTCS->DTCS"
]
rf.valid_skips = self.SKIP_VALUES
rf.valid_dtcs_codes = self.DTCS_CODES
rf.memory_bounds = (1, 15)
rf.valid_power_levels = self.POWER_LEVELS
rf.valid_bands = self.VALID_BANDS
return rf
MEM_FORMAT = """
#seekto 0x0010;
struct {
lbcd rxfreq[4];
lbcd txfreq[4];
ul16 rxtone;
ul16 txtone;
u8 unknown0:4,
scode:4;
u8 unknown1;
u8 unknown2:7,
lowpower:1;
u8 unknown3:1,
wide:1,
unknown4:2,
bcl:1,
scan:1,
pttid:2;
} memory[15];
#seekto 0x0B00;
struct {
u8 code[5];
u8 unused[11];
} pttid[15];
#seekto 0x0CAA;
struct {
u8 code[5];
u8 unused1:6,
aniid:2;
u8 unknown[2];
u8 dtmfon;
u8 dtmfoff;
} ani;
#seekto 0x0E20;
struct {
u8 unused01:4,
squelch:4;
u8 unused02;
u8 unused03;
u8 unused04:5,
save:3;
u8 unused05:4,
vox:4;
u8 unused06;
u8 unused07:4,
abr:4;
u8 unused08:7,
tdr:1;
u8 unused09:7,
beep:1;
u8 unused10:2,
timeout:6;
u8 unused11[4];
u8 unused12:6,
voice:2;
u8 unused13;
u8 unused14:6,
dtmfst:2;
u8 unused15;
u8 unused16:6,
screv:2;
u8 unused17:6,
pttid:2;
u8 unused18:2,
pttlt:6;
u8 unused19:6,
mdfa:2;
u8 unused20:6,
mdfb:2;
u8 unused21;
u8 unused22:7,
sync:1;
u8 unused23[4];
u8 unused24:6,
wtled:2;
u8 unused25:6,
rxled:2;
u8 unused26:6,
txled:2;
u8 unused27:6,
almod:2;
u8 unused28:7,
dbptt:1;
u8 unused29:6,
tdrab:2;
u8 unused30:7,
ste:1;
u8 unused31:4,
rpste:4;
u8 unused32:4,
rptrl:4;
u8 unused33:7,
ponmsg:1;
u8 unused34:7,
roger:1;
u8 unused35:6,
rtone:2;
u8 unused36;
u8 unused37:6,
rogerrx:2;
u8 unused38;
u8 displayab:1,
unknown1:2,
fmradio:1,
alarm:1,
unknown2:1,
reset:1,
menu:1;
u8 unused39;
u8 workmode;
u8 keylock;
u8 cht;
} settings;
#seekto 0x0E76;
struct {
u8 unused1:1,
mrcha:7;
u8 unused2:1,
mrchb:7;
} wmchannel;
#seekto 0x0F4E;
u16 fm_presets;
#seekto 0x1010;
struct {
char name[7];
u8 unknown1[9];
} names[15];
#seekto 0x1ED0;
struct {
char line1[7];
char line2[7];
} sixpoweron_msg;
#seekto 0x1EE0;
struct {
char line1[7];
char line2[7];
} poweron_msg;
#seekto 0x1EF0;
struct {
char line1[7];
char line2[7];
} firmware_msg;
struct squelch {
u8 sql0;
u8 sql1;
u8 sql2;
u8 sql3;
u8 sql4;
u8 sql5;
u8 sql6;
u8 sql7;
u8 sql8;
u8 sql9;
};
#seekto 0x1F60;
struct {
struct squelch vhf;
} squelch;
"""
@classmethod
def get_prompts(cls):
rp = chirp_common.RadioPrompts()
rp.experimental = \
('The BTech MURS-V1 driver is a beta version.\n'
'\n'
'Please save an unedited copy of your first successful\n'
'download to a CHIRP Radio Images(*.img) file.'
)
rp.pre_download = _(
dedent("""\
Follow these instructions to download your info:
1 - Turn off your radio
2 - Connect your interface cable
3 - Turn on your radio
4 - Do the download of your radio data
"""))
rp.pre_upload = _(
dedent("""\
Follow this instructions to upload your info:
1 - Turn off your radio
2 - Connect your interface cable
3 - Turn on your radio
4 - Do the upload of your radio data
"""))
return rp
def process_mmap(self):
"""Process the mem map into the mem object"""
self._memobj = bitwise.parse(self.MEM_FORMAT, self._mmap)
def _get_mem(self, number):
return self._memobj.memory[number - 1]
def _get_nam(self, number):
return self._memobj.names[number - 1]
def get_memory(self, number):
_mem = self._get_mem(number)
_nam = self._get_nam(number)
mem = chirp_common.Memory()
mem.number = number
mem.freq = int(_mem.rxfreq) * 10
for char in _nam.name:
if str(char) == "\xFF":
char = " " # The OEM software may have 0xFF mid-name
mem.name += str(char)
mem.name = mem.name.rstrip()
dtcs_pol = ["N", "N"]
if _mem.txtone in [0, 0xFFFF]:
txmode = ""
elif _mem.txtone >= 0x0258:
txmode = "Tone"
mem.rtone = int(_mem.txtone) / 10.0
elif _mem.txtone <= 0x0258:
txmode = "DTCS"
if _mem.txtone > 0x69:
index = _mem.txtone - 0x6A
dtcs_pol[0] = "R"
else:
index = _mem.txtone - 1
mem.dtcs = self.DTCS_CODES[index]
else:
LOG.warn("Bug: txtone is %04x" % _mem.txtone)
if _mem.rxtone in [0, 0xFFFF]:
rxmode = ""
elif _mem.rxtone >= 0x0258:
rxmode = "Tone"
mem.ctone = int(_mem.rxtone) / 10.0
elif _mem.rxtone <= 0x0258:
rxmode = "DTCS"
if _mem.rxtone >= 0x6A:
index = _mem.rxtone - 0x6A
dtcs_pol[1] = "R"
else:
index = _mem.rxtone - 1
mem.rx_dtcs = self.DTCS_CODES[index]
else:
LOG.warn("Bug: rxtone is %04x" % _mem.rxtone)
if txmode == "Tone" and not rxmode:
mem.tmode = "Tone"
elif txmode == rxmode and txmode == "Tone" and mem.rtone == mem.ctone:
mem.tmode = "TSQL"
elif txmode == rxmode and txmode == "DTCS" and mem.dtcs == mem.rx_dtcs:
mem.tmode = "DTCS"
elif rxmode or txmode:
mem.tmode = "Cross"
mem.cross_mode = "%s->%s" % (txmode, rxmode)
mem.dtcs_polarity = "".join(dtcs_pol)
if not _mem.scan:
mem.skip = "S"
levels = self.POWER_LEVELS
try:
mem.power = levels[_mem.lowpower]
except IndexError:
LOG.error("Radio reported invalid power level %s (in %s)" %
(_mem.power, levels))
mem.power = levels[0]
mem.mode = _mem.wide and "FM" or "NFM"
mem.extra = RadioSettingGroup("Extra", "extra")
rs = RadioSetting("bcl", "BCL", RadioSettingValueBoolean(_mem.bcl))
mem.extra.append(rs)
rs = RadioSetting(
"pttid", "PTT ID",
RadioSettingValueList(self.PTTID_LIST,
self.PTTID_LIST[_mem.pttid]))
mem.extra.append(rs)
rs = RadioSetting(
"scode", "S-CODE",
RadioSettingValueList(self.SCODE_LIST,
self.SCODE_LIST[_mem.scode]))
mem.extra.append(rs)
return mem
def _set_mem(self, number):
return self._memobj.memory[number - 1]
def _set_nam(self, number):
return self._memobj.names[number - 1]
def validate_memory(self, mem):
msgs = baofeng_common.BaofengCommonHT.validate_memory(self, mem)
if mem.freq != int(MURS_FREQS[mem.number - 1] * 1000000):
msgs.append(
chirp_common.ValidationError(
'Memory location cannot change frequency'))
if mem.mode == "FM" and (mem.number - 1) not in FM_MODE:
msgs.append(
chirp_common.ValidationError(
'Memory location only supports NFM'))
return msgs
def set_memory(self, mem):
_mem = self._set_mem(mem.number)
_nam = self._set_nam(mem.number)
_namelength = self.get_features().valid_name_length
for i in range(_namelength):
try:
_nam.name[i] = mem.name[i]
except IndexError:
_nam.name[i] = "\xFF"
rxmode = txmode = ""
if mem.tmode == "Tone":
_mem.txtone = int(mem.rtone * 10)
_mem.rxtone = 0
elif mem.tmode == "TSQL":
_mem.txtone = int(mem.ctone * 10)
_mem.rxtone = int(mem.ctone * 10)
elif mem.tmode == "DTCS":
rxmode = txmode = "DTCS"
_mem.txtone = self.DTCS_CODES.index(mem.dtcs) + 1
_mem.rxtone = self.DTCS_CODES.index(mem.dtcs) + 1
elif mem.tmode == "Cross":
txmode, rxmode = mem.cross_mode.split("->", 1)
if txmode == "Tone":
_mem.txtone = int(mem.rtone * 10)
elif txmode == "DTCS":
_mem.txtone = self.DTCS_CODES.index(mem.dtcs) + 1
else:
_mem.txtone = 0
if rxmode == "Tone":
_mem.rxtone = int(mem.ctone * 10)
elif rxmode == "DTCS":
_mem.rxtone = self.DTCS_CODES.index(mem.rx_dtcs) + 1
else:
_mem.rxtone = 0
else:
_mem.rxtone = 0
_mem.txtone = 0
if txmode == "DTCS" and mem.dtcs_polarity[0] == "R":
_mem.txtone += 0x69
if rxmode == "DTCS" and mem.dtcs_polarity[1] == "R":
_mem.rxtone += 0x69
_mem.scan = mem.skip != "S"
_mem.wide = mem.mode == "FM"
if mem.power:
_mem.lowpower = self.POWER_LEVELS.index(mem.power)
else:
_mem.lowpower = 0
# extra settings
if len(mem.extra) > 0:
# there are setting, parse
for setting in mem.extra:
setattr(_mem, setting.get_name(), setting.value)
else:
# there are no extra settings, load defaults
_mem.bcl = 0
_mem.pttid = 0
_mem.scode = 0
def get_settings(self):
"""Translate the bit in the mem_struct into settings in the UI"""
_mem = self._memobj
basic = RadioSettingGroup("basic", "Basic Settings")
advanced = RadioSettingGroup("advanced", "Advanced Settings")
other = RadioSettingGroup("other", "Other Settings")
work = RadioSettingGroup("work", "Work Mode Settings")
fm_preset = RadioSettingGroup("fm_preset", "FM Preset")
dtmfe = RadioSettingGroup("dtmfe", "DTMF Encode Settings")
service = RadioSettingGroup("service", "Service Settings")
top = RadioSettings(basic, advanced, other, work, fm_preset, dtmfe,
service)
# Basic settings
if _mem.settings.squelch > 0x09:
val = 0x00
else:
val = _mem.settings.squelch
rs = RadioSetting(
"settings.squelch", "Squelch",
RadioSettingValueList(LIST_OFF1TO9, LIST_OFF1TO9[val]))
basic.append(rs)
if _mem.settings.save > 0x04:
val = 0x00
else:
val = _mem.settings.save
rs = RadioSetting("settings.save", "Battery Saver",
RadioSettingValueList(LIST_SAVE, LIST_SAVE[val]))
basic.append(rs)
if _mem.settings.vox > 0x0A:
val = 0x00
else:
val = _mem.settings.vox
rs = RadioSetting(
"settings.vox", "Vox",
RadioSettingValueList(LIST_OFF1TO10, LIST_OFF1TO10[val]))
basic.append(rs)
if _mem.settings.abr > 0x0A:
val = 0x00
else:
val = _mem.settings.abr
rs = RadioSetting(
"settings.abr", "Backlight Timeout",
RadioSettingValueList(LIST_OFF1TO10, LIST_OFF1TO10[val]))
basic.append(rs)
rs = RadioSetting("settings.tdr", "Dual Watch",
RadioSettingValueBoolean(_mem.settings.tdr))
basic.append(rs)
rs = RadioSetting("settings.beep", "Beep",
RadioSettingValueBoolean(_mem.settings.beep))
basic.append(rs)
if _mem.settings.timeout > 0x27:
val = 0x03
else:
val = _mem.settings.timeout
rs = RadioSetting(
"settings.timeout", "Timeout Timer",
RadioSettingValueList(LIST_TIMEOUT, LIST_TIMEOUT[val]))
basic.append(rs)
if _mem.settings.voice > 0x02:
val = 0x01
else:
val = _mem.settings.voice
rs = RadioSetting("settings.voice", "Voice Prompt",
RadioSettingValueList(LIST_VOICE, LIST_VOICE[val]))
basic.append(rs)
rs = RadioSetting(
"settings.dtmfst", "DTMF Sidetone",
RadioSettingValueList(LIST_DTMFST,
LIST_DTMFST[_mem.settings.dtmfst]))
basic.append(rs)
if _mem.settings.screv > 0x02:
val = 0x01
else:
val = _mem.settings.screv
rs = RadioSetting("settings.screv", "Scan Resume",
RadioSettingValueList(LIST_RESUME, LIST_RESUME[val]))
basic.append(rs)
rs = RadioSetting(
"settings.pttid", "When to send PTT ID",
RadioSettingValueList(LIST_PTTID, LIST_PTTID[_mem.settings.pttid]))
basic.append(rs)
if _mem.settings.pttlt > 0x1E:
val = 0x05
else:
val = _mem.settings.pttlt
rs = RadioSetting("pttlt", "PTT ID Delay",
RadioSettingValueInteger(0, 50, val))
basic.append(rs)
rs = RadioSetting(
"settings.mdfa", "Display Mode (A)",
RadioSettingValueList(LIST_MODE, LIST_MODE[_mem.settings.mdfa]))
basic.append(rs)
rs = RadioSetting(
"settings.mdfb", "Display Mode (B)",
RadioSettingValueList(LIST_MODE, LIST_MODE[_mem.settings.mdfb]))
basic.append(rs)
rs = RadioSetting("settings.sync", "Sync A & B",
RadioSettingValueBoolean(_mem.settings.sync))
basic.append(rs)
rs = RadioSetting(
"settings.wtled", "Standby LED Color",
RadioSettingValueList(LIST_COLOR, LIST_COLOR[_mem.settings.wtled]))
basic.append(rs)
rs = RadioSetting(
"settings.rxled", "RX LED Color",
RadioSettingValueList(LIST_COLOR, LIST_COLOR[_mem.settings.rxled]))
basic.append(rs)
rs = RadioSetting(
"settings.txled", "TX LED Color",
RadioSettingValueList(LIST_COLOR, LIST_COLOR[_mem.settings.txled]))
basic.append(rs)
val = _mem.settings.almod
rs = RadioSetting("settings.almod", "Alarm Mode",
RadioSettingValueList(LIST_ALMOD, LIST_ALMOD[val]))
basic.append(rs)
rs = RadioSetting("settings.dbptt", "Double PTT",
RadioSettingValueBoolean(_mem.settings.dbptt))
basic.append(rs)
rs = RadioSetting("settings.ste", "Squelch Tail Eliminate (HT to HT)",
RadioSettingValueBoolean(_mem.settings.ste))
basic.append(rs)
rs = RadioSetting(
"settings.ponmsg", "Power-On Message",
RadioSettingValueList(LIST_PONMSG,
LIST_PONMSG[_mem.settings.ponmsg]))
basic.append(rs)
rs = RadioSetting("settings.roger", "Roger Beep",
RadioSettingValueBoolean(_mem.settings.roger))
basic.append(rs)
rs = RadioSetting(
"settings.rtone", "Tone Burst Frequency",
RadioSettingValueList(LIST_RTONE, LIST_RTONE[_mem.settings.rtone]))
basic.append(rs)
rs = RadioSetting(
"settings.rogerrx", "Roger Beep (RX)",
RadioSettingValueList(LIST_OFFAB,
LIST_OFFAB[_mem.settings.rogerrx]))
basic.append(rs)
# Advanced settings
rs = RadioSetting("settings.reset", "RESET Menu",
RadioSettingValueBoolean(_mem.settings.reset))
advanced.append(rs)
rs = RadioSetting("settings.menu", "All Menus",
RadioSettingValueBoolean(_mem.settings.menu))
advanced.append(rs)
rs = RadioSetting("settings.fmradio", "Broadcast FM Radio",
RadioSettingValueBoolean(_mem.settings.fmradio))
advanced.append(rs)
rs = RadioSetting("settings.alarm", "Alarm Sound",
RadioSettingValueBoolean(_mem.settings.alarm))
advanced.append(rs)
# Other settings
def _filter(name):
filtered = ""
for char in str(name):
if char in chirp_common.CHARSET_ASCII:
filtered += char
else:
filtered += " "
return filtered
_msg = _mem.firmware_msg
val = RadioSettingValueString(0, 7, _filter(_msg.line1))
val.set_mutable(False)
rs = RadioSetting("firmware_msg.line1", "Firmware Message 1", val)
other.append(rs)
val = RadioSettingValueString(0, 7, _filter(_msg.line2))
val.set_mutable(False)
rs = RadioSetting("firmware_msg.line2", "Firmware Message 2", val)
other.append(rs)
_msg = _mem.sixpoweron_msg
val = RadioSettingValueString(0, 7, _filter(_msg.line1))
val.set_mutable(False)
rs = RadioSetting("sixpoweron_msg.line1", "6+Power-On Message 1", val)
other.append(rs)
val = RadioSettingValueString(0, 7, _filter(_msg.line2))
val.set_mutable(False)
rs = RadioSetting("sixpoweron_msg.line2", "6+Power-On Message 2", val)
other.append(rs)
_msg = _mem.poweron_msg
rs = RadioSetting("poweron_msg.line1", "Power-On Message 1",
RadioSettingValueString(0, 7, _filter(_msg.line1)))
other.append(rs)
rs = RadioSetting("poweron_msg.line2", "Power-On Message 2",
RadioSettingValueString(0, 7, _filter(_msg.line2)))
other.append(rs)
# Work mode settings
rs = RadioSetting(
"settings.displayab", "Display",
RadioSettingValueList(LIST_AB, LIST_AB[_mem.settings.displayab]))
work.append(rs)
rs = RadioSetting("settings.keylock", "Keypad Lock",
RadioSettingValueBoolean(_mem.settings.keylock))
work.append(rs)
rs = RadioSetting(
"wmchannel.mrcha", "MR A Channel",
RadioSettingValueInteger(1, 15, _mem.wmchannel.mrcha))
work.append(rs)
rs = RadioSetting(
"wmchannel.mrchb", "MR B Channel",
RadioSettingValueInteger(1, 15, _mem.wmchannel.mrchb))
work.append(rs)
# broadcast FM settings
_fm_presets = self._memobj.fm_presets
if _fm_presets <= 108.0 * 10 - 650:
preset = _fm_presets / 10.0 + 65
elif _fm_presets >= 65.0 * 10 and _fm_presets <= 108.0 * 10:
preset = _fm_presets / 10.0
else:
preset = 76.0
rs = RadioSetting("fm_presets", "FM Preset(MHz)",
RadioSettingValueFloat(65, 108.0, preset, 0.1, 1))
fm_preset.append(rs)
# DTMF settings
def apply_code(setting, obj, length):
code = []
for j in range(0, length):
try:
code.append(DTMF_CHARS.index(str(setting.value)[j]))
except IndexError:
code.append(0xFF)
obj.code = code
for i in range(0, 15):
_codeobj = self._memobj.pttid[i].code
_code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F])
val = RadioSettingValueString(0, 5, _code, False)
val.set_charset(DTMF_CHARS)
pttid = RadioSetting("pttid/%i.code" % i,
"Signal Code %i" % (i + 1), val)
pttid.set_apply_callback(apply_code, self._memobj.pttid[i], 5)
dtmfe.append(pttid)
if _mem.ani.dtmfon > 0xC3:
val = 0x03
else:
val = _mem.ani.dtmfon
rs = RadioSetting(
"ani.dtmfon", "DTMF Speed (on)",
RadioSettingValueList(LIST_DTMFSPEED, LIST_DTMFSPEED[val]))
dtmfe.append(rs)
if _mem.ani.dtmfoff > 0xC3:
val = 0x03
else:
val = _mem.ani.dtmfoff
rs = RadioSetting(
"ani.dtmfoff", "DTMF Speed (off)",
RadioSettingValueList(LIST_DTMFSPEED, LIST_DTMFSPEED[val]))
dtmfe.append(rs)
_codeobj = self._memobj.ani.code
_code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F])
val = RadioSettingValueString(0, 5, _code, False)
val.set_charset(DTMF_CHARS)
rs = RadioSetting("ani.code", "ANI Code", val)
rs.set_apply_callback(apply_code, self._memobj.ani, 5)
dtmfe.append(rs)
rs = RadioSetting(
"ani.aniid", "When to send ANI ID",
RadioSettingValueList(LIST_PTTID, LIST_PTTID[_mem.ani.aniid]))
dtmfe.append(rs)
# Service settings
for index in range(0, 10):
key = "squelch.vhf.sql%i" % (index)
_obj = self._memobj.squelch.vhf
val = RadioSettingValueInteger(0, 123,
getattr(_obj, "sql%i" % (index)))
if index == 0:
val.set_mutable(False)
name = "Squelch %i" % (index)
rs = RadioSetting(key, name, val)
service.append(rs)
return top
@classmethod
def match_model(cls, filedata, filename):
match_size = False
match_model = False
# testing the file data size
if len(filedata) == 0x2008:
match_size = True
# testing the firmware model fingerprint
match_model = model_match(cls, filedata)
if match_size and match_model:
return True
else:
return False
u8 unknown3c2;
u8 timeout;
u8 voxgain;
u8 specialcode;
u8 unknown3c6;
u8 voxdelay;
} settings;
"""
CMD_ACK = "\x06"
CMD_STX = "\x02"
CMD_ENQ = "\x05"
POWER_LEVELS = [
chirp_common.PowerLevel("Low", watts=0.50),
chirp_common.PowerLevel("High", watts=3.00)
]
TIMEOUT_LIST = ["Off"] + ["%s seconds" % x for x in range(30, 330, 30)]
SCANMODE_LIST = ["Carrier", "Timer"]
VOICE_LIST = ["Off", "Chinese", "English"]
VOX_LIST = ["Off"] + ["%s" % x for x in range(1, 9)]
VOXDELAY_LIST = ["0.5", "1.0", "1.5", "2.0", "2.5", "3.0"]
MODE_LIST = ["WFM", "NFM"]
TONES = chirp_common.TONES
DTCS_CODES = chirp_common.DTCS_CODES
SETTING_LISTS = {
"tot": TIMEOUT_LIST,
"scanmode": SCANMODE_LIST,
u8 rtonesplitflag:1,
rtone:7;
u8 dtcssplitflag:1,
dtcs:7;
} memory[200];
"""
MODES = ["FM", "NFM"]
TMODES = ["", "Tone", "TSQL", "DTCS", "TSQL-R", "Cross"]
CROSS_MODES = [
"DTCS->", "Tone->DTCS", "DTCS->Tone", "Tone->Tone", "DTCS->DTCS"
]
DUPLEX = ["", "-", "+", "split"]
POWER_LEVELS = [
chirp_common.PowerLevel("Hi", watts=75),
chirp_common.PowerLevel("Low3", watts=30),
chirp_common.PowerLevel("Low2", watts=10),
chirp_common.PowerLevel("Low1", watts=5),
]
CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ +-/?C[] _"
STEPS = [5.0, 10.0, 12.5, 15.0, 20.0, 25.0, 50.0, 100.0]
def _decode_tone(radiotone):
try:
chirptone = chirp_common.TONES[radiotone]
except IndexError:
chirptone = 100
LOG.debug("found invalid radio tone: %i\n" % radiotone)
"""
DUPLEX = ["", "-", "+", "split"]
MODES = ["FM", "AM", "WFM", "FM"] # last is auto
TMODES = ["", "Tone", "TSQL", "DTCS"]
STEPS = [5.0, 10.0, 12.5, 15.0, 20.0, 25.0, 50.0, 100.0, 9.0, 200.0,
5.0] # last is auto, 9.0k and 200.0k are unadvertised
CHARSET = ["%i" % int(x) for x in range(0, 10)] + \
[chr(x) for x in range(ord("A"), ord("Z")+1)] + \
list(" +-/\x00[]__" + ("\x00" * 9) + "$%%\x00**.|=\\\x00@") + \
list("\x00" * 100)
POWER_LEVELS = [
chirp_common.PowerLevel("Hi", watts=5.00),
chirp_common.PowerLevel("L3", watts=2.50),
chirp_common.PowerLevel("L2", watts=1.00),
chirp_common.PowerLevel("L1", watts=0.30)
]
POWER_LEVELS_220 = [
chirp_common.PowerLevel("Hi", watts=1.50),
chirp_common.PowerLevel("L3", watts=1.00),
chirp_common.PowerLevel("L2", watts=0.50),
chirp_common.PowerLevel("L1", watts=0.20)
]
class VX6Bank(chirp_common.NamedBank):
"""A VX6 Bank"""
def get_name(self):
#
# Chirp Driver for TYT TH-9000D (models: 2M (144 Mhz), 1.25M (220 Mhz) and 70cm (440 Mhz) radios)
#
# Version 1.0
#
# - Skip channels
#
# Global Parameters
#
MMAPSIZE = 16384
TONES = [62.5] + list(chirp_common.TONES)
TMODES = ['','Tone','DTCS','']
DUPLEXES = ['','err','-','+'] # index 2 not used
MODES = ['WFM','FM','NFM'] # 25k, 20k,15k bw
TUNING_STEPS=[ 5.0, 6.25, 8.33, 10.0, 12.5, 15.0, 20.0, 25.0, 30.0, 50.0 ] # index 0-9
POWER_LEVELS=[chirp_common.PowerLevel("High", watts=65),
chirp_common.PowerLevel("Mid", watts=25),
chirp_common.PowerLevel("Low", watts=10)]
CROSS_MODES = chirp_common.CROSS_MODES
APO_LIST = [ "Off","30 min","1 hr","2 hrs" ]
BGCOLOR_LIST = ["Blue","Orange","Purple"]
BGBRIGHT_LIST = ["%s" % x for x in range(1,32)]
SQUELCH_LIST = ["Off"] + ["Level %s" % x for x in range(1,20)]
TIMEOUT_LIST = ["Off"] + ["%s min" % x for x in range(1,30)]
TXPWR_LIST = ["60W","25W"] # maximum power for Hi setting
TBSTFREQ_LIST = ["1750Hz","2100Hz","1000Hz","1450Hz"]
BEEP_LIST = ["Off","On"]
SETTING_LISTS = {
class TYTUV3R25Radio(TYTUV3RRadio):
MODEL = "TH-UV3R-25"
_memsize = 2864
POWER_LEVELS = [
chirp_common.PowerLevel("High", watts=2.00),
chirp_common.PowerLevel("Low", watts=0.80)
]
def get_features(self):
rf = super(TYTUV3R25Radio, self).get_features()
rf.valid_tuning_steps = [
2.5, 5.0, 6.25, 10.0, 12.5, 25.0, 37.50, 50.0, 100.0
]
rf.valid_power_levels = self.POWER_LEVELS
return rf
def sync_in(self):
self.pipe.timeout = 2
self._mmap = tyt_uv3r_download(self)
self.process_mmap()
def sync_out(self):
tyt_uv3r_upload(self)
def process_mmap(self):
self._memobj = bitwise.parse(mem_format, self._mmap)
def get_raw_memory(self, number):
return repr(self._memobj.memory[number - 1])
def get_memory(self, number):
_mem = self._memobj.memory[number - 1]
mem = chirp_common.Memory()
mem.number = number
bit = 1 << ((number - 1) % 8)
byte = (number - 1) / 8
if self._memobj.emptyflags[byte] & bit:
mem.empty = True
return mem
mem.freq = _mem.rx_freq * 10
mem.offset = abs(_mem.rx_freq - _mem.tx_freq) * 10
if _mem.tx_freq == _mem.rx_freq:
mem.duplex = ""
elif _mem.tx_freq < _mem.rx_freq:
mem.duplex = "-"
elif _mem.tx_freq > _mem.rx_freq:
mem.duplex = "+"
mem.mode = _mem.iswide and "FM" or "NFM"
self._decode_tone(mem, _mem)
mem.skip = (self._memobj.skipflags[byte] & bit) and "S" or ""
for char in _mem.name:
try:
c = THUV3R_CHARSET[char]
except:
c = ""
mem.name += c
mem.name = mem.name.rstrip()
mem.power = self.POWER_LEVELS[not _mem.power_high]
mem.extra = RadioSettingGroup("extra", "Extra Settings")
rs = RadioSetting("bclo_n", "Busy Channel Lockout",
RadioSettingValueBoolean(not _mem.bclo_n))
mem.extra.append(rs)
rs = RadioSetting("vox_n", "VOX",
RadioSettingValueBoolean(not _mem.vox_n))
mem.extra.append(rs)
rs = RadioSetting("tail", "Squelch Tail Elimination",
RadioSettingValueBoolean(_mem.tail))
mem.extra.append(rs)
rs = RadioSetting(
"voice_mode", "Voice Mode",
RadioSettingValueList(VOICE_MODE_LIST,
VOICE_MODE_LIST[_mem.voice_mode - 1]))
mem.extra.append(rs)
return mem
def set_memory(self, mem):
_mem = self._memobj.memory[mem.number - 1]
bit = 1 << ((mem.number - 1) % 8)
byte = (mem.number - 1) / 8
if mem.empty:
self._memobj.emptyflags[byte] |= bit
_mem.set_raw("\xFF" * 20)
return
self._memobj.emptyflags[byte] &= ~bit
_mem.rx_freq = mem.freq / 10
if mem.duplex == "":
_mem.tx_freq = _mem.rx_freq
elif mem.duplex == "-":
_mem.tx_freq = _mem.rx_freq - mem.offset / 10.0
elif mem.duplex == "+":
_mem.tx_freq = _mem.rx_freq + mem.offset / 10.0
_mem.iswide = mem.mode == "FM"
self._encode_tone(mem, _mem)
if mem.skip:
self._memobj.skipflags[byte] |= bit
else:
self._memobj.skipflags[byte] &= ~bit
name = []
for char in mem.name.ljust(6):
try:
c = THUV3R_CHARSET.index(char)
except:
c = THUV3R_CHARSET.index(" ")
name.append(c)
_mem.name = name
if mem.power == self.POWER_LEVELS[0]:
_mem.power_high = 1
else:
_mem.power_high = 0
for element in mem.extra:
if element.get_name() == 'voice_mode':
setattr(_mem, element.get_name(), int(element.value) + 1)
elif element.get_name().endswith('_n'):
setattr(_mem, element.get_name(), 1 - int(element.value))
else:
setattr(_mem, element.get_name(), element.value)
@classmethod
def match_model(cls, filedata, filename):
return len(filedata) == cls._memsize
raise
except (Exception, e):
raise errors.RadioError("Failed to communicate with radio: %s" % e)
def puxing_upload(radio):
"""Talk to a Puxing PX-777 and do an upload"""
try:
puxing_prep(radio)
return do_upload(radio, 0x0000, 0x0C40, 0x0008)
except errors.RadioError:
raise
except (Exception, e):
raise errors.RadioError("Failed to communicate with radio: %s" % e)
POWER_LEVELS = [chirp_common.PowerLevel("High", watts=5.00),
chirp_common.PowerLevel("Low", watts=1.00)]
PUXING_CHARSET = list("0123456789") + \
[chr(x + ord("A")) for x in range(0, 26)] + \
list("- ")
PUXING_MEM_FORMAT = """
#seekto 0x0000;
struct {
lbcd rx_freq[4];
lbcd tx_freq[4];
lbcd rx_tone[2];
lbcd tx_tone[2];
u8 _3_unknown_1;
u8 _2_unknown_1:2,
class KGUV8ERadio(chirp_common.CloneModeRadio,
chirp_common.ExperimentalRadio):
"""Wouxun KG-UV8E"""
VENDOR = "Wouxun"
MODEL = "KG-UV8E"
_model = "KG-UV8D-A"
_file_ident = "kguv8e" # lowercase
BAUD_RATE = 19200
POWER_LEVELS = [chirp_common.PowerLevel("L", watts=1),
chirp_common.PowerLevel("H", watts=5)]
_mmap = ""
def _checksum(self, data):
cs = 0
for byte in data:
cs += ord(byte)
return chr(cs % 256)
def _write_record(self, cmd, payload = None):
# build the packet
_header = '\x7b' + chr(cmd) + '\xff'
_length = 0
if payload:
_length = len(payload)
# update the length field
_header += chr(_length)
if payload:
# calculate checksum then add it with the payload to the packet and encrypt
crc = self._checksum(_header[1:] + payload)
payload += crc
_header += self.encrypt(payload)
else:
# calculate and add encrypted checksum to the packet
crc = self._checksum(_header[1:])
_header += self.strxor(crc, '\x57')
try:
self.pipe.write(_header)
except (Exception, e):
raise errors.RadioError("Failed to communicate with radio: %s" % e)
def _read_record(self):
# read 4 chars for the header
_header = self.pipe.read(4)
if len(_header) != 4:
raise errors.RadioError('Radio did not respond')
_length = ord(_header[3])
_packet = self.pipe.read(_length)
_rcs_xor = _packet[-1]
_packet = self.decrypt(_packet)
_cs = ord(self._checksum(_header[1:] + _packet))
# read the checksum and decrypt it
_rcs = ord(self.strxor(self.pipe.read(1), _rcs_xor))
return (_rcs != _cs, _packet)
def decrypt(self, data):
result = ''
for i in range(len(data)-1, 0, -1):
result += self.strxor(data[i], data[i - 1])
result += self.strxor(data[0], '\x57')
return result[::-1]
def encrypt(self, data):
result = self.strxor('\x57', data[0])
for i in range(1, len(data), 1):
result += self.strxor(result[i - 1], data[i])
return result
def strxor (self, xora, xorb):
return chr(ord(xora) ^ ord(xorb))
# Identify the radio
#
# A Gotcha: the first identify packet returns a bad checksum, subsequent
# attempts return the correct checksum... (well it does on my radio!)
#
# The ID record returned by the radio also includes the current frequency range
# as 4 bytes big-endian in 10Hz increments
#
# Offset
# 0:10 Model, zero padded (Use first 7 chars for 'KG-UV8D')
# 11:14 UHF rx lower limit (in units of 10Hz)
# 15:18 UHF rx upper limit
# 19:22 UHF tx lower limit
# 23:26 UHF tx upper limit
# 27:30 VHF rx lower limit
# 31:34 VHF rx upper limit
# 35:38 VHF tx lower limit
# 39:42 VHF tx upper limit
@classmethod
def match_model(cls, filedata, filename):
id = cls._file_ident
return cls._file_ident in 'kg' + filedata[0x426:0x430].replace('(', '').replace(')', '').lower()
def _identify(self):
"""Do the identification dance"""
for _i in range(0, 10):
self._write_record(CMD_ID)
_chksum_err, _resp = self._read_record()
LOG.debug("Got:\n%s" % util.hexprint(_resp))
if _chksum_err:
LOG.error("Checksum error: retrying ident...")
time.sleep(0.100)
continue
LOG.debug("Model %s" % util.hexprint(_resp[0:9]))
if _resp[0:9] == self._model:
return
if len(_resp) == 0:
raise Exception("Radio not responding")
else:
raise Exception("Unable to identify radio")
def _finish(self):
self._write_record(CMD_END)
def process_mmap(self):
self._memobj = bitwise.parse(_MEM_FORMAT, self._mmap)
def sync_in(self):
try:
self._mmap = self._download()
except errors.RadioError:
raise
except (Exception, e):
raise errors.RadioError("Failed to communicate with radio: %s" % e)
self.process_mmap()
def sync_out(self):
self._upload()
# TODO: Load all memory.
# It would be smarter to only load the active areas and none of
# the padding/unused areas. Padding still need to be investigated.
def _download(self):
"""Talk to a wouxun KG-UV8E and do a download"""
try:
self._identify()
return self._do_download(0, 32768, 64)
except errors.RadioError:
raise
except (Exception, e):
LOG.exception('Unknown error during download process')
raise errors.RadioError("Failed to communicate with radio: %s" % e)
def _do_download(self, start, end, blocksize):
# allocate & fill memory
image = ""
for i in range(start, end, blocksize):
req = chr(i / 256) + chr(i % 256) + chr(blocksize)
self._write_record(CMD_RD, req)
cs_error, resp = self._read_record()
if cs_error:
LOG.debug(util.hexprint(resp))
raise Exception("Checksum error on read")
LOG.debug("Got:\n%s" % util.hexprint(resp))
image += resp[2:]
if self.status_fn:
status = chirp_common.Status()
status.cur = i
status.max = end
status.msg = "Cloning from radio"
self.status_fn(status)
self._finish()
return memmap.MemoryMap(''.join(image))
def _upload(self):
"""Talk to a wouxun KG-UV8E and do a upload"""
try:
self._identify()
self._do_upload(0, 32768, 64)
except errors.RadioError:
raise
except (Exception, e):
raise errors.RadioError("Failed to communicate with radio: %s" % e)
return
def _do_upload(self, start, end, blocksize):
ptr = start
for i in range(start, end, blocksize):
req = chr(i / 256) + chr(i % 256)
chunk = self.get_mmap()[ptr:ptr + blocksize]
self._write_record(CMD_WR, req + chunk)
# ~ LOG.debug(util.hexprint(req + chunk))
cserr, ack = self._read_record()
# ~ LOG.debug(util.hexprint(ack))
j = ord(ack[0]) * 256 + ord(ack[1])
if cserr or j != ptr:
raise Exception("Radio did not ack block %i" % ptr)
ptr += blocksize
if self.status_fn:
status = chirp_common.Status()
status.cur = i
status.max = end
status.msg = "Cloning to radio"
self.status_fn(status)
self._finish()
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.has_settings = True
rf.has_ctone = True
rf.has_rx_dtcs = True
rf.has_cross = True
rf.has_tuning_step = False
rf.has_bank = False
rf.can_odd_split = True
rf.valid_skips = ["", "S"]
rf.valid_tmodes = ["", "Tone", "TSQL", "DTCS", "Cross"]
rf.valid_cross_modes = [
"Tone->Tone",
"Tone->DTCS",
"DTCS->Tone",
"DTCS->",
"->Tone",
"->DTCS",
"DTCS->DTCS",
]
rf.valid_modes = ["FM", "NFM"]
rf.valid_power_levels = self.POWER_LEVELS
rf.valid_name_length = 8
rf.valid_duplexes = ["", "-", "+", "split", "off"]
rf.valid_bands = [(134000000, 175000000), # supports 2m
(220000000, 260000000), # supports 1.25m
(400000000, 520000000)] # supports 70cm
rf.valid_characters = chirp_common.CHARSET_ASCII
rf.memory_bounds = (1, 999) # 999 memories
rf.valid_tuning_steps = STEPS
return rf
@classmethod
def get_prompts(cls):
rp = chirp_common.RadioPrompts()
rp.experimental = \
('This driver is experimental.\n'
'\n'
'Please keep a copy of your memories with the original software '
'if you treasure them, this driver is new and may contain'
' bugs.\n'
'\n'
)
return rp
def get_raw_memory(self, number):
return repr(self._memobj.memory[number])
def _get_tone(self, _mem, mem):
def _get_dcs(val):
code = int("%03o" % (val & 0x07FF))
pol = (val & 0x8000) and "R" or "N"
return code, pol
tpol = False
if _mem.txtone != 0xFFFF and (_mem.txtone & 0x2800) == 0x2800:
tcode, tpol = _get_dcs(_mem.txtone)
mem.dtcs = tcode
txmode = "DTCS"
elif _mem.txtone != 0xFFFF and _mem.txtone != 0x0:
mem.rtone = (_mem.txtone & 0x7fff) / 10.0
txmode = "Tone"
else:
txmode = ""
rpol = False
if _mem.rxtone != 0xFFFF and (_mem.rxtone & 0x2800) == 0x2800:
rcode, rpol = _get_dcs(_mem.rxtone)
mem.rx_dtcs = rcode
rxmode = "DTCS"
elif _mem.rxtone != 0xFFFF and _mem.rxtone != 0x0:
mem.ctone = (_mem.rxtone & 0x7fff) / 10.0
rxmode = "Tone"
else:
rxmode = ""
if txmode == "Tone" and not rxmode:
mem.tmode = "Tone"
elif txmode == rxmode and txmode == "Tone" and mem.rtone == mem.ctone:
mem.tmode = "TSQL"
elif txmode == rxmode and txmode == "DTCS" and mem.dtcs == mem.rx_dtcs:
mem.tmode = "DTCS"
elif rxmode or txmode:
mem.tmode = "Cross"
mem.cross_mode = "%s->%s" % (txmode, rxmode)
# always set it even if no dtcs is used
mem.dtcs_polarity = "%s%s" % (tpol or "N", rpol or "N")
LOG.debug("Got TX %s (%i) RX %s (%i)" %
(txmode, _mem.txtone, rxmode, _mem.rxtone))
def get_memory(self, number):
_mem = self._memobj.memory[number]
_nam = self._memobj.names[number]
mem = chirp_common.Memory()
mem.number = number
_valid = self._memobj.valid[mem.number]
LOG.debug("%d %s", number, _valid == MEM_VALID)
if _valid != MEM_VALID:
mem.empty = True
return mem
else:
mem.empty = False
mem.freq = int(_mem.rxfreq) * 10
if _mem.txfreq == 0xFFFFFFFF:
# TX freq not set
mem.duplex = "off"
mem.offset = 0
elif int(_mem.rxfreq) == int(_mem.txfreq):
mem.duplex = ""
mem.offset = 0
elif abs(int(_mem.rxfreq) * 10 - int(_mem.txfreq) * 10) > 70000000:
mem.duplex = "split"
mem.offset = int(_mem.txfreq) * 10
else:
mem.duplex = int(_mem.rxfreq) > int(_mem.txfreq) and "-" or "+"
mem.offset = abs(int(_mem.rxfreq) - int(_mem.txfreq)) * 10
for char in _nam.name:
if char != 0:
mem.name += chr(char)
mem.name = mem.name.rstrip()
self._get_tone(_mem, mem)
mem.skip = "" if bool(_mem.scan_add) else "S"
mem.power = self.POWER_LEVELS[_mem.power]
mem.mode = _mem.iswide and "FM" or "NFM"
return mem
def _set_tone(self, mem, _mem):
def _set_dcs(code, pol):
val = int("%i" % code, 8) + 0x2800
if pol == "R":
val += 0x8000
return val
rx_mode = tx_mode = None
rxtone = txtone = 0x0000
if mem.tmode == "Tone":
tx_mode = "Tone"
rx_mode = None
txtone = int(mem.rtone * 10) + 0x8000
elif mem.tmode == "TSQL":
rx_mode = tx_mode = "Tone"
rxtone = txtone = int(mem.ctone * 10) + 0x8000
elif mem.tmode == "DTCS":
tx_mode = rx_mode = "DTCS"
txtone = _set_dcs(mem.dtcs, mem.dtcs_polarity[0])
rxtone = _set_dcs(mem.dtcs, mem.dtcs_polarity[1])
elif mem.tmode == "Cross":
tx_mode, rx_mode = mem.cross_mode.split("->")
if tx_mode == "DTCS":
txtone = _set_dcs(mem.dtcs, mem.dtcs_polarity[0])
elif tx_mode == "Tone":
txtone = int(mem.rtone * 10) + 0x8000
if rx_mode == "DTCS":
rxtone = _set_dcs(mem.rx_dtcs, mem.dtcs_polarity[1])
elif rx_mode == "Tone":
rxtone = int(mem.ctone * 10) + 0x8000
_mem.rxtone = rxtone
_mem.txtone = txtone
LOG.debug("Set TX %s (%i) RX %s (%i)" %
(tx_mode, _mem.txtone, rx_mode, _mem.rxtone))
def set_memory(self, mem):
number = mem.number
_mem = self._memobj.memory[number]
_nam = self._memobj.names[number]
if mem.empty:
_mem.set_raw("\x00" * (_mem.size() / 8))
self._memobj.valid[number] = 0
self._memobj.names[number].set_raw("\x00" * (_nam.size() / 8))
return
_mem.rxfreq = int(mem.freq / 10)
if mem.duplex == "off":
_mem.txfreq = 0xFFFFFFFF
elif mem.duplex == "split":
_mem.txfreq = int(mem.offset / 10)
elif mem.duplex == "off":
for i in range(0, 4):
_mem.txfreq[i].set_raw("\xFF")
elif mem.duplex == "+":
_mem.txfreq = int(mem.freq / 10) + int(mem.offset / 10)
elif mem.duplex == "-":
_mem.txfreq = int(mem.freq / 10) - int(mem.offset / 10)
else:
_mem.txfreq = int(mem.freq / 10)
_mem.scan_add = int(mem.skip != "S")
_mem.iswide = int(mem.mode == "FM")
# set the tone
self._set_tone(mem, _mem)
# set the scrambler and compander to off by default
_mem.scrambler = 0
_mem.compander = 0
# set the power
if mem.power:
_mem.power = self.POWER_LEVELS.index(mem.power)
else:
_mem.power = True
# set to mute mode to QT (not QT+DTMF or QT*DTMF) by default
_mem.mute_mode = 0
for i in range(0, len(_nam.name)):
if i < len(mem.name) and mem.name[i]:
_nam.name[i] = ord(mem.name[i])
else:
_nam.name[i] = 0x0
self._memobj.valid[mem.number] = MEM_VALID
def _get_settings(self):
_settings = self._memobj.settings
_vfoa = self._memobj.vfoa
_vfob = self._memobj.vfob
cfg_grp = RadioSettingGroup("cfg_grp", "Configuration")
vfoa_grp = RadioSettingGroup("vfoa_grp", "VFO A Settings")
vfob_grp = RadioSettingGroup("vfob_grp", "VFO B Settings")
key_grp = RadioSettingGroup("key_grp", "Key Settings")
lmt_grp = RadioSettingGroup("lmt_grp", "Frequency Limits")
uhf_lmt_grp = RadioSettingGroup("uhf_lmt_grp", "UHF")
vhf_lmt_grp = RadioSettingGroup("vhf_lmt_grp", "VHF")
vhf1_lmt_grp = RadioSettingGroup("vhf1_lmt_grp", "VHF1")
oem_grp = RadioSettingGroup("oem_grp", "OEM Info")
lmt_grp.append(vhf_lmt_grp);
lmt_grp.append(vhf1_lmt_grp);
lmt_grp.append(uhf_lmt_grp);
group = RadioSettings(cfg_grp, vfoa_grp, vfob_grp,
key_grp, lmt_grp, oem_grp)
#
# Configuration Settings
#
rs = RadioSetting("channel_menu", "Menu available in channel mode",
RadioSettingValueBoolean(_settings.channel_menu))
cfg_grp.append(rs)
rs = RadioSetting("ponmsg", "Poweron message",
RadioSettingValueList(
PONMSG_LIST, PONMSG_LIST[_settings.ponmsg]))
cfg_grp.append(rs)
rs = RadioSetting("voice", "Voice Guide",
RadioSettingValueBoolean(_settings.voice))
cfg_grp.append(rs)
rs = RadioSetting("language", "Language",
RadioSettingValueList(LANGUAGE_LIST,
LANGUAGE_LIST[_settings.
language]))
cfg_grp.append(rs)
rs = RadioSetting("timeout", "Timeout Timer",
RadioSettingValueList(
TIMEOUT_LIST, TIMEOUT_LIST[_settings.timeout]))
cfg_grp.append(rs)
rs = RadioSetting("toalarm", "Timeout Alarm",
RadioSettingValueInteger(0, 10, _settings.toalarm))
cfg_grp.append(rs)
rs = RadioSetting("roger_beep", "Roger Beep",
RadioSettingValueList(ROGER_LIST,
ROGER_LIST[_settings.roger_beep]))
cfg_grp.append(rs)
rs = RadioSetting("power_save", "Power save",
RadioSettingValueBoolean(_settings.power_save))
cfg_grp.append(rs)
rs = RadioSetting("autolock", "Autolock",
RadioSettingValueBoolean(_settings.autolock))
cfg_grp.append(rs)
rs = RadioSetting("keylock", "Keypad Lock",
RadioSettingValueBoolean(_settings.keylock))
cfg_grp.append(rs)
rs = RadioSetting("beep", "Keypad Beep",
RadioSettingValueBoolean(_settings.beep))
cfg_grp.append(rs)
rs = RadioSetting("stopwatch", "Stopwatch",
RadioSettingValueBoolean(_settings.stopwatch))
cfg_grp.append(rs)
rs = RadioSetting("backlight", "Backlight",
RadioSettingValueList(BACKLIGHT_LIST,
BACKLIGHT_LIST[_settings.
backlight]))
cfg_grp.append(rs)
rs = RadioSetting("dtmf_st", "DTMF Sidetone",
RadioSettingValueList(DTMFST_LIST,
DTMFST_LIST[_settings.
dtmf_st]))
cfg_grp.append(rs)
rs = RadioSetting("ani_sw", "ANI-ID Switch",
RadioSettingValueBoolean(_settings.ani_sw))
cfg_grp.append(rs)
rs = RadioSetting("ptt_id", "PTT-ID Delay",
RadioSettingValueList(PTTID_LIST,
PTTID_LIST[_settings.ptt_id]))
cfg_grp.append(rs)
rs = RadioSetting("ring_time", "Ring Time",
RadioSettingValueList(LIST_10,
LIST_10[_settings.ring_time]))
cfg_grp.append(rs)
rs = RadioSetting("scan_rev", "Scan Mode",
RadioSettingValueList(SCANMODE_LIST,
SCANMODE_LIST[_settings.
scan_rev]))
cfg_grp.append(rs)
rs = RadioSetting("vox", "VOX",
RadioSettingValueList(LIST_10,
LIST_10[_settings.vox]))
cfg_grp.append(rs)
rs = RadioSetting("prich_sw", "Priority Channel Switch",
RadioSettingValueBoolean(_settings.prich_sw))
cfg_grp.append(rs)
rs = RadioSetting("pri_ch", "Priority Channel",
RadioSettingValueInteger(1, 999, _settings.pri_ch))
cfg_grp.append(rs)
rs = RadioSetting("rpt_mode", "Radio Mode",
RadioSettingValueList(RPTMODE_LIST,
RPTMODE_LIST[_settings.
rpt_mode]))
cfg_grp.append(rs)
rs = RadioSetting("rpt_set", "Repeater Setting",
RadioSettingValueList(RPTSET_LIST,
RPTSET_LIST[_settings.
rpt_set]))
cfg_grp.append(rs)
rs = RadioSetting("rpt_spk", "Repeater Mode Speaker",
RadioSettingValueBoolean(_settings.rpt_spk))
cfg_grp.append(rs)
rs = RadioSetting("rpt_ptt", "Repeater PTT",
RadioSettingValueBoolean(_settings.rpt_ptt))
cfg_grp.append(rs)
rs = RadioSetting("dtmf_tx_time", "DTMF Tx Duration",
RadioSettingValueList(DTMF_TIMES,
DTMF_TIMES[_settings.
dtmf_tx_time]))
cfg_grp.append(rs)
rs = RadioSetting("dtmf_interval", "DTMF Interval",
RadioSettingValueList(DTMF_TIMES,
DTMF_TIMES[_settings.
dtmf_interval]))
cfg_grp.append(rs)
rs = RadioSetting("alert", "Alert Tone",
RadioSettingValueList(ALERTS_LIST,
ALERTS_LIST[_settings.alert]))
cfg_grp.append(rs)
rs = RadioSetting("rpt_tone", "Repeater Tone",
RadioSettingValueBoolean(_settings.rpt_tone))
cfg_grp.append(rs)
rs = RadioSetting("rpt_hold", "Repeater Hold Time",
RadioSettingValueList(HOLD_TIMES,
HOLD_TIMES[_settings.
rpt_hold]))
cfg_grp.append(rs)
rs = RadioSetting("scan_det", "Scan DET",
RadioSettingValueBoolean(_settings.scan_det))
cfg_grp.append(rs)
rs = RadioSetting("sc_qt", "SC-QT",
RadioSettingValueList(SCQT_LIST,
SCQT_LIST[_settings.sc_qt]))
cfg_grp.append(rs)
rs = RadioSetting("smuteset", "SubFreq Mute",
RadioSettingValueList(SMUTESET_LIST,
SMUTESET_LIST[_settings.
smuteset]))
cfg_grp.append(rs)
#
# VFO A Settings
#
rs = RadioSetting("workmode_a", "VFO A Workmode",
RadioSettingValueList(WORKMODE_LIST, WORKMODE_LIST[_settings.workmode_a]))
vfoa_grp.append(rs)
rs = RadioSetting("work_cha", "VFO A Channel",
RadioSettingValueInteger(1, 999, _settings.work_cha))
vfoa_grp.append(rs)
rs = RadioSetting("vfoa.rxfreq", "VFO A Rx Frequency",
RadioSettingValueInteger(
134000000, 520000000, _vfoa.rxfreq * 10, 5000))
vfoa_grp.append(rs)
rs = RadioSetting("vfoa.txoffset", "VFO A Tx Offset",
RadioSettingValueInteger(
0, 520000000, _vfoa.txoffset * 10, 5000))
vfoa_grp.append(rs)
# u16 rxtone;
# u16 txtone;
rs = RadioSetting("vfoa.power", "VFO A Power",
RadioSettingValueList(
POWER_LIST, POWER_LIST[_vfoa.power]))
vfoa_grp.append(rs)
# shift_dir:2
rs = RadioSetting("vfoa.iswide", "VFO A NBFM",
RadioSettingValueList(
BANDWIDTH_LIST, BANDWIDTH_LIST[_vfoa.iswide]))
vfoa_grp.append(rs)
rs = RadioSetting("vfoa.mute_mode", "VFO A Mute",
RadioSettingValueList(
SPMUTE_LIST, SPMUTE_LIST[_vfoa.mute_mode]))
vfoa_grp.append(rs)
rs = RadioSetting("vfoa.step", "VFO A Step (kHz)",
RadioSettingValueList(
STEP_LIST, STEP_LIST[_vfoa.step]))
vfoa_grp.append(rs)
rs = RadioSetting("vfoa.squelch", "VFO A Squelch",
RadioSettingValueList(
LIST_10, LIST_10[_vfoa.squelch]))
vfoa_grp.append(rs)
rs = RadioSetting("bcl_a", "Busy Channel Lock-out A",
RadioSettingValueBoolean(_settings.bcl_a))
vfoa_grp.append(rs)
#
# VFO B Settings
#
rs = RadioSetting("workmode_b", "VFO B Workmode",
RadioSettingValueList(WORKMODE_LIST, WORKMODE_LIST[_settings.workmode_b]))
vfob_grp.append(rs)
rs = RadioSetting("work_chb", "VFO B Channel",
RadioSettingValueInteger(1, 999, _settings.work_chb))
vfob_grp.append(rs)
rs = RadioSetting("vfob.rxfreq", "VFO B Rx Frequency",
RadioSettingValueInteger(
134000000, 520000000, _vfob.rxfreq * 10, 5000))
vfob_grp.append(rs)
rs = RadioSetting("vfob.txoffset", "VFO B Tx Offset",
RadioSettingValueInteger(
0, 520000000, _vfob.txoffset * 10, 5000))
vfob_grp.append(rs)
# u16 rxtone;
# u16 txtone;
rs = RadioSetting("vfob.power", "VFO B Power",
RadioSettingValueList(
POWER_LIST, POWER_LIST[_vfob.power]))
vfob_grp.append(rs)
# shift_dir:2
rs = RadioSetting("vfob.iswide", "VFO B NBFM",
RadioSettingValueList(
BANDWIDTH_LIST, BANDWIDTH_LIST[_vfob.iswide]))
vfob_grp.append(rs)
rs = RadioSetting("vfob.mute_mode", "VFO B Mute",
RadioSettingValueList(
SPMUTE_LIST, SPMUTE_LIST[_vfob.mute_mode]))
vfob_grp.append(rs)
rs = RadioSetting("vfob.step", "VFO B Step (kHz)",
RadioSettingValueList(
STEP_LIST, STEP_LIST[_vfob.step]))
vfob_grp.append(rs)
rs = RadioSetting("vfob.squelch", "VFO B Squelch",
RadioSettingValueList(
LIST_10, LIST_10[_vfob.squelch]))
vfob_grp.append(rs)
rs = RadioSetting("bcl_b", "Busy Channel Lock-out B",
RadioSettingValueBoolean(_settings.bcl_b))
vfob_grp.append(rs)
#
# Key Settings
#
_msg = str(_settings.dispstr).split("\0")[0]
val = RadioSettingValueString(0, 15, _msg)
val.set_mutable(True)
rs = RadioSetting("dispstr", "Display Message", val)
key_grp.append(rs)
dtmfchars = "0123456789"
_codeobj = _settings.ani_code
_code = "".join([dtmfchars[x] for x in _codeobj if int(x) < 0x0A])
val = RadioSettingValueString(3, 6, _code, False)
val.set_charset(dtmfchars)
rs = RadioSetting("ani_code", "ANI Code", val)
def apply_ani_id(setting, obj):
value = []
for j in range(0, 6):
try:
value.append(dtmfchars.index(str(setting.value)[j]))
except IndexError:
value.append(0xFF)
obj.ani_code = value
rs.set_apply_callback(apply_ani_id, _settings)
key_grp.append(rs)
rs = RadioSetting("pf1_func", "PF1 Key function",
RadioSettingValueList(
PF1KEY_LIST,
PF1KEY_LIST[_settings.pf1_func]))
key_grp.append(rs)
rs = RadioSetting("pf3_func", "PF3 Key function",
RadioSettingValueList(
PF3KEY_LIST,
PF3KEY_LIST[_settings.pf3_func]))
key_grp.append(rs)
#
# Limits settings
#
rs = RadioSetting("vhf_limits.rx_start", "VHF RX Lower Limit",
RadioSettingValueInteger(
134000000, 174997500,
self._memobj.vhf_limits.rx_start * 10, 5000))
vhf_lmt_grp.append(rs)
rs = RadioSetting("vhf_limits.rx_stop", "VHF RX Upper Limit",
RadioSettingValueInteger(
134000000, 174997500,
self._memobj.vhf_limits.rx_stop * 10, 5000))
vhf_lmt_grp.append(rs)
rs = RadioSetting("vhf_limits.tx_start", "VHF TX Lower Limit",
RadioSettingValueInteger(
134000000, 174997500,
self._memobj.vhf_limits.tx_start * 10, 5000))
vhf_lmt_grp.append(rs)
rs = RadioSetting("vhf_limits.tx_stop", "VHF TX Upper Limit",
RadioSettingValueInteger(
134000000, 174997500,
self._memobj.vhf_limits.tx_stop * 10, 5000))
vhf_lmt_grp.append(rs)
rs = RadioSetting("vhf1_limits.rx_start", "VHF1 RX Lower Limit",
RadioSettingValueInteger(
220000000, 265000000,
self._memobj.vhf1_limits.rx_start * 10, 5000))
vhf1_lmt_grp.append(rs)
rs = RadioSetting("vhf1_limits.rx_stop", "VHF1 RX Upper Limit",
RadioSettingValueInteger(
220000000, 265000000,
self._memobj.vhf1_limits.rx_stop * 10, 5000))
vhf1_lmt_grp.append(rs)
rs = RadioSetting("vhf1_limits.tx_start", "VHF1 TX Lower Limit",
RadioSettingValueInteger(
220000000, 265000000,
self._memobj.vhf1_limits.tx_start * 10, 5000))
vhf1_lmt_grp.append(rs)
rs = RadioSetting("vhf1_limits.tx_stop", "VHF1 TX Upper Limit",
RadioSettingValueInteger(
220000000, 265000000,
self._memobj.vhf1_limits.tx_stop * 10, 5000))
vhf1_lmt_grp.append(rs)
rs = RadioSetting("uhf_limits.rx_start", "UHF RX Lower Limit",
RadioSettingValueInteger(
400000000, 520000000,
self._memobj.uhf_limits.rx_start * 10, 5000))
uhf_lmt_grp.append(rs)
rs = RadioSetting("uhf_limits.rx_stop", "UHF RX Upper Limit",
RadioSettingValueInteger(
400000000, 520000000,
self._memobj.uhf_limits.rx_stop * 10, 5000))
uhf_lmt_grp.append(rs)
rs = RadioSetting("uhf_limits.tx_start", "UHF TX Lower Limit",
RadioSettingValueInteger(
400000000, 520000000,
self._memobj.uhf_limits.tx_start * 10, 5000))
uhf_lmt_grp.append(rs)
rs = RadioSetting("uhf_limits.tx_stop", "UHF TX Upper Limit",
RadioSettingValueInteger(
400000000, 520000000,
self._memobj.uhf_limits.tx_stop * 10, 5000))
uhf_lmt_grp.append(rs)
#
# OEM info
#
def _decode(lst):
_str = ''.join([chr(c) for c in lst
if chr(c) in chirp_common.CHARSET_ASCII])
return _str
def do_nothing(setting, obj):
return
_str = _decode(self._memobj.oem_info.model)
val = RadioSettingValueString(0, 15, _str)
val.set_mutable(False)
rs = RadioSetting("oem_info.model", "Model", val)
rs.set_apply_callback(do_nothing, _settings)
oem_grp.append(rs)
_str = _decode(self._memobj.oem_info.oem1)
val = RadioSettingValueString(0, 15, _str)
val.set_mutable(False)
rs = RadioSetting("oem_info.oem1", "OEM String 1", val)
rs.set_apply_callback(do_nothing, _settings)
oem_grp.append(rs)
_str = _decode(self._memobj.oem_info.oem2)
val = RadioSettingValueString(0, 15, _str)
val.set_mutable(False)
rs = RadioSetting("oem_info.oem2", "OEM String 2", val)
rs.set_apply_callback(do_nothing, _settings)
oem_grp.append(rs)
_str = _decode(self._memobj.oem_info.version)
val = RadioSettingValueString(0, 15, _str)
val.set_mutable(False)
rs = RadioSetting("oem_info.version", "Software Version", val)
rs.set_apply_callback(do_nothing, _settings)
oem_grp.append(rs)
_str = _decode(self._memobj.oem_info.date)
val = RadioSettingValueString(0, 15, _str)
val.set_mutable(False)
rs = RadioSetting("oem_info.date", "OEM Date", val)
rs.set_apply_callback(do_nothing, _settings)
oem_grp.append(rs)
return group
def get_settings(self):
try:
return self._get_settings()
except:
import traceback
LOG.error("Failed to parse settings: %s", traceback.format_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()
else:
LOG.debug("Setting %s = %s" % (setting, element.value))
if self._is_freq(element):
setattr(obj, setting, int(element.value)/10)
else:
setattr(obj, setting, element.value)
except (Exception, e):
LOG.debug(element.get_name())
raise
def _is_freq(self, element):
return "rxfreq" in element.get_name() or "txoffset" in element.get_name() or "rx_start" in element.get_name() or "rx_stop" in element.get_name() or "tx_start" in element.get_name() or "tx_stop" in element.get_name()
struct {
char name[24];
} Vertex_Standard_AH003M;
struct {
u8 dtmf[16];
} dtmf_mem[16];
"""
MODES_VHF = ["FM", "AM"]
MODES_UHF = ["FM"] # AM can be set but is ignored by the radio
DUPLEX = ["", "-", "+", "split"]
TONE_MODES_RADIO = ["", "Tone", "TSQL", "CTCSS Bell", "DTCS"]
TONE_MODES = ["", "Tone", "TSQL", "DTCS"]
POWER_LEVELS = [
chirp_common.PowerLevel("Low", watts=5),
chirp_common.PowerLevel("Low2", watts=10),
chirp_common.PowerLevel("Low3", watts=20),
chirp_common.PowerLevel("High", watts=35),
]
TUNING_STEPS = [5.0, 10.0, 12.5, 15.0, 20.0, 25.0, 50.0]
SKIP_VALUES = ["", "S"]
CHARSET = r"!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^ _"
DTMF_CHARSET = "0123456789*# "
SPECIAL_CHANS = ['VFO-VHF', 'VFO-UHF', 'Home-VHF', 'Home-UHF', 'VFO', 'Home']
SCAN_LIMITS = ["L1", "U1", "L2", "U2", "L3", "U3", "L4", "U4", "L5", "U5"]
def do_download(radio):
"""This is your download function"""
return _download(radio)
class RT21Radio(chirp_common.CloneModeRadio):
"""RETEVIS RT21"""
VENDOR = "Retevis"
MODEL = "RT21"
BAUD_RATE = 9600
BLOCK_SIZE = 0x10
BLOCK_SIZE_UP = 0x10
POWER_LEVELS = [chirp_common.PowerLevel("Low", watts=1.00),
chirp_common.PowerLevel("High", watts=2.50)]
_magic = "PRMZUNE"
_fingerprint = "P3207s\xF8\xFF"
_upper = 16
_skipflags = True
_reserved = False
_gmrs = False
_ranges = [
(0x0000, 0x0400),
]
_memsize = 0x0400
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.has_settings = True
rf.has_bank = False
rf.has_ctone = True
rf.has_cross = True
rf.has_rx_dtcs = True
rf.has_tuning_step = False
rf.can_odd_split = True
rf.has_name = False
rf.valid_skips = ["", "S"]
rf.valid_tmodes = ["", "Tone", "TSQL", "DTCS", "Cross"]
rf.valid_cross_modes = ["Tone->Tone", "Tone->DTCS", "DTCS->Tone",
"->Tone", "->DTCS", "DTCS->", "DTCS->DTCS"]
rf.valid_power_levels = self.POWER_LEVELS
rf.valid_duplexes = ["", "-", "+", "split", "off"]
rf.valid_modes = ["NFM", "FM"] # 12.5 KHz, 25 kHz.
rf.memory_bounds = (1, self._upper)
rf.valid_tuning_steps = [2.5, 5., 6.25, 10., 12.5, 25.]
rf.valid_bands = [(400000000, 480000000)]
return rf
def process_mmap(self):
self._memobj = bitwise.parse(MEM_FORMAT, self._mmap)
def validate_memory(self, mem):
msgs = ""
msgs = chirp_common.CloneModeRadio.validate_memory(self, mem)
_msg_freq = 'Memory location cannot change frequency'
_msg_simplex = 'Memory location only supports Duplex:(None)'
_msg_duplex = 'Memory location only supports Duplex: +'
_msg_offset = 'Memory location only supports Offset: 5.000000'
_msg_nfm = 'Memory location only supports Mode: NFM'
_msg_txp = 'Memory location only supports Power: Low'
# GMRS models
if self._gmrs:
# range of memories with values set by FCC rules
if mem.freq != int(GMRS_FREQS[mem.number - 1] * 1000000):
# warn user can't change frequency
msgs.append(chirp_common.ValidationError(_msg_freq))
# channels 1 - 22 are simplex only
if mem.number <= 22:
if str(mem.duplex) != "":
# warn user can't change duplex
msgs.append(chirp_common.ValidationError(_msg_simplex))
# channels 23 - 30 are +5 MHz duplex only
if mem.number >= 23:
if str(mem.duplex) != "+":
# warn user can't change duplex
msgs.append(chirp_common.ValidationError(_msg_duplex))
if str(mem.offset) != "5000000":
# warn user can't change offset
msgs.append(chirp_common.ValidationError(_msg_offset))
# channels 8 - 14 are low power NFM only
if mem.number >= 8 and mem.number <= 14:
if mem.mode != "NFM":
# warn user can't change mode
msgs.append(chirp_common.ValidationError(_msg_nfm))
if mem.power != "Low":
# warn user can't change power
msgs.append(chirp_common.ValidationError(_msg_txp))
return msgs
def sync_in(self):
"""Download from radio"""
try:
data = do_download(self)
except errors.RadioError:
# Pass through any real errors we raise
raise
except:
# If anything unexpected happens, make sure we raise
# a RadioError and log the problem
LOG.exception('Unexpected error during download')
raise errors.RadioError('Unexpected error communicating '
'with the radio')
self._mmap = data
self.process_mmap()
def sync_out(self):
"""Upload to radio"""
try:
do_upload(self)
except:
# If anything unexpected happens, make sure we raise
# a RadioError and log the problem
LOG.exception('Unexpected error during upload')
raise errors.RadioError('Unexpected error communicating '
'with the radio')
def get_raw_memory(self, number):
return repr(self._memobj.memory[number - 1])
def _get_tone(self, _mem, mem):
def _get_dcs(val):
code = int("%03o" % (val & 0x07FF))
pol = (val & 0x8000) and "R" or "N"
return code, pol
if _mem.tx_tone != 0xFFFF and _mem.tx_tone > 0x2000:
tcode, tpol = _get_dcs(_mem.tx_tone)
mem.dtcs = tcode
txmode = "DTCS"
elif _mem.tx_tone != 0xFFFF:
mem.rtone = _mem.tx_tone / 10.0
txmode = "Tone"
else:
txmode = ""
if _mem.rx_tone != 0xFFFF and _mem.rx_tone > 0x2000:
rcode, rpol = _get_dcs(_mem.rx_tone)
mem.rx_dtcs = rcode
rxmode = "DTCS"
elif _mem.rx_tone != 0xFFFF:
mem.ctone = _mem.rx_tone / 10.0
rxmode = "Tone"
else:
rxmode = ""
if txmode == "Tone" and not rxmode:
mem.tmode = "Tone"
elif txmode == rxmode and txmode == "Tone" and mem.rtone == mem.ctone:
mem.tmode = "TSQL"
elif txmode == rxmode and txmode == "DTCS" and mem.dtcs == mem.rx_dtcs:
mem.tmode = "DTCS"
elif rxmode or txmode:
mem.tmode = "Cross"
mem.cross_mode = "%s->%s" % (txmode, rxmode)
if mem.tmode == "DTCS":
mem.dtcs_polarity = "%s%s" % (tpol, rpol)
LOG.debug("Got TX %s (%i) RX %s (%i)" %
(txmode, _mem.tx_tone, rxmode, _mem.rx_tone))
def get_memory(self, number):
if self._skipflags:
bitpos = (1 << ((number - 1) % 8))
bytepos = ((number - 1) / 8)
LOG.debug("bitpos %s" % bitpos)
LOG.debug("bytepos %s" % bytepos)
_skp = self._memobj.skipflags[bytepos]
mem = chirp_common.Memory()
mem.number = number
if self.MODEL == "RB17A":
if mem.number < 17:
_mem = self._memobj.lomems[number - 1]
else:
_mem = self._memobj.himems[number - 17]
else:
_mem = self._memobj.memory[number - 1]
if self._reserved:
_rsvd = _mem.reserved.get_raw()
mem.freq = int(_mem.rxfreq) * 10
# We'll consider any blank (i.e. 0MHz frequency) to be empty
if mem.freq == 0:
mem.empty = True
return mem
if _mem.rxfreq.get_raw() == "\xFF\xFF\xFF\xFF":
mem.freq = 0
mem.empty = True
return mem
if _mem.get_raw() == ("\xFF" * 16):
LOG.debug("Initializing empty memory")
if self.MODEL == "RB17A":
_mem.set_raw("\x00" * 13 + "\x04\xFF\xFF")
if self.MODEL == "RB26" or self.MODEL == "RT76":
_mem.set_raw("\x00" * 13 + _rsvd)
else:
_mem.set_raw("\x00" * 13 + "\x30\x8F\xF8")
if int(_mem.rxfreq) == int(_mem.txfreq):
mem.duplex = ""
mem.offset = 0
else:
mem.duplex = int(_mem.rxfreq) > int(_mem.txfreq) and "-" or "+"
mem.offset = abs(int(_mem.rxfreq) - int(_mem.txfreq)) * 10
mem.mode = _mem.wide and "FM" or "NFM"
self._get_tone(_mem, mem)
mem.power = self.POWER_LEVELS[_mem.highpower]
if self.MODEL != "RT76":
mem.skip = "" if (_skp & bitpos) else "S"
LOG.debug("mem.skip %s" % mem.skip)
mem.extra = RadioSettingGroup("Extra", "extra")
if self.MODEL == "RT21" or self.MODEL == "RB17A":
rs = RadioSettingValueList(BCL_LIST, BCL_LIST[_mem.bcl])
rset = RadioSetting("bcl", "Busy Channel Lockout", rs)
mem.extra.append(rset)
rs = RadioSettingValueList(SCRAMBLE_LIST,
SCRAMBLE_LIST[_mem.scramble_type - 8])
rset = RadioSetting("scramble_type", "Scramble Type", rs)
mem.extra.append(rset)
if self.MODEL == "RB17A":
rs = RadioSettingValueList(CDCSS_LIST, CDCSS_LIST[_mem.cdcss])
rset = RadioSetting("cdcss", "Cdcss Mode", rs)
mem.extra.append(rset)
if self.MODEL == "RB26" or self.MODEL == "RT76":
if self.MODEL == "RB26":
rs = RadioSettingValueBoolean(_mem.bcl)
rset = RadioSetting("bcl", "Busy Channel Lockout", rs)
mem.extra.append(rset)
rs = RadioSettingValueBoolean(_mem.compander)
rset = RadioSetting("compander", "Compander", rs)
mem.extra.append(rset)
if self._gmrs:
GMRS_IMMUTABLE = ["freq", "duplex", "offset"]
if mem.number >= 8 and mem.number <= 14:
mem.immutable = GMRS_IMMUTABLE + ["power", "mode"]
else:
mem.immutable = GMRS_IMMUTABLE
return mem
def _set_tone(self, mem, _mem):
def _set_dcs(code, pol):
val = int("%i" % code, 8) + 0x2800
if pol == "R":
val += 0x8000
return val
rx_mode = tx_mode = None
rx_tone = tx_tone = 0xFFFF
if mem.tmode == "Tone":
tx_mode = "Tone"
rx_mode = None
tx_tone = int(mem.rtone * 10)
elif mem.tmode == "TSQL":
rx_mode = tx_mode = "Tone"
rx_tone = tx_tone = int(mem.ctone * 10)
elif mem.tmode == "DTCS":
tx_mode = rx_mode = "DTCS"
tx_tone = _set_dcs(mem.dtcs, mem.dtcs_polarity[0])
rx_tone = _set_dcs(mem.dtcs, mem.dtcs_polarity[1])
elif mem.tmode == "Cross":
tx_mode, rx_mode = mem.cross_mode.split("->")
if tx_mode == "DTCS":
tx_tone = _set_dcs(mem.dtcs, mem.dtcs_polarity[0])
elif tx_mode == "Tone":
tx_tone = int(mem.rtone * 10)
if rx_mode == "DTCS":
rx_tone = _set_dcs(mem.rx_dtcs, mem.dtcs_polarity[1])
elif rx_mode == "Tone":
rx_tone = int(mem.ctone * 10)
_mem.rx_tone = rx_tone
_mem.tx_tone = tx_tone
LOG.debug("Set TX %s (%i) RX %s (%i)" %
(tx_mode, _mem.tx_tone, rx_mode, _mem.rx_tone))
def set_memory(self, mem):
if self._skipflags:
bitpos = (1 << ((mem.number - 1) % 8))
bytepos = ((mem.number - 1) / 8)
LOG.debug("bitpos %s" % bitpos)
LOG.debug("bytepos %s" % bytepos)
_skp = self._memobj.skipflags[bytepos]
if self.MODEL == "RB17A":
if mem.number < 17:
_mem = self._memobj.lomems[mem.number - 1]
else:
_mem = self._memobj.himems[mem.number - 17]
else:
_mem = self._memobj.memory[mem.number - 1]
if self._reserved:
_rsvd = _mem.reserved.get_raw()
if mem.empty:
if self.MODEL == "RB17A":
_mem.set_raw("\xFF" * 12 + "\x00\x00\xFF\xFF")
elif self.MODEL == "RB26" or self.MODEL == "RT76":
_mem.set_raw("\xFF" * 13 + _rsvd)
else:
_mem.set_raw("\xFF" * (_mem.size() / 8))
if self._gmrs:
GMRS_FREQ = int(GMRS_FREQS[mem.number - 1] * 100000)
if mem.number > 22:
_mem.rxfreq = GMRS_FREQ
_mem.txfreq = int(_mem.rxfreq) + 500000
_mem.wide = True
else:
_mem.rxfreq = _mem.txfreq = GMRS_FREQ
if mem.number >= 8 and mem.number <= 14:
_mem.wide = False
_mem.highpower = False
else:
_mem.wide = True
_mem.highpower = True
return
if self.MODEL == "RB17A":
_mem.set_raw("\x00" * 13 + "\x00\xFF\xFF")
elif self.MODEL == "RB26" or self.MODEL == "RT76":
_mem.set_raw("\x00" * 13 + _rsvd)
else:
_mem.set_raw("\x00" * 13 + "\x30\x8F\xF8")
_mem.rxfreq = mem.freq / 10
if mem.duplex == "off":
for i in range(0, 4):
_mem.txfreq[i].set_raw("\xFF")
elif mem.duplex == "split":
_mem.txfreq = mem.offset / 10
elif mem.duplex == "+":
_mem.txfreq = (mem.freq + mem.offset) / 10
elif mem.duplex == "-":
_mem.txfreq = (mem.freq - mem.offset) / 10
else:
_mem.txfreq = mem.freq / 10
_mem.wide = mem.mode == "FM"
self._set_tone(mem, _mem)
_mem.highpower = mem.power == self.POWER_LEVELS[1]
if self.MODEL != "RT76":
if mem.skip != "S":
_skp |= bitpos
else:
_skp &= ~bitpos
LOG.debug("_skp %s" % _skp)
for setting in mem.extra:
if setting.get_name() == "scramble_type":
setattr(_mem, setting.get_name(), int(setting.value) + 8)
setattr(_mem, "scramble_type2", int(setting.value) + 8)
else:
setattr(_mem, setting.get_name(), setting.value)
def get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic Settings")
top = RadioSettings(basic)
if self.MODEL == "RT21" or self.MODEL == "RB17A":
_keys = self._memobj.keys
rs = RadioSettingValueList(TIMEOUTTIMER_LIST,
TIMEOUTTIMER_LIST[_settings.tot - 1])
rset = RadioSetting("tot", "Time-out timer", rs)
basic.append(rset)
rs = RadioSettingValueList(TOTALERT_LIST,
TOTALERT_LIST[_settings.totalert])
rset = RadioSetting("totalert", "TOT Pre-alert", rs)
basic.append(rset)
rs = RadioSettingValueInteger(0, 9, _settings.squelch)
rset = RadioSetting("squelch", "Squelch Level", rs)
basic.append(rset)
rs = RadioSettingValueList(VOICE_LIST, VOICE_LIST[_settings.voice])
rset = RadioSetting("voice", "Voice Annumciation", rs)
basic.append(rset)
if self.MODEL == "RB17A":
rs = RadioSettingValueList(ALARM_LIST,
ALARM_LIST[_settings.alarm])
rset = RadioSetting("alarm", "Alarm Type", rs)
basic.append(rset)
rs = RadioSettingValueBoolean(_settings.save)
rset = RadioSetting("save", "Battery Saver", rs)
basic.append(rset)
rs = RadioSettingValueBoolean(_settings.use_scramble)
rset = RadioSetting("use_scramble", "Scramble", rs)
basic.append(rset)
rs = RadioSettingValueBoolean(_settings.use_vox)
rset = RadioSetting("use_vox", "VOX", rs)
basic.append(rset)
rs = RadioSettingValueList(VOX_LIST, VOX_LIST[_settings.vox])
rset = RadioSetting("vox", "VOX Gain", rs)
basic.append(rset)
def apply_pf1_listvalue(setting, obj):
LOG.debug("Setting value: " + str(
setting.value) + " from list")
val = str(setting.value)
index = PF1_CHOICES.index(val)
val = PF1_VALUES[index]
obj.set_value(val)
if _keys.pf1 in PF1_VALUES:
idx = PF1_VALUES.index(_keys.pf1)
else:
idx = LIST_DTMF_SPECIAL_VALUES.index(0x04)
rs = RadioSettingValueList(PF1_CHOICES, PF1_CHOICES[idx])
rset = RadioSetting("keys.pf1", "PF1 Key Function", rs)
rset.set_apply_callback(apply_pf1_listvalue, _keys.pf1)
basic.append(rset)
def apply_topkey_listvalue(setting, obj):
LOG.debug("Setting value: " + str(setting.value) +
" from list")
val = str(setting.value)
index = TOPKEY_CHOICES.index(val)
val = TOPKEY_VALUES[index]
obj.set_value(val)
if self.MODEL == "RB17A":
if _keys.topkey in TOPKEY_VALUES:
idx = TOPKEY_VALUES.index(_keys.topkey)
else:
idx = TOPKEY_VALUES.index(0x0C)
rs = RadioSettingValueList(TOPKEY_CHOICES, TOPKEY_CHOICES[idx])
rset = RadioSetting("keys.topkey", "Top Key Function", rs)
rset.set_apply_callback(apply_topkey_listvalue, _keys.topkey)
basic.append(rset)
if self.MODEL == "RB26" or self.MODEL == "RT76":
if self.MODEL == "RB26":
_settings2 = self._memobj.settings2
_settings3 = self._memobj.settings3
rs = RadioSettingValueInteger(0, 9, _settings.squelch)
rset = RadioSetting("squelch", "Squelch Level", rs)
basic.append(rset)
rs = RadioSettingValueList(TIMEOUTTIMER_LIST,
TIMEOUTTIMER_LIST[_settings.tot - 1])
rset = RadioSetting("tot", "Time-out timer", rs)
basic.append(rset)
if self.MODEL == "RT76":
rs = RadioSettingValueList(VOICE_LIST3,
VOICE_LIST3[_settings.voice])
rset = RadioSetting("voice", "Voice Annumciation", rs)
basic.append(rset)
if self.MODEL == "RB26":
rs = RadioSettingValueList(VOICE_LIST2,
VOICE_LIST2[_settings.voice])
rset = RadioSetting("voice", "Voice Annumciation", rs)
basic.append(rset)
rs = RadioSettingValueBoolean(not _settings.chnumberd)
rset = RadioSetting("chnumberd", "Channel Number Enable", rs)
basic.append(rset)
rs = RadioSettingValueBoolean(_settings.save)
rset = RadioSetting("save", "Battery Save", rs)
basic.append(rset)
rs = RadioSettingValueBoolean(_settings.beep)
rset = RadioSetting("beep", "Beep", rs)
basic.append(rset)
if self.MODEL == "RB26":
rs = RadioSettingValueBoolean(not _settings.tail)
rset = RadioSetting("tail", "QT/DQT Tail", rs)
basic.append(rset)
rs = RadioSettingValueList(SAVE_LIST, SAVE_LIST[_settings.savem])
rset = RadioSetting("savem", "Battery Save Mode", rs)
basic.append(rset)
rs = RadioSettingValueList(GAIN_LIST, GAIN_LIST[_settings.gain])
rset = RadioSetting("gain", "MIC Gain", rs)
basic.append(rset)
rs = RadioSettingValueList(WARN_LIST, WARN_LIST[_settings.warn])
rset = RadioSetting("warn", "Warn Mode", rs)
basic.append(rset)
if self.MODEL == "RB26":
rs = RadioSettingValueBoolean(_settings3.vox)
rset = RadioSetting("settings3.vox", "Vox Function", rs)
basic.append(rset)
rs = RadioSettingValueList(VOXL_LIST,
VOXL_LIST[_settings3.voxl])
rset = RadioSetting("settings3.voxl", "Vox Level", rs)
basic.append(rset)
rs = RadioSettingValueList(VOXD_LIST,
VOXD_LIST[_settings3.voxd])
rset = RadioSetting("settings3.voxd", "Vox Delay", rs)
basic.append(rset)
rs = RadioSettingValueList(PFKEY_LIST,
PFKEY_LIST[_settings.pf1])
rset = RadioSetting("pf1", "PF1 Key Set", rs)
basic.append(rset)
rs = RadioSettingValueList(PFKEY_LIST,
PFKEY_LIST[_settings.pf2])
rset = RadioSetting("pf2", "PF2 Key Set", rs)
basic.append(rset)
rs = RadioSettingValueInteger(1, 30, _settings2.chnumber + 1)
rset = RadioSetting("settings2.chnumber", "Channel Number", rs)
basic.append(rset)
if self.MODEL == "RT76":
rs = RadioSettingValueBoolean(_settings.vox)
rset = RadioSetting("vox", "Vox Function", rs)
basic.append(rset)
rs = RadioSettingValueList(VOXL_LIST,
VOXL_LIST[_settings.voxl])
rset = RadioSetting("voxl", "Vox Level", rs)
basic.append(rset)
rs = RadioSettingValueList(VOXD_LIST,
VOXD_LIST[_settings.voxd])
rset = RadioSetting("voxd", "Vox Delay", rs)
basic.append(rset)
rs = RadioSettingValueInteger(1, 30, _settings.chnumber + 1)
rset = RadioSetting("chnumber", "Channel Number", rs)
basic.append(rset)
return top
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 == "channel":
setattr(obj, setting, int(element.value) - 1)
elif setting == "chnumber":
setattr(obj, setting, int(element.value) - 1)
elif setting == "chnumberd":
setattr(obj, setting, not int(element.value))
elif setting == "tail":
setattr(obj, setting, not int(element.value))
elif setting == "tot":
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
