CHIRP

# Copyright 2016-2023:

# * Jim Unroe KC9HI, <rock.unroe@gmail.com>

# Modified for Baojie BJ-218: 2018

#    Rick DeWitt (RJD), <aa0rd@yahoo.com>

# Modified for Baojie BJ-318: April 2021

#    Mark Hartong, AJ4YI <mark.hartong@verizon.net>

# Modified for Baojie BJ-318: January 2023

#    Mark Hartong, AJ4YI <mark.hartong@verizon.net>

#    1. Removed Experimental Warning

#    2. Added Brown & Yellow as Color Selections

#    3. Max VFO Volume Setting to 15 ( vice 10)

#        

# 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

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

LOG = logging.getLogger(__name__)

MEM_FORMAT = """

#seekto 0x0200;

struct {

  u8  init_bank; // determines which VFO is primary A or B

  u8  volume;    // not used BJ-318, band volume is controlled vfo u8 bvol

  u16 fm_freq;   // not used BJ-318, freq is controlled hello_lims u16 fm_318

  u8  wtled;     // not used BJ-318

  u8  rxled;     // not used BJ-318

  u8  txled;     // not used BJ-318

  u8  ledsw;

  u8  beep;

  u8  ring;

  u8  bcl;

  u8  tot;

  u16 sig_freq;

  u16 dtmf_txms;

  u8  init_sql;  // not used BJ-318, band squelch is controlled vfo u8 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;    // not used in BJ-318, is set in memory map

  char  hello1[7];   // not used in BJ-318, is set in memory map

  u8  hello2_cnt;    // not used in BJ-318, is set in memory map

  char  hello2[7];   // not used in BJ-318, is set in memory map

  u32  vhf_low;

  u32  vhf_high;

  u32  uhf_low;

  u32  uhf_high;

  u8  lims_on;       // first byte @ at address 0x02f0;

  u8 unknown_1;      // use in BJ-318 unknown

  u8 lang;           // BJ-318 Display language

                     // 02 = English 00 and 01 are Asian

  u8 up_scr_color;   // BJ-318 upper screen character color

  u8 dn_scr_color;   // BJ-318 lower screen character color

                     // purple=00, red=01, emerald=02, blue=03,

                     // sky_blue=04, black=05, brown=06, yellow=07 required hex values for color

                     // Note   sky_blue and black look the same on the

                     // BJ-318 screen

  u16 fm_318;        // FM stored Frequency in BJ-318

} 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;        // sets power Hi=02h, Medium=01h, Low=00

                     // sets power for entire vfo band

  u8  fm_bw;

  u8  cmp_nder;

  u8  scrm_blr;

  u8  shift;

  u32 offset;

  u16 step;

  u8  sql;           // squelch for entire vfo band

                     // integer values 0 (low) to 9 (high)

  u8  bvol;          // sets volume for vfo band

                     // integer values 0  (low) TO 15 (high)

};

#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,            // binary value for

                          // individual channel power

                          // set to "High" or "Low"

                          // BJ-318 band power overrides any

                          // individual channel power setting

      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

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

# Screen Color Settings

# BJ-218 Colors

LIST_COLOR = ["Off", "Orange", "Blue", "Purple"]

# BJ-318 Colors

LIST_COLOR318 = ["Purple", "Red", "Emerald", "Blue", "Sky_Blue", "Black", "Brown", "Yellow"]

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,   # not used in BJ-318, other radios use

    "rxled": LIST_COLOR,   # not used in BJ-318, other radios use

    "txled": LIST_COLOR,   # not used in BJ-318, other radios use

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

    "up_scr_color": LIST_COLOR318,  # unique to BJ-318

    "dn_scr_color": LIST_COLOR318,  # unique to BJ-318

}

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 = b""

    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 = b"PROM_LIN"

    _rawsend(radio, magic)

    ack = _rawrecv(radio, 1)

    if ack != b"\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 = b"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 = b""

    for addr in range(0, MEM_SIZE, BLOCK_SIZE):

        frame = _make_frame(b"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)

    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(b"WRIE", addr, BLOCK_SIZE, data)

        _rawsend(radio, frame)

        # Receiving the response

        ack = _rawrecv(radio, 1)

        if ack != b"\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.encode())

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

    """LUITON LT-725UV Radio"""

    VENDOR = "LUITON"

    MODEL = "LT-725UV"

    NEEDS_COMPAT_SERIAL = False

    MODES = ["NFM", "FM"]

    TONES = chirp_common.TONES

    DTCS_CODES = sorted(chirp_common.DTCS_CODES + [645])

    NAME_LENGTH = 7

    DTMF_CHARS = list("0123456789ABCD*#")

    # Channel Power: 2 levels

    # BJ-318 uses 3 power levels for each VFO "Band"

    # Low = 5W, Med = 10W, High = 25W

    # The band power selection in a VFO applies to the VFO and overrides

    # the stored channel power selection

    # The firmware channel memory structure provides only 1 bit for

    # individual channel power settings, limiting potential channel

    # power selection options to 2 levels: Low or High.

    POWER_LEVELS = [chirp_common.PowerLevel("Low", watts=5.00),

                    chirp_common.PowerLevel("High", watts=30.00)]

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

        if cls.MODEL == "BJ-318":

            msg = \

                ('\n'

                 'The individual BJ-318 channel power settings set in CHIRP are ignored by \n'

                 'the radio. They are allowed to be set in hopes of a future firmware \n'

                 'change by the manufacturer. While the CHIRP driver will allow setting \n'

                 'the individual VFO power to High (25W), Med (10W) or Low (5W) they \n' 

                 'are converted to just Low (5W) and High (25W) on upload. The Med setting \n'

                 'reverts to Low. \n'

                 '\n'

                 'Changing a channel power setting must be done manually using the front \n'

                 'panel menu control (or the microphone controls while in VFO mode.)'

                 )

        else:

            msg = \

                ('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 converted to just Low and High at'

                 ' upload.'

                 ' The Mid setting reverts to Low.'

                 )

        rp.info = msg

        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 = self.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)

        rf.valid_tuning_steps = STEPS

        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.MemoryMapBytes(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[0:_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 = self.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 == self.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)

        # BJ-318 set by vfo, skip

        if self.MODEL != "BJ-318":

            rs = RadioSettingValueInteger(0, 20, _sets.volume)

            volume = RadioSetting("settings.volume", "Volume", rs)

            basic.append(volume)

        # BJ-318 set by vfo, skip

        if self.MODEL != "BJ-318":

            vala = _vfoa.bpower        # 2bits values 0,1,2= Low, Mid, High

            rx = RadioSettingValueList(LIST_BPOWER, LIST_BPOWER[vala])

            powera = RadioSetting("upper.vfoa.bpower", "Power (Upper)", rx)

            basic.append(powera)

        # BJ-318 set by vfo, skip

        if self.MODEL != "BJ-318":

            valb = _vfob.bpower

            rx = RadioSettingValueList(LIST_BPOWER, LIST_BPOWER[valb])

            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