Re: [chirp_devel] [PATCH] [LT-725UV] Add Support for LUITON LT-725UV

Here is a test image for the LUITON LT-725UV mobile radio.

Jim KC9HI

On Sat, Sep 3, 2016 at 8:01 PM, Jim Unroe rock.unroe@gmail.com wrote:

# HG changeset patch # User Jim Unroe rock.unroe@gmail.com # Date 1472946898 14400 # Node ID 75cb01b8fb0d0a0f523db839a1eb876839861050 # Parent 617ef175811dcf0d49b8dba8769e845972ebf672 [LT-725UV] Add Support for LUITON LT-725UV

This patch adds basic support for the LUITON LT-725UV mobile radio.

#3745

diff -r 617ef175811d -r 75cb01b8fb0d chirp/drivers/lt725uv.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/chirp/drivers/lt725uv.py Sat Sep 03 19:54:58 2016 -0400 @@ -0,0 +1,763 @@ +# Copyright 2016: +# * Jim Unroe KC9HI, rock.unroe@gmail.com +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see http://www.gnu.org/licenses/.

+import 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

+from textwrap import dedent

+MEM_FORMAT = """ +#seekto 0x0200; +struct {

• u8 unknown1;
• u8 volume;
• u8 unknown2[2];
• u8 wtled;
• u8 rxled;
• u8 txled;
• u8 ledsw;
• u8 beep;
• u8 ring;
• u8 bcl;
• u8 tot;

+} settings;

+struct vfo {

• u8 unknown1[2];
• u32 rxfreq;
• u8 unknown2[8];
• u8 power;
• u8 unknown3[3];
• u24 offset;
• u32 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[6];
• u8 unused;

+};

+#seekto 0x0400; +struct mem upper_memory[128];

+#seekto 0x1000; +struct mem lower_memory[128];

+"""

+MEM_SIZE = 0x1C00 +BLOCK_SIZE = 0x40 +STIMEOUT = 2

+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"]
  

+LIST_POWER = ["Low", "Mid", "High"] +LIST_COLOR = ["Off", "Orange", "Blue", "Purple"] +LIST_LEDSW = ["Auto", "On"] +LIST_RING = ["Off"] + ["%s seconds" % x for x in range(1, 10)] +LIST_TIMEOUT = ["Off"] + ["%s seconds" % x for x in range(30, 630, 30)]

+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 data 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 += "LT-725UV"
• 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"""
• rid = data[0x1C00:0x1C08]
• if rid == cls.MODEL:

•    return True
  

• 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 = 6
• 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 = \
  

•        ('The UV-50X3 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 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_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 = self.MODES[_mem.wide]
  

•    # 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
  

•    eotsignal = RadioSetting("eotsignal", "Transmit end signaling",
  

•                             RadioSettingValueList(LIST_SIGNAL,
  

•                                 LIST_SIGNAL[val]))
  

•    mem.extra.append(eotsignal)
  

•    compandor = RadioSetting("compandor", "Compandor",
  

•                             RadioSettingValueBoolean(bool(_mem.compandor)))
  

•    mem.extra.append(compandor)
  

•    scrambler = RadioSetting("scrambler", "Scrambler",
  

•                             RadioSettingValueBoolean(bool(_mem.scrambler)))
  

•    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)
  

•    # 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"""
  

•    _mem = self._memobj
  

•    basic = RadioSettingGroup("basic", "Basic Settings")
  

•    top = RadioSettings(basic)
  

•    # Basic
  

•    volume = RadioSetting("settings.volume", "Volume",
  

•                          RadioSettingValueInteger(0, 20,
  

•                              _mem.settings.volume))
  

•    basic.append(volume)
  

•    powera = RadioSetting("upper.vfoa.power", "Power (Upper)",
  

•                          RadioSettingValueList(LIST_POWER, LIST_POWER[
  

•                              _mem.upper.vfoa.power]))
  

•    basic.append(powera)
  

•    powerb = RadioSetting("lower.vfob.power", "Power (Lower)",
  

•                          RadioSettingValueList(LIST_POWER, LIST_POWER[
  

•                              _mem.lower.vfob.power]))
  

•    basic.append(powerb)
  

•    wtled = RadioSetting("settings.wtled", "Standby LED Color",
  

•                         RadioSettingValueList(LIST_COLOR, LIST_COLOR[
  

•                             _mem.settings.wtled]))
  

•    basic.append(wtled)
  

•    rxled = RadioSetting("settings.rxled", "RX LED Color",
  

•                         RadioSettingValueList(LIST_COLOR, LIST_COLOR[
  

•                             _mem.settings.rxled]))
  

•    basic.append(rxled)
  

•    txled = RadioSetting("settings.txled", "TX LED Color",
  

•                         RadioSettingValueList(LIST_COLOR, LIST_COLOR[
  

•                             _mem.settings.txled]))
  

•    basic.append(txled)
  

•    ledsw = RadioSetting("settings.ledsw", "Back light mode",
  

•                         RadioSettingValueList(LIST_LEDSW, LIST_LEDSW[
  

•                             _mem.settings.ledsw]))
  

•    basic.append(ledsw)
  

•    beep = RadioSetting("settings.beep", "Beep",
  

•                        RadioSettingValueBoolean(bool(_mem.settings.beep)))
  

•    basic.append(beep)
  

•    ring = RadioSetting("settings.ring", "Ring",
  

•                        RadioSettingValueList(LIST_RING, LIST_RING[
  

•                            _mem.settings.ring]))
  

•    basic.append(ring)
  

•    bcl = RadioSetting("settings.bcl", "Busy channel lockout",
  

•                       RadioSettingValueBoolean(bool(_mem.settings.bcl)))
  

•    basic.append(bcl)
  

•    tot = RadioSetting("settings.tot", "Timeout Timer",
  

•                       RadioSettingValueList(LIST_TIMEOUT, LIST_TIMEOUT[
  

•                           _mem.settings.tot]))
  

•    basic.append(tot)
  

•    if _mem.upper.vfoa.sql == 0xFF:
  

•        val = 0x04
  

•    else:
  

•        val = _mem.upper.vfoa.sql
  

•    sqla = RadioSetting("upper.vfoa.sql", "Squelch (Upper)",
  

•                        RadioSettingValueInteger(0, 9, val))
  

•    basic.append(sqla)
  

•    if _mem.lower.vfob.sql == 0xFF:
  

•        val = 0x04
  

•    else:
  

•        val = _mem.lower.vfob.sql
  

•    sqlb = RadioSetting("lower.vfob.sql", "Squelch (Lower)",
  

•                        RadioSettingValueInteger(0, 9, val))
  

•    basic.append(sqlb)
  

•    return top
  

• 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"