CHIRP

#  Copyright (c) 2022 <angelof9@protonmail.com>

#

#  BSD 2-Clause "Simplified" License

#  https://opensource.org/licenses/BSD-2-Clause

#

#  Redistribution and use in source and binary forms,

#  with or without modification, are permitted provided

#  that the following conditions are met:

#

#  1. Redistributions of source code must retain the above

#     copyright notice, this list of conditions and

#     the following disclaimer.

#  2. Redistributions in binary form must reproduce the

#     above copyright notice, this list of conditions and

#     the following disclaimer in the documentation

#     and/or other materials provided with the distribution.

#

#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

#  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

#  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

#  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR

#  CONTRIBUTORS

#  BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,

#  OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

#  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

#  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

#  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

#  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

#  THE POSSIBILITY OF SUCH DAMAGE.

#  Python3 byte clean by Darryl Pogue

#  Pep8 style copliant by Jim Unroe <rock.unroe@gmail.com>

import logging

import struct

from chirp import (

    bitwise,

    chirp_common,

    directory,

    errors,

    memmap,

    util,

)

from chirp.settings import (

    RadioSetting,

    RadioSettingGroup,

    RadioSettings,

    RadioSettingValueBoolean,

    RadioSettingValueInteger,

    RadioSettingValueList,

    RadioSettingValueString,

    RadioSettingValueMap,

    RadioSettingValueFloat,

    InvalidValueError

)

from textwrap import dedent

LOG = logging.getLogger(__name__)

# 'True' or 'False'

# True unlocks:

# - FM preset

# - Channel memory  # preset

# - Killswitch (with revive killed radios)

# - Bands settings

# - Disable radio identification string verification

#   (good to recover from a bad state)

RT490_EXPERIMENTAL = True

MEM_FORMAT_RT490 = """

struct {                    // Memory settings

  lbcd rxfreq[4];

  lbcd txfreq[4];

  ul16 rxtone;

  ul16 txtone;

  u8 signal;            // int 0->14, Signal 1->15

  u8 pttid;             // ['OFF', 'BOT', 'EOT', 'Both']

  u8 dcp:4,             // What is DCP ? FHSS ? DC-FHSS ??? TODO

     power:4;           // POWER_LEVELS

  u8 unknown3_0:1,      // Used by the driver to store AM/NAM flag

                        // (thank you Radtel for free space)

     narrow:1,          // bool true=NFM false=FM (col[7] a)

     unknown3_1:1,

     unknown3_2:1,

     bcl:1,             // bool (col[9] a2)

     scan:1,            // bool (col[10] a3)

     tx_enable:1,       // bool (col[1] a4)

     learn:1;           // bool ??? TODO (col[14] a5)

} memory[%(memsize)d];

#seekto 0x1000;             // Memory names (@4096)

struct {

  char name[12];

  u8 ffpad[4];

} memname[%(memsize)d];

#seekto 0x2000;             // GOOD DCP keys ??? TODO ?? (@8192)

struct {

  u8 code[4];

} memcode[%(memsize)d];     // up to @x2400

                        // Filled with xFF during download (=> no need to fill

                        // with xFF), ready to upload

#seekto 0x3400;             // Custom ANI Names (@13312)

struct {

  char name[10];

  u8 ffpad[6];

} custom_ani_names[10];

                        // Filled with xFF during download (=> no need to fill

                        // with xFF), ready to upload

#seekto 0x3500;             // ANI Codes (@13568)

struct {

  u8 anicode[6];

  u8 ffpad[10];

} anicodes[60];

                        // Filled with xFF during download (=> no need to fill

                        // with xFF), ready to upload

#seekto 0x3900;             // Custom channel names (@14592)

struct {

  char name[10];

  u8 ffpad[6];

} custom_channel_names[10];

                        // Filled with xFF during download (=> no need to fill

                        // with xFF), ready to upload

#seekto 0x3A00;             // Settings (@14848)

struct {

  u8 squelch;           // 0: int 0 -> 9

  u8 savemode;          // 1: ['OFF', 'Normal', 'Super', 'Deep']

  u8 vox;               // 2: off=0, 1 -> 9

  u8 backlight;         // 3: ['OFF', '5s', '15s', '20s', '30s', '1m', '2m',

                        //     '3m']

  u8 tdr;               // 4: bool

  u8 timeout;           // 5: n*30seconds, 0-240s

  u8 beep;              // 6: bool

  u8 voice;             // 7: bool

  u8 byte_not_used_10;  // 8: Allways 1

  u8 dtmfst;            // 9: ['OFF', 'KB Side Tone', 'ANI Side Tone',

                        //     'KB ST + ANI ST']

  u8 scanmode;          // 10: ['TO', 'CO', 'SE']

  u8 pttid;             // 11: ['OFF', 'BOT', 'EOT', 'Both']

  u8 pttiddelay;        // 12: ['0', '100ms', '200ms', '400ms', '600ms',

                        //      '800ms', '1000ms']

  u8 cha_disp;          // 13: ['Name', 'Freq', 'Channel ID']

  u8 chb_disp;          // 14: ['Name', 'Freq', 'Channel ID']

  u8 bcl;               // 15: bool

  u8 autolock;          // 0: ['OFF', '5s', '10s', 15s']

  u8 alarm_mode;        // 1: ['Site', 'Tone', 'Code']

  u8 alarmsound;        // 2: bool

  u8 txundertdr;        // 3: ['OFF', 'A', 'B']

  u8 tailnoiseclear;    // 4: [off, on]

  u8 rptnoiseclear;     // 5: n*100ms, 0-1000

  u8 rptnoisedelay;     // 6: n*100ms, 0-1000

  u8 roger;             // 7: bool

  u8 active_channel;    // 8: 0 or 1

  u8 fmradio;           // 9: boolean, inverted

  u8 workmodeb:4,       // 10:up    ['VFO', 'CH Mode']

     workmodea:4;       // 10:down  ['VFO', 'CH Mode']

  u8 kblock;            // 11: bool                  // TODO TEST WITH autolock

  u8 powermsg;          // 12: 0=Image / 1=Voltage

  u8 byte_not_used_21;  // 13: Allways 0

  u8 rpttone;           // 14: ['1000Hz', '1450Hz', '1750Hz', '2100Hz']

  u8 byte_not_used_22;  // 15: pad with xFF

  u8 vox_delay;         // 0: [str(float(a)/10)+'s' for a in range(5,21)]

                        //     '0.5s' to '2.0s'

  u8 timer_menu_quit;   // 1: ['5s', '10s', '15s', '20s', '25s', '30s', '35s',

                        //     '40s', '45s', '50s', '60s']

  u8 byte_not_used_30;  // 2: pad with xFF

  u8 byte_not_used_31;  // 3: pad with xFF

  u8 enable_killsw;     // 4: bool

  u8 display_ani;       // 5: bool

  u8 byte_not_used_32;  // 6: pad with xFF

  u8 enable_gps;        // 7: bool

  u8 scan_dcs;          // 8: ['All', 'Receive', 'Transmit']

  u8 ani_id;            // 9: int 0-59 (ANI 1-60)

  u8 rx_time;           // 10: bool

  u8 ffpad0[5];          // 11: Pad xFF

  u8 cha_memidx;        // 0: Memory index when channel A use memories

  u8 byte_not_used_40;

  u8 chb_memidx;        // 2: Memory index when channel B use memories

  u8 byte_not_used_41;

  u8 ffpad1[10];

  ul16 fmpreset;

} settings;

                        // Filled with xFF during download (=> no need to fill

                        // with xFF), ready to upload

struct settings_vfo_chan {

  u8   rxfreq[8];       // 0

  ul16 rxtone;          // 8

  ul16 txtone;          // 10

  ul16 byte_not_used0;  // 12 Pad xFF

  u8   sftd:4,          // 14 Shift dir ['OFF', '+', '-']

       signal:4;        // 14 int 0->14, Signal 1->15

  u8   byte_not_used1;  // 15 Pad xFF

  u8   power;           // 16:0 POWER_LEVELS

  u8   fhss:4,          // 17 ['OFF', 'FHSS 1', 'FHSS 2', 'FHSS 3', 'FHSS 4']

       narrow:4;        // 17 bool true=NFM false=FM

  u8   byte_not_used2;  // 18 Pad xFF but received 0x00 ???

  u8   freqstep;        // 19:3 ['2.5 KHz', '5.0 KHz', '6.25 KHz',

                        //       '10.0 KHz', '12.5 KHz', '20.0 KHz',

                        //       '25.0 KHz', '50.0 KHz']

  u8   byte_not_used3;  // 20:4 Pad xFF but received 0x00 ??? TODO

  u8   offset[6];       // 21:5 Freq NN.NNNN (without the dot) TEST TEST

  u8   byte_not_used4;  // 27:11   Pad xFF

  u8   byte_not_used5;  // 28      Pad xFF

  u8   byte_not_used6;  // 29      Pad xFF

  u8   byte_not_used7;  // 30      Pad xFF

  u8   byte_not_used8;  // 31:15   Pad xFF

};

#seekto 0x3A40;             // VFO A/B (@14912)

struct {

  struct settings_vfo_chan vfo_a;

  struct settings_vfo_chan vfo_b;

} settings_vfo;

#seekto 0x3A80;             // Side keys settings (@14976)

struct {                    // Values from Radio

  u8 pf2_short;         // { '7': 'FM', '10': 'Tx Power', '28': 'Scan',

                        //  '29': 'Search, '1': 'PPT B' }

  u8 pf2_long;          // { '7': 'FM', '10': 'Tx Power', '28': 'Scan',

                        //  '29': 'Search' }

  u8 pf3_short;         // {'7': 'FM', '10': 'Tx Power', '28': 'Scan',

                        //  '29': 'Search'}

  u8 ffpad;             // Pad xFF

} settings_sidekeys;

struct dtmfcode {

  u8 code[5];           // 5 digits DTMF

  u8 ffpad[11];         // Pad xFF

};

                        // Filled with xFF during download (=> no need to fill

                        // with xFF), ready to upload

#seekto 0x3B00;             // DTMF (@15104)

struct dtmfcode settings_dtmfgroup[15];

struct {                // @15296+3x16

  u8 byte_not_used1;    // 0: Pad xFF something here

  u8 byte_not_used2;    // 1: Pad xFF something here

  u8 byte_not_used3;    // 2: Pad xFF something here

  u8 byte_not_used4;    // 3: Pad xFF

  u8 byte_not_used5;    // 4: Pad xFF

  u8 unknown_dtmf;      // 5: 0 TODO ???? wtf is alarmcode/alarmcall TODO

  u8 pttid;             // 6: [off, BOT, EOT, Both]

  u8 dtmf_speed_on;     // 7: ['50ms', '100ms', '200ms', '300ms', '500ms']

  u8 dtmf_speed_off;    // 8:0 ['50ms', '100ms', '200ms', '300ms', '500ms']

} settings_dtmf;

                        // Filled with xFF during download (=> no need to fill

                        // with xFF), ready to upload

#seekto 0x3C00;             // DTMF Kill/ReLive Codes (@15360)

struct {

  u8 kill_dtmf[6];      // 0: Kill DTMF

  u8 ffpad1[2];         // Pad xFF

  u8 revive_dtmf[6];    // 8: Revive DTMF

  u8 ffpad2[2];         // Pad xFF

} settings_killswitch;

                            // Some unknown data between 0x3E00 and 0x3F00

#seekto 0x3F80;             // Hmm hmm

struct {

  u8 unknown_data_0[16];

  u8 unknown_data_1;

  u8 active;            // Bool radio killed (killed=0, active=1)

  u8 unknown_data_2[46];

} management_settings;

struct band {

  u8 enable;            // 0 bool / enable-disable Tx on band

  bbcd freq_low[2];       // 1 lowest band frequency

  bbcd freq_high[2];      // 3 highest band frequency

};

#seekto 0x3FC0;             // Bands settings (@16320)

struct {

  struct band band136;  // 0  Settings for 136MHz band

  struct band band400;  // 5  Settings for 400MHz band

  struct band band200;  // 10 Settings for 200MHz band

  u8 byte_not_used1;    // 15

  struct band band350;  // 0  Settings for 350MHz band

  u8 byte_not_used2[43];// 5

} settings_bands;

"""

CMD_ACK = b"\x06"

DTCS_CODES = tuple(sorted(chirp_common.DTCS_CODES + (645,)))

DTMFCHARS = '0123456789ABCD*#'

def _enter_programming_mode(radio):

    serial = radio.pipe

    exito = False

    for i in range(0, 5):

        serial.write(radio._magic)

        ack = serial.read(1)

        try:

            if ack == CMD_ACK:

                exito = True

                break

        except Exception:

            LOG.debug("Attempt #%s, failed, trying again" % i)

            pass

    # check if we had EXITO

    if exito is False:

        msg = "The radio did not accept program mode after five tries.\n"

        msg += "Check you interface cable and power cycle your radio."

        raise errors.RadioError(msg)

    try:

        serial.write(b"F")

        ident = serial.read(8)

    except Exception:

        raise errors.RadioError("Error communicating with radio")

    if not ident.startswith(radio._fingerprint) and not RT490_EXPERIMENTAL:

        LOG.debug(util.hexprint(ident))

        raise errors.RadioError("Radio returned unknown identification string")

def _exit_programming_mode(radio):

    serial = radio.pipe

    try:

        serial.write(b"E")

    except Exception:

        raise errors.RadioError("Radio refused to exit programming mode")

def _read_block(radio, block_addr, block_size):

    serial = radio.pipe

    cmd = struct.pack(">cHb", b'R', block_addr, block_size)

    expectedresponse = b"R" + cmd[1:]

    LOG.debug("Reading block %04x..." % (block_addr))

    try:

        serial.write(cmd)

        response = serial.read(4 + block_size)

        if response[:4] != expectedresponse:

            raise Exception("Error reading block %04x." % (block_addr))

        block_data = response[4:]

    except Exception:

        raise errors.RadioError("Failed to read block at %04x" % block_addr)

    return block_data

def _write_block(radio, block_addr, block_size):

    serial = radio.pipe

    cmd = struct.pack(">cHb", b'W', block_addr, block_size)

    data = radio.get_mmap()[block_addr:block_addr + block_size]

    LOG.debug("Writing Data:")

    LOG.debug(util.hexprint(cmd + data))

    try:

        serial.write(cmd + data)

        if serial.read(1) != CMD_ACK:

            raise Exception("No ACK")

    except Exception:

        raise errors.RadioError("Failed to send block "

                                "to radio at %04x" % block_addr)

def do_download(radio):

    LOG.debug("download")

    _enter_programming_mode(radio)

    data = b""

    status = chirp_common.Status()

    status.msg = "Cloning from radio"

    status.cur = 0

    status.max = radio._memsize

    for addr in range(0, radio._memsize, radio.BLOCK_SIZE):

        status.cur = addr + radio.BLOCK_SIZE

        radio.status_fn(status)

        block = _read_block(radio, addr, radio.BLOCK_SIZE)

        data += block

        LOG.debug("Address: %04x" % addr)

        LOG.debug(util.hexprint(block))

    _exit_programming_mode(radio)

    return memmap.MemoryMapBytes(data)

def do_upload(radio):

    status = chirp_common.Status()

    status.msg = "Uploading to radio"

    _enter_programming_mode(radio)

    status.cur = 0

    status.max = radio._memsize

    for start_addr, end_addr in radio._ranges:

        for addr in range(start_addr, end_addr, radio.BLOCK_SIZE):

            status.cur = addr + radio.BLOCK_SIZE

            radio.status_fn(status)

            _write_block(radio, addr, radio.BLOCK_SIZE)

    _exit_programming_mode(radio)

class RT490Radio(chirp_common.CloneModeRadio):

    """RADTEL RT-490"""

    VENDOR = "Radtel"

    MODEL = "RT-490"

    BLOCK_SIZE = 0x40  # 64 bytes

    BAUD_RATE = 9600

    NEEDS_COMPAT_SERIAL = False

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

                    chirp_common.PowerLevel("L", watts=3.00)]

    # magic = progmode + modelType + garbage (works with any last char)

    _magic = b"PROGROMJJCCU"

    # fingerprint is default band ranges of the radio

    # the driver can change band ranges and fingerprint will

    # change accordingly, so it is not used to verify radio id.

    _fingerprint = b"\x01\x36\x01\x80\x04\x00\x05\x20"

    # Ranges of memory used when uploading data to radio

    # same as official software

    _ranges = [

               (0x0000, 0x2400),

               (0x3400, 0x3C40),

               (0x3FC0, 0x4000)

              ]

    if RT490_EXPERIMENTAL:

        # Experimental driver (already heavily tested)

        _ranges = [(0x0000, 0x2400), (0x3400, 0x3C40), (0x3F80, 0x4000)]

    # Danger zone

    # _ranges = [(0x0000, 0x2500), (0x3400, 0x3C40), (0x3E00, 0x4000)]

    # 16KB of memory, download read everything

    # same as official software (remark: loops if overread :))

    _memsize = 16384

    POWER_LEVELS_LIST = [str(i) for i in POWER_LEVELS]

    FHSS_LIST = ['OFF', 'ENCRYPT 1', 'ENCRYPT 2', 'ENCRYPT 3', 'ENCRYPT 4']

    DCP_LIST = ['OFF', 'DCP1', 'DCP2', 'DCP3', 'DCP4']  # Same as FHSS ?

    #                                                   # Seems yes

    TUNING_STEPS = [2.5, 5.0, 6.25, 10.0, 12.5, 20.0, 25.0, 50.0]

    TUNING_STEPS_LIST = [str(i)+' KHz' for i in TUNING_STEPS]

    SIGNAL = [str(i) for i in range(1, 16)]

    PTTID = ['OFF', 'BOT', 'EOT', 'Both']

    PTTIDDELAYS = ['0', '100ms', '200ms', '400ms', '600ms', '800ms', '1000ms']

    DTMF_SPEEDS = ['50ms', '100ms', '200ms', '300ms', '500ms']

    SIDEKEY_VALUEMAP = [('FM', 7), ('Tx Power', 10), ('Scan', 28),

                        ('Search', 29), ('PTT B', 1)]

    KEY_CHARS = '0123456789ABCDEF'

    FULL_CHARSET_ASCII = ("".join([chr(x) for x in range(ord(" "),

                          ord("~") + 1)] + [chr(x) for x in range(128, 255)] +

                              [chr(0)]))

    VFO_SFTD = ['OFF', '+', '-']

    WORKMODES = ['VFO', 'Memory Mode']

    SAVEMODES = ['OFF', 'Normal', 'Super', 'Deep']

    DISPLAYMODES = ['Name', 'Freq', 'Memory ID']

    SCANMODES = ['TO', 'CO', 'SE']

    ALARMMODES = ['On Site', 'Send Sound', 'Send Code']

    TDRTXMODES = ['OFF', 'A', 'B']

    SCANDCSMODES = ['All', 'Receive', 'Transmit']

    POWERMESSAGES = ['Image', 'Voltage']

    FMRADIO = ['ON', 'OFF']

    ENABLERADIO = ['Killed', 'Active']

    CHANNELS = ['A', 'B']

    TOT_LIST = ['OFF'] + [str(i*30) + "s" for i in range(1, 9)]

    VOX_LIST = ['OFF'] + [str(i) for i in range(1, 9)]

    BACKLIGHT_TO = ['OFF', '5s', '10s', '15s', '20s', '30s', '1m', '2m', '3m']

    AUTOLOCK_TO = ['OFF', '5s', '10s', '15s']

    MENUEXIT_TO = ['5s', '10s', '15s', '20s', '25s', '30s', '35s', '40s',

                   '45s', '50s', '60s']

    SQUELCHLVLS = [str(i) for i in range(10)]

    ANI_IDS = [str(i+1) for i in range(60)]

    VOXDELAYLIST = [str(float(a)/10)+'s' for a in range(5, 21)]

    DTMFSTLIST = ['OFF', 'DT Side Tone', 'ANI Side Tone', 'DT ST + ANI ST']

    RPTTONES = ['1000Hz', '1450Hz', '1750Hz', '2100Hz']

    RPTNOISE = [str(a)+'s' for a in range(11)]

    _memory_size = _upper = 256  # Number of memory slots

    _mem_params = (_upper-1)

    _frs = _murs = _pmr = _gmrs = True

    def set_settings(self, settings):

        for element in settings:

            if not isinstance(element, RadioSetting):

                self.set_settings(element)

                continue

            else:

                self._set_setting(element)

    def _set_setting(self, setting):  # WIP

        _mem = self._memobj

        key = setting.get_name()

        val = setting.value

        if key.startswith('dummy'):

            return

        elif key.startswith('settings_dtmfgroup.'):

            if str(val) == "":

                setattr(_mem.settings_dtmfgroup[int(key.split('@')[1])-1],

                        'code', [0xFF]*5)

            else:

                tmp = [DTMFCHARS.index(c) for c in str(val)]

                tmp += [0xFF] * (5 - len(tmp))

                setattr(_mem.settings_dtmfgroup[int(key.split('@')[1])-1],

                        'code', tmp)

        elif key.startswith('settings.'):

            if key.endswith('_memidx'):

                val = int(val) - 1

            if key.endswith('fmpreset'):

                tmp = val.get_value() * 10

                setattr(_mem.settings, key.split('.')[1], tmp)

            else:

                setattr(_mem.settings, key.split('.')[1], int(val))

        elif key.startswith('settings_dtmf.'):

            attr = key.split('.')[1]

            setattr(_mem.settings_dtmf, attr, int(val))

            if attr.startswith('pttid'):

                setattr(_mem.settings, attr, int(val))

        elif key.startswith('settings_sidekeys.'):

            setattr(_mem.settings_sidekeys, key.split('.')[1], int(val))

        elif key.startswith('settings_vfo.'):  # TODO rx/tx tones

            tmp = key.split('.')

            attr = tmp[2]

            vfo = tmp[1]

            # LOG.debug(">>> PRE key '%s'" % key)

            # LOG.debug(">>> PRE val '%s'" % val)

            if attr.startswith('rxfreq'):

                value = chirp_common.parse_freq(str(val)) / 10

                for i in range(7, -1, -1):

                    _mem.settings_vfo[vfo].rxfreq[i] = value % 10

                    value /= 10

            elif attr.startswith('offset'):

                value = int(float(str(val)) * 10000)

                for i in range(5, -1, -1):

                    _mem.settings_vfo[vfo].offset[i] = value % 10

                    value /= 10

            else:

                setattr(_mem.settings_vfo[vfo], attr, int(val))

        elif key.startswith('settings_bands.'):

            tmp = key.split('.')

            attr = tmp[2]

            band = tmp[1]

            setattr(_mem.settings_bands[band], attr, int(val))

        elif key.startswith('settings_killswitch.'):

            attr = key.split('.')[1]

            if attr.endswith('dtmf'):

                if str(val) == "":

                    setattr(_mem.settings_killswitch, attr,

                            [0x01, 0x02, 0x01, 0x03, 0x01, 0x04])

                else:

                    setattr(_mem.settings_killswitch, attr,

                            [DTMFCHARS.index(c) for c in str(val)])

            elif attr.startswith('enable'):

                setattr(_mem.settings_killswitch, attr, int(val))

            else:

                LOG.debug(">>> TODO key '%s'" % key)

                LOG.debug(">>> TODO val '%s'" % val)

        elif key.startswith('custom_') or key.startswith('anicode') \

                or key.startswith('memcode'):

            tmp = key.split('@')

            if key.startswith('anicode'):

                val = [DTMFCHARS.index(c) for c in str(val)]

                val += [0xFF] * (6 - len(val))

                for i in range(10):

                    _mem[str(tmp[0])][int(tmp[2])]["ffpad"][i] = 0xFF

            elif key.startswith('memcode'):

                if len(str(val)) > 0:

                    tmpp = str(val).zfill(6)

                    val = self._encode_key(tmpp)

                else:

                    val = (0xFF, 0xFF, 0xFF, 0xFF)

            if key.startswith('custom_'):

                for i in range(6):

                    _mem[str(tmp[0])][int(tmp[2])]["ffpad"][i] = 0xFF

            setattr(_mem[str(tmp[0])][int(tmp[2])], str(tmp[1]), val)

        elif key.startswith('management_settings'):

            setattr(_mem.management_settings, key.split('.')[1], int(val))

        else:

            LOG.debug(">>> TODO _set_setting key '%s'" % key)

            LOG.debug(">>> TODO _set_setting val '%s'" % val)

    def _get_settings_bands(self):

        _mem = self._memobj

        ret = RadioSettingGroup('bands', 'Bands')

        bands = [('136', _mem.settings_bands.band136),

                 ('200', _mem.settings_bands.band200),

                 ('350', _mem.settings_bands.band350),

                 ('400', _mem.settings_bands.band400)]

        for label, band in bands:

            rs = RadioSetting('settings_bands.band%s.enable' % label,

                              'Enable Band %s' % label,

                              RadioSettingValueBoolean(band.enable))

            ret.append(rs)

            rsi = RadioSettingValueInteger(1, 1000, band.freq_low)

            # if label == '136' or label == '400':

            #     rsi.set_mutable(False)

            rs = RadioSetting("settings_bands.band%s.freq_low" % label,

                              "Band %s Lower Limit (MHz) (EXPERIMENTAL)"

                              % label, rsi)

            ret.append(rs)

            rsi = RadioSettingValueInteger(1, 1000, band.freq_high)

            # if label == '350':

            #     rsi.set_mutable(False)

            rs = RadioSetting("settings_bands.band%s.freq_high" % label,

                              "Band %s Upper Limit (MHz) (EXPERIMENTAL)"

                              % label, rsi)

            ret.append(rs)

        return ret

    def _get_settings_ks(self):

        _mem = self._memobj

        ret = RadioSettingGroup('killswitch', 'Killswitch')

        # Kill Enable/Disable enable_killsw

        rsvb = RadioSettingValueBoolean(_mem.settings.enable_killsw)

        ret.append(RadioSetting('settings.enable_killsw',

                                'Enable Killswitch', rsvb))

        # Kill DTMF

        cur = ''.join(

            DTMFCHARS[i]

            for i in _mem.settings_killswitch.kill_dtmf if int(i) < 0xF)

        ret.append(

            RadioSetting('settings_killswitch.kill_dtmf', 'DTMF Kill',

                         RadioSettingValueString(6, 6, cur,

                                                 autopad=False,

                                                 charset=DTMFCHARS)))

        # Revive DTMF

        cur = ''.join(

            DTMFCHARS[i]

            for i in _mem.settings_killswitch.revive_dtmf if int(i) < 0xF)

        ret.append(

            RadioSetting('settings_killswitch.revive_dtmf', 'DTMF Revive',

                         RadioSettingValueString(6, 6, cur,

                                                 autopad=False,

                                                 charset=DTMFCHARS)))

        # Enable/Disable entire radio

        rs = RadioSettingValueString(0, 255, "Can be used to revive radio")

        rs.set_mutable(False)

        ret.append(RadioSetting('dummy', 'Factory reserved', rs))

        tmp = 1 if int(_mem.management_settings.active) > 0 else 0

        ret.append(RadioSetting('management_settings.active', 'Radio Status',

                                RadioSettingValueList(self.ENABLERADIO,

                                                      self.ENABLERADIO[tmp])))

        return ret

    def _get_settings_dtmf(self):

        _mem = self._memobj

        dtmf = RadioSettingGroup('dtmf', 'DTMF')

        # DTMF Group

        msgs = ["Allowed chars (%s)" % DTMFCHARS,

                "Input from 0 to 5 characters."

                ]

        for msg in msgs:

            rsvs = RadioSettingValueString(0, 255, msg, autopad=False)

            rsvs.set_mutable(False)

            rs = RadioSetting('dummy_dtmf_msg_%i' % msgs.index(msg),

                              'Input rule %i' % int(msgs.index(msg)+1), rsvs)

            dtmf.append(rs)

        for i in range(1, 16):

            cur = ''.join(

                DTMFCHARS[i]

                for i in _mem.settings_dtmfgroup[i - 1].code if int(i) < 0xF)

            dtmf.append(

                RadioSetting(

                    'settings_dtmfgroup.code@%i' % i, 'PTT ID Code %i' % i,

                    RadioSettingValueString(0, 5, cur,

                                            autopad=False,

                                            charset=DTMFCHARS)))

        # DTMF Speed (on time in ms)

        dtmf_speed_on = int(_mem.settings_dtmf.dtmf_speed_on)

        if dtmf_speed_on > len(self.DTMF_SPEEDS)-1:

            _mem.settings_dtmf.dtmf_speed_on = 0

            LOG.debug('DTMF Speed On overflow')

        cur = self.DTMF_SPEEDS[dtmf_speed_on]

        dtmf.append(

            RadioSetting(

                'settings_dtmf.dtmf_speed_on', 'DTMF Speed (on time in ms)',

                RadioSettingValueList(self.DTMF_SPEEDS, cur)))

        # DTMF Speed (on time in ms)

        dtmf_speed_off = int(_mem.settings_dtmf.dtmf_speed_off)

        if dtmf_speed_off > len(self.DTMF_SPEEDS)-1:

            _mem.settings_dtmf.dtmf_speed_off = 0

            LOG.debug('DTMF Speed Off overflow')

        cur = self.DTMF_SPEEDS[dtmf_speed_off]

        dtmf.append(

            RadioSetting(

                'settings_dtmf.dtmf_speed_off', 'DTMF Speed (off time in ms)',

                RadioSettingValueList(self.DTMF_SPEEDS, cur)))

        # PTT ID

        pttid = int(_mem.settings_dtmf.pttid)

        if pttid > len(self.PTTID)-1:

            _mem.settings_dtmf.pttid = 0

            LOG.debug('PTT ID overflow')

        cur = self.PTTID[pttid]

        dtmf.append(

            RadioSetting(

                'settings_dtmf.pttid', 'Send DTMF Code (PTT ID)',

                RadioSettingValueList(self.PTTID, cur)))

        # PTT ID Delay

        pttiddelay = int(_mem.settings.pttiddelay)

        if pttiddelay > len(self.PTTIDDELAYS)-1:

            _mem.settings.pttiddelay = 0

            LOG.debug('PTT ID  Delay overflow')

        cur = self.PTTIDDELAYS[pttiddelay]

        rsvl = RadioSettingValueList(self.PTTIDDELAYS, cur)

        dtmf.append(RadioSetting('settings.pttiddelay',

                    'PTT ID Delay', rsvl))

        rsvl = RadioSettingValueList(self.DTMFSTLIST,

                                     self.DTMFSTLIST[_mem.settings.dtmfst])

        dtmf.append(RadioSetting('settings.dtmfst',

                                 'DTMF Side Tone (Required for GPS ID)', rsvl))

        return dtmf

    def _get_settings_sidekeys(self):

        _mem = self._memobj

        ret = RadioSettingGroup('sidekeys', 'Side Keys')

        rsvm = RadioSettingValueMap(self.SIDEKEY_VALUEMAP,

                                    _mem.settings_sidekeys.pf2_short)

        ret.append(RadioSetting('settings_sidekeys.pf2_short',

                                'Side key 1 (PTT2) Short press', rsvm))

        rsvm = RadioSettingValueMap(self.SIDEKEY_VALUEMAP[:-1],

                                    _mem.settings_sidekeys.pf2_long)

        ret.append(RadioSetting('settings_sidekeys.pf2_long',

                                'Side key 1 (PTT2) Long press', rsvm))

        rsvm = RadioSettingValueMap(self.SIDEKEY_VALUEMAP[:-1],

                                    _mem.settings_sidekeys.pf3_short)

        ret.append(RadioSetting('settings_sidekeys.pf3_short',

                                'Side key 2 (PTT3) Short press', rsvm))

        rs = RadioSettingValueString(0, 255, "MONI")

        rs.set_mutable(False)

        ret.append(RadioSetting('dummy', 'Side key 2 (PTT3) Long press', rs))

        return ret

    def _get_settings_vfo(self, vfo, chan):  # WIP TODO Rx/Tx tones

        _mem = self._memobj

        ret = RadioSettingGroup('settings_vfo@%s' % chan.lower(),

                                'VFO %s Settings' % chan)

        rsvl = RadioSettingValueList(self.WORKMODES,

                                     self.WORKMODES[_mem.settings[

                                         'workmode'+chan.lower()]])

        ret.append(RadioSetting('settings.workmode%s' % chan.lower(),

                                'VFO %s Workmode' % chan, rsvl))

        tmp = ''.join(DTMFCHARS[i] for i in _mem.settings_vfo[

                      'vfo_'+chan.lower()].rxfreq if i < 0xFF)

        rsvf = RadioSettingValueFloat(66, 550, chirp_common.format_freq(

                                      int(tmp) * 10), resolution=0.00001,

                                      precision=5)

        ret.append(RadioSetting('settings_vfo.vfo_%s.rxfreq' % chan.lower(),

                                'Rx Frequency', rsvf))

        # TODO Rx/Tx tones

        rsvl = RadioSettingValueList(self.VFO_SFTD,

                                     self.VFO_SFTD[_mem.settings_vfo[

                                         'vfo_'+chan.lower()].sftd])

        ret.append(RadioSetting('settings_vfo.vfo_%s.sftd' % chan.lower(),

                                'Freq offset direction', rsvl))

        tmp = ''.join(DTMFCHARS[i] for i in _mem.settings_vfo[

                      'vfo_'+chan.lower()].offset if i < 0xFF)

        rsvf = RadioSettingValueFloat(0, 99.9999, float(tmp) / 10000)

        ret.append(RadioSetting('settings_vfo.vfo_%s.offset' % chan.lower(),

                                'Tx Offset', rsvf))

        rsvl = RadioSettingValueList(self.SIGNAL,

                                     self.SIGNAL[

                                         _mem.settings_vfo[

                                             'vfo_'+chan.lower()].signal])

        ret.append(RadioSetting('settings_vfo.vfo_%s.signal' % chan.lower(),

                                'PTT ID Code (S-Code)', rsvl))

        rsvl = RadioSettingValueList(self.POWER_LEVELS_LIST,

                                     self.POWER_LEVELS_LIST[

                                         _mem.settings_vfo[

                                             'vfo_'+chan.lower()].power])

        ret.append(RadioSetting('settings_vfo.vfo_%s.power' % chan.lower(),

                                'Tx Power', rsvl))

        rsvl = RadioSettingValueList(self.FHSS_LIST,

                                     self.FHSS_LIST[

                                         _mem.settings_vfo[

                                             'vfo_'+chan.lower()].fhss])

        ret.append(RadioSetting('settings_vfo.vfo_%s.fhss' % chan.lower(),

                                'FHSS (Encryption)', rsvl))

        rsvl = RadioSettingValueList(['Wide', 'Narrow'],

                                     ['Wide', 'Narrow'][

                                         _mem.settings_vfo[

                                             'vfo_'+chan.lower()].narrow])

        ret.append(RadioSetting('settings_vfo.vfo_%s.narrow' % chan.lower(),

                                'Wide / Narrow', rsvl))

        rsvl = RadioSettingValueList(self.TUNING_STEPS_LIST,

                                     self.TUNING_STEPS_LIST[

                                         _mem.settings_vfo[

                                             'vfo_'+chan.lower()].freqstep])

        ret.append(RadioSetting('settings_vfo.vfo_%s.freqstep' % chan.lower(),

                                'Tuning Step', rsvl))

        return ret

    def _get_custom_channel_names(self):

        _mem = self._memobj

        ret = RadioSettingGroup('ccn', 'Custom Channel Names')

        msgs = ["Add custom chan names to radio",

                "-> Menu 09 CH-NAME",

                "Allowed chars (ASCII only)",

                "Input from 0 to 10 characters."

                ]

        for msg in msgs:

            rsvs = RadioSettingValueString(0, 255, msg, autopad=False)

            rsvs.set_mutable(False)

            rs = RadioSetting('dummy_cnames_msg_%i' % msgs.index(msg),

                              'Input rule %i' % int(msgs.index(msg)+1), rsvs)

            ret.append(rs)

        for i in range(0, len(_mem.custom_channel_names)):