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_memory(self, number):
_mem = self._memobj.memory[number - 1]
_nam = self._memobj.chan_names[number - 1]
def _is_empty():
for i in range(0, 4):
if _mem.rx_freq[i].get_raw() != "\xFF":
return False
return True
mem = chirp_common.Memory()
mem.number = number
if _is_empty():
mem.empty = True
return mem
mem.freq = int(_mem.rx_freq) * 10
if int(_mem.rx_freq) == int(_mem.tx_freq):
mem.duplex = ""
mem.offset = 0
else:
mem.duplex = int(_mem.rx_freq) > int(_mem.tx_freq) and "-" or "+"
mem.offset = abs(int(_mem.rx_freq) - int(_mem.tx_freq)) * 10
mem.mode = _mem.w_n and "FM" or "NFM"
self._get_tone(_mem, mem)
mem.power = POWER_LEVELS[_mem.power]
mem.extra = RadioSettingGroup("Extra", "extra")
rs = RadioSetting(
"lout", "Lock out",
RadioSettingValueList(OFF_ON_LIST, OFF_ON_LIST[_mem.lout]))
mem.extra.append(rs)
rs = RadioSetting(
"busy_loc", "Busy lock",
RadioSettingValueList(BUSYLOCK_LIST, BUSYLOCK_LIST[_mem.busy_loc]))
mem.extra.append(rs)
rs = RadioSetting(
"scan_add", "Scan add",
RadioSettingValueList(NO_YES_LIST, NO_YES_LIST[_mem.scan_add]))
mem.extra.append(rs)
#TODO: Show name channel
## count = 0
## for i in _nam.chan_name:
## if i == 0xFF:
## break
## try:
## mem.name += IP620_CHARSET[i]
## except Exception:
## LOG.error("Unknown name char %i: 0x%02x (mem %i)" %
## (count, i, number - 1))
## mem.name += " "
## count += 1
## mem.name = mem.name.rstrip()
return mem
def get_memory(self, number):
_mem = self._memobj.memory[number - 1]
mem = chirp_common.Memory()
mem.number = number
if _mem.get_raw().startswith("\xFF\xFF\xFF\xFF"):
mem.empty = True
return mem
mem.freq = int(_mem.rx_freq) * 10
txfreq = int(_mem.tx_freq) * 10
if self._is_txinh(_mem):
mem.duplex = "off"
mem.offset = 0
elif txfreq == mem.freq:
mem.duplex = ""
elif abs(txfreq - mem.freq) > 70000000:
mem.duplex = "split"
mem.offset = txfreq
elif txfreq < mem.freq:
mem.duplex = "-"
mem.offset = mem.freq - txfreq
elif txfreq > mem.freq:
mem.duplex = "+"
mem.offset = txfreq - mem.freq
txmode, txval, txpol = self._decode_tone(_mem.tx_tone)
rxmode, rxval, rxpol = self._decode_tone(_mem.rx_tone)
chirp_common.split_tone_decode(mem, (txmode, txval, txpol),
(rxmode, rxval, rxpol))
mem.name = str(self._memobj.names[number - 1].name)
mem.name = mem.name.replace("\xFF", " ").rstrip()
mem.skip = not _mem.scan and "S" or ""
mem.mode = _mem.isnarrow and "NFM" or "FM"
mem.power = POWER_LEVELS[1 - _mem.ishighpower]
mem.extra = RadioSettingGroup("extra", "Extra Settings")
rs = RadioSetting(
"pttid", "PTT ID",
RadioSettingValueList(PTTID_LIST, PTTID_LIST[_mem.pttid]))
mem.extra.append(rs)
rs = RadioSetting("vox", "VOX", RadioSettingValueBoolean(_mem.vox))
mem.extra.append(rs)
rs = RadioSetting("bcl", "Busy Channel Lockout",
RadioSettingValueList(BCL_LIST, BCL_LIST[_mem.bcl]))
mem.extra.append(rs)
rs = RadioSetting(
"scramble_code", "Scramble Code",
RadioSettingValueList(CODES_LIST, CODES_LIST[_mem.scramble_code]))
mem.extra.append(rs)
return mem
def get_memory(self, number):
bitpos = (1 << ((number - 1) % 8))
bytepos = ((number - 1) / 8)
LOG.debug("bitpos %s" % bitpos)
LOG.debug("bytepos %s" % bytepos)
_mem = self._memobj.memory[number - 1]
_skp = self._memobj.skipflags[bytepos]
mem = chirp_common.Memory()
mem.number = number
mem.freq = int(_mem.rxfreq) * 10
# We'll consider any blank (i.e. 0MHz frequency) to be empty
if mem.freq == 0:
mem.empty = True
return mem
if _mem.rxfreq.get_raw() == "\xFF\xFF\xFF\xFF":
mem.freq = 0
mem.empty = True
return mem
if _mem.get_raw() == ("\xFF" * 16):
LOG.debug("Initializing empty memory")
_mem.set_raw("\x00" * 13 + "\x30\x8F\xF8")
if int(_mem.rxfreq) == int(_mem.txfreq):
mem.duplex = ""
mem.offset = 0
else:
mem.duplex = int(_mem.rxfreq) > int(_mem.txfreq) and "-" or "+"
mem.offset = abs(int(_mem.rxfreq) - int(_mem.txfreq)) * 10
mem.mode = _mem.wide and "FM" or "NFM"
self._get_tone(_mem, mem)
mem.power = RT21_POWER_LEVELS[_mem.highpower]
mem.skip = "" if (_skp & bitpos) else "S"
LOG.debug("mem.skip %s" % mem.skip)
mem.extra = RadioSettingGroup("Extra", "extra")
rs = RadioSetting("bcl", "Busy Channel Lockout",
RadioSettingValueList(BCL_LIST, BCL_LIST[_mem.bcl]))
mem.extra.append(rs)
rs = RadioSetting(
"scramble_type", "Scramble Type",
RadioSettingValueList(SCRAMBLE_LIST,
SCRAMBLE_LIST[_mem.scramble_type - 8]))
mem.extra.append(rs)
return mem
def get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic Settings")
top = RadioSettings(basic)
rs = RadioSetting("settings.squelch", "Squelch Level",
RadioSettingValueInteger(0, 9, _settings.squelch))
basic.append(rs)
rs = RadioSetting(
"settings.timeout", "Timeout Timer",
RadioSettingValueList(TIMEOUT_LIST,
TIMEOUT_LIST[_settings.timeout]))
basic.append(rs)
rs = RadioSetting(
"settings.scanmode", "Scan Mode",
RadioSettingValueList(SCANMODE_LIST,
SCANMODE_LIST[_settings.scanmode]))
basic.append(rs)
rs = RadioSetting(
"settings.voice", "Voice Prompts",
RadioSettingValueList(VOICE_LIST, VOICE_LIST[_settings.voice]))
basic.append(rs)
rs = RadioSetting(
"settings.voxgain", "VOX Level",
RadioSettingValueList(VOX_LIST, VOX_LIST[_settings.voxgain]))
basic.append(rs)
rs = RadioSetting(
"settings.voxdelay", "VOX Delay Time",
RadioSettingValueList(VOXDELAY_LIST,
VOXDELAY_LIST[_settings.voxdelay]))
basic.append(rs)
rs = RadioSetting("settings.save", "Battery Save",
RadioSettingValueBoolean(_settings.save))
basic.append(rs)
rs = RadioSetting("settings.beep", "Beep Tone",
RadioSettingValueBoolean(_settings.beep))
basic.append(rs)
def _filter(name):
filtered = ""
for char in str(name):
if char in VALID_CHARS:
filtered += char
else:
filtered += " "
return filtered
return top
def _get_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_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic Settings")
top = RadioSettings(basic)
rs = RadioSetting(
"squelchlevel", "Squelch level",
RadioSettingValueInteger(0, 9, _settings.squelchlevel))
basic.append(rs)
rs = RadioSetting(
"timeouttimer", "Timeout timer",
RadioSettingValueList(TIMEOUTTIMER_LIST,
TIMEOUTTIMER_LIST[_settings.timeouttimer]))
basic.append(rs)
rs = RadioSetting(
"scanmode", "Scan mode",
RadioSettingValueList(SCANMODE_LIST,
SCANMODE_LIST[_settings.scanmode]))
basic.append(rs)
rs = RadioSetting(
"voiceprompt", "Voice prompt",
RadioSettingValueList(VOICE_LIST,
VOICE_LIST[_settings.voiceprompt]))
basic.append(rs)
rs = RadioSetting(
"voxlevel", "Vox level",
RadioSettingValueList(VOXLEVEL_LIST,
VOXLEVEL_LIST[_settings.voxlevel]))
basic.append(rs)
rs = RadioSetting(
"voxdelay", "VOX delay",
RadioSettingValueList(VOXDELAY_LIST,
VOXDELAY_LIST[_settings.voxdelay]))
basic.append(rs)
rs = RadioSetting("batterysaver", "Battery saver",
RadioSettingValueBoolean(_settings.batterysaver))
basic.append(rs)
rs = RadioSetting("beep", "Beep",
RadioSettingValueBoolean(_settings.beep))
basic.append(rs)
return top
def get_memory(self, number):
_mem = self._memobj.memory[number - 1]
mem = chirp_common.Memory()
mem.number = number
if _mem.get_raw()[:4] == "\xFF\xFF\xFF\xFF":
mem.empty = True
return mem
mem.freq = int(_mem.rx_freq) * 10
offset = (int(_mem.tx_freq) * 10) - mem.freq
if offset < 0:
mem.offset = abs(offset)
mem.duplex = "-"
elif offset > 0:
mem.offset = offset
mem.duplex = "+"
else:
mem.offset = 0
self._get_tone(_mem, mem)
mem.power = POWER_LEVELS[_mem.highpower]
mem.mode = MODES[_mem.wide]
mem.skip = not _mem.scan and "S" or ""
mem.extra = RadioSettingGroup("all", "All Settings")
bcl = RadioSetting("bcl", "Busy Channel Lockout",
RadioSettingValueBoolean(bool(_mem.bcl)))
mem.extra.append(bcl)
beat = RadioSetting("beatshift", "Beat Shift",
RadioSettingValueBoolean(bool(_mem.beatshift)))
mem.extra.append(beat)
pttid = RadioSetting("pttid", "PTT ID",
RadioSettingValueList(PTTID,
PTTID[_mem.pttid]))
mem.extra.append(pttid)
signal = RadioSetting("signaling", "Signaling",
RadioSettingValueList(SIGNAL,
SIGNAL[
_mem.signaling & 0x01]))
mem.extra.append(signal)
return mem
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_memory(self, number):
if not self._repeaters:
self.do_fetch()
repeater = self._repeaters[number]
mem = chirp_common.Memory()
mem.number = number
mem.name = repeater.get('city')
mem.freq = chirp_common.parse_freq(repeater.get('frequency'))
offset = chirp_common.parse_freq(repeater.get('offset', '0'))
if offset > 0:
mem.duplex = "+"
elif offset < 0:
mem.duplex = "-"
else:
mem.duplex = ""
mem.offset = abs(offset)
mem.mode = 'DMR'
mem.comment = repeater.get('map_info')
mem.extra = RadioSettingGroup("Extra", "extra")
rs = RadioSetting(
"color_code", "Color Code", RadioSettingValueList(
range(16), int(repeater.get('color_code', 0))))
mem.extra.append(rs)
return mem
def decode_sql(self, mem, chan):
"""
examine the radio channel fields and determine the correct
CHIRP CSV values for tmode, cross_mode, and sql_override
"""
mem.extra = RadioSettingGroup("Extra", "extra")
extra_modes = ["(None)", "PAGER"]
value = extra_modes[chan.sql_type == 6]
valuelist = RadioSettingValueList(extra_modes, value)
rs = RadioSetting("sql_override", "Squelch override", valuelist)
mem.extra.append(rs)
if chan.sql_type == 6:
return
sql_map = RADIO_TMODES[chan.sql_type]
ndx = 0
if len(sql_map[0]) > 1:
# the sql_type is TSQL or DCS, so there are multiple UI mappings
x = getattr(chan, sql_map[1])
r = getattr(chan, sql_map[2])
ndx = self.LOOKUP.index([x == 0, r == 0])
if ndx == 3 and x == r:
ndx = 4
mem.tmode = sql_map[0][ndx][0]
cross = sql_map[0][ndx][1]
if cross:
mem.cross_mode = cross
if chan.rx_ctcss:
mem.ctone = TONE_MAP[chan.rx_ctcss]
if chan.tx_ctcss:
mem.rtone = TONE_MAP[chan.tx_ctcss]
if chan.tx_dcs:
mem.dtcs = DTCS_MAP[chan.tx_dcs]
if chan.rx_dcs:
mem.rx_dtcs = DTCS_MAP[chan.rx_dcs]
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
basic = RadioSettingGroup("basic", "Basic Settings")
top = RadioSettings(basic)
rs = RadioSetting(
"tot", "Time-out timer",
RadioSettingValueList(TIMEOUTTIMER_LIST,
TIMEOUTTIMER_LIST[_settings.tot]))
basic.append(rs)
rs = RadioSetting(
"totalert", "TOT Pre-alert",
RadioSettingValueList(TOTALERT_LIST,
TOTALERT_LIST[_settings.totalert]))
basic.append(rs)
rs = RadioSetting(
"vox", "VOX Gain",
RadioSettingValueList(VOX_LIST, VOX_LIST[_settings.vox]))
basic.append(rs)
rs = RadioSetting(
"voice", "Voice Annumciation",
RadioSettingValueList(VOICE_LIST, VOICE_LIST[_settings.voice]))
basic.append(rs)
rs = RadioSetting("squelch", "Squelch Level",
RadioSettingValueInteger(0, 9, _settings.squelch))
basic.append(rs)
rs = RadioSetting(
"voxdelay", "VOX Delay",
RadioSettingValueList(VOXDELAY_LIST,
VOXDELAY_LIST[_settings.voxdelay]))
basic.append(rs)
rs = RadioSetting("beep", "Beep",
RadioSettingValueBoolean(_settings.beep))
basic.append(rs)
rs = RadioSetting("save", "Battery Saver",
RadioSettingValueBoolean(_settings.save))
basic.append(rs)
return top
def _get_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_memory(self, number):
_mem = self._memobj.memory[number - 1]
mem = chirp_common.Memory()
mem.number = number
bit = 1 << ((number - 1) % 8)
byte = (number - 1) / 8
if self._memobj.emptyflags[byte] & bit:
mem.empty = True
return mem
mem.freq = _mem.rx_freq * 10
mem.offset = abs(_mem.rx_freq - _mem.tx_freq) * 10
if _mem.tx_freq == _mem.rx_freq:
mem.duplex = ""
elif _mem.tx_freq < _mem.rx_freq:
mem.duplex = "-"
elif _mem.tx_freq > _mem.rx_freq:
mem.duplex = "+"
mem.mode = _mem.iswide and "FM" or "NFM"
self._decode_tone(mem, _mem)
mem.skip = (self._memobj.skipflags[byte] & bit) and "S" or ""
for char in _mem.name:
try:
c = THUV3R_CHARSET[char]
except:
c = ""
mem.name += c
mem.name = mem.name.rstrip()
mem.power = self.POWER_LEVELS[not _mem.power_high]
mem.extra = RadioSettingGroup("extra", "Extra Settings")
rs = RadioSetting("bclo_n", "Busy Channel Lockout",
RadioSettingValueBoolean(not _mem.bclo_n))
mem.extra.append(rs)
rs = RadioSetting("vox_n", "VOX",
RadioSettingValueBoolean(not _mem.vox_n))
mem.extra.append(rs)
rs = RadioSetting("tail", "Squelch Tail Elimination",
RadioSettingValueBoolean(_mem.tail))
mem.extra.append(rs)
rs = RadioSetting(
"voice_mode", "Voice Mode",
RadioSettingValueList(VOICE_MODE_LIST,
VOICE_MODE_LIST[_mem.voice_mode - 1]))
mem.extra.append(rs)
return mem
def get_settings(self):
"""
Return a RadioSettings list containing one or more RadioSettingGroup
or RadioSetting objects. These represent general settings that can
be adjusted on the radio.
"""
cur = self._memobj.settings
basic = RadioSettingGroup('basic', 'Basic Settings')
rs = RadioSetting(
'squelchlevel', 'Squelch level',
RadioSettingValueInteger(minval=0,
maxval=9,
current=cur.squelchlevel))
basic.append(rs)
rs = RadioSetting(
'timeouttimer', 'Timeout timer',
RadioSettingValueList(
options=self.TIMEOUTTIMER_LIST,
current=self.TIMEOUTTIMER_LIST[cur.timeouttimer]))
basic.append(rs)
rs = RadioSetting(
'voiceprompt', 'Voice prompt',
RadioSettingValueList(options=self.VOICE_LIST,
current=self.VOICE_LIST[cur.voiceprompt]))
basic.append(rs)
rs = RadioSetting(
'voxlevel', 'Vox level',
RadioSettingValueList(options=self.VOXLEVEL_LIST,
current=self.VOXLEVEL_LIST[cur.voxlevel]))
basic.append(rs)
rs = RadioSetting(
'voxdelay', 'VOX delay',
RadioSettingValueList(options=self.VOXDELAY_LIST,
current=self.VOXDELAY_LIST[cur.voxdelay]))
basic.append(rs)
basic.append(
RadioSetting('batterysaver', 'Battery saver',
RadioSettingValueBoolean(current=cur.batterysaver)))
basic.append(
RadioSetting('beep', 'Beep',
RadioSettingValueBoolean(current=cur.beep)))
return RadioSettings(basic)
def _get_gm_settings(self):
menu = RadioSettingGroup("first_settings", "Group Monitor")
# 24 GM RNG Select the beep option while receiving digital GM information. OFF / IN RNG /ALWAYS
first_settings = self._memobj.first_settings
val = RadioSettingValueList(self._GM_RING,
self._GM_RING[first_settings.gm_ring])
rs = RadioSetting("first_settings.gm_ring", "GM Ring", val)
menu.append(rs)
# 25 GM INT Set the transmission interval of digital GM information. OFF / NORMAL / LONG
scan_settings = self._memobj.scan_settings
val = RadioSettingValueList(
self._GM_INTERVAL, self._GM_INTERVAL[scan_settings.gm_interval])
rs = RadioSetting("scan_settings.gm_interval", "GM Interval", val)
menu.append(rs)
return menu
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 _get_display_settings(self):
menu = RadioSettingGroup("display_settings", "Display")
scan_settings = self._memobj.scan_settings
val = RadioSettingValueList(self._LAMP_KEY,
self._LAMP_KEY[scan_settings.lamp])
rs = RadioSetting("scan_settings.lamp", "Lamp", val)
menu.append(rs)
val = RadioSettingValueList(self._LCD_DIMMER,
self._LCD_DIMMER[scan_settings.lcd_dimmer])
rs = RadioSetting("scan_settings.lcd_dimmer", "LCD Dimmer", val)
menu.append(rs)
opening_message = self._memobj.opening_message
val = RadioSettingValueList(
self._OPENING_MESSAGE, self._OPENING_MESSAGE[opening_message.flag])
rs = RadioSetting("opening_message.flag", "Opening Msg Mode", val)
menu.append(rs)
return menu
def _get_aprs_smartbeacon(self):
menu = RadioSettingGroup("aprs_smartbeacon", "APRS SmartBeacon")
aprs = self._memobj.aprs
val = RadioSettingValueList(
self._SMARTBEACON_PROFILE,
self._SMARTBEACON_PROFILE[aprs.active_smartbeaconing])
rs = RadioSetting("aprs.active_smartbeaconing", "SmartBeacon profile",
val)
menu.append(rs)
for profile in range(3):
pfx = "type%d" % (profile + 1)
path = "aprs.smartbeaconing_profile[%d]" % profile
prof = aprs.smartbeaconing_profile[profile]
low_val = RadioSettingValueInteger(2, 30, prof.low_speed_mph)
high_val = RadioSettingValueInteger(3, 70, prof.high_speed_mph)
low_val.get_max = lambda: min(30, int(high_val.get_value()) - 1)
rs = RadioSetting("%s.low_speed_mph" % path,
"%s Low Speed (mph)" % pfx, low_val)
menu.append(rs)
rs = RadioSetting("%s.high_speed_mph" % path,
"%s High Speed (mph)" % pfx, high_val)
menu.append(rs)
val = RadioSettingValueInteger(1, 100, prof.slow_rate_min)
rs = RadioSetting("%s.slow_rate_min" % path,
"%s Slow rate (minutes)" % pfx, val)
menu.append(rs)
val = RadioSettingValueInteger(10, 180, prof.fast_rate_sec)
rs = RadioSetting("%s.fast_rate_sec" % path,
"%s Fast rate (seconds)" % pfx, val)
menu.append(rs)
val = RadioSettingValueInteger(5, 90, prof.turn_angle)
rs = RadioSetting("%s.turn_angle" % path,
"%s Turn angle (degrees)" % pfx, val)
menu.append(rs)
val = RadioSettingValueInteger(1, 255, prof.turn_slop)
rs = RadioSetting("%s.turn_slop" % path, "%s Turn slop" % pfx, val)
menu.append(rs)
val = RadioSettingValueInteger(5, 180, prof.turn_time_sec)
rs = RadioSetting("%s.turn_time_sec" % path,
"%s Turn time (seconds)" % pfx, val)
menu.append(rs)
return menu
def get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic")
settings = RadioSettings(basic)
display = ["Frequency", "Channel", "Name"]
rs = RadioSetting("display", "Display",
RadioSettingValueList(display,
display[_settings.display]))
basic.append(rs)
apo = ["Off"] + ['%.1f hour(s)' % (0.5 * x) for x in range(1, 25)]
rs = RadioSetting("apo", "Automatic Power Off",
RadioSettingValueList(apo,
apo[_settings.apo]))
basic.append(rs)
def filter(s):
s_ = ""
for i in range(0, 8):
c = str(s[i])
s_ += (c if c in chirp_common.CHARSET_ASCII else "")
return s_
rs = RadioSetting("welcome", "Welcome Message",
RadioSettingValueString(0, 8,
filter(_settings.welcome)))
basic.append(rs)
rs = RadioSetting("beep", "Beep Enabled",
RadioSettingValueBoolean(_settings.beep))
basic.append(rs)
mute = ["Off", "TX", "RX", "TX/RX"]
rs = RadioSetting("mute", "Sub Band Mute",
RadioSettingValueList(mute,
mute[_settings.mute]))
basic.append(rs)
return settings
def get_memory(self, number):
_mem = self._memobj.memory[number - 1]
mem = chirp_common.Memory()
mem.number = number
mem.freq = int(_mem.rxfreq) * 10
# We'll consider any blank (i.e. 0MHz frequency) to be empty
if mem.freq == 0:
mem.empty = True
return mem
if _mem.rxfreq.get_raw() == "\xFF\xFF\xFF\xFF":
mem.freq = 0
mem.empty = True
return mem
if int(_mem.rxfreq) == int(_mem.txfreq):
mem.duplex = ""
mem.offset = 0
else:
mem.duplex = int(_mem.rxfreq) > int(_mem.txfreq) and "-" or "+"
mem.offset = abs(int(_mem.rxfreq) - int(_mem.txfreq)) * 10
mem.mode = _mem.wide and "FM" or "NFM"
rxtone = txtone = None
txtone = self.decode_tone(_mem.txtone)
rxtone = self.decode_tone(_mem.rxtone)
chirp_common.split_tone_decode(mem, txtone, rxtone)
mem.power = RT26_POWER_LEVELS[_mem.highpower]
if _mem.skip:
mem.skip = "S"
mem.extra = RadioSettingGroup("Extra", "extra")
rs = RadioSetting("bcl", "BCL", RadioSettingValueBoolean(not _mem.bcl))
mem.extra.append(rs)
rs = RadioSetting("epilogue", "Epilogue(STE)",
RadioSettingValueBoolean(_mem.epilogue))
mem.extra.append(rs)
val = 3 - _mem.pttid
rs = RadioSetting("pttid", "PTT ID",
RadioSettingValueList(LIST_PTTID, LIST_PTTID[val]))
mem.extra.append(rs)
return mem
def _get_extra(self, _mem):
group = RadioSettingGroup('extra', 'Extra')
s = RadioSetting('bcl', 'Busy Channel Lockout',
RadioSettingValueBoolean(_mem.bcl))
group.append(s)
s = RadioSetting('fhss', 'FHSS', RadioSettingValueBoolean(_mem.fhss))
group.append(s)
# pttid, signal
cur = PTTID[int(_mem.pttid)]
s = RadioSetting('pttid', 'PTTID', RadioSettingValueList(PTTID, cur))
group.append(s)
cur = SIGNAL[int(_mem.signal)]
s = RadioSetting('signal', 'Signal',
RadioSettingValueList(SIGNAL, cur))
group.append(s)
return group
def _get_scan_settings(self):
menu = RadioSettingGroup("scan_settings", "Scan")
scan_settings = self._memobj.scan_settings
# 23 DW RVT Turn the "Priority Channel Revert" feature ON or OFF during Dual Receive.
val = RadioSettingValueList(self._OFF_ON,
self._OFF_ON[scan_settings.dw_rt])
rs = RadioSetting("scan_settings.dw_rt",
"Dual Watch Priority Channel Revert", val)
menu.append(rs)
# 21 DW INT Set the priority memory channel monitoring interval during Dual Receive. 0.1S - 5.0S - 10.0S
val = RadioSettingValueList(
self._SCAN_RESTART, self._SCAN_RESTART[scan_settings.dw_interval])
rs = RadioSetting("scan_settings.dw_interval", "Dual Watch Interval",
val)
menu.append(rs)
# 22 DW RSM Configure the scan stop mode settings for Dual Receive. 2.0S - 10.0 S / BUSY / HOLD
first_settings = self._memobj.first_settings
val = RadioSettingValueList(
self._SCAN_RESUME,
self._SCAN_RESUME[first_settings.dw_resume_interval])
rs = RadioSetting("first_settings.dw_resume_interval",
"Dual Watch Resume Interval", val)
menu.append(rs)
# 51 SCN.LMP Set the scan lamp ON or OFF when scanning stops. OFF / ON
val = RadioSettingValueList(self._OFF_ON,
self._OFF_ON[scan_settings.scan_lamp])
rs = RadioSetting("scan_settings.scan_lamp", "Scan Lamp", val)
menu.append(rs)
# 53 SCN.STR Set the scanning restart time. 0.1 S - 2.0 S - 10.0 S
val = RadioSettingValueList(
self._SCAN_RESTART, self._SCAN_RESTART[scan_settings.scan_restart])
rs = RadioSetting("scan_settings.scan_restart", "Scan Restart", val)
menu.append(rs)
# Scan Width Section
# 50 SCV.WTH Set the VFO scan frequency range. BAND / ALL - NOT FOUND!
# Scan Resume Section
# 52 SCN.RSM Configure the scan stop mode settings. 2.0 S - 5.0 S - 10.0 S / BUSY / HOLD
first_settings = self._memobj.first_settings
val = RadioSettingValueList(
self._SCAN_RESUME, self._SCAN_RESUME[first_settings.scan_resume])
rs = RadioSetting("first_settings.scan_resume", "Scan Resume", val)
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_memory(self, number):
_mem = self._memobj.memory[number]
_flag = self._memobj.flags[number]
mem = chirp_common.Memory()
mem.number = number
if _flag.empty:
mem.empty = True
return mem
mult = int(TUNING_STEPS[_mem.tuning_step] * 1000)
mem.freq = (_mem.frequency * mult)
mem.offset = (_mem.offset * mult)
mem.name = str(_mem.name).rstrip()
mem.rtone = chirp_common.TONES[_mem.repeater_tone]
mem.ctone = chirp_common.TONES[_mem.ctcss_tone]
mem.dtcs = chirp_common.DTCS_CODES[_mem.dtcs_code]
mem.tuning_step = TUNING_STEPS[_mem.tuning_step]
mem.tmode = TONE_MODES[_mem.tone_mode]
mem.mode = "NFM" if _mem.mode_narrow else "FM"
mem.dtcs_polarity = DTCS_POLARITY[_mem.dtcs_polarity]
mem.duplex = DUPLEX[_mem.duplex]
mem.skip = "S" if _flag.skip else ""
mem.power = POWER_LEVELS[_mem.power]
# Reverse duplex
mem.extra = RadioSettingGroup("extra", "Extra")
rev = RadioSetting("reverse_duplex", "Reverse duplex",
RadioSettingValueBoolean(bool(_mem.reverse_duplex)))
rev.set_doc("Reverse duplex")
mem.extra.append(rev)
# Tx inhibit
tx_inhibit = RadioSetting(
"tx_inhibit", "TX inhibit",
RadioSettingValueBoolean(bool(_mem.tx_inhibit)))
tx_inhibit.set_doc("TX inhibit")
mem.extra.append(tx_inhibit)
# Memory display style
opt = ["Frequency", "Label"]
dsp = RadioSetting("display_style", "Display style",
RadioSettingValueList(opt, opt[_mem.display_style]))
dsp.set_doc("Memory display style")
mem.extra.append(dsp)
return mem
def get_settings(self):
_settings = self._memobj.settings
groups = RadioSettings()
for description in self.class_group_descs:
groupname, title, parms = description
group = RadioSettingGroup(groupname, title)
groups.append(group)
for parm in parms:
param, title, opts = parm
try:
if isinstance(opts, list):
# setting is a single value from the list
objval = getattr(_settings, param)
value = opts[objval]
valuelist = RadioSettingValueList(opts, value)
group.append(RadioSetting(param, title, valuelist))
else:
# setting needs special handling. opts[0] is a
# function name
opts[0](self, group, parm)
except Exception as e:
LOG.debug("%s: cannot set %s to %s" %
(e, param, repr(objval)))
return groups
def get_settings(self):
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")
group = RadioSettings(basic)
rs = RadioSetting("ch", "Channel Indication Mode",
RadioSettingValueBoolean(_settings.ch))
basic.append(rs)
rs = RadioSetting("expand", "Expanded Settings Mode",
RadioSettingValueBoolean(_settings.expand))
basic.append(rs)
rs = RadioSetting("beep", "Beep Tones",
RadioSettingValueBoolean(_settings.beep))
basic.append(rs)
rs = RadioSetting(
"autorp", "Auto Repeater Function",
RadioSettingValueList(AUTORP_LIST, AUTORP_LIST[_settings.autorp]))
basic.append(rs)
rs = RadioSetting("ritfunct", "RIT Runction",
RadioSettingValueBoolean(_settings.ritfunct))
basic.append(rs)
rs = RadioSetting("rit", "RIT Shift (KHz)",
RadioSettingValueInteger(-7, 7, _settings.rit))
basic.append(rs)
rs = RadioSetting("lock", "Lock",
RadioSettingValueBoolean(_settings.lock))
basic.append(rs)
rs = RadioSetting(
"lockgroup", "Lock Group",
RadioSettingValueList(LOCKGROUP_LIST,
LOCKGROUP_LIST[_settings.lockgroup]))
basic.append(rs)
rs = RadioSetting(
"squelch", "Squelch",
RadioSettingValueList(SQUELCH_LIST,
SQUELCH_LIST[_settings.squelch]))
basic.append(rs)
rs = RadioSetting(
"monitor", "Monitor Switch Function",
RadioSettingValueList(MONITOR_LIST,
MONITOR_LIST[_settings.monitor]))
basic.append(rs)
rs = RadioSetting(
"light", "Display Backlighting",
RadioSettingValueList(LIGHT_LIST, LIGHT_LIST[_settings.light]))
basic.append(rs)
rs = RadioSetting(
"priority", "Priority Watch Operation",
RadioSettingValueList(PRIORITY_LIST,
PRIORITY_LIST[_settings.priority]))
basic.append(rs)
rs = RadioSetting("p_scan", "Frequency Skip Function",
RadioSettingValueBoolean(_settings.p_scan))
basic.append(rs)
rs = RadioSetting(
"bnk_scan", "Memory Bank Scan Selection",
RadioSettingValueList(BANKSCAN_LIST,
BANKSCAN_LIST[_settings.bnk_scan]))
basic.append(rs)
rs = RadioSetting(
"edge", "Band Edge Scan Selection",
RadioSettingValueList(EDGE_LIST, EDGE_LIST[_settings.edge]))
basic.append(rs)
rs = RadioSetting(
"pause", "Scan Pause Time",
RadioSettingValueList(PAUSE_LIST, PAUSE_LIST[_settings.pause]))
basic.append(rs)
rs = RadioSetting(
"resume", "Scan Resume Time",
RadioSettingValueList(RESUME_LIST, RESUME_LIST[_settings.resume]))
basic.append(rs)
rs = RadioSetting("p_save", "Power Saver",
RadioSettingValueBoolean(_settings.p_save))
basic.append(rs)
rs = RadioSetting(
"ap_off", "Auto Power-off Function",
RadioSettingValueList(APOFF_LIST, APOFF_LIST[_settings.ap_off]))
basic.append(rs)
rs = RadioSetting("speed", "Dial Speed Acceleration",
RadioSettingValueBoolean(_settings.speed))
basic.append(rs)
rs = RadioSetting(
"d_sel", "Dial Select Step",
RadioSettingValueList(D_SEL_LIST, D_SEL_LIST[_settings.d_sel]))
basic.append(rs)
return group
