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 = tuple(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, 520000000)]

    # 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.rstrip())

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