def get_prog(i, val_list, valndx, sname, longname, f_apply):
k = str(i + 1)
val = val_list[valndx]
valuelist = RadioSettingValueList(val_list, val)
rs = RadioSetting(sname + k, longname + k, valuelist)
rs.set_apply_callback(f_apply, i, self._memobj)
group.append(rs)
def get_string_setting(self, obj, valid_chars, desc1, desc2, group):
content = ''
maxlen = len(obj)
for x in range(0, maxlen):
content += chr(obj[x])
val = RadioSettingValueString(0, maxlen, content, True, valid_chars)
rs = RadioSetting(desc1, desc2, val)
rs.set_apply_callback(self.apply_str_to_bytearray, obj)
group.append(rs)
def _inverted_flag_setting(self, key, name, obj=None):
if obj is None:
obj = self._memobj.settings
def apply_inverted(setting, key):
setattr(obj, key, not int(setting.value))
v = not getattr(obj, key)
s = RadioSetting(key, name, RadioSettingValueBoolean(v))
s.set_apply_callback(apply_inverted, key)
return s
def _decode_opening_message(self, opening_message):
msg = ""
for i in opening_message.message.padded_yaesu:
if i == 0xFF:
break
msg += chr(int(i))
val = RadioSettingValueString(0, 16, msg)
rs = RadioSetting("opening_message.message.padded_yaesu",
"Opening Message", val)
rs.set_apply_callback(self._apply_opening_message,
opening_message.message.padded_yaesu)
return rs
def _pure_choice_setting(self, settings_key, name, choices, default='Off'):
if default is not None:
choices = [default] + choices
s = RadioSetting(
settings_key, name,
RadioSettingValueList(
choices,
get_choice(self._memobj.settings, settings_key, choices,
default)))
s.set_apply_callback(set_choice, self._memobj.settings, settings_key,
choices, default)
return s
def _decode_opening_message(self, opening_message):
msg = ""
for i in opening_message.message.padded_yaesu:
if i == 0xFF:
break
msg += chr(int(i))
val = RadioSettingValueString(0, 16, msg)
rs = RadioSetting("opening_message.message.padded_yaesu",
"Opening Message", val)
rs.set_apply_callback(self._apply_opening_message,
opening_message.message.padded_yaesu)
return rs
def _get_ost(self, parent):
tones = chirp_common.TONES[:]
def apply_tone(setting, index, which):
if str(setting.value) == 'Off':
val = 0xFFFF
else:
val = int(float(str(setting.value)) * 10)
setattr(self._memobj.ost_tones[index], '%stone' % which, val)
def _tones():
return ['Off'] + [str(x) for x in tones]
for i in range(0, 40):
_ost = self._memobj.ost_tones[i]
ost = RadioSettingGroup('ost%i' % i,
'OST %i' % (i + 1))
cur = str(_ost.name).rstrip('\x00')
name = RadioSetting('name%i' % i, 'Name',
RadioSettingValueString(0, 12, cur))
ost.append(name)
if _ost.rxtone == 0xFFFF:
cur = 'Off'
else:
cur = round(int(_ost.rxtone) / 10.0, 1)
if cur not in tones:
LOG.debug('Non-standard OST rx tone %i %s' % (i, cur))
tones.append(cur)
tones.sort()
rx = RadioSetting('rxtone%i' % i, 'RX Tone',
RadioSettingValueList(_tones(),
str(cur)))
rx.set_apply_callback(apply_tone, i, 'rx')
ost.append(rx)
if _ost.txtone == 0xFFFF:
cur = 'Off'
else:
cur = round(int(_ost.txtone) / 10.0, 1)
if cur not in tones:
LOG.debug('Non-standard OST tx tone %i %s' % (i, cur))
tones.append(cur)
tones.sort()
tx = RadioSetting('txtone%i' % i, 'TX Tone',
RadioSettingValueList(_tones(),
str(cur)))
tx.set_apply_callback(apply_tone, i, 'tx')
ost.append(tx)
parent.append(ost)
def _get_display_settings(self):
menu = RadioSettingGroup("display", "Display")
display_settings = self._memobj.settings
val = RadioSettingValueString(
0, 8,
str(display_settings.power_on_msg).rstrip("\xFF"))
rs = RadioSetting("display.power_on_msg", "Power on message", val)
rs.set_apply_callback(self.apply_power_on_msg, display_settings)
menu.append(rs)
val = RadioSettingValueList(
self._LCD_CONTRAST,
self._LCD_CONTRAST[display_settings.contrast - 1])
rs = RadioSetting("display.contrast", "LCD Contrast", val)
rs.set_apply_callback(self.apply_lcd_contrast, display_settings)
menu.append(rs)
val = RadioSettingValueList(
self._LAMP_CONTROL,
self._LAMP_CONTROL[display_settings.lamp_control])
rs = RadioSetting("display.lamp_control", "Lamp Control", val)
rs.set_apply_callback(self.apply_lamp_control, display_settings)
menu.append(rs)
val = RadioSettingValueList(
self._LAMP_TIMER,
self._LAMP_TIMER[display_settings.lamp_timer - 2])
rs = RadioSetting("display.lamp_timer", "Lamp Timer", val)
rs.set_apply_callback(self.apply_lamp_timer, display_settings)
menu.append(rs)
return menu
def _get_display_settings(self):
menu = RadioSettingGroup("display", "Display")
display_settings = self._memobj.settings
val = RadioSettingValueString(
0, 8, str(display_settings.power_on_msg).rstrip("\xFF"))
rs = RadioSetting("display.power_on_msg", "Power on message", val)
rs.set_apply_callback(self.apply_power_on_msg, display_settings)
menu.append(rs)
val = RadioSettingValueList(
self._LCD_CONTRAST,
self._LCD_CONTRAST[display_settings.contrast - 1])
rs = RadioSetting("display.contrast", "LCD Contrast",
val)
rs.set_apply_callback(self.apply_lcd_contrast, display_settings)
menu.append(rs)
val = RadioSettingValueList(
self._LAMP_CONTROL,
self._LAMP_CONTROL[display_settings.lamp_control])
rs = RadioSetting("display.lamp_control", "Lamp Control",
val)
rs.set_apply_callback(self.apply_lamp_control, display_settings)
menu.append(rs)
val = RadioSettingValueList(
self._LAMP_TIMER,
self._LAMP_TIMER[display_settings.lamp_timer - 2])
rs = RadioSetting("display.lamp_timer", "Lamp Timer",
val)
rs.set_apply_callback(self.apply_lamp_timer, display_settings)
menu.append(rs)
return menu
def _get_battery_settings(self):
menu = RadioSettingGroup("battery", "Battery")
battery_settings = self._memobj.settings
val = RadioSettingValueList(
self._BATTERY_SAVER,
self._BATTERY_SAVER[battery_settings.battery_saver])
rs = RadioSetting("battery.battery_saver", "Battery Saver", val)
rs.set_apply_callback(self.apply_battery_saver, battery_settings)
menu.append(rs)
val = RadioSettingValueList(self._APO, self._APO[battery_settings.APO])
rs = RadioSetting("battery.APO", "Auto Power Off", val)
rs.set_apply_callback(self.apply_APO, battery_settings)
menu.append(rs)
return menu
def _get_audio_settings(self):
menu = RadioSettingGroup("audio", "Audio")
audio_settings = self._memobj.settings
val = RadioSettingValueList(
self._AUDIO_BALANCE, self._AUDIO_BALANCE[audio_settings.balance])
rs = RadioSetting("audio.balance", "Balance", val)
rs.set_apply_callback(self.apply_balance, audio_settings)
menu.append(rs)
val = RadioSettingValueList(self._KEY_BEEP,
self._KEY_BEEP[audio_settings.key_beep])
rs = RadioSetting("audio.key_beep", "Key Beep", val)
rs.set_apply_callback(self.apply_key_beep, audio_settings)
menu.append(rs)
return menu
def _get_dtmf_settings(self):
menu = RadioSettingGroup("dtmf_settings", "DTMF")
dtmf = self._memobj.scan_settings
val = RadioSettingValueList(
self._DTMF_MODE,
self._DTMF_MODE[dtmf.dtmf_mode])
rs = RadioSetting("scan_settings.dtmf_mode", "DTMF Mode", val)
menu.append(rs)
val = RadioSettingValueList(
self._DTMF_DELAY,
self._DTMF_DELAY[dtmf.dtmf_delay])
rs = RadioSetting(
"scan_settings.dtmf_delay", "DTMF Delay", val)
menu.append(rs)
val = RadioSettingValueList(
self._DTMF_SPEED,
self._DTMF_SPEED[dtmf.dtmf_speed])
rs = RadioSetting(
"scan_settings.dtmf_speed", "DTMF Speed", val)
menu.append(rs)
for i in range(10):
name = "dtmf_%02d" % (i + 1)
if i == 9:
name = "dtmf_%02d" % 0
dtmfsetting = self._memobj.dtmf[i]
dtmfstr = ""
for c in dtmfsetting.memory:
if c == 0xFF:
break
if c < len(FT70_DTMF_CHARS):
dtmfstr += FT70_DTMF_CHARS[c]
dtmfentry = RadioSettingValueString(0, 16, dtmfstr)
dtmfentry.set_charset(
FT70_DTMF_CHARS + list("abcdef ")) # Allow input in lowercase, space ? validation fails otherwise
rs = RadioSetting(name, name.upper(), dtmfentry)
rs.set_apply_callback(self.apply_dtmf, i)
menu.append(rs)
return menu
def _get_battery_settings(self):
menu = RadioSettingGroup("battery", "Battery")
battery_settings = self._memobj.settings
val = RadioSettingValueList(
self._BATTERY_SAVER,
self._BATTERY_SAVER[battery_settings.battery_saver])
rs = RadioSetting("battery.battery_saver", "Battery Saver",
val)
rs.set_apply_callback(self.apply_battery_saver, battery_settings)
menu.append(rs)
val = RadioSettingValueList(
self._APO,
self._APO[battery_settings.APO])
rs = RadioSetting("battery.APO", "Auto Power Off",
val)
rs.set_apply_callback(self.apply_APO, battery_settings)
menu.append(rs)
return menu
def _get_audio_settings(self):
menu = RadioSettingGroup("audio", "Audio")
audio_settings = self._memobj.settings
val = RadioSettingValueList(
self._AUDIO_BALANCE,
self._AUDIO_BALANCE[audio_settings.balance])
rs = RadioSetting("audio.balance", "Balance",
val)
rs.set_apply_callback(self.apply_balance, audio_settings)
menu.append(rs)
val = RadioSettingValueList(
self._KEY_BEEP,
self._KEY_BEEP[audio_settings.key_beep])
rs = RadioSetting("audio.key_beep", "Key Beep",
val)
rs.set_apply_callback(self.apply_key_beep, audio_settings)
menu.append(rs)
return menu
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_conventional(self):
settings = self._memobj.settings
conv = RadioSettingGroup('conv', 'Conventional')
inverted_flags = [('busy_led', 'Busy LED'),
('ost_memory', 'OST Status Memory'),
('tone_off', 'Tone Off'),
('ptt_release', 'PTT Release tone'),
('ptt_proceed', 'PTT Proceed Tone')]
for key, name in inverted_flags:
conv.append(self._inverted_flag_setting(key, name))
def apply_pttt(setting):
settings.ptt_timer = int(setting.value)
pttt = RadioSetting(
'pttt', 'PTT Proceed Tone Timer (ms)',
RadioSettingValueInteger(0, 6000, int(settings.ptt_timer)))
pttt.set_apply_callback(apply_pttt)
conv.append(pttt)
self._get_ost(conv)
return conv
def get_settings(self):
"""Translate the bit in the mem_struct into settings in the UI"""
_mem = self._memobj
basic = RadioSettingGroup("basic", "Basic")
work = RadioSettingGroup("work", "Work Mode Settings")
top = RadioSettings(basic, work)
# Basic
sql = RadioSetting("settings.sql", "Squelch Level",
RadioSettingValueList(LIST_SQL, LIST_SQL[
_mem.settings.sql]))
basic.append(sql)
tot = RadioSetting("settings.tot", "Time out timer",
RadioSettingValueList(LIST_TOT, LIST_TOT[
_mem.settings.tot]))
basic.append(tot)
key_lock = RadioSetting("settings.key", "Keyboard Lock",
RadioSettingValueList(KEY_LOCK, KEY_LOCK[
_mem.settings.key]))
basic.append(key_lock)
bw = RadioSetting("settings.bw", "Bandwidth",
RadioSettingValueList(BW, BW[_mem.settings.bw]))
basic.append(bw)
powerrank = RadioSetting("settings.powerrank", "Power output adjust",
RadioSettingValueList(POWER_RANK, POWER_RANK[
_mem.settings.powerrank]))
basic.append(powerrank)
lamp = RadioSetting("settings.lamp", "LCD Lamp",
RadioSettingValueBoolean(_mem.settings.lamp))
basic.append(lamp)
lamp_auto = RadioSetting("settings.lamp_auto", "LCD Lamp auto on/off",
RadioSettingValueBoolean(
_mem.settings.lamp_auto))
basic.append(lamp_auto)
bs = RadioSetting("settings.bs", "Battery Save",
RadioSettingValueBoolean(_mem.settings.bs))
basic.append(bs)
warning = RadioSetting("settings.warning", "Warning Alerts",
RadioSettingValueBoolean(_mem.settings.warning))
basic.append(warning)
monitor = RadioSetting("settings.monitor", "Monitor key",
RadioSettingValueBoolean(_mem.settings.monitor))
basic.append(monitor)
# Work mode settings
wmset = RadioSetting("settings.wmem", "VFO/MR Mode",
RadioSettingValueList(
W_MODE, W_MODE[_mem.settings.wmem]))
work.append(wmset)
power = RadioSetting("settings.power", "Actual Power",
RadioSettingValueList(POWER_LEVELS, POWER_LEVELS[
_mem.settings.power]))
work.append(power)
active_ch = RadioSetting("settings.active_ch", "Work Channel",
RadioSettingValueList(ACTIVE_CH, ACTIVE_CH[
_mem.settings.active_ch]))
work.append(active_ch)
# vfo rx validation
if _mem.vfo.vrx_freq.get_raw()[0] == "\xFF":
# if the vfo is not set, the UI cares about the
# length of the field, so set a default
LOG.debug("Setting VFO to default %s" % self._VFO_DEFAULT)
vfo = self._VFO_DEFAULT
else:
vfo = int(_mem.vfo.vrx_freq) * 10
# frecuency apply_callback
def apply_freq(setting, obj):
"""Setting is the UI returned value, obj is the memmap object"""
value = chirp_common.parse_freq(str(setting.value))
obj.set_value(value / 10)
# preparing for callback on vrxfreq (handled also in a special )
vf_freq = RadioSetting("none.vrx_freq", "VFO frequency",
RadioSettingValueString(0, 10, chirp_common.
format_freq(vfo)))
vf_freq.set_apply_callback(apply_freq, _mem.vfo.vrx_freq)
work.append(vf_freq)
# shift works
# VSHIFT = ["None", "-", "+"]
sset = 0
if bool(_mem.vfo.shift_minus) is True:
sset = 1
elif bool(_mem.vfo.shift_plus) is True:
sset = 2
shift = RadioSetting("none.shift", "VFO Shift",
RadioSettingValueList(VSHIFT, VSHIFT[sset]))
work.append(shift)
# vfo shift validation if none set it to ZERO
if _mem.settings.vfo_shift.get_raw()[0] == "\xFF":
# if the shift is not set, the UI cares about the
# length of the field, so set to zero
LOG.debug("VFO shift not set, setting it to zero")
vfo_shift = 0
else:
vfo_shift = int(_mem.settings.vfo_shift) * 10
offset = RadioSetting("none.vfo_shift", "VFO Offset",
RadioSettingValueString(0, 9, chirp_common.
format_freq(vfo_shift)))
work.append(offset)
step = RadioSetting("settings", "VFO step",
RadioSettingValueList(STEPF, STEPF[
_mem.settings.step]))
work.append(step)
# FD-288 Family ANI settings
if "FD-288" in self.MODEL:
ani_mode = RadioSetting("ani_mode", "ANI ID",
RadioSettingValueList(ANI, ANI[
_mem.settings.ani_mode]))
work.append(ani_mode)
# it can't be \xFF
ani_value = str(_mem.settings.ani)
if ani_value == "\xFF\xFF\xFF":
ani_value = "200"
ani_value = "".join(x for x in ani_value if (int(x) >= 2 and
int(x) <= 9))
ani = RadioSetting("ani", "ANI (200-999)",
RadioSettingValueString(0, 3, ani_value))
work.append(ani)
return top
def get_settings(self):
"""Translate the bit in the mem_struct into settings in the UI"""
# Define mem struct write-back shortcuts
_sets = self._memobj.settings
_vfoa = self._memobj.upper.vfoa
_vfob = self._memobj.lower.vfob
_lims = self._memobj.hello_lims
_codes = self._memobj.codes
_dtmf = self._memobj.dtmf_tab
basic = RadioSettingGroup("basic", "Basic Settings")
a_band = RadioSettingGroup("a_band", "VFO A-Upper Settings")
b_band = RadioSettingGroup("b_band", "VFO B-Lower Settings")
codes = RadioSettingGroup("codes", "Codes & DTMF Groups")
lims = RadioSettingGroup("lims", "PowerOn & Freq Limits")
group = RadioSettings(basic, a_band, b_band, lims, codes)
# Basic Settings
bnd_mode = RadioSetting("settings.init_bank", "TDR Band Default",
RadioSettingValueList(LIST_TDR_DEF,
LIST_TDR_DEF[ _sets.init_bank]))
basic.append(bnd_mode)
volume = RadioSetting("settings.volume", "Volume",
RadioSettingValueInteger(0, 20, _sets.volume))
basic.append(volume)
val = _vfoa.bpower # 2bits values 0,1,2= Low, Mid, High
rx = RadioSettingValueList(LIST_BPOWER, LIST_BPOWER[val])
powera = RadioSetting("upper.vfoa.bpower", "Power (Upper)", rx)
basic.append(powera)
val = _vfob.bpower
rx = RadioSettingValueList(LIST_BPOWER, LIST_BPOWER[val])
powerb = RadioSetting("lower.vfob.bpower", "Power (Lower)", rx)
basic.append(powerb)
def my_word2raw(setting, obj, atrb, mlt=10):
"""Callback function to convert UI floating value to u16 int"""
if str(setting.value) == "Off":
frq = 0x0FFFF
else:
frq = int(float(str(setting.value)) * float(mlt))
if frq == 0:
frq = 0xFFFF
setattr(obj, atrb, frq)
return
def my_adjraw(setting, obj, atrb, fix):
"""Callback: add or subtract fix from value."""
vx = int(str(setting.value))
value = vx + int(fix)
if value < 0:
value = 0
if atrb == "frq_chn_mode" and int(str(setting.value)) == 2:
value = vx * 2 # Special handling for frq_chn_mode
setattr(obj, atrb, value)
return
def my_dbl2raw(setting, obj, atrb, flg=1):
"""Callback: convert from freq 146.7600 to 14760000 U32."""
value = chirp_common.parse_freq(str(setting.value)) / 10
# flg=1 means 0 becomes ff, else leave as possible 0
if flg == 1 and value == 0:
value = 0xFFFFFFFF
setattr(obj, atrb, value)
return
def my_val_list(setting, obj, atrb):
"""Callback:from ValueList with non-sequential, actual values."""
value = int(str(setting.value)) # Get the integer value
if atrb == "tot":
value = int(value / 30) # 30 second increments
setattr(obj, atrb, value)
return
def my_spcl(setting, obj, atrb):
"""Callback: Special handling based on atrb."""
if atrb == "frq_chn_mode":
idx = LIST_VFOMODE.index (str(setting.value)) # Returns 0 or 1
value = idx * 2 # Set bit 1
setattr(obj, atrb, value)
return
def my_tone_strn(obj, is_atr, pol_atr, tone_atr):
"""Generate the CTCS/DCS tone code string."""
vx = int(getattr(obj, tone_atr))
if vx == 16383 or vx == 0:
return "Off" # 16383 is all bits set
if getattr(obj, is_atr) == 0: # Simple CTCSS code
tstr = str(vx / 10.0)
else: # DCS
if getattr(obj, pol_atr) == 0:
tstr = "D{:03x}R".format(vx)
else:
tstr = "D{:03x}N".format(vx)
return tstr
def my_set_tone(setting, obj, is_atr, pol_atr, tone_atr):
"""Callback- create the tone setting from string code."""
sx = str(setting.value) # '131.8' or 'D231N' or 'Off'
if sx == "Off":
isx = 1
polx = 1
tonx = 0x3FFF
elif sx[0] == "D": # DCS
isx = 1
if sx[4] == "N":
polx = 1
else:
polx = 0
tonx = int(sx[1:4], 16)
else: # CTCSS
isx = 0
polx = 0
tonx = int(float(sx) * 10.0)
setattr(obj, is_atr, isx)
setattr(obj, pol_atr, polx)
setattr(obj, tone_atr, tonx)
return
val = _sets.fm_freq / 10.0
if val == 0:
val = 88.9 # 0 is not valid
rx = RadioSettingValueFloat(65, 108.0, val, 0.1, 1)
rs = RadioSetting("settings.fm_freq", "FM Broadcast Freq (MHz)", rx)
rs.set_apply_callback(my_word2raw, _sets, "fm_freq")
basic.append(rs)
wtled = RadioSetting("settings.wtled", "Standby LED Color",
RadioSettingValueList(LIST_COLOR, LIST_COLOR[
_sets.wtled]))
basic.append(wtled)
rxled = RadioSetting("settings.rxled", "RX LED Color",
RadioSettingValueList(LIST_COLOR, LIST_COLOR[
_sets.rxled]))
basic.append(rxled)
txled = RadioSetting("settings.txled", "TX LED Color",
RadioSettingValueList(LIST_COLOR, LIST_COLOR[
_sets.txled]))
basic.append(txled)
ledsw = RadioSetting("settings.ledsw", "Back light mode",
RadioSettingValueList(LIST_LEDSW, LIST_LEDSW[
_sets.ledsw]))
basic.append(ledsw)
beep = RadioSetting("settings.beep", "Beep",
RadioSettingValueBoolean(bool(_sets.beep)))
basic.append(beep)
ring = RadioSetting("settings.ring", "Ring",
RadioSettingValueList(LIST_RING, LIST_RING[
_sets.ring]))
basic.append(ring)
bcl = RadioSetting("settings.bcl", "Busy channel lockout",
RadioSettingValueBoolean(bool(_sets.bcl)))
basic.append(bcl)
if _vfoa.sql == 0xFF:
val = 0x04
else:
val = _vfoa.sql
sqla = RadioSetting("upper.vfoa.sql", "Squelch (Upper)",
RadioSettingValueInteger(0, 9, val))
basic.append(sqla)
if _vfob.sql == 0xFF:
val = 0x04
else:
val = _vfob.sql
sqlb = RadioSetting("lower.vfob.sql", "Squelch (Lower)",
RadioSettingValueInteger(0, 9, val))
basic.append(sqlb)
tmp = str(int(_sets.tot) * 30) # 30 sec step counter
rs = RadioSetting("settings.tot", "Transmit Timeout (Secs)",
RadioSettingValueList(LIST_TIMEOUT, tmp))
rs.set_apply_callback(my_val_list, _sets, "tot")
basic.append(rs)
tmp = str(int(_sets.sig_freq))
rs = RadioSetting("settings.sig_freq", "Single Signaling Tone (Htz)",
RadioSettingValueList(LIST_SSF, tmp))
rs.set_apply_callback(my_val_list, _sets, "sig_freq")
basic.append(rs)
tmp = str(int(_sets.dtmf_txms))
rs = RadioSetting("settings.dtmf_txms", "DTMF Tx Duration (mSecs)",
RadioSettingValueList(LIST_DTMFTX, tmp))
rs.set_apply_callback(my_val_list, _sets, "dtmf_txms")
basic.append(rs)
rs = RadioSetting("settings.rptr_mode", "Repeater Mode",
RadioSettingValueBoolean(bool(_sets.rptr_mode)))
basic.append(rs)
# UPPER BAND SETTINGS
# Freq Mode, convert bit 1 state to index pointer
val = _vfoa.frq_chn_mode / 2
rx = RadioSettingValueList(LIST_VFOMODE, LIST_VFOMODE[val])
rs = RadioSetting("upper.vfoa.frq_chn_mode", "Default Mode", rx)
rs.set_apply_callback(my_spcl, _vfoa, "frq_chn_mode")
a_band.append(rs)
val =_vfoa.chan_num + 1 # Add 1 for 1-128 displayed
rs = RadioSetting("upper.vfoa.chan_num", "Initial Chan",
RadioSettingValueInteger(1, 128, val))
rs.set_apply_callback(my_adjraw, _vfoa, "chan_num", -1)
a_band.append(rs)
val = _vfoa.rxfreq / 100000.0
if (val < 136.0 or val > 176.0):
val = 146.520 # 2m calling
rs = RadioSetting("upper.vfoa.rxfreq ", "Default Recv Freq (MHz)",
RadioSettingValueFloat(136.0, 176.0, val, 0.001, 5))
rs.set_apply_callback(my_dbl2raw, _vfoa, "rxfreq")
a_band.append(rs)
tmp = my_tone_strn(_vfoa, "is_rxdigtone", "rxdtcs_pol", "rx_tone")
rs = RadioSetting("rx_tone", "Default Recv CTCSS (Htz)",
RadioSettingValueList(LIST_CTCSS, tmp))
rs.set_apply_callback(my_set_tone, _vfoa, "is_rxdigtone",
"rxdtcs_pol", "rx_tone")
a_band.append(rs)
rx = RadioSettingValueList(LIST_RECVMODE,
LIST_RECVMODE[_vfoa.rx_mode])
rs = RadioSetting("upper.vfoa.rx_mode", "Default Recv Mode", rx)
a_band.append(rs)
tmp = my_tone_strn(_vfoa, "is_txdigtone", "txdtcs_pol", "tx_tone")
rs = RadioSetting("tx_tone", "Default Xmit CTCSS (Htz)",
RadioSettingValueList(LIST_CTCSS, tmp))
rs.set_apply_callback(my_set_tone, _vfoa, "is_txdigtone",
"txdtcs_pol", "tx_tone")
a_band.append(rs)
rs = RadioSetting("upper.vfoa.launch_sig", "Launch Signaling",
RadioSettingValueList(LIST_SIGNAL,
LIST_SIGNAL[_vfoa.launch_sig]))
a_band.append(rs)
rx = RadioSettingValueList(LIST_SIGNAL,LIST_SIGNAL[_vfoa.tx_end_sig])
rs = RadioSetting("upper.vfoa.tx_end_sig", "Xmit End Signaling", rx)
a_band.append(rs)
rx = RadioSettingValueList(LIST_BW, LIST_BW[_vfoa.fm_bw])
rs = RadioSetting("upper.vfoa.fm_bw", "Wide/Narrow Band", rx)
a_band.append(rs)
rx = RadioSettingValueBoolean(bool(_vfoa.cmp_nder))
rs = RadioSetting("upper.vfoa.cmp_nder", "Compandor", rx)
a_band.append(rs)
rs = RadioSetting("upper.vfoa.scrm_blr", "Scrambler",
RadioSettingValueBoolean(bool(_vfoa.scrm_blr)))
a_band.append(rs)
rx = RadioSettingValueList(LIST_SHIFT, LIST_SHIFT[_vfoa.shift])
rs = RadioSetting("upper.vfoa.shift", "Xmit Shift", rx)
a_band.append(rs)
val = _vfoa.offset / 100000.0
rs = RadioSetting("upper.vfoa.offset", "Xmit Offset (MHz)",
RadioSettingValueFloat(0, 100.0, val, 0.001, 3))
# Allow zero value
rs.set_apply_callback(my_dbl2raw, _vfoa, "offset", 0)
a_band.append(rs)
tmp = str(_vfoa.step / 100.0)
rs = RadioSetting("step", "Freq step (KHz)",
RadioSettingValueList(LIST_STEPS, tmp))
rs.set_apply_callback(my_word2raw, _vfoa,"step", 100)
a_band.append(rs)
# LOWER BAND SETTINGS
val = _vfob.frq_chn_mode / 2
rx = RadioSettingValueList(LIST_VFOMODE, LIST_VFOMODE[val])
rs = RadioSetting("lower.vfob.frq_chn_mode", "Default Mode", rx)
rs.set_apply_callback(my_spcl, _vfob, "frq_chn_mode")
b_band.append(rs)
val = _vfob.chan_num + 1
rs = RadioSetting("lower.vfob.chan_num", "Initial Chan",
RadioSettingValueInteger(0, 127, val))
rs.set_apply_callback(my_adjraw, _vfob, "chan_num", -1)
b_band.append(rs)
val = _vfob.rxfreq / 100000.0
if (val < 400.0 or val > 480.0):
val = 446.0 # UHF calling
rs = RadioSetting("lower.vfob.rxfreq ", "Default Recv Freq (MHz)",
RadioSettingValueFloat(400.0, 480.0, val, 0.001, 5))
rs.set_apply_callback(my_dbl2raw, _vfob, "rxfreq")
b_band.append(rs)
tmp = my_tone_strn(_vfob, "is_rxdigtone", "rxdtcs_pol", "rx_tone")
rs = RadioSetting("rx_tone", "Default Recv CTCSS (Htz)",
RadioSettingValueList(LIST_CTCSS, tmp))
rs.set_apply_callback(my_set_tone, _vfob, "is_rxdigtone",
"rxdtcs_pol", "rx_tone")
b_band.append(rs)
rx = RadioSettingValueList(LIST_RECVMODE, LIST_RECVMODE[_vfob.rx_mode])
rs = RadioSetting("lower.vfob.rx_mode", "Default Recv Mode", rx)
b_band.append(rs)
tmp = my_tone_strn(_vfob, "is_txdigtone", "txdtcs_pol", "tx_tone")
rs = RadioSetting("tx_tone", "Default Xmit CTCSS (Htz)",
RadioSettingValueList(LIST_CTCSS, tmp))
rs.set_apply_callback(my_set_tone, _vfob, "is_txdigtone",
"txdtcs_pol", "tx_tone")
b_band.append(rs)
rx = RadioSettingValueList(LIST_SIGNAL,LIST_SIGNAL[_vfob.launch_sig])
rs = RadioSetting("lower.vfob.launch_sig", "Launch Signaling", rx)
b_band.append(rs)
rx = RadioSettingValueList(LIST_SIGNAL,LIST_SIGNAL[_vfob.tx_end_sig])
rs = RadioSetting("lower.vfob.tx_end_sig", "Xmit End Signaling", rx)
b_band.append(rs)
rx = RadioSettingValueList(LIST_BW, LIST_BW[_vfob.fm_bw])
rs = RadioSetting("lower.vfob.fm_bw", "Wide/Narrow Band", rx)
b_band.append(rs)
rs = RadioSetting("lower.vfob.cmp_nder", "Compandor",
RadioSettingValueBoolean(bool(_vfob.cmp_nder)))
b_band.append(rs)
rs = RadioSetting("lower.vfob.scrm_blr", "Scrambler",
RadioSettingValueBoolean(bool(_vfob.scrm_blr)))
b_band.append(rs)
rx = RadioSettingValueList(LIST_SHIFT, LIST_SHIFT[_vfob.shift])
rs = RadioSetting("lower.vfob.shift", "Xmit Shift", rx)
b_band.append(rs)
val = _vfob.offset / 100000.0
rs = RadioSetting("lower.vfob.offset", "Xmit Offset (MHz)",
RadioSettingValueFloat(0, 100.0, val, 0.001, 3))
rs.set_apply_callback(my_dbl2raw, _vfob, "offset", 0)
b_band.append(rs)
tmp = str(_vfob.step / 100.0)
rs = RadioSetting("step", "Freq step (KHz)",
RadioSettingValueList(LIST_STEPS, tmp))
rs.set_apply_callback(my_word2raw, _vfob, "step", 100)
b_band.append(rs)
# PowerOn & Freq Limits Settings
def chars2str(cary, knt):
"""Convert raw memory char array to a string: NOT a callback."""
stx = ""
for char in cary[:knt]:
stx += chr(char)
return stx
def my_str2ary(setting, obj, atrba, atrbc):
"""Callback: convert 7-char string to char array with count."""
ary = ""
knt = 7
for j in range (6, -1, -1): # Strip trailing spaces
if str(setting.value)[j] == "" or str(setting.value)[j] == " ":
knt = knt - 1
else:
break
for j in range(0, 7, 1):
if j < knt: ary += str(setting.value)[j]
else: ary += chr(0xFF)
setattr(obj, atrba, ary)
setattr(obj, atrbc, knt)
return
tmp = chars2str(_lims.hello1, _lims.hello1_cnt)
rs = RadioSetting("hello_lims.hello1", "Power-On Message 1",
RadioSettingValueString(0, 7, tmp))
rs.set_apply_callback(my_str2ary, _lims, "hello1", "hello1_cnt")
lims.append(rs)
tmp = chars2str(_lims.hello2, _lims.hello2_cnt)
rs = RadioSetting("hello_lims.hello2", "Power-On Message 2",
RadioSettingValueString(0, 7, tmp))
rs.set_apply_callback(my_str2ary, _lims,"hello2", "hello2_cnt")
lims.append(rs)
# VALID_BANDS = [(136000000, 176000000),400000000, 480000000)]
lval = _lims.vhf_low / 100000.0
uval = _lims.vhf_high / 100000.0
if lval >= uval:
lval = 144.0
uval = 158.0
rs = RadioSetting("hello_lims.vhf_low", "Lower VHF Band Limit (MHz)",
RadioSettingValueFloat(136.0, 176.0, lval, 0.001, 3))
rs.set_apply_callback(my_dbl2raw, _lims, "vhf_low")
lims.append(rs)
rs = RadioSetting("hello_lims.vhf_high", "Upper VHF Band Limit (MHz)",
RadioSettingValueFloat(136.0, 176.0, uval, 0.001, 3))
rs.set_apply_callback(my_dbl2raw, _lims, "vhf_high")
lims.append(rs)
lval = _lims.uhf_low / 100000.0
uval = _lims.uhf_high / 100000.0
if lval >= uval:
lval = 420.0
uval = 470.0
rs = RadioSetting("hello_lims.uhf_low", "Lower UHF Band Limit (MHz)",
RadioSettingValueFloat(400.0, 480.0, lval, 0.001, 3))
rs.set_apply_callback(my_dbl2raw, _lims, "uhf_low")
lims.append(rs)
rs = RadioSetting("hello_lims.uhf_high", "Upper UHF Band Limit (MHz)",
RadioSettingValueFloat(400.0, 480.0, uval, 0.001, 3))
rs.set_apply_callback(my_dbl2raw, _lims, "uhf_high")
lims.append(rs)
# Codes and DTMF Groups Settings
def make_dtmf(ary, knt):
"""Generate the DTMF code 1-8, NOT a callback."""
tmp = ""
if knt > 0 and knt != 0xff:
for val in ary[:knt]:
if val > 0 and val <= 9:
tmp += chr(val + 48)
elif val == 0x0a:
tmp += "0"
elif val == 0x0d:
tmp += "A"
elif val == 0x0e:
tmp += "B"
elif val == 0x0f:
tmp += "C"
elif val == 0x00:
tmp += "D"
elif val == 0x0b:
tmp += "*"
elif val == 0x0c:
tmp += "#"
else:
msg = ("Invalid Character. Must be: 0-9,A,B,C,D,*,#")
raise InvalidValueError(msg)
return tmp
def my_dtmf2raw(setting, obj, atrba, atrbc, syz=7):
"""Callback: DTMF Code; sends 5 or 7-byte string."""
draw = []
knt = syz
for j in range (syz - 1, -1, -1): # Strip trailing spaces
if str(setting.value)[j] == "" or str(setting.value)[j] == " ":
knt = knt - 1
else:
break
for j in range(0, syz):
bx = str(setting.value)[j]
obx = ord(bx)
dig = 0x0ff
if j < knt and knt > 0: # (Else) is pads
if bx == "0":
dig = 0x0a
elif bx == "A":
dig = 0x0d
elif bx == "B":
dig = 0x0e
elif bx == "C":
dig = 0x0f
elif bx == "D":
dig = 0x00
elif bx == "*":
dig = 0x0b
elif bx == "#":
dig = 0x0c
elif obx >= 49 and obx <= 57:
dig = obx - 48
else:
msg = ("Must be: 0-9,A,B,C,D,*,#")
raise InvalidValueError(msg)
# - End if/elif/else for bx
# - End if J<=knt
draw.append(dig) # Generate string of bytes
# - End for j
setattr(obj, atrba, draw)
setattr(obj, atrbc, knt)
return
tmp = make_dtmf(_codes.native_id_code, _codes.native_id_cnt)
rs = RadioSetting("codes.native_id_code", "Native ID Code",
RadioSettingValueString(0, 7, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes, "native_id_code",
"native_id_cnt", 7)
codes.append(rs)
tmp = make_dtmf(_codes.master_id_code, _codes.master_id_cnt)
rs = RadioSetting("codes.master_id_code", "Master Control ID Code",
RadioSettingValueString(0, 7, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes, "master_id_code",
"master_id_cnt",7)
codes.append(rs)
tmp = make_dtmf(_codes.alarm_code, _codes.alarm_cnt)
rs = RadioSetting("codes.alarm_code", "Alarm Code",
RadioSettingValueString(0, 5, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes, "alarm_code",
"alarm_cnt", 5)
codes.append(rs)
tmp = make_dtmf(_codes.id_disp_code, _codes.id_disp_cnt)
rs = RadioSetting("codes.id_disp_code", "Identify Display Code",
RadioSettingValueString(0, 5, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes, "id_disp_code",
"id_disp_cnt", 5)
codes.append(rs)
tmp = make_dtmf(_codes.revive_code, _codes.revive_cnt)
rs = RadioSetting("codes.revive_code", "Revive Code",
RadioSettingValueString(0, 5, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes,"revive_code",
"revive_cnt", 5)
codes.append(rs)
tmp = make_dtmf(_codes.stun_code, _codes.stun_cnt)
rs = RadioSetting("codes.stun_code", "Remote Stun Code",
RadioSettingValueString(0, 5, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes, "stun_code",
"stun_cnt", 5)
codes.append(rs)
tmp = make_dtmf(_codes.kill_code, _codes.kill_cnt)
rs = RadioSetting("codes.kill_code", "Remote KILL Code",
RadioSettingValueString(0, 5, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes, "kill_code",
"kill_cnt", 5)
codes.append(rs)
tmp = make_dtmf(_codes.monitor_code, _codes.monitor_cnt)
rs = RadioSetting("codes.monitor_code", "Monitor Code",
RadioSettingValueString(0, 5, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes, "monitor_code",
"monitor_cnt", 5)
codes.append(rs)
val = _codes.state_now
if val > 2:
val = 0
rx = RadioSettingValueList(LIST_STATE, LIST_STATE[val])
rs = RadioSetting("codes.state_now", "Current State", rx)
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf1, _dtmf.dtmf1_cnt)
rs = RadioSetting("dtmf_tab.dtmf1", "DTMF1 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf1", "dtmf1_cnt")
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf2, _dtmf.dtmf2_cnt)
rs = RadioSetting("dtmf_tab.dtmf2", "DTMF2 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf2", "dtmf2_cnt")
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf3, _dtmf.dtmf3_cnt)
rs = RadioSetting("dtmf_tab.dtmf3", "DTMF3 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf3", "dtmf3_cnt")
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf4, _dtmf.dtmf4_cnt)
rs = RadioSetting("dtmf_tab.dtmf4", "DTMF4 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf4", "dtmf4_cnt")
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf5, _dtmf.dtmf5_cnt)
rs = RadioSetting("dtmf_tab.dtmf5", "DTMF5 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf5", "dtmf5_cnt")
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf6, _dtmf.dtmf6_cnt)
rs = RadioSetting("dtmf_tab.dtmf6", "DTMF6 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf6", "dtmf6_cnt")
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf7, _dtmf.dtmf7_cnt)
rs = RadioSetting("dtmf_tab.dtmf7", "DTMF7 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf7", "dtmf7_cnt")
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf8, _dtmf.dtmf8_cnt)
rs = RadioSetting("dtmf_tab.dtmf8", "DTMF8 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf8", "dtmf8_cnt")
codes.append(rs)
return group # END get_settings()
def _get_common2(self):
settings = self._memobj.settings
common2 = RadioSettingGroup('common2', 'Common 2')
def apply_ponmsgtext(setting):
settings.pon_msgtext = (
str(setting.value)[:12].strip().ljust(12, '\x00'))
common2.append(
self._pure_choice_setting('pon_msgtype', 'Power On Message Type',
STARTUP_MODES))
_text = str(settings.pon_msgtext).rstrip('\x00')
text = RadioSetting('settings.pon_msgtext',
'Power On Text',
RadioSettingValueString(
0, 12, _text))
text.set_apply_callback(apply_ponmsgtext)
common2.append(text)
def apply_volume(setting, key):
setattr(settings, key, VOLUMES[str(setting.value)])
volumes = {'poweron_tone': 'Power-on Tone',
'control_tone': 'Control Tone',
'warning_tone': 'Warning Tone',
'alert_tone': 'Alert Tone',
'sidetone': 'Sidetone',
'locator_tone': 'Locator Tone'}
for value, name in volumes.items():
setting = getattr(settings, value)
volume = RadioSetting('settings.%s' % value, name,
RadioSettingValueList(
VOLUMES.keys(),
VOLUMES_REV.get(int(setting), 0)))
volume.set_apply_callback(apply_volume, value)
common2.append(volume)
def apply_vol_level(setting, key):
setattr(settings, key, int(setting.value))
levels = {'lo_volume': 'Low Volume Level (Fixed Volume)',
'hi_volume': 'High Volume Level (Fixed Volume)',
'min_volume': 'Minimum Audio Volume',
'max_volume': 'Maximum Audio Volume'}
for value, name in levels.items():
setting = getattr(settings, value)
if 'Audio' in name:
minimum = 0
else:
minimum = 1
volume = RadioSetting(
'settings.%s' % value, name,
RadioSettingValueInteger(minimum, 31, int(setting)))
volume.set_apply_callback(apply_vol_level, value)
common2.append(volume)
def apply_vo(setting):
val = int(setting.value)
if val < 0:
val = abs(val) | 0x80
settings.tone_volume_offset = val
_voloffset = int(settings.tone_volume_offset)
if _voloffset & 0x80:
_voloffset = abs(_voloffset & 0x7F) * -1
voloffset = RadioSetting(
'tvo', 'Tone Volume Offset',
RadioSettingValueInteger(
-5, 5,
_voloffset))
voloffset.set_apply_callback(apply_vo)
common2.append(voloffset)
def apply_mvp(setting):
settings.min_vol_preset = MIN_VOL_PRESET[str(setting.value)]
_volpreset = int(settings.min_vol_preset)
volpreset = RadioSetting(
'mvp', 'Minimum Volume Type',
RadioSettingValueList(MIN_VOL_PRESET.keys(),
MIN_VOL_PRESET_REV[_volpreset]))
volpreset.set_apply_callback(apply_mvp)
if not self.is_portable and 'mvp' in ONLY_MOBILE_SETTINGS:
common2.append(volpreset)
return common2
def _get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic Settings")
advanced = RadioSettingGroup("advanced", "Advanced Settings")
group = RadioSettingGroup("top", "All Settings", basic, advanced)
rs = RadioSetting("squelch", "Carrier Squelch Level",
RadioSettingValueInteger(0, 9, _settings.squelch))
basic.append(rs)
rs = RadioSetting("save", "Battery Saver",
RadioSettingValueInteger(0, 4, _settings.save))
basic.append(rs)
rs = RadioSetting("abr", "Backlight",
RadioSettingValueBoolean(_settings.abr))
basic.append(rs)
rs = RadioSetting("tdr", "Dual Watch (BDR)",
RadioSettingValueBoolean(_settings.tdr))
advanced.append(rs)
rs = RadioSetting("tdrab", "Dual Watch TX Priority",
RadioSettingValueList(uv5r.TDRAB_LIST,
uv5r.TDRAB_LIST[_settings.tdrab]))
advanced.append(rs)
rs = RadioSetting("alarm", "Alarm",
RadioSettingValueBoolean(_settings.alarm))
advanced.append(rs)
rs = RadioSetting("beep", "Beep",
RadioSettingValueBoolean(_settings.beep))
basic.append(rs)
rs = RadioSetting("timeout", "Timeout Timer",
RadioSettingValueList(uv5r.TIMEOUT_LIST,
uv5r.TIMEOUT_LIST[_settings.timeout]))
basic.append(rs)
rs = RadioSetting("screv", "Scan Resume",
RadioSettingValueList(uv5r.RESUME_LIST,
uv5r.RESUME_LIST[_settings.screv]))
advanced.append(rs)
rs = RadioSetting("mdfa", "Display Mode (A)",
RadioSettingValueList(uv5r.MODE_LIST,
uv5r.MODE_LIST[_settings.mdfa]))
basic.append(rs)
rs = RadioSetting("mdfb", "Display Mode (B)",
RadioSettingValueList(uv5r.MODE_LIST,
uv5r.MODE_LIST[_settings.mdfb]))
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("fmradio", "Broadcast FM Radio",
RadioSettingValueBoolean(_settings.fmradio))
advanced.append(rs)
rs = RadioSetting("wtled", "Standby LED Color",
RadioSettingValueList(COLOR_LIST,
COLOR_LIST[_settings.wtled]))
basic.append(rs)
rs = RadioSetting("rxled", "RX LED Color",
RadioSettingValueList(COLOR_LIST,
COLOR_LIST[_settings.rxled]))
basic.append(rs)
rs = RadioSetting("txled", "TX LED Color",
RadioSettingValueList(COLOR_LIST,
COLOR_LIST[_settings.txled]))
basic.append(rs)
rs = RadioSetting("reset", "RESET Menu",
RadioSettingValueBoolean(_settings.reset))
advanced.append(rs)
rs = RadioSetting("menu", "All Menus",
RadioSettingValueBoolean(_settings.menu))
advanced.append(rs)
if len(self._mmap.get_packed()) == 0x1808:
# Old image, without aux block
return group
other = RadioSettingGroup("other", "Other Settings")
group.append(other)
def _filter(name):
filtered = ""
for char in str(name):
if char in chirp_common.CHARSET_ASCII:
filtered += char
else:
filtered += " "
return filtered
_msg = self._memobj.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)
limit = "limits"
vhf_limit = getattr(self._memobj, limit).vhf
rs = RadioSetting("%s.vhf.lower" % limit, "VHF Lower Limit (MHz)",
RadioSettingValueInteger(1, 1000,
vhf_limit.lower))
other.append(rs)
rs = RadioSetting("%s.vhf.upper" % limit, "VHF Upper Limit (MHz)",
RadioSettingValueInteger(1, 1000,
vhf_limit.upper))
other.append(rs)
rs = RadioSetting("%s.vhf.enable" % limit, "VHF TX Enabled",
RadioSettingValueBoolean(vhf_limit.enable))
other.append(rs)
uhf_limit = getattr(self._memobj, limit).uhf
rs = RadioSetting("%s.uhf.lower" % limit, "UHF Lower Limit (MHz)",
RadioSettingValueInteger(1, 1000,
uhf_limit.lower))
other.append(rs)
rs = RadioSetting("%s.uhf.upper" % limit, "UHF Upper Limit (MHz)",
RadioSettingValueInteger(1, 1000,
uhf_limit.upper))
other.append(rs)
rs = RadioSetting("%s.uhf.enable" % limit, "UHF TX Enabled",
RadioSettingValueBoolean(uhf_limit.enable))
other.append(rs)
workmode = RadioSettingGroup("workmode", "Work Mode Settings")
group.append(workmode)
options = ["A", "B"]
rs = RadioSetting("displayab", "Display Selected",
RadioSettingValueList(options,
options[_settings.displayab]))
workmode.append(rs)
options = ["Frequency", "Channel"]
rs = RadioSetting("workmode", "VFO/MR Mode",
RadioSettingValueList(options,
options[_settings.workmode]))
workmode.append(rs)
rs = RadioSetting("keylock", "Keypad Lock",
RadioSettingValueBoolean(_settings.keylock))
workmode.append(rs)
_mrcna = self._memobj.wmchannel.mrcha
rs = RadioSetting("wmchannel.mrcha", "MR A Channel",
RadioSettingValueInteger(0, 127, _mrcna))
workmode.append(rs)
_mrcnb = self._memobj.wmchannel.mrchb
rs = RadioSetting("wmchannel.mrchb", "MR B Channel",
RadioSettingValueInteger(0, 127, _mrcnb))
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:
raise InvalidValueError("Can't be between 174.00000-400.00000")
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(self._memobj.vfoa.freq))
val1a.set_validate_callback(my_validate)
rs = RadioSetting("vfoa.freq", "VFO A Frequency", val1a)
rs.set_apply_callback(apply_freq, self._memobj.vfoa)
workmode.append(rs)
val1b = RadioSettingValueString(0, 10,
convert_bytes_to_freq(self._memobj.vfob.freq))
val1b.set_validate_callback(my_validate)
rs = RadioSetting("vfob.freq", "VFO B Frequency", val1b)
rs.set_apply_callback(apply_freq, self._memobj.vfob)
workmode.append(rs)
options = ["Off", "+", "-"]
rs = RadioSetting("vfoa.sftd", "VFO A Shift",
RadioSettingValueList(options,
options[self._memobj.vfoa.sftd]))
workmode.append(rs)
rs = RadioSetting("vfob.sftd", "VFO B Shift",
RadioSettingValueList(options,
options[self._memobj.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 * 10000)
def apply_offset(setting, obj):
value = chirp_common.parse_freq(str(setting.value)) / 10000
for i in range(3, -1, -1):
obj.offset[i] = value % 10
value /= 10
val1a = RadioSettingValueString(0, 10,
convert_bytes_to_offset(self._memobj.vfoa.offset))
rs = RadioSetting("vfoa.offset", "VFO A Offset (0.00-69.95)", val1a)
rs.set_apply_callback(apply_offset, self._memobj.vfoa)
workmode.append(rs)
val1b = RadioSettingValueString(0, 10,
convert_bytes_to_offset(self._memobj.vfob.offset))
rs = RadioSetting("vfob.offset", "VFO B Offset (0.00-69.95)", val1b)
rs.set_apply_callback(apply_offset, self._memobj.vfob)
workmode.append(rs)
options = ["High", "Low"]
rs = RadioSetting("vfoa.txpower", "VFO A Power",
RadioSettingValueList(options,
options[self._memobj.vfoa.txpower]))
workmode.append(rs)
rs = RadioSetting("vfob.txpower", "VFO B Power",
RadioSettingValueList(options,
options[self._memobj.vfob.txpower]))
workmode.append(rs)
options = ["Wide", "Narrow"]
rs = RadioSetting("vfoa.widenarr", "VFO A Bandwidth",
RadioSettingValueList(options,
options[self._memobj.vfoa.widenarr]))
workmode.append(rs)
rs = RadioSetting("vfob.widenarr", "VFO B Bandwidth",
RadioSettingValueList(options,
options[self._memobj.vfob.widenarr]))
workmode.append(rs)
options = ["%s" % x for x in range(1, 16)]
rs = RadioSetting("vfoa.scode", "VFO A PTT-ID",
RadioSettingValueList(options,
options[self._memobj.vfoa.scode]))
workmode.append(rs)
rs = RadioSetting("vfob.scode", "VFO B PTT-ID",
RadioSettingValueList(options,
options[self._memobj.vfob.scode]))
workmode.append(rs)
rs = RadioSetting("vfoa.step", "VFO A Tuning Step",
RadioSettingValueList(uv5r.STEP291_LIST,
uv5r.STEP291_LIST[self._memobj.vfoa.step]))
workmode.append(rs)
rs = RadioSetting("vfob.step", "VFO B Tuning Step",
RadioSettingValueList(uv5r.STEP291_LIST,
uv5r.STEP291_LIST[self._memobj.vfob.step]))
workmode.append(rs)
fm_preset = RadioSettingGroup("fm_preset", "FM Radio Preset")
group.append(fm_preset)
preset = self._memobj.fm_preset / 10.0 + 87
rs = RadioSetting("fm_preset", "FM Preset(MHz)",
RadioSettingValueFloat(87, 107.5, preset, 0.1, 1))
fm_preset.append(rs)
dtmf = RadioSettingGroup("dtmf", "DTMF Settings")
group.append(dtmf)
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)
_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, self._memobj.ani)
dtmf.append(rs)
options = ["Off", "BOT", "EOT", "Both"]
rs = RadioSetting("ani.aniid", "ANI ID",
RadioSettingValueList(options,
options[self._memobj.ani.aniid]))
dtmf.append(rs)
_codeobj = self._memobj.ani.alarmcode
_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.alarmcode", "Alarm Code", val)
def apply_code(setting, obj):
alarmcode = []
for j in range(5):
try:
alarmcode.append(dtmfchars.index(str(setting.value)[j]))
except IndexError:
alarmcode.append(0xFF)
obj.alarmcode = alarmcode
rs.set_apply_callback(apply_code, self._memobj.ani)
dtmf.append(rs)
rs = RadioSetting("dtmfst", "DTMF Sidetone",
RadioSettingValueList(uv5r.DTMFST_LIST,
uv5r.DTMFST_LIST[_settings.dtmfst]))
dtmf.append(rs)
rs = RadioSetting("ani.dtmfon", "DTMF Speed (on)",
RadioSettingValueList(uv5r.DTMFSPEED_LIST,
uv5r.DTMFSPEED_LIST[self._memobj.ani.dtmfon]))
dtmf.append(rs)
rs = RadioSetting("ani.dtmfoff", "DTMF Speed (off)",
RadioSettingValueList(uv5r.DTMFSPEED_LIST,
uv5r.DTMFSPEED_LIST[self._memobj.ani.dtmfoff]))
dtmf.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):
_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_aprs_rx_settings(self):
menu = RadioSettingGroup("aprs_rx", "APRS Receive")
aprs = self._memobj.aprs
val = RadioSettingValueList(self._RX_BAUD, self._RX_BAUD[aprs.rx_baud])
rs = RadioSetting("aprs.rx_baud", "Modem RX", val)
menu.append(rs)
val = RadioSettingValueBoolean(aprs.aprs_mute)
rs = RadioSetting("aprs.aprs_mute", "APRS Mute", val)
menu.append(rs)
if self._has_af_dual:
val = RadioSettingValueBoolean(aprs.af_dual)
rs = RadioSetting("aprs.af_dual", "AF Dual", val)
menu.append(rs)
val = RadioSettingValueBoolean(aprs.ring_msg)
rs = RadioSetting("aprs.ring_msg", "Ring on Message RX", val)
menu.append(rs)
val = RadioSettingValueBoolean(aprs.ring_beacon)
rs = RadioSetting("aprs.ring_beacon", "Ring on Beacon RX", val)
menu.append(rs)
val = RadioSettingValueList(self._FLASH,
self._FLASH[aprs.flash_msg])
rs = RadioSetting("aprs.flash_msg", "Flash on personal message", val)
menu.append(rs)
if self._has_vibrate:
val = RadioSettingValueList(self._FLASH,
self._FLASH[aprs.vibrate_msg])
rs = RadioSetting("aprs.vibrate_msg",
"Vibrate on personal message", val)
menu.append(rs)
val = RadioSettingValueList(self._FLASH[:10],
self._FLASH[aprs.flash_bln])
rs = RadioSetting("aprs.flash_bln", "Flash on bulletin message", val)
menu.append(rs)
if self._has_vibrate:
val = RadioSettingValueList(self._FLASH[:10],
self._FLASH[aprs.vibrate_bln])
rs = RadioSetting("aprs.vibrate_bln",
"Vibrate on bulletin message", val)
menu.append(rs)
val = RadioSettingValueList(self._FLASH[:10],
self._FLASH[aprs.flash_grp])
rs = RadioSetting("aprs.flash_grp", "Flash on group message", val)
menu.append(rs)
if self._has_vibrate:
val = RadioSettingValueList(self._FLASH[:10],
self._FLASH[aprs.vibrate_grp])
rs = RadioSetting("aprs.vibrate_grp",
"Vibrate on group message", val)
menu.append(rs)
filter_val = [m.padded_string for m in aprs.msg_group]
filter_val = self._strip_ff_pads(filter_val)
for index, filter_text in enumerate(filter_val):
val = RadioSettingValueString(0, 9, filter_text)
rs = RadioSetting("aprs.msg_group_%d" % index,
"Message Group %d" % (index + 1), val)
menu.append(rs)
rs.set_apply_callback(self.apply_ff_padded_string,
aprs.msg_group[index])
# TODO: Use filter_val as the list entries and update it on edit.
val = RadioSettingValueList(
self._MSG_GROUP_NAMES,
self._MSG_GROUP_NAMES[aprs.selected_msg_group])
rs = RadioSetting("aprs.selected_msg_group", "Selected Message Group",
val)
menu.append(rs)
val = RadioSettingValueBoolean(aprs.filter_mic_e)
rs = RadioSetting("aprs.filter_mic_e", "Receive Mic-E Beacons", val)
menu.append(rs)
val = RadioSettingValueBoolean(aprs.filter_position)
rs = RadioSetting("aprs.filter_position", "Receive Position Beacons",
val)
menu.append(rs)
val = RadioSettingValueBoolean(aprs.filter_weather)
rs = RadioSetting("aprs.filter_weather", "Receive Weather Beacons",
val)
menu.append(rs)
val = RadioSettingValueBoolean(aprs.filter_object)
rs = RadioSetting("aprs.filter_object", "Receive Object Beacons", val)
menu.append(rs)
val = RadioSettingValueBoolean(aprs.filter_item)
rs = RadioSetting("aprs.filter_item", "Receive Item Beacons", val)
menu.append(rs)
val = RadioSettingValueBoolean(aprs.filter_status)
rs = RadioSetting("aprs.filter_status", "Receive Status Beacons", val)
menu.append(rs)
val = RadioSettingValueBoolean(aprs.filter_other)
rs = RadioSetting("aprs.filter_other", "Receive Other Beacons", val)
menu.append(rs)
return menu
def _get_zones(self):
zones = RadioSettingGroup('zones', 'Zones')
zone_count = RadioSetting('_zonecount',
'Number of Zones',
RadioSettingValueInteger(
1, 128, len(self._zones)))
zone_count.set_doc('Number of zones in the radio. '
'Requires a save and re-load of the '
'file to take effect. Reducing this number '
'will DELETE memories in affected zones!')
zones.append(zone_count)
for i in range(len(self._zones)):
zone = RadioSettingGroup('zone%i' % i, 'Zone %i' % (i + 1))
_zone = getattr(self._memobj, 'zone%i' % i).zoneinfo
_name = str(_zone.name).rstrip('\x00')
name = RadioSetting('name%i' % i, 'Name',
RadioSettingValueString(0, 12, _name))
zone.append(name)
def apply_timer(setting, key):
val = int(setting.value)
if val == 0:
val = 0xFFFF
setattr(_zone, key, val)
def collapse(val):
val = int(val)
if val == 0xFFFF:
val = 0
return val
timer = RadioSetting(
'timeout', 'Time-out Timer',
RadioSettingValueInteger(15, 1200, collapse(_zone.timeout)))
timer.set_apply_callback(apply_timer, 'timeout')
zone.append(timer)
timer = RadioSetting(
'tot_alert', 'TOT Pre-Alert',
RadioSettingValueInteger(0, 10, collapse(_zone.tot_alert)))
timer.set_apply_callback(apply_timer, 'tot_alert')
zone.append(timer)
timer = RadioSetting(
'tot_rekey', 'TOT Re-Key Time',
RadioSettingValueInteger(0, 60, collapse(_zone.tot_rekey)))
timer.set_apply_callback(apply_timer, 'tot_rekey')
zone.append(timer)
timer = RadioSetting(
'tot_reset', 'TOT Reset Time',
RadioSettingValueInteger(0, 15, collapse(_zone.tot_reset)))
timer.set_apply_callback(apply_timer, 'tot_reset')
zone.append(timer)
zone.append(self._inverted_flag_setting(
'bcl_override', 'BCL Override',
_zone))
zones.append(zone)
return zones
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")
#dtmfd = RadioSettingGroup("dtmfd", "DTMF Decode Settings")
#service = RadioSettingGroup("service", "Service Settings")
#top = RadioSettings(basic, advanced, other, work, fm_preset, dtmfe,
# dtmfd, service)
top = RadioSettings(basic, advanced, )
# Basic settings
rs = RadioSetting("settings.beep", "Beep",
RadioSettingValueBoolean(_mem.settings.beep))
basic.append(rs)
if _mem.settings.squelcha > 0x09:
val = 0x00
else:
val = _mem.settings.squelcha
rs = RadioSetting("squelcha", "Squelch Level A",
RadioSettingValueInteger(0, 9, _mem.settings.squelcha))
basic.append(rs)
if _mem.settings.squelchb > 0x09:
val = 0x00
else:
val = _mem.settings.squelchb
rs = RadioSetting("squelchb", "Squelch Level B",
RadioSettingValueInteger(0, 9, _mem.settings.squelchb))
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)
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)
rs = RadioSetting("settings.autolk", "Automatic Key Lock",
RadioSettingValueBoolean(_mem.settings.autolk))
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)
if _mem.settings.toa > 0x0A:
val = 0x00
else:
val = _mem.settings.toa
rs = RadioSetting("settings.toa", "Time-out Pre-Alert",
RadioSettingValueList(
LIST_OFF1TO10, LIST_OFF1TO10[val]))
basic.append(rs)
if _mem.settings.timeout > 0x28:
val = 0x03
else:
val = _mem.settings.timeout
rs = RadioSetting("settings.timeout", "Timeout Timer",
RadioSettingValueList(
LIST_TIMEOUT, LIST_TIMEOUT[val]))
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)
rs = RadioSetting("settings.roger", "Roger Beep",
RadioSettingValueList(LIST_ROGER, LIST_ROGER[
_mem.settings.roger]))
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.pf1", "PF1 Key Assignment",
RadioSettingValueList(LIST_PF1, LIST_PF1[
_mem.settings.pf1]))
basic.append(rs)
rs = RadioSetting("settings.tdr", "Dual Watch(TDR)",
RadioSettingValueBoolean(_mem.settings.tdr))
basic.append(rs)
rs = RadioSetting("settings.ani", "ANI",
RadioSettingValueBoolean(_mem.settings.ani))
basic.append(rs)
if _mem.settings.pttdly > 0x0A:
val = 0x00
else:
val = _mem.settings.pttdly
rs = RadioSetting("settings.pttdly", "PTT ID Delay",
RadioSettingValueList(
LIST_OFF1TO30, LIST_OFF1TO30[val]))
basic.append(rs)
rs = RadioSetting("settings.pttid", "When to send PTT ID",
RadioSettingValueList(LIST_PTTID,
LIST_PTTID[_mem.settings.pttid]))
basic.append(rs)
rs = RadioSetting("settings.dtmfst", "DTMF Sidetone",
RadioSettingValueList(LIST_DTMFST, LIST_DTMFST[
_mem.settings.dtmfst]))
basic.append(rs)
rs = RadioSetting("settings.ponmsg", "Power-On Message",
RadioSettingValueList(LIST_PONMSG, LIST_PONMSG[
_mem.settings.ponmsg]))
basic.append(rs)
rs = RadioSetting("settings.dw", "DW",
RadioSettingValueBoolean(_mem.settings.dw))
basic.append(rs)
# Advanced settings
rs = RadioSetting("settings.prioritych", "Priority Channel",
RadioSettingValueList(LIST_PRIORITY, LIST_PRIORITY[
_mem.settings.prioritych]))
advanced.append(rs)
rs = RadioSetting("settings.vfomr", "Work Mode",
RadioSettingValueList(LIST_WORKMODE, LIST_WORKMODE[
_mem.settings.vfomr]))
advanced.append(rs)
dtmfchars = "0123456789"
_codeobj = _mem.settings.code
_code = "".join([dtmfchars[x] for x in _codeobj if int(x) < 0x1F])
val = RadioSettingValueString(0, 3, _code, False)
val.set_charset(dtmfchars)
rs = RadioSetting("settings.code", "PTT-ID Code", val)
def apply_code(setting, obj):
code = []
for j in range(0, 3):
try:
code.append(dtmfchars.index(str(setting.value)[j]))
except IndexError:
code.append(0xFF)
obj.code = code
rs.set_apply_callback(apply_code, _mem.settings)
advanced.append(rs)
_codeobj = _mem.settings.password
_code = "".join([dtmfchars[x] for x in _codeobj if int(x) < 0x1F])
val = RadioSettingValueString(0, 6, _code, False)
val.set_charset(dtmfchars)
rs = RadioSetting("settings.password", "Control Password", 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.password = code
rs.set_apply_callback(apply_code, _mem.settings)
advanced.append(rs)
if _mem.settings.tdrab > 0x01:
val = 0x00
else:
val = _mem.settings.tdrab
rs = RadioSetting("settings.tdrab", "Dual Watch TX Priority",
RadioSettingValueList(
LIST_AB, LIST_AB[val]))
advanced.append(rs)
rs = RadioSetting("settings.keylk", "Key Lock",
RadioSettingValueBoolean(_mem.settings.keylk))
advanced.append(rs)
rs = RadioSetting("settings.control", "Control Code",
RadioSettingValueBoolean(_mem.settings.control))
advanced.append(rs)
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")
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")
dtmfd = RadioSettingGroup("dtmfd", "DTMF Decode Settings")
service = RadioSettingGroup("service", "Service Settings")
top = RadioSettings(basic, advanced, other, work, fm_preset, dtmfe,
dtmfd, 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)
if _mem.settings.almod > 0x02:
val = 0x00
else:
val = _mem.settings.almod
rs = RadioSetting("settings.almod", "Alarm Mode",
RadioSettingValueList(LIST_ALMOD, LIST_ALMOD[val]))
basic.append(rs)
if _mem.settings.tdrab > 0x02:
val = 0x00
else:
val = _mem.settings.tdrab
rs = RadioSetting("settings.tdrab", "Dual Watch TX Priority",
RadioSettingValueList(LIST_OFFAB, LIST_OFFAB[val]))
basic.append(rs)
rs = RadioSetting("settings.ste", "Squelch Tail Eliminate (HT to HT)",
RadioSettingValueBoolean(_mem.settings.ste))
basic.append(rs)
if _mem.settings.rpste > 0x0A:
val = 0x00
else:
val = _mem.settings.rpste
rs = RadioSetting("settings.rpste",
"Squelch Tail Eliminate (repeater)",
RadioSettingValueList(LIST_RPSTE, LIST_RPSTE[val]))
basic.append(rs)
if _mem.settings.rptrl > 0x0A:
val = 0x00
else:
val = _mem.settings.rptrl
rs = RadioSetting(
"settings.rptrl", "STE Repeater Delay",
RadioSettingValueList(LIST_STEDELAY, LIST_STEDELAY[val]))
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.dani", "Decode ANI",
RadioSettingValueBoolean(_mem.settings.dani))
basic.append(rs)
if _mem.settings.dtmfg > 0x3C:
val = 0x14
else:
val = _mem.settings.dtmfg
rs = RadioSetting("settings.dtmfg", "DTMF Gain",
RadioSettingValueInteger(0, 60, val))
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)
if str(_mem.firmware_msg.line1) == "UVVG302":
lower = 136
upper = 174
else:
lower = 130
upper = 179
rs = RadioSetting(
"limits.vhf.lower", "VHF Lower Limit (MHz)",
RadioSettingValueInteger(lower, upper, _mem.limits.vhf.lower))
other.append(rs)
rs = RadioSetting(
"limits.vhf.upper", "VHF Upper Limit (MHz)",
RadioSettingValueInteger(lower, upper, _mem.limits.vhf.upper))
other.append(rs)
if str(_mem.firmware_msg.line1) == "UVVG302":
lower = 200
upper = 230
else:
lower = 220
upper = 225
rs = RadioSetting(
"limits.vhf2.lower", "VHF2 Lower Limit (MHz)",
RadioSettingValueInteger(lower, upper, _mem.limits.vhf2.lower))
other.append(rs)
rs = RadioSetting(
"limits.vhf2.upper", "VHF2 Upper Limit (MHz)",
RadioSettingValueInteger(lower, upper, _mem.limits.vhf2.upper))
other.append(rs)
if str(_mem.firmware_msg.line1) == "UVVG302":
lower = 400
upper = 480
else:
lower = 400
upper = 520
rs = RadioSetting(
"limits.uhf.lower", "UHF Lower Limit (MHz)",
RadioSettingValueInteger(lower, upper, _mem.limits.uhf.lower))
other.append(rs)
rs = RadioSetting(
"limits.uhf.upper", "UHF Upper Limit (MHz)",
RadioSettingValueInteger(lower, upper, _mem.limits.uhf.upper))
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.workmode", "VFO/MR Mode",
RadioSettingValueList(LIST_WORKMODE,
LIST_WORKMODE[_mem.settings.workmode]))
work.append(rs)
rs = RadioSetting("settings.keylock", "Keypad Lock",
RadioSettingValueBoolean(_mem.settings.keylock))
work.append(rs)
rs = RadioSetting(
"wmchannel.mrcha", "MR A Channel",
RadioSettingValueInteger(0, 127, _mem.wmchannel.mrcha))
work.append(rs)
rs = RadioSetting(
"wmchannel.mrchb", "MR B Channel",
RadioSettingValueInteger(0, 127, _mem.wmchannel.mrchb))
work.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):
_vhf_lower = int(_mem.limits.vhf.lower)
_vhf_upper = int(_mem.limits.vhf.upper)
_vhf2_lower = int(_mem.limits.vhf2.lower)
_vhf2_upper = int(_mem.limits.vhf2.upper)
_uhf_lower = int(_mem.limits.uhf.lower)
_uhf_upper = int(_mem.limits.uhf.upper)
value = chirp_common.parse_freq(value)
msg = ("Can't be less than %i.0000")
if value > 99000000 and value < _vhf_lower * 1000000:
raise InvalidValueError(msg % (_vhf_lower))
msg = ("Can't be between %i.9975-%i.0000")
if (_vhf_upper + 1) * 1000000 <= value and \
value < _vhf2_lower * 1000000:
raise InvalidValueError(msg % (_vhf_upper, _vhf2_lower))
if (_vhf2_upper + 1) * 1000000 <= value and \
value < _uhf_lower * 1000000:
raise InvalidValueError(msg % (_vhf2_upper, _uhf_lower))
msg = ("Can't be greater than %i.9975")
if value > 99000000 and value >= (_uhf_upper + 1) * 1000000:
raise InvalidValueError(msg % (_uhf_upper))
return chirp_common.format_freq(value)
def apply_freq(setting, obj):
value = chirp_common.parse_freq(str(setting.value)) / 10
for i in range(7, -1, -1):
obj.freq[i] = value % 10
value /= 10
val1a = RadioSettingValueString(0, 10,
convert_bytes_to_freq(_mem.vfo.a.freq))
val1a.set_validate_callback(my_validate)
rs = RadioSetting("vfo.a.freq", "VFO A Frequency", val1a)
rs.set_apply_callback(apply_freq, _mem.vfo.a)
work.append(rs)
val1b = RadioSettingValueString(0, 10,
convert_bytes_to_freq(_mem.vfo.b.freq))
val1b.set_validate_callback(my_validate)
rs = RadioSetting("vfo.b.freq", "VFO B Frequency", val1b)
rs.set_apply_callback(apply_freq, _mem.vfo.b)
work.append(rs)
rs = RadioSetting(
"vfo.a.sftd", "VFO A Shift",
RadioSettingValueList(LIST_SHIFTD, LIST_SHIFTD[_mem.vfo.a.sftd]))
work.append(rs)
rs = RadioSetting(
"vfo.b.sftd", "VFO B Shift",
RadioSettingValueList(LIST_SHIFTD, LIST_SHIFTD[_mem.vfo.b.sftd]))
work.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 * 1000)
def apply_offset(setting, obj):
value = chirp_common.parse_freq(str(setting.value)) / 1000
for i in range(5, -1, -1):
obj.offset[i] = value % 10
value /= 10
val1a = RadioSettingValueString(
0, 10, convert_bytes_to_offset(_mem.vfo.a.offset))
rs = RadioSetting("vfo.a.offset", "VFO A Offset", val1a)
rs.set_apply_callback(apply_offset, _mem.vfo.a)
work.append(rs)
val1b = RadioSettingValueString(
0, 10, convert_bytes_to_offset(_mem.vfo.b.offset))
rs = RadioSetting("vfo.b.offset", "VFO B Offset", val1b)
rs.set_apply_callback(apply_offset, _mem.vfo.b)
work.append(rs)
rs = RadioSetting(
"vfo.a.txpower", "VFO A Power",
RadioSettingValueList(LIST_TXPOWER,
LIST_TXPOWER[_mem.vfo.a.txpower]))
work.append(rs)
rs = RadioSetting(
"vfo.b.txpower", "VFO B Power",
RadioSettingValueList(LIST_TXPOWER,
LIST_TXPOWER[_mem.vfo.b.txpower]))
work.append(rs)
rs = RadioSetting(
"vfo.a.widenarr", "VFO A Bandwidth",
RadioSettingValueList(LIST_BANDWIDTH,
LIST_BANDWIDTH[_mem.vfo.a.widenarr]))
work.append(rs)
rs = RadioSetting(
"vfo.b.widenarr", "VFO B Bandwidth",
RadioSettingValueList(LIST_BANDWIDTH,
LIST_BANDWIDTH[_mem.vfo.b.widenarr]))
work.append(rs)
rs = RadioSetting(
"vfo.a.scode", "VFO A S-CODE",
RadioSettingValueList(LIST_SCODE, LIST_SCODE[_mem.vfo.a.scode]))
work.append(rs)
rs = RadioSetting(
"vfo.b.scode", "VFO B S-CODE",
RadioSettingValueList(LIST_SCODE, LIST_SCODE[_mem.vfo.b.scode]))
work.append(rs)
rs = RadioSetting(
"vfo.a.step", "VFO A Tuning Step",
RadioSettingValueList(LIST_STEP, LIST_STEP[_mem.vfo.a.step]))
work.append(rs)
rs = RadioSetting(
"vfo.b.step", "VFO B Tuning Step",
RadioSettingValueList(LIST_STEP, LIST_STEP[_mem.vfo.b.step]))
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 encode settings
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, 16, _code, False)
val.set_charset(DTMF_CHARS)
rs = RadioSetting("pttid/%i.code" % i, "Signal Code %i" % (i + 1),
val)
def apply_code(setting, obj):
code = []
for j in range(0, 16):
try:
code.append(DTMF_CHARS.index(str(setting.value)[j]))
except IndexError:
code.append(0xFF)
obj.code = code
rs.set_apply_callback(apply_code, self._memobj.pttid[i])
dtmfe.append(rs)
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, 7, _code, False)
val.set_charset(DTMF_CHARS)
rs = RadioSetting("ani.code", "ANI Code", val)
def apply_code(setting, obj):
code = []
for j in range(0, 7):
try:
code.append(DTMF_CHARS.index(str(setting.value)[j]))
except IndexError:
code.append(0xFF)
obj.code = code
rs.set_apply_callback(apply_code, self._memobj.ani)
dtmfe.append(rs)
rs = RadioSetting(
"ani.aniid", "When to send ANI ID",
RadioSettingValueList(LIST_PTTID, LIST_PTTID[_mem.ani.aniid]))
dtmfe.append(rs)
# DTMF decode settings
rs = RadioSetting("ani.mastervice", "Master and Vice ID",
RadioSettingValueBoolean(_mem.ani.mastervice))
dtmfd.append(rs)
_codeobj = _mem.ani.masterid
_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.masterid", "Master Control ID", val)
def apply_code(setting, obj):
code = []
for j in range(0, 5):
try:
code.append(DTMF_CHARS.index(str(setting.value)[j]))
except IndexError:
code.append(0xFF)
obj.masterid = code
rs.set_apply_callback(apply_code, self._memobj.ani)
dtmfd.append(rs)
rs = RadioSetting("ani.minspection", "Master Inspection",
RadioSettingValueBoolean(_mem.ani.minspection))
dtmfd.append(rs)
rs = RadioSetting("ani.mmonitor", "Master Monitor",
RadioSettingValueBoolean(_mem.ani.mmonitor))
dtmfd.append(rs)
rs = RadioSetting("ani.mstun", "Master Stun",
RadioSettingValueBoolean(_mem.ani.mstun))
dtmfd.append(rs)
rs = RadioSetting("ani.mkill", "Master Kill",
RadioSettingValueBoolean(_mem.ani.mkill))
dtmfd.append(rs)
rs = RadioSetting("ani.mrevive", "Master Revive",
RadioSettingValueBoolean(_mem.ani.mrevive))
dtmfd.append(rs)
_codeobj = _mem.ani.viceid
_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.viceid", "Vice Control ID", val)
def apply_code(setting, obj):
code = []
for j in range(0, 5):
try:
code.append(DTMF_CHARS.index(str(setting.value)[j]))
except IndexError:
code.append(0xFF)
obj.viceid = code
rs.set_apply_callback(apply_code, self._memobj.ani)
dtmfd.append(rs)
rs = RadioSetting("ani.vinspection", "Vice Inspection",
RadioSettingValueBoolean(_mem.ani.vinspection))
dtmfd.append(rs)
rs = RadioSetting("ani.vmonitor", "Vice Monitor",
RadioSettingValueBoolean(_mem.ani.vmonitor))
dtmfd.append(rs)
rs = RadioSetting("ani.vstun", "Vice Stun",
RadioSettingValueBoolean(_mem.ani.vstun))
dtmfd.append(rs)
rs = RadioSetting("ani.vkill", "Vice Kill",
RadioSettingValueBoolean(_mem.ani.vkill))
dtmfd.append(rs)
rs = RadioSetting("ani.vrevive", "Vice Revive",
RadioSettingValueBoolean(_mem.ani.vrevive))
dtmfd.append(rs)
_codeobj = _mem.ani.inspection
_code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F])
val = RadioSettingValueString(0, 8, _code, False)
val.set_charset(DTMF_CHARS)
rs = RadioSetting("ani.inspection", "Inspection Code", val)
def apply_code(setting, obj):
code = []
for j in range(0, 8):
try:
code.append(DTMF_CHARS.index(str(setting.value)[j]))
except IndexError:
code.append(0xFF)
obj.inspection = code
rs.set_apply_callback(apply_code, self._memobj.ani)
dtmfd.append(rs)
_codeobj = _mem.ani.monitor
_code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F])
val = RadioSettingValueString(0, 8, _code, False)
val.set_charset(DTMF_CHARS)
rs = RadioSetting("ani.monitor", "Monitor Code", val)
def apply_code(setting, obj):
code = []
for j in range(0, 8):
try:
code.append(DTMF_CHARS.index(str(setting.value)[j]))
except IndexError:
code.append(0xFF)
obj.monitor = code
rs.set_apply_callback(apply_code, self._memobj.ani)
dtmfd.append(rs)
_codeobj = _mem.ani.alarmcode
_code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F])
val = RadioSettingValueString(0, 8, _code, False)
val.set_charset(DTMF_CHARS)
rs = RadioSetting("ani.alarm", "Alarm Code", val)
def apply_code(setting, obj):
code = []
for j in range(0, 8):
try:
code.append(DTMF_CHARS.index(str(setting.value)[j]))
except IndexError:
code.append(0xFF)
obj.alarmcode = code
rs.set_apply_callback(apply_code, self._memobj.ani)
dtmfd.append(rs)
_codeobj = _mem.ani.stun
_code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F])
val = RadioSettingValueString(0, 8, _code, False)
val.set_charset(DTMF_CHARS)
rs = RadioSetting("ani.stun", "Stun Code", val)
def apply_code(setting, obj):
code = []
for j in range(0, 8):
try:
code.append(DTMF_CHARS.index(str(setting.value)[j]))
except IndexError:
code.append(0xFF)
obj.stun = code
rs.set_apply_callback(apply_code, self._memobj.ani)
dtmfd.append(rs)
_codeobj = _mem.ani.kill
_code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F])
val = RadioSettingValueString(0, 8, _code, False)
val.set_charset(DTMF_CHARS)
rs = RadioSetting("ani.kill", "Kill Code", val)
def apply_code(setting, obj):
code = []
for j in range(0, 8):
try:
code.append(DTMF_CHARS.index(str(setting.value)[j]))
except IndexError:
code.append(0xFF)
obj.kill = code
rs.set_apply_callback(apply_code, self._memobj.ani)
dtmfd.append(rs)
_codeobj = _mem.ani.revive
_code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F])
val = RadioSettingValueString(0, 8, _code, False)
val.set_charset(DTMF_CHARS)
rs = RadioSetting("ani.revive", "Revive Code", val)
def apply_code(setting, obj):
code = []
for j in range(0, 8):
try:
code.append(DTMF_CHARS.index(str(setting.value)[j]))
except IndexError:
code.append(0xFF)
obj.revive = code
rs.set_apply_callback(apply_code, self._memobj.ani)
dtmfd.append(rs)
def apply_dmtf_listvalue(setting, obj):
LOG.debug("Setting value: " + str(setting.value) + " from list")
val = str(setting.value)
index = LIST_DTMF_SPECIAL_DIGITS.index(val)
val = LIST_DTMF_SPECIAL_VALUES[index]
obj.set_value(val)
if _mem.ani.groupcode in LIST_DTMF_SPECIAL_VALUES:
idx = LIST_DTMF_SPECIAL_VALUES.index(_mem.ani.groupcode)
else:
idx = LIST_DTMF_SPECIAL_VALUES.index(0x0B)
rs = RadioSetting(
"ani.groupcode", "Group Code",
RadioSettingValueList(LIST_DTMF_SPECIAL_DIGITS,
LIST_DTMF_SPECIAL_DIGITS[idx]))
rs.set_apply_callback(apply_dmtf_listvalue, _mem.ani.groupcode)
dtmfd.append(rs)
if _mem.ani.spacecode in LIST_DTMF_SPECIAL_VALUES:
idx = LIST_DTMF_SPECIAL_VALUES.index(_mem.ani.spacecode)
else:
idx = LIST_DTMF_SPECIAL_VALUES.index(0x0C)
rs = RadioSetting(
"ani.spacecode", "Space Code",
RadioSettingValueList(LIST_DTMF_SPECIAL_DIGITS,
LIST_DTMF_SPECIAL_DIGITS[idx]))
rs.set_apply_callback(apply_dmtf_listvalue, _mem.ani.spacecode)
dtmfd.append(rs)
if _mem.ani.resettime > 0x9F:
val = 0x4F
else:
val = _mem.ani.resettime
rs = RadioSetting(
"ani.resettime", "Reset Time",
RadioSettingValueList(LIST_RESETTIME, LIST_RESETTIME[val]))
dtmfd.append(rs)
if _mem.ani.delayproctime > 0x27:
val = 0x04
else:
val = _mem.ani.delayproctime
rs = RadioSetting(
"ani.delayproctime", "Delay Processing Time",
RadioSettingValueList(LIST_DELAYPROCTIME, LIST_DELAYPROCTIME[val]))
dtmfd.append(rs)
# Service settings
for band in ["vhf", "uhf"]:
for index in range(0, 10):
key = "squelch.%s.sql%i" % (band, index)
if band == "vhf":
_obj = self._memobj.squelch.vhf
elif band == "uhf":
_obj = self._memobj.squelch.uhf
val = RadioSettingValueInteger(
0, 123, getattr(_obj, "sql%i" % (index)))
if index == 0:
val.set_mutable(False)
name = "%s Squelch %i" % (band.upper(), index)
rs = RadioSetting(key, name, val)
service.append(rs)
return top
def get_settings(self):
"""Translate the MEM_FORMAT structs into settings in the UI"""
# Define mem struct write-back shortcuts
_sets = self._memobj.settings
_cmnt = self._memobj.comment
_wxch = self._memobj.abwx
_dtm = self._memobj.dtmfcode
_pses = self._memobj.pgmscanedge
_bklk = self._memobj.banklink
basic = RadioSettingGroup("basic", "Basic Settings")
mickey = RadioSettingGroup("mickey", "Microphone Keys")
bluet = RadioSettingGroup("bluet", "Bluetooth")
disp = RadioSettingGroup("disp", "Display")
sound = RadioSettingGroup("sound", "Sounds")
dtmf = RadioSettingGroup("dtmf", "DTMF Codes")
abset = RadioSettingGroup("abset", "A/B Band Settings")
edges = RadioSettingGroup("edges", "Program Scan Edges")
pslnk = RadioSettingGroup("pslnk", "Program Scan Links")
other = RadioSettingGroup("other", "Other Settings")
group = RadioSettings(basic, disp, sound, mickey, dtmf, abset, bluet,
edges, pslnk, other)
def mic_keys(setting, obj, atrb):
""" Callback to set subset of mic key options """
stx = str(setting.value)
value = MICKEYOPTS.index(stx)
setattr(obj, atrb, value)
return
def hex_val(setting, obj, atrb):
""" Callback to store string as hex values """
value = int(str(setting.value), 16)
setattr(obj, atrb, value)
return
def unpack_str(codestr):
"""Convert u8 DTMF array to a string: NOT a callback."""
stx = ""
for i in range(0, 24): # unpack up to ff
if codestr[i] != 0xff: # Issue 8159 fix
if codestr[i] == 0x0E:
stx += "*"
elif codestr[i] == 0x0F:
stx += "#"
else:
stx += format(int(codestr[i]), '0X')
return stx
def pack_chars(setting, obj, atrb, ndx):
"""Callback to build 0-9,A-D,*# nibble array from string"""
# String will be f padded to 24 bytes
# Chars are stored as hex values
ary = []
stx = str(setting.value).upper()
stx = stx.strip() # trim spaces
# Remove illegal characters first
sty = ""
for j in range(0, len(stx)):
if stx[j] in MDTMF_CHARS:
sty += stx[j]
for j in range(0, 24):
if j < len(sty): # Issue 8159 fix
if sty[j] == "*":
chrv = 0xE
elif sty[j] == "#":
chrv = 0xF
else:
chrv = int(sty[j], 16)
else: # pad to 24 bytes
chrv = 0xFF
ary.append(chrv) # append byte
setattr(obj[ndx], atrb, ary)
return
def myset_comment(setting, obj, atrb, knt):
""" Callback to create space-padded char array"""
stx = str(setting.value)
for i in range(0, knt):
if i > len(stx):
str.append(0x20)
setattr(obj, atrb, stx)
return
def myset_psnam(setting, obj, ndx, atrb, knt):
""" Callback to generate space-padded, uppercase char array """
# This sub also is specific to object arrays
stx = str(setting.value).upper()
for i in range(0, knt):
if i > len(stx):
str.append(0x20)
setattr(obj[ndx], atrb, stx)
return
def myset_frqflgs(setting, obj, ndx, flg, frq):
""" Callback to gen flag/freq pairs """
vfrq = float(str(setting.value))
vfrq = int(vfrq * 1000000)
vflg = 0x10
if vfrq % 6250 == 0:
vflg = 0x08
vfrq = int(vfrq / 6250)
elif vfrq % 5000 == 0:
vflg = 0
vfrq = int(vfrq / 5000)
else:
vfrq = int(vfrq / 8333)
setattr(obj[ndx], flg, vflg)
setattr(obj[ndx], frq, vfrq)
return
def banklink(ary):
""" Sub to generate A-J string from 2-byte bit pattern """
stx = ""
for kx in range(0, 10):
if kx < 8:
val = ary[0]
msk = 1 << kx
else:
val = ary[1]
msk = 1 << (kx - 8)
if val & msk:
stx += chr(kx + 65)
else:
stx += "_"
return stx
def myset_banklink(setting, obj, atrb):
"""Callback to create 10-bit, u8[2] array from 10 char string"""
stx = str(setting.value).upper()
ary = [0, 0]
for kx in range(0, 10):
if stx[kx] == chr(kx + 65):
if kx < 8:
ary[0] = ary[0] + (1 << kx)
else:
ary[1] = ary[1] + (1 << (kx - 8))
setattr(obj, atrb, ary)
return
def myset_tsopt(setting, obj, ndx, atrb, bx):
""" Callback to set scan Edge tstep """
stx = str(setting.value)
flg = 0
if stx == "-":
val = 0xff
else:
if bx == 1: # Air band
if stx == "Auto":
val = 0xe
elif stx == "25k":
val = 8
elif stx == "8.33k":
val = 2
else: # VHF or UHF
optx = [
"-", "5k", "6.25k", "10k", "12.5k", "15k", "20k",
"25k", "30k", "50k"
]
val = optx.index(stx) + 1
setattr(obj[ndx], atrb, val)
# and set flag
setattr(obj[ndx], "flag", flg)
return
def myset_mdopt(setting, obj, ndx, atrb, bx):
""" Callback to set Scan Edge mode """
stx = str(setting.value)
if stx == "-":
val = 0xf
elif stx == "FM":
val = 0
else:
val = 1
setattr(obj[ndx], atrb, val)
return
def myset_bitmask(setting, obj, ndx, atrb, knt):
""" Callback to gnerate byte-array bitmask from string"""
# knt is BIT count to process
lsx = str(setting.value).strip().split(",")
for kx in range(0, len(lsx)):
try:
lsx[kx] = int(lsx[kx])
except Exception:
lsx[kx] = -99 # will nop
ary = [0, 0, 0, 0xfe]
for kx in range(0, knt):
if kx < 8:
if kx in lsx:
ary[0] += 1 << kx
elif kx >= 8 and kx < 16:
if kx in lsx:
ary[1] += 1 << (kx - 8)
elif kx >= 16 and kx < 24:
if kx in lsx:
ary[2] += 1 << (kx - 16)
else:
if kx in lsx: # only bit 25
ary[3] += 1
setattr(obj[ndx], atrb, ary)
return
# --- Basic
options = ["Off", "S-Meter Squelch", "ATT"]
rx = RadioSettingValueList(options, options[_sets.sqlatt])
rset = RadioSetting("settings.sqlatt", "Squelch/ATT", rx)
basic.append(rset)
options = ["Short", "Long"]
rx = RadioSettingValueList(options, options[_sets.sqldly])
rset = RadioSetting("settings.sqldly", "Squelch Delay", rx)
basic.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.pttlock))
rset = RadioSetting("settings.pttlock", "PTT Lockout", rx)
basic.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.bcl))
rset = RadioSetting("settings.bcl", "Busy Channel Lockout", rx)
basic.append(rset)
options = ["Off", "1m", "3m", "5m", "10m", "15m", "30m"]
rx = RadioSettingValueList(options, options[_sets.tot])
rset = RadioSetting("settings.tot", "Tx Timeout", rx)
basic.append(rset)
val = int(_sets.vfohome)
if val == 0xffff:
val = 0
val = val / 1000000.0
rx = RadioSettingValueFloat(0.0, 550.0, val, 0.005, 4)
rx.set_mutable(False)
rset = RadioSetting("settings.vfohome", "Home VFO (Read-Only)", rx)
basic.append(rset)
val = _sets.homech
if val == 0xffff:
val = -1
rx = RadioSettingValueInteger(-1, 999, val)
rx.set_mutable(False)
rset = RadioSetting("settings.homech", "Home Channel (Read-Only)", rx)
basic.append(rset)
options = ["1", "2", "3", "4"]
rx = RadioSettingValueList(options, options[_sets.micgain])
rset = RadioSetting("settings.micgain", "Microphone Gain", rx)
basic.append(rset)
_bmem = self._memobj.initmem
rx = RadioSettingValueInteger(0, 999, _bmem.left_memory)
rset = RadioSetting("initmem.left_memory",
"Left Bank Initial Mem Chan", rx)
basic.append(rset)
rx = RadioSettingValueInteger(0, 999, _bmem.right_memory)
rset = RadioSetting("initmem.right_memory",
"Right Bank Initial Mem Chan", rx)
basic.append(rset)
stx = ""
for i in range(0, 16):
stx += chr(_cmnt.com[i])
stx = stx.rstrip()
rx = RadioSettingValueString(0, 16, stx)
rset = RadioSetting("comment.com", "Comment (16 chars)", rx)
rset.set_apply_callback(myset_comment, _cmnt, "com", 16)
basic.append(rset)
# --- Other
rset = RadioSetting("drv_clone_speed", "Use Hi-Speed Clone",
RadioSettingValueBoolean(self._can_hispeed))
other.append(rset)
options = ["Single", "All", "Ham"]
rx = RadioSettingValueList(options, options[_sets.actband])
rset = RadioSetting("settings.actband", "Active Band", rx)
other.append(rset)
options = ["Slow", "Mid", "Fast", "Auto"]
rx = RadioSettingValueList(options, options[_sets.fanspeed])
rset = RadioSetting("settings.fanspeed", "Fan Speed", rx)
other.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.dialspdup))
rset = RadioSetting("settings.dialspdup", "Dial Speed-Up", rx)
other.append(rset)
options = ["Off", "On(Dup)", "On(Dup+Tone)"]
rx = RadioSettingValueList(options, options[_sets.autorptr])
rset = RadioSetting("settings.autorptr", "Auto Repeater", rx)
other.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.rmtmic))
rset = RadioSetting("settings.rmtmic", "One-Touch PTT (Remote Mic)",
rx)
other.append(rset)
options = ["Low", "Mid", "High"]
rx = RadioSettingValueList(options, options[_sets.vhfpower])
rset = RadioSetting("settings.vhfpower", "VHF Power Default", rx)
other.append(rset)
rx = RadioSettingValueList(options, options[_sets.uhfpower])
rset = RadioSetting("settings.uhfpower", "UHF Power Default", rx)
other.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.toneburst))
rset = RadioSetting("settings.toneburst", "1750 Htz Tone Burst", rx)
other.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.ifxchg))
rset = RadioSetting("settings.ifxchg", "IF Exchange", rx)
other.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.rpthangup))
rset = RadioSetting("settings.rpthangup", "Repeater Hang up Timeout",
rx)
other.append(rset)
stx = str(_sets.civaddr)[2:] # Hex value
rx = RadioSettingValueString(1, 2, stx)
rset = RadioSetting("settings.civaddr", "CI-V Address (90)", rx)
rset.set_apply_callback(hex_val, _sets, "civaddr")
other.append(rset)
options = ["1200", "2400", "4800", "9600", "19200", "Auto"]
rx = RadioSettingValueList(options, options[_sets.civbaud])
rset = RadioSetting("settings.civbaud", "CI-V Baud Rate (bps)", rx)
other.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.civtcvr))
rset = RadioSetting("settings.civtcvr", "CI-V Transceive", rx)
other.append(rset)
# A/B Band Settings
options = ["Off", "On", "Bell"]
rx = RadioSettingValueList(options, options[_sets.aprichn])
rset = RadioSetting("settings.aprichn",
"A Band: VFO Priority Watch Mode", rx)
abset.append(rset)
options = [
"2", "4", "6", "8", "10", "12", "14", "16", "18", "20", "Hold"
]
rx = RadioSettingValueList(options, options[_sets.ascanpause])
rset = RadioSetting("settings.ascanpause",
"-- A Band: Scan Pause Time (Secs)", rx)
abset.append(rset)
options = ["0", "1", "2", "3", "4", "5", "Hold"]
rx = RadioSettingValueList(options, options[_sets.ascanresume])
rset = RadioSetting("settings.ascanresume",
"-- A Band: Scan Resume Time (Secs)", rx)
abset.append(rset)
options = ["5", "10", "15"]
rx = RadioSettingValueList(options, options[_sets.atmpskiptym])
rset = RadioSetting("settings.atmpskiptym",
"-- A Band: Temp Skip Time (Secs)", rx)
abset.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.aprgskpscn))
rset = RadioSetting("settings.aprgskpscn",
"-- A Band: Program Skip Scan", rx)
abset.append(rset)
rx = RadioSettingValueString(10, 10, banklink(_bklk.alnk))
rset = RadioSetting("banklink.alnk",
"-- A Band Banklink (use _ to skip)", rx)
rset.set_apply_callback(myset_banklink, _bklk, "alnk")
abset.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.awxalert))
rset = RadioSetting("settings.awxalert", "-- A Band: Weather Alert",
rx)
abset.append(rset)
# Use list for Wx chans since chan 1 = index 0
options = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]
rx = RadioSettingValueList(options, options[_wxch.awxchan])
rset = RadioSetting("abwx.awxchan", "-- A Band: Weather Channel", rx)
abset.append(rset)
options = ["Off", "On", "Bell"]
rx = RadioSettingValueList(options, options[_sets.bprichn])
rset = RadioSetting("settings.bprichn",
"B Band: VFO Priority Watch Mode", rx)
abset.append(rset)
options = [
"2", "4", "6", "8", "10", "12", "14", "16", "18", "20", "Hold"
]
rx = RadioSettingValueList(options, options[_sets.bscanpause])
rset = RadioSetting("settings.bscanpause",
"-- B Band: Scan Pause Time (Secs)", rx)
abset.append(rset)
options = ["0", "1", "2", "3", "4", "5", "Hold"]
rx = RadioSettingValueList(options, options[_sets.bscanresume])
rset = RadioSetting("settings.bscanresume",
"-- B Band: Scan Resume Time (Secs)", rx)
abset.append(rset)
options = ["5", "10", "15"]
rx = RadioSettingValueList(options, options[_sets.btmpskiptym])
rset = RadioSetting("settings.btmpskiptym",
"-- B Band: Temp Skip Time (Secs)", rx)
abset.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.bprgskpscn))
rset = RadioSetting("settings.bprgskpscn",
"-- B Band: Program Skip Scan", rx)
abset.append(rset)
rx = RadioSettingValueString(10, 10, banklink(_bklk.blnk))
rset = RadioSetting("banklink.blnk",
"-- B Band Banklink (use _ to skip)", rx)
rset.set_apply_callback(myset_banklink, _bklk, "blnk")
abset.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.bwxalert))
rset = RadioSetting("settings.bwxalert", "-- B Band: Weather Alert",
rx)
abset.append(rset)
options = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]
rx = RadioSettingValueList(options, options[_wxch.bwxchan])
rset = RadioSetting("abwx.bwxchan", "-- B Band: Weather Channel", rx)
abset.append(rset)
# --- Microphone Keys
# The Mic keys get wierd: stored values are indecis to the full
# options list, but only a subset is valid...
shortopts = [
"Off", "Monitor", "MR (Ch 0)", "MR (Ch 1)", "Band/Bank", "Scan",
"Temp Skip", "Mode", "Low", "Dup", "Priority", "Tone", "MW",
"Mute", "DTMF Direct", "T-Call"
]
ptr = shortopts.index(MICKEYOPTS[_sets.mickyrxf1])
rx = RadioSettingValueList(shortopts, shortopts[ptr])
rset = RadioSetting("settings.mickyrxf1", "During Rx/Standby [F-1]",
rx)
rset.set_apply_callback(mic_keys, _sets, "mickyrxf1")
mickey.append(rset)
ptr = shortopts.index(MICKEYOPTS[_sets.mickyrxf2])
rx = RadioSettingValueList(shortopts, shortopts[ptr])
rset = RadioSetting("settings.mickyrxf2", "During Rx/Standby [F-2]",
rx)
rset.set_apply_callback(mic_keys, _sets, "mickyrxf2")
mickey.append(rset)
options = ["Off", "Low", "T-Call"] # NOT a subset of MICKEYOPTS
rx = RadioSettingValueList(options, options[_sets.mickytxf1])
rset = RadioSetting("settings.mickytxf1", "During Tx [F-1]", rx)
mickey.append(rset)
rx = RadioSettingValueList(options, options[_sets.mickytxf2])
rset = RadioSetting("settings.mickytxf2", "During Tx [F-2]", rx)
mickey.append(rset)
# These next two get the full options list
rx = RadioSettingValueList(MICKEYOPTS, MICKEYOPTS[_sets.mickyrxup])
rset = RadioSetting("settings.mickyrxup", "During Rx/Standby [Up]", rx)
mickey.append(rset)
rx = RadioSettingValueList(MICKEYOPTS, MICKEYOPTS[_sets.mickyrxdn])
rset = RadioSetting("settings.mickyrxdn", "During Rx/Standby [Down]",
rx)
mickey.append(rset)
options = ["Off", "Low", "T-Call"]
rx = RadioSettingValueList(options, options[_sets.mickytxup])
rset = RadioSetting("settings.mickytxup", "During Tx [Up]", rx)
mickey.append(rset)
rx = RadioSettingValueList(options, options[_sets.mickytxdn])
rset = RadioSetting("settings.mickytxdn", "During Tx [Down]", rx)
mickey.append(rset)
# --- Bluetooth
rx = RadioSettingValueBoolean(bool(_sets.btoothon))
rset = RadioSetting("settings.btoothon", "Bluetooth", rx)
bluet.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.btoothauto))
rset = RadioSetting("settings.btoothauto", "Auto Connect", rx)
bluet.append(rset)
options = ["Headset Only", "Headset & Speaker"]
rx = RadioSettingValueList(options, options[_sets.bthdset])
rset = RadioSetting("settings.bthdset", "Headset Audio", rx)
bluet.append(rset)
options = [
"Normal", "Microphone", "PTT (Audio:Main)", "PTT(Audio:Controller)"
]
rx = RadioSettingValueList(options, options[_sets.bthfctn])
rset = RadioSetting("settings.bthfctn", "Headset Function", rx)
bluet.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.bthvox))
rset = RadioSetting("settings.bthvox", "Vox", rx)
bluet.append(rset)
options = ["Off", "1.0", "2", "3", "4", "5", "6", "7", "8", "9", "10"]
rx = RadioSettingValueList(options, options[_sets.bthvoxlvl])
rset = RadioSetting("settings.bthvoxlvl", "Vox Level", rx)
bluet.append(rset)
options = ["0.5", "1.0", "1.5", "2.0", "2.5", "3.0"]
rx = RadioSettingValueList(options, options[_sets.bthvoxdly])
rset = RadioSetting("settings.bthvoxdly", "Vox Delay (Secs)", rx)
bluet.append(rset)
options = ["Off", "1", "2", "3", "4", "5", "10", "15"]
rx = RadioSettingValueList(options, options[_sets.bthvoxtot])
rset = RadioSetting("settings.bthvoxtot", "Vox Time-Out (Mins)", rx)
bluet.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.bthhdpsav))
rset = RadioSetting("settings.bthhdpsav", "ICOM Headset Power-Save",
rx)
bluet.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.bth1ptt))
rset = RadioSetting("settings.bth1ptt", "ICOM Headset One-Touch PTT",
rx)
bluet.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.bthpttbeep))
rset = RadioSetting("settings.bthpttbeep", "ICOM Headset PTT Beep", rx)
bluet.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.bthcustbeep))
rset = RadioSetting("settings.bthcustbeep",
"ICOM Headset Custom Key Beep", rx)
bluet.append(rset)
rx = RadioSettingValueList(MICKEYOPTS, MICKEYOPTS[_sets.bthplaykey])
rset = RadioSetting("settings.bthplaykey",
"ICOM Headset Custom Key [Play]", rx)
bluet.append(rset)
rx = RadioSettingValueList(MICKEYOPTS, MICKEYOPTS[_sets.bthfwdkey])
rset = RadioSetting("settings.bthfwdkey",
"ICOM Headset Custom Key [Fwd]", rx)
bluet.append(rset)
rx = RadioSettingValueList(MICKEYOPTS, MICKEYOPTS[_sets.bthrwdkey])
rset = RadioSetting("settings.bthrwdkey",
"ICOM Headset Custom Key [Rwd]", rx)
bluet.append(rset)
# ---- Display
options = ["1: Dark", "2", "3", "4: Bright"]
rx = RadioSettingValueList(options, options[_sets.backlight])
rset = RadioSetting("settings.backlight", "Backlight Level", rx)
disp.append(rset)
options = ["Off", "Auto-Off", "Auto-1", "Auto-2", "Auto-3"]
rx = RadioSettingValueList(options, options[_sets.autodim])
rset = RadioSetting("settings.autodim", "Auto Dimmer", rx)
disp.append(rset)
options = ["5", "10"]
rx = RadioSettingValueList(options, options[_sets.autodimtot])
rset = RadioSetting("settings.autodimtot",
"Auto-Dimmer Timeout (Secs)", rx)
disp.append(rset)
options = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]
rx = RadioSettingValueList(options, options[_sets.contrast])
rset = RadioSetting("settings.contrast", "LCD Contrast", rx)
disp.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.openmsg))
rset = RadioSetting("settings.openmsg", "Opening Message", rx)
disp.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.memname))
rset = RadioSetting("settings.memname", "Memory Names", rx)
disp.append(rset)
options = ["CH ID", "Frequency"]
rx = RadioSettingValueList(options, options[_sets.airbandch])
rset = RadioSetting("settings.airbandch", "Air Band Display", rx)
disp.append(rset)
# -- Sounds
rx = RadioSettingValueInteger(0, 9, _sets.beeplvl)
rset = RadioSetting("settings.beeplvl", "Beep Level", rx)
sound.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.homebeep))
rset = RadioSetting("settings.homebeep", "Home Chan Beep", rx)
sound.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.keybeep))
rset = RadioSetting("settings.keybeep", "Key Touch Beep", rx)
sound.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.bandedgbeep))
rset = RadioSetting("settings.bandedgbeep", "Band Edge Beep", rx)
sound.append(rset)
rx = RadioSettingValueBoolean(bool(_sets.scanstpbeep))
rset = RadioSetting("settings.scanstpbeep", "Scan Stop Beep", rx)
sound.append(rset)
options = ["Off", "Mute", "Beep", "Mute & Beep"]
rx = RadioSettingValueList(options, options[_sets.subandmute])
rset = RadioSetting("settings.subandmute", "Sub Band Mute", rx)
sound.append(rset)
# --- DTMF Codes
options = ["100", "200", "300", "500"]
rx = RadioSettingValueList(options, options[_sets.dtmfspd])
rset = RadioSetting("settings.dtmfspd", "DTMF Speed (mSecs)", rx)
dtmf.append(rset)
for kx in range(0, 16):
stx = unpack_str(_dtm[kx].codes)
rx = RadioSettingValueString(0, 24, stx)
# NOTE the / to indicate indexed array
rset = RadioSetting("dtmfcode/%d.codes" % kx, "DTMF Code %X" % kx,
rx)
rset.set_apply_callback(pack_chars, _dtm, "codes", kx)
dtmf.append(rset)
# --- Program Scan Edges
for kx in range(0, 25):
stx = ""
for i in range(0, 6):
stx += chr(_pses[kx].name[i])
stx = stx.rstrip()
rx = RadioSettingValueString(0, 6, stx)
rset = RadioSetting("pgmscanedge/%d.name" % kx,
"Program Scan %d Name" % kx, rx)
rset.set_apply_callback(myset_psnam, _pses, kx, "name", 6)
edges.append(rset)
# Freq's use the multiplier flags
fmult = 5000.0
if _pses[kx].loflags == 0x10:
fmult = 8333
if _pses[kx].loflags == 0x08:
fmult = 6250.0
flow = (int(_pses[kx].lofreq) * fmult) / 1000000.0
flow = round(flow, 4)
fmult = 5000.0
if _pses[kx].hiflags == 0x10:
fmult = 8333
if _pses[kx].hiflags == 0x08:
fmult = 6250.0
fhigh = (int(_pses[kx].hifreq) * fmult) / 1000000.0
fhigh = round(fhigh, 4)
if (flow > 0) and (flow >= fhigh): # reverse em
val = flow
flow = fhigh
fhigh = val
rx = RadioSettingValueFloat(0, 550.0, flow, 0.010, 3)
rset = RadioSetting("pgmscanedge/%d.lofreq" % kx,
"-- Scan %d Low Limit" % kx, rx)
rset.set_apply_callback(myset_frqflgs, _pses, kx, "loflags",
"lofreq")
edges.append(rset)
rx = RadioSettingValueFloat(0, 550.0, fhigh, 0.010, 3)
rset = RadioSetting("pgmscanedge/%d.hifreq" % kx,
"-- Scan %d High Limit" % kx, rx)
rset.set_apply_callback(myset_frqflgs, _pses, kx, "hiflags",
"hifreq")
edges.append(rset)
# Tstep and Mode depend on the bands
ndxt = 0
ndxm = 0
bxnd = 0
tsopt = [
"-", "5k", "6.25k", "10k", "12.5k", "15k", "20k", "25k", "30k",
"50k"
]
mdopt = ["-", "FM", "FM-N"]
if fhigh > 0:
if fhigh < 135.0: # Air band
bxnd = 1
tsopt = ["-", "8.33k", "25k", "Auto"]
ndxt = _pses[kx].tstp
if ndxt == 0xe: # Auto
ndxt = 3
elif ndxt == 8: # 25k
ndxt = 2
elif ndxt == 2: # 8.33k
ndxt = 1
else:
ndxt = 0
mdopt = ["-"]
elif (flow >= 137.0) and (fhigh <= 174.0): # VHF
ndxt = _pses[kx].tstp - 1
ndxm = _pses[kx].mode + 1
bxnd = 2
elif (flow >= 375.0) and (fhigh <= 550.0): # UHF
ndxt = _pses[kx].tstp - 1
ndxm = _pses[kx].mode + 1
bxnd = 3
else: # Mixed, ndx's = 0 default
tsopt = ["-"]
mdopt = ["-"]
bxnd = 4
if (ndxt > 9) or (ndxt < 0):
ndxt = 0 # trap ff
if ndxm > 2:
ndxm = 0
# end if fhigh > 0
rx = RadioSettingValueList(tsopt, tsopt[ndxt])
rset = RadioSetting("pgmscanedge/%d.tstp" % kx,
"-- Scan %d Freq Step" % kx, rx)
rset.set_apply_callback(myset_tsopt, _pses, kx, "tstp", bxnd)
edges.append(rset)
rx = RadioSettingValueList(mdopt, mdopt[ndxm])
rset = RadioSetting("pgmscanedge/%d.mode" % kx,
"-- Scan %d Mode" % kx, rx)
rset.set_apply_callback(myset_mdopt, _pses, kx, "mode", bxnd)
edges.append(rset)
# End for kx
# --- Program Scan Links
_psln = self._memobj.pslnam
_pslg = self._memobj.pslgrps
for kx in range(0, 10):
stx = ""
for i in range(0, 6):
stx += chr(_psln[kx].nam[i])
stx = stx.rstrip()
rx = RadioSettingValueString(0, 6, stx)
rset = RadioSetting("pslnam/%d.nam" % kx,
"Program Scan Link %d Name" % kx, rx)
rset.set_apply_callback(myset_psnam, _psln, kx, "nam", 6)
pslnk.append(rset)
for px in range(0, 25):
# Generate string numeric representation of 4-byte bitmask
stx = ""
for nx in range(0, 25):
if nx < 8:
if (_pslg[kx].msk[0] & (1 << nx)):
stx += "%0d, " % nx
elif (nx >= 8) and (nx < 16):
if (_pslg[kx].msk[1] & (1 << (nx - 8))):
sstx += "%0d, " % nx
elif (nx >= 16) and (nx < 24):
if (_pslg[kx].msk[2] & (1 << (nx - 16))):
stx += "%0d, " % nx
elif (nx >= 24):
if (_pslg[kx].msk[3] & (1 << (nx - 24))):
stx += "%0d, " % nx
rx = RadioSettingValueString(0, 80, stx)
rset = RadioSetting("pslgrps/%d.msk" % kx,
"--- Scan Link %d Scans" % kx, rx)
rset.set_apply_callback(myset_bitmask, _pslg, kx, "msk", 25)
pslnk.append(rset)
# end for px
# End for kx
return group # END get_settings()
def get_settings(self):
_settings = self._memobj.settings
repeater = RadioSettingGroup("repeater", "Repeater Settings")
ctcss = RadioSettingGroup("ctcss", "CTCSS/DCS/DTMF Settings")
arts = RadioSettingGroup("arts", "ARTS Settings")
scan = RadioSettingGroup("scan", "Scan Settings")
power = RadioSettingGroup("power", "Power Saver Settings")
wires = RadioSettingGroup("wires", "WiRES(tm) Settings")
eai = RadioSettingGroup("eai", "EAI/EPCS Settings")
switch = RadioSettingGroup("switch", "Switch/Knob Settings")
misc = RadioSettingGroup("misc", "Miscellaneous Settings")
mbls = RadioSettingGroup("banks", "Memory Bank Link Scan")
setmode = RadioSettings(repeater, ctcss, arts, scan, power,
wires, eai, switch, misc, mbls)
# APO
opts = ["OFF"] + ["%0.1f" % (x * 0.5) for x in range(1, 24+1)]
misc.append(
RadioSetting(
"apo", "Automatic Power Off",
RadioSettingValueList(opts, opts[_settings.apo])))
# AR.BEP
opts = ["OFF", "INRANG", "ALWAYS"]
arts.append(
RadioSetting(
"ar_bep", "ARTS Beep",
RadioSettingValueList(opts, opts[_settings.ar_bep])))
# AR.INT
opts = ["25 SEC", "15 SEC"]
arts.append(
RadioSetting(
"ar_int", "ARTS Polling Interval",
RadioSettingValueList(opts, opts[_settings.ar_int])))
# ARS
opts = ["OFF", "ON"]
repeater.append(
RadioSetting(
"ars", "Automatic Repeater Shift",
RadioSettingValueList(opts, opts[_settings.ars])))
# BCLO
opts = ["OFF", "ON"]
misc.append(RadioSetting(
"bclo", "Busy Channel Lock-Out",
RadioSettingValueList(opts, opts[_settings.bclo])))
# BEEP
opts = ["OFF", "KEY", "KEY+SC"]
rs = RadioSetting(
"beep_key", "Enable the Beeper",
RadioSettingValueList(
opts, opts[_settings.beep_key + _settings.beep_sc]))
def apply_beep(s, obj):
setattr(obj, "beep_key",
(int(s.value) & 1) or ((int(s.value) >> 1) & 1))
setattr(obj, "beep_sc", (int(s.value) >> 1) & 1)
rs.set_apply_callback(apply_beep, self._memobj.settings)
switch.append(rs)
# BELL
opts = ["OFF", "1T", "3T", "5T", "8T", "CONT"]
ctcss.append(RadioSetting("bell", "Bell Repetitions",
RadioSettingValueList(opts, opts[_settings.bell])))
# BSY.LED
opts = ["ON", "OFF"]
misc.append(RadioSetting("bsy_led", "Busy LED",
RadioSettingValueList(opts, opts[_settings.bsy_led])))
# DCS.NR
opts = ["TR/X N", "RX R", "TX R", "T/RX R"]
ctcss.append(RadioSetting("dcs_nr", "\"Inverted\" DCS Code Decoding",
RadioSettingValueList(opts, opts[_settings.dcs_nr])))
# DT.DLY
opts = ["50 MS", "100 MS", "250 MS", "450 MS", "750 MS", "1000 MS"]
ctcss.append(RadioSetting("dt_dly", "DTMF Autodialer Delay Time",
RadioSettingValueList(opts, opts[_settings.dt_dly])))
# DT.SPD
opts = ["50 MS", "100 MS"]
ctcss.append(RadioSetting("dt_spd", "DTMF Autodialer Sending Speed",
RadioSettingValueList(opts, opts[_settings.dt_spd])))
# DT.WRT
for i in range(0, 9):
dtmf = self._memobj.dtmf[i]
str = ""
for c in dtmf.memory:
if c == 0xFF:
break
if c < len(DTMF_CHARS):
str += DTMF_CHARS[c]
val = RadioSettingValueString(0, 16, str, False)
val.set_charset(DTMF_CHARS + list("abcd"))
rs = RadioSetting("dtmf_%i" % i,
"DTMF Autodialer Memory %i" % (i + 1), val)
def apply_dtmf(s, obj):
str = s.value.get_value().upper().rstrip()
val = [DTMF_CHARS.index(x) for x in str]
for x in range(len(val), 16):
val.append(0xFF)
obj.memory = val
rs.set_apply_callback(apply_dtmf, dtmf)
ctcss.append(rs)
# EDG.BEP
opts = ["OFF", "ON"]
misc.append(RadioSetting("edg_bep", "Band Edge Beeper",
RadioSettingValueList(opts, opts[_settings.edg_bep])))
# I.NET
opts = ["OFF", "COD", "MEM"]
rs = RadioSetting("inet", "Internet Link Connection",
RadioSettingValueList(
opts, opts[_settings.inet - 1]))
def apply_inet(s, obj):
setattr(obj, s.get_name(), int(s.value) + 1)
rs.set_apply_callback(apply_inet, self._memobj.settings)
wires.append(rs)
# INT.CD
opts = ["CODE 0", "CODE 1", "CODE 2", "CODE 3", "CODE 4",
"CODE 5", "CODE 6", "CODE 7", "CODE 8", "CODE 9",
"CODE A", "CODE B", "CODE C", "CODE D", "CODE E", "CODE F"]
wires.append(RadioSetting("int_cd", "Access Number for WiRES(TM)",
RadioSettingValueList(opts, opts[_settings.int_cd])))
# INT.MR
opts = ["d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9"]
wires.append(RadioSetting(
"int_mr", "Access Number (DTMF) for Non-WiRES(TM)",
RadioSettingValueList(opts, opts[_settings.int_mr])))
# LAMP
opts = ["KEY", "5SEC", "TOGGLE"]
switch.append(RadioSetting("lamp", "Lamp Mode",
RadioSettingValueList(opts, opts[_settings.lamp])))
# LOCK
opts = ["LK KEY", "LKDIAL", "LK K+D", "LK PTT",
"LP P+K", "LK P+D", "LK ALL"]
rs = RadioSetting("lock", "Control Locking",
RadioSettingValueList(
opts, opts[_settings.lock - 1]))
def apply_lock(s, obj):
setattr(obj, s.get_name(), int(s.value) + 1)
rs.set_apply_callback(apply_lock, self._memobj.settings)
switch.append(rs)
# M/T-CL
opts = ["MONI", "T-CALL"]
switch.append(RadioSetting("mt_cl", "MONI Switch Function",
RadioSettingValueList(opts, opts[_settings.mt_cl])))
# PAG.ABK
opts = ["OFF", "ON"]
eai.append(RadioSetting("pag_abk", "Paging Answer Back",
RadioSettingValueList(opts, opts[_settings.pag_abk])))
# RESUME
opts = ["TIME", "HOLD", "BUSY"]
scan.append(RadioSetting("resume", "Scan Resume Mode",
RadioSettingValueList(opts, opts[_settings.resume])))
# REV/HM
opts = ["REV", "HOME"]
switch.append(RadioSetting("rev_hm", "HM/RV Key Function",
RadioSettingValueList(opts, opts[_settings.rev_hm])))
# RF.SQL
opts = ["OFF", "S-1", "S-2", "S-3", "S-4", "S-5", "S-6",
"S-7", "S-8", "S-FULL"]
misc.append(RadioSetting("rf_sql", "RF Squelch Threshold",
RadioSettingValueList(opts, opts[_settings.rf_sql])))
# PRI.RVT
opts = ["OFF", "ON"]
scan.append(RadioSetting("pri_rvt", "Priority Revert",
RadioSettingValueList(opts, opts[_settings.pri_rvt])))
# RXSAVE
opts = ["OFF", "200 MS", "300 MS", "500 MS", "1 S", "2 S"]
power.append(RadioSetting(
"rxsave", "Receive Mode Batery Savery Interval",
RadioSettingValueList(opts, opts[_settings.rxsave])))
# S.SRCH
opts = ["SINGLE", "CONT"]
misc.append(RadioSetting("ssrch", "Smart Search Sweep Mode",
RadioSettingValueList(opts, opts[_settings.ssrch])))
# SCN.MD
opts = ["MEM", "ONLY"]
scan.append(RadioSetting(
"scn_md", "Memory Scan Channel Selection Mode",
RadioSettingValueList(opts, opts[_settings.scn_md])))
# SCN.LMP
opts = ["OFF", "ON"]
scan.append(RadioSetting("scn_lmp", "Scan Lamp",
RadioSettingValueList(opts, opts[_settings.scn_lmp])))
# TOT
opts = ["OFF"] + ["%dMIN" % (x) for x in range(1, 30+1)]
misc.append(RadioSetting("tot", "Timeout Timer",
RadioSettingValueList(opts, opts[_settings.tot])))
# TX.LED
opts = ["ON", "OFF"]
misc.append(RadioSetting("tx_led", "TX LED",
RadioSettingValueList(opts, opts[_settings.tx_led])))
# TXSAVE
opts = ["OFF", "ON"]
power.append(RadioSetting("txsave", "Transmitter Battery Saver",
RadioSettingValueList(opts, opts[_settings.txsave])))
# VFO.BND
opts = ["BAND", "ALL"]
misc.append(RadioSetting("vfo_bnd", "VFO Band Edge Limiting",
RadioSettingValueList(opts, opts[_settings.vfo_bnd])))
# WX.ALT
opts = ["OFF", "ON"]
scan.append(RadioSetting("wx_alt", "Weather Alert Scan",
RadioSettingValueList(opts, opts[_settings.wx_alt])))
# MBS
for i in range(0, 10):
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)
return setmode
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
_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")
oem_grp = RadioSettingGroup("oem_grp", "OEM Info")
lmt_grp.append(uhf_lmt_grp);
lmt_grp.append(vhf_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("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)
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)
#
# 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
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):
"""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.autolk", "Automatic Key Lock",
RadioSettingValueBoolean(_mem.settings.autolk))
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)
if _mem.settings.tdrab > 0x02:
val = 0x00
else:
val = _mem.settings.tdrab
rs = RadioSetting("settings.tdrab", "Dual Watch TX Priority",
RadioSettingValueList(
LIST_OFFAB, LIST_OFFAB[val]))
basic.append(rs)
rs = RadioSetting("settings.ste", "Squelch Tail Eliminate (HT to HT)",
RadioSettingValueBoolean(_mem.settings.ste))
basic.append(rs)
if _mem.settings.rpste > 0x0A:
val = 0x00
else:
val = _mem.settings.rpste
rs = RadioSetting("settings.rpste",
"Squelch Tail Eliminate (repeater)",
RadioSettingValueList(
LIST_RPSTE, LIST_RPSTE[val]))
basic.append(rs)
if _mem.settings.rptrl > 0x0A:
val = 0x00
else:
val = _mem.settings.rptrl
rs = RadioSetting("settings.rptrl", "STE Repeater Delay",
RadioSettingValueList(
LIST_STEDELAY, LIST_STEDELAY[val]))
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)
# 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)
lower = 130
upper = 179
rs = RadioSetting("limits.vhf.lower", "VHF Lower Limit (MHz)",
RadioSettingValueInteger(
lower, upper, _mem.limits.vhf.lower))
other.append(rs)
rs = RadioSetting("limits.vhf.upper", "VHF Upper Limit (MHz)",
RadioSettingValueInteger(
lower, upper, _mem.limits.vhf.upper))
other.append(rs)
lower = 400
upper = 520
rs = RadioSetting("limits.uhf.lower", "UHF Lower Limit (MHz)",
RadioSettingValueInteger(
lower, upper, _mem.limits.uhf.lower))
other.append(rs)
rs = RadioSetting("limits.uhf.upper", "UHF Upper Limit (MHz)",
RadioSettingValueInteger(
lower, upper, _mem.limits.uhf.upper))
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.workmode", "VFO/MR Mode",
RadioSettingValueList(
LIST_WORKMODE,
LIST_WORKMODE[_mem.settings.workmode]))
work.append(rs)
rs = RadioSetting("settings.keylock", "Keypad Lock",
RadioSettingValueBoolean(_mem.settings.keylock))
work.append(rs)
rs = RadioSetting("wmchannel.mrcha", "MR A Channel",
RadioSettingValueInteger(0, 127,
_mem.wmchannel.mrcha))
work.append(rs)
rs = RadioSetting("wmchannel.mrchb", "MR B Channel",
RadioSettingValueInteger(0, 127,
_mem.wmchannel.mrchb))
work.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)
msg = ("Can't be less than %i.0000")
if value > 99000000 and value < 130 * 1000000:
raise InvalidValueError(msg % (130))
msg = ("Can't be between %i.9975-%i.0000")
if (179 + 1) * 1000000 <= value and value < 400 * 1000000:
raise InvalidValueError(msg % (179, 400))
msg = ("Can't be greater than %i.9975")
if value > 99000000 and value > (520 + 1) * 1000000:
raise InvalidValueError(msg % (520))
return chirp_common.format_freq(value)
def apply_freq(setting, obj):
value = chirp_common.parse_freq(str(setting.value)) / 10
for i in range(7, -1, -1):
obj.freq[i] = value % 10
value /= 10
val1a = RadioSettingValueString(0, 10,
convert_bytes_to_freq(_mem.vfo.a.freq))
val1a.set_validate_callback(my_validate)
rs = RadioSetting("vfo.a.freq", "VFO A Frequency", val1a)
rs.set_apply_callback(apply_freq, _mem.vfo.a)
work.append(rs)
val1b = RadioSettingValueString(0, 10,
convert_bytes_to_freq(_mem.vfo.b.freq))
val1b.set_validate_callback(my_validate)
rs = RadioSetting("vfo.b.freq", "VFO B Frequency", val1b)
rs.set_apply_callback(apply_freq, _mem.vfo.b)
work.append(rs)
rs = RadioSetting("vfo.a.sftd", "VFO A Shift",
RadioSettingValueList(
LIST_SHIFTD, LIST_SHIFTD[_mem.vfo.a.sftd]))
work.append(rs)
rs = RadioSetting("vfo.b.sftd", "VFO B Shift",
RadioSettingValueList(
LIST_SHIFTD, LIST_SHIFTD[_mem.vfo.b.sftd]))
work.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 * 1000)
def apply_offset(setting, obj):
value = chirp_common.parse_freq(str(setting.value)) / 1000
for i in range(5, -1, -1):
obj.offset[i] = value % 10
value /= 10
val1a = RadioSettingValueString(
0, 10, convert_bytes_to_offset(_mem.vfo.a.offset))
rs = RadioSetting("vfo.a.offset",
"VFO A Offset", val1a)
rs.set_apply_callback(apply_offset, _mem.vfo.a)
work.append(rs)
val1b = RadioSettingValueString(
0, 10, convert_bytes_to_offset(_mem.vfo.b.offset))
rs = RadioSetting("vfo.b.offset",
"VFO B Offset", val1b)
rs.set_apply_callback(apply_offset, _mem.vfo.b)
work.append(rs)
rs = RadioSetting("vfo.a.txpower3", "VFO A Power",
RadioSettingValueList(
LIST_TXPOWER,
LIST_TXPOWER[_mem.vfo.a.txpower3]))
work.append(rs)
rs = RadioSetting("vfo.b.txpower3", "VFO B Power",
RadioSettingValueList(
LIST_TXPOWER,
LIST_TXPOWER[_mem.vfo.b.txpower3]))
work.append(rs)
rs = RadioSetting("vfo.a.widenarr", "VFO A Bandwidth",
RadioSettingValueList(
LIST_BANDWIDTH,
LIST_BANDWIDTH[_mem.vfo.a.widenarr]))
work.append(rs)
rs = RadioSetting("vfo.b.widenarr", "VFO B Bandwidth",
RadioSettingValueList(
LIST_BANDWIDTH,
LIST_BANDWIDTH[_mem.vfo.b.widenarr]))
work.append(rs)
rs = RadioSetting("vfo.a.scode", "VFO A S-CODE",
RadioSettingValueList(
LIST_SCODE,
LIST_SCODE[_mem.vfo.a.scode]))
work.append(rs)
rs = RadioSetting("vfo.b.scode", "VFO B S-CODE",
RadioSettingValueList(
LIST_SCODE,
LIST_SCODE[_mem.vfo.b.scode]))
work.append(rs)
rs = RadioSetting("vfo.a.step", "VFO A Tuning Step",
RadioSettingValueList(
LIST_STEP, LIST_STEP[_mem.vfo.a.step]))
work.append(rs)
rs = RadioSetting("vfo.b.step", "VFO B Tuning Step",
RadioSettingValueList(
LIST_STEP, LIST_STEP[_mem.vfo.b.step]))
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 band in ["vhf", "uhf"]:
for index in range(0, 10):
key = "squelch.%s.sql%i" % (band, index)
if band == "vhf":
_obj = self._memobj.squelch.vhf
elif band == "uhf":
_obj = self._memobj.squelch.uhf
val = RadioSettingValueInteger(0, 123,
getattr(_obj, "sql%i" % (index)))
if index == 0:
val.set_mutable(False)
name = "%s Squelch %i" % (band.upper(), index)
rs = RadioSetting(key, name, val)
service.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):
_keys = self._memobj.keys
_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 - 1]))
basic.append(rs)
rs = RadioSetting("totalert", "TOT Pre-alert",
RadioSettingValueList(
TOTALERT_LIST,
TOTALERT_LIST[_settings.totalert]))
basic.append(rs)
rs = RadioSetting("squelch", "Squelch Level",
RadioSettingValueInteger(0, 9, _settings.squelch))
basic.append(rs)
rs = RadioSetting("voice", "Voice Annumciation",
RadioSettingValueList(
VOICE_LIST, VOICE_LIST[_settings.voice]))
basic.append(rs)
rs = RadioSetting("save", "Battery Saver",
RadioSettingValueBoolean(_settings.save))
basic.append(rs)
rs = RadioSetting("use_scramble", "Scramble",
RadioSettingValueBoolean(_settings.use_scramble))
basic.append(rs)
rs = RadioSetting("use_vox", "VOX",
RadioSettingValueBoolean(_settings.use_vox))
basic.append(rs)
rs = RadioSetting("vox", "VOX Gain",
RadioSettingValueList(
VOX_LIST, VOX_LIST[_settings.vox]))
basic.append(rs)
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 = RadioSetting("keys.pf1", "PF1 Key Function",
RadioSettingValueList(PF1_CHOICES,
PF1_CHOICES[idx]))
rs.set_apply_callback(apply_pf1_listvalue, _keys.pf1)
basic.append(rs)
return top
def _get_aprs_tx_settings(self):
menu = RadioSettingGroup("aprs_tx", "APRS Transmit")
aprs = self._memobj.aprs
beacon_type = (aprs.tx_smartbeacon << 1) | aprs.tx_interval_beacon;
val = RadioSettingValueList(self._BEACON_TYPE,
self._BEACON_TYPE[beacon_type])
rs = RadioSetting("aprs.transmit", "TX Beacons", val)
rs.set_apply_callback(self.apply_beacon_type, aprs)
menu.append(rs)
val = RadioSettingValueList(self._TX_DELAY,
self._TX_DELAY[aprs.tx_delay])
rs = RadioSetting("aprs.tx_delay", "TX Delay", val)
menu.append(rs)
val = RadioSettingValueList(self._BEACON_INT,
self._BEACON_INT[aprs.beacon_interval])
rs = RadioSetting("aprs.beacon_interval", "Beacon Interval", val)
menu.append(rs)
desc = []
status = [m.padded_string for m in self._memobj.aprs_beacon_status_txt]
status = self._strip_ff_pads(status)
for index, msg_text in enumerate(status):
val = RadioSettingValueString(0, 60, msg_text)
desc.append("Beacon Status Text %d" % (index + 1))
rs = RadioSetting("aprs_beacon_status_txt_%d" % index, desc[-1],
val)
rs.set_apply_callback(self.apply_ff_padded_string,
self._memobj.aprs_beacon_status_txt[index])
menu.append(rs)
val = RadioSettingValueList(desc,
desc[aprs.selected_beacon_status_txt])
rs = RadioSetting("aprs.selected_beacon_status_txt",
"Beacon Status Text", val)
menu.append(rs)
message_macro = [m.padded_string for m in aprs.message_macro]
message_macro = self._strip_ff_pads(message_macro)
for index, msg_text in enumerate(message_macro):
val = RadioSettingValueString(0, 16, msg_text)
rs = RadioSetting("aprs.message_macro_%d" % index,
"Message Macro %d" % (index + 1), val)
rs.set_apply_callback(self.apply_ff_padded_string,
aprs.message_macro[index])
menu.append(rs)
path_str = list(self._DIGI_PATHS)
path_str[3] = self._digi_path_to_str(aprs.digi_path_3_6[0])
val = RadioSettingValueString(0, 22, path_str[3])
rs = RadioSetting("aprs.digi_path_3", "Digi Path 4 (2 entries)", val)
rs.set_apply_callback(self.apply_digi_path, aprs.digi_path_3_6[0])
menu.append(rs)
path_str[4] = self._digi_path_to_str(aprs.digi_path_3_6[1])
val = RadioSettingValueString(0, 22, path_str[4])
rs = RadioSetting("aprs.digi_path_4", "Digi Path 5 (2 entries)", val)
rs.set_apply_callback(self.apply_digi_path, aprs.digi_path_3_6[1])
menu.append(rs)
path_str[5] = self._digi_path_to_str(aprs.digi_path_3_6[2])
val = RadioSettingValueString(0, 22, path_str[5])
rs = RadioSetting("aprs.digi_path_5", "Digi Path 6 (2 entries)", val)
rs.set_apply_callback(self.apply_digi_path, aprs.digi_path_3_6[2])
menu.append(rs)
path_str[6] = self._digi_path_to_str(aprs.digi_path_3_6[3])
val = RadioSettingValueString(0, 22, path_str[6])
rs = RadioSetting("aprs.digi_path_6", "Digi Path 7 (2 entries)", val)
rs.set_apply_callback(self.apply_digi_path, aprs.digi_path_3_6[3])
menu.append(rs)
path_str[7] = self._digi_path_to_str(aprs.digi_path_7)
val = RadioSettingValueString(0, 88, path_str[7])
rs = RadioSetting("aprs.digi_path_7", "Digi Path 8 (8 entries)", val)
rs.set_apply_callback(self.apply_digi_path, aprs.digi_path_7)
menu.append(rs)
# Show friendly messages for empty slots rather than blanks.
# TODO: Rebuild this when digi_path_[34567] change.
#path_str[3] = path_str[3] or self._DIGI_PATHS[3]
#path_str[4] = path_str[4] or self._DIGI_PATHS[4]
#path_str[5] = path_str[5] or self._DIGI_PATHS[5]
#path_str[6] = path_str[6] or self._DIGI_PATHS[6]
#path_str[7] = path_str[7] or self._DIGI_PATHS[7]
path_str[3] = self._DIGI_PATHS[3]
path_str[4] = self._DIGI_PATHS[4]
path_str[5] = self._DIGI_PATHS[5]
path_str[6] = self._DIGI_PATHS[6]
path_str[7] = self._DIGI_PATHS[7]
val = RadioSettingValueList(path_str,
path_str[aprs.selected_digi_path])
rs = RadioSetting("aprs.selected_digi_path", "Selected Digi Path", val)
menu.append(rs)
return menu
def get_settings(self):
try:
_squelch = 1
basic = RadioSettingGroup("basic", "Basic")
expand_1 = RadioSettingGroup("expand_1", "Expand 1")
expand_2 = RadioSettingGroup("expand_2", "Expand 2")
dtmf_autodial = RadioSettingGroup("dtmf_autodial", "DTMF autodial")
group = RadioSettings(basic, expand_1, expand_2, dtmf_autodial)
# basic
basic.append(
RadioSetting(
"mem_channel", "Current memory channel",
RadioSettingValueInteger(0, MEM_NUM - 1,
self.memobj.mem_channel)))
basic.append(
RadioSetting(
"squelch_level", "Squelch level",
RadioSettingValueList(
SQUELCH_LEVEL,
SQUELCH_LEVEL[self.memobj.squelch_level])))
basic.append(
RadioSetting(
"scan_resume", "Scan resume",
RadioSettingValueList(
SCAN_RESUME, SCAN_RESUME[self.memobj.scan_resume])))
basic.append(
RadioSetting(
"scan_pause", "Scan pause",
RadioSettingValueList(SCAN_PAUSE,
SCAN_PAUSE[self.memobj.scan_pause])))
basic.append(
RadioSetting(
"beep_volume", "Beep audio",
RadioSettingValueList(
BEEP_VOLUME, BEEP_VOLUME[self.memobj.beep_volume])))
basic.append(
RadioSetting("beep", "Operation beep",
RadioSettingValueBoolean(self.memobj.beep)))
basic.append(
RadioSetting(
"backlight", "LCD backlight",
RadioSettingValueList(BACKLIGHT,
BACKLIGHT[self.memobj.backlight])))
basic.append(
RadioSetting("busy_led", "Busy LED",
RadioSettingValueBoolean(self.memobj.busy_led)))
basic.append(
RadioSetting(
"auto_power_off", "Auto power off",
RadioSettingValueList(
AUTO_POWER_OFF,
AUTO_POWER_OFF[self.memobj.auto_power_off])))
basic.append(
RadioSetting(
"power_save", "Power save",
RadioSettingValueList(POWER_SAVE,
POWER_SAVE[self.memobj.power_save])))
basic.append(
RadioSetting(
"monitor", "Monitor",
RadioSettingValueList(MONITOR,
MONITOR[self.memobj.monitor])))
basic.append(
RadioSetting(
"dial_speedup", "Dial speedup",
RadioSettingValueBoolean(self.memobj.dial_speedup)))
basic.append(
RadioSetting(
"auto_repeater", "Auto repeater",
RadioSettingValueList(
AUTO_REPEATER,
AUTO_REPEATER[self.memobj.auto_repeater])))
basic.append(
RadioSetting(
"hm_75a_function", "HM-75A function",
RadioSettingValueList(
HM_75A_FUNCTION,
HM_75A_FUNCTION[self.memobj.hm_75a_function])))
basic.append(
RadioSetting("wx_alert", "WX alert",
RadioSettingValueBoolean(self.memobj.wx_alert)))
basic.append(
RadioSetting(
"wx_channel", "Current WX channel",
RadioSettingValueList(WX_CHANNEL,
WX_CHANNEL[self.memobj.wx_channel])))
basic.append(
RadioSetting(
"comment", "Comment",
RadioSettingValueString(0,
COMMENT_LEN,
str(self.memobj.comment),
autopad=True)))
basic.append(
RadioSetting(
"tune_step", "Current tune step",
RadioSettingValueList(
TUNE_STEP_STR, TUNE_STEP_STR[self.memobj.tune_step])))
basic.append(
RadioSetting(
"band_selected", "Selected band",
RadioSettingValueInteger(0, BANDS - 1,
self.memobj.band_selected)))
basic.append(
RadioSetting(
"memory_display", "Memory display",
RadioSettingValueList(
MEMORY_DISPLAY,
MEMORY_DISPLAY[self.memobj.memory_display])))
basic.append(
RadioSetting("memory_name", "Memory name",
RadioSettingValueBoolean(
self.memobj.memory_name)))
basic.append(
RadioSetting(
"dial_select", "Dial select",
RadioSettingValueList(
DIAL_SELECT, DIAL_SELECT[self.memobj.dial_select])))
basic.append(
RadioSetting(
"power", "RF power",
RadioSettingValueList(POWER, POWER[self.memobj.power])))
basic.append(
RadioSetting("vfo", "Current VFO",
RadioSettingValueList(VFO, VFO[self.memobj.vfo])))
basic.append(
RadioSetting("attenuator", "RF attenuator",
RadioSettingValueBoolean(self.memobj.attenuator)))
basic.append(
RadioSetting("skip_scan", "Skip scan",
RadioSettingValueBoolean(self.memobj.skip_scan)))
# TODO: this needs to be reverse engineered, because the following commented
# code does not seem correct
# basic.append(RadioSetting("mode", "Current mode",
# RadioSettingValueList(OPERATION_MODE,
# OPERATION_MODE[self.memobj.mode])))
basic.append(
RadioSetting(
"vfo_scan", "VFO scan",
RadioSettingValueList(VFO_SCAN,
VFO_SCAN[self.memobj.vfo_scan])))
basic.append(
RadioSetting(
"memory_scan", "Memory scan",
RadioSettingValueList(
MEMORY_SCAN, MEMORY_SCAN[self.memobj.memory_scan])))
basic.append(
RadioSetting(
"tv_channel", "Current TV channel",
RadioSettingValueInteger(0, TV_CHANNELS - 1,
self.memobj.tv_channel)))
# DTMF auto dial
dtmf_autodial.append(
RadioSetting(
"autodial", "Autodial",
RadioSettingValueList(AUTODIAL,
AUTODIAL[self.memobj.autodial])))
dtmf_autodial.append(
RadioSetting(
"dtmf_speed", "Speed",
RadioSettingValueList(DTMF_SPEED,
DTMF_SPEED[self.memobj.dtmf_speed])))
for x in range(DTMF_AUTODIAL_NUM):
rs = RadioSetting(
"dtmf_codes[%d].dtmf_digits" % x, "DTMF autodial: %d" % x,
RadioSettingValueString(
0,
DTMF_DIGITS_NUM,
self.dtmf_icom2chirp(
self.memobj.dtmf_codes[x].dtmf_digits),
autopad=True,
charset="0123456789ABCD*#abcd "))
rs.set_apply_callback(self.apply_dtmf_autodial,
self.memobj.dtmf_codes[x].dtmf_digits)
dtmf_autodial.append(rs)
# expand 1
expand_1.append(
RadioSetting("expand_1", "Expand 1",
RadioSettingValueBoolean(self.memobj.expand_1)))
expand_1.append(
RadioSetting(
"scan_stop_beep", "Scan stop beep",
RadioSettingValueBoolean(self.memobj.scan_stop_beep)))
expand_1.append(
RadioSetting(
"scan_stop_light", "Scan stop light",
RadioSettingValueBoolean(self.memobj.scan_stop_light)))
expand_1.append(
RadioSetting(
"light_postion", "Light position",
RadioSettingValueList(
LIGHT_POSITION,
LIGHT_POSITION[self.memobj.light_position])))
expand_1.append(
RadioSetting(
"light_color", "Light color",
RadioSettingValueList(
LIGHT_COLOR, LIGHT_COLOR[self.memobj.light_color])))
expand_1.append(
RadioSetting(
"band_edge_beep", "Band edge beep",
RadioSettingValueBoolean(self.memobj.band_edge_beep)))
expand_1.append(
RadioSetting(
"auto_power_on", "Auto power on",
RadioSettingValueList(
AUTO_POWER_ON,
AUTO_POWER_ON[self.memobj.auto_power_on])))
expand_1.append(
RadioSetting(
"key_lock", "Key lock",
RadioSettingValueList(KEY_LOCK,
KEY_LOCK[self.memobj.key_lock])))
expand_1.append(
RadioSetting("ptt_lock", "PTT lock",
RadioSettingValueBoolean(self.memobj.ptt_lock)))
expand_1.append(
RadioSetting(
"lcd_contrast", "LCD contrast",
RadioSettingValueList(
LCD_CONTRAST, LCD_CONTRAST[self.memobj.lcd_contrast])))
expand_1.append(
RadioSetting(
"opening_message", "Opening message",
RadioSettingValueBoolean(self.memobj.opening_message)))
expand_1.append(
RadioSetting(
"opening_message_text", "Opening message",
RadioSettingValueString(
0,
OPENING_MESSAGE_LEN,
str(self.memobj.opening_message_text),
autopad=True,
charset=CHARSET)))
# expand 2
expand_2.append(
RadioSetting("expand_2", "Expand 2",
RadioSettingValueBoolean(self.memobj.expand_2)))
expand_2.append(
RadioSetting(
"busy_lockout", "Busy lock out",
RadioSettingValueBoolean(self.memobj.busy_lockout)))
expand_2.append(
RadioSetting(
"timeout_timer", "Timeout timer",
RadioSettingValueList(
TIMEOUT_TIMER,
TIMEOUT_TIMER[self.memobj.timeout_timer])))
expand_2.append(
RadioSetting(
"active_band", "Active band",
RadioSettingValueList(
ACTIVE_BAND, ACTIVE_BAND[self.memobj.active_band])))
expand_2.append(
RadioSetting("fm_narrow", "FM narrow",
RadioSettingValueBoolean(self.memobj.fm_narrow)))
expand_2.append(
RadioSetting("split", "Split",
RadioSettingValueBoolean(self.memobj.split)))
expand_2.append(
RadioSetting(
"morse_code_enable", "Morse code synthesizer",
RadioSettingValueBoolean(self.memobj.morse_code_enable)))
expand_2.append(
RadioSetting(
"morse_code_speed", "Morse code speed",
RadioSettingValueList(
MORSE_CODE_SPEED,
MORSE_CODE_SPEED[self.memobj.morse_code_speed])))
return group
except:
import traceback
LOG.error("Failed to parse settings: %s", traceback.format_exc())
return None
def _get_aprs_general_settings(self):
menu = RadioSettingGroup("aprs_general", "APRS General")
aprs = self._memobj.aprs
val = RadioSettingValueString(0, 6,
str(aprs.my_callsign.callsign).rstrip("\xFF"))
rs = RadioSetting("aprs.my_callsign.callsign", "My Callsign", val)
rs.set_apply_callback(self.apply_callsign, aprs.my_callsign)
menu.append(rs)
val = RadioSettingValueList(
chirp_common.APRS_SSID,
chirp_common.APRS_SSID[aprs.my_callsign.ssid])
rs = RadioSetting("aprs.my_callsign.ssid", "My SSID", val)
menu.append(rs)
val = RadioSettingValueList(self._MY_SYMBOL,
self._MY_SYMBOL[aprs.selected_my_symbol])
rs = RadioSetting("aprs.selected_my_symbol", "My Symbol", val)
menu.append(rs)
symbols = list(chirp_common.APRS_SYMBOLS)
selected = aprs.custom_symbol
if aprs.custom_symbol >= len(chirp_common.APRS_SYMBOLS):
symbols.append("%d" % aprs.custom_symbol)
selected = len(symbols) - 1
val = RadioSettingValueList(symbols, symbols[selected])
rs = RadioSetting("aprs.custom_symbol_text", "User Selected Symbol",
val)
rs.set_apply_callback(self.apply_custom_symbol, aprs)
menu.append(rs)
val = RadioSettingValueList(
chirp_common.APRS_POSITION_COMMENT,
chirp_common.APRS_POSITION_COMMENT[aprs.selected_position_comment])
rs = RadioSetting("aprs.selected_position_comment", "Position Comment",
val)
menu.append(rs)
latitude = self._latlong_to_str(aprs.latitude_sign,
aprs.latitude_degree,
aprs.latitude_minute,
aprs.latitude_second,
True, aprs.aprs_units_position_mmss)
longitude = self._latlong_to_str(aprs.longitude_sign,
aprs.longitude_degree,
aprs.longitude_minute,
aprs.longitude_second,
False, aprs.aprs_units_position_mmss)
# TODO: Rebuild this when aprs_units_position_mmss changes.
# TODO: Rebuild this when latitude/longitude change.
# TODO: Add saved positions p1 - p10 to memory map.
position_str = list(self._POSITIONS)
#position_str[1] = "%s %s" % (latitude, longitude)
#position_str[2] = "%s %s" % (latitude, longitude)
val = RadioSettingValueList(position_str,
position_str[aprs.selected_position])
rs = RadioSetting("aprs.selected_position", "My Position", val)
menu.append(rs)
val = RadioSettingValueString(0, 10, latitude)
rs = RadioSetting("latitude", "Manual Latitude", val)
rs.set_apply_callback(self.apply_lat_long, aprs)
menu.append(rs)
val = RadioSettingValueString(0, 11, longitude)
rs = RadioSetting("longitude", "Manual Longitude", val)
rs.set_apply_callback(self.apply_lat_long, aprs)
menu.append(rs)
val = RadioSettingValueList(self._TIME_SOURCE,
self._TIME_SOURCE[aprs.set_time_manually])
rs = RadioSetting("aprs.set_time_manually", "Time Source", val)
menu.append(rs)
val = RadioSettingValueList(self._TZ, self._TZ[aprs.timezone])
rs = RadioSetting("aprs.timezone", "Timezone", val)
menu.append(rs)
val = RadioSettingValueList(self._SPEED_UNITS,
self._SPEED_UNITS[aprs.aprs_units_speed])
rs = RadioSetting("aprs.aprs_units_speed", "APRS Speed Units", val)
menu.append(rs)
val = RadioSettingValueList(self._SPEED_UNITS,
self._SPEED_UNITS[aprs.gps_units_speed])
rs = RadioSetting("aprs.gps_units_speed", "GPS Speed Units", val)
menu.append(rs)
val = RadioSettingValueList(self._ALT_UNITS,
self._ALT_UNITS[aprs.aprs_units_altitude_ft])
rs = RadioSetting("aprs.aprs_units_altitude_ft", "APRS Altitude Units",
val)
menu.append(rs)
val = RadioSettingValueList(self._ALT_UNITS,
self._ALT_UNITS[aprs.gps_units_altitude_ft])
rs = RadioSetting("aprs.gps_units_altitude_ft", "GPS Altitude Units",
val)
menu.append(rs)
val = RadioSettingValueList(self._POS_UNITS,
self._POS_UNITS[aprs.aprs_units_position_mmss])
rs = RadioSetting("aprs.aprs_units_position_mmss",
"APRS Position Format", val)
menu.append(rs)
val = RadioSettingValueList(self._POS_UNITS,
self._POS_UNITS[aprs.gps_units_position_sss])
rs = RadioSetting("aprs.gps_units_position_sss",
"GPS Position Format", val)
menu.append(rs)
val = RadioSettingValueList(self._DIST_UNITS,
self._DIST_UNITS[aprs.aprs_units_distance_m])
rs = RadioSetting("aprs.aprs_units_distance_m", "APRS Distance Units",
val)
menu.append(rs)
val = RadioSettingValueList(self._WIND_UNITS,
self._WIND_UNITS[aprs.aprs_units_wind_mph])
rs = RadioSetting("aprs.aprs_units_wind_mph", "APRS Wind Speed Units",
val)
menu.append(rs)
val = RadioSettingValueList(self._RAIN_UNITS,
self._RAIN_UNITS[aprs.aprs_units_rain_inch])
rs = RadioSetting("aprs.aprs_units_rain_inch", "APRS Rain Units", val)
menu.append(rs)
val = RadioSettingValueList(self._TEMP_UNITS,
self._TEMP_UNITS[aprs.aprs_units_temperature_f])
rs = RadioSetting("aprs.aprs_units_temperature_f",
"APRS Temperature Units", val)
menu.append(rs)
return menu
def get_settings(self):
_settings = self._memobj.settings
_vfo = self._memobj.vfo
basic = RadioSettingGroup("basic", "Basic Settings")
group = RadioSettings(basic)
rs = RadioSetting("squelch", "Squelch Level",
RadioSettingValueInteger(0, 9, _settings.squelch))
basic.append(rs)
rs = RadioSetting("backlight", "LCD Back Light",
RadioSettingValueList(
BACKLIGHT_LIST,
BACKLIGHT_LIST[_settings.backlight]))
basic.append(rs)
rs = RadioSetting("beep", "Keypad Beep",
RadioSettingValueBoolean(_settings.beep))
basic.append(rs)
rs = RadioSetting("vox", "VOX Level (0=OFF)",
RadioSettingValueInteger(0, 9, _settings.vox))
basic.append(rs)
rs = RadioSetting("dw", "Dual Watch",
RadioSettingValueBoolean(_settings.dw))
basic.append(rs)
rs = RadioSetting("ste", "Squelch Tail Eliminate",
RadioSettingValueList(
STE_LIST, STE_LIST[_settings.ste]))
basic.append(rs)
rs = RadioSetting("save", "Battery Saver",
RadioSettingValueBoolean(_settings.save))
basic.append(rs)
rs = RadioSetting("timeout", "Time Out Timer",
RadioSettingValueList(
TIMEOUT_LIST, TIMEOUT_LIST[_settings.timeout]))
basic.append(rs)
rs = RadioSetting("scanm", "Scan Mode",
RadioSettingValueList(
SCANM_LIST, SCANM_LIST[_settings.scanm]))
basic.append(rs)
rs = RadioSetting("relaym", "Repeater Sound Response",
RadioSettingValueBoolean(_settings.relaym))
basic.append(rs)
rs = RadioSetting("bclo", "Busy Channel Lock Out",
RadioSettingValueBoolean(_settings.bclo))
basic.append(rs)
rs = RadioSetting("pri", "Priority Channel Scanning",
RadioSettingValueBoolean(_settings.pri))
basic.append(rs)
rs = RadioSetting("pri_ch", "Priority Channel",
RadioSettingValueList(
PRI_CH_LIST, PRI_CH_LIST[_settings.pri_ch]))
basic.append(rs)
rs = RadioSetting("ch_flag", "Display Mode",
RadioSettingValueList(
CH_FLAG_LIST, CH_FLAG_LIST[_settings.ch_flag]))
basic.append(rs)
_limit = int(self._memobj.limits.lower_vhf) / 10
if _limit < 115 or _limit > 239:
_limit = 144
rs = RadioSetting("limits.lower_vhf", "VHF Lower Limit (115-239 MHz)",
RadioSettingValueInteger(115, 235, _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
if _limit < 115 or _limit > 239:
_limit = 146
rs = RadioSetting("limits.upper_vhf", "VHF Upper Limit (115-239 MHz)",
RadioSettingValueInteger(115, 235, _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
if _limit < 200 or _limit > 529:
_limit = 420
rs = RadioSetting("limits.lower_uhf", "UHF Lower Limit (200-529 MHz)",
RadioSettingValueInteger(200, 529, _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
if _limit < 200 or _limit > 529:
_limit = 450
rs = RadioSetting("limits.upper_uhf", "UHF Upper Limit (200-529 MHz)",
RadioSettingValueInteger(200, 529, _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)
vfo_preset = RadioSettingGroup("vfo_preset", "VFO Presets")
group.append(vfo_preset)
def convert_bytes_to_freq(bytes):
real_freq = 0
real_freq = bytes
return chirp_common.format_freq(real_freq * 10)
def apply_vhf_freq(setting, obj):
value = chirp_common.parse_freq(str(setting.value)) / 10
obj.vhf.freq = value
val = RadioSettingValueString(
0, 10, convert_bytes_to_freq(int(_vfo.vhf.freq)))
rs = RadioSetting("vfo.vhf.freq",
"VHF RX Frequency (115.00000-236.00000)", val)
rs.set_apply_callback(apply_vhf_freq, _vfo)
vfo_preset.append(rs)
rs = RadioSetting("vfo.vhf.duplex", "Shift Direction",
RadioSettingValueList(
DUPLEX_LIST, DUPLEX_LIST[_vfo.vhf.duplex]))
vfo_preset.append(rs)
def convert_bytes_to_offset(bytes):
real_offset = 0
real_offset = bytes
return chirp_common.format_freq(real_offset * 10000)
def apply_vhf_offset(setting, obj):
value = chirp_common.parse_freq(str(setting.value)) / 10000
obj.vhf.offset = value
val = RadioSettingValueString(
0, 10, convert_bytes_to_offset(int(_vfo.vhf.offset)))
rs = RadioSetting("vfo.vhf.offset", "Offset (0.00-37.995)", val)
rs.set_apply_callback(apply_vhf_offset, _vfo)
vfo_preset.append(rs)
rs = RadioSetting("vfo.vhf.power", "Power Level",
RadioSettingValueList(
POWER_LIST, POWER_LIST[_vfo.vhf.power]))
vfo_preset.append(rs)
rs = RadioSetting("vfo.vhf.bandwidth", "Bandwidth",
RadioSettingValueList(
BANDWIDTH_LIST,
BANDWIDTH_LIST[_vfo.vhf.bandwidth]))
vfo_preset.append(rs)
rs = RadioSetting("vfo.vhf.step", "Step",
RadioSettingValueList(
STEP_LIST, STEP_LIST[_vfo.vhf.step]))
vfo_preset.append(rs)
def apply_uhf_freq(setting, obj):
value = chirp_common.parse_freq(str(setting.value)) / 10
obj.uhf.freq = value
val = RadioSettingValueString(
0, 10, convert_bytes_to_freq(int(_vfo.uhf.freq)))
rs = RadioSetting("vfo.uhf.freq",
"UHF RX Frequency (200.00000-529.00000)", val)
rs.set_apply_callback(apply_uhf_freq, _vfo)
vfo_preset.append(rs)
rs = RadioSetting("vfo.uhf.duplex", "Shift Direction",
RadioSettingValueList(
DUPLEX_LIST, DUPLEX_LIST[_vfo.uhf.duplex]))
vfo_preset.append(rs)
def apply_uhf_offset(setting, obj):
value = chirp_common.parse_freq(str(setting.value)) / 10000
obj.uhf.offset = value
val = RadioSettingValueString(
0, 10, convert_bytes_to_offset(int(_vfo.uhf.offset)))
rs = RadioSetting("vfo.uhf.offset", "Offset (0.00-69.995)", val)
rs.set_apply_callback(apply_uhf_offset, _vfo)
vfo_preset.append(rs)
rs = RadioSetting("vfo.uhf.power", "Power Level",
RadioSettingValueList(
POWER_LIST, POWER_LIST[_vfo.uhf.power]))
vfo_preset.append(rs)
rs = RadioSetting("vfo.uhf.bandwidth", "Bandwidth",
RadioSettingValueList(
BANDWIDTH_LIST,
BANDWIDTH_LIST[_vfo.uhf.bandwidth]))
vfo_preset.append(rs)
rs = RadioSetting("vfo.uhf.step", "Step",
RadioSettingValueList(
STEP_LIST, STEP_LIST[_vfo.uhf.step]))
vfo_preset.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)
return group
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):
_keys = self._memobj.keys
_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 - 1]))
basic.append(rs)
rs = RadioSetting(
"totalert", "TOT Pre-alert",
RadioSettingValueList(TOTALERT_LIST,
TOTALERT_LIST[_settings.totalert]))
basic.append(rs)
rs = RadioSetting("squelch", "Squelch Level",
RadioSettingValueInteger(0, 9, _settings.squelch))
basic.append(rs)
rs = RadioSetting(
"voice", "Voice Annumciation",
RadioSettingValueList(VOICE_LIST, VOICE_LIST[_settings.voice]))
basic.append(rs)
rs = RadioSetting("save", "Battery Saver",
RadioSettingValueBoolean(_settings.save))
basic.append(rs)
rs = RadioSetting("use_scramble", "Scramble",
RadioSettingValueBoolean(_settings.use_scramble))
basic.append(rs)
rs = RadioSetting("use_vox", "VOX",
RadioSettingValueBoolean(_settings.use_vox))
basic.append(rs)
rs = RadioSetting(
"vox", "VOX Gain",
RadioSettingValueList(VOX_LIST, VOX_LIST[_settings.vox]))
basic.append(rs)
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 = RadioSetting("keys.pf1", "PF1 Key Function",
RadioSettingValueList(PF1_CHOICES, PF1_CHOICES[idx]))
rs.set_apply_callback(apply_pf1_listvalue, _keys.pf1)
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):
_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_common1(self):
settings = self._memobj.settings
common1 = RadioSettingGroup('common1', 'Common 1')
common1.append(self._pure_choice_setting('sublcd',
'Sub LCD Display',
SUBLCD,
default='None'))
def apply_clockfmt(setting):
settings.clockfmt = CLOCKFMT.index(str(setting.value))
clockfmt = RadioSetting(
'clockfmt', 'Clock Format',
RadioSettingValueList(CLOCKFMT,
CLOCKFMT[settings.clockfmt]))
clockfmt.set_apply_callback(apply_clockfmt)
common1.append(clockfmt)
def apply_datefmt(setting):
settings.datefmt = DATEFMT.index(str(setting.value))
datefmt = RadioSetting(
'datefmt', 'Date Format',
RadioSettingValueList(DATEFMT,
DATEFMT[settings.datefmt]))
datefmt.set_apply_callback(apply_datefmt)
common1.append(datefmt)
common1.append(self._pure_choice_setting('micsense',
'Mic Sense High',
MICSENSE))
def apply_modereset(setting):
val = int(setting.value)
if val == 0:
val = 0xFFFF
settings.modereset = val
_modereset = int(settings.modereset)
if _modereset == 0xFFFF:
_modereset = 0
modereset = RadioSetting(
'modereset', 'Mode Reset Timer',
RadioSettingValueInteger(0, 300, _modereset))
modereset.set_apply_callback(apply_modereset)
common1.append(modereset)
inverted_flags = [('power_switch_memory', 'Power Switch Memory'),
('scrambler_memory', 'Scrambler Memory'),
('off_hook_decode', 'Off-Hook Decode'),
('ssi', 'Signal Strength Indicator'),
('ignition_sense', 'Ingnition Sense')]
for key, name in inverted_flags:
if self.is_portable and key in ONLY_MOBILE_SETTINGS:
# Skip settings that are not valid for portables
continue
common1.append(self._inverted_flag_setting(key, name))
if not self.is_portable and 'ignition_mode' in ONLY_MOBILE_SETTINGS:
common1.append(self._pure_choice_setting('ignition_mode',
'Ignition Mode',
['Ignition & SW',
'Ignition Only'],
None))
def apply_it(setting):
settings.ignition_time = int(setting.value) / 600
_it = int(settings.ignition_time) * 600
it = RadioSetting(
'it', 'Ignition Timer (s)',
RadioSettingValueInteger(10, 28800, _it))
it.set_apply_callback(apply_it)
if not self.is_portable and 'it' in ONLY_MOBILE_SETTINGS:
common1.append(it)
return common1
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
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.autolk", "Auto Lock Keypad",
RadioSettingValueBoolean(_mem.settings.autolk))
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)
if _mem.settings.almod > 0x02:
val = 0x00
else:
val = _mem.settings.almod
rs = RadioSetting("settings.almod", "Alarm Mode",
RadioSettingValueList(LIST_ALMOD, LIST_ALMOD[val]))
basic.append(rs)
if _mem.settings.tcall > 0x05:
val = 0x00
else:
val = _mem.settings.tcall
rs = RadioSetting("settings.tcall", "Tone Burst Frequency",
RadioSettingValueList(LIST_TCALL, LIST_TCALL[val]))
basic.append(rs)
rs = RadioSetting("settings.ste", "Squelch Tail Eliminate (HT to HT)",
RadioSettingValueBoolean(_mem.settings.ste))
basic.append(rs)
if _mem.settings.rpste > 0x0A:
val = 0x00
else:
val = _mem.settings.rpste
rs = RadioSetting("settings.rpste",
"Squelch Tail Eliminate (repeater)",
RadioSettingValueList(LIST_RPSTE, LIST_RPSTE[val]))
basic.append(rs)
if _mem.settings.rptrl > 0x0A:
val = 0x00
else:
val = _mem.settings.rptrl
rs = RadioSetting(
"settings.rptrl", "STE Repeater Delay",
RadioSettingValueList(LIST_STEDELAY, LIST_STEDELAY[val]))
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)
# 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, 8, _filter(_msg.line1))
val.set_mutable(False)
rs = RadioSetting("firmware_msg.line1", "Firmware Message 1", val)
other.append(rs)
val = RadioSettingValueString(0, 8, _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, 8, _filter(_msg.line1))
val.set_mutable(False)
rs = RadioSetting("sixpoweron_msg.line1", "6+Power-On Message 1", val)
other.append(rs)
val = RadioSettingValueString(0, 8, _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)
lower = 136
upper = 174
rs = RadioSetting(
"limits.vhf.lower", "VHF Lower Limit (MHz)",
RadioSettingValueInteger(lower, upper, _mem.limits.vhf.lower))
other.append(rs)
rs = RadioSetting(
"limits.vhf.upper", "VHF Upper Limit (MHz)",
RadioSettingValueInteger(lower, upper, _mem.limits.vhf.upper))
other.append(rs)
lower = 400
upper = 520
rs = RadioSetting(
"limits.uhf.lower", "UHF Lower Limit (MHz)",
RadioSettingValueInteger(lower, upper, _mem.limits.uhf.lower))
other.append(rs)
rs = RadioSetting(
"limits.uhf.upper", "UHF Upper Limit (MHz)",
RadioSettingValueInteger(lower, upper, _mem.limits.uhf.upper))
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.workmode", "VFO/MR Mode",
RadioSettingValueList(LIST_WORKMODE,
LIST_WORKMODE[_mem.settings.workmode]))
work.append(rs)
rs = RadioSetting("settings.keylock", "Keypad Lock",
RadioSettingValueBoolean(_mem.settings.keylock))
work.append(rs)
rs = RadioSetting(
"wmchannel.mrcha", "MR A Channel",
RadioSettingValueInteger(0, 127, _mem.wmchannel.mrcha))
work.append(rs)
rs = RadioSetting(
"wmchannel.mrchb", "MR B Channel",
RadioSettingValueInteger(0, 127, _mem.wmchannel.mrchb))
work.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):
_vhf_lower = int(_mem.limits.vhf.lower)
_vhf_upper = int(_mem.limits.vhf.upper)
_uhf_lower = int(_mem.limits.uhf.lower)
_uhf_upper = int(_mem.limits.uhf.upper)
value = chirp_common.parse_freq(value)
msg = ("Can't be less than %i.0000")
if value > 99000000 and value < _vhf_lower * 1000000:
raise InvalidValueError(msg % _vhf_lower)
msg = ("Can't be between %i.9975-%i.0000")
if _vhf_upper * 1000000 <= value and value < _uhf_lower * 1000000:
raise InvalidValueError(msg % (_vhf_upper - 1, _uhf_lower))
msg = ("Can't be greater than %i.9975")
if value > 99000000 and value >= _uhf_upper * 1000000:
raise InvalidValueError(msg % (_uhf_upper - 1))
return chirp_common.format_freq(value)
def apply_freq(setting, obj):
value = chirp_common.parse_freq(str(setting.value)) / 10
for i in range(7, -1, -1):
obj.freq[i] = value % 10
value /= 10
val1a = RadioSettingValueString(0, 10,
convert_bytes_to_freq(_mem.vfo.a.freq))
val1a.set_validate_callback(my_validate)
rs = RadioSetting("vfo.a.freq", "VFO A Frequency", val1a)
rs.set_apply_callback(apply_freq, _mem.vfo.a)
work.append(rs)
val1b = RadioSettingValueString(0, 10,
convert_bytes_to_freq(_mem.vfo.b.freq))
val1b.set_validate_callback(my_validate)
rs = RadioSetting("vfo.b.freq", "VFO B Frequency", val1b)
rs.set_apply_callback(apply_freq, _mem.vfo.b)
work.append(rs)
rs = RadioSetting(
"vfo.a.sftd", "VFO A Shift",
RadioSettingValueList(LIST_SHIFTD, LIST_SHIFTD[_mem.vfo.a.sftd]))
work.append(rs)
rs = RadioSetting(
"vfo.b.sftd", "VFO B Shift",
RadioSettingValueList(LIST_SHIFTD, LIST_SHIFTD[_mem.vfo.b.sftd]))
work.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 * 1000)
def apply_offset(setting, obj):
value = chirp_common.parse_freq(str(setting.value)) / 1000
for i in range(5, -1, -1):
obj.offset[i] = value % 10
value /= 10
val1a = RadioSettingValueString(
0, 10, convert_bytes_to_offset(_mem.vfo.a.offset))
rs = RadioSetting("vfo.a.offset", "VFO A Offset", val1a)
rs.set_apply_callback(apply_offset, _mem.vfo.a)
work.append(rs)
val1b = RadioSettingValueString(
0, 10, convert_bytes_to_offset(_mem.vfo.b.offset))
rs = RadioSetting("vfo.b.offset", "VFO B Offset", val1b)
rs.set_apply_callback(apply_offset, _mem.vfo.b)
work.append(rs)
rs = RadioSetting(
"vfo.a.txpower", "VFO A Power",
RadioSettingValueList(LIST_TXPOWER,
LIST_TXPOWER[_mem.vfo.a.txpower]))
work.append(rs)
rs = RadioSetting(
"vfo.b.txpower", "VFO B Power",
RadioSettingValueList(LIST_TXPOWER,
LIST_TXPOWER[_mem.vfo.b.txpower]))
work.append(rs)
rs = RadioSetting(
"vfo.a.widenarr", "VFO A Bandwidth",
RadioSettingValueList(LIST_BANDWIDTH,
LIST_BANDWIDTH[_mem.vfo.a.widenarr]))
work.append(rs)
rs = RadioSetting(
"vfo.b.widenarr", "VFO B Bandwidth",
RadioSettingValueList(LIST_BANDWIDTH,
LIST_BANDWIDTH[_mem.vfo.b.widenarr]))
work.append(rs)
rs = RadioSetting(
"vfo.a.scode", "VFO A S-CODE",
RadioSettingValueList(LIST_SCODE, LIST_SCODE[_mem.vfo.a.scode]))
work.append(rs)
rs = RadioSetting(
"vfo.b.scode", "VFO B S-CODE",
RadioSettingValueList(LIST_SCODE, LIST_SCODE[_mem.vfo.b.scode]))
work.append(rs)
rs = RadioSetting(
"vfo.a.step", "VFO A Tuning Step",
RadioSettingValueList(LIST_STEP, LIST_STEP[_mem.vfo.a.step]))
work.append(rs)
rs = RadioSetting(
"vfo.b.step", "VFO B Tuning Step",
RadioSettingValueList(LIST_STEP, LIST_STEP[_mem.vfo.b.step]))
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.sql%i" % (index)
_obj = self._memobj.squelch
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
def get_settings(self):
"""Translate the bit in the mem_struct into settings in the UI"""
# Define mem struct write-back shortcuts
_sets = self._memobj.settings
_vfoa = self._memobj.upper.vfoa
_vfob = self._memobj.lower.vfob
_lims = self._memobj.hello_lims
_codes = self._memobj.codes
_dtmf = self._memobj.dtmf_tab
basic = RadioSettingGroup("basic", "Basic Settings")
a_band = RadioSettingGroup("a_band", "VFO A-Upper Settings")
b_band = RadioSettingGroup("b_band", "VFO B-Lower Settings")
codes = RadioSettingGroup("codes", "Codes & DTMF Groups")
lims = RadioSettingGroup("lims", "PowerOn & Freq Limits")
group = RadioSettings(basic, a_band, b_band, lims, codes)
# Basic Settings
bnd_mode = RadioSetting(
"settings.init_bank", "TDR Band Default",
RadioSettingValueList(LIST_TDR_DEF, LIST_TDR_DEF[_sets.init_bank]))
basic.append(bnd_mode)
volume = RadioSetting("settings.volume", "Volume",
RadioSettingValueInteger(0, 20, _sets.volume))
basic.append(volume)
val = _vfoa.bpower # 2bits values 0,1,2= Low, Mid, High
rx = RadioSettingValueList(LIST_BPOWER, LIST_BPOWER[val])
powera = RadioSetting("upper.vfoa.bpower", "Power (Upper)", rx)
basic.append(powera)
val = _vfob.bpower
rx = RadioSettingValueList(LIST_BPOWER, LIST_BPOWER[val])
powerb = RadioSetting("lower.vfob.bpower", "Power (Lower)", rx)
basic.append(powerb)
def my_word2raw(setting, obj, atrb, mlt=10):
"""Callback function to convert UI floating value to u16 int"""
if str(setting.value) == "Off":
frq = 0x0FFFF
else:
frq = int(float(str(setting.value)) * float(mlt))
if frq == 0:
frq = 0xFFFF
setattr(obj, atrb, frq)
return
def my_adjraw(setting, obj, atrb, fix):
"""Callback: add or subtract fix from value."""
vx = int(str(setting.value))
value = vx + int(fix)
if value < 0:
value = 0
if atrb == "frq_chn_mode" and int(str(setting.value)) == 2:
value = vx * 2 # Special handling for frq_chn_mode
setattr(obj, atrb, value)
return
def my_dbl2raw(setting, obj, atrb, flg=1):
"""Callback: convert from freq 146.7600 to 14760000 U32."""
value = chirp_common.parse_freq(str(setting.value)) / 10
# flg=1 means 0 becomes ff, else leave as possible 0
if flg == 1 and value == 0:
value = 0xFFFFFFFF
setattr(obj, atrb, value)
return
def my_val_list(setting, obj, atrb):
"""Callback:from ValueList with non-sequential, actual values."""
value = int(str(setting.value)) # Get the integer value
if atrb == "tot":
value = int(value / 30) # 30 second increments
setattr(obj, atrb, value)
return
def my_spcl(setting, obj, atrb):
"""Callback: Special handling based on atrb."""
if atrb == "frq_chn_mode":
idx = LIST_VFOMODE.index(str(setting.value)) # Returns 0 or 1
value = idx * 2 # Set bit 1
setattr(obj, atrb, value)
return
def my_tone_strn(obj, is_atr, pol_atr, tone_atr):
"""Generate the CTCS/DCS tone code string."""
vx = int(getattr(obj, tone_atr))
if vx == 16383 or vx == 0:
return "Off" # 16383 is all bits set
if getattr(obj, is_atr) == 0: # Simple CTCSS code
tstr = str(vx / 10.0)
else: # DCS
if getattr(obj, pol_atr) == 0:
tstr = "D{:03x}R".format(vx)
else:
tstr = "D{:03x}N".format(vx)
return tstr
def my_set_tone(setting, obj, is_atr, pol_atr, tone_atr):
"""Callback- create the tone setting from string code."""
sx = str(setting.value) # '131.8' or 'D231N' or 'Off'
if sx == "Off":
isx = 1
polx = 1
tonx = 0x3FFF
elif sx[0] == "D": # DCS
isx = 1
if sx[4] == "N":
polx = 1
else:
polx = 0
tonx = int(sx[1:4], 16)
else: # CTCSS
isx = 0
polx = 0
tonx = int(float(sx) * 10.0)
setattr(obj, is_atr, isx)
setattr(obj, pol_atr, polx)
setattr(obj, tone_atr, tonx)
return
val = _sets.fm_freq / 10.0
if val == 0:
val = 88.9 # 0 is not valid
rx = RadioSettingValueFloat(65, 108.0, val, 0.1, 1)
rs = RadioSetting("settings.fm_freq", "FM Broadcast Freq (MHz)", rx)
rs.set_apply_callback(my_word2raw, _sets, "fm_freq")
basic.append(rs)
wtled = RadioSetting(
"settings.wtled", "Standby LED Color",
RadioSettingValueList(LIST_COLOR, LIST_COLOR[_sets.wtled]))
basic.append(wtled)
rxled = RadioSetting(
"settings.rxled", "RX LED Color",
RadioSettingValueList(LIST_COLOR, LIST_COLOR[_sets.rxled]))
basic.append(rxled)
txled = RadioSetting(
"settings.txled", "TX LED Color",
RadioSettingValueList(LIST_COLOR, LIST_COLOR[_sets.txled]))
basic.append(txled)
ledsw = RadioSetting(
"settings.ledsw", "Back light mode",
RadioSettingValueList(LIST_LEDSW, LIST_LEDSW[_sets.ledsw]))
basic.append(ledsw)
beep = RadioSetting("settings.beep", "Beep",
RadioSettingValueBoolean(bool(_sets.beep)))
basic.append(beep)
ring = RadioSetting(
"settings.ring", "Ring",
RadioSettingValueList(LIST_RING, LIST_RING[_sets.ring]))
basic.append(ring)
bcl = RadioSetting("settings.bcl", "Busy channel lockout",
RadioSettingValueBoolean(bool(_sets.bcl)))
basic.append(bcl)
if _vfoa.sql == 0xFF:
val = 0x04
else:
val = _vfoa.sql
sqla = RadioSetting("upper.vfoa.sql", "Squelch (Upper)",
RadioSettingValueInteger(0, 9, val))
basic.append(sqla)
if _vfob.sql == 0xFF:
val = 0x04
else:
val = _vfob.sql
sqlb = RadioSetting("lower.vfob.sql", "Squelch (Lower)",
RadioSettingValueInteger(0, 9, val))
basic.append(sqlb)
tmp = str(int(_sets.tot) * 30) # 30 sec step counter
rs = RadioSetting("settings.tot", "Transmit Timeout (Secs)",
RadioSettingValueList(LIST_TIMEOUT, tmp))
rs.set_apply_callback(my_val_list, _sets, "tot")
basic.append(rs)
tmp = str(int(_sets.sig_freq))
rs = RadioSetting("settings.sig_freq", "Single Signaling Tone (Htz)",
RadioSettingValueList(LIST_SSF, tmp))
rs.set_apply_callback(my_val_list, _sets, "sig_freq")
basic.append(rs)
tmp = str(int(_sets.dtmf_txms))
rs = RadioSetting("settings.dtmf_txms", "DTMF Tx Duration (mSecs)",
RadioSettingValueList(LIST_DTMFTX, tmp))
rs.set_apply_callback(my_val_list, _sets, "dtmf_txms")
basic.append(rs)
rs = RadioSetting("settings.rptr_mode", "Repeater Mode",
RadioSettingValueBoolean(bool(_sets.rptr_mode)))
basic.append(rs)
# UPPER BAND SETTINGS
# Freq Mode, convert bit 1 state to index pointer
val = _vfoa.frq_chn_mode / 2
rx = RadioSettingValueList(LIST_VFOMODE, LIST_VFOMODE[val])
rs = RadioSetting("upper.vfoa.frq_chn_mode", "Default Mode", rx)
rs.set_apply_callback(my_spcl, _vfoa, "frq_chn_mode")
a_band.append(rs)
val = _vfoa.chan_num + 1 # Add 1 for 1-128 displayed
rs = RadioSetting("upper.vfoa.chan_num", "Initial Chan",
RadioSettingValueInteger(1, 128, val))
rs.set_apply_callback(my_adjraw, _vfoa, "chan_num", -1)
a_band.append(rs)
val = _vfoa.rxfreq / 100000.0
if (val < 136.0 or val > 176.0):
val = 146.520 # 2m calling
rs = RadioSetting("upper.vfoa.rxfreq ", "Default Recv Freq (MHz)",
RadioSettingValueFloat(136.0, 176.0, val, 0.001, 5))
rs.set_apply_callback(my_dbl2raw, _vfoa, "rxfreq")
a_band.append(rs)
tmp = my_tone_strn(_vfoa, "is_rxdigtone", "rxdtcs_pol", "rx_tone")
rs = RadioSetting("rx_tone", "Default Recv CTCSS (Htz)",
RadioSettingValueList(LIST_CTCSS, tmp))
rs.set_apply_callback(my_set_tone, _vfoa, "is_rxdigtone", "rxdtcs_pol",
"rx_tone")
a_band.append(rs)
rx = RadioSettingValueList(LIST_RECVMODE, LIST_RECVMODE[_vfoa.rx_mode])
rs = RadioSetting("upper.vfoa.rx_mode", "Default Recv Mode", rx)
a_band.append(rs)
tmp = my_tone_strn(_vfoa, "is_txdigtone", "txdtcs_pol", "tx_tone")
rs = RadioSetting("tx_tone", "Default Xmit CTCSS (Htz)",
RadioSettingValueList(LIST_CTCSS, tmp))
rs.set_apply_callback(my_set_tone, _vfoa, "is_txdigtone", "txdtcs_pol",
"tx_tone")
a_band.append(rs)
rs = RadioSetting(
"upper.vfoa.launch_sig", "Launch Signaling",
RadioSettingValueList(LIST_SIGNAL, LIST_SIGNAL[_vfoa.launch_sig]))
a_band.append(rs)
rx = RadioSettingValueList(LIST_SIGNAL, LIST_SIGNAL[_vfoa.tx_end_sig])
rs = RadioSetting("upper.vfoa.tx_end_sig", "Xmit End Signaling", rx)
a_band.append(rs)
rx = RadioSettingValueList(LIST_BW, LIST_BW[_vfoa.fm_bw])
rs = RadioSetting("upper.vfoa.fm_bw", "Wide/Narrow Band", rx)
a_band.append(rs)
rx = RadioSettingValueBoolean(bool(_vfoa.cmp_nder))
rs = RadioSetting("upper.vfoa.cmp_nder", "Compandor", rx)
a_band.append(rs)
rs = RadioSetting("upper.vfoa.scrm_blr", "Scrambler",
RadioSettingValueBoolean(bool(_vfoa.scrm_blr)))
a_band.append(rs)
rx = RadioSettingValueList(LIST_SHIFT, LIST_SHIFT[_vfoa.shift])
rs = RadioSetting("upper.vfoa.shift", "Xmit Shift", rx)
a_band.append(rs)
val = _vfoa.offset / 100000.0
rs = RadioSetting("upper.vfoa.offset", "Xmit Offset (MHz)",
RadioSettingValueFloat(0, 100.0, val, 0.001, 3))
# Allow zero value
rs.set_apply_callback(my_dbl2raw, _vfoa, "offset", 0)
a_band.append(rs)
tmp = str(_vfoa.step / 100.0)
rs = RadioSetting("step", "Freq step (KHz)",
RadioSettingValueList(LIST_STEPS, tmp))
rs.set_apply_callback(my_word2raw, _vfoa, "step", 100)
a_band.append(rs)
# LOWER BAND SETTINGS
val = _vfob.frq_chn_mode / 2
rx = RadioSettingValueList(LIST_VFOMODE, LIST_VFOMODE[val])
rs = RadioSetting("lower.vfob.frq_chn_mode", "Default Mode", rx)
rs.set_apply_callback(my_spcl, _vfob, "frq_chn_mode")
b_band.append(rs)
val = _vfob.chan_num + 1
rs = RadioSetting("lower.vfob.chan_num", "Initial Chan",
RadioSettingValueInteger(0, 127, val))
rs.set_apply_callback(my_adjraw, _vfob, "chan_num", -1)
b_band.append(rs)
val = _vfob.rxfreq / 100000.0
if (val < 400.0 or val > 480.0):
val = 446.0 # UHF calling
rs = RadioSetting("lower.vfob.rxfreq ", "Default Recv Freq (MHz)",
RadioSettingValueFloat(400.0, 480.0, val, 0.001, 5))
rs.set_apply_callback(my_dbl2raw, _vfob, "rxfreq")
b_band.append(rs)
tmp = my_tone_strn(_vfob, "is_rxdigtone", "rxdtcs_pol", "rx_tone")
rs = RadioSetting("rx_tone", "Default Recv CTCSS (Htz)",
RadioSettingValueList(LIST_CTCSS, tmp))
rs.set_apply_callback(my_set_tone, _vfob, "is_rxdigtone", "rxdtcs_pol",
"rx_tone")
b_band.append(rs)
rx = RadioSettingValueList(LIST_RECVMODE, LIST_RECVMODE[_vfob.rx_mode])
rs = RadioSetting("lower.vfob.rx_mode", "Default Recv Mode", rx)
b_band.append(rs)
tmp = my_tone_strn(_vfob, "is_txdigtone", "txdtcs_pol", "tx_tone")
rs = RadioSetting("tx_tone", "Default Xmit CTCSS (Htz)",
RadioSettingValueList(LIST_CTCSS, tmp))
rs.set_apply_callback(my_set_tone, _vfob, "is_txdigtone", "txdtcs_pol",
"tx_tone")
b_band.append(rs)
rx = RadioSettingValueList(LIST_SIGNAL, LIST_SIGNAL[_vfob.launch_sig])
rs = RadioSetting("lower.vfob.launch_sig", "Launch Signaling", rx)
b_band.append(rs)
rx = RadioSettingValueList(LIST_SIGNAL, LIST_SIGNAL[_vfob.tx_end_sig])
rs = RadioSetting("lower.vfob.tx_end_sig", "Xmit End Signaling", rx)
b_band.append(rs)
rx = RadioSettingValueList(LIST_BW, LIST_BW[_vfob.fm_bw])
rs = RadioSetting("lower.vfob.fm_bw", "Wide/Narrow Band", rx)
b_band.append(rs)
rs = RadioSetting("lower.vfob.cmp_nder", "Compandor",
RadioSettingValueBoolean(bool(_vfob.cmp_nder)))
b_band.append(rs)
rs = RadioSetting("lower.vfob.scrm_blr", "Scrambler",
RadioSettingValueBoolean(bool(_vfob.scrm_blr)))
b_band.append(rs)
rx = RadioSettingValueList(LIST_SHIFT, LIST_SHIFT[_vfob.shift])
rs = RadioSetting("lower.vfob.shift", "Xmit Shift", rx)
b_band.append(rs)
val = _vfob.offset / 100000.0
rs = RadioSetting("lower.vfob.offset", "Xmit Offset (MHz)",
RadioSettingValueFloat(0, 100.0, val, 0.001, 3))
rs.set_apply_callback(my_dbl2raw, _vfob, "offset", 0)
b_band.append(rs)
tmp = str(_vfob.step / 100.0)
rs = RadioSetting("step", "Freq step (KHz)",
RadioSettingValueList(LIST_STEPS, tmp))
rs.set_apply_callback(my_word2raw, _vfob, "step", 100)
b_band.append(rs)
# PowerOn & Freq Limits Settings
def chars2str(cary, knt):
"""Convert raw memory char array to a string: NOT a callback."""
stx = ""
for char in cary[:knt]:
stx += chr(char)
return stx
def my_str2ary(setting, obj, atrba, atrbc):
"""Callback: convert 7-char string to char array with count."""
ary = ""
knt = 7
for j in range(6, -1, -1): # Strip trailing spaces
if str(setting.value)[j] == "" or str(setting.value)[j] == " ":
knt = knt - 1
else:
break
for j in range(0, 7, 1):
if j < knt: ary += str(setting.value)[j]
else: ary += chr(0xFF)
setattr(obj, atrba, ary)
setattr(obj, atrbc, knt)
return
tmp = chars2str(_lims.hello1, _lims.hello1_cnt)
rs = RadioSetting("hello_lims.hello1", "Power-On Message 1",
RadioSettingValueString(0, 7, tmp))
rs.set_apply_callback(my_str2ary, _lims, "hello1", "hello1_cnt")
lims.append(rs)
tmp = chars2str(_lims.hello2, _lims.hello2_cnt)
rs = RadioSetting("hello_lims.hello2", "Power-On Message 2",
RadioSettingValueString(0, 7, tmp))
rs.set_apply_callback(my_str2ary, _lims, "hello2", "hello2_cnt")
lims.append(rs)
# VALID_BANDS = [(136000000, 176000000),400000000, 480000000)]
lval = _lims.vhf_low / 100000.0
uval = _lims.vhf_high / 100000.0
if lval >= uval:
lval = 144.0
uval = 158.0
rs = RadioSetting("hello_lims.vhf_low", "Lower VHF Band Limit (MHz)",
RadioSettingValueFloat(136.0, 176.0, lval, 0.001, 3))
rs.set_apply_callback(my_dbl2raw, _lims, "vhf_low")
lims.append(rs)
rs = RadioSetting("hello_lims.vhf_high", "Upper VHF Band Limit (MHz)",
RadioSettingValueFloat(136.0, 176.0, uval, 0.001, 3))
rs.set_apply_callback(my_dbl2raw, _lims, "vhf_high")
lims.append(rs)
lval = _lims.uhf_low / 100000.0
uval = _lims.uhf_high / 100000.0
if lval >= uval:
lval = 420.0
uval = 470.0
rs = RadioSetting("hello_lims.uhf_low", "Lower UHF Band Limit (MHz)",
RadioSettingValueFloat(400.0, 480.0, lval, 0.001, 3))
rs.set_apply_callback(my_dbl2raw, _lims, "uhf_low")
lims.append(rs)
rs = RadioSetting("hello_lims.uhf_high", "Upper UHF Band Limit (MHz)",
RadioSettingValueFloat(400.0, 480.0, uval, 0.001, 3))
rs.set_apply_callback(my_dbl2raw, _lims, "uhf_high")
lims.append(rs)
# Codes and DTMF Groups Settings
def make_dtmf(ary, knt):
"""Generate the DTMF code 1-8, NOT a callback."""
tmp = ""
if knt > 0 and knt != 0xff:
for val in ary[:knt]:
if val > 0 and val <= 9:
tmp += chr(val + 48)
elif val == 0x0a:
tmp += "0"
elif val == 0x0d:
tmp += "A"
elif val == 0x0e:
tmp += "B"
elif val == 0x0f:
tmp += "C"
elif val == 0x00:
tmp += "D"
elif val == 0x0b:
tmp += "*"
elif val == 0x0c:
tmp += "#"
else:
msg = ("Invalid Character. Must be: 0-9,A,B,C,D,*,#")
raise InvalidValueError(msg)
return tmp
def my_dtmf2raw(setting, obj, atrba, atrbc, syz=7):
"""Callback: DTMF Code; sends 5 or 7-byte string."""
draw = []
knt = syz
for j in range(syz - 1, -1, -1): # Strip trailing spaces
if str(setting.value)[j] == "" or str(setting.value)[j] == " ":
knt = knt - 1
else:
break
for j in range(0, syz):
bx = str(setting.value)[j]
obx = ord(bx)
dig = 0x0ff
if j < knt and knt > 0: # (Else) is pads
if bx == "0":
dig = 0x0a
elif bx == "A":
dig = 0x0d
elif bx == "B":
dig = 0x0e
elif bx == "C":
dig = 0x0f
elif bx == "D":
dig = 0x00
elif bx == "*":
dig = 0x0b
elif bx == "#":
dig = 0x0c
elif obx >= 49 and obx <= 57:
dig = obx - 48
else:
msg = ("Must be: 0-9,A,B,C,D,*,#")
raise InvalidValueError(msg)
# - End if/elif/else for bx
# - End if J<=knt
draw.append(dig) # Generate string of bytes
# - End for j
setattr(obj, atrba, draw)
setattr(obj, atrbc, knt)
return
tmp = make_dtmf(_codes.native_id_code, _codes.native_id_cnt)
rs = RadioSetting("codes.native_id_code", "Native ID Code",
RadioSettingValueString(0, 7, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes, "native_id_code",
"native_id_cnt", 7)
codes.append(rs)
tmp = make_dtmf(_codes.master_id_code, _codes.master_id_cnt)
rs = RadioSetting("codes.master_id_code", "Master Control ID Code",
RadioSettingValueString(0, 7, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes, "master_id_code",
"master_id_cnt", 7)
codes.append(rs)
tmp = make_dtmf(_codes.alarm_code, _codes.alarm_cnt)
rs = RadioSetting("codes.alarm_code", "Alarm Code",
RadioSettingValueString(0, 5, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes, "alarm_code", "alarm_cnt",
5)
codes.append(rs)
tmp = make_dtmf(_codes.id_disp_code, _codes.id_disp_cnt)
rs = RadioSetting("codes.id_disp_code", "Identify Display Code",
RadioSettingValueString(0, 5, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes, "id_disp_code",
"id_disp_cnt", 5)
codes.append(rs)
tmp = make_dtmf(_codes.revive_code, _codes.revive_cnt)
rs = RadioSetting("codes.revive_code", "Revive Code",
RadioSettingValueString(0, 5, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes, "revive_code", "revive_cnt",
5)
codes.append(rs)
tmp = make_dtmf(_codes.stun_code, _codes.stun_cnt)
rs = RadioSetting("codes.stun_code", "Remote Stun Code",
RadioSettingValueString(0, 5, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes, "stun_code", "stun_cnt", 5)
codes.append(rs)
tmp = make_dtmf(_codes.kill_code, _codes.kill_cnt)
rs = RadioSetting("codes.kill_code", "Remote KILL Code",
RadioSettingValueString(0, 5, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes, "kill_code", "kill_cnt", 5)
codes.append(rs)
tmp = make_dtmf(_codes.monitor_code, _codes.monitor_cnt)
rs = RadioSetting("codes.monitor_code", "Monitor Code",
RadioSettingValueString(0, 5, tmp))
rs.set_apply_callback(my_dtmf2raw, _codes, "monitor_code",
"monitor_cnt", 5)
codes.append(rs)
val = _codes.state_now
if val > 2:
val = 0
rx = RadioSettingValueList(LIST_STATE, LIST_STATE[val])
rs = RadioSetting("codes.state_now", "Current State", rx)
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf1, _dtmf.dtmf1_cnt)
rs = RadioSetting("dtmf_tab.dtmf1", "DTMF1 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf1", "dtmf1_cnt")
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf2, _dtmf.dtmf2_cnt)
rs = RadioSetting("dtmf_tab.dtmf2", "DTMF2 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf2", "dtmf2_cnt")
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf3, _dtmf.dtmf3_cnt)
rs = RadioSetting("dtmf_tab.dtmf3", "DTMF3 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf3", "dtmf3_cnt")
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf4, _dtmf.dtmf4_cnt)
rs = RadioSetting("dtmf_tab.dtmf4", "DTMF4 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf4", "dtmf4_cnt")
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf5, _dtmf.dtmf5_cnt)
rs = RadioSetting("dtmf_tab.dtmf5", "DTMF5 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf5", "dtmf5_cnt")
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf6, _dtmf.dtmf6_cnt)
rs = RadioSetting("dtmf_tab.dtmf6", "DTMF6 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf6", "dtmf6_cnt")
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf7, _dtmf.dtmf7_cnt)
rs = RadioSetting("dtmf_tab.dtmf7", "DTMF7 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf7", "dtmf7_cnt")
codes.append(rs)
dtm = make_dtmf(_dtmf.dtmf8, _dtmf.dtmf8_cnt)
rs = RadioSetting("dtmf_tab.dtmf8", "DTMF8 String",
RadioSettingValueString(0, 7, dtm))
rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf8", "dtmf8_cnt")
codes.append(rs)
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):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic Settings")
fm = RadioSettingGroup("fm", "FM Radio")
adv = RadioSettingGroup("adv", "Advanced Settings")
group = RadioSettings(basic, fm, adv)
# ## Basic Settings
rs = RadioSetting("tx_pwr", "TX Power",
RadioSettingValueList(
POWER_LIST, POWER_LIST[_settings.tx_pwr]))
basic.append(rs)
rs = RadioSetting("channel", "Active Channel",
RadioSettingValueInteger(1, 20, _settings.channel))
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)
# volume validation, as the OEM software set 0xFF on write
_volume = _settings.volume
if _volume > 7:
_volume = 7
rs = RadioSetting("volume", "Volume Level",
RadioSettingValueInteger(0, 7, _volume))
basic.append(rs)
rs = RadioSetting("scantype", "Scan Type",
RadioSettingValueList(SCAN_TYPE_LIST, SCAN_TYPE_LIST[
_settings.scantype]))
basic.append(rs)
rs = RadioSetting("timeout", "Time Out Timer (seconds)",
RadioSettingValueList(
TOT_LIST, TOT_LIST[_settings.timeout]))
basic.append(rs)
rs = RadioSetting("voice", "Voice Prompt",
RadioSettingValueList(
LANGUAGE_LIST, LANGUAGE_LIST[_settings.voice]))
basic.append(rs)
rs = RadioSetting("alarm", "Alarm Time",
RadioSettingValueList(
TIMER_LIST, TIMER_LIST[_settings.alarm]))
basic.append(rs)
rs = RadioSetting("backlight", "Backlight",
RadioSettingValueList(
BACKLIGHT_LIST,
BACKLIGHT_LIST[_settings.backlight]))
basic.append(rs)
rs = RadioSetting("blo", "Busy Lockout",
RadioSettingValueBoolean(_settings.blo))
basic.append(rs)
rs = RadioSetting("ste", "Squelch Tail Eliminate",
RadioSettingValueBoolean(_settings.ste))
basic.append(rs)
rs = RadioSetting("batsave", "Battery Save",
RadioSettingValueBoolean(_settings.batsave))
basic.append(rs)
rs = RadioSetting("lock", "Key Lock",
RadioSettingValueBoolean(_settings.lock))
basic.append(rs)
rs = RadioSetting("beep", "Key Beep",
RadioSettingValueBoolean(_settings.beep))
basic.append(rs)
# ## FM Settings
rs = RadioSetting("fm_funct", "FM Function",
RadioSettingValueBoolean(_settings.fm_funct))
fm.append(rs)
rs = RadioSetting("fmrange", "FM Range",
RadioSettingValueList(
FM_RANGE_LIST, FM_RANGE_LIST[_settings.fmrange]))
fm.append(rs)
# callbacks for the FM VFO
def apply_fm_freq(setting, obj):
setattr(obj, setting.get_name(), int(setting.value.
get_value() * 10) - 650)
_fm_vfo = int(_settings.fm_vfo) * 0.1 + 65
rs = RadioSetting("fm_vfo", "FM Station",
RadioSettingValueFloat(65, 108, _fm_vfo))
rs.set_apply_callback(apply_fm_freq, _settings)
fm.append(rs)
# ## Advanced
def apply_limit(setting, obj):
setattr(obj, setting.get_name(), int(setting.value) * 10)
rs = RadioSetting("vhfl", "VHF Low Limit",
RadioSettingValueInteger(130, 174, int(
_settings.vhfl) / 10))
rs.set_apply_callback(apply_limit, _settings)
adv.append(rs)
rs = RadioSetting("vhfh", "VHF High Limit",
RadioSettingValueInteger(130, 174, int(
_settings.vhfh) / 10))
rs.set_apply_callback(apply_limit, _settings)
adv.append(rs)
rs = RadioSetting("uhfl", "UHF Low Limit",
RadioSettingValueInteger(400, 520, int(
_settings.uhfl) / 10))
rs.set_apply_callback(apply_limit, _settings)
adv.append(rs)
rs = RadioSetting("uhfh", "UHF High Limit",
RadioSettingValueInteger(400, 520, int(
_settings.uhfh) / 10))
rs.set_apply_callback(apply_limit, _settings)
adv.append(rs)
rs = RadioSetting("relaym", "Relay Mode",
RadioSettingValueList(RELAY_MODE_LIST,
RELAY_MODE_LIST[_settings.relaym]))
adv.append(rs)
return group
