CHIRP

# Copyright 2023 Jim Unroe <rock.unroe@gmail.com>

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import logging

import struct

from chirp import (

    bitwise,

    chirp_common,

    directory,

    errors,

    memmap,

    util,

)

from chirp.settings import (

    RadioSetting,

    RadioSettingGroup,

    RadioSettings,

    RadioSettingValueBoolean,

    RadioSettingValueInteger,

    RadioSettingValueList,

    RadioSettingValueString,

)

LOG = logging.getLogger(__name__)

MEM_FORMAT = """

#seekto 0x0000;

struct {

  lbcd rxfreq[4];     // 0-3

  lbcd txfreq[4];     // 4-7

  ul16 rxtone;        // 8-9

  ul16 txtone;        // A-B

  u8 unknown1:4,      // C

     scode:4;         //     Signaling

  u8 unknown2:6,      // D

     pttid:2;         //     PTT-ID

  u8 unknown3:6,      // E

     txpower:2;       //     Power Level  0 = H, 1 = L, 2 = M

  u8 unknown4:1,      // F

     narrow:1,        //     Bandwidth  0 = Wide, 1 = Narrow

     encrypt:2,       //     Encrypt

     bcl:1,           //     BCL

     scan:1,          //     Scan  0 = Skip, 1 = Scan

     unknown5:1,      //

     learning:1;      //     Learning

  lbcd code[3];       // 0-2 Code

  u8 unknown6;        // 3

  char name[12];      // 4-F 12-character Alpha Tag

} memory[256];

#seekto 0x9000;

struct {

  u8 unused:4,        // 9000

     sql:4;           //      Squelch Level

  u8 unused_9001:6,   // 9001

     save:2;          //      Battery Save

  u8 unused_9002:4,   // 9002

     vox:4;           //      VOX Level

  u8 unused_9003:4,   // 9003

     abr:4;           //      Auto BackLight

  u8 unused_9004:7,   // 9004

     tdr:1;           //      TDR

  u8 unused:5,        // 9005

     tot:3;           //      Time-out Timer

  u8 unused_9006:7,   // 9006

     beep:1;          //      Beep

  u8 unused_9007:7,   // 9007

     voice:1;         //      Voice Prompt

  u8 unused_9008:7,   // 9008

     language:1;      //      Language

  u8 unused_9009:6,   // 9009

     dtmfst:2;        //      DTMF ST

  u8 unused_900a:6,   // 900A

     screv:2;         //      Scan Mode

  u8 unknown_900b;    // 900B

  u8 unused_900c:5,   // 900C

     pttlt:3;         //      PTT Delay

  u8 unused_900d:7,   // 900D

     mdfa:1;          //      Channel_A Display

  u8 unused_9003:7,   // 900E

     mdfb:1;          //      Channel_B Display

  u8 unknown_900f;    // 900F

  u8 unused_9010:4,   // 9010

     autolk:4;        //      Key Auto Lock

  u8 unused_9011:6,   // 9011

     almode:2;        //      Alarm Mode

  u8 unused_9012:7,   // 9012

     alarmsound:1;    //      Alarm Sound

  u8 unused_9013:6,   // 9013

     dualtx:2;        //      Dual TX

  u8 unused_9014:7,   // 9014

     ste:1;           //      Tail Noise Clear

  u8 unused_9015:4,   // 9015

     rpste:4;         //      RPT Noise Clear

  u8 unused_9016:4,   // 9016

     rptrl:4;         //      RPT Noise Delay

  u8 unused_9017:7,   // 9017

     roger:1;         //      Roger

  u8 unknown_9018;    // 9018

  u8 unused_9019:7,   // 9019

     fmradio:1;       //      FM Radio

  u8 unused_901a1:3,  // 901A

     vfomrb:1,        //      WorkMode B

     unused_901a2:3,  //

     vfomra:1;        //      WorkMode A

  u8 unused_901b:7,   // 901B

     kblock:1;        //      KB Lock

  u8 unused_901c:7,   // 901C

     ponmsg:1;        //      Power On Msg

  u8 unknown_901d;    // 901D

  u8 unused_901e:6,   // 901E

     tone:2;          //      Pilot

  u8 unknown_901f;    // 901F

  u8 unused_9020:4,   // 9020

     voxd:4;          //      VOX Delay

  u8 unused_9021:4,   // 9021

     menuquit:4;      //      Menu Auto Quit

  u8 unused_9022:7,   // 9022

     tailcode:1;      //      Tail Code (RT-470L)

  u8 unknown_9023;    // 9023

  u8 unknown_9024;    // 9024

  u8 unknown_9025;    // 9025

  u8 unknown_9026;    // 9026

  u8 unknown_9027;    // 9027

  u8 unknown_9028;    // 9028

  u8 unused_9029:6,   // 9029

     qtsave:2;        //      QT Save Type

  u8 ani;             // 902A ANI

  u8 skey2_sp;        // 902B Skey2 Short

  u8 skey2_lp;        // 902C Skey2 Long

  u8 skey3_sp;        // 902D Skey3 Short

  u8 topkey_sp;       // 902E Top Key (RT-470L)

  u8 unused_902f:7,   // 902F

     rxendtail:1;     //      Tone Rx End

  u8 skey3_lp;        // 9030 Skey3 Long (RT-470L)

} settings;

#seekto 0xA020;

struct {

  u8 code[5];         //      5-character DTMF Encoder Groups

  u8 unused[11];

} pttid[15];

#seekto 0xA006;

struct {

  u8 unused_a006:4,   // A006

     pttid:4;         //      PTT-ID

  u8 unused_a007:5,   // A007

     dtmfon:3;        //      DTMF Speed (on time)

  u8 unused_a008:5,   // A008

     dtmfoff:3;       //      DTMF Speed (off time)

} dtmf;

#seekto 0xB000;

struct {

  u8 code[3];         //      3-character ANI Code Groups

} anicodes[60];

#seekto 0xB0C0;

struct {

  char name[6];       //      6-character ANI Code Group Names

  u8 unused[10];

} aninames[30];

"""

CMD_ACK = b"\x06"

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

DTMF_CHARS = "0123456789 *#ABCD"

TXPOWER_HIGH = 0x00

TXPOWER_LOW = 0x01

TXPOWER_MID = 0x02

ABR_LIST = ["On", "5 seconds", "10 seconds", "15 seconds", "20 seconds",

            "30 seconds", "1 minute", "2 minutes", "3 minutes"]

ALMODE_LIST = ["Site", "Tone", "Code"]

AUTOLK_LIST = ABR_LIST[:4]

DTMFSPEED_LIST = ["50 ms", "100 ms", "200 ms", "300 ms", "500 ms"]

DTMFST_LIST = ["Off", "KeyBoard Side Tone", "ANI Side Tone", "KB ST + ANI ST"]

DUALTX_LIST = ["Off", "A", "B"]

ENCRYPT_LIST = ["Off", "DCP1", "DCP2", "DCP3"]

LANGUAGE_LIST = ["English", "Chinese"]

MDF_LIST = ["Name", "Frequency"]

MENUQUIT_LIST = ["%s seconds" % x for x in range(5, 55, 5)] + ["60 seconds"]

OFF1TO9_LIST = ["Off"] + ["%s" % x for x in range(1, 10)]

PONMSG_LIST = ["Logo", "Voltage"]

PTTID_LIST = ["Off", "BOT", "EOT", "Both"]

PTTIDCODE_LIST = ["%s" % x for x in range(1, 16)]

PTTLT_LIST = ["None", "100 seconds"] + \

             ["%s seconds" % x for x in range(200, 1200, 200)]

QTSAVE_LIST = ["All", "RX", "TX"]

RPSTE_LIST = ["Off"] + ["%s ms" % x for x in range(100, 1100, 100)]

SAVE_LIST = ["Off", "Normal", "Super", "Deep"]

SCREV_LIST = ["Time (TO)", "Carrier (CO)", "Search (SE)"]

TAILCODE_LIST = ["55 Hz", "62.5 Hz"]

TONERXEND_LIST = ["Off", "MDC-1200"]

TONE_LIST = ["1000 Hz", "1450 Hz", "1750 Hz", "2100 Hz"]

TOT_LIST = ["Off", "30 seconds", "60 seconds", "120 seconds", "240 seconds",

            "480 seconds"]

VOXD_LIST = ["%s seconds" % str(x / 10) for x in range(5, 21)]

WORKMODE_LIST = ["VFO Mode", "Channel Mode"]

ALL_SKEY_CHOICES = ["OFF",

                    "FM Radio",

                    "TX Power Level",

                    "Scan",

                    "Search",

                    "Flashlight",

                    "NOAA Weather",

                    "Monitor",

                    "PTT B",

                    "SOS"]

ALL_SKEY_VALUES = [0xFF,

                   0x07,

                   0x0A,

                   0x1C,

                   0x1D,

                   0x08,

                   0x0C,

                   0x05,

                   0x01,

                   0x03]

SETTING_LISTS = {

    "abr": ABR_LIST,

    "almod": ALMODE_LIST,

    "autolk": AUTOLK_LIST,

    "dtmfoff": DTMFSPEED_LIST,

    "dtmfon": DTMFSPEED_LIST,

    "dtmfst": DTMFST_LIST,

    "dualtx": DUALTX_LIST,

    "encrypt": ENCRYPT_LIST,

    "language": LANGUAGE_LIST,

    "mdfa": MDF_LIST,

    "mdfb": MDF_LIST,

    "menuquit": MENUQUIT_LIST,

    "ponmsg": PONMSG_LIST,

    "pttid": PTTID_LIST,

    "pttlt": PTTLT_LIST,

    "qtsave": QTSAVE_LIST,

    "rpste": RPSTE_LIST,

    "rptrl": RPSTE_LIST,

    "rxendtail": TONERXEND_LIST,

    "save": SAVE_LIST,

    "scode": PTTIDCODE_LIST,

    "screv": SCREV_LIST,

    "tailcode": TAILCODE_LIST,

    "tone": TONE_LIST,

    "tot": TOT_LIST,

    "vox": OFF1TO9_LIST,

    "voxd": VOXD_LIST,

    "workmode": WORKMODE_LIST

    }

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 ident not in radio._fingerprint:

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

            status.cur = addr + radio.BLOCK_SIZE_UP

            radio.status_fn(status)

            _write_block(radio, addr, radio.BLOCK_SIZE_UP)

    _exit_programming_mode(radio)

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

class JC8810base(chirp_common.CloneModeRadio):

    """MML JC-8810"""

    VENDOR = "MML"

    MODEL = "JC-8810base"

    BAUD_RATE = 57600

    NEEDS_COMPAT_SERIAL = False

    BLOCK_SIZE = 0x40

    BLOCK_SIZE_UP = 0x40

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

                    chirp_common.PowerLevel("M", watts=8.00),

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

    VALID_BANDS = [(108000000, 136000000),

                   (136000000, 180000000),

                   (200000000, 260000000),

                   (330000000, 400000000),

                   (400000000, 520000000)]

    _magic = b"PROGRAMJC81U"

    _fingerprint = [b"\x00\x00\x00\x26\x00\x20\xD8\x04",

                    b"\x00\x00\x00\x42\x00\x20\xF0\x04"]

    _ranges = [

               (0x0000, 0x2000),

               (0x8000, 0x8040),

               (0x9000, 0x9040),

               (0xA000, 0xA140),

               (0xB000, 0xB300)

              ]

    _memsize = 0xB300

    _valid_chars = chirp_common.CHARSET_ALPHANUMERIC + \

        "`~!@#$%^&*()-=_+[]\\{}|;':\",./<>?"

    def get_features(self):

        rf = chirp_common.RadioFeatures()

        rf.has_settings = True

        rf.has_bank = False

        rf.has_ctone = True

        rf.has_cross = True

        rf.has_rx_dtcs = True

        rf.has_tuning_step = False

        rf.can_odd_split = True

        rf.has_name = True

        rf.valid_name_length = 12

        rf.valid_characters = self._valid_chars

        rf.valid_skips = ["", "S"]

        rf.valid_tmodes = ["", "Tone", "TSQL", "DTCS", "Cross"]

        rf.valid_cross_modes = ["Tone->Tone", "Tone->DTCS", "DTCS->Tone",

                                "->Tone", "->DTCS", "DTCS->", "DTCS->DTCS"]

        rf.valid_power_levels = self.POWER_LEVELS

        rf.valid_duplexes = ["", "-", "+", "split", "off"]

        rf.valid_modes = ["FM", "NFM"]  # 25 kHz, 12.5 KHz.

        rf.valid_dtcs_codes = DTCS

        rf.memory_bounds = (1, 256)

        rf.valid_tuning_steps = [2.5, 5., 6.25, 10., 12.5, 20., 25., 50.]

        rf.valid_bands = self.VALID_BANDS

        return rf

    def process_mmap(self):

        self._memobj = bitwise.parse(MEM_FORMAT, self._mmap)

    def sync_in(self):

        """Download from radio"""

        try:

            data = do_download(self)

        except errors.RadioError:

            # Pass through any real errors we raise

            raise

        except Exception:

            # 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 = data

        self.process_mmap()

    def sync_out(self):

        """Upload to radio"""

        try:

            do_upload(self)

        except Exception:

            # 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 _is_txinh(self, _mem):

        raw_tx = ""

        for i in range(0, 4):

            raw_tx += _mem.txfreq[i].get_raw()

        return raw_tx == "\xFF\xFF\xFF\xFF"

    def get_memory(self, number):

        """Get the mem representation from the radio image"""

        _mem = self._memobj.memory[number - 1]

        # Create a high-level memory object to return to the UI

        mem = chirp_common.Memory()

        # Memory number

        mem.number = number

        if _mem.get_raw()[0] == "\xff":

            mem.empty = True

            return mem

        # Freq and offset

        mem.freq = int(_mem.rxfreq) * 10

        # tx freq can be blank

        if _mem.get_raw()[4] == "\xFF":

            # TX freq not set

            mem.offset = 0

            mem.duplex = "off"

        else:

            # TX freq set

            offset = (int(_mem.txfreq) * 10) - mem.freq

            if offset != 0:

                if _split(self.get_features(), mem.freq, int(

                          _mem.txfreq) * 10):

                    mem.duplex = "split"

                    mem.offset = int(_mem.txfreq) * 10

                elif offset < 0:

                    mem.offset = abs(offset)

                    mem.duplex = "-"

                elif offset > 0:

                    mem.offset = offset

                    mem.duplex = "+"

            else:

                mem.offset = 0

        for char in _mem.name:

            if str(char) == "\xFF":

                char = " "  # may have 0xFF mid-name

            mem.name += str(char)

        mem.name = mem.name.rstrip()

        dtcs_pol = ["N", "N"]

        if _mem.txtone in [0, 0xFFFF]:

            txmode = ""

        elif _mem.txtone >= 0x0258:

            txmode = "Tone"

            mem.rtone = int(_mem.txtone) / 10.0

        elif _mem.txtone <= 0x0258:

            txmode = "DTCS"

            if _mem.txtone > 0x69:

                index = _mem.txtone - 0x6A

                dtcs_pol[0] = "R"

            else:

                index = _mem.txtone - 1

            mem.dtcs = DTCS[index]

        else:

            LOG.warn("Bug: txtone is %04x" % _mem.txtone)

        if _mem.rxtone in [0, 0xFFFF]:

            rxmode = ""

        elif _mem.rxtone >= 0x0258:

            rxmode = "Tone"

            mem.ctone = int(_mem.rxtone) / 10.0

        elif _mem.rxtone <= 0x0258:

            rxmode = "DTCS"

            if _mem.rxtone >= 0x6A:

                index = _mem.rxtone - 0x6A

                dtcs_pol[1] = "R"

            else:

                index = _mem.rxtone - 1

            mem.rx_dtcs = DTCS[index]

        else:

            LOG.warn("Bug: rxtone is %04x" % _mem.rxtone)

        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)

        if not _mem.scan:

            mem.skip = "S"

        _levels = self.POWER_LEVELS

        if _mem.txpower == TXPOWER_HIGH:

            mem.power = _levels[0]

        elif _mem.txpower == TXPOWER_MID:

            mem.power = _levels[1]

        elif _mem.txpower == TXPOWER_LOW:

            mem.power = _levels[2]

        else:

            LOG.error('%s: get_mem: unhandled power level: 0x%02x' %

                      (mem.name, _mem.txpower))

        mem.mode = _mem.narrow and "NFM" or "FM"

        mem.extra = RadioSettingGroup("Extra", "extra")

        # BCL (Busy Channel Lockout)

        rs = RadioSettingValueBoolean(_mem.bcl)

        rset = RadioSetting("bcl", "BCL", rs)

        mem.extra.append(rset)

        # PTT-ID

        rs = RadioSettingValueList(PTTID_LIST, PTTID_LIST[_mem.pttid])

        rset = RadioSetting("pttid", "PTT ID", rs)

        mem.extra.append(rset)

        # Signal (DTMF Encoder Group #)

        rs = RadioSettingValueList(PTTIDCODE_LIST, PTTIDCODE_LIST[_mem.scode])

        rset = RadioSetting("scode", "PTT ID Code", rs)

        mem.extra.append(rset)

        return mem

    def set_memory(self, mem):

        _mem = self._memobj.memory[mem.number - 1]

        if mem.empty:

            _mem.set_raw("\xff" * 32)

            return

        _mem.set_raw("\x00" * 16 + "\xFF" * 16)

        _mem.rxfreq = mem.freq / 10

        if mem.duplex == "off":

            for i in range(0, 4):

                _mem.txfreq[i].set_raw("\xFF")

        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

        _namelength = self.get_features().valid_name_length

        for i in range(_namelength):

            try:

                _mem.name[i] = mem.name[i]

            except IndexError:

                _mem.name[i] = "\xFF"

        rxmode = txmode = ""

        if mem.tmode == "Tone":

            _mem.txtone = int(mem.rtone * 10)

            _mem.rxtone = 0

        elif mem.tmode == "TSQL":

            _mem.txtone = int(mem.ctone * 10)

            _mem.rxtone = int(mem.ctone * 10)

        elif mem.tmode == "DTCS":

            rxmode = txmode = "DTCS"

            _mem.txtone = DTCS.index(mem.dtcs) + 1

            _mem.rxtone = DTCS.index(mem.dtcs) + 1

        elif mem.tmode == "Cross":

            txmode, rxmode = mem.cross_mode.split("->", 1)

            if txmode == "Tone":

                _mem.txtone = int(mem.rtone * 10)

            elif txmode == "DTCS":

                _mem.txtone = DTCS.index(mem.dtcs) + 1

            else:

                _mem.txtone = 0

            if rxmode == "Tone":

                _mem.rxtone = int(mem.ctone * 10)

            elif rxmode == "DTCS":

                _mem.rxtone = DTCS.index(mem.rx_dtcs) + 1

            else:

                _mem.rxtone = 0

        else:

            _mem.rxtone = 0

            _mem.txtone = 0

        if txmode == "DTCS" and mem.dtcs_polarity[0] == "R":

            _mem.txtone += 0x69

        if rxmode == "DTCS" and mem.dtcs_polarity[1] == "R":

            _mem.rxtone += 0x69

        _mem.scan = mem.skip != "S"

        _mem.narrow = mem.mode == "NFM"

        _levels = self.POWER_LEVELS

        if mem.power is None:

            _mem.txpower = TXPOWER_HIGH

        elif mem.power == _levels[0]:

            _mem.txpower = TXPOWER_HIGH

        elif mem.power == _levels[1]:

            _mem.txpower = TXPOWER_MID

        elif mem.power == _levels[2]:

            _mem.txpower = TXPOWER_LOW

        else:

            LOG.error('%s: set_mem: unhandled power level: %s' %

                      (mem.name, mem.power))

        for setting in mem.extra:

            if setting.get_name() == "scramble_type":

                setattr(_mem, setting.get_name(), int(setting.value) + 8)

                setattr(_mem, "scramble_type2", int(setting.value) + 8)

            else:

                setattr(_mem, setting.get_name(), setting.value)

    def get_settings(self):

        _dtmf = self._memobj.dtmf

        _settings = self._memobj.settings

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

        group = RadioSettings(basic)

        # Menu 12: TOT

        rs = RadioSettingValueList(TOT_LIST, TOT_LIST[_settings.tot])

        rset = RadioSetting("tot", "Time Out Timer", rs)

        basic.append(rset)

        # Menu 00: SQL

        rs = RadioSettingValueInteger(0, 9, _settings.sql)

        rset = RadioSetting("sql", "Squelch Level", rs)

        basic.append(rset)

        # Menu 13: VOX

        rs = RadioSettingValueList(OFF1TO9_LIST, OFF1TO9_LIST[_settings.vox])

        rset = RadioSetting("vox", "VOX", rs)

        basic.append(rset)

        # Menu 39: VOX DELAY

        rs = RadioSettingValueList(VOXD_LIST, VOXD_LIST[_settings.voxd])

        rset = RadioSetting("voxd", "VOX Delay", rs)

        basic.append(rset)

        # Menu 15: VOICE

        rs = RadioSettingValueBoolean(_settings.voice)

        rset = RadioSetting("voice", "Voice Prompts", rs)

        basic.append(rset)

        # Menu 17: LANGUAGE

        rs = RadioSettingValueList(LANGUAGE_LIST,

                                   LANGUAGE_LIST[_settings.language])

        rset = RadioSetting("language", "Voice", rs)

        basic.append(rset)

        # Menu 23: ABR

        rs = RadioSettingValueList(ABR_LIST, ABR_LIST[_settings.abr])

        rset = RadioSetting("abr", "Auto BackLight", rs)

        basic.append(rset)

        # Work Mode A

        rs = RadioSettingValueList(WORKMODE_LIST,

                                   WORKMODE_LIST[_settings.vfomra])

        rset = RadioSetting("vfomra", "Work Mode A", rs)

        basic.append(rset)

        # Work Mode B

        rs = RadioSettingValueList(WORKMODE_LIST,

                                   WORKMODE_LIST[_settings.vfomrb])

        rset = RadioSetting("vfomrb", "Work Mode B", rs)

        basic.append(rset)

        # Menu 19: SC-REV

        rs = RadioSettingValueList(SCREV_LIST, SCREV_LIST[_settings.screv])

        rset = RadioSetting("screv", "Scan Resume Method", rs)

        basic.append(rset)

        # Menu 10: SAVE

        rs = RadioSettingValueList(SAVE_LIST,

                                   SAVE_LIST[_settings.save])

        rset = RadioSetting("save", "Battery Save Mode", rs)

        basic.append(rset)

        # Menu 42: MDF-A

        rs = RadioSettingValueList(MDF_LIST, MDF_LIST[_settings.mdfa])

        rset = RadioSetting("mdfa", "Memory Display Format A", rs)

        basic.append(rset)

        # Menu 43: MDF-B

        rs = RadioSettingValueList(MDF_LIST, MDF_LIST[_settings.mdfb])

        rset = RadioSetting("mdfb", "Memory Display Format B", rs)

        basic.append(rset)

        # Menu 33: DTMFST (DTMF ST)

        rs = RadioSettingValueList(DTMFST_LIST, DTMFST_LIST[_settings.dtmfst])

        rset = RadioSetting("dtmfst", "DTMF Side Tone", rs)

        basic.append(rset)

        # Menu 37: PTT-LT

        rs = RadioSettingValueList(PTTLT_LIST, PTTLT_LIST[_settings.pttlt])

        rset = RadioSetting("pttlt", "PTT Delay", rs)

        basic.append(rset)

        rs = RadioSettingValueInteger(1, 60, _settings.ani + 1)

        rset = RadioSetting("ani", "ANI", rs)

        basic.append(rset)

        def apply_skey_listvalue(setting, obj):

            LOG.debug("Setting value: " + str(setting.value) + " from list")

            val = str(setting.value)

            index = SKEY_CHOICES.index(val)

            val = SKEY_VALUES[index]

            obj.set_value(val)

        # Menu 20: PF2

        if self.MODEL in ["RT-470"]:

            unwanted = [0, 7, 9]

        elif self.MODEL in ["RT-470L"]:

            unwanted = [9]

        else:

            unwanted = []

        SKEY_CHOICES = ALL_SKEY_CHOICES.copy()

        SKEY_VALUES = ALL_SKEY_VALUES.copy()

        for ele in sorted(unwanted, reverse=True):

            del SKEY_CHOICES[ele]

            del SKEY_VALUES[ele]

        if _settings.skey2_sp in SKEY_VALUES:

            idx = SKEY_VALUES.index(_settings.skey2_sp)

        else:

            idx = SKEY_VALUES.index(0x07)  # default FM

        rs = RadioSettingValueList(SKEY_CHOICES, SKEY_CHOICES[idx])

        rset = RadioSetting("skey2_sp", "PF2 Key (Short Press)", rs)

        rset.set_apply_callback(apply_skey_listvalue, _settings.skey2_sp)