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:
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 DTMF_CHARS:
sty += stx[j]
for j in range(0, 24):
if j < len(sty):
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
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
def _get_settings(self):
_settings = self._memobj.settings
_service = self._memobj.service
_msg = self._memobj.messages
cfg_grp = RadioSettingGroup("cfg_grp", "Basic Settings")
adv_grp = RadioSettingGroup("adv_grp", "Advanced Settings")
key_grp = RadioSettingGroup("key_grp", "Key Assignment")
group = RadioSettings(cfg_grp, adv_grp, key_grp)
#
# Basic Settings
#
rs = RadioSetting(
"apo", "Auto Power Off",
RadioSettingValueList(APO_LIST, APO_LIST[_settings.apo]))
cfg_grp.append(rs)
rs = RadioSetting(
"sql", "Squelch Level",
RadioSettingValueList(SQL_LIST, SQL_LIST[_settings.sql]))
cfg_grp.append(rs)
rs = RadioSetting(
"scanm", "Scan Mode",
RadioSettingValueList(SCANM_LIST, SCANM_LIST[_settings.scanm]))
cfg_grp.append(rs)
rs = RadioSetting(
"tot", "Time Out Timer",
RadioSettingValueList(TOT_LIST, TOT_LIST[_settings.tot]))
cfg_grp.append(rs)
rs = RadioSetting(
"step", "Step",
RadioSettingValueList(STEP_LIST, STEP_LIST[_settings.step]))
cfg_grp.append(rs)
rs = RadioSetting(
"monitor", "Monitor",
RadioSettingValueList(MONITOR_LIST,
MONITOR_LIST[_settings.monitor]))
cfg_grp.append(rs)
rs = RadioSetting(
"vfomr", "VFO/MR",
RadioSettingValueList(VFOMR_LIST, VFOMR_LIST[_settings.vfomr]))
cfg_grp.append(rs)
rs = RadioSetting(
"mrcha", "MR/CHA",
RadioSettingValueList(MRCHA_LIST, MRCHA_LIST[_settings.mrcha]))
cfg_grp.append(rs)
rs = RadioSetting(
"vol", "Volume",
RadioSettingValueList(VOL_LIST, VOL_LIST[_settings.vol]))
cfg_grp.append(rs)
rs = RadioSetting(
"opendis", "Open Display",
RadioSettingValueList(OPENDIS_LIST,
OPENDIS_LIST[_settings.opendis]))
cfg_grp.append(rs)
def _filter(name):
filtered = ""
for char in str(name):
if char in chirp_common.CHARSET_ASCII:
filtered += char
else:
filtered += " "
LOG.debug("Filtered: %s" % filtered)
return filtered
rs = RadioSetting("messages.user1", "User-defined Message 1",
RadioSettingValueString(0, 7, _filter(_msg.user1)))
cfg_grp.append(rs)
rs = RadioSetting("messages.user2", "User-defined Message 2",
RadioSettingValueString(0, 7, _filter(_msg.user2)))
cfg_grp.append(rs)
val = RadioSettingValueString(0, 7, _filter(_msg.system))
val.set_mutable(False)
rs = RadioSetting("messages.system", "System Message", val)
cfg_grp.append(rs)
rs = RadioSetting(
"lamp", "Backlight",
RadioSettingValueList(LAMP_LIST, LAMP_LIST[_settings.lamp]))
cfg_grp.append(rs)
rs = RadioSetting(
"keylockm", "Key Lock Mode",
RadioSettingValueList(KEYLOCKM_LIST,
KEYLOCKM_LIST[_settings.keylockm]))
cfg_grp.append(rs)
rs = RadioSetting(
"absel", "A/B Select",
RadioSettingValueList(ABSEL_LIST, ABSEL_LIST[_settings.absel]))
cfg_grp.append(rs)
rs = RadioSetting("obeep", "Open Beep",
RadioSettingValueBoolean(_settings.obeep))
cfg_grp.append(rs)
rs = RadioSetting("rbeep", "Roger Beep",
RadioSettingValueBoolean(_settings.rbeep))
cfg_grp.append(rs)
rs = RadioSetting("keylock_off", "Key Lock",
RadioSettingValueBoolean(not _settings.keylock_off))
cfg_grp.append(rs)
rs = RadioSetting("ctdcsb", "CT/DCS Busy Lock",
RadioSettingValueBoolean(_settings.ctdcsb))
cfg_grp.append(rs)
rs = RadioSetting("alarm", "Alarm Key",
RadioSettingValueBoolean(_settings.alarm))
cfg_grp.append(rs)
rs = RadioSetting("save", "Battery Save",
RadioSettingValueBoolean(_settings.save))
cfg_grp.append(rs)
rs = RadioSetting("kbeep", "Key Beep",
RadioSettingValueBoolean(_settings.kbeep))
cfg_grp.append(rs)
rs = RadioSetting("reset", "Reset Enable",
RadioSettingValueBoolean(_settings.reset))
cfg_grp.append(rs)
rs = RadioSetting("smfont_off", "Small Font",
RadioSettingValueBoolean(not _settings.smfont_off))
cfg_grp.append(rs)
rs = RadioSetting("aliasen_off", "Alias Enable",
RadioSettingValueBoolean(not _settings.aliasen_off))
cfg_grp.append(rs)
rs = RadioSetting("txstop_off", "TX Stop",
RadioSettingValueBoolean(not _settings.txstop_off))
cfg_grp.append(rs)
rs = RadioSetting("dw_off", "Dual Watch",
RadioSettingValueBoolean(not _settings.dw_off))
cfg_grp.append(rs)
rs = RadioSetting("fmen_off", "FM Enable",
RadioSettingValueBoolean(not _settings.fmen_off))
cfg_grp.append(rs)
rs = RadioSetting("fmdw", "FM Dual Watch",
RadioSettingValueBoolean(_settings.fmdw))
cfg_grp.append(rs)
rs = RadioSetting("fmscan_off", "FM Scan",
RadioSettingValueBoolean(not _settings.fmscan_off))
cfg_grp.append(rs)
rs = RadioSetting(
"keypadmic_off", "Keypad MIC",
RadioSettingValueBoolean(not _settings.keypadmic_off))
cfg_grp.append(rs)
rs = RadioSetting(
"voxgain", "VOX Gain",
RadioSettingValueList(VOXGAIN_LIST,
VOXGAIN_LIST[_settings.voxgain]))
cfg_grp.append(rs)
rs = RadioSetting(
"voxdt", "VOX Delay Time",
RadioSettingValueList(VOXDT_LIST, VOXDT_LIST[_settings.voxdt]))
cfg_grp.append(rs)
rs = RadioSetting("vir", "VOX Inhibit on Receive",
RadioSettingValueBoolean(_settings.vir))
cfg_grp.append(rs)
#
# Advanced Settings
#
val = (_settings.dtmftime) - 5
rs = RadioSetting(
"dtmftime", "DTMF Digit Time",
RadioSettingValueList(DTMFTIME_LIST, DTMFTIME_LIST[val]))
adv_grp.append(rs)
val = (_settings.dtmfspace) - 5
rs = RadioSetting(
"dtmfspace", "DTMF Digit Space Time",
RadioSettingValueList(DTMFTIME_LIST, DTMFTIME_LIST[val]))
adv_grp.append(rs)
val = (_settings.dtmfdelay) / 5
rs = RadioSetting(
"dtmfdelay", "DTMF 1st Digit Delay",
RadioSettingValueList(DTMFDELAY_LIST, DTMFDELAY_LIST[val]))
adv_grp.append(rs)
val = (_settings.dtmfpretime) / 10 - 1
rs = RadioSetting(
"dtmfpretime", "DTMF Pretime",
RadioSettingValueList(DTMFPRETIME_LIST, DTMFPRETIME_LIST[val]))
adv_grp.append(rs)
val = (_settings.dtmfdelay2) / 5
rs = RadioSetting(
"dtmfdelay2", "DTMF * and # Digit Delay",
RadioSettingValueList(DTMFDELAY2_LIST, DTMFDELAY2_LIST[val]))
adv_grp.append(rs)
rs = RadioSetting("ackdecode", "ACK Decode",
RadioSettingValueBoolean(_settings.ackdecode))
adv_grp.append(rs)
rs = RadioSetting("dtmfst", "DTMF Sidetone",
RadioSettingValueBoolean(_settings.dtmfst))
adv_grp.append(rs)
rs = RadioSetting("service.rssi400", "Squelch Base Level (UHF)",
RadioSettingValueInteger(0, 255, _service.rssi400))
adv_grp.append(rs)
rs = RadioSetting("service.rssi136", "Squelch Base Level (VHF)",
RadioSettingValueInteger(0, 255, _service.rssi136))
adv_grp.append(rs)
#
# Key Settings
#
val = (_settings.lptime) - 5
rs = RadioSetting("lptime", "Long Press Time",
RadioSettingValueList(LPTIME_LIST, LPTIME_LIST[val]))
key_grp.append(rs)
rs = RadioSetting(
"keyp1long", "P1 Long Key",
RadioSettingValueList(PFKEYLONG_LIST,
PFKEYLONG_LIST[_settings.keyp1long]))
key_grp.append(rs)
rs = RadioSetting(
"keyp1short", "P1 Short Key",
RadioSettingValueList(PFKEYSHORT_LIST,
PFKEYSHORT_LIST[_settings.keyp1short]))
key_grp.append(rs)
rs = RadioSetting(
"keyp2long", "P2 Long Key",
RadioSettingValueList(PFKEYLONG_LIST,
PFKEYLONG_LIST[_settings.keyp2long]))
key_grp.append(rs)
rs = RadioSetting(
"keyp2short", "P2 Short Key",
RadioSettingValueList(PFKEYSHORT_LIST,
PFKEYSHORT_LIST[_settings.keyp2short]))
key_grp.append(rs)
rs = RadioSetting(
"keyp3long", "P3 Long Key",
RadioSettingValueList(PFKEYLONG_LIST,
PFKEYLONG_LIST[_settings.keyp3long]))
key_grp.append(rs)
rs = RadioSetting(
"keyp3short", "P3 Short Key",
RadioSettingValueList(PFKEYSHORT_LIST,
PFKEYSHORT_LIST[_settings.keyp3short]))
key_grp.append(rs)
val = RadioSettingValueList(PFKEYSHORT_LIST,
PFKEYSHORT_LIST[_settings.keymshort])
val.set_mutable(_settings.menuen == 0)
rs = RadioSetting("keymshort", "M Short Key", val)
key_grp.append(rs)
val = RadioSettingValueBoolean(_settings.menuen)
rs = RadioSetting("menuen", "Menu Enable", val)
key_grp.append(rs)
return group
def get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic")
dtmf = RadioSettingGroup("dtmf", "DTMF")
arts = RadioSettingGroup("arts", "ARTS")
top = RadioSettings(basic, arts, dtmf)
options = ["off", "30m", "1h", "3h", "5h", "8h"]
rs = RadioSetting(
"apo", "APO time (hrs)",
RadioSettingValueList(options, options[_settings.apo]))
basic.append(rs)
rs = RadioSetting("ars", "Auto Repeater Shift",
RadioSettingValueBoolean(_settings.ars))
basic.append(rs)
rs = RadioSetting("att", "Attenuation",
RadioSettingValueBoolean(_settings.att))
basic.append(rs)
rs = RadioSetting("bclo", "Busy Channel Lockout",
RadioSettingValueBoolean(_settings.bclo))
basic.append(rs)
rs = RadioSetting("beep", "Beep",
RadioSettingValueBoolean(_settings.beep))
basic.append(rs)
options = ["off", "1", "3", "5", "8", "cont"]
rs = RadioSetting(
"bell", "Bell",
RadioSettingValueList(options, options[_settings.bell]))
basic.append(rs)
rs = RadioSetting("busyled", "Busy LED",
RadioSettingValueBoolean(_settings.busyled))
basic.append(rs)
options = ["5", "10", "50", "100"]
rs = RadioSetting(
"chcounter", "Channel Counter (MHz)",
RadioSettingValueList(options, options[_settings.chcounter]))
basic.append(rs)
rs = RadioSetting("dcsrev", "DCS Reverse",
RadioSettingValueBoolean(_settings.dcsrev))
basic.append(rs)
options = map(str, range(0, 12 + 1))
rs = RadioSetting(
"dimmer", "Dimmer",
RadioSettingValueList(options, options[_settings.dimmer]))
basic.append(rs)
rs = RadioSetting("edgebeep", "Edge Beep",
RadioSettingValueBoolean(_settings.edgebeep))
basic.append(rs)
options = [
"beep", "strobe", "bp+str", "beam", "bp+beam", "cw", "bp+cw"
]
rs = RadioSetting(
"emergmode", "Emergency Mode",
RadioSettingValueList(options, options[_settings.emergmode]))
basic.append(rs)
options = ["Home", "Reverse"]
rs = RadioSetting(
"hmrv", "HM/RV key",
RadioSettingValueList(options, options[_settings.hmrv]))
basic.append(rs)
options = ["My Menu", "Internet"]
rs = RadioSetting(
"internet_key", "Internet key",
RadioSettingValueList(options, options[_settings.internet_key]))
basic.append(rs)
options = [
"1 APO", "2 AR BEP", "3 AR INT", "4 ARS", "5 ATT", "6 BCLO",
"7 BEEP", "8 BELL", "9 BSYLED", "10 CH CNT", "11 CK SFT",
"12 CW ID", "13 DC VLT", "14 DCS CD", "15 DCS RV", "16 DIMMER",
"17 DTMF", "18 DTMF S", "19 EDG BP", "20 EMG S", "21 HLFDEV",
"22 HM/RV", "23 INT MD", "24 LAMP", "25 LOCK", "26 M/T-CL",
"27 MW MD", "28 NAME", "29 NM SET", "30 OPNMSG", "31 RESUME",
"32 RF SQL", "33 RPT", "34 RX MD", "35 RXSAVE", "36 S SCH",
"37 SCNLMP", "38 SHIFT", "39 SKIP", "40 SPLIT", "41 SQL",
"42 SQL TYP", "43 STEP", "44 TN FRQ", "45 TOT", "46 TXSAVE",
"47 VFO MD", "48 TR SQL (JAPAN)", "48 WX ALT"
]
rs = RadioSetting(
"mymenu", "My Menu function",
RadioSettingValueList(options, options[_settings.mymenu - 9]))
basic.append(rs)
options = ["wires", "link"]
rs = RadioSetting(
"internet_mode", "Internet mode",
RadioSettingValueList(options, options[_settings.internet_mode]))
basic.append(rs)
options = ["key", "cont", "off"]
rs = RadioSetting(
"lamp", "Lamp mode",
RadioSettingValueList(options, options[_settings.lamp]))
basic.append(rs)
options = [
"key", "dial", "key+dial", "ptt", "key+ptt", "dial+ptt", "all"
]
rs = RadioSetting(
"lock", "Lock mode",
RadioSettingValueList(options, options[_settings.lock]))
basic.append(rs)
options = ["monitor", "tone call"]
rs = RadioSetting(
"moni_tcall", "MONI key",
RadioSettingValueList(options, options[_settings.moni_tcall]))
basic.append(rs)
options = ["lower", "next"]
rs = RadioSetting(
"mwmode", "Memory write mode",
RadioSettingValueList(options, options[_settings.mwmode]))
basic.append(rs)
options = map(str, range(0, 15 + 1))
rs = RadioSetting(
"nfm_sql", "NFM Sql",
RadioSettingValueList(options, options[_settings.nfm_sql]))
basic.append(rs)
options = map(str, range(0, 8 + 1))
rs = RadioSetting(
"wfm_sql", "WFM Sql",
RadioSettingValueList(options, options[_settings.wfm_sql]))
basic.append(rs)
options = ["off", "dc", "msg"]
rs = RadioSetting(
"openmsgmode", "Opening message",
RadioSettingValueList(options, options[_settings.openmsgmode]))
basic.append(rs)
openmsg = RadioSettingValueString(
0, 6, self._decode_chars(_settings.openmsg.get_value()))
openmsg.set_charset(CHARSET)
rs = RadioSetting("openmsg", "Opening Message", openmsg)
basic.append(rs)
options = ["3s", "5s", "10s", "busy", "hold"]
rs = RadioSetting(
"resume", "Resume",
RadioSettingValueList(options, options[_settings.resume]))
basic.append(rs)
options = ["off"] + map(str, range(1, 9 + 1))
rs = RadioSetting(
"rfsql", "RF Sql",
RadioSettingValueList(options, options[_settings.rfsql]))
basic.append(rs)
options = ["off", "200ms", "300ms", "500ms", "1s", "2s"]
rs = RadioSetting(
"rxsave", "RX pwr save",
RadioSettingValueList(options, options[_settings.rxsave]))
basic.append(rs)
options = ["single", "cont"]
rs = RadioSetting(
"smartsearch", "Smart search",
RadioSettingValueList(options, options[_settings.smartsearch]))
basic.append(rs)
rs = RadioSetting("scan_lamp", "Scan lamp",
RadioSettingValueBoolean(_settings.scan_lamp))
basic.append(rs)
rs = RadioSetting("split", "Split",
RadioSettingValueBoolean(_settings.split))
basic.append(rs)
options = ["off", "1", "3", "5", "10"]
rs = RadioSetting(
"tot", "TOT (mins)",
RadioSettingValueList(options, options[_settings.tot]))
basic.append(rs)
rs = RadioSetting("txsave", "TX pwr save",
RadioSettingValueBoolean(_settings.txsave))
basic.append(rs)
options = ["all", "band"]
rs = RadioSetting(
"vfomode", "VFO mode",
RadioSettingValueList(options, options[_settings.vfomode]))
basic.append(rs)
rs = RadioSetting("wx_alert", "WX Alert",
RadioSettingValueBoolean(_settings.wx_alert))
basic.append(rs)
# todo: priority channel
# todo: handle WX ch labels
# arts settings (ar beep, ar int, cwid en, cwid field)
options = ["15s", "25s"]
rs = RadioSetting(
"artsinterval", "ARTS Interval",
RadioSettingValueList(options, options[_settings.artsinterval]))
arts.append(rs)
options = ["off", "in range", "always"]
rs = RadioSetting(
"artsbeep", "ARTS Beep",
RadioSettingValueList(options, options[_settings.artsbeep]))
arts.append(rs)
rs = RadioSetting("cwid_en", "CWID Enable",
RadioSettingValueBoolean(_settings.cwid_en))
arts.append(rs)
cwid = RadioSettingValueString(
0, 16, self._decode_chars(_settings.cwid.get_value()))
cwid.set_charset(CHARSET)
rs = RadioSetting("cwid", "CWID", cwid)
arts.append(rs)
# setup dtmf
options = ["manual", "auto"]
rs = RadioSetting(
"dtmfmode", "DTMF mode",
RadioSettingValueList(options, options[_settings.dtmfmode]))
dtmf.append(rs)
for i in range(0, 8 + 1):
name = "dtmf" + str(i + 1)
dtmfsetting = self._memobj.dtmf[i]
# dtmflen = getattr(_settings, objname + "_len")
dtmfstr = ""
for c in dtmfsetting.digits:
if c < len(DTMFCHARSET):
dtmfstr += DTMFCHARSET[c]
LOG.debug(dtmfstr)
dtmfentry = RadioSettingValueString(0, 16, dtmfstr)
dtmfentry.set_charset(DTMFCHARSET + list(" "))
rs = RadioSetting(name, name.upper(), dtmfentry)
dtmf.append(rs)
return top
def get_memory(self, number):
"""Get the mem representation from the radio image"""
_mem = self._memobj.memory[number - 1]
# Create a high-level memory object to return to the UI
mem = chirp_common.Memory()
# Memory number
mem.number = number
if _mem.get_raw()[0] == "\xFF":
mem.empty = True
# but is not enough, you have to clear the memory in the mmap
# to get it ready for the sync_out process, just in case
_mem.set_raw("\xFF" * 16)
# set the channel to inactive state
self.set_active(number - 1, False)
return mem
# Freq and offset
mem.freq = int(_mem.rxfreq) * 10
# tx freq can be blank
if _mem.get_raw()[4] == "\xFF" or int(_mem.txen) == 255:
# TX freq not set
mem.offset = 0
mem.duplex = "off"
else:
# TX feq set
offset = (int(_mem.txfreq) * 10) - mem.freq
if offset < 0:
mem.offset = abs(offset)
mem.duplex = "-"
elif offset > 0:
mem.offset = offset
mem.duplex = "+"
else:
mem.offset = 0
# power
mem.power = POWER_LEVELS[int(_mem.power)]
# skip
mem.skip = self.get_scan(number - 1)
# tone data
rxtone = txtone = None
txtone = self.decode_tone(_mem.tx_tone)
rxtone = self.decode_tone(_mem.rx_tone)
chirp_common.split_tone_decode(mem, txtone, rxtone)
# Extra
# bank and number in the channel
mem.extra = RadioSettingGroup("extra", "Extra")
bl = RadioSetting("busy", "Busy Channel lock",
RadioSettingValueBoolean(not bool(_mem.busy)))
mem.extra.append(bl)
sf = RadioSetting("shift", "Beat Shift",
RadioSettingValueBoolean(not bool(_mem.shift)))
mem.extra.append(sf)
return mem
def get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic Settings")
group = RadioSettings(basic)
rs = RadioSetting("ch", "Channel Indication Mode",
RadioSettingValueBoolean(_settings.ch))
basic.append(rs)
rs = RadioSetting("expand", "Expanded Settings Mode",
RadioSettingValueBoolean(_settings.expand))
basic.append(rs)
rs = RadioSetting("beep", "Beep Tones",
RadioSettingValueBoolean(_settings.beep))
basic.append(rs)
rs = RadioSetting(
"autorp", "Auto Repeater Function",
RadioSettingValueList(AUTORP_LIST, AUTORP_LIST[_settings.autorp]))
basic.append(rs)
rs = RadioSetting("ritfunct", "RIT Runction",
RadioSettingValueBoolean(_settings.ritfunct))
basic.append(rs)
rs = RadioSetting("rit", "RIT Shift (KHz)",
RadioSettingValueInteger(-7, 7, _settings.rit))
basic.append(rs)
rs = RadioSetting("lock", "Lock",
RadioSettingValueBoolean(_settings.lock))
basic.append(rs)
rs = RadioSetting(
"lockgroup", "Lock Group",
RadioSettingValueList(LOCKGROUP_LIST,
LOCKGROUP_LIST[_settings.lockgroup]))
basic.append(rs)
rs = RadioSetting(
"squelch", "Squelch",
RadioSettingValueList(SQUELCH_LIST,
SQUELCH_LIST[_settings.squelch]))
basic.append(rs)
rs = RadioSetting(
"monitor", "Monitor Switch Function",
RadioSettingValueList(MONITOR_LIST,
MONITOR_LIST[_settings.monitor]))
basic.append(rs)
rs = RadioSetting(
"light", "Display Backlighting",
RadioSettingValueList(LIGHT_LIST, LIGHT_LIST[_settings.light]))
basic.append(rs)
rs = RadioSetting(
"priority", "Priority Watch Operation",
RadioSettingValueList(PRIORITY_LIST,
PRIORITY_LIST[_settings.priority]))
basic.append(rs)
rs = RadioSetting("p_scan", "Frequency Skip Function",
RadioSettingValueBoolean(_settings.p_scan))
basic.append(rs)
rs = RadioSetting(
"bnk_scan", "Memory Bank Scan Selection",
RadioSettingValueList(BANKSCAN_LIST,
BANKSCAN_LIST[_settings.bnk_scan]))
basic.append(rs)
rs = RadioSetting(
"edge", "Band Edge Scan Selection",
RadioSettingValueList(EDGE_LIST, EDGE_LIST[_settings.edge]))
basic.append(rs)
rs = RadioSetting(
"pause", "Scan Pause Time",
RadioSettingValueList(PAUSE_LIST, PAUSE_LIST[_settings.pause]))
basic.append(rs)
rs = RadioSetting(
"resume", "Scan Resume Time",
RadioSettingValueList(RESUME_LIST, RESUME_LIST[_settings.resume]))
basic.append(rs)
rs = RadioSetting("p_save", "Power Saver",
RadioSettingValueBoolean(_settings.p_save))
basic.append(rs)
rs = RadioSetting(
"ap_off", "Auto Power-off Function",
RadioSettingValueList(APOFF_LIST, APOFF_LIST[_settings.ap_off]))
basic.append(rs)
rs = RadioSetting("speed", "Dial Speed Acceleration",
RadioSettingValueBoolean(_settings.speed))
basic.append(rs)
rs = RadioSetting(
"d_sel", "Dial Select Step",
RadioSettingValueList(D_SEL_LIST, D_SEL_LIST[_settings.d_sel]))
basic.append(rs)
return group
def get_memory(self, number):
_mem = self._memobj.memory[number]
_nam = self._memobj.names[number]
mem = chirp_common.Memory()
mem.number = number
if _mem.get_raw()[0] == "\xff":
mem.empty = True
return mem
mem.freq = int(_mem.rxfreq) * 10
# TX freq set
offset = (int(_mem.txfreq) * 10) - mem.freq
if offset != 0:
if offset > 0:
mem.offset = offset
mem.duplex = "+"
else:
mem.offset = 0
for char in _nam.name:
if str(char) == "\xFF":
char = " " # The OEM software may have 0xFF mid-name
mem.name += str(char)
mem.name = mem.name.rstrip()
dtcs_pol = ["N", "N"]
if _mem.txtone in [0, 0xFFFF]:
txmode = ""
elif _mem.txtone >= 0x0258:
txmode = "Tone"
mem.rtone = int(_mem.txtone) / 10.0
elif _mem.txtone <= 0x0258:
txmode = "DTCS"
if _mem.txtone > 0x69:
index = _mem.txtone - 0x6A
dtcs_pol[0] = "R"
else:
index = _mem.txtone - 1
mem.dtcs = self.DTCS_CODES[index]
else:
LOG.warn("Bug: txtone is %04x" % _mem.txtone)
if _mem.rxtone in [0, 0xFFFF]:
rxmode = ""
elif _mem.rxtone >= 0x0258:
rxmode = "Tone"
mem.ctone = int(_mem.rxtone) / 10.0
elif _mem.rxtone <= 0x0258:
rxmode = "DTCS"
if _mem.rxtone >= 0x6A:
index = _mem.rxtone - 0x6A
dtcs_pol[1] = "R"
else:
index = _mem.rxtone - 1
mem.rx_dtcs = self.DTCS_CODES[index]
else:
LOG.warn("Bug: rxtone is %04x" % _mem.rxtone)
if txmode == "Tone" and not rxmode:
mem.tmode = "Tone"
elif txmode == rxmode and txmode == "Tone" and mem.rtone == mem.ctone:
mem.tmode = "TSQL"
elif txmode == rxmode and txmode == "DTCS" and mem.dtcs == mem.rx_dtcs:
mem.tmode = "DTCS"
elif rxmode or txmode:
mem.tmode = "Cross"
mem.cross_mode = "%s->%s" % (txmode, rxmode)
mem.dtcs_polarity = "".join(dtcs_pol)
if not _mem.scan:
mem.skip = "S"
levels = self.POWER_LEVELS
try:
mem.power = levels[_mem.lowpower]
except IndexError:
LOG.error("Radio reported invalid power level %s (in %s)" %
(_mem.power, levels))
mem.power = levels[0]
mem.mode = _mem.wide and "FM" or "NFM"
mem.extra = RadioSettingGroup("Extra", "extra")
rs = RadioSetting("bcl", "BCL", RadioSettingValueBoolean(_mem.bcl))
mem.extra.append(rs)
rs = RadioSetting(
"pttid", "PTT ID",
RadioSettingValueList(self.PTTID_LIST,
self.PTTID_LIST[_mem.pttid]))
mem.extra.append(rs)
rs = RadioSetting(
"scode", "S-CODE",
RadioSettingValueList(self.SCODE_LIST,
self.SCODE_LIST[_mem.scode]))
mem.extra.append(rs)
return mem
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_memory(self, number):
_mem = self._get_mem(number)
_nam = self._get_nam(number)
mem = chirp_common.Memory()
mem.number = number
if _mem.get_raw()[0] == "\xff":
mem.empty = True
return mem
mem.freq = int(_mem.rxfreq) * 10
if self._is_txinh(_mem):
# TX freq not set
mem.duplex = "off"
mem.offset = 0
else:
# TX freq set
offset = (int(_mem.txfreq) * 10) - mem.freq
if offset != 0:
if _split(self.get_features(), mem.freq,
int(_mem.txfreq) * 10):
mem.duplex = "split"
mem.offset = int(_mem.txfreq) * 10
elif offset < 0:
mem.offset = abs(offset)
mem.duplex = "-"
elif offset > 0:
mem.offset = offset
mem.duplex = "+"
else:
mem.offset = 0
if _nam.name:
for char in _nam.name:
try:
mem.name += CHARSET[char]
except IndexError:
break
mem.name = mem.name.rstrip()
if _mem.txtone in [0, 0xFFFF]:
txmode = ""
elif _mem.txtone >= 0x0258:
txmode = "Tone"
mem.rtone = int(_mem.txtone) / 10.0
else:
LOG.warn("Bug: txtone is %04x" % _mem.txtone)
if _mem.rxtone in [0, 0xFFFF]:
rxmode = ""
elif _mem.rxtone >= 0x0258:
rxmode = "Tone"
mem.ctone = int(_mem.rxtone) / 10.0
else:
LOG.warn("Bug: rxtone is %04x" % _mem.rxtone)
if txmode == "Tone" and not rxmode:
mem.tmode = "Tone"
elif txmode == rxmode and txmode == "Tone" and mem.rtone == mem.ctone:
mem.tmode = "TSQL"
elif rxmode or txmode:
mem.tmode = "Cross"
mem.cross_mode = "%s->%s" % (txmode, rxmode)
if not _mem.scan:
mem.skip = "S"
mem.power = POWER_LEVELS[1 - _mem.highpower]
mem.mode = _mem.wide and "FM" or "NFM"
mem.extra = RadioSettingGroup("Extra", "extra")
rs = RadioSetting(
"dtmf", "DTMF",
RadioSettingValueList(LIST_DTMF, LIST_DTMF[_mem.dtmf]))
mem.extra.append(rs)
rs = RadioSetting("bcl", "BCL", RadioSettingValueBoolean(_mem.bcl))
mem.extra.append(rs)
return mem
def _get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic")
arts = RadioSettingGroup("arts", "ARTS")
dtmf = RadioSettingGroup("dtmf", "DTMF")
wires = RadioSettingGroup("wires", "WIRES")
misc = RadioSettingGroup("misc", "Misc")
top = RadioSettings(basic, arts, dtmf, wires, misc)
# BASIC
val = RadioSettingValueList(
self._APO, self._APO[_settings.auto_power_off])
rs = RadioSetting("auto_power_off", "Auto Power Off", val)
basic.append(rs)
val = RadioSettingValueList(
self._BEEP_LEVEL, self._BEEP_LEVEL[_settings.beep_level])
rs = RadioSetting("beep_level", "Beep Level", val)
basic.append(rs)
val = RadioSettingValueList(
self._DIM_LEVEL, self._DIM_LEVEL[_settings.lcd_dimmer])
rs = RadioSetting("lcd_dimmer", "Dimmer Level", val)
basic.append(rs)
val = RadioSettingValueList(
self._LAMP, self._LAMP[_settings.lamp])
rs = RadioSetting("lamp", "Keypad Lamp", val)
basic.append(rs)
val = RadioSettingValueList(
self._LOCK, self._LOCK[_settings.lock])
rs = RadioSetting("lock", "Lock", val)
basic.append(rs)
val = RadioSettingValueList(
self._NUM_1_9, self._NUM_1_9[_settings.mic_gain])
rs = RadioSetting("mic_gain", "Mic Gain", val)
basic.append(rs)
val = RadioSettingValueList(
self._OPEN_MSG, self._OPEN_MSG[_settings.open_message_mode])
rs = RadioSetting("open_message_mode",
"Open Message Mode", val)
basic.append(rs)
val = RadioSettingValueString(0, 6,
self._decode_chars(
_settings.open_message))
val.set_charset(CHARSET)
rs = RadioSetting("open_message", "Opening Message", val)
basic.append(rs)
passstr = ""
for c in _settings.password:
if c < len(PASS_CHARSET):
passstr += PASS_CHARSET[c]
val = RadioSettingValueString(0, 4, passstr)
val.set_charset(PASS_CHARSET)
rs = RadioSetting("password", "Password", val)
basic.append(rs)
val = RadioSettingValueList(
self._RESUME, self._RESUME[_settings.resume])
rs = RadioSetting("resume", "Scan Resume", val)
basic.append(rs)
val = RadioSettingValueList(
self._MONI_TCALL, self._MONI_TCALL[_settings.moni_tcall])
rs = RadioSetting("moni_tcall", "MONI/T-CALL switch", val)
basic.append(rs)
rs = RadioSetting("scan_lamp", "Scan Lamp",
RadioSettingValueBoolean(_settings.scan_lamp))
basic.append(rs)
rs = RadioSetting("beep", "Keypad Beep",
RadioSettingValueBoolean(_settings.beep))
basic.append(rs)
rs = RadioSetting("busy_led", "Busy LED",
RadioSettingValueBoolean(_settings.busy_led))
basic.append(rs)
rs = RadioSetting("bclo", "Busy Channel Lock-Out",
RadioSettingValueBoolean(_settings.bclo))
basic.append(rs)
rs = RadioSetting("wx_alert", "WX Alert",
RadioSettingValueBoolean(_settings.wx_alert))
basic.append(rs)
rs = RadioSetting("att", "Attenuator",
RadioSettingValueBoolean(_settings.att))
basic.append(rs)
# ARTS
val = RadioSettingValueList(
self._ARTS_INT, self._ARTS_INT[_settings.arts_interval])
rs = RadioSetting("arts_interval", "ARTS Interval", val)
arts.append(rs)
val = RadioSettingValueList(
self._ARTSBEEP, self._ARTSBEEP[_settings.arts_beep])
rs = RadioSetting("arts_beep", "ARTS Beep", val)
arts.append(rs)
rs = RadioSetting("arts_cwid", "ARTS Send CWID",
RadioSettingValueBoolean(_settings.arts_cwid))
arts.append(rs)
val = RadioSettingValueString(0, 16,
self._decode_chars(
_settings.arts_cwid_alpha))
val.set_charset(CHARSET)
rs = RadioSetting("arts_cwid_alpha", "ARTS CW ID", val)
arts.append(rs)
# DTMF
val = RadioSettingValueList(
self._MAN_AUTO, self._MAN_AUTO[_settings.dtmf_autodial])
rs = RadioSetting("dtmf_autodial", "DTMF Autodial", val)
dtmf.append(rs)
val = RadioSettingValueList(
self._NUM_0_9, self._NUM_0_9[_settings.last_dtmf])
rs = RadioSetting("last_dtmf", "Last DTMF Memory Set", val)
dtmf.append(rs)
for i in range(10):
name = "dtmf_" + str(i)
dtmfsetting = self._memobj.dtmf[i]
dtmfstr = ""
for c in dtmfsetting.memory:
if c < len(DTMFCHARSET):
dtmfstr += DTMFCHARSET[c]
dtmfentry = RadioSettingValueString(0, 16, dtmfstr)
rs = RadioSetting(name, name.upper(), dtmfentry)
dtmf.append(rs)
# WIRES
val = RadioSettingValueList(
self._INT_CD, self._INT_CD[_settings.internet_code])
rs = RadioSetting("internet_code", "Internet Code", val)
wires.append(rs)
val = RadioSettingValueList(
self._INT_MD, self._INT_MD[_settings.internet_mode])
rs = RadioSetting("internet_mode",
"Internet Link Connection mode", val)
wires.append(rs)
val = RadioSettingValueList(
self._MAN_AUTO, self._MAN_AUTO[_settings.int_autodial])
rs = RadioSetting("int_autodial", "Internet Autodial", val)
wires.append(rs)
val = RadioSettingValueList(
self._NUM_0_63, self._NUM_0_63[_settings.last_internet_dtmf])
rs = RadioSetting("last_internet_dtmf",
"Last Internet DTMF Memory Set", val)
wires.append(rs)
for i in range(64):
name = "wires_dtmf_" + str(i)
dtmfsetting = self._memobj.internet_dtmf[i]
dtmfstr = ""
for c in dtmfsetting.memory:
if c < len(DTMFCHARSET):
dtmfstr += DTMFCHARSET[c]
dtmfentry = RadioSettingValueString(0, 8, dtmfstr)
rs = RadioSetting(name, name.upper(), dtmfentry)
wires.append(rs)
# MISC
val = RadioSettingValueList(
self._BELL, self._BELL[_settings.bell])
rs = RadioSetting("bell", "CTCSS/DCS Bell", val)
misc.append(rs)
val = RadioSettingValueList(
self._CH_CNT, self._CH_CNT[_settings.channel_counter_width])
rs = RadioSetting("channel_counter_width",
"Channel Counter Search Width", val)
misc.append(rs)
val = RadioSettingValueList(
self._EMERGENCY, self._EMERGENCY[_settings.emergency])
rs = RadioSetting("emergency", "Emergency alarm", val)
misc.append(rs)
val = RadioSettingValueList(
self._ON_TIMER, self._ON_TIMER[_settings.on_timer])
rs = RadioSetting("on_timer", "On Timer", val)
misc.append(rs)
rs = RadioSetting("pager_answer_back", "Pager Answer Back",
RadioSettingValueBoolean(
_settings.pager_answer_back))
misc.append(rs)
val = RadioSettingValueList(
self._NUM_1_50, self._NUM_1_50[_settings.pager_rx_tone1])
rs = RadioSetting("pager_rx_tone1", "Pager RX Tone 1", val)
misc.append(rs)
val = RadioSettingValueList(
self._NUM_1_50, self._NUM_1_50[_settings.pager_rx_tone2])
rs = RadioSetting("pager_rx_tone2", "Pager RX Tone 2", val)
misc.append(rs)
val = RadioSettingValueList(
self._NUM_1_50, self._NUM_1_50[_settings.pager_tx_tone1])
rs = RadioSetting("pager_tx_tone1", "Pager TX Tone 1", val)
misc.append(rs)
val = RadioSettingValueList(
self._NUM_1_50, self._NUM_1_50[_settings.pager_tx_tone2])
rs = RadioSetting("pager_tx_tone2", "Pager TX Tone 2", val)
misc.append(rs)
val = RadioSettingValueList(
self._PTT_DELAY, self._PTT_DELAY[_settings.ptt_delay])
rs = RadioSetting("ptt_delay", "PTT Delay", val)
misc.append(rs)
val = RadioSettingValueList(
self._RF_SQL, self._RF_SQL[_settings.rf_squelch])
rs = RadioSetting("rf_squelch", "RF Squelch", val)
misc.append(rs)
val = RadioSettingValueList(
self._RX_SAVE, self._RX_SAVE[_settings.rx_save])
rs = RadioSetting("rx_save", "RX Save", val)
misc.append(rs)
val = RadioSettingValueList(
self._TOT, self._TOT[_settings.tx_timeout])
rs = RadioSetting("tx_timeout", "TOT", val)
misc.append(rs)
val = RadioSettingValueList(
self._WAKEUP, self._WAKEUP[_settings.wakeup])
rs = RadioSetting("wakeup", "Wakeup", val)
misc.append(rs)
rs = RadioSetting("edge_beep", "Band-Edge Beep",
RadioSettingValueBoolean(_settings.edge_beep))
misc.append(rs)
val = RadioSettingValueList(
self._VFO_MODE, self._VFO_MODE[_settings.vfo_mode])
rs = RadioSetting("vfo_mode", "VFO Band Edge Limiting", val)
misc.append(rs)
rs = RadioSetting("tone_search_mute", "Tone Search Mute",
RadioSettingValueBoolean(_settings.tone_search_mute))
misc.append(rs)
val = RadioSettingValueList(
self._TS_SPEED, self._TS_SPEED[_settings.ts_speed])
rs = RadioSetting("ts_speed", "Tone Search Speed", val)
misc.append(rs)
rs = RadioSetting("dmr_wrt", "Direct Memory Recall Overwrite",
RadioSettingValueBoolean(_settings.dmr_wrt))
misc.append(rs)
rs = RadioSetting("tx_saver", "TX Battery Saver",
RadioSettingValueBoolean(_settings.tx_saver))
misc.append(rs)
val = RadioSettingValueList(
self._SMART_SEARCH, self._SMART_SEARCH[_settings.smart_search])
rs = RadioSetting("smart_search", "Smart Search", val)
misc.append(rs)
val = RadioSettingValueList(
self._HOME_REV, self._HOME_REV[_settings.home_rev])
rs = RadioSetting("home_rev", "HM/RV(EMG)R/H key", val)
misc.append(rs)
val = RadioSettingValueList(
self._MEM_W_MD, self._MEM_W_MD[_settings.memory_method])
rs = RadioSetting("memory_method", "Memory Write Method", val)
misc.append(rs)
return top
def get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic Settings")
top = RadioSettings(basic)
# TODO: Check that all these settings actually do what they
# say they do.
rs = RadioSetting("voiceprompt", "Voice prompt",
RadioSettingValueBoolean(_settings.voiceprompt))
basic.append(rs)
rs = RadioSetting(
"voicelanguage", "Voice language",
RadioSettingValueList(VOICE_LIST,
VOICE_LIST[_settings.voicelanguage]))
basic.append(rs)
rs = RadioSetting("scan", "Scan",
RadioSettingValueBoolean(_settings.scan))
basic.append(rs)
rs = RadioSetting(
"settings2.scanmode", "Scan mode",
RadioSettingValueList(
SCANMODE_LIST, SCANMODE_LIST[self._memobj.settings2.scanmode]))
basic.append(rs)
rs = RadioSetting("vox", "VOX",
RadioSettingValueBoolean(_settings.vox))
basic.append(rs)
rs = RadioSetting(
"voxlevel", "VOX level",
RadioSettingValueInteger(1, 5, _settings.voxlevel + 1))
basic.append(rs)
rs = RadioSetting("voxinhibitonrx", "Inhibit VOX on receive",
RadioSettingValueBoolean(_settings.voxinhibitonrx))
basic.append(rs)
rs = RadioSetting("lowvolinhibittx", "Low voltage inhibit transmit",
RadioSettingValueBoolean(_settings.lowvolinhibittx))
basic.append(rs)
rs = RadioSetting("highvolinhibittx", "High voltage inhibit transmit",
RadioSettingValueBoolean(_settings.highvolinhibittx))
basic.append(rs)
rs = RadioSetting("alarm", "Alarm",
RadioSettingValueBoolean(_settings.alarm))
basic.append(rs)
# TODO: This should probably be called “FM Broadcast Band Radio”
# or something. I'm not sure if the model actually has one though.
if self._has_fm:
rs = RadioSetting("fmradio", "FM function",
RadioSettingValueBoolean(_settings.fmradio))
basic.append(rs)
rs = RadioSetting(
"settings2.beep", "Beep",
RadioSettingValueBoolean(self._memobj.settings2.beep))
basic.append(rs)
rs = RadioSetting(
"settings2.batterysaver", "Battery saver",
RadioSettingValueBoolean(self._memobj.settings2.batterysaver))
basic.append(rs)
rs = RadioSetting(
"settings2.squelchlevel", "Squelch level",
RadioSettingValueInteger(0, 9,
self._memobj.settings2.squelchlevel))
basic.append(rs)
if self._has_sidekey:
rs = RadioSetting(
"settings2.sidekeyfunction", "Side key function",
RadioSettingValueList(
self.SIDEKEYFUNCTION_LIST, self.SIDEKEYFUNCTION_LIST[
self._memobj.settings2.sidekeyfunction]))
basic.append(rs)
rs = RadioSetting(
"settings2.timeouttimer", "Timeout timer",
RadioSettingValueList(
TIMEOUTTIMER_LIST,
TIMEOUTTIMER_LIST[self._memobj.settings2.timeouttimer]))
basic.append(rs)
return top
def _get_extra(self, _mem, mem):
mem.extra = RadioSettingGroup("extra", "Extra")
dig = RadioSetting("isdigital", "Digital",
RadioSettingValueBoolean(bool(_mem.isdigital)))
dig.set_doc("Digital/Packet mode enabled")
mem.extra.append(dig)
def get_settings(self):
china = RadioSettingGroup("china", "China Map Fix")
smartbeacon = RadioSettingGroup("smartbeacon", "Smartbeacon")
aprs = RadioSettingGroup("aprs", "APRS", china, smartbeacon)
digipeat = RadioSettingGroup("digipeat", "Digipeat")
system = RadioSettingGroup("system", "System")
settings = RadioSettings(aprs, digipeat, system)
aprs.append(
RadioSetting(
"callsign", "Callsign",
RadioSettingValueString(0, 6, self._mmap.callsign[:6])))
aprs.append(
RadioSetting(
"ssid", "SSID",
RadioSettingValueInteger(0, 15,
ord(self._mmap.callsign[6]) - 0x30)))
pttdelay = PTT_DELAY[int(self._mmap.pttdelay) - 1]
aprs.append(
RadioSetting("pttdelay", "PTT Delay",
RadioSettingValueList(PTT_DELAY, pttdelay)))
output = OUTPUT[int(self._mmap.output) - 1]
aprs.append(
RadioSetting("output", "Output",
RadioSettingValueList(OUTPUT, output)))
aprs.append(
RadioSetting("mice", "Mic-E",
RadioSettingValueBoolean(strbool(self._mmap.mice))))
try:
mice_msg = MICE_MESSAGE[int(self._mmap.multiple['mice_message'])]
aprs.append(
RadioSetting("mice_message", "Mic-E Message",
RadioSettingValueList(MICE_MESSAGE, mice_msg)))
except NotImplementedError:
pass
try:
aprs.append(
RadioSetting(
"path1", "Path 1",
RadioSettingValueString(0,
6,
self._mmap.path1[:6],
autopad=True,
charset=CHARSET)))
ssid1 = ord(self._mmap.path1[6]) - 0x30
aprs.append(
RadioSetting("ssid1", "SSID 1",
RadioSettingValueInteger(0, 7, ssid1)))
aprs.append(
RadioSetting(
"path2", "Path 2",
RadioSettingValueString(0,
6,
self._mmap.path2[:6],
autopad=True,
charset=CHARSET)))
ssid2 = ord(self._mmap.path2[6]) - 0x30
aprs.append(
RadioSetting("ssid2", "SSID 2",
RadioSettingValueInteger(0, 7, ssid2)))
aprs.append(
RadioSetting(
"path3", "Path 3",
RadioSettingValueString(0,
6,
self._mmap.path3[:6],
autopad=True,
charset=CHARSET)))
ssid3 = ord(self._mmap.path3[6]) - 0x30
aprs.append(
RadioSetting("ssid3", "SSID 3",
RadioSettingValueInteger(0, 7, ssid3)))
except NotImplementedError:
aprs.append(
RadioSetting(
"path", "Path",
RadioSettingValueList(PATH, PATH[int(self._mmap.path)])))
aprs.append(
RadioSetting("table", "Table or Overlay",
RadioSettingValueList(TABLE, self._mmap.symbol[1])))
aprs.append(
RadioSetting("symbol", "Symbol",
RadioSettingValueList(SYMBOL, self._mmap.symbol[0])))
aprs.append(
RadioSetting(
"beacon", "Beacon Mode",
RadioSettingValueList(BEACON,
BEACON[int(self._mmap.beacon) - 1])))
aprs.append(
RadioSetting("rate", "Beacon Rate (seconds)",
RadioSettingValueInteger(10, 9999, self._mmap.rate)))
aprs.append(
RadioSetting(
"comment", "Comment",
RadioSettingValueString(0,
34,
self._mmap.comment,
autopad=False,
charset=CHARSET)))
try:
voltage = self._mmap.multiple['voltage']
aprs.append(
RadioSetting("voltage", "Voltage in comment",
RadioSettingValueBoolean(voltage)))
temperature = self._mmap.multiple['temperature']
aprs.append(
RadioSetting("temperature", "Temperature in comment",
RadioSettingValueBoolean(temperature)))
except NotImplementedError:
pass
aprs.append(
RadioSetting(
"status", "Status",
RadioSettingValueString(0,
34,
self._mmap.status,
autopad=False,
charset=CHARSET)))
try:
telemetry = self._mmap.multiple['telemetry']
aprs.append(
RadioSetting("telemetry", "Telemetry",
RadioSettingValueBoolean(telemetry)))
telemetry_every = self._mmap.multiple['telemetry_every']
aprs.append(
RadioSetting("telemetry_every", "Telemetry every",
RadioSettingValueInteger(1, 99, telemetry_every)))
timeslot_enable = self._mmap.multiple['telemetry']
aprs.append(
RadioSetting("timeslot_enable", "Timeslot",
RadioSettingValueBoolean(timeslot_enable)))
timeslot = self._mmap.multiple['timeslot']
aprs.append(
RadioSetting("timeslot", "Timeslot (second of minute)",
RadioSettingValueInteger(0, 59, timeslot)))
except NotImplementedError:
pass
fields = [
("chinamapfix", "China map fix",
RadioSettingValueBoolean(strbool(self._mmap.chinamapfix[0]))),
("chinalat", "Lat",
RadioSettingValueInteger(-45, 45,
ord(self._mmap.chinamapfix[2]) - 80)),
("chinalon", "Lon",
RadioSettingValueInteger(-45, 45,
ord(self._mmap.chinamapfix[1]) - 80)),
]
for field in fields:
china.append(RadioSetting(*field))
try:
# Sometimes when digipeat is disabled, alias is 0xFF
alias = ALIAS[int(self._mmap.digipeat[1]) - 1]
except ValueError:
alias = ALIAS[0]
fields = [
("digipeat", "Digipeat",
RadioSettingValueBoolean(strbool(self._mmap.digipeat[0]))),
("alias", "Digipeat Alias", RadioSettingValueList(ALIAS, alias)),
("virtualgps", "Static Position",
RadioSettingValueBoolean(strbool(self._mmap.virtualgps[0]))),
("btext", "Static Position BTEXT",
RadioSettingValueString(0,
27,
self._mmap.virtualgps[1:],
autopad=False,
charset=CHARSET)),
]
for field in fields:
digipeat.append(RadioSetting(*field))
sb = self._mmap.smartbeacon
fields = [
("lowspeed", "Low Speed"),
("highspeed", "High Speed"),
("slowrate", "Slow Rate (seconds)"),
("fastrate", "Fast Rate (seconds)"),
("turnslope", "Turn Slope"),
("turnangle", "Turn Angle"),
("turntime", "Turn Time (seconds)"),
]
for field in fields:
smartbeacon.append(
RadioSetting(field[0], field[1],
RadioSettingValueInteger(0, 9999, sb[field[0]])))
system.append(
RadioSetting("version", "Version (read-only)",
RadioSettingValueString(0, 14, self._mmap.version)))
system.append(
RadioSetting("autooff", "Auto off (after 90 minutes)",
RadioSettingValueBoolean(strbool(
self._mmap.autooff))))
system.append(
RadioSetting("beep", "Beep on transmit",
RadioSettingValueBoolean(strbool(self._mmap.beep))))
system.append(
RadioSetting(
"highaltitude", "High Altitude",
RadioSettingValueBoolean(strbool(self._mmap.highaltitude))))
system.append(
RadioSetting(
"busywait", "Wait for clear channel before transmit",
RadioSettingValueBoolean(strbool(self._mmap.busywait))))
try:
system.append(
RadioSetting(
"tx_volume", "Transmit volume",
RadioSettingValueList(map(str, range(1, 7)),
self._mmap.tx_volume)))
system.append(
RadioSetting(
"rx_volume", "Receive volume",
RadioSettingValueList(map(str, range(1, 10)),
self._mmap.rx_volume)))
system.append(
RadioSetting(
"squelch", "Squelch",
RadioSettingValueList(map(str, range(
0, 9)), str(self._mmap.multiple['squelch']))))
system.append(
RadioSetting(
"tx_serial_ui_out", "Tx serial UI out",
RadioSettingValueBoolean(
strbool(self._mmap.tx_serial_ui_out))))
system.append(
RadioSetting(
"auto_on", "Auto-on with 5V input",
RadioSettingValueBoolean(strbool(self._mmap.auto_on[0]))))
system.append(
RadioSetting(
"auto_on_delay", "Auto-off delay after 5V lost (seconds)",
RadioSettingValueInteger(0, 9999,
int(self._mmap.auto_on[1:]))))
system.append(
RadioSetting(
"tfx", "TF/X",
RadioSettingValueBoolean(self._mmap.multiple['tfx'])))
system.append(
RadioSetting(
"blueled", "Light blue LED on GPS lock",
RadioSettingValueBoolean(self._mmap.multiple['blueled'])))
system.append(
RadioSetting(
"dcd", "Blue LED shows software DCD",
RadioSettingValueBoolean(self._mmap.multiple['dcd'])))
system.append(
RadioSetting(
"tf_card", "TF card format",
RadioSettingValueList(
TF_CARD,
TF_CARD[int(self._mmap.multiple['tf_card'])])))
except NotImplementedError:
pass
return settings
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_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]
mem = chirp_common.Memory()
mem.number = number
mem.freq = int(_mem.rx_freq) * 10
txfreq = int(_mem.tx_freq) * 10
if txfreq == mem.freq:
mem.duplex = ""
elif txfreq == 0:
mem.duplex = "off"
mem.offset = 0
# 166666665*10 is the equivalent for FF FF FF FF
# stored in the TX field
elif txfreq == 1666666650:
mem.duplex = "off"
mem.offset = 0
elif txfreq < mem.freq:
mem.duplex = "-"
mem.offset = mem.freq - txfreq
elif txfreq > mem.freq:
mem.duplex = "+"
mem.offset = txfreq - mem.freq
# get bandwith FM or NFM
mem.mode = MODE_LIST[_mem.mode]
# tone data
txtone = self.decode_tone(_mem.tx_tone)
rxtone = self.decode_tone(_mem.rx_tone)
chirp_common.split_tone_decode(mem, txtone, rxtone)
mem.power = POWER_LEVELS[_mem.power]
# add extra channel settings to the OTHER tab of the properties
# extra settings are unfortunately inverted
mem.extra = RadioSettingGroup("extra", "Extra")
scanadd = RadioSetting(
"scanadd", "Scan Add",
RadioSettingValueBoolean(not bool(_mem.scanadd)))
scanadd.set_doc("Add channel for scanning")
mem.extra.append(scanadd)
bclo = RadioSetting("bclo", "Busy Lockout",
RadioSettingValueBoolean(not bool(_mem.bclo)))
bclo.set_doc("Busy Lockout")
mem.extra.append(bclo)
scramb = RadioSetting("scramb", "Scramble",
RadioSettingValueBoolean(not bool(_mem.scramb)))
scramb.set_doc("Scramble Audio Signal")
mem.extra.append(scramb)
compand = RadioSetting(
"compand", "Compander",
RadioSettingValueBoolean(not bool(_mem.compand)))
compand.set_doc("Compress Audio for TX")
mem.extra.append(compand)
return mem
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")
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 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"]
nx = _sets.ty & 7 # Can have 'reserved' upper 2 digits
rx = RadioSettingValueString(14, 22, options[nx])
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 & 7], 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_memory(self, number):
_mem, _name = self._get_memobjs(number)
mem = chirp_common.Memory()
if isinstance(number, str):
mem.number = SPECIALS[number]
mem.extd_number = number
else:
mem.number = number
if _mem.get_raw().startswith("\xFF\xFF\xFF\xFF"):
mem.empty = True
return mem
if isinstance(number, int):
enabled = self._memobj.enable[(number - 1) / 8].flags[7 - ((number - 1) % 8)]
dont_skip = self._memobj.skip[(number - 1) / 8].flags[7 - ((number - 1) % 8)]
else:
enabled = True
dont_skip = True
if not enabled:
mem.empty = True
return mem
mem.freq = int(_mem.rx_freq) * 10
mem.duplex = THUVF8D_DUPLEX[_mem.duplex]
mem.offset = int(_mem.offset) * 10
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(_mem.name).rstrip('\xFF ')
mem.skip = dont_skip and "" or "S"
mem.mode = _mem.wideband and "FM" or "NFM"
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("bclo", "Busy Channel Lockout",
RadioSettingValueList(BCLO_LIST,
BCLO_LIST[_mem.bclo]))
mem.extra.append(rs)
rs = RadioSetting("apro", "APRO",
RadioSettingValueList(APRO_LIST,
APRO_LIST[_mem.apro]))
mem.extra.append(rs)
rs = RadioSetting("rpt_md", "Repeater Mode",
RadioSettingValueList(RPTMD_LIST,
RPTMD_LIST[_mem.rpt_md]))
mem.extra.append(rs)
return mem
def get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic Settings")
group = RadioSettingGroup("top", "All Settings", 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(136, 174, _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(136, 174, _limit))
def apply_limit(setting, obj):
value = int(setting.value) * 10
obj.upper_vhf = value
rs.set_apply_callback(apply_limit, self._memobj.limits)
basic.append(rs)
_limit = int(self._memobj.limits.lower_uhf) / 10
rs = RadioSetting("limits.lower_uhf", "UHF Lower Limit (MHz)",
RadioSettingValueInteger(400, 520, _limit))
def apply_limit(setting, obj):
value = int(setting.value) * 10
obj.lower_uhf = value
rs.set_apply_callback(apply_limit, self._memobj.limits)
basic.append(rs)
_limit = int(self._memobj.limits.upper_uhf) / 10
rs = RadioSetting("limits.upper_uhf", "UHF Upper Limit (MHz)",
RadioSettingValueInteger(400, 520, _limit))
def apply_limit(setting, obj):
value = int(setting.value) * 10
obj.upper_uhf = value
rs.set_apply_callback(apply_limit, self._memobj.limits)
basic.append(rs)
fm_preset = RadioSettingGroup("fm_preset", "FM Radio Presets")
group.append(fm_preset)
for i in range(0, 16):
if self._memobj.fm_presets[i] < 0x01AF:
used = True
preset = self._memobj.fm_presets[i] / 10.0 + 65
else:
used = False
preset = 65
rs = RadioSetting("fm_presets_%1i" % i, "FM Preset %i" % (i + 1),
RadioSettingValueBoolean(used),
RadioSettingValueFloat(65, 108, preset, 0.1, 1))
fm_preset.append(rs)
testmode = RadioSettingGroup("testmode", "Test Mode Settings")
group.append(testmode)
vhfdata = [
"136-139", "140-144", "145-149", "150-154", "155-159", "160-164",
"165-169", "170-174"
]
uhfdata = [
"400-409", "410-419", "420-429", "430-439", "440-449", "450-459",
"460-469", "470-479"
]
powernamedata = ["Hi", "Lo"]
powerkeydata = ["hipwr", "lopwr"]
for power in range(0, 2):
for index in range(0, 8):
key = "test.vhf%s%i" % (powerkeydata[power], index)
name = "%s Mhz %s Power" % (vhfdata[index],
powernamedata[power])
rs = RadioSetting(
key, name,
RadioSettingValueInteger(
0, 255,
getattr(self._memobj.test,
"vhf%s%i" % (powerkeydata[power], index))))
testmode.append(rs)
for power in range(0, 2):
for index in range(0, 8):
key = "test.uhf%s%i" % (powerkeydata[power], index)
name = "%s Mhz %s Power" % (uhfdata[index],
powernamedata[power])
rs = RadioSetting(
key, name,
RadioSettingValueInteger(
0, 255,
getattr(self._memobj.test,
"uhf%s%i" % (powerkeydata[power], index))))
testmode.append(rs)
for band in ["vhf", "uhf"]:
for index in range(0, 10):
key = "test.%ssquelch%i" % (band, index)
name = "%s Squelch %i" % (band.upper(), index)
rs = RadioSetting(
key, name,
RadioSettingValueInteger(
0, 255,
getattr(self._memobj.test,
"%ssquelch%i" % (band, index))))
testmode.append(rs)
return group
def get_settings(self):
_settings = self._memobj.settings
group = RadioSettingGroup("top", "All Settings")
group.append(
RadioSetting("mode", "Mode",
RadioSettingValueList(MODE_LIST,
MODE_LIST[_settings.mode])))
group.append(
RadioSetting("ab_switch", "A/B",
RadioSettingValueList(AB_LIST,
AB_LIST[_settings.ab_switch])))
group.append(
RadioSetting("a_channel", "A Selected Memory",
RadioSettingValueInteger(1, 128, _settings.a_channel + 1)))
group.append(
RadioSetting("b_channel", "B Selected Memory",
RadioSettingValueInteger(1, 128, _settings.b_channel + 1)))
group.append(
RadioSetting("a_display", "A Channel Display",
RadioSettingValueList(DISPLAY_LIST,
DISPLAY_LIST[_settings.a_display])))
group.append(
RadioSetting("b_display", "B Channel Display",
RadioSettingValueList(DISPLAY_LIST,
DISPLAY_LIST[_settings.b_display])))
group.append(
RadioSetting("tx_sel", "Priority Transmit",
RadioSettingValueList(TXSEL_LIST,
TXSEL_LIST[_settings.tx_sel])))
group.append(
RadioSetting("vox_level", "VOX Level",
RadioSettingValueList(VOX_LIST,
VOX_LIST[_settings.vox_level])))
group.append(
RadioSetting("squelch", "Squelch Level",
RadioSettingValueInteger(0, 9, _settings.squelch)))
group.append(
RadioSetting("dwait", "Dual Wait",
RadioSettingValueBoolean(_settings.dwait)))
group.append(
RadioSetting("led", "LED Mode",
RadioSettingValueList(LED_LIST,
LED_LIST[_settings.led])))
group.append(
RadioSetting("light", "Light Color",
RadioSettingValueList(LIGHT_LIST,
LIGHT_LIST[_settings.light])))
group.append(
RadioSetting("beep", "Beep",
RadioSettingValueBoolean(_settings.beep)))
group.append(
RadioSetting("ani", "ANI",
RadioSettingValueBoolean(_settings.ani)))
group.append(
RadioSetting("tot", "Timeout Timer",
RadioSettingValueList(TOT_LIST,
TOT_LIST[_settings.tot])))
group.append(
RadioSetting("roger", "Roger Beep",
RadioSettingValueBoolean(_settings.roger)))
group.append(
RadioSetting("dw", "Dual Watch",
RadioSettingValueBoolean(_settings.dw)))
group.append(
RadioSetting("rxsave", "RX Save",
RadioSettingValueBoolean(_settings.rxsave)))
def _filter(name):
return str(name).rstrip("\xFF").rstrip()
group.append(
RadioSetting("ponmsg", "Power-On Message",
RadioSettingValueString(0, 7,
_filter(_settings.ponmsg))))
group.append(
RadioSetting("scan_mode", "Scan Mode",
RadioSettingValueList(SCAN_MODE_LIST,
SCAN_MODE_LIST[_settings.scan_mode])))
group.append(
RadioSetting("autolk", "Auto Lock",
RadioSettingValueBoolean(_settings.autolk)))
group.append(
RadioSetting("lock_mode", "Keypad Lock Mode",
RadioSettingValueList(LOCK_MODE_LIST,
LOCK_MODE_LIST[_settings.lock_mode])))
group.append(
RadioSetting("voice", "Voice Prompt",
RadioSettingValueBoolean(_settings.voice)))
group.append(
RadioSetting("opnmsg", "Opening Message",
RadioSettingValueList(OPNMSG_LIST,
OPNMSG_LIST[_settings.opnmsg])))
group.append(
RadioSetting("tuning_step", "Tuning Step",
RadioSettingValueList(TUNING_STEPS_LIST,
TUNING_STEPS_LIST[_settings.tuning_step])))
group.append(
RadioSetting("lamp_t", "Backlight Timeout",
RadioSettingValueList(BACKLIGHT_TIMEOUT_LIST,
BACKLIGHT_TIMEOUT_LIST[_settings.lamp_t])))
group.append(
RadioSetting("a_work_area", "A Work Area",
RadioSettingValueList(AB_LIST,
AB_LIST[_settings.a_work_area])))
group.append(
RadioSetting("b_work_area", "B Work Area",
RadioSettingValueList(AB_LIST,
AB_LIST[_settings.b_work_area])))
return group
group.append(
RadioSetting("disnm", "Display Name",
RadioSettingValueBoolean(_settings.disnm)))
return group
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)
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.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.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.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):
"""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_memory(self, number):
LOG.debug("Getting %s" % number)
f = self._classes["mem"]()
mem = chirp_common.Memory()
if self._is_special(number):
info = self._get_special_info(number)
LOG.debug("Special info: %s" % info)
if self._rf.has_bank:
f.set_location(info.channel, info.bank)
else:
f.set_location(info.channel)
mem.number = info.location
mem.extd_number = info.name
mem.immutable = ["number", "extd_number"]
else:
if self._rf.has_bank:
ch, bnk = self.mem_to_ch_bnk(number)
f.set_location(ch, bnk)
LOG.debug("Bank %i, Channel %02i" % (bnk, ch))
else:
f.set_location(number)
mem.number = number
self._send_frame(f)
f = self._recv_frame(f)
if len(f.get_data()) == 0:
raise errors.RadioError("Radio reported error")
if f.get_data() and f.get_data()[-1] == "\xFF":
mem.empty = True
LOG.debug("Found %i empty" % mem.number)
return mem
memobj = f.get_obj()
LOG.debug(repr(memobj))
try:
if memobj.skip == 1:
mem.skip = ""
else:
mem.skip = "S"
except AttributeError:
pass
mem.freq = int(memobj.freq)
try:
mem.mode = self._MODES[memobj.mode]
# We do not know what a variety of the positions between
# PSK and DV mean, so let's behave as if those values
# are not set to maintain consistency between known-unknown
# values and unknown-unknown ones.
if mem.mode is None:
raise IndexError(memobj.mode)
except IndexError:
LOG.error(
"Bank %s location %s is set for mode %s, but no known "
"mode matches that value.",
int(memobj.bank),
int(memobj.number),
repr(memobj.mode),
)
raise
if self._unified_modes and memobj.filter == 2:
try:
# Adjust mode to its narrow variant
mem.mode = self._UNIFIED_MODES[mem.mode]
except KeyError:
LOG.error(
"Bank %s location %s is set for mode %s with filter %s, "
"but no known mode matches that combination.",
int(memobj.bank),
int(memobj.number),
repr(memobj.mode),
int(memobj.filter),
)
raise
if self._rf.has_name:
mem.name = str(memobj.name).rstrip()
if self._rf.valid_tmodes:
mem.tmode = self._rf.valid_tmodes[memobj.tmode]
if self._rf.has_dtcs_polarity:
if memobj.dtcs_polarity == 0x11:
mem.dtcs_polarity = "RR"
elif memobj.dtcs_polarity == 0x10:
mem.dtcs_polarity = "RN"
elif memobj.dtcs_polarity == 0x01:
mem.dtcs_polarity = "NR"
else:
mem.dtcs_polarity = "NN"
if self._rf.has_dtcs:
mem.dtcs = bitwise.bcd_to_int(memobj.dtcs)
if "Tone" in self._rf.valid_tmodes:
mem.rtone = int(memobj.rtone) / 10.0
if "TSQL" in self._rf.valid_tmodes and self._rf.has_ctone:
mem.ctone = int(memobj.ctone) / 10.0
if self._rf.valid_duplexes:
mem.duplex = self._rf.valid_duplexes[memobj.duplex]
if self._rf.can_odd_split and memobj.spl:
if hasattr(memobj, "duplex"):
mem.duplex = "split"
mem.offset = int(memobj.freq_tx)
mem.immutable = []
elif hasattr(memobj, "duplexOffset"):
mem.offset = int(memobj.duplexOffset) * 100
else:
mem.immutable = ["offset"]
try:
dig = RadioSetting("dig", "Digital",
RadioSettingValueBoolean(bool(memobj.dig)))
except AttributeError:
pass
else:
dig.set_doc("Enable digital mode")
if not mem.extra:
mem.extra = RadioSettingGroup("extra", "Extra")
mem.extra.append(dig)
if not self._unified_modes:
options = ["Wide", "Mid", "Narrow"]
try:
fil = RadioSetting(
"filter", "Filter",
RadioSettingValueList(options,
options[memobj.filter - 1]))
except AttributeError:
pass
else:
fil.set_doc("Filter settings")
if not mem.extra:
mem.extra = RadioSettingGroup("extra", "Extra")
mem.extra.append(fil)
return mem
def get_memory(self, number):
"""Get the mem representation from the radio image"""
bitpos = (1 << (number % 8))
bytepos = (number / 8)
_mem = self._memory_obj()[number]
_names = self._name_obj()[number]
_scn = self._scan_obj()[bytepos]
_usd = self._used_obj()[bytepos]
isused = bitpos & int(_usd)
isscan = bitpos & int(_scn)
# Create a high-level memory object to return to the UI
mem = chirp_common.Memory()
# Memory number
mem.number = number
if not isused:
mem.empty = True
return mem
# Freq and offset
mem.freq = int(_mem.rxfreq) * 10
# tx freq can be blank
if _mem.get_raw()[4] == "\xFF":
# TX freq not set
mem.offset = 0
mem.duplex = "off"
else:
# TX feq set
offset = (int(_mem.txfreq) * 10) - mem.freq
if offset < 0:
mem.offset = abs(offset)
mem.duplex = "-"
elif offset > 0:
mem.offset = offset
mem.duplex = "+"
else:
mem.offset = 0
# skip
if not isscan:
mem.skip = "S"
# name TAG of the channel
mem.name = str(_names.name).strip("\xFF")
# power
mem.power = POWER_LEVELS[int(_mem.txp)]
# wide/narrow
mem.mode = MODES[int(_mem.wn)]
# tone data
rxtone = txtone = None
txtone = self.decode_tone(_mem.txtone)
rxtone = self.decode_tone(_mem.rxtone)
chirp_common.split_tone_decode(mem, txtone, rxtone)
# Extra
mem.extra = RadioSettingGroup("extra", "Extra")
bcl = RadioSetting("bcl", "Busy channel lockout",
RadioSettingValueBoolean(bool(_mem.bcl)))
mem.extra.append(bcl)
revert = RadioSetting("revert", "Revert",
RadioSettingValueBoolean(bool(_mem.revert)))
mem.extra.append(revert)
dname = RadioSetting("dname", "Display name",
RadioSettingValueBoolean(bool(_mem.dname)))
mem.extra.append(dname)
return mem
def get_settings(self):
"""Translate the bit in the mem_struct into settings in the UI"""
sett = self._memobj.settings
# basic features of the radio
basic = RadioSettingGroup("basic", "Basic Settings")
# keys
fkeys = RadioSettingGroup("keys", "Function keys")
top = RadioSettings(basic, fkeys)
# Basic
val = RadioSettingValueString(0, 35, self._VARIANT)
val.set_mutable(False)
mod = RadioSetting("not.mod", "Radio version", val)
basic.append(mod)
beep = RadioSetting("settings.beep", "Beep tone",
RadioSettingValueBoolean(bool(sett.beep)))
basic.append(beep)
bsave = RadioSetting("settings.batt_save", "Battery save",
RadioSettingValueBoolean(bool(sett.batt_save)))
basic.append(bsave)
deal = RadioSetting("settings.dealer", "Dealer & Test",
RadioSettingValueBoolean(bool(sett.dealer)))
basic.append(deal)
add = RadioSetting("settings.add", "Del / Add feature",
RadioSettingValueBoolean(bool(sett.add)))
basic.append(add)
# In some cases the values that follows can be 0xFF (HARD RESET)
# so we need to take and validate that
if int(sett.tot) == 0xff:
# 120 sec
sett.tot = 4
if int(sett.tot_alert) == 0xff:
# 10 secs
sett.tot_alert = 1
if int(sett.tot_rekey) == 0xff:
# off
sett.tot_rekey = 0
if int(sett.tot_reset) == 0xff:
# off
sett.tot_reset = 0
if int(sett.sql) == 0xff:
# a confortable level ~6
sett.sql = 6
tot = RadioSetting("settings.tot", "Time Out Timer (TOT)",
RadioSettingValueList(TOT, TOT[int(sett.tot)]))
basic.append(tot)
tota = RadioSetting(
"settings.tot_alert", "TOT pre-plert",
RadioSettingValueList(TOT_A, TOT_A[int(sett.tot_alert)]))
basic.append(tota)
totrk = RadioSetting(
"settings.tot_rekey", "TOT rekey time",
RadioSettingValueList(TOT_RK, TOT_RK[int(sett.tot_rekey)]))
basic.append(totrk)
totrs = RadioSetting(
"settings.tot_reset", "TOT reset time",
RadioSettingValueList(TOT_RS, TOT_RS[int(sett.tot_reset)]))
basic.append(totrs)
sql = RadioSetting("settings.sql", "Squelch level",
RadioSettingValueList(SQL, SQL[int(sett.sql)]))
basic.append(sql)
# front keys
m = int(sett.kMoni)
if m > 3:
m = 1
mon = RadioSetting("settings.kMoni", "Monitor",
RadioSettingValueList(MONI, MONI[m]))
fkeys.append(mon)
s = int(sett.kScan)
if s > 3:
s = 1
scn = RadioSetting("settings.kScan", "Scan",
RadioSettingValueList(SCAN, SCAN[s]))
fkeys.append(scn)
d = int(sett.kDial)
if d > 1:
d = 0
dial = RadioSetting("settings.kDial", "Dial",
RadioSettingValueList(YESNO, YESNO[d]))
fkeys.append(dial)
t = int(sett.kTa)
if t > 2:
t = 2
ta = RadioSetting("settings.kTa", "Ta",
RadioSettingValueList(TA, TA[t]))
fkeys.append(ta)
l = int(sett.kLo)
if l > 1:
l = 0
low = RadioSetting("settings.kLo", "Low",
RadioSettingValueList(YESNO, YESNO[l]))
fkeys.append(low)
return top
def get_settings(self):
"""Translate the bit in the mem_struct into settings in the UI"""
_mem = self._memobj
basic = RadioSettingGroup("basic", "Basic Settings")
other = RadioSettingGroup("other", "Other Settings")
work = RadioSettingGroup("work", "Work Mode Settings")
dtmf = RadioSettingGroup("dtmf", "DTMF Settings")
top = RadioSettings(basic, other, work, dtmf)
# Basic
# Audio: A01-A04
aftone = RadioSetting(
"settings.aftone", "AF tone control",
RadioSettingValueList(LIST_AFTONE,
LIST_AFTONE[_mem.settings.aftone]))
basic.append(aftone)
spkr = RadioSetting(
"settings.spkr", "Speaker",
RadioSettingValueList(LIST_SPKR, LIST_SPKR[_mem.settings.spkr]))
basic.append(spkr)
audio = RadioSetting(
"settings.audio", "Stereo/Mono",
RadioSettingValueList(LIST_AUDIO, LIST_AUDIO[_mem.settings.audio]))
basic.append(audio)
sbmute = RadioSetting(
"settings.sbmute", "Sub band mute",
RadioSettingValueList(LIST_SBMUTE,
LIST_SBMUTE[_mem.settings.sbmute]))
basic.append(sbmute)
# TX/RX: B01-B08
mgain = RadioSetting(
"settings.mgain", "Mic gain",
RadioSettingValueList(LIST_MLNHM, LIST_MLNHM[_mem.settings.mgain]))
basic.append(mgain)
ptt = RadioSetting(
"settings.ptt", "PTT mode",
RadioSettingValueList(LIST_PTT, LIST_PTT[_mem.settings.ptt]))
basic.append(ptt)
# B03 (per channel)
# B04 (per channel)
rxexp = RadioSetting(
"settings.rxexp", "RX expansion",
RadioSettingValueList(LIST_RXEXP, LIST_RXEXP[_mem.settings.rxexp]))
basic.append(rxexp)
vox = RadioSetting(
"settings.vox", "Vox",
RadioSettingValueList(LIST_VOX, LIST_VOX[_mem.settings.vox]))
basic.append(vox)
voxs = RadioSetting(
"settings.voxs", "Vox sensitivity",
RadioSettingValueList(LIST_MLNHM, LIST_MLNHM[_mem.settings.voxs]))
basic.append(voxs)
# B08 (per channel)
# Display: C01-C06
display = RadioSetting(
"settings.display", "Display select",
RadioSettingValueList(LIST_DISPLAY,
LIST_DISPLAY[_mem.settings.display]))
basic.append(display)
lcdb = RadioSetting(
"settings.lcdb", "LCD brightness",
RadioSettingValueList(LIST_MINMAX,
LIST_MINMAX[_mem.settings.lcdb]))
basic.append(lcdb)
color = RadioSetting(
"settings.color", "LCD color",
RadioSettingValueList(LIST_COLOR, LIST_COLOR[_mem.settings.color]))
basic.append(color)
lcdc = RadioSetting(
"settings.lcdc", "LCD contrast",
RadioSettingValueList(LIST_MINMAX,
LIST_MINMAX[_mem.settings.lcdc]))
basic.append(lcdc)
btime = RadioSetting(
"settings.btime", "LCD backlight time",
RadioSettingValueList(LIST_BTIME, LIST_BTIME[_mem.settings.btime]))
basic.append(btime)
keyb = RadioSetting(
"settings.keyb", "Key brightness",
RadioSettingValueList(LIST_MINMAX,
LIST_MINMAX[_mem.settings.keyb]))
basic.append(keyb)
# Memory: D01-D04
# D01 (per channel)
# D02 (per channel)
mrscan = RadioSetting(
"settings.mrscan", "Memory scan type",
RadioSettingValueList(LIST_MRSCAN,
LIST_MRSCAN[_mem.settings.mrscan]))
basic.append(mrscan)
# D04 (per channel)
# Scan: E01-E04
dwstop = RadioSetting(
"settings.dwstop", "Dual watch stop",
RadioSettingValueList(LIST_DWSTOP,
LIST_DWSTOP[_mem.settings.dwstop]))
basic.append(dwstop)
scand = RadioSetting(
"settings.scand", "Scan direction",
RadioSettingValueList(LIST_SCAND, LIST_SCAND[_mem.settings.scand]))
basic.append(scand)
scanr = RadioSetting(
"settings.scanr", "Scan resume",
RadioSettingValueList(LIST_SCANR, LIST_SCANR[_mem.settings.scanr]))
basic.append(scanr)
scansb = RadioSetting("settings.scansb", "Scan stop beep",
RadioSettingValueBoolean(_mem.settings.scansb))
basic.append(scansb)
# System: F01-F09
apo = RadioSetting(
"settings.apo", "Automatic power off [hours]",
RadioSettingValueList(LIST_APO, LIST_APO[_mem.settings.apo]))
basic.append(apo)
ars = RadioSetting("settings.ars", "Automatic repeater shift",
RadioSettingValueBoolean(_mem.settings.ars))
basic.append(ars)
beep = RadioSetting(
"settings.beep", "Beep volume",
RadioSettingValueList(LIST_BEEP, LIST_BEEP[_mem.settings.beep]))
basic.append(beep)
fkey = RadioSetting(
"settings.fkey", "F key",
RadioSettingValueList(LIST_FKEY, LIST_FKEY[_mem.settings.fkey]))
basic.append(fkey)
pfkey1 = RadioSetting(
"settings.pfkey1", "Mic P1 key",
RadioSettingValueList(LIST_PFKEY,
LIST_PFKEY[_mem.settings.pfkey1]))
basic.append(pfkey1)
pfkey2 = RadioSetting(
"settings.pfkey2", "Mic P2 key",
RadioSettingValueList(LIST_PFKEY,
LIST_PFKEY[_mem.settings.pfkey2]))
basic.append(pfkey2)
pfkey3 = RadioSetting(
"settings.pfkey3", "Mic P3 key",
RadioSettingValueList(LIST_PFKEY,
LIST_PFKEY[_mem.settings.pfkey3]))
basic.append(pfkey3)
pfkey4 = RadioSetting(
"settings.pfkey4", "Mic P4 key",
RadioSettingValueList(LIST_PFKEY,
LIST_PFKEY[_mem.settings.pfkey4]))
basic.append(pfkey4)
omode = RadioSetting(
"settings.omode", "Operation mode",
RadioSettingValueList(LIST_AB, LIST_AB[_mem.settings.omode]))
basic.append(omode)
rxcoverm = RadioSetting(
"settings.rxcoverm", "RX coverage - memory",
RadioSettingValueList(LIST_COVERAGE,
LIST_COVERAGE[_mem.settings.rxcoverm]))
basic.append(rxcoverm)
rxcoverv = RadioSetting(
"settings.rxcoverv", "RX coverage - VFO",
RadioSettingValueList(LIST_COVERAGE,
LIST_COVERAGE[_mem.settings.rxcoverv]))
basic.append(rxcoverv)
tot = RadioSetting(
"settings.tot", "Time out timer [min]",
RadioSettingValueList(LIST_TOT, LIST_TOT[_mem.settings.tot]))
basic.append(tot)
# Timer/Clock: G01-G04
# G01
datefmt = RadioSetting(
"settings.datefmt", "Date format",
RadioSettingValueList(LIST_DATEFMT,
LIST_DATEFMT[_mem.settings.datefmt]))
basic.append(datefmt)
timefmt = RadioSetting(
"settings.timefmt", "Time format",
RadioSettingValueList(LIST_TIMEFMT,
LIST_TIMEFMT[_mem.settings.timefmt]))
basic.append(timefmt)
timesig = RadioSetting("settings.timesig", "Time signal",
RadioSettingValueBoolean(_mem.settings.timesig))
basic.append(timesig)
tz = RadioSetting(
"settings.tz", "Time zone",
RadioSettingValueList(LIST_TZ, LIST_TZ[_mem.settings.tz]))
basic.append(tz)
# Signaling: H01-H06
bell = RadioSetting(
"settings.bell", "Bell ringer",
RadioSettingValueList(LIST_BELL, LIST_BELL[_mem.settings.bell]))
basic.append(bell)
# H02 (per channel)
dtmfmodenc = RadioSetting(
"settings.dtmfmodenc", "DTMF mode encode",
RadioSettingValueBoolean(_mem.settings.dtmfmodenc))
basic.append(dtmfmodenc)
dtmfmoddec = RadioSetting(
"settings.dtmfmoddec", "DTMF mode decode",
RadioSettingValueBoolean(_mem.settings.dtmfmoddec))
basic.append(dtmfmoddec)
# H04 (per channel)
decbandsel = RadioSetting(
"settings.decbandsel", "DTMF band select",
RadioSettingValueList(LIST_AB, LIST_AB[_mem.settings.decbandsel]))
basic.append(decbandsel)
sqlexp = RadioSetting("settings.sqlexp", "SQL expansion",
RadioSettingValueBoolean(_mem.settings.sqlexp))
basic.append(sqlexp)
# Pkt: I01-I03
databnd = RadioSetting(
"settings.databnd", "Packet data band",
RadioSettingValueList(LIST_DATABND,
LIST_DATABND[_mem.settings.databnd]))
basic.append(databnd)
dataspd = RadioSetting(
"settings.dataspd", "Packet data speed",
RadioSettingValueList(LIST_DATASPD,
LIST_DATASPD[_mem.settings.dataspd]))
basic.append(dataspd)
datasql = RadioSetting(
"settings.datasql", "Packet data squelch",
RadioSettingValueList(LIST_DATASQL,
LIST_DATASQL[_mem.settings.datasql]))
basic.append(datasql)
# Other
dw = RadioSetting("settings.dw", "Dual watch",
RadioSettingValueBoolean(_mem.settings.dw))
other.append(dw)
cpuclk = RadioSetting(
"settings.cpuclk", "CPU clock frequency",
RadioSettingValueList(LIST_CPUCLK,
LIST_CPUCLK[_mem.settings.cpuclk]))
other.append(cpuclk)
def _filter(name):
filtered = ""
for char in str(name):
if char in VALID_CHARS:
filtered += char
else:
filtered += " "
return filtered
line16 = RadioSetting(
"poweron_msg.line16", "Power-on message",
RadioSettingValueString(0, 16, _filter(_mem.poweron_msg.line16)))
other.append(line16)
line32 = RadioSetting(
"embedded_msg.line32", "Embedded message",
RadioSettingValueString(0, 32, _filter(_mem.embedded_msg.line32)))
other.append(line32)
# Work
workmoda = RadioSetting(
"settings.workmoda", "Work mode A",
RadioSettingValueList(LIST_WORK,
LIST_WORK[_mem.settings.workmoda]))
work.append(workmoda)
workmodb = RadioSetting(
"settings.workmodb", "Work mode B",
RadioSettingValueList(LIST_WORK,
LIST_WORK[_mem.settings.workmodb]))
work.append(workmodb)
wbanda = RadioSetting(
"settings.wbanda", "Work band A",
RadioSettingValueList(LIST_WBANDA,
LIST_WBANDA[(_mem.settings.wbanda) - 1]))
work.append(wbanda)
wbandb = RadioSetting(
"settings.wbandb", "Work band B",
RadioSettingValueList(LIST_WBANDB,
LIST_WBANDB[(_mem.settings.wbandb) - 4]))
work.append(wbandb)
sqla = RadioSetting(
"settings.sqla", "Squelch A",
RadioSettingValueList(LIST_SQL, LIST_SQL[_mem.settings.sqla]))
work.append(sqla)
sqlb = RadioSetting(
"settings.sqlb", "Squelch B",
RadioSettingValueList(LIST_SQL, LIST_SQL[_mem.settings.sqlb]))
work.append(sqlb)
stepa = RadioSetting(
"settings.stepa", "Auto step A",
RadioSettingValueList(LIST_STEP, LIST_STEP[_mem.settings.stepa]))
work.append(stepa)
stepb = RadioSetting(
"settings.stepb", "Auto step B",
RadioSettingValueList(LIST_STEP, LIST_STEP[_mem.settings.stepb]))
work.append(stepb)
mrcha = RadioSetting(
"settings.mrcha", "Current channel A",
RadioSettingValueInteger(0, 499, _mem.settings.mrcha))
work.append(mrcha)
mrchb = RadioSetting(
"settings.mrchb", "Current channel B",
RadioSettingValueInteger(0, 499, _mem.settings.mrchb))
work.append(mrchb)
val = _mem.settings.offseta / 100.00
offseta = RadioSetting("settings.offseta", "Offset A (0-37.95)",
RadioSettingValueFloat(0, 38.00, val, 0.05, 2))
work.append(offseta)
val = _mem.settings.offsetb / 100.00
offsetb = RadioSetting("settings.offsetb", "Offset B (0-79.95)",
RadioSettingValueFloat(0, 80.00, val, 0.05, 2))
work.append(offsetb)
wpricha = RadioSetting(
"settings.wpricha", "Priority channel A",
RadioSettingValueInteger(0, 499, _mem.settings.wpricha))
work.append(wpricha)
wprichb = RadioSetting(
"settings.wprichb", "Priority channel B",
RadioSettingValueInteger(0, 499, _mem.settings.wprichb))
work.append(wprichb)
smode = RadioSetting(
"settings.smode", "Smart function mode",
RadioSettingValueList(LIST_SMODE, LIST_SMODE[_mem.settings.smode]))
work.append(smode)
# dtmf
ttdkey = RadioSetting(
"dtmf.ttdkey", "D key function",
RadioSettingValueList(LIST_TTDKEY, LIST_TTDKEY[_mem.dtmf.ttdkey]))
dtmf.append(ttdkey)
ttdgt = RadioSetting(
"dtmf.ttdgt", "Digit time",
RadioSettingValueList(LIST_TT200,
LIST_TT200[(_mem.dtmf.ttdgt) - 5]))
dtmf.append(ttdgt)
ttint = RadioSetting(
"dtmf.ttint", "Interval time",
RadioSettingValueList(LIST_TT200,
LIST_TT200[(_mem.dtmf.ttint) - 5]))
dtmf.append(ttint)
tt1stdgt = RadioSetting(
"dtmf.tt1stdgt", "1st digit time",
RadioSettingValueList(LIST_TT200,
LIST_TT200[(_mem.dtmf.tt1stdgt) - 5]))
dtmf.append(tt1stdgt)
tt1stdly = RadioSetting(
"dtmf.tt1stdly", "1st digit delay time",
RadioSettingValueList(LIST_TT1000,
LIST_TT1000[(_mem.dtmf.tt1stdly) - 2]))
dtmf.append(tt1stdly)
ttdlyqt = RadioSetting(
"dtmf.ttdlyqt", "Digit delay when use qt",
RadioSettingValueList(LIST_TT1000,
LIST_TT1000[(_mem.dtmf.ttdlyqt) - 2]))
dtmf.append(ttdlyqt)
ttsig = RadioSetting(
"dtmf2.ttsig", "Signal",
RadioSettingValueList(LIST_TTSIG, LIST_TTSIG[_mem.dtmf2.ttsig]))
dtmf.append(ttsig)
ttautorst = RadioSetting(
"dtmf2.ttautorst", "Auto reset time",
RadioSettingValueList(LIST_TTAUTORST,
LIST_TTAUTORST[_mem.dtmf2.ttautorst]))
dtmf.append(ttautorst)
if _mem.dtmf2.ttgrpcode > 0x06:
val = 0x00
else:
val = _mem.dtmf2.ttgrpcode
ttgrpcode = RadioSetting(
"dtmf2.ttgrpcode", "Group code",
RadioSettingValueList(LIST_TTGRPCODE, LIST_TTGRPCODE[val]))
dtmf.append(ttgrpcode)
ttintcode = RadioSetting(
"dtmf2.ttintcode", "Interval code",
RadioSettingValueList(LIST_TTINTCODE,
LIST_TTINTCODE[_mem.dtmf2.ttintcode]))
dtmf.append(ttintcode)
if _mem.dtmf2.ttalert > 0x04:
val = 0x00
else:
val = _mem.dtmf2.ttalert
ttalert = RadioSetting(
"dtmf2.ttalert", "Alert tone/transpond",
RadioSettingValueList(LIST_TTALERT, LIST_TTALERT[val]))
dtmf.append(ttalert)
ttautod = RadioSetting(
"dtmf.ttautod", "Auto dial group",
RadioSettingValueList(LIST_TTAUTOD,
LIST_TTAUTOD[_mem.dtmf.ttautod]))
dtmf.append(ttautod)
# setup 9 dtmf autodial entries
for i in map(str, range(1, 10)):
objname = "code" + i
strname = "Code " + str(i)
dtmfsetting = getattr(_mem.dtmfcode, objname)
dtmflen = getattr(_mem.dtmfcode, objname + "_len")
dtmfstr = self._bbcd2dtmf(dtmfsetting, dtmflen)
code = RadioSettingValueString(0, 16, dtmfstr)
code.set_charset(DTMF_CHARS + list(" "))
rs = RadioSetting("dtmfcode." + objname, strname, code)
dtmf.append(rs)
return top
def get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic Settings")
top = RadioSettings(basic)
rs = RadioSetting("lpt", "Long Press Time[s]",
RadioSettingValueList(
LIST_LPT,
LIST_LPT[_settings.lpt]))
basic.append(rs)
if _settings.k1shortp > 4:
val = 1
else:
val = _settings.k1shortp
rs = RadioSetting("k1shortp", "Key 1 Short Press",
RadioSettingValueList(
LIST_SHORT_PRESS,
LIST_SHORT_PRESS[val]))
basic.append(rs)
if _settings.k1longp > 6:
val = 3
else:
val = _settings.k1longp
rs = RadioSetting("k1longp", "Key 1 Long Press",
RadioSettingValueList(
LIST_LONG_PRESS,
LIST_LONG_PRESS[val]))
basic.append(rs)
if _settings.k2shortp > 4:
val = 4
else:
val = _settings.k2shortp
rs = RadioSetting("k2shortp", "Key 2 Short Press",
RadioSettingValueList(
LIST_SHORT_PRESS,
LIST_SHORT_PRESS[val]))
basic.append(rs)
if _settings.k2longp > 6:
val = 4
else:
val = _settings.k2longp
rs = RadioSetting("k2longp", "Key 2 Long Press",
RadioSettingValueList(
LIST_LONG_PRESS,
LIST_LONG_PRESS[val]))
basic.append(rs)
rs = RadioSetting("voxc", "VOX Control",
RadioSettingValueBoolean(not _settings.voxc))
basic.append(rs)
if _settings.voxg > 8:
val = 4
else:
val = _settings.voxg + 1
rs = RadioSetting("voxg", "VOX Gain",
RadioSettingValueInteger(1, 9, val))
basic.append(rs)
rs = RadioSetting("voxd", "VOX Delay Time",
RadioSettingValueList(
LIST_VOXDELAY,
LIST_VOXDELAY[_settings.voxd]))
basic.append(rs)
rs = RadioSetting("voxi", "VOX Inhibit on Receive",
RadioSettingValueBoolean(not _settings.voxi))
basic.append(rs)
if _settings.squelch > 8:
val = 4
else:
val = _settings.squelch
rs = RadioSetting("squelch", "Squelch Level",
RadioSettingValueInteger(0, 9, val))
basic.append(rs)
if _settings.voice == 3:
val = 1
else:
val = _settings.voice
rs = RadioSetting("voice", "Voice Prompts",
RadioSettingValueList(
LIST_VOICE,
LIST_VOICE[val]))
basic.append(rs)
rs = RadioSetting("tone", "Tone",
RadioSettingValueBoolean(_settings.tone))
basic.append(rs)
rs = RadioSetting("lovoltnotx", "TX Inhibit (when battery < 6 volts)",
RadioSettingValueBoolean(_settings.lovoltnotx))
basic.append(rs)
rs = RadioSetting("hivoltnotx", "TX Inhibit (when battery > 9 volts)",
RadioSettingValueBoolean(_settings.hivoltnotx))
basic.append(rs)
if _settings.tot > 10:
val = 6
else:
val = _settings.tot
rs = RadioSetting("tot", "Time-out Timer[s]",
RadioSettingValueList(
LIST_TIMEOUTTIMER,
LIST_TIMEOUTTIMER[val]))
basic.append(rs)
if _settings.save < 3:
val = 0
else:
val = _settings.save - 3
rs = RadioSetting("save", "Battery Saver",
RadioSettingValueList(
LIST_SAVE,
LIST_SAVE[val]))
basic.append(rs)
rs = RadioSetting("ssave", "Super Battery Saver[s]",
RadioSettingValueList(
LIST_SSAVE,
LIST_SSAVE[_settings.ssave]))
basic.append(rs)
rs = RadioSetting("alarm", "Incept Alarm",
RadioSettingValueBoolean(_settings.alarm))
basic.append(rs)
rs = RadioSetting("scan", "Scan Function",
RadioSettingValueBoolean(_settings.scan))
basic.append(rs)
if _settings.prioritych > 15:
val = 0
else:
val = _settings.prioritych + 1
rs = RadioSetting("prioritych", "Priority Channel",
RadioSettingValueList(
LIST_PRIORITYCH,
LIST_PRIORITYCH[val]))
basic.append(rs)
if _settings.scanspeed > 8:
val = 4
else:
val = _settings.scanspeed
rs = RadioSetting("scanspeed", "Scan Speed[ms]",
RadioSettingValueList(
LIST_SCANSPEED,
LIST_SCANSPEED[val]))
basic.append(rs)
if _settings.scandelay > 27:
val = 12
else:
val = _settings.scandelay
rs = RadioSetting("scandelay", "Scan Droupout Delay Time[s]",
RadioSettingValueList(
LIST_SCANDELAY,
LIST_SCANDELAY[val]))
basic.append(rs)
return top
def get_settings(self):
_msg = self._memobj.welcome_msg
_oem = self._memobj.oem_info
_settings = self._memobj.settings
cfg_grp = RadioSettingGroup("cfg_grp", "Function Setup")
oem_grp = RadioSettingGroup("oem_grp", "OEM Info")
group = RadioSettings(cfg_grp, oem_grp)
def _filter(name):
filtered = ""
for char in str(name):
if char in chirp_common.CHARSET_ASCII:
filtered += char
else:
filtered += " "
return filtered
#
# Function Setup
#
rs = RadioSetting("welcome_msg.line1", "Welcome Message 1",
RadioSettingValueString(0, 6, _filter(_msg.line1)))
cfg_grp.append(rs)
rs = RadioSetting("welcome_msg.line2", "Welcome Message 2",
RadioSettingValueString(0, 6, _filter(_msg.line2)))
cfg_grp.append(rs)
rs = RadioSetting(
"display", "Display Mode",
RadioSettingValueList(DISPLAY, DISPLAY[_settings.display]))
cfg_grp.append(rs)
rs = RadioSetting(
"upvfomr", "Up VFO/MR",
RadioSettingValueList(VFOMR, VFOMR[_settings.upvfomr]))
cfg_grp.append(rs)
rs = RadioSetting(
"dnvfomr", "Down VFO/MR",
RadioSettingValueList(VFOMR, VFOMR[_settings.dnvfomr]))
cfg_grp.append(rs)
rs = RadioSetting(
"upwork", "Up Work Mode",
RadioSettingValueList(WORKMODE, WORKMODE[_settings.upwork]))
cfg_grp.append(rs)
rs = RadioSetting(
"upmrbank", "Up MR Bank",
RadioSettingValueList(MRBANK, MRBANK[_settings.upmrbank]))
cfg_grp.append(rs)
rs = RadioSetting("upmrch", "Up MR Channel",
RadioSettingValueInteger(0, 200, _settings.upmrch))
cfg_grp.append(rs)
rs = RadioSetting(
"dnwork", "Down Work Mode",
RadioSettingValueList(WORKMODE, WORKMODE[_settings.dnwork]))
cfg_grp.append(rs)
rs = RadioSetting(
"dnmrbank", "Down MR Bank",
RadioSettingValueList(MRBANK, MRBANK[_settings.dnmrbank]))
cfg_grp.append(rs)
rs = RadioSetting("dnmrch", "Down MR Channel",
RadioSettingValueInteger(0, 200, _settings.dnmrch))
cfg_grp.append(rs)
rs = RadioSetting("main", "Main",
RadioSettingValueList(MAIN, MAIN[_settings.main]))
cfg_grp.append(rs)
rs = RadioSetting("pause", "Scan Pause Time",
RadioSettingValueList(PAUSE, PAUSE[_settings.pause]))
cfg_grp.append(rs)
rs = RadioSetting("stop", "Function Keys Stop Time",
RadioSettingValueList(STOP, STOP[_settings.stop]))
cfg_grp.append(rs)
rs = RadioSetting(
"backlight", "Backlight",
RadioSettingValueList(BACKLIGHT, BACKLIGHT[_settings.backlight]))
cfg_grp.append(rs)
rs = RadioSetting("color", "Backlight Color",
RadioSettingValueList(COLOR, COLOR[_settings.color]))
cfg_grp.append(rs)
rs = RadioSetting(
"vdisplay", "Vice-Machine Display",
RadioSettingValueList(VDISPLAY, VDISPLAY[_settings.vdisplay]))
cfg_grp.append(rs)
rs = RadioSetting(
"voxlevel", "Vox Level",
RadioSettingValueList(VOXLEVEL, VOXLEVEL[_settings.voxlevel]))
cfg_grp.append(rs)
rs = RadioSetting(
"voxdelay", "Vox Delay",
RadioSettingValueList(VOXDELAY, VOXDELAY[_settings.voxdelay]))
cfg_grp.append(rs)
rs = RadioSetting("tot", "Time Out Timer",
RadioSettingValueList(TOT, TOT[_settings.tot]))
cfg_grp.append(rs)
rs = RadioSetting("tbst", "Tone Burst",
RadioSettingValueList(TBST, TBST[_settings.tbst]))
cfg_grp.append(rs)
rs = RadioSetting("monikey", "MONI Key Function",
RadioSettingValueList(MONI, MONI[_settings.monikey]))
cfg_grp.append(rs)
if self.MODEL == "TERMN-8R":
rs = RadioSetting(
"pf1key", "PF1 Key Function",
RadioSettingValueList(PFKEYT, PFKEYT[_settings.pf1key]))
cfg_grp.append(rs)
rs = RadioSetting(
"pf2key", "PF2 Key Function",
RadioSettingValueList(PFKEYT, PFKEYT[_settings.pf2key]))
cfg_grp.append(rs)
if self.MODEL == "OBLTR-8R":
rs = RadioSetting(
"pf1key", "PF1 Key Function",
RadioSettingValueList(PFKEYO, PFKEYO[_settings.pf1key]))
cfg_grp.append(rs)
rs = RadioSetting(
"fmam", "PF2 Key Function",
RadioSettingValueList(PFKEYO, PFKEYO[_settings.fmam]))
cfg_grp.append(rs)
rs = RadioSetting("apo", "Automatic Power Off",
RadioSettingValueList(APO, APO[_settings.apo]))
cfg_grp.append(rs)
rs = RadioSetting("save", "Power Save",
RadioSettingValueList(SAVE, SAVE[_settings.save]))
cfg_grp.append(rs)
rs = RadioSetting("tail", "Tail Eliminator Type",
RadioSettingValueList(TAIL, TAIL[_settings.tail]))
cfg_grp.append(rs)
rs = RadioSetting(
"fmvfomr", "FM VFO/MR",
RadioSettingValueList(VFOMR, VFOMR[_settings.fmvfomr]))
cfg_grp.append(rs)
rs = RadioSetting("fmmrch", "FM MR Channel",
RadioSettingValueInteger(0, 100, _settings.fmmrch))
cfg_grp.append(rs)
rs = RadioSetting("noaa", "NOAA",
RadioSettingValueList(NOAA, NOAA[_settings.noaa]))
cfg_grp.append(rs)
rs = RadioSetting(
"noaach", "NOAA Channel",
RadioSettingValueList(NOAACH, NOAACH[_settings.noaach]))
cfg_grp.append(rs)
rs = RadioSetting(
"part95", "PART95",
RadioSettingValueList(PART95, PART95[_settings.part95]))
cfg_grp.append(rs)
rs = RadioSetting("gmrs", "GMRS",
RadioSettingValueList(GMRS, GMRS[_settings.gmrs]))
cfg_grp.append(rs)
rs = RadioSetting("murs", "MURS",
RadioSettingValueList(MURS, MURS[_settings.murs]))
cfg_grp.append(rs)
for i in range(0, 9):
val = self._memobj.banklink[i].bank
rs = RadioSetting("banklink/%i.bank" % i, "Bank Link %i" % (i + 1),
RadioSettingValueBoolean(val))
cfg_grp.append(rs)
val = self._memobj.banklink[9].bank
rs = RadioSetting("banklink/9.bank", "Bank Link 0",
RadioSettingValueBoolean(val))
cfg_grp.append(rs)
rs = RadioSetting("allband", "All Band",
RadioSettingValueBoolean(_settings.allband))
cfg_grp.append(rs)
rs = RadioSetting("alarmoff", "Alarm Function Off",
RadioSettingValueBoolean(_settings.alarmoff))
cfg_grp.append(rs)
rs = RadioSetting("beep", "Beep",
RadioSettingValueBoolean(_settings.beep))
cfg_grp.append(rs)
rs = RadioSetting("radio", "Radio",
RadioSettingValueBoolean(_settings.radio))
cfg_grp.append(rs)
if self.MODEL == "TERMN-8R":
rs = RadioSetting("keylock", "Keylock",
RadioSettingValueBoolean(_settings.keylock))
cfg_grp.append(rs)
rs = RadioSetting("fastscan", "Fast Scan",
RadioSettingValueBoolean(_settings.fastscan))
cfg_grp.append(rs)
if self.MODEL == "OBLTR-8R":
# "pf2key" is used for OBLTR-8R "keylock"
rs = RadioSetting("pf2key", "Keylock",
RadioSettingValueBoolean(_settings.pf2key))
cfg_grp.append(rs)
rs = RadioSetting("fastscano", "Fast Scan",
RadioSettingValueBoolean(_settings.fastscano))
cfg_grp.append(rs)
rs = RadioSetting("uplink", "Up Bank Link Select",
RadioSettingValueBoolean(_settings.uplink))
cfg_grp.append(rs)
rs = RadioSetting("downlink", "Down Bank Link Select",
RadioSettingValueBoolean(_settings.downlink))
cfg_grp.append(rs)
#
# OEM info
#
val = RadioSettingValueString(0, 7, _filter(_oem.model))
val.set_mutable(False)
rs = RadioSetting("oem_info.model", "Model", val)
oem_grp.append(rs)
val = RadioSettingValueString(0, 9, _filter(_oem.date))
val.set_mutable(False)
rs = RadioSetting("oem_info.date", "Date", val)
oem_grp.append(rs)
val = RadioSettingValueString(0, 16, _filter(_oem.dealer))
val.set_mutable(False)
rs = RadioSetting("oem_info.dealer", "Dealer Code", val)
oem_grp.append(rs)
val = RadioSettingValueString(0, 9, _filter(_oem.stockdate))
val.set_mutable(False)
rs = RadioSetting("oem_info.stockdate", "Stock Date", val)
oem_grp.append(rs)
val = RadioSettingValueString(0, 9, _filter(_oem.selldate))
val.set_mutable(False)
rs = RadioSetting("oem_info.selldate", "Sell Date", val)
oem_grp.append(rs)
return group
def get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic")
cw = RadioSettingGroup("cw", "CW")
packet = RadioSettingGroup("packet", "Digital & packet")
panel = RadioSettingGroup("panel", "Panel settings")
extended = RadioSettingGroup("extended", "Extended")
antenna = RadioSettingGroup("antenna", "Antenna selection")
panelcontr = RadioSettingGroup("panelcontr", "Panel controls")
top = RadioSettings(basic, cw, packet, panelcontr, panel, extended,
antenna)
rs = RadioSetting("ars_144", "144 ARS",
RadioSettingValueBoolean(_settings.ars_144))
basic.append(rs)
rs = RadioSetting("ars_430", "430 ARS",
RadioSettingValueBoolean(_settings.ars_430))
basic.append(rs)
rs = RadioSetting(
"pkt9600_mic", "Paket 9600 mic level",
RadioSettingValueInteger(0, 100, _settings.pkt9600_mic))
packet.append(rs)
options = ["enable", "disable"]
rs = RadioSetting(
"disable_amfm_dial", "AM&FM Dial",
RadioSettingValueList(options,
options[_settings.disable_amfm_dial]))
panel.append(rs)
rs = RadioSetting("am_mic", "AM mic level",
RadioSettingValueInteger(0, 100, _settings.am_mic))
basic.append(rs)
options = ["OFF", "1h", "2h", "3h", "4h", "5h", "6h"]
rs = RadioSetting(
"apo_time", "APO time",
RadioSettingValueList(options, options[_settings.apo_time]))
basic.append(rs)
options = ["OFF", "Range", "All"]
rs = RadioSetting(
"arts_beep", "ARTS beep",
RadioSettingValueList(options, options[_settings.arts_beep]))
basic.append(rs)
options = ["OFF", "ON", "Auto"]
rs = RadioSetting(
"backlight", "Backlight",
RadioSettingValueList(options, options[_settings.backlight]))
panel.append(rs)
options = ["6h", "8h", "10h"]
rs = RadioSetting(
"batt_chg", "Battery charge",
RadioSettingValueList(options, options[_settings.batt_chg]))
basic.append(rs)
options = ["440Hz", "880Hz"]
rs = RadioSetting(
"beep_freq", "Beep frequency",
RadioSettingValueList(options, options[_settings.beep_freq]))
panel.append(rs)
rs = RadioSetting(
"beep_volume", "Beep volume",
RadioSettingValueInteger(0, 100, _settings.beep_volume))
panel.append(rs)
options = ["4800", "9600", "38400"]
rs = RadioSetting(
"cat_rate", "CAT rate",
RadioSettingValueList(options, options[_settings.cat_rate]))
basic.append(rs)
options = ["Blue", "Amber", "Violet"]
rs = RadioSetting(
"color", "Color",
RadioSettingValueList(options, options[_settings.color]))
panel.append(rs)
rs = RadioSetting(
"contrast", "Contrast",
RadioSettingValueInteger(1, 12, _settings.contrast - 1))
panel.append(rs)
rs = RadioSetting("cw_delay", "CW delay (*10 ms)",
RadioSettingValueInteger(1, 250, _settings.cw_delay))
cw.append(rs)
rs = RadioSetting("cw_id", "CW id",
RadioSettingValueBoolean(_settings.cw_id))
cw.append(rs)
options = ["Normal", "Reverse"]
rs = RadioSetting(
"cw_paddle", "CW paddle",
RadioSettingValueList(options, options[_settings.cw_paddle]))
cw.append(rs)
options = ["%i Hz" % i for i in range(300, 1001, 50)]
rs = RadioSetting(
"cw_pitch", "CW pitch",
RadioSettingValueList(options, options[_settings.cw_pitch]))
cw.append(rs)
options = ["%i wpm" % i for i in range(4, 61)]
rs = RadioSetting(
"cw_speed", "CW speed",
RadioSettingValueList(options, options[_settings.cw_speed]))
cw.append(rs)
options = ["1:%1.1f" % (i / 10) for i in range(25, 46, 1)]
rs = RadioSetting(
"cw_weight", "CW weight",
RadioSettingValueList(options, options[_settings.cw_weight]))
cw.append(rs)
rs = RadioSetting(
"dig_disp", "Dig disp (*10 Hz)",
RadioSettingValueInteger(-300, 300, _settings.dig_disp))
packet.append(rs)
rs = RadioSetting("dig_mic", "Dig mic",
RadioSettingValueInteger(0, 100, _settings.dig_mic))
packet.append(rs)
options = ["RTTY", "PSK31-L", "PSK31-U", "USER-L", "USER-U"]
rs = RadioSetting(
"dig_mode", "Dig mode",
RadioSettingValueList(options, options[_settings.dig_mode]))
packet.append(rs)
rs = RadioSetting(
"dig_shift", "Dig shift (*10 Hz)",
RadioSettingValueInteger(-300, 300, _settings.dig_shift))
packet.append(rs)
rs = RadioSetting("fm_mic", "FM mic",
RadioSettingValueInteger(0, 100, _settings.fm_mic))
basic.append(rs)
options = ["Dial", "Freq", "Panel"]
rs = RadioSetting(
"lock_mode", "Lock mode",
RadioSettingValueList(options, options[_settings.lock_mode]))
panel.append(rs)
options = ["Fine", "Coarse"]
rs = RadioSetting(
"main_step", "Main step",
RadioSettingValueList(options, options[_settings.main_step]))
panel.append(rs)
rs = RadioSetting("mem_group", "Mem group",
RadioSettingValueBoolean(_settings.mem_group))
basic.append(rs)
rs = RadioSetting("mic_key", "Mic key",
RadioSettingValueBoolean(_settings.mic_key))
cw.append(rs)
rs = RadioSetting("mic_scan", "Mic scan",
RadioSettingValueBoolean(_settings.mic_scan))
basic.append(rs)
options = ["Off", "SSB", "CW"]
rs = RadioSetting(
"op_filter", "Optional filter",
RadioSettingValueList(options, options[_settings.op_filter]))
basic.append(rs)
rs = RadioSetting("pkt_mic", "Packet mic",
RadioSettingValueInteger(0, 100, _settings.pkt_mic))
packet.append(rs)
options = ["1200", "9600"]
rs = RadioSetting(
"pkt_rate", "Packet rate",
RadioSettingValueList(options, options[_settings.pkt_rate]))
packet.append(rs)
options = ["Off", "3 sec", "5 sec", "10 sec"]
rs = RadioSetting(
"resume_scan", "Resume scan",
RadioSettingValueList(options, options[_settings.resume_scan]))
basic.append(rs)
options = ["Cont", "Chk"]
rs = RadioSetting(
"scope", "Scope",
RadioSettingValueList(options, options[_settings.scope]))
basic.append(rs)
rs = RadioSetting("sidetone", "Sidetone",
RadioSettingValueInteger(0, 100, _settings.sidetone))
cw.append(rs)
options = ["RF-Gain", "Squelch"]
rs = RadioSetting(
"sql_rf_gain", "Squelch/RF-Gain",
RadioSettingValueList(options, options[_settings.sql_rf_gain]))
panel.append(rs)
rs = RadioSetting("ssb_mic", "SSB Mic",
RadioSettingValueInteger(0, 100, _settings.ssb_mic))
basic.append(rs)
options = ["%i" % i for i in range(0, 21)]
options[0] = "Off"
rs = RadioSetting(
"tot_time", "Time-out timer",
RadioSettingValueList(options, options[_settings.tot_time]))
basic.append(rs)
rs = RadioSetting("vox_delay", "VOX delay (*100 ms)",
RadioSettingValueInteger(1, 25, _settings.vox_delay))
basic.append(rs)
rs = RadioSetting("vox_gain", "VOX Gain",
RadioSettingValueInteger(0, 100, _settings.vox_gain))
basic.append(rs)
rs = RadioSetting("extended_menu", "Extended menu",
RadioSettingValueBoolean(_settings.extended_menu))
extended.append(rs)
options = ["Tn-Rn", "Tn-Riv", "Tiv-Rn", "Tiv-Riv"]
rs = RadioSetting(
"dcs_inv", "DCS coding",
RadioSettingValueList(options, options[_settings.dcs_inv]))
extended.append(rs)
rs = RadioSetting(
"r_lsb_car", "LSB Rx carrier point (*10 Hz)",
RadioSettingValueInteger(-30, 30, _settings.r_lsb_car))
extended.append(rs)
rs = RadioSetting(
"r_usb_car", "USB Rx carrier point (*10 Hz)",
RadioSettingValueInteger(-30, 30, _settings.r_usb_car))
extended.append(rs)
rs = RadioSetting(
"t_lsb_car", "LSB Tx carrier point (*10 Hz)",
RadioSettingValueInteger(-30, 30, _settings.t_lsb_car))
extended.append(rs)
rs = RadioSetting(
"t_usb_car", "USB Tx carrier point (*10 Hz)",
RadioSettingValueInteger(-30, 30, _settings.t_usb_car))
extended.append(rs)
options = ["Hi", "L3", "L2", "L1"]
rs = RadioSetting(
"tx_power", "TX power",
RadioSettingValueList(options, options[_settings.tx_power]))
basic.append(rs)
options = ["Front", "Rear"]
rs = RadioSetting(
"hf_antenna", "HF",
RadioSettingValueList(options, options[_settings.hf_antenna]))
antenna.append(rs)
rs = RadioSetting(
"sixm_antenna", "6M",
RadioSettingValueList(options, options[_settings.sixm_antenna]))
antenna.append(rs)
rs = RadioSetting(
"bc_antenna", "Broadcasting",
RadioSettingValueList(options, options[_settings.bc_antenna]))
antenna.append(rs)
rs = RadioSetting(
"air_antenna", "Air band",
RadioSettingValueList(options, options[_settings.air_antenna]))
antenna.append(rs)
rs = RadioSetting(
"vhf_antenna", "VHF",
RadioSettingValueList(options, options[_settings.vhf_antenna]))
antenna.append(rs)
rs = RadioSetting(
"uhf_antenna", "UHF",
RadioSettingValueList(options, options[_settings.uhf_antenna]))
antenna.append(rs)
st = RadioSettingValueString(
0, 7,
''.join([self._CALLSIGN_CHARSET[x]
for x in self._memobj.callsign]))
st.set_charset(self._CALLSIGN_CHARSET)
rs = RadioSetting("callsign", "Callsign", st)
cw.append(rs)
rs = RadioSetting("spl", "Split",
RadioSettingValueBoolean(_settings.spl))
panelcontr.append(rs)
options = ["None", "Up", "Down"]
rs = RadioSetting(
"scn_mode", "Scan mode",
RadioSettingValueList(options, options[_settings.scn_mode]))
panelcontr.append(rs)
rs = RadioSetting("pri", "Priority",
RadioSettingValueBoolean(_settings.pri))
panelcontr.append(rs)
rs = RadioSetting("dw", "Dual watch",
RadioSettingValueBoolean(_settings.dw))
panelcontr.append(rs)
rs = RadioSetting("art", "Auto-range transponder",
RadioSettingValueBoolean(_settings.art))
panelcontr.append(rs)
rs = RadioSetting("nb", "Noise blanker",
RadioSettingValueBoolean(_settings.nb))
panelcontr.append(rs)
options = ["Auto", "Fast", "Slow", "Off"]
rs = RadioSetting(
"agc", "AGC", RadioSettingValueList(options,
options[_settings.agc]))
panelcontr.append(rs)
options = ["PWR", "ALC", "SWR", "MOD"]
rs = RadioSetting(
"pwr_meter_mode", "Power meter mode",
RadioSettingValueList(options, options[_settings.pwr_meter_mode]))
panelcontr.append(rs)
rs = RadioSetting("vox", "Vox",
RadioSettingValueBoolean(_settings.vox))
panelcontr.append(rs)
rs = RadioSetting("bk", "Semi break-in",
RadioSettingValueBoolean(_settings.bk))
cw.append(rs)
rs = RadioSetting("kyr", "Keyer",
RadioSettingValueBoolean(_settings.kyr))
cw.append(rs)
options = ["enabled", "disabled"]
rs = RadioSetting(
"fst", "Fast",
RadioSettingValueList(options, options[_settings.fst]))
panelcontr.append(rs)
options = ["enabled", "disabled"]
rs = RadioSetting(
"lock", "Lock",
RadioSettingValueList(options, options[_settings.lock]))
panelcontr.append(rs)
return top
def get_settings(self):
def _get(cmd):
return self._cmd('%s?' % cmd, 0).split(':')[1].strip()
cw = RadioSettingGroup('beacon', 'Beacon Settings')
cl = RadioSetting('CL%15s', 'CW Callsign',
RadioSettingValueString(0, 15, _get('CL')))
cw.append(cl)
cf = RadioSetting('CF%4i', 'CW Audio Frequency',
RadioSettingValueInteger(400, 1300, int(_get('CF'))))
cw.append(cf)
cs = RadioSetting('CS%02i', 'CW Speed',
RadioSettingValueInteger(5, 25, int(_get('CS'))))
cw.append(cs)
bc = RadioSetting('BC%03i', 'CW Beacon Timer',
RadioSettingValueInteger(0, 600, int(_get('BC'))))
cw.append(bc)
bm = RadioSetting('BM%15s', 'Beacon Message',
RadioSettingValueString(0, 15, _get('BM')))
cw.append(bm)
bt = RadioSetting('BT%03i', 'Beacon Timer',
RadioSettingValueInteger(0, 600, int(_get('BT'))))
cw.append(bt)
it = RadioSetting('IT%03i', 'CW ID Timer',
RadioSettingValueInteger(0, 500, int(_get('IT'))))
cw.append(it)
tg = RadioSetting('TG%7s', 'CW Timeout Message',
RadioSettingValueString(0, 7, _get('TG')))
cw.append(tg)
io = RadioSettingGroup('io', 'IO')
af = RadioSetting('AF%i', 'Arduino LPF',
RadioSettingValueBoolean(_get('AF') == 'ON'))
io.append(af)
input_pin = ['OFF', 'SQ OPEN', 'PTT']
ai = RadioSetting(
'AI%i', 'Arduino Input Pin',
RadioSettingValueList(input_pin, input_pin[int(_get('AI'))]))
io.append(ai)
output_pin = [
'LOW', 'SQ OPEN', 'DTMF DETECT', 'TX ON', 'CTCSS DET', 'HIGH'
]
ao = RadioSetting(
'AO%i', 'Arduino Output Pin',
RadioSettingValueList(output_pin, output_pin[int(_get('AO'))]))
io.append(ao)
bauds = [str(x) for x in BAUDS]
b1 = RadioSetting('B1%i', 'Arduino Baudrate',
RadioSettingValueList(bauds, bauds[int(_get('B1'))]))
io.append(b1)
b2 = RadioSetting('B2%i', 'Main Baudrate',
RadioSettingValueList(bauds, bauds[int(_get('B2'))]))
io.append(b2)
dtmf = RadioSettingGroup('dtmf', 'DTMF Settings')
dd = RadioSetting('DD%04i', 'DTMF Tone Duration',
RadioSettingValueInteger(50, 2000, int(_get('DD'))))
dtmf.append(dd)
dr = RadioSetting('DR%i', 'DTMF Tone Detector',
RadioSettingValueBoolean(_get('DR') == 'ON'))
dtmf.append(dr)
gt = RadioSetting('GT%02i', 'DTMF/CW Tone Gain',
RadioSettingValueInteger(0, 15, int(_get('GT'))))
dtmf.append(gt)
sd = RadioSetting('SD%i', 'DTMF/CW Side Tone',
RadioSettingValueBoolean(_get('SD') == 'ON'))
dtmf.append(sd)
general = RadioSettingGroup('general', 'General')
dp = RadioSetting('DP%i', 'Pre-Emphasis',
RadioSettingValueBoolean(_get('DP') == 'ON'))
general.append(dp)
fw = RadioSetting('_fw', 'Firmware Version',
RadioSettingValueString(0, 20, _get('FW')))
general.append(fw)
gm = RadioSetting('GM%02i', 'Mic Gain',
RadioSettingValueInteger(0, 15, int(_get('GM'))))
general.append(gm)
hp = RadioSetting('HP%i', 'Audio High-Pass Filter',
RadioSettingValueBoolean(_get('HP') == 'ON'))
general.append(hp)
ht = RadioSetting('HT%04i', 'Hang Time',
RadioSettingValueInteger(0, 5000, int(_get('HT'))))
general.append(ht)
ledmode = ['OFF', 'ON', 'SQ OPEN', 'BATT CHG STAT']
ld = RadioSetting(
'LD%i', 'LED Mode',
RadioSettingValueList(ledmode, ledmode[int(_get('LD'))]))
general.append(ld)
sq = RadioSetting('SQ%i', 'Squelch Level',
RadioSettingValueInteger(0, 9, int(_get('SQ'))))
general.append(sq)
to = RadioSetting('TO%03i', 'Timeout Timer',
RadioSettingValueInteger(0, 600, int(_get('TO'))))
general.append(to)
vu = RadioSetting('VU%02i', 'Receiver Audio Volume',
RadioSettingValueInteger(0, 39, int(_get('VU'))))
general.append(vu)
rc = RadioSetting('RC%i', 'Current Channel',
RadioSettingValueInteger(0, 9, 0))
rc.set_doc('Choosing one of these values causes the radio '
'to change to the selected channel. The radio '
'cannot tell CHIRP what channel is selected.')
general.append(rc)
return RadioSettings(general, cw, io, dtmf)