def get_settings(self): _mem = self._memobj basic = RadioSettingGroup("basic", "Basic") top = RadioSettings(basic) def _f(val): string = "" for char in str(val): if char == "\xFF": break string += char return string line1 = RadioSetting( "messages.line1", "Message Line 1", RadioSettingValueString(0, 32, _f(_mem.messages.line1), autopad=False)) basic.append(line1) line2 = RadioSetting( "messages.line2", "Message Line 2", RadioSettingValueString(0, 32, _f(_mem.messages.line2), autopad=False)) basic.append(line2) return top
def _get_display_settings(self): menu = RadioSettingGroup("display", "Display") display_settings = self._memobj.settings val = RadioSettingValueString( 0, 8, str(display_settings.power_on_msg).rstrip("\xFF")) rs = RadioSetting("display.power_on_msg", "Power on message", val) rs.set_apply_callback(self.apply_power_on_msg, display_settings) menu.append(rs) val = RadioSettingValueList( self._LCD_CONTRAST, self._LCD_CONTRAST[display_settings.contrast - 1]) rs = RadioSetting("display.contrast", "LCD Contrast", val) rs.set_apply_callback(self.apply_lcd_contrast, display_settings) menu.append(rs) val = RadioSettingValueList( self._LAMP_CONTROL, self._LAMP_CONTROL[display_settings.lamp_control]) rs = RadioSetting("display.lamp_control", "Lamp Control", val) rs.set_apply_callback(self.apply_lamp_control, display_settings) menu.append(rs) val = RadioSettingValueList( self._LAMP_TIMER, self._LAMP_TIMER[display_settings.lamp_timer - 2]) rs = RadioSetting("display.lamp_timer", "Lamp Timer", val) rs.set_apply_callback(self.apply_lamp_timer, display_settings) menu.append(rs) return menu
def get_string_setting(self, obj, valid_chars, desc1, desc2, group): content = '' maxlen = len(obj) for x in range(0, maxlen): content += chr(obj[x]) val = RadioSettingValueString(0, maxlen, content, True, valid_chars) rs = RadioSetting(desc1, desc2, val) rs.set_apply_callback(self.apply_str_to_bytearray, obj) group.append(rs)
def get_settings(self): _general = self._memobj.general _info = self._memobj.info basic = RadioSettingGroup("basic", "Basic") info = RadioSettingGroup("info", "Model Info") general = RadioSettingGroup("general", "General Settings") # top = RadioSettings(identity, basic) top = RadioSettings(general) general.append(RadioSetting( "dmrid", "DMR Radio ID", RadioSettingValueInteger(0, 100000000, _general.dmrid))) general.append(RadioSetting( "line1", "Startup Line 1", RadioSettingValueString(0, 10, utftoasc(str(_general.line1))))) general.append(RadioSetting( "line2", "Startup Line 2", RadioSettingValueString(0, 10, utftoasc(str(_general.line2))))) return top
def _decode_opening_message(self, opening_message): msg = "" for i in opening_message.message.padded_yaesu: if i == 0xFF: break msg += chr(int(i)) val = RadioSettingValueString(0, 16, msg) rs = RadioSetting("opening_message.message.padded_yaesu", "Opening Message", val) rs.set_apply_callback(self._apply_opening_message, opening_message.message.padded_yaesu) return rs
def _get_ost(self, parent): tones = chirp_common.TONES[:] def apply_tone(setting, index, which): if str(setting.value) == 'Off': val = 0xFFFF else: val = int(float(str(setting.value)) * 10) setattr(self._memobj.ost_tones[index], '%stone' % which, val) def _tones(): return ['Off'] + [str(x) for x in tones] for i in range(0, 40): _ost = self._memobj.ost_tones[i] ost = RadioSettingGroup('ost%i' % i, 'OST %i' % (i + 1)) cur = str(_ost.name).rstrip('\x00') name = RadioSetting('name%i' % i, 'Name', RadioSettingValueString(0, 12, cur)) ost.append(name) if _ost.rxtone == 0xFFFF: cur = 'Off' else: cur = round(int(_ost.rxtone) / 10.0, 1) if cur not in tones: LOG.debug('Non-standard OST rx tone %i %s' % (i, cur)) tones.append(cur) tones.sort() rx = RadioSetting('rxtone%i' % i, 'RX Tone', RadioSettingValueList(_tones(), str(cur))) rx.set_apply_callback(apply_tone, i, 'rx') ost.append(rx) if _ost.txtone == 0xFFFF: cur = 'Off' else: cur = round(int(_ost.txtone) / 10.0, 1) if cur not in tones: LOG.debug('Non-standard OST tx tone %i %s' % (i, cur)) tones.append(cur) tones.sort() tx = RadioSetting('txtone%i' % i, 'TX Tone', RadioSettingValueList(_tones(), str(cur))) tx.set_apply_callback(apply_tone, i, 'tx') ost.append(tx) parent.append(ost)
def get_settings(self): top = RadioSettings() aprs = RadioSettingGroup("aprs", "APRS") top.append(aprs) myc = self._memobj.aprs_my_callsign rs = RadioSetting( "aprs_my_callsign.call", "APRS My Callsign", RadioSettingValueString(0, 6, aprs_call_to_str(myc.call))) aprs.append(rs) rs = RadioSetting("aprs_my_callsign.ssid", "APRS My SSID", RadioSettingValueInteger(0, 15, myc.ssid)) aprs.append(rs) return top
def _get_dtmf_settings(self): menu = RadioSettingGroup("dtmf_settings", "DTMF") dtmf = self._memobj.scan_settings val = RadioSettingValueList( self._DTMF_MODE, self._DTMF_MODE[dtmf.dtmf_mode]) rs = RadioSetting("scan_settings.dtmf_mode", "DTMF Mode", val) menu.append(rs) val = RadioSettingValueList( self._DTMF_DELAY, self._DTMF_DELAY[dtmf.dtmf_delay]) rs = RadioSetting( "scan_settings.dtmf_delay", "DTMF Delay", val) menu.append(rs) val = RadioSettingValueList( self._DTMF_SPEED, self._DTMF_SPEED[dtmf.dtmf_speed]) rs = RadioSetting( "scan_settings.dtmf_speed", "DTMF Speed", val) menu.append(rs) for i in range(10): name = "dtmf_%02d" % (i + 1) if i == 9: name = "dtmf_%02d" % 0 dtmfsetting = self._memobj.dtmf[i] dtmfstr = "" for c in dtmfsetting.memory: if c == 0xFF: break if c < len(FT70_DTMF_CHARS): dtmfstr += FT70_DTMF_CHARS[c] dtmfentry = RadioSettingValueString(0, 16, dtmfstr) dtmfentry.set_charset( FT70_DTMF_CHARS + list("abcdef ")) # Allow input in lowercase, space ? validation fails otherwise rs = RadioSetting(name, name.upper(), dtmfentry) rs.set_apply_callback(self.apply_dtmf, i) menu.append(rs) return menu
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic") settings = RadioSettings(basic) display = ["Frequency", "Channel", "Name"] rs = RadioSetting("display", "Display", RadioSettingValueList(display, display[_settings.display])) basic.append(rs) apo = ["Off"] + ['%.1f hour(s)' % (0.5 * x) for x in range(1, 25)] rs = RadioSetting("apo", "Automatic Power Off", RadioSettingValueList(apo, apo[_settings.apo])) basic.append(rs) def filter(s): s_ = "" for i in range(0, 8): c = str(s[i]) s_ += (c if c in chirp_common.CHARSET_ASCII else "") return s_ rs = RadioSetting("welcome", "Welcome Message", RadioSettingValueString(0, 8, filter(_settings.welcome))) basic.append(rs) rs = RadioSetting("beep", "Beep Enabled", RadioSettingValueBoolean(_settings.beep)) basic.append(rs) mute = ["Off", "TX", "RX", "TX/RX"] rs = RadioSetting("mute", "Sub Band Mute", RadioSettingValueList(mute, mute[_settings.mute])) basic.append(rs) return settings
def get_settings(self): """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): """Translate the MEM_FORMAT structs into settings in the UI""" # Define mem struct write-back shortcuts _sets = self._memobj.settings _asf = self._memobj.asf _ssf = self._memobj.ssf _mex = self._memobj.exset _chm = self._memobj.ch_mem basic = RadioSettingGroup("basic", "Basic Settings") pvfo = RadioSettingGroup("pvfo", "VFO Band Edges") mena = RadioSettingGroup("mena", "Menu A") menb = RadioSettingGroup("menb", "Menu B") amode = RadioSettingGroup("amode", "Auto Mode") ssc = RadioSettingGroup("ssc", "Slow Scan") group = RadioSettings(basic, pvfo, mena, menb, amode, ssc) mhz1 = 1000000. # Callback functions def _my_readonly(setting, obj, atrb): """NOP callback, prevents writing the setting""" vx = 0 return def my_adjraw(setting, obj, atrb, fix=0, ndx=-1): """Callback for Integer add or subtract fix from value.""" vx = int(str(setting.value)) value = vx + int(fix) if value < 0: value = 0 if ndx < 0: setattr(obj, atrb, value) else: setattr(obj[ndx], atrb, value) return def my_mhz_val(setting, obj, atrb, ndx=-1): """ Callback to set freq back to Htz""" vx = float(str(setting.value)) vx = int(vx * mhz1) if ndx < 0: setattr(obj, atrb, vx) else: setattr(obj[ndx], atrb, vx) return def my_bool(setting, obj, atrb, ndx=-1): """ Callback to properly set boolean """ # set_settings is not setting [indexed] booleans??? vx = 0 if str(setting.value) == "True": vx = 1 if ndx < 0: setattr(obj, atrb, vx) else: setattr(obj[ndx], atrb, vx) return def my_asf_mode(setting, obj, nx=0): """ Callback to extract mode and create asmode, asdata """ v1 = TS480_MODES.index(str(setting.value)) v2 = 0 # asdata vx = v1 + 1 # stored as CAT values, same as xmode if v1 == 7: vx = 9 if v1 > 7: # a Data mode v2 = 1 if v1 == 8: vx = 1 # LSB elif v1 == 9: vx = 2 # USB elif v1 == 10: vx = 4 # FM setattr(obj[nx], "asdata", v2) setattr(obj[nx], "asmode", vx) return def my_fnctns(setting, obj, ndx, atrb): """ Filter only valid key function assignments """ vx = int(str(setting.value)) if vx > 79: vx = 99 # Off setattr(obj[ndx], atrb, vx) return def my_labels(kx): lbl = "%03i:" % kx # SG EX number lbl += self.EX_LBL[kx] # and the label to match return lbl # ===== BASIC GROUP ===== options = [ "TS-480HX (200W)", "TS-480SAT (100W + AT)", "Japanese 50W type", "Japanese 20W type" ] rx = RadioSettingValueString(14, 22, options[_sets.ty]) rset = RadioSetting("settings.ty", "FirmwareVersion", rx) rset.set_apply_callback(_my_readonly, _sets, "ty") basic.append(rset) rx = RadioSettingValueInteger(0, 255, _sets.ag) rset = RadioSetting("settings.ag", "AF Gain", rx) # rset.set_apply_callback(my_adjraw, _sets, "ag", -1) basic.append(rset) rx = RadioSettingValueInteger(0, 100, _sets.rg) rset = RadioSetting("settings.rg", "RF Gain", rx) # rset.set_apply_callback(my_adjraw, _sets, "rg", -1) basic.append(rset) options = ["ANT1", "ANT2"] # CAUTION: an has value of 1 or 2 rx = RadioSettingValueList(options, options[_sets.an - 1]) rset = RadioSetting("settings.an", "Antenna Selected", rx) # Add 1 to the changed value. S/b 1/2 rset.set_apply_callback(my_val_list, options, _sets, "an", 1) basic.append(rset) rx = RadioSettingValueInteger(0, 100, _sets.mg) rset = RadioSetting("settings.mg", "Microphone gain", rx) basic.append(rset) nx = 5 # Coarse step if bool(_mex[0].ex021): # Power Fine enabled in menu A nx = 1 vx = _sets.pc # Trap invalid values from run_tests.py if vx < 5: vx = 5 options = [200, 100, 50, 20] # subject to firmware rx = RadioSettingValueInteger(5, options[_sets.ty], vx, nx) sx = "TX Output power (Watts)" rset = RadioSetting("settings.pc", sx, rx) basic.append(rset) val = _sets.fa / mhz1 # valid range is for receiver rx = RadioSettingValueFloat(0.05, 60.0, val, 0.001, 3) sx = "VFO-A Frequency (MHz)" rset = RadioSetting("settings.fa", sx, rx) rset.set_apply_callback(my_mhz_val, _sets, "fa") basic.append(rset) val = _sets.fb / mhz1 rx = RadioSettingValueFloat(0.05, 60.0, val, 0.001, 3) sx = "VFO-B Frequency (MHz)" rset = RadioSetting("settings.fb", sx, rx) rset.set_apply_callback(my_mhz_val, _sets, "fb") basic.append(rset) options = ["Menu A", "Menu B"] rx = RadioSettingValueList(options, options[_sets.mf]) sx = "Menu Selected" rset = RadioSetting("settings.mf", sx, rx) rset.set_apply_callback(my_val_list, options, _sets, "mf") basic.append(rset) # ==== VFO Edges Group ================ for mx in range(100, 110): val = _chm[mx].rxfreq / mhz1 if val < 1.8: # Many operators never use this val = 1.8 # So default is 0.0 rx = RadioSettingValueFloat(1.8, 54.0, val, 0.001, 3) sx = "VFO-Band %i lower limit (MHz)" % (mx - 100) rset = RadioSetting("ch_mem.rxfreq/%d" % mx, sx, rx) rset.set_apply_callback(my_mhz_val, _chm, "rxfreq", mx) pvfo.append(rset) val = _chm[mx].txfreq / mhz1 if val < 1.8: val = 54.0 rx = RadioSettingValueFloat(1.8, 54.0, val, 0.001, 3) sx = " VFO-Band %i upper limit (MHz)" % (mx - 100) rset = RadioSetting("ch_mem.txfreq/%d" % mx, sx, rx) rset.set_apply_callback(my_mhz_val, _chm, "txfreq", mx) pvfo.append(rset) kx = _chm[mx].xmode options = [ "None", "LSB", "USB", "CW", "FM", "AM", "FSK", "CW-R", "N/A", "FSK-R" ] rx = RadioSettingValueList(options, options[kx]) sx = " VFO-Band %i Tx/Rx Mode" % (mx - 100) rset = RadioSetting("ch_mem.xmode/%d" % mx, sx, rx) rset.set_apply_callback(my_val_list, options, _chm, "xmode", 0, mx) pvfo.append(rset) # ==== Menu A/B Group ================= for mx in range(2): # A/B index sx = my_labels(0) rx = RadioSettingValueInteger(0, 4, _mex[mx].ex000) rset = RadioSetting("exset.ex000", sx, rx) if mx == 0: mena.append(rset) else: menb.append(rset) rx = RadioSettingValueInteger(0, 9, _mex[mx].ex012) sx = my_labels(12) rset = RadioSetting("exset.ex012", sx, rx) if mx == 0: mena.append(rset) else: menb.append(rset) sx = my_labels(13) rx = RadioSettingValueInteger(0, 9, _mex[mx].ex013) rset = RadioSetting("exset.ex013", sx, rx) if mx == 0: mena.append(rset) else: menb.append(rset) sx = my_labels(14) rx = RadioSettingValueInteger(0, 9, _mex[mx].ex014) rset = RadioSetting("exset.ex014", sx, rx) if mx == 0: mena.append(rset) else: menb.append(rset) options = ["250", "500", "1000"] rx = RadioSettingValueList(options, options[_mex[mx].ex003]) sx = my_labels(3) rset = RadioSetting("exset.ex003/%d" % mx, sx, rx) rset.set_apply_callback(my_val_list, options, _mex, "ex003", 0, mx) if mx == 0: mena.append(rset) else: menb.append(rset) rx = RadioSettingValueBoolean(bool(_mex[mx].ex007)) sx = my_labels(7) rset = RadioSetting("exset.ex007/%d" % mx, sx, rx) rset.set_apply_callback(my_bool, _mex, "ex007", mx) if mx == 0: mena.append(rset) else: menb.append(rset) rx = RadioSettingValueBoolean(bool(_mex[mx].ex008)) sx = my_labels(8) rset = RadioSetting("exset.ex008/%d" % mx, sx, rx) rset.set_apply_callback(my_bool, _mex, "ex008", mx) if mx == 0: mena.append(rset) else: menb.append(rset) options = ["100", "200", "300", "400", "500"] rx = RadioSettingValueList(options, options[_mex[mx].ex009]) sx = my_labels(9) rset = RadioSetting("exset.ex009/%d" % mx, sx, rx) rset.set_apply_callback(my_val_list, options, _mex, "ex009", 0, mx) if mx == 0: mena.append(rset) else: menb.append(rset) rx = RadioSettingValueBoolean(bool(_mex[mx].ex010)) sx = my_labels(10) rset = RadioSetting("exset.ex010/%d" % mx, sx, rx) rset.set_apply_callback(my_bool, _mex, "ex010", mx) if mx == 0: mena.append(rset) else: menb.append(rset) options = ["TO", "CO"] rx = RadioSettingValueList(options, options[_mex[mx].ex011]) sx = my_labels(11) rset = RadioSetting("exset.ex011/%d" % mx, sx, rx) rset.set_apply_callback(my_val_list, options, _mex, "ex011", 0, mx) if mx == 0: mena.append(rset) else: menb.append(rset) rx = RadioSettingValueBoolean(bool(_mex[mx].ex021)) sx = my_labels(21) rset = RadioSetting("exset.ex021/%d" % mx, sx, rx) rset.set_apply_callback(my_bool, _mex, "ex021", mx) if mx == 0: mena.append(rset) else: menb.append(rset) options = ["Off", "3", "5", "10", "20", "30"] rx = RadioSettingValueList(options, options[_mex[mx].ex022]) sx = my_labels(22) rset = RadioSetting("exset.ex022/%d" % mx, sx, rx) rset.set_apply_callback(my_val_list, options, _mex, "ex022", 0, mx) if mx == 0: mena.append(rset) else: menb.append(rset) rx = RadioSettingValueInteger(0, 99, _mex[mx].ex048) sx = my_labels(48) rset = RadioSetting("exset.ex048/%d" % mx, sx, rx) rset.set_apply_callback(my_fnctns, _mex, mx, "ex048") if mx == 0: mena.append(rset) else: menb.append(rset) rx = RadioSettingValueInteger(0, 99, _mex[mx].ex049) sx = my_labels(49) rset = RadioSetting("exset.ex049/%d" % mx, sx, rx) rset.set_apply_callback(my_fnctns, _mex, mx, "ex049") if mx == 0: mena.append(rset) else: menb.append(rset) rx = RadioSettingValueInteger(0, 99, _mex[mx].ex050) sx = my_labels(50) rset = RadioSetting("exset.ex050/%d" % mx, sx, rx) rset.set_apply_callback(my_fnctns, _mex, mx, "ex050") if mx == 0: mena.append(rset) else: menb.append(rset) rx = RadioSettingValueInteger(0, 99, _mex[mx].ex051) sx = my_labels(51) rset = RadioSetting("exset.ex051/%d" % mx, sx, rx) rset.set_apply_callback(my_fnctns, _mex, mx, "ex051") if mx == 0: mena.append(rset) else: menb.append(rset) rx = RadioSettingValueInteger(0, 99, _mex[mx].ex052) sx = my_labels(52) rset = RadioSetting("exset.ex052/%d" % mx, sx, rx) rset.set_apply_callback(my_fnctns, _mex, mx, "ex052") if mx == 0: mena.append(rset) else: menb.append(rset) # End of for mx loop # ==== Auto Scan Params (amode) ============== for ix in range(32): val = _asf[ix].asfreq / mhz1 rx = RadioSettingValueFloat(0.03, 60.0, val, 0.001, 3) rset = RadioSetting("asf.asfreq/%d" % ix, "Scan %02i Freq (MHz)" % ix, rx) rset.set_apply_callback(my_mhz_val, _asf, "asfreq", ix) amode.append(rset) mx = _asf[ix].asmode - 1 # Same logic as xmode if _asf[ix].asmode == 9: mx = 7 rx = RadioSettingValueList(TS480_MODES, TS480_MODES[mx]) rset = RadioSetting("asf.asmode/%d" % ix, " Mode", rx) rset.set_apply_callback(my_asf_mode, _asf, ix) amode.append(rset) # ==== Slow Scan Settings === for ix in range(10): # Chans for nx in range(5): # spots px = ((ix * 5) + nx) val = _ssf[px].ssfreq / mhz1 stx = " - - - Slot %02i Freq (MHz)" % nx if nx == 0: stx = "Slow Scan %02i, Slot 0 Freq (MHz" % ix rx = RadioSettingValueFloat(0, 54.0, val, 0.001, 3) rset = RadioSetting("ssf.ssfreq/%d" % px, stx, rx) rset.set_apply_callback(my_mhz_val, _ssf, "ssfreq", px) ssc.append(rset) return group # END get_settings()
def get_settings(self): _settings = self._memobj.settings _mem = self._memobj basic = RadioSettingGroup("basic", "Basic Settings") dtmf = RadioSettingGroup("dtmf", "DTMF Settings") top = RadioSettings(basic, dtmf) if _settings.k1shortp > 5: val = 4 else: val = _settings.k1shortp rs = RadioSetting( "k1shortp", "Key 1 Short Press", RadioSettingValueList(LIST_SHORT_PRESS, LIST_SHORT_PRESS[val])) basic.append(rs) if _settings.k1longp > 5: val = 5 else: val = _settings.k1longp rs = RadioSetting( "k1longp", "Key 1 Long Press", RadioSettingValueList(LIST_LONG_PRESS, LIST_LONG_PRESS[val])) basic.append(rs) if _settings.k2shortp > 5: val = 1 else: val = _settings.k2shortp rs = RadioSetting( "k2shortp", "Key 2 Short Press", RadioSettingValueList(LIST_SHORT_PRESS, LIST_SHORT_PRESS[val])) basic.append(rs) if _settings.k2longp > 5: val = 3 else: val = _settings.k2longp rs = RadioSetting( "k2longp", "Key 2 Long Press", RadioSettingValueList(LIST_LONG_PRESS, LIST_LONG_PRESS[val])) basic.append(rs) rs = RadioSetting("vox", "VOX", RadioSettingValueBoolean(not _settings.vox)) basic.append(rs) if _settings.voxg > 8: val = 4 else: val = _settings.voxg + 1 rs = RadioSetting("voxg", "VOX Gain", RadioSettingValueInteger(1, 9, val)) basic.append(rs) rs = RadioSetting( "voxd", "VOX Delay Time", RadioSettingValueList(LIST_VOXDELAY, LIST_VOXDELAY[_settings.voxd])) basic.append(rs) rs = RadioSetting("voxi", "VOX Inhibit on Receive", RadioSettingValueBoolean(_settings.voxi)) basic.append(rs) if _settings.squelch > 9: val = 5 else: val = _settings.squelch rs = RadioSetting("squelch", "Squelch Level", RadioSettingValueInteger(0, 9, val)) basic.append(rs) if _settings.voice == 3: val = 1 else: val = _settings.voice rs = RadioSetting("voice", "Voice Prompts", RadioSettingValueList(LIST_VOICE, LIST_VOICE[val])) basic.append(rs) rs = RadioSetting("tone", "Tone", RadioSettingValueBoolean(_settings.tone)) basic.append(rs) rs = RadioSetting("lovoltnotx", "TX Inhibit (when battery < 6 volts)", RadioSettingValueBoolean(_settings.lovoltnotx)) basic.append(rs) rs = RadioSetting("hivoltnotx", "TX Inhibit (when battery > 9 volts)", RadioSettingValueBoolean(_settings.hivoltnotx)) basic.append(rs) if _settings.tot > 0x28: val = 6 else: val = _settings.tot rs = RadioSetting( "tot", "Time-out Timer[s]", RadioSettingValueList(LIST_TIMEOUTTIMER, LIST_TIMEOUTTIMER[val])) basic.append(rs) if _settings.save < 3: val = 0 else: val = _settings.save - 3 rs = RadioSetting("save", "Battery Saver", RadioSettingValueList(LIST_SAVE, LIST_SAVE[val])) basic.append(rs) rs = RadioSetting( "ssave", "Super Battery Saver[s]", RadioSettingValueList(LIST_SSAVE, LIST_SSAVE[_settings.ssave])) basic.append(rs) rs = RadioSetting("fmradio", "Broadcast FM", RadioSettingValueBoolean(_settings.fmradio)) basic.append(rs) if _settings.scanspeed > 8: val = 4 else: val = _settings.scanspeed rs = RadioSetting( "scanspeed", "Scan Speed[ms]", RadioSettingValueList(LIST_SCANSPEED, LIST_SCANSPEED[val])) basic.append(rs) if _settings.scandelay > 27: val = 12 else: val = _settings.scandelay rs = RadioSetting( "scandelay", "Scan Droupout Delay Time[s]", RadioSettingValueList(LIST_SCANDELAY, LIST_SCANDELAY[val])) basic.append(rs) if _mem.dtmf.dtmfspd > 11: val = 2 else: val = _mem.dtmf.dtmfspd + 4 rs = RadioSetting("dtmf.dtmfspd", "DTMF Speed[digit/s]", RadioSettingValueInteger(4, 15, val)) dtmf.append(rs) if _mem.dtmf.digtime > 10: val = 0 else: val = _mem.dtmf.digtime rs = RadioSetting( "dtmf.digtime", "1st Digit Time[ms]", RadioSettingValueList(LIST_DIGTIME, LIST_DIGTIME[val])) dtmf.append(rs) if _mem.dtmf.digdelay > 9: val = 0 else: val = _mem.dtmf.digdelay rs = RadioSetting( "dtmf.digdelay", "1st Digit Delay[ms]", RadioSettingValueList(LIST_DIGDELAY, LIST_DIGDELAY[val])) dtmf.append(rs) rs = RadioSetting( "dtmf.starhash", "* and # Time[ms]", RadioSettingValueList(LIST_STARHASH, LIST_STARHASH[_mem.dtmf.starhash])) dtmf.append(rs) rs = RadioSetting( "dtmf.codespace", "Code Space Time[ms]", RadioSettingValueList(LIST_CODESPACE, LIST_CODESPACE[_mem.dtmf.codespace])) dtmf.append(rs) rs = RadioSetting("dtmf.sidetone", "DTMF Sidetone", RadioSettingValueBoolean(_mem.dtmf.sidetone)) dtmf.append(rs) # setup pttid entries for i in range(0, 2): objname = "code" + str(i + 1) names = ["PTT ID(BOT)", "PTT ID(EOT)"] strname = str(names[i]) dtmfsetting = getattr(_mem.dtmf, objname) dtmflen = getattr(_mem.dtmf, objname + "_len") dtmfstr = self._bbcd2dtmf(dtmfsetting, dtmflen) code = RadioSettingValueString(0, 16, dtmfstr) code.set_charset(DTMF_CHARSET + list(" ")) rs = RadioSetting("dtmf." + objname, strname, code) dtmf.append(rs) def _filter(name): filtered = "" for char in str(name): if char in NUMERIC_CHARSET: filtered += char else: filtered += " " return filtered # setup id code entry codesetting = getattr(_mem.dtmf, "idcode") codestr = self._bbcd2num(codesetting, 6) code = RadioSettingValueString(0, 6, _filter(codestr)) code.set_charset(NUMERIC_CHARSET + list(" ")) rs = RadioSetting("dtmf.idcode", "ID Code", code) dtmf.append(rs) if _mem.dtmf.groupcode > 6: val = 0 else: val = _mem.dtmf.groupcode rs = RadioSetting( "dtmf.groupcode", "Group Code", RadioSettingValueList(LIST_GROUPCODE, LIST_GROUPCODE[val])) dtmf.append(rs) if _mem.dtmf.resettime > 60: val = 0 else: val = _mem.dtmf.resettime rs = RadioSetting( "dtmf.resettime", "Auto Reset Time[s]", RadioSettingValueList(LIST_RESETTIME, LIST_RESETTIME[_mem.dtmf.resettime])) dtmf.append(rs) rs = RadioSetting("dtmf.txdecode", "TX Decode", RadioSettingValueBoolean(_mem.dtmf.txdecode)) dtmf.append(rs) rs = RadioSetting( "dtmf.decodeto", "Decode Time Out[ms]", RadioSettingValueList(LIST_DECODETO, LIST_DECODETO[_mem.dtmf.decodeto])) dtmf.append(rs) rs = RadioSetting("dtmf.decodetone", "Decode Tone", RadioSettingValueBoolean(_mem.dtmf.decodetone)) dtmf.append(rs) rs = RadioSetting("dtmf.resettone", "Reset Tone", RadioSettingValueBoolean(_mem.dtmf.resettone)) dtmf.append(rs) rs = RadioSetting( "dtmf.stuntype", "Stun Type", RadioSettingValueList(LIST_STUNTYPE, LIST_STUNTYPE[_mem.dtmf.stuntype])) dtmf.append(rs) ## setup stun entry objname = "code3" strname = "Stun Code" dtmfsetting = getattr(_mem.dtmf, objname) dtmflen = getattr(_mem.dtmf, objname + "_len") dtmfstr = self._bbcd2dtmf(dtmfsetting, dtmflen) code = RadioSettingValueString(0, 10, dtmfstr) code.set_charset(DTMF_CHARSET + list(" ")) rs = RadioSetting("dtmf." + objname, strname, code) dtmf.append(rs) return top
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic Settings") group = RadioSettings(basic) options = ["Time", "Carrier", "Search"] rs = RadioSetting( "scantype", "Scan Type", RadioSettingValueList(options, options[_settings.scantype])) basic.append(rs) options = ["Off"] + ["%s min" % x for x in range(1, 8)] rs = RadioSetting( "timeout", "Time Out Timer", RadioSettingValueList(options, options[_settings.timeout])) basic.append(rs) options = ["A", "B"] rs = RadioSetting( "freqmode_ab", "Frequency Mode", RadioSettingValueList(options, options[_settings.freqmode_ab])) basic.append(rs) options = ["Frequency Mode", "Channel Mode"] rs = RadioSetting( "workmode_a", "Radio Work Mode(A)", RadioSettingValueList(options, options[_settings.workmode_a])) basic.append(rs) rs = RadioSetting( "workmode_b", "Radio Work Mode(B)", RadioSettingValueList(options, options[_settings.workmode_b])) basic.append(rs) options = ["Frequency", "Name", "Channel"] rs = RadioSetting( "mdf_a", "Display Format(F1)", RadioSettingValueList(options, options[_settings.mdf_a])) basic.append(rs) rs = RadioSetting( "mdf_b", "Display Format(F2)", RadioSettingValueList(options, options[_settings.mdf_b])) basic.append(rs) rs = RadioSetting( "mem_chan_a", "Mem Channel (A)", RadioSettingValueInteger(1, 99, _settings.mem_chan_a)) basic.append(rs) rs = RadioSetting( "mem_chan_b", "Mem Channel (B)", RadioSettingValueInteger(1, 99, _settings.mem_chan_b)) basic.append(rs) options = ["Off", "BOT", "EOT", "Both"] rs = RadioSetting( "pttid", "PTT-ID", RadioSettingValueList(options, options[_settings.pttid])) basic.append(rs) dtmfchars = "0123456789ABCD*#" _codeobj = self._memobj.pttid.code _code = "".join([dtmfchars[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 6, _code, False) val.set_charset(dtmfchars) rs = RadioSetting("pttid.code", "PTT-ID Code", val) def apply_code(setting, obj): code = [] for j in range(0, 6): try: code.append(dtmfchars.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.code = code rs.set_apply_callback(apply_code, self._memobj.pttid) basic.append(rs) rs = RadioSetting("squelch", "Squelch Level", RadioSettingValueInteger(0, 9, _settings.squelch)) basic.append(rs) rs = RadioSetting("vox", "VOX Level", RadioSettingValueInteger(0, 9, _settings.vox)) basic.append(rs) options = ["Frequency Mode", "Channel Mode"] rs = RadioSetting( "workmode_fm", "FM Work Mode", RadioSettingValueList(options, options[_settings.workmode_fm])) basic.append(rs) options = ["Current Frequency", "F1 Frequency", "F2 Frequency"] rs = RadioSetting( "txtdr", "Dual Standby TX Priority", RadioSettingValueList(options, options[_settings.txtdr])) basic.append(rs) options = ["English", "Chinese"] rs = RadioSetting( "language", "Language", RadioSettingValueList(options, options[_settings.language])) basic.append(rs) rs = RadioSetting("tdr", "Dual Standby", RadioSettingValueBoolean(_settings.tdr)) basic.append(rs) rs = RadioSetting("roger", "Roger Beep", RadioSettingValueBoolean(_settings.roger)) basic.append(rs) rs = RadioSetting("backlight", "Backlight", RadioSettingValueBoolean(_settings.backlight)) basic.append(rs) rs = RadioSetting("save_funct", "Save Mode", RadioSettingValueBoolean(_settings.save_funct)) basic.append(rs) rs = RadioSetting("fm", "FM Function", RadioSettingValueBoolean(_settings.fm)) basic.append(rs) rs = RadioSetting( "beep_tone_disabled", "Beep Prompt", RadioSettingValueBoolean(not _settings.beep_tone_disabled)) basic.append(rs) rs = RadioSetting("voice_prompt", "Voice Prompt", RadioSettingValueBoolean(_settings.voice_prompt)) basic.append(rs) rs = RadioSetting("sidetone", "DTMF Side Tone", RadioSettingValueBoolean(_settings.sidetone)) basic.append(rs) rs = RadioSetting("ste_disabled", "Squelch Tail Eliminate", RadioSettingValueBoolean(not _settings.ste_disabled)) basic.append(rs) _limit = int(self._memobj.limits.lower_vhf) / 10 rs = RadioSetting("limits.lower_vhf", "VHF Lower Limit (MHz)", RadioSettingValueInteger(128, 270, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.lower_vhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) _limit = int(self._memobj.limits.upper_vhf) / 10 rs = RadioSetting("limits.upper_vhf", "VHF Upper Limit (MHz)", RadioSettingValueInteger(128, 270, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.upper_vhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) _limit = int(self._memobj.limits.lower_uhf) / 10 rs = RadioSetting("limits.lower_uhf", "UHF Lower Limit (MHz)", RadioSettingValueInteger(400, 520, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.lower_uhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) _limit = int(self._memobj.limits.upper_uhf) / 10 rs = RadioSetting("limits.upper_uhf", "UHF Upper Limit (MHz)", RadioSettingValueInteger(400, 520, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.upper_uhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) fm_preset = RadioSettingGroup("fm_preset", "FM Radio Presets") group.append(fm_preset) for i in range(0, 16): if self._memobj.fm_presets[i] < 0x01AF: used = True preset = self._memobj.fm_presets[i] / 10.0 + 65 else: used = False preset = 65 rs = RadioSetting("fm_presets_%1i" % i, "FM Preset %i" % (i + 1), RadioSettingValueBoolean(used), RadioSettingValueFloat(65, 108, preset, 0.1, 1)) fm_preset.append(rs) testmode = RadioSettingGroup("testmode", "Test Mode Settings") group.append(testmode) vhfdata = [ "136-139", "140-144", "145-149", "150-154", "155-159", "160-164", "165-169", "170-174" ] uhfdata = [ "400-409", "410-419", "420-429", "430-439", "440-449", "450-459", "460-469", "470-479" ] powernamedata = ["Hi", "Lo"] powerkeydata = ["hipwr", "lopwr"] for power in range(0, 2): for index in range(0, 8): key = "test.vhf%s%i" % (powerkeydata[power], index) name = "%s Mhz %s Power" % (vhfdata[index], powernamedata[power]) rs = RadioSetting( key, name, RadioSettingValueInteger( 0, 255, getattr(self._memobj.test, "vhf%s%i" % (powerkeydata[power], index)))) testmode.append(rs) for power in range(0, 2): for index in range(0, 8): key = "test.uhf%s%i" % (powerkeydata[power], index) name = "%s Mhz %s Power" % (uhfdata[index], powernamedata[power]) rs = RadioSetting( key, name, RadioSettingValueInteger( 0, 255, getattr(self._memobj.test, "uhf%s%i" % (powerkeydata[power], index)))) testmode.append(rs) for band in ["vhf", "uhf"]: for index in range(0, 10): key = "test.%ssquelch%i" % (band, index) name = "%s Squelch %i" % (band.upper(), index) rs = RadioSetting( key, name, RadioSettingValueInteger( 0, 255, getattr(self._memobj.test, "%ssquelch%i" % (band, index)))) testmode.append(rs) return group
def get_settings(self): 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_zones(self): zones = RadioSettingGroup('zones', 'Zones') zone_count = RadioSetting('_zonecount', 'Number of Zones', RadioSettingValueInteger( 1, 128, len(self._zones))) zone_count.set_doc('Number of zones in the radio. ' 'Requires a save and re-load of the ' 'file to take effect. Reducing this number ' 'will DELETE memories in affected zones!') zones.append(zone_count) for i in range(len(self._zones)): zone = RadioSettingGroup('zone%i' % i, 'Zone %i' % (i + 1)) _zone = getattr(self._memobj, 'zone%i' % i).zoneinfo _name = str(_zone.name).rstrip('\x00') name = RadioSetting('name%i' % i, 'Name', RadioSettingValueString(0, 12, _name)) zone.append(name) def apply_timer(setting, key): val = int(setting.value) if val == 0: val = 0xFFFF setattr(_zone, key, val) def collapse(val): val = int(val) if val == 0xFFFF: val = 0 return val timer = RadioSetting( 'timeout', 'Time-out Timer', RadioSettingValueInteger(15, 1200, collapse(_zone.timeout))) timer.set_apply_callback(apply_timer, 'timeout') zone.append(timer) timer = RadioSetting( 'tot_alert', 'TOT Pre-Alert', RadioSettingValueInteger(0, 10, collapse(_zone.tot_alert))) timer.set_apply_callback(apply_timer, 'tot_alert') zone.append(timer) timer = RadioSetting( 'tot_rekey', 'TOT Re-Key Time', RadioSettingValueInteger(0, 60, collapse(_zone.tot_rekey))) timer.set_apply_callback(apply_timer, 'tot_rekey') zone.append(timer) timer = RadioSetting( 'tot_reset', 'TOT Reset Time', RadioSettingValueInteger(0, 15, collapse(_zone.tot_reset))) timer.set_apply_callback(apply_timer, 'tot_reset') zone.append(timer) zone.append(self._inverted_flag_setting( 'bcl_override', 'BCL Override', _zone)) zones.append(zone) return zones
def get_settings(self): """Translate the bit in the mem_struct into settings in the UI""" _mem = self._memobj basic = RadioSettingGroup("basic", "Basic") 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) power = RadioSetting("settings.power", "Actual Power", RadioSettingValueList(POWER_LEVELS, POWER_LEVELS[_mem.settings.power])) basic.append(power) 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) 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("VFO freq not set, setting it to default %s" % self._VFO_DEFAULT) vfo = self._VFO_DEFAULT else: vfo = int(_mem.vfo.vrx_freq) * 10 vf_freq = RadioSetting("vfo.vrx_freq", "VFO frequency", RadioSettingValueString(0, 10, chirp_common.format_freq(vfo))) 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("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("settings.vfo_shift", "VFO Offset", RadioSettingValueString(0, 9, chirp_common.format_freq(vfo_shift))) work.append(offset) step = RadioSetting("settings.step", "VFO step", RadioSettingValueList(STEPF, STEPF[_mem.settings.step])) work.append(step) # at least for FD-268A/B it doesn't work as stated, so disabled # by now #scamble = RadioSetting("vfo.scramble", "Scramble", #RadioSettingValueList(ONOFF, #ONOFF[int(_mem.vfo.scramble)])) #work.append(scamble) #busy_lock = RadioSetting("vfo.busy_lock", "Busy Lock out", #RadioSettingValueList(ONOFF, #ONOFF[int(_mem.vfo.busy_lock)])) #work.append(busy_lock) # FD-288 Family ANI settings if "FD-288" in self.MODEL: ani_mode = RadioSetting("settings.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("settings.ani", "ANI (200-999)", RadioSettingValueString(0, 3, ani_value)) work.append(ani) return top
def _get_settings(self): _settings = self._memobj.settings _vfoa = self._memobj.vfoa _vfob = self._memobj.vfob cfg_grp = RadioSettingGroup("cfg_grp", "Configuration") vfoa_grp = RadioSettingGroup("vfoa_grp", "VFO A Settings") vfob_grp = RadioSettingGroup("vfob_grp", "VFO B Settings") key_grp = RadioSettingGroup("key_grp", "Key Settings") lmt_grp = RadioSettingGroup("lmt_grp", "Frequency Limits") uhf_lmt_grp = RadioSettingGroup("uhf_lmt_grp", "UHF") vhf_lmt_grp = RadioSettingGroup("vhf_lmt_grp", "VHF") vhf1_lmt_grp = RadioSettingGroup("vhf1_lmt_grp", "VHF1") oem_grp = RadioSettingGroup("oem_grp", "OEM Info") lmt_grp.append(vhf_lmt_grp); lmt_grp.append(vhf1_lmt_grp); lmt_grp.append(uhf_lmt_grp); group = RadioSettings(cfg_grp, vfoa_grp, vfob_grp, key_grp, lmt_grp, oem_grp) # # Configuration Settings # rs = RadioSetting("channel_menu", "Menu available in channel mode", RadioSettingValueBoolean(_settings.channel_menu)) cfg_grp.append(rs) rs = RadioSetting("ponmsg", "Poweron message", RadioSettingValueList( PONMSG_LIST, PONMSG_LIST[_settings.ponmsg])) cfg_grp.append(rs) rs = RadioSetting("voice", "Voice Guide", RadioSettingValueBoolean(_settings.voice)) cfg_grp.append(rs) rs = RadioSetting("language", "Language", RadioSettingValueList(LANGUAGE_LIST, LANGUAGE_LIST[_settings. language])) cfg_grp.append(rs) rs = RadioSetting("timeout", "Timeout Timer", RadioSettingValueList( TIMEOUT_LIST, TIMEOUT_LIST[_settings.timeout])) cfg_grp.append(rs) rs = RadioSetting("toalarm", "Timeout Alarm", RadioSettingValueInteger(0, 10, _settings.toalarm)) cfg_grp.append(rs) rs = RadioSetting("roger_beep", "Roger Beep", RadioSettingValueList(ROGER_LIST, ROGER_LIST[_settings.roger_beep])) cfg_grp.append(rs) rs = RadioSetting("power_save", "Power save", RadioSettingValueBoolean(_settings.power_save)) cfg_grp.append(rs) rs = RadioSetting("autolock", "Autolock", RadioSettingValueBoolean(_settings.autolock)) cfg_grp.append(rs) rs = RadioSetting("keylock", "Keypad Lock", RadioSettingValueBoolean(_settings.keylock)) cfg_grp.append(rs) rs = RadioSetting("beep", "Keypad Beep", RadioSettingValueBoolean(_settings.beep)) cfg_grp.append(rs) rs = RadioSetting("stopwatch", "Stopwatch", RadioSettingValueBoolean(_settings.stopwatch)) cfg_grp.append(rs) rs = RadioSetting("backlight", "Backlight", RadioSettingValueList(BACKLIGHT_LIST, BACKLIGHT_LIST[_settings. backlight])) cfg_grp.append(rs) rs = RadioSetting("dtmf_st", "DTMF Sidetone", RadioSettingValueList(DTMFST_LIST, DTMFST_LIST[_settings. dtmf_st])) cfg_grp.append(rs) rs = RadioSetting("ani_sw", "ANI-ID Switch", RadioSettingValueBoolean(_settings.ani_sw)) cfg_grp.append(rs) rs = RadioSetting("ptt_id", "PTT-ID Delay", RadioSettingValueList(PTTID_LIST, PTTID_LIST[_settings.ptt_id])) cfg_grp.append(rs) rs = RadioSetting("ring_time", "Ring Time", RadioSettingValueList(LIST_10, LIST_10[_settings.ring_time])) cfg_grp.append(rs) rs = RadioSetting("scan_rev", "Scan Mode", RadioSettingValueList(SCANMODE_LIST, SCANMODE_LIST[_settings. scan_rev])) cfg_grp.append(rs) rs = RadioSetting("vox", "VOX", RadioSettingValueList(LIST_10, LIST_10[_settings.vox])) cfg_grp.append(rs) rs = RadioSetting("prich_sw", "Priority Channel Switch", RadioSettingValueBoolean(_settings.prich_sw)) cfg_grp.append(rs) rs = RadioSetting("pri_ch", "Priority Channel", RadioSettingValueInteger(1, 999, _settings.pri_ch)) cfg_grp.append(rs) rs = RadioSetting("rpt_mode", "Radio Mode", RadioSettingValueList(RPTMODE_LIST, RPTMODE_LIST[_settings. rpt_mode])) cfg_grp.append(rs) rs = RadioSetting("rpt_set", "Repeater Setting", RadioSettingValueList(RPTSET_LIST, RPTSET_LIST[_settings. rpt_set])) cfg_grp.append(rs) rs = RadioSetting("rpt_spk", "Repeater Mode Speaker", RadioSettingValueBoolean(_settings.rpt_spk)) cfg_grp.append(rs) rs = RadioSetting("rpt_ptt", "Repeater PTT", RadioSettingValueBoolean(_settings.rpt_ptt)) cfg_grp.append(rs) rs = RadioSetting("dtmf_tx_time", "DTMF Tx Duration", RadioSettingValueList(DTMF_TIMES, DTMF_TIMES[_settings. dtmf_tx_time])) cfg_grp.append(rs) rs = RadioSetting("dtmf_interval", "DTMF Interval", RadioSettingValueList(DTMF_TIMES, DTMF_TIMES[_settings. dtmf_interval])) cfg_grp.append(rs) rs = RadioSetting("alert", "Alert Tone", RadioSettingValueList(ALERTS_LIST, ALERTS_LIST[_settings.alert])) cfg_grp.append(rs) rs = RadioSetting("rpt_tone", "Repeater Tone", RadioSettingValueBoolean(_settings.rpt_tone)) cfg_grp.append(rs) rs = RadioSetting("rpt_hold", "Repeater Hold Time", RadioSettingValueList(HOLD_TIMES, HOLD_TIMES[_settings. rpt_hold])) cfg_grp.append(rs) rs = RadioSetting("scan_det", "Scan DET", RadioSettingValueBoolean(_settings.scan_det)) cfg_grp.append(rs) rs = RadioSetting("sc_qt", "SC-QT", RadioSettingValueList(SCQT_LIST, SCQT_LIST[_settings.sc_qt])) cfg_grp.append(rs) rs = RadioSetting("smuteset", "SubFreq Mute", RadioSettingValueList(SMUTESET_LIST, SMUTESET_LIST[_settings. smuteset])) cfg_grp.append(rs) # # VFO A Settings # rs = RadioSetting("workmode_a", "VFO A Workmode", RadioSettingValueList(WORKMODE_LIST, WORKMODE_LIST[_settings.workmode_a])) vfoa_grp.append(rs) rs = RadioSetting("work_cha", "VFO A Channel", RadioSettingValueInteger(1, 999, _settings.work_cha)) vfoa_grp.append(rs) rs = RadioSetting("vfoa.rxfreq", "VFO A Rx Frequency", RadioSettingValueInteger( 134000000, 520000000, _vfoa.rxfreq * 10, 5000)) vfoa_grp.append(rs) rs = RadioSetting("vfoa.txoffset", "VFO A Tx Offset", RadioSettingValueInteger( 0, 520000000, _vfoa.txoffset * 10, 5000)) vfoa_grp.append(rs) # u16 rxtone; # u16 txtone; rs = RadioSetting("vfoa.power", "VFO A Power", RadioSettingValueList( POWER_LIST, POWER_LIST[_vfoa.power])) vfoa_grp.append(rs) # shift_dir:2 rs = RadioSetting("vfoa.iswide", "VFO A NBFM", RadioSettingValueList( BANDWIDTH_LIST, BANDWIDTH_LIST[_vfoa.iswide])) vfoa_grp.append(rs) rs = RadioSetting("vfoa.mute_mode", "VFO A Mute", RadioSettingValueList( SPMUTE_LIST, SPMUTE_LIST[_vfoa.mute_mode])) vfoa_grp.append(rs) rs = RadioSetting("vfoa.step", "VFO A Step (kHz)", RadioSettingValueList( STEP_LIST, STEP_LIST[_vfoa.step])) vfoa_grp.append(rs) rs = RadioSetting("vfoa.squelch", "VFO A Squelch", RadioSettingValueList( LIST_10, LIST_10[_vfoa.squelch])) vfoa_grp.append(rs) rs = RadioSetting("bcl_a", "Busy Channel Lock-out A", RadioSettingValueBoolean(_settings.bcl_a)) vfoa_grp.append(rs) # # VFO B Settings # rs = RadioSetting("workmode_b", "VFO B Workmode", RadioSettingValueList(WORKMODE_LIST, WORKMODE_LIST[_settings.workmode_b])) vfob_grp.append(rs) rs = RadioSetting("work_chb", "VFO B Channel", RadioSettingValueInteger(1, 999, _settings.work_chb)) vfob_grp.append(rs) rs = RadioSetting("vfob.rxfreq", "VFO B Rx Frequency", RadioSettingValueInteger( 134000000, 520000000, _vfob.rxfreq * 10, 5000)) vfob_grp.append(rs) rs = RadioSetting("vfob.txoffset", "VFO B Tx Offset", RadioSettingValueInteger( 0, 520000000, _vfob.txoffset * 10, 5000)) vfob_grp.append(rs) # u16 rxtone; # u16 txtone; rs = RadioSetting("vfob.power", "VFO B Power", RadioSettingValueList( POWER_LIST, POWER_LIST[_vfob.power])) vfob_grp.append(rs) # shift_dir:2 rs = RadioSetting("vfob.iswide", "VFO B NBFM", RadioSettingValueList( BANDWIDTH_LIST, BANDWIDTH_LIST[_vfob.iswide])) vfob_grp.append(rs) rs = RadioSetting("vfob.mute_mode", "VFO B Mute", RadioSettingValueList( SPMUTE_LIST, SPMUTE_LIST[_vfob.mute_mode])) vfob_grp.append(rs) rs = RadioSetting("vfob.step", "VFO B Step (kHz)", RadioSettingValueList( STEP_LIST, STEP_LIST[_vfob.step])) vfob_grp.append(rs) rs = RadioSetting("vfob.squelch", "VFO B Squelch", RadioSettingValueList( LIST_10, LIST_10[_vfob.squelch])) vfob_grp.append(rs) rs = RadioSetting("bcl_b", "Busy Channel Lock-out B", RadioSettingValueBoolean(_settings.bcl_b)) vfob_grp.append(rs) # # Key Settings # _msg = str(_settings.dispstr).split("\0")[0] val = RadioSettingValueString(0, 15, _msg) val.set_mutable(True) rs = RadioSetting("dispstr", "Display Message", val) key_grp.append(rs) dtmfchars = "0123456789" _codeobj = _settings.ani_code _code = "".join([dtmfchars[x] for x in _codeobj if int(x) < 0x0A]) val = RadioSettingValueString(3, 6, _code, False) val.set_charset(dtmfchars) rs = RadioSetting("ani_code", "ANI Code", val) def apply_ani_id(setting, obj): value = [] for j in range(0, 6): try: value.append(dtmfchars.index(str(setting.value)[j])) except IndexError: value.append(0xFF) obj.ani_code = value rs.set_apply_callback(apply_ani_id, _settings) key_grp.append(rs) rs = RadioSetting("pf1_func", "PF1 Key function", RadioSettingValueList( PF1KEY_LIST, PF1KEY_LIST[_settings.pf1_func])) key_grp.append(rs) rs = RadioSetting("pf3_func", "PF3 Key function", RadioSettingValueList( PF3KEY_LIST, PF3KEY_LIST[_settings.pf3_func])) key_grp.append(rs) # # Limits settings # rs = RadioSetting("vhf_limits.rx_start", "VHF RX Lower Limit", RadioSettingValueInteger( 134000000, 174997500, self._memobj.vhf_limits.rx_start * 10, 5000)) vhf_lmt_grp.append(rs) rs = RadioSetting("vhf_limits.rx_stop", "VHF RX Upper Limit", RadioSettingValueInteger( 134000000, 174997500, self._memobj.vhf_limits.rx_stop * 10, 5000)) vhf_lmt_grp.append(rs) rs = RadioSetting("vhf_limits.tx_start", "VHF TX Lower Limit", RadioSettingValueInteger( 134000000, 174997500, self._memobj.vhf_limits.tx_start * 10, 5000)) vhf_lmt_grp.append(rs) rs = RadioSetting("vhf_limits.tx_stop", "VHF TX Upper Limit", RadioSettingValueInteger( 134000000, 174997500, self._memobj.vhf_limits.tx_stop * 10, 5000)) vhf_lmt_grp.append(rs) rs = RadioSetting("vhf1_limits.rx_start", "VHF1 RX Lower Limit", RadioSettingValueInteger( 220000000, 265000000, self._memobj.vhf1_limits.rx_start * 10, 5000)) vhf1_lmt_grp.append(rs) rs = RadioSetting("vhf1_limits.rx_stop", "VHF1 RX Upper Limit", RadioSettingValueInteger( 220000000, 265000000, self._memobj.vhf1_limits.rx_stop * 10, 5000)) vhf1_lmt_grp.append(rs) rs = RadioSetting("vhf1_limits.tx_start", "VHF1 TX Lower Limit", RadioSettingValueInteger( 220000000, 265000000, self._memobj.vhf1_limits.tx_start * 10, 5000)) vhf1_lmt_grp.append(rs) rs = RadioSetting("vhf1_limits.tx_stop", "VHF1 TX Upper Limit", RadioSettingValueInteger( 220000000, 265000000, self._memobj.vhf1_limits.tx_stop * 10, 5000)) vhf1_lmt_grp.append(rs) rs = RadioSetting("uhf_limits.rx_start", "UHF RX Lower Limit", RadioSettingValueInteger( 400000000, 520000000, self._memobj.uhf_limits.rx_start * 10, 5000)) uhf_lmt_grp.append(rs) rs = RadioSetting("uhf_limits.rx_stop", "UHF RX Upper Limit", RadioSettingValueInteger( 400000000, 520000000, self._memobj.uhf_limits.rx_stop * 10, 5000)) uhf_lmt_grp.append(rs) rs = RadioSetting("uhf_limits.tx_start", "UHF TX Lower Limit", RadioSettingValueInteger( 400000000, 520000000, self._memobj.uhf_limits.tx_start * 10, 5000)) uhf_lmt_grp.append(rs) rs = RadioSetting("uhf_limits.tx_stop", "UHF TX Upper Limit", RadioSettingValueInteger( 400000000, 520000000, self._memobj.uhf_limits.tx_stop * 10, 5000)) uhf_lmt_grp.append(rs) # # OEM info # def _decode(lst): _str = ''.join([chr(c) for c in lst if chr(c) in chirp_common.CHARSET_ASCII]) return _str def do_nothing(setting, obj): return _str = _decode(self._memobj.oem_info.model) val = RadioSettingValueString(0, 15, _str) val.set_mutable(False) rs = RadioSetting("oem_info.model", "Model", val) rs.set_apply_callback(do_nothing, _settings) oem_grp.append(rs) _str = _decode(self._memobj.oem_info.oem1) val = RadioSettingValueString(0, 15, _str) val.set_mutable(False) rs = RadioSetting("oem_info.oem1", "OEM String 1", val) rs.set_apply_callback(do_nothing, _settings) oem_grp.append(rs) _str = _decode(self._memobj.oem_info.oem2) val = RadioSettingValueString(0, 15, _str) val.set_mutable(False) rs = RadioSetting("oem_info.oem2", "OEM String 2", val) rs.set_apply_callback(do_nothing, _settings) oem_grp.append(rs) _str = _decode(self._memobj.oem_info.version) val = RadioSettingValueString(0, 15, _str) val.set_mutable(False) rs = RadioSetting("oem_info.version", "Software Version", val) rs.set_apply_callback(do_nothing, _settings) oem_grp.append(rs) _str = _decode(self._memobj.oem_info.date) val = RadioSettingValueString(0, 15, _str) val.set_mutable(False) rs = RadioSetting("oem_info.date", "OEM Date", val) rs.set_apply_callback(do_nothing, _settings) oem_grp.append(rs) return group
def get_settings(self): _settings = self._memobj.settings _dtmf_strings = self._memobj.dtmf_strings _passwd = self._memobj.passwd repeater = RadioSettingGroup("repeater", "Repeater Settings") ctcss = RadioSettingGroup("ctcss", "CTCSS/DCS/EPCS Settings") arts = RadioSettingGroup("arts", "ARTS Settings") mbls = RadioSettingGroup("banks", "Memory Settings") scan = RadioSettingGroup("scan", "Scan Settings") dtmf = RadioSettingGroup("dtmf", "DTMF Settings") wires = RadioSettingGroup("wires", "WiRES(tm) Settings") switch = RadioSettingGroup("switch", "Switch/Knob Settings") disp = RadioSettingGroup("disp", "Display Settings") misc = RadioSettingGroup("misc", "Miscellaneous Settings") setmode = RadioSettings(repeater, ctcss, arts, mbls, scan, dtmf, wires, switch, disp, misc) # numbers and names of settings refer to the way they're # presented in the set menu, as well as the list starting on # page 74 of the manual # 1 APO opts = ["Off", "30 Min", "1 Hour", "3 Hour", "5 Hour", "8 Hour"] misc.append( RadioSetting("apo", "Automatic Power Off", RadioSettingValueList(opts, opts[_settings.apo]))) # 2 AR.BEP opts = ["Off", "In Range", "Always"] arts.append( RadioSetting( "arts_beep", "ARTS Beep", RadioSettingValueList(opts, opts[_settings.arts_beep]))) # 3 AR.INT opts = ["15 Sec", "25 Sec"] arts.append( RadioSetting( "arts_interval", "ARTS Polling Interval", RadioSettingValueList(opts, opts[_settings.arts_interval]))) # 4 ARS opts = ["Off", "On"] repeater.append( RadioSetting("ars", "Automatic Repeater Shift", RadioSettingValueList(opts, opts[_settings.ars]))) # 5 BCLO opts = ["Off", "On"] misc.append( RadioSetting( "busy_lockout", "Busy Channel Lock-Out", RadioSettingValueList(opts, opts[_settings.busy_lockout]))) # 6 BEEP opts = ["Off", "Key+Scan", "Key"] switch.append( RadioSetting("beep", "Enable the Beeper", RadioSettingValueList(opts, opts[_settings.beep]))) # 7 BELL opts = ["Off", "1", "3", "5", "8", "Continuous"] ctcss.append( RadioSetting("bell", "Bell Repetitions", RadioSettingValueList(opts, opts[_settings.bell]))) # 8 BNK.LNK for i in range(0, 8): opts = ["Off", "On"] mbs = (self._memobj.mbs >> i) & 1 rs = RadioSetting("mbs%i" % i, "Bank %s Scan" % (i + 1), RadioSettingValueList(opts, opts[mbs])) def apply_mbs(s, index): if int(s.value): self._memobj.mbs |= (1 << index) else: self._memobj.mbs &= ~(1 << index) rs.set_apply_callback(apply_mbs, i) mbls.append(rs) # 9 BNK.NM - A per-bank attribute, nothing to do here. # 10 CLK.SFT - A per-channel attribute, nothing to do here. # 11 CW.ID opts = ["Off", "On"] arts.append( RadioSetting("cw_id", "CW ID Enable", RadioSettingValueList(opts, opts[_settings.cw_id]))) cw_id_text = "" for i in _settings.cw_id_string: try: cw_id_text += CHARSET[i & 0x7F] except IndexError: if i != 0xff: LOG.debug("unknown char index in cw id: %x " % (i)) val = RadioSettingValueString(0, 16, cw_id_text, True) val.set_charset(CHARSET + "abcdefghijklmnopqrstuvwxyz") rs = RadioSetting("cw_id_string", "CW Identifier Text", val) def apply_cw_id(s): str = s.value.get_value().upper().rstrip() mval = "" mval = [chr(CHARSET.index(x)) for x in str] for x in range(len(mval), 16): mval.append(chr(0xff)) for x in range(0, 16): _settings.cw_id_string[x] = ord(mval[x]) rs.set_apply_callback(apply_cw_id) arts.append(rs) # 12 CWTRNG opts = [ "Off", "4WPM", "5WPM", "6WPM", "7WPM", "8WPM", "9WPM", "10WPM", "11WPM", "12WPM", "13WPM", "15WPM", "17WPM", "20WPM", "24WPM", "30WPM", "40WPM" ] misc.append( RadioSetting("cw_trng", "CW Training", RadioSettingValueList(opts, opts[_settings.cw_trng]))) # todo: make the setting of the units here affect the display # of the speed. Not critical, but would be slick. opts = ["CPM", "WPM"] misc.append( RadioSetting( "cw_trng_units", "CW Training Units", RadioSettingValueList(opts, opts[_settings.cw_trng_units]))) # 13 DC VLT - a read-only status, so nothing to do here # 14 DCS CD - A per-channel attribute, nothing to do here # 15 DCS.RV opts = ["Disabled", "Enabled"] ctcss.append( RadioSetting( "inverted_dcs", "\"Inverted\" DCS Code Decoding", RadioSettingValueList(opts, opts[_settings.inverted_dcs]))) # 16 DIMMER opts = ["Off"] + ["Level %d" % (x) for x in range(1, 11)] disp.append( RadioSetting("dimmer", "Dimmer", RadioSettingValueList(opts, opts[_settings.dimmer]))) # 17 DT.A/M opts = ["Manual", "Auto"] dtmf.append( RadioSetting( "dtmf_mode", "DTMF Autodialer", RadioSettingValueList(opts, opts[_settings.dtmf_mode]))) # 18 DT.DLY opts = ["50 ms", "250 ms", "450 ms", "750 ms", "1000 ms"] dtmf.append( RadioSetting( "dtmf_delay", "DTMF Autodialer Delay Time", RadioSettingValueList(opts, opts[_settings.dtmf_delay]))) # 19 DT.SET for memslot in range(0, 10): dtmf_memory = "" for i in _dtmf_strings[memslot].dtmf_string: if i != 0xFF: try: dtmf_memory += CHARSET[i] except IndexError: LOG.debug("unknown char index in dtmf: %x " % (i)) val = RadioSettingValueString(0, 16, dtmf_memory, True) val.set_charset(CHARSET + "abcdef") rs = RadioSetting("dtmf_string_%d" % memslot, "DTMF Memory %d" % memslot, val) def apply_dtmf(s, i): LOG.debug("applying dtmf for %x\n" % i) str = s.value.get_value().upper().rstrip() LOG.debug("str is %s\n" % str) mval = "" mval = [chr(CHARSET.index(x)) for x in str] for x in range(len(mval), 16): mval.append(chr(0xff)) for x in range(0, 16): _dtmf_strings[i].dtmf_string[x] = ord(mval[x]) rs.set_apply_callback(apply_dtmf, memslot) dtmf.append(rs) # 20 DT.SPD opts = ["50 ms", "100 ms"] dtmf.append( RadioSetting( "dtmf_speed", "DTMF Autodialer Sending Speed", RadioSettingValueList(opts, opts[_settings.dtmf_speed]))) # 21 EDG.BEP opts = ["Off", "On"] mbls.append( RadioSetting( "edge_beep", "Band Edge Beeper", RadioSettingValueList(opts, opts[_settings.edge_beep]))) # 22 INT.CD opts = ["DTMF %X" % (x) for x in range(0, 16)] wires.append( RadioSetting("int_cd", "Access Number for WiRES(TM)", RadioSettingValueList(opts, opts[_settings.int_cd]))) # 23 ING MD opts = ["Sister Radio Group", "Friends Radio Group"] wires.append( RadioSetting( "wires_mode", "Internet Link Connection Mode", RadioSettingValueList(opts, opts[_settings.wires_mode]))) # 24 INT.A/M opts = ["Manual", "Auto"] wires.append( RadioSetting( "wires_auto", "Internet Link Autodialer", RadioSettingValueList(opts, opts[_settings.wires_auto]))) # 25 INT.SET opts = ["F%d" % (x) for x in range(0, 10)] wires.append( RadioSetting("int_set", "Memory Register for " "non-WiRES Internet", RadioSettingValueList(opts, opts[_settings.int_set]))) # 26 LOCK opts = [ "Key", "Dial", "Key + Dial", "PTT", "Key + PTT", "Dial + PTT", "All" ] switch.append( RadioSetting("lock", "Control Locking", RadioSettingValueList(opts, opts[_settings.lock]))) # 27 MCGAIN opts = ["Level %d" % (x) for x in range(1, 10)] misc.append( RadioSetting("mic_gain", "Microphone Gain", RadioSettingValueList(opts, opts[_settings.mic_gain]))) # 28 MEM.SCN opts = ["Tag 1", "Tag 2", "All Channels"] rs = RadioSetting( "scan_mode", "Memory Scan Mode", RadioSettingValueList(opts, opts[_settings.scan_mode - 1])) # this setting is unusual in that it starts at 1 instead of 0. # that is, index 1 corresponds to "Tag 1", and index 0 is invalid. # so we create a custom callback to handle this. def apply_scan_mode(s): myopts = ["Tag 1", "Tag 2", "All Channels"] _settings.scan_mode = myopts.index(s.value.get_value()) + 1 rs.set_apply_callback(apply_scan_mode) mbls.append(rs) # 29 MW MD opts = ["Lower", "Next"] mbls.append( RadioSetting("mw_mode", "Memory Write Mode", RadioSettingValueList(opts, opts[_settings.mw_mode]))) # 30 NM SET - This is per channel, so nothing to do here # 31 OPN.MSG opts = ["Off", "DC Supply Voltage", "Text Message"] disp.append( RadioSetting("open_msg", "Opening Message Type", RadioSettingValueList(opts, opts[_settings.open_msg]))) openmsg = "" for i in _settings.openMsg_Text: try: openmsg += CHARSET[i & 0x7F] except IndexError: if i != 0xff: LOG.debug("unknown char index in openmsg: %x " % (i)) val = RadioSettingValueString(0, 6, openmsg, True) val.set_charset(CHARSET + "abcdefghijklmnopqrstuvwxyz") rs = RadioSetting("openMsg_Text", "Opening Message Text", val) def apply_openmsg(s): str = s.value.get_value().upper().rstrip() mval = "" mval = [chr(CHARSET.index(x)) for x in str] for x in range(len(mval), 6): mval.append(chr(0xff)) for x in range(0, 6): _settings.openMsg_Text[x] = ord(mval[x]) rs.set_apply_callback(apply_openmsg) disp.append(rs) # 32 PAGER - a per-channel attribute # 33 PAG.ABK opts = ["Off", "On"] ctcss.append( RadioSetting("pag_abk", "Paging Answer Back", RadioSettingValueList(opts, opts[_settings.pag_abk]))) # 34 PAG.CDR opts = ["%2.2d" % (x) for x in range(1, 50)] ctcss.append( RadioSetting( "pag_cdr_1", "Receive Page Code 1", RadioSettingValueList(opts, opts[_settings.pag_cdr_1]))) ctcss.append( RadioSetting( "pag_cdr_2", "Receive Page Code 2", RadioSettingValueList(opts, opts[_settings.pag_cdr_2]))) # 35 PAG.CDT opts = ["%2.2d" % (x) for x in range(1, 50)] ctcss.append( RadioSetting( "pag_cdt_1", "Transmit Page Code 1", RadioSettingValueList(opts, opts[_settings.pag_cdt_1]))) ctcss.append( RadioSetting( "pag_cdt_2", "Transmit Page Code 2", RadioSettingValueList(opts, opts[_settings.pag_cdt_2]))) # Common Button Options button_opts = [ "Squelch Off", "Weather", "Smart Search", "Tone Scan", "Scan", "T Call", "ARTS" ] # 36 PRG P1 opts = button_opts + ["DC Volts"] switch.append( RadioSetting("prog_p1", "P1 Button", RadioSettingValueList(opts, opts[_settings.prog_p1]))) # 37 PRG P2 opts = button_opts + ["Dimmer"] switch.append( RadioSetting("prog_p2", "P2 Button", RadioSettingValueList(opts, opts[_settings.prog_p2]))) # 38 PRG P3 opts = button_opts + ["Mic Gain"] switch.append( RadioSetting("prog_p3", "P3 Button", RadioSettingValueList(opts, opts[_settings.prog_p3]))) # 39 PRG P4 opts = button_opts + ["Skip"] switch.append( RadioSetting("prog_p4", "P4 Button", RadioSettingValueList(opts, opts[_settings.prog_p4]))) # 40 PSWD password = "" for i in _passwd: if i != 0xFF: try: password += CHARSET[i] except IndexError: LOG.debug("unknown char index in password: %x " % (i)) val = RadioSettingValueString(0, 4, password, True) val.set_charset(CHARSET[0:15] + "abcdef ") rs = RadioSetting("passwd", "Password", val) def apply_password(s): str = s.value.get_value().upper().rstrip() mval = "" mval = [chr(CHARSET.index(x)) for x in str] for x in range(len(mval), 4): mval.append(chr(0xff)) for x in range(0, 4): _passwd[x] = ord(mval[x]) rs.set_apply_callback(apply_password) misc.append(rs) # 41 RESUME opts = ["3 Sec", "5 Sec", "10 Sec", "Busy", "Hold"] scan.append( RadioSetting("resume", "Scan Resume Mode", RadioSettingValueList(opts, opts[_settings.resume]))) # 42 RF.SQL opts = ["Off"] + ["S-%d" % (x) for x in range(1, 10)] misc.append( RadioSetting("rf_sql", "RF Squelch Threshold", RadioSettingValueList(opts, opts[_settings.rf_sql]))) # 43 RPT - per channel attribute, nothing to do here # 44 RVRT opts = ["Off", "On"] misc.append( RadioSetting("revert", "Priority Revert", RadioSettingValueList(opts, opts[_settings.revert]))) # 45 S.SRCH opts = ["Single", "Continuous"] misc.append( RadioSetting("s_search", "Smart Search Sweep Mode", RadioSettingValueList(opts, opts[_settings.s_search]))) # 46 SHIFT - per channel setting, nothing to do here # 47 SKIP = per channel setting, nothing to do here # 48 SPLIT - per channel attribute, nothing to do here # 49 SQL.TYP - per channel attribute, nothing to do here # 50 STEP - per channel attribute, nothing to do here # 51 TEMP - read-only status, nothing to do here # 52 TN FRQ - per channel attribute, nothing to do here # 53 TOT opts = ["Off", "1 Min", "3 Min", "5 Min", "10 Min"] misc.append( RadioSetting("tot", "Timeout Timer", RadioSettingValueList(opts, opts[_settings.tot]))) # 54 TS MUT opts = ["Off", "On"] ctcss.append( RadioSetting("ts_mut", "Tone Search Mute", RadioSettingValueList(opts, opts[_settings.ts_mut]))) # 55 TS SPEED opts = ["Fast", "Slow"] ctcss.append( RadioSetting("ts_speed", "Tone Search Scanner Speed", RadioSettingValueList(opts, opts[_settings.ts_speed]))) # 56 VFO.SCN opts = ["+/- 1MHz", "+/- 2MHz", "+/-5MHz", "All"] scan.append( RadioSetting("vfo_scan", "VFO Scanner Width", RadioSettingValueList(opts, opts[_settings.vfo_scan]))) # 57 WX.ALT opts = ["Off", "On"] misc.append( RadioSetting("wx_alert", "Weather Alert Scan", RadioSettingValueList(opts, opts[_settings.wx_alert]))) # 58 WX.VOL opts = ["Normal", "Maximum"] misc.append( RadioSetting( "wx_vol_max", "Weather Alert Volume", RadioSettingValueList(opts, opts[_settings.wx_vol_max]))) # 59 W/N DV - this is a per-channel attribute, nothing to do here return setmode
def get_settings(self): """Translate the bit in the mem_struct into settings in the UI""" _mem = self._memobj basic = RadioSettingGroup("basic", "Basic Settings") advanced = RadioSettingGroup("advanced", "Advanced Settings") other = RadioSettingGroup("other", "Other Settings") work = RadioSettingGroup("work", "Work Mode Settings") fm_preset = RadioSettingGroup("fm_preset", "FM Preset") dtmfe = RadioSettingGroup("dtmfe", "DTMF Encode Settings") service = RadioSettingGroup("service", "Service Settings") top = RadioSettings(basic, advanced, other, work, fm_preset, dtmfe, service) # Basic settings if _mem.settings.squelch > 0x09: val = 0x00 else: val = _mem.settings.squelch rs = RadioSetting( "settings.squelch", "Squelch", RadioSettingValueList(LIST_OFF1TO9, LIST_OFF1TO9[val])) basic.append(rs) if _mem.settings.save > 0x04: val = 0x00 else: val = _mem.settings.save rs = RadioSetting("settings.save", "Battery Saver", RadioSettingValueList(LIST_SAVE, LIST_SAVE[val])) basic.append(rs) if _mem.settings.vox > 0x0A: val = 0x00 else: val = _mem.settings.vox rs = RadioSetting( "settings.vox", "Vox", RadioSettingValueList(LIST_OFF1TO10, LIST_OFF1TO10[val])) basic.append(rs) if _mem.settings.abr > 0x0A: val = 0x00 else: val = _mem.settings.abr rs = RadioSetting( "settings.abr", "Backlight Timeout", RadioSettingValueList(LIST_OFF1TO10, LIST_OFF1TO10[val])) basic.append(rs) rs = RadioSetting("settings.tdr", "Dual Watch", RadioSettingValueBoolean(_mem.settings.tdr)) basic.append(rs) rs = RadioSetting("settings.beep", "Beep", RadioSettingValueBoolean(_mem.settings.beep)) basic.append(rs) if _mem.settings.timeout > 0x27: val = 0x03 else: val = _mem.settings.timeout rs = RadioSetting( "settings.timeout", "Timeout Timer", RadioSettingValueList(LIST_TIMEOUT, LIST_TIMEOUT[val])) basic.append(rs) if _mem.settings.voice > 0x02: val = 0x01 else: val = _mem.settings.voice rs = RadioSetting("settings.voice", "Voice Prompt", RadioSettingValueList(LIST_VOICE, LIST_VOICE[val])) basic.append(rs) rs = RadioSetting( "settings.dtmfst", "DTMF Sidetone", RadioSettingValueList(LIST_DTMFST, LIST_DTMFST[_mem.settings.dtmfst])) basic.append(rs) if _mem.settings.screv > 0x02: val = 0x01 else: val = _mem.settings.screv rs = RadioSetting("settings.screv", "Scan Resume", RadioSettingValueList(LIST_RESUME, LIST_RESUME[val])) basic.append(rs) rs = RadioSetting( "settings.pttid", "When to send PTT ID", RadioSettingValueList(LIST_PTTID, LIST_PTTID[_mem.settings.pttid])) basic.append(rs) if _mem.settings.pttlt > 0x1E: val = 0x05 else: val = _mem.settings.pttlt rs = RadioSetting("pttlt", "PTT ID Delay", RadioSettingValueInteger(0, 50, val)) basic.append(rs) rs = RadioSetting( "settings.mdfa", "Display Mode (A)", RadioSettingValueList(LIST_MODE, LIST_MODE[_mem.settings.mdfa])) basic.append(rs) rs = RadioSetting( "settings.mdfb", "Display Mode (B)", RadioSettingValueList(LIST_MODE, LIST_MODE[_mem.settings.mdfb])) basic.append(rs) rs = RadioSetting("settings.sync", "Sync A & B", RadioSettingValueBoolean(_mem.settings.sync)) basic.append(rs) rs = RadioSetting( "settings.wtled", "Standby LED Color", RadioSettingValueList(LIST_COLOR, LIST_COLOR[_mem.settings.wtled])) basic.append(rs) rs = RadioSetting( "settings.rxled", "RX LED Color", RadioSettingValueList(LIST_COLOR, LIST_COLOR[_mem.settings.rxled])) basic.append(rs) rs = RadioSetting( "settings.txled", "TX LED Color", RadioSettingValueList(LIST_COLOR, LIST_COLOR[_mem.settings.txled])) basic.append(rs) val = _mem.settings.almod rs = RadioSetting("settings.almod", "Alarm Mode", RadioSettingValueList(LIST_ALMOD, LIST_ALMOD[val])) basic.append(rs) rs = RadioSetting("settings.dbptt", "Double PTT", RadioSettingValueBoolean(_mem.settings.dbptt)) basic.append(rs) rs = RadioSetting("settings.ste", "Squelch Tail Eliminate (HT to HT)", RadioSettingValueBoolean(_mem.settings.ste)) basic.append(rs) rs = RadioSetting( "settings.ponmsg", "Power-On Message", RadioSettingValueList(LIST_PONMSG, LIST_PONMSG[_mem.settings.ponmsg])) basic.append(rs) rs = RadioSetting("settings.roger", "Roger Beep", RadioSettingValueBoolean(_mem.settings.roger)) basic.append(rs) rs = RadioSetting( "settings.rtone", "Tone Burst Frequency", RadioSettingValueList(LIST_RTONE, LIST_RTONE[_mem.settings.rtone])) basic.append(rs) rs = RadioSetting( "settings.rogerrx", "Roger Beep (RX)", RadioSettingValueList(LIST_OFFAB, LIST_OFFAB[_mem.settings.rogerrx])) basic.append(rs) # Advanced settings rs = RadioSetting("settings.reset", "RESET Menu", RadioSettingValueBoolean(_mem.settings.reset)) advanced.append(rs) rs = RadioSetting("settings.menu", "All Menus", RadioSettingValueBoolean(_mem.settings.menu)) advanced.append(rs) rs = RadioSetting("settings.fmradio", "Broadcast FM Radio", RadioSettingValueBoolean(_mem.settings.fmradio)) advanced.append(rs) rs = RadioSetting("settings.alarm", "Alarm Sound", RadioSettingValueBoolean(_mem.settings.alarm)) advanced.append(rs) # Other settings def _filter(name): filtered = "" for char in str(name): if char in chirp_common.CHARSET_ASCII: filtered += char else: filtered += " " return filtered _msg = _mem.firmware_msg val = RadioSettingValueString(0, 7, _filter(_msg.line1)) val.set_mutable(False) rs = RadioSetting("firmware_msg.line1", "Firmware Message 1", val) other.append(rs) val = RadioSettingValueString(0, 7, _filter(_msg.line2)) val.set_mutable(False) rs = RadioSetting("firmware_msg.line2", "Firmware Message 2", val) other.append(rs) _msg = _mem.sixpoweron_msg val = RadioSettingValueString(0, 7, _filter(_msg.line1)) val.set_mutable(False) rs = RadioSetting("sixpoweron_msg.line1", "6+Power-On Message 1", val) other.append(rs) val = RadioSettingValueString(0, 7, _filter(_msg.line2)) val.set_mutable(False) rs = RadioSetting("sixpoweron_msg.line2", "6+Power-On Message 2", val) other.append(rs) _msg = _mem.poweron_msg rs = RadioSetting("poweron_msg.line1", "Power-On Message 1", RadioSettingValueString(0, 7, _filter(_msg.line1))) other.append(rs) rs = RadioSetting("poweron_msg.line2", "Power-On Message 2", RadioSettingValueString(0, 7, _filter(_msg.line2))) other.append(rs) # Work mode settings rs = RadioSetting( "settings.displayab", "Display", RadioSettingValueList(LIST_AB, LIST_AB[_mem.settings.displayab])) work.append(rs) rs = RadioSetting("settings.keylock", "Keypad Lock", RadioSettingValueBoolean(_mem.settings.keylock)) work.append(rs) rs = RadioSetting( "wmchannel.mrcha", "MR A Channel", RadioSettingValueInteger(1, 15, _mem.wmchannel.mrcha)) work.append(rs) rs = RadioSetting( "wmchannel.mrchb", "MR B Channel", RadioSettingValueInteger(1, 15, _mem.wmchannel.mrchb)) work.append(rs) # broadcast FM settings _fm_presets = self._memobj.fm_presets if _fm_presets <= 108.0 * 10 - 650: preset = _fm_presets / 10.0 + 65 elif _fm_presets >= 65.0 * 10 and _fm_presets <= 108.0 * 10: preset = _fm_presets / 10.0 else: preset = 76.0 rs = RadioSetting("fm_presets", "FM Preset(MHz)", RadioSettingValueFloat(65, 108.0, preset, 0.1, 1)) fm_preset.append(rs) # DTMF settings def apply_code(setting, obj, length): code = [] for j in range(0, length): try: code.append(DTMF_CHARS.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.code = code for i in range(0, 15): _codeobj = self._memobj.pttid[i].code _code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 5, _code, False) val.set_charset(DTMF_CHARS) pttid = RadioSetting("pttid/%i.code" % i, "Signal Code %i" % (i + 1), val) pttid.set_apply_callback(apply_code, self._memobj.pttid[i], 5) dtmfe.append(pttid) if _mem.ani.dtmfon > 0xC3: val = 0x03 else: val = _mem.ani.dtmfon rs = RadioSetting( "ani.dtmfon", "DTMF Speed (on)", RadioSettingValueList(LIST_DTMFSPEED, LIST_DTMFSPEED[val])) dtmfe.append(rs) if _mem.ani.dtmfoff > 0xC3: val = 0x03 else: val = _mem.ani.dtmfoff rs = RadioSetting( "ani.dtmfoff", "DTMF Speed (off)", RadioSettingValueList(LIST_DTMFSPEED, LIST_DTMFSPEED[val])) dtmfe.append(rs) _codeobj = self._memobj.ani.code _code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 5, _code, False) val.set_charset(DTMF_CHARS) rs = RadioSetting("ani.code", "ANI Code", val) rs.set_apply_callback(apply_code, self._memobj.ani, 5) dtmfe.append(rs) rs = RadioSetting( "ani.aniid", "When to send ANI ID", RadioSettingValueList(LIST_PTTID, LIST_PTTID[_mem.ani.aniid])) dtmfe.append(rs) # Service settings for index in range(0, 10): key = "squelch.vhf.sql%i" % (index) _obj = self._memobj.squelch.vhf val = RadioSettingValueInteger(0, 123, getattr(_obj, "sql%i" % (index))) if index == 0: val.set_mutable(False) name = "Squelch %i" % (index) rs = RadioSetting(key, name, val) service.append(rs) return top
def get_settings(self): _settings = self._memobj.settings _message = self._memobj.embedded_msg basic = RadioSettingGroup("basic", "Basic Settings") top = RadioSettings(basic) rs = RadioSetting("squelch", "Squelch Level", RadioSettingValueInteger(0, 9, _settings.squelch)) basic.append(rs) rs = RadioSetting("tot", "Time-out timer", RadioSettingValueList( TIMEOUTTIMER_LIST, TIMEOUTTIMER_LIST[_settings.tot])) basic.append(rs) rs = RadioSetting("voice", "Voice Prompts", RadioSettingValueList( VOICE_LIST, VOICE_LIST[_settings.voice])) basic.append(rs) rs = RadioSetting("pf2key", "PF2 Key", RadioSettingValueList( PF2KEY_LIST, PF2KEY_LIST[_settings.pf2key])) basic.append(rs) rs = RadioSetting("vox", "Vox", RadioSettingValueBoolean(_settings.vox)) basic.append(rs) rs = RadioSetting("voxgain", "VOX Level", RadioSettingValueList( VOX_LIST, VOX_LIST[_settings.voxgain])) basic.append(rs) rs = RadioSetting("voxdelay", "VOX Delay Time", RadioSettingValueList( VOXDELAY_LIST, VOXDELAY_LIST[_settings.voxdelay])) basic.append(rs) rs = RadioSetting("save", "Battery Save", RadioSettingValueBoolean(_settings.save)) basic.append(rs) rs = RadioSetting("beep", "Beep", RadioSettingValueBoolean(_settings.beep)) basic.append(rs) def _filter(name): filtered = "" for char in str(name): if char in VALID_CHARS: filtered += char else: filtered += " " return filtered rs = RadioSetting("embedded_msg.line1", "Embedded Message 1", RadioSettingValueString(0, 32, _filter( _message.line1))) basic.append(rs) rs = RadioSetting("embedded_msg.line2", "Embedded Message 2", RadioSettingValueString(0, 32, _filter( _message.line2))) basic.append(rs) return top
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic") cw = RadioSettingGroup("cw", "CW") packet = RadioSettingGroup("packet", "Digital & packet") panel = RadioSettingGroup("panel", "Panel settings") extended = RadioSettingGroup("extended", "Extended") panelcontr = RadioSettingGroup("panelcontr", "Panel controls") top = RadioSettingGroup("top", "All Settings", basic, cw, packet, panelcontr, panel, extended) rs = RadioSetting("extended_menu", "Extended menu", RadioSettingValueBoolean(_settings.extended_menu)) extended.append(rs) rs = RadioSetting("ars_144", "144MHz ARS", RadioSettingValueBoolean(_settings.ars_144)) basic.append(rs) rs = RadioSetting("ars_430", "430MHz ARS", RadioSettingValueBoolean(_settings.ars_430)) basic.append(rs) options = ["enable", "disable"] rs = RadioSetting( "disable_amfm_dial", "AM&FM Dial", RadioSettingValueList(options, options[_settings.disable_amfm_dial])) panel.append(rs) rs = RadioSetting("am_mic", "AM mic gain", RadioSettingValueInteger(0, 100, _settings.am_mic)) basic.append(rs) options = ["OFF", "1h", "2h", "3h", "4h", "5h", "6h"] rs = RadioSetting( "apo_time", "APO time", RadioSettingValueList(options, options[_settings.apo_time])) basic.append(rs) options = ["OFF", "Range", "All"] rs = RadioSetting( "arts_beep", "ARTS beep", RadioSettingValueList(options, options[_settings.arts_beep])) basic.append(rs) rs = RadioSetting("arts_id", "ARTS ID", RadioSettingValueBoolean(_settings.arts_id)) extended.append(rs) s = RadioSettingValueString( 0, 10, ''.join([self._CALLSIGN_CHARSET[x] for x in self._memobj.arts_idw])) s.set_charset(self._CALLSIGN_CHARSET) rs = RadioSetting("arts_idw", "ARTS IDW", s) extended.append(rs) s = RadioSettingValueString( 0, 40, ''.join( [self._BEACON_CHARSET[x] for x in self._memobj.beacon_text1])) s.set_charset(self._BEACON_CHARSET) rs = RadioSetting("beacon_text1", "Beacon text1", s) extended.append(rs) s = RadioSettingValueString( 0, 40, ''.join( [self._BEACON_CHARSET[x] for x in self._memobj.beacon_text2])) s.set_charset(self._BEACON_CHARSET) rs = RadioSetting("beacon_text2", "Beacon text2", s) extended.append(rs) s = RadioSettingValueString( 0, 40, ''.join( [self._BEACON_CHARSET[x] for x in self._memobj.beacon_text3])) s.set_charset(self._BEACON_CHARSET) rs = RadioSetting("beacon_text3", "Beacon text3", s) extended.append(rs) options = ["OFF"] + ["%i sec" % i for i in range(1, 256)] rs = RadioSetting( "beacon_time", "Beacon time", RadioSettingValueList(options, options[_settings.beacon_time])) extended.append(rs) options = ["440Hz", "880Hz", "1760Hz"] rs = RadioSetting( "beep_tone", "Beep tone", RadioSettingValueList(options, options[_settings.beep_tone])) panel.append(rs) rs = RadioSetting("beep_vol", "Beep volume", RadioSettingValueInteger(0, 100, _settings.beep_vol)) panel.append(rs) rs = RadioSetting( "r_lsb_car", "LSB Rx carrier point (*10 Hz)", RadioSettingValueInteger(-30, 30, _settings.r_lsb_car)) extended.append(rs) rs = RadioSetting( "r_usb_car", "USB Rx carrier point (*10 Hz)", RadioSettingValueInteger(-30, 30, _settings.r_usb_car)) extended.append(rs) rs = RadioSetting( "t_lsb_car", "LSB Tx carrier point (*10 Hz)", RadioSettingValueInteger(-30, 30, _settings.t_lsb_car)) extended.append(rs) rs = RadioSetting( "t_usb_car", "USB Tx carrier point (*10 Hz)", RadioSettingValueInteger(-30, 30, _settings.t_usb_car)) extended.append(rs) options = ["4800", "9600", "38400"] rs = RadioSetting( "cat_rate", "CAT rate", RadioSettingValueList(options, options[_settings.cat_rate])) basic.append(rs) options = ["CAT", "Linear", "Tuner"] rs = RadioSetting( "cat_lin_tun", "CAT/LIN/TUN selection", RadioSettingValueList(options, options[_settings.cat_lin_tun])) extended.append(rs) options = ["MAIN", "VFO/MEM", "CLAR"] # TODO test the 3 options on non D radio # which have only SEL and MAIN rs = RadioSetting( "clar_dial_sel", "Clarifier dial selection", RadioSettingValueList(options, options[_settings.clar_dial_sel])) panel.append(rs) rs = RadioSetting("cw_auto_mode", "CW Automatic mode", RadioSettingValueBoolean(_settings.cw_auto_mode)) cw.append(rs) options = ["USB", "LSB", "AUTO"] rs = RadioSetting( "cw_bfo", "CW BFO", RadioSettingValueList(options, options[_settings.cw_bfo])) cw.append(rs) options = ["FULL"] + ["%i ms" % (i * 10) for i in range(3, 301)] val = (_settings.cw_delay + _settings.cw_delay_hi * 256) - 2 rs = RadioSetting("cw_delay", "CW delay", RadioSettingValueList(options, options[val])) cw.append(rs) options = ["Normal", "Reverse"] rs = RadioSetting( "cw_key_rev", "CW key reverse", RadioSettingValueList(options, options[_settings.cw_key_rev])) cw.append(rs) rs = RadioSetting("cw_paddle", "CW paddle", RadioSettingValueBoolean(_settings.cw_paddle)) cw.append(rs) options = ["%i Hz" % i for i in range(400, 801, 100)] rs = RadioSetting( "cw_pitch", "CW pitch", RadioSettingValueList(options, options[_settings.cw_pitch])) cw.append(rs) options = ["%i ms" % i for i in range(5, 31, 5)] rs = RadioSetting( "cw_qsk", "CW QSK", RadioSettingValueList(options, options[_settings.cw_qsk])) cw.append(rs) rs = RadioSetting( "cw_sidetone", "CW sidetone volume", RadioSettingValueInteger(0, 100, _settings.cw_sidetone)) cw.append(rs) options = ["%i wpm" % i for i in range(4, 61)] rs = RadioSetting( "cw_speed", "CW speed", RadioSettingValueList(options, options[_settings.cw_speed])) cw.append(rs) options = ["Numeric", "Alphabet", "AlphaNumeric"] rs = RadioSetting( "cw_training", "CW trainig", RadioSettingValueList(options, options[_settings.cw_training])) cw.append(rs) options = ["1:%1.1f" % (i / 10) for i in range(25, 46, 1)] rs = RadioSetting( "cw_weight", "CW weight", RadioSettingValueList(options, options[_settings.cw_weight])) cw.append(rs) options = ["Tn-Rn", "Tn-Riv", "Tiv-Rn", "Tiv-Riv"] rs = RadioSetting( "dcs_inv", "DCS inv", RadioSettingValueList(options, options[_settings.dcs_inv])) extended.append(rs) options = ["Fine", "Coarse"] rs = RadioSetting( "dial_step", "Dial step", RadioSettingValueList(options, options[_settings.dial_step])) panel.append(rs) rs = RadioSetting( "dig_disp", "Dig disp (*10 Hz)", RadioSettingValueInteger(-300, 300, _settings.dig_disp)) packet.append(rs) rs = RadioSetting("dig_mic", "Dig gain", RadioSettingValueInteger(0, 100, _settings.dig_mic)) packet.append(rs) options = ["RTTYL", "RTTYU", "PSK31-L", "PSK31-U", "USER-L", "USER-U"] rs = RadioSetting( "dig_mode", "Dig mode", RadioSettingValueList(options, options[_settings.dig_mode])) packet.append(rs) rs = RadioSetting( "dig_shift", "Dig shift (*10 Hz)", RadioSettingValueInteger(-300, 300, _settings.dig_shift)) packet.append(rs) rs = RadioSetting("dig_vox", "Dig vox", RadioSettingValueInteger(0, 100, _settings.dig_vox)) packet.append(rs) options = ["ARTS", "BAND", "FIX", "MEMGRP", "MODE", "MTR", "VFO"] rs = RadioSetting( "disp_color", "Display color mode", RadioSettingValueList(options, options[_settings.disp_color])) panel.append(rs) rs = RadioSetting( "disp_color_arts", "Display color ARTS set", RadioSettingValueInteger(0, 1, _settings.disp_color_arts)) panel.append(rs) rs = RadioSetting( "disp_color_band", "Display color band set", RadioSettingValueInteger(0, 1, _settings.disp_color_band)) panel.append(rs) rs = RadioSetting( "disp_color_memgrp", "Display color memory group set", RadioSettingValueInteger(0, 1, _settings.disp_color_memgrp)) panel.append(rs) rs = RadioSetting( "disp_color_mode", "Display color mode set", RadioSettingValueInteger(0, 1, _settings.disp_color_mode)) panel.append(rs) rs = RadioSetting( "disp_color_mtr", "Display color meter set", RadioSettingValueInteger(0, 1, _settings.disp_color_mtr)) panel.append(rs) rs = RadioSetting( "disp_color_vfo", "Display color VFO set", RadioSettingValueInteger(0, 1, _settings.disp_color_vfo)) panel.append(rs) rs = RadioSetting( "disp_color_fix", "Display color fix set", RadioSettingValueInteger(1, 32, _settings.disp_color_fix + 1)) panel.append(rs) rs = RadioSetting( "disp_contrast", "Contrast", RadioSettingValueInteger(3, 15, _settings.disp_contrast + 2)) panel.append(rs) rs = RadioSetting( "disp_intensity", "Intensity", RadioSettingValueInteger(1, 3, _settings.disp_intensity)) panel.append(rs) options = ["OFF", "Auto1", "Auto2", "ON"] rs = RadioSetting( "disp_mode", "Display backlight mode", RadioSettingValueList(options, options[_settings.disp_mode])) panel.append(rs) options = ["60Hz", "120Hz", "240Hz"] rs = RadioSetting( "dsp_bpf", "Dsp band pass filter", RadioSettingValueList(options, options[_settings.dsp_bpf])) cw.append(rs) options = [ "100Hz", "160Hz", "220Hz", "280Hz", "340Hz", "400Hz", "460Hz", "520Hz", "580Hz", "640Hz", "720Hz", "760Hz", "820Hz", "880Hz", "940Hz", "1000Hz" ] rs = RadioSetting( "dsp_hpf", "Dsp hi pass filter cut off", RadioSettingValueList(options, options[_settings.dsp_hpf])) basic.append(rs) options = [ "1000Hz", "1160Hz", "1320Hz", "1480Hz", "1650Hz", "1800Hz", "1970Hz", "2130Hz", "2290Hz", "2450Hz", "2610Hz", "2770Hz", "2940Hz", "3100Hz", "3260Hz", "3420Hz", "3580Hz", "3740Hz", "3900Hz", "4060Hz", "4230Hz", "4390Hz", "4550Hz", "4710Hz", "4870Hz", "5030Hz", "5190Hz", "5390Hz", "5520Hz", "5680Hz", "5840Hz", "6000Hz" ] rs = RadioSetting( "dsp_lpf", "Dsp low pass filter cut off", RadioSettingValueList(options, options[_settings.dsp_lpf])) basic.append(rs) options = ["OFF", "LPF", "HPF", "BOTH"] rs = RadioSetting( "dsp_mic_eq", "Dsp mic equalization", RadioSettingValueList(options, options[_settings.dsp_mic_eq])) basic.append(rs) rs = RadioSetting( "dsp_nr", "DSP noise reduction level", RadioSettingValueInteger(1, 16, _settings.dsp_nr + 1)) basic.append(rs) # emergency only for US model rs = RadioSetting("fm_mic", "FM mic gain", RadioSettingValueInteger(0, 100, _settings.fm_mic)) basic.append(rs) rs = RadioSetting("home_vfo", "Enable HOME to VFO moving", RadioSettingValueBoolean(_settings.home_vfo)) panel.append(rs) options = ["Dial", "Freq", "Panel", "All"] rs = RadioSetting( "lock_mode", "Lock mode", RadioSettingValueList(options, options[_settings.lock_mode])) panel.append(rs) rs = RadioSetting("mem_group", "Mem group", RadioSettingValueBoolean(_settings.mem_group)) basic.append(rs) options = [ "CW SIDETONE", "CW SPEED", "MHz/MEM GRP", "MIC GAIN", "NB LEVEL", "RF POWER", "STEP" ] rs = RadioSetting( "mem_vfo_dial_mode", "Mem/VFO dial mode", RadioSettingValueList(options, options[_settings.mem_vfo_dial_mode])) panel.append(rs) rs = RadioSetting("mic_scan", "Mic scan", RadioSettingValueBoolean(_settings.mic_scan)) basic.append(rs) options = ["NOR", "RMT", "CAT"] rs = RadioSetting( "mic_sel", "Mic selection", RadioSettingValueList(options, options[_settings.mic_sel])) extended.append(rs) options = ["SIG", "CTR", "VLT", "N/A", "FS", "OFF"] rs = RadioSetting( "mtr_arx_sel", "Meter receive selection", RadioSettingValueList(options, options[_settings.mtr_arx_sel])) extended.append(rs) options = ["PWR", "ALC", "MOD", "SWR", "VLT", "N/A", "OFF"] rs = RadioSetting( "mtr_atx_sel", "Meter transmit selection", RadioSettingValueList(options, options[_settings.mtr_atx_sel])) extended.append(rs) rs = RadioSetting("mtr_peak_hold", "Meter peak hold", RadioSettingValueBoolean(_settings.mtr_peak_hold)) extended.append(rs) rs = RadioSetting("nb_level", "Noise blanking level", RadioSettingValueInteger(0, 100, _settings.nb_level)) basic.append(rs) s = RadioSettingValueString( 0, 4, ''.join([ self._CALLSIGN_CHARSET[x] for x in self._memobj.op_filter1_name ])) s.set_charset(self._CALLSIGN_CHARSET) rs = RadioSetting("op_filter1_name", "Optional filter1 name", s) extended.append(rs) s = RadioSettingValueString( 0, 4, ''.join([ self._CALLSIGN_CHARSET[x] for x in self._memobj.op_filter2_name ])) s.set_charset(self._CALLSIGN_CHARSET) rs = RadioSetting("op_filter2_name", "Optional filter2 name", s) extended.append(rs) rs = RadioSetting( "pg_a", "Programmable key MFq:A", RadioSettingValueList(self.PROGRAMMABLEOPTIONS, self.PROGRAMMABLEOPTIONS[_settings.pg_a])) extended.append(rs) rs = RadioSetting( "pg_b", "Programmable key MFq:B", RadioSettingValueList(self.PROGRAMMABLEOPTIONS, self.PROGRAMMABLEOPTIONS[_settings.pg_b])) extended.append(rs) rs = RadioSetting( "pg_c", "Programmable key MFq:C", RadioSettingValueList(self.PROGRAMMABLEOPTIONS, self.PROGRAMMABLEOPTIONS[_settings.pg_c])) extended.append(rs) rs = RadioSetting( "pg_acc", "Programmable mic key ACC", RadioSettingValueList(self.PROGRAMMABLEOPTIONS, self.PROGRAMMABLEOPTIONS[_settings.pg_acc])) extended.append(rs) rs = RadioSetting( "pg_p1", "Programmable mic key P1", RadioSettingValueList(self.PROGRAMMABLEOPTIONS, self.PROGRAMMABLEOPTIONS[_settings.pg_p1])) extended.append(rs) rs = RadioSetting( "pg_p2", "Programmable mic key P2", RadioSettingValueList(self.PROGRAMMABLEOPTIONS, self.PROGRAMMABLEOPTIONS[_settings.pg_p2])) extended.append(rs) rs = RadioSetting("pkt1200", "Packet 1200 gain level", RadioSettingValueInteger(0, 100, _settings.pkt1200)) packet.append(rs) rs = RadioSetting("pkt9600", "Packet 9600 gain level", RadioSettingValueInteger(0, 100, _settings.pkt9600)) packet.append(rs) options = ["1200", "9600"] rs = RadioSetting( "pkt_rate", "Packet rate", RadioSettingValueList(options, options[_settings.pkt_rate])) packet.append(rs) rs = RadioSetting( "proc_level", "Proc level", RadioSettingValueInteger(0, 100, _settings.proc_level)) basic.append(rs) rs = RadioSetting( "rf_power_hf", "Rf power set HF", RadioSettingValueInteger(5, 100, _settings.rf_power_hf)) basic.append(rs) rs = RadioSetting( "rf_power_6m", "Rf power set 6m", RadioSettingValueInteger(5, 100, _settings.rf_power_6m)) basic.append(rs) rs = RadioSetting( "rf_power_vhf", "Rf power set VHF", RadioSettingValueInteger(5, 50, _settings.rf_power_vhf)) basic.append(rs) rs = RadioSetting( "rf_power_uhf", "Rf power set UHF", RadioSettingValueInteger(2, 20, _settings.rf_power_uhf)) basic.append(rs) options = ["TIME", "BUSY", "STOP"] rs = RadioSetting( "scan_mode", "Scan mode", RadioSettingValueList(options, options[_settings.scan_mode])) basic.append(rs) rs = RadioSetting( "scan_resume", "Scan resume", RadioSettingValueInteger(1, 10, _settings.scan_resume)) basic.append(rs) rs = RadioSetting("split_tone", "Split tone enable", RadioSettingValueBoolean(_settings.split_tone)) extended.append(rs) options = ["RF-Gain", "Squelch"] rs = RadioSetting( "sql_rf_gain", "Squelch/RF-Gain", RadioSettingValueList(options, options[_settings.sql_rf_gain])) panel.append(rs) rs = RadioSetting("ssb_mic", "SSB Mic gain", RadioSettingValueInteger(0, 100, _settings.ssb_mic)) basic.append(rs) options = ["Off"] + ["%i" % i for i in range(1, 21)] rs = RadioSetting( "tot_time", "Time-out timer", RadioSettingValueList(options, options[_settings.tot_time])) basic.append(rs) options = ["OFF", "ATAS(HF)", "ATAS(HF&50)", "ATAS(ALL)", "TUNER"] rs = RadioSetting( "tuner_atas", "Tuner/ATAS device", RadioSettingValueList(options, options[_settings.tuner_atas])) extended.append(rs) rs = RadioSetting( "tx_if_filter", "Transmit IF filter", RadioSettingValueList(self.FILTERS, self.FILTERS[_settings.tx_if_filter])) basic.append(rs) rs = RadioSetting("vox_delay", "VOX delay (*100 ms)", RadioSettingValueInteger(1, 30, _settings.vox_delay)) basic.append(rs) rs = RadioSetting("vox_gain", "VOX Gain", RadioSettingValueInteger(1, 100, _settings.vox_gain)) basic.append(rs) rs = RadioSetting( "xvtr_a", "Xvtr A displacement", RadioSettingValueInteger( -4294967295, 4294967295, self._memobj.xvtr_a_offset * (-1 if _settings.xvtr_a_negative else 1))) extended.append(rs) rs = RadioSetting( "xvtr_b", "Xvtr B displacement", RadioSettingValueInteger( -4294967295, 4294967295, self._memobj.xvtr_b_offset * (-1 if _settings.xvtr_b_negative else 1))) extended.append(rs) options = ["OFF", "XVTR A", "XVTR B"] rs = RadioSetting( "xvtr_sel", "Transverter function selection", RadioSettingValueList(options, options[_settings.xvtr_sel])) extended.append(rs) rs = RadioSetting("disp", "Display large", RadioSettingValueBoolean(_settings.disp)) panel.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) rs = RadioSetting("scope_peakhold", "Scope max hold", RadioSettingValueBoolean(_settings.scope_peakhold)) panelcontr.append(rs) options = ["21", "31", "127"] rs = RadioSetting( "scope_width", "Scope width (channels)", RadioSettingValueList(options, options[_settings.scope_width])) panelcontr.append(rs) rs = RadioSetting("proc", "Speech processor", RadioSettingValueBoolean(_settings.proc)) panelcontr.append(rs) return top
def get_settings(self): _settings = self._memobj.settings _info = self._memobj.info _bandlimits = self._memobj.bandlimits basic = RadioSettingGroup("basic", "Basic") info = RadioSettingGroup("info", "Model Info") top = RadioSettings(basic, info) basic.append(RadioSetting( "beep", "Beep", RadioSettingValueBoolean(_settings.beep))) basic.append(RadioSetting( "beep_vol", "Beep Volume", RadioSettingValueInteger(0, 15, _settings.beep_vol))) basic.append(RadioSetting( "keylock", "Key Lock", RadioSettingValueBoolean(_settings.keylock))) basic.append(RadioSetting( "ani_display", "ANI Display", RadioSettingValueBoolean(_settings.ani_display))) basic.append(RadioSetting( "auto_xfer", "Auto Transfer", RadioSettingValueBoolean(_settings.auto_xfer))) basic.append(RadioSetting( "auto_contact", "Auto Contact Always Remind", RadioSettingValueBoolean(_settings.auto_contact))) basic.append(RadioSetting( "auto_am", "Auto AM", RadioSettingValueBoolean(_settings.auto_am))) basic.append(RadioSetting( "left_sql", "Left Squelch", RadioSettingValueList( SQLPRESET, SQLPRESET[_settings.left_sql]))) basic.append(RadioSetting( "right_sql", "Right Squelch", RadioSettingValueList( SQLPRESET, SQLPRESET[_settings.right_sql]))) # basic.append(RadioSetting("apo", "Auto Power off (0.1h)", # RadioSettingValueInteger(0, 20, _settings.apo))) opts = ["Off"] + ["%0.1f" % (t / 10.0) for t in range(1, 21, 1)] basic.append(RadioSetting( "apo", "Auto Power off (Hours)", RadioSettingValueList(opts, opts[_settings.apo]))) opts = ["Off", "1", "2", "3", "Full"] basic.append(RadioSetting( "backlight", "Display Backlight", RadioSettingValueList(opts, opts[_settings.backlight]))) opts = ["Off", "Right", "Left", "Both"] basic.append(RadioSetting( "pttlock", "PTT Lock", RadioSettingValueList(opts, opts[_settings.pttlock]))) opts = ["Manual", "Auto"] basic.append(RadioSetting( "hyper_chan", "Hyper Channel", RadioSettingValueList(opts, opts[_settings.hyper_chan]))) opts = ["Key 1", "Key 2"] basic.append(RadioSetting( "right_func_key", "Right Function Key", RadioSettingValueList(opts, opts[_settings.right_func_key]))) opts = ["1000Hz", "1450Hz", "1750Hz", "2100Hz"] basic.append(RadioSetting( "tbst_freq", "Tone Burst Frequency", RadioSettingValueList(opts, opts[_settings.tbst_freq]))) opts = ["Off", "TX", "RX", "TX RX"] basic.append(RadioSetting( "mute_mode", "Mute Mode", RadioSettingValueList(opts, opts[_settings.mute_mode]))) opts = ["MEM", "MSM"] scanmode = RadioSetting( "scan_mode", "Scan Mode", RadioSettingValueList(opts, opts[_settings.scan_mode])) scanmode.set_doc("MEM = Normal scan, bypass channels marked skip. " " MSM = Scan only channels marked priority.") basic.append(scanmode) opts = ["TO", "CO"] basic.append(RadioSetting( "scan_resume", "Scan Resume", RadioSettingValueList(opts, opts[_settings.scan_resume]))) opts = ["%0.1f" % (t / 10.0) for t in range(0, 51, 1)] basic.append(RadioSetting( "exit_delay", "Span Transit Exit Delay", RadioSettingValueList(opts, opts[_settings.exit_delay]))) basic.append(RadioSetting( "tot", "Time Out Timer (minutes)", RadioSettingValueInteger(0, 30, _settings.tot))) basic.append(RadioSetting( "tot_alert", "Time Out Timer Pre Alert(seconds)", RadioSettingValueInteger(0, 15, _settings.tot_alert))) basic.append(RadioSetting( "tot_rekey", "Time Out Rekey (seconds)", RadioSettingValueInteger(0, 15, _settings.tot_rekey))) basic.append(RadioSetting( "tot_reset", "Time Out Reset(seconds)", RadioSettingValueInteger(0, 15, _settings.tot_reset))) basic.append(RadioSetting( "p1", "P1 Function", RadioSettingValueList(MICKEYFUNC, MICKEYFUNC[_settings.p1]))) basic.append(RadioSetting( "p2", "P2 Function", RadioSettingValueList(MICKEYFUNC, MICKEYFUNC[_settings.p2]))) basic.append(RadioSetting( "p3", "P3 Function", RadioSettingValueList(MICKEYFUNC, MICKEYFUNC[_settings.p3]))) basic.append(RadioSetting( "p4", "P4 Function", RadioSettingValueList(MICKEYFUNC, MICKEYFUNC[_settings.p4]))) # opts = ["0", "1"] # basic.append(RadioSetting("x", "Desc", # RadioSettingValueList(opts, opts[_settings.x]))) def _filter(name): filtered = "" for char in str(name): if char in chirp_common.CHARSET_ASCII: filtered += char else: filtered += " " return filtered rsvs = RadioSettingValueString(0, 8, _filter(_info.sn)) rsvs.set_mutable(False) rs = RadioSetting("sn", "Serial Number", rsvs) info.append(rs) rsvs = RadioSettingValueString(0, 8, _filter(_info.model)) rsvs.set_mutable(False) rs = RadioSetting("model", "Model Name", rsvs) info.append(rs) rsvs = RadioSettingValueString(0, 16, _filter(_info.code)) rsvs.set_mutable(False) rs = RadioSetting("code", "Model Code", rsvs) info.append(rs) progdate = "%d/%d/%d" % (_info.prog_mon, _info.prog_day, _info.prog_yr) rsvs = RadioSettingValueString(0, 10, progdate) rsvs.set_mutable(False) rs = RadioSetting("progdate", "Last Program Date", rsvs) info.append(rs) # 9 band limits for i in range(0, 9): objname = BANDS[i] + "lorx" objnamepp = BANDS[i] + " Rx Start" # rsv = RadioSettingValueInteger(0, 100000000, # int(_bandlimits[i].lorx)) rsv = RadioSettingValueString( 0, 10, format_freq(int(_bandlimits[i].lorx)*10)) rsv.set_mutable(False) rs = RadioSetting(objname, objnamepp, rsv) info.append(rs) objname = BANDS[i] + "hirx" objnamepp = BANDS[i] + " Rx end" rsv = RadioSettingValueString( 0, 10, format_freq(int(_bandlimits[i].hirx)*10)) rsv.set_mutable(False) rs = RadioSetting(objname, objnamepp, rsv) info.append(rs) objname = BANDS[i] + "lotx" objnamepp = BANDS[i] + " Tx Start" rsv = RadioSettingValueString( 0, 10, format_freq(int(_bandlimits[i].lotx)*10)) rsv.set_mutable(False) rs = RadioSetting(objname, objnamepp, rsv) info.append(rs) objname = BANDS[i] + "hitx" objnamepp = BANDS[i] + " Tx end" rsv = RadioSettingValueString( 0, 10, format_freq(int(_bandlimits[i].hitx)*10)) rsv.set_mutable(False) rs = RadioSetting(objname, objnamepp, rsv) info.append(rs) return top
def _get_settings(self): _ani = self._memobj.ani _settings = self._memobj.settings _vfoa = self._memobj.vfoa _vfob = self._memobj.vfob _keymaps = self._memobj.keymaps basic = RadioSettingGroup("basic", "Basic Settings") advanced = RadioSettingGroup("advanced", "Advanced Settings") workmode = RadioSettingGroup("workmode", "Work Mode Settings") keymaps = RadioSettingGroup("keymaps", "KeyMaps") dtmf = RadioSettingGroup("dtmf", "DTMF Settings") group = RadioSettings(basic, advanced, workmode, keymaps, dtmf) rs = RadioSetting("squelch", "Carrier Squelch Level", RadioSettingValueInteger(0, 5, _settings.squelch)) basic.append(rs) rs = RadioSetting("battery_saver", "Battery Save", RadioSettingValueBoolean(_settings.battery_saver)) advanced.append(rs) rs = RadioSetting( "vox", "VOX Sensitivity", RadioSettingValueList(VOX_LIST, VOX_LIST[_settings.vox])) basic.append(rs) rs = RadioSetting( "auto_bl", "Auto Backlight Timeout", RadioSettingValueList(AUTOBL_LIST, AUTOBL_LIST[_settings.auto_bl])) advanced.append(rs) rs = RadioSetting( "tot", "TX Timeout Timer", RadioSettingValueList(TOT_LIST, TOT_LIST[_settings.tot])) basic.append(rs) rs = RadioSetting("beep", "Beep", RadioSettingValueBoolean(_settings.beep)) basic.append(rs) rs = RadioSetting("voice", "Voice", RadioSettingValueBoolean(_settings.voice)) advanced.append(rs) rs = RadioSetting( "language", "Language", RadioSettingValueList(LANGUAGE_LIST, LANGUAGE_LIST[_settings.language])) advanced.append(rs) rs = RadioSetting( "mdfa", "Display Mode (A)", RadioSettingValueList(MODE_LIST, MODE_LIST[_settings.mdfa])) basic.append(rs) rs = RadioSetting( "mdfb", "Display Mode (B)", RadioSettingValueList(MODE_LIST, MODE_LIST[_settings.mdfb])) basic.append(rs) rs = RadioSetting( "scan_mode", "Scan Mode", RadioSettingValueList(SCAN_MODE_LIST, SCAN_MODE_LIST[_settings.scan_mode])) basic.append(rs) rs = RadioSetting("bcl", "Busy Channel Lockout", RadioSettingValueBoolean(_settings.bcl)) advanced.append(rs) rs = RadioSetting("autolk", "Automatic Key Lock", RadioSettingValueBoolean(_settings.autolk)) advanced.append(rs) rs = RadioSetting( "almod", "Alarm Mode", RadioSettingValueList(ALMOD_LIST, ALMOD_LIST[_settings.almod])) advanced.append(rs) rs = RadioSetting("alsnd", "Alarm Sound", RadioSettingValueBoolean(_settings.alsnd)) advanced.append(rs) rs = RadioSetting("ste", "Squelch Tail Eliminate (HT to HT)", RadioSettingValueBoolean(_settings.ste)) advanced.append(rs) rs = RadioSetting( "rpste", "Squelch Tail Eliminate (repeater)", RadioSettingValueList(RPSTE_LIST, RPSTE_LIST[_settings.rpste])) advanced.append(rs) rs = RadioSetting( "rptrl", "STE Repeater Delay", RadioSettingValueList(STEDELAY_LIST, STEDELAY_LIST[_settings.rptrl])) advanced.append(rs) rs = RadioSetting("fmradio", "Disable Broadcast FM Radio", RadioSettingValueBoolean(_settings.fmradio)) advanced.append(rs) rs = RadioSetting("keylock", "Keypad Lock", RadioSettingValueBoolean(_settings.keylock)) advanced.append(rs) rs = RadioSetting( "voxdelay", "VOX Delay", RadioSettingValueList(VOX_DELAY_LIST, VOX_DELAY_LIST[_settings.voxdelay])) advanced.append(rs) rs = RadioSetting( "menu_timeout", "Menu Timeout", RadioSettingValueList(MENU_TIMEOUT_LIST, MENU_TIMEOUT_LIST[_settings.menu_timeout])) advanced.append(rs) rs = RadioSetting( "micgain", "Mic Gain", RadioSettingValueList(MICGAIN_LIST, MICGAIN_LIST[_settings.micgain])) advanced.append(rs) for entry in KEY_FUNCTIONS: if entry[1] == _keymaps.sidekey: rs = RadioSetting( "keymaps.sidekey", "Side Key Short Press", RadioSettingValueMap(KEY_FUNCTIONS, _keymaps.sidekey)) keymaps.append(rs) for entry in KEY_FUNCTIONS: if entry[1] == _keymaps.sidekeyl: rs = RadioSetting( "keymaps.sidekeyl", "Side Key Long Press", RadioSettingValueMap(KEY_FUNCTIONS, _keymaps.sidekeyl)) keymaps.append(rs) rs = RadioSetting( "workmodea", "Work Mode (A)", RadioSettingValueList(WORKMODE_LIST, WORKMODE_LIST[_settings.workmodea])) workmode.append(rs) rs = RadioSetting( "workmodeb", "Work Mode (B)", RadioSettingValueList(WORKMODE_LIST, WORKMODE_LIST[_settings.workmodeb])) workmode.append(rs) def convert_bytes_to_freq(bytes): real_freq = 0 for byte in bytes: real_freq = (real_freq * 10) + byte return chirp_common.format_freq(real_freq * 10) def my_validate(value): value = chirp_common.parse_freq(value) if 17400000 <= value and value < 40000000: msg = ("Can't be between 174.00000-400.00000") raise InvalidValueError(msg) return chirp_common.format_freq(value) def apply_freq(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 10 obj.band = value >= 40000000 for i in range(7, -1, -1): obj.freq[i] = value % 10 value /= 10 val1a = RadioSettingValueString(0, 10, convert_bytes_to_freq(_vfoa.freq)) val1a.set_validate_callback(my_validate) rs = RadioSetting("vfoa.freq", "VFO A Frequency", val1a) rs.set_apply_callback(apply_freq, _vfoa) workmode.append(rs) val1b = RadioSettingValueString(0, 10, convert_bytes_to_freq(_vfob.freq)) val1b.set_validate_callback(my_validate) rs = RadioSetting("vfob.freq", "VFO B Frequency", val1b) rs.set_apply_callback(apply_freq, _vfob) workmode.append(rs) rs = RadioSetting( "vfoa.sftd", "VFO A Shift", RadioSettingValueList(SHIFTD_LIST, SHIFTD_LIST[_vfoa.sftd])) workmode.append(rs) rs = RadioSetting( "vfob.sftd", "VFO B Shift", RadioSettingValueList(SHIFTD_LIST, SHIFTD_LIST[_vfob.sftd])) workmode.append(rs) def convert_bytes_to_offset(bytes): real_offset = 0 for byte in bytes: real_offset = (real_offset * 10) + byte return chirp_common.format_freq(real_offset * 100) def apply_offset(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 100 for i in range(5, -1, -1): obj.offset[i] = value % 10 value /= 10 val1a = RadioSettingValueString(0, 10, convert_bytes_to_offset(_vfoa.offset)) rs = RadioSetting("vfoa.offset", "VFO A Offset (0.0-999.999)", val1a) rs.set_apply_callback(apply_offset, _vfoa) workmode.append(rs) val1b = RadioSettingValueString(0, 10, convert_bytes_to_offset(_vfob.offset)) rs = RadioSetting("vfob.offset", "VFO B Offset (0.0-999.999)", val1b) rs.set_apply_callback(apply_offset, _vfob) workmode.append(rs) rs = RadioSetting( "vfoa.txpower", "VFO A Power", RadioSettingValueList(TXPOWER_LIST, TXPOWER_LIST[_vfoa.txpower])) workmode.append(rs) rs = RadioSetting( "vfob.txpower", "VFO B Power", RadioSettingValueList(TXPOWER_LIST, TXPOWER_LIST[_vfob.txpower])) workmode.append(rs) rs = RadioSetting( "vfoa.widenarr", "VFO A Bandwidth", RadioSettingValueList(BANDWIDTH_LIST, BANDWIDTH_LIST[_vfoa.widenarr])) workmode.append(rs) rs = RadioSetting( "vfob.widenarr", "VFO B Bandwidth", RadioSettingValueList(BANDWIDTH_LIST, BANDWIDTH_LIST[_vfob.widenarr])) workmode.append(rs) rs = RadioSetting( "vfoa.scode", "VFO A PTT-ID", RadioSettingValueList(PTTIDCODE_LIST, PTTIDCODE_LIST[_vfoa.scode])) workmode.append(rs) rs = RadioSetting( "vfob.scode", "VFO B PTT-ID", RadioSettingValueList(PTTIDCODE_LIST, PTTIDCODE_LIST[_vfob.scode])) workmode.append(rs) rs = RadioSetting( "vfoa.step", "VFO A Tuning Step", RadioSettingValueList(STEP_LIST, STEP_LIST[_vfoa.step])) workmode.append(rs) rs = RadioSetting( "vfob.step", "VFO B Tuning Step", RadioSettingValueList(STEP_LIST, STEP_LIST[_vfob.step])) workmode.append(rs) dtmfchars = "0123456789 *#ABCD" for i in range(0, 15): _codeobj = self._memobj.pttid[i].code _code = "".join([dtmfchars[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 5, _code, False) val.set_charset(dtmfchars) rs = RadioSetting("pttid/%i.code" % i, "PTT ID Code %i" % (i + 1), val) def apply_code(setting, obj): code = [] for j in range(0, 5): try: code.append(dtmfchars.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.code = code rs.set_apply_callback(apply_code, self._memobj.pttid[i]) dtmf.append(rs) rs = RadioSetting( "ani.aniid", "ANI ID", RadioSettingValueList(PTTID_LIST, PTTID_LIST[_ani.aniid])) dtmf.append(rs) _codeobj = self._memobj.ani.code _code = "".join([dtmfchars[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 5, _code, False) val.set_charset(dtmfchars) rs = RadioSetting("ani.code", "ANI Code", val) def apply_code(setting, obj): code = [] for j in range(0, 5): try: code.append(dtmfchars.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.code = code rs.set_apply_callback(apply_code, _ani) dtmf.append(rs) rs = RadioSetting( "dtmfst", "DTMF Sidetone", RadioSettingValueList(DTMFST_LIST, DTMFST_LIST[_settings.dtmfst])) dtmf.append(rs) if _ani.dtmfon > 0xC3: val = 0x00 else: val = _ani.dtmfon rs = RadioSetting( "ani.dtmfon", "DTMF Speed (on)", RadioSettingValueList(DTMFSPEED_LIST, DTMFSPEED_LIST[val])) dtmf.append(rs) if _ani.dtmfoff > 0xC3: val = 0x00 else: val = _ani.dtmfoff rs = RadioSetting( "ani.dtmfoff", "DTMF Speed (off)", RadioSettingValueList(DTMFSPEED_LIST, DTMFSPEED_LIST[val])) dtmf.append(rs) rs = RadioSetting( "pttlt", "PTT ID Delay", RadioSettingValueList(PTTLT_LIST, PTTLT_LIST[_settings.pttlt])) dtmf.append(rs) return group
def _get_settings(self): _settings = self._memobj.settings 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 _freqrange = self._memobj.freqrange _slabel = self._memobj.slabel basic = RadioSettingGroup("basic","Global Settings") freqrange = RadioSettingGroup("freqrange","Frequency Ranges") top = RadioSettingGroup("top","All Settings",basic,freqrange) settings = RadioSettings(top) def _filter(name): filtered = "" for char in str(name): if char in chirp_common.CHARSET_ASCII: filtered += char else: filtered += "" return filtered val = RadioSettingValueString(0,7,_filter(_slabel.startname)) rs = RadioSetting("startname","Startup Label",val) basic.append(rs) rs = RadioSetting("bg_color","LCD Color", RadioSettingValueList(BGCOLOR_LIST, BGCOLOR_LIST[_settings.bg_color])) basic.append(rs) rs = RadioSetting("bg_brightness","LCD Brightness", RadioSettingValueList(BGBRIGHT_LIST, BGBRIGHT_LIST[_settings.bg_brightness])) basic.append(rs) rs = RadioSetting("squelch","Squelch Level", RadioSettingValueList(SQUELCH_LIST, SQUELCH_LIST[_settings.squelch])) basic.append(rs) rs = RadioSetting("timeout_timer","Timeout Timer (TOT)", RadioSettingValueList(TIMEOUT_LIST, TIMEOUT_LIST[_settings.timeout_timer])) basic.append(rs) rs = RadioSetting("auto_power_off","Auto Power Off (APO)", RadioSettingValueList(APO_LIST, APO_LIST[_settings.auto_power_off])) basic.append(rs) rs = RadioSetting("voice_prompt","Beep Prompt", RadioSettingValueList(BEEP_LIST, BEEP_LIST[_settings.voice_prompt])) basic.append(rs) rs = RadioSetting("tbst_freq","Tone Burst Frequency", RadioSettingValueList(TBSTFREQ_LIST, TBSTFREQ_LIST[_settings.tbst_freq])) basic.append(rs) rs = RadioSetting("choose_tx_power","Max Level of TX Power", RadioSettingValueList(TXPWR_LIST, TXPWR_LIST[_settings.choose_tx_power])) basic.append(rs) (flow,fhigh) = self.valid_freq[0] flow /= 1000 fhigh /= 1000 fmidrange = (fhigh- flow)/2 rs = RadioSetting("txrangelow","TX Freq, Lower Limit (khz)", RadioSettingValueInteger(flow, flow + fmidrange, int(_freqrange.txrangelow)/10)) freqrange.append(rs) rs = RadioSetting("txrangehi","TX Freq, Upper Limit (khz)", RadioSettingValueInteger(fhigh-fmidrange, fhigh, int(_freqrange.txrangehi)/10)) freqrange.append(rs) rs = RadioSetting("rxrangelow","RX Freq, Lower Limit (khz)", RadioSettingValueInteger(flow, flow+fmidrange, int(_freqrange.rxrangelow)/10)) freqrange.append(rs) rs = RadioSetting("rxrangehi","RX Freq, Upper Limit (khz)", RadioSettingValueInteger(fhigh-fmidrange, fhigh, int(_freqrange.rxrangehi)/10)) freqrange.append(rs) return settings
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic") cw = RadioSettingGroup("cw", "CW") packet = RadioSettingGroup("packet", "Digital & packet") panel = RadioSettingGroup("panel", "Panel settings") extended = RadioSettingGroup("extended", "Extended") antenna = RadioSettingGroup("antenna", "Antenna selection") panelcontr = RadioSettingGroup("panelcontr", "Panel controls") top = RadioSettingGroup("top", "All Settings", basic, cw, packet, panelcontr, panel, extended, antenna) rs = RadioSetting("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) s = RadioSettingValueString(0, 7, ''.join([self._CALLSIGN_CHARSET[x] for x in self._memobj.callsign])) s.set_charset(self._CALLSIGN_CHARSET) rs = RadioSetting("callsign", "Callsign", s) 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_common2(self): settings = self._memobj.settings common2 = RadioSettingGroup('common2', 'Common 2') def apply_ponmsgtext(setting): settings.pon_msgtext = ( str(setting.value)[:12].strip().ljust(12, '\x00')) common2.append( self._pure_choice_setting('pon_msgtype', 'Power On Message Type', STARTUP_MODES)) _text = str(settings.pon_msgtext).rstrip('\x00') text = RadioSetting('settings.pon_msgtext', 'Power On Text', RadioSettingValueString( 0, 12, _text)) text.set_apply_callback(apply_ponmsgtext) common2.append(text) def apply_volume(setting, key): setattr(settings, key, VOLUMES[str(setting.value)]) volumes = {'poweron_tone': 'Power-on Tone', 'control_tone': 'Control Tone', 'warning_tone': 'Warning Tone', 'alert_tone': 'Alert Tone', 'sidetone': 'Sidetone', 'locator_tone': 'Locator Tone'} for value, name in volumes.items(): setting = getattr(settings, value) volume = RadioSetting('settings.%s' % value, name, RadioSettingValueList( VOLUMES.keys(), VOLUMES_REV.get(int(setting), 0))) volume.set_apply_callback(apply_volume, value) common2.append(volume) def apply_vol_level(setting, key): setattr(settings, key, int(setting.value)) levels = {'lo_volume': 'Low Volume Level (Fixed Volume)', 'hi_volume': 'High Volume Level (Fixed Volume)', 'min_volume': 'Minimum Audio Volume', 'max_volume': 'Maximum Audio Volume'} for value, name in levels.items(): setting = getattr(settings, value) if 'Audio' in name: minimum = 0 else: minimum = 1 volume = RadioSetting( 'settings.%s' % value, name, RadioSettingValueInteger(minimum, 31, int(setting))) volume.set_apply_callback(apply_vol_level, value) common2.append(volume) def apply_vo(setting): val = int(setting.value) if val < 0: val = abs(val) | 0x80 settings.tone_volume_offset = val _voloffset = int(settings.tone_volume_offset) if _voloffset & 0x80: _voloffset = abs(_voloffset & 0x7F) * -1 voloffset = RadioSetting( 'tvo', 'Tone Volume Offset', RadioSettingValueInteger( -5, 5, _voloffset)) voloffset.set_apply_callback(apply_vo) common2.append(voloffset) def apply_mvp(setting): settings.min_vol_preset = MIN_VOL_PRESET[str(setting.value)] _volpreset = int(settings.min_vol_preset) volpreset = RadioSetting( 'mvp', 'Minimum Volume Type', RadioSettingValueList(MIN_VOL_PRESET.keys(), MIN_VOL_PRESET_REV[_volpreset])) volpreset.set_apply_callback(apply_mvp) if not self.is_portable and 'mvp' in ONLY_MOBILE_SETTINGS: common2.append(volpreset) return common2
def get_settings(self): _settings = self._memobj.settings group = RadioSettingGroup("basic", "Basic") top = RadioSettings(group) 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 top group.append( RadioSetting("disnm", "Display Name", RadioSettingValueBoolean(_settings.disnm))) return group
def get_settings(self): common = RadioSettingGroup("common", "Common Settings") band = RadioSettingGroup("band", "Band dependent Settings") arts = RadioSettingGroup("arts", "Auto Range Transponder System (ARTS)") dtmf = RadioSettingGroup("dtmf", "DTMF Settings") mic_button = RadioSettingGroup("mic_button", "Microphone Buttons") setmode = RadioSettings(common, band, arts, dtmf, mic_button) _overlay = self._memobj.overlay # numbers and names of settings refer to the way they're # presented in the set menu, as well as the list starting on # page 49 of the manual # 1 Automatic Power Off opts = [ "Off", "30 Min", "1 Hour", "1.5 Hours", "2 Hours", "2.5 Hours", "3 Hours", "3.5 Hours", "4 Hours", "4.5 Hours", "5 Hours", "5.5 Hours", "6 Hours", "6.5 Hours", "7 Hours", "7.5 Hours", "8 Hours", "8.5 Hours", "9 Hours", "9.5 Hours", "10 Hours", "10.5 Hours", "11 Hours", "11.5 Hours", "12 Hours", ] common.append( RadioSetting("apo", "Automatic Power Off", RadioSettingValueList(opts, opts[_overlay.apo]))) # 2 Automatic Repeater Shift function opts = ["Off", "On"] band.append( RadioSetting("ars_vhf", "Automatic Repeater Shift VHF", RadioSettingValueList(opts, opts[_overlay.ars_vhf]))) band.append( RadioSetting("ars_uhf", "Automatic Repeater Shift UHF", RadioSettingValueList(opts, opts[_overlay.ars_uhf]))) # 3 Selects the ARTS mode. # -> Only useful to set it on the radio directly # 4 Enables/disables the key/button beeper. opts = ["Off", "On"] common.append( RadioSetting("beep", "Key/Button Beep", RadioSettingValueList(opts, opts[_overlay.beep]))) # 5 Enables/disables the CW IDer during ARTS operation. opts = ["Off", "On"] arts.append( RadioSetting("cwid", "Enables/Disables the CW ID", RadioSettingValueList(opts, opts[_overlay.cwid]))) # 6 Callsign during ARTS operation. cwidw = _overlay.cwidw.get_raw() cwidw = cwidw.rstrip('\x00') val = RadioSettingValueString(0, 6, cwidw) val.set_charset(CHARSET) rs = RadioSetting("cwidw", "CW Identifier Callsign", val) def apply_cwid(setting): value_string = setting.value.get_value() _overlay.cwidw.set_value(value_string) rs.set_apply_callback(apply_cwid) arts.append(rs) # 7 Front panel display's illumination level. opts = ["0: Off", "1: Max", "2", "3", "4", "5", "6", "7: Min"] common.append( RadioSetting("dim", "Display Illumination", RadioSettingValueList(opts, opts[_overlay.dim]))) # 8 Setting the DCS code number. # Note: This Menu item can be set independently for each band, # and independently in each memory. # 9 Activates the DCS Code Search # -> Only useful if set on radio itself # 10 Selects 'Normal' or 'Inverted' DCS coding. opts = ["TRX Normal", "RX Reversed", "TX Reversed", "TRX Reversed"] band.append( RadioSetting("dcsnr_vhf", "DCS coding VHF", RadioSettingValueList(opts, opts[_overlay.dcsnr_vhf]))) band.append( RadioSetting("dcsnr_uhf", "DCS coding UHF", RadioSettingValueList(opts, opts[_overlay.dcsnr_uhf]))) # 11 Selects the 'sub' band display format opts = [ "Frequency", "Off / Sub Band disabled", "DC Input Voltage", "CW ID" ] common.append( RadioSetting("disp", "Sub Band Display Format", RadioSettingValueList(opts, opts[_overlay.disp]))) # 12 Setting the DTMF Autodialer delay time opts = ["50 ms", "250 ms", "450 ms", "750 ms", "1 s"] dtmf.append( RadioSetting("dtmfd", "Autodialer delay time", RadioSettingValueList(opts, opts[_overlay.dtmfd]))) # 13 Setting the DTMF Autodialer sending speed opts = ["50 ms", "75 ms", "100 ms"] dtmf.append( RadioSetting("dtmfs", "Autodialer sending speed", RadioSettingValueList(opts, opts[_overlay.dtmfs]))) # 14 Current DTMF Autodialer memory rs = RadioSetting("dtmfw", "Current Autodialer memory", RadioSettingValueInteger(1, 16, _overlay.dtmfw + 1)) def apply_dtmfw(setting): _overlay.dtmfw = setting.value.get_value() - 1 rs.set_apply_callback(apply_dtmfw) dtmf.append(rs) # DTMF Memory for i in range(16): dtmf_string = "" for j in range(16): dtmf_char = '' dtmf_int = int(self._memobj.dtmf_mem[i].dtmf[j]) if dtmf_int < 10: dtmf_char = str(dtmf_int) elif dtmf_int == 14: dtmf_char = '*' elif dtmf_int == 15: dtmf_char = '#' elif dtmf_int == 255: break dtmf_string += dtmf_char radio_setting_value_string = RadioSettingValueString( 0, 16, dtmf_string) radio_setting_value_string.set_charset(DTMF_CHARSET) rs = RadioSetting("dtmf_{0:02d}".format(i), "DTMF Mem " + str(i + 1), radio_setting_value_string) def apply_dtmf(setting, index): radio_setting_value_string = setting.value.get_value().rstrip() j = 0 for dtmf_char in radio_setting_value_string: dtmf_int = 255 if dtmf_char in "0123456789": dtmf_int = int(dtmf_char) elif dtmf_char == '*': dtmf_int = 14 elif dtmf_char == '#': dtmf_int = 15 if dtmf_int < 255: self._memobj.dtmf_mem[index].dtmf[j] = dtmf_int j += 1 if j < 16: self._memobj.dtmf_mem[index].dtmf[j] = 255 rs.set_apply_callback(apply_dtmf, i) dtmf.append(rs) # 16 Enables/disables the PTT switch lock opts = ["Off", "Band A", "Band B", "Both"] common.append( RadioSetting("lockt", "PTT switch lock", RadioSettingValueList(opts, opts[_overlay.lockt]))) # 17 Selects the Microphone type to be used opts = ["MH-42", "MH-48"] common.append( RadioSetting("mic", "Microphone type", RadioSettingValueList(opts, opts[_overlay.mic]))) # 18 Reduces the audio level on the sub receiver when the # main receiver is active opts = ["Off", "On"] common.append( RadioSetting("mute", "Mute Sub Receiver", RadioSettingValueList(opts, opts[_overlay.mute]))) # 20 - 23 Programming the microphones button assignment buttons = [ "ACC / P1", "P / P2", "P1 / P3", "P2 / P4", ] opts_button = [ "Low", "Tone", "MHz", "Rev", "Home", "Band", "VFO / Memory", "Sql Off", "1750 Hz Tone Call", "Repeater", "Priority" ] for i, button in enumerate(buttons): rs = RadioSetting( "button" + str(i), button, RadioSettingValueList(opts_button, opts_button[_overlay.button[i]])) def apply_button(setting, index): value_string = setting.value.get_value() value_int = opts_button.index(value_string) _overlay.button[index] = value_int rs.set_apply_callback(apply_button, i) mic_button.append(rs) # 24 Adjusts the RF SQL threshold level opts = ["Off", "S-1", "S-5", "S-9", "S-FULL"] band.append( RadioSetting( "rf_sql_vhf", "RF Sql VHF", RadioSettingValueList(opts, opts[_overlay.rf_sql_vhf]))) band.append( RadioSetting( "rf_sql_uhf", "RF Sql UHF", RadioSettingValueList(opts, opts[_overlay.rf_sql_uhf]))) # 25 Selects the Scan-Resume mode opts = ["Busy", "Time"] band.append( RadioSetting("scan_vhf", "Scan-Resume VHF", RadioSettingValueList(opts, opts[_overlay.scan_vhf]))) band.append( RadioSetting("scan_uhf", "Scan-Resume UHF", RadioSettingValueList(opts, opts[_overlay.scan_uhf]))) # 28 Defining the audio path to the external speaker opts = ["Off", "Band A", "Band B", "Both"] common.append( RadioSetting( "speaker_cnt", "External Speaker", RadioSettingValueList(opts, opts[_overlay.speaker_cnt]))) # 31 Sets the Time-Out Timer opts = ["Off", "Band A", "Band B", "Both"] common.append( RadioSetting("tot", "TX Time-Out [Min.] (0 = Off)", RadioSettingValueInteger(0, 30, _overlay.tot))) # 32 Reducing the MIC Gain (and Deviation) opts = ["Off", "On"] band.append( RadioSetting("txnar_vhf", "TX Narrowband VHF", RadioSettingValueList(opts, opts[_overlay.txnar_vhf]))) band.append( RadioSetting("txnar_uhf", "TX Narrowband UHF", RadioSettingValueList(opts, opts[_overlay.txnar_uhf]))) # 33 Enables/disables the VFO Tracking feature opts = ["Off", "On"] common.append( RadioSetting("vfotr", "VFO Tracking", RadioSettingValueList(opts, opts[_overlay.vfotr]))) # 34 Selects the receiving mode on the VHF band opts = ["Inhibit (only FM)", "AM", "Auto"] common.append( RadioSetting("am", "AM Mode", RadioSettingValueList(opts, opts[_overlay.am]))) # Current Band opts = ["VHF", "UHF"] common.append( RadioSetting( "current_band", "Current Band", RadioSettingValueList(opts, opts[_overlay.current_band]))) # Show number of VHF and UHF channels val = RadioSettingValueString(0, 7, str(int(self._memobj.nb_mem_used_vhf))) val.set_mutable(False) rs = RadioSetting("num_chan_vhf", "Number of VHF channels", val) common.append(rs) val = RadioSettingValueString(0, 7, str(int(self._memobj.nb_mem_used_uhf))) val.set_mutable(False) rs = RadioSetting("num_chan_uhf", "Number of UHF channels", val) common.append(rs) return setmode
def get_settings(self): try: _squelch = 1 basic = RadioSettingGroup("basic", "Basic") expand_1 = RadioSettingGroup("expand_1", "Expand 1") expand_2 = RadioSettingGroup("expand_2", "Expand 2") dtmf_autodial = RadioSettingGroup("dtmf_autodial", "DTMF autodial") group = RadioSettings(basic, expand_1, expand_2, dtmf_autodial) # basic basic.append( RadioSetting( "mem_channel", "Current memory channel", RadioSettingValueInteger(0, MEM_NUM - 1, self.memobj.mem_channel))) basic.append( RadioSetting( "squelch_level", "Squelch level", RadioSettingValueList( SQUELCH_LEVEL, SQUELCH_LEVEL[self.memobj.squelch_level]))) basic.append( RadioSetting( "scan_resume", "Scan resume", RadioSettingValueList( SCAN_RESUME, SCAN_RESUME[self.memobj.scan_resume]))) basic.append( RadioSetting( "scan_pause", "Scan pause", RadioSettingValueList(SCAN_PAUSE, SCAN_PAUSE[self.memobj.scan_pause]))) basic.append( RadioSetting( "beep_volume", "Beep audio", RadioSettingValueList( BEEP_VOLUME, BEEP_VOLUME[self.memobj.beep_volume]))) basic.append( RadioSetting("beep", "Operation beep", RadioSettingValueBoolean(self.memobj.beep))) basic.append( RadioSetting( "backlight", "LCD backlight", RadioSettingValueList(BACKLIGHT, BACKLIGHT[self.memobj.backlight]))) basic.append( RadioSetting("busy_led", "Busy LED", RadioSettingValueBoolean(self.memobj.busy_led))) basic.append( RadioSetting( "auto_power_off", "Auto power off", RadioSettingValueList( AUTO_POWER_OFF, AUTO_POWER_OFF[self.memobj.auto_power_off]))) basic.append( RadioSetting( "power_save", "Power save", RadioSettingValueList(POWER_SAVE, POWER_SAVE[self.memobj.power_save]))) basic.append( RadioSetting( "monitor", "Monitor", RadioSettingValueList(MONITOR, MONITOR[self.memobj.monitor]))) basic.append( RadioSetting( "dial_speedup", "Dial speedup", RadioSettingValueBoolean(self.memobj.dial_speedup))) basic.append( RadioSetting( "auto_repeater", "Auto repeater", RadioSettingValueList( AUTO_REPEATER, AUTO_REPEATER[self.memobj.auto_repeater]))) basic.append( RadioSetting( "hm_75a_function", "HM-75A function", RadioSettingValueList( HM_75A_FUNCTION, HM_75A_FUNCTION[self.memobj.hm_75a_function]))) basic.append( RadioSetting("wx_alert", "WX alert", RadioSettingValueBoolean(self.memobj.wx_alert))) basic.append( RadioSetting( "wx_channel", "Current WX channel", RadioSettingValueList(WX_CHANNEL, WX_CHANNEL[self.memobj.wx_channel]))) basic.append( RadioSetting( "comment", "Comment", RadioSettingValueString(0, COMMENT_LEN, str(self.memobj.comment), autopad=True))) basic.append( RadioSetting( "tune_step", "Current tune step", RadioSettingValueList( TUNE_STEP_STR, TUNE_STEP_STR[self.memobj.tune_step]))) basic.append( RadioSetting( "band_selected", "Selected band", RadioSettingValueInteger(0, BANDS - 1, self.memobj.band_selected))) basic.append( RadioSetting( "memory_display", "Memory display", RadioSettingValueList( MEMORY_DISPLAY, MEMORY_DISPLAY[self.memobj.memory_display]))) basic.append( RadioSetting("memory_name", "Memory name", RadioSettingValueBoolean( self.memobj.memory_name))) basic.append( RadioSetting( "dial_select", "Dial select", RadioSettingValueList( DIAL_SELECT, DIAL_SELECT[self.memobj.dial_select]))) basic.append( RadioSetting( "power", "RF power", RadioSettingValueList(POWER, POWER[self.memobj.power]))) basic.append( RadioSetting("vfo", "Current VFO", RadioSettingValueList(VFO, VFO[self.memobj.vfo]))) basic.append( RadioSetting("attenuator", "RF attenuator", RadioSettingValueBoolean(self.memobj.attenuator))) basic.append( RadioSetting("skip_scan", "Skip scan", RadioSettingValueBoolean(self.memobj.skip_scan))) # TODO: this needs to be reverse engineered, because the following commented # code does not seem correct # basic.append(RadioSetting("mode", "Current mode", # RadioSettingValueList(OPERATION_MODE, # OPERATION_MODE[self.memobj.mode]))) basic.append( RadioSetting( "vfo_scan", "VFO scan", RadioSettingValueList(VFO_SCAN, VFO_SCAN[self.memobj.vfo_scan]))) basic.append( RadioSetting( "memory_scan", "Memory scan", RadioSettingValueList( MEMORY_SCAN, MEMORY_SCAN[self.memobj.memory_scan]))) basic.append( RadioSetting( "tv_channel", "Current TV channel", RadioSettingValueInteger(0, TV_CHANNELS - 1, self.memobj.tv_channel))) # DTMF auto dial dtmf_autodial.append( RadioSetting( "autodial", "Autodial", RadioSettingValueList(AUTODIAL, AUTODIAL[self.memobj.autodial]))) dtmf_autodial.append( RadioSetting( "dtmf_speed", "Speed", RadioSettingValueList(DTMF_SPEED, DTMF_SPEED[self.memobj.dtmf_speed]))) for x in range(DTMF_AUTODIAL_NUM): rs = RadioSetting( "dtmf_codes[%d].dtmf_digits" % x, "DTMF autodial: %d" % x, RadioSettingValueString( 0, DTMF_DIGITS_NUM, self.dtmf_icom2chirp( self.memobj.dtmf_codes[x].dtmf_digits), autopad=True, charset="0123456789ABCD*#abcd ")) rs.set_apply_callback(self.apply_dtmf_autodial, self.memobj.dtmf_codes[x].dtmf_digits) dtmf_autodial.append(rs) # expand 1 expand_1.append( RadioSetting("expand_1", "Expand 1", RadioSettingValueBoolean(self.memobj.expand_1))) expand_1.append( RadioSetting( "scan_stop_beep", "Scan stop beep", RadioSettingValueBoolean(self.memobj.scan_stop_beep))) expand_1.append( RadioSetting( "scan_stop_light", "Scan stop light", RadioSettingValueBoolean(self.memobj.scan_stop_light))) expand_1.append( RadioSetting( "light_postion", "Light position", RadioSettingValueList( LIGHT_POSITION, LIGHT_POSITION[self.memobj.light_position]))) expand_1.append( RadioSetting( "light_color", "Light color", RadioSettingValueList( LIGHT_COLOR, LIGHT_COLOR[self.memobj.light_color]))) expand_1.append( RadioSetting( "band_edge_beep", "Band edge beep", RadioSettingValueBoolean(self.memobj.band_edge_beep))) expand_1.append( RadioSetting( "auto_power_on", "Auto power on", RadioSettingValueList( AUTO_POWER_ON, AUTO_POWER_ON[self.memobj.auto_power_on]))) expand_1.append( RadioSetting( "key_lock", "Key lock", RadioSettingValueList(KEY_LOCK, KEY_LOCK[self.memobj.key_lock]))) expand_1.append( RadioSetting("ptt_lock", "PTT lock", RadioSettingValueBoolean(self.memobj.ptt_lock))) expand_1.append( RadioSetting( "lcd_contrast", "LCD contrast", RadioSettingValueList( LCD_CONTRAST, LCD_CONTRAST[self.memobj.lcd_contrast]))) expand_1.append( RadioSetting( "opening_message", "Opening message", RadioSettingValueBoolean(self.memobj.opening_message))) expand_1.append( RadioSetting( "opening_message_text", "Opening message", RadioSettingValueString( 0, OPENING_MESSAGE_LEN, str(self.memobj.opening_message_text), autopad=True, charset=CHARSET))) # expand 2 expand_2.append( RadioSetting("expand_2", "Expand 2", RadioSettingValueBoolean(self.memobj.expand_2))) expand_2.append( RadioSetting( "busy_lockout", "Busy lock out", RadioSettingValueBoolean(self.memobj.busy_lockout))) expand_2.append( RadioSetting( "timeout_timer", "Timeout timer", RadioSettingValueList( TIMEOUT_TIMER, TIMEOUT_TIMER[self.memobj.timeout_timer]))) expand_2.append( RadioSetting( "active_band", "Active band", RadioSettingValueList( ACTIVE_BAND, ACTIVE_BAND[self.memobj.active_band]))) expand_2.append( RadioSetting("fm_narrow", "FM narrow", RadioSettingValueBoolean(self.memobj.fm_narrow))) expand_2.append( RadioSetting("split", "Split", RadioSettingValueBoolean(self.memobj.split))) expand_2.append( RadioSetting( "morse_code_enable", "Morse code synthesizer", RadioSettingValueBoolean(self.memobj.morse_code_enable))) expand_2.append( RadioSetting( "morse_code_speed", "Morse code speed", RadioSettingValueList( MORSE_CODE_SPEED, MORSE_CODE_SPEED[self.memobj.morse_code_speed]))) return group except: import traceback LOG.error("Failed to parse settings: %s", traceback.format_exc()) return None