CHIRP

# Copyright 2011 Dan Smith <dsmith@danplanet.com>

# --        2019 Rick DeWitt <aa0rd@yahoo.com>

# -- Implementing Kenwood TM-D710G as MCP Clone Mode for Python 2.7

# -- Thanks to Herm Halbach, W7HRM, for the 710 model testing.

# 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 3 of the License, or

# (at your option) any later version.

#

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

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

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

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

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

import time

import struct

import logging

import re

import math

from chirp import chirp_common, directory, memmap

from chirp import bitwise, errors, util

from chirp.settings import RadioSettingGroup, RadioSetting, \

    RadioSettingValueBoolean, RadioSettingValueList, \

    RadioSettingValueString, RadioSettingValueInteger, \

    RadioSettingValueFloat, RadioSettings, InvalidValueError

from textwrap import dedent

from chirp.drivers import kenwood_live

LOG = logging.getLogger(__name__)

HAS_FUTURE = True

try:                         # PY3 compliance

    from builtins import bytes

except ImportError:

    HAS_FUTURE = False

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

              'available; %s requires it' % __name__)

BAUD = 0

STIMEOUT = 0.2

TERM = b'\x0d'         # Cmd write terminator (CR)

ACK = b'\x06'           # Data write acknowledge char

W8S = 0.001      # short wait, secs

W8L = 0.1       # long wait

TMD710_DUPLEX = ["", "+", "-", "n/a", "split"]

TMD710_SKIP = ["", "S"]

TMD710_MODES = ["FM", "NFM", "AM"]

TMD710_BANDS = [(118000000, 135995000),

                (136000000, 199995000),

                (200000000, 299995000),

                (300000000, 399995000),

                (400000000, 523995000),

                (800000000, 1299995000)]

TMD710_STEPS = [5.0, 6.25, 8.33, 10.0, 12.5, 15.0, 20.0, 25.0,

                30.0, 50.0, 100.0]

# Need string list of those steps for mem.extra value list

STEPS_STR = []

for val in TMD710_STEPS:

    STEPS_STR.append("%3.2f" % val)

TMD710_TONE_MODES = ["", "Tone", "TSQL", "DTCS", "Cross"]

TMD710_CROSS = ["Tone->Tone", "Tone->DTCS", "DTCS->Tone"]

TMD710_DTSC = list(chirp_common.DTCS_CODES)

TMD710_TONES = list(chirp_common.TONES)

TMD710_TONES.remove(159.8)

TMD710_TONES.remove(165.5)

TMD710_TONES.remove(171.3)

TMD710_TONES.remove(177.3)

TMD710_TONES.remove(183.5)

TMD710_TONES.remove(189.9)

TMD710_TONES.remove(196.6)

TMD710_TONES.remove(199.5)

TMD710_CHARS = chirp_common.CHARSET_ASCII

TMD710_CHARS += chr(34)     # "

def _command(ser, cmd, rsplen, w8t=0.01):

    """Send cmd to radio via ser port

    cmd is output string with possible terminator

    rsplen is expected response char count, NOT incl prefix and term

    If rsplen = 0 then do not0 read after write """

    ser.write(cmd)

    LOG.debug(" Out %4i ->: %s" % (len(cmd), util.hexprint(cmd[0: 32])))

    time.sleep(w8t)

    result = b""

    if rsplen > 0:  # read response

        result = ser.read(rsplen)

        LOG.debug(" In %4i <-: %s" % (len(result),

                                      util.hexprint(result[0: 32])))

    return result

def _connect_radio(radio):

    """Determine baud rate and verify radio on-line"""

    global BAUD

    xid = "D710" + radio.SHORT

    resp = kenwood_live.get_id(radio.pipe)

    BAUD = radio.pipe.baudrate      # As detected by kenwood_live

    LOG.debug("Got [%s] at %i Baud." % (resp, BAUD))

    resp = resp[3:]     # Strip "ID " prefix

    if len(resp) > 2:   # Got something from "ID"

        if resp == xid:     # Good comms

            return

        else:

            stx = "Radio responded as %s, not %s." % (resp, xid)

            raise errors.RadioError(stx)

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

def _update_status(self, status, step=1):

    """ Increment status bar """

    status.cur += step

    self.status_fn(status)

    return

def _val_list(setting, opts, obj, atrb, fix=0, ndx=-1):

    """Callback:from ValueList. Set the integer index.

    This function is here to be available to get_mem and get_set

    fix is optional additive offset to the list index

    ndx is optional obj[ndx] array index """

    value = opts.index(str(setting.value))

    value += fix

    if ndx >= 0:    # indexed obj

        setattr(obj[ndx], atrb, value)

    else:

        setattr(obj, atrb, value)

    return

class KenwoodTMx710Radio(chirp_common.CloneModeRadio):

    """ Base class for TMD-710 """

    VENDOR = "Kenwood"

    MODEL = "TM-x710"

    SHORT = "X"       # Short model ID code

    NEEDS_COMPAT_SERIAL = False

    _upper = 999         # Number of normal chans

    # Put Special memory channels after normal ones

    SPECIAL_MEMORIES = {"Scan-0Lo": 1000, "Scan-0Hi": 1001,

                        "Scan-1Lo": 1002, "Scan-1Hi": 1003,

                        "Scan-2Lo": 1004, "Scan-2Hi": 1005,

                        "Scan-3Lo": 1006, "Scan-3Hi": 1007,

                        "Scan-4Lo": 1008, "Scan-4Hi": 1009,

                        "Scan-5Lo": 1010, "Scan-5Hi": 1011,

                        "Scan-6Lo": 1012, "Scan-6Hi": 1013,

                        "Scan-7Lo": 1014, "Scan-7Hi": 1015,

                        "Scan-8Lo": 1016, "Scan-8Hi": 1017,

                        "Scan-9Lo": 1018, "Scan-9Hi": 1019,

                        "WX-1": 1020, "WX-2": 1021,

                        "WX-3": 1022, "WX-4": 1023,

                        "WX-5": 1024, "WX-6": 1025,

                        "WX-7": 1026, "WX-8": 1027,

                        "WX-9": 1028, "WX-10": 1029,

                        "Call C0": 1030, "Call C1": 1031

                        }

    # _REV dict is used to retrieve name given number

    SPECIAL_MEMORIES_REV = dict(zip(SPECIAL_MEMORIES.values(),

                                    SPECIAL_MEMORIES.keys()))

    def get_features(self):

        rf = chirp_common.RadioFeatures()

        rf.can_odd_split = True

        rf.has_dtcs = True

        rf.has_dtcs_polarity = False

        if self.SHORT == "G":             # NOT for D710

            rf.has_rx_dtcs = True       # Enable DTCS Rx Code column

            rf.has_cross = True

            rf.valid_cross_modes = TMD710_CROSS

        rf.has_bank = False

        rf.has_settings = True

        rf.has_ctone = True

        rf.has_mode = True

        rf.has_comment = False

        rf.valid_tmodes = TMD710_TONE_MODES

        rf.valid_modes = TMD710_MODES

        rf.valid_duplexes = TMD710_DUPLEX

        rf.valid_tuning_steps = TMD710_STEPS

        rf.valid_tones = TMD710_TONES

        rf.valid_dtcs_codes = TMD710_DTSC

        # Supports upper and lower case text

        rf.valid_characters = TMD710_CHARS

        rf.valid_name_length = 8

        rf.valid_skips = TMD710_SKIP

        rf.valid_bands = TMD710_BANDS

        rf.memory_bounds = (0, 999)        # including special chans 1000-1029

        rf.valid_special_chans = sorted(self.SPECIAL_MEMORIES.keys())

        return rf

    @classmethod

    def get_prompts(cls):

        rp = chirp_common.RadioPrompts()

        rp.pre_download = _(dedent("""\

            Connect your interface cable to the PC Port on the

            back of the 'TX/RX' unit. NOT the Com Port on the head.

            """))

        rp.pre_upload = _(dedent("""\

            Connect your interface cable to the PC Port on the

            back of the 'TX/RX' unit. NOT the Com Port on the head.

            """))

        return rp

    def sync_in(self):

        """Download from radio"""

        try:

            _connect_radio(self)

            data = bytes(self._read_mem())

        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 = memmap.MemoryMapBytes(data)

        self.process_mmap()

    def sync_out(self):

        """Upload to radio"""

        try:

            _connect_radio(self)

            self._write_mem()

        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 process_mmap(self):

        """Process the mem map into the mem object"""

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

    def get_memory(self, number):

        """Convert raw channel data (_mem) into UI columns (mem)"""

        mem = chirp_common.Memory()

        if self.SHORT == "G":

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

        # If called from 'Properties', spcl chans number is integer

        propflg = False

        if isinstance(number, int):

            if number > 999:

                propflg = True

        if isinstance(number, str) or propflg:

            if propflg:

                mem.number = number

                mem.name = self.SPECIAL_MEMORIES_REV[number]

                mem.extd_number = mem.name

            else:

                mem.name = number   # Spcl chns 1st var

                mem.number = self.SPECIAL_MEMORIES[number]

                mem.extd_number = number    # Uses name as LOC

                mem.immutable = ["name"]

            if mem.number < 1030:       # Scan edges, WX

                _mem = self._memobj.ch_mem[mem.number]

                _map = self._memobj.chmap[mem.number]

            else:                       # Call chans

                _mem = self._memobj.call[mem.number - 1030]

        else:       # Normal mem chans

            _mem = self._memobj.ch_mem[number]

            _nam = self._memobj.ch_nam[number]

            _map = self._memobj.chmap[number]

            mem.number = number

            mnx = ""

            for char in _nam.name:

                if int(char) < 127:

                    mnx += chr(int(char))

            mem.name = mnx.rstrip()

        if _mem.rxfreq == 0x0ffffffff or _mem.rxfreq == 0:

            mem.empty = True

            return mem

        mem.empty = False

        if mem.number < 1030 and _map.skip != 0x0ff:      # empty

            mem.skip = TMD710_SKIP[_map.skip]

        mem.freq = int(_mem.rxfreq)

        mem.duplex = TMD710_DUPLEX[_mem.duplex]

        mem.offset = int(_mem.offset)

        # Duplex = 4 (split); offset contains the TX freq

        mem.mode = TMD710_MODES[_mem.mode]

        # _mem.tmode is 4-bit pattern, not number

        mx = 0      # No tone

        mem.cross_mode = TMD710_CROSS[0]

        mem.rx_dtcs = TMD710_DTSC[_mem.dtcs]

        mem.dtcs = TMD710_DTSC[_mem.dtcs]

        if self.SHORT == "G":

            if _mem.tmode & 8:     # Tone

                mx = 1

            if _mem.tmode & 4:     # Tsql

                mx = 2

            if _mem.tmode & 2:     # Dtcs

                mx = 3

            if _mem.tmode & 1:     # Cross

                mx = 4

                if _mem.cross == 1:     # Tone->DTCS

                    mem.cross_mode = TMD710_CROSS[1]

                if _mem.cross == 2:     # DTCS->Tone

                    mem.cross_mode = TMD710_CROSS[2]

        else:           # D710; may have bit 8 set

            if _mem.tmode & 4:     # Tone

                mx = 1

            if _mem.tmode & 2:     # Tsql

                mx = 2

            if _mem.tmode & 1:     # Dtcs

                mx = 3

                mem.dtcs = TMD710_DTSC[_mem.dtcs]

        mem.tmode = TMD710_TONE_MODES[mx]

        mem.ctone = TMD710_TONES[_mem.ctone]

        mem.rtone = TMD710_TONES[_mem.rtone]

        mem.tuning_step = TMD710_STEPS[_mem.tstep]

        if self.SHORT == "G":         # Only the 710G

            rx = RadioSettingValueList(STEPS_STR, STEPS_STR[_mem.splitstep])

            sx = "Split TX step (KHz)"

            rset = RadioSetting("splitstep", sx, rx)

            mem.extra.append(rset)

        return mem

    def set_memory(self, mem):

        """Convert UI column data (mem) into MEM_FORMAT memory (_mem)"""

        if mem.number > 999:      # Special chans

            if mem.number < 1030:        # Scan, Wx

                _mem = self._memobj.ch_mem[mem.number]

                _map = self._memobj.chmap[mem.number]

            else:                        # Call chans

                _mem = self._memobj.call[mem.number - 1030]

            _nam = None

        else:

            _mem = self._memobj.ch_mem[mem.number]

            _nam = self._memobj.ch_nam[mem.number]

            _map = self._memobj.chmap[mem.number]

            nx = len(mem.name)

            for ix in range(8):

                if ix < nx:

                    _nam.name[ix] = mem.name[ix]

                else:

                    _nam.name[ix] = chr(0x0ff)    # needs 8 chrs

        if mem.empty:

            _mem.rxfreq = 0x0ffffffff

            _mem.offset = 0x0ffffff

            _mem.duplex = 0x0f

            _mem.tstep = 0x0ff

            _mem.tmode = 0x0f

            _mem.mode = 0x0ff

            _mem.rtone = 0x0ff

            _mem.ctone = 0x0ff

            _mem.dtcs = 0x0ff

            _map.skip = 0x0ff

            _map.band = 0x0ff

            if _nam:

                for ix in range(8):

                    _nam.name[ix] = chr(0x0ff)

            return

        if _mem.rxfreq == 0x0ffffffff:    # New Channel needs defaults

            _mem.rxfreq = 144000000

            _map.band = 5

            _map.skip = 0

            _mem.mode = 0

            _mem.duplex = 0

            _mem.offset = 0

            _mem.rtone = 8

            _mem.ctone = 8

            _mem.dtcs = 0

            _mem.tstep = 0

            _mem.splitstep = 0

        # Now use the UI values entered so far

        _mem.rxfreq = mem.freq

        _mem.mode = TMD710_MODES.index(mem.mode)

        try:

            _tone = mem.rtone

            _mem.rtone = TMD710_TONES.index(mem.rtone)

            _tone = mem.ctone

            _mem.ctone = TMD710_TONES.index(mem.ctone)

        except ValueError:

            raise errors.UnsupportedToneError("This radio does not support " +

                                              "tone %.1fHz" % _tone)

        _mem.dtcs = TMD710_DTSC.index(mem.dtcs)

        _mem.tmode = 0      # None

        _mem.cross = 0

        if self.SHORT == "G":

            if mem.tmode == "Tone":

                _mem.tmode = 8

            if mem.tmode == "TSQL":

                _mem.tmode = 4

            if mem.tmode == "DTCS":

                _mem.tmode = 2

            if mem.tmode == "Cross":

                _mem.tmode = 1

                mx = TMD710_CROSS.index(mem.cross_mode)

                _mem.cross = 3          # t -t

                if mx == 1:

                    _mem.cross = 1      # t-d

                    _mem.dtcs = TMD710_DTSC.index(mem.rx_dtcs)

                if mx == 2:

                    _mem.cross = 2      # d-t

                    _mem.dtcs = TMD710_DTSC.index(mem.dtcs)

        else:

            _mem.tmode = 0x80       # None

            if mem.tmode == "Tone":

                _mem.tmode = 0x0c

            if mem.tmode == "TSQL":

                _mem.tmode = 0x0a

            if mem.tmode == "DTCS":

                _mem.tmode = 0x09

        if mem.duplex == "n/a":     # Not valid

            mem.duplex = ""

        _mem.duplex = TMD710_DUPLEX.index(mem.duplex)

        _mem.offset = mem.offset

        _mem.tstep = TMD710_STEPS.index(mem.tuning_step)

        # Set _map.band for this bank. Not Calls!

        if mem.number < 1030:

            _map.band = 5

            val = mem.freq

            for mx in range(6):     # Band codes are 0, 5, 6, 7, 8, 9

                if val >= TMD710_BANDS[mx][0] and \

                        val <= TMD710_BANDS[mx][1]:

                    _map.band = mx

                    if mx > 0:

                        _map.band = mx + 4

            _map.skip = TMD710_SKIP.index(mem.skip)

        # Only 1 mem.extra entry now

        for ext in mem.extra:

            if ext.get_name() == "splitstep":

                val = STEPS_STR.index(str(ext.value))

                setattr(_mem, "splitstep", val)

            else:

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

        return

    def get_settings(self):

        """Translate the MEM_FORMAT structs into settings in the UI"""

        # Define mem struct write-back shortcuts

        if self.SHORT == "G":

            _bmp = self._memobj.bitmap

        _blk1 = self._memobj.block1

        _blk1a = self._memobj.block1a

        _pmg = self._memobj.pmg     # array[6] of settings

        _dtmc = self._memobj.dtmc

        _dtmn = self._memobj.dtmn

        _com = self._memobj.mcpcom

        _skyc = self._memobj.skycmd

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

        disp = RadioSettingGroup("disp", "PM0: Display")    # PM[0] settings

        aud = RadioSettingGroup("aud", "PM0: Audio")

        aux = RadioSettingGroup("aux", "PM0: Aux")

        txrx = RadioSettingGroup("txrc", "PM0: Transmit/Receive")

        memz = RadioSettingGroup("memz", "PM0: Memory")

        pfk = RadioSettingGroup("pfk", "PM0: PF Keys")

        pvfo = RadioSettingGroup("pvfo", "PM0: Programmable VFO")

        bmsk = RadioSettingGroup("bmsk", "PM0: Band Masks")    # end PM[0]

        rptr = RadioSettingGroup("rptr", "Repeater")

        dtmf = RadioSettingGroup("dtmf", "DTMF")

        skyk = RadioSettingGroup("skyk", "Sky Command")

        pmm = RadioSettingGroup("pmm", "PM Groups 1-5(Partial)")

        group = RadioSettings(basic, disp, aud, aux, txrx, memz, pvfo, pfk,

                              bmsk, rptr, dtmf, skyk, pmm)

        mhz1 = 1000000.   # Raw freq is stored with 0.1 Htz resolution

        def _adjraw(setting, obj, atrb, fix=0, ndx=-1):

            """Callback for Integer add or subtract fix from value."""

            vx = int(str(setting.value))

            value = vx + int(fix)

            if value < 0:

                value = 0

            if ndx < 0:

                setattr(obj, atrb, value)

            else:

                setattr(obj[ndx], atrb, value)

            return

        def _mhz_val(setting, obj, atrb, ndx=-1, ndy=-1):

            """ Callback to set freq back to Htz """

            vx = float(str(setting.value))

            vx = int(vx * mhz1)

            if ndx < 0:

                setattr(obj, atrb, vx)

            else:

                if atrb[0:7] == "progvfo":      # 2-deep

                    stx = atrb.split(".")

                    setattr(obj[ndx].progvfo[ndy], stx[1], vx)

                else:

                    setattr(obj[ndx], atrb, vx)

            return

        def _char_to_str(chrx):

            """ Remove ff pads from char array """

            #  chrx is char array

            str1 = ""

            for sx in chrx:

                if int(sx) > 31 and int(sx) < 127:

                    str1 += chr(int(sx))

            return str1

        def _pswd_vfy(setting, obj, atrb):

            """ Verify password is 1-6 chars, numbers 1-5 """

            str1 = str(setting.value).strip()   # initial

            str2 = ''.join(filter(lambda c: c in '12345', str1))  # valid chars

            if str1 != str2:

                # Two lines due to python 73 char limit

                sx = "Bad characters in Password"

                raise errors.RadioError(sx)

            str2 = str1.ljust(6, chr(255))      # pad to 6 with ff's

            setattr(obj, atrb, str2)

            return

        def _pad_str(setting, lenstr, padchr, obj, atrb, ndx=-1):

            """ pad string to lenstr with padchr  """

            str1 = str(setting.value).strip()      # initial string

            str2 = str1.ljust(lenstr, padchr)

            if ndx < 0:

                setattr(obj, atrb, str2)

            else:

                setattr(obj[ndx], atrb, str2)

            return

        # ===== BASIC GROUP =====

        sx = _char_to_str(_com.comnt)

        rx = RadioSettingValueString(0, 32, sx)

        sx = "Comment"

        rset = RadioSetting("mcpcom.comnt", sx, rx)

        basic.append(rset)

        rx = RadioSettingValueInteger(0, 5, _blk1.pmrecall)

        sx = "Current PM Select"

        rset = RadioSetting("block1.pmrecall", sx, rx)

        basic.append(rset)

        rx = RadioSettingValueBoolean(bool(_blk1.pwdon))

        sx = "Password"

        rset = RadioSetting("block1.pwdon", sx, rx)

        basic.append(rset)

        sx = _char_to_str(_blk1.pswd).strip()

        rx = RadioSettingValueString(0, 6, sx)

        # rx.set_charset("12345")   # Keeps finding `'

        sx = "-   Password (numerals 1-5)"

        rset = RadioSetting("block1.pswd", sx, rx)

        rset.set_apply_callback(_pswd_vfy, _blk1, "pswd")

        basic.append(rset)

        # ===== PM0 (off) DISPLAY GROUP =====

        rx = RadioSettingValueString(0, 8, _char_to_str(_pmg[0].pwron))

        sx = "Power-On message"

        rset = RadioSetting("pmg/0.pwron", sx, rx)

        disp.append(rset)

        if self.SHORT == "G":         # TMD-710G

            rx = RadioSettingValueBoolean(bool(_bmp.bmpon))

            sx = "PM0: Custom display bitmap"

            rset = RadioSetting("bitmap.bmpon", sx, rx)

            disp.append(rset)

            rx = RadioSettingValueString(0, 64, _char_to_str(_bmp.bmpfyl))

            rx.set_mutable(False)

            sx = "-   Custom bitmap filename"

            rset = RadioSetting("bitmap.bmpfyl", sx, rx)

            rset.set_doc("Read-only: To modify, use MCP-6 s/w")

            disp.append(rset)

        opts = ["VFO", "Mem Recall"]

        rx = RadioSettingValueList(opts, opts[_pmg[0].a_mr])

        sx = "A: Left Side VFO/MR"

        rset = RadioSetting("pmg/0.a_mr", sx, rx)

        rset.set_apply_callback(_val_list, opts, _pmg[0], "a_mr")

        disp.append(rset)

        rx = RadioSettingValueInteger(0, 999, _pmg[0].a_chn)

        sx = "A: Left Side MR Channel"

        rset = RadioSetting("pmg/0.a_chn", sx, rx)

        disp.append(rset)

        rx = RadioSettingValueList(opts, opts[_pmg[0].b_mr])

        sx = "B: Right Side VFO/MR"

        rset = RadioSetting("pmg/0.b_mr", sx, rx)

        rset.set_apply_callback(_val_list, opts, _pmg[0], "b_mr")

        disp.append(rset)

        rx = RadioSettingValueInteger(0, 999, _pmg[0].b_chn)

        sx = "B: Right Side MR Channel"

        rset = RadioSetting("pmg/0.b_chn", sx, rx)

        disp.append(rset)

        rx = RadioSettingValueInteger(0, 8, _pmg[0].bright)

        sx = "Brightness level"

        rset = RadioSetting("pmg/0.bright", sx, rx)

        disp.append(rset)

        opts = ["Amber", "Green"]

        rx = RadioSettingValueList(opts, opts[_pmg[0].bkltclr])

        sx = "Backlight color"

        rset = RadioSetting("pmg/0.bkltclr", sx, rx)

        rset.set_apply_callback(_val_list, opts, _pmg[0], "bkltclr")

        disp.append(rset)

        val = _pmg[0].bkltcont + 1

        rx = RadioSettingValueInteger(1, 16, val)

        sx = "Contrast level"

        rset = RadioSetting("pmg/0.bkltcont", sx, rx)

        rset.set_apply_callback(_adjraw, _pmg[0], "bkltcont", -1)

        disp.append(rset)

        opts = ["Positive", "Negative"]

        rx = RadioSettingValueList(opts, opts[_pmg[0].dsprev])

        sx = "Color mode"

        rset = RadioSetting("pmg/0.dsprev", sx, rx)

        rset.set_apply_callback(_val_list, opts, _pmg[0], "dsprev")

        disp.append(rset)

        rx = RadioSettingValueBoolean(bool(_pmg[0].autobri))

        sx = "Auto brightness"

        rset = RadioSetting("pmg/0.autobri", sx, rx)

        disp.append(rset)

        rx = RadioSettingValueBoolean(bool(_pmg[0].dispbar))

        sx = "Display partition bar"

        rset = RadioSetting("pmg/0.dispbar", sx, rx)

        disp.append(rset)

        rx = RadioSettingValueBoolean(bool(_pmg[0].single))

        sx = "Single band display"

        rset = RadioSetting("pmg/0.single", sx, rx)

        disp.append(rset)

        rx = RadioSettingValueBoolean(bool(_pmg[0].autopm))

        sx = "Auto PM Store"

        rset = RadioSetting("pmg/0.autopm", sx, rx)

        disp.append(rset)

        # ===== AUDIO GROUP =====

        rx = RadioSettingValueBoolean(bool(_pmg[0].beepon))

        sx = "Beep On"

        rset = RadioSetting("pmg/0.beepon", sx, rx)

        aud.append(rset)

        val = _pmg[0].beepvol + 1     # 1-7 downloads as 0-6

        rx = RadioSettingValueInteger(1, 7, val)

        sx = "Beep volume (1 - 7)"

        rset = RadioSetting("pmg/0.beepvol", sx, rx)

        rset.set_apply_callback(_adjraw, _pmg[0], "beepvol", -1)

        aud.append(rset)

        opts = ["Mode1", "Mode2"]

        rx = RadioSettingValueList(opts, opts[_pmg[0].extspkr])

        sx = "External Speaker"

        rset = RadioSetting("pmg/0.extspkr", sx, rx)

        rset.set_apply_callback(_val_list, opts, _pmg[0], "extspkr")

        aud.append(rset)

        rx = RadioSettingValueBoolean(bool(_pmg[0].pbkrpt))

        sx = "VGS Plugin: Playback repeat"

        rset = RadioSetting("pmg/0.pbkrpt", sx, rx)

        aud.append(rset)

        rx = RadioSettingValueInteger(0, 60, _pmg[0].pbkint)

        sx = "     Playback repeat interval (0 - 60 secs)"

        rset = RadioSetting("pmg/0.pbkint", sx, rx)

        aud.append(rset)

        rx = RadioSettingValueBoolean(bool(_pmg[0].cntrec))

        sx = "     Continuous recording"

        rset = RadioSetting("pmg/0.cntrec", sx, rx)

        aud.append(rset)

        opts = ["Off", "Auto", "Manual"]

        rx = RadioSettingValueList(opts, opts[_pmg[0].ance])

        sx = "     Announce mode"

        rset = RadioSetting("pmg/0.ance", sx, rx)

        rset.set_apply_callback(_val_list, opts, _pmg[0], "ance")

        aud.append(rset)

        opts = ["English", "Japanese"]

        rx = RadioSettingValueList(opts, opts[_pmg[0].lang])

        sx = "     Announce language"

        rset = RadioSetting("pmg/0.lang", sx, rx)

        rset.set_apply_callback(_val_list, opts, _pmg[0], "lang")

        aud.append(rset)

        rx = RadioSettingValueInteger(1, 7, _pmg[0].vcvol + 1)

        sx = "     Voice volume (1 - 7)"

        rset = RadioSetting("pmg/0.vcvol", sx, rx)

        rset.set_apply_callback(_adjraw, _pmg[0], "vcvol", -1)

        aud.append(rset)

        rx = RadioSettingValueInteger(0, 4, _pmg[0].vcspd)

        sx = "     Voice speed (0 - 4)"

        rset = RadioSetting("pmg/0.vcspd", sx, rx)

        aud.append(rset)

        # ===== AUX GROUP =====

        opts = ["9600", "19200", "38400", "57600"]

        rx = RadioSettingValueList(opts, opts[_blk1.pcbaud])

        sx = "PC port baud rate"

        rset = RadioSetting("block1.pcbaud", sx, rx)

        rset.set_apply_callback(_val_list, opts, _blk1, "pcbaud")

        aux.append(rset)

        opts = ["A-Band", "B-Band", "TX-A / RX-B", "RX-A / TX-B"]

        rx = RadioSettingValueList(opts, opts[_pmg[0].intband])

        sx = "Internal TNC band"

        rset = RadioSetting("pmg/0.intband", sx, rx)

        rset.set_apply_callback(_val_list, opts, _pmg[0], "intband")

        aux.append(rset)

        opts = ["A-Band", "B-Band", "TX-A / RX-B", "RX-A / TX-B"]

        rx = RadioSettingValueList(opts, opts[_pmg[0].extband])

        sx = "External TNC band"

        rset = RadioSetting("pmg/0.extband", sx, rx)

        rset.set_apply_callback(_val_list, opts, _pmg[0], "extband")

        aux.append(rset)

        opts = ["1200", "9600"]

        rx = RadioSettingValueList(opts, opts[_pmg[0].extbaud])

        sx = "External TNC baud"

        rset = RadioSetting("pmg/0.extbaud", sx, rx)