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 logging

import math

import os

import threading

from chirp import chirp_common, directory, errors, util

from chirp.settings import RadioSetting, RadioSettingGroup, \

RadioSettingValueInteger, RadioSettingValueBoolean, \

RadioSettingValueString, RadioSettingValueList, RadioSettingValueMap, \

RadioSettings, RadioSettingValueFloat

LOG = logging.getLogger(__name__)

class KenwoodD7Position(RadioSettingGroup):

def __init__(self, name, shortname, radio, *args, **kwargs):

super().__init__(name, shortname, *args, **kwargs)

self._radio = radio

if ' ' in name:

index = name.split(" ", 1)[1]

else:

index = ''

rs = RadioSetting("latd%s" % index, "Latitude degrees",

RadioSettingValueInteger(0, 90, 0))

self.append(rs)

rs = RadioSetting("latm%s" % index, "Latitude minutes",

RadioSettingValueFloat(0, 59.99, 0,

resolution=0.01,

precision=2))

self.append(rs)

rs = RadioSetting("south%s" % index, "South",

RadioSettingValueBoolean(False))

self.append(rs)

rs = RadioSetting("longd%s" % index, "Longitude degrees",

RadioSettingValueInteger(0, 180, 0))

self.append(rs)

rs = RadioSetting("longm%s" % index, "Longitude minutes",

RadioSettingValueFloat(0, 59.99, 0,

resolution=0.01, precision=2))

self.append(rs)

rs = RadioSetting("west%s" % index, "West",

RadioSettingValueBoolean(False))

self.append(rs)

def kenwood_d7_read_value(self):

index = self._get_index()

name = self.get_name()

rawval = self._radio._kenwood_get(name)[1]

curr_value = int(rawval[0:2])

self["latd%s" % index].value.set_value(curr_value)

curr_value = int(rawval[2:6]) / 100

self["latm%s" % index].value.set_value(curr_value)

curr_value = int(rawval[6:8])

self["south%s" % index].value.set_value(curr_value)

curr_value = int(rawval[8:11])

self["longd%s" % index].value.set_value(curr_value)

curr_value = int(rawval[11:15]) / 100

self["longm%s" % index].value.set_value(curr_value)

curr_value = int(rawval[15:17])

self["west%s" % index].value.set_value(curr_value)

self['latd%s' % index].value._has_changed = False

self['latm%s' % index].value._has_changed = False

self['south%s' % index].value._has_changed = False

self['longd%s' % index].value._has_changed = False

self['longm%s' % index].value._has_changed = False

self['west%s' % index].value._has_changed = False

def _get_index(self):

name = self.get_name()

if ' ' in name:

return name.split(" ", 1)[1]

return ''

def changed(self):

index = self._get_index()

if self['latd%s' % index].changed():

return True

if self['latm%s' % index].changed():

return True

if self['south%s' % index].changed():

return True

if self['longd%s' % index].changed():

return True

if self['longm%s' % index].changed():

return True

if self['west%s' % index].changed():

return True

return False

def kenwood_d7_set_value(self):

index = self._get_index()

latd = self['latd%s' % index].value.get_value()

latm = self['latm%s' % index].value.get_value()

latmd = int(round(math.modf(latm)[0] * 100))

latm = int(round(latm))

south = int(self['south%s' % index].value.get_value())

longd = self['longd%s' % index].value.get_value()

longm = self['longm%s' % index].value.get_value()

longmd = int(round(math.modf(longm)[0] * 100))

longm = int(round(longm))

west = int(self['west%s' % index].value.get_value())

args = '%s%02d%02d%02d%02d%03d%02d%02d%02d' % (index,

latd, latm, latmd,

south,

longd, longm, longmd,

west)

if index != '':

index = ' ' + index

self._radio._kenwood_set('MP%s' % index, args)

# TODO: Hacking up _has_changed is bad... but we don't want

# to re-send all the set commands each time either.

self['latd%s' % index].value._has_changed = False

self['latm%s' % index].value._has_changed = False

self['south%s' % index].value._has_changed = False

self['longd%s' % index].value._has_changed = False

self['longm%s' % index].value._has_changed = False

self['west%s' % index].value._has_changed = False

class KenwoodD7DTMFMemory(RadioSettingGroup):

DTMF_CHARSET = "ABCD#*0123456789 "

def __init__(self, name, shortname, radio, *args, **kwargs):

super().__init__(name, shortname, *args, **kwargs)

self._radio = radio

self._name = name

index = self._get_index()

rs = RadioSetting("DMN %s" % index, "Memory Name",

RadioSettingValueString(0, 8, '', False))

self.append(rs)

rs = RadioSetting("DM %s" % index, "Memory Value",

RadioSettingValueString(0, 16, '', False,

self.DTMF_CHARSET))

self.append(rs)

def _get_index(self):

return "%02d" % int(self._name.split(" ", 1)[1])

def kenwood_d7_read_value(self):

index = self._get_index()

value = self._radio._kenwood_get("DM %s" % index)[1]

value = value.replace("E", "*").replace("F", "#")

vname = self._radio._kenwood_get("DMN %s" % index)[1]

self["DMN %s" % index].value.set_value(vname)

self["DMN %s" % index].value._has_changed = False

self["DM %s" % index].value.set_value(value)

self["DM %s" % index].value._has_changed = False

def changed(self):

for element in self:

if element.changed():

return True

return False

def kenwood_d7_set_value(self):

for element in self:

if not element.changed():

continue

newval = element.value.get_value()

newval = newval.replace("*", "E").replace("#", "F")

self._radio._kenwood_set(element.get_name(),

newval)

element.value._has_changed = False

class KenwoodD7ProgrammableVFOs(RadioSettingGroup):

def __init__(self, name, shortname, radio, *args, **kwargs):

self._radio = radio

super().__init__(name, shortname, *args, **kwargs)

for optname, index, minimum, maximum in self._radio._PROGRAMMABLE_VFOS:

group = RadioSettingGroup("PV %d" % index, optname)

self.append(group)

rs = RadioSetting("PV %dL" % index, "Lower Limit",

RadioSettingValueInteger(minimum, maximum,

minimum))

group.append(rs)

rs = RadioSetting("PV %dU" % index, "Upper Limit",

RadioSettingValueInteger(minimum, maximum,

maximum))

group.append(rs)

def _get_index(self, element):

name = element.get_name()

return int(name.split(" ", 1)[1])

def kenwood_d7_read_value(self):

for element in self:

index = self._get_index(element)

rv = self._radio._kenwood_get("PV %d" % index)[1]

lower, upper = rv.split(',', 1)

lower = int(lower)

upper = int(upper)

pvdl = "PV %dL" % index

pvdu = "PV %dU" % index

element[pvdl].value.set_value(lower)

element[pvdl].value._has_changed = False

element[pvdu].value.set_value(upper)

element[pvdu].value._has_changed = False

def changed(self):

for element in self:

for bound in element:

if bound.changed():

return True

return False

# TODO: Custom validator things...

def kenwood_d7_set_value(self):

for element in self:

index = self._get_index(element)

pvdl = "PV %dL" % index

pvdu = "PV %dU" % index

if element[pvdl].changed() or element[pvdu].changed():

lower = element[pvdl].value.get_value()

upper = element[pvdu].value.get_value()

args = "%05d,%05d" % (lower, upper)

self._radio._kenwood_set(element.get_name(), args)

element[pvdl].value._has_changed = False

element[pvdu].value._has_changed = False

class KenwoodD7Family(chirp_common.LiveRadio):

VENDOR = "Kenwood"

MODEL = ""

HARDWARE_FLOW = False

_ARG_DELIMITER = " "

_BAUDS = [9600]

_CMD_DELIMITER = "\r"

_DISABLE_AI_CMD = ('AI', '0')

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

_HAS_NAME = True

_LOCK = threading.Lock()

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

_NOCACHE = "CHIRP_NOCACHE" in os.environ

_SPLIT = True

_STEPS = (5.0, 6.25, 10.0, 12.5, 15.0, 20.0, 25.0, 30.0, 50.0, 100.0)

_TONES = chirp_common.OLD_TONES

_LOWER = 0

_UPPER = 199

_BANDS = []

_CALL_CHANS = ("VHF Call", "UHF Call")

_SPECIAL_CHANS = ("L0", "U0",

"L1", "U1",

"L2", "U2",

"L3", "U3",

"L4", "U4",

"L5", "U5",

"L6", "U6",

"L7", "U7",

"L8", "U8",

"L9", "U9",

*_CALL_CHANS)

# These are used more than once in _COMMON_SETTINGS

_BOOL = {'type': 'bool'}

_DATA_BAND = {'type': 'list',

'values': ("A", "B", "A:TX/B:RX", "A:RX/B:TX")}

_DTMF_MEMORY = {'type': KenwoodD7DTMFMemory}

_ON_OFF_DUAL_MAP = {'type': 'map',

'map': (("Off", "0"), ("On", "1,0")),

'set_requires': (('DL', True),),

'get_requires': (('DL', True),)}

_POSITION = {'type': KenwoodD7Position}

_SSTV_CHARSET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 !?-/"

_SSTV_COLOURS = {'type': 'list',

'values': ("Black", "Blue", "Red", "Magenta", "Green",

"Cyan", "Yellow", "White")}

_STATUS_TEXT = {'type': 'string', 'max_len': 32}

_SQUELCH = {'type': 'list', 'digits': 2,

'values': ("Open", "1", "2", "3", "4", "5")}

# Settings that are shared by at least two radios.

# If a third radio does not have the setting at all, the presence

# here won't matter. If it has it but with different parameters,

# it can be overridden in the subclass _SETTINGS dict.

_COMMON_SETTINGS = {

"AIP": _BOOL,

"ARL": {'type': 'map',

'map': (('Off', '0000'),) + tuple(

[('%i' % x, '%04i' % x)

for x in range(10, 2510, 10)])},

"ARLM": {'type': 'string', 'max_len': 45},

"AMGG": {'type': 'string', 'max_len': 45,

'charset': "ABCDEFGHIJKLMNOPQRSTUVWXYZ*,-0123456789"},

"AMR": _BOOL,

"APO": {'type': 'list',

'values': ("Off", "30min", "60min")},

"ARO": _BOOL,

# ASC x requires that the specified VFO is enabled on TH-D7G

# (ie: dual is on or VFO is current) for both fetch and set

# Easiest to just enable DL before set/read

"ASC 0": _ON_OFF_DUAL_MAP,

"ASC 1": _ON_OFF_DUAL_MAP,

"BAL": {'type': 'list',

'values': ("4:0", "3:1", "2:2", "1:3", "0:4")},

"BC": {'type': 'list',

'values': ("A", "B")},

"BCN": _BOOL,

# BEL x requires that the specified VFO is enabled on TH-D7G

# (ie: dual is on or VFO is current) for both fetch and set

# Easiest to just enable DL before set/read

"BEL 0": _ON_OFF_DUAL_MAP,

"BEL 1": _ON_OFF_DUAL_MAP,

"BEP": {'type': 'list',

'values': ("Off", "Key", "Key+Data", "All")},

"BEPT": {'type': 'list',

'values': ("Off", "Mine", "All New", "All")},

"CH": _BOOL,

"CKEY": {'type': 'list',

'values': ("Call", "1750 Hz")},

"CNT": {'type': 'integer', 'min': 1, 'max': 16},

"DL": _BOOL,

"DS": {'type': 'list',

'values': ("Data Band", "Both Bands")},

"DTB": _DATA_BAND,

"DTBA": _DATA_BAND,

"dtmfmem 00": _DTMF_MEMORY,

"dtmfmem 01": _DTMF_MEMORY,

"dtmfmem 02": _DTMF_MEMORY,

"dtmfmem 03": _DTMF_MEMORY,

"dtmfmem 04": _DTMF_MEMORY,

"dtmfmem 05": _DTMF_MEMORY,

"dtmfmem 06": _DTMF_MEMORY,

"dtmfmem 07": _DTMF_MEMORY,

"dtmfmem 08": _DTMF_MEMORY,

"dtmfmem 09": _DTMF_MEMORY,

"DTX": {'type': 'list',

'values': ("Manual", "PTT", "Auto")},

"ELK": {'type': 'bool'},

"GU": {'type': 'list',

'values': ("Not Used", "NMEA", "NMEA96")},

# This isn't exactly shared, but each radio adds to this list

"ICO": {'type': 'map',

'map': (('Kenwood', '0,0'),

('Runner', '0,1'),

('House ', '0,2'),

('Tent', '0,3'),

('Boat', '0,4'),

('SSTV', '0,5'),

('Plane', '0,6'),

('Speedboat', '0,7'),

('Car', '0,8'),

('Bicycle', '0,9'),

('TRIANGLE(DF station)', '0,A'),

('Jeep', '0,B'),

('Recreational Vehicle', '0,C'),

('Truck ', '0,D'),

('Van', '0,E'))},

"KILO": {'type': 'list',

'values': ("Miles", "Kilometers")},

"LK": _BOOL,

"LMP": _BOOL,

"MAC": _SSTV_COLOURS,

"MES": {'type': 'string', 'max_len': 8},

# NOTE: Requires memory mode to be active

"MNF": {'type': 'list',

'values': ("Name", "Frequency")},

"MP 1": _POSITION,

"MP 2": _POSITION,

"MP 3": _POSITION,

"MYC": {'type': 'string', 'max_len': 9},

"PAMB": {'type': 'list',

'values': ("Off", "1 Digit", "2 Digits", "3 Digits",

"4 Digits")},

"PKSA": {'type': 'list',

'values': ("1200", "9600")},

"POSC": {'type': 'list',

'values': ("Off Duty", "Enroute", "In Service", "Returning",

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

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

"CUSTOM 6", "Emergency")},

"PP": {'type': 'string', 'max_len': 32},

"PT": {'type': 'list',

'values': ("100ms", "200ms", "500ms", "750ms",

"1000ms", "1500ms", "2000ms")},

"PV": {'type': KenwoodD7ProgrammableVFOs},

"RSC": _SSTV_COLOURS,

"RSV": {'type': 'string', 'max_len': 10, 'charset': _SSTV_CHARSET},

"SCC": {'type': 'string', 'max_len': 8},

"SCR": {'type': 'list',

'values': ("Time", "Carrier", "Seek")},

"SCT": {'type': 'string', 'max_len': 8},

"SKTN": {'type': 'map',

'map': tuple([(str(x), "%02d" % (ind + 1))

for ind, x in enumerate(_TONES) if x != 69.3])},

"SMC": _SSTV_COLOURS,

"SMSG": {'type': 'string', 'max_len': 9, 'charset': _SSTV_CHARSET},

"SMY": {'type': 'string', 'max_len': 8, 'charset': _SSTV_CHARSET},

"SQ 0": _SQUELCH,

"SQ 1": _SQUELCH,

"STAT 1": _STATUS_TEXT,

"STAT 2": _STATUS_TEXT,

"STAT 3": _STATUS_TEXT,

"STXR": {'type': 'list',

'values': ("Off", "1/1", "1/2", "1/3", "1/4", "1/5", "1/6",

"1/7", "1/8")},

"SV": {'type': 'list',

'values': ("Off", "0.2s", "0.4s", "0.6s", "0.8s", "1.0s",

"2s", "3s", "4s", "5s")},

"TEMP": {'type': 'list',

'values': ("°F", "°C")},

"TH": _BOOL,

"TNC": _BOOL,

"TSP": _BOOL,

"TXD": {'type': 'map',

'map': (("100ms", "1"), ("200ms", "2"), ("300ms", "3"),

("400ms", "4"), ("500ms", "5"), ("750ms", "6"),

("1000ms", "7"))},

"TXH": _BOOL,

"TXI": {'type': 'list',

'values': ("30sec", "1min", "2min", "3min", "4min", "5min",

"10min", "20min", "30min")},

"TXS": _BOOL,

"TZ": {'type': 'list',

'values': ("UTC - 12:00", "UTC - 11:30", "UTC - 11:00",

"UTC - 10:30", "UTC - 10:00", "UTC - 9:30",

"UTC - 9:00", "UTC - 8:30", "UTC - 8:00",

"UTC - 7:30", "UTC - 7:00", "UTC - 6:30",

"UTC - 6:00", "UTC - 5:30", "UTC - 5:00",

"UTC - 4:30", "UTC - 4:00", "UTC - 3:30",

"UTC - 3:00", "UTC - 2:30", "UTC - 2:00",

"UTC - 1:30", "UTC - 1:00", "UTC - 0:30",

"UTC", "UTC + 0:30", "UTC + 1:00", "UTC + 1:30",

"UTC + 2:00", "UTC + 2:30", "UTC + 3:00",

"UTC + 3:30", "UTC + 4:00", "UTC + 4:30",

"UTC + 5:00", "UTC + 5:30", "UTC + 6:00",

"UTC + 6:30", "UTC + 7:00", "UTC + 7:30",

"UTC + 8:00", "UTC + 8:30", "UTC + 9:00",

"UTC + 9:30", "UTC + 10:00", "UTC + 10:30",

"UTC + 11:00", "UTC + 11:30", "UTC + 12:00")},

"UPR": {'type': 'string', 'max_len': 9,

'charset': "ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789"},

"VCS": _BOOL,

"WAY": {'type': 'list',

'values': ("Off", "6 digit NMEA", "7 digit NMEA",

"8 digit NMEA", "9 digit NMEA", "6 digit Magellan",

"DGPS")}}

_PROGRAMMABLE_VFOS = (

("Band A, 118 MHz Sub-Band", 1, 118, 135),

("Band A, VHF Sub-Band", 2, 136, 173),

("Band B, VHF Sub-Band", 3, 144, 147),

("Band B, UHF Sub-Band", 6, 400, 479))

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

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

# Clear the caches

self._memcache = {}

self._setcache = {}

self._baud = 9600

self._cur_setting = 0

self._setting_count = 0

self._vfo = 0

if self.pipe:

self.pipe.timeout = 0.5

radio_id = self._get_id()

if hasattr(self, '_ID_STRING'):

id_str = self._ID_STRING

else:

id_str = self.MODEL.split(" ")[0]

if radio_id != id_str:

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

id_str))

self._command(*self._DISABLE_AI_CMD)

# This returns the index value for CR/CW commands, not the index

# in the memory list grid

def _call_index(self, memid_or_index):

if isinstance(memid_or_index, int):

memid = self._index_to_memid(memid_or_index)

else:

memid = memid_or_index

return self._CALL_CHANS.index(memid)

# This returns the memid from the index value in CR/CW commands, not

# the index in the memory list grid

def _call_index_to_memid(self, index):

return self._CALL_CHANS[index]

def _cmd_get_memory_name(self, memid):

return "MNA", "%i,%s" % (self._vfo, memid)

def _cmd_get_memory_or_split(self, memid, split):

sd = split and 1 or 0

if self._is_call(memid):

return "CR", "%d,%d" % (self._call_index(memid), split)

return "MR", "%i,%d,%s" % (self._vfo, sd, memid)

def _cmd_set_memory_name(self, memid, name):

if self._is_call(memid):

return None

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

def _cmd_set_memory_or_split(self, memid, memory, split):

if not memory.empty:

spec = "," + ",".join(self._make_mem_spec(memid, memory))

else:

spec = ''

sd = split and 1 or 0

if (self._is_call(memid)):

return "CW", "%d,%d%s" % (self._call_index(memid), sd, spec)

return "MW", "%i,%d,%s%s" % (self._vfo, sd, memid, spec)

def _count_settings(self, entries):

for entry in entries:

if (type(entry[1]) is tuple):

self._count_settings(entry[1])

else:

self._setting_count += 1

def _create_group(self, entries, grp=None):

if grp is None:

grp = RadioSettings()

for entry in entries:

if (type(entry[1]) is tuple):

subgrp = RadioSettingGroup(entry[0].lower(), entry[0])

grp.append(self._create_group(entry[1], subgrp))

else:

setting = self._get_setting_data(entry[0])

if setting['type'] == 'undefined':

continue

if setting['type'] == 'list':

rsvl = RadioSettingValueList(setting['values'])

rs = RadioSetting(entry[0], entry[1], rsvl)

elif setting['type'] == 'bool':

rs = RadioSetting(entry[0], entry[1],

RadioSettingValueBoolean(False))

elif setting['type'] == 'string':

params = {}

if 'charset' in setting:

params['charset'] = setting['charset']

else:

params['charset'] = chirp_common.CHARSET_ASCII

minlen = 'min_len' in setting and setting['min_len'] or 0

dummy = params['charset'][0] * minlen

rsvs = RadioSettingValueString(minlen,

setting['max_len'],

dummy,

False, **params)

rs = RadioSetting(entry[0], entry[1], rsvs)

elif setting['type'] == 'integer':

rs = RadioSetting(entry[0], entry[1],

RadioSettingValueInteger(setting['min'],

setting['max'],

setting['min']))

elif setting['type'] == 'map':

rsvs = RadioSettingValueMap(setting['map'],

setting['map'][0][1])

rs = RadioSetting(entry[0], entry[1], rsvs)

else:

rs = setting['type'](entry[0], entry[1], self)

rs.kenwood_d7_loaded = False

grp.append(rs)

self._setcache[entry[0]] = rs

return grp

def _do_prerequisite(self, cmd, get, do):

if get:

arg = 'get_requires'

else:

arg = 'set_requires'

setting = self._get_setting_data(cmd)

if arg not in setting:

return

# Undo prerequisites in the reverse order they were applied

if not do:

it = reversed(setting[arg])