Project

General

Profile

Bug #857 » ft857.py

Filippi Marco, 05/09/2013 10:41 AM

 
#
# Copyright 2012 Filippi Marco <iz3gme.marco@gmail.com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 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/>.

"""FT857 - FT857/US management module"""

from chirp import ft817, chirp_common, errors, directory
from chirp.settings import RadioSetting, RadioSettingGroup, \
RadioSettingValueInteger, RadioSettingValueList, \
RadioSettingValueBoolean, RadioSettingValueString
import os

@directory.register
class FT857Radio(ft817.FT817Radio):
"""Yaesu FT-857/897"""
MODEL = "FT-857/897"
_model = ""

TMODES = {
0x04 : "Tone",
0x05 : "TSQL",
# 0x08 : "DTCS Enc", not supported in UI yet
0x0a : "DTCS",
0xff : "Cross",
0x00 : "",
}
TMODES_REV = dict(zip(TMODES.values(), TMODES.keys()))

CROSS_MODES = {
0x01 : "->Tone",
0x02 : "->DTCS",
# 0x04 : "Tone->", not supported in UI yet
0x05 : "Tone->Tone",
0x06 : "Tone->DTCS",
0x08 : "DTCS->",
0x09 : "DTCS->Tone",
0x0a : "DTCS->DTCS",
}
CROSS_MODES_REV = dict(zip(CROSS_MODES.values(), CROSS_MODES.keys()))

_memsize = 7341
# block 9 (140 Bytes long) is to be repeted 40 times
# should be 42 times but this way I can use original 817 functions
_block_lengths = [ 2, 82, 252, 196, 252, 196, 212, 55, 140, 140, 140,
38, 176]
# warning ranges has to be in this exact order
VALID_BANDS = [(100000, 33000000), (33000000, 56000000),
(76000000, 108000000), (108000000, 137000000),
(137000000, 164000000), (420000000, 470000000)]

MEM_FORMAT = """
struct mem_struct{
u8 tag_on_off:1,
tag_default:1,
unknown1:3,
mode:3;
u8 duplex:2,
is_duplex:1,
is_cwdig_narrow:1,
is_fm_narrow:1,
freq_range:3;
u8 skip:1,
unknokwn1_1:1,
ipo:1,
att:1,
unknown2:4;
u8 ssb_step:2,
am_step:3,
fm_step:3;
u8 unknown3:3,
is_split_tone:1,
tmode:4;
u8 unknown4:2,
tx_mode:3,
tx_freq_range:3;
u8 unknown5:1,
unknown_toneflag:1,
tone:6;
u8 unknown6:1,
unknown_rxtoneflag:1,
rxtone:6;
u8 unknown7:1,
dcs:7;
u8 unknown8:1,
rxdcs:7;
ul16 rit;
u32 freq;
u32 offset;
u8 name[8];
};
#seekto 0x5;
struct {
u8 unknown1:4,
cw_speed_unit:1,
cw_key_rev:1,
unknown2:2;
u8 unknown3[2];
u8 disp_mode:2,
unknown4:2,
disp_contrast:4;
u8 unknown5:4,
clar_dial_sel:2,
beep_tone:2;
u8 arts_beep:2,
dial_step:1,
arts_id:1,
unknown6:1,
pkt_rate:1,
unknown7:2;
u8 unknown8:2,
lock_mode:2,
unknown9:1,
cw_pitch:3;
u8 sql_rf_gain:1,
ars_144:1,
ars_430:1,
cw_weight:5;
u8 cw_delay;
u8 cw_delay_hi:1
cw_sidetone:7;
u8 unknown10:2,
cw_speed:6;
u8 disable_amfm_dial:1,
vox_gain:7;
u8 cat_rate:2,
emergency:1,
vox_delay:5;
u8 dig_mode:3,
mem_group:1,
unknown11:1,
apo_time:3;
u8 dcs_inv:2,
unknown12:1,
tot_time:5;
u8 mic_scan:1,
ssb_mic:7;
u8 cw_paddle:1,
am_mic:7;
u8 unknown13:1,
fm_mic:7;
u8 unknown14:1,
dig_mic:7;
u8 extended_menu:1,
pkt1200:7;
u8 unknown15:1,
pkt9600:7;
ul16 dig_shift;
ul16 dig_disp;
u8 r_lsb_car;
u8 r_usb_car;
u8 t_lsb_car;
u8 t_usb_car;
u8 unknown16:1,
menu_item:7;
u8 unknown17[5];
u8 unknown18:1,
mtr_peak_hold:1,
mic_sel:2,
cat_lin_tun:2,
unknown19:1,
split_tone:1;
u8 unknown20:1,
beep_vol:7;
u8 unknown21:1,
dig_vox:7;
u8 ext_menu:1,
home_vfo:1,
scan_mode:2,
scan_resume:4;
u8 cw_auto_mode:1,
cw_training:2,
cw_qsk:3,
cw_bfo:2;
u8 dsp_nr:4,
dsp_bpf:2,
dsp_mic_eq:2;
u8 unknown22:3,
dsp_lpf:5;
u8 mtr_atx_sel:3,
unknown23:1,
dsp_hpf:4;
u8 unknown24:2,
disp_intensity:2,
unknown25:1,
disp_color:3;
u8 unknown26:1,
disp_color_vfo:1,
disp_color_mtr:1,
disp_color_mode:1,
disp_color_memgrp:1,
unknown27:1,
disp_color_band:1,
disp_color_arts:1;
u8 unknown28:3,
disp_color_fix:5;
u8 unknown29:1,
nb_level:7;
u8 unknown30:1,
proc_level:7;
u8 unknown31:1,
rf_power_hf:7;
u8 unknown32:2,
tuner_atas:3,
mem_vfo_dial_mode:3;
u8 pg_a;
u8 pg_b;
u8 pg_c;
u8 pg_acc;
u8 pg_p1;
u8 pg_p2;
u8 unknown33:3,
xvtr_sel:2,
unknown33_1:2,
op_filter1:1;
u8 unknown34:6,
tx_if_filter:2;
u8 unknown35:3,
xvtr_a_negative:1,
xvtr_b_negative:1,
mtr_arx_sel:3;
u8 beacon_time;
u8 unknown36[2];
u8 dig_vox_enable:1,
unknown37:7;
u8 unknown39:1,
rf_power_6m:7;
u8 unknown40:1,
rf_power_vhf:7;
u8 unknown41:1,
rf_power_uhf:7;
} settings;

#seekto 0x54;
struct mem_struct vfoa[16];
struct mem_struct vfob[16];
struct mem_struct home[4];
struct mem_struct qmb;
struct mem_struct mtqmb;
struct mem_struct mtune;
#seekto 0x4a9;
u8 visible[25];
ul16 pmsvisible;
#seekto 0x4c4;
u8 filled[25];
ul16 pmsfilled;
#seekto 0x4df;
struct mem_struct memory[200];
struct mem_struct pms[10];
#seekto 0x1bf3;
u8 arts_idw[10];
u8 beacon_text1[40];
u8 beacon_text2[40];
u8 beacon_text3[40];

#seekto 0x1CAD;
struct mem_struct sixtymeterchannels[5];
"""

_CALLSIGN_CHARSET = [chr(x) for x in range(ord("0"), ord("9")+1) +
range(ord("A"), ord("Z")+1)] + [" ", "/"]
_CALLSIGN_CHARSET_REV = dict(zip(_CALLSIGN_CHARSET,
range(0,len(_CALLSIGN_CHARSET))))
_BEACON_CHARSET = _CALLSIGN_CHARSET + ["+", "."]
_BEACON_CHARSET_REV = dict(zip(_BEACON_CHARSET,
range(0,len(_BEACON_CHARSET))))

# WARNING Index are hard wired in memory management code !!!
SPECIAL_MEMORIES = {
"VFOa-1.8M" : -37,
"VFOa-3.5M" : -36,
"VFOa-5M" : -35,
"VFOa-7M" : -34,
"VFOa-10M" : -33,
"VFOa-14M" : -32,
"VFOa-18M" : -31,
"VFOa-21M" : -30,
"VFOa-24M" : -29,
"VFOa-28M" : -28,
"VFOa-50M" : -27,
"VFOa-FM" : -26,
"VFOa-AIR" : -25,
"VFOa-144" : -24,
"VFOa-430" : -23,
"VFOa-HF" : -22,
"VFOb-1.8M" : -21,
"VFOb-3.5M" : -20,
"VFOb-5M" : -19,
"VFOb-7M" : -18,
"VFOb-10M" : -17,
"VFOb-14M" : -16,
"VFOb-18M" : -15,
"VFOb-21M" : -14,
"VFOb-24M" : -13,
"VFOb-28M" : -12,
"VFOb-50M" : -11,
"VFOb-FM" : -10,
"VFOb-AIR" : -9,
"VFOb-144M" : -8,
"VFOb-430M" : -7,
"VFOb-HF" : -6,
"HOME HF" : -5,
"HOME 50M" : -4,
"HOME 144M" : -3,
"HOME 430M" : -2,
"QMB" : -1,
}
FIRST_VFOB_INDEX = -6
LAST_VFOB_INDEX = -21
FIRST_VFOA_INDEX = -22
LAST_VFOA_INDEX = -37

SPECIAL_PMS = {
"PMS-1L" : -47,
"PMS-1U" : -46,
"PMS-2L" : -45,
"PMS-2U" : -44,
"PMS-3L" : -43,
"PMS-3U" : -42,
"PMS-4L" : -41,
"PMS-4U" : -40,
"PMS-5L" : -39,
"PMS-5U" : -38,
}
LAST_PMS_INDEX = -47

SPECIAL_MEMORIES.update(SPECIAL_PMS)

SPECIAL_MEMORIES_REV = dict(zip(SPECIAL_MEMORIES.values(),
SPECIAL_MEMORIES.keys()))

FILTERS = [ "CFIL", "FIL1", "FIL2" ]
PROGRAMMABLEOPTIONS = [
"MFa:A/B", "MFa:A=B", "MFa:SPL",
"MFb:MW", "MFb:SKIP/MCLR", "MFb:TAG",
"MFc:STO", "MFc:RCL", "MFc:PROC",
"MFd:RPT", "MFd:REV", "MFd:VOX",
"MFe:TON/ENC", "MFe:TON/DEC", "MFe:TDCH",
"MFf:ARTS", "MFf:SRCH", "MFf:PMS",
"MFg:SCN", "MFg:PRI", "MFg:DW",
"MFh:SCOP", "MFh:WID", "MFh:STEP",
"MFi:MTR", "MFi:SWR", "MFi:DISP",
"MFj:SPOT", "MFj:BK", "MFj:KYR",
"MFk:TUNE", "MFk:DOWN", "MFk:UP",
"MFl:NB", "MFl:AGC", "MFl:AGC SEL",
"MFm:IPO", "MFm:ATT", "MFm:NAR",
"MFn:CFIL", "MFn:FIL1", "MFn:FIL2",
"MFo:PLY1", "MFo:PLY2", "MFo:PLY3",
"MFp:DNR", "MFp:DNF", "MFp:DBF",
"01:EXT MENU", "02:144MHz ARS", "03:430MHz ARS",
"04:AM&FM DIAL", "05:AM MIC GAIN", "06:AM STEP",
"07:APO TIME", "08:ARTS BEEP", "09:ARTS ID",
"10:ARTS IDW", "11:BEACON TEXT", "12:BEACON TIME",
"13:BEEP TONE", "14:BEEP VOL", "15:CAR LSB R",
"16:CAR LSB T", "17:CAR USB R", "18:CAR USB T",
"19:CAT RATE", "20:CAT/LIN/TUN", "21:CLAR DIAL SEL",
"22:CW AUTO MODE", "23:CW BFO", "24:CW DELAY",
"25:CW KEY REV", "26:CW PADDLE", "27:CW PITCH",
"28:CW QSK", "29:CW SIDE TONE", "30:CW SPEED",
"31:CW TRAINING", "32:CW WEIGHT", "33:DCS CODE",
"34:DCS INV", "35:DIAL STEP", "36:DIG DISP",
"37:DIG GAIN", "38:DIG MODE", "39:DIG SHIFT",
"40:DIG VOX", "41:DISP COLOR", "42:DISP CONTRAST",
"43:DISP INTENSITY", "44:DISP MODE", "45:DSP BPF WIDTH",
"46:DSP HPF CUTOFF", "47:DSP LPF CUTOFF","48:DSP MIC EQ",
"49:DSP NR LEVEL", "50:EMERGENCY", "51:FM MIC GAIN",
"52:FM STEP", "53:HOME->VFO", "54:LOCK MODE",
"55:MEM GROUP", "56:MEM TAG", "57:MEM/VFO DIAL MODE",
"58:MIC SCAN", "59:MIC SEL", "60:MTR ARX",
"61:MTR ATX", "62:MTR PEAK HOLD", "63:NB LEVEL",
"64:OP FILTER", "71:PKT 1200", "72:PKT 9600",
"73:PKT RATE", "74:PROC LEVEL", "75:RF POWER SET",
"76:RPT SHIFT", "77:SCAN MODE", "78:SCAN RESUME",
"79:SPLIT TONE", "80:SQL/RF GAIN", "81:SSB MIC GAIN",
"82:SSB STEP", "83:TONE FREQ", "84:TX TIME",
"85:TUNER/ATAS", "86:TX IF FILTER", "87:VOX DELAY",
"88:VOX GAIN", "89:XVTR A FREQ", "90:XVTR B FREQ",
"91:XVTR SEL",
"MONI", "Q.SPL", "TCALL", "ATC", "USER"]
def get_features(self):
rf = ft817.FT817Radio.get_features(self)
rf.has_cross = True
rf.has_ctone = True
rf.has_rx_dtcs = True
rf.valid_tmodes = self.TMODES_REV.keys()
rf.valid_cross_modes = self.CROSS_MODES_REV.keys()
return rf

def _get_duplex(self, mem, _mem):
# radio set is_duplex only for + and - but not for split
# at the same time it does not complain if we set it same way 817 does
# (so no set_duplex here)
mem.duplex = self.DUPLEX[_mem.duplex]

def _get_tmode(self, mem, _mem):
if not _mem.is_split_tone:
mem.tmode = self.TMODES[int(_mem.tmode)]
else:
mem.tmode = "Cross"
mem.cross_mode = self.CROSS_MODES[int(_mem.tmode)]

if mem.tmode == "Tone":
mem.rtone = mem.ctone = chirp_common.TONES[_mem.tone]
elif mem.tmode == "TSQL":
mem.rtone = mem.ctone = chirp_common.TONES[_mem.tone]
elif mem.tmode == "DTCS Enc": # UI does not support it yet but
# this code has alreay been tested
mem.dtcs = mem.rx_dtcs = chirp_common.DTCS_CODES[_mem.dcs]
elif mem.tmode == "DTCS":
mem.dtcs = mem.rx_dtcs = chirp_common.DTCS_CODES[_mem.dcs]
elif mem.tmode == "Cross":
mem.ctone = chirp_common.TONES[_mem.rxtone]
# don't want to fail for this
try:
mem.rtone = chirp_common.TONES[_mem.tone]
except IndexError:
mem.rtone = chirp_common.TONES[0]
mem.dtcs = chirp_common.DTCS_CODES[_mem.dcs]
mem.rx_dtcs = chirp_common.DTCS_CODES[_mem.rxdcs]

def _set_tmode(self, mem, _mem):
if mem.tmode != "Cross":
_mem.is_split_tone = 0
_mem.tmode = self.TMODES_REV[mem.tmode]
else:
_mem.tmode = self.CROSS_MODES_REV[mem.cross_mode]
_mem.is_split_tone = 1

if mem.tmode == "Tone":
_mem.tone = _mem.rxtone = chirp_common.TONES.index(mem.rtone)
elif mem.tmode == "TSQL":
_mem.tone = _mem.rxtone = chirp_common.TONES.index(mem.ctone)
elif mem.tmode == "DTCS Enc": # UI does not support it yet but
# this code has alreay been tested
_mem.dcs = _mem.rxdcs = chirp_common.DTCS_CODES.index(mem.dtcs)
elif mem.tmode == "DTCS":
_mem.dcs = _mem.rxdcs = chirp_common.DTCS_CODES.index(mem.rx_dtcs)
elif mem.tmode == "Cross":
_mem.tone = chirp_common.TONES.index(mem.rtone)
_mem.rxtone = chirp_common.TONES.index(mem.ctone)
_mem.dcs = chirp_common.DTCS_CODES.index(mem.dtcs)
_mem.rxdcs = chirp_common.DTCS_CODES.index(mem.rx_dtcs)
# have to put this bit to 0 otherwise we get strange display in tone
# frequency (menu 83). See bug #88 and #163
_mem.unknown_toneflag = 0
# dunno if there's the same problem here but to be safe ...
_mem.unknown_rxtoneflag = 0

def _get_memory(self, mem, _mem):
mem.freq = int(_mem.freq) * 10
mem.offset = int(_mem.offset) * 10
self._get_duplex(mem, _mem)
mem.mode = self.MODES[_mem.mode]
if mem.mode == "FM":
if _mem.is_fm_narrow == 1:
mem.mode = "NFM"
mem.tuning_step = self.STEPSFM[_mem.fm_step]
elif mem.mode == "AM":
mem.tuning_step = self.STEPSAM[_mem.am_step]
elif mem.mode == "CW" or mem.mode == "CWR":
if _mem.is_cwdig_narrow == 1:
mem.mode = "N" + mem.mode
mem.tuning_step = self.STEPSSSB[_mem.ssb_step]
else:
try:
mem.tuning_step = self.STEPSSSB[_mem.ssb_step]
except IndexError:
pass
mem.skip = _mem.skip and "S" or ""
self._get_tmode(mem, _mem)

if _mem.tag_on_off == 1:
for i in _mem.name:
if i == "\xFF":
break
if i < 0x80:
mem.name += self.CHARSET[i]
else:
mem.name += "*"
mem.name = mem.name.rstrip()
else:
mem.name = ""

mem.extra = RadioSettingGroup("extra", "Extra")
ipo = RadioSetting("ipo", "IPO",
RadioSettingValueBoolean(bool(_mem.ipo)))
ipo.set_doc("Bypass preamp")
mem.extra.append(ipo)
att = RadioSetting("att", "ATT",
RadioSettingValueBoolean(bool(_mem.att)))
att.set_doc("10dB front end attenuator")
mem.extra.append(att)

return mem

def get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic")
cw = RadioSettingGroup("cw", "CW")
packet = RadioSettingGroup("packet", "Digital & packet")
panel = RadioSettingGroup("panel", "Panel settings")
extended = RadioSettingGroup("extended", "Extended")
antenna = RadioSettingGroup("antenna", "Antenna selection")
panelcontr = RadioSettingGroup("panelcontr", "Panel controls")
top = RadioSettingGroup("top", "All Settings", basic, cw, packet,
panelcontr, panel, extended, antenna)

rs = RadioSetting("extended_menu", "Extended menu",
RadioSettingValueBoolean(_settings.extended_menu))
extended.append(rs)
rs = RadioSetting("ars_144", "144MHz ARS",
RadioSettingValueBoolean(_settings.ars_144))
basic.append(rs)
rs = RadioSetting("ars_430", "430MHz ARS",
RadioSettingValueBoolean(_settings.ars_430))
basic.append(rs)
options = ["enable", "disable"]
rs = RadioSetting("disable_amfm_dial", "AM&FM Dial",
RadioSettingValueList(options,
options[_settings.disable_amfm_dial]))
panel.append(rs)
rs = RadioSetting("am_mic", "AM mic gain",
RadioSettingValueInteger(0, 100, _settings.am_mic))
basic.append(rs)
options = ["OFF", "1h", "2h", "3h", "4h", "5h", "6h"]
rs = RadioSetting("apo_time", "APO time",
RadioSettingValueList(options,
options[_settings.apo_time]))
basic.append(rs)
options = ["OFF", "Range", "All"]
rs = RadioSetting("arts_beep", "ARTS beep",
RadioSettingValueList(options,
options[_settings.arts_beep]))
basic.append(rs)
rs = RadioSetting("arts_id", "ARTS ID",
RadioSettingValueBoolean(_settings.arts_id))
extended.append(rs)
s = RadioSettingValueString(0, 10,
''.join([self._CALLSIGN_CHARSET[x] for x in
self._memobj.arts_idw]))
s.set_charset(self._CALLSIGN_CHARSET)
rs = RadioSetting("arts_idw", "ARTS IDW", s)
extended.append(rs)
s = RadioSettingValueString(0, 40,
''.join([self._BEACON_CHARSET[x] for x in
self._memobj.beacon_text1]))
s.set_charset(self._BEACON_CHARSET)
rs = RadioSetting("beacon_text1", "Beacon text1", s)
extended.append(rs)
s = RadioSettingValueString(0, 40,
''.join([self._BEACON_CHARSET[x] for x in
self._memobj.beacon_text2]))
s.set_charset(self._BEACON_CHARSET)
rs = RadioSetting("beacon_text2", "Beacon text2", s)
extended.append(rs)
s = RadioSettingValueString(0, 40,
''.join([self._BEACON_CHARSET[x] for x in
self._memobj.beacon_text3]))
s.set_charset(self._BEACON_CHARSET)
rs = RadioSetting("beacon_text3", "Beacon text3", s)
extended.append(rs)
options = ["OFF"]+["%i sec" % i for i in range(1,256)]
rs = RadioSetting("beacon_time", "Beacon time",
RadioSettingValueList(options,
options[_settings.beacon_time]))
extended.append(rs)
options = ["440Hz", "880Hz", "1760Hz"]
rs = RadioSetting("beep_tone", "Beep tone",
RadioSettingValueList(options,
options[_settings.beep_tone]))
panel.append(rs)
rs = RadioSetting("beep_vol", "Beep volume",
RadioSettingValueInteger(0, 100, _settings.beep_vol))
panel.append(rs)
rs = RadioSetting("r_lsb_car", "LSB Rx carrier point (*10 Hz)",
RadioSettingValueInteger(-30, 30, _settings.r_lsb_car))
extended.append(rs)
rs = RadioSetting("r_usb_car", "USB Rx carrier point (*10 Hz)",
RadioSettingValueInteger(-30, 30, _settings.r_usb_car))
extended.append(rs)
rs = RadioSetting("t_lsb_car", "LSB Tx carrier point (*10 Hz)",
RadioSettingValueInteger(-30, 30, _settings.t_lsb_car))
extended.append(rs)
rs = RadioSetting("t_usb_car", "USB Tx carrier point (*10 Hz)",
RadioSettingValueInteger(-30, 30, _settings.t_usb_car))
extended.append(rs)
options = ["4800", "9600", "38400"]
rs = RadioSetting("cat_rate", "CAT rate",
RadioSettingValueList(options,
options[_settings.cat_rate]))
basic.append(rs)
options = ["CAT", "Linear", "Tuner"]
rs = RadioSetting("cat_lin_tun", "CAT/LIN/TUN selection",
RadioSettingValueList(options,
options[_settings.cat_lin_tun]))
extended.append(rs)
options = ["MAIN", "VFO/MEM", "CLAR"] # TODO test the 3 options on non D radio
# which have only SEL and MAIN
rs = RadioSetting("clar_dial_sel", "Clarifier dial selection",
RadioSettingValueList(options,
options[_settings.clar_dial_sel]))
panel.append(rs)
rs = RadioSetting("cw_auto_mode", "CW Automatic mode",
RadioSettingValueBoolean(_settings.cw_auto_mode))
cw.append(rs)
options = ["USB", "LSB", "AUTO"]
rs = RadioSetting("cw_bfo", "CW BFO",
RadioSettingValueList(options,
options[_settings.cw_bfo]))
cw.append(rs)
options = ["FULL"]+["%i ms" % (i*10) for i in range(3,301)]
val = (_settings.cw_delay + _settings.cw_delay_hi * 256) - 2
rs = RadioSetting("cw_delay", "CW delay",
RadioSettingValueList(options,
options[val]))
cw.append(rs)
options = ["Normal", "Reverse"]
rs = RadioSetting("cw_key_rev", "CW key reverse",
RadioSettingValueList(options,
options[_settings.cw_key_rev]))
cw.append(rs)
rs = RadioSetting("cw_paddle", "CW paddle",
RadioSettingValueBoolean(_settings.cw_paddle))
cw.append(rs)
options = ["%i Hz" % i for i in range(400,801,100)]
rs = RadioSetting("cw_pitch", "CW pitch",
RadioSettingValueList(options,
options[_settings.cw_pitch]))
cw.append(rs)
options = ["%i ms" % i for i in range(5,31,5)]
rs = RadioSetting("cw_qsk", "CW QSK",
RadioSettingValueList(options,
options[_settings.cw_qsk]))
cw.append(rs)
rs = RadioSetting("cw_sidetone", "CW sidetone volume",
RadioSettingValueInteger(0, 100, _settings.cw_sidetone))
cw.append(rs)
options = ["%i wpm" % i for i in range(4,61)]
rs = RadioSetting("cw_speed", "CW speed",
RadioSettingValueList(options,
options[_settings.cw_speed]))
cw.append(rs)
options = ["Numeric", "Alphabet", "AlphaNumeric"]
rs = RadioSetting("cw_training", "CW trainig",
RadioSettingValueList(options,
options[_settings.cw_training]))
cw.append(rs)
options = ["1:%1.1f" % (i/10) for i in range(25,46,1)]
rs = RadioSetting("cw_weight", "CW weight",
RadioSettingValueList(options,
options[_settings.cw_weight]))
cw.append(rs)
options = ["Tn-Rn", "Tn-Riv", "Tiv-Rn", "Tiv-Riv"]
rs = RadioSetting("dcs_inv", "DCS inv",
RadioSettingValueList(options,
options[_settings.dcs_inv]))
extended.append(rs)
options = ["Fine", "Coarse"]
rs = RadioSetting("dial_step", "Dial step",
RadioSettingValueList(options,
options[_settings.dial_step]))
panel.append(rs)
rs = RadioSetting("dig_disp", "Dig disp (*10 Hz)",
RadioSettingValueInteger(-300, 300, _settings.dig_disp))
packet.append(rs)
rs = RadioSetting("dig_mic", "Dig gain",
RadioSettingValueInteger(0, 100, _settings.dig_mic))
packet.append(rs)
options = ["RTTYL", "RTTYU", "PSK31-L", "PSK31-U", "USER-L", "USER-U"]
rs = RadioSetting("dig_mode", "Dig mode",
RadioSettingValueList(options,
options[_settings.dig_mode]))
packet.append(rs)
rs = RadioSetting("dig_shift", "Dig shift (*10 Hz)",
RadioSettingValueInteger(-300, 300, _settings.dig_shift))
packet.append(rs)
rs = RadioSetting("dig_vox", "Dig vox",
RadioSettingValueInteger(0, 100, _settings.dig_vox))
packet.append(rs)
options = ["ARTS", "BAND", "FIX", "MEMGRP", "MODE", "MTR", "VFO"]
rs = RadioSetting("disp_color", "Display color mode",
RadioSettingValueList(options,
options[_settings.disp_color]))
panel.append(rs)
rs = RadioSetting("disp_color_arts", "Display color ARTS set",
RadioSettingValueInteger(0, 1,_settings.disp_color_arts))
panel.append(rs)
rs = RadioSetting("disp_color_band", "Display color band set",
RadioSettingValueInteger(0, 1,_settings.disp_color_band))
panel.append(rs)
rs = RadioSetting("disp_color_memgrp", "Display color memory group set",
RadioSettingValueInteger(0, 1,_settings.disp_color_memgrp))
panel.append(rs)
rs = RadioSetting("disp_color_mode", "Display color mode set",
RadioSettingValueInteger(0, 1,_settings.disp_color_mode))
panel.append(rs)
rs = RadioSetting("disp_color_mtr", "Display color meter set",
RadioSettingValueInteger(0, 1,_settings.disp_color_mtr))
panel.append(rs)
rs = RadioSetting("disp_color_vfo", "Display color VFO set",
RadioSettingValueInteger(0, 1,_settings.disp_color_vfo))
panel.append(rs)
rs = RadioSetting("disp_color_fix", "Display color fix set",
RadioSettingValueInteger(1, 32,_settings.disp_color_fix+1))
panel.append(rs)
rs = RadioSetting("disp_contrast", "Contrast",
RadioSettingValueInteger(3, 15,_settings.disp_contrast+2))
panel.append(rs)
rs = RadioSetting("disp_intensity", "Intensity",
RadioSettingValueInteger(1, 3,_settings.disp_intensity))
panel.append(rs)
options = ["OFF", "Auto1", "Auto2", "ON"]
rs = RadioSetting("disp_mode", "Display backlight mode",
RadioSettingValueList(options,
options[_settings.disp_mode]))
panel.append(rs)
options = ["60Hz", "120Hz", "240Hz"]
rs = RadioSetting("dsp_bpf", "Dsp band pass filter",
RadioSettingValueList(options,
options[_settings.dsp_bpf]))
cw.append(rs)
options = ["100Hz", "160Hz", "220Hz", "280Hz", "340Hz", "400Hz", "460Hz", "520Hz",
"580Hz", "640Hz", "720Hz", "760Hz", "820Hz", "880Hz", "940Hz", "1000Hz"]
rs = RadioSetting("dsp_hpf", "Dsp hi pass filter cut off",
RadioSettingValueList(options,
options[_settings.dsp_hpf]))
basic.append(rs)
options = ["1000Hz", "1160Hz", "1320Hz", "1480Hz", "1650Hz", "1800Hz", "1970Hz", "2130Hz",
"2290Hz", "2450Hz", "2610Hz", "2770Hz", "2940Hz", "3100Hz", "3260Hz", "3420Hz",
"3580Hz", "3740Hz", "3900Hz", "4060Hz", "4230Hz", "4390Hz", "4550Hz", "4710Hz",
"4870Hz", "5030Hz", "5190Hz", "5390Hz", "5520Hz", "5680Hz", "5840Hz", "6000Hz"]
rs = RadioSetting("dsp_lpf", "Dsp low pass filter cut off",
RadioSettingValueList(options,
options[_settings.dsp_lpf]))
basic.append(rs)
options = ["OFF", "LPF", "HPF", "BOTH"]
rs = RadioSetting("dsp_mic_eq", "Dsp mic equalization",
RadioSettingValueList(options,
options[_settings.dsp_mic_eq]))
basic.append(rs)
rs = RadioSetting("dsp_nr", "DSP noise reduction level",
RadioSettingValueInteger(1, 16, _settings.dsp_nr+1))
basic.append(rs)
# emergency only for US model
rs = RadioSetting("fm_mic", "FM mic gain",
RadioSettingValueInteger(0, 100, _settings.fm_mic))
basic.append(rs)
rs = RadioSetting("home_vfo", "Enable HOME to VFO moving",
RadioSettingValueBoolean(_settings.home_vfo))
panel.append(rs)
options = ["Dial", "Freq", "Panel", "All"]
rs = RadioSetting("lock_mode", "Lock mode",
RadioSettingValueList(options,
options[_settings.lock_mode]))
panel.append(rs)
rs = RadioSetting("mem_group", "Mem group",
RadioSettingValueBoolean(_settings.mem_group))
basic.append(rs)
options = ["CW SIDETONE", "CW SPEED", "MHz/MEM GRP", "MIC GAIN",
"NB LEVEL", "RF POWER", "STEP"]
rs = RadioSetting("mem_vfo_dial_mode", "Mem/VFO dial mode",
RadioSettingValueList(options,
options[_settings.mem_vfo_dial_mode]))
panel.append(rs)
rs = RadioSetting("mic_scan", "Mic scan",
RadioSettingValueBoolean(_settings.mic_scan))
basic.append(rs)
options = ["NOR", "RMT", "CAT"]
rs = RadioSetting("mic_sel", "Mic selection",
RadioSettingValueList(options,
options[_settings.mic_sel]))
extended.append(rs)
options = ["SIG", "CTR", "VLT", "N/A", "FS", "OFF"]
rs = RadioSetting("mtr_arx_sel", "Meter receive selection",
RadioSettingValueList(options,
options[_settings.mtr_arx_sel]))
extended.append(rs)
options = ["PWR", "ALC", "MOD", "SWR", "VLT", "N/A", "OFF"]
rs = RadioSetting("mtr_atx_sel", "Meter transmit selection",
RadioSettingValueList(options,
options[_settings.mtr_atx_sel]))
extended.append(rs)
rs = RadioSetting("mtr_peak_hold", "Meter peak hold",
RadioSettingValueBoolean(_settings.mtr_peak_hold))
extended.append(rs)
rs = RadioSetting("nb_level", "Noise blanking level",
RadioSettingValueInteger(0, 100, _settings.nb_level))
basic.append(rs)
# TODO op_filter1
# TODO op_filter2
rs = RadioSetting("pg_a", "Programmable key MFq:A",
RadioSettingValueList(self.PROGRAMMABLEOPTIONS,
self.PROGRAMMABLEOPTIONS[_settings.pg_a]))
extended.append(rs)
rs = RadioSetting("pg_b", "Programmable key MFq:B",
RadioSettingValueList(self.PROGRAMMABLEOPTIONS,
self.PROGRAMMABLEOPTIONS[_settings.pg_b]))
extended.append(rs)
rs = RadioSetting("pg_c", "Programmable key MFq:C",
RadioSettingValueList(self.PROGRAMMABLEOPTIONS,
self.PROGRAMMABLEOPTIONS[_settings.pg_c]))
extended.append(rs)
rs = RadioSetting("pg_acc", "Programmable mic key ACC",
RadioSettingValueList(self.PROGRAMMABLEOPTIONS,
self.PROGRAMMABLEOPTIONS[_settings.pg_acc]))
extended.append(rs)
rs = RadioSetting("pg_p1", "Programmable mic key P1",
RadioSettingValueList(self.PROGRAMMABLEOPTIONS,
self.PROGRAMMABLEOPTIONS[_settings.pg_p1]))
extended.append(rs)
rs = RadioSetting("pg_p2", "Programmable mic key P2",
RadioSettingValueList(self.PROGRAMMABLEOPTIONS,
self.PROGRAMMABLEOPTIONS[_settings.pg_p2]))
extended.append(rs)
rs = RadioSetting("pkt1200", "Packet 1200 gain level",
RadioSettingValueInteger(0, 100, _settings.pkt1200))
packet.append(rs)
rs = RadioSetting("pkt9600", "Packet 9600 gain level",
RadioSettingValueInteger(0, 100, _settings.pkt9600))
packet.append(rs)
options = ["1200", "9600"]
rs = RadioSetting("pkt_rate", "Packet rate",
RadioSettingValueList(options,
options[_settings.pkt_rate]))
packet.append(rs)
rs = RadioSetting("proc_level", "Proc level",
RadioSettingValueInteger(0, 100, _settings.proc_level))
basic.append(rs)
rs = RadioSetting("rf_power_hf", "Rf power set HF",
RadioSettingValueInteger(5, 100, _settings.rf_power_hf))
basic.append(rs)
rs = RadioSetting("rf_power_6m", "Rf power set 6m",
RadioSettingValueInteger(5, 100, _settings.rf_power_6m))
basic.append(rs)
rs = RadioSetting("rf_power_vhf", "Rf power set VHF",
RadioSettingValueInteger(5, 50, _settings.rf_power_vhf))
basic.append(rs)
rs = RadioSetting("rf_power_uhf", "Rf power set UHF",
RadioSettingValueInteger(2, 20, _settings.rf_power_uhf))
basic.append(rs)
options = ["TIME", "BUSY", "STOP"]
rs = RadioSetting("scan_mode", "Scan mode",
RadioSettingValueList(options,
options[_settings.scan_mode]))
basic.append(rs)
rs = RadioSetting("scan_resume", "Scan resume",
RadioSettingValueInteger(1, 10, _settings.scan_resume))
basic.append(rs)
rs = RadioSetting("split_tone", "Split tone enable",
RadioSettingValueBoolean(_settings.split_tone))
extended.append(rs)
options = ["RF-Gain", "Squelch"]
rs = RadioSetting("sql_rf_gain", "Squelch/RF-Gain",
RadioSettingValueList(options,
options[_settings.sql_rf_gain]))
panel.append(rs)
rs = RadioSetting("ssb_mic", "SSB Mic gain",
RadioSettingValueInteger(0, 100, _settings.ssb_mic))
basic.append(rs)
options = ["Off"]+["%i" % i for i in range(1, 21)]
rs = RadioSetting("tot_time", "Time-out timer",
RadioSettingValueList(options,
options[_settings.tot_time]))
basic.append(rs)
options = ["OFF", "ATAS(HF)", "ATAS(HF&50)", "ATAS(ALL)", "TUNER"]
rs = RadioSetting("tuner_atas", "Tuner/ATAS device",
RadioSettingValueList(options,
options[_settings.tuner_atas]))
extended.append(rs)
rs = RadioSetting("tx_if_filter", "Transmit IF filter",
RadioSettingValueList(self.FILTERS,
self.FILTERS[_settings.tx_if_filter]))
basic.append(rs)
rs = RadioSetting("vox_delay", "VOX delay (*100 ms)",
RadioSettingValueInteger(1, 30, _settings.vox_delay))
basic.append(rs)
rs = RadioSetting("vox_gain", "VOX Gain",
RadioSettingValueInteger(1, 100, _settings.vox_gain))
basic.append(rs)
# TODO xvtr_a_freq
# TODO xvtr_b_freq
options = ["OFF", "XVTR A", "XVTR B"]
rs = RadioSetting("xvtr_sel", "Transverter function selection",
RadioSettingValueList(options,
options[_settings.xvtr_sel]))
extended.append(rs)
return top

def set_settings(self, settings):
_settings = self._memobj.settings
for element in settings:
if not isinstance(element, RadioSetting):
self.set_settings(element)
continue
try:
if "." in element.get_name():
bits = element.get_name().split(".")
obj = self._memobj
for bit in bits[:-1]:
obj = getattr(obj, bit)
setting = bits[-1]
else:
obj = _settings
setting = element.get_name()
if os.getenv("CHIRP_DEBUG"):
print "Setting %s(%s) <= %s" % (setting,
getattr(obj, setting), element.value)
if setting == "arts_idw":
self._memobj.arts_idw = \
[self._CALLSIGN_CHARSET_REV[x] for x in
str(element.value)]
elif setting in ["beacon_text1", "beacon_text2", "beacon_text3"]:
setattr(self._memobj, setting,
[self._BEACON_CHARSET_REV[x] for x in
str(element.value)])
elif setting == "cw_delay":
val = int(element.value)+2
setattr(obj, "cw_delay_hi", val/256)
setattr(obj, setting, val&0xff)
elif setting == "dig_vox":
val = int(element.value)
setattr(obj, "dig_vox_enable", int(val>0))
setattr(obj, setting, val)
elif setting in ["disp_color_fix", "dsp_nr"]:
setattr(obj, setting, int(element.value)-1)
elif setting == "disp_contrast":
setattr(obj, setting, int(element.value)-2)
else:
setattr(obj, setting, element.value)
except Exception, e:
print element.get_name()
raise

@directory.register
class FT857USRadio(FT857Radio):
"""Yaesu FT857/897 (US version)"""
# seems that radios configured for 5MHz operations send one paket more
# than others so we have to distinguish sub models
MODEL = "FT-857/897 (US)"

_model = ""
_memsize = 7481
# block 9 (140 Bytes long) is to be repeted 40 times
# should be 42 times but this way I can use original 817 functions
_block_lengths = [ 2, 82, 252, 196, 252, 196, 212, 55, 140, 140, 140, 38,
176, 140]

SPECIAL_60M = {
"M-601" : -52,
"M-602" : -51,
"M-603" : -50,
"M-604" : -49,
"M-605" : -48,
}
LAST_SPECIAL60M_INDEX = -52
SPECIAL_MEMORIES = dict(FT857Radio.SPECIAL_MEMORIES)
SPECIAL_MEMORIES.update(SPECIAL_60M)

SPECIAL_MEMORIES_REV = dict(zip(SPECIAL_MEMORIES.values(),
SPECIAL_MEMORIES.keys()))

# this is identical to the one in FT817ND_US_Radio but we inherit from 857
def _get_special_60m(self, number):
mem = chirp_common.Memory()
mem.number = self.SPECIAL_60M[number]
mem.extd_number = number

_mem = self._memobj.sixtymeterchannels[-self.LAST_SPECIAL60M_INDEX +
mem.number]

mem = self._get_memory(mem, _mem)

mem.immutable = ["number", "skip", "rtone", "ctone",
"extd_number", "name", "dtcs", "tmode", "cross_mode",
"dtcs_polarity", "power", "duplex", "offset",
"comment", "empty"]

return mem

# this is identical to the one in FT817ND_US_Radio but we inherit from 857
def _set_special_60m(self, mem):
if mem.empty:
# can't delete 60M memories!
raise Exception("Sorry, 60M memory can't be deleted")

cur_mem = self._get_special_60m(self.SPECIAL_MEMORIES_REV[mem.number])

for key in cur_mem.immutable:
if cur_mem.__dict__[key] != mem.__dict__[key]:
raise errors.RadioError("Editing field `%s' " % key +
"is not supported on M-60x channels")

if mem.mode not in ["USB", "LSB", "CW", "CWR", "NCW", "NCWR", "DIG"]:
raise errors.RadioError("Mode {mode} is not valid "
"in 60m channels".format(mode=mem.mode))
_mem = self._memobj.sixtymeterchannels[-self.LAST_SPECIAL60M_INDEX +
mem.number]
self._set_memory(mem, _mem)

def get_memory(self, number):
if number in self.SPECIAL_60M.keys():
return self._get_special_60m(number)
elif number < 0 and \
self.SPECIAL_MEMORIES_REV[number] in self.SPECIAL_60M.keys():
# I can't stop delete operation from loosing extd_number but
# I know how to get it back
return self._get_special_60m(self.SPECIAL_MEMORIES_REV[number])
else:
return FT857Radio.get_memory(self, number)

def set_memory(self, memory):
if memory.number in self.SPECIAL_60M.values():
return self._set_special_60m(memory)
else:
return FT857Radio.set_memory(self, memory)

def get_settings(self):
top = FT857Radio.get_settings(self)
basic = top["basic"]
rs = RadioSetting("emergency", "Emergency",
RadioSettingValueBoolean(self._memobj.settings.emergency))
basic.append(rs)
return top

(3-3/3)