|
# Copyright 2020 Uriel Corfa <uriel@corfa.fr>
|
|
#
|
|
# 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 struct
|
|
import time
|
|
import os
|
|
import logging
|
|
|
|
from chirp import chirp_common, errors, util, directory, memmap
|
|
from chirp.settings import RadioSetting, RadioSettingGroup, \
|
|
RadioSettingValueInteger, RadioSettingValueList, \
|
|
RadioSettingValueBoolean, RadioSettingValueString, \
|
|
RadioSettings
|
|
from chirp import bitwise
|
|
from textwrap import dedent
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
MEM_FORMAT = """
|
|
struct channel {
|
|
lbcd rxfreq[4];
|
|
lbcd txfreq[4];
|
|
ul16 rxtone;
|
|
ul16 txtone;
|
|
u8 unknown1:3,
|
|
busylock:1,
|
|
scanadd:1,
|
|
unknown2:3;
|
|
u8 unknown3:2,
|
|
power:1,
|
|
width:1,
|
|
unknown4:4;
|
|
u8 signalcode;
|
|
u8 unknown5;
|
|
};
|
|
|
|
#seekto 0x0000;
|
|
struct channel memory[128];
|
|
|
|
#seekto 0x0f60;
|
|
struct channel vfo1;
|
|
#seekto 0x0f70;
|
|
struct channel vfo2;
|
|
|
|
#seekto 0x1000;
|
|
struct {
|
|
u8 name[8];
|
|
u8 unknown[8];
|
|
} names[128];
|
|
|
|
#seekto 0x0E20;
|
|
struct {
|
|
u8 mdfa; // 0x0E20
|
|
u8 step; // 0x0E21
|
|
u8 squelch; // 0x0E22
|
|
u8 powersave; // 0x0E23
|
|
u8 vox; // 0x0E24
|
|
u8 unknownE25; // 0x0E25
|
|
u8 tot; // 0x0E26
|
|
u8 unknownE27; // 0x0E27
|
|
u8 dualwatch; // 0x0E28
|
|
u8 unknownE29[4]; // 0x0E29 .. 2C
|
|
u8 beep; // 0x0E2D
|
|
u8 lang; // 0x0E2E
|
|
u8 unknownE2F; // 0x0E2F
|
|
|
|
u8 dtmfst; // 0x0E30
|
|
u8 unknownE31; // 0x0E31
|
|
u8 chan1; // 0x0E32
|
|
u8 chan2; // 0x0E33
|
|
u8 pttlt; // 0x0E34
|
|
u8 pttid; // 0x0E35
|
|
u8 unknownE36; // 0x0E36
|
|
u8 mdfb; // 0x0E37
|
|
u8 scanresmode; // 0x0E38
|
|
u8 autolk; // 0x0E39
|
|
u8 unknnownE3A[3]; // 0x0E3A .. 3C
|
|
u8 stbycolor; // 0x0E3D
|
|
u8 rxcolor; // 0x0E3E
|
|
u8 txcolor; // 0x0E3F
|
|
|
|
u8 alarm; // 0x0E40
|
|
u8 unknownE41; // 0x0E41
|
|
u8 tdrab; // 0x0E42
|
|
u8 ste; // 0x0E43
|
|
u8 rpste; // 0x0E44
|
|
u8 rptrl; // 0x0E45
|
|
u8 ponmsg; // 0x0E46
|
|
u8 roger; // 0x0E47
|
|
u8 unknownE48[4]; // 0x0E48 .. 4B
|
|
u8 vfomr; // 0x0E4C
|
|
u8 locked; // 0x0E4D
|
|
u8 abr; // 0x0E4E
|
|
u8 unknownE4F; // 0x0E4F
|
|
|
|
u8 unknownE50[10]; // 0x0E50 .. 59
|
|
u8 aniid[5]; // 0x0E5A .. 5E
|
|
u8 unknownE5F; // 0x0E5F // This is probably supposed to remain
|
|
// at 0xff, as a string terminator for
|
|
// the ANI ID
|
|
} settings;
|
|
|
|
#seekto 0x0B00;
|
|
struct {
|
|
u8 dtmf[5];
|
|
u8 unused[11];
|
|
} dtmf[16];
|
|
"""
|
|
|
|
MAGIC = b"\x4b\x6b\x4e\x48\x53\x47\x30\x4e\x02"
|
|
VERSION = b"\x06\x4a\x35\x36\x30\x32\x43\xf8"
|
|
|
|
SPECIALS = {
|
|
"VFO1": ("vfo1", -2),
|
|
"VFO2": ("vfo2", -1),
|
|
}
|
|
NUM_CHANNELS = 128
|
|
|
|
POWER_LEVELS = [chirp_common.PowerLevel("Low", watts=1.00),
|
|
chirp_common.PowerLevel("High", watts=4.00)]
|
|
MODES = ["NFM", "FM"]
|
|
STEPS = [2.5, 5.0, 6.25, 10.0, 12.5, 25.0]
|
|
LANGUAGES = ["Off", "Chinese", "English"]
|
|
SCANRES_MODES = ["Skip after 5s",
|
|
"Skip when carrier-wave drops",
|
|
"Stop when found"]
|
|
COLORS = ["Off", "Green", "Purple", "Sky blue"]
|
|
DTMFST_MODES = ["Off", "DT-ST", "ANI", "DT-ST + ANI"]
|
|
PTTID_MODES = ["Off", "BOT", "EOT", "Both"]
|
|
DISPLAY_MODES = ["Frequency", "Channel no", "Name"]
|
|
ALARM_MODES = ["Tone", "Code", "Site"]
|
|
TDRAB_MODES = ["Off", "A only (upper row)", "B only (lower row)"]
|
|
VFOMR_MODES = ["VFO", "Channels"]
|
|
TOT_TIMES = [str(x) for x in range(15, 601, 15)]
|
|
|
|
DTMF_CHARS = "1234567890*#ABCD"
|
|
|
|
|
|
def _send(radio, msg):
|
|
LOG.debug("Sending msg:\n%s" % util.hexprint(msg))
|
|
try:
|
|
radio.pipe.write(msg)
|
|
except Exception, e:
|
|
raise errors.RadioError("Serial write error: %s", e)
|
|
|
|
|
|
def _read(radio, size):
|
|
try:
|
|
answer = radio.pipe.read(size)
|
|
except Exception, e:
|
|
raise errors.RadioError("Serial read error: %s", e)
|
|
LOG.debug("Recv:\n%s" % util.hexprint(answer))
|
|
return answer
|
|
|
|
|
|
def ident(radio):
|
|
radio.pipe.timeout = 1
|
|
|
|
_send(radio, MAGIC)
|
|
ack = _read(radio, 1)
|
|
time.sleep(0.1)
|
|
if ack != b"\x06":
|
|
raise errors.RadioError("Radio did not respond to ident")
|
|
_send(radio, b"\x02")
|
|
version = _read(radio, 8)
|
|
if version != VERSION:
|
|
raise errors.RadioError("Unknown version: %s", version)
|
|
|
|
|
|
def _read_block(radio, start, size):
|
|
_send(radio, b"\x06")
|
|
ack = _read(radio, 1)
|
|
if ack != b"\x06":
|
|
raise errors.RadioError("Radio not ready to read")
|
|
|
|
msg = struct.pack(">BHB", ord("R"), start, size)
|
|
_send(radio, msg)
|
|
|
|
header = _read(radio, 4)
|
|
op, rstart, rsize = struct.unpack(">BHB", header)
|
|
if op != ord('W'):
|
|
raise errors.RadioError(
|
|
"Wrong reply: expected 87 (W), got %s (%s)" % (op, chr(op)))
|
|
if rstart != start:
|
|
raise errors.RadioError(
|
|
"Radio read started at %s, expected %s" % (rstart, start))
|
|
data = _read(radio, rsize)
|
|
if len(data) != size:
|
|
raise errors.RadioError("Radio refused to send block 0x%04x" % start)
|
|
return data
|
|
|
|
|
|
def _write_block(radio, start, block):
|
|
size = len(block)
|
|
msg = struct.pack(">BHB", ord("W"), start, size)
|
|
_send(radio, msg)
|
|
_send(radio, block)
|
|
ack = _read(radio, 1)
|
|
if ack != b"\x06":
|
|
raise errors.RadioError("Radio failed to write")
|
|
|
|
|
|
def do_download(radio):
|
|
"""This is your download function"""
|
|
# Check we're talking to the real deal
|
|
ident(radio)
|
|
|
|
status = chirp_common.Status()
|
|
status.msg = "Cloning from UV-R50"
|
|
status.max = 0x2000
|
|
|
|
mm = memmap.MemoryMap(b"\x00" * 0x2000)
|
|
for i in range(0x0000, 0x1fb0, 0x40):
|
|
status.cur = i
|
|
radio.status_fn(status)
|
|
data = _read_block(radio, i, 0x40)
|
|
mm.set(i, data)
|
|
|
|
return mm
|
|
|
|
|
|
def do_upload(radio):
|
|
"""This is your upload function"""
|
|
ident(radio)
|
|
|
|
status = chirp_common.Status()
|
|
status.msg = "Cloning to UV-R50"
|
|
status.max = 0x2000
|
|
|
|
# Unclear why, but the official client reads this before writing
|
|
# and the radio won't let us write before we read this block.
|
|
_read_block(radio, 0x0fd0, 0x40)
|
|
|
|
_send(radio, b"\x06")
|
|
ack = _read(radio, 1)
|
|
if ack != b"\x06":
|
|
raise errors.RadioError("Radio not ready to write")
|
|
|
|
mm = radio.get_mmap()
|
|
for i in range(0x0000, 0x1fe0, 0x10):
|
|
status.cur = i
|
|
radio.status_fn(status)
|
|
block = mm[i:i+0x10]
|
|
_write_block(radio, i, block)
|
|
|
|
# Get the serial port connection
|
|
serial = radio.pipe
|
|
|
|
# Our fake radio is just a simple upload of 1000 bytes
|
|
# to the serial port. Do that one byte at a time, reading
|
|
# from our memory map
|
|
for i in range(0, 1000):
|
|
serial.write(radio.get_mmap()[i])
|
|
|
|
|
|
@directory.register
|
|
class QuanshengUVR50Radio(chirp_common.CloneModeRadio):
|
|
"""Quansheng UV-R50 radio.
|
|
|
|
This is probably V1 of this radio, and documentation about other
|
|
models is sparse on the internet. As far as I can tell, UV-R50-2
|
|
and UV-R50-CX are just different cases for the same internal
|
|
hardware, but I only have one model and I'm not sure which one.
|
|
|
|
"""
|
|
VENDOR = "Quansheng"
|
|
MODEL = "UV-R50"
|
|
BAUD_RATE = 9600
|
|
NEEDS_COMPAT_SERIAL = False
|
|
|
|
_chars = dict(enumerate(range(ord('0'), ord('9') + 1) +
|
|
range(ord('A'), ord('Z') + 1)))
|
|
|
|
def _ascii2quansheng(self, asc, maxlen):
|
|
"""Converts ASCII to an encoding the R50 understands."""
|
|
revchars = {c: int(pos) for (pos, c) in self._chars.items()}
|
|
asc = asc.ljust(maxlen).upper()
|
|
qs = []
|
|
for i in range(maxlen):
|
|
qs.append(revchars.get(ord(asc[i]), 0xff))
|
|
return qs
|
|
|
|
def _quansheng2ascii(self, qs, maxlen):
|
|
"""Converts the R50's text encoding scheme to ASCII."""
|
|
asc = ''
|
|
for i in range(maxlen):
|
|
c = int(qs[i])
|
|
if c not in self._chars:
|
|
return asc
|
|
asc += chr(self._chars[c])
|
|
return asc
|
|
|
|
def _dtmf2ascii(self, dtmf):
|
|
asci = ""
|
|
for i in range(5):
|
|
c = dtmf[i]
|
|
if c - 1 > len(DTMF_CHARS):
|
|
return asci
|
|
asci += DTMF_CHARS[c - 1]
|
|
return asci
|
|
|
|
def _ascii2dtmf(self, asci):
|
|
dtmf = []
|
|
for x in asci.ljust(5, "?"):
|
|
try:
|
|
dtmf.append(DTMF_CHARS.index(x) + 1)
|
|
except ValueError:
|
|
dtmf.append(0xff)
|
|
return dtmf
|
|
|
|
def get_settings(self):
|
|
_set = self._memobj.settings
|
|
_dtmf = self._memobj.dtmf
|
|
grp = RadioSettingGroup("uvr50", "UV-R50")
|
|
grp.append(RadioSetting("vfomr", "Operation mode", RadioSettingValueList(VFOMR_MODES, VFOMR_MODES[_set.vfomr])))
|
|
grp.append(RadioSetting("tot", "Time-out timer", RadioSettingValueList(TOT_TIMES, TOT_TIMES[_set.tot])))
|
|
grp.append(RadioSetting("squelch", "Squelch level", RadioSettingValueInteger(0, 9, _set.squelch)))
|
|
grp.append(RadioSetting("vox", "VOX", RadioSettingValueInteger(0, 9, _set.vox)))
|
|
grp.append(RadioSetting("lang", "Language", RadioSettingValueList(LANGUAGES, LANGUAGES[_set.lang])))
|
|
grp.append(RadioSetting("scanresmode", "Scan Resume Mode", RadioSettingValueList(SCANRES_MODES, SCANRES_MODES[_set.scanresmode])))
|
|
grp.append(RadioSetting("roger", "Roger sound", RadioSettingValueBoolean(_set.roger)))
|
|
grp.append(RadioSetting("stbycolor", "Standby back-light color", RadioSettingValueList(COLORS, COLORS[_set.stbycolor])))
|
|
grp.append(RadioSetting("rxcolor", "Receiving back-light color", RadioSettingValueList(COLORS, COLORS[_set.rxcolor])))
|
|
grp.append(RadioSetting("txcolor", "Transmitting back-light color", RadioSettingValueList(COLORS, COLORS[_set.txcolor])))
|
|
grp.append(RadioSetting("step", "Step", RadioSettingValueList([str(x) for x in STEPS], str(STEPS[_set.step]))))
|
|
grp.append(RadioSetting("powersave", "Power saving", RadioSettingValueInteger(0, 4, _set.powersave)))
|
|
grp.append(RadioSetting("abr", "Auto backlight duration (s)", RadioSettingValueInteger(0, 5, _set.abr)))
|
|
grp.append(RadioSetting("dualwatch", "Dual watch", RadioSettingValueBoolean(_set.dualwatch)))
|
|
grp.append(RadioSetting("tdrab", "Transmit row (TDR AB)", RadioSettingValueList(TDRAB_MODES, TDRAB_MODES[_set.tdrab])))
|
|
grp.append(RadioSetting("beep", "Key press beep", RadioSettingValueBoolean(_set.beep)))
|
|
|
|
def aniid_apply(setting, obj, encode):
|
|
value = str(setting.value)
|
|
obj.aniid = encode(value)
|
|
rs = RadioSetting("aniid", "ANI ID", RadioSettingValueString(1, 5, self._quansheng2ascii(_set.aniid, 5), charset="0123456789ABCDEF "))
|
|
rs.set_apply_callback(aniid_apply, _set, lambda x: self._ascii2quansheng(x, 5))
|
|
grp.append(rs)
|
|
|
|
grp.append(RadioSetting("dtmfst", "DTMFST", RadioSettingValueList(DTMFST_MODES, DTMFST_MODES[_set.dtmfst])))
|
|
grp.append(RadioSetting("pttid", "Send PTT ID", RadioSettingValueList(PTTID_MODES, PTTID_MODES[_set.pttid])))
|
|
grp.append(RadioSetting("pttlt", "PTT ID prolong time (ms)", RadioSettingValueInteger(0, 30, _set.pttlt)))
|
|
grp.append(RadioSetting("mdfa", "Display mode channel A", RadioSettingValueList(DISPLAY_MODES, DISPLAY_MODES[_set.mdfa])))
|
|
grp.append(RadioSetting("mdfb", "Display mode channel B", RadioSettingValueList(DISPLAY_MODES, DISPLAY_MODES[_set.mdfb])))
|
|
grp.append(RadioSetting("autolk", "Auto-lock UI", RadioSettingValueBoolean(_set.autolk)))
|
|
grp.append(RadioSetting("locked", "Locked UI", RadioSettingValueBoolean(_set.locked)))
|
|
grp.append(RadioSetting("alarm", "Alarm mode", RadioSettingValueList(ALARM_MODES, ALARM_MODES[_set.alarm])))
|
|
grp.append(RadioSetting("ste", "Tail tone elimination", RadioSettingValueBoolean(_set.ste)))
|
|
grp.append(RadioSetting("rpste", "Repeater tail tone elimination (ms)", RadioSettingValueInteger(0, 10, _set.rpste)))
|
|
grp.append(RadioSetting("rptrl", "Repeater tail tone elimination time (ms)", RadioSettingValueInteger(0, 10, _set.rptrl)))
|
|
grp.append(RadioSetting("ponmsg", "Display logo at startup", RadioSettingValueBoolean(_set.ponmsg)))
|
|
|
|
dtmf = RadioSettingGroup("dtmf", "DTMF")
|
|
|
|
def dtmf_apply(setting, obj, encode):
|
|
value = str(setting.value)
|
|
obj.dtmf = encode(value)
|
|
|
|
for i in range(0, 15):
|
|
vs = RadioSettingValueString(0, 5,
|
|
self._dtmf2ascii(_dtmf[i].dtmf),
|
|
False)
|
|
vs.set_charset(DTMF_CHARS)
|
|
rs = RadioSetting("dtmf/%d" % i, "DTMF %d" % (i + 1), vs)
|
|
rs.set_apply_callback(dtmf_apply, self._memobj.dtmf[i],
|
|
self._ascii2dtmf)
|
|
dtmf.append(rs)
|
|
|
|
g = RadioSettings(grp, dtmf)
|
|
return g
|
|
|
|
def set_settings(self, settings):
|
|
"""Automatically apply the settings recursively."""
|
|
_settings = self._memobj.settings
|
|
for element in settings:
|
|
if not isinstance(element, RadioSetting):
|
|
self.set_settings(element)
|
|
continue
|
|
else:
|
|
name = element.get_name()
|
|
if "." in name:
|
|
bits = name.split(".")
|
|
obj = self._memobj
|
|
for bit in bits[:-1]:
|
|
if "/" in bit:
|
|
bit, index = bit.split("/", 1)
|
|
index = int(index)
|
|
obj = getattr(obj, bit)[index]
|
|
else:
|
|
obj = getattr(obj, bit)
|
|
setting = bits[-1]
|
|
else:
|
|
obj = _settings
|
|
setting = element.get_name()
|
|
|
|
if element.has_apply_callback():
|
|
element.run_apply_callback()
|
|
elif element.value.get_mutable():
|
|
setattr(obj, setting, element.value)
|
|
|
|
def get_features(self):
|
|
rf = chirp_common.RadioFeatures()
|
|
rf.has_bank = False
|
|
rf.has_dtcs = True
|
|
rf.has_ctone = True
|
|
rf.has_rx_dtcs = True
|
|
rf.has_offset = True
|
|
rf.has_name = True
|
|
rf.has_cross = True
|
|
rf.has_settings = True
|
|
rf.has_tuning_step = False
|
|
rf.can_odd_split = True
|
|
rf.can_delete = True
|
|
|
|
rf.memory_bounds = (0, NUM_CHANNELS - 1)
|
|
|
|
rf.valid_skips = [""] # UV-R50 has no support for scan skips
|
|
rf.valid_bands = [(136000000, 174000000),
|
|
(400000000, 520000000),
|
|
]
|
|
rf.valid_duplexes = ["", "-", "+", "off", "split"]
|
|
rf.valid_characters = "".join([chr(x) for x in self._chars.values()])
|
|
rf.valid_name_length = 7
|
|
rf.valid_modes = MODES
|
|
rf.valid_tmodes = ["", "Tone", "TSQL", "DTCS", "Cross"]
|
|
rf.valid_cross_modes = ["Tone->Tone", "Tone->DTCS",
|
|
"DTCS->Tone", "DTCS->DTCS", "DTCS->",
|
|
"->Tone", "->DTCS"]
|
|
rf.valid_power_levels = POWER_LEVELS
|
|
rf.valid_tuning_steps = STEPS
|
|
rf.valid_special_chans = SPECIALS.keys()
|
|
return rf
|
|
|
|
def process_mmap(self):
|
|
self._memobj = bitwise.parse(MEM_FORMAT, self._mmap)
|
|
|
|
def sync_in(self):
|
|
self._mmap = do_download(self)
|
|
self.process_mmap()
|
|
|
|
def sync_out(self):
|
|
do_upload(self)
|
|
|
|
def get_raw_memory(self, number):
|
|
return repr(self._memobj.memory[number])
|
|
|
|
def get_memory(self, number):
|
|
mem = chirp_common.Memory()
|
|
|
|
if number in SPECIALS:
|
|
name = number
|
|
_mem = self._memobj.__getattr__(SPECIALS[number][0])
|
|
mem.extd_number = number
|
|
number = SPECIALS[number][1]
|
|
else:
|
|
_nam = self._memobj.names[number]
|
|
name = self._quansheng2ascii(_nam.name, 8)
|
|
_mem = self._memobj.memory[number]
|
|
|
|
mem.number = number
|
|
|
|
if _mem.rxfreq.get_raw() in ["\xff\xff\xff\xff", "\xa5\xa5\xa5\xa5"]:
|
|
mem.empty = True
|
|
return mem
|
|
|
|
mem.name = name
|
|
mem.power = POWER_LEVELS[_mem.power]
|
|
mem.mode = MODES[_mem.width]
|
|
mem.freq = int(_mem.rxfreq) * 10
|
|
offset = (int(_mem.txfreq) - int(_mem.rxfreq)) * 10
|
|
|
|
if offset == 0:
|
|
mem.duplex = "off"
|
|
mem.offset = 0
|
|
elif offset > 120000000: # 120MHz
|
|
mem.duplex = "split"
|
|
mem.offset = _mem.txfreq * 10
|
|
elif offset < 0:
|
|
mem.duplex = "-"
|
|
mem.offset = abs(offset)
|
|
else:
|
|
mem.duplex = "+"
|
|
mem.offset = offset
|
|
|
|
class ToneWord(object):
|
|
def __init__(self, word):
|
|
"""Decodes the tx or rx "tone" word of a channel or freq.
|
|
|
|
The encoding scheme varies depend on what is encoded:
|
|
|
|
- The most significant nibble encodes what kind of
|
|
tone/code squelch is used (CTCSS or DTCS);
|
|
|
|
- For CTCSS, the last 3 nibbles encode the tone as a
|
|
straight frequency;
|
|
|
|
- For DTCS, the last 2 nibbles (lower byte) encode the
|
|
DTCS code, and the polarity is encoded in the most
|
|
significant bit of the word.
|
|
|
|
If this channel is not set to tx/rx anything, the high
|
|
byte is 0xff.
|
|
"""
|
|
self.is_set = (word & 0xff00 != 0xff00) and word != 0x0000
|
|
self.is_dtcs = word & 0x2000 and self.is_set
|
|
if self.is_dtcs:
|
|
self.dtcs_pol = "R" if word & 0x8000 else "N"
|
|
self.dtcs_index = (word & 0x01ff)
|
|
else:
|
|
self.dtcs_pol = "N"
|
|
self.dtcs_index = None
|
|
self.is_ctcss = not self.is_dtcs and self.is_set
|
|
self.tone = (word & 0x0fff) if self.is_ctcss else None
|
|
if self.is_ctcss:
|
|
self.mode = "Tone"
|
|
elif self.is_dtcs:
|
|
self.mode = "DTCS"
|
|
else:
|
|
self.mode = ""
|
|
|
|
def equals(self, o):
|
|
if self.is_set != o.is_set:
|
|
return False
|
|
if self.mode != o.mode:
|
|
return False
|
|
if self.mode == "Tone" and self.tone != o.tone:
|
|
return False
|
|
# For DTCS, we consider different polarities as
|
|
# "equal", i.e. that's not a "Cross" mode.
|
|
if self.mode == "DTCS" and self.dtcs_index != o.dtcs_index:
|
|
return False
|
|
return True
|
|
|
|
rx = ToneWord(_mem.rxtone)
|
|
tx = ToneWord(_mem.txtone)
|
|
|
|
# The logic here gets a bit complicated, because this radio
|
|
# lets you do any kind of crossing and just stores "what do I
|
|
# need to send" and "what do I expect to receive" for each
|
|
# channel. Chirp likes symmetry more, e.g. TSQL is
|
|
# "Tone->Tone" when the tones are equal. The wiki page at
|
|
# https://chirp.danplanet.com/projects/chirp/wiki/DevelopersToneModes
|
|
# has an overview of Chirp's tone modes.
|
|
# The reverse logic in set_memory is maybe easier to follow.
|
|
if tx.equals(rx):
|
|
if tx.is_ctcss:
|
|
mem.rtone = float(int(tx.tone)) / 10.0
|
|
mem.ctone = float(int(tx.tone)) / 10.0
|
|
mem.tmode = "TSQL"
|
|
elif tx.is_dtcs:
|
|
mem.dtcs = chirp_common.ALL_DTCS_CODES[tx.dtcs_index]
|
|
mem.rx_dtcs = chirp_common.ALL_DTCS_CODES[tx.dtcs_index]
|
|
mem.tmode = "DTCS"
|
|
else:
|
|
mem.tmode = ""
|
|
elif tx.is_ctcss and not rx.is_set:
|
|
mem.tmode = "Tone"
|
|
mem.rtone = float(int(tx.tone)) / 10.0
|
|
else:
|
|
mem.tmode = "Cross"
|
|
mem.cross_mode = "%s->%s" % (tx.mode, rx.mode)
|
|
if rx.is_ctcss:
|
|
mem.ctone = float(int(rx.tone)) / 10.0
|
|
elif rx.is_dtcs:
|
|
mem.rx_dtcs = chirp_common.ALL_DTCS_CODES[rx.dtcs_index]
|
|
if tx.is_ctcss:
|
|
mem.rtone = float(int(tx.tone)) / 10.0
|
|
elif tx.is_dtcs:
|
|
mem.dtcs = chirp_common.ALL_DTCS_CODES[tx.dtcs_index]
|
|
|
|
mem.dtcs_polarity = "%s%s" % (tx.dtcs_pol, rx.dtcs_pol)
|
|
|
|
mem.extra = RadioSettingGroup("Extra", "extra")
|
|
mem.extra.append(RadioSetting("busylock", "Busy lock",
|
|
RadioSettingValueBoolean(_mem.busylock)))
|
|
mem.extra.append(RadioSetting("scanadd", "Scan add",
|
|
RadioSettingValueBoolean(_mem.scanadd)))
|
|
|
|
if mem.freq == 0:
|
|
mem.empty = True
|
|
|
|
return mem
|
|
|
|
def set_memory(self, mem):
|
|
# Get a low-level memory object mapped to the image
|
|
if mem.number < 0:
|
|
_mem = self._memobj.__getattr__(SPECIALS[mem.extd_number][0])
|
|
else:
|
|
_mem = self._memobj.memory[mem.number]
|
|
_nam = self._memobj.names[mem.number]
|
|
_nam.name = self._ascii2quansheng(mem.name, 8)
|
|
|
|
if mem.empty:
|
|
_mem.set_raw(b'\xa5' * 8 + b'\xff' * 8)
|
|
return
|
|
|
|
# Convert to low-level frequency representation
|
|
_mem.rxfreq = mem.freq / 10
|
|
if mem.duplex in [None, "", "off"]:
|
|
_mem.txfreq = _mem.rxfreq
|
|
elif mem.duplex == "+":
|
|
_mem.txfreq = (mem.freq + mem.offset) / 10
|
|
elif mem.duplex == "-":
|
|
_mem.txfreq = (mem.freq - mem.offset) / 10
|
|
else: # "split", aka odd split
|
|
_mem.txfreq = mem.offset / 10
|
|
|
|
_mem.power = (mem.power != POWER_LEVELS[0])
|
|
_mem.width = (mem.mode == "FM")
|
|
|
|
def encodetone(mode, tone, dtcs, polarity):
|
|
"""This is the reverse of decodetone in get_memory."""
|
|
if mode == "":
|
|
return 0xffff
|
|
elif mode == "Tone":
|
|
return 0x0fff & int(tone * 10)
|
|
elif mode == "DTCS":
|
|
return (
|
|
(0x8000 if polarity == "R" else 0x0000) |
|
|
(0x2000) |
|
|
(0x0fff & (chirp_common.ALL_DTCS_CODES.index(dtcs)))
|
|
)
|
|
|
|
if mem.tmode == "Cross":
|
|
txmode, rxmode = mem.cross_mode.split("->")
|
|
_mem.txtone = encodetone(txmode, mem.rtone,
|
|
mem.dtcs, mem.dtcs_polarity[0])
|
|
_mem.rxtone = encodetone(rxmode, mem.ctone,
|
|
mem.rx_dtcs, mem.dtcs_polarity[1])
|
|
elif mem.tmode == "Tone":
|
|
_mem.txtone = encodetone("Tone", mem.rtone,
|
|
mem.dtcs, mem.dtcs_polarity[0])
|
|
_mem.rxtone = 0xffff
|
|
elif mem.tmode == "TSQL":
|
|
_mem.txtone = encodetone("Tone", mem.ctone,
|
|
mem.dtcs, mem.dtcs_polarity[0])
|
|
_mem.rxtone = encodetone("Tone", mem.ctone,
|
|
mem.dtcs, mem.dtcs_polarity[1])
|
|
elif mem.tmode == "DTCS":
|
|
_mem.txtone = encodetone("DTCS", mem.rtone,
|
|
mem.dtcs, mem.dtcs_polarity[0])
|
|
_mem.rxtone = encodetone("DTCS", mem.ctone,
|
|
mem.dtcs, mem.dtcs_polarity[1])
|
|
else:
|
|
_mem.txtone = 0xffff
|
|
_mem.rxtone = 0xffff
|
|
|
|
# TODO: we may want to work around issue 4121: settings is
|
|
# empty when editing in the "table" interface. See UV5R driver
|
|
# for a working approach.
|
|
for setting in mem.extra:
|
|
setattr(_mem, setting.get_name(), setting.value)
|
|
|
|
|