[chirp_devel] Luiton LT725UV Update
Rick DeWitt
Sun Mar 18 12:29:27 PDT 2018
I suppose you expected an attachment, eh?
Rick DeWitt
AA0RD
Sequim, Washington, USA
360-681-3494
On 3/15/2018 3:37 PM, Jim Unroe wrote:
> Rick,
>
>> I have scrubbed the style and made the exp prompt change. Tox won't load on
>> my Win7 so I manually fixed all the style issues I could find.
> It doesn't check on my Windows PC like it used to. I can't get tox to
> work on my Linux PC either. :-(
>
>
> But I did visually scan through the driver and I see things that I
> don't think would pass.
>
> There are many lines that exceed 79 characters per line. There are
> some evaluations that have no white space and others that have too
> much white space on one side or the other and sometimes both.
>
> Now concerning the driver.
>
> The driver downloads from and uploads to my LT-725UV OK. I programmed
> my local 146.640- repeater into the top (A) VFO and the frequency
> displayed is 146.63974 MHz. I remember having this issue when I added
> the VFO frequency settings to the UV-5R driver. I believe I was told
> is has something to do with the error introduced when converting
> between binary and decimal numbers. You can look at the uv5r.py driver
> to see what I had to do to resolve this issue.
>
> Jim
-------------- next part --------------
# Copyright 2016:
# * Jim Unroe KC9HI, <rock.unroe at gmail.com>
# Modified for Baojie BJ-218: 2018 by Rick DeWitt (RJD), <aa0rd at yahoo.com>#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import time
import struct
import logging
import re
LOG = logging.getLogger(__name__)
from chirp import chirp_common, directory, memmap
from chirp import bitwise, errors, util
from chirp.settings import RadioSettingGroup, RadioSetting, \
RadioSettingValueBoolean, RadioSettingValueList, \
RadioSettingValueString, RadioSettingValueInteger, \
RadioSettingValueFloat, RadioSettings,InvalidValueError
from textwrap import dedent
MEM_FORMAT = """
#seekto 0x0200;
struct {
u8 init_bank;
u8 volume;
u16 fm_freq;
u8 wtled;
u8 rxled;
u8 txled;
u8 ledsw;
u8 beep;
u8 ring;
u8 bcl;
u8 tot;
u16 sig_freq;
u16 dtmf_txms;
u8 init_sql;
u8 rptr_mode;
} settings;
#seekto 0x0240;
struct {
u8 dtmf1_cnt;
u8 dtmf1[7];
u8 dtmf2_cnt;
u8 dtmf2[7];
u8 dtmf3_cnt;
u8 dtmf3[7];
u8 dtmf4_cnt;
u8 dtmf4[7];
u8 dtmf5_cnt;
u8 dtmf5[7];
u8 dtmf6_cnt;
u8 dtmf6[7];
u8 dtmf7_cnt;
u8 dtmf7[7];
u8 dtmf8_cnt;
u8 dtmf8[7];
} dtmf_tab;
#seekto 0x0280;
struct {
u8 native_id_cnt;
u8 native_id_code[7];
u8 master_id_cnt;
u8 master_id_code[7];
u8 alarm_cnt;
u8 alarm_code[5];
u8 id_disp_cnt;
u8 id_disp_code[5];
u8 revive_cnt;
u8 revive_code[5];
u8 stun_cnt;
u8 stun_code[5];
u8 kill_cnt;
u8 kill_code[5];
u8 monitor_cnt;
u8 monitor_code[5];
u8 state_now;
} codes;
#seekto 0x02d0;
struct {
u8 hello1_cnt;
char hello1[7];
u8 hello2_cnt;
char hello2[7];
u32 vhf_low;
u32 vhf_high;
u32 uhf_low;
u32 uhf_high;
u8 lims_on;
} hello_lims;
struct vfo {
u8 frq_chn_mode;
u8 chan_num;
u32 rxfreq;
u16 is_rxdigtone:1,
rxdtcs_pol:1,
rx_tone:14;
u8 rx_mode;
u8 unknown_ff;
u16 is_txdigtone:1,
txdtcs_pol:1,
tx_tone:14;
u8 launch_sig;
u8 tx_end_sig;
u8 bpower;
u8 fm_bw;
u8 cmp_nder;
u8 scrm_blr;
u8 shift;
u32 offset;
u16 step;
u8 sql;
};
#seekto 0x0300;
struct {
struct vfo vfoa;
} upper;
#seekto 0x0380;
struct {
struct vfo vfob;
} lower;
struct mem {
u32 rxfreq;
u16 is_rxdigtone:1,
rxdtcs_pol:1,
rxtone:14;
u8 recvmode;
u32 txfreq;
u16 is_txdigtone:1,
txdtcs_pol:1,
txtone:14;
u8 botsignal;
u8 eotsignal;
u8 power:1,
wide:1,
compandor:1
scrambler:1
unknown:4;
u8 namelen;
u8 name[7];
};
#seekto 0x0400;
struct mem upper_memory[128];
#seekto 0x1000;
struct mem lower_memory[128];
#seekto 0x1C00;
struct {
char mod_num[6];
} mod_id;
"""
MEM_SIZE = 0x1C00
BLOCK_SIZE = 0x40
STIMEOUT = 2
# Channel power: 2 levels
POWER_LEVELS = [chirp_common.PowerLevel("Low", watts=5.00),
chirp_common.PowerLevel("High", watts=30.00)]
LIST_RECVMODE = ["QT/DQT", "QT/DQT + Signaling"]
LIST_SIGNAL = ["Off"] + ["DTMF%s" % x for x in range(1, 9)] + \
["DTMF%s + Identity" % x for x in range(1, 9)] + \
["Identity code"]
# Band Power settings, can be different than channel power
LIST_BPOWER = ["Low", "Mid", "High"] # Tri-power models
LIST_COLOR = ["Off", "Orange", "Blue", "Purple"]
LIST_LEDSW = ["Auto", "On"]
LIST_RING = ["Off"] + ["%s" % x for x in range(1, 10)]
LIST_TDR_DEF = ["A-Upper", "B-Lower"]
LIST_TIMEOUT = ["Off"] + ["%s" % x for x in range(30, 630, 30)]
LIST_VFOMODE = ["Frequency Mode", "Channel Mode"]
# Tones are numeric, Defined in \chirp\chirp_common.py
TONES_CTCSS = sorted(chirp_common.TONES)
# Converted to strings
LIST_CTCSS = ["Off"] +[str(x) for x in TONES_CTCSS]
# Now append the DxxxN and DxxxI DTCS codes from chirp_common
for x in chirp_common.DTCS_CODES:
LIST_CTCSS.append("D{:03d}N".format(x))
for x in chirp_common.DTCS_CODES:
LIST_CTCSS.append("D{:03d}R".format(x))
LIST_BW= ["Narrow", "Wide"]
LIST_SHIFT= ["Off"," + ", " - "]
STEPS = [2.5, 5.0, 6.25, 10.0, 12.5, 20.0, 25.0, 50.0]
LIST_STEPS = [str(x) for x in STEPS]
LIST_STATE = ["Normal", "Stun", "Kill"]
LIST_SSF = ["1000", "1450", "1750", "2100"]
LIST_DTMFTX= ["50", "100", "150", "200", "300","500"]
SETTING_LISTS = {
"init_bank": LIST_TDR_DEF ,
"tot": LIST_TIMEOUT,
"wtled": LIST_COLOR,
"rxled": LIST_COLOR,
"txled": LIST_COLOR,
"sig_freq": LIST_SSF,
"dtmf_txms": LIST_DTMFTX,
"ledsw": LIST_LEDSW,
"frq_chn_mode": LIST_VFOMODE,
"rx_tone": LIST_CTCSS,
"tx_tone": LIST_CTCSS,
"rx_mode": LIST_RECVMODE,
"launch_sig": LIST_SIGNAL,
"tx_end_sig": LIST_SIGNAL,
"bpower":LIST_BPOWER,
"fm_bw": LIST_BW,
"shift": LIST_SHIFT,
"step": LIST_STEPS,
"ring": LIST_RING,
"state_now": LIST_STATE
}
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))
def _rawrecv(radio, amount):
"""Raw read from the radio device"""
data = ""
try:
data = radio.pipe.read(amount)
except:
_exit_program_mode(radio)
msg = "Generic error reading data from radio; check your cable."
raise errors.RadioError(msg)
if len(data) != amount:
_exit_program_mode(radio)
msg = "Error reading from radio: not the amount of data we want."
raise errors.RadioError(msg)
return data
def _rawsend(radio, data):
"""Raw send to the radio device"""
try:
radio.pipe.write(data)
except:
raise errors.RadioError("Error sending data to radio")
def _make_frame(cmd, addr, length, data=""):
"""Pack the info in the headder format"""
frame = struct.pack(">4sHH", cmd, addr, length)
# Add the data if set
if len(data) != 0:
frame += data
# Return the data
return frame
def _recv(radio, addr, length):
"""Get data from the radio """
data = _rawrecv(radio, length)
# DEBUG
LOG.info("Response:")
LOG.debug(util.hexprint(data))
return data
def _do_ident(radio):
"""Put the radio in PROGRAM mode & identify it"""
# Set the serial discipline
radio.pipe.baudrate = 19200
radio.pipe.parity = "N"
radio.pipe.timeout = STIMEOUT
# Flush input buffer
_clean_buffer(radio)
magic = "PROM_LIN"
_rawsend(radio, magic)
ack = _rawrecv(radio, 1)
if ack != "\x06":
_exit_program_mode(radio)
if ack:
LOG.debug(repr(ack))
raise errors.RadioError("Radio did not respond")
return True
def _exit_program_mode(radio):
endframe = "EXIT"
_rawsend(radio, endframe)
def _download(radio):
"""Get the memory map"""
# Put radio in program mode and identify it
_do_ident(radio)
# UI progress
status = chirp_common.Status()
status.cur = 0
status.max = MEM_SIZE / BLOCK_SIZE
status.msg = "Cloning from radio..."
radio.status_fn(status)
data = ""
for addr in range(0, MEM_SIZE, BLOCK_SIZE):
frame = _make_frame("READ", addr, BLOCK_SIZE)
# DEBUG
LOG.info("Request sent:")
LOG.debug(util.hexprint(frame))
# Sending the read request
_rawsend(radio, frame)
# Now we read
d = _recv(radio, addr, BLOCK_SIZE)
# Aggregate the data
data += d
# UI Update
status.cur = addr / BLOCK_SIZE
status.msg = "Cloning from radio..."
radio.status_fn(status)
_exit_program_mode(radio)
data += radio.MODEL.ljust(8)
return data
def _upload(radio):
"""Upload procedure"""
# Put radio in program mode and identify it
_do_ident(radio)
# UI progress
status = chirp_common.Status()
status.cur = 0
status.max = MEM_SIZE / BLOCK_SIZE
status.msg = "Cloning to radio..."
radio.status_fn(status)
# The fun starts here
for addr in range(0, MEM_SIZE, BLOCK_SIZE):
# Sending the data
data = radio.get_mmap()[addr:addr + BLOCK_SIZE]
frame = _make_frame("WRIE", addr, BLOCK_SIZE, data)
_rawsend(radio, frame)
# Receiving the response
ack = _rawrecv(radio, 1)
if ack != "\x06":
_exit_program_mode(radio)
msg = "Bad ack writing block 0x%04x" % addr
raise errors.RadioError(msg)
# UI Update
status.cur = addr / BLOCK_SIZE
status.msg = "Cloning to radio..."
radio.status_fn(status)
_exit_program_mode(radio)
def model_match(cls, data):
"""Match the opened/downloaded image to the correct version"""
if len(data) == 0x1C08:
rid = data[0x1C00:0x1C08]
return rid.startswith(cls.MODEL)
else:
return False
def _split(rf, f1, f2):
"""Returns False if the two freqs are in the same band (no split)
or True otherwise"""
# Determine if the two freqs are in the same band
for low, high in rf.valid_bands:
if f1 >= low and f1 <= high and \
f2 >= low and f2 <= high:
# If the two freqs are on the same Band this is not a split
return False
# If you get here is because the freq pairs are split
return True
@directory.register
class LT725UV(chirp_common.CloneModeRadio,
chirp_common.ExperimentalRadio):
"""LUITON LT-725UV Radio"""
VENDOR = "LUITON"
MODEL = "LT-725UV"
MODES = ["NFM", "FM"]
TONES = chirp_common.TONES
DTCS_CODES = sorted(chirp_common.DTCS_CODES + [645])
NAME_LENGTH = 7
DTMF_CHARS = list("0123456789ABCD*#")
VALID_BANDS = [(136000000, 176000000),
(400000000, 480000000)]
# Valid chars on the LCD
VALID_CHARS = chirp_common.CHARSET_ALPHANUMERIC + \
"`{|}!\"#$%&'()*+,-./:;<=>?@[]^_"
@classmethod
def get_prompts(cls):
rp = chirp_common.RadioPrompts()
rp.experimental = \
('Some notes about POWER settings:\n'
'- The individual channel power settings are ignored'
' by the radio.\n'
' They are allowed to be set (and downloaded) in hopes of'
' a future firmware update.\n'
'- Power settings done \'Live\' in the radio apply to the'
' entire upper or lower band.\n'
'- Tri-power radio models will set and download the three'
' band-power'
' levels, but they are\n converted to just Low and High at'
' upload.'
' The Mid setting reverts to Low.'
)
rp.pre_download = _(dedent("""\
Follow this 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 get_features(self):
rf = chirp_common.RadioFeatures()
rf.has_settings = True
rf.has_bank = False
rf.has_tuning_step = False
rf.can_odd_split = True
rf.has_name = True
rf.has_offset = True
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.has_sub_devices = self.VARIANT == ""
rf.valid_modes = self.MODES
rf.valid_characters = self.VALID_CHARS
rf.valid_duplexes = ["", "-", "+", "split", "off"]
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 = []
rf.valid_power_levels = POWER_LEVELS
rf.valid_name_length = self.NAME_LENGTH
rf.valid_dtcs_codes = self.DTCS_CODES
rf.valid_bands = self.VALID_BANDS
rf.memory_bounds = (1, 128)
return rf
def get_sub_devices(self):
return [LT725UVUpper(self._mmap), LT725UVLower(self._mmap)]
def sync_in(self):
"""Download from radio"""
try:
data = _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 = memmap.MemoryMap(data)
self.process_mmap()
def sync_out(self):
"""Upload to radio"""
try:
_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 process_mmap(self):
"""Process the mem map into the mem object"""
self._memobj = bitwise.parse(MEM_FORMAT, self._mmap)
def get_raw_memory(self, number):
return repr(self._memobj.memory[number - 1])
def _memory_obj(self, suffix=""):
return getattr(self._memobj, "%s_memory%s" % (self._vfo, suffix))
def _get_dcs(self, val):
return int(str(val)[2:-18])
def _set_dcs(self, val):
return int(str(val), 16)
def get_memory(self, number):
_mem = self._memory_obj()[number - 1]
mem = chirp_common.Memory()
mem.number = number
if _mem.get_raw()[0] == "\xff":
mem.empty = True
return mem
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 _split(self.get_features(), mem.freq, int(_mem.txfreq) * 10):
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 _mem.name[:_mem.namelen]:
mem.name += chr(char)
dtcs_pol = ["N", "N"]
if _mem.rxtone == 0x3FFF:
rxmode = ""
elif _mem.is_rxdigtone == 0:
# CTCSS
rxmode = "Tone"
mem.ctone = int(_mem.rxtone) / 10.0
else:
# Digital
rxmode = "DTCS"
mem.rx_dtcs = self._get_dcs(_mem.rxtone)
if _mem.rxdtcs_pol == 1:
dtcs_pol[1] = "R"
if _mem.txtone == 0x3FFF:
txmode = ""
elif _mem.is_txdigtone == 0:
# CTCSS
txmode = "Tone"
mem.rtone = int(_mem.txtone) / 10.0
else:
# Digital
txmode = "DTCS"
mem.dtcs = self._get_dcs(_mem.txtone)
if _mem.txdtcs_pol == 1:
dtcs_pol[0] = "R"
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)
mem.mode = _mem.wide and "FM" or "NFM"
mem.power = POWER_LEVELS[_mem.power]
# Extra
mem.extra = RadioSettingGroup("extra", "Extra")
if _mem.recvmode == 0xFF:
val = 0x00
else:
val = _mem.recvmode
recvmode = RadioSetting("recvmode", "Receiving mode",
RadioSettingValueList(LIST_RECVMODE,
LIST_RECVMODE[val]))
mem.extra.append(recvmode)
if _mem.botsignal == 0xFF:
val = 0x00
else:
val = _mem.botsignal
botsignal = RadioSetting("botsignal", "Launch signaling",
RadioSettingValueList(LIST_SIGNAL,
LIST_SIGNAL[val]))
mem.extra.append(botsignal)
if _mem.eotsignal == 0xFF:
val = 0x00
else:
val = _mem.eotsignal
rx = RadioSettingValueList(LIST_SIGNAL, LIST_SIGNAL[val])
eotsignal = RadioSetting("eotsignal", "Transmit end signaling", rx)
mem.extra.append(eotsignal)
rx = RadioSettingValueBoolean(bool(_mem.compandor))
compandor = RadioSetting("compandor", "Compandor", rx)
mem.extra.append(compandor)
rx = RadioSettingValueBoolean(bool(_mem.scrambler))
scrambler = RadioSetting("scrambler", "Scrambler", rx)
mem.extra.append(scrambler)
return mem
def set_memory(self, mem):
_mem = self._memory_obj()[mem.number - 1]
if mem.empty:
_mem.set_raw("\xff" * 24)
_mem.namelen = 0
return
_mem.set_raw("\xFF" * 15 + "\x00\x00" + "\xFF" * 7)
_mem.rxfreq = mem.freq / 10
if mem.duplex == "off":
_mem.txfreq = 0xFFFFFFFF
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.namelen = len(mem.name)
_namelength = self.get_features().valid_name_length
for i in range(_namelength):
try:
_mem.name[i] = ord(mem.name[i])
except IndexError:
_mem.name[i] = 0xFF
rxmode = ""
txmode = ""
if mem.tmode == "Tone":
txmode = "Tone"
elif mem.tmode == "TSQL":
rxmode = "Tone"
txmode = "TSQL"
elif mem.tmode == "DTCS":
rxmode = "DTCSSQL"
txmode = "DTCS"
elif mem.tmode == "Cross":
txmode, rxmode = mem.cross_mode.split("->", 1)
if rxmode == "":
_mem.rxdtcs_pol = 1
_mem.is_rxdigtone = 1
_mem.rxtone = 0x3FFF
elif rxmode == "Tone":
_mem.rxdtcs_pol = 0
_mem.is_rxdigtone = 0
_mem.rxtone = int(mem.ctone * 10)
elif rxmode == "DTCSSQL":
_mem.rxdtcs_pol = 1 if mem.dtcs_polarity[1] == "R" else 0
_mem.is_rxdigtone = 1
_mem.rxtone = self._set_dcs(mem.dtcs)
elif rxmode == "DTCS":
_mem.rxdtcs_pol = 1 if mem.dtcs_polarity[1] == "R" else 0
_mem.is_rxdigtone = 1
_mem.rxtone = self._set_dcs(mem.rx_dtcs)
if txmode == "":
_mem.txdtcs_pol = 1
_mem.is_txdigtone = 1
_mem.txtone = 0x3FFF
elif txmode == "Tone":
_mem.txdtcs_pol = 0
_mem.is_txdigtone = 0
_mem.txtone = int(mem.rtone * 10)
elif txmode == "TSQL":
_mem.txdtcs_pol = 0
_mem.is_txdigtone = 0
_mem.txtone = int(mem.ctone * 10)
elif txmode == "DTCS":
_mem.txdtcs_pol = 1 if mem.dtcs_polarity[0] == "R" else 0
_mem.is_txdigtone = 1
_mem.txtone = self._set_dcs(mem.dtcs)
_mem.wide = self.MODES.index(mem.mode)
_mem.power = mem.power == POWER_LEVELS[1]
# Extra settings
for setting in mem.extra:
setattr(_mem, setting.get_name(), setting.value)
def get_settings(self):
"""Translate the bit in the mem_struct into settings in the UI"""
# Define mem struct write-back shortcuts
_sets = self._memobj.settings
_vfoa = self._memobj.upper.vfoa
_vfob = self._memobj.lower.vfob
_lims = self._memobj.hello_lims
_codes = self._memobj.codes
_dtmf = self._memobj.dtmf_tab
basic = RadioSettingGroup("basic", "Basic Settings")
a_band = RadioSettingGroup("a_band", "VFO A-Upper Settings")
b_band = RadioSettingGroup("b_band", "VFO B-Lower Settings")
codes = RadioSettingGroup("codes", "Codes & DTMF Groups")
lims = RadioSettingGroup("lims", "PowerOn & Freq Limits")
group = RadioSettings(basic, a_band, b_band, lims, codes)
# Basic Settings
bnd_mode = RadioSetting("settings.init_bank", "TDR Band Default",
RadioSettingValueList(LIST_TDR_DEF,
LIST_TDR_DEF[ _sets.init_bank]))
basic.append(bnd_mode)
volume = RadioSetting("settings.volume", "Volume",
RadioSettingValueInteger(0, 20, _sets.volume))
basic.append(volume)
val = _vfoa.bpower # 2bits values 0,1,2= Low, Mid, High
rx = RadioSettingValueList(LIST_BPOWER, LIST_BPOWER[val])
powera = RadioSetting("upper.vfoa.bpower", "Power (Upper)", rx)
basic.append(powera)
val = _vfob.bpower
rx = RadioSettingValueList(LIST_BPOWER, LIST_BPOWER[val])
powerb = RadioSetting("lower.vfob.bpower", "Power (Lower)", rx)
basic.append(powerb)
def my_word2raw(setting, obj, atrb, mlt=10):
"""Callback function to convert UI floating value to u16 int"""
if str( setting.value) == "Off":
frq = 0x0FFFF
else:
frq=int(float(str(setting.value)) * float(mlt))
if frq == 0:
frq = 0xFFFF
setattr(obj, atrb, frq)
return
def my_adjraw(setting, obj, atrb, fix):
"""Callback: add or subtract fix from value."""
vx = int(str(setting.value))
value = vx + int(fix)
if value < 0:
value = 0
if atrb == "frq_chn_mode" and int(str(setting.value)) == 2:
value = vx * 2 # Special handling for frq_chn_mode
setattr(obj, atrb, value)
return
def my_dbl2raw(setting, obj, atrb, flg=1):
"""Callback: convert from freq 146.7600 to 14760000 U32."""
value = chirp_common.parse_freq(str(setting.value)) / 10
# flg=1 means 0 becomes ff, else leave as possible 0
if flg == 1 and value == 0:
value = 0xFFFFFFFF
setattr(obj, atrb, value)
return
def my_val_list(setting, obj, atrb):
"""Callback:from ValueList with non-sequential, actual values."""
value = int(str(setting.value)) # Get the integer value
if atrb == "tot":
value = int(value / 30) # 30 second increments
setattr(obj, atrb, value)
return
def my_spcl(setting, obj, atrb):
"""Callback: Special handling based on atrb."""
if atrb == "frq_chn_mode":
idx = LIST_VFOMODE.index (str(setting.value)) # Returns 0 or 1
value = idx * 2 # Set bit 1
setattr(obj, atrb, value)
return
def my_tone_strn(obj, is_atr, pol_atr, tone_atr):
"""Generate the CTCS/DCS tone code string."""
vx = int(getattr(obj, tone_atr))
if vx == 16383 or vx == 0:
return "Off" # 16383 is all bits set
if getattr(obj, is_atr) == 0: # Simple CTCSS code
tstr = str(vx / 10.0)
else: # DCS
if getattr(obj, pol_atr) == 0:
tstr = "D{:03x}R".format(vx)
else:
tstr = "D{:03x}N".format(vx)
return tstr
def my_set_tone(setting, obj, is_atr, pol_atr, tone_atr):
"""Callback- create the tone setting from string code."""
sx = str(setting.value) # '131.8' or 'D231N' or 'Off'
if sx == "Off":
isx = 1
polx = 1
tonx = 0x3FFF
elif sx[0] == "D": # DCS
isx = 1
if sx[4] == "N":
polx = 1
else:
polx = 0
tonx = int(sx[1:4], 16)
else: # CTCSS
isx = 0
polx = 0
tonx = int(float(sx) * 10.0)
setattr(obj, is_atr, isx)
setattr(obj, pol_atr, polx)
setattr(obj, tone_atr, tonx)
return
val = _sets.fm_freq / 10.0
if val == 0:
val = 88.9 # 0 is not valid
rx = RadioSettingValueFloat(65, 108.0, val, 0.1, 1)
rs = RadioSetting("settings.fm_freq", "FM Broadcast Freq (MHz)", rx)
rs.set_apply_callback(my_word2raw, _sets, "fm_freq")
basic.append(rs)
wtled = RadioSetting("settings.wtled", "Standby LED Color",
RadioSettingValueList(LIST_COLOR, LIST_COLOR[
_sets.wtled]))
basic.append(wtled)
rxled = RadioSetting("settings.rxled", "RX LED Color",
RadioSettingValueList(LIST_COLOR, LIST_COLOR[
_sets.rxled]))
basic.append(rxled)
txled = RadioSetting("settings.txled", "TX LED Color",
RadioSettingValueList(LIST_COLOR, LIST_COLOR[
_sets.txled]))
basic.append(txled)
ledsw = RadioSetting("settings.ledsw", "Back light mode",
RadioSettingValueList(LIST_LEDSW, LIST_LEDSW[
_sets.ledsw]))
basic.append(ledsw)
beep = RadioSetting("settings.beep", "Beep",
RadioSettingValueBoolean(bool(_sets.beep)))
basic.append(beep)
ring = RadioSetting("settings.ring", "Ring",
RadioSettingValueList(LIST_RING, LIST_RING[
_sets.ring]))
basic.append(ring)
bcl = RadioSetting("settings.bcl", "Busy channel lockout",
RadioSettingValueBoolean(bool(_sets.bcl)))
basic.append(bcl)
if _vfoa.sql == 0xFF:
val = 0x04
else:
val = _vfoa.sql
sqla = RadioSetting("upper.vfoa.sql", "Squelch (Upper)",
RadioSettingValueInteger(0, 9, val))
basic.append(sqla)
if _vfob.sql == 0xFF:
val = 0x04
else:
val = _vfob.sql
sqlb = RadioSetting("lower.vfob.sql", "Squelch (Lower)",
RadioSettingValueInteger(0, 9, val))
basic.append(sqlb)
tmp = str(int(_sets.tot) * 30) # 30 sec step counter
rs = RadioSetting("settings.tot", "Transmit Timeout (Secs)",
RadioSettingValueList(LIST_TIMEOUT, tmp))
rs.set_apply_callback(my_val_list, _sets, "tot")
basic.append(rs)
tmp =str(int( _sets.sig_freq))
rs = RadioSetting("settings.sig_freq", "Single Signaling Tone (Htz)",
RadioSettingValueList(LIST_SSF, tmp))
rs.set_apply_callback(my_val_list, _sets, "sig_freq")
basic.append(rs)
tmp =str(int( _sets.dtmf_txms))
rs = RadioSetting("settings.dtmf_txms", "DTMF Tx Duration (mSecs)",
RadioSettingValueList(LIST_DTMFTX, tmp))
rs.set_apply_callback(my_val_list, _sets, "dtmf_txms")
basic.append(rs)
rs = RadioSetting("settings.rptr_mode", "Repeater Mode",
RadioSettingValueBoolean(bool(_sets.rptr_mode)))
basic.append(rs)
# UPPER BAND SETTINGS
# Freq Mode, convert bit 1 state to index pointer
val = _vfoa.frq_chn_mode / 2
rx = RadioSettingValueList(LIST_VFOMODE, LIST_VFOMODE[val])
rs = RadioSetting("upper.vfoa.frq_chn_mode", "Default Mode", rx)
rs.set_apply_callback(my_spcl, _vfoa, "frq_chn_mode")
a_band.append(rs)
val =_vfoa.chan_num + 1 # Add 1 for 1-128 displayed
rs = RadioSetting("upper.vfoa.chan_num", "Initial Chan",
RadioSettingValueInteger(1, 128, val))
rs.set_apply_callback(my_adjraw, _vfoa, "chan_num", -1)
a_band.append(rs)
val = _vfoa.rxfreq / 100000.0
if (val < 136.0 or val > 176.0):
val = 146.520 # 2m calling
rs = RadioSetting("upper.vfoa.rxfreq ", "Default Recv Freq (MHz)",
RadioSettingValueFloat(136.0, 176.0, val, 0.001, 5))
rs.set_apply_callback(my_dbl2raw, _vfoa, "rxfreq")
a_band.append(rs)
tmp = my_tone_strn(_vfoa, "is_rxdigtone", "rxdtcs_pol", "rx_tone")
rs = RadioSetting("rx_tone", "Default Recv CTCSS (Htz)",
RadioSettingValueList(LIST_CTCSS, tmp))
rs.set_apply_callback(my_set_tone, _vfoa, "is_rxdigtone",
"rxdtcs_pol", "rx_tone")
a_band.append(rs)
rx = RadioSettingValueList(LIST_RECVMODE,
LIST_RECVMODE[_vfoa.rx_mode])
rs = RadioSetting("upper.vfoa.rx_mode", "Default Recv Mode", rx)
a_band.append(rs)
tmp = my_tone_strn(_vfoa, "is_txdigtone", "txdtcs_pol", "tx_tone")
rs = RadioSetting("tx_tone", "Default Xmit CTCSS (Htz)",
RadioSettingValueList(LIST_CTCSS, tmp))
rs.set_apply_callback(my_set_tone, _vfoa, "is_txdigtone",
"txdtcs_pol", "tx_tone")
a_band.append(rs)
rs = RadioSetting("upper.vfoa.launch_sig", "Launch Signaling",
RadioSettingValueList(LIST_SIGNAL,
LIST_SIGNAL[_vfoa.launch_sig]))
a_band.append(rs)
rx = RadioSettingValueList(LIST_SIGNAL,LIST_SIGNAL[_vfoa.tx_end_sig])
rs = RadioSetting("upper.vfoa.tx_end_sig", "Xmit End Signaling", rx)
a_band.append(rs)
rx = RadioSettingValueList(LIST_BW, LIST_BW[_vfoa.fm_bw])
rs = RadioSetting("upper.vfoa.fm_bw", "Wide/Narrow Band", rx)
a_band.append(rs)
rx = RadioSettingValueBoolean(bool(_vfoa.cmp_nder))
rs = RadioSetting("upper.vfoa.cmp_nder", "Compandor", rx)
a_band.append(rs)
rs = RadioSetting("upper.vfoa.scrm_blr", "Scrambler",
RadioSettingValueBoolean(bool(_vfoa.scrm_blr)))
a_band.append(rs)
rx = RadioSettingValueList(LIST_SHIFT, LIST_SHIFT[_vfoa.shift])
rs = RadioSetting("upper.vfoa.shift", "Xmit Shift", rx)
a_band.append(rs)
val = _vfoa.offset / 100000.0
rs = RadioSetting("upper.vfoa.offset", "Xmit Offset (MHz)",
RadioSettingValueFloat(0, 100.0, val, 0.001, 3))
# Allow zero value
rs.set_apply_callback(my_dbl2raw, _vfoa, "offset", 0)
a_band.append(rs)
tmp = str(_vfoa.step / 100.0)
rs = RadioSetting("step", "Freq step (KHz)",
RadioSettingValueList(LIST_STEPS, tmp))
rs.set_apply_callback(my_word2raw, _vfoa,"step", 100)
a_band.append(rs)
# LOWER BAND SETTINGS
val = _vfob.frq_chn_mode / 2
rx = RadioSettingValueList(LIST_VFOMODE, LIST_VFOMODE[val])
rs = RadioSetting("lower.vfob.frq_chn_mode", "Default Mode", rx)
rs.set_apply_callback(my_spcl, _vfob, "frq_chn_mode")
b_band.append(rs)
val = _vfob.chan_num + 1
rs = RadioSetting("lower.vfob.chan_num", "Initial Chan",
RadioSettingValueInteger(0, 127, val))
rs.set_apply_callback(my_adjraw, _vfob, "chan_num", -1)
b_band.append(rs)
val = _vfob.rxfreq / 100000.0
if (val < 400.0 or val > 480.0):
val = 446.0 # UHF calling
rs = RadioSetting("lower.vfob.rxfreq ", "Default Recv Freq (MHz)",
RadioSettingValueFloat(400.0, 480.0, val, 0.001, 5))
rs.set_apply_callback(my_dbl2raw, _vfob, "rxfreq")
b_band.append(rs)
tmp = my_tone_strn(_vfob, "is_rxdigtone", "rxdtcs_pol", "rx_tone")
rs = RadioSetting("rx_tone", "Default Recv CTCSS (Htz)",
RadioSettingValueList(LIST_CTCSS, tmp))
rs.set_apply_callback(my_set_tone, _vfob, "is_rxdigtone",
"rxdtcs_pol", "rx_tone")
b_band.append(rs)
rx = RadioSettingValueList(LIST_RECVMODE, LIST_RECVMODE[_vfob.rx_mode])
rs = RadioSetting("lower.vfob.rx_mode", "Default Recv Mode", rx)
b_band.append(rs)
tmp = my_tone_strn(_vfob, "is_txdigtone", "txdtcs_pol", "tx_tone")
rs = RadioSetting("tx_tone", "Default Xmit CTCSS (Htz)",
RadioSettingValueList(LIST_CTCSS, tmp))
rs.set_apply_callback(my_set_tone, _vfob, "is_txdigtone",
"txdtcs_pol", "tx_tone")
b_band.append(rs)
rx = RadioSettingValueList(LIST_SIGNAL,LIST_SIGNAL[_vfob.launch_sig])
rs = RadioSetting("lower.vfob.launch_sig", "Launch Signaling", rx)
b_band.append(rs)
rx = RadioSettingValueList(LIST_SIGNAL,LIST_SIGNAL[_vfob.tx_end_sig])
rs = RadioSetting("lower.vfob.tx_end_sig", "Xmit End Signaling", rx)
b_band.append(rs)
rx = RadioSettingValueList(LIST_BW, LIST_BW[_vfob.fm_bw])
rs = RadioSetting("lower.vfob.fm_bw", "Wide/Narrow Band", rx)
b_band.append(rs)
rs = RadioSetting("lower.vfob.cmp_nder", "Compandor",
RadioSettingValueBoolean(bool(_vfob.cmp_nder)))
b_band.append(rs)
rs = RadioSetting("lower.vfob.scrm_blr", "Scrambler",
RadioSettingValueBoolean(bool(_vfob.scrm_blr)))
b_band.append(rs)
rx = RadioSettingValueList(LIST_SHIFT, LIST_SHIFT[_vfob.shift])
rs = RadioSetting("lower.vfob.shift", "Xmit Shift", rx)
b_band.append(rs)
val = _vfob.offset / 100000.0
rs = RadioSetting("lower.vfob.offset", "Xmit Offset (MHz)",
RadioSettingValueFloat(0, 100.0, val, 0.001, 3))
rs.set_apply_callback(my_dbl2raw, _vfob, "offset", 0)
b_band.append(rs)
tmp = str(_vfob.step / 100.0)
rs = RadioSetting("step", "Freq step (KHz)",
RadioSettingValueList(LIST_STEPS, tmp))
rs.set_apply_callback(my_word2raw, _vfob, "step", 100)
b_band.append(rs)
# PowerOn & Freq Limits Settings
def chars2str(cary, knt):
"""Convert raw memory char array to a string: NOT a callback."""
stx = ""
for char in cary[:knt]:
stx += chr(char)
return stx
def my_str2ary(setting, obj, atrba, atrbc):
"""Callback: convert 7-char string to char array with count."""
ary = ""
knt = 7
for j in range (6, -1, -1): # Strip trailing spaces
if str(setting.value)[j] == "" or str(setting.value)[j] == " ":
knt = knt - 1
else:
break
for j in range(0, 7, 1):
if j < knt: ary += str(setting.value)[j]
else: ary += chr(0xFF)
setattr(obj, atrba, ary)
setattr(obj, atrbc, knt)
return
tmp = chars2str(_lims.hello1, _lims.hello1_cnt)
rs = RadioSetting("hello_lims.hello1", "Power-On Message 1",
RadioSettingValueString(0, 7, tmp))
rs.set_apply_callback(my_str2ary, _lims, "hello1", "hello1_cnt")
lims.append(rs)
tmp = chars2str( _lims.hello2, _lims.hello2_cnt)
rs = RadioSetting("hello_lims.hello2", "Power-On Message 2",
RadioSettingValueString(0, 7, tmp))
rs.set_apply_callback(my_str2ary, _lims,"hello2", "hello2_cnt")
lims.append(rs)
# VALID_BANDS = [(136000000, 176000000),400000000, 480000000)]
lval = _lims.vhf_low / 100000.0
uval = _lims.vhf_high / 100000.0
if lval >= uval:
lval = 144.0
uval = 158.0
rs = RadioSetting("hello_lims.vhf_low", "Lower VHF Band Limit (MHz)",
RadioSettingValueFloat(136.0, 176.0, lval, 0.001, 3))
rs.set_apply_callback(my_dbl2raw, _lims, "vhf_low")
lims.append(rs)
rs = RadioSetting("hello_lims.vhf_high", "Upper VHF Band Limit (MHz)",
RadioSettingValueFloat(136.0, 176.0, uval, 0.001, 3))
rs.set_apply_callback(my_dbl2raw, _lims, "vhf_high")
lims.append(rs)
lval = _lims.uhf_low / 100000.0
uval = _lims.uhf_high / 100000.0
if lval >= uval:
lval = 420.0
uval = 470.0
rs = RadioSetting("hello_lims.uhf_low", "Lower UHF Band Limit (MHz)",
RadioSettingValueFloat(400.0, 480.0, lval, 0.001, 3))
rs.set_apply_callback(my_dbl2raw, _lims, "uhf_low")
lims.append(rs)
rs = RadioSetting("hello_lims.uhf_high", "Upper UHF Band Limit (MHz)",
RadioSettingValueFloat(400.0, 480.0, uval, 0.001, 3))
rs.set_apply_callback(my_dbl2raw, _lims, "uhf_high")
lims.append(rs)
# Codes and DTMF Groups Settings
def make_dtmf(ary, knt):
"""Generate the DTMF code 1-8, NOT a callback."""
tmp = ""
if knt > 0 and knt != 0xff:
for val in ary[:knt]:
if val > 0 and val <= 9:
tmp += chr(val + 48)
elif val == 0x0a:
tmp += "0"
elif val == 0x0d:
tmp += "A"
elif val == 0x0e:
tmp += "B"
elif val == 0x0f:
tmp += "C"
elif val == 0x00:
tmp += "D"
elif val == 0x0b:
tmp += "*"
elif val == 0x0c:
tmp += "#"
else:
msg = ("Invalid Character. Must be: 0-9,A,B,C,D,*,#")
raise InvalidValueError(msg)
return tmp
def my_dtmf2raw(setting, obj, atrba, atrbc, syz=7):
"""Callback: DTMF Code; sends 5 or 7-byte string."""
draw = []
knt = syz
for j in range (syz - 1, -1, -1): # Strip trailing spaces
if str(setting.value)[j] == "" or str(setting.value)[j] == " ":
knt = knt - 1
else:
break
for j in range(0, syz):
bx = str(setting.value)[j]
obx = ord(bx)
dig = 0x0ff
if j < knt and knt > 0: # (Else) is pads
if bx == "0":
dig = 0x0a
elif bx == "A":
dig = 0x0d
elif bx == "B":
dig = 0x0e
elif bx == "C":
dig = 0x0f
elif bx == "D":
dig = 0x00
elif bx == "*":
dig = 0x0b
elif bx == "#":
dig = 0x0c
elif obx >= 49 and obx <= 57:
dig = obx - 48
else:
msg = ("Must be: 0-9,A,B,C,D,*,#")
raise InvalidValueError(msg)
# - End if/elif/else for bx
# - End if J<=knt
draw.append(dig) # Generate string of bytes
# - End for j
setattr(obj, atrba, draw)
setattr(obj, atrbc, knt)
return
tmp = make_dtmf(_codes.native_id_code, _codes.native_id_cnt)
rs = RadioSetting("codes.native_id_code", "Native ID Code",
RadioSettingValueString(0, 7, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes, "native_id_code",
"native_id_cnt", 7)
codes.append(rs)
tmp = make_dtmf( _codes.master_id_code, _codes.master_id_cnt)
rs = RadioSetting("codes.master_id_code", "Master Control ID Code",
RadioSettingValueString(0, 7, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes, "master_id_code",
"master_id_cnt",7)
codes.append(rs)
tmp = make_dtmf( _codes.alarm_code, _codes.alarm_cnt)
rs = RadioSetting("codes.alarm_code", "Alarm Code",
RadioSettingValueString(0, 5, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes, "alarm_code",
"alarm_cnt", 5)
codes.append(rs)
tmp = make_dtmf( _codes.id_disp_code, _codes.id_disp_cnt)
rs = RadioSetting("codes.id_disp_code", "Identify Display Code",
RadioSettingValueString(0, 5, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes, "id_disp_code",
"id_disp_cnt", 5)
codes.append(rs)
tmp = make_dtmf( _codes.revive_code, _codes.revive_cnt)
rs = RadioSetting("codes.revive_code", "Revive Code",
RadioSettingValueString(0, 5, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes,"revive_code",
"revive_cnt", 5)
codes.append(rs)
tmp = make_dtmf( _codes.stun_code, _codes.stun_cnt)
rs = RadioSetting("codes.stun_code", "Remote Stun Code",
RadioSettingValueString(0, 5, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes, "stun_code",
"stun_cnt", 5)
codes.append(rs)
tmp = make_dtmf( _codes.kill_code, _codes.kill_cnt)
rs = RadioSetting("codes.kill_code", "Remote KILL Code",
RadioSettingValueString(0, 5, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes, "kill_code",
"kill_cnt", 5)
codes.append(rs)
tmp = make_dtmf( _codes.monitor_code, _codes.monitor_cnt)
rs = RadioSetting("codes.monitor_code", "Monitor Code",
RadioSettingValueString(0, 5, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes, "monitor_code",
"monitor_cnt", 5)
codes.append(rs)
val = _codes.state_now
if val > 2:
val = 0
rx = RadioSettingValueList(LIST_STATE, LIST_STATE[val])
rs = RadioSetting("codes.state_now", "Current State", rx)
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf1, _dtmf.dtmf1_cnt)
rs = RadioSetting("dtmf_tab.dtmf1", "DTMF1 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf1", "dtmf1_cnt")
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf2, _dtmf.dtmf2_cnt)
rs = RadioSetting("dtmf_tab.dtmf2", "DTMF2 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf2", "dtmf2_cnt")
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf3, _dtmf.dtmf3_cnt)
rs = RadioSetting("dtmf_tab.dtmf3", "DTMF3 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf3", "dtmf3_cnt")
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf4, _dtmf.dtmf4_cnt)
rs = RadioSetting("dtmf_tab.dtmf4", "DTMF4 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf4", "dtmf4_cnt")
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf5, _dtmf.dtmf5_cnt)
rs = RadioSetting("dtmf_tab.dtmf5", "DTMF5 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf5", "dtmf5_cnt")
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf6, _dtmf.dtmf6_cnt)
rs = RadioSetting("dtmf_tab.dtmf6", "DTMF6 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf6", "dtmf6_cnt")
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf7, _dtmf.dtmf7_cnt)
rs = RadioSetting("dtmf_tab.dtmf7", "DTMF7 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf7", "dtmf7_cnt")
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf8, _dtmf.dtmf8_cnt)
rs = RadioSetting("dtmf_tab.dtmf8", "DTMF8 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf8", "dtmf8_cnt")
codes.append(rs)
return group # END get_settings()
def set_settings(self, settings):
_settings = self._memobj.settings
_mem = self._memobj
for element in settings:
if not isinstance(element, RadioSetting):
self.set_settings(element)
continue
else:
try:
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():
LOG.debug("Using apply callback")
element.run_apply_callback()
elif element.value.get_mutable():
LOG.debug("Setting %s = %s" % (setting, element.value))
setattr(obj, setting, element.value)
except Exception, e:
LOG.debug(element.get_name())
raise
@classmethod
def match_model(cls, filedata, filename):
match_size = False
match_model = False
# Testing the file data size
if len(filedata) == MEM_SIZE + 8:
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
class LT725UVUpper(LT725UV):
VARIANT = "Upper"
_vfo = "upper"
class LT725UVLower(LT725UV):
VARIANT = "Lower"
_vfo = "lower"
class Zastone(chirp_common.Alias):
"""Declare BJ-218 alias for Zastone BJ-218."""
VENDOR = "Zastone"
MODEL = "BJ-218"
class Hesenate(chirp_common.Alias):
"""Declare BJ-218 alias for Hesenate BJ-218."""
VENDOR = "Hesenate"
MODEL = "BJ-218"
@directory.register
class Baojie218(LT725UV):
"""Baojie BJ-218"""
VENDOR = "Baojie"
MODEL = "BJ-218"
ALIASES = [Zastone, Hesenate, ]
More information about the chirp_devel
mailing list