def _get_settings(self):
top = RadioSettings(self._get_config_settings(),
self._get_digital_settings(),
self._get_display_settings(),
self._get_dtmf_settings(), self._get_gm_settings(),
self._get_scan_settings())
return top
def get_settings(self):
_mem = self._memobj
basic = RadioSettingGroup("basic", "Basic")
top = RadioSettings(basic)
def _f(val):
string = ""
for char in str(val):
if char == "\xFF":
break
string += char
return string
line1 = RadioSetting(
"messages.line1", "Message Line 1",
RadioSettingValueString(0,
32,
_f(_mem.messages.line1),
autopad=False))
basic.append(line1)
line2 = RadioSetting(
"messages.line2", "Message Line 2",
RadioSettingValueString(0,
32,
_f(_mem.messages.line2),
autopad=False))
basic.append(line2)
return top
def get_settings(self):
settings = self._memobj.settings
zones = self._get_zones()
common1 = self._get_common1()
common2 = self._get_common2()
conv = self._get_conventional()
top = RadioSettings(zones, common1, common2, conv)
return top
def make_speed_switch_setting(radio):
if not radio.__class__._can_hispeed:
return {}
drvopts = RadioSettingGroup("drvopts", "Driver Options")
top = RadioSettings(drvopts)
rs = RadioSetting("drv_clone_speed", "Use Hi-Speed Clone",
RadioSettingValueBoolean(radio._can_hispeed))
drvopts.append(rs)
return top
def get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic Settings")
top = RadioSettings(basic)
rs = RadioSetting("settings.squelch", "Squelch Level",
RadioSettingValueInteger(0, 9, _settings.squelch))
basic.append(rs)
rs = RadioSetting(
"settings.timeout", "Timeout Timer",
RadioSettingValueList(TIMEOUT_LIST,
TIMEOUT_LIST[_settings.timeout]))
basic.append(rs)
rs = RadioSetting(
"settings.scanmode", "Scan Mode",
RadioSettingValueList(SCANMODE_LIST,
SCANMODE_LIST[_settings.scanmode]))
basic.append(rs)
rs = RadioSetting(
"settings.voice", "Voice Prompts",
RadioSettingValueList(VOICE_LIST, VOICE_LIST[_settings.voice]))
basic.append(rs)
rs = RadioSetting(
"settings.voxgain", "VOX Level",
RadioSettingValueList(VOX_LIST, VOX_LIST[_settings.voxgain]))
basic.append(rs)
rs = RadioSetting(
"settings.voxdelay", "VOX Delay Time",
RadioSettingValueList(VOXDELAY_LIST,
VOXDELAY_LIST[_settings.voxdelay]))
basic.append(rs)
rs = RadioSetting("settings.save", "Battery Save",
RadioSettingValueBoolean(_settings.save))
basic.append(rs)
rs = RadioSetting("settings.beep", "Beep Tone",
RadioSettingValueBoolean(_settings.beep))
basic.append(rs)
def _filter(name):
filtered = ""
for char in str(name):
if char in VALID_CHARS:
filtered += char
else:
filtered += " "
return filtered
return top
def get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic Settings")
top = RadioSettings(basic)
rs = RadioSetting(
"squelchlevel", "Squelch level",
RadioSettingValueInteger(0, 9, _settings.squelchlevel))
basic.append(rs)
rs = RadioSetting(
"timeouttimer", "Timeout timer",
RadioSettingValueList(TIMEOUTTIMER_LIST,
TIMEOUTTIMER_LIST[_settings.timeouttimer]))
basic.append(rs)
rs = RadioSetting(
"scanmode", "Scan mode",
RadioSettingValueList(SCANMODE_LIST,
SCANMODE_LIST[_settings.scanmode]))
basic.append(rs)
rs = RadioSetting(
"voiceprompt", "Voice prompt",
RadioSettingValueList(VOICE_LIST,
VOICE_LIST[_settings.voiceprompt]))
basic.append(rs)
rs = RadioSetting(
"voxlevel", "Vox level",
RadioSettingValueList(VOXLEVEL_LIST,
VOXLEVEL_LIST[_settings.voxlevel]))
basic.append(rs)
rs = RadioSetting(
"voxdelay", "VOX delay",
RadioSettingValueList(VOXDELAY_LIST,
VOXDELAY_LIST[_settings.voxdelay]))
basic.append(rs)
rs = RadioSetting("batterysaver", "Battery saver",
RadioSettingValueBoolean(_settings.batterysaver))
basic.append(rs)
rs = RadioSetting("beep", "Beep",
RadioSettingValueBoolean(_settings.beep))
basic.append(rs)
return top
def get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic Settings")
top = RadioSettings(basic)
rs = RadioSetting(
"tot", "Time-out timer",
RadioSettingValueList(TIMEOUTTIMER_LIST,
TIMEOUTTIMER_LIST[_settings.tot]))
basic.append(rs)
rs = RadioSetting(
"totalert", "TOT Pre-alert",
RadioSettingValueList(TOTALERT_LIST,
TOTALERT_LIST[_settings.totalert]))
basic.append(rs)
rs = RadioSetting(
"vox", "VOX Gain",
RadioSettingValueList(VOX_LIST, VOX_LIST[_settings.vox]))
basic.append(rs)
rs = RadioSetting(
"voice", "Voice Annumciation",
RadioSettingValueList(VOICE_LIST, VOICE_LIST[_settings.voice]))
basic.append(rs)
rs = RadioSetting("squelch", "Squelch Level",
RadioSettingValueInteger(0, 9, _settings.squelch))
basic.append(rs)
rs = RadioSetting(
"voxdelay", "VOX Delay",
RadioSettingValueList(VOXDELAY_LIST,
VOXDELAY_LIST[_settings.voxdelay]))
basic.append(rs)
rs = RadioSetting("beep", "Beep",
RadioSettingValueBoolean(_settings.beep))
basic.append(rs)
rs = RadioSetting("save", "Battery Saver",
RadioSettingValueBoolean(_settings.save))
basic.append(rs)
return top
def get_settings(self):
top = RadioSettings()
aprs = RadioSettingGroup("aprs", "APRS")
top.append(aprs)
myc = self._memobj.aprs_my_callsign
rs = RadioSetting(
"aprs_my_callsign.call", "APRS My Callsign",
RadioSettingValueString(0, 6, aprs_call_to_str(myc.call)))
aprs.append(rs)
rs = RadioSetting("aprs_my_callsign.ssid", "APRS My SSID",
RadioSettingValueInteger(0, 15, myc.ssid))
aprs.append(rs)
return top
def get_settings(self):
"""
Return a RadioSettings list containing one or more RadioSettingGroup
or RadioSetting objects. These represent general settings that can
be adjusted on the radio.
"""
cur = self._memobj.settings
basic = RadioSettingGroup('basic', 'Basic Settings')
rs = RadioSetting(
'squelchlevel', 'Squelch level',
RadioSettingValueInteger(minval=0,
maxval=9,
current=cur.squelchlevel))
basic.append(rs)
rs = RadioSetting(
'timeouttimer', 'Timeout timer',
RadioSettingValueList(
options=self.TIMEOUTTIMER_LIST,
current=self.TIMEOUTTIMER_LIST[cur.timeouttimer]))
basic.append(rs)
rs = RadioSetting(
'voiceprompt', 'Voice prompt',
RadioSettingValueList(options=self.VOICE_LIST,
current=self.VOICE_LIST[cur.voiceprompt]))
basic.append(rs)
rs = RadioSetting(
'voxlevel', 'Vox level',
RadioSettingValueList(options=self.VOXLEVEL_LIST,
current=self.VOXLEVEL_LIST[cur.voxlevel]))
basic.append(rs)
rs = RadioSetting(
'voxdelay', 'VOX delay',
RadioSettingValueList(options=self.VOXDELAY_LIST,
current=self.VOXDELAY_LIST[cur.voxdelay]))
basic.append(rs)
basic.append(
RadioSetting('batterysaver', 'Battery saver',
RadioSettingValueBoolean(current=cur.batterysaver)))
basic.append(
RadioSetting('beep', 'Beep',
RadioSettingValueBoolean(current=cur.beep)))
return RadioSettings(basic)
def get_settings(self):
_general = self._memobj.general
_info = self._memobj.info
basic = RadioSettingGroup("basic", "Basic")
info = RadioSettingGroup("info", "Model Info")
general = RadioSettingGroup("general", "General Settings")
# top = RadioSettings(identity, basic)
top = RadioSettings(general)
general.append(RadioSetting(
"dmrid", "DMR Radio ID",
RadioSettingValueInteger(0, 100000000, _general.dmrid)))
general.append(RadioSetting(
"line1", "Startup Line 1",
RadioSettingValueString(0, 10, utftoasc(str(_general.line1)))))
general.append(RadioSetting(
"line2", "Startup Line 2",
RadioSettingValueString(0, 10, utftoasc(str(_general.line2)))))
return top
def get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic")
settings = RadioSettings(basic)
display = ["Frequency", "Channel", "Name"]
rs = RadioSetting("display", "Display",
RadioSettingValueList(display,
display[_settings.display]))
basic.append(rs)
apo = ["Off"] + ['%.1f hour(s)' % (0.5 * x) for x in range(1, 25)]
rs = RadioSetting("apo", "Automatic Power Off",
RadioSettingValueList(apo,
apo[_settings.apo]))
basic.append(rs)
def filter(s):
s_ = ""
for i in range(0, 8):
c = str(s[i])
s_ += (c if c in chirp_common.CHARSET_ASCII else "")
return s_
rs = RadioSetting("welcome", "Welcome Message",
RadioSettingValueString(0, 8,
filter(_settings.welcome)))
basic.append(rs)
rs = RadioSetting("beep", "Beep Enabled",
RadioSettingValueBoolean(_settings.beep))
basic.append(rs)
mute = ["Off", "TX", "RX", "TX/RX"]
rs = RadioSetting("mute", "Sub Band Mute",
RadioSettingValueList(mute,
mute[_settings.mute]))
basic.append(rs)
return settings
def get_settings(self):
_settings = self._memobj.settings
setmode = RadioSettingGroup("setmode", "General Settings")
settings = RadioSettings(setmode)
# LCD Backlight
opts = ["Off", "On", "Auto"]
setmode.append(
RadioSetting("lcd", "LCD Backlight",
RadioSettingValueList(opts, opts[_settings.lcd])))
# Mic Gain
rs = RadioSetting("mic", "Mic Gain",
RadioSettingValueInteger(1, 4, _settings.mic + 1))
def apply_mic(s, obj):
setattr(obj, s.get_name(), int(s.value) - 1)
rs.set_apply_callback(apply_mic, self._memobj.settings)
setmode.append(rs)
# Dial Assignment
opts = ["Volume", "Tuning"]
setmode.append(
RadioSetting(
"dial_assignment", "Dial Assignment",
RadioSettingValueList(opts, opts[_settings.dial_assignment])))
# Display Type
opts = ["Frequency", "Channel", "Name"]
setmode.append(
RadioSetting(
"disp_type", "Display Type",
RadioSettingValueList(opts, opts[_settings.disp_type])))
return settings
def get_settings(self):
_settings = self._memobj.settings
groups = RadioSettings()
for description in self.class_group_descs:
groupname, title, parms = description
group = RadioSettingGroup(groupname, title)
groups.append(group)
for parm in parms:
param, title, opts = parm
try:
if isinstance(opts, list):
# setting is a single value from the list
objval = getattr(_settings, param)
value = opts[objval]
valuelist = RadioSettingValueList(opts, value)
group.append(RadioSetting(param, title, valuelist))
else:
# setting needs special handling. opts[0] is a
# function name
opts[0](self, group, parm)
except Exception as e:
LOG.debug("%s: cannot set %s to %s" %
(e, param, repr(objval)))
return groups
def _get_settings(self):
_settings = self._memobj.settings
_freqrange = self._memobj.freqrange
_slabel = self._memobj.slabel
basic = RadioSettingGroup("basic","Global Settings")
freqrange = RadioSettingGroup("freqrange","Frequency Ranges")
top = RadioSettingGroup("top","All Settings",basic,freqrange)
settings = RadioSettings(top)
def _filter(name):
filtered = ""
for char in str(name):
if char in chirp_common.CHARSET_ASCII:
filtered += char
else:
filtered += ""
return filtered
val = RadioSettingValueString(0,7,_filter(_slabel.startname))
rs = RadioSetting("startname","Startup Label",val)
basic.append(rs)
rs = RadioSetting("bg_color","LCD Color",
RadioSettingValueList(BGCOLOR_LIST, BGCOLOR_LIST[_settings.bg_color]))
basic.append(rs)
rs = RadioSetting("bg_brightness","LCD Brightness",
RadioSettingValueList(BGBRIGHT_LIST, BGBRIGHT_LIST[_settings.bg_brightness]))
basic.append(rs)
rs = RadioSetting("squelch","Squelch Level",
RadioSettingValueList(SQUELCH_LIST, SQUELCH_LIST[_settings.squelch]))
basic.append(rs)
rs = RadioSetting("timeout_timer","Timeout Timer (TOT)",
RadioSettingValueList(TIMEOUT_LIST, TIMEOUT_LIST[_settings.timeout_timer]))
basic.append(rs)
rs = RadioSetting("auto_power_off","Auto Power Off (APO)",
RadioSettingValueList(APO_LIST, APO_LIST[_settings.auto_power_off]))
basic.append(rs)
rs = RadioSetting("voice_prompt","Beep Prompt",
RadioSettingValueList(BEEP_LIST, BEEP_LIST[_settings.voice_prompt]))
basic.append(rs)
rs = RadioSetting("tbst_freq","Tone Burst Frequency",
RadioSettingValueList(TBSTFREQ_LIST, TBSTFREQ_LIST[_settings.tbst_freq]))
basic.append(rs)
rs = RadioSetting("choose_tx_power","Max Level of TX Power",
RadioSettingValueList(TXPWR_LIST, TXPWR_LIST[_settings.choose_tx_power]))
basic.append(rs)
(flow,fhigh) = self.valid_freq[0]
flow /= 1000
fhigh /= 1000
fmidrange = (fhigh- flow)/2
rs = RadioSetting("txrangelow","TX Freq, Lower Limit (khz)", RadioSettingValueInteger(flow,
flow + fmidrange,
int(_freqrange.txrangelow)/10))
freqrange.append(rs)
rs = RadioSetting("txrangehi","TX Freq, Upper Limit (khz)", RadioSettingValueInteger(fhigh-fmidrange,
fhigh,
int(_freqrange.txrangehi)/10))
freqrange.append(rs)
rs = RadioSetting("rxrangelow","RX Freq, Lower Limit (khz)", RadioSettingValueInteger(flow,
flow+fmidrange,
int(_freqrange.rxrangelow)/10))
freqrange.append(rs)
rs = RadioSetting("rxrangehi","RX Freq, Upper Limit (khz)", RadioSettingValueInteger(fhigh-fmidrange,
fhigh,
int(_freqrange.rxrangehi)/10))
freqrange.append(rs)
return settings
def get_settings(self):
_settings = self._memobj.settings
_message = self._memobj.embedded_msg
basic = RadioSettingGroup("basic", "Basic Settings")
top = RadioSettings(basic)
rs = RadioSetting("squelch", "Squelch Level",
RadioSettingValueInteger(0, 9, _settings.squelch))
basic.append(rs)
rs = RadioSetting("tot", "Time-out timer",
RadioSettingValueList(
TIMEOUTTIMER_LIST,
TIMEOUTTIMER_LIST[_settings.tot]))
basic.append(rs)
rs = RadioSetting("voice", "Voice Prompts",
RadioSettingValueList(
VOICE_LIST, VOICE_LIST[_settings.voice]))
basic.append(rs)
rs = RadioSetting("pf2key", "PF2 Key",
RadioSettingValueList(
PF2KEY_LIST, PF2KEY_LIST[_settings.pf2key]))
basic.append(rs)
rs = RadioSetting("vox", "Vox",
RadioSettingValueBoolean(_settings.vox))
basic.append(rs)
rs = RadioSetting("voxgain", "VOX Level",
RadioSettingValueList(
VOX_LIST, VOX_LIST[_settings.voxgain]))
basic.append(rs)
rs = RadioSetting("voxdelay", "VOX Delay Time",
RadioSettingValueList(
VOXDELAY_LIST,
VOXDELAY_LIST[_settings.voxdelay]))
basic.append(rs)
rs = RadioSetting("save", "Battery Save",
RadioSettingValueBoolean(_settings.save))
basic.append(rs)
rs = RadioSetting("beep", "Beep",
RadioSettingValueBoolean(_settings.beep))
basic.append(rs)
def _filter(name):
filtered = ""
for char in str(name):
if char in VALID_CHARS:
filtered += char
else:
filtered += " "
return filtered
rs = RadioSetting("embedded_msg.line1", "Embedded Message 1",
RadioSettingValueString(0, 32, _filter(
_message.line1)))
basic.append(rs)
rs = RadioSetting("embedded_msg.line2", "Embedded Message 2",
RadioSettingValueString(0, 32, _filter(
_message.line2)))
basic.append(rs)
return top
def get_settings(self):
_settings = self._memobj.settings
_settings_misc = self._memobj.settings_misc
basic = RadioSettingGroup("basic", "Basic Settings")
top = RadioSettings(basic)
rs = RadioSetting(
"rf_sql", "Squelch level (SQL)",
RadioSettingValueList(RFSQL_LIST, RFSQL_LIST[_settings.rf_sql]))
basic.append(rs)
rs = RadioSetting(
"step_freq", "Step frequency KHz (STP)",
RadioSettingValueList(STEP_LIST, STEP_LIST[_settings.step_freq]))
basic.append(rs)
rs = RadioSetting(
"fm_radio", "FM radio (DW)",
RadioSettingValueList(OFF_ON_LIST,
OFF_ON_LIST[_settings_misc.fm_radio]))
basic.append(rs)
rs = RadioSetting(
"call_tone", "Call tone (CK)",
RadioSettingValueList(CALLTONE_LIST,
CALLTONE_LIST[_settings.call_tone]))
basic.append(rs)
rs = RadioSetting(
"tot", "Time-out timer (TOT)",
RadioSettingValueList(TIMEOUT_LIST, TIMEOUT_LIST[_settings.tot]))
basic.append(rs)
rs = RadioSetting(
"chan_disp_way", "Channel display way",
RadioSettingValueList(CH_FLAG_LIST,
CH_FLAG_LIST[_settings.chan_disp_way]))
basic.append(rs)
rs = RadioSetting(
"vox", "VOX Gain (VOX)",
RadioSettingValueList(VOX_LIST, VOX_LIST[_settings.vox]))
basic.append(rs)
rs = RadioSetting(
"vox_dly", "VOX Delay",
RadioSettingValueList(VOXDELAY_LIST,
VOXDELAY_LIST[_settings.vox_dly]))
basic.append(rs)
rs = RadioSetting(
"beep", "Beep (BP)",
RadioSettingValueList(OFF_ON_LIST, OFF_ON_LIST[_settings.beep]))
basic.append(rs)
rs = RadioSetting(
"auto_lock", "Auto lock (KY)",
RadioSettingValueList(NO_YES_LIST,
NO_YES_LIST[_settings_misc.auto_lock]))
basic.append(rs)
rs = RadioSetting(
"bat_save", "Battery Saver (SAV)",
RadioSettingValueList(BAT_SAVE_LIST,
BAT_SAVE_LIST[_settings.bat_save]))
basic.append(rs)
rs = RadioSetting(
"chan_pri", "Channel PRI (PRI)",
RadioSettingValueList(OFF_ON_LIST,
OFF_ON_LIST[_settings.chan_pri]))
basic.append(rs)
rs = RadioSetting(
"chan_pri_num", "Channel PRI time Sec (PRI)",
RadioSettingValueList(PRI_NUM_LIST,
PRI_NUM_LIST[_settings.chan_pri_num]))
basic.append(rs)
rs = RadioSetting(
"end_beep", "End beep (ET)",
RadioSettingValueList(ENDBEEP_LIST,
ENDBEEP_LIST[_settings.end_beep]))
basic.append(rs)
rs = RadioSetting(
"ch_mode", "CH mode",
RadioSettingValueList(ON_OFF_LIST, ON_OFF_LIST[_settings.ch_mode]))
basic.append(rs)
rs = RadioSetting(
"scan_rev", "Scan rev (SCAN)",
RadioSettingValueList(SCANM_LIST, SCANM_LIST[_settings.scan_rev]))
basic.append(rs)
rs = RadioSetting(
"enc", "Frequency lock (ENC)",
RadioSettingValueList(OFF_ON_LIST, OFF_ON_LIST[_settings.enc]))
basic.append(rs)
rs = RadioSetting(
"wait_back_light", "Wait back light (LED)",
RadioSettingValueList(BACKLIGHT_LIST,
BACKLIGHT_LIST[_settings.wait_back_light]))
basic.append(rs)
return top
def _get_settings(self):
_ani = self._memobj.ani
_settings = self._memobj.settings
_vfoa = self._memobj.vfoa
_vfob = self._memobj.vfob
_keymaps = self._memobj.keymaps
basic = RadioSettingGroup("basic", "Basic Settings")
advanced = RadioSettingGroup("advanced", "Advanced Settings")
workmode = RadioSettingGroup("workmode", "Work Mode Settings")
keymaps = RadioSettingGroup("keymaps", "KeyMaps")
dtmf = RadioSettingGroup("dtmf", "DTMF Settings")
group = RadioSettings(basic, advanced, workmode, keymaps, dtmf)
rs = RadioSetting("squelch", "Carrier Squelch Level",
RadioSettingValueInteger(0, 5, _settings.squelch))
basic.append(rs)
rs = RadioSetting("battery_saver", "Battery Save",
RadioSettingValueBoolean(_settings.battery_saver))
advanced.append(rs)
rs = RadioSetting(
"vox", "VOX Sensitivity",
RadioSettingValueList(VOX_LIST, VOX_LIST[_settings.vox]))
basic.append(rs)
rs = RadioSetting(
"auto_bl", "Auto Backlight Timeout",
RadioSettingValueList(AUTOBL_LIST, AUTOBL_LIST[_settings.auto_bl]))
advanced.append(rs)
rs = RadioSetting(
"tot", "TX Timeout Timer",
RadioSettingValueList(TOT_LIST, TOT_LIST[_settings.tot]))
basic.append(rs)
rs = RadioSetting("beep", "Beep",
RadioSettingValueBoolean(_settings.beep))
basic.append(rs)
rs = RadioSetting("voice", "Voice",
RadioSettingValueBoolean(_settings.voice))
advanced.append(rs)
rs = RadioSetting(
"language", "Language",
RadioSettingValueList(LANGUAGE_LIST,
LANGUAGE_LIST[_settings.language]))
advanced.append(rs)
rs = RadioSetting(
"mdfa", "Display Mode (A)",
RadioSettingValueList(MODE_LIST, MODE_LIST[_settings.mdfa]))
basic.append(rs)
rs = RadioSetting(
"mdfb", "Display Mode (B)",
RadioSettingValueList(MODE_LIST, MODE_LIST[_settings.mdfb]))
basic.append(rs)
rs = RadioSetting(
"scan_mode", "Scan Mode",
RadioSettingValueList(SCAN_MODE_LIST,
SCAN_MODE_LIST[_settings.scan_mode]))
basic.append(rs)
rs = RadioSetting("bcl", "Busy Channel Lockout",
RadioSettingValueBoolean(_settings.bcl))
advanced.append(rs)
rs = RadioSetting("autolk", "Automatic Key Lock",
RadioSettingValueBoolean(_settings.autolk))
advanced.append(rs)
rs = RadioSetting(
"almod", "Alarm Mode",
RadioSettingValueList(ALMOD_LIST, ALMOD_LIST[_settings.almod]))
advanced.append(rs)
rs = RadioSetting("alsnd", "Alarm Sound",
RadioSettingValueBoolean(_settings.alsnd))
advanced.append(rs)
rs = RadioSetting("ste", "Squelch Tail Eliminate (HT to HT)",
RadioSettingValueBoolean(_settings.ste))
advanced.append(rs)
rs = RadioSetting(
"rpste", "Squelch Tail Eliminate (repeater)",
RadioSettingValueList(RPSTE_LIST, RPSTE_LIST[_settings.rpste]))
advanced.append(rs)
rs = RadioSetting(
"rptrl", "STE Repeater Delay",
RadioSettingValueList(STEDELAY_LIST,
STEDELAY_LIST[_settings.rptrl]))
advanced.append(rs)
rs = RadioSetting("fmradio", "Disable Broadcast FM Radio",
RadioSettingValueBoolean(_settings.fmradio))
advanced.append(rs)
rs = RadioSetting("keylock", "Keypad Lock",
RadioSettingValueBoolean(_settings.keylock))
advanced.append(rs)
rs = RadioSetting(
"voxdelay", "VOX Delay",
RadioSettingValueList(VOX_DELAY_LIST,
VOX_DELAY_LIST[_settings.voxdelay]))
advanced.append(rs)
rs = RadioSetting(
"menu_timeout", "Menu Timeout",
RadioSettingValueList(MENU_TIMEOUT_LIST,
MENU_TIMEOUT_LIST[_settings.menu_timeout]))
advanced.append(rs)
rs = RadioSetting(
"micgain", "Mic Gain",
RadioSettingValueList(MICGAIN_LIST,
MICGAIN_LIST[_settings.micgain]))
advanced.append(rs)
for entry in KEY_FUNCTIONS:
if entry[1] == _keymaps.sidekey:
rs = RadioSetting(
"keymaps.sidekey", "Side Key Short Press",
RadioSettingValueMap(KEY_FUNCTIONS, _keymaps.sidekey))
keymaps.append(rs)
for entry in KEY_FUNCTIONS:
if entry[1] == _keymaps.sidekeyl:
rs = RadioSetting(
"keymaps.sidekeyl", "Side Key Long Press",
RadioSettingValueMap(KEY_FUNCTIONS, _keymaps.sidekeyl))
keymaps.append(rs)
rs = RadioSetting(
"workmodea", "Work Mode (A)",
RadioSettingValueList(WORKMODE_LIST,
WORKMODE_LIST[_settings.workmodea]))
workmode.append(rs)
rs = RadioSetting(
"workmodeb", "Work Mode (B)",
RadioSettingValueList(WORKMODE_LIST,
WORKMODE_LIST[_settings.workmodeb]))
workmode.append(rs)
def convert_bytes_to_freq(bytes):
real_freq = 0
for byte in bytes:
real_freq = (real_freq * 10) + byte
return chirp_common.format_freq(real_freq * 10)
def my_validate(value):
value = chirp_common.parse_freq(value)
if 17400000 <= value and value < 40000000:
msg = ("Can't be between 174.00000-400.00000")
raise InvalidValueError(msg)
return chirp_common.format_freq(value)
def apply_freq(setting, obj):
value = chirp_common.parse_freq(str(setting.value)) / 10
obj.band = value >= 40000000
for i in range(7, -1, -1):
obj.freq[i] = value % 10
value /= 10
val1a = RadioSettingValueString(0, 10,
convert_bytes_to_freq(_vfoa.freq))
val1a.set_validate_callback(my_validate)
rs = RadioSetting("vfoa.freq", "VFO A Frequency", val1a)
rs.set_apply_callback(apply_freq, _vfoa)
workmode.append(rs)
val1b = RadioSettingValueString(0, 10,
convert_bytes_to_freq(_vfob.freq))
val1b.set_validate_callback(my_validate)
rs = RadioSetting("vfob.freq", "VFO B Frequency", val1b)
rs.set_apply_callback(apply_freq, _vfob)
workmode.append(rs)
rs = RadioSetting(
"vfoa.sftd", "VFO A Shift",
RadioSettingValueList(SHIFTD_LIST, SHIFTD_LIST[_vfoa.sftd]))
workmode.append(rs)
rs = RadioSetting(
"vfob.sftd", "VFO B Shift",
RadioSettingValueList(SHIFTD_LIST, SHIFTD_LIST[_vfob.sftd]))
workmode.append(rs)
def convert_bytes_to_offset(bytes):
real_offset = 0
for byte in bytes:
real_offset = (real_offset * 10) + byte
return chirp_common.format_freq(real_offset * 100)
def apply_offset(setting, obj):
value = chirp_common.parse_freq(str(setting.value)) / 100
for i in range(5, -1, -1):
obj.offset[i] = value % 10
value /= 10
val1a = RadioSettingValueString(0, 10,
convert_bytes_to_offset(_vfoa.offset))
rs = RadioSetting("vfoa.offset", "VFO A Offset (0.0-999.999)", val1a)
rs.set_apply_callback(apply_offset, _vfoa)
workmode.append(rs)
val1b = RadioSettingValueString(0, 10,
convert_bytes_to_offset(_vfob.offset))
rs = RadioSetting("vfob.offset", "VFO B Offset (0.0-999.999)", val1b)
rs.set_apply_callback(apply_offset, _vfob)
workmode.append(rs)
rs = RadioSetting(
"vfoa.txpower", "VFO A Power",
RadioSettingValueList(TXPOWER_LIST, TXPOWER_LIST[_vfoa.txpower]))
workmode.append(rs)
rs = RadioSetting(
"vfob.txpower", "VFO B Power",
RadioSettingValueList(TXPOWER_LIST, TXPOWER_LIST[_vfob.txpower]))
workmode.append(rs)
rs = RadioSetting(
"vfoa.widenarr", "VFO A Bandwidth",
RadioSettingValueList(BANDWIDTH_LIST,
BANDWIDTH_LIST[_vfoa.widenarr]))
workmode.append(rs)
rs = RadioSetting(
"vfob.widenarr", "VFO B Bandwidth",
RadioSettingValueList(BANDWIDTH_LIST,
BANDWIDTH_LIST[_vfob.widenarr]))
workmode.append(rs)
rs = RadioSetting(
"vfoa.scode", "VFO A PTT-ID",
RadioSettingValueList(PTTIDCODE_LIST, PTTIDCODE_LIST[_vfoa.scode]))
workmode.append(rs)
rs = RadioSetting(
"vfob.scode", "VFO B PTT-ID",
RadioSettingValueList(PTTIDCODE_LIST, PTTIDCODE_LIST[_vfob.scode]))
workmode.append(rs)
rs = RadioSetting(
"vfoa.step", "VFO A Tuning Step",
RadioSettingValueList(STEP_LIST, STEP_LIST[_vfoa.step]))
workmode.append(rs)
rs = RadioSetting(
"vfob.step", "VFO B Tuning Step",
RadioSettingValueList(STEP_LIST, STEP_LIST[_vfob.step]))
workmode.append(rs)
dtmfchars = "0123456789 *#ABCD"
for i in range(0, 15):
_codeobj = self._memobj.pttid[i].code
_code = "".join([dtmfchars[x] for x in _codeobj if int(x) < 0x1F])
val = RadioSettingValueString(0, 5, _code, False)
val.set_charset(dtmfchars)
rs = RadioSetting("pttid/%i.code" % i, "PTT ID Code %i" % (i + 1),
val)
def apply_code(setting, obj):
code = []
for j in range(0, 5):
try:
code.append(dtmfchars.index(str(setting.value)[j]))
except IndexError:
code.append(0xFF)
obj.code = code
rs.set_apply_callback(apply_code, self._memobj.pttid[i])
dtmf.append(rs)
rs = RadioSetting(
"ani.aniid", "ANI ID",
RadioSettingValueList(PTTID_LIST, PTTID_LIST[_ani.aniid]))
dtmf.append(rs)
_codeobj = self._memobj.ani.code
_code = "".join([dtmfchars[x] for x in _codeobj if int(x) < 0x1F])
val = RadioSettingValueString(0, 5, _code, False)
val.set_charset(dtmfchars)
rs = RadioSetting("ani.code", "ANI Code", val)
def apply_code(setting, obj):
code = []
for j in range(0, 5):
try:
code.append(dtmfchars.index(str(setting.value)[j]))
except IndexError:
code.append(0xFF)
obj.code = code
rs.set_apply_callback(apply_code, _ani)
dtmf.append(rs)
rs = RadioSetting(
"dtmfst", "DTMF Sidetone",
RadioSettingValueList(DTMFST_LIST, DTMFST_LIST[_settings.dtmfst]))
dtmf.append(rs)
if _ani.dtmfon > 0xC3:
val = 0x00
else:
val = _ani.dtmfon
rs = RadioSetting(
"ani.dtmfon", "DTMF Speed (on)",
RadioSettingValueList(DTMFSPEED_LIST, DTMFSPEED_LIST[val]))
dtmf.append(rs)
if _ani.dtmfoff > 0xC3:
val = 0x00
else:
val = _ani.dtmfoff
rs = RadioSetting(
"ani.dtmfoff", "DTMF Speed (off)",
RadioSettingValueList(DTMFSPEED_LIST, DTMFSPEED_LIST[val]))
dtmf.append(rs)
rs = RadioSetting(
"pttlt", "PTT ID Delay",
RadioSettingValueList(PTTLT_LIST, PTTLT_LIST[_settings.pttlt]))
dtmf.append(rs)
return group
def _get_settings(self):
# TODO
top = RadioSettings()
return top
def get_settings(self):
"""Translate the bit in the mem_struct into settings in the UI"""
_mem = self._memobj
basic = RadioSettingGroup("basic", "Basic Settings")
other = RadioSettingGroup("other", "Other Settings")
work = RadioSettingGroup("work", "Work Mode Settings")
dtmf = RadioSettingGroup("dtmf", "DTMF Settings")
top = RadioSettings(basic, other, work, dtmf)
# Basic
# Audio: A01-A04
aftone = RadioSetting(
"settings.aftone", "AF tone control",
RadioSettingValueList(LIST_AFTONE,
LIST_AFTONE[_mem.settings.aftone]))
basic.append(aftone)
spkr = RadioSetting(
"settings.spkr", "Speaker",
RadioSettingValueList(LIST_SPKR, LIST_SPKR[_mem.settings.spkr]))
basic.append(spkr)
audio = RadioSetting(
"settings.audio", "Stereo/Mono",
RadioSettingValueList(LIST_AUDIO, LIST_AUDIO[_mem.settings.audio]))
basic.append(audio)
sbmute = RadioSetting(
"settings.sbmute", "Sub band mute",
RadioSettingValueList(LIST_SBMUTE,
LIST_SBMUTE[_mem.settings.sbmute]))
basic.append(sbmute)
# TX/RX: B01-B08
mgain = RadioSetting(
"settings.mgain", "Mic gain",
RadioSettingValueList(LIST_MLNHM, LIST_MLNHM[_mem.settings.mgain]))
basic.append(mgain)
ptt = RadioSetting(
"settings.ptt", "PTT mode",
RadioSettingValueList(LIST_PTT, LIST_PTT[_mem.settings.ptt]))
basic.append(ptt)
# B03 (per channel)
# B04 (per channel)
rxexp = RadioSetting(
"settings.rxexp", "RX expansion",
RadioSettingValueList(LIST_RXEXP, LIST_RXEXP[_mem.settings.rxexp]))
basic.append(rxexp)
vox = RadioSetting(
"settings.vox", "Vox",
RadioSettingValueList(LIST_VOX, LIST_VOX[_mem.settings.vox]))
basic.append(vox)
voxs = RadioSetting(
"settings.voxs", "Vox sensitivity",
RadioSettingValueList(LIST_MLNHM, LIST_MLNHM[_mem.settings.voxs]))
basic.append(voxs)
# B08 (per channel)
# Display: C01-C06
display = RadioSetting(
"settings.display", "Display select",
RadioSettingValueList(LIST_DISPLAY,
LIST_DISPLAY[_mem.settings.display]))
basic.append(display)
lcdb = RadioSetting(
"settings.lcdb", "LCD brightness",
RadioSettingValueList(LIST_MINMAX,
LIST_MINMAX[_mem.settings.lcdb]))
basic.append(lcdb)
color = RadioSetting(
"settings.color", "LCD color",
RadioSettingValueList(LIST_COLOR, LIST_COLOR[_mem.settings.color]))
basic.append(color)
lcdc = RadioSetting(
"settings.lcdc", "LCD contrast",
RadioSettingValueList(LIST_MINMAX,
LIST_MINMAX[_mem.settings.lcdc]))
basic.append(lcdc)
btime = RadioSetting(
"settings.btime", "LCD backlight time",
RadioSettingValueList(LIST_BTIME, LIST_BTIME[_mem.settings.btime]))
basic.append(btime)
keyb = RadioSetting(
"settings.keyb", "Key brightness",
RadioSettingValueList(LIST_MINMAX,
LIST_MINMAX[_mem.settings.keyb]))
basic.append(keyb)
# Memory: D01-D04
# D01 (per channel)
# D02 (per channel)
mrscan = RadioSetting(
"settings.mrscan", "Memory scan type",
RadioSettingValueList(LIST_MRSCAN,
LIST_MRSCAN[_mem.settings.mrscan]))
basic.append(mrscan)
# D04 (per channel)
# Scan: E01-E04
dwstop = RadioSetting(
"settings.dwstop", "Dual watch stop",
RadioSettingValueList(LIST_DWSTOP,
LIST_DWSTOP[_mem.settings.dwstop]))
basic.append(dwstop)
scand = RadioSetting(
"settings.scand", "Scan direction",
RadioSettingValueList(LIST_SCAND, LIST_SCAND[_mem.settings.scand]))
basic.append(scand)
scanr = RadioSetting(
"settings.scanr", "Scan resume",
RadioSettingValueList(LIST_SCANR, LIST_SCANR[_mem.settings.scanr]))
basic.append(scanr)
scansb = RadioSetting("settings.scansb", "Scan stop beep",
RadioSettingValueBoolean(_mem.settings.scansb))
basic.append(scansb)
# System: F01-F09
apo = RadioSetting(
"settings.apo", "Automatic power off [hours]",
RadioSettingValueList(LIST_APO, LIST_APO[_mem.settings.apo]))
basic.append(apo)
ars = RadioSetting("settings.ars", "Automatic repeater shift",
RadioSettingValueBoolean(_mem.settings.ars))
basic.append(ars)
beep = RadioSetting(
"settings.beep", "Beep volume",
RadioSettingValueList(LIST_BEEP, LIST_BEEP[_mem.settings.beep]))
basic.append(beep)
fkey = RadioSetting(
"settings.fkey", "F key",
RadioSettingValueList(LIST_FKEY, LIST_FKEY[_mem.settings.fkey]))
basic.append(fkey)
pfkey1 = RadioSetting(
"settings.pfkey1", "Mic P1 key",
RadioSettingValueList(LIST_PFKEY,
LIST_PFKEY[_mem.settings.pfkey1]))
basic.append(pfkey1)
pfkey2 = RadioSetting(
"settings.pfkey2", "Mic P2 key",
RadioSettingValueList(LIST_PFKEY,
LIST_PFKEY[_mem.settings.pfkey2]))
basic.append(pfkey2)
pfkey3 = RadioSetting(
"settings.pfkey3", "Mic P3 key",
RadioSettingValueList(LIST_PFKEY,
LIST_PFKEY[_mem.settings.pfkey3]))
basic.append(pfkey3)
pfkey4 = RadioSetting(
"settings.pfkey4", "Mic P4 key",
RadioSettingValueList(LIST_PFKEY,
LIST_PFKEY[_mem.settings.pfkey4]))
basic.append(pfkey4)
omode = RadioSetting(
"settings.omode", "Operation mode",
RadioSettingValueList(LIST_AB, LIST_AB[_mem.settings.omode]))
basic.append(omode)
rxcoverm = RadioSetting(
"settings.rxcoverm", "RX coverage - memory",
RadioSettingValueList(LIST_COVERAGE,
LIST_COVERAGE[_mem.settings.rxcoverm]))
basic.append(rxcoverm)
rxcoverv = RadioSetting(
"settings.rxcoverv", "RX coverage - VFO",
RadioSettingValueList(LIST_COVERAGE,
LIST_COVERAGE[_mem.settings.rxcoverv]))
basic.append(rxcoverv)
tot = RadioSetting(
"settings.tot", "Time out timer [min]",
RadioSettingValueList(LIST_TOT, LIST_TOT[_mem.settings.tot]))
basic.append(tot)
# Timer/Clock: G01-G04
# G01
datefmt = RadioSetting(
"settings.datefmt", "Date format",
RadioSettingValueList(LIST_DATEFMT,
LIST_DATEFMT[_mem.settings.datefmt]))
basic.append(datefmt)
timefmt = RadioSetting(
"settings.timefmt", "Time format",
RadioSettingValueList(LIST_TIMEFMT,
LIST_TIMEFMT[_mem.settings.timefmt]))
basic.append(timefmt)
timesig = RadioSetting("settings.timesig", "Time signal",
RadioSettingValueBoolean(_mem.settings.timesig))
basic.append(timesig)
tz = RadioSetting(
"settings.tz", "Time zone",
RadioSettingValueList(LIST_TZ, LIST_TZ[_mem.settings.tz]))
basic.append(tz)
# Signaling: H01-H06
bell = RadioSetting(
"settings.bell", "Bell ringer",
RadioSettingValueList(LIST_BELL, LIST_BELL[_mem.settings.bell]))
basic.append(bell)
# H02 (per channel)
dtmfmodenc = RadioSetting(
"settings.dtmfmodenc", "DTMF mode encode",
RadioSettingValueBoolean(_mem.settings.dtmfmodenc))
basic.append(dtmfmodenc)
dtmfmoddec = RadioSetting(
"settings.dtmfmoddec", "DTMF mode decode",
RadioSettingValueBoolean(_mem.settings.dtmfmoddec))
basic.append(dtmfmoddec)
# H04 (per channel)
decbandsel = RadioSetting(
"settings.decbandsel", "DTMF band select",
RadioSettingValueList(LIST_AB, LIST_AB[_mem.settings.decbandsel]))
basic.append(decbandsel)
sqlexp = RadioSetting("settings.sqlexp", "SQL expansion",
RadioSettingValueBoolean(_mem.settings.sqlexp))
basic.append(sqlexp)
# Pkt: I01-I03
databnd = RadioSetting(
"settings.databnd", "Packet data band",
RadioSettingValueList(LIST_DATABND,
LIST_DATABND[_mem.settings.databnd]))
basic.append(databnd)
dataspd = RadioSetting(
"settings.dataspd", "Packet data speed",
RadioSettingValueList(LIST_DATASPD,
LIST_DATASPD[_mem.settings.dataspd]))
basic.append(dataspd)
datasql = RadioSetting(
"settings.datasql", "Packet data squelch",
RadioSettingValueList(LIST_DATASQL,
LIST_DATASQL[_mem.settings.datasql]))
basic.append(datasql)
# Other
dw = RadioSetting("settings.dw", "Dual watch",
RadioSettingValueBoolean(_mem.settings.dw))
other.append(dw)
cpuclk = RadioSetting(
"settings.cpuclk", "CPU clock frequency",
RadioSettingValueList(LIST_CPUCLK,
LIST_CPUCLK[_mem.settings.cpuclk]))
other.append(cpuclk)
def _filter(name):
filtered = ""
for char in str(name):
if char in VALID_CHARS:
filtered += char
else:
filtered += " "
return filtered
line16 = RadioSetting(
"poweron_msg.line16", "Power-on message",
RadioSettingValueString(0, 16, _filter(_mem.poweron_msg.line16)))
other.append(line16)
line32 = RadioSetting(
"embedded_msg.line32", "Embedded message",
RadioSettingValueString(0, 32, _filter(_mem.embedded_msg.line32)))
other.append(line32)
# Work
workmoda = RadioSetting(
"settings.workmoda", "Work mode A",
RadioSettingValueList(LIST_WORK,
LIST_WORK[_mem.settings.workmoda]))
work.append(workmoda)
workmodb = RadioSetting(
"settings.workmodb", "Work mode B",
RadioSettingValueList(LIST_WORK,
LIST_WORK[_mem.settings.workmodb]))
work.append(workmodb)
wbanda = RadioSetting(
"settings.wbanda", "Work band A",
RadioSettingValueList(LIST_WBANDA,
LIST_WBANDA[(_mem.settings.wbanda) - 1]))
work.append(wbanda)
wbandb = RadioSetting(
"settings.wbandb", "Work band B",
RadioSettingValueList(LIST_WBANDB,
LIST_WBANDB[(_mem.settings.wbandb) - 4]))
work.append(wbandb)
sqla = RadioSetting(
"settings.sqla", "Squelch A",
RadioSettingValueList(LIST_SQL, LIST_SQL[_mem.settings.sqla]))
work.append(sqla)
sqlb = RadioSetting(
"settings.sqlb", "Squelch B",
RadioSettingValueList(LIST_SQL, LIST_SQL[_mem.settings.sqlb]))
work.append(sqlb)
stepa = RadioSetting(
"settings.stepa", "Auto step A",
RadioSettingValueList(LIST_STEP, LIST_STEP[_mem.settings.stepa]))
work.append(stepa)
stepb = RadioSetting(
"settings.stepb", "Auto step B",
RadioSettingValueList(LIST_STEP, LIST_STEP[_mem.settings.stepb]))
work.append(stepb)
mrcha = RadioSetting(
"settings.mrcha", "Current channel A",
RadioSettingValueInteger(0, 499, _mem.settings.mrcha))
work.append(mrcha)
mrchb = RadioSetting(
"settings.mrchb", "Current channel B",
RadioSettingValueInteger(0, 499, _mem.settings.mrchb))
work.append(mrchb)
val = _mem.settings.offseta / 100.00
offseta = RadioSetting("settings.offseta", "Offset A (0-37.95)",
RadioSettingValueFloat(0, 38.00, val, 0.05, 2))
work.append(offseta)
val = _mem.settings.offsetb / 100.00
offsetb = RadioSetting("settings.offsetb", "Offset B (0-79.95)",
RadioSettingValueFloat(0, 80.00, val, 0.05, 2))
work.append(offsetb)
wpricha = RadioSetting(
"settings.wpricha", "Priority channel A",
RadioSettingValueInteger(0, 499, _mem.settings.wpricha))
work.append(wpricha)
wprichb = RadioSetting(
"settings.wprichb", "Priority channel B",
RadioSettingValueInteger(0, 499, _mem.settings.wprichb))
work.append(wprichb)
smode = RadioSetting(
"settings.smode", "Smart function mode",
RadioSettingValueList(LIST_SMODE, LIST_SMODE[_mem.settings.smode]))
work.append(smode)
# dtmf
ttdkey = RadioSetting(
"dtmf.ttdkey", "D key function",
RadioSettingValueList(LIST_TTDKEY, LIST_TTDKEY[_mem.dtmf.ttdkey]))
dtmf.append(ttdkey)
ttdgt = RadioSetting(
"dtmf.ttdgt", "Digit time",
RadioSettingValueList(LIST_TT200,
LIST_TT200[(_mem.dtmf.ttdgt) - 5]))
dtmf.append(ttdgt)
ttint = RadioSetting(
"dtmf.ttint", "Interval time",
RadioSettingValueList(LIST_TT200,
LIST_TT200[(_mem.dtmf.ttint) - 5]))
dtmf.append(ttint)
tt1stdgt = RadioSetting(
"dtmf.tt1stdgt", "1st digit time",
RadioSettingValueList(LIST_TT200,
LIST_TT200[(_mem.dtmf.tt1stdgt) - 5]))
dtmf.append(tt1stdgt)
tt1stdly = RadioSetting(
"dtmf.tt1stdly", "1st digit delay time",
RadioSettingValueList(LIST_TT1000,
LIST_TT1000[(_mem.dtmf.tt1stdly) - 2]))
dtmf.append(tt1stdly)
ttdlyqt = RadioSetting(
"dtmf.ttdlyqt", "Digit delay when use qt",
RadioSettingValueList(LIST_TT1000,
LIST_TT1000[(_mem.dtmf.ttdlyqt) - 2]))
dtmf.append(ttdlyqt)
ttsig = RadioSetting(
"dtmf2.ttsig", "Signal",
RadioSettingValueList(LIST_TTSIG, LIST_TTSIG[_mem.dtmf2.ttsig]))
dtmf.append(ttsig)
ttautorst = RadioSetting(
"dtmf2.ttautorst", "Auto reset time",
RadioSettingValueList(LIST_TTAUTORST,
LIST_TTAUTORST[_mem.dtmf2.ttautorst]))
dtmf.append(ttautorst)
if _mem.dtmf2.ttgrpcode > 0x06:
val = 0x00
else:
val = _mem.dtmf2.ttgrpcode
ttgrpcode = RadioSetting(
"dtmf2.ttgrpcode", "Group code",
RadioSettingValueList(LIST_TTGRPCODE, LIST_TTGRPCODE[val]))
dtmf.append(ttgrpcode)
ttintcode = RadioSetting(
"dtmf2.ttintcode", "Interval code",
RadioSettingValueList(LIST_TTINTCODE,
LIST_TTINTCODE[_mem.dtmf2.ttintcode]))
dtmf.append(ttintcode)
if _mem.dtmf2.ttalert > 0x04:
val = 0x00
else:
val = _mem.dtmf2.ttalert
ttalert = RadioSetting(
"dtmf2.ttalert", "Alert tone/transpond",
RadioSettingValueList(LIST_TTALERT, LIST_TTALERT[val]))
dtmf.append(ttalert)
ttautod = RadioSetting(
"dtmf.ttautod", "Auto dial group",
RadioSettingValueList(LIST_TTAUTOD,
LIST_TTAUTOD[_mem.dtmf.ttautod]))
dtmf.append(ttautod)
# setup 9 dtmf autodial entries
for i in map(str, range(1, 10)):
objname = "code" + i
strname = "Code " + str(i)
dtmfsetting = getattr(_mem.dtmfcode, objname)
dtmflen = getattr(_mem.dtmfcode, objname + "_len")
dtmfstr = self._bbcd2dtmf(dtmfsetting, dtmflen)
code = RadioSettingValueString(0, 16, dtmfstr)
code.set_charset(DTMF_CHARS + list(" "))
rs = RadioSetting("dtmfcode." + objname, strname, code)
dtmf.append(rs)
return top
def get_settings(self):
_settings = self._memobj.settings
_mem = self._memobj
basic = RadioSettingGroup("basic", "Basic Settings")
dtmf = RadioSettingGroup("dtmf", "DTMF Settings")
top = RadioSettings(basic, dtmf)
if _settings.k1shortp > 5:
val = 4
else:
val = _settings.k1shortp
rs = RadioSetting(
"k1shortp", "Key 1 Short Press",
RadioSettingValueList(LIST_SHORT_PRESS, LIST_SHORT_PRESS[val]))
basic.append(rs)
if _settings.k1longp > 5:
val = 5
else:
val = _settings.k1longp
rs = RadioSetting(
"k1longp", "Key 1 Long Press",
RadioSettingValueList(LIST_LONG_PRESS, LIST_LONG_PRESS[val]))
basic.append(rs)
if _settings.k2shortp > 5:
val = 1
else:
val = _settings.k2shortp
rs = RadioSetting(
"k2shortp", "Key 2 Short Press",
RadioSettingValueList(LIST_SHORT_PRESS, LIST_SHORT_PRESS[val]))
basic.append(rs)
if _settings.k2longp > 5:
val = 3
else:
val = _settings.k2longp
rs = RadioSetting(
"k2longp", "Key 2 Long Press",
RadioSettingValueList(LIST_LONG_PRESS, LIST_LONG_PRESS[val]))
basic.append(rs)
rs = RadioSetting("vox", "VOX",
RadioSettingValueBoolean(not _settings.vox))
basic.append(rs)
if _settings.voxg > 8:
val = 4
else:
val = _settings.voxg + 1
rs = RadioSetting("voxg", "VOX Gain",
RadioSettingValueInteger(1, 9, val))
basic.append(rs)
rs = RadioSetting(
"voxd", "VOX Delay Time",
RadioSettingValueList(LIST_VOXDELAY,
LIST_VOXDELAY[_settings.voxd]))
basic.append(rs)
rs = RadioSetting("voxi", "VOX Inhibit on Receive",
RadioSettingValueBoolean(_settings.voxi))
basic.append(rs)
if _settings.squelch > 9:
val = 5
else:
val = _settings.squelch
rs = RadioSetting("squelch", "Squelch Level",
RadioSettingValueInteger(0, 9, val))
basic.append(rs)
if _settings.voice == 3:
val = 1
else:
val = _settings.voice
rs = RadioSetting("voice", "Voice Prompts",
RadioSettingValueList(LIST_VOICE, LIST_VOICE[val]))
basic.append(rs)
rs = RadioSetting("tone", "Tone",
RadioSettingValueBoolean(_settings.tone))
basic.append(rs)
rs = RadioSetting("lovoltnotx", "TX Inhibit (when battery < 6 volts)",
RadioSettingValueBoolean(_settings.lovoltnotx))
basic.append(rs)
rs = RadioSetting("hivoltnotx", "TX Inhibit (when battery > 9 volts)",
RadioSettingValueBoolean(_settings.hivoltnotx))
basic.append(rs)
if _settings.tot > 0x28:
val = 6
else:
val = _settings.tot
rs = RadioSetting(
"tot", "Time-out Timer[s]",
RadioSettingValueList(LIST_TIMEOUTTIMER, LIST_TIMEOUTTIMER[val]))
basic.append(rs)
if _settings.save < 3:
val = 0
else:
val = _settings.save - 3
rs = RadioSetting("save", "Battery Saver",
RadioSettingValueList(LIST_SAVE, LIST_SAVE[val]))
basic.append(rs)
rs = RadioSetting(
"ssave", "Super Battery Saver[s]",
RadioSettingValueList(LIST_SSAVE, LIST_SSAVE[_settings.ssave]))
basic.append(rs)
rs = RadioSetting("fmradio", "Broadcast FM",
RadioSettingValueBoolean(_settings.fmradio))
basic.append(rs)
if _settings.scanspeed > 8:
val = 4
else:
val = _settings.scanspeed
rs = RadioSetting(
"scanspeed", "Scan Speed[ms]",
RadioSettingValueList(LIST_SCANSPEED, LIST_SCANSPEED[val]))
basic.append(rs)
if _settings.scandelay > 27:
val = 12
else:
val = _settings.scandelay
rs = RadioSetting(
"scandelay", "Scan Droupout Delay Time[s]",
RadioSettingValueList(LIST_SCANDELAY, LIST_SCANDELAY[val]))
basic.append(rs)
if _mem.dtmf.dtmfspd > 11:
val = 2
else:
val = _mem.dtmf.dtmfspd + 4
rs = RadioSetting("dtmf.dtmfspd", "DTMF Speed[digit/s]",
RadioSettingValueInteger(4, 15, val))
dtmf.append(rs)
if _mem.dtmf.digtime > 10:
val = 0
else:
val = _mem.dtmf.digtime
rs = RadioSetting(
"dtmf.digtime", "1st Digit Time[ms]",
RadioSettingValueList(LIST_DIGTIME, LIST_DIGTIME[val]))
dtmf.append(rs)
if _mem.dtmf.digdelay > 9:
val = 0
else:
val = _mem.dtmf.digdelay
rs = RadioSetting(
"dtmf.digdelay", "1st Digit Delay[ms]",
RadioSettingValueList(LIST_DIGDELAY, LIST_DIGDELAY[val]))
dtmf.append(rs)
rs = RadioSetting(
"dtmf.starhash", "* and # Time[ms]",
RadioSettingValueList(LIST_STARHASH,
LIST_STARHASH[_mem.dtmf.starhash]))
dtmf.append(rs)
rs = RadioSetting(
"dtmf.codespace", "Code Space Time[ms]",
RadioSettingValueList(LIST_CODESPACE,
LIST_CODESPACE[_mem.dtmf.codespace]))
dtmf.append(rs)
rs = RadioSetting("dtmf.sidetone", "DTMF Sidetone",
RadioSettingValueBoolean(_mem.dtmf.sidetone))
dtmf.append(rs)
# setup pttid entries
for i in range(0, 2):
objname = "code" + str(i + 1)
names = ["PTT ID(BOT)", "PTT ID(EOT)"]
strname = str(names[i])
dtmfsetting = getattr(_mem.dtmf, objname)
dtmflen = getattr(_mem.dtmf, objname + "_len")
dtmfstr = self._bbcd2dtmf(dtmfsetting, dtmflen)
code = RadioSettingValueString(0, 16, dtmfstr)
code.set_charset(DTMF_CHARSET + list(" "))
rs = RadioSetting("dtmf." + objname, strname, code)
dtmf.append(rs)
def _filter(name):
filtered = ""
for char in str(name):
if char in NUMERIC_CHARSET:
filtered += char
else:
filtered += " "
return filtered
# setup id code entry
codesetting = getattr(_mem.dtmf, "idcode")
codestr = self._bbcd2num(codesetting, 6)
code = RadioSettingValueString(0, 6, _filter(codestr))
code.set_charset(NUMERIC_CHARSET + list(" "))
rs = RadioSetting("dtmf.idcode", "ID Code", code)
dtmf.append(rs)
if _mem.dtmf.groupcode > 6:
val = 0
else:
val = _mem.dtmf.groupcode
rs = RadioSetting(
"dtmf.groupcode", "Group Code",
RadioSettingValueList(LIST_GROUPCODE, LIST_GROUPCODE[val]))
dtmf.append(rs)
if _mem.dtmf.resettime > 60:
val = 0
else:
val = _mem.dtmf.resettime
rs = RadioSetting(
"dtmf.resettime", "Auto Reset Time[s]",
RadioSettingValueList(LIST_RESETTIME,
LIST_RESETTIME[_mem.dtmf.resettime]))
dtmf.append(rs)
rs = RadioSetting("dtmf.txdecode", "TX Decode",
RadioSettingValueBoolean(_mem.dtmf.txdecode))
dtmf.append(rs)
rs = RadioSetting(
"dtmf.decodeto", "Decode Time Out[ms]",
RadioSettingValueList(LIST_DECODETO,
LIST_DECODETO[_mem.dtmf.decodeto]))
dtmf.append(rs)
rs = RadioSetting("dtmf.decodetone", "Decode Tone",
RadioSettingValueBoolean(_mem.dtmf.decodetone))
dtmf.append(rs)
rs = RadioSetting("dtmf.resettone", "Reset Tone",
RadioSettingValueBoolean(_mem.dtmf.resettone))
dtmf.append(rs)
rs = RadioSetting(
"dtmf.stuntype", "Stun Type",
RadioSettingValueList(LIST_STUNTYPE,
LIST_STUNTYPE[_mem.dtmf.stuntype]))
dtmf.append(rs)
## setup stun entry
objname = "code3"
strname = "Stun Code"
dtmfsetting = getattr(_mem.dtmf, objname)
dtmflen = getattr(_mem.dtmf, objname + "_len")
dtmfstr = self._bbcd2dtmf(dtmfsetting, dtmflen)
code = RadioSettingValueString(0, 10, dtmfstr)
code.set_charset(DTMF_CHARSET + list(" "))
rs = RadioSetting("dtmf." + objname, strname, code)
dtmf.append(rs)
return top
def get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic Settings")
top = RadioSettings(basic)
if self.MODEL == "RT21" or self.MODEL == "RB17A":
_keys = self._memobj.keys
rs = RadioSettingValueList(TIMEOUTTIMER_LIST,
TIMEOUTTIMER_LIST[_settings.tot - 1])
rset = RadioSetting("tot", "Time-out timer", rs)
basic.append(rset)
rs = RadioSettingValueList(TOTALERT_LIST,
TOTALERT_LIST[_settings.totalert])
rset = RadioSetting("totalert", "TOT Pre-alert", rs)
basic.append(rset)
rs = RadioSettingValueInteger(0, 9, _settings.squelch)
rset = RadioSetting("squelch", "Squelch Level", rs)
basic.append(rset)
rs = RadioSettingValueList(VOICE_LIST, VOICE_LIST[_settings.voice])
rset = RadioSetting("voice", "Voice Annumciation", rs)
basic.append(rset)
if self.MODEL == "RB17A":
rs = RadioSettingValueList(ALARM_LIST,
ALARM_LIST[_settings.alarm])
rset = RadioSetting("alarm", "Alarm Type", rs)
basic.append(rset)
rs = RadioSettingValueBoolean(_settings.save)
rset = RadioSetting("save", "Battery Saver", rs)
basic.append(rset)
rs = RadioSettingValueBoolean(_settings.use_scramble)
rset = RadioSetting("use_scramble", "Scramble", rs)
basic.append(rset)
rs = RadioSettingValueBoolean(_settings.use_vox)
rset = RadioSetting("use_vox", "VOX", rs)
basic.append(rset)
rs = RadioSettingValueList(VOX_LIST, VOX_LIST[_settings.vox])
rset = RadioSetting("vox", "VOX Gain", rs)
basic.append(rset)
def apply_pf1_listvalue(setting, obj):
LOG.debug("Setting value: " + str(
setting.value) + " from list")
val = str(setting.value)
index = PF1_CHOICES.index(val)
val = PF1_VALUES[index]
obj.set_value(val)
if _keys.pf1 in PF1_VALUES:
idx = PF1_VALUES.index(_keys.pf1)
else:
idx = LIST_DTMF_SPECIAL_VALUES.index(0x04)
rs = RadioSettingValueList(PF1_CHOICES, PF1_CHOICES[idx])
rset = RadioSetting("keys.pf1", "PF1 Key Function", rs)
rset.set_apply_callback(apply_pf1_listvalue, _keys.pf1)
basic.append(rset)
def apply_topkey_listvalue(setting, obj):
LOG.debug("Setting value: " + str(setting.value) +
" from list")
val = str(setting.value)
index = TOPKEY_CHOICES.index(val)
val = TOPKEY_VALUES[index]
obj.set_value(val)
if self.MODEL == "RB17A":
if _keys.topkey in TOPKEY_VALUES:
idx = TOPKEY_VALUES.index(_keys.topkey)
else:
idx = TOPKEY_VALUES.index(0x0C)
rs = RadioSettingValueList(TOPKEY_CHOICES, TOPKEY_CHOICES[idx])
rset = RadioSetting("keys.topkey", "Top Key Function", rs)
rset.set_apply_callback(apply_topkey_listvalue, _keys.topkey)
basic.append(rset)
if self.MODEL == "RB26" or self.MODEL == "RT76":
if self.MODEL == "RB26":
_settings2 = self._memobj.settings2
_settings3 = self._memobj.settings3
rs = RadioSettingValueInteger(0, 9, _settings.squelch)
rset = RadioSetting("squelch", "Squelch Level", rs)
basic.append(rset)
rs = RadioSettingValueList(TIMEOUTTIMER_LIST,
TIMEOUTTIMER_LIST[_settings.tot - 1])
rset = RadioSetting("tot", "Time-out timer", rs)
basic.append(rset)
if self.MODEL == "RT76":
rs = RadioSettingValueList(VOICE_LIST3,
VOICE_LIST3[_settings.voice])
rset = RadioSetting("voice", "Voice Annumciation", rs)
basic.append(rset)
if self.MODEL == "RB26":
rs = RadioSettingValueList(VOICE_LIST2,
VOICE_LIST2[_settings.voice])
rset = RadioSetting("voice", "Voice Annumciation", rs)
basic.append(rset)
rs = RadioSettingValueBoolean(not _settings.chnumberd)
rset = RadioSetting("chnumberd", "Channel Number Enable", rs)
basic.append(rset)
rs = RadioSettingValueBoolean(_settings.save)
rset = RadioSetting("save", "Battery Save", rs)
basic.append(rset)
rs = RadioSettingValueBoolean(_settings.beep)
rset = RadioSetting("beep", "Beep", rs)
basic.append(rset)
if self.MODEL == "RB26":
rs = RadioSettingValueBoolean(not _settings.tail)
rset = RadioSetting("tail", "QT/DQT Tail", rs)
basic.append(rset)
rs = RadioSettingValueList(SAVE_LIST, SAVE_LIST[_settings.savem])
rset = RadioSetting("savem", "Battery Save Mode", rs)
basic.append(rset)
rs = RadioSettingValueList(GAIN_LIST, GAIN_LIST[_settings.gain])
rset = RadioSetting("gain", "MIC Gain", rs)
basic.append(rset)
rs = RadioSettingValueList(WARN_LIST, WARN_LIST[_settings.warn])
rset = RadioSetting("warn", "Warn Mode", rs)
basic.append(rset)
if self.MODEL == "RB26":
rs = RadioSettingValueBoolean(_settings3.vox)
rset = RadioSetting("settings3.vox", "Vox Function", rs)
basic.append(rset)
rs = RadioSettingValueList(VOXL_LIST,
VOXL_LIST[_settings3.voxl])
rset = RadioSetting("settings3.voxl", "Vox Level", rs)
basic.append(rset)
rs = RadioSettingValueList(VOXD_LIST,
VOXD_LIST[_settings3.voxd])
rset = RadioSetting("settings3.voxd", "Vox Delay", rs)
basic.append(rset)
rs = RadioSettingValueList(PFKEY_LIST,
PFKEY_LIST[_settings.pf1])
rset = RadioSetting("pf1", "PF1 Key Set", rs)
basic.append(rset)
rs = RadioSettingValueList(PFKEY_LIST,
PFKEY_LIST[_settings.pf2])
rset = RadioSetting("pf2", "PF2 Key Set", rs)
basic.append(rset)
rs = RadioSettingValueInteger(1, 30, _settings2.chnumber + 1)
rset = RadioSetting("settings2.chnumber", "Channel Number", rs)
basic.append(rset)
if self.MODEL == "RT76":
rs = RadioSettingValueBoolean(_settings.vox)
rset = RadioSetting("vox", "Vox Function", rs)
basic.append(rset)
rs = RadioSettingValueList(VOXL_LIST,
VOXL_LIST[_settings.voxl])
rset = RadioSetting("voxl", "Vox Level", rs)
basic.append(rset)
rs = RadioSettingValueList(VOXD_LIST,
VOXD_LIST[_settings.voxd])
rset = RadioSetting("voxd", "Vox Delay", rs)
basic.append(rset)
rs = RadioSettingValueInteger(1, 30, _settings.chnumber + 1)
rset = RadioSetting("chnumber", "Channel Number", rs)
basic.append(rset)
return top
def _get_settings(self):
top = RadioSettings(self._get_display_settings(),
self._get_audio_settings(),
self._get_battery_settings())
return top
def get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic Settings")
group = RadioSettings(basic)
options = ["Time", "Carrier", "Search"]
rs = RadioSetting(
"scantype", "Scan Type",
RadioSettingValueList(options, options[_settings.scantype]))
basic.append(rs)
options = ["Off"] + ["%s min" % x for x in range(1, 8)]
rs = RadioSetting(
"timeout", "Time Out Timer",
RadioSettingValueList(options, options[_settings.timeout]))
basic.append(rs)
options = ["A", "B"]
rs = RadioSetting(
"freqmode_ab", "Frequency Mode",
RadioSettingValueList(options, options[_settings.freqmode_ab]))
basic.append(rs)
options = ["Frequency Mode", "Channel Mode"]
rs = RadioSetting(
"workmode_a", "Radio Work Mode(A)",
RadioSettingValueList(options, options[_settings.workmode_a]))
basic.append(rs)
rs = RadioSetting(
"workmode_b", "Radio Work Mode(B)",
RadioSettingValueList(options, options[_settings.workmode_b]))
basic.append(rs)
options = ["Frequency", "Name", "Channel"]
rs = RadioSetting(
"mdf_a", "Display Format(F1)",
RadioSettingValueList(options, options[_settings.mdf_a]))
basic.append(rs)
rs = RadioSetting(
"mdf_b", "Display Format(F2)",
RadioSettingValueList(options, options[_settings.mdf_b]))
basic.append(rs)
rs = RadioSetting(
"mem_chan_a", "Mem Channel (A)",
RadioSettingValueInteger(1, 99, _settings.mem_chan_a))
basic.append(rs)
rs = RadioSetting(
"mem_chan_b", "Mem Channel (B)",
RadioSettingValueInteger(1, 99, _settings.mem_chan_b))
basic.append(rs)
options = ["Off", "BOT", "EOT", "Both"]
rs = RadioSetting(
"pttid", "PTT-ID",
RadioSettingValueList(options, options[_settings.pttid]))
basic.append(rs)
dtmfchars = "0123456789ABCD*#"
_codeobj = self._memobj.pttid.code
_code = "".join([dtmfchars[x] for x in _codeobj if int(x) < 0x1F])
val = RadioSettingValueString(0, 6, _code, False)
val.set_charset(dtmfchars)
rs = RadioSetting("pttid.code", "PTT-ID Code", val)
def apply_code(setting, obj):
code = []
for j in range(0, 6):
try:
code.append(dtmfchars.index(str(setting.value)[j]))
except IndexError:
code.append(0xFF)
obj.code = code
rs.set_apply_callback(apply_code, self._memobj.pttid)
basic.append(rs)
rs = RadioSetting("squelch", "Squelch Level",
RadioSettingValueInteger(0, 9, _settings.squelch))
basic.append(rs)
rs = RadioSetting("vox", "VOX Level",
RadioSettingValueInteger(0, 9, _settings.vox))
basic.append(rs)
options = ["Frequency Mode", "Channel Mode"]
rs = RadioSetting(
"workmode_fm", "FM Work Mode",
RadioSettingValueList(options, options[_settings.workmode_fm]))
basic.append(rs)
options = ["Current Frequency", "F1 Frequency", "F2 Frequency"]
rs = RadioSetting(
"txtdr", "Dual Standby TX Priority",
RadioSettingValueList(options, options[_settings.txtdr]))
basic.append(rs)
options = ["English", "Chinese"]
rs = RadioSetting(
"language", "Language",
RadioSettingValueList(options, options[_settings.language]))
basic.append(rs)
rs = RadioSetting("tdr", "Dual Standby",
RadioSettingValueBoolean(_settings.tdr))
basic.append(rs)
rs = RadioSetting("roger", "Roger Beep",
RadioSettingValueBoolean(_settings.roger))
basic.append(rs)
rs = RadioSetting("backlight", "Backlight",
RadioSettingValueBoolean(_settings.backlight))
basic.append(rs)
rs = RadioSetting("save_funct", "Save Mode",
RadioSettingValueBoolean(_settings.save_funct))
basic.append(rs)
rs = RadioSetting("fm", "FM Function",
RadioSettingValueBoolean(_settings.fm))
basic.append(rs)
rs = RadioSetting(
"beep_tone_disabled", "Beep Prompt",
RadioSettingValueBoolean(not _settings.beep_tone_disabled))
basic.append(rs)
rs = RadioSetting("voice_prompt", "Voice Prompt",
RadioSettingValueBoolean(_settings.voice_prompt))
basic.append(rs)
rs = RadioSetting("sidetone", "DTMF Side Tone",
RadioSettingValueBoolean(_settings.sidetone))
basic.append(rs)
rs = RadioSetting("ste_disabled", "Squelch Tail Eliminate",
RadioSettingValueBoolean(not _settings.ste_disabled))
basic.append(rs)
_limit = int(self._memobj.limits.lower_vhf) / 10
rs = RadioSetting("limits.lower_vhf", "VHF Lower Limit (MHz)",
RadioSettingValueInteger(128, 270, _limit))
def apply_limit(setting, obj):
value = int(setting.value) * 10
obj.lower_vhf = value
rs.set_apply_callback(apply_limit, self._memobj.limits)
basic.append(rs)
_limit = int(self._memobj.limits.upper_vhf) / 10
rs = RadioSetting("limits.upper_vhf", "VHF Upper Limit (MHz)",
RadioSettingValueInteger(128, 270, _limit))
def apply_limit(setting, obj):
value = int(setting.value) * 10
obj.upper_vhf = value
rs.set_apply_callback(apply_limit, self._memobj.limits)
basic.append(rs)
_limit = int(self._memobj.limits.lower_uhf) / 10
rs = RadioSetting("limits.lower_uhf", "UHF Lower Limit (MHz)",
RadioSettingValueInteger(400, 520, _limit))
def apply_limit(setting, obj):
value = int(setting.value) * 10
obj.lower_uhf = value
rs.set_apply_callback(apply_limit, self._memobj.limits)
basic.append(rs)
_limit = int(self._memobj.limits.upper_uhf) / 10
rs = RadioSetting("limits.upper_uhf", "UHF Upper Limit (MHz)",
RadioSettingValueInteger(400, 520, _limit))
def apply_limit(setting, obj):
value = int(setting.value) * 10
obj.upper_uhf = value
rs.set_apply_callback(apply_limit, self._memobj.limits)
basic.append(rs)
fm_preset = RadioSettingGroup("fm_preset", "FM Radio Presets")
group.append(fm_preset)
for i in range(0, 16):
if self._memobj.fm_presets[i] < 0x01AF:
used = True
preset = self._memobj.fm_presets[i] / 10.0 + 65
else:
used = False
preset = 65
rs = RadioSetting("fm_presets_%1i" % i, "FM Preset %i" % (i + 1),
RadioSettingValueBoolean(used),
RadioSettingValueFloat(65, 108, preset, 0.1, 1))
fm_preset.append(rs)
testmode = RadioSettingGroup("testmode", "Test Mode Settings")
group.append(testmode)
vhfdata = [
"136-139", "140-144", "145-149", "150-154", "155-159", "160-164",
"165-169", "170-174"
]
uhfdata = [
"400-409", "410-419", "420-429", "430-439", "440-449", "450-459",
"460-469", "470-479"
]
powernamedata = ["Hi", "Lo"]
powerkeydata = ["hipwr", "lopwr"]
for power in range(0, 2):
for index in range(0, 8):
key = "test.vhf%s%i" % (powerkeydata[power], index)
name = "%s Mhz %s Power" % (vhfdata[index],
powernamedata[power])
rs = RadioSetting(
key, name,
RadioSettingValueInteger(
0, 255,
getattr(self._memobj.test,
"vhf%s%i" % (powerkeydata[power], index))))
testmode.append(rs)
for power in range(0, 2):
for index in range(0, 8):
key = "test.uhf%s%i" % (powerkeydata[power], index)
name = "%s Mhz %s Power" % (uhfdata[index],
powernamedata[power])
rs = RadioSetting(
key, name,
RadioSettingValueInteger(
0, 255,
getattr(self._memobj.test,
"uhf%s%i" % (powerkeydata[power], index))))
testmode.append(rs)
for band in ["vhf", "uhf"]:
for index in range(0, 10):
key = "test.%ssquelch%i" % (band, index)
name = "%s Squelch %i" % (band.upper(), index)
rs = RadioSetting(
key, name,
RadioSettingValueInteger(
0, 255,
getattr(self._memobj.test,
"%ssquelch%i" % (band, index))))
testmode.append(rs)
return group
def _get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic")
arts = RadioSettingGroup("arts", "ARTS")
dtmf = RadioSettingGroup("dtmf", "DTMF")
wires = RadioSettingGroup("wires", "WIRES")
misc = RadioSettingGroup("misc", "Misc")
top = RadioSettings(basic, arts, dtmf, wires, misc)
# BASIC
val = RadioSettingValueList(
self._APO, self._APO[_settings.auto_power_off])
rs = RadioSetting("auto_power_off", "Auto Power Off", val)
basic.append(rs)
val = RadioSettingValueList(
self._BEEP_LEVEL, self._BEEP_LEVEL[_settings.beep_level])
rs = RadioSetting("beep_level", "Beep Level", val)
basic.append(rs)
val = RadioSettingValueList(
self._DIM_LEVEL, self._DIM_LEVEL[_settings.lcd_dimmer])
rs = RadioSetting("lcd_dimmer", "Dimmer Level", val)
basic.append(rs)
val = RadioSettingValueList(
self._LAMP, self._LAMP[_settings.lamp])
rs = RadioSetting("lamp", "Keypad Lamp", val)
basic.append(rs)
val = RadioSettingValueList(
self._LOCK, self._LOCK[_settings.lock])
rs = RadioSetting("lock", "Lock", val)
basic.append(rs)
val = RadioSettingValueList(
self._NUM_1_9, self._NUM_1_9[_settings.mic_gain])
rs = RadioSetting("mic_gain", "Mic Gain", val)
basic.append(rs)
val = RadioSettingValueList(
self._OPEN_MSG, self._OPEN_MSG[_settings.open_message_mode])
rs = RadioSetting("open_message_mode",
"Open Message Mode", val)
basic.append(rs)
val = RadioSettingValueString(0, 6,
self._decode_chars(
_settings.open_message))
val.set_charset(CHARSET)
rs = RadioSetting("open_message", "Opening Message", val)
basic.append(rs)
passstr = ""
for c in _settings.password:
if c < len(PASS_CHARSET):
passstr += PASS_CHARSET[c]
val = RadioSettingValueString(0, 4, passstr)
val.set_charset(PASS_CHARSET)
rs = RadioSetting("password", "Password", val)
basic.append(rs)
val = RadioSettingValueList(
self._RESUME, self._RESUME[_settings.resume])
rs = RadioSetting("resume", "Scan Resume", val)
basic.append(rs)
val = RadioSettingValueList(
self._MONI_TCALL, self._MONI_TCALL[_settings.moni_tcall])
rs = RadioSetting("moni_tcall", "MONI/T-CALL switch", val)
basic.append(rs)
rs = RadioSetting("scan_lamp", "Scan Lamp",
RadioSettingValueBoolean(_settings.scan_lamp))
basic.append(rs)
rs = RadioSetting("beep", "Keypad Beep",
RadioSettingValueBoolean(_settings.beep))
basic.append(rs)
rs = RadioSetting("busy_led", "Busy LED",
RadioSettingValueBoolean(_settings.busy_led))
basic.append(rs)
rs = RadioSetting("bclo", "Busy Channel Lock-Out",
RadioSettingValueBoolean(_settings.bclo))
basic.append(rs)
rs = RadioSetting("wx_alert", "WX Alert",
RadioSettingValueBoolean(_settings.wx_alert))
basic.append(rs)
rs = RadioSetting("att", "Attenuator",
RadioSettingValueBoolean(_settings.att))
basic.append(rs)
# ARTS
val = RadioSettingValueList(
self._ARTS_INT, self._ARTS_INT[_settings.arts_interval])
rs = RadioSetting("arts_interval", "ARTS Interval", val)
arts.append(rs)
val = RadioSettingValueList(
self._ARTSBEEP, self._ARTSBEEP[_settings.arts_beep])
rs = RadioSetting("arts_beep", "ARTS Beep", val)
arts.append(rs)
rs = RadioSetting("arts_cwid", "ARTS Send CWID",
RadioSettingValueBoolean(_settings.arts_cwid))
arts.append(rs)
val = RadioSettingValueString(0, 16,
self._decode_chars(
_settings.arts_cwid_alpha))
val.set_charset(CHARSET)
rs = RadioSetting("arts_cwid_alpha", "ARTS CW ID", val)
arts.append(rs)
# DTMF
val = RadioSettingValueList(
self._MAN_AUTO, self._MAN_AUTO[_settings.dtmf_autodial])
rs = RadioSetting("dtmf_autodial", "DTMF Autodial", val)
dtmf.append(rs)
val = RadioSettingValueList(
self._NUM_0_9, self._NUM_0_9[_settings.last_dtmf])
rs = RadioSetting("last_dtmf", "Last DTMF Memory Set", val)
dtmf.append(rs)
for i in range(10):
name = "dtmf_" + str(i)
dtmfsetting = self._memobj.dtmf[i]
dtmfstr = ""
for c in dtmfsetting.memory:
if c < len(DTMFCHARSET):
dtmfstr += DTMFCHARSET[c]
dtmfentry = RadioSettingValueString(0, 16, dtmfstr)
rs = RadioSetting(name, name.upper(), dtmfentry)
dtmf.append(rs)
# WIRES
val = RadioSettingValueList(
self._INT_CD, self._INT_CD[_settings.internet_code])
rs = RadioSetting("internet_code", "Internet Code", val)
wires.append(rs)
val = RadioSettingValueList(
self._INT_MD, self._INT_MD[_settings.internet_mode])
rs = RadioSetting("internet_mode",
"Internet Link Connection mode", val)
wires.append(rs)
val = RadioSettingValueList(
self._MAN_AUTO, self._MAN_AUTO[_settings.int_autodial])
rs = RadioSetting("int_autodial", "Internet Autodial", val)
wires.append(rs)
val = RadioSettingValueList(
self._NUM_0_63, self._NUM_0_63[_settings.last_internet_dtmf])
rs = RadioSetting("last_internet_dtmf",
"Last Internet DTMF Memory Set", val)
wires.append(rs)
for i in range(64):
name = "wires_dtmf_" + str(i)
dtmfsetting = self._memobj.internet_dtmf[i]
dtmfstr = ""
for c in dtmfsetting.memory:
if c < len(DTMFCHARSET):
dtmfstr += DTMFCHARSET[c]
dtmfentry = RadioSettingValueString(0, 8, dtmfstr)
rs = RadioSetting(name, name.upper(), dtmfentry)
wires.append(rs)
# MISC
val = RadioSettingValueList(
self._BELL, self._BELL[_settings.bell])
rs = RadioSetting("bell", "CTCSS/DCS Bell", val)
misc.append(rs)
val = RadioSettingValueList(
self._CH_CNT, self._CH_CNT[_settings.channel_counter_width])
rs = RadioSetting("channel_counter_width",
"Channel Counter Search Width", val)
misc.append(rs)
val = RadioSettingValueList(
self._EMERGENCY, self._EMERGENCY[_settings.emergency])
rs = RadioSetting("emergency", "Emergency alarm", val)
misc.append(rs)
val = RadioSettingValueList(
self._ON_TIMER, self._ON_TIMER[_settings.on_timer])
rs = RadioSetting("on_timer", "On Timer", val)
misc.append(rs)
rs = RadioSetting("pager_answer_back", "Pager Answer Back",
RadioSettingValueBoolean(
_settings.pager_answer_back))
misc.append(rs)
val = RadioSettingValueList(
self._NUM_1_50, self._NUM_1_50[_settings.pager_rx_tone1])
rs = RadioSetting("pager_rx_tone1", "Pager RX Tone 1", val)
misc.append(rs)
val = RadioSettingValueList(
self._NUM_1_50, self._NUM_1_50[_settings.pager_rx_tone2])
rs = RadioSetting("pager_rx_tone2", "Pager RX Tone 2", val)
misc.append(rs)
val = RadioSettingValueList(
self._NUM_1_50, self._NUM_1_50[_settings.pager_tx_tone1])
rs = RadioSetting("pager_tx_tone1", "Pager TX Tone 1", val)
misc.append(rs)
val = RadioSettingValueList(
self._NUM_1_50, self._NUM_1_50[_settings.pager_tx_tone2])
rs = RadioSetting("pager_tx_tone2", "Pager TX Tone 2", val)
misc.append(rs)
val = RadioSettingValueList(
self._PTT_DELAY, self._PTT_DELAY[_settings.ptt_delay])
rs = RadioSetting("ptt_delay", "PTT Delay", val)
misc.append(rs)
val = RadioSettingValueList(
self._RF_SQL, self._RF_SQL[_settings.rf_squelch])
rs = RadioSetting("rf_squelch", "RF Squelch", val)
misc.append(rs)
val = RadioSettingValueList(
self._RX_SAVE, self._RX_SAVE[_settings.rx_save])
rs = RadioSetting("rx_save", "RX Save", val)
misc.append(rs)
val = RadioSettingValueList(
self._TOT, self._TOT[_settings.tx_timeout])
rs = RadioSetting("tx_timeout", "TOT", val)
misc.append(rs)
val = RadioSettingValueList(
self._WAKEUP, self._WAKEUP[_settings.wakeup])
rs = RadioSetting("wakeup", "Wakeup", val)
misc.append(rs)
rs = RadioSetting("edge_beep", "Band-Edge Beep",
RadioSettingValueBoolean(_settings.edge_beep))
misc.append(rs)
val = RadioSettingValueList(
self._VFO_MODE, self._VFO_MODE[_settings.vfo_mode])
rs = RadioSetting("vfo_mode", "VFO Band Edge Limiting", val)
misc.append(rs)
rs = RadioSetting("tone_search_mute", "Tone Search Mute",
RadioSettingValueBoolean(_settings.tone_search_mute))
misc.append(rs)
val = RadioSettingValueList(
self._TS_SPEED, self._TS_SPEED[_settings.ts_speed])
rs = RadioSetting("ts_speed", "Tone Search Speed", val)
misc.append(rs)
rs = RadioSetting("dmr_wrt", "Direct Memory Recall Overwrite",
RadioSettingValueBoolean(_settings.dmr_wrt))
misc.append(rs)
rs = RadioSetting("tx_saver", "TX Battery Saver",
RadioSettingValueBoolean(_settings.tx_saver))
misc.append(rs)
val = RadioSettingValueList(
self._SMART_SEARCH, self._SMART_SEARCH[_settings.smart_search])
rs = RadioSetting("smart_search", "Smart Search", val)
misc.append(rs)
val = RadioSettingValueList(
self._HOME_REV, self._HOME_REV[_settings.home_rev])
rs = RadioSetting("home_rev", "HM/RV(EMG)R/H key", val)
misc.append(rs)
val = RadioSettingValueList(
self._MEM_W_MD, self._MEM_W_MD[_settings.memory_method])
rs = RadioSetting("memory_method", "Memory Write Method", val)
misc.append(rs)
return top
def _get_settings(self):
_settings = self._memobj.settings
_vfoa = self._memobj.vfoa
_vfob = self._memobj.vfob
cfg_grp = RadioSettingGroup("cfg_grp", "Configuration")
vfoa_grp = RadioSettingGroup("vfoa_grp", "VFO A Settings")
vfob_grp = RadioSettingGroup("vfob_grp", "VFO B Settings")
key_grp = RadioSettingGroup("key_grp", "Key Settings")
lmt_grp = RadioSettingGroup("lmt_grp", "Frequency Limits")
uhf_lmt_grp = RadioSettingGroup("uhf_lmt_grp", "UHF")
vhf_lmt_grp = RadioSettingGroup("vhf_lmt_grp", "VHF")
vhf1_lmt_grp = RadioSettingGroup("vhf1_lmt_grp", "VHF1")
oem_grp = RadioSettingGroup("oem_grp", "OEM Info")
lmt_grp.append(vhf_lmt_grp);
lmt_grp.append(vhf1_lmt_grp);
lmt_grp.append(uhf_lmt_grp);
group = RadioSettings(cfg_grp, vfoa_grp, vfob_grp,
key_grp, lmt_grp, oem_grp)
#
# Configuration Settings
#
rs = RadioSetting("channel_menu", "Menu available in channel mode",
RadioSettingValueBoolean(_settings.channel_menu))
cfg_grp.append(rs)
rs = RadioSetting("ponmsg", "Poweron message",
RadioSettingValueList(
PONMSG_LIST, PONMSG_LIST[_settings.ponmsg]))
cfg_grp.append(rs)
rs = RadioSetting("voice", "Voice Guide",
RadioSettingValueBoolean(_settings.voice))
cfg_grp.append(rs)
rs = RadioSetting("language", "Language",
RadioSettingValueList(LANGUAGE_LIST,
LANGUAGE_LIST[_settings.
language]))
cfg_grp.append(rs)
rs = RadioSetting("timeout", "Timeout Timer",
RadioSettingValueList(
TIMEOUT_LIST, TIMEOUT_LIST[_settings.timeout]))
cfg_grp.append(rs)
rs = RadioSetting("toalarm", "Timeout Alarm",
RadioSettingValueInteger(0, 10, _settings.toalarm))
cfg_grp.append(rs)
rs = RadioSetting("roger_beep", "Roger Beep",
RadioSettingValueList(ROGER_LIST,
ROGER_LIST[_settings.roger_beep]))
cfg_grp.append(rs)
rs = RadioSetting("power_save", "Power save",
RadioSettingValueBoolean(_settings.power_save))
cfg_grp.append(rs)
rs = RadioSetting("autolock", "Autolock",
RadioSettingValueBoolean(_settings.autolock))
cfg_grp.append(rs)
rs = RadioSetting("keylock", "Keypad Lock",
RadioSettingValueBoolean(_settings.keylock))
cfg_grp.append(rs)
rs = RadioSetting("beep", "Keypad Beep",
RadioSettingValueBoolean(_settings.beep))
cfg_grp.append(rs)
rs = RadioSetting("stopwatch", "Stopwatch",
RadioSettingValueBoolean(_settings.stopwatch))
cfg_grp.append(rs)
rs = RadioSetting("backlight", "Backlight",
RadioSettingValueList(BACKLIGHT_LIST,
BACKLIGHT_LIST[_settings.
backlight]))
cfg_grp.append(rs)
rs = RadioSetting("dtmf_st", "DTMF Sidetone",
RadioSettingValueList(DTMFST_LIST,
DTMFST_LIST[_settings.
dtmf_st]))
cfg_grp.append(rs)
rs = RadioSetting("ani_sw", "ANI-ID Switch",
RadioSettingValueBoolean(_settings.ani_sw))
cfg_grp.append(rs)
rs = RadioSetting("ptt_id", "PTT-ID Delay",
RadioSettingValueList(PTTID_LIST,
PTTID_LIST[_settings.ptt_id]))
cfg_grp.append(rs)
rs = RadioSetting("ring_time", "Ring Time",
RadioSettingValueList(LIST_10,
LIST_10[_settings.ring_time]))
cfg_grp.append(rs)
rs = RadioSetting("scan_rev", "Scan Mode",
RadioSettingValueList(SCANMODE_LIST,
SCANMODE_LIST[_settings.
scan_rev]))
cfg_grp.append(rs)
rs = RadioSetting("vox", "VOX",
RadioSettingValueList(LIST_10,
LIST_10[_settings.vox]))
cfg_grp.append(rs)
rs = RadioSetting("prich_sw", "Priority Channel Switch",
RadioSettingValueBoolean(_settings.prich_sw))
cfg_grp.append(rs)
rs = RadioSetting("pri_ch", "Priority Channel",
RadioSettingValueInteger(1, 999, _settings.pri_ch))
cfg_grp.append(rs)
rs = RadioSetting("rpt_mode", "Radio Mode",
RadioSettingValueList(RPTMODE_LIST,
RPTMODE_LIST[_settings.
rpt_mode]))
cfg_grp.append(rs)
rs = RadioSetting("rpt_set", "Repeater Setting",
RadioSettingValueList(RPTSET_LIST,
RPTSET_LIST[_settings.
rpt_set]))
cfg_grp.append(rs)
rs = RadioSetting("rpt_spk", "Repeater Mode Speaker",
RadioSettingValueBoolean(_settings.rpt_spk))
cfg_grp.append(rs)
rs = RadioSetting("rpt_ptt", "Repeater PTT",
RadioSettingValueBoolean(_settings.rpt_ptt))
cfg_grp.append(rs)
rs = RadioSetting("dtmf_tx_time", "DTMF Tx Duration",
RadioSettingValueList(DTMF_TIMES,
DTMF_TIMES[_settings.
dtmf_tx_time]))
cfg_grp.append(rs)
rs = RadioSetting("dtmf_interval", "DTMF Interval",
RadioSettingValueList(DTMF_TIMES,
DTMF_TIMES[_settings.
dtmf_interval]))
cfg_grp.append(rs)
rs = RadioSetting("alert", "Alert Tone",
RadioSettingValueList(ALERTS_LIST,
ALERTS_LIST[_settings.alert]))
cfg_grp.append(rs)
rs = RadioSetting("rpt_tone", "Repeater Tone",
RadioSettingValueBoolean(_settings.rpt_tone))
cfg_grp.append(rs)
rs = RadioSetting("rpt_hold", "Repeater Hold Time",
RadioSettingValueList(HOLD_TIMES,
HOLD_TIMES[_settings.
rpt_hold]))
cfg_grp.append(rs)
rs = RadioSetting("scan_det", "Scan DET",
RadioSettingValueBoolean(_settings.scan_det))
cfg_grp.append(rs)
rs = RadioSetting("sc_qt", "SC-QT",
RadioSettingValueList(SCQT_LIST,
SCQT_LIST[_settings.sc_qt]))
cfg_grp.append(rs)
rs = RadioSetting("smuteset", "SubFreq Mute",
RadioSettingValueList(SMUTESET_LIST,
SMUTESET_LIST[_settings.
smuteset]))
cfg_grp.append(rs)
#
# VFO A Settings
#
rs = RadioSetting("workmode_a", "VFO A Workmode",
RadioSettingValueList(WORKMODE_LIST, WORKMODE_LIST[_settings.workmode_a]))
vfoa_grp.append(rs)
rs = RadioSetting("work_cha", "VFO A Channel",
RadioSettingValueInteger(1, 999, _settings.work_cha))
vfoa_grp.append(rs)
rs = RadioSetting("vfoa.rxfreq", "VFO A Rx Frequency",
RadioSettingValueInteger(
134000000, 520000000, _vfoa.rxfreq * 10, 5000))
vfoa_grp.append(rs)
rs = RadioSetting("vfoa.txoffset", "VFO A Tx Offset",
RadioSettingValueInteger(
0, 520000000, _vfoa.txoffset * 10, 5000))
vfoa_grp.append(rs)
# u16 rxtone;
# u16 txtone;
rs = RadioSetting("vfoa.power", "VFO A Power",
RadioSettingValueList(
POWER_LIST, POWER_LIST[_vfoa.power]))
vfoa_grp.append(rs)
# shift_dir:2
rs = RadioSetting("vfoa.iswide", "VFO A NBFM",
RadioSettingValueList(
BANDWIDTH_LIST, BANDWIDTH_LIST[_vfoa.iswide]))
vfoa_grp.append(rs)
rs = RadioSetting("vfoa.mute_mode", "VFO A Mute",
RadioSettingValueList(
SPMUTE_LIST, SPMUTE_LIST[_vfoa.mute_mode]))
vfoa_grp.append(rs)
rs = RadioSetting("vfoa.step", "VFO A Step (kHz)",
RadioSettingValueList(
STEP_LIST, STEP_LIST[_vfoa.step]))
vfoa_grp.append(rs)
rs = RadioSetting("vfoa.squelch", "VFO A Squelch",
RadioSettingValueList(
LIST_10, LIST_10[_vfoa.squelch]))
vfoa_grp.append(rs)
rs = RadioSetting("bcl_a", "Busy Channel Lock-out A",
RadioSettingValueBoolean(_settings.bcl_a))
vfoa_grp.append(rs)
#
# VFO B Settings
#
rs = RadioSetting("workmode_b", "VFO B Workmode",
RadioSettingValueList(WORKMODE_LIST, WORKMODE_LIST[_settings.workmode_b]))
vfob_grp.append(rs)
rs = RadioSetting("work_chb", "VFO B Channel",
RadioSettingValueInteger(1, 999, _settings.work_chb))
vfob_grp.append(rs)
rs = RadioSetting("vfob.rxfreq", "VFO B Rx Frequency",
RadioSettingValueInteger(
134000000, 520000000, _vfob.rxfreq * 10, 5000))
vfob_grp.append(rs)
rs = RadioSetting("vfob.txoffset", "VFO B Tx Offset",
RadioSettingValueInteger(
0, 520000000, _vfob.txoffset * 10, 5000))
vfob_grp.append(rs)
# u16 rxtone;
# u16 txtone;
rs = RadioSetting("vfob.power", "VFO B Power",
RadioSettingValueList(
POWER_LIST, POWER_LIST[_vfob.power]))
vfob_grp.append(rs)
# shift_dir:2
rs = RadioSetting("vfob.iswide", "VFO B NBFM",
RadioSettingValueList(
BANDWIDTH_LIST, BANDWIDTH_LIST[_vfob.iswide]))
vfob_grp.append(rs)
rs = RadioSetting("vfob.mute_mode", "VFO B Mute",
RadioSettingValueList(
SPMUTE_LIST, SPMUTE_LIST[_vfob.mute_mode]))
vfob_grp.append(rs)
rs = RadioSetting("vfob.step", "VFO B Step (kHz)",
RadioSettingValueList(
STEP_LIST, STEP_LIST[_vfob.step]))
vfob_grp.append(rs)
rs = RadioSetting("vfob.squelch", "VFO B Squelch",
RadioSettingValueList(
LIST_10, LIST_10[_vfob.squelch]))
vfob_grp.append(rs)
rs = RadioSetting("bcl_b", "Busy Channel Lock-out B",
RadioSettingValueBoolean(_settings.bcl_b))
vfob_grp.append(rs)
#
# Key Settings
#
_msg = str(_settings.dispstr).split("\0")[0]
val = RadioSettingValueString(0, 15, _msg)
val.set_mutable(True)
rs = RadioSetting("dispstr", "Display Message", val)
key_grp.append(rs)
dtmfchars = "0123456789"
_codeobj = _settings.ani_code
_code = "".join([dtmfchars[x] for x in _codeobj if int(x) < 0x0A])
val = RadioSettingValueString(3, 6, _code, False)
val.set_charset(dtmfchars)
rs = RadioSetting("ani_code", "ANI Code", val)
def apply_ani_id(setting, obj):
value = []
for j in range(0, 6):
try:
value.append(dtmfchars.index(str(setting.value)[j]))
except IndexError:
value.append(0xFF)
obj.ani_code = value
rs.set_apply_callback(apply_ani_id, _settings)
key_grp.append(rs)
rs = RadioSetting("pf1_func", "PF1 Key function",
RadioSettingValueList(
PF1KEY_LIST,
PF1KEY_LIST[_settings.pf1_func]))
key_grp.append(rs)
rs = RadioSetting("pf3_func", "PF3 Key function",
RadioSettingValueList(
PF3KEY_LIST,
PF3KEY_LIST[_settings.pf3_func]))
key_grp.append(rs)
#
# Limits settings
#
rs = RadioSetting("vhf_limits.rx_start", "VHF RX Lower Limit",
RadioSettingValueInteger(
134000000, 174997500,
self._memobj.vhf_limits.rx_start * 10, 5000))
vhf_lmt_grp.append(rs)
rs = RadioSetting("vhf_limits.rx_stop", "VHF RX Upper Limit",
RadioSettingValueInteger(
134000000, 174997500,
self._memobj.vhf_limits.rx_stop * 10, 5000))
vhf_lmt_grp.append(rs)
rs = RadioSetting("vhf_limits.tx_start", "VHF TX Lower Limit",
RadioSettingValueInteger(
134000000, 174997500,
self._memobj.vhf_limits.tx_start * 10, 5000))
vhf_lmt_grp.append(rs)
rs = RadioSetting("vhf_limits.tx_stop", "VHF TX Upper Limit",
RadioSettingValueInteger(
134000000, 174997500,
self._memobj.vhf_limits.tx_stop * 10, 5000))
vhf_lmt_grp.append(rs)
rs = RadioSetting("vhf1_limits.rx_start", "VHF1 RX Lower Limit",
RadioSettingValueInteger(
220000000, 265000000,
self._memobj.vhf1_limits.rx_start * 10, 5000))
vhf1_lmt_grp.append(rs)
rs = RadioSetting("vhf1_limits.rx_stop", "VHF1 RX Upper Limit",
RadioSettingValueInteger(
220000000, 265000000,
self._memobj.vhf1_limits.rx_stop * 10, 5000))
vhf1_lmt_grp.append(rs)
rs = RadioSetting("vhf1_limits.tx_start", "VHF1 TX Lower Limit",
RadioSettingValueInteger(
220000000, 265000000,
self._memobj.vhf1_limits.tx_start * 10, 5000))
vhf1_lmt_grp.append(rs)
rs = RadioSetting("vhf1_limits.tx_stop", "VHF1 TX Upper Limit",
RadioSettingValueInteger(
220000000, 265000000,
self._memobj.vhf1_limits.tx_stop * 10, 5000))
vhf1_lmt_grp.append(rs)
rs = RadioSetting("uhf_limits.rx_start", "UHF RX Lower Limit",
RadioSettingValueInteger(
400000000, 520000000,
self._memobj.uhf_limits.rx_start * 10, 5000))
uhf_lmt_grp.append(rs)
rs = RadioSetting("uhf_limits.rx_stop", "UHF RX Upper Limit",
RadioSettingValueInteger(
400000000, 520000000,
self._memobj.uhf_limits.rx_stop * 10, 5000))
uhf_lmt_grp.append(rs)
rs = RadioSetting("uhf_limits.tx_start", "UHF TX Lower Limit",
RadioSettingValueInteger(
400000000, 520000000,
self._memobj.uhf_limits.tx_start * 10, 5000))
uhf_lmt_grp.append(rs)
rs = RadioSetting("uhf_limits.tx_stop", "UHF TX Upper Limit",
RadioSettingValueInteger(
400000000, 520000000,
self._memobj.uhf_limits.tx_stop * 10, 5000))
uhf_lmt_grp.append(rs)
#
# OEM info
#
def _decode(lst):
_str = ''.join([chr(c) for c in lst
if chr(c) in chirp_common.CHARSET_ASCII])
return _str
def do_nothing(setting, obj):
return
_str = _decode(self._memobj.oem_info.model)
val = RadioSettingValueString(0, 15, _str)
val.set_mutable(False)
rs = RadioSetting("oem_info.model", "Model", val)
rs.set_apply_callback(do_nothing, _settings)
oem_grp.append(rs)
_str = _decode(self._memobj.oem_info.oem1)
val = RadioSettingValueString(0, 15, _str)
val.set_mutable(False)
rs = RadioSetting("oem_info.oem1", "OEM String 1", val)
rs.set_apply_callback(do_nothing, _settings)
oem_grp.append(rs)
_str = _decode(self._memobj.oem_info.oem2)
val = RadioSettingValueString(0, 15, _str)
val.set_mutable(False)
rs = RadioSetting("oem_info.oem2", "OEM String 2", val)
rs.set_apply_callback(do_nothing, _settings)
oem_grp.append(rs)
_str = _decode(self._memobj.oem_info.version)
val = RadioSettingValueString(0, 15, _str)
val.set_mutable(False)
rs = RadioSetting("oem_info.version", "Software Version", val)
rs.set_apply_callback(do_nothing, _settings)
oem_grp.append(rs)
_str = _decode(self._memobj.oem_info.date)
val = RadioSettingValueString(0, 15, _str)
val.set_mutable(False)
rs = RadioSetting("oem_info.date", "OEM Date", val)
rs.set_apply_callback(do_nothing, _settings)
oem_grp.append(rs)
return group
def get_settings(self):
_settings = self._memobj.settings
_dtmf_strings = self._memobj.dtmf_strings
_passwd = self._memobj.passwd
repeater = RadioSettingGroup("repeater", "Repeater Settings")
ctcss = RadioSettingGroup("ctcss", "CTCSS/DCS/EPCS Settings")
arts = RadioSettingGroup("arts", "ARTS Settings")
mbls = RadioSettingGroup("banks", "Memory Settings")
scan = RadioSettingGroup("scan", "Scan Settings")
dtmf = RadioSettingGroup("dtmf", "DTMF Settings")
wires = RadioSettingGroup("wires", "WiRES(tm) Settings")
switch = RadioSettingGroup("switch", "Switch/Knob Settings")
disp = RadioSettingGroup("disp", "Display Settings")
misc = RadioSettingGroup("misc", "Miscellaneous Settings")
setmode = RadioSettings(repeater, ctcss, arts, mbls, scan, dtmf, wires,
switch, disp, misc)
# numbers and names of settings refer to the way they're
# presented in the set menu, as well as the list starting on
# page 74 of the manual
# 1 APO
opts = ["Off", "30 Min", "1 Hour", "3 Hour", "5 Hour", "8 Hour"]
misc.append(
RadioSetting("apo", "Automatic Power Off",
RadioSettingValueList(opts, opts[_settings.apo])))
# 2 AR.BEP
opts = ["Off", "In Range", "Always"]
arts.append(
RadioSetting(
"arts_beep", "ARTS Beep",
RadioSettingValueList(opts, opts[_settings.arts_beep])))
# 3 AR.INT
opts = ["15 Sec", "25 Sec"]
arts.append(
RadioSetting(
"arts_interval", "ARTS Polling Interval",
RadioSettingValueList(opts, opts[_settings.arts_interval])))
# 4 ARS
opts = ["Off", "On"]
repeater.append(
RadioSetting("ars", "Automatic Repeater Shift",
RadioSettingValueList(opts, opts[_settings.ars])))
# 5 BCLO
opts = ["Off", "On"]
misc.append(
RadioSetting(
"busy_lockout", "Busy Channel Lock-Out",
RadioSettingValueList(opts, opts[_settings.busy_lockout])))
# 6 BEEP
opts = ["Off", "Key+Scan", "Key"]
switch.append(
RadioSetting("beep", "Enable the Beeper",
RadioSettingValueList(opts, opts[_settings.beep])))
# 7 BELL
opts = ["Off", "1", "3", "5", "8", "Continuous"]
ctcss.append(
RadioSetting("bell", "Bell Repetitions",
RadioSettingValueList(opts, opts[_settings.bell])))
# 8 BNK.LNK
for i in range(0, 8):
opts = ["Off", "On"]
mbs = (self._memobj.mbs >> i) & 1
rs = RadioSetting("mbs%i" % i, "Bank %s Scan" % (i + 1),
RadioSettingValueList(opts, opts[mbs]))
def apply_mbs(s, index):
if int(s.value):
self._memobj.mbs |= (1 << index)
else:
self._memobj.mbs &= ~(1 << index)
rs.set_apply_callback(apply_mbs, i)
mbls.append(rs)
# 9 BNK.NM - A per-bank attribute, nothing to do here.
# 10 CLK.SFT - A per-channel attribute, nothing to do here.
# 11 CW.ID
opts = ["Off", "On"]
arts.append(
RadioSetting("cw_id", "CW ID Enable",
RadioSettingValueList(opts, opts[_settings.cw_id])))
cw_id_text = ""
for i in _settings.cw_id_string:
try:
cw_id_text += CHARSET[i & 0x7F]
except IndexError:
if i != 0xff:
LOG.debug("unknown char index in cw id: %x " % (i))
val = RadioSettingValueString(0, 16, cw_id_text, True)
val.set_charset(CHARSET + "abcdefghijklmnopqrstuvwxyz")
rs = RadioSetting("cw_id_string", "CW Identifier Text", val)
def apply_cw_id(s):
str = s.value.get_value().upper().rstrip()
mval = ""
mval = [chr(CHARSET.index(x)) for x in str]
for x in range(len(mval), 16):
mval.append(chr(0xff))
for x in range(0, 16):
_settings.cw_id_string[x] = ord(mval[x])
rs.set_apply_callback(apply_cw_id)
arts.append(rs)
# 12 CWTRNG
opts = [
"Off", "4WPM", "5WPM", "6WPM", "7WPM", "8WPM", "9WPM", "10WPM",
"11WPM", "12WPM", "13WPM", "15WPM", "17WPM", "20WPM", "24WPM",
"30WPM", "40WPM"
]
misc.append(
RadioSetting("cw_trng", "CW Training",
RadioSettingValueList(opts, opts[_settings.cw_trng])))
# todo: make the setting of the units here affect the display
# of the speed. Not critical, but would be slick.
opts = ["CPM", "WPM"]
misc.append(
RadioSetting(
"cw_trng_units", "CW Training Units",
RadioSettingValueList(opts, opts[_settings.cw_trng_units])))
# 13 DC VLT - a read-only status, so nothing to do here
# 14 DCS CD - A per-channel attribute, nothing to do here
# 15 DCS.RV
opts = ["Disabled", "Enabled"]
ctcss.append(
RadioSetting(
"inverted_dcs", "\"Inverted\" DCS Code Decoding",
RadioSettingValueList(opts, opts[_settings.inverted_dcs])))
# 16 DIMMER
opts = ["Off"] + ["Level %d" % (x) for x in range(1, 11)]
disp.append(
RadioSetting("dimmer", "Dimmer",
RadioSettingValueList(opts, opts[_settings.dimmer])))
# 17 DT.A/M
opts = ["Manual", "Auto"]
dtmf.append(
RadioSetting(
"dtmf_mode", "DTMF Autodialer",
RadioSettingValueList(opts, opts[_settings.dtmf_mode])))
# 18 DT.DLY
opts = ["50 ms", "250 ms", "450 ms", "750 ms", "1000 ms"]
dtmf.append(
RadioSetting(
"dtmf_delay", "DTMF Autodialer Delay Time",
RadioSettingValueList(opts, opts[_settings.dtmf_delay])))
# 19 DT.SET
for memslot in range(0, 10):
dtmf_memory = ""
for i in _dtmf_strings[memslot].dtmf_string:
if i != 0xFF:
try:
dtmf_memory += CHARSET[i]
except IndexError:
LOG.debug("unknown char index in dtmf: %x " % (i))
val = RadioSettingValueString(0, 16, dtmf_memory, True)
val.set_charset(CHARSET + "abcdef")
rs = RadioSetting("dtmf_string_%d" % memslot,
"DTMF Memory %d" % memslot, val)
def apply_dtmf(s, i):
LOG.debug("applying dtmf for %x\n" % i)
str = s.value.get_value().upper().rstrip()
LOG.debug("str is %s\n" % str)
mval = ""
mval = [chr(CHARSET.index(x)) for x in str]
for x in range(len(mval), 16):
mval.append(chr(0xff))
for x in range(0, 16):
_dtmf_strings[i].dtmf_string[x] = ord(mval[x])
rs.set_apply_callback(apply_dtmf, memslot)
dtmf.append(rs)
# 20 DT.SPD
opts = ["50 ms", "100 ms"]
dtmf.append(
RadioSetting(
"dtmf_speed", "DTMF Autodialer Sending Speed",
RadioSettingValueList(opts, opts[_settings.dtmf_speed])))
# 21 EDG.BEP
opts = ["Off", "On"]
mbls.append(
RadioSetting(
"edge_beep", "Band Edge Beeper",
RadioSettingValueList(opts, opts[_settings.edge_beep])))
# 22 INT.CD
opts = ["DTMF %X" % (x) for x in range(0, 16)]
wires.append(
RadioSetting("int_cd", "Access Number for WiRES(TM)",
RadioSettingValueList(opts, opts[_settings.int_cd])))
# 23 ING MD
opts = ["Sister Radio Group", "Friends Radio Group"]
wires.append(
RadioSetting(
"wires_mode", "Internet Link Connection Mode",
RadioSettingValueList(opts, opts[_settings.wires_mode])))
# 24 INT.A/M
opts = ["Manual", "Auto"]
wires.append(
RadioSetting(
"wires_auto", "Internet Link Autodialer",
RadioSettingValueList(opts, opts[_settings.wires_auto])))
# 25 INT.SET
opts = ["F%d" % (x) for x in range(0, 10)]
wires.append(
RadioSetting("int_set", "Memory Register for "
"non-WiRES Internet",
RadioSettingValueList(opts, opts[_settings.int_set])))
# 26 LOCK
opts = [
"Key", "Dial", "Key + Dial", "PTT", "Key + PTT", "Dial + PTT",
"All"
]
switch.append(
RadioSetting("lock", "Control Locking",
RadioSettingValueList(opts, opts[_settings.lock])))
# 27 MCGAIN
opts = ["Level %d" % (x) for x in range(1, 10)]
misc.append(
RadioSetting("mic_gain", "Microphone Gain",
RadioSettingValueList(opts,
opts[_settings.mic_gain])))
# 28 MEM.SCN
opts = ["Tag 1", "Tag 2", "All Channels"]
rs = RadioSetting(
"scan_mode", "Memory Scan Mode",
RadioSettingValueList(opts, opts[_settings.scan_mode - 1]))
# this setting is unusual in that it starts at 1 instead of 0.
# that is, index 1 corresponds to "Tag 1", and index 0 is invalid.
# so we create a custom callback to handle this.
def apply_scan_mode(s):
myopts = ["Tag 1", "Tag 2", "All Channels"]
_settings.scan_mode = myopts.index(s.value.get_value()) + 1
rs.set_apply_callback(apply_scan_mode)
mbls.append(rs)
# 29 MW MD
opts = ["Lower", "Next"]
mbls.append(
RadioSetting("mw_mode", "Memory Write Mode",
RadioSettingValueList(opts, opts[_settings.mw_mode])))
# 30 NM SET - This is per channel, so nothing to do here
# 31 OPN.MSG
opts = ["Off", "DC Supply Voltage", "Text Message"]
disp.append(
RadioSetting("open_msg", "Opening Message Type",
RadioSettingValueList(opts,
opts[_settings.open_msg])))
openmsg = ""
for i in _settings.openMsg_Text:
try:
openmsg += CHARSET[i & 0x7F]
except IndexError:
if i != 0xff:
LOG.debug("unknown char index in openmsg: %x " % (i))
val = RadioSettingValueString(0, 6, openmsg, True)
val.set_charset(CHARSET + "abcdefghijklmnopqrstuvwxyz")
rs = RadioSetting("openMsg_Text", "Opening Message Text", val)
def apply_openmsg(s):
str = s.value.get_value().upper().rstrip()
mval = ""
mval = [chr(CHARSET.index(x)) for x in str]
for x in range(len(mval), 6):
mval.append(chr(0xff))
for x in range(0, 6):
_settings.openMsg_Text[x] = ord(mval[x])
rs.set_apply_callback(apply_openmsg)
disp.append(rs)
# 32 PAGER - a per-channel attribute
# 33 PAG.ABK
opts = ["Off", "On"]
ctcss.append(
RadioSetting("pag_abk", "Paging Answer Back",
RadioSettingValueList(opts, opts[_settings.pag_abk])))
# 34 PAG.CDR
opts = ["%2.2d" % (x) for x in range(1, 50)]
ctcss.append(
RadioSetting(
"pag_cdr_1", "Receive Page Code 1",
RadioSettingValueList(opts, opts[_settings.pag_cdr_1])))
ctcss.append(
RadioSetting(
"pag_cdr_2", "Receive Page Code 2",
RadioSettingValueList(opts, opts[_settings.pag_cdr_2])))
# 35 PAG.CDT
opts = ["%2.2d" % (x) for x in range(1, 50)]
ctcss.append(
RadioSetting(
"pag_cdt_1", "Transmit Page Code 1",
RadioSettingValueList(opts, opts[_settings.pag_cdt_1])))
ctcss.append(
RadioSetting(
"pag_cdt_2", "Transmit Page Code 2",
RadioSettingValueList(opts, opts[_settings.pag_cdt_2])))
# Common Button Options
button_opts = [
"Squelch Off", "Weather", "Smart Search", "Tone Scan", "Scan",
"T Call", "ARTS"
]
# 36 PRG P1
opts = button_opts + ["DC Volts"]
switch.append(
RadioSetting("prog_p1", "P1 Button",
RadioSettingValueList(opts, opts[_settings.prog_p1])))
# 37 PRG P2
opts = button_opts + ["Dimmer"]
switch.append(
RadioSetting("prog_p2", "P2 Button",
RadioSettingValueList(opts, opts[_settings.prog_p2])))
# 38 PRG P3
opts = button_opts + ["Mic Gain"]
switch.append(
RadioSetting("prog_p3", "P3 Button",
RadioSettingValueList(opts, opts[_settings.prog_p3])))
# 39 PRG P4
opts = button_opts + ["Skip"]
switch.append(
RadioSetting("prog_p4", "P4 Button",
RadioSettingValueList(opts, opts[_settings.prog_p4])))
# 40 PSWD
password = ""
for i in _passwd:
if i != 0xFF:
try:
password += CHARSET[i]
except IndexError:
LOG.debug("unknown char index in password: %x " % (i))
val = RadioSettingValueString(0, 4, password, True)
val.set_charset(CHARSET[0:15] + "abcdef ")
rs = RadioSetting("passwd", "Password", val)
def apply_password(s):
str = s.value.get_value().upper().rstrip()
mval = ""
mval = [chr(CHARSET.index(x)) for x in str]
for x in range(len(mval), 4):
mval.append(chr(0xff))
for x in range(0, 4):
_passwd[x] = ord(mval[x])
rs.set_apply_callback(apply_password)
misc.append(rs)
# 41 RESUME
opts = ["3 Sec", "5 Sec", "10 Sec", "Busy", "Hold"]
scan.append(
RadioSetting("resume", "Scan Resume Mode",
RadioSettingValueList(opts, opts[_settings.resume])))
# 42 RF.SQL
opts = ["Off"] + ["S-%d" % (x) for x in range(1, 10)]
misc.append(
RadioSetting("rf_sql", "RF Squelch Threshold",
RadioSettingValueList(opts, opts[_settings.rf_sql])))
# 43 RPT - per channel attribute, nothing to do here
# 44 RVRT
opts = ["Off", "On"]
misc.append(
RadioSetting("revert", "Priority Revert",
RadioSettingValueList(opts, opts[_settings.revert])))
# 45 S.SRCH
opts = ["Single", "Continuous"]
misc.append(
RadioSetting("s_search", "Smart Search Sweep Mode",
RadioSettingValueList(opts,
opts[_settings.s_search])))
# 46 SHIFT - per channel setting, nothing to do here
# 47 SKIP = per channel setting, nothing to do here
# 48 SPLIT - per channel attribute, nothing to do here
# 49 SQL.TYP - per channel attribute, nothing to do here
# 50 STEP - per channel attribute, nothing to do here
# 51 TEMP - read-only status, nothing to do here
# 52 TN FRQ - per channel attribute, nothing to do here
# 53 TOT
opts = ["Off", "1 Min", "3 Min", "5 Min", "10 Min"]
misc.append(
RadioSetting("tot", "Timeout Timer",
RadioSettingValueList(opts, opts[_settings.tot])))
# 54 TS MUT
opts = ["Off", "On"]
ctcss.append(
RadioSetting("ts_mut", "Tone Search Mute",
RadioSettingValueList(opts, opts[_settings.ts_mut])))
# 55 TS SPEED
opts = ["Fast", "Slow"]
ctcss.append(
RadioSetting("ts_speed", "Tone Search Scanner Speed",
RadioSettingValueList(opts,
opts[_settings.ts_speed])))
# 56 VFO.SCN
opts = ["+/- 1MHz", "+/- 2MHz", "+/-5MHz", "All"]
scan.append(
RadioSetting("vfo_scan", "VFO Scanner Width",
RadioSettingValueList(opts,
opts[_settings.vfo_scan])))
# 57 WX.ALT
opts = ["Off", "On"]
misc.append(
RadioSetting("wx_alert", "Weather Alert Scan",
RadioSettingValueList(opts,
opts[_settings.wx_alert])))
# 58 WX.VOL
opts = ["Normal", "Maximum"]
misc.append(
RadioSetting(
"wx_vol_max", "Weather Alert Volume",
RadioSettingValueList(opts, opts[_settings.wx_vol_max])))
# 59 W/N DV - this is a per-channel attribute, nothing to do here
return setmode
def get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic Settings")
group = RadioSettings(basic)
rs = RadioSetting("ch", "Channel Indication Mode",
RadioSettingValueBoolean(_settings.ch))
basic.append(rs)
rs = RadioSetting("expand", "Expanded Settings Mode",
RadioSettingValueBoolean(_settings.expand))
basic.append(rs)
rs = RadioSetting("beep", "Beep Tones",
RadioSettingValueBoolean(_settings.beep))
basic.append(rs)
rs = RadioSetting(
"autorp", "Auto Repeater Function",
RadioSettingValueList(AUTORP_LIST, AUTORP_LIST[_settings.autorp]))
basic.append(rs)
rs = RadioSetting("ritfunct", "RIT Runction",
RadioSettingValueBoolean(_settings.ritfunct))
basic.append(rs)
rs = RadioSetting("rit", "RIT Shift (KHz)",
RadioSettingValueInteger(-7, 7, _settings.rit))
basic.append(rs)
rs = RadioSetting("lock", "Lock",
RadioSettingValueBoolean(_settings.lock))
basic.append(rs)
rs = RadioSetting(
"lockgroup", "Lock Group",
RadioSettingValueList(LOCKGROUP_LIST,
LOCKGROUP_LIST[_settings.lockgroup]))
basic.append(rs)
rs = RadioSetting(
"squelch", "Squelch",
RadioSettingValueList(SQUELCH_LIST,
SQUELCH_LIST[_settings.squelch]))
basic.append(rs)
rs = RadioSetting(
"monitor", "Monitor Switch Function",
RadioSettingValueList(MONITOR_LIST,
MONITOR_LIST[_settings.monitor]))
basic.append(rs)
rs = RadioSetting(
"light", "Display Backlighting",
RadioSettingValueList(LIGHT_LIST, LIGHT_LIST[_settings.light]))
basic.append(rs)
rs = RadioSetting(
"priority", "Priority Watch Operation",
RadioSettingValueList(PRIORITY_LIST,
PRIORITY_LIST[_settings.priority]))
basic.append(rs)
rs = RadioSetting("p_scan", "Frequency Skip Function",
RadioSettingValueBoolean(_settings.p_scan))
basic.append(rs)
rs = RadioSetting(
"bnk_scan", "Memory Bank Scan Selection",
RadioSettingValueList(BANKSCAN_LIST,
BANKSCAN_LIST[_settings.bnk_scan]))
basic.append(rs)
rs = RadioSetting(
"edge", "Band Edge Scan Selection",
RadioSettingValueList(EDGE_LIST, EDGE_LIST[_settings.edge]))
basic.append(rs)
rs = RadioSetting(
"pause", "Scan Pause Time",
RadioSettingValueList(PAUSE_LIST, PAUSE_LIST[_settings.pause]))
basic.append(rs)
rs = RadioSetting(
"resume", "Scan Resume Time",
RadioSettingValueList(RESUME_LIST, RESUME_LIST[_settings.resume]))
basic.append(rs)
rs = RadioSetting("p_save", "Power Saver",
RadioSettingValueBoolean(_settings.p_save))
basic.append(rs)
rs = RadioSetting(
"ap_off", "Auto Power-off Function",
RadioSettingValueList(APOFF_LIST, APOFF_LIST[_settings.ap_off]))
basic.append(rs)
rs = RadioSetting("speed", "Dial Speed Acceleration",
RadioSettingValueBoolean(_settings.speed))
basic.append(rs)
rs = RadioSetting(
"d_sel", "Dial Select Step",
RadioSettingValueList(D_SEL_LIST, D_SEL_LIST[_settings.d_sel]))
basic.append(rs)
return group
def get_settings(self):
"""Translate the MEM_FORMAT structs into settings in the UI"""
# Define mem struct write-back shortcuts
_sets = self._memobj.settings
_asf = self._memobj.asf
_ssf = self._memobj.ssf
_mex = self._memobj.exset
_chm = self._memobj.ch_mem
basic = RadioSettingGroup("basic", "Basic Settings")
pvfo = RadioSettingGroup("pvfo", "VFO Band Edges")
mena = RadioSettingGroup("mena", "Menu A")
menb = RadioSettingGroup("menb", "Menu B")
amode = RadioSettingGroup("amode", "Auto Mode")
ssc = RadioSettingGroup("ssc", "Slow Scan")
group = RadioSettings(basic, pvfo, mena, menb, amode, ssc)
mhz1 = 1000000.
# Callback functions
def _my_readonly(setting, obj, atrb):
"""NOP callback, prevents writing the setting"""
vx = 0
return
def my_adjraw(setting, obj, atrb, fix=0, ndx=-1):
"""Callback for Integer add or subtract fix from value."""
vx = int(str(setting.value))
value = vx + int(fix)
if value < 0:
value = 0
if ndx < 0:
setattr(obj, atrb, value)
else:
setattr(obj[ndx], atrb, value)
return
def my_mhz_val(setting, obj, atrb, ndx=-1):
""" Callback to set freq back to Htz"""
vx = float(str(setting.value))
vx = int(vx * mhz1)
if ndx < 0:
setattr(obj, atrb, vx)
else:
setattr(obj[ndx], atrb, vx)
return
def my_bool(setting, obj, atrb, ndx=-1):
""" Callback to properly set boolean """
# set_settings is not setting [indexed] booleans???
vx = 0
if str(setting.value) == "True":
vx = 1
if ndx < 0:
setattr(obj, atrb, vx)
else:
setattr(obj[ndx], atrb, vx)
return
def my_asf_mode(setting, obj, nx=0):
""" Callback to extract mode and create asmode, asdata """
v1 = TS480_MODES.index(str(setting.value))
v2 = 0 # asdata
vx = v1 + 1 # stored as CAT values, same as xmode
if v1 == 7:
vx = 9
if v1 > 7: # a Data mode
v2 = 1
if v1 == 8:
vx = 1 # LSB
elif v1 == 9:
vx = 2 # USB
elif v1 == 10:
vx = 4 # FM
setattr(obj[nx], "asdata", v2)
setattr(obj[nx], "asmode", vx)
return
def my_fnctns(setting, obj, ndx, atrb):
""" Filter only valid key function assignments """
vx = int(str(setting.value))
if vx > 79:
vx = 99 # Off
setattr(obj[ndx], atrb, vx)
return
def my_labels(kx):
lbl = "%03i:" % kx # SG EX number
lbl += self.EX_LBL[kx] # and the label to match
return lbl
# ===== BASIC GROUP =====
options = [
"TS-480HX (200W)", "TS-480SAT (100W + AT)", "Japanese 50W type",
"Japanese 20W type"
]
rx = RadioSettingValueString(14, 22, options[_sets.ty])
rset = RadioSetting("settings.ty", "FirmwareVersion", rx)
rset.set_apply_callback(_my_readonly, _sets, "ty")
basic.append(rset)
rx = RadioSettingValueInteger(0, 255, _sets.ag)
rset = RadioSetting("settings.ag", "AF Gain", rx)
# rset.set_apply_callback(my_adjraw, _sets, "ag", -1)
basic.append(rset)
rx = RadioSettingValueInteger(0, 100, _sets.rg)
rset = RadioSetting("settings.rg", "RF Gain", rx)
# rset.set_apply_callback(my_adjraw, _sets, "rg", -1)
basic.append(rset)
options = ["ANT1", "ANT2"]
# CAUTION: an has value of 1 or 2
rx = RadioSettingValueList(options, options[_sets.an - 1])
rset = RadioSetting("settings.an", "Antenna Selected", rx)
# Add 1 to the changed value. S/b 1/2
rset.set_apply_callback(my_val_list, options, _sets, "an", 1)
basic.append(rset)
rx = RadioSettingValueInteger(0, 100, _sets.mg)
rset = RadioSetting("settings.mg", "Microphone gain", rx)
basic.append(rset)
nx = 5 # Coarse step
if bool(_mex[0].ex021): # Power Fine enabled in menu A
nx = 1
vx = _sets.pc # Trap invalid values from run_tests.py
if vx < 5:
vx = 5
options = [200, 100, 50, 20] # subject to firmware
rx = RadioSettingValueInteger(5, options[_sets.ty], vx, nx)
sx = "TX Output power (Watts)"
rset = RadioSetting("settings.pc", sx, rx)
basic.append(rset)
val = _sets.fa / mhz1 # valid range is for receiver
rx = RadioSettingValueFloat(0.05, 60.0, val, 0.001, 3)
sx = "VFO-A Frequency (MHz)"
rset = RadioSetting("settings.fa", sx, rx)
rset.set_apply_callback(my_mhz_val, _sets, "fa")
basic.append(rset)
val = _sets.fb / mhz1
rx = RadioSettingValueFloat(0.05, 60.0, val, 0.001, 3)
sx = "VFO-B Frequency (MHz)"
rset = RadioSetting("settings.fb", sx, rx)
rset.set_apply_callback(my_mhz_val, _sets, "fb")
basic.append(rset)
options = ["Menu A", "Menu B"]
rx = RadioSettingValueList(options, options[_sets.mf])
sx = "Menu Selected"
rset = RadioSetting("settings.mf", sx, rx)
rset.set_apply_callback(my_val_list, options, _sets, "mf")
basic.append(rset)
# ==== VFO Edges Group ================
for mx in range(100, 110):
val = _chm[mx].rxfreq / mhz1
if val < 1.8: # Many operators never use this
val = 1.8 # So default is 0.0
rx = RadioSettingValueFloat(1.8, 54.0, val, 0.001, 3)
sx = "VFO-Band %i lower limit (MHz)" % (mx - 100)
rset = RadioSetting("ch_mem.rxfreq/%d" % mx, sx, rx)
rset.set_apply_callback(my_mhz_val, _chm, "rxfreq", mx)
pvfo.append(rset)
val = _chm[mx].txfreq / mhz1
if val < 1.8:
val = 54.0
rx = RadioSettingValueFloat(1.8, 54.0, val, 0.001, 3)
sx = " VFO-Band %i upper limit (MHz)" % (mx - 100)
rset = RadioSetting("ch_mem.txfreq/%d" % mx, sx, rx)
rset.set_apply_callback(my_mhz_val, _chm, "txfreq", mx)
pvfo.append(rset)
kx = _chm[mx].xmode
options = [
"None", "LSB", "USB", "CW", "FM", "AM", "FSK", "CW-R", "N/A",
"FSK-R"
]
rx = RadioSettingValueList(options, options[kx])
sx = " VFO-Band %i Tx/Rx Mode" % (mx - 100)
rset = RadioSetting("ch_mem.xmode/%d" % mx, sx, rx)
rset.set_apply_callback(my_val_list, options, _chm, "xmode", 0, mx)
pvfo.append(rset)
# ==== Menu A/B Group =================
for mx in range(2): # A/B index
sx = my_labels(0)
rx = RadioSettingValueInteger(0, 4, _mex[mx].ex000)
rset = RadioSetting("exset.ex000", sx, rx)
if mx == 0:
mena.append(rset)
else:
menb.append(rset)
rx = RadioSettingValueInteger(0, 9, _mex[mx].ex012)
sx = my_labels(12)
rset = RadioSetting("exset.ex012", sx, rx)
if mx == 0:
mena.append(rset)
else:
menb.append(rset)
sx = my_labels(13)
rx = RadioSettingValueInteger(0, 9, _mex[mx].ex013)
rset = RadioSetting("exset.ex013", sx, rx)
if mx == 0:
mena.append(rset)
else:
menb.append(rset)
sx = my_labels(14)
rx = RadioSettingValueInteger(0, 9, _mex[mx].ex014)
rset = RadioSetting("exset.ex014", sx, rx)
if mx == 0:
mena.append(rset)
else:
menb.append(rset)
options = ["250", "500", "1000"]
rx = RadioSettingValueList(options, options[_mex[mx].ex003])
sx = my_labels(3)
rset = RadioSetting("exset.ex003/%d" % mx, sx, rx)
rset.set_apply_callback(my_val_list, options, _mex, "ex003", 0, mx)
if mx == 0:
mena.append(rset)
else:
menb.append(rset)
rx = RadioSettingValueBoolean(bool(_mex[mx].ex007))
sx = my_labels(7)
rset = RadioSetting("exset.ex007/%d" % mx, sx, rx)
rset.set_apply_callback(my_bool, _mex, "ex007", mx)
if mx == 0:
mena.append(rset)
else:
menb.append(rset)
rx = RadioSettingValueBoolean(bool(_mex[mx].ex008))
sx = my_labels(8)
rset = RadioSetting("exset.ex008/%d" % mx, sx, rx)
rset.set_apply_callback(my_bool, _mex, "ex008", mx)
if mx == 0:
mena.append(rset)
else:
menb.append(rset)
options = ["100", "200", "300", "400", "500"]
rx = RadioSettingValueList(options, options[_mex[mx].ex009])
sx = my_labels(9)
rset = RadioSetting("exset.ex009/%d" % mx, sx, rx)
rset.set_apply_callback(my_val_list, options, _mex, "ex009", 0, mx)
if mx == 0:
mena.append(rset)
else:
menb.append(rset)
rx = RadioSettingValueBoolean(bool(_mex[mx].ex010))
sx = my_labels(10)
rset = RadioSetting("exset.ex010/%d" % mx, sx, rx)
rset.set_apply_callback(my_bool, _mex, "ex010", mx)
if mx == 0:
mena.append(rset)
else:
menb.append(rset)
options = ["TO", "CO"]
rx = RadioSettingValueList(options, options[_mex[mx].ex011])
sx = my_labels(11)
rset = RadioSetting("exset.ex011/%d" % mx, sx, rx)
rset.set_apply_callback(my_val_list, options, _mex, "ex011", 0, mx)
if mx == 0:
mena.append(rset)
else:
menb.append(rset)
rx = RadioSettingValueBoolean(bool(_mex[mx].ex021))
sx = my_labels(21)
rset = RadioSetting("exset.ex021/%d" % mx, sx, rx)
rset.set_apply_callback(my_bool, _mex, "ex021", mx)
if mx == 0:
mena.append(rset)
else:
menb.append(rset)
options = ["Off", "3", "5", "10", "20", "30"]
rx = RadioSettingValueList(options, options[_mex[mx].ex022])
sx = my_labels(22)
rset = RadioSetting("exset.ex022/%d" % mx, sx, rx)
rset.set_apply_callback(my_val_list, options, _mex, "ex022", 0, mx)
if mx == 0:
mena.append(rset)
else:
menb.append(rset)
rx = RadioSettingValueInteger(0, 99, _mex[mx].ex048)
sx = my_labels(48)
rset = RadioSetting("exset.ex048/%d" % mx, sx, rx)
rset.set_apply_callback(my_fnctns, _mex, mx, "ex048")
if mx == 0:
mena.append(rset)
else:
menb.append(rset)
rx = RadioSettingValueInteger(0, 99, _mex[mx].ex049)
sx = my_labels(49)
rset = RadioSetting("exset.ex049/%d" % mx, sx, rx)
rset.set_apply_callback(my_fnctns, _mex, mx, "ex049")
if mx == 0:
mena.append(rset)
else:
menb.append(rset)
rx = RadioSettingValueInteger(0, 99, _mex[mx].ex050)
sx = my_labels(50)
rset = RadioSetting("exset.ex050/%d" % mx, sx, rx)
rset.set_apply_callback(my_fnctns, _mex, mx, "ex050")
if mx == 0:
mena.append(rset)
else:
menb.append(rset)
rx = RadioSettingValueInteger(0, 99, _mex[mx].ex051)
sx = my_labels(51)
rset = RadioSetting("exset.ex051/%d" % mx, sx, rx)
rset.set_apply_callback(my_fnctns, _mex, mx, "ex051")
if mx == 0:
mena.append(rset)
else:
menb.append(rset)
rx = RadioSettingValueInteger(0, 99, _mex[mx].ex052)
sx = my_labels(52)
rset = RadioSetting("exset.ex052/%d" % mx, sx, rx)
rset.set_apply_callback(my_fnctns, _mex, mx, "ex052")
if mx == 0:
mena.append(rset)
else:
menb.append(rset)
# End of for mx loop
# ==== Auto Scan Params (amode) ==============
for ix in range(32):
val = _asf[ix].asfreq / mhz1
rx = RadioSettingValueFloat(0.03, 60.0, val, 0.001, 3)
rset = RadioSetting("asf.asfreq/%d" % ix,
"Scan %02i Freq (MHz)" % ix, rx)
rset.set_apply_callback(my_mhz_val, _asf, "asfreq", ix)
amode.append(rset)
mx = _asf[ix].asmode - 1 # Same logic as xmode
if _asf[ix].asmode == 9:
mx = 7
rx = RadioSettingValueList(TS480_MODES, TS480_MODES[mx])
rset = RadioSetting("asf.asmode/%d" % ix, " Mode", rx)
rset.set_apply_callback(my_asf_mode, _asf, ix)
amode.append(rset)
# ==== Slow Scan Settings ===
for ix in range(10): # Chans
for nx in range(5): # spots
px = ((ix * 5) + nx)
val = _ssf[px].ssfreq / mhz1
stx = " - - - Slot %02i Freq (MHz)" % nx
if nx == 0:
stx = "Slow Scan %02i, Slot 0 Freq (MHz" % ix
rx = RadioSettingValueFloat(0, 54.0, val, 0.001, 3)
rset = RadioSetting("ssf.ssfreq/%d" % px, stx, rx)
rset.set_apply_callback(my_mhz_val, _ssf, "ssfreq", px)
ssc.append(rset)
return group # END get_settings()
def get_settings(self):
common = RadioSettingGroup("common", "Common Settings")
band = RadioSettingGroup("band", "Band dependent Settings")
arts = RadioSettingGroup("arts",
"Auto Range Transponder System (ARTS)")
dtmf = RadioSettingGroup("dtmf", "DTMF Settings")
mic_button = RadioSettingGroup("mic_button", "Microphone Buttons")
setmode = RadioSettings(common, band, arts, dtmf, mic_button)
_overlay = self._memobj.overlay
# numbers and names of settings refer to the way they're
# presented in the set menu, as well as the list starting on
# page 49 of the manual
# 1 Automatic Power Off
opts = [
"Off",
"30 Min",
"1 Hour",
"1.5 Hours",
"2 Hours",
"2.5 Hours",
"3 Hours",
"3.5 Hours",
"4 Hours",
"4.5 Hours",
"5 Hours",
"5.5 Hours",
"6 Hours",
"6.5 Hours",
"7 Hours",
"7.5 Hours",
"8 Hours",
"8.5 Hours",
"9 Hours",
"9.5 Hours",
"10 Hours",
"10.5 Hours",
"11 Hours",
"11.5 Hours",
"12 Hours",
]
common.append(
RadioSetting("apo", "Automatic Power Off",
RadioSettingValueList(opts, opts[_overlay.apo])))
# 2 Automatic Repeater Shift function
opts = ["Off", "On"]
band.append(
RadioSetting("ars_vhf", "Automatic Repeater Shift VHF",
RadioSettingValueList(opts, opts[_overlay.ars_vhf])))
band.append(
RadioSetting("ars_uhf", "Automatic Repeater Shift UHF",
RadioSettingValueList(opts, opts[_overlay.ars_uhf])))
# 3 Selects the ARTS mode.
# -> Only useful to set it on the radio directly
# 4 Enables/disables the key/button beeper.
opts = ["Off", "On"]
common.append(
RadioSetting("beep", "Key/Button Beep",
RadioSettingValueList(opts, opts[_overlay.beep])))
# 5 Enables/disables the CW IDer during ARTS operation.
opts = ["Off", "On"]
arts.append(
RadioSetting("cwid", "Enables/Disables the CW ID",
RadioSettingValueList(opts, opts[_overlay.cwid])))
# 6 Callsign during ARTS operation.
cwidw = _overlay.cwidw.get_raw()
cwidw = cwidw.rstrip('\x00')
val = RadioSettingValueString(0, 6, cwidw)
val.set_charset(CHARSET)
rs = RadioSetting("cwidw", "CW Identifier Callsign", val)
def apply_cwid(setting):
value_string = setting.value.get_value()
_overlay.cwidw.set_value(value_string)
rs.set_apply_callback(apply_cwid)
arts.append(rs)
# 7 Front panel display's illumination level.
opts = ["0: Off", "1: Max", "2", "3", "4", "5", "6", "7: Min"]
common.append(
RadioSetting("dim", "Display Illumination",
RadioSettingValueList(opts, opts[_overlay.dim])))
# 8 Setting the DCS code number.
# Note: This Menu item can be set independently for each band,
# and independently in each memory.
# 9 Activates the DCS Code Search
# -> Only useful if set on radio itself
# 10 Selects 'Normal' or 'Inverted' DCS coding.
opts = ["TRX Normal", "RX Reversed", "TX Reversed", "TRX Reversed"]
band.append(
RadioSetting("dcsnr_vhf", "DCS coding VHF",
RadioSettingValueList(opts,
opts[_overlay.dcsnr_vhf])))
band.append(
RadioSetting("dcsnr_uhf", "DCS coding UHF",
RadioSettingValueList(opts,
opts[_overlay.dcsnr_uhf])))
# 11 Selects the 'sub' band display format
opts = [
"Frequency", "Off / Sub Band disabled", "DC Input Voltage", "CW ID"
]
common.append(
RadioSetting("disp", "Sub Band Display Format",
RadioSettingValueList(opts, opts[_overlay.disp])))
# 12 Setting the DTMF Autodialer delay time
opts = ["50 ms", "250 ms", "450 ms", "750 ms", "1 s"]
dtmf.append(
RadioSetting("dtmfd", "Autodialer delay time",
RadioSettingValueList(opts, opts[_overlay.dtmfd])))
# 13 Setting the DTMF Autodialer sending speed
opts = ["50 ms", "75 ms", "100 ms"]
dtmf.append(
RadioSetting("dtmfs", "Autodialer sending speed",
RadioSettingValueList(opts, opts[_overlay.dtmfs])))
# 14 Current DTMF Autodialer memory
rs = RadioSetting("dtmfw", "Current Autodialer memory",
RadioSettingValueInteger(1, 16, _overlay.dtmfw + 1))
def apply_dtmfw(setting):
_overlay.dtmfw = setting.value.get_value() - 1
rs.set_apply_callback(apply_dtmfw)
dtmf.append(rs)
# DTMF Memory
for i in range(16):
dtmf_string = ""
for j in range(16):
dtmf_char = ''
dtmf_int = int(self._memobj.dtmf_mem[i].dtmf[j])
if dtmf_int < 10:
dtmf_char = str(dtmf_int)
elif dtmf_int == 14:
dtmf_char = '*'
elif dtmf_int == 15:
dtmf_char = '#'
elif dtmf_int == 255:
break
dtmf_string += dtmf_char
radio_setting_value_string = RadioSettingValueString(
0, 16, dtmf_string)
radio_setting_value_string.set_charset(DTMF_CHARSET)
rs = RadioSetting("dtmf_{0:02d}".format(i),
"DTMF Mem " + str(i + 1),
radio_setting_value_string)
def apply_dtmf(setting, index):
radio_setting_value_string = setting.value.get_value().rstrip()
j = 0
for dtmf_char in radio_setting_value_string:
dtmf_int = 255
if dtmf_char in "0123456789":
dtmf_int = int(dtmf_char)
elif dtmf_char == '*':
dtmf_int = 14
elif dtmf_char == '#':
dtmf_int = 15
if dtmf_int < 255:
self._memobj.dtmf_mem[index].dtmf[j] = dtmf_int
j += 1
if j < 16:
self._memobj.dtmf_mem[index].dtmf[j] = 255
rs.set_apply_callback(apply_dtmf, i)
dtmf.append(rs)
# 16 Enables/disables the PTT switch lock
opts = ["Off", "Band A", "Band B", "Both"]
common.append(
RadioSetting("lockt", "PTT switch lock",
RadioSettingValueList(opts, opts[_overlay.lockt])))
# 17 Selects the Microphone type to be used
opts = ["MH-42", "MH-48"]
common.append(
RadioSetting("mic", "Microphone type",
RadioSettingValueList(opts, opts[_overlay.mic])))
# 18 Reduces the audio level on the sub receiver when the
# main receiver is active
opts = ["Off", "On"]
common.append(
RadioSetting("mute", "Mute Sub Receiver",
RadioSettingValueList(opts, opts[_overlay.mute])))
# 20 - 23 Programming the microphones button assignment
buttons = [
"ACC / P1",
"P / P2",
"P1 / P3",
"P2 / P4",
]
opts_button = [
"Low", "Tone", "MHz", "Rev", "Home", "Band", "VFO / Memory",
"Sql Off", "1750 Hz Tone Call", "Repeater", "Priority"
]
for i, button in enumerate(buttons):
rs = RadioSetting(
"button" + str(i), button,
RadioSettingValueList(opts_button,
opts_button[_overlay.button[i]]))
def apply_button(setting, index):
value_string = setting.value.get_value()
value_int = opts_button.index(value_string)
_overlay.button[index] = value_int
rs.set_apply_callback(apply_button, i)
mic_button.append(rs)
# 24 Adjusts the RF SQL threshold level
opts = ["Off", "S-1", "S-5", "S-9", "S-FULL"]
band.append(
RadioSetting(
"rf_sql_vhf", "RF Sql VHF",
RadioSettingValueList(opts, opts[_overlay.rf_sql_vhf])))
band.append(
RadioSetting(
"rf_sql_uhf", "RF Sql UHF",
RadioSettingValueList(opts, opts[_overlay.rf_sql_uhf])))
# 25 Selects the Scan-Resume mode
opts = ["Busy", "Time"]
band.append(
RadioSetting("scan_vhf", "Scan-Resume VHF",
RadioSettingValueList(opts, opts[_overlay.scan_vhf])))
band.append(
RadioSetting("scan_uhf", "Scan-Resume UHF",
RadioSettingValueList(opts, opts[_overlay.scan_uhf])))
# 28 Defining the audio path to the external speaker
opts = ["Off", "Band A", "Band B", "Both"]
common.append(
RadioSetting(
"speaker_cnt", "External Speaker",
RadioSettingValueList(opts, opts[_overlay.speaker_cnt])))
# 31 Sets the Time-Out Timer
opts = ["Off", "Band A", "Band B", "Both"]
common.append(
RadioSetting("tot", "TX Time-Out [Min.] (0 = Off)",
RadioSettingValueInteger(0, 30, _overlay.tot)))
# 32 Reducing the MIC Gain (and Deviation)
opts = ["Off", "On"]
band.append(
RadioSetting("txnar_vhf", "TX Narrowband VHF",
RadioSettingValueList(opts,
opts[_overlay.txnar_vhf])))
band.append(
RadioSetting("txnar_uhf", "TX Narrowband UHF",
RadioSettingValueList(opts,
opts[_overlay.txnar_uhf])))
# 33 Enables/disables the VFO Tracking feature
opts = ["Off", "On"]
common.append(
RadioSetting("vfotr", "VFO Tracking",
RadioSettingValueList(opts, opts[_overlay.vfotr])))
# 34 Selects the receiving mode on the VHF band
opts = ["Inhibit (only FM)", "AM", "Auto"]
common.append(
RadioSetting("am", "AM Mode",
RadioSettingValueList(opts, opts[_overlay.am])))
# Current Band
opts = ["VHF", "UHF"]
common.append(
RadioSetting(
"current_band", "Current Band",
RadioSettingValueList(opts, opts[_overlay.current_band])))
# Show number of VHF and UHF channels
val = RadioSettingValueString(0, 7,
str(int(self._memobj.nb_mem_used_vhf)))
val.set_mutable(False)
rs = RadioSetting("num_chan_vhf", "Number of VHF channels", val)
common.append(rs)
val = RadioSettingValueString(0, 7,
str(int(self._memobj.nb_mem_used_uhf)))
val.set_mutable(False)
rs = RadioSetting("num_chan_uhf", "Number of UHF channels", val)
common.append(rs)
return setmode
def get_settings(self):
"""Translate the bit in the mem_struct into settings in the UI"""
_mem = self._memobj
basic = RadioSettingGroup("basic", "Basic Settings")
advanced = RadioSettingGroup("advanced", "Advanced Settings")
other = RadioSettingGroup("other", "Other Settings")
work = RadioSettingGroup("work", "Work Mode Settings")
fm_preset = RadioSettingGroup("fm_preset", "FM Preset")
dtmfe = RadioSettingGroup("dtmfe", "DTMF Encode Settings")
service = RadioSettingGroup("service", "Service Settings")
top = RadioSettings(basic, advanced, other, work, fm_preset, dtmfe,
service)
# Basic settings
if _mem.settings.squelch > 0x09:
val = 0x00
else:
val = _mem.settings.squelch
rs = RadioSetting(
"settings.squelch", "Squelch",
RadioSettingValueList(LIST_OFF1TO9, LIST_OFF1TO9[val]))
basic.append(rs)
if _mem.settings.save > 0x04:
val = 0x00
else:
val = _mem.settings.save
rs = RadioSetting("settings.save", "Battery Saver",
RadioSettingValueList(LIST_SAVE, LIST_SAVE[val]))
basic.append(rs)
if _mem.settings.vox > 0x0A:
val = 0x00
else:
val = _mem.settings.vox
rs = RadioSetting(
"settings.vox", "Vox",
RadioSettingValueList(LIST_OFF1TO10, LIST_OFF1TO10[val]))
basic.append(rs)
if _mem.settings.abr > 0x0A:
val = 0x00
else:
val = _mem.settings.abr
rs = RadioSetting(
"settings.abr", "Backlight Timeout",
RadioSettingValueList(LIST_OFF1TO10, LIST_OFF1TO10[val]))
basic.append(rs)
rs = RadioSetting("settings.tdr", "Dual Watch",
RadioSettingValueBoolean(_mem.settings.tdr))
basic.append(rs)
rs = RadioSetting("settings.beep", "Beep",
RadioSettingValueBoolean(_mem.settings.beep))
basic.append(rs)
if _mem.settings.timeout > 0x27:
val = 0x03
else:
val = _mem.settings.timeout
rs = RadioSetting(
"settings.timeout", "Timeout Timer",
RadioSettingValueList(LIST_TIMEOUT, LIST_TIMEOUT[val]))
basic.append(rs)
if _mem.settings.voice > 0x02:
val = 0x01
else:
val = _mem.settings.voice
rs = RadioSetting("settings.voice", "Voice Prompt",
RadioSettingValueList(LIST_VOICE, LIST_VOICE[val]))
basic.append(rs)
rs = RadioSetting(
"settings.dtmfst", "DTMF Sidetone",
RadioSettingValueList(LIST_DTMFST,
LIST_DTMFST[_mem.settings.dtmfst]))
basic.append(rs)
if _mem.settings.screv > 0x02:
val = 0x01
else:
val = _mem.settings.screv
rs = RadioSetting("settings.screv", "Scan Resume",
RadioSettingValueList(LIST_RESUME, LIST_RESUME[val]))
basic.append(rs)
rs = RadioSetting(
"settings.pttid", "When to send PTT ID",
RadioSettingValueList(LIST_PTTID, LIST_PTTID[_mem.settings.pttid]))
basic.append(rs)
if _mem.settings.pttlt > 0x1E:
val = 0x05
else:
val = _mem.settings.pttlt
rs = RadioSetting("pttlt", "PTT ID Delay",
RadioSettingValueInteger(0, 50, val))
basic.append(rs)
rs = RadioSetting(
"settings.mdfa", "Display Mode (A)",
RadioSettingValueList(LIST_MODE, LIST_MODE[_mem.settings.mdfa]))
basic.append(rs)
rs = RadioSetting(
"settings.mdfb", "Display Mode (B)",
RadioSettingValueList(LIST_MODE, LIST_MODE[_mem.settings.mdfb]))
basic.append(rs)
rs = RadioSetting("settings.sync", "Sync A & B",
RadioSettingValueBoolean(_mem.settings.sync))
basic.append(rs)
rs = RadioSetting(
"settings.wtled", "Standby LED Color",
RadioSettingValueList(LIST_COLOR, LIST_COLOR[_mem.settings.wtled]))
basic.append(rs)
rs = RadioSetting(
"settings.rxled", "RX LED Color",
RadioSettingValueList(LIST_COLOR, LIST_COLOR[_mem.settings.rxled]))
basic.append(rs)
rs = RadioSetting(
"settings.txled", "TX LED Color",
RadioSettingValueList(LIST_COLOR, LIST_COLOR[_mem.settings.txled]))
basic.append(rs)
val = _mem.settings.almod
rs = RadioSetting("settings.almod", "Alarm Mode",
RadioSettingValueList(LIST_ALMOD, LIST_ALMOD[val]))
basic.append(rs)
rs = RadioSetting("settings.dbptt", "Double PTT",
RadioSettingValueBoolean(_mem.settings.dbptt))
basic.append(rs)
rs = RadioSetting("settings.ste", "Squelch Tail Eliminate (HT to HT)",
RadioSettingValueBoolean(_mem.settings.ste))
basic.append(rs)
rs = RadioSetting(
"settings.ponmsg", "Power-On Message",
RadioSettingValueList(LIST_PONMSG,
LIST_PONMSG[_mem.settings.ponmsg]))
basic.append(rs)
rs = RadioSetting("settings.roger", "Roger Beep",
RadioSettingValueBoolean(_mem.settings.roger))
basic.append(rs)
rs = RadioSetting(
"settings.rtone", "Tone Burst Frequency",
RadioSettingValueList(LIST_RTONE, LIST_RTONE[_mem.settings.rtone]))
basic.append(rs)
rs = RadioSetting(
"settings.rogerrx", "Roger Beep (RX)",
RadioSettingValueList(LIST_OFFAB,
LIST_OFFAB[_mem.settings.rogerrx]))
basic.append(rs)
# Advanced settings
rs = RadioSetting("settings.reset", "RESET Menu",
RadioSettingValueBoolean(_mem.settings.reset))
advanced.append(rs)
rs = RadioSetting("settings.menu", "All Menus",
RadioSettingValueBoolean(_mem.settings.menu))
advanced.append(rs)
rs = RadioSetting("settings.fmradio", "Broadcast FM Radio",
RadioSettingValueBoolean(_mem.settings.fmradio))
advanced.append(rs)
rs = RadioSetting("settings.alarm", "Alarm Sound",
RadioSettingValueBoolean(_mem.settings.alarm))
advanced.append(rs)
# Other settings
def _filter(name):
filtered = ""
for char in str(name):
if char in chirp_common.CHARSET_ASCII:
filtered += char
else:
filtered += " "
return filtered
_msg = _mem.firmware_msg
val = RadioSettingValueString(0, 7, _filter(_msg.line1))
val.set_mutable(False)
rs = RadioSetting("firmware_msg.line1", "Firmware Message 1", val)
other.append(rs)
val = RadioSettingValueString(0, 7, _filter(_msg.line2))
val.set_mutable(False)
rs = RadioSetting("firmware_msg.line2", "Firmware Message 2", val)
other.append(rs)
_msg = _mem.sixpoweron_msg
val = RadioSettingValueString(0, 7, _filter(_msg.line1))
val.set_mutable(False)
rs = RadioSetting("sixpoweron_msg.line1", "6+Power-On Message 1", val)
other.append(rs)
val = RadioSettingValueString(0, 7, _filter(_msg.line2))
val.set_mutable(False)
rs = RadioSetting("sixpoweron_msg.line2", "6+Power-On Message 2", val)
other.append(rs)
_msg = _mem.poweron_msg
rs = RadioSetting("poweron_msg.line1", "Power-On Message 1",
RadioSettingValueString(0, 7, _filter(_msg.line1)))
other.append(rs)
rs = RadioSetting("poweron_msg.line2", "Power-On Message 2",
RadioSettingValueString(0, 7, _filter(_msg.line2)))
other.append(rs)
# Work mode settings
rs = RadioSetting(
"settings.displayab", "Display",
RadioSettingValueList(LIST_AB, LIST_AB[_mem.settings.displayab]))
work.append(rs)
rs = RadioSetting("settings.keylock", "Keypad Lock",
RadioSettingValueBoolean(_mem.settings.keylock))
work.append(rs)
rs = RadioSetting(
"wmchannel.mrcha", "MR A Channel",
RadioSettingValueInteger(1, 15, _mem.wmchannel.mrcha))
work.append(rs)
rs = RadioSetting(
"wmchannel.mrchb", "MR B Channel",
RadioSettingValueInteger(1, 15, _mem.wmchannel.mrchb))
work.append(rs)
# broadcast FM settings
_fm_presets = self._memobj.fm_presets
if _fm_presets <= 108.0 * 10 - 650:
preset = _fm_presets / 10.0 + 65
elif _fm_presets >= 65.0 * 10 and _fm_presets <= 108.0 * 10:
preset = _fm_presets / 10.0
else:
preset = 76.0
rs = RadioSetting("fm_presets", "FM Preset(MHz)",
RadioSettingValueFloat(65, 108.0, preset, 0.1, 1))
fm_preset.append(rs)
# DTMF settings
def apply_code(setting, obj, length):
code = []
for j in range(0, length):
try:
code.append(DTMF_CHARS.index(str(setting.value)[j]))
except IndexError:
code.append(0xFF)
obj.code = code
for i in range(0, 15):
_codeobj = self._memobj.pttid[i].code
_code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F])
val = RadioSettingValueString(0, 5, _code, False)
val.set_charset(DTMF_CHARS)
pttid = RadioSetting("pttid/%i.code" % i,
"Signal Code %i" % (i + 1), val)
pttid.set_apply_callback(apply_code, self._memobj.pttid[i], 5)
dtmfe.append(pttid)
if _mem.ani.dtmfon > 0xC3:
val = 0x03
else:
val = _mem.ani.dtmfon
rs = RadioSetting(
"ani.dtmfon", "DTMF Speed (on)",
RadioSettingValueList(LIST_DTMFSPEED, LIST_DTMFSPEED[val]))
dtmfe.append(rs)
if _mem.ani.dtmfoff > 0xC3:
val = 0x03
else:
val = _mem.ani.dtmfoff
rs = RadioSetting(
"ani.dtmfoff", "DTMF Speed (off)",
RadioSettingValueList(LIST_DTMFSPEED, LIST_DTMFSPEED[val]))
dtmfe.append(rs)
_codeobj = self._memobj.ani.code
_code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F])
val = RadioSettingValueString(0, 5, _code, False)
val.set_charset(DTMF_CHARS)
rs = RadioSetting("ani.code", "ANI Code", val)
rs.set_apply_callback(apply_code, self._memobj.ani, 5)
dtmfe.append(rs)
rs = RadioSetting(
"ani.aniid", "When to send ANI ID",
RadioSettingValueList(LIST_PTTID, LIST_PTTID[_mem.ani.aniid]))
dtmfe.append(rs)
# Service settings
for index in range(0, 10):
key = "squelch.vhf.sql%i" % (index)
_obj = self._memobj.squelch.vhf
val = RadioSettingValueInteger(0, 123,
getattr(_obj, "sql%i" % (index)))
if index == 0:
val.set_mutable(False)
name = "Squelch %i" % (index)
rs = RadioSetting(key, name, val)
service.append(rs)
return top
