[chirp_devel] [PATCH] [New Model] Add Support for Retevis RT23 Radio

13 Jun 2017

# HG changeset patch
# User Jim Unroe rock.unroe@gmail.com
# Date 1497404221 14400
# Node ID 5af61447fc034ef20d7bf2e1799bd092b641c51e
# Parent  fa2ef4dedc56b786c2ff94d70a5a9b2c94785973
[New Model] Add Support for Retevis RT23 Radio
This patch adds basic support for the Retevis RT23 radio.
#4619
diff -r fa2ef4dedc56 -r 5af61447fc03 chirp/drivers/retevis_rt23.py

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/chirp/drivers/retevis_rt23.py	Tue Jun 13 21:37:01 2017 -0400
@@ -0,0 +1,872 @@
+# Copyright 2017 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 time
+import os
+import struct
+import re
+import logging
+
+from chirp import chirp_common, directory, memmap
+from chirp import bitwise, errors, util
+from chirp.settings import RadioSetting, RadioSettingGroup, \
+    RadioSettingValueInteger, RadioSettingValueList, \
+    RadioSettingValueBoolean, RadioSettingValueString, \
+    RadioSettings
+
+LOG = logging.getLogger(__name__)
+
+MEM_FORMAT = """
+struct memory {
+  lbcd rxfreq[4];
+  lbcd txfreq[4];
+  lbcd rxtone[2];
+  lbcd txtone[2];
+  u8 unknown1;
+  u8 pttid:2,     // PTT-ID
+     unknown2:1,
+     signaling:1, // Signaling(ANI)
+     unknown3:1,
+     bcl:1,       // Busy Channel Lockout
+     unknown4:2;
+  u8 unknown5:3,
+     highpower:1, // Power Level
+     isnarrow:1,  // Bandwidth
+     scan:1,      // Scan Add
+     unknown6:2;
+  u8 unknown7;
+};
+
+#seekto 0x0010;
+struct memory channels[128];
+
+#seekto 0x0810;
+struct memory vfo_a;
+struct memory vfo_b;
+
+#seekto 0x0830;
+struct {
+  u8 unknown_0830_1:4,
+     color:2,               // Background Color
+     dst:1,                 // DTMF Side Tone
+     txsel:1;               // Priority TX Channel Select
+  u8 scans:2,               // Scan Mode
+     unknown_0831:1,
+     autolk:1,              // Auto Key Lock
+     save:1,                // Battery Save
+     beep:1,                // Key Beep
+     voice:2;               // Voice Prompt
+  u8 vfomr_fm:1,            // FM Radio Display Mode
+     led:2,                 // Background Light
+     unknown_0832_2:1,
+     dw:1,                  // FM Radio Dual Watch
+     name:1,                // Display Names
+     vfomr_a:2;             // Display Mode A
+  u8 opnset:2,              // Power On Message
+     unknown_0833_1:3,
+     dwait:1,               // Dual Standby
+     vfomr_b:2;             // Display Mode B
+  u8 mrcha;                 // mr a ch num
+  u8 mrchb;                 // mr b ch num
+  u8 fmch;                  // fm radio ch num
+  u8 unknown_0837_1:1,
+     ste:1,                 // Squelch Tail Eliminate
+     roger:1,               // Roger Beep
+     unknown_0837_2:1,
+     vox:4;                 // VOX
+  u8 step:4,                // Step
+     unknown_0838_1:4;
+  u8 squelch;               // Squelch
+  u8 tot;                   // Time Out Timer
+  u8 rptmod:1,              // Repeater Mode
+     volmod:2,              // Volume Mode
+     rptptt:1,              // Repeater PTT Switch
+     rptspk:1,              // Repeater Speaker
+     relay:3;               // Cross Band Repeater Enable
+  u8 unknown_083C:4,        // 0x083C
+     rptrl:4;               // Repeater TX Delay
+  u8 pf1:4,                 // Function Key 1
+     pf2:4;                 // Function Key 2
+  u8 vot;                   // VOX Delay Time
+} settings;
+
+#seekto 0x0848;
+struct {
+  char line1[7];
+} poweron_msg;
+
+struct limit {
+  bbcd lower[2];
+  bbcd upper[2];
+};
+
+#seekto 0x0850;
+struct {
+  struct limit vhf;
+  struct limit uhf;
+} limits;
+
+#seekto 0x08D0;
+struct {
+  char name[7];
+  u8 unknown2[1];
+} names[128];
+
+#seekto 0x0D20;
+u8 usedflags[16];
+u8 scanflags[16];
+
+#seekto 0x0FA0;
+struct {
+  u8 unknown_0FA0_1:4,
+     dispab:1,              // select a/b
+     unknown_0FA0_2:3;
+} settings2;
+"""
+
+CMD_ACK = "\x06"
+BLOCK_SIZE = 0x10
+
+RT23_POWER_LEVELS = [chirp_common.PowerLevel("Low", watts=1.00),
+                     chirp_common.PowerLevel("High", watts=2.50)]
+
+
+RT23_DTCS = sorted(chirp_common.DTCS_CODES +
+                   [17, 50, 55, 135, 217, 254, 305, 645, 765])
+
+RT23_CHARSET = chirp_common.CHARSET_UPPER_NUMERIC + \
+    ":;<=>?@ !"#$%&'()*+,-./"
+
+LIST_COLOR = ["Blue", "Orange", "Purple"]
+LIST_LED = ["Off", "On", "Auto"]
+LIST_OPNSET = ["Full", "Voltage", "Message"]
+LIST_PFKEY = [
+    "Radio",
+    "Sub-channel Sent",
+    "Scan",
+    "Alarm",
+    "DTMF",
+    "Squelch Off Momentarily",
+    "Battery Power Indicator",
+    "Tone 1750",
+    "Tone 2100",
+    "Tone 1000",
+    "Tone 1450"]
+LIST_PTTID = ["Off", "BOT", "EOT", "Both"]
+LIST_RPTMOD = ["Single", "Double"]
+LIST_RPTRL = ["0.5S", "1.0S", "1.5S", "2.0S", "2.5S", "3.0S", "3.5S", "4.0S",
+              "4.5S"]
+LIST_SCANS = ["Time Operated", "Carrier Operated", "Search"]
+LIST_SIGNALING = ["No", "DTMF"]
+LIST_TOT = ["OFF"] + ["%s seconds" % x for x in range(30, 300, 30)]
+LIST_TXSEL = ["Edit", "Busy"]
+LIST_STEP = ["2.50K", "5.00K", "6.25K", "10.00K", "12,50K", "20.00K", "25.00K",
+             "50.00K"]
+LIST_VFOMR = ["VFO", "MR(Frequency)", "MR(Channel #/Name)"]
+LIST_VFOMRFM = ["VFO", "Channel"]
+LIST_VOICE = ["Off", "Chinese", "English"]
+LIST_VOLMOD = ["Off", "Sub", "Main"]
+LIST_VOT = ["0.5S", "1.0S", "1.5S", "2.0S", "3.0S"]
+LIST_VOX = ["OFF"] + ["%s" % x for x in range(1, 6)]
+
+
+def _rt23_enter_programming_mode(radio):
+    serial = radio.pipe
+
+    magic = "PROIUAM"
+    exito = False
+    for i in range(0, 5):
+        for j in range(0, len(magic)):
+            time.sleep(0.005)
+            serial.write(magic[j])
+        ack = serial.read(1)
+
+        try:
+            if ack == CMD_ACK:
+                exito = True
+                break
+        except:
+            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("\x02")
+        ident = serial.read(8)
+    except:
+        raise errors.RadioError("Error communicating with radio")
+
+    if not ident.startswith("P31183"):
+        LOG.debug(util.hexprint(ident))
+        raise errors.RadioError("Radio returned unknown identification string")
+
+    try:
+        serial.write(CMD_ACK)
+        ack = serial.read(1)
+    except:
+        raise errors.RadioError("Error communicating with radio")
+
+    if ack != CMD_ACK:
+        raise errors.RadioError("Radio refused to enter programming mode")
+
+
+def _rt23_exit_programming_mode(radio):
+    serial = radio.pipe
+    try:
+        serial.write("E")
+    except:
+        raise errors.RadioError("Radio refused to exit programming mode")
+
+
+def _rt23_read_block(radio, block_addr, block_size):
+    serial = radio.pipe
+
+    cmd = struct.pack(">cHb", 'R', block_addr, BLOCK_SIZE)
+    expectedresponse = "W" + cmd[1:]
+    LOG.debug("Reading block %04x..." % (block_addr))
+
+    try:
+        serial.write(cmd)
+        response = serial.read(4 + BLOCK_SIZE + 1)
+        if response[:4] != expectedresponse:
+            raise Exception("Error reading block %04x." % (block_addr))
+
+        chunk = response[4:]
+
+        cs = 0
+        for byte in chunk[:-1]:
+            cs += ord(byte)
+        if ord(chunk[-1]) != (cs & 0xFF):
+            raise Exception("Block failed checksum!")
+
+        block_data = chunk[:-1]
+    except:
+        raise errors.RadioError("Failed to read block at %04x" % block_addr)
+
+    return block_data
+
+
+def _rt23_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]
+    cs = 0
+    for byte in data:
+        cs += ord(byte)
+    data += chr(cs & 0xFF)
+
+    LOG.debug("Writing Data:")
+    LOG.debug(util.hexprint(cmd + data))
+
+    try:
+        for j in range(0, len(cmd)):
+            time.sleep(0.002)
+            serial.write(cmd[j])
+        for j in range(0, len(data)):
+            time.sleep(0.002)
+            serial.write(data[j])
+        if serial.read(1) != 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")
+    _rt23_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, BLOCK_SIZE):
+        status.cur = addr + BLOCK_SIZE
+        radio.status_fn(status)
+
+        block = _rt23_read_block(radio, addr, BLOCK_SIZE)
+        if addr == 0 and block.startswith("\xFF" * 6):
+            block = "P31183" + "\xFF" * 10
+        data += block
+
+        LOG.debug("Address: %04x" % addr)
+        LOG.debug(util.hexprint(block))
+
+    _rt23_exit_programming_mode(radio)
+
+    return memmap.MemoryMap(data)
+
+
+def do_upload(radio):
+    status = chirp_common.Status()
+    status.msg = "Uploading to radio"
+
+    _rt23_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, BLOCK_SIZE):
+            status.cur = addr + BLOCK_SIZE
+            radio.status_fn(status)
+            _rt23_write_block(radio, addr, BLOCK_SIZE)
+
+
+def model_match(cls, data):
+    """Match the opened/downloaded image to the correct version"""
+
+    if len(data) == 0x1000:
+        rid = data[0x0000:0x0006]
+        return rid == "P31183"
+    else:
+        return False
+
+
+def _split(rf, f1, f2):
+    """Returns False if the two freqs are in the same band (no split)
+    or True otherwise"""
+
+    # determine if the two freqs are in the same band
+    for low, high in rf.valid_bands:
+        if f1 >= low and f1 <= high and \
+                f2 >= low and f2 <= high:
+            # if the two freqs are on the same Band this is not a split
+            return False
+
+    # if you get here is because the freq pairs are split
+    return True
+
+
+@directory.register
+class RT23Radio(chirp_common.CloneModeRadio):
+    """RETEVIS RT23"""
+    VENDOR = "Retevis"
+    MODEL = "RT23"
+    BAUD_RATE = 9600
+
+    _ranges = [
+               (0x0000, 0x0EC0),
+              ]
+    _memsize = 0x1000
+
+    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.valid_name_length = 7
+        rf.valid_characters = RT23_CHARSET
+        rf.has_name = True
+        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 = RT23_POWER_LEVELS
+        rf.valid_duplexes = ["", "-", "+", "split", "off"]
+        rf.valid_modes = ["FM", "NFM"]  # 25 KHz, 12.5 KHz.
+        rf.memory_bounds = (1, 128)
+        rf.valid_bands = [
+            (136000000, 174000000),
+            (400000000, 480000000)]
+
+        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:
+            # 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:
+            # 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 get_raw_memory(self, number):
+        return repr(self._memobj.memory[number - 1])
+
+    def decode_tone(self, val):
+        """Parse the tone data to decode from mem, it returns:
+        Mode (''|DTCS|Tone), Value (None|###), Polarity (None,N,R)"""
+        if val.get_raw() == "\xFF\xFF":
+            return '', None, None
+
+        val = int(val)
+        if val >= 12000:
+            a = val - 12000
+            return 'DTCS', a, 'R'
+        elif val >= 8000:
+            a = val - 8000
+            return 'DTCS', a, 'N'
+        else:
+            a = val / 10.0
+            return 'Tone', a, None
+
+    def encode_tone(self, memval, mode, value, pol):
+        """Parse the tone data to encode from UI to mem"""
+        if mode == '':
+            memval[0].set_raw(0xFF)
+            memval[1].set_raw(0xFF)
+        elif mode == 'Tone':
+            memval.set_value(int(value * 10))
+        elif mode == 'DTCS':
+            flag = 0x80 if pol == 'N' else 0xC0
+            memval.set_value(value)
+            memval[1].set_bits(flag)
+        else:
+            raise Exception("Internal error: invalid mode `%s'" % mode)
+
+    def get_memory(self, number):
+        mem = chirp_common.Memory()
+        _mem = self._memobj.channels[number-1]
+        _nam = self._memobj.names[number - 1]
+        mem.number = number
+        bitpos = (1 << ((number - 1) % 8))
+        bytepos = ((number - 1) / 8)
+        _scn = self._memobj.scanflags[bytepos]
+        _usd = self._memobj.usedflags[bytepos]
+        isused = bitpos & int(_usd)
+        isscan = bitpos & int(_scn)
+
+        if not isused:
+            mem.empty = True
+            return mem
+
+        mem.freq = int(_mem.rxfreq) * 10
+
+        # We'll consider any blank (i.e. 0MHz frequency) to be empty
+        if mem.freq == 0:
+            mem.empty = True
+            return mem
+
+        if _mem.rxfreq.get_raw() == "\xFF\xFF\xFF\xFF":
+            mem.empty = True
+            return mem
+
+        if _mem.get_raw() == ("\xFF" * 16):
+            LOG.debug("Initializing empty memory")
+            _mem.set_raw("\x00" * 16)
+
+        # 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 _nam.name:
+            if str(char) == "\xFF":
+                char = " "
+            mem.name += str(char)
+        mem.name = mem.name.rstrip()
+
+        mem.mode = _mem.isnarrow and "NFM" or "FM"
+
+        rxtone = txtone = None
+        txtone = self.decode_tone(_mem.txtone)
+        rxtone = self.decode_tone(_mem.rxtone)
+        chirp_common.split_tone_decode(mem, txtone, rxtone)
+
+        mem.power = RT23_POWER_LEVELS[_mem.highpower]
+
+        if not isscan:
+            mem.skip = "S"
+
+        mem.extra = RadioSettingGroup("Extra", "extra")
+
+        rs = RadioSetting("bcl", "BCL",
+                          RadioSettingValueBoolean(_mem.bcl))
+        mem.extra.append(rs)
+
+        rs = RadioSetting("pttid", "PTT ID",
+                          RadioSettingValueList(
+                              LIST_PTTID, LIST_PTTID[_mem.pttid]))
+        mem.extra.append(rs)
+
+        rs = RadioSetting("signaling", "Optional Signaling",
+                          RadioSettingValueList(LIST_SIGNALING,
+                              LIST_SIGNALING[_mem.signaling]))
+        mem.extra.append(rs)
+
+        return mem
+
+    def set_memory(self, mem):
+        LOG.debug("Setting %i(%s)" % (mem.number, mem.extd_number))
+        _mem = self._memobj.channels[mem.number - 1]
+        _nam = self._memobj.names[mem.number - 1]
+        bitpos = (1 << ((mem.number - 1) % 8))
+        bytepos = ((mem.number - 1) / 8)
+        _scn = self._memobj.scanflags[bytepos]
+        _usd = self._memobj.usedflags[bytepos]
+
+        if mem.empty:
+            _mem.set_raw("\xFF" * 16)
+            _nam.name = ("\xFF" * 7)
+            _usd &= ~bitpos
+            _scn &= ~bitpos
+            return
+        else:
+            _usd |= bitpos
+
+        if _mem.get_raw() == ("\xFF" * 16):
+            LOG.debug("Initializing empty memory")
+            _mem.set_raw("\x00" * 16)
+            _scn |= bitpos
+
+        _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:
+                _nam.name[i] = mem.name[i]
+            except IndexError:
+                _nam.name[i] = "\xFF"
+
+        _mem.scan = mem.skip != "S"
+        if mem.skip == "S":
+            _scn &= ~bitpos
+        else:
+            _scn |= bitpos
+        _mem.isnarrow = mem.mode == "NFM"
+
+        ((txmode, txtone, txpol), (rxmode, rxtone, rxpol)) = \
+            chirp_common.split_tone_encode(mem)
+        self.encode_tone(_mem.txtone, txmode, txtone, txpol)
+        self.encode_tone(_mem.rxtone, rxmode, rxtone, rxpol)
+
+        _mem.highpower = mem.power == RT23_POWER_LEVELS[1]
+
+        for setting in mem.extra:
+            setattr(_mem, setting.get_name(), setting.value)
+
+    def get_settings(self):
+        _settings = self._memobj.settings
+        _mem = self._memobj
+        basic = RadioSettingGroup("basic", "Basic Settings")
+        advanced = RadioSettingGroup("advanced", "Advanced Settings")
+        other = RadioSettingGroup("other", "Other Settings")
+        workmode = RadioSettingGroup("workmode", "Workmode Settings")
+        fmradio = RadioSettingGroup("fmradio", "FM Radio Settings")
+        top = RadioSettings(basic, advanced, other, workmode, fmradio)
+
+        save = RadioSetting("save", "Battery Saver",
+                            RadioSettingValueBoolean(_settings.save))
+        basic.append(save)
+
+        vox = RadioSetting("vox", "VOX Gain",
+                           RadioSettingValueList(
+                               LIST_VOX, LIST_VOX[_settings.vox]))
+        basic.append(vox)
+
+        squelch = RadioSetting("squelch", "Squelch Level",
+                               RadioSettingValueInteger(
+                                   0, 9, _settings.squelch))
+        basic.append(squelch)
+
+        relay = RadioSetting("relay", "Repeater",
+                             RadioSettingValueBoolean(_settings.relay))
+        basic.append(relay)
+
+        tot = RadioSetting("tot", "Time-out timer", RadioSettingValueList(
+                           LIST_TOT, LIST_TOT[_settings.tot]))
+        basic.append(tot)
+
+        beep = RadioSetting("beep", "Key Beep",
+                            RadioSettingValueBoolean(_settings.beep))
+        basic.append(beep)
+
+        color = RadioSetting("color", "Background Color", RadioSettingValueList(
+                             LIST_COLOR, LIST_COLOR[_settings.color - 1]))
+        basic.append(color)
+
+        vot = RadioSetting("vot", "VOX Delay Time", RadioSettingValueList(
+                           LIST_VOT, LIST_VOT[_settings.vot]))
+        basic.append(vot)
+
+        dwait = RadioSetting("dwait", "Dual Standby",
+                             RadioSettingValueBoolean(_settings.dwait))
+        basic.append(dwait)
+
+        led = RadioSetting("led", "Background Light", RadioSettingValueList(
+                           LIST_LED, LIST_LED[_settings.led]))
+        basic.append(led)
+
+        voice = RadioSetting("voice", "Voice Prompt", RadioSettingValueList(
+                             LIST_VOICE, LIST_VOICE[_settings.voice]))
+        basic.append(voice)
+
+        roger = RadioSetting("roger", "Roger Beep",
+                             RadioSettingValueBoolean(_settings.roger))
+        basic.append(roger)
+
+        autolk = RadioSetting("autolk", "Auto Key Lock",
+                              RadioSettingValueBoolean(_settings.autolk))
+        basic.append(autolk)
+
+        opnset = RadioSetting("opnset", "Open Mode Set",
+                              RadioSettingValueList(
+                                  LIST_OPNSET, LIST_OPNSET[_settings.opnset]))
+        basic.append(opnset)
+
+        def _filter(name):
+            filtered = ""
+            for char in str(name):
+                if char in chirp_common.CHARSET_ASCII:
+                    filtered += char
+                else:
+                    filtered += " "
+            return filtered
+
+        _msg = self._memobj.poweron_msg
+        ponmsg = RadioSetting("poweron_msg.line1", "Power-On Message",
+                              RadioSettingValueString(
+                                  0, 7, _filter(_msg.line1)))
+        basic.append(ponmsg)
+
+
+        scans = RadioSetting("scans", "Scan Mode", RadioSettingValueList(
+                             LIST_SCANS, LIST_SCANS[_settings.scans]))
+        basic.append(scans)
+
+        dw = RadioSetting("dw", "FM Radio Dual Watch",
+                          RadioSettingValueBoolean(_settings.dw))
+        basic.append(dw)
+
+        name = RadioSetting("name", "Display Names",
+                            RadioSettingValueBoolean(_settings.name))
+        basic.append(name)
+
+        rptrl = RadioSetting("rptrl", "Repeater TX Delay", 
+                             RadioSettingValueList(LIST_RPTRL, LIST_RPTRL[
+                                 _settings.rptrl]))
+        basic.append(rptrl)
+
+        rptspk = RadioSetting("rptspk", "Repeater Speaker",
+                              RadioSettingValueBoolean(_settings.rptspk))
+        basic.append(rptspk)
+
+        rptptt = RadioSetting("rptptt", "Repeater PTT Switch",
+                            RadioSettingValueBoolean(_settings.rptptt))
+        basic.append(rptptt)
+
+        rptmod = RadioSetting("rptmod", "Repeater Mode",
+                              RadioSettingValueList(
+                                  LIST_RPTMOD, LIST_RPTMOD[_settings.rptmod]))
+        basic.append(rptmod)
+
+        volmod = RadioSetting("volmod", "Volume Mode",
+                              RadioSettingValueList(
+                                  LIST_VOLMOD, LIST_VOLMOD[_settings.volmod]))
+        basic.append(volmod)
+
+        dst = RadioSetting("dst", "DTMF Side Tone",
+                            RadioSettingValueBoolean(_settings.dst))
+        basic.append(dst)
+
+        txsel = RadioSetting("txsel", "Priority TX Channel",
+                             RadioSettingValueList(
+                                 LIST_TXSEL, LIST_TXSEL[_settings.txsel]))
+        basic.append(txsel)
+
+        ste = RadioSetting("ste", "Squelch Tail Eliminate",
+                           RadioSettingValueBoolean(_settings.ste))
+        basic.append(ste)
+
+        #advanced
+        if _settings.pf1 > 0x0A:
+            val = 0x00
+        else:
+            val = _settings.pf1
+        pf1 = RadioSetting("pf1", "PF1 Key",
+                           RadioSettingValueList(
+                               LIST_PFKEY, LIST_PFKEY[val]))
+        advanced.append(pf1)
+
+        if _settings.pf2 > 0x0A:
+            val = 0x00
+        else:
+            val = _settings.pf2
+        pf2 = RadioSetting("pf2", "PF2 Key",
+                           RadioSettingValueList(
+                               LIST_PFKEY, LIST_PFKEY[val]))
+        advanced.append(pf2)
+
+        # other
+        _limit = str(int(_mem.limits.vhf.lower) / 10)
+        val = RadioSettingValueString(0, 3, _limit)
+        val.set_mutable(False)
+        rs = RadioSetting("limits.vhf.lower", "VHF low", val)
+        other.append(rs)
+
+        _limit = str(int(_mem.limits.vhf.upper) / 10)
+        val = RadioSettingValueString(0, 3, _limit)
+        val.set_mutable(False)
+        rs = RadioSetting("limits.vhf.upper", "VHF high", val)
+        other.append(rs)
+
+        _limit = str(int(_mem.limits.uhf.lower) / 10)
+        val = RadioSettingValueString(0, 3, _limit)
+        val.set_mutable(False)
+        rs = RadioSetting("limits.uhf.lower", "UHF low", val)
+        other.append(rs)
+
+        _limit = str(int(_mem.limits.uhf.upper) / 10)
+        val = RadioSettingValueString(0, 3, _limit)
+        val.set_mutable(False)
+        rs = RadioSetting("limits.uhf.upper", "UHF high", val)
+        other.append(rs)
+
+        #work mode
+        vfomr_a = RadioSetting("vfomr_a", "Display Mode A",
+                               RadioSettingValueList(
+                                   LIST_VFOMR, LIST_VFOMR[_settings.vfomr_a]))
+        workmode.append(vfomr_a)
+
+        vfomr_b = RadioSetting("vfomr_b", "Display Mode B",
+                               RadioSettingValueList(
+                                   LIST_VFOMR, LIST_VFOMR[_settings.vfomr_b]))
+        workmode.append(vfomr_b)
+
+        mrcha = RadioSetting("mrcha", "Channel # A",
+                             RadioSettingValueInteger(
+                                 1, 128, _settings.mrcha))
+        workmode.append(mrcha)
+
+        mrchb = RadioSetting("mrchb", "Channel # B",
+                             RadioSettingValueInteger(
+                                 1, 128, _settings.mrchb))
+        workmode.append(mrchb)
+
+        #fm radio
+        vfomr_fm = RadioSetting("vfomr_fm", "FM Radio Display Mode",
+                                RadioSettingValueList(
+                                    LIST_VFOMRFM, LIST_VFOMRFM[
+                                        _settings.vfomr_fm]))
+        fmradio.append(vfomr_fm)
+
+        fmch = RadioSetting("fmch", "FM Radio Channel #",
+                            RadioSettingValueInteger(
+                                 1, 25, _settings.fmch))
+        fmradio.append(fmch)
+
+        return top
+
+    def set_settings(self, settings):
+        for element in settings:
+            if not isinstance(element, RadioSetting):
+                self.set_settings(element)
+                continue
+            else:
+                try:
+                    if "." in element.get_name():
+                        bits = element.get_name().split(".")
+                        obj = self._memobj
+                        for bit in bits[:-1]:
+                            obj = getattr(obj, bit)
+                        setting = bits[-1]
+                    else:
+                        obj = self._memobj.settings
+                        setting = element.get_name()
+
+                    if element.has_apply_callback():
+                        LOG.debug("Using apply callback")
+                        element.run_apply_callback()
+                    elif setting == "color":
+                        setattr(obj, setting, int(element.value) + 1)
+                    elif element.value.get_mutable():
+                        LOG.debug("Setting %s = %s" % (setting, element.value))
+                        setattr(obj, setting, element.value)
+                except Exception, e:
+                    LOG.debug(element.get_name())
+                    raise
+
+    @classmethod
+    def match_model(cls, filedata, filename):
+        match_size = False
+        match_model = False
+
+        # testing the file data size
+        if len(filedata) in [0x1000, ]:
+            match_size = True
+
+        # testing the model fingerprint
+        match_model = model_match(cls, filedata)
+
+        if match_size and match_model:
+            return True
+        else:
+            return False

    