CHIRP

# Copyright 2010 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 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 threading

import os

import sys

import time

import logging

from chirp import chirp_common, errors, directory, util

from chirp.settings import RadioSetting, RadioSettingGroup, \

    RadioSettingValueInteger, RadioSettingValueBoolean, \

    RadioSettingValueString, RadioSettingValueList, RadioSettings

LOG = logging.getLogger(__name__)

NOCACHE = "CHIRP_NOCACHE" in os.environ

DUPLEX = {0: "", 1: "+", 2: "-"}

MODES = {0: "FM", 1: "AM"}

STEPS = list(chirp_common.TUNING_STEPS)

STEPS.append(100.0)

KENWOOD_TONES = list(chirp_common.TONES)

KENWOOD_TONES.remove(159.8)

KENWOOD_TONES.remove(165.5)

KENWOOD_TONES.remove(171.3)

KENWOOD_TONES.remove(177.3)

KENWOOD_TONES.remove(183.5)

KENWOOD_TONES.remove(189.9)

KENWOOD_TONES.remove(196.6)

KENWOOD_TONES.remove(199.5)

THF6_MODES = ["FM", "WFM", "AM", "LSB", "USB", "CW"]

RADIO_IDS = {

    "ID019": "TS-2000",

    "ID009": "TS-850",

    "ID020": "TS-480_LiveMode",

    "ID021": "TS-590S/SG_LiveMode",         # S-model uses same class

    "ID023": "TS-590S/SG_LiveMode"          # as SG

}

LOCK = threading.Lock()

COMMAND_RESP_BUFSIZE = 8

LAST_BAUD = 4800

LAST_DELIMITER = ("\r", " ")

# The Kenwood TS-2000, TS-480, TS-590 & TS-850 use ";"

# as a CAT command message delimiter, and all others use "\n".

# Also, TS-2000 and TS-590 don't space delimite the command

# fields, but others do.

def _command(ser, cmd, *args):

    """Send @cmd to radio via @ser"""

    global LOCK, LAST_DELIMITER, COMMAND_RESP_BUFSIZE

    start = time.time()

    # TODO: This global use of LAST_DELIMITER breaks reentrancy

    # and needs to be fixed.

    if args:

        cmd += LAST_DELIMITER[1] + LAST_DELIMITER[1].join(args)

    cmd += LAST_DELIMITER[0]

    LOG.debug("PC->RADIO: %s" % cmd.strip())

    ser.write(cmd.encode('cp1252'))

    result = ""

    while not result.endswith(LAST_DELIMITER[0]):

        result += ser.read(COMMAND_RESP_BUFSIZE).decode('cp1252')

        if (time.time() - start) > 0.5:

            LOG.error("Timeout waiting for data")

            break

    if result.endswith(LAST_DELIMITER[0]):

        LOG.debug("RADIO->PC: %r" % result.strip())

        result = result[:-1]

    else:

        LOG.error("Giving up")

    return result.strip()

def command(ser, cmd, *args):

    with LOCK:

        return _command(ser, cmd, *args)

def get_id(ser):

    """Get the ID of the radio attached to @ser"""

    global LAST_BAUD

    bauds = [4800, 9600, 19200, 38400, 57600, 115200]

    bauds.remove(LAST_BAUD)

    # Make sure LAST_BAUD is last so that it is tried first below

    bauds.append(LAST_BAUD)

    global LAST_DELIMITER

    command_delimiters = [("\r", " "), (";", "")]

    for delimiter in command_delimiters:

        # Process the baud options in reverse order so that we try the

        # last one first, and then start with the high-speed ones next

        for i in reversed(bauds):

            LAST_DELIMITER = delimiter

            LOG.info("Trying ID at baud %i with delimiter \"%s\"" %

                     (i, repr(delimiter)))

            ser.baudrate = i

            ser.write(LAST_DELIMITER[0].encode())

            ser.read(25)

            try:

                resp = command(ser, "ID")

            except UnicodeDecodeError:

                # If we got binary here, we are using the wrong rate

                # or not talking to a kenwood live radio.

                continue

            # most kenwood radios

            if " " in resp:

                LAST_BAUD = i

                return resp.split(" ")[1]

            # Radio responded in the right baud rate,

            # but threw an error because of all the crap

            # we have been hurling at it. Retry the ID at this

            # baud rate, which will almost definitely work.

            if "?" in resp:

                resp = command(ser, "ID")

                LAST_BAUD = i

                if " " in resp:

                    return resp.split(" ")[1]

            # Kenwood radios that return ID numbers

            if resp in list(RADIO_IDS.keys()):

                return RADIO_IDS[resp]

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

def get_tmode(tone, ctcss, dcs):

    """Get the tone mode based on the values of the tone, ctcss, dcs"""

    if dcs and int(dcs) == 1:

        return "DTCS"

    elif int(ctcss):

        return "TSQL"

    elif int(tone):

        return "Tone"

    else:

        return ""

def iserr(result):

    """Returns True if the @result from a radio is an error"""

    return result in ["N", "?"]

class KenwoodLiveRadio(chirp_common.LiveRadio):

    """Base class for all live-mode kenwood radios"""

    BAUD_RATE = 9600

    VENDOR = "Kenwood"

    MODEL = ""

    NEEDS_COMPAT_SERIAL = False

    HARDWARE_FLOW = True

    _vfo = 0

    _upper = 200

    _kenwood_split = False

    _kenwood_valid_tones = list(chirp_common.TONES)

    _has_name = True

    def __init__(self, *args, **kwargs):

        chirp_common.LiveRadio.__init__(self, *args, **kwargs)

        self._memcache = {}

        if self.pipe:

            self.pipe.timeout = 0.1

            radio_id = get_id(self.pipe)

            if radio_id != self.MODEL.split(" ")[0]:

                raise Exception("Radio reports %s (not %s)" % (radio_id,

                                                               self.MODEL))

            command(self.pipe, "AI", "0")

    def _cmd_get_memory(self, number):

        return "MR", "%i,0,%03i" % (self._vfo, number)

    def _cmd_get_memory_name(self, number):

        return "MNA", "%i,%03i" % (self._vfo, number)

    def _cmd_get_split(self, number):

        return "MR", "%i,1,%03i" % (self._vfo, number)

    def _cmd_set_memory(self, number, spec):

        if spec:

            spec = "," + spec

        return "MW", "%i,0,%03i%s" % (self._vfo, number, spec)

    def _cmd_set_memory_name(self, number, name):

        return "MNA", "%i,%03i,%s" % (self._vfo, number, name)

    def _cmd_set_split(self, number, spec):

        return "MW", "%i,1,%03i,%s" % (self._vfo, number, spec)

    def get_raw_memory(self, number):

        return command(self.pipe, *self._cmd_get_memory(number))

    def get_memory(self, number):

        if number < 0 or number > self._upper:

            raise errors.InvalidMemoryLocation(

                "Number must be between 0 and %i" % self._upper)

        if number in self._memcache and not NOCACHE:

            return self._memcache[number]

        result = command(self.pipe, *self._cmd_get_memory(number))

        if result == "N" or result == "E":

            mem = chirp_common.Memory()

            mem.number = number

            mem.empty = True

            self._memcache[mem.number] = mem

            return mem

        elif " " not in result:

            LOG.error("Not sure what to do with this: `%s'" % result)

            raise errors.RadioError("Unexpected result returned from radio")

        value = result.split(" ")[1]

        spec = value.split(",")

        mem = self._parse_mem_spec(spec)

        self._memcache[mem.number] = mem

        if self._has_name:

            result = command(self.pipe, *self._cmd_get_memory_name(number))

            if " " in result:

                value = result.split(" ", 1)[1]

                if value.count(",") == 2:

                    _zero, _loc, mem.name = value.split(",")

                else:

                    _loc, mem.name = value.split(",")

        if mem.duplex == "" and self._kenwood_split:

            result = command(self.pipe, *self._cmd_get_split(number))

            if " " in result:

                value = result.split(" ", 1)[1]

                self._parse_split_spec(mem, value.split(","))

        return mem

    def _make_mem_spec(self, mem):

        pass

    def _parse_mem_spec(self, spec):

        pass

    def _parse_split_spec(self, mem, spec):

        mem.duplex = "split"

        mem.offset = int(spec[2])

    def _make_split_spec(self, mem):

        return ("%011i" % mem.offset, "0")

    def set_memory(self, memory):

        if memory.number < 0 or memory.number > self._upper:

            raise errors.InvalidMemoryLocation(

                "Number must be between 0 and %i" % self._upper)

        spec = self._make_mem_spec(memory)

        spec = ",".join(spec)

        r1 = command(self.pipe, *self._cmd_set_memory(memory.number, spec))

        if not iserr(r1) and self._has_name:

            time.sleep(0.5)

            r2 = command(self.pipe, *self._cmd_set_memory_name(memory.number,

                                                               memory.name))

            if not iserr(r2):

                memory.name = memory.name.rstrip()

                self._memcache[memory.number] = memory

            else:

                raise errors.InvalidDataError("Radio refused name %i: %s" %

                                              (memory.number,

                                               repr(memory.name)))

        elif self._has_name:

            raise errors.InvalidDataError("Radio refused %i" % memory.number)

        if memory.duplex == "split" and self._kenwood_split:

            spec = ",".join(self._make_split_spec(memory))

            result = command(self.pipe, *self._cmd_set_split(memory.number,

                                                             spec))

            if iserr(result):

                raise errors.InvalidDataError("Radio refused %i" %

                                              memory.number)

    def erase_memory(self, number):

        if number not in self._memcache:

            return

        resp = command(self.pipe, *self._cmd_set_memory(number, ""))

        if iserr(resp):

            raise errors.RadioError("Radio refused delete of %i" % number)

        del self._memcache[number]

    def _kenwood_get(self, cmd):

        resp = command(self.pipe, cmd)

        if " " in resp:

            return resp.split(" ", 1)

        else:

            if resp == cmd:

                return [resp, ""]

            else:

                raise errors.RadioError("Radio refused to return %s" % cmd)

    def _kenwood_set(self, cmd, value):

        resp = command(self.pipe, cmd, value)

        if resp[:len(cmd)] == cmd:

            return

        raise errors.RadioError("Radio refused to set %s" % cmd)

    def _kenwood_get_bool(self, cmd):

        _cmd, result = self._kenwood_get(cmd)

        return result == "1"

    def _kenwood_set_bool(self, cmd, value):

        return self._kenwood_set(cmd, str(int(value)))

    def _kenwood_get_int(self, cmd):

        _cmd, result = self._kenwood_get(cmd)

        return int(result)

    def _kenwood_set_int(self, cmd, value, digits=1):

        return self._kenwood_set(cmd, ("%%0%ii" % digits) % value)

    def set_settings(self, settings):

        for element in settings:

            if not isinstance(element, RadioSetting):

                self.set_settings(element)

                continue

            if not element.changed():

                continue

            if isinstance(element.value, RadioSettingValueBoolean):

                self._kenwood_set_bool(element.get_name(), element.value)

            elif isinstance(element.value, RadioSettingValueList):

                options = self._get_setting_options(element.get_name())

                if len(options) > 9:

                    digits = 2

                else:

                    digits = 1

                self._kenwood_set_int(element.get_name(),

                                      options.index(str(element.value)),

                                      digits)

            elif isinstance(element.value, RadioSettingValueInteger):

                if element.value.get_max() > 9:

                    digits = 2

                else:

                    digits = 1

                self._kenwood_set_int(element.get_name(),

                                      element.value, digits)

            elif isinstance(element.value, RadioSettingValueString):

                self._kenwood_set(element.get_name(), str(element.value))

            else:

                LOG.error("Unknown type %s" % element.value)

class KenwoodOldLiveRadio(KenwoodLiveRadio):

    _kenwood_valid_tones = list(chirp_common.OLD_TONES)

    def set_memory(self, memory):

        supported_tones = list(chirp_common.OLD_TONES)

        supported_tones.remove(69.3)

        if memory.rtone not in supported_tones:

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

                                              "tone %.1fHz" % memory.rtone)

        if memory.ctone not in supported_tones:

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

                                              "tone %.1fHz" % memory.ctone)

        return KenwoodLiveRadio.set_memory(self, memory)

@directory.register

class THD7Radio(KenwoodOldLiveRadio):

    """Kenwood TH-D7"""

    MODEL = "TH-D7"

    _kenwood_split = True

    _BEP_OPTIONS = ["Off", "Key", "Key+Data", "All"]

    _POSC_OPTIONS = ["Off Duty", "Enroute", "In Service", "Returning",

                     "Committed", "Special", "Priority", "Emergency"]

    _SETTINGS_OPTIONS = {

        "BAL": ["4:0", "3:1", "2:2", "1:3", "0:4"],

        "BEP": None,

        "BEPT": ["Off", "Mine", "All New"],  # D700 has fourth "All"

        "DS": ["Data Band", "Both Bands"],

        "DTB": ["A", "B"],

        "DTBA": ["A", "B", "A:TX/B:RX"],  # D700 has fourth A:RX/B:TX

        "DTX": ["Manual", "PTT", "Auto"],

        "ICO": ["Kenwood", "Runner", "House", "Tent", "Boat", "SSTV",

                "Plane", "Speedboat", "Car", "Bicycle"],

        "MNF": ["Name", "Frequency"],

        "PKSA": ["1200", "9600"],

        "POSC": None,

        "PT": ["100ms", "200ms", "500ms", "750ms",

               "1000ms", "1500ms", "2000ms"],

        "SCR": ["Time", "Carrier", "Seek"],

        "SV": ["Off", "0.2s", "0.4s", "0.6s", "0.8s", "1.0s",

               "2s", "3s", "4s", "5s"],

        "TEMP": ["F", "C"],

        "TXI": ["30sec", "1min", "2min", "3min", "4min", "5min",

                "10min", "20min", "30min"],

        "UNIT": ["English", "Metric"],

        "WAY": ["Off", "6 digit NMEA", "7 digit NMEA", "8 digit NMEA",

                "9 digit NMEA", "6 digit Magellan", "DGPS"],

    }

    def get_features(self):

        rf = chirp_common.RadioFeatures()

        rf.has_settings = True

        rf.has_dtcs = False

        rf.has_dtcs_polarity = False

        rf.has_bank = False

        rf.has_mode = True

        rf.has_tuning_step = False

        rf.can_odd_split = True

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

        rf.valid_modes = list(MODES.values())

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

        rf.valid_characters = \

            chirp_common.CHARSET_ALPHANUMERIC + "/.-+*)('&%$#! ~}|{"

        rf.valid_name_length = 7

        rf.valid_tuning_steps = STEPS

        rf.memory_bounds = (1, self._upper)

        return rf

    def _make_mem_spec(self, mem):

        if mem.duplex in " -+":

            duplex = util.get_dict_rev(DUPLEX, mem.duplex)

            offset = mem.offset

        else:

            duplex = 0

            offset = 0

        spec = (

            "%011i" % mem.freq,

            "%X" % STEPS.index(mem.tuning_step),

            "%i" % duplex,

            "0",

            "%i" % (mem.tmode == "Tone"),

            "%i" % (mem.tmode == "TSQL"),

            "",  # DCS Flag

            "%02i" % (self._kenwood_valid_tones.index(mem.rtone) + 1),

            "",  # DCS Code

            "%02i" % (self._kenwood_valid_tones.index(mem.ctone) + 1),

            "%09i" % offset,

            "%i" % util.get_dict_rev(MODES, mem.mode),

            "%i" % ((mem.skip == "S") and 1 or 0))

        return spec

    def _parse_mem_spec(self, spec):

        mem = chirp_common.Memory()

        mem.number = int(spec[2])

        mem.freq = int(spec[3], 10)

        mem.tuning_step = STEPS[int(spec[4], 16)]

        mem.duplex = DUPLEX[int(spec[5])]

        mem.tmode = get_tmode(spec[7], spec[8], spec[9])

        mem.rtone = self._kenwood_valid_tones[int(spec[10]) - 1]

        mem.ctone = self._kenwood_valid_tones[int(spec[12]) - 1]

        if spec[11] and spec[11].isdigit():

            mem.dtcs = chirp_common.DTCS_CODES[int(spec[11][:-1]) - 1]

        else:

            LOG.warn("Unknown or invalid DCS: %s" % spec[11])

        if spec[13]:

            mem.offset = int(spec[13])

        else:

            mem.offset = 0

        mem.mode = MODES[int(spec[14])]

        mem.skip = int(spec[15]) and "S" or ""

        return mem

    EXTRA_BOOL_SETTINGS = {

        'main': [("LMP", "Lamp")],

        'dtmf': [("TXH", "TX Hold")],

    }

    EXTRA_LIST_SETTINGS = {

        'main': [("BAL", "Balance"),

                 ("MNF", "Memory Display Mode")],

        'save': [("SV", "Battery Save")],

    }

    def _get_setting_options(self, setting):

        opts = self._SETTINGS_OPTIONS[setting]

        if opts is None:

            opts = getattr(self, '_%s_OPTIONS' % setting)

        return opts

    def get_settings(self):

        main = RadioSettingGroup("main", "Main")

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

        tnc = RadioSettingGroup("tnc", "TNC")

        save = RadioSettingGroup("save", "Save")

        display = RadioSettingGroup("display", "Display")

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

        radio = RadioSettingGroup("radio", "Radio",

                                  aux, tnc, save, display, dtmf)

        sky = RadioSettingGroup("sky", "SkyCommand")

        aprs = RadioSettingGroup("aprs", "APRS")

        top = RadioSettings(main, radio, aprs, sky)

        bools = [("AMR", aprs, "APRS Message Auto-Reply"),

                 ("AIP", aux, "Advanced Intercept Point"),

                 ("ARO", aux, "Automatic Repeater Offset"),

                 ("BCN", aprs, "Beacon"),

                 ("CH", radio, "Channel Mode Display"),

                 # ("DIG", aprs, "APRS Digipeater"),

                 ("DL", main, "Dual"),

                 ("LK", main, "Lock"),

                 ("TSP", dtmf, "DTMF Fast Transmission"),

                 ]

        for setting, group, name in bools:

            value = self._kenwood_get_bool(setting)

            rs = RadioSetting(setting, name,

                              RadioSettingValueBoolean(value))

            group.append(rs)

        lists = [("BEP", aux, "Beep"),

                 ("BEPT", aprs, "APRS Beep"),

                 ("DS", tnc, "Data Sense"),

                 ("DTB", tnc, "Data Band"),

                 ("DTBA", aprs, "APRS Data Band"),

                 ("DTX", aprs, "APRS Data TX"),

                 # ("ICO", aprs, "APRS Icon"),

                 ("PKSA", aprs, "APRS Packet Speed"),

                 ("POSC", aprs, "APRS Position Comment"),

                 ("PT", dtmf, "DTMF Speed"),

                 ("TEMP", aprs, "APRS Temperature Units"),

                 ("TXI", aprs, "APRS Transmit Interval"),

                 # ("UNIT", aprs, "APRS Display Units"),

                 ("WAY", aprs, "Waypoint Mode"),

                 ]

        for setting, group, name in lists:

            value = self._kenwood_get_int(setting)

            options = self._get_setting_options(setting)

            rs = RadioSetting(setting, name,

                              RadioSettingValueList(options,

                                                    options[value]))

            group.append(rs)

        for group_name, settings in self.EXTRA_BOOL_SETTINGS.items():

            group = locals()[group_name]

            for setting, name in settings:

                value = self._kenwood_get_bool(setting)

                rs = RadioSetting(setting, name,

                                  RadioSettingValueBoolean(value))

                group.append(rs)

        for group_name, settings in self.EXTRA_LIST_SETTINGS.items():

            group = locals()[group_name]

            for setting, name in settings:

                value = self._kenwood_get_int(setting)

                options = self._get_setting_options(setting)

                rs = RadioSetting(setting, name,

                                  RadioSettingValueBoolean(value))

                group.append(rs)

        ints = [("CNT", display, "Contrast", 1, 16),

                ]

        for setting, group, name, minv, maxv in ints:

            value = self._kenwood_get_int(setting)

            rs = RadioSetting(setting, name,

                              RadioSettingValueInteger(minv, maxv, value))

            group.append(rs)

        strings = [("MES", display, "Power-on Message", 8),

                   ("MYC", aprs, "APRS Callsign", 8),

                   ("PP", aprs, "APRS Path", 32),

                   ("SCC", sky, "SkyCommand Callsign", 8),

                   ("SCT", sky, "SkyCommand To Callsign", 8),

                   # ("STAT", aprs, "APRS Status Text", 32),

                   ]

        for setting, group, name, length in strings:

            _cmd, value = self._kenwood_get(setting)

            rs = RadioSetting(setting, name,

                              RadioSettingValueString(0, length, value))

            group.append(rs)

        return top

@directory.register

class THD7GRadio(THD7Radio):

    """Kenwood TH-D7G"""

    MODEL = "TH-D7G"

    def get_features(self):

        rf = super(THD7GRadio, self).get_features()

        rf.valid_name_length = 8

        return rf

@directory.register

class TMD700Radio(THD7Radio):

    """Kenwood TH-D700"""

    MODEL = "TM-D700"

    _kenwood_split = True

    _BEP_OPTIONS = ["Off", "Key"]

    _POSC_OPTIONS = ["Off Duty", "Enroute", "In Service", "Returning",

                     "Committed", "Special", "Priority", "CUSTOM 0",

                     "CUSTOM 1", "CUSTOM 2", "CUSTOM 4", "CUSTOM 5",

                     "CUSTOM 6", "Emergency"]

    EXTRA_BOOL_SETTINGS = {}

    EXTRA_LIST_SETTINGS = {}

    def get_features(self):

        rf = chirp_common.RadioFeatures()

        rf.has_settings = True

        rf.has_dtcs = True

        rf.has_dtcs_polarity = False

        rf.has_bank = False

        rf.has_mode = True

        rf.has_tuning_step = False

        rf.can_odd_split = True

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

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

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

        rf.valid_characters = chirp_common.CHARSET_ALPHANUMERIC

        rf.valid_name_length = 8

        rf.valid_tuning_steps = STEPS

        rf.memory_bounds = (1, self._upper)

        return rf

    def _make_mem_spec(self, mem):

        if mem.duplex in " -+":

            duplex = util.get_dict_rev(DUPLEX, mem.duplex)

        else:

            duplex = 0

        spec = (

            "%011i" % mem.freq,

            "%X" % STEPS.index(mem.tuning_step),

            "%i" % duplex,

            "0",

            "%i" % (mem.tmode == "Tone"),

            "%i" % (mem.tmode == "TSQL"),

            "%i" % (mem.tmode == "DTCS"),

            "%02i" % (self._kenwood_valid_tones.index(mem.rtone) + 1),

            "%03i0" % (chirp_common.DTCS_CODES.index(mem.dtcs) + 1),

            "%02i" % (self._kenwood_valid_tones.index(mem.ctone) + 1),

            "%09i" % mem.offset,

            "%i" % util.get_dict_rev(MODES, mem.mode),

            "%i" % ((mem.skip == "S") and 1 or 0))

        return spec

    def _parse_mem_spec(self, spec):

        mem = chirp_common.Memory()

        mem.number = int(spec[2])

        mem.freq = int(spec[3])

        mem.tuning_step = STEPS[int(spec[4], 16)]

        mem.duplex = DUPLEX[int(spec[5])]

        mem.tmode = get_tmode(spec[7], spec[8], spec[9])

        mem.rtone = self._kenwood_valid_tones[int(spec[10]) - 1]

        mem.ctone = self._kenwood_valid_tones[int(spec[12]) - 1]

        if spec[11] and spec[11].isdigit():

            mem.dtcs = chirp_common.DTCS_CODES[int(spec[11][:-1]) - 1]

        else:

            LOG.warn("Unknown or invalid DCS: %s" % spec[11])

        if spec[13]:

            mem.offset = int(spec[13])

        else:

            mem.offset = 0

        mem.mode = MODES[int(spec[14])]

        mem.skip = int(spec[15]) and "S" or ""

        return mem

@directory.register

class TMV7Radio(KenwoodOldLiveRadio):

    """Kenwood TM-V7"""

    MODEL = "TM-V7"

    mem_upper_limit = 200  # Will be updated

    def get_features(self):

        rf = chirp_common.RadioFeatures()

        rf.has_dtcs = False

        rf.has_dtcs_polarity = False

        rf.has_bank = False

        rf.has_mode = False

        rf.has_tuning_step = False

        rf.valid_modes = ["FM"]

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

        rf.valid_characters = chirp_common.CHARSET_ALPHANUMERIC

        rf.valid_name_length = 7

        rf.valid_tuning_steps = STEPS

        rf.has_sub_devices = True

        rf.memory_bounds = (1, self._upper)

        return rf

    def _make_mem_spec(self, mem):

        spec = (

            "%011i" % mem.freq,

            "%X" % STEPS.index(mem.tuning_step),

            "%i" % util.get_dict_rev(DUPLEX, mem.duplex),

            "0",

            "%i" % (mem.tmode == "Tone"),

            "%i" % (mem.tmode == "TSQL"),

            "0",

            "%02i" % (self._kenwood_valid_tones.index(mem.rtone) + 1),

            "000",

            "%02i" % (self._kenwood_valid_tones.index(mem.ctone) + 1),

            "",

            "0")

        return spec

    def _parse_mem_spec(self, spec):

        mem = chirp_common.Memory()

        mem.number = int(spec[2])

        mem.freq = int(spec[3])