CHIRP

# Copyright 2012 Dan Smith <dsmith@danplanet.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 struct

import time

import logging

from chirp import chirp_common, errors, util, directory, memmap

from chirp import bitwise

from chirp.settings import InvalidValueError, RadioSetting, \

    RadioSettingGroup, RadioSettingValueFloat, \

    RadioSettingValueList, RadioSettingValueBoolean, \

    RadioSettingValueString, RadioSettings

from textwrap import dedent

from chirp import bandplan_na

LOG = logging.getLogger(__name__)

AIRBAND = (108000000, 135999999)

MEM_FORMAT = """

#seekto 0x0008;

struct {

  lbcd rxfreq[4];

  lbcd txfreq[4];

  lbcd rxtone[2];

  lbcd txtone[2];

  u8 unused1;

  u8 pttid:2,

     freqhop:1,

     unused3:1,

     unused4:1,

     bcl:1,

     unused5:1,

     unused2:1;

  u8 unused6:1,

     unused7:1,

     lowpower:2,

     wide:1,

     unused8:1,

     offset:2;

  u8 unused10;

} memory[200];

#seekto 0x0CA8;

struct {

  u8 txled:1,

     rxled:1,

     unused11:1,

     ham:1,

     gmrs:1,

     unused14:1,

     unused15:1,

     pritx:1;

  u8 scanmode:2,

     unused16:1,

     keyautolock:1,

     unused17:1,

     btnvoice:1,

     unknown18:1,

     voiceprompt:1;

  u8 fmworkmode:1,

     sync:1,

     tonevoice:2,

     fmrec:1,

     mdfa:1,

     aworkmode:2;

  u8 ponmsg:2,

     unused19:1,

     mdfb:1,

     unused20:1,

     dbrx:1,

     bworkmode:2;

  u8 ablock;

  u8 bblock;

  u8 fmroad;

  u8 unused21:1,

     tailclean:1,

     rogerprompt:1,

     unused23:1,

     unused24:1,

     voxgain:3;

  u8 astep:4,

     bstep:4;

  u8 squelch;

  u8 tot;

  u8 lang;

  u8 save;

  u8 ligcon;

  u8 voxdelay;

  u8 onlychmode:1,

     unused:6,

     alarm:1;

} settings;

//#seekto 0x0CB8;

struct {

    u8 ofseta[4];

} aoffset;

//#seekto 0x0CBC;

struct {

    u8 ofsetb[4];

} boffset;

#seekto 0x0CD8;

struct{

    lbcd fmblock[4];

}fmmode[25];

#seekto 0x0D48;

struct {

  char name[8];

  u8 unknown2[8];

} names[200];

#seekto 0x1A08;

lbit usedflags[200];

#seekto 0x1a28;

lbit scanadd[200];

#seekto 0x1B38;

lbcd fmvfo[4];

#seekto 0x1B58;

struct {

  lbcd rxfreqa[4];

  lbcd txfreq[4];

  u8 rxtone[2];

  u8 txtone[2];

  u8 unused1;

  u8 pttid:2,

     specialqta:1,

     unused3:1,

     unused4:1,

     bcl:1,

     unused5:1,

     unused2:1;

  u8 unused6:1,

     unused7:1,

     lowpower:2,

     wide:1,

     unused8:1,

     offset:2;

  u8 unused10;

} vfoa;

//#seekto 0x1B68;

struct {

  lbcd rxfreqb[4];

  lbcd txfreq[4];

  u8 rxtoneb[2];

  u8 txtone[2];

  u8 unused1;

  u8 pttid:2,

     specialqtb:1,

     unused3:1,

     unused4:1,

     bclb:1,

     unused5:1,

     unused2:1;

  u8 unused6:1,

     unused7:1,

     lowpowerb:2,

     wideb:1,

     unused8:1,

     offsetb:2;

  u8 unused10;

} vfob;

//#seekto 0x1B78;

lbit fmusedflags[32];

#seekto 0x1c08;

struct {

  char msg1[16];

  char msg2[16];

  char msg3[16];

} poweron_msg;

#seekto 0x1CC8;

struct{

  u8 stopkey1;

  u8 ssidekey1;

  u8 ssidekey2;

  u8 ltopkey2;

  u8 lsidekey3;

  u8 lsidekey4;

  u8 unused25[10];

} press;

#seekto 0x1E28;

struct{

    u8 idcode[3];

}icode;

#seekto 0x1E31;

struct{

    u8 gcode;

}groupcode;

#seekto 0x1E38;

struct{

    u8 group1[7];

}group1;

#seekto 0x1E48;

struct{

    u8 group2[7];

}group2;

#seekto 0x1E58;

struct{

    u8 group3[7];

}group3;

#seekto 0x1E68;

struct{

    u8 group4[7];

}group4;

#seekto 0x1E78;

struct{

    u8 group5[7];

}group5;

#seekto 0x1E88;

struct{

    u8 group6[7];

}group6;

#seekto 0x1E98;

struct{

    u8 group7[7];

}group7;

#seekto 0x1EA8;

struct{

    u8 group8[7];

}group8;

#seekto 0x1EC8;

struct{

    u8 scode[7];

}startcode;

#seekto 0x1ED8;

struct{

    u8 ecode[7];

}endcode;

"""

MEM_FORMAT_H3 = """

#seekto 0x0008;

struct {

  lbcd rxfreq[4];

  lbcd txfreq[4];

  lbcd rxtone[2];

  lbcd txtone[2];

  u8 unused1;

  u8 pttid:2,

     freqhop:1,

     unused3:1,

     unused4:1,

     bcl:1,

     unused5:1,

     unused2:1;

  u8 unused6:1,

     scramble:1,

     lowpower:2,

     wide:1,

     unused8:1,

     offset:2;

  u8 unused10;

} memory[200];

#seekto 0x0C98;

struct{

  u8 stopkey1;

  u8 ssidekey1;

  u8 ssidekey2;

  u8 ltopkey2;

  u8 lsidekey3;

  u8 lsidekey4;

} press;

#seekto 0x0CA8;

struct {

  u8 txled:1,

     rxled:1,

     unused11:1,

     ham:1,

     gmrs:1,

     unused14:1,

     unused15:1,

     pritx:1;

  u8 scanmode:2,

     unused16:1,

     keyautolock:1,

     unused17:1,

     btnvoice:1,

     unknown18:1,

     voiceprompt:1;

  u8 fmworkmode:1,

     sync:1,

     tonevoice:2,

     fmrec:1,

     mdfa:1,

     aworkmode:2;

  u8 ponmsg:2,

     unused19:1,

     mdfb:1,

     unused20:1,

     dbrx:1,

     bworkmode:2;

  u8 ablock;

  u8 bblock;

  u8 fmroad;

  u8 unused21:1,

     tailclean:1,

     rogerprompt_:1,

     kill:1,

     stun:1,

     voxgain:3;

  u8 astep:4,

     bstep:4;

  u8 squelch;

  u8 tot;

  u8 rogerprompt:2,

     unused11_4:4,

     lang:1,

     unused11_1:1;

  u8 save;

  u8 ligcon;

  u8 voxdelay;

  u8 onlychmode:1,

     breathled:3,

     unused:3,

     alarm:1;

} settings;

//#seekto 0x0CB8;

struct {

    u8 ofseta[4];

} aoffset;

//#seekto 0x0CBC;

struct {

    u8 ofsetb[4];

} boffset;

#seekto 0x0CD8;

struct{

    lbcd fmblock[4];

}fmmode[25];

#seekto 0x0D48;

struct {

  char name[8];

} names[200];

#seekto 0x1808;

struct{

    u8 stuncode[16];

    u8 killcode[16];

}skcode;

//#seekto 0x1828;

struct{

    u8 idcode[3];

}icode;

#seekto 0x1837;

struct{

    u8 gcode;

}groupcode;

//#seekto 0x1838;

struct{

    u8 group1[7];

}group1;

#seekto 0x1848;

struct{

    u8 group2[7];

}group2;

#seekto 0x1858;

struct{

    u8 group3[7];

}group3;

#seekto 0x1868;

struct{

    u8 group4[7];

}group4;

#seekto 0x1878;

struct{

    u8 group5[7];

}group5;

#seekto 0x1888;

struct{

    u8 group6[7];

}group6;

#seekto 0x1898;

struct{

    u8 group7[7];

}group7;

#seekto 0x18A8;

struct{

    u8 group8[7];

}group8;

#seekto 0x18C8;

struct{

    u8 scode[7];

}startcode;

#seekto 0x18D8;

struct{

    u8 ecode[7];

}endcode;

#seekto 0x1908;

lbit usedflags[200];

#seekto 0x1928;

lbit scanadd[200];

#seekto 0x1948;

lbit fmusedflags[32];

#seekto 0x1958;

struct {

  lbcd rxfreqa[4];

  lbcd txfreq[4];

  u8 rxtone[2];

  u8 txtone[2];

  u8 unused1;

  u8 pttid:2,

     specialqta:1,

     unused3:1,

     unused4:1,

     bcl:1,

     unused5:1,

     unused2:1;

  u8 unused6:1,

     unused7:1,

     lowpower:2,

     wide:1,

     unused8:1,

     offset:2;

  u8 unused10;

} vfoa;

//#seekto 0x1968;

struct {

  lbcd rxfreqb[4];

  lbcd txfreq[4];

  u8 rxtoneb[2];

  u8 txtone[2];

  u8 unused1;

  u8 pttid:2,

     specialqtb:1,

     unused3:1,

     unused4:1,

     bclb:1,

     unused5:1,

     unused2:1;

  u8 unused6:1,

     unused7:1,

     lowpowerb:2,

     wideb:1,

     unused8:1,

     offsetb:2;

  u8 unused10;

} vfob;

//#seekto 0x1978;

lbcd fmvfo[4];

#seekto 0x1c08;

struct {

  char msg1[16];

  char msg2[16];

  char msg3[16];

} poweron_msg;

#seekto 0x1f28;

struct{

  u8 micgain;

} mic;

"""

# basic settings

SQUELCH = ['%s' % x for x in range(0, 10)]

LIGHT_LIST = ["CONT", "5s", "10s", "15s", "30s"]

VOICE_PRMPT_LIST = ["OFF", "ON"]

AUTOLOCK_LIST = ["OFF", "ON"]

TIME_OUT_LIST = ["OFF", "60s", "120s", "180s"]

MDFA_LIST = ["Frequency", "Name"]

MDFB_LIST = ["Frequency", "Name"]

SYNC_LIST = ["ON", "OFF"]

LANG_LIST = ["Chinese", "English"]

BTV_SAVER_LIST = ["OFF", "1:1", "1:2", "1:3", "1:4"]

DBRX_LIST = ["OFF", "ON"]

ASTEP_LIST = ["2.50K", "5.00K", "6.25K",

              "10.00K", "12.00K", "25.00K", "50.00K"]

BSTEP_LIST = ["2.50K", "5.00K", "6.25K",

              "10.00K", "12.00K", "25.00K", "50.00K"]

SCAN_MODE_LIST = ["TO", "CO", "SE"]

PRIO_LIST = ["Edit", "Busy"]

SHORT_KEY_LIST = ["None", "FM Radio", "Lamp", "Monitor",

                  "TONE", "Alarm", "Weather"]

LONG_KEY_LIST = ["None", "FM Radio", "Lamp",

                 "Monitor", "TONE", "Alarm", "Weather"]

BUSYLOCK_LIST = ["Off", "On"]

PRESS_NAME = ["stopkey1", "ssidekey1", "ssidekey2",

              "ltopkey2", "lsidekey3", "lsidekey4"]

VFOA_NAME = ["rxfreqa",

             "txfreq",

             "rxtone",

             "txtone",

             "pttid",

             "specialqta",

             "bcl",

             "lowpower",

             "wide",

             "offset"]

VFOB_NAME = ["rxfreqb",

             "txfreq",

             "rxtoneb",

             "txtone",

             "pttid",

             "specialqtb",

             "bclb",

             "lowpowerb",

             "wideb",

             "offsetb"]

# KEY

VOX_GAIN = ["OFF", "1", "2", "3", "4", "5"]

VOX_DELAY = ["1.05s", "2.0s", "3.0s"]

PTTID_VALUES = ["Off", "BOT", "EOT", "BOTH"]

BCLOCK_VALUES = ["Off", "On"]

FREQHOP_VALUES = ["Off", "On"]

SCAN_VALUES = ["Del", "Add"]

# AB CHANNEL

A_OFFSET = ["Off", "-", "+"]

A_TX_POWER = ["Low", "Mid", "High"]

A_BAND = ["Wide", "Narrow"]

A_BUSYLOCK = ["Off", "On"]

A_SPEC_QTDQT = ["Off", "On"]

A_WORKMODE = ["VFO", "VFO+CH", "CH Mode"]

B_OFFSET = ["Off", "-", "+"]

B_TX_POWER = ["Low", "Mid", "High"]

B_BAND = ["Wide", "Narrow"]

B_BUSYLOCK = ["Off", "On"]

B_SPEC_QTDQT = ["Off", "On"]

B_WORKMODE = ["VFO", "VFO+CH", "CH Mode"]

# FM

FM_WORKMODE = ["CH", "VFO"]

FM_CHANNEL = ['%s' % x for x in range(0, 26)]

# DTMF

GROUPCODE = ["", "Off", "*", "#", "A", "B", "C", "D"]

AB_LIST = ["A", "B"]

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

BANDWIDTH_LIST = ["Wide", "Narrow"]

COLOR_LIST = ["Off", "Blue", "Orange", "Purple"]

DTMFSPEED_LIST = ["%s ms" % x for x in range(50, 2010, 10)]

DTMFST_LIST = ["OFF", "DT-ST", "ANI-ST", "DT+ANI"]

MODE_LIST = ["Channel", "Name", "Frequency"]

PONMSG_LIST = ["Full", "Message", "Icon"]

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

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

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

RESUME_LIST = ["TO", "CO", "SE"]

ROGERRX_LIST = ["Off"] + AB_LIST

RPSTE_LIST = ["OFF"] + ["%s" % x for x in range(1, 11)]

SAVE_LIST = ["Off", "1:1", "1:2", "1:3", "1:4"]

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

SHIFTD_LIST = ["Off", "+", "-"]

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

STEPS = [2.5, 5.0, 6.25, 10.0, 12.5, 25.0]

STEP_LIST = [str(x) for x in STEPS]

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

STEP291_LIST = [str(x) for x in STEPS]

TDRAB_LIST = ["Off"] + AB_LIST

TDRCH_LIST = ["CH%s" % x for x in range(1, 129)]

TIMEOUT_LIST = ["%s sec" % x for x in range(15, 615, 15)] + \

    ["Off (if supported by radio)"]

VOICE_LIST = ["Off", "English", "Chinese"]

VOX_LIST = ["OFF"] + ["%s" % x for x in range(1, 11)]

WORKMODE_LIST = ["Frequency", "Channel"]

# mic

MIC_GAIN_LIST = ['%s' % x for x in range(0, 10)]

MIC_GAIN_LIST_H8 = ['%s' % x for x in range(0, 33)]

H8_LIST = ["TD-H8", "TD-H8-HAM", "TD-H8-GMRS"]

GMRS_FREQS = bandplan_na.GMRS_HIRPT

NOAA_FREQS = [162550000, 162400000, 162475000, 162425000, 162450000,

              162500000, 162525000, 161650000, 161775000, 161750000,

              162000000]

HAM_GMRS_NAME = ["NOAA 1", "NOAA 2", "NOAA 3", "NOAA 4", "NOAA 5", "NOAA 6",

                 "NOAA 7", "NOAA 8", "NOAA 9", "NOAA 10", "NOAA 11"]

ALL_MODEL = ["TD-H8", "TD-H8-HAM", "TD-H8-GMRS", "TD-H3",

             "TD-H3-HAM", "TD-H3-GMRS"]

TD_H8 = b"\x50\x56\x4F\x4A\x48\x1C\x14"

TD_H3 = b"\x50\x56\x4F\x4A\x48\x5C\x14"

def in_range(freq, ranges):

    for lo, hi in ranges:

        if lo <= freq <= hi:

            return True

    return False

def _do_status(radio, block):

    status = chirp_common.Status()

    status.msg = "Cloning"

    status.cur = block

    status.max = radio._memsize

    radio.status_fn(status)

def _upper_band_from_data(data):

    return data[0x03:0x04]

def _upper_band_from_image(radio):

    return _upper_band_from_data(radio.get_mmap())

def _firmware_version_from_data(data, version_start, version_stop):

    version_tag = data[version_start:version_stop]

    return version_tag

def _firmware_version_from_image(radio):

    version = _firmware_version_from_data(radio.get_mmap(),

                                          radio._fw_ver_file_start,

                                          radio._fw_ver_file_stop)

    # LOG.debug("_firmware_version_from_image: " + util.hexprint(version))

    return version

def _do_ident(serial, magic, secondack=True):

    serial.timeout = 1

    LOG.info("Sending Magic: %s" % util.hexprint(magic))

    serial.write(magic)

    ack = serial.read(1)

    if ack != b"\x06":

        if ack:

            # LOG.debug(repr(ack))

            pass

        raise errors.RadioError("Radio did not respond")

    serial.write(b"\x02")

    response = b""

    for i in range(1, 9):

        byte = serial.read(1)

        response += byte

        if byte == b"\xDD":

            break

    if len(response) in [8, 12]:

        # DEBUG

        LOG.info("Valid response, got this:")

        LOG.info(util.hexprint(response))

        if len(response) == 12:

            ident = response[0] + response[3] + response[5] + response[7:]

        else:

            ident = response

    else:

        # bad response

        msg = "Unexpected response, got this:"

        msg += util.hexprint(response)

        LOG.debug(msg)

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

    if secondack:

        serial.write(b"\x06")

        ack = serial.read(1)

        if ack != b"\x06":

            raise errors.RadioError("Radio refused clone")

    return ident

def response_mode(mode):

    data = mode

    return data

def _read_block(radio, start, size):

    serial = radio.pipe

    cmd = struct.pack(">cHb", b'R', start, size)

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

    try:

        serial.write(cmd)

        response = serial.read(5 + size)

        if response[:4] != expectedresponse:

            raise errors.RadioError("Error reading block %04x." % (start))

        block_data = response[4:-1]

    except Exception:

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

    return block_data

def _get_radio_firmware_version(radio):

    if radio.MODEL in ALL_MODEL:

        block = _read_block(radio, 0x1B40, 0x20)

        version = block[0:6]

    return version

IDENT_BLACKLIST = {

    b"\x50\x56\x4F\x4A\x48\x1C\x14": "Radio identifies as TIDRADIO TD-H8",

}

def _do_download(radio):

    # Radio must have already been ident'd by detect_from_serial()

    data = radio.ident_mode

    # Main block

    LOG.info("Downloading...")

    for i in range(0, radio._memsize, 0x20):

        block = _read_block(radio, i, 0x20)

        data += block

        _do_status(radio, i)

    _do_status(radio, radio._memsize)

    LOG.info("done.")

    return memmap.MemoryMapBytes(data)

def _exit_write_block(radio):

    serial = radio.pipe

    try:

        serial.write(b"E")

    except Exception:

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

def _write_block(radio, addr, data):

    serial = radio.pipe

    cmd = struct.pack(">cHb", b'W', addr, 0x20)

    data = radio.get_mmap()[addr + 8: addr + 40]

    # The checksum needs to be in the last

    check_sum = bytes([sum(data) & 0xFF])

    data += check_sum

    used_data = cmd + data

    serial.write(used_data)

    ack = radio.pipe.read(1)

    if ack != b"\x06":

        raise errors.RadioError("Radio refused to accept block 0x%04x" % addr)

def _do_upload(radio):

    data = _do_ident(radio.pipe, radio._idents[0])

    radio_version = _get_radio_firmware_version(radio)

    LOG.info("Radio Version is %s" % repr(radio_version))

    if radio.ident_mode == data:

        LOG.info("Successful match.")

    else:

        msg = ("Model mismatch!")

        raise errors.RadioError(msg)

    # Main block

    LOG.debug("Uploading...")

    for start_addr, end_addr in radio._ranges_main:

        for addr in range(start_addr, end_addr, 0x20):

            _write_block(radio, addr, 0x20)

            _do_status(radio, addr)

    _exit_write_block(radio)

    LOG.debug("Upload all done.")

TDH8_CHARSET = chirp_common.CHARSET_ALPHANUMERIC + \

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

@directory.register

class TDH8(chirp_common.CloneModeRadio):

    """TIDRADIO TD-H8"""

    VENDOR = "TIDRADIO"

    MODEL = "TD-H8"

    ident_mode = b'P31183\xff\xff'

    BAUD_RATE = 38400

    NEEDS_COMPAT_SERIAL = False

    _memsize = 0x1eef

    _ranges_main = [(0x0000, 0x1eef)]

    _idents = [TD_H8]

    _txbands = [(136000000, 175000000), (400000000, 521000000)]

    _rxbands = []

    _aux_block = True

    _tri_power = True

    _gmrs = False

    _ham = False

    _mem_params = (0x1F2F)

    # offset of fw version in image file

    _fw_ver_file_start = 0x1838

    _fw_ver_file_stop = 0x1846

    _valid_chars = TDH8_CHARSET

    _tx_power = [chirp_common.PowerLevel("Low",  watts=1.00),

                 chirp_common.PowerLevel("Mid",  watts=4.00),

                 chirp_common.PowerLevel("High", watts=8.00)]

    @classmethod

    def detect_from_serial(cls, pipe):

        ident = _do_ident(pipe, cls._idents[0])

        for rclass in [cls] + cls.detected_models():

            if (rclass.ident_mode == ident and

                    rclass.MODEL.startswith(cls.MODEL)):

                return rclass

        LOG.error('No model match found for %r', ident)

        raise errors.RadioError('Unsupported model')

    @classmethod

    def get_prompts(cls):

        rp = chirp_common.RadioPrompts()

        rp.pre_download = (dedent("""\

            1. Turn radio off.

            2. Connect cable to mic/spkr connector.

            3. Make sure connector is firmly connected.

            4. Turn radio on (volume may need to be set at 100%).

            5. Ensure that the radio is tuned to channel with no activity.

            6. Click OK to download image from device."""))

        rp.pre_upload = (dedent("""\

            1. Turn radio off.

            2. Connect cable to mic/spkr connector.

            3. Make sure connector is firmly connected.

            4. Turn radio on (volume may need to be set at 100%).

            5. Ensure that the radio is tuned to channel with no activity.

            6. Click OK to upload image to device."""))

        return rp

    def get_features(self):

        rf = chirp_common.RadioFeatures()

        rf.has_settings = True

        rf.has_bank = False

        rf.has_cross = True

        rf.has_ctone = True

        rf.has_rx_dtcs = True

        rf.has_tuning_step = False

        rf.has_ctone = True

        rf.can_odd_split = True

        rf.valid_name_length = 8

        rf.valid_characters = self._valid_chars

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

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

        rf.valid_cross_modes = [

            "Tone->Tone",

            "DTCS->",

            "->DTCS",

            "Tone->DTCS",

            "DTCS->Tone",

            "->Tone",

            "DTCS->DTCS"]

        rf.valid_power_levels = [x for x in self._tx_power if x]

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

        rf.valid_modes = ["FM", "NFM"]

        rf.valid_tuning_steps = STEPS

        rf.valid_bands = self._txbands + self._rxbands

        rf.valid_bands.sort()

        rf.memory_bounds = (1, 199)

        return rf

    def process_mmap(self):

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

    def sync_in(self):

        try:

            self._mmap = _do_download(self)

            self.process_mmap()

        except Exception as e:

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

    def sync_out(self):

        try:

            _do_upload(self)

        except errors.RadioError:

            raise

        except Exception as e:

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

    def get_raw_memory(self, number):

        return repr(self._memobj.memory[number])

    # Encoding processing

    def _decode_tone(self, val):

        if val == 16665 or val == 0:

            return '', None, None

        elif val >= 12000:

            return 'DTCS', val - 12000, 'R'

        elif val >= 8000:

            return 'DTCS', val - 8000, 'N'

        else:

            return 'Tone', val / 10.0, None

    # Decoding processing

    def _encode_tone(self, memval, mode, value, pol):

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

        return self._memobj.memory[number]

    def _get_nam(self, number):

        return self._memobj.names[number - 1]

    def _get_fm(self, number):

        return self._memobj.fmmode[number]

    def _get_get_scanvfo(self, number):

        return self._memobj.fmvfo[number]

    def get_memory(self, number):

        _mem = self._get_mem(number)

        _nam = self._get_nam(number)

        mem = chirp_common.Memory()

        mem.number = number

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