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.

import time

import os

import struct

import unittest

import logging

from chirp import chirp_common, directory, memmap

from chirp import bitwise, errors, util

from chirp.settings import RadioSetting, RadioSettingGroup, \

    RadioSettingValueInteger, RadioSettingValueList, \

    RadioSettingValueBoolean, RadioSettings, \

    RadioSettingValueString, RadioSettingValueMap, \

    RadioSettingValueFloat, InvalidValueError

from textwrap import dedent

LOG = logging.getLogger(__name__)

try:

    from builtins import bytes

    has_future = True

except ImportError:

    has_future = False

    LOG.debug('python-future package is not available; '

              '%s requires it' % __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;

"""

def _rt490_enter_programming_mode(radio):

    serial = radio.pipe

    try:

        serial.write(radio._magic)

        ack = serial.read(1)

    except:

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

    if not ack:

        raise errors.RadioError("No response from radio")

    elif ack != radio.CMD_ACK:

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

    try:

        serial.write("\x46")

        ident = serial.read(8)

    except:

        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 _rt490_exit_programming_mode(radio):

    serial = radio.pipe

    try:

        serial.write(radio.CMD_EXIT)

    except:

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

def _rt490_read_block(radio, block_addr, block_size):

    serial = radio.pipe

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

    expectedresponse = cmd

    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:

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

    return block_data

def _rt490_write_block(radio, block_addr, block_size):

    serial = radio.pipe

    cmd = struct.pack(">cHb", '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) != radio.CMD_ACK:

            raise Exception("No ACK")

    except:

        raise errors.RadioError("Failed to send block "

                                "to radio at %04x" % block_addr)

def do_download(radio):

    LOG.debug("download")

    _rt490_enter_programming_mode(radio)

    data = ""

    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 = _rt490_read_block(radio, addr, radio.BLOCK_SIZE)

        data += block

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

        LOG.debug(util.hexprint(block))

    _rt490_exit_programming_mode(radio)

    return memmap.MemoryMap(data)

def do_upload(radio):

    status = chirp_common.Status()

    status.msg = "Uploading to radio"

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

            _rt490_write_block(radio, addr, radio.BLOCK_SIZE)

    _rt490_exit_programming_mode(radio)

class RT490Radio(chirp_common.CloneModeRadio):

    """RADTEL RT-490"""

    VENDOR = "Radtel"

    MODEL = "RT-490"

    BLOCK_SIZE = 0x40 # 64 bytes

    CMD_EXIT = "E"

    BAUD_RATE = 9600

    # Advertised bands

    """

    VALID_BANDS = [

                    ( 66000000, 108000000),

                    (108000000, 136000000),

                    (136000000, 180000000),

                    (200000000, 260000000),

                    (350000000, 400000000),

                    (400000000, 520000000),

                ]"""

    # Tx/Rx bands

    VALID_BANDS = [

                    (108000000, 136000000),

                    (136000000, 180000000),

                    (200000000, 260000000),

                    (350000000, 400000000),

                    (400000000, 520000000),

                ]

    VALID_MODES = [ "FM", "NFM", "AM", "NAM" ]

    POWER_LEVELS = [ chirp_common.PowerLevel("High",  watts=5),

                     chirp_common.PowerLevel("Low", watts=3) ]

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

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

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

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

    DTMFCHARS =  '0123456789ABCD*#'

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

    CMD_ACK = "\x06"

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

    _magic = "PROGROM" + "JJCC" + "U"

    # 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 = "\x01\x36\x01\x80\x04\x00\x05\x20"

    _memory_size = _upper = 256 # Number of memory slots

    _mem_params = (_upper-1)

    _frs = _murs = _pmr = _gmrs = True

    # 16KB of memory, download read everything

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

    _memsize = 16384

    # 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) ]

    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

        key = setting.get_name()

        val = setting.value

        if key.startswith('dummy'):

            return

        elif key.startswith('settings_dtmfgroup.'):

            if str(val) == "":

                setattr(self._memobj.settings_dtmfgroup[int(key.split('@')[1])-1], 'code', [0xFF]*5)

            else:

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

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

                setattr(self._memobj.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(self._memobj.settings, key.split('.')[1], tmp)

            else:

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

        elif key.startswith('settings_dtmf.'):

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

            setattr(self._memobj.settings_dtmf, attr, int(val))

            if attr.startswith('pttid'):

                setattr(self._memobj.settings, attr, int(val))

        elif key.startswith('settings_sidekeys.'):

            setattr(self._memobj.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):

                    self._memobj.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):

                    self._memobj.settings_vfo[vfo].offset[i] = value % 10

                    value /= 10

            else:

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

        elif key.startswith('settings_bands.'):

            tmp = key.split('.')

            attr = tmp[2]

            band = tmp[1]

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

        elif key.startswith('settings_killswitch.'):

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

            if attr.endswith('dtmf'):

                if str(val) == "":

                    setattr(self._memobj.settings_killswitch, attr, [0x01, 0x02, 0x01, 0x03, 0x01, 0x04])

                else:

                    setattr(self._memobj.settings_killswitch, attr, [self.DTMFCHARS.index(c) for c in str(val)])

            elif attr.startswith('enable'):

                setattr(self._memobj.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 = [self.DTMFCHARS.index(c) for c in str(val)]

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

                for i in range(10):

                    self._memobj[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):

                    self._memobj[str(tmp[0])][int(tmp[2])]["ffpad"][i] = 0xFF

            setattr(self._memobj[str(tmp[0])][int(tmp[2])], str(tmp[1]), val)

        elif key.startswith('management_settings'):

            setattr(self._memobj.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):

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

        bands = [ ('136', self._memobj.settings_bands.band136), ('200', self._memobj.settings_bands.band200),

                  ('350', self._memobj.settings_bands.band350), ('400', self._memobj.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):

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

        # Kill Enable/Disable enable_killsw

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

                    RadioSettingValueBoolean(self._memobj.settings.enable_killsw)))

        # Kill DTMF

        cur = ''.join(

            self.DTMFCHARS[i]

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

        ret.append(

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

                            RadioSettingValueString(6, 6, cur,

                                                autopad=False,

                                                charset=self.DTMFCHARS)))

        # Revive DTMF

        cur = ''.join(

            self.DTMFCHARS[i]

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

        ret.append(

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

                            RadioSettingValueString(6, 6, cur,

                                                autopad=False,

                                                charset=self.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(self._memobj.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):

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

        # DTMF Group

        msgs = [ "Allowed chars (%s)" % self.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(

                self.DTMFCHARS[i]

                for i in self._memobj.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=self.DTMFCHARS)))

        # DTMF Speed (on time in ms)

        dtmf_speed_on = int(self._memobj.settings_dtmf.dtmf_speed_on)

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

            self._memobj.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(self._memobj.settings_dtmf.dtmf_speed_off)

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

            self._memobj.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(self._memobj.settings_dtmf.pttid)

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

            self._memobj.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(self._memobj.settings.pttiddelay)

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

            self._memobj.settings.pttiddelay = 0

            LOG.debug('PTT ID  Delay overflow')

        cur = self.PTTIDDELAYS[pttiddelay]

        dtmf.append(

            RadioSetting(

                'settings.pttiddelay', 'PTT ID Delay',

                RadioSettingValueList(self.PTTIDDELAYS, cur)))

        dtmf.append(

            RadioSetting(

                'settings.dtmfst', 'DTMF Side Tone (Required for GPS ID)',

                RadioSettingValueList(self.DTMFSTLIST, self.DTMFSTLIST[self._memobj.settings.dtmfst])))

        return dtmf

    def _get_settings_sidekeys(self):

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

        ret.append(RadioSetting( 'settings_sidekeys.pf2_short', 'Side key 1 (PTT2) Short press',

                      RadioSettingValueMap( self.SIDEKEY_VALUEMAP, self._memobj.settings_sidekeys.pf2_short)))

        ret.append(RadioSetting( 'settings_sidekeys.pf2_long', 'Side key 1 (PTT2) Long press',

                      RadioSettingValueMap( self.SIDEKEY_VALUEMAP[:-1], self._memobj.settings_sidekeys.pf2_long)))

        ret.append(RadioSetting( 'settings_sidekeys.pf3_short', 'Side key 2 (PTT3) Short press',

                      RadioSettingValueMap( self.SIDEKEY_VALUEMAP[:-1], self._memobj.settings_sidekeys.pf3_short)))

        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

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

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

                                RadioSettingValueList(

                                self.WORKMODES,

                                self.WORKMODES[self._memobj.settings['workmode'+chan.lower()]])))

        tmp = ''.join(self.DTMFCHARS[i] for i in self._memobj.settings_vfo['vfo_'+chan.lower()].rxfreq if i < 0xFF)

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

                          RadioSettingValueFloat(

                              66, 550, chirp_common.format_freq(int(tmp) * 10), resolution=0.00001, precision=5 )))

        # TODO Rx/Tx tones

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

                                RadioSettingValueList(

                                self.VFO_SFTD,

                                self.VFO_SFTD[self._memobj.settings_vfo['vfo_'+chan.lower()].sftd])))

        tmp = ''.join(self.DTMFCHARS[i] for i in self._memobj.settings_vfo['vfo_'+chan.lower()].offset if i < 0xFF)

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

                          RadioSettingValueFloat(

                              0, 99.9999, float(tmp) / 10000) ))

        ret.append(RadioSetting('settings_vfo.vfo_%s.signal' % chan.lower(), 'PTT ID Code (S-Code)',

                                RadioSettingValueList(self.SIGNAL,

                                                      self.SIGNAL[self._memobj.settings_vfo['vfo_'+chan.lower()].signal])))

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

                                RadioSettingValueList(self.POWER_LEVELS_LIST,

                                                      self.POWER_LEVELS_LIST[self._memobj.settings_vfo['vfo_'+chan.lower()].power])))

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

                                RadioSettingValueList(self.FHSS_LIST,

                                                      self.FHSS_LIST[self._memobj.settings_vfo['vfo_'+chan.lower()].fhss])))

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

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

                                                      ['Wide', 'Narrow'][self._memobj.settings_vfo['vfo_'+chan.lower()].narrow])))

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

                                RadioSettingValueList(self.TUNING_STEPS_LIST,

                                                      self.TUNING_STEPS_LIST[self._memobj.settings_vfo['vfo_'+chan.lower()].freqstep])))

        return ret

    def _get_custom_channel_names(self):

        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(self._memobj.custom_channel_names)):

            tmp = ''.join([ str(j) for j in self._memobj.custom_channel_names[i].name

                                   if ord(str(j)) < 0xFF and ord(str(j)) > 0x00])

            ret.append( RadioSetting( 'custom_channel_names@name@%i' % i,

                                      'Custom Channel Name (%i)' % i,

                                      RadioSettingValueString(0, 10, tmp, autopad=True,

                                                              charset=self.FULL_CHARSET_ASCII)))

        return ret

    def _get_custom_ani_names(self):

        ret = RadioSettingGroup('can', 'Custom ANI Names')

        msgs = [ "Can be used as radio id in GPS.",

                "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_caninames_msg_%i' % msgs.index(msg), 'Input rule %i' % int(msgs.index(msg)+1), rsvs)

            ret.append(rs)

        for i in range(0, len(self._memobj.custom_ani_names)):

            tmp = ''.join([ str(j) for j in self._memobj.custom_ani_names[i].name

                                   if ord(str(j)) < 0xFF and ord(str(j)) > 0x00])

            ret.append( RadioSetting( 'custom_ani_names@name@%i' % i,

                                      'Custom ANI Name (%i)' % (i+51),

                                      RadioSettingValueString(0, 10, tmp, autopad=True,