def get_settings(self): top = RadioSettings() aprs = RadioSettingGroup("aprs", "APRS") top.append(aprs) myc = self._memobj.aprs_my_callsign rs = RadioSetting("aprs_my_callsign.call", "APRS My Callsign", RadioSettingValueString(0, 6, aprs_call_to_str(myc.call))) aprs.append(rs) rs = RadioSetting("aprs_my_callsign.ssid", "APRS My SSID", RadioSettingValueInteger(0, 15, myc.ssid)) aprs.append(rs) return top
def _get_settings(self): _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): """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 basic = RadioSettingGroup("basic", "Basic Settings") group = RadioSettings(basic) options = ["Time", "Carrier", "Search"] rs = RadioSetting( "scantype", "Scan Type", RadioSettingValueList(options, options[_settings.scantype])) basic.append(rs) options = ["Off"] + ["%s min" % x for x in range(1, 8)] rs = RadioSetting( "timeout", "Time Out Timer", RadioSettingValueList(options, options[_settings.timeout])) basic.append(rs) options = ["A", "B"] rs = RadioSetting( "freqmode_ab", "Frequency Mode", RadioSettingValueList(options, options[_settings.freqmode_ab])) basic.append(rs) options = ["Frequency Mode", "Channel Mode"] rs = RadioSetting( "workmode_a", "Radio Work Mode(A)", RadioSettingValueList(options, options[_settings.workmode_a])) basic.append(rs) rs = RadioSetting( "workmode_b", "Radio Work Mode(B)", RadioSettingValueList(options, options[_settings.workmode_b])) basic.append(rs) options = ["Frequency", "Name", "Channel"] rs = RadioSetting( "mdf_a", "Display Format(F1)", RadioSettingValueList(options, options[_settings.mdf_a])) basic.append(rs) rs = RadioSetting( "mdf_b", "Display Format(F2)", RadioSettingValueList(options, options[_settings.mdf_b])) basic.append(rs) rs = RadioSetting( "mem_chan_a", "Mem Channel (A)", RadioSettingValueInteger(1, 99, _settings.mem_chan_a)) basic.append(rs) rs = RadioSetting( "mem_chan_b", "Mem Channel (B)", RadioSettingValueInteger(1, 99, _settings.mem_chan_b)) basic.append(rs) options = ["Off", "BOT", "EOT", "Both"] rs = RadioSetting( "pttid", "PTT-ID", RadioSettingValueList(options, options[_settings.pttid])) basic.append(rs) dtmfchars = "0123456789ABCD*#" _codeobj = self._memobj.pttid.code _code = "".join([dtmfchars[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 6, _code, False) val.set_charset(dtmfchars) rs = RadioSetting("pttid.code", "PTT-ID Code", val) def apply_code(setting, obj): code = [] for j in range(0, 6): try: code.append(dtmfchars.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.code = code rs.set_apply_callback(apply_code, self._memobj.pttid) basic.append(rs) rs = RadioSetting("squelch", "Squelch Level", RadioSettingValueInteger(0, 9, _settings.squelch)) basic.append(rs) rs = RadioSetting("vox", "VOX Level", RadioSettingValueInteger(0, 9, _settings.vox)) basic.append(rs) options = ["Frequency Mode", "Channel Mode"] rs = RadioSetting( "workmode_fm", "FM Work Mode", RadioSettingValueList(options, options[_settings.workmode_fm])) basic.append(rs) options = ["Current Frequency", "F1 Frequency", "F2 Frequency"] rs = RadioSetting( "txtdr", "Dual Standby TX Priority", RadioSettingValueList(options, options[_settings.txtdr])) basic.append(rs) options = ["English", "Chinese"] rs = RadioSetting( "language", "Language", RadioSettingValueList(options, options[_settings.language])) basic.append(rs) rs = RadioSetting("tdr", "Dual Standby", RadioSettingValueBoolean(_settings.tdr)) basic.append(rs) rs = RadioSetting("roger", "Roger Beep", RadioSettingValueBoolean(_settings.roger)) basic.append(rs) rs = RadioSetting("backlight", "Backlight", RadioSettingValueBoolean(_settings.backlight)) basic.append(rs) rs = RadioSetting("save_funct", "Save Mode", RadioSettingValueBoolean(_settings.save_funct)) basic.append(rs) rs = RadioSetting("fm", "FM Function", RadioSettingValueBoolean(_settings.fm)) basic.append(rs) rs = RadioSetting( "beep_tone_disabled", "Beep Prompt", RadioSettingValueBoolean(not _settings.beep_tone_disabled)) basic.append(rs) rs = RadioSetting("voice_prompt", "Voice Prompt", RadioSettingValueBoolean(_settings.voice_prompt)) basic.append(rs) rs = RadioSetting("sidetone", "DTMF Side Tone", RadioSettingValueBoolean(_settings.sidetone)) basic.append(rs) rs = RadioSetting("ste_disabled", "Squelch Tail Eliminate", RadioSettingValueBoolean(not _settings.ste_disabled)) basic.append(rs) _limit = int(self._memobj.limits.lower_vhf) / 10 rs = RadioSetting("limits.lower_vhf", "VHF Lower Limit (MHz)", RadioSettingValueInteger(128, 270, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.lower_vhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) _limit = int(self._memobj.limits.upper_vhf) / 10 rs = RadioSetting("limits.upper_vhf", "VHF Upper Limit (MHz)", RadioSettingValueInteger(128, 270, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.upper_vhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) _limit = int(self._memobj.limits.lower_uhf) / 10 rs = RadioSetting("limits.lower_uhf", "UHF Lower Limit (MHz)", RadioSettingValueInteger(400, 520, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.lower_uhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) _limit = int(self._memobj.limits.upper_uhf) / 10 rs = RadioSetting("limits.upper_uhf", "UHF Upper Limit (MHz)", RadioSettingValueInteger(400, 520, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.upper_uhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) fm_preset = RadioSettingGroup("fm_preset", "FM Radio Presets") group.append(fm_preset) for i in range(0, 16): if self._memobj.fm_presets[i] < 0x01AF: used = True preset = self._memobj.fm_presets[i] / 10.0 + 65 else: used = False preset = 65 rs = RadioSetting("fm_presets_%1i" % i, "FM Preset %i" % (i + 1), RadioSettingValueBoolean(used), RadioSettingValueFloat(65, 108, preset, 0.1, 1)) fm_preset.append(rs) testmode = RadioSettingGroup("testmode", "Test Mode Settings") group.append(testmode) vhfdata = [ "136-139", "140-144", "145-149", "150-154", "155-159", "160-164", "165-169", "170-174" ] uhfdata = [ "400-409", "410-419", "420-429", "430-439", "440-449", "450-459", "460-469", "470-479" ] powernamedata = ["Hi", "Lo"] powerkeydata = ["hipwr", "lopwr"] for power in range(0, 2): for index in range(0, 8): key = "test.vhf%s%i" % (powerkeydata[power], index) name = "%s Mhz %s Power" % (vhfdata[index], powernamedata[power]) rs = RadioSetting( key, name, RadioSettingValueInteger( 0, 255, getattr(self._memobj.test, "vhf%s%i" % (powerkeydata[power], index)))) testmode.append(rs) for power in range(0, 2): for index in range(0, 8): key = "test.uhf%s%i" % (powerkeydata[power], index) name = "%s Mhz %s Power" % (uhfdata[index], powernamedata[power]) rs = RadioSetting( key, name, RadioSettingValueInteger( 0, 255, getattr(self._memobj.test, "uhf%s%i" % (powerkeydata[power], index)))) testmode.append(rs) for band in ["vhf", "uhf"]: for index in range(0, 10): key = "test.%ssquelch%i" % (band, index) name = "%s Squelch %i" % (band.upper(), index) rs = RadioSetting( key, name, RadioSettingValueInteger( 0, 255, getattr(self._memobj.test, "%ssquelch%i" % (band, index)))) testmode.append(rs) return group
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic Settings") group = RadioSettings(basic) options = ["Time", "Carrier", "Search"] rs = RadioSetting("scantype", "Scan Type", RadioSettingValueList(options, options[_settings.scantype])) basic.append(rs) options = ["Off"] + ["%s min" % x for x in range(1, 8)] rs = RadioSetting("timeout", "Time Out Timer", RadioSettingValueList( options, options[_settings.timeout])) basic.append(rs) options = ["A", "B"] rs = RadioSetting("freqmode_ab", "Frequency Mode", RadioSettingValueList( options, options[_settings.freqmode_ab])) basic.append(rs) options = ["Frequency Mode", "Channel Mode"] rs = RadioSetting("workmode_a", "Radio Work Mode(A)", RadioSettingValueList( options, options[_settings.workmode_a])) basic.append(rs) rs = RadioSetting("workmode_b", "Radio Work Mode(B)", RadioSettingValueList( options, options[_settings.workmode_b])) basic.append(rs) options = ["Frequency", "Name", "Channel"] rs = RadioSetting("mdf_a", "Display Format(F1)", RadioSettingValueList( options, options[_settings.mdf_a])) basic.append(rs) rs = RadioSetting("mdf_b", "Display Format(F2)", RadioSettingValueList( options, options[_settings.mdf_b])) basic.append(rs) rs = RadioSetting("mem_chan_a", "Mem Channel (A)", RadioSettingValueInteger( 1, 99, _settings.mem_chan_a)) basic.append(rs) rs = RadioSetting("mem_chan_b", "Mem Channel (B)", RadioSettingValueInteger( 1, 99, _settings.mem_chan_b)) basic.append(rs) options = ["Off", "BOT", "EOT", "Both"] rs = RadioSetting("pttid", "PTT-ID", RadioSettingValueList( options, options[_settings.pttid])) basic.append(rs) dtmfchars = "0123456789ABCD*#" _codeobj = self._memobj.pttid.code _code = "".join([dtmfchars[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 6, _code, False) val.set_charset(dtmfchars) rs = RadioSetting("pttid.code", "PTT-ID Code", val) def apply_code(setting, obj): code = [] for j in range(0, 6): try: code.append(dtmfchars.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.code = code rs.set_apply_callback(apply_code, self._memobj.pttid) basic.append(rs) rs = RadioSetting("squelch", "Squelch Level", RadioSettingValueInteger(0, 9, _settings.squelch)) basic.append(rs) rs = RadioSetting("vox", "VOX Level", RadioSettingValueInteger(0, 9, _settings.vox)) basic.append(rs) options = ["Frequency Mode", "Channel Mode"] rs = RadioSetting("workmode_fm", "FM Work Mode", RadioSettingValueList( options, options[_settings.workmode_fm])) basic.append(rs) options = ["Current Frequency", "F1 Frequency", "F2 Frequency"] rs = RadioSetting("txtdr", "Dual Standby TX Priority", RadioSettingValueList(options, options[_settings.txtdr])) basic.append(rs) options = ["English", "Chinese"] rs = RadioSetting("language", "Language", RadioSettingValueList(options, options[_settings.language])) basic.append(rs) rs = RadioSetting("tdr", "Dual Standby", RadioSettingValueBoolean(_settings.tdr)) basic.append(rs) rs = RadioSetting("roger", "Roger Beep", RadioSettingValueBoolean(_settings.roger)) basic.append(rs) rs = RadioSetting("backlight", "Backlight", RadioSettingValueBoolean(_settings.backlight)) basic.append(rs) rs = RadioSetting("save_funct", "Save Mode", RadioSettingValueBoolean(_settings.save_funct)) basic.append(rs) rs = RadioSetting("fm", "FM Function", RadioSettingValueBoolean(_settings.fm)) basic.append(rs) rs = RadioSetting("beep_tone_disabled", "Beep Prompt", RadioSettingValueBoolean( not _settings.beep_tone_disabled)) basic.append(rs) rs = RadioSetting("voice_prompt", "Voice Prompt", RadioSettingValueBoolean(_settings.voice_prompt)) basic.append(rs) rs = RadioSetting("sidetone", "DTMF Side Tone", RadioSettingValueBoolean(_settings.sidetone)) basic.append(rs) rs = RadioSetting("ste_disabled", "Squelch Tail Eliminate", RadioSettingValueBoolean(not _settings.ste_disabled)) basic.append(rs) _limit = int(self._memobj.limits.lower_vhf) / 10 rs = RadioSetting("limits.lower_vhf", "VHF Lower Limit (MHz)", RadioSettingValueInteger(128, 270, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.lower_vhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) _limit = int(self._memobj.limits.upper_vhf) / 10 rs = RadioSetting("limits.upper_vhf", "VHF Upper Limit (MHz)", RadioSettingValueInteger(128, 270, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.upper_vhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) _limit = int(self._memobj.limits.lower_uhf) / 10 rs = RadioSetting("limits.lower_uhf", "UHF Lower Limit (MHz)", RadioSettingValueInteger(400, 520, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.lower_uhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) _limit = int(self._memobj.limits.upper_uhf) / 10 rs = RadioSetting("limits.upper_uhf", "UHF Upper Limit (MHz)", RadioSettingValueInteger(400, 520, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.upper_uhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) fm_preset = RadioSettingGroup("fm_preset", "FM Radio Presets") group.append(fm_preset) for i in range(0, 16): if self._memobj.fm_presets[i] < 0x01AF: used = True preset = self._memobj.fm_presets[i] / 10.0 + 65 else: used = False preset = 65 rs = RadioSetting("fm_presets_%1i" % i, "FM Preset %i" % (i + 1), RadioSettingValueBoolean(used), RadioSettingValueFloat(65, 108, preset, 0.1, 1)) fm_preset.append(rs) testmode = RadioSettingGroup("testmode", "Test Mode Settings") group.append(testmode) vhfdata = ["136-139", "140-144", "145-149", "150-154", "155-159", "160-164", "165-169", "170-174"] uhfdata = ["400-409", "410-419", "420-429", "430-439", "440-449", "450-459", "460-469", "470-479"] powernamedata = ["Hi", "Lo"] powerkeydata = ["hipwr", "lopwr"] for power in range(0, 2): for index in range(0, 8): key = "test.vhf%s%i" % (powerkeydata[power], index) name = "%s Mhz %s Power" % (vhfdata[index], powernamedata[power]) rs = RadioSetting( key, name, RadioSettingValueInteger( 0, 255, getattr( self._memobj.test, "vhf%s%i" % (powerkeydata[power], index)))) testmode.append(rs) for power in range(0, 2): for index in range(0, 8): key = "test.uhf%s%i" % (powerkeydata[power], index) name = "%s Mhz %s Power" % (uhfdata[index], powernamedata[power]) rs = RadioSetting( key, name, RadioSettingValueInteger( 0, 255, getattr( self._memobj.test, "uhf%s%i" % (powerkeydata[power], index)))) testmode.append(rs) for band in ["vhf", "uhf"]: for index in range(0, 10): key = "test.%ssquelch%i" % (band, index) name = "%s Squelch %i" % (band.upper(), index) rs = RadioSetting( key, name, RadioSettingValueInteger( 0, 255, getattr( self._memobj.test, "%ssquelch%i" % (band, index)))) testmode.append(rs) return group
def _get_settings(self): _settings = self._memobj.settings _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): """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 basic = RadioSettingGroup("basic", "Basic Settings") fm = RadioSettingGroup("fm", "FM Radio") adv = RadioSettingGroup("adv", "Advanced Settings") group = RadioSettings(basic, fm, adv) # ## Basic Settings rs = RadioSetting("tx_pwr", "TX Power", RadioSettingValueList( POWER_LIST, POWER_LIST[_settings.tx_pwr])) basic.append(rs) rs = RadioSetting("channel", "Active Channel", RadioSettingValueInteger(1, 20, _settings.channel)) basic.append(rs) rs = RadioSetting("squelch", "Squelch Level", RadioSettingValueInteger(0, 9, _settings.squelch)) basic.append(rs) rs = RadioSetting("vox", "VOX Level", RadioSettingValueInteger(0, 9, _settings.vox)) basic.append(rs) # volume validation, as the OEM software set 0xFF on write _volume = _settings.volume if _volume > 7: _volume = 7 rs = RadioSetting("volume", "Volume Level", RadioSettingValueInteger(0, 7, _volume)) basic.append(rs) rs = RadioSetting("scantype", "Scan Type", RadioSettingValueList(SCAN_TYPE_LIST, SCAN_TYPE_LIST[ _settings.scantype])) basic.append(rs) rs = RadioSetting("timeout", "Time Out Timer (seconds)", RadioSettingValueList( TOT_LIST, TOT_LIST[_settings.timeout])) basic.append(rs) rs = RadioSetting("voice", "Voice Prompt", RadioSettingValueList( LANGUAGE_LIST, LANGUAGE_LIST[_settings.voice])) basic.append(rs) rs = RadioSetting("alarm", "Alarm Time", RadioSettingValueList( TIMER_LIST, TIMER_LIST[_settings.alarm])) basic.append(rs) rs = RadioSetting("backlight", "Backlight", RadioSettingValueList( BACKLIGHT_LIST, BACKLIGHT_LIST[_settings.backlight])) basic.append(rs) rs = RadioSetting("blo", "Busy Lockout", RadioSettingValueBoolean(_settings.blo)) basic.append(rs) rs = RadioSetting("ste", "Squelch Tail Eliminate", RadioSettingValueBoolean(_settings.ste)) basic.append(rs) rs = RadioSetting("batsave", "Battery Save", RadioSettingValueBoolean(_settings.batsave)) basic.append(rs) rs = RadioSetting("lock", "Key Lock", RadioSettingValueBoolean(_settings.lock)) basic.append(rs) rs = RadioSetting("beep", "Key Beep", RadioSettingValueBoolean(_settings.beep)) basic.append(rs) # ## FM Settings rs = RadioSetting("fm_funct", "FM Function", RadioSettingValueBoolean(_settings.fm_funct)) fm.append(rs) rs = RadioSetting("fmrange", "FM Range", RadioSettingValueList( FM_RANGE_LIST, FM_RANGE_LIST[_settings.fmrange])) fm.append(rs) # callbacks for the FM VFO def apply_fm_freq(setting, obj): setattr(obj, setting.get_name(), int(setting.value. get_value() * 10) - 650) _fm_vfo = int(_settings.fm_vfo) * 0.1 + 65 rs = RadioSetting("fm_vfo", "FM Station", RadioSettingValueFloat(65, 108, _fm_vfo)) rs.set_apply_callback(apply_fm_freq, _settings) fm.append(rs) # ## Advanced def apply_limit(setting, obj): setattr(obj, setting.get_name(), int(setting.value) * 10) rs = RadioSetting("vhfl", "VHF Low Limit", RadioSettingValueInteger(130, 174, int( _settings.vhfl) / 10)) rs.set_apply_callback(apply_limit, _settings) adv.append(rs) rs = RadioSetting("vhfh", "VHF High Limit", RadioSettingValueInteger(130, 174, int( _settings.vhfh) / 10)) rs.set_apply_callback(apply_limit, _settings) adv.append(rs) rs = RadioSetting("uhfl", "UHF Low Limit", RadioSettingValueInteger(400, 520, int( _settings.uhfl) / 10)) rs.set_apply_callback(apply_limit, _settings) adv.append(rs) rs = RadioSetting("uhfh", "UHF High Limit", RadioSettingValueInteger(400, 520, int( _settings.uhfh) / 10)) rs.set_apply_callback(apply_limit, _settings) adv.append(rs) rs = RadioSetting("relaym", "Relay Mode", RadioSettingValueList(RELAY_MODE_LIST, RELAY_MODE_LIST[_settings.relaym])) adv.append(rs) return group
def get_settings(self): _settings = self._memobj.settings 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): _msg = self._memobj.welcome_msg _oem = self._memobj.oem_info _settings = self._memobj.settings cfg_grp = RadioSettingGroup("cfg_grp", "Function Setup") oem_grp = RadioSettingGroup("oem_grp", "OEM Info") group = RadioSettings(cfg_grp, oem_grp) def _filter(name): filtered = "" for char in str(name): if char in chirp_common.CHARSET_ASCII: filtered += char else: filtered += " " return filtered # # Function Setup # rs = RadioSetting("welcome_msg.line1", "Welcome Message 1", RadioSettingValueString(0, 6, _filter(_msg.line1))) cfg_grp.append(rs) rs = RadioSetting("welcome_msg.line2", "Welcome Message 2", RadioSettingValueString(0, 6, _filter(_msg.line2))) cfg_grp.append(rs) rs = RadioSetting( "display", "Display Mode", RadioSettingValueList(DISPLAY, DISPLAY[_settings.display])) cfg_grp.append(rs) rs = RadioSetting( "upvfomr", "Up VFO/MR", RadioSettingValueList(VFOMR, VFOMR[_settings.upvfomr])) cfg_grp.append(rs) rs = RadioSetting( "dnvfomr", "Down VFO/MR", RadioSettingValueList(VFOMR, VFOMR[_settings.dnvfomr])) cfg_grp.append(rs) rs = RadioSetting( "upwork", "Up Work Mode", RadioSettingValueList(WORKMODE, WORKMODE[_settings.upwork])) cfg_grp.append(rs) rs = RadioSetting( "upmrbank", "Up MR Bank", RadioSettingValueList(MRBANK, MRBANK[_settings.upmrbank])) cfg_grp.append(rs) rs = RadioSetting("upmrch", "Up MR Channel", RadioSettingValueInteger(0, 200, _settings.upmrch)) cfg_grp.append(rs) rs = RadioSetting( "dnwork", "Down Work Mode", RadioSettingValueList(WORKMODE, WORKMODE[_settings.dnwork])) cfg_grp.append(rs) rs = RadioSetting( "dnmrbank", "Down MR Bank", RadioSettingValueList(MRBANK, MRBANK[_settings.dnmrbank])) cfg_grp.append(rs) rs = RadioSetting("dnmrch", "Down MR Channel", RadioSettingValueInteger(0, 200, _settings.dnmrch)) cfg_grp.append(rs) rs = RadioSetting("main", "Main", RadioSettingValueList(MAIN, MAIN[_settings.main])) cfg_grp.append(rs) rs = RadioSetting("pause", "Scan Pause Time", RadioSettingValueList(PAUSE, PAUSE[_settings.pause])) cfg_grp.append(rs) rs = RadioSetting("stop", "Function Keys Stop Time", RadioSettingValueList(STOP, STOP[_settings.stop])) cfg_grp.append(rs) rs = RadioSetting( "backlight", "Backlight", RadioSettingValueList(BACKLIGHT, BACKLIGHT[_settings.backlight])) cfg_grp.append(rs) rs = RadioSetting("color", "Backlight Color", RadioSettingValueList(COLOR, COLOR[_settings.color])) cfg_grp.append(rs) rs = RadioSetting( "vdisplay", "Vice-Machine Display", RadioSettingValueList(VDISPLAY, VDISPLAY[_settings.vdisplay])) cfg_grp.append(rs) rs = RadioSetting( "voxlevel", "Vox Level", RadioSettingValueList(VOXLEVEL, VOXLEVEL[_settings.voxlevel])) cfg_grp.append(rs) rs = RadioSetting( "voxdelay", "Vox Delay", RadioSettingValueList(VOXDELAY, VOXDELAY[_settings.voxdelay])) cfg_grp.append(rs) rs = RadioSetting("tot", "Time Out Timer", RadioSettingValueList(TOT, TOT[_settings.tot])) cfg_grp.append(rs) rs = RadioSetting("tbst", "Tone Burst", RadioSettingValueList(TBST, TBST[_settings.tbst])) cfg_grp.append(rs) rs = RadioSetting("monikey", "MONI Key Function", RadioSettingValueList(MONI, MONI[_settings.monikey])) cfg_grp.append(rs) if self.MODEL == "TERMN-8R": rs = RadioSetting( "pf1key", "PF1 Key Function", RadioSettingValueList(PFKEYT, PFKEYT[_settings.pf1key])) cfg_grp.append(rs) rs = RadioSetting( "pf2key", "PF2 Key Function", RadioSettingValueList(PFKEYT, PFKEYT[_settings.pf2key])) cfg_grp.append(rs) if self.MODEL == "OBLTR-8R": rs = RadioSetting( "pf1key", "PF1 Key Function", RadioSettingValueList(PFKEYO, PFKEYO[_settings.pf1key])) cfg_grp.append(rs) rs = RadioSetting( "fmam", "PF2 Key Function", RadioSettingValueList(PFKEYO, PFKEYO[_settings.fmam])) cfg_grp.append(rs) rs = RadioSetting("apo", "Automatic Power Off", RadioSettingValueList(APO, APO[_settings.apo])) cfg_grp.append(rs) rs = RadioSetting("save", "Power Save", RadioSettingValueList(SAVE, SAVE[_settings.save])) cfg_grp.append(rs) rs = RadioSetting("tail", "Tail Eliminator Type", RadioSettingValueList(TAIL, TAIL[_settings.tail])) cfg_grp.append(rs) rs = RadioSetting( "fmvfomr", "FM VFO/MR", RadioSettingValueList(VFOMR, VFOMR[_settings.fmvfomr])) cfg_grp.append(rs) rs = RadioSetting("fmmrch", "FM MR Channel", RadioSettingValueInteger(0, 100, _settings.fmmrch)) cfg_grp.append(rs) rs = RadioSetting("noaa", "NOAA", RadioSettingValueList(NOAA, NOAA[_settings.noaa])) cfg_grp.append(rs) rs = RadioSetting( "noaach", "NOAA Channel", RadioSettingValueList(NOAACH, NOAACH[_settings.noaach])) cfg_grp.append(rs) rs = RadioSetting( "part95", "PART95", RadioSettingValueList(PART95, PART95[_settings.part95])) cfg_grp.append(rs) rs = RadioSetting("gmrs", "GMRS", RadioSettingValueList(GMRS, GMRS[_settings.gmrs])) cfg_grp.append(rs) rs = RadioSetting("murs", "MURS", RadioSettingValueList(MURS, MURS[_settings.murs])) cfg_grp.append(rs) for i in range(0, 9): val = self._memobj.banklink[i].bank rs = RadioSetting("banklink/%i.bank" % i, "Bank Link %i" % (i + 1), RadioSettingValueBoolean(val)) cfg_grp.append(rs) val = self._memobj.banklink[9].bank rs = RadioSetting("banklink/9.bank", "Bank Link 0", RadioSettingValueBoolean(val)) cfg_grp.append(rs) rs = RadioSetting("allband", "All Band", RadioSettingValueBoolean(_settings.allband)) cfg_grp.append(rs) rs = RadioSetting("alarmoff", "Alarm Function Off", RadioSettingValueBoolean(_settings.alarmoff)) cfg_grp.append(rs) rs = RadioSetting("beep", "Beep", RadioSettingValueBoolean(_settings.beep)) cfg_grp.append(rs) rs = RadioSetting("radio", "Radio", RadioSettingValueBoolean(_settings.radio)) cfg_grp.append(rs) if self.MODEL == "TERMN-8R": rs = RadioSetting("keylock", "Keylock", RadioSettingValueBoolean(_settings.keylock)) cfg_grp.append(rs) rs = RadioSetting("fastscan", "Fast Scan", RadioSettingValueBoolean(_settings.fastscan)) cfg_grp.append(rs) if self.MODEL == "OBLTR-8R": # "pf2key" is used for OBLTR-8R "keylock" rs = RadioSetting("pf2key", "Keylock", RadioSettingValueBoolean(_settings.pf2key)) cfg_grp.append(rs) rs = RadioSetting("fastscano", "Fast Scan", RadioSettingValueBoolean(_settings.fastscano)) cfg_grp.append(rs) rs = RadioSetting("uplink", "Up Bank Link Select", RadioSettingValueBoolean(_settings.uplink)) cfg_grp.append(rs) rs = RadioSetting("downlink", "Down Bank Link Select", RadioSettingValueBoolean(_settings.downlink)) cfg_grp.append(rs) # # OEM info # val = RadioSettingValueString(0, 7, _filter(_oem.model)) val.set_mutable(False) rs = RadioSetting("oem_info.model", "Model", val) oem_grp.append(rs) val = RadioSettingValueString(0, 9, _filter(_oem.date)) val.set_mutable(False) rs = RadioSetting("oem_info.date", "Date", val) oem_grp.append(rs) val = RadioSettingValueString(0, 16, _filter(_oem.dealer)) val.set_mutable(False) rs = RadioSetting("oem_info.dealer", "Dealer Code", val) oem_grp.append(rs) val = RadioSettingValueString(0, 9, _filter(_oem.stockdate)) val.set_mutable(False) rs = RadioSetting("oem_info.stockdate", "Stock Date", val) oem_grp.append(rs) val = RadioSettingValueString(0, 9, _filter(_oem.selldate)) val.set_mutable(False) rs = RadioSetting("oem_info.selldate", "Sell Date", val) oem_grp.append(rs) return group
def get_settings(self): """Translate the bit in the mem_struct into settings in the UI""" _mem = self._memobj basic = RadioSettingGroup("basic", "Basic Settings") advanced = RadioSettingGroup("advanced", "Advanced Settings") other = RadioSettingGroup("other", "Other Settings") work = RadioSettingGroup("work", "Work Mode Settings") fm_preset = RadioSettingGroup("fm_preset", "FM Preset") dtmfe = RadioSettingGroup("dtmfe", "DTMF Encode Settings") service = RadioSettingGroup("service", "Service Settings") top = RadioSettings(basic, advanced, other, work, fm_preset, dtmfe, service) # Basic settings if _mem.settings.squelch > 0x09: val = 0x00 else: val = _mem.settings.squelch rs = RadioSetting( "settings.squelch", "Squelch", RadioSettingValueList(LIST_OFF1TO9, LIST_OFF1TO9[val])) basic.append(rs) if _mem.settings.save > 0x04: val = 0x00 else: val = _mem.settings.save rs = RadioSetting("settings.save", "Battery Saver", RadioSettingValueList(LIST_SAVE, LIST_SAVE[val])) basic.append(rs) if _mem.settings.vox > 0x0A: val = 0x00 else: val = _mem.settings.vox rs = RadioSetting( "settings.vox", "Vox", RadioSettingValueList(LIST_OFF1TO10, LIST_OFF1TO10[val])) basic.append(rs) if _mem.settings.abr > 0x0A: val = 0x00 else: val = _mem.settings.abr rs = RadioSetting( "settings.abr", "Backlight Timeout", RadioSettingValueList(LIST_OFF1TO10, LIST_OFF1TO10[val])) basic.append(rs) rs = RadioSetting("settings.tdr", "Dual Watch", RadioSettingValueBoolean(_mem.settings.tdr)) basic.append(rs) rs = RadioSetting("settings.beep", "Beep", RadioSettingValueBoolean(_mem.settings.beep)) basic.append(rs) if _mem.settings.timeout > 0x27: val = 0x03 else: val = _mem.settings.timeout rs = RadioSetting( "settings.timeout", "Timeout Timer", RadioSettingValueList(LIST_TIMEOUT, LIST_TIMEOUT[val])) basic.append(rs) if _mem.settings.voice > 0x02: val = 0x01 else: val = _mem.settings.voice rs = RadioSetting("settings.voice", "Voice Prompt", RadioSettingValueList(LIST_VOICE, LIST_VOICE[val])) basic.append(rs) rs = RadioSetting( "settings.dtmfst", "DTMF Sidetone", RadioSettingValueList(LIST_DTMFST, LIST_DTMFST[_mem.settings.dtmfst])) basic.append(rs) if _mem.settings.screv > 0x02: val = 0x01 else: val = _mem.settings.screv rs = RadioSetting("settings.screv", "Scan Resume", RadioSettingValueList(LIST_RESUME, LIST_RESUME[val])) basic.append(rs) rs = RadioSetting( "settings.pttid", "When to send PTT ID", RadioSettingValueList(LIST_PTTID, LIST_PTTID[_mem.settings.pttid])) basic.append(rs) if _mem.settings.pttlt > 0x1E: val = 0x05 else: val = _mem.settings.pttlt rs = RadioSetting("pttlt", "PTT ID Delay", RadioSettingValueInteger(0, 50, val)) basic.append(rs) rs = RadioSetting( "settings.mdfa", "Display Mode (A)", RadioSettingValueList(LIST_MODE, LIST_MODE[_mem.settings.mdfa])) basic.append(rs) rs = RadioSetting( "settings.mdfb", "Display Mode (B)", RadioSettingValueList(LIST_MODE, LIST_MODE[_mem.settings.mdfb])) basic.append(rs) rs = RadioSetting("settings.autolk", "Auto Lock Keypad", RadioSettingValueBoolean(_mem.settings.autolk)) basic.append(rs) rs = RadioSetting( "settings.wtled", "Standby LED Color", RadioSettingValueList(LIST_COLOR, LIST_COLOR[_mem.settings.wtled])) basic.append(rs) rs = RadioSetting( "settings.rxled", "RX LED Color", RadioSettingValueList(LIST_COLOR, LIST_COLOR[_mem.settings.rxled])) basic.append(rs) rs = RadioSetting( "settings.txled", "TX LED Color", RadioSettingValueList(LIST_COLOR, LIST_COLOR[_mem.settings.txled])) basic.append(rs) if _mem.settings.almod > 0x02: val = 0x00 else: val = _mem.settings.almod rs = RadioSetting("settings.almod", "Alarm Mode", RadioSettingValueList(LIST_ALMOD, LIST_ALMOD[val])) basic.append(rs) if _mem.settings.tcall > 0x05: val = 0x00 else: val = _mem.settings.tcall rs = RadioSetting("settings.tcall", "Tone Burst Frequency", RadioSettingValueList(LIST_TCALL, LIST_TCALL[val])) basic.append(rs) rs = RadioSetting("settings.ste", "Squelch Tail Eliminate (HT to HT)", RadioSettingValueBoolean(_mem.settings.ste)) basic.append(rs) if _mem.settings.rpste > 0x0A: val = 0x00 else: val = _mem.settings.rpste rs = RadioSetting("settings.rpste", "Squelch Tail Eliminate (repeater)", RadioSettingValueList(LIST_RPSTE, LIST_RPSTE[val])) basic.append(rs) if _mem.settings.rptrl > 0x0A: val = 0x00 else: val = _mem.settings.rptrl rs = RadioSetting( "settings.rptrl", "STE Repeater Delay", RadioSettingValueList(LIST_STEDELAY, LIST_STEDELAY[val])) basic.append(rs) rs = RadioSetting( "settings.ponmsg", "Power-On Message", RadioSettingValueList(LIST_PONMSG, LIST_PONMSG[_mem.settings.ponmsg])) basic.append(rs) rs = RadioSetting("settings.roger", "Roger Beep", RadioSettingValueBoolean(_mem.settings.roger)) basic.append(rs) # Advanced settings rs = RadioSetting("settings.reset", "RESET Menu", RadioSettingValueBoolean(_mem.settings.reset)) advanced.append(rs) rs = RadioSetting("settings.menu", "All Menus", RadioSettingValueBoolean(_mem.settings.menu)) advanced.append(rs) rs = RadioSetting("settings.fmradio", "Broadcast FM Radio", RadioSettingValueBoolean(_mem.settings.fmradio)) advanced.append(rs) rs = RadioSetting("settings.alarm", "Alarm Sound", RadioSettingValueBoolean(_mem.settings.alarm)) advanced.append(rs) # Other settings def _filter(name): filtered = "" for char in str(name): if char in chirp_common.CHARSET_ASCII: filtered += char else: filtered += " " return filtered _msg = _mem.firmware_msg val = RadioSettingValueString(0, 8, _filter(_msg.line1)) val.set_mutable(False) rs = RadioSetting("firmware_msg.line1", "Firmware Message 1", val) other.append(rs) val = RadioSettingValueString(0, 8, _filter(_msg.line2)) val.set_mutable(False) rs = RadioSetting("firmware_msg.line2", "Firmware Message 2", val) other.append(rs) _msg = _mem.sixpoweron_msg val = RadioSettingValueString(0, 8, _filter(_msg.line1)) val.set_mutable(False) rs = RadioSetting("sixpoweron_msg.line1", "6+Power-On Message 1", val) other.append(rs) val = RadioSettingValueString(0, 8, _filter(_msg.line2)) val.set_mutable(False) rs = RadioSetting("sixpoweron_msg.line2", "6+Power-On Message 2", val) other.append(rs) _msg = _mem.poweron_msg rs = RadioSetting("poweron_msg.line1", "Power-On Message 1", RadioSettingValueString(0, 7, _filter(_msg.line1))) other.append(rs) rs = RadioSetting("poweron_msg.line2", "Power-On Message 2", RadioSettingValueString(0, 7, _filter(_msg.line2))) other.append(rs) lower = 136 upper = 174 rs = RadioSetting( "limits.vhf.lower", "VHF Lower Limit (MHz)", RadioSettingValueInteger(lower, upper, _mem.limits.vhf.lower)) other.append(rs) rs = RadioSetting( "limits.vhf.upper", "VHF Upper Limit (MHz)", RadioSettingValueInteger(lower, upper, _mem.limits.vhf.upper)) other.append(rs) lower = 400 upper = 520 rs = RadioSetting( "limits.uhf.lower", "UHF Lower Limit (MHz)", RadioSettingValueInteger(lower, upper, _mem.limits.uhf.lower)) other.append(rs) rs = RadioSetting( "limits.uhf.upper", "UHF Upper Limit (MHz)", RadioSettingValueInteger(lower, upper, _mem.limits.uhf.upper)) other.append(rs) # Work mode settings rs = RadioSetting( "settings.displayab", "Display", RadioSettingValueList(LIST_AB, LIST_AB[_mem.settings.displayab])) work.append(rs) rs = RadioSetting( "settings.workmode", "VFO/MR Mode", RadioSettingValueList(LIST_WORKMODE, LIST_WORKMODE[_mem.settings.workmode])) work.append(rs) rs = RadioSetting("settings.keylock", "Keypad Lock", RadioSettingValueBoolean(_mem.settings.keylock)) work.append(rs) rs = RadioSetting( "wmchannel.mrcha", "MR A Channel", RadioSettingValueInteger(0, 127, _mem.wmchannel.mrcha)) work.append(rs) rs = RadioSetting( "wmchannel.mrchb", "MR B Channel", RadioSettingValueInteger(0, 127, _mem.wmchannel.mrchb)) work.append(rs) def convert_bytes_to_freq(bytes): real_freq = 0 for byte in bytes: real_freq = (real_freq * 10) + byte return chirp_common.format_freq(real_freq * 10) def my_validate(value): _vhf_lower = int(_mem.limits.vhf.lower) _vhf_upper = int(_mem.limits.vhf.upper) _uhf_lower = int(_mem.limits.uhf.lower) _uhf_upper = int(_mem.limits.uhf.upper) value = chirp_common.parse_freq(value) msg = ("Can't be less than %i.0000") if value > 99000000 and value < _vhf_lower * 1000000: raise InvalidValueError(msg % _vhf_lower) msg = ("Can't be between %i.9975-%i.0000") if _vhf_upper * 1000000 <= value and value < _uhf_lower * 1000000: raise InvalidValueError(msg % (_vhf_upper - 1, _uhf_lower)) msg = ("Can't be greater than %i.9975") if value > 99000000 and value >= _uhf_upper * 1000000: raise InvalidValueError(msg % (_uhf_upper - 1)) return chirp_common.format_freq(value) def apply_freq(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 10 for i in range(7, -1, -1): obj.freq[i] = value % 10 value /= 10 val1a = RadioSettingValueString(0, 10, convert_bytes_to_freq(_mem.vfo.a.freq)) val1a.set_validate_callback(my_validate) rs = RadioSetting("vfo.a.freq", "VFO A Frequency", val1a) rs.set_apply_callback(apply_freq, _mem.vfo.a) work.append(rs) val1b = RadioSettingValueString(0, 10, convert_bytes_to_freq(_mem.vfo.b.freq)) val1b.set_validate_callback(my_validate) rs = RadioSetting("vfo.b.freq", "VFO B Frequency", val1b) rs.set_apply_callback(apply_freq, _mem.vfo.b) work.append(rs) rs = RadioSetting( "vfo.a.sftd", "VFO A Shift", RadioSettingValueList(LIST_SHIFTD, LIST_SHIFTD[_mem.vfo.a.sftd])) work.append(rs) rs = RadioSetting( "vfo.b.sftd", "VFO B Shift", RadioSettingValueList(LIST_SHIFTD, LIST_SHIFTD[_mem.vfo.b.sftd])) work.append(rs) def convert_bytes_to_offset(bytes): real_offset = 0 for byte in bytes: real_offset = (real_offset * 10) + byte return chirp_common.format_freq(real_offset * 1000) def apply_offset(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 1000 for i in range(5, -1, -1): obj.offset[i] = value % 10 value /= 10 val1a = RadioSettingValueString( 0, 10, convert_bytes_to_offset(_mem.vfo.a.offset)) rs = RadioSetting("vfo.a.offset", "VFO A Offset", val1a) rs.set_apply_callback(apply_offset, _mem.vfo.a) work.append(rs) val1b = RadioSettingValueString( 0, 10, convert_bytes_to_offset(_mem.vfo.b.offset)) rs = RadioSetting("vfo.b.offset", "VFO B Offset", val1b) rs.set_apply_callback(apply_offset, _mem.vfo.b) work.append(rs) rs = RadioSetting( "vfo.a.txpower", "VFO A Power", RadioSettingValueList(LIST_TXPOWER, LIST_TXPOWER[_mem.vfo.a.txpower])) work.append(rs) rs = RadioSetting( "vfo.b.txpower", "VFO B Power", RadioSettingValueList(LIST_TXPOWER, LIST_TXPOWER[_mem.vfo.b.txpower])) work.append(rs) rs = RadioSetting( "vfo.a.widenarr", "VFO A Bandwidth", RadioSettingValueList(LIST_BANDWIDTH, LIST_BANDWIDTH[_mem.vfo.a.widenarr])) work.append(rs) rs = RadioSetting( "vfo.b.widenarr", "VFO B Bandwidth", RadioSettingValueList(LIST_BANDWIDTH, LIST_BANDWIDTH[_mem.vfo.b.widenarr])) work.append(rs) rs = RadioSetting( "vfo.a.scode", "VFO A S-CODE", RadioSettingValueList(LIST_SCODE, LIST_SCODE[_mem.vfo.a.scode])) work.append(rs) rs = RadioSetting( "vfo.b.scode", "VFO B S-CODE", RadioSettingValueList(LIST_SCODE, LIST_SCODE[_mem.vfo.b.scode])) work.append(rs) rs = RadioSetting( "vfo.a.step", "VFO A Tuning Step", RadioSettingValueList(LIST_STEP, LIST_STEP[_mem.vfo.a.step])) work.append(rs) rs = RadioSetting( "vfo.b.step", "VFO B Tuning Step", RadioSettingValueList(LIST_STEP, LIST_STEP[_mem.vfo.b.step])) work.append(rs) # broadcast FM settings _fm_presets = self._memobj.fm_presets if _fm_presets <= 108.0 * 10 - 650: preset = _fm_presets / 10.0 + 65 elif _fm_presets >= 65.0 * 10 and _fm_presets <= 108.0 * 10: preset = _fm_presets / 10.0 else: preset = 76.0 rs = RadioSetting("fm_presets", "FM Preset(MHz)", RadioSettingValueFloat(65, 108.0, preset, 0.1, 1)) fm_preset.append(rs) # DTMF settings def apply_code(setting, obj, length): code = [] for j in range(0, length): try: code.append(DTMF_CHARS.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.code = code for i in range(0, 15): _codeobj = self._memobj.pttid[i].code _code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 5, _code, False) val.set_charset(DTMF_CHARS) pttid = RadioSetting("pttid/%i.code" % i, "Signal Code %i" % (i + 1), val) pttid.set_apply_callback(apply_code, self._memobj.pttid[i], 5) dtmfe.append(pttid) if _mem.ani.dtmfon > 0xC3: val = 0x03 else: val = _mem.ani.dtmfon rs = RadioSetting( "ani.dtmfon", "DTMF Speed (on)", RadioSettingValueList(LIST_DTMFSPEED, LIST_DTMFSPEED[val])) dtmfe.append(rs) if _mem.ani.dtmfoff > 0xC3: val = 0x03 else: val = _mem.ani.dtmfoff rs = RadioSetting( "ani.dtmfoff", "DTMF Speed (off)", RadioSettingValueList(LIST_DTMFSPEED, LIST_DTMFSPEED[val])) dtmfe.append(rs) _codeobj = self._memobj.ani.code _code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 5, _code, False) val.set_charset(DTMF_CHARS) rs = RadioSetting("ani.code", "ANI Code", val) rs.set_apply_callback(apply_code, self._memobj.ani, 5) dtmfe.append(rs) rs = RadioSetting( "ani.aniid", "When to send ANI ID", RadioSettingValueList(LIST_PTTID, LIST_PTTID[_mem.ani.aniid])) dtmfe.append(rs) # Service settings for index in range(0, 10): key = "squelch.sql%i" % (index) _obj = self._memobj.squelch val = RadioSettingValueInteger(0, 123, getattr(_obj, "sql%i" % (index))) if index == 0: val.set_mutable(False) name = "Squelch %i" % (index) rs = RadioSetting(key, name, val) service.append(rs) return top
def _get_settings(self): _settings = self._memobj.settings _service = self._memobj.service _msg = self._memobj.messages cfg_grp = RadioSettingGroup("cfg_grp", "Basic Settings") adv_grp = RadioSettingGroup("adv_grp", "Advanced Settings") key_grp = RadioSettingGroup("key_grp", "Key Assignment") group = RadioSettings(cfg_grp, adv_grp, key_grp) # # Basic Settings # rs = RadioSetting( "apo", "Auto Power Off", RadioSettingValueList(APO_LIST, APO_LIST[_settings.apo])) cfg_grp.append(rs) rs = RadioSetting( "sql", "Squelch Level", RadioSettingValueList(SQL_LIST, SQL_LIST[_settings.sql])) cfg_grp.append(rs) rs = RadioSetting( "scanm", "Scan Mode", RadioSettingValueList(SCANM_LIST, SCANM_LIST[_settings.scanm])) cfg_grp.append(rs) rs = RadioSetting( "tot", "Time Out Timer", RadioSettingValueList(TOT_LIST, TOT_LIST[_settings.tot])) cfg_grp.append(rs) rs = RadioSetting( "step", "Step", RadioSettingValueList(STEP_LIST, STEP_LIST[_settings.step])) cfg_grp.append(rs) rs = RadioSetting( "monitor", "Monitor", RadioSettingValueList(MONITOR_LIST, MONITOR_LIST[_settings.monitor])) cfg_grp.append(rs) rs = RadioSetting( "vfomr", "VFO/MR", RadioSettingValueList(VFOMR_LIST, VFOMR_LIST[_settings.vfomr])) cfg_grp.append(rs) rs = RadioSetting( "mrcha", "MR/CHA", RadioSettingValueList(MRCHA_LIST, MRCHA_LIST[_settings.mrcha])) cfg_grp.append(rs) rs = RadioSetting( "vol", "Volume", RadioSettingValueList(VOL_LIST, VOL_LIST[_settings.vol])) cfg_grp.append(rs) rs = RadioSetting( "opendis", "Open Display", RadioSettingValueList(OPENDIS_LIST, OPENDIS_LIST[_settings.opendis])) cfg_grp.append(rs) def _filter(name): filtered = "" for char in str(name): if char in chirp_common.CHARSET_ASCII: filtered += char else: filtered += " " LOG.debug("Filtered: %s" % filtered) return filtered rs = RadioSetting("messages.user1", "User-defined Message 1", RadioSettingValueString(0, 7, _filter(_msg.user1))) cfg_grp.append(rs) rs = RadioSetting("messages.user2", "User-defined Message 2", RadioSettingValueString(0, 7, _filter(_msg.user2))) cfg_grp.append(rs) val = RadioSettingValueString(0, 7, _filter(_msg.system)) val.set_mutable(False) rs = RadioSetting("messages.system", "System Message", val) cfg_grp.append(rs) rs = RadioSetting( "lamp", "Backlight", RadioSettingValueList(LAMP_LIST, LAMP_LIST[_settings.lamp])) cfg_grp.append(rs) rs = RadioSetting( "keylockm", "Key Lock Mode", RadioSettingValueList(KEYLOCKM_LIST, KEYLOCKM_LIST[_settings.keylockm])) cfg_grp.append(rs) rs = RadioSetting( "absel", "A/B Select", RadioSettingValueList(ABSEL_LIST, ABSEL_LIST[_settings.absel])) cfg_grp.append(rs) rs = RadioSetting("obeep", "Open Beep", RadioSettingValueBoolean(_settings.obeep)) cfg_grp.append(rs) rs = RadioSetting("rbeep", "Roger Beep", RadioSettingValueBoolean(_settings.rbeep)) cfg_grp.append(rs) rs = RadioSetting("keylock_off", "Key Lock", RadioSettingValueBoolean(not _settings.keylock_off)) cfg_grp.append(rs) rs = RadioSetting("ctdcsb", "CT/DCS Busy Lock", RadioSettingValueBoolean(_settings.ctdcsb)) cfg_grp.append(rs) rs = RadioSetting("alarm", "Alarm Key", RadioSettingValueBoolean(_settings.alarm)) cfg_grp.append(rs) rs = RadioSetting("save", "Battery Save", RadioSettingValueBoolean(_settings.save)) cfg_grp.append(rs) rs = RadioSetting("kbeep", "Key Beep", RadioSettingValueBoolean(_settings.kbeep)) cfg_grp.append(rs) rs = RadioSetting("reset", "Reset Enable", RadioSettingValueBoolean(_settings.reset)) cfg_grp.append(rs) rs = RadioSetting("smfont_off", "Small Font", RadioSettingValueBoolean(not _settings.smfont_off)) cfg_grp.append(rs) rs = RadioSetting("aliasen_off", "Alias Enable", RadioSettingValueBoolean(not _settings.aliasen_off)) cfg_grp.append(rs) rs = RadioSetting("txstop_off", "TX Stop", RadioSettingValueBoolean(not _settings.txstop_off)) cfg_grp.append(rs) rs = RadioSetting("dw_off", "Dual Watch", RadioSettingValueBoolean(not _settings.dw_off)) cfg_grp.append(rs) rs = RadioSetting("fmen_off", "FM Enable", RadioSettingValueBoolean(not _settings.fmen_off)) cfg_grp.append(rs) rs = RadioSetting("fmdw", "FM Dual Watch", RadioSettingValueBoolean(_settings.fmdw)) cfg_grp.append(rs) rs = RadioSetting("fmscan_off", "FM Scan", RadioSettingValueBoolean(not _settings.fmscan_off)) cfg_grp.append(rs) rs = RadioSetting( "keypadmic_off", "Keypad MIC", RadioSettingValueBoolean(not _settings.keypadmic_off)) cfg_grp.append(rs) rs = RadioSetting( "voxgain", "VOX Gain", RadioSettingValueList(VOXGAIN_LIST, VOXGAIN_LIST[_settings.voxgain])) cfg_grp.append(rs) rs = RadioSetting( "voxdt", "VOX Delay Time", RadioSettingValueList(VOXDT_LIST, VOXDT_LIST[_settings.voxdt])) cfg_grp.append(rs) rs = RadioSetting("vir", "VOX Inhibit on Receive", RadioSettingValueBoolean(_settings.vir)) cfg_grp.append(rs) # # Advanced Settings # val = (_settings.dtmftime) - 5 rs = RadioSetting( "dtmftime", "DTMF Digit Time", RadioSettingValueList(DTMFTIME_LIST, DTMFTIME_LIST[val])) adv_grp.append(rs) val = (_settings.dtmfspace) - 5 rs = RadioSetting( "dtmfspace", "DTMF Digit Space Time", RadioSettingValueList(DTMFTIME_LIST, DTMFTIME_LIST[val])) adv_grp.append(rs) val = (_settings.dtmfdelay) / 5 rs = RadioSetting( "dtmfdelay", "DTMF 1st Digit Delay", RadioSettingValueList(DTMFDELAY_LIST, DTMFDELAY_LIST[val])) adv_grp.append(rs) val = (_settings.dtmfpretime) / 10 - 1 rs = RadioSetting( "dtmfpretime", "DTMF Pretime", RadioSettingValueList(DTMFPRETIME_LIST, DTMFPRETIME_LIST[val])) adv_grp.append(rs) val = (_settings.dtmfdelay2) / 5 rs = RadioSetting( "dtmfdelay2", "DTMF * and # Digit Delay", RadioSettingValueList(DTMFDELAY2_LIST, DTMFDELAY2_LIST[val])) adv_grp.append(rs) rs = RadioSetting("ackdecode", "ACK Decode", RadioSettingValueBoolean(_settings.ackdecode)) adv_grp.append(rs) rs = RadioSetting("dtmfst", "DTMF Sidetone", RadioSettingValueBoolean(_settings.dtmfst)) adv_grp.append(rs) rs = RadioSetting("service.rssi400", "Squelch Base Level (UHF)", RadioSettingValueInteger(0, 255, _service.rssi400)) adv_grp.append(rs) rs = RadioSetting("service.rssi136", "Squelch Base Level (VHF)", RadioSettingValueInteger(0, 255, _service.rssi136)) adv_grp.append(rs) # # Key Settings # val = (_settings.lptime) - 5 rs = RadioSetting("lptime", "Long Press Time", RadioSettingValueList(LPTIME_LIST, LPTIME_LIST[val])) key_grp.append(rs) rs = RadioSetting( "keyp1long", "P1 Long Key", RadioSettingValueList(PFKEYLONG_LIST, PFKEYLONG_LIST[_settings.keyp1long])) key_grp.append(rs) rs = RadioSetting( "keyp1short", "P1 Short Key", RadioSettingValueList(PFKEYSHORT_LIST, PFKEYSHORT_LIST[_settings.keyp1short])) key_grp.append(rs) rs = RadioSetting( "keyp2long", "P2 Long Key", RadioSettingValueList(PFKEYLONG_LIST, PFKEYLONG_LIST[_settings.keyp2long])) key_grp.append(rs) rs = RadioSetting( "keyp2short", "P2 Short Key", RadioSettingValueList(PFKEYSHORT_LIST, PFKEYSHORT_LIST[_settings.keyp2short])) key_grp.append(rs) rs = RadioSetting( "keyp3long", "P3 Long Key", RadioSettingValueList(PFKEYLONG_LIST, PFKEYLONG_LIST[_settings.keyp3long])) key_grp.append(rs) rs = RadioSetting( "keyp3short", "P3 Short Key", RadioSettingValueList(PFKEYSHORT_LIST, PFKEYSHORT_LIST[_settings.keyp3short])) key_grp.append(rs) val = RadioSettingValueList(PFKEYSHORT_LIST, PFKEYSHORT_LIST[_settings.keymshort]) val.set_mutable(_settings.menuen == 0) rs = RadioSetting("keymshort", "M Short Key", val) key_grp.append(rs) val = RadioSettingValueBoolean(_settings.menuen) rs = RadioSetting("menuen", "Menu Enable", val) key_grp.append(rs) return group
def get_settings(self): """Translate the MEM_FORMAT structs into settings in the UI""" # Define mem struct write-back shortcuts _sets = self._memobj.settings _cmnt = self._memobj.comment _wxch = self._memobj.abwx _dtm = self._memobj.dtmfcode _pses = self._memobj.pgmscanedge _bklk = self._memobj.banklink basic = RadioSettingGroup("basic", "Basic Settings") mickey = RadioSettingGroup("mickey", "Microphone Keys") bluet = RadioSettingGroup("bluet", "Bluetooth") disp = RadioSettingGroup("disp", "Display") sound = RadioSettingGroup("sound", "Sounds") dtmf = RadioSettingGroup("dtmf", "DTMF Codes") abset = RadioSettingGroup("abset", "A/B Band Settings") edges = RadioSettingGroup("edges", "Program Scan Edges") pslnk = RadioSettingGroup("pslnk", "Program Scan Links") other = RadioSettingGroup("other", "Other Settings") group = RadioSettings(basic, disp, sound, mickey, dtmf, abset, bluet, edges, pslnk, other) def mic_keys(setting, obj, atrb): """ Callback to set subset of mic key options """ stx = str(setting.value) value = MICKEYOPTS.index(stx) setattr(obj, atrb, value) return def hex_val(setting, obj, atrb): """ Callback to store string as hex values """ value = int(str(setting.value), 16) setattr(obj, atrb, value) return def unpack_str(codestr): """Convert u8 DTMF array to a string: NOT a callback.""" stx = "" for i in range(0, 24): # unpack up to ff if codestr[i] != 0xff: # Issue 8159 fix if codestr[i] == 0x0E: stx += "*" elif codestr[i] == 0x0F: stx += "#" else: stx += format(int(codestr[i]), '0X') return stx def pack_chars(setting, obj, atrb, ndx): """Callback to build 0-9,A-D,*# nibble array from string""" # String will be f padded to 24 bytes # Chars are stored as hex values ary = [] stx = str(setting.value).upper() stx = stx.strip() # trim spaces # Remove illegal characters first sty = "" for j in range(0, len(stx)): if stx[j] in MDTMF_CHARS: sty += stx[j] for j in range(0, 24): if j < len(sty): # Issue 8159 fix if sty[j] == "*": chrv = 0xE elif sty[j] == "#": chrv = 0xF else: chrv = int(sty[j], 16) else: # pad to 24 bytes chrv = 0xFF ary.append(chrv) # append byte setattr(obj[ndx], atrb, ary) return def myset_comment(setting, obj, atrb, knt): """ Callback to create space-padded char array""" stx = str(setting.value) for i in range(0, knt): if i > len(stx): str.append(0x20) setattr(obj, atrb, stx) return def myset_psnam(setting, obj, ndx, atrb, knt): """ Callback to generate space-padded, uppercase char array """ # This sub also is specific to object arrays stx = str(setting.value).upper() for i in range(0, knt): if i > len(stx): str.append(0x20) setattr(obj[ndx], atrb, stx) return def myset_frqflgs(setting, obj, ndx, flg, frq): """ Callback to gen flag/freq pairs """ vfrq = float(str(setting.value)) vfrq = int(vfrq * 1000000) vflg = 0x10 if vfrq % 6250 == 0: vflg = 0x08 vfrq = int(vfrq / 6250) elif vfrq % 5000 == 0: vflg = 0 vfrq = int(vfrq / 5000) else: vfrq = int(vfrq / 8333) setattr(obj[ndx], flg, vflg) setattr(obj[ndx], frq, vfrq) return def banklink(ary): """ Sub to generate A-J string from 2-byte bit pattern """ stx = "" for kx in range(0, 10): if kx < 8: val = ary[0] msk = 1 << kx else: val = ary[1] msk = 1 << (kx - 8) if val & msk: stx += chr(kx + 65) else: stx += "_" return stx def myset_banklink(setting, obj, atrb): """Callback to create 10-bit, u8[2] array from 10 char string""" stx = str(setting.value).upper() ary = [0, 0] for kx in range(0, 10): if stx[kx] == chr(kx + 65): if kx < 8: ary[0] = ary[0] + (1 << kx) else: ary[1] = ary[1] + (1 << (kx - 8)) setattr(obj, atrb, ary) return def myset_tsopt(setting, obj, ndx, atrb, bx): """ Callback to set scan Edge tstep """ stx = str(setting.value) flg = 0 if stx == "-": val = 0xff else: if bx == 1: # Air band if stx == "Auto": val = 0xe elif stx == "25k": val = 8 elif stx == "8.33k": val = 2 else: # VHF or UHF optx = [ "-", "5k", "6.25k", "10k", "12.5k", "15k", "20k", "25k", "30k", "50k" ] val = optx.index(stx) + 1 setattr(obj[ndx], atrb, val) # and set flag setattr(obj[ndx], "flag", flg) return def myset_mdopt(setting, obj, ndx, atrb, bx): """ Callback to set Scan Edge mode """ stx = str(setting.value) if stx == "-": val = 0xf elif stx == "FM": val = 0 else: val = 1 setattr(obj[ndx], atrb, val) return def myset_bitmask(setting, obj, ndx, atrb, knt): """ Callback to gnerate byte-array bitmask from string""" # knt is BIT count to process lsx = str(setting.value).strip().split(",") for kx in range(0, len(lsx)): try: lsx[kx] = int(lsx[kx]) except Exception: lsx[kx] = -99 # will nop ary = [0, 0, 0, 0xfe] for kx in range(0, knt): if kx < 8: if kx in lsx: ary[0] += 1 << kx elif kx >= 8 and kx < 16: if kx in lsx: ary[1] += 1 << (kx - 8) elif kx >= 16 and kx < 24: if kx in lsx: ary[2] += 1 << (kx - 16) else: if kx in lsx: # only bit 25 ary[3] += 1 setattr(obj[ndx], atrb, ary) return # --- Basic options = ["Off", "S-Meter Squelch", "ATT"] rx = RadioSettingValueList(options, options[_sets.sqlatt]) rset = RadioSetting("settings.sqlatt", "Squelch/ATT", rx) basic.append(rset) options = ["Short", "Long"] rx = RadioSettingValueList(options, options[_sets.sqldly]) rset = RadioSetting("settings.sqldly", "Squelch Delay", rx) basic.append(rset) rx = RadioSettingValueBoolean(bool(_sets.pttlock)) rset = RadioSetting("settings.pttlock", "PTT Lockout", rx) basic.append(rset) rx = RadioSettingValueBoolean(bool(_sets.bcl)) rset = RadioSetting("settings.bcl", "Busy Channel Lockout", rx) basic.append(rset) options = ["Off", "1m", "3m", "5m", "10m", "15m", "30m"] rx = RadioSettingValueList(options, options[_sets.tot]) rset = RadioSetting("settings.tot", "Tx Timeout", rx) basic.append(rset) val = int(_sets.vfohome) if val == 0xffff: val = 0 val = val / 1000000.0 rx = RadioSettingValueFloat(0.0, 550.0, val, 0.005, 4) rx.set_mutable(False) rset = RadioSetting("settings.vfohome", "Home VFO (Read-Only)", rx) basic.append(rset) val = _sets.homech if val == 0xffff: val = -1 rx = RadioSettingValueInteger(-1, 999, val) rx.set_mutable(False) rset = RadioSetting("settings.homech", "Home Channel (Read-Only)", rx) basic.append(rset) options = ["1", "2", "3", "4"] rx = RadioSettingValueList(options, options[_sets.micgain]) rset = RadioSetting("settings.micgain", "Microphone Gain", rx) basic.append(rset) _bmem = self._memobj.initmem rx = RadioSettingValueInteger(0, 999, _bmem.left_memory) rset = RadioSetting("initmem.left_memory", "Left Bank Initial Mem Chan", rx) basic.append(rset) rx = RadioSettingValueInteger(0, 999, _bmem.right_memory) rset = RadioSetting("initmem.right_memory", "Right Bank Initial Mem Chan", rx) basic.append(rset) stx = "" for i in range(0, 16): stx += chr(_cmnt.com[i]) stx = stx.rstrip() rx = RadioSettingValueString(0, 16, stx) rset = RadioSetting("comment.com", "Comment (16 chars)", rx) rset.set_apply_callback(myset_comment, _cmnt, "com", 16) basic.append(rset) # --- Other rset = RadioSetting("drv_clone_speed", "Use Hi-Speed Clone", RadioSettingValueBoolean(self._can_hispeed)) other.append(rset) options = ["Single", "All", "Ham"] rx = RadioSettingValueList(options, options[_sets.actband]) rset = RadioSetting("settings.actband", "Active Band", rx) other.append(rset) options = ["Slow", "Mid", "Fast", "Auto"] rx = RadioSettingValueList(options, options[_sets.fanspeed]) rset = RadioSetting("settings.fanspeed", "Fan Speed", rx) other.append(rset) rx = RadioSettingValueBoolean(bool(_sets.dialspdup)) rset = RadioSetting("settings.dialspdup", "Dial Speed-Up", rx) other.append(rset) options = ["Off", "On(Dup)", "On(Dup+Tone)"] rx = RadioSettingValueList(options, options[_sets.autorptr]) rset = RadioSetting("settings.autorptr", "Auto Repeater", rx) other.append(rset) rx = RadioSettingValueBoolean(bool(_sets.rmtmic)) rset = RadioSetting("settings.rmtmic", "One-Touch PTT (Remote Mic)", rx) other.append(rset) options = ["Low", "Mid", "High"] rx = RadioSettingValueList(options, options[_sets.vhfpower]) rset = RadioSetting("settings.vhfpower", "VHF Power Default", rx) other.append(rset) rx = RadioSettingValueList(options, options[_sets.uhfpower]) rset = RadioSetting("settings.uhfpower", "UHF Power Default", rx) other.append(rset) rx = RadioSettingValueBoolean(bool(_sets.toneburst)) rset = RadioSetting("settings.toneburst", "1750 Htz Tone Burst", rx) other.append(rset) rx = RadioSettingValueBoolean(bool(_sets.ifxchg)) rset = RadioSetting("settings.ifxchg", "IF Exchange", rx) other.append(rset) rx = RadioSettingValueBoolean(bool(_sets.rpthangup)) rset = RadioSetting("settings.rpthangup", "Repeater Hang up Timeout", rx) other.append(rset) stx = str(_sets.civaddr)[2:] # Hex value rx = RadioSettingValueString(1, 2, stx) rset = RadioSetting("settings.civaddr", "CI-V Address (90)", rx) rset.set_apply_callback(hex_val, _sets, "civaddr") other.append(rset) options = ["1200", "2400", "4800", "9600", "19200", "Auto"] rx = RadioSettingValueList(options, options[_sets.civbaud]) rset = RadioSetting("settings.civbaud", "CI-V Baud Rate (bps)", rx) other.append(rset) rx = RadioSettingValueBoolean(bool(_sets.civtcvr)) rset = RadioSetting("settings.civtcvr", "CI-V Transceive", rx) other.append(rset) # A/B Band Settings options = ["Off", "On", "Bell"] rx = RadioSettingValueList(options, options[_sets.aprichn]) rset = RadioSetting("settings.aprichn", "A Band: VFO Priority Watch Mode", rx) abset.append(rset) options = [ "2", "4", "6", "8", "10", "12", "14", "16", "18", "20", "Hold" ] rx = RadioSettingValueList(options, options[_sets.ascanpause]) rset = RadioSetting("settings.ascanpause", "-- A Band: Scan Pause Time (Secs)", rx) abset.append(rset) options = ["0", "1", "2", "3", "4", "5", "Hold"] rx = RadioSettingValueList(options, options[_sets.ascanresume]) rset = RadioSetting("settings.ascanresume", "-- A Band: Scan Resume Time (Secs)", rx) abset.append(rset) options = ["5", "10", "15"] rx = RadioSettingValueList(options, options[_sets.atmpskiptym]) rset = RadioSetting("settings.atmpskiptym", "-- A Band: Temp Skip Time (Secs)", rx) abset.append(rset) rx = RadioSettingValueBoolean(bool(_sets.aprgskpscn)) rset = RadioSetting("settings.aprgskpscn", "-- A Band: Program Skip Scan", rx) abset.append(rset) rx = RadioSettingValueString(10, 10, banklink(_bklk.alnk)) rset = RadioSetting("banklink.alnk", "-- A Band Banklink (use _ to skip)", rx) rset.set_apply_callback(myset_banklink, _bklk, "alnk") abset.append(rset) rx = RadioSettingValueBoolean(bool(_sets.awxalert)) rset = RadioSetting("settings.awxalert", "-- A Band: Weather Alert", rx) abset.append(rset) # Use list for Wx chans since chan 1 = index 0 options = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"] rx = RadioSettingValueList(options, options[_wxch.awxchan]) rset = RadioSetting("abwx.awxchan", "-- A Band: Weather Channel", rx) abset.append(rset) options = ["Off", "On", "Bell"] rx = RadioSettingValueList(options, options[_sets.bprichn]) rset = RadioSetting("settings.bprichn", "B Band: VFO Priority Watch Mode", rx) abset.append(rset) options = [ "2", "4", "6", "8", "10", "12", "14", "16", "18", "20", "Hold" ] rx = RadioSettingValueList(options, options[_sets.bscanpause]) rset = RadioSetting("settings.bscanpause", "-- B Band: Scan Pause Time (Secs)", rx) abset.append(rset) options = ["0", "1", "2", "3", "4", "5", "Hold"] rx = RadioSettingValueList(options, options[_sets.bscanresume]) rset = RadioSetting("settings.bscanresume", "-- B Band: Scan Resume Time (Secs)", rx) abset.append(rset) options = ["5", "10", "15"] rx = RadioSettingValueList(options, options[_sets.btmpskiptym]) rset = RadioSetting("settings.btmpskiptym", "-- B Band: Temp Skip Time (Secs)", rx) abset.append(rset) rx = RadioSettingValueBoolean(bool(_sets.bprgskpscn)) rset = RadioSetting("settings.bprgskpscn", "-- B Band: Program Skip Scan", rx) abset.append(rset) rx = RadioSettingValueString(10, 10, banklink(_bklk.blnk)) rset = RadioSetting("banklink.blnk", "-- B Band Banklink (use _ to skip)", rx) rset.set_apply_callback(myset_banklink, _bklk, "blnk") abset.append(rset) rx = RadioSettingValueBoolean(bool(_sets.bwxalert)) rset = RadioSetting("settings.bwxalert", "-- B Band: Weather Alert", rx) abset.append(rset) options = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"] rx = RadioSettingValueList(options, options[_wxch.bwxchan]) rset = RadioSetting("abwx.bwxchan", "-- B Band: Weather Channel", rx) abset.append(rset) # --- Microphone Keys # The Mic keys get wierd: stored values are indecis to the full # options list, but only a subset is valid... shortopts = [ "Off", "Monitor", "MR (Ch 0)", "MR (Ch 1)", "Band/Bank", "Scan", "Temp Skip", "Mode", "Low", "Dup", "Priority", "Tone", "MW", "Mute", "DTMF Direct", "T-Call" ] ptr = shortopts.index(MICKEYOPTS[_sets.mickyrxf1]) rx = RadioSettingValueList(shortopts, shortopts[ptr]) rset = RadioSetting("settings.mickyrxf1", "During Rx/Standby [F-1]", rx) rset.set_apply_callback(mic_keys, _sets, "mickyrxf1") mickey.append(rset) ptr = shortopts.index(MICKEYOPTS[_sets.mickyrxf2]) rx = RadioSettingValueList(shortopts, shortopts[ptr]) rset = RadioSetting("settings.mickyrxf2", "During Rx/Standby [F-2]", rx) rset.set_apply_callback(mic_keys, _sets, "mickyrxf2") mickey.append(rset) options = ["Off", "Low", "T-Call"] # NOT a subset of MICKEYOPTS rx = RadioSettingValueList(options, options[_sets.mickytxf1]) rset = RadioSetting("settings.mickytxf1", "During Tx [F-1]", rx) mickey.append(rset) rx = RadioSettingValueList(options, options[_sets.mickytxf2]) rset = RadioSetting("settings.mickytxf2", "During Tx [F-2]", rx) mickey.append(rset) # These next two get the full options list rx = RadioSettingValueList(MICKEYOPTS, MICKEYOPTS[_sets.mickyrxup]) rset = RadioSetting("settings.mickyrxup", "During Rx/Standby [Up]", rx) mickey.append(rset) rx = RadioSettingValueList(MICKEYOPTS, MICKEYOPTS[_sets.mickyrxdn]) rset = RadioSetting("settings.mickyrxdn", "During Rx/Standby [Down]", rx) mickey.append(rset) options = ["Off", "Low", "T-Call"] rx = RadioSettingValueList(options, options[_sets.mickytxup]) rset = RadioSetting("settings.mickytxup", "During Tx [Up]", rx) mickey.append(rset) rx = RadioSettingValueList(options, options[_sets.mickytxdn]) rset = RadioSetting("settings.mickytxdn", "During Tx [Down]", rx) mickey.append(rset) # --- Bluetooth rx = RadioSettingValueBoolean(bool(_sets.btoothon)) rset = RadioSetting("settings.btoothon", "Bluetooth", rx) bluet.append(rset) rx = RadioSettingValueBoolean(bool(_sets.btoothauto)) rset = RadioSetting("settings.btoothauto", "Auto Connect", rx) bluet.append(rset) options = ["Headset Only", "Headset & Speaker"] rx = RadioSettingValueList(options, options[_sets.bthdset]) rset = RadioSetting("settings.bthdset", "Headset Audio", rx) bluet.append(rset) options = [ "Normal", "Microphone", "PTT (Audio:Main)", "PTT(Audio:Controller)" ] rx = RadioSettingValueList(options, options[_sets.bthfctn]) rset = RadioSetting("settings.bthfctn", "Headset Function", rx) bluet.append(rset) rx = RadioSettingValueBoolean(bool(_sets.bthvox)) rset = RadioSetting("settings.bthvox", "Vox", rx) bluet.append(rset) options = ["Off", "1.0", "2", "3", "4", "5", "6", "7", "8", "9", "10"] rx = RadioSettingValueList(options, options[_sets.bthvoxlvl]) rset = RadioSetting("settings.bthvoxlvl", "Vox Level", rx) bluet.append(rset) options = ["0.5", "1.0", "1.5", "2.0", "2.5", "3.0"] rx = RadioSettingValueList(options, options[_sets.bthvoxdly]) rset = RadioSetting("settings.bthvoxdly", "Vox Delay (Secs)", rx) bluet.append(rset) options = ["Off", "1", "2", "3", "4", "5", "10", "15"] rx = RadioSettingValueList(options, options[_sets.bthvoxtot]) rset = RadioSetting("settings.bthvoxtot", "Vox Time-Out (Mins)", rx) bluet.append(rset) rx = RadioSettingValueBoolean(bool(_sets.bthhdpsav)) rset = RadioSetting("settings.bthhdpsav", "ICOM Headset Power-Save", rx) bluet.append(rset) rx = RadioSettingValueBoolean(bool(_sets.bth1ptt)) rset = RadioSetting("settings.bth1ptt", "ICOM Headset One-Touch PTT", rx) bluet.append(rset) rx = RadioSettingValueBoolean(bool(_sets.bthpttbeep)) rset = RadioSetting("settings.bthpttbeep", "ICOM Headset PTT Beep", rx) bluet.append(rset) rx = RadioSettingValueBoolean(bool(_sets.bthcustbeep)) rset = RadioSetting("settings.bthcustbeep", "ICOM Headset Custom Key Beep", rx) bluet.append(rset) rx = RadioSettingValueList(MICKEYOPTS, MICKEYOPTS[_sets.bthplaykey]) rset = RadioSetting("settings.bthplaykey", "ICOM Headset Custom Key [Play]", rx) bluet.append(rset) rx = RadioSettingValueList(MICKEYOPTS, MICKEYOPTS[_sets.bthfwdkey]) rset = RadioSetting("settings.bthfwdkey", "ICOM Headset Custom Key [Fwd]", rx) bluet.append(rset) rx = RadioSettingValueList(MICKEYOPTS, MICKEYOPTS[_sets.bthrwdkey]) rset = RadioSetting("settings.bthrwdkey", "ICOM Headset Custom Key [Rwd]", rx) bluet.append(rset) # ---- Display options = ["1: Dark", "2", "3", "4: Bright"] rx = RadioSettingValueList(options, options[_sets.backlight]) rset = RadioSetting("settings.backlight", "Backlight Level", rx) disp.append(rset) options = ["Off", "Auto-Off", "Auto-1", "Auto-2", "Auto-3"] rx = RadioSettingValueList(options, options[_sets.autodim]) rset = RadioSetting("settings.autodim", "Auto Dimmer", rx) disp.append(rset) options = ["5", "10"] rx = RadioSettingValueList(options, options[_sets.autodimtot]) rset = RadioSetting("settings.autodimtot", "Auto-Dimmer Timeout (Secs)", rx) disp.append(rset) options = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"] rx = RadioSettingValueList(options, options[_sets.contrast]) rset = RadioSetting("settings.contrast", "LCD Contrast", rx) disp.append(rset) rx = RadioSettingValueBoolean(bool(_sets.openmsg)) rset = RadioSetting("settings.openmsg", "Opening Message", rx) disp.append(rset) rx = RadioSettingValueBoolean(bool(_sets.memname)) rset = RadioSetting("settings.memname", "Memory Names", rx) disp.append(rset) options = ["CH ID", "Frequency"] rx = RadioSettingValueList(options, options[_sets.airbandch]) rset = RadioSetting("settings.airbandch", "Air Band Display", rx) disp.append(rset) # -- Sounds rx = RadioSettingValueInteger(0, 9, _sets.beeplvl) rset = RadioSetting("settings.beeplvl", "Beep Level", rx) sound.append(rset) rx = RadioSettingValueBoolean(bool(_sets.homebeep)) rset = RadioSetting("settings.homebeep", "Home Chan Beep", rx) sound.append(rset) rx = RadioSettingValueBoolean(bool(_sets.keybeep)) rset = RadioSetting("settings.keybeep", "Key Touch Beep", rx) sound.append(rset) rx = RadioSettingValueBoolean(bool(_sets.bandedgbeep)) rset = RadioSetting("settings.bandedgbeep", "Band Edge Beep", rx) sound.append(rset) rx = RadioSettingValueBoolean(bool(_sets.scanstpbeep)) rset = RadioSetting("settings.scanstpbeep", "Scan Stop Beep", rx) sound.append(rset) options = ["Off", "Mute", "Beep", "Mute & Beep"] rx = RadioSettingValueList(options, options[_sets.subandmute]) rset = RadioSetting("settings.subandmute", "Sub Band Mute", rx) sound.append(rset) # --- DTMF Codes options = ["100", "200", "300", "500"] rx = RadioSettingValueList(options, options[_sets.dtmfspd]) rset = RadioSetting("settings.dtmfspd", "DTMF Speed (mSecs)", rx) dtmf.append(rset) for kx in range(0, 16): stx = unpack_str(_dtm[kx].codes) rx = RadioSettingValueString(0, 24, stx) # NOTE the / to indicate indexed array rset = RadioSetting("dtmfcode/%d.codes" % kx, "DTMF Code %X" % kx, rx) rset.set_apply_callback(pack_chars, _dtm, "codes", kx) dtmf.append(rset) # --- Program Scan Edges for kx in range(0, 25): stx = "" for i in range(0, 6): stx += chr(_pses[kx].name[i]) stx = stx.rstrip() rx = RadioSettingValueString(0, 6, stx) rset = RadioSetting("pgmscanedge/%d.name" % kx, "Program Scan %d Name" % kx, rx) rset.set_apply_callback(myset_psnam, _pses, kx, "name", 6) edges.append(rset) # Freq's use the multiplier flags fmult = 5000.0 if _pses[kx].loflags == 0x10: fmult = 8333 if _pses[kx].loflags == 0x08: fmult = 6250.0 flow = (int(_pses[kx].lofreq) * fmult) / 1000000.0 flow = round(flow, 4) fmult = 5000.0 if _pses[kx].hiflags == 0x10: fmult = 8333 if _pses[kx].hiflags == 0x08: fmult = 6250.0 fhigh = (int(_pses[kx].hifreq) * fmult) / 1000000.0 fhigh = round(fhigh, 4) if (flow > 0) and (flow >= fhigh): # reverse em val = flow flow = fhigh fhigh = val rx = RadioSettingValueFloat(0, 550.0, flow, 0.010, 3) rset = RadioSetting("pgmscanedge/%d.lofreq" % kx, "-- Scan %d Low Limit" % kx, rx) rset.set_apply_callback(myset_frqflgs, _pses, kx, "loflags", "lofreq") edges.append(rset) rx = RadioSettingValueFloat(0, 550.0, fhigh, 0.010, 3) rset = RadioSetting("pgmscanedge/%d.hifreq" % kx, "-- Scan %d High Limit" % kx, rx) rset.set_apply_callback(myset_frqflgs, _pses, kx, "hiflags", "hifreq") edges.append(rset) # Tstep and Mode depend on the bands ndxt = 0 ndxm = 0 bxnd = 0 tsopt = [ "-", "5k", "6.25k", "10k", "12.5k", "15k", "20k", "25k", "30k", "50k" ] mdopt = ["-", "FM", "FM-N"] if fhigh > 0: if fhigh < 135.0: # Air band bxnd = 1 tsopt = ["-", "8.33k", "25k", "Auto"] ndxt = _pses[kx].tstp if ndxt == 0xe: # Auto ndxt = 3 elif ndxt == 8: # 25k ndxt = 2 elif ndxt == 2: # 8.33k ndxt = 1 else: ndxt = 0 mdopt = ["-"] elif (flow >= 137.0) and (fhigh <= 174.0): # VHF ndxt = _pses[kx].tstp - 1 ndxm = _pses[kx].mode + 1 bxnd = 2 elif (flow >= 375.0) and (fhigh <= 550.0): # UHF ndxt = _pses[kx].tstp - 1 ndxm = _pses[kx].mode + 1 bxnd = 3 else: # Mixed, ndx's = 0 default tsopt = ["-"] mdopt = ["-"] bxnd = 4 if (ndxt > 9) or (ndxt < 0): ndxt = 0 # trap ff if ndxm > 2: ndxm = 0 # end if fhigh > 0 rx = RadioSettingValueList(tsopt, tsopt[ndxt]) rset = RadioSetting("pgmscanedge/%d.tstp" % kx, "-- Scan %d Freq Step" % kx, rx) rset.set_apply_callback(myset_tsopt, _pses, kx, "tstp", bxnd) edges.append(rset) rx = RadioSettingValueList(mdopt, mdopt[ndxm]) rset = RadioSetting("pgmscanedge/%d.mode" % kx, "-- Scan %d Mode" % kx, rx) rset.set_apply_callback(myset_mdopt, _pses, kx, "mode", bxnd) edges.append(rset) # End for kx # --- Program Scan Links _psln = self._memobj.pslnam _pslg = self._memobj.pslgrps for kx in range(0, 10): stx = "" for i in range(0, 6): stx += chr(_psln[kx].nam[i]) stx = stx.rstrip() rx = RadioSettingValueString(0, 6, stx) rset = RadioSetting("pslnam/%d.nam" % kx, "Program Scan Link %d Name" % kx, rx) rset.set_apply_callback(myset_psnam, _psln, kx, "nam", 6) pslnk.append(rset) for px in range(0, 25): # Generate string numeric representation of 4-byte bitmask stx = "" for nx in range(0, 25): if nx < 8: if (_pslg[kx].msk[0] & (1 << nx)): stx += "%0d, " % nx elif (nx >= 8) and (nx < 16): if (_pslg[kx].msk[1] & (1 << (nx - 8))): sstx += "%0d, " % nx elif (nx >= 16) and (nx < 24): if (_pslg[kx].msk[2] & (1 << (nx - 16))): stx += "%0d, " % nx elif (nx >= 24): if (_pslg[kx].msk[3] & (1 << (nx - 24))): stx += "%0d, " % nx rx = RadioSettingValueString(0, 80, stx) rset = RadioSetting("pslgrps/%d.msk" % kx, "--- Scan Link %d Scans" % kx, rx) rset.set_apply_callback(myset_bitmask, _pslg, kx, "msk", 25) pslnk.append(rset) # end for px # End for kx return group # END get_settings()
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic Settings") top = RadioSettings(basic) # TODO: Check that all these settings actually do what they # say they do. rs = RadioSetting("voiceprompt", "Voice prompt", RadioSettingValueBoolean(_settings.voiceprompt)) basic.append(rs) rs = RadioSetting( "voicelanguage", "Voice language", RadioSettingValueList(VOICE_LIST, VOICE_LIST[_settings.voicelanguage])) basic.append(rs) rs = RadioSetting("scan", "Scan", RadioSettingValueBoolean(_settings.scan)) basic.append(rs) rs = RadioSetting( "settings2.scanmode", "Scan mode", RadioSettingValueList( SCANMODE_LIST, SCANMODE_LIST[self._memobj.settings2.scanmode])) basic.append(rs) rs = RadioSetting("vox", "VOX", RadioSettingValueBoolean(_settings.vox)) basic.append(rs) rs = RadioSetting( "voxlevel", "VOX level", RadioSettingValueInteger(1, 5, _settings.voxlevel + 1)) basic.append(rs) rs = RadioSetting("voxinhibitonrx", "Inhibit VOX on receive", RadioSettingValueBoolean(_settings.voxinhibitonrx)) basic.append(rs) rs = RadioSetting("lowvolinhibittx", "Low voltage inhibit transmit", RadioSettingValueBoolean(_settings.lowvolinhibittx)) basic.append(rs) rs = RadioSetting("highvolinhibittx", "High voltage inhibit transmit", RadioSettingValueBoolean(_settings.highvolinhibittx)) basic.append(rs) rs = RadioSetting("alarm", "Alarm", RadioSettingValueBoolean(_settings.alarm)) basic.append(rs) # TODO: This should probably be called “FM Broadcast Band Radio” # or something. I'm not sure if the model actually has one though. rs = RadioSetting("fmradio", "FM function", RadioSettingValueBoolean(_settings.fmradio)) basic.append(rs) rs = RadioSetting( "settings2.beep", "Beep", RadioSettingValueBoolean(self._memobj.settings2.beep)) basic.append(rs) rs = RadioSetting( "settings2.batterysaver", "Battery saver", RadioSettingValueBoolean(self._memobj.settings2.batterysaver)) basic.append(rs) rs = RadioSetting( "settings2.squelchlevel", "Squelch level", RadioSettingValueInteger(0, 9, self._memobj.settings2.squelchlevel)) basic.append(rs) rs = RadioSetting( "settings2.sidekeyfunction", "Side key function", RadioSettingValueList( SIDEKEYFUNCTION_LIST, SIDEKEYFUNCTION_LIST[self._memobj.settings2.sidekeyfunction])) basic.append(rs) rs = RadioSetting( "settings2.timeouttimer", "Timeout timer", RadioSettingValueList( TIMEOUTTIMER_LIST, TIMEOUTTIMER_LIST[self._memobj.settings2.timeouttimer])) basic.append(rs) return top
def get_settings(self): common = RadioSettingGroup("common", "Common Settings") band = RadioSettingGroup("band", "Band dependent Settings") arts = RadioSettingGroup("arts", "Auto Range Transponder System (ARTS)") dtmf = RadioSettingGroup("dtmf", "DTMF Settings") mic_button = RadioSettingGroup("mic_button", "Microphone Buttons") setmode = RadioSettings(common, band, arts, dtmf, mic_button) _overlay = self._memobj.overlay # numbers and names of settings refer to the way they're # presented in the set menu, as well as the list starting on # page 49 of the manual # 1 Automatic Power Off opts = [ "Off", "30 Min", "1 Hour", "1.5 Hours", "2 Hours", "2.5 Hours", "3 Hours", "3.5 Hours", "4 Hours", "4.5 Hours", "5 Hours", "5.5 Hours", "6 Hours", "6.5 Hours", "7 Hours", "7.5 Hours", "8 Hours", "8.5 Hours", "9 Hours", "9.5 Hours", "10 Hours", "10.5 Hours", "11 Hours", "11.5 Hours", "12 Hours", ] common.append( RadioSetting("apo", "Automatic Power Off", RadioSettingValueList(opts, opts[_overlay.apo]))) # 2 Automatic Repeater Shift function opts = ["Off", "On"] band.append( RadioSetting("ars_vhf", "Automatic Repeater Shift VHF", RadioSettingValueList(opts, opts[_overlay.ars_vhf]))) band.append( RadioSetting("ars_uhf", "Automatic Repeater Shift UHF", RadioSettingValueList(opts, opts[_overlay.ars_uhf]))) # 3 Selects the ARTS mode. # -> Only useful to set it on the radio directly # 4 Enables/disables the key/button beeper. opts = ["Off", "On"] common.append( RadioSetting("beep", "Key/Button Beep", RadioSettingValueList(opts, opts[_overlay.beep]))) # 5 Enables/disables the CW IDer during ARTS operation. opts = ["Off", "On"] arts.append( RadioSetting("cwid", "Enables/Disables the CW ID", RadioSettingValueList(opts, opts[_overlay.cwid]))) # 6 Callsign during ARTS operation. cwidw = _overlay.cwidw.get_raw() cwidw = cwidw.rstrip('\x00') val = RadioSettingValueString(0, 6, cwidw) val.set_charset(CHARSET) rs = RadioSetting("cwidw", "CW Identifier Callsign", val) def apply_cwid(setting): value_string = setting.value.get_value() _overlay.cwidw.set_value(value_string) rs.set_apply_callback(apply_cwid) arts.append(rs) # 7 Front panel display's illumination level. opts = ["0: Off", "1: Max", "2", "3", "4", "5", "6", "7: Min"] common.append( RadioSetting("dim", "Display Illumination", RadioSettingValueList(opts, opts[_overlay.dim]))) # 8 Setting the DCS code number. # Note: This Menu item can be set independently for each band, # and independently in each memory. # 9 Activates the DCS Code Search # -> Only useful if set on radio itself # 10 Selects 'Normal' or 'Inverted' DCS coding. opts = ["TRX Normal", "RX Reversed", "TX Reversed", "TRX Reversed"] band.append( RadioSetting("dcsnr_vhf", "DCS coding VHF", RadioSettingValueList(opts, opts[_overlay.dcsnr_vhf]))) band.append( RadioSetting("dcsnr_uhf", "DCS coding UHF", RadioSettingValueList(opts, opts[_overlay.dcsnr_uhf]))) # 11 Selects the 'sub' band display format opts = [ "Frequency", "Off / Sub Band disabled", "DC Input Voltage", "CW ID" ] common.append( RadioSetting("disp", "Sub Band Display Format", RadioSettingValueList(opts, opts[_overlay.disp]))) # 12 Setting the DTMF Autodialer delay time opts = ["50 ms", "250 ms", "450 ms", "750 ms", "1 s"] dtmf.append( RadioSetting("dtmfd", "Autodialer delay time", RadioSettingValueList(opts, opts[_overlay.dtmfd]))) # 13 Setting the DTMF Autodialer sending speed opts = ["50 ms", "75 ms", "100 ms"] dtmf.append( RadioSetting("dtmfs", "Autodialer sending speed", RadioSettingValueList(opts, opts[_overlay.dtmfs]))) # 14 Current DTMF Autodialer memory rs = RadioSetting("dtmfw", "Current Autodialer memory", RadioSettingValueInteger(1, 16, _overlay.dtmfw + 1)) def apply_dtmfw(setting): _overlay.dtmfw = setting.value.get_value() - 1 rs.set_apply_callback(apply_dtmfw) dtmf.append(rs) # DTMF Memory for i in range(16): dtmf_string = "" for j in range(16): dtmf_char = '' dtmf_int = int(self._memobj.dtmf_mem[i].dtmf[j]) if dtmf_int < 10: dtmf_char = str(dtmf_int) elif dtmf_int == 14: dtmf_char = '*' elif dtmf_int == 15: dtmf_char = '#' elif dtmf_int == 255: break dtmf_string += dtmf_char radio_setting_value_string = RadioSettingValueString( 0, 16, dtmf_string) radio_setting_value_string.set_charset(DTMF_CHARSET) rs = RadioSetting("dtmf_{0:02d}".format(i), "DTMF Mem " + str(i + 1), radio_setting_value_string) def apply_dtmf(setting, index): radio_setting_value_string = setting.value.get_value().rstrip() j = 0 for dtmf_char in radio_setting_value_string: dtmf_int = 255 if dtmf_char in "0123456789": dtmf_int = int(dtmf_char) elif dtmf_char == '*': dtmf_int = 14 elif dtmf_char == '#': dtmf_int = 15 if dtmf_int < 255: self._memobj.dtmf_mem[index].dtmf[j] = dtmf_int j += 1 if j < 16: self._memobj.dtmf_mem[index].dtmf[j] = 255 rs.set_apply_callback(apply_dtmf, i) dtmf.append(rs) # 16 Enables/disables the PTT switch lock opts = ["Off", "Band A", "Band B", "Both"] common.append( RadioSetting("lockt", "PTT switch lock", RadioSettingValueList(opts, opts[_overlay.lockt]))) # 17 Selects the Microphone type to be used opts = ["MH-42", "MH-48"] common.append( RadioSetting("mic", "Microphone type", RadioSettingValueList(opts, opts[_overlay.mic]))) # 18 Reduces the audio level on the sub receiver when the # main receiver is active opts = ["Off", "On"] common.append( RadioSetting("mute", "Mute Sub Receiver", RadioSettingValueList(opts, opts[_overlay.mute]))) # 20 - 23 Programming the microphones button assignment buttons = [ "ACC / P1", "P / P2", "P1 / P3", "P2 / P4", ] opts_button = [ "Low", "Tone", "MHz", "Rev", "Home", "Band", "VFO / Memory", "Sql Off", "1750 Hz Tone Call", "Repeater", "Priority" ] for i, button in enumerate(buttons): rs = RadioSetting( "button" + str(i), button, RadioSettingValueList(opts_button, opts_button[_overlay.button[i]])) def apply_button(setting, index): value_string = setting.value.get_value() value_int = opts_button.index(value_string) _overlay.button[index] = value_int rs.set_apply_callback(apply_button, i) mic_button.append(rs) # 24 Adjusts the RF SQL threshold level opts = ["Off", "S-1", "S-5", "S-9", "S-FULL"] band.append( RadioSetting( "rf_sql_vhf", "RF Sql VHF", RadioSettingValueList(opts, opts[_overlay.rf_sql_vhf]))) band.append( RadioSetting( "rf_sql_uhf", "RF Sql UHF", RadioSettingValueList(opts, opts[_overlay.rf_sql_uhf]))) # 25 Selects the Scan-Resume mode opts = ["Busy", "Time"] band.append( RadioSetting("scan_vhf", "Scan-Resume VHF", RadioSettingValueList(opts, opts[_overlay.scan_vhf]))) band.append( RadioSetting("scan_uhf", "Scan-Resume UHF", RadioSettingValueList(opts, opts[_overlay.scan_uhf]))) # 28 Defining the audio path to the external speaker opts = ["Off", "Band A", "Band B", "Both"] common.append( RadioSetting( "speaker_cnt", "External Speaker", RadioSettingValueList(opts, opts[_overlay.speaker_cnt]))) # 31 Sets the Time-Out Timer opts = ["Off", "Band A", "Band B", "Both"] common.append( RadioSetting("tot", "TX Time-Out [Min.] (0 = Off)", RadioSettingValueInteger(0, 30, _overlay.tot))) # 32 Reducing the MIC Gain (and Deviation) opts = ["Off", "On"] band.append( RadioSetting("txnar_vhf", "TX Narrowband VHF", RadioSettingValueList(opts, opts[_overlay.txnar_vhf]))) band.append( RadioSetting("txnar_uhf", "TX Narrowband UHF", RadioSettingValueList(opts, opts[_overlay.txnar_uhf]))) # 33 Enables/disables the VFO Tracking feature opts = ["Off", "On"] common.append( RadioSetting("vfotr", "VFO Tracking", RadioSettingValueList(opts, opts[_overlay.vfotr]))) # 34 Selects the receiving mode on the VHF band opts = ["Inhibit (only FM)", "AM", "Auto"] common.append( RadioSetting("am", "AM Mode", RadioSettingValueList(opts, opts[_overlay.am]))) # Current Band opts = ["VHF", "UHF"] common.append( RadioSetting( "current_band", "Current Band", RadioSettingValueList(opts, opts[_overlay.current_band]))) # Show number of VHF and UHF channels val = RadioSettingValueString(0, 7, str(int(self._memobj.nb_mem_used_vhf))) val.set_mutable(False) rs = RadioSetting("num_chan_vhf", "Number of VHF channels", val) common.append(rs) val = RadioSettingValueString(0, 7, str(int(self._memobj.nb_mem_used_uhf))) val.set_mutable(False) rs = RadioSetting("num_chan_uhf", "Number of UHF channels", val) common.append(rs) return setmode
def get_settings(self): _settings = self._memobj.settings group = RadioSettingGroup("basic", "Basic") top = RadioSettings(group) 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("squelch", "Squelch Level", RadioSettingValueInteger(0, 9, _settings.squelch))) group.append( RadioSetting( "vox_level", "VOX Level", RadioSettingValueList(VOX_LIST, VOX_LIST[_settings.vox_level]))) group.append( RadioSetting("beep", "Beep", RadioSettingValueBoolean(_settings.beep))) group.append( RadioSetting("ani", "ANI", RadioSettingValueBoolean(_settings.ani))) group.append( RadioSetting("dwait", "D.WAIT", RadioSettingValueBoolean(_settings.dwait))) 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))) group.append( RadioSetting( "scans", "Scans", RadioSettingValueList(SCANS_LIST, SCANS_LIST[_settings.scans]))) group.append( RadioSetting("autolk", "Auto Lock", RadioSettingValueBoolean(_settings.autolk))) group.append( RadioSetting("voice", "Voice", RadioSettingValueBoolean(_settings.voice))) group.append( RadioSetting( "opnmsg", "Opening Message", RadioSettingValueList(OPNMSG_LIST, OPNMSG_LIST[_settings.opnmsg]))) group.append( RadioSetting("disnm", "Display Name", RadioSettingValueBoolean(_settings.disnm))) def _filter(name): LOG.debug(repr(str(name))) return str(name).rstrip("\xFF").rstrip() group.append( RadioSetting( "ponmsg", "Power-On Message", RadioSettingValueString(0, 6, _filter(_settings.ponmsg)))) return top
def get_settings(self): """Translate the bit in the mem_struct into settings in the UI""" _mem = self._memobj basic = RadioSettingGroup("basic", "Basic") work = RadioSettingGroup("work", "Work Mode Settings") top = RadioSettings(basic, work) # Basic sql = RadioSetting("settings.sql", "Squelch Level", RadioSettingValueList(LIST_SQL, LIST_SQL[ _mem.settings.sql])) basic.append(sql) tot = RadioSetting("settings.tot", "Time out timer", RadioSettingValueList(LIST_TOT, LIST_TOT[ _mem.settings.tot])) basic.append(tot) 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 basic = RadioSettingGroup("basic", "Basic Settings") top = RadioSettings(basic) if self.MODEL == "RT21" or self.MODEL == "RB17A": _keys = self._memobj.keys rs = RadioSettingValueList(TIMEOUTTIMER_LIST, TIMEOUTTIMER_LIST[_settings.tot - 1]) rset = RadioSetting("tot", "Time-out timer", rs) basic.append(rset) rs = RadioSettingValueList(TOTALERT_LIST, TOTALERT_LIST[_settings.totalert]) rset = RadioSetting("totalert", "TOT Pre-alert", rs) basic.append(rset) rs = RadioSettingValueInteger(0, 9, _settings.squelch) rset = RadioSetting("squelch", "Squelch Level", rs) basic.append(rset) rs = RadioSettingValueList(VOICE_LIST, VOICE_LIST[_settings.voice]) rset = RadioSetting("voice", "Voice Annumciation", rs) basic.append(rset) if self.MODEL == "RB17A": rs = RadioSettingValueList(ALARM_LIST, ALARM_LIST[_settings.alarm]) rset = RadioSetting("alarm", "Alarm Type", rs) basic.append(rset) rs = RadioSettingValueBoolean(_settings.save) rset = RadioSetting("save", "Battery Saver", rs) basic.append(rset) rs = RadioSettingValueBoolean(_settings.use_scramble) rset = RadioSetting("use_scramble", "Scramble", rs) basic.append(rset) rs = RadioSettingValueBoolean(_settings.use_vox) rset = RadioSetting("use_vox", "VOX", rs) basic.append(rset) rs = RadioSettingValueList(VOX_LIST, VOX_LIST[_settings.vox]) rset = RadioSetting("vox", "VOX Gain", rs) basic.append(rset) def apply_pf1_listvalue(setting, obj): LOG.debug("Setting value: " + str( setting.value) + " from list") val = str(setting.value) index = PF1_CHOICES.index(val) val = PF1_VALUES[index] obj.set_value(val) if _keys.pf1 in PF1_VALUES: idx = PF1_VALUES.index(_keys.pf1) else: idx = LIST_DTMF_SPECIAL_VALUES.index(0x04) rs = RadioSettingValueList(PF1_CHOICES, PF1_CHOICES[idx]) rset = RadioSetting("keys.pf1", "PF1 Key Function", rs) rset.set_apply_callback(apply_pf1_listvalue, _keys.pf1) basic.append(rset) def apply_topkey_listvalue(setting, obj): LOG.debug("Setting value: " + str(setting.value) + " from list") val = str(setting.value) index = TOPKEY_CHOICES.index(val) val = TOPKEY_VALUES[index] obj.set_value(val) if self.MODEL == "RB17A": if _keys.topkey in TOPKEY_VALUES: idx = TOPKEY_VALUES.index(_keys.topkey) else: idx = TOPKEY_VALUES.index(0x0C) rs = RadioSettingValueList(TOPKEY_CHOICES, TOPKEY_CHOICES[idx]) rset = RadioSetting("keys.topkey", "Top Key Function", rs) rset.set_apply_callback(apply_topkey_listvalue, _keys.topkey) basic.append(rset) if self.MODEL == "RB26" or self.MODEL == "RT76": if self.MODEL == "RB26": _settings2 = self._memobj.settings2 _settings3 = self._memobj.settings3 rs = RadioSettingValueInteger(0, 9, _settings.squelch) rset = RadioSetting("squelch", "Squelch Level", rs) basic.append(rset) rs = RadioSettingValueList(TIMEOUTTIMER_LIST, TIMEOUTTIMER_LIST[_settings.tot - 1]) rset = RadioSetting("tot", "Time-out timer", rs) basic.append(rset) if self.MODEL == "RT76": rs = RadioSettingValueList(VOICE_LIST3, VOICE_LIST3[_settings.voice]) rset = RadioSetting("voice", "Voice Annumciation", rs) basic.append(rset) if self.MODEL == "RB26": rs = RadioSettingValueList(VOICE_LIST2, VOICE_LIST2[_settings.voice]) rset = RadioSetting("voice", "Voice Annumciation", rs) basic.append(rset) rs = RadioSettingValueBoolean(not _settings.chnumberd) rset = RadioSetting("chnumberd", "Channel Number Enable", rs) basic.append(rset) rs = RadioSettingValueBoolean(_settings.save) rset = RadioSetting("save", "Battery Save", rs) basic.append(rset) rs = RadioSettingValueBoolean(_settings.beep) rset = RadioSetting("beep", "Beep", rs) basic.append(rset) if self.MODEL == "RB26": rs = RadioSettingValueBoolean(not _settings.tail) rset = RadioSetting("tail", "QT/DQT Tail", rs) basic.append(rset) rs = RadioSettingValueList(SAVE_LIST, SAVE_LIST[_settings.savem]) rset = RadioSetting("savem", "Battery Save Mode", rs) basic.append(rset) rs = RadioSettingValueList(GAIN_LIST, GAIN_LIST[_settings.gain]) rset = RadioSetting("gain", "MIC Gain", rs) basic.append(rset) rs = RadioSettingValueList(WARN_LIST, WARN_LIST[_settings.warn]) rset = RadioSetting("warn", "Warn Mode", rs) basic.append(rset) if self.MODEL == "RB26": rs = RadioSettingValueBoolean(_settings3.vox) rset = RadioSetting("settings3.vox", "Vox Function", rs) basic.append(rset) rs = RadioSettingValueList(VOXL_LIST, VOXL_LIST[_settings3.voxl]) rset = RadioSetting("settings3.voxl", "Vox Level", rs) basic.append(rset) rs = RadioSettingValueList(VOXD_LIST, VOXD_LIST[_settings3.voxd]) rset = RadioSetting("settings3.voxd", "Vox Delay", rs) basic.append(rset) rs = RadioSettingValueList(PFKEY_LIST, PFKEY_LIST[_settings.pf1]) rset = RadioSetting("pf1", "PF1 Key Set", rs) basic.append(rset) rs = RadioSettingValueList(PFKEY_LIST, PFKEY_LIST[_settings.pf2]) rset = RadioSetting("pf2", "PF2 Key Set", rs) basic.append(rset) rs = RadioSettingValueInteger(1, 30, _settings2.chnumber + 1) rset = RadioSetting("settings2.chnumber", "Channel Number", rs) basic.append(rset) if self.MODEL == "RT76": rs = RadioSettingValueBoolean(_settings.vox) rset = RadioSetting("vox", "Vox Function", rs) basic.append(rset) rs = RadioSettingValueList(VOXL_LIST, VOXL_LIST[_settings.voxl]) rset = RadioSetting("voxl", "Vox Level", rs) basic.append(rset) rs = RadioSettingValueList(VOXD_LIST, VOXD_LIST[_settings.voxd]) rset = RadioSetting("voxd", "Vox Delay", rs) basic.append(rset) rs = RadioSettingValueInteger(1, 30, _settings.chnumber + 1) rset = RadioSetting("chnumber", "Channel Number", rs) basic.append(rset) return top
def get_settings(self): try: _squelch = 1 basic = RadioSettingGroup("basic", "Basic") expand_1 = RadioSettingGroup("expand_1", "Expand 1") expand_2 = RadioSettingGroup("expand_2", "Expand 2") dtmf_autodial = RadioSettingGroup("dtmf_autodial", "DTMF autodial") group = RadioSettings(basic, expand_1, expand_2, dtmf_autodial) # basic basic.append( RadioSetting( "mem_channel", "Current memory channel", RadioSettingValueInteger(0, MEM_NUM - 1, self.memobj.mem_channel))) basic.append( RadioSetting( "squelch_level", "Squelch level", RadioSettingValueList( SQUELCH_LEVEL, SQUELCH_LEVEL[self.memobj.squelch_level]))) basic.append( RadioSetting( "scan_resume", "Scan resume", RadioSettingValueList( SCAN_RESUME, SCAN_RESUME[self.memobj.scan_resume]))) basic.append( RadioSetting( "scan_pause", "Scan pause", RadioSettingValueList(SCAN_PAUSE, SCAN_PAUSE[self.memobj.scan_pause]))) basic.append( RadioSetting( "beep_volume", "Beep audio", RadioSettingValueList( BEEP_VOLUME, BEEP_VOLUME[self.memobj.beep_volume]))) basic.append( RadioSetting("beep", "Operation beep", RadioSettingValueBoolean(self.memobj.beep))) basic.append( RadioSetting( "backlight", "LCD backlight", RadioSettingValueList(BACKLIGHT, BACKLIGHT[self.memobj.backlight]))) basic.append( RadioSetting("busy_led", "Busy LED", RadioSettingValueBoolean(self.memobj.busy_led))) basic.append( RadioSetting( "auto_power_off", "Auto power off", RadioSettingValueList( AUTO_POWER_OFF, AUTO_POWER_OFF[self.memobj.auto_power_off]))) basic.append( RadioSetting( "power_save", "Power save", RadioSettingValueList(POWER_SAVE, POWER_SAVE[self.memobj.power_save]))) basic.append( RadioSetting( "monitor", "Monitor", RadioSettingValueList(MONITOR, MONITOR[self.memobj.monitor]))) basic.append( RadioSetting( "dial_speedup", "Dial speedup", RadioSettingValueBoolean(self.memobj.dial_speedup))) basic.append( RadioSetting( "auto_repeater", "Auto repeater", RadioSettingValueList( AUTO_REPEATER, AUTO_REPEATER[self.memobj.auto_repeater]))) basic.append( RadioSetting( "hm_75a_function", "HM-75A function", RadioSettingValueList( HM_75A_FUNCTION, HM_75A_FUNCTION[self.memobj.hm_75a_function]))) basic.append( RadioSetting("wx_alert", "WX alert", RadioSettingValueBoolean(self.memobj.wx_alert))) basic.append( RadioSetting( "wx_channel", "Current WX channel", RadioSettingValueList(WX_CHANNEL, WX_CHANNEL[self.memobj.wx_channel]))) basic.append( RadioSetting( "comment", "Comment", RadioSettingValueString(0, COMMENT_LEN, str(self.memobj.comment), autopad=True))) basic.append( RadioSetting( "tune_step", "Current tune step", RadioSettingValueList( TUNE_STEP_STR, TUNE_STEP_STR[self.memobj.tune_step]))) basic.append( RadioSetting( "band_selected", "Selected band", RadioSettingValueInteger(0, BANDS - 1, self.memobj.band_selected))) basic.append( RadioSetting( "memory_display", "Memory display", RadioSettingValueList( MEMORY_DISPLAY, MEMORY_DISPLAY[self.memobj.memory_display]))) basic.append( RadioSetting("memory_name", "Memory name", RadioSettingValueBoolean( self.memobj.memory_name))) basic.append( RadioSetting( "dial_select", "Dial select", RadioSettingValueList( DIAL_SELECT, DIAL_SELECT[self.memobj.dial_select]))) basic.append( RadioSetting( "power", "RF power", RadioSettingValueList(POWER, POWER[self.memobj.power]))) basic.append( RadioSetting("vfo", "Current VFO", RadioSettingValueList(VFO, VFO[self.memobj.vfo]))) basic.append( RadioSetting("attenuator", "RF attenuator", RadioSettingValueBoolean(self.memobj.attenuator))) basic.append( RadioSetting("skip_scan", "Skip scan", RadioSettingValueBoolean(self.memobj.skip_scan))) # TODO: this needs to be reverse engineered, because the following commented # code does not seem correct # basic.append(RadioSetting("mode", "Current mode", # RadioSettingValueList(OPERATION_MODE, # OPERATION_MODE[self.memobj.mode]))) basic.append( RadioSetting( "vfo_scan", "VFO scan", RadioSettingValueList(VFO_SCAN, VFO_SCAN[self.memobj.vfo_scan]))) basic.append( RadioSetting( "memory_scan", "Memory scan", RadioSettingValueList( MEMORY_SCAN, MEMORY_SCAN[self.memobj.memory_scan]))) basic.append( RadioSetting( "tv_channel", "Current TV channel", RadioSettingValueInteger(0, TV_CHANNELS - 1, self.memobj.tv_channel))) # DTMF auto dial dtmf_autodial.append( RadioSetting( "autodial", "Autodial", RadioSettingValueList(AUTODIAL, AUTODIAL[self.memobj.autodial]))) dtmf_autodial.append( RadioSetting( "dtmf_speed", "Speed", RadioSettingValueList(DTMF_SPEED, DTMF_SPEED[self.memobj.dtmf_speed]))) for x in range(DTMF_AUTODIAL_NUM): rs = RadioSetting( "dtmf_codes[%d].dtmf_digits" % x, "DTMF autodial: %d" % x, RadioSettingValueString( 0, DTMF_DIGITS_NUM, self.dtmf_icom2chirp( self.memobj.dtmf_codes[x].dtmf_digits), autopad=True, charset="0123456789ABCD*#abcd ")) rs.set_apply_callback(self.apply_dtmf_autodial, self.memobj.dtmf_codes[x].dtmf_digits) dtmf_autodial.append(rs) # expand 1 expand_1.append( RadioSetting("expand_1", "Expand 1", RadioSettingValueBoolean(self.memobj.expand_1))) expand_1.append( RadioSetting( "scan_stop_beep", "Scan stop beep", RadioSettingValueBoolean(self.memobj.scan_stop_beep))) expand_1.append( RadioSetting( "scan_stop_light", "Scan stop light", RadioSettingValueBoolean(self.memobj.scan_stop_light))) expand_1.append( RadioSetting( "light_postion", "Light position", RadioSettingValueList( LIGHT_POSITION, LIGHT_POSITION[self.memobj.light_position]))) expand_1.append( RadioSetting( "light_color", "Light color", RadioSettingValueList( LIGHT_COLOR, LIGHT_COLOR[self.memobj.light_color]))) expand_1.append( RadioSetting( "band_edge_beep", "Band edge beep", RadioSettingValueBoolean(self.memobj.band_edge_beep))) expand_1.append( RadioSetting( "auto_power_on", "Auto power on", RadioSettingValueList( AUTO_POWER_ON, AUTO_POWER_ON[self.memobj.auto_power_on]))) expand_1.append( RadioSetting( "key_lock", "Key lock", RadioSettingValueList(KEY_LOCK, KEY_LOCK[self.memobj.key_lock]))) expand_1.append( RadioSetting("ptt_lock", "PTT lock", RadioSettingValueBoolean(self.memobj.ptt_lock))) expand_1.append( RadioSetting( "lcd_contrast", "LCD contrast", RadioSettingValueList( LCD_CONTRAST, LCD_CONTRAST[self.memobj.lcd_contrast]))) expand_1.append( RadioSetting( "opening_message", "Opening message", RadioSettingValueBoolean(self.memobj.opening_message))) expand_1.append( RadioSetting( "opening_message_text", "Opening message", RadioSettingValueString( 0, OPENING_MESSAGE_LEN, str(self.memobj.opening_message_text), autopad=True, charset=CHARSET))) # expand 2 expand_2.append( RadioSetting("expand_2", "Expand 2", RadioSettingValueBoolean(self.memobj.expand_2))) expand_2.append( RadioSetting( "busy_lockout", "Busy lock out", RadioSettingValueBoolean(self.memobj.busy_lockout))) expand_2.append( RadioSetting( "timeout_timer", "Timeout timer", RadioSettingValueList( TIMEOUT_TIMER, TIMEOUT_TIMER[self.memobj.timeout_timer]))) expand_2.append( RadioSetting( "active_band", "Active band", RadioSettingValueList( ACTIVE_BAND, ACTIVE_BAND[self.memobj.active_band]))) expand_2.append( RadioSetting("fm_narrow", "FM narrow", RadioSettingValueBoolean(self.memobj.fm_narrow))) expand_2.append( RadioSetting("split", "Split", RadioSettingValueBoolean(self.memobj.split))) expand_2.append( RadioSetting( "morse_code_enable", "Morse code synthesizer", RadioSettingValueBoolean(self.memobj.morse_code_enable))) expand_2.append( RadioSetting( "morse_code_speed", "Morse code speed", RadioSettingValueList( MORSE_CODE_SPEED, MORSE_CODE_SPEED[self.memobj.morse_code_speed]))) return group except: import traceback LOG.error("Failed to parse settings: %s", traceback.format_exc()) return None
def _get_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 _vfo = self._memobj.vfo basic = RadioSettingGroup("basic", "Basic Settings") group = RadioSettings(basic) rs = RadioSetting("squelch", "Squelch Level", RadioSettingValueInteger(0, 9, _settings.squelch)) basic.append(rs) rs = RadioSetting("backlight", "LCD Back Light", RadioSettingValueList( BACKLIGHT_LIST, BACKLIGHT_LIST[_settings.backlight])) basic.append(rs) rs = RadioSetting("beep", "Keypad Beep", RadioSettingValueBoolean(_settings.beep)) basic.append(rs) rs = RadioSetting("vox", "VOX Level (0=OFF)", RadioSettingValueInteger(0, 9, _settings.vox)) basic.append(rs) rs = RadioSetting("dw", "Dual Watch", RadioSettingValueBoolean(_settings.dw)) basic.append(rs) rs = RadioSetting("ste", "Squelch Tail Eliminate", RadioSettingValueList( STE_LIST, STE_LIST[_settings.ste])) basic.append(rs) rs = RadioSetting("save", "Battery Saver", RadioSettingValueBoolean(_settings.save)) basic.append(rs) rs = RadioSetting("timeout", "Time Out Timer", RadioSettingValueList( TIMEOUT_LIST, TIMEOUT_LIST[_settings.timeout])) basic.append(rs) rs = RadioSetting("scanm", "Scan Mode", RadioSettingValueList( SCANM_LIST, SCANM_LIST[_settings.scanm])) basic.append(rs) rs = RadioSetting("relaym", "Repeater Sound Response", RadioSettingValueBoolean(_settings.relaym)) basic.append(rs) rs = RadioSetting("bclo", "Busy Channel Lock Out", RadioSettingValueBoolean(_settings.bclo)) basic.append(rs) rs = RadioSetting("pri", "Priority Channel Scanning", RadioSettingValueBoolean(_settings.pri)) basic.append(rs) rs = RadioSetting("pri_ch", "Priority Channel", RadioSettingValueList( PRI_CH_LIST, PRI_CH_LIST[_settings.pri_ch])) basic.append(rs) rs = RadioSetting("ch_flag", "Display Mode", RadioSettingValueList( CH_FLAG_LIST, CH_FLAG_LIST[_settings.ch_flag])) basic.append(rs) _limit = int(self._memobj.limits.lower_vhf) / 10 if _limit < 115 or _limit > 239: _limit = 144 rs = RadioSetting("limits.lower_vhf", "VHF Lower Limit (115-239 MHz)", RadioSettingValueInteger(115, 235, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.lower_vhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) _limit = int(self._memobj.limits.upper_vhf) / 10 if _limit < 115 or _limit > 239: _limit = 146 rs = RadioSetting("limits.upper_vhf", "VHF Upper Limit (115-239 MHz)", RadioSettingValueInteger(115, 235, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.upper_vhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) _limit = int(self._memobj.limits.lower_uhf) / 10 if _limit < 200 or _limit > 529: _limit = 420 rs = RadioSetting("limits.lower_uhf", "UHF Lower Limit (200-529 MHz)", RadioSettingValueInteger(200, 529, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.lower_uhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) _limit = int(self._memobj.limits.upper_uhf) / 10 if _limit < 200 or _limit > 529: _limit = 450 rs = RadioSetting("limits.upper_uhf", "UHF Upper Limit (200-529 MHz)", RadioSettingValueInteger(200, 529, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.upper_uhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) vfo_preset = RadioSettingGroup("vfo_preset", "VFO Presets") group.append(vfo_preset) def convert_bytes_to_freq(bytes): real_freq = 0 real_freq = bytes return chirp_common.format_freq(real_freq * 10) def apply_vhf_freq(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 10 obj.vhf.freq = value val = RadioSettingValueString( 0, 10, convert_bytes_to_freq(int(_vfo.vhf.freq))) rs = RadioSetting("vfo.vhf.freq", "VHF RX Frequency (115.00000-236.00000)", val) rs.set_apply_callback(apply_vhf_freq, _vfo) vfo_preset.append(rs) rs = RadioSetting("vfo.vhf.duplex", "Shift Direction", RadioSettingValueList( DUPLEX_LIST, DUPLEX_LIST[_vfo.vhf.duplex])) vfo_preset.append(rs) def convert_bytes_to_offset(bytes): real_offset = 0 real_offset = bytes return chirp_common.format_freq(real_offset * 10000) def apply_vhf_offset(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 10000 obj.vhf.offset = value val = RadioSettingValueString( 0, 10, convert_bytes_to_offset(int(_vfo.vhf.offset))) rs = RadioSetting("vfo.vhf.offset", "Offset (0.00-37.995)", val) rs.set_apply_callback(apply_vhf_offset, _vfo) vfo_preset.append(rs) rs = RadioSetting("vfo.vhf.power", "Power Level", RadioSettingValueList( POWER_LIST, POWER_LIST[_vfo.vhf.power])) vfo_preset.append(rs) rs = RadioSetting("vfo.vhf.bandwidth", "Bandwidth", RadioSettingValueList( BANDWIDTH_LIST, BANDWIDTH_LIST[_vfo.vhf.bandwidth])) vfo_preset.append(rs) rs = RadioSetting("vfo.vhf.step", "Step", RadioSettingValueList( STEP_LIST, STEP_LIST[_vfo.vhf.step])) vfo_preset.append(rs) def apply_uhf_freq(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 10 obj.uhf.freq = value val = RadioSettingValueString( 0, 10, convert_bytes_to_freq(int(_vfo.uhf.freq))) rs = RadioSetting("vfo.uhf.freq", "UHF RX Frequency (200.00000-529.00000)", val) rs.set_apply_callback(apply_uhf_freq, _vfo) vfo_preset.append(rs) rs = RadioSetting("vfo.uhf.duplex", "Shift Direction", RadioSettingValueList( DUPLEX_LIST, DUPLEX_LIST[_vfo.uhf.duplex])) vfo_preset.append(rs) def apply_uhf_offset(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 10000 obj.uhf.offset = value val = RadioSettingValueString( 0, 10, convert_bytes_to_offset(int(_vfo.uhf.offset))) rs = RadioSetting("vfo.uhf.offset", "Offset (0.00-69.995)", val) rs.set_apply_callback(apply_uhf_offset, _vfo) vfo_preset.append(rs) rs = RadioSetting("vfo.uhf.power", "Power Level", RadioSettingValueList( POWER_LIST, POWER_LIST[_vfo.uhf.power])) vfo_preset.append(rs) rs = RadioSetting("vfo.uhf.bandwidth", "Bandwidth", RadioSettingValueList( BANDWIDTH_LIST, BANDWIDTH_LIST[_vfo.uhf.bandwidth])) vfo_preset.append(rs) rs = RadioSetting("vfo.uhf.step", "Step", RadioSettingValueList( STEP_LIST, STEP_LIST[_vfo.uhf.step])) vfo_preset.append(rs) fm_preset = RadioSettingGroup("fm_preset", "FM Radio Presets") group.append(fm_preset) for i in range(0, 16): if self._memobj.fm_presets[i] < 0x01AF: used = True preset = self._memobj.fm_presets[i] / 10.0 + 65 else: used = False preset = 65 rs = RadioSetting("fm_presets_%1i" % i, "FM Preset %i" % (i + 1), RadioSettingValueBoolean(used), RadioSettingValueFloat(65, 108, preset, 0.1, 1)) fm_preset.append(rs) return group
def _get_settings(self): top = RadioSettings(self._get_display_settings(), self._get_audio_settings(), self._get_battery_settings()) return top
def get_settings(self): _keys = self._memobj.keys _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic Settings") top = RadioSettings(basic) rs = RadioSetting( "tot", "Time-out timer", RadioSettingValueList(TIMEOUTTIMER_LIST, TIMEOUTTIMER_LIST[_settings.tot - 1])) basic.append(rs) rs = RadioSetting( "totalert", "TOT Pre-alert", RadioSettingValueList(TOTALERT_LIST, TOTALERT_LIST[_settings.totalert])) basic.append(rs) rs = RadioSetting("squelch", "Squelch Level", RadioSettingValueInteger(0, 9, _settings.squelch)) basic.append(rs) rs = RadioSetting( "voice", "Voice Annumciation", RadioSettingValueList(VOICE_LIST, VOICE_LIST[_settings.voice])) basic.append(rs) rs = RadioSetting("save", "Battery Saver", RadioSettingValueBoolean(_settings.save)) basic.append(rs) rs = RadioSetting("use_scramble", "Scramble", RadioSettingValueBoolean(_settings.use_scramble)) basic.append(rs) rs = RadioSetting("use_vox", "VOX", RadioSettingValueBoolean(_settings.use_vox)) basic.append(rs) rs = RadioSetting( "vox", "VOX Gain", RadioSettingValueList(VOX_LIST, VOX_LIST[_settings.vox])) basic.append(rs) def apply_pf1_listvalue(setting, obj): LOG.debug("Setting value: " + str(setting.value) + " from list") val = str(setting.value) index = PF1_CHOICES.index(val) val = PF1_VALUES[index] obj.set_value(val) if _keys.pf1 in PF1_VALUES: idx = PF1_VALUES.index(_keys.pf1) else: idx = LIST_DTMF_SPECIAL_VALUES.index(0x04) rs = RadioSetting("keys.pf1", "PF1 Key Function", RadioSettingValueList(PF1_CHOICES, PF1_CHOICES[idx])) rs.set_apply_callback(apply_pf1_listvalue, _keys.pf1) basic.append(rs) return top
def get_settings(self): _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): china = RadioSettingGroup("china", "China Map Fix") smartbeacon = RadioSettingGroup("smartbeacon", "Smartbeacon") aprs = RadioSettingGroup("aprs", "APRS", china, smartbeacon) digipeat = RadioSettingGroup("digipeat", "Digipeat") system = RadioSettingGroup("system", "System") settings = RadioSettings(aprs, digipeat, system) aprs.append( RadioSetting( "callsign", "Callsign", RadioSettingValueString(0, 6, self._mmap.callsign[:6]))) aprs.append( RadioSetting( "ssid", "SSID", RadioSettingValueInteger(0, 15, ord(self._mmap.callsign[6]) - 0x30))) pttdelay = PTT_DELAY[int(self._mmap.pttdelay) - 1] aprs.append( RadioSetting("pttdelay", "PTT Delay", RadioSettingValueList(PTT_DELAY, pttdelay))) output = OUTPUT[int(self._mmap.output) - 1] aprs.append( RadioSetting("output", "Output", RadioSettingValueList(OUTPUT, output))) aprs.append( RadioSetting("mice", "Mic-E", RadioSettingValueBoolean(strbool(self._mmap.mice)))) try: mice_msg = MICE_MESSAGE[int(self._mmap.multiple['mice_message'])] aprs.append( RadioSetting("mice_message", "Mic-E Message", RadioSettingValueList(MICE_MESSAGE, mice_msg))) except NotImplementedError: pass try: aprs.append( RadioSetting( "path1", "Path 1", RadioSettingValueString(0, 6, self._mmap.path1[:6], autopad=True, charset=CHARSET))) ssid1 = ord(self._mmap.path1[6]) - 0x30 aprs.append( RadioSetting("ssid1", "SSID 1", RadioSettingValueInteger(0, 7, ssid1))) aprs.append( RadioSetting( "path2", "Path 2", RadioSettingValueString(0, 6, self._mmap.path2[:6], autopad=True, charset=CHARSET))) ssid2 = ord(self._mmap.path2[6]) - 0x30 aprs.append( RadioSetting("ssid2", "SSID 2", RadioSettingValueInteger(0, 7, ssid2))) aprs.append( RadioSetting( "path3", "Path 3", RadioSettingValueString(0, 6, self._mmap.path3[:6], autopad=True, charset=CHARSET))) ssid3 = ord(self._mmap.path3[6]) - 0x30 aprs.append( RadioSetting("ssid3", "SSID 3", RadioSettingValueInteger(0, 7, ssid3))) except NotImplementedError: aprs.append( RadioSetting( "path", "Path", RadioSettingValueList(PATH, PATH[int(self._mmap.path)]))) aprs.append( RadioSetting("table", "Table or Overlay", RadioSettingValueList(TABLE, self._mmap.symbol[1]))) aprs.append( RadioSetting("symbol", "Symbol", RadioSettingValueList(SYMBOL, self._mmap.symbol[0]))) aprs.append( RadioSetting( "beacon", "Beacon Mode", RadioSettingValueList(BEACON, BEACON[int(self._mmap.beacon) - 1]))) aprs.append( RadioSetting("rate", "Beacon Rate (seconds)", RadioSettingValueInteger(10, 9999, self._mmap.rate))) aprs.append( RadioSetting( "comment", "Comment", RadioSettingValueString(0, 34, self._mmap.comment, autopad=False, charset=CHARSET))) try: voltage = self._mmap.multiple['voltage'] aprs.append( RadioSetting("voltage", "Voltage in comment", RadioSettingValueBoolean(voltage))) temperature = self._mmap.multiple['temperature'] aprs.append( RadioSetting("temperature", "Temperature in comment", RadioSettingValueBoolean(temperature))) except NotImplementedError: pass aprs.append( RadioSetting( "status", "Status", RadioSettingValueString(0, 34, self._mmap.status, autopad=False, charset=CHARSET))) try: telemetry = self._mmap.multiple['telemetry'] aprs.append( RadioSetting("telemetry", "Telemetry", RadioSettingValueBoolean(telemetry))) telemetry_every = self._mmap.multiple['telemetry_every'] aprs.append( RadioSetting("telemetry_every", "Telemetry every", RadioSettingValueInteger(1, 99, telemetry_every))) timeslot_enable = self._mmap.multiple['telemetry'] aprs.append( RadioSetting("timeslot_enable", "Timeslot", RadioSettingValueBoolean(timeslot_enable))) timeslot = self._mmap.multiple['timeslot'] aprs.append( RadioSetting("timeslot", "Timeslot (second of minute)", RadioSettingValueInteger(0, 59, timeslot))) except NotImplementedError: pass fields = [ ("chinamapfix", "China map fix", RadioSettingValueBoolean(strbool(self._mmap.chinamapfix[0]))), ("chinalat", "Lat", RadioSettingValueInteger(-45, 45, ord(self._mmap.chinamapfix[2]) - 80)), ("chinalon", "Lon", RadioSettingValueInteger(-45, 45, ord(self._mmap.chinamapfix[1]) - 80)), ] for field in fields: china.append(RadioSetting(*field)) try: # Sometimes when digipeat is disabled, alias is 0xFF alias = ALIAS[int(self._mmap.digipeat[1]) - 1] except ValueError: alias = ALIAS[0] fields = [ ("digipeat", "Digipeat", RadioSettingValueBoolean(strbool(self._mmap.digipeat[0]))), ("alias", "Digipeat Alias", RadioSettingValueList(ALIAS, alias)), ("virtualgps", "Static Position", RadioSettingValueBoolean(strbool(self._mmap.virtualgps[0]))), ("btext", "Static Position BTEXT", RadioSettingValueString(0, 27, self._mmap.virtualgps[1:], autopad=False, charset=CHARSET)), ] for field in fields: digipeat.append(RadioSetting(*field)) sb = self._mmap.smartbeacon fields = [ ("lowspeed", "Low Speed"), ("highspeed", "High Speed"), ("slowrate", "Slow Rate (seconds)"), ("fastrate", "Fast Rate (seconds)"), ("turnslope", "Turn Slope"), ("turnangle", "Turn Angle"), ("turntime", "Turn Time (seconds)"), ] for field in fields: smartbeacon.append( RadioSetting(field[0], field[1], RadioSettingValueInteger(0, 9999, sb[field[0]]))) system.append( RadioSetting("version", "Version (read-only)", RadioSettingValueString(0, 14, self._mmap.version))) system.append( RadioSetting("autooff", "Auto off (after 90 minutes)", RadioSettingValueBoolean(strbool( self._mmap.autooff)))) system.append( RadioSetting("beep", "Beep on transmit", RadioSettingValueBoolean(strbool(self._mmap.beep)))) system.append( RadioSetting( "highaltitude", "High Altitude", RadioSettingValueBoolean(strbool(self._mmap.highaltitude)))) system.append( RadioSetting( "busywait", "Wait for clear channel before transmit", RadioSettingValueBoolean(strbool(self._mmap.busywait)))) try: system.append( RadioSetting( "tx_volume", "Transmit volume", RadioSettingValueList(map(str, range(1, 7)), self._mmap.tx_volume))) system.append( RadioSetting( "rx_volume", "Receive volume", RadioSettingValueList(map(str, range(1, 10)), self._mmap.rx_volume))) system.append( RadioSetting( "squelch", "Squelch", RadioSettingValueList(map(str, range( 0, 9)), str(self._mmap.multiple['squelch'])))) system.append( RadioSetting( "tx_serial_ui_out", "Tx serial UI out", RadioSettingValueBoolean( strbool(self._mmap.tx_serial_ui_out)))) system.append( RadioSetting( "auto_on", "Auto-on with 5V input", RadioSettingValueBoolean(strbool(self._mmap.auto_on[0])))) system.append( RadioSetting( "auto_on_delay", "Auto-off delay after 5V lost (seconds)", RadioSettingValueInteger(0, 9999, int(self._mmap.auto_on[1:])))) system.append( RadioSetting( "tfx", "TF/X", RadioSettingValueBoolean(self._mmap.multiple['tfx']))) system.append( RadioSetting( "blueled", "Light blue LED on GPS lock", RadioSettingValueBoolean(self._mmap.multiple['blueled']))) system.append( RadioSetting( "dcd", "Blue LED shows software DCD", RadioSettingValueBoolean(self._mmap.multiple['dcd']))) system.append( RadioSetting( "tf_card", "TF card format", RadioSettingValueList( TF_CARD, TF_CARD[int(self._mmap.multiple['tf_card'])]))) except NotImplementedError: pass return settings
def _get_settings(self): # TODO top = RadioSettings() 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): _settings = self._memobj.settings _settings_misc = self._memobj.settings_misc basic = RadioSettingGroup("basic", "Basic Settings") top = RadioSettings(basic) rs = RadioSetting( "rf_sql", "Squelch level (SQL)", RadioSettingValueList(RFSQL_LIST, RFSQL_LIST[_settings.rf_sql])) basic.append(rs) rs = RadioSetting( "step_freq", "Step frequency KHz (STP)", RadioSettingValueList(STEP_LIST, STEP_LIST[_settings.step_freq])) basic.append(rs) rs = RadioSetting( "fm_radio", "FM radio (DW)", RadioSettingValueList(OFF_ON_LIST, OFF_ON_LIST[_settings_misc.fm_radio])) basic.append(rs) rs = RadioSetting( "call_tone", "Call tone (CK)", RadioSettingValueList(CALLTONE_LIST, CALLTONE_LIST[_settings.call_tone])) basic.append(rs) rs = RadioSetting( "tot", "Time-out timer (TOT)", RadioSettingValueList(TIMEOUT_LIST, TIMEOUT_LIST[_settings.tot])) basic.append(rs) rs = RadioSetting( "chan_disp_way", "Channel display way", RadioSettingValueList(CH_FLAG_LIST, CH_FLAG_LIST[_settings.chan_disp_way])) basic.append(rs) rs = RadioSetting( "vox", "VOX Gain (VOX)", RadioSettingValueList(VOX_LIST, VOX_LIST[_settings.vox])) basic.append(rs) rs = RadioSetting( "vox_dly", "VOX Delay", RadioSettingValueList(VOXDELAY_LIST, VOXDELAY_LIST[_settings.vox_dly])) basic.append(rs) rs = RadioSetting( "beep", "Beep (BP)", RadioSettingValueList(OFF_ON_LIST, OFF_ON_LIST[_settings.beep])) basic.append(rs) rs = RadioSetting( "auto_lock", "Auto lock (KY)", RadioSettingValueList(NO_YES_LIST, NO_YES_LIST[_settings_misc.auto_lock])) basic.append(rs) rs = RadioSetting( "bat_save", "Battery Saver (SAV)", RadioSettingValueList(BAT_SAVE_LIST, BAT_SAVE_LIST[_settings.bat_save])) basic.append(rs) rs = RadioSetting( "chan_pri", "Channel PRI (PRI)", RadioSettingValueList(OFF_ON_LIST, OFF_ON_LIST[_settings.chan_pri])) basic.append(rs) rs = RadioSetting( "chan_pri_num", "Channel PRI time Sec (PRI)", RadioSettingValueList(PRI_NUM_LIST, PRI_NUM_LIST[_settings.chan_pri_num])) basic.append(rs) rs = RadioSetting( "end_beep", "End beep (ET)", RadioSettingValueList(ENDBEEP_LIST, ENDBEEP_LIST[_settings.end_beep])) basic.append(rs) rs = RadioSetting( "ch_mode", "CH mode", RadioSettingValueList(ON_OFF_LIST, ON_OFF_LIST[_settings.ch_mode])) basic.append(rs) rs = RadioSetting( "scan_rev", "Scan rev (SCAN)", RadioSettingValueList(SCANM_LIST, SCANM_LIST[_settings.scan_rev])) basic.append(rs) rs = RadioSetting( "enc", "Frequency lock (ENC)", RadioSettingValueList(OFF_ON_LIST, OFF_ON_LIST[_settings.enc])) basic.append(rs) rs = RadioSetting( "wait_back_light", "Wait back light (LED)", RadioSettingValueList(BACKLIGHT_LIST, BACKLIGHT_LIST[_settings.wait_back_light])) basic.append(rs) return top
def get_settings(self): _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 _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 _dtmf_strings = self._memobj.dtmf_strings _passwd = self._memobj.passwd repeater = RadioSettingGroup("repeater", "Repeater Settings") ctcss = RadioSettingGroup("ctcss", "CTCSS/DCS/EPCS Settings") arts = RadioSettingGroup("arts", "ARTS Settings") mbls = RadioSettingGroup("banks", "Memory Settings") scan = RadioSettingGroup("scan", "Scan Settings") dtmf = RadioSettingGroup("dtmf", "DTMF Settings") wires = RadioSettingGroup("wires", "WiRES(tm) Settings") switch = RadioSettingGroup("switch", "Switch/Knob Settings") disp = RadioSettingGroup("disp", "Display Settings") misc = RadioSettingGroup("misc", "Miscellaneous Settings") setmode = RadioSettings(repeater, ctcss, arts, mbls, scan, dtmf, wires, switch, disp, misc) # numbers and names of settings refer to the way they're # presented in the set menu, as well as the list starting on # page 74 of the manual # 1 APO opts = ["Off", "30 Min", "1 Hour", "3 Hour", "5 Hour", "8 Hour"] misc.append( RadioSetting("apo", "Automatic Power Off", RadioSettingValueList(opts, opts[_settings.apo]))) # 2 AR.BEP opts = ["Off", "In Range", "Always"] arts.append( RadioSetting( "arts_beep", "ARTS Beep", RadioSettingValueList(opts, opts[_settings.arts_beep]))) # 3 AR.INT opts = ["15 Sec", "25 Sec"] arts.append( RadioSetting( "arts_interval", "ARTS Polling Interval", RadioSettingValueList(opts, opts[_settings.arts_interval]))) # 4 ARS opts = ["Off", "On"] repeater.append( RadioSetting("ars", "Automatic Repeater Shift", RadioSettingValueList(opts, opts[_settings.ars]))) # 5 BCLO opts = ["Off", "On"] misc.append( RadioSetting( "busy_lockout", "Busy Channel Lock-Out", RadioSettingValueList(opts, opts[_settings.busy_lockout]))) # 6 BEEP opts = ["Off", "Key+Scan", "Key"] switch.append( RadioSetting("beep", "Enable the Beeper", RadioSettingValueList(opts, opts[_settings.beep]))) # 7 BELL opts = ["Off", "1", "3", "5", "8", "Continuous"] ctcss.append( RadioSetting("bell", "Bell Repetitions", RadioSettingValueList(opts, opts[_settings.bell]))) # 8 BNK.LNK for i in range(0, 8): opts = ["Off", "On"] mbs = (self._memobj.mbs >> i) & 1 rs = RadioSetting("mbs%i" % i, "Bank %s Scan" % (i + 1), RadioSettingValueList(opts, opts[mbs])) def apply_mbs(s, index): if int(s.value): self._memobj.mbs |= (1 << index) else: self._memobj.mbs &= ~(1 << index) rs.set_apply_callback(apply_mbs, i) mbls.append(rs) # 9 BNK.NM - A per-bank attribute, nothing to do here. # 10 CLK.SFT - A per-channel attribute, nothing to do here. # 11 CW.ID opts = ["Off", "On"] arts.append( RadioSetting("cw_id", "CW ID Enable", RadioSettingValueList(opts, opts[_settings.cw_id]))) cw_id_text = "" for i in _settings.cw_id_string: try: cw_id_text += CHARSET[i & 0x7F] except IndexError: if i != 0xff: LOG.debug("unknown char index in cw id: %x " % (i)) val = RadioSettingValueString(0, 16, cw_id_text, True) val.set_charset(CHARSET + "abcdefghijklmnopqrstuvwxyz") rs = RadioSetting("cw_id_string", "CW Identifier Text", val) def apply_cw_id(s): str = s.value.get_value().upper().rstrip() mval = "" mval = [chr(CHARSET.index(x)) for x in str] for x in range(len(mval), 16): mval.append(chr(0xff)) for x in range(0, 16): _settings.cw_id_string[x] = ord(mval[x]) rs.set_apply_callback(apply_cw_id) arts.append(rs) # 12 CWTRNG opts = [ "Off", "4WPM", "5WPM", "6WPM", "7WPM", "8WPM", "9WPM", "10WPM", "11WPM", "12WPM", "13WPM", "15WPM", "17WPM", "20WPM", "24WPM", "30WPM", "40WPM" ] misc.append( RadioSetting("cw_trng", "CW Training", RadioSettingValueList(opts, opts[_settings.cw_trng]))) # todo: make the setting of the units here affect the display # of the speed. Not critical, but would be slick. opts = ["CPM", "WPM"] misc.append( RadioSetting( "cw_trng_units", "CW Training Units", RadioSettingValueList(opts, opts[_settings.cw_trng_units]))) # 13 DC VLT - a read-only status, so nothing to do here # 14 DCS CD - A per-channel attribute, nothing to do here # 15 DCS.RV opts = ["Disabled", "Enabled"] ctcss.append( RadioSetting( "inverted_dcs", "\"Inverted\" DCS Code Decoding", RadioSettingValueList(opts, opts[_settings.inverted_dcs]))) # 16 DIMMER opts = ["Off"] + ["Level %d" % (x) for x in range(1, 11)] disp.append( RadioSetting("dimmer", "Dimmer", RadioSettingValueList(opts, opts[_settings.dimmer]))) # 17 DT.A/M opts = ["Manual", "Auto"] dtmf.append( RadioSetting( "dtmf_mode", "DTMF Autodialer", RadioSettingValueList(opts, opts[_settings.dtmf_mode]))) # 18 DT.DLY opts = ["50 ms", "250 ms", "450 ms", "750 ms", "1000 ms"] dtmf.append( RadioSetting( "dtmf_delay", "DTMF Autodialer Delay Time", RadioSettingValueList(opts, opts[_settings.dtmf_delay]))) # 19 DT.SET for memslot in range(0, 10): dtmf_memory = "" for i in _dtmf_strings[memslot].dtmf_string: if i != 0xFF: try: dtmf_memory += CHARSET[i] except IndexError: LOG.debug("unknown char index in dtmf: %x " % (i)) val = RadioSettingValueString(0, 16, dtmf_memory, True) val.set_charset(CHARSET + "abcdef") rs = RadioSetting("dtmf_string_%d" % memslot, "DTMF Memory %d" % memslot, val) def apply_dtmf(s, i): LOG.debug("applying dtmf for %x\n" % i) str = s.value.get_value().upper().rstrip() LOG.debug("str is %s\n" % str) mval = "" mval = [chr(CHARSET.index(x)) for x in str] for x in range(len(mval), 16): mval.append(chr(0xff)) for x in range(0, 16): _dtmf_strings[i].dtmf_string[x] = ord(mval[x]) rs.set_apply_callback(apply_dtmf, memslot) dtmf.append(rs) # 20 DT.SPD opts = ["50 ms", "100 ms"] dtmf.append( RadioSetting( "dtmf_speed", "DTMF Autodialer Sending Speed", RadioSettingValueList(opts, opts[_settings.dtmf_speed]))) # 21 EDG.BEP opts = ["Off", "On"] mbls.append( RadioSetting( "edge_beep", "Band Edge Beeper", RadioSettingValueList(opts, opts[_settings.edge_beep]))) # 22 INT.CD opts = ["DTMF %X" % (x) for x in range(0, 16)] wires.append( RadioSetting("int_cd", "Access Number for WiRES(TM)", RadioSettingValueList(opts, opts[_settings.int_cd]))) # 23 ING MD opts = ["Sister Radio Group", "Friends Radio Group"] wires.append( RadioSetting( "wires_mode", "Internet Link Connection Mode", RadioSettingValueList(opts, opts[_settings.wires_mode]))) # 24 INT.A/M opts = ["Manual", "Auto"] wires.append( RadioSetting( "wires_auto", "Internet Link Autodialer", RadioSettingValueList(opts, opts[_settings.wires_auto]))) # 25 INT.SET opts = ["F%d" % (x) for x in range(0, 10)] wires.append( RadioSetting("int_set", "Memory Register for " "non-WiRES Internet", RadioSettingValueList(opts, opts[_settings.int_set]))) # 26 LOCK opts = [ "Key", "Dial", "Key + Dial", "PTT", "Key + PTT", "Dial + PTT", "All" ] switch.append( RadioSetting("lock", "Control Locking", RadioSettingValueList(opts, opts[_settings.lock]))) # 27 MCGAIN opts = ["Level %d" % (x) for x in range(1, 10)] misc.append( RadioSetting("mic_gain", "Microphone Gain", RadioSettingValueList(opts, opts[_settings.mic_gain]))) # 28 MEM.SCN opts = ["Tag 1", "Tag 2", "All Channels"] rs = RadioSetting( "scan_mode", "Memory Scan Mode", RadioSettingValueList(opts, opts[_settings.scan_mode - 1])) # this setting is unusual in that it starts at 1 instead of 0. # that is, index 1 corresponds to "Tag 1", and index 0 is invalid. # so we create a custom callback to handle this. def apply_scan_mode(s): myopts = ["Tag 1", "Tag 2", "All Channels"] _settings.scan_mode = myopts.index(s.value.get_value()) + 1 rs.set_apply_callback(apply_scan_mode) mbls.append(rs) # 29 MW MD opts = ["Lower", "Next"] mbls.append( RadioSetting("mw_mode", "Memory Write Mode", RadioSettingValueList(opts, opts[_settings.mw_mode]))) # 30 NM SET - This is per channel, so nothing to do here # 31 OPN.MSG opts = ["Off", "DC Supply Voltage", "Text Message"] disp.append( RadioSetting("open_msg", "Opening Message Type", RadioSettingValueList(opts, opts[_settings.open_msg]))) openmsg = "" for i in _settings.openMsg_Text: try: openmsg += CHARSET[i & 0x7F] except IndexError: if i != 0xff: LOG.debug("unknown char index in openmsg: %x " % (i)) val = RadioSettingValueString(0, 6, openmsg, True) val.set_charset(CHARSET + "abcdefghijklmnopqrstuvwxyz") rs = RadioSetting("openMsg_Text", "Opening Message Text", val) def apply_openmsg(s): str = s.value.get_value().upper().rstrip() mval = "" mval = [chr(CHARSET.index(x)) for x in str] for x in range(len(mval), 6): mval.append(chr(0xff)) for x in range(0, 6): _settings.openMsg_Text[x] = ord(mval[x]) rs.set_apply_callback(apply_openmsg) disp.append(rs) # 32 PAGER - a per-channel attribute # 33 PAG.ABK opts = ["Off", "On"] ctcss.append( RadioSetting("pag_abk", "Paging Answer Back", RadioSettingValueList(opts, opts[_settings.pag_abk]))) # 34 PAG.CDR opts = ["%2.2d" % (x) for x in range(1, 50)] ctcss.append( RadioSetting( "pag_cdr_1", "Receive Page Code 1", RadioSettingValueList(opts, opts[_settings.pag_cdr_1]))) ctcss.append( RadioSetting( "pag_cdr_2", "Receive Page Code 2", RadioSettingValueList(opts, opts[_settings.pag_cdr_2]))) # 35 PAG.CDT opts = ["%2.2d" % (x) for x in range(1, 50)] ctcss.append( RadioSetting( "pag_cdt_1", "Transmit Page Code 1", RadioSettingValueList(opts, opts[_settings.pag_cdt_1]))) ctcss.append( RadioSetting( "pag_cdt_2", "Transmit Page Code 2", RadioSettingValueList(opts, opts[_settings.pag_cdt_2]))) # Common Button Options button_opts = [ "Squelch Off", "Weather", "Smart Search", "Tone Scan", "Scan", "T Call", "ARTS" ] # 36 PRG P1 opts = button_opts + ["DC Volts"] switch.append( RadioSetting("prog_p1", "P1 Button", RadioSettingValueList(opts, opts[_settings.prog_p1]))) # 37 PRG P2 opts = button_opts + ["Dimmer"] switch.append( RadioSetting("prog_p2", "P2 Button", RadioSettingValueList(opts, opts[_settings.prog_p2]))) # 38 PRG P3 opts = button_opts + ["Mic Gain"] switch.append( RadioSetting("prog_p3", "P3 Button", RadioSettingValueList(opts, opts[_settings.prog_p3]))) # 39 PRG P4 opts = button_opts + ["Skip"] switch.append( RadioSetting("prog_p4", "P4 Button", RadioSettingValueList(opts, opts[_settings.prog_p4]))) # 40 PSWD password = "" for i in _passwd: if i != 0xFF: try: password += CHARSET[i] except IndexError: LOG.debug("unknown char index in password: %x " % (i)) val = RadioSettingValueString(0, 4, password, True) val.set_charset(CHARSET[0:15] + "abcdef ") rs = RadioSetting("passwd", "Password", val) def apply_password(s): str = s.value.get_value().upper().rstrip() mval = "" mval = [chr(CHARSET.index(x)) for x in str] for x in range(len(mval), 4): mval.append(chr(0xff)) for x in range(0, 4): _passwd[x] = ord(mval[x]) rs.set_apply_callback(apply_password) misc.append(rs) # 41 RESUME opts = ["3 Sec", "5 Sec", "10 Sec", "Busy", "Hold"] scan.append( RadioSetting("resume", "Scan Resume Mode", RadioSettingValueList(opts, opts[_settings.resume]))) # 42 RF.SQL opts = ["Off"] + ["S-%d" % (x) for x in range(1, 10)] misc.append( RadioSetting("rf_sql", "RF Squelch Threshold", RadioSettingValueList(opts, opts[_settings.rf_sql]))) # 43 RPT - per channel attribute, nothing to do here # 44 RVRT opts = ["Off", "On"] misc.append( RadioSetting("revert", "Priority Revert", RadioSettingValueList(opts, opts[_settings.revert]))) # 45 S.SRCH opts = ["Single", "Continuous"] misc.append( RadioSetting("s_search", "Smart Search Sweep Mode", RadioSettingValueList(opts, opts[_settings.s_search]))) # 46 SHIFT - per channel setting, nothing to do here # 47 SKIP = per channel setting, nothing to do here # 48 SPLIT - per channel attribute, nothing to do here # 49 SQL.TYP - per channel attribute, nothing to do here # 50 STEP - per channel attribute, nothing to do here # 51 TEMP - read-only status, nothing to do here # 52 TN FRQ - per channel attribute, nothing to do here # 53 TOT opts = ["Off", "1 Min", "3 Min", "5 Min", "10 Min"] misc.append( RadioSetting("tot", "Timeout Timer", RadioSettingValueList(opts, opts[_settings.tot]))) # 54 TS MUT opts = ["Off", "On"] ctcss.append( RadioSetting("ts_mut", "Tone Search Mute", RadioSettingValueList(opts, opts[_settings.ts_mut]))) # 55 TS SPEED opts = ["Fast", "Slow"] ctcss.append( RadioSetting("ts_speed", "Tone Search Scanner Speed", RadioSettingValueList(opts, opts[_settings.ts_speed]))) # 56 VFO.SCN opts = ["+/- 1MHz", "+/- 2MHz", "+/-5MHz", "All"] scan.append( RadioSetting("vfo_scan", "VFO Scanner Width", RadioSettingValueList(opts, opts[_settings.vfo_scan]))) # 57 WX.ALT opts = ["Off", "On"] misc.append( RadioSetting("wx_alert", "Weather Alert Scan", RadioSettingValueList(opts, opts[_settings.wx_alert]))) # 58 WX.VOL opts = ["Normal", "Maximum"] misc.append( RadioSetting( "wx_vol_max", "Weather Alert Volume", RadioSettingValueList(opts, opts[_settings.wx_vol_max]))) # 59 W/N DV - this is a per-channel attribute, nothing to do here return setmode
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic Settings") group = RadioSettings(basic) rs = RadioSetting("ch", "Channel Indication Mode", RadioSettingValueBoolean(_settings.ch)) basic.append(rs) rs = RadioSetting("expand", "Expanded Settings Mode", RadioSettingValueBoolean(_settings.expand)) basic.append(rs) rs = RadioSetting("beep", "Beep Tones", RadioSettingValueBoolean(_settings.beep)) basic.append(rs) rs = RadioSetting( "autorp", "Auto Repeater Function", RadioSettingValueList(AUTORP_LIST, AUTORP_LIST[_settings.autorp])) basic.append(rs) rs = RadioSetting("ritfunct", "RIT Runction", RadioSettingValueBoolean(_settings.ritfunct)) basic.append(rs) rs = RadioSetting("rit", "RIT Shift (KHz)", RadioSettingValueInteger(-7, 7, _settings.rit)) basic.append(rs) rs = RadioSetting("lock", "Lock", RadioSettingValueBoolean(_settings.lock)) basic.append(rs) rs = RadioSetting( "lockgroup", "Lock Group", RadioSettingValueList(LOCKGROUP_LIST, LOCKGROUP_LIST[_settings.lockgroup])) basic.append(rs) rs = RadioSetting( "squelch", "Squelch", RadioSettingValueList(SQUELCH_LIST, SQUELCH_LIST[_settings.squelch])) basic.append(rs) rs = RadioSetting( "monitor", "Monitor Switch Function", RadioSettingValueList(MONITOR_LIST, MONITOR_LIST[_settings.monitor])) basic.append(rs) rs = RadioSetting( "light", "Display Backlighting", RadioSettingValueList(LIGHT_LIST, LIGHT_LIST[_settings.light])) basic.append(rs) rs = RadioSetting( "priority", "Priority Watch Operation", RadioSettingValueList(PRIORITY_LIST, PRIORITY_LIST[_settings.priority])) basic.append(rs) rs = RadioSetting("p_scan", "Frequency Skip Function", RadioSettingValueBoolean(_settings.p_scan)) basic.append(rs) rs = RadioSetting( "bnk_scan", "Memory Bank Scan Selection", RadioSettingValueList(BANKSCAN_LIST, BANKSCAN_LIST[_settings.bnk_scan])) basic.append(rs) rs = RadioSetting( "edge", "Band Edge Scan Selection", RadioSettingValueList(EDGE_LIST, EDGE_LIST[_settings.edge])) basic.append(rs) rs = RadioSetting( "pause", "Scan Pause Time", RadioSettingValueList(PAUSE_LIST, PAUSE_LIST[_settings.pause])) basic.append(rs) rs = RadioSetting( "resume", "Scan Resume Time", RadioSettingValueList(RESUME_LIST, RESUME_LIST[_settings.resume])) basic.append(rs) rs = RadioSetting("p_save", "Power Saver", RadioSettingValueBoolean(_settings.p_save)) basic.append(rs) rs = RadioSetting( "ap_off", "Auto Power-off Function", RadioSettingValueList(APOFF_LIST, APOFF_LIST[_settings.ap_off])) basic.append(rs) rs = RadioSetting("speed", "Dial Speed Acceleration", RadioSettingValueBoolean(_settings.speed)) basic.append(rs) rs = RadioSetting( "d_sel", "Dial Select Step", RadioSettingValueList(D_SEL_LIST, D_SEL_LIST[_settings.d_sel])) basic.append(rs) return group
def _get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic Settings") advanced = RadioSettingGroup("advanced", "Advanced Settings") group = RadioSettings(basic, advanced) rs = RadioSetting("squelch", "Carrier Squelch Level", RadioSettingValueInteger(0, 9, _settings.squelch)) basic.append(rs) rs = RadioSetting("save", "Battery Saver", RadioSettingValueInteger(0, 4, _settings.save)) basic.append(rs) rs = RadioSetting("abr", "Backlight", RadioSettingValueBoolean(_settings.abr)) basic.append(rs) rs = RadioSetting("tdr", "Dual Watch (BDR)", RadioSettingValueBoolean(_settings.tdr)) advanced.append(rs) rs = RadioSetting("tdrab", "Dual Watch TX Priority", RadioSettingValueList( uv5r.TDRAB_LIST, uv5r.TDRAB_LIST[_settings.tdrab])) advanced.append(rs) rs = RadioSetting("alarm", "Alarm", RadioSettingValueBoolean(_settings.alarm)) advanced.append(rs) rs = RadioSetting("beep", "Beep", RadioSettingValueBoolean(_settings.beep)) basic.append(rs) rs = RadioSetting("timeout", "Timeout Timer", RadioSettingValueList( uv5r.TIMEOUT_LIST, uv5r.TIMEOUT_LIST[_settings.timeout])) basic.append(rs) rs = RadioSetting("screv", "Scan Resume", RadioSettingValueList( uv5r.RESUME_LIST, uv5r.RESUME_LIST[_settings.screv])) advanced.append(rs) rs = RadioSetting("mdfa", "Display Mode (A)", RadioSettingValueList( uv5r.MODE_LIST, uv5r.MODE_LIST[_settings.mdfa])) basic.append(rs) rs = RadioSetting("mdfb", "Display Mode (B)", RadioSettingValueList( uv5r.MODE_LIST, uv5r.MODE_LIST[_settings.mdfb])) basic.append(rs) rs = RadioSetting("bcl", "Busy Channel Lockout", RadioSettingValueBoolean(_settings.bcl)) advanced.append(rs) rs = RadioSetting("autolk", "Automatic Key Lock", RadioSettingValueBoolean(_settings.autolk)) advanced.append(rs) rs = RadioSetting("fmradio", "Broadcast FM Radio", RadioSettingValueBoolean(_settings.fmradio)) advanced.append(rs) rs = RadioSetting("wtled", "Standby LED Color", RadioSettingValueList( COLOR_LIST, COLOR_LIST[_settings.wtled])) basic.append(rs) rs = RadioSetting("rxled", "RX LED Color", RadioSettingValueList( COLOR_LIST, COLOR_LIST[_settings.rxled])) basic.append(rs) rs = RadioSetting("txled", "TX LED Color", RadioSettingValueList( COLOR_LIST, COLOR_LIST[_settings.txled])) basic.append(rs) rs = RadioSetting("reset", "RESET Menu", RadioSettingValueBoolean(_settings.reset)) advanced.append(rs) rs = RadioSetting("menu", "All Menus", RadioSettingValueBoolean(_settings.menu)) advanced.append(rs) if len(self._mmap.get_packed()) == 0x1808: # Old image, without aux block return group other = RadioSettingGroup("other", "Other Settings") group.append(other) def _filter(name): filtered = "" for char in str(name): if char in chirp_common.CHARSET_ASCII: filtered += char else: filtered += " " return filtered _msg = self._memobj.poweron_msg rs = RadioSetting("poweron_msg.line1", "Power-On Message 1", RadioSettingValueString(0, 7, _filter(_msg.line1))) other.append(rs) rs = RadioSetting("poweron_msg.line2", "Power-On Message 2", RadioSettingValueString(0, 7, _filter(_msg.line2))) other.append(rs) limit = "limits" vhf_limit = getattr(self._memobj, limit).vhf rs = RadioSetting("%s.vhf.lower" % limit, "VHF Lower Limit (MHz)", RadioSettingValueInteger( 1, 1000, vhf_limit.lower)) other.append(rs) rs = RadioSetting("%s.vhf.upper" % limit, "VHF Upper Limit (MHz)", RadioSettingValueInteger( 1, 1000, vhf_limit.upper)) other.append(rs) rs = RadioSetting("%s.vhf.enable" % limit, "VHF TX Enabled", RadioSettingValueBoolean(vhf_limit.enable)) other.append(rs) uhf_limit = getattr(self._memobj, limit).uhf rs = RadioSetting("%s.uhf.lower" % limit, "UHF Lower Limit (MHz)", RadioSettingValueInteger( 1, 1000, uhf_limit.lower)) other.append(rs) rs = RadioSetting("%s.uhf.upper" % limit, "UHF Upper Limit (MHz)", RadioSettingValueInteger( 1, 1000, uhf_limit.upper)) other.append(rs) rs = RadioSetting("%s.uhf.enable" % limit, "UHF TX Enabled", RadioSettingValueBoolean(uhf_limit.enable)) other.append(rs) workmode = RadioSettingGroup("workmode", "Work Mode Settings") group.append(workmode) options = ["A", "B"] rs = RadioSetting("displayab", "Display Selected", RadioSettingValueList( options, options[_settings.displayab])) workmode.append(rs) options = ["Frequency", "Channel"] rs = RadioSetting("workmode", "VFO/MR Mode", RadioSettingValueList( options, options[_settings.workmode])) workmode.append(rs) rs = RadioSetting("keylock", "Keypad Lock", RadioSettingValueBoolean(_settings.keylock)) workmode.append(rs) _mrcna = self._memobj.wmchannel.mrcha rs = RadioSetting("wmchannel.mrcha", "MR A Channel", RadioSettingValueInteger(0, 127, _mrcna)) workmode.append(rs) _mrcnb = self._memobj.wmchannel.mrchb rs = RadioSetting("wmchannel.mrchb", "MR B Channel", RadioSettingValueInteger(0, 127, _mrcnb)) workmode.append(rs) def convert_bytes_to_freq(bytes): real_freq = 0 for byte in bytes: real_freq = (real_freq * 10) + byte return chirp_common.format_freq(real_freq * 10) def my_validate(value): value = chirp_common.parse_freq(value) if 17400000 <= value and value < 40000000: raise InvalidValueError("Can't be between 174.00000-400.00000") return chirp_common.format_freq(value) def apply_freq(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 10 obj.band = value >= 40000000 for i in range(7, -1, -1): obj.freq[i] = value % 10 value /= 10 val1a = RadioSettingValueString( 0, 10, convert_bytes_to_freq(self._memobj.vfoa.freq)) val1a.set_validate_callback(my_validate) rs = RadioSetting("vfoa.freq", "VFO A Frequency", val1a) rs.set_apply_callback(apply_freq, self._memobj.vfoa) workmode.append(rs) val1b = RadioSettingValueString( 0, 10, convert_bytes_to_freq(self._memobj.vfob.freq)) val1b.set_validate_callback(my_validate) rs = RadioSetting("vfob.freq", "VFO B Frequency", val1b) rs.set_apply_callback(apply_freq, self._memobj.vfob) workmode.append(rs) options = ["Off", "+", "-"] rs = RadioSetting("vfoa.sftd", "VFO A Shift", RadioSettingValueList( options, options[self._memobj.vfoa.sftd])) workmode.append(rs) rs = RadioSetting("vfob.sftd", "VFO B Shift", RadioSettingValueList( options, options[self._memobj.vfob.sftd])) workmode.append(rs) def convert_bytes_to_offset(bytes): real_offset = 0 for byte in bytes: real_offset = (real_offset * 10) + byte return chirp_common.format_freq(real_offset * 10000) def apply_offset(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 10000 for i in range(3, -1, -1): obj.offset[i] = value % 10 value /= 10 val1a = RadioSettingValueString( 0, 10, convert_bytes_to_offset(self._memobj.vfoa.offset)) rs = RadioSetting("vfoa.offset", "VFO A Offset (0.00-69.95)", val1a) rs.set_apply_callback(apply_offset, self._memobj.vfoa) workmode.append(rs) val1b = RadioSettingValueString( 0, 10, convert_bytes_to_offset(self._memobj.vfob.offset)) rs = RadioSetting("vfob.offset", "VFO B Offset (0.00-69.95)", val1b) rs.set_apply_callback(apply_offset, self._memobj.vfob) workmode.append(rs) options = ["High", "Low"] rs = RadioSetting("vfoa.txpower", "VFO A Power", RadioSettingValueList( options, options[self._memobj.vfoa.txpower])) workmode.append(rs) rs = RadioSetting("vfob.txpower", "VFO B Power", RadioSettingValueList( options, options[self._memobj.vfob.txpower])) workmode.append(rs) options = ["Wide", "Narrow"] rs = RadioSetting("vfoa.widenarr", "VFO A Bandwidth", RadioSettingValueList( options, options[self._memobj.vfoa.widenarr])) workmode.append(rs) rs = RadioSetting("vfob.widenarr", "VFO B Bandwidth", RadioSettingValueList( options, options[self._memobj.vfob.widenarr])) workmode.append(rs) options = ["%s" % x for x in range(1, 16)] rs = RadioSetting("vfoa.scode", "VFO A PTT-ID", RadioSettingValueList( options, options[self._memobj.vfoa.scode])) workmode.append(rs) rs = RadioSetting("vfob.scode", "VFO B PTT-ID", RadioSettingValueList( options, options[self._memobj.vfob.scode])) workmode.append(rs) rs = RadioSetting("vfoa.step", "VFO A Tuning Step", RadioSettingValueList( STEP_LIST, STEP_LIST[self._memobj.vfoa.step])) workmode.append(rs) rs = RadioSetting("vfob.step", "VFO B Tuning Step", RadioSettingValueList( STEP_LIST, STEP_LIST[self._memobj.vfob.step])) workmode.append(rs) fm_preset = RadioSettingGroup("fm_preset", "FM Radio Preset") group.append(fm_preset) preset = self._memobj.fm_preset / 10.0 + 87 rs = RadioSetting("fm_preset", "FM Preset(MHz)", RadioSettingValueFloat(87, 107.5, preset, 0.1, 1)) fm_preset.append(rs) dtmf = RadioSettingGroup("dtmf", "DTMF Settings") group.append(dtmf) dtmfchars = "0123456789 *#ABCD" for i in range(0, 15): _codeobj = self._memobj.pttid[i].code _code = "".join([dtmfchars[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 5, _code, False) val.set_charset(dtmfchars) rs = RadioSetting("pttid/%i.code" % i, "PTT ID Code %i" % (i + 1), val) def apply_code(setting, obj): code = [] for j in range(0, 5): try: code.append(dtmfchars.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.code = code rs.set_apply_callback(apply_code, self._memobj.pttid[i]) dtmf.append(rs) _codeobj = self._memobj.ani.code _code = "".join([dtmfchars[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 5, _code, False) val.set_charset(dtmfchars) rs = RadioSetting("ani.code", "ANI Code", val) def apply_code(setting, obj): code = [] for j in range(0, 5): try: code.append(dtmfchars.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.code = code rs.set_apply_callback(apply_code, self._memobj.ani) dtmf.append(rs) options = ["Off", "BOT", "EOT", "Both"] rs = RadioSetting("ani.aniid", "ANI ID", RadioSettingValueList( options, options[self._memobj.ani.aniid])) dtmf.append(rs) _codeobj = self._memobj.ani.alarmcode _code = "".join([dtmfchars[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 5, _code, False) val.set_charset(dtmfchars) rs = RadioSetting("ani.alarmcode", "Alarm Code", val) def apply_code(setting, obj): alarmcode = [] for j in range(5): try: alarmcode.append(dtmfchars.index(str(setting.value)[j])) except IndexError: alarmcode.append(0xFF) obj.alarmcode = alarmcode rs.set_apply_callback(apply_code, self._memobj.ani) dtmf.append(rs) rs = RadioSetting("dtmfst", "DTMF Sidetone", RadioSettingValueList( uv5r.DTMFST_LIST, uv5r.DTMFST_LIST[_settings.dtmfst])) dtmf.append(rs) rs = RadioSetting("ani.dtmfon", "DTMF Speed (on)", RadioSettingValueList( uv5r.DTMFSPEED_LIST, uv5r.DTMFSPEED_LIST[self._memobj.ani.dtmfon])) dtmf.append(rs) rs = RadioSetting("ani.dtmfoff", "DTMF Speed (off)", RadioSettingValueList( uv5r.DTMFSPEED_LIST, uv5r.DTMFSPEED_LIST[self._memobj.ani.dtmfoff])) dtmf.append(rs) return group