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

import re

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)

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

# The Kenwood TS-2000 uses ";" as a CAT command message delimiter, and all

# others use "\n". Also, TS-2000 doesn't space delimite the command fields,

# but others do.

LAST_DELIMITER = ("\r", " ")

LOCK = threading.Lock()

def command(ser, cmd, *args):

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

    global LOCK, LAST_DELIMITER

    start = time.time()

    LOCK.acquire()

    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)

    result = ""

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

        result += ser.read(8)

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

            LOG.error("Timeout waiting for data")

            break

    if result.endswith(LAST_DELIMITER[0]):

        result = result[:-1]

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

    LOCK.release()

    return result.strip()

LAST_BAUD = 9600

def get_id(ser):

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

    global LAST_BAUD

    bauds = [9600, 19200, 38400, 57600]

    bauds.remove(LAST_BAUD)

    bauds.insert(0, LAST_BAUD)

    global LAST_DELIMITER

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

    for i in bauds:

        for j in command_delimiters:

            LAST_DELIMITER = j

            LOG.info("Trying ID at baud %i" % i)

            ser.setBaudrate(i)

            ser.write(LAST_DELIMITER[0])

            ser.read(25)

            resp = command(ser, "ID")

            # most kenwood radios

            if " " in resp:

                LAST_BAUD = i

                return resp.split(" ")[1]

            # TS-2000

            if "ID019" == resp:

                LAST_BADE = i

                return "TS-2000"

    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 = ""

    _vfo = 0

    _upper = 200

    _kenwood_split = False

    _kenwood_valid_tones = list(chirp_common.TONES)

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

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

        self._memcache = {}

        if self.pipe:

            self.pipe.setTimeout(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

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

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

        else:

            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._SETTINGS_OPTIONS[element.get_name()]

                self._kenwood_set_int(element.get_name(),

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

            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

    _SETTINGS_OPTIONS = {

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

        "BEP": ["Off", "Key", "Key+Data", "All"],

        "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": ["Off Duty", "Enroute", "In Service", "Returning",

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

        "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 = MODES.values()

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

        rf.valid_characters = \

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

        rf.valid_name_length = 7

        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

    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"),

                 ("LMP", main, "Lamp"),

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

                 ("TXH", dtmf, "TX Hold"),

                 ]

        for setting, group, name in bools:

            value = self._kenwood_get_bool(setting)

            rs = RadioSetting(setting, name,

                              RadioSettingValueBoolean(value))

            group.append(rs)

        lists = [("BAL", main, "Balance"),

                 ("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"),

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

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

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

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

                 ("SV", save, "Battery Save"),

                 ("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._SETTINGS_OPTIONS[setting]

            rs = RadioSetting(setting, name,

                              RadioSettingValueList(options,

                                                    options[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(KenwoodOldLiveRadio):

    """Kenwood TH-D700"""

    MODEL = "TM-D700"

    _kenwood_split = True

    def get_features(self):

        rf = chirp_common.RadioFeatures()

        rf.has_dtcs = True

        rf.has_dtcs_polarity = False

        rf.has_bank = False

        rf.has_mode = False

        rf.has_tuning_step = False

        rf.can_odd_split = True

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

        rf.valid_modes = ["FM"]

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

        rf.valid_characters = chirp_common.CHARSET_ALPHANUMERIC

        rf.valid_name_length = 8

        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.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])

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

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

        if int(spec[7]):

            mem.tmode = "Tone"

        elif int(spec[8]):

            mem.tmode = "TSQL"

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

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

        return mem

    def get_sub_devices(self):

        return [TMV7RadioVHF(self.pipe), TMV7RadioUHF(self.pipe)]

    def __test_location(self, loc):

        mem = self.get_memory(loc)

        if not mem.empty:

            # Memory was not empty, must be valid

            return True

        # Mem was empty (or invalid), try to set it

        if self._vfo == 0:

            mem.freq = 144000000

        else:

            mem.freq = 440000000

        mem.empty = False

        try:

            self.set_memory(mem)

        except Exception:

            # Failed, so we're past the limit

            return False

        # Erase what we did

        try:

            self.erase_memory(loc)

        except Exception:

            pass  # V7A Can't delete just yet

        return True

    def _detect_split(self):

        return 50

class TMV7RadioSub(TMV7Radio):

    """Base class for the TM-V7 sub devices"""

    def __init__(self, pipe):

        TMV7Radio.__init__(self, pipe)

        self._detect_split()

class TMV7RadioVHF(TMV7RadioSub):

    """TM-V7 VHF subdevice"""

    VARIANT = "VHF"

    _vfo = 0

class TMV7RadioUHF(TMV7RadioSub):

    """TM-V7 UHF subdevice"""

    VARIANT = "UHF"

    _vfo = 1

@directory.register

class TMG707Radio(TMV7Radio):

    """Kenwood TM-G707"""

    MODEL = "TM-G707"

    def get_features(self):

        rf = TMV7Radio.get_features(self)

        rf.has_sub_devices = False

        rf.memory_bounds = (1, 180)

        rf.valid_bands = [(118000000, 174000000),

                          (300000000, 520000000),

                          (800000000, 999000000)]

        return rf

THG71_STEPS = [5, 6.25, 10, 12.5, 15, 20, 25, 30, 50, 100]

@directory.register

class THG71Radio(TMV7Radio):

    """Kenwood TH-G71"""

    MODEL = "TH-G71"

    def get_features(self):

        rf = TMV7Radio.get_features(self)

        rf.has_tuning_step = True

        rf.valid_tuning_steps = list(THG71_STEPS)

        rf.valid_name_length = 6

        rf.has_sub_devices = False

        rf.valid_bands = [(118000000, 174000000),

                          (320000000, 470000000),

                          (800000000, 945000000)]

        return rf

    def _make_mem_spec(self, mem):

        spec = (

            "%011i" % mem.freq,