def get_settings(self): """Translate the bit in the mem_struct into settings in the UI""" sett = self._memobj.settings # basic features of the radio basic = RadioSettingGroup("basic", "Basic Settings") # keys fkeys = RadioSettingGroup("keys", "Function keys") top = RadioSettings(basic, fkeys) # Basic val = RadioSettingValueString(0, 35, self._VARIANT) val.set_mutable(False) mod = RadioSetting("not.mod", "Radio version", val) basic.append(mod) beep = RadioSetting("settings.beep", "Beep tone", RadioSettingValueBoolean(bool(sett.beep))) basic.append(beep) bsave = RadioSetting("settings.batt_save", "Battery save", RadioSettingValueBoolean(bool(sett.batt_save))) basic.append(bsave) deal = RadioSetting("settings.dealer", "Dealer & Test", RadioSettingValueBoolean(bool(sett.dealer))) basic.append(deal) add = RadioSetting("settings.add", "Del / Add feature", RadioSettingValueBoolean(bool(sett.add))) basic.append(add) # In some cases the values that follows can be 0xFF (HARD RESET) # so we need to take and validate that if int(sett.tot) == 0xff: # 120 sec sett.tot = 4 if int(sett.tot_alert) == 0xff: # 10 secs sett.tot_alert = 1 if int(sett.tot_rekey) == 0xff: # off sett.tot_rekey = 0 if int(sett.tot_reset) == 0xff: # off sett.tot_reset = 0 if int(sett.sql) == 0xff: # a confortable level ~6 sett.sql = 6 tot = RadioSetting("settings.tot", "Time Out Timer (TOT)", RadioSettingValueList(TOT, TOT[int(sett.tot)])) basic.append(tot) tota = RadioSetting( "settings.tot_alert", "TOT pre-plert", RadioSettingValueList(TOT_A, TOT_A[int(sett.tot_alert)])) basic.append(tota) totrk = RadioSetting( "settings.tot_rekey", "TOT rekey time", RadioSettingValueList(TOT_RK, TOT_RK[int(sett.tot_rekey)])) basic.append(totrk) totrs = RadioSetting( "settings.tot_reset", "TOT reset time", RadioSettingValueList(TOT_RS, TOT_RS[int(sett.tot_reset)])) basic.append(totrs) sql = RadioSetting("settings.sql", "Squelch level", RadioSettingValueList(SQL, SQL[int(sett.sql)])) basic.append(sql) # front keys m = int(sett.kMoni) if m > 3: m = 1 mon = RadioSetting("settings.kMoni", "Monitor", RadioSettingValueList(MONI, MONI[m])) fkeys.append(mon) s = int(sett.kScan) if s > 3: s = 1 scn = RadioSetting("settings.kScan", "Scan", RadioSettingValueList(SCAN, SCAN[s])) fkeys.append(scn) d = int(sett.kDial) if d > 1: d = 0 dial = RadioSetting("settings.kDial", "Dial", RadioSettingValueList(YESNO, YESNO[d])) fkeys.append(dial) t = int(sett.kTa) if t > 2: t = 2 ta = RadioSetting("settings.kTa", "Ta", RadioSettingValueList(TA, TA[t])) fkeys.append(ta) l = int(sett.kLo) if l > 1: l = 0 low = RadioSetting("settings.kLo", "Low", RadioSettingValueList(YESNO, YESNO[l])) fkeys.append(low) return top
def get_memory(self, number): LOG.debug("Getting %i" % number) f = self._classes["mem"]() if self._rf.has_bank: ch, bnk = self.mem_to_ch_bnk(number) f.set_location(ch, bnk) LOG.debug("Bank %i, Channel %02i" % (bnk, ch)) else: f.set_location(number) self._send_frame(f) mem = chirp_common.Memory() mem.number = number mem.immutable = [] f = self._recv_frame(f) if len(f.get_data()) == 0: raise errors.RadioError("Radio reported error") if f.get_data() and f.get_data()[-1] == "\xFF": mem.empty = True LOG.debug("Found %i empty" % mem.number) return mem memobj = f.get_obj() LOG.debug(repr(memobj)) try: if memobj.skip == 1: mem.skip = "" else: mem.skip = "S" except AttributeError: pass mem.freq = int(memobj.freq) try: mem.mode = self._MODES[memobj.mode] # We do not know what a variety of the positions between # PSK and DV mean, so let's behave as if those values # are not set to maintain consistency between known-unknown # values and unknown-unknown ones. if mem.mode is None: raise IndexError(memobj.mode) except IndexError: LOG.error( "Bank %s location %s is set for mode %s, but no known " "mode matches that value.", int(memobj.bank), int(memobj.number), repr(memobj.mode), ) raise if self._rf.has_name: mem.name = str(memobj.name).rstrip() if self._rf.valid_tmodes: mem.tmode = self._rf.valid_tmodes[memobj.tmode] if self._rf.has_dtcs_polarity: if memobj.dtcs_polarity == 0x11: mem.dtcs_polarity = "RR" elif memobj.dtcs_polarity == 0x10: mem.dtcs_polarity = "RN" elif memobj.dtcs_polarity == 0x01: mem.dtcs_polarity = "NR" else: mem.dtcs_polarity = "NN" if self._rf.has_dtcs: mem.dtcs = bitwise.bcd_to_int(memobj.dtcs) if "Tone" in self._rf.valid_tmodes: mem.rtone = int(memobj.rtone) / 10.0 if "TSQL" in self._rf.valid_tmodes and self._rf.has_ctone: mem.ctone = int(memobj.ctone) / 10.0 if self._rf.valid_duplexes: mem.duplex = self._rf.valid_duplexes[memobj.duplex] if self._rf.can_odd_split and memobj.spl: mem.duplex = "split" mem.offset = int(memobj.freq_tx) mem.immutable = [] else: mem.immutable = ["offset"] mem.extra = RadioSettingGroup("extra", "Extra") try: dig = RadioSetting("dig", "Digital", RadioSettingValueBoolean(bool(memobj.dig))) except AttributeError: pass else: dig.set_doc("Enable digital mode") mem.extra.append(dig) options = ["Wide", "Mid", "Narrow"] try: fil = RadioSetting( "filter", "Filter", RadioSettingValueList(options, options[memobj.filter - 1])) except AttributeError: pass else: fil.set_doc("Filter settings") mem.extra.append(fil) return mem
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): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic") dtmf = RadioSettingGroup("dtmf", "DTMF Code & Paging") arts = RadioSettingGroup("arts", "ARTS") autodial = RadioSettingGroup("autodial", "AutoDial") top = RadioSettings(basic, autodial, arts, dtmf) rs = RadioSetting("squelch", "Squelch", RadioSettingValueInteger(0, 15, _settings.squelch)) basic.append(rs) rs = RadioSetting("keybeep", "Keypad Beep", RadioSettingValueBoolean(_settings.keybeep)) basic.append(rs) rs = RadioSetting("scnl", "Scan Lamp", RadioSettingValueBoolean(_settings.scnl)) basic.append(rs) options = ["off", "30m", "1h", "3h", "5h", "8h"] rs = RadioSetting( "apo", "APO time (hrs)", RadioSettingValueList(options, options[_settings.apo])) basic.append(rs) options = ["off", "1m", "2.5m", "5m", "10m"] rs = RadioSetting( "timeout", "Time Out Timer", RadioSettingValueList(options, options[_settings.timeout])) basic.append(rs) options = [ "key", "dial", "key+dial", "ptt", "key+ptt", "dial+ptt", "all" ] rs = RadioSetting( "lock", "Lock mode", RadioSettingValueList(options, options[_settings.lock])) basic.append(rs) options = ["off", "0.2", "0.3", "0.5", "1.0", "2.0"] rs = RadioSetting( "rxsave", "RX Save (sec)", RadioSettingValueList(options, options[_settings.rxsave])) basic.append(rs) options = ["5sec", "key", "tgl"] rs = RadioSetting( "lamp", "Lamp mode", RadioSettingValueList(options, options[_settings.lamp])) basic.append(rs) options = ["off", "1", "3", "5", "8", "rpt"] rs = RadioSetting( "bell", "Bell Repetitions", RadioSettingValueList(options, options[_settings.bell])) basic.append(rs) rs = RadioSetting("cwid_en", "CWID Enable", RadioSettingValueBoolean(_settings.cwid_en)) arts.append(rs) cwid = RadioSettingValueString( 0, 16, self._decode_cwid(_settings.cwid.get_value())) cwid.set_charset(CHARSET) rs = RadioSetting("cwid", "CWID", cwid) arts.append(rs) options = ["off", "rx", "tx", "trx"] rs = RadioSetting( "artsmode", "ARTS Mode", RadioSettingValueList(options, options[_settings.artsmode])) arts.append(rs) options = ["off", "in range", "always"] rs = RadioSetting( "artsbeep", "ARTS Beep", RadioSettingValueList(options, options[_settings.artsbeep])) arts.append(rs) for i in range(0, 8): dialsettings = _settings.autodial[i] dialstr = "" for c in dialsettings.digits: if c < len(DTMFCHARSET): dialstr += DTMFCHARSET[c] dialentry = RadioSettingValueString(0, 16, dialstr) dialentry.set_charset(DTMFCHARSET + list(" ")) rs = RadioSetting("autodial" + str(i + 1), "AutoDial " + str(i + 1), dialentry) autodial.append(rs) dialstr = "" for c in _settings.autodial9_ro.digits: if c < len(DTMFCHARSET): dialstr += DTMFCHARSET[c] dialentry = RadioSettingValueString(0, 32, dialstr) dialentry.set_mutable(False) rs = RadioSetting("autodial9_ro", "AutoDial 9 (read only)", dialentry) autodial.append(rs) options = ["50ms", "100ms"] rs = RadioSetting( "pagingspeed", "Paging Speed", RadioSettingValueList(options, options[_settings.pagingspeed])) dtmf.append(rs) options = ["250ms", "450ms", "750ms", "1000ms"] rs = RadioSetting( "pagingdelay", "Paging Delay", RadioSettingValueList(options, options[_settings.pagingdelay])) dtmf.append(rs) options = ["off", "1", "3", "5", "8", "rpt"] rs = RadioSetting( "pagingbell", "Paging Bell Repetitions", RadioSettingValueList(options, options[_settings.pagingbell])) dtmf.append(rs) options = ["off", "ans", "for"] rs = RadioSetting( "paginganswer", "Paging Answerback", RadioSettingValueList(options, options[_settings.paginganswer])) dtmf.append(rs) rs = RadioSetting("code_dec_c_en", "Paging Code C Decode Enable", RadioSettingValueBoolean(_settings.code_dec_c_en)) dtmf.append(rs) _str = str(bitwise.bcd_to_int(_settings.pagingcodec_ro)) code = RadioSettingValueString(0, 3, _str) code.set_charset(NUMERIC_CHARSET + list(" ")) code.set_mutable(False) rs = RadioSetting("pagingcodec_ro", "Paging Code C (read only)", code) dtmf.append(rs) rs = RadioSetting("code_dec_p_en", "Paging Code P Decode Enable", RadioSettingValueBoolean(_settings.code_dec_p_en)) dtmf.append(rs) _str = str(bitwise.bcd_to_int(_settings.pagingcodep)) code = RadioSettingValueString(0, 3, _str) code.set_charset(NUMERIC_CHARSET + list(" ")) rs = RadioSetting("pagingcodep", "Paging Code P", code) dtmf.append(rs) for i in range(0, 6): num = str(i + 1) name = "code_dec_" + num + "_en" rs = RadioSetting( name, "Paging Code " + num + " Decode Enable", RadioSettingValueBoolean(getattr(_settings, name))) dtmf.append(rs) _str = str(bitwise.bcd_to_int(_settings.pagingcode[i].digits)) code = RadioSettingValueString(0, 3, _str) code.set_charset(NUMERIC_CHARSET + list(" ")) rs = RadioSetting("pagingcode" + num, "Paging Code " + num, 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): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic Settings") # 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 basic
def get_settings(self): """Translate the bit in the mem_struct into settings in the UI""" _mem = self._memobj basic = RadioSettingGroup("basic", "Basic Settings") advanced = RadioSettingGroup("advanced", "Advanced Settings") other = RadioSettingGroup("other", "Other Settings") work = RadioSettingGroup("work", "Work Mode Settings") fm_preset = RadioSettingGroup("fm_preset", "FM Preset") dtmfe = RadioSettingGroup("dtmfe", "DTMF Encode Settings") dtmfd = RadioSettingGroup("dtmfd", "DTMF Decode Settings") service = RadioSettingGroup("service", "Service Settings") top = RadioSettings(basic, advanced, other, work, fm_preset, dtmfe, dtmfd, service) # Basic settings if _mem.settings.squelch > 0x09: val = 0x00 else: val = _mem.settings.squelch rs = RadioSetting( "settings.squelch", "Squelch", RadioSettingValueList(LIST_OFF1TO9, LIST_OFF1TO9[val])) basic.append(rs) if _mem.settings.save > 0x04: val = 0x00 else: val = _mem.settings.save rs = RadioSetting("settings.save", "Battery Saver", RadioSettingValueList(LIST_SAVE, LIST_SAVE[val])) basic.append(rs) if _mem.settings.vox > 0x0A: val = 0x00 else: val = _mem.settings.vox rs = RadioSetting( "settings.vox", "Vox", RadioSettingValueList(LIST_OFF1TO10, LIST_OFF1TO10[val])) basic.append(rs) if _mem.settings.abr > 0x0A: val = 0x00 else: val = _mem.settings.abr rs = RadioSetting( "settings.abr", "Backlight Timeout", RadioSettingValueList(LIST_OFF1TO10, LIST_OFF1TO10[val])) basic.append(rs) rs = RadioSetting("settings.tdr", "Dual Watch", RadioSettingValueBoolean(_mem.settings.tdr)) basic.append(rs) rs = RadioSetting("settings.beep", "Beep", RadioSettingValueBoolean(_mem.settings.beep)) basic.append(rs) if _mem.settings.timeout > 0x27: val = 0x03 else: val = _mem.settings.timeout rs = RadioSetting( "settings.timeout", "Timeout Timer", RadioSettingValueList(LIST_TIMEOUT, LIST_TIMEOUT[val])) basic.append(rs) if _mem.settings.voice > 0x02: val = 0x01 else: val = _mem.settings.voice rs = RadioSetting("settings.voice", "Voice Prompt", RadioSettingValueList(LIST_VOICE, LIST_VOICE[val])) basic.append(rs) rs = RadioSetting( "settings.dtmfst", "DTMF Sidetone", RadioSettingValueList(LIST_DTMFST, LIST_DTMFST[_mem.settings.dtmfst])) basic.append(rs) if _mem.settings.screv > 0x02: val = 0x01 else: val = _mem.settings.screv rs = RadioSetting("settings.screv", "Scan Resume", RadioSettingValueList(LIST_RESUME, LIST_RESUME[val])) basic.append(rs) rs = RadioSetting( "settings.pttid", "When to send PTT ID", RadioSettingValueList(LIST_PTTID, LIST_PTTID[_mem.settings.pttid])) basic.append(rs) if _mem.settings.pttlt > 0x1E: val = 0x05 else: val = _mem.settings.pttlt rs = RadioSetting("pttlt", "PTT ID Delay", RadioSettingValueInteger(0, 50, val)) basic.append(rs) rs = RadioSetting( "settings.mdfa", "Display Mode (A)", RadioSettingValueList(LIST_MODE, LIST_MODE[_mem.settings.mdfa])) basic.append(rs) rs = RadioSetting( "settings.mdfb", "Display Mode (B)", RadioSettingValueList(LIST_MODE, LIST_MODE[_mem.settings.mdfb])) basic.append(rs) rs = RadioSetting("settings.sync", "Sync A & B", RadioSettingValueBoolean(_mem.settings.sync)) basic.append(rs) rs = RadioSetting( "settings.wtled", "Standby LED Color", RadioSettingValueList(LIST_COLOR, LIST_COLOR[_mem.settings.wtled])) basic.append(rs) rs = RadioSetting( "settings.rxled", "RX LED Color", RadioSettingValueList(LIST_COLOR, LIST_COLOR[_mem.settings.rxled])) basic.append(rs) rs = RadioSetting( "settings.txled", "TX LED Color", RadioSettingValueList(LIST_COLOR, LIST_COLOR[_mem.settings.txled])) basic.append(rs) if _mem.settings.almod > 0x02: val = 0x00 else: val = _mem.settings.almod rs = RadioSetting("settings.almod", "Alarm Mode", RadioSettingValueList(LIST_ALMOD, LIST_ALMOD[val])) basic.append(rs) if _mem.settings.tdrab > 0x02: val = 0x00 else: val = _mem.settings.tdrab rs = RadioSetting("settings.tdrab", "Dual Watch TX Priority", RadioSettingValueList(LIST_OFFAB, LIST_OFFAB[val])) basic.append(rs) rs = RadioSetting("settings.ste", "Squelch Tail Eliminate (HT to HT)", RadioSettingValueBoolean(_mem.settings.ste)) basic.append(rs) if _mem.settings.rpste > 0x0A: val = 0x00 else: val = _mem.settings.rpste rs = RadioSetting("settings.rpste", "Squelch Tail Eliminate (repeater)", RadioSettingValueList(LIST_RPSTE, LIST_RPSTE[val])) basic.append(rs) if _mem.settings.rptrl > 0x0A: val = 0x00 else: val = _mem.settings.rptrl rs = RadioSetting( "settings.rptrl", "STE Repeater Delay", RadioSettingValueList(LIST_STEDELAY, LIST_STEDELAY[val])) basic.append(rs) rs = RadioSetting( "settings.ponmsg", "Power-On Message", RadioSettingValueList(LIST_PONMSG, LIST_PONMSG[_mem.settings.ponmsg])) basic.append(rs) rs = RadioSetting("settings.roger", "Roger Beep", RadioSettingValueBoolean(_mem.settings.roger)) basic.append(rs) rs = RadioSetting("settings.dani", "Decode ANI", RadioSettingValueBoolean(_mem.settings.dani)) basic.append(rs) if _mem.settings.dtmfg > 0x3C: val = 0x14 else: val = _mem.settings.dtmfg rs = RadioSetting("settings.dtmfg", "DTMF Gain", RadioSettingValueInteger(0, 60, val)) basic.append(rs) # Advanced settings rs = RadioSetting("settings.reset", "RESET Menu", RadioSettingValueBoolean(_mem.settings.reset)) advanced.append(rs) rs = RadioSetting("settings.menu", "All Menus", RadioSettingValueBoolean(_mem.settings.menu)) advanced.append(rs) rs = RadioSetting("settings.fmradio", "Broadcast FM Radio", RadioSettingValueBoolean(_mem.settings.fmradio)) advanced.append(rs) rs = RadioSetting("settings.alarm", "Alarm Sound", RadioSettingValueBoolean(_mem.settings.alarm)) advanced.append(rs) # Other settings def _filter(name): filtered = "" for char in str(name): if char in chirp_common.CHARSET_ASCII: filtered += char else: filtered += " " return filtered _msg = _mem.firmware_msg val = RadioSettingValueString(0, 7, _filter(_msg.line1)) val.set_mutable(False) rs = RadioSetting("firmware_msg.line1", "Firmware Message 1", val) other.append(rs) val = RadioSettingValueString(0, 7, _filter(_msg.line2)) val.set_mutable(False) rs = RadioSetting("firmware_msg.line2", "Firmware Message 2", val) other.append(rs) _msg = _mem.sixpoweron_msg val = RadioSettingValueString(0, 7, _filter(_msg.line1)) val.set_mutable(False) rs = RadioSetting("sixpoweron_msg.line1", "6+Power-On Message 1", val) other.append(rs) val = RadioSettingValueString(0, 7, _filter(_msg.line2)) val.set_mutable(False) rs = RadioSetting("sixpoweron_msg.line2", "6+Power-On Message 2", val) other.append(rs) _msg = _mem.poweron_msg rs = RadioSetting("poweron_msg.line1", "Power-On Message 1", RadioSettingValueString(0, 7, _filter(_msg.line1))) other.append(rs) rs = RadioSetting("poweron_msg.line2", "Power-On Message 2", RadioSettingValueString(0, 7, _filter(_msg.line2))) other.append(rs) if str(_mem.firmware_msg.line1) == "UVVG302": lower = 136 upper = 174 else: lower = 130 upper = 179 rs = RadioSetting( "limits.vhf.lower", "VHF Lower Limit (MHz)", RadioSettingValueInteger(lower, upper, _mem.limits.vhf.lower)) other.append(rs) rs = RadioSetting( "limits.vhf.upper", "VHF Upper Limit (MHz)", RadioSettingValueInteger(lower, upper, _mem.limits.vhf.upper)) other.append(rs) if str(_mem.firmware_msg.line1) == "UVVG302": lower = 200 upper = 230 else: lower = 220 upper = 225 rs = RadioSetting( "limits.vhf2.lower", "VHF2 Lower Limit (MHz)", RadioSettingValueInteger(lower, upper, _mem.limits.vhf2.lower)) other.append(rs) rs = RadioSetting( "limits.vhf2.upper", "VHF2 Upper Limit (MHz)", RadioSettingValueInteger(lower, upper, _mem.limits.vhf2.upper)) other.append(rs) if str(_mem.firmware_msg.line1) == "UVVG302": lower = 400 upper = 480 else: lower = 400 upper = 520 rs = RadioSetting( "limits.uhf.lower", "UHF Lower Limit (MHz)", RadioSettingValueInteger(lower, upper, _mem.limits.uhf.lower)) other.append(rs) rs = RadioSetting( "limits.uhf.upper", "UHF Upper Limit (MHz)", RadioSettingValueInteger(lower, upper, _mem.limits.uhf.upper)) other.append(rs) # Work mode settings rs = RadioSetting( "settings.displayab", "Display", RadioSettingValueList(LIST_AB, LIST_AB[_mem.settings.displayab])) work.append(rs) rs = RadioSetting( "settings.workmode", "VFO/MR Mode", RadioSettingValueList(LIST_WORKMODE, LIST_WORKMODE[_mem.settings.workmode])) work.append(rs) rs = RadioSetting("settings.keylock", "Keypad Lock", RadioSettingValueBoolean(_mem.settings.keylock)) work.append(rs) rs = RadioSetting( "wmchannel.mrcha", "MR A Channel", RadioSettingValueInteger(0, 127, _mem.wmchannel.mrcha)) work.append(rs) rs = RadioSetting( "wmchannel.mrchb", "MR B Channel", RadioSettingValueInteger(0, 127, _mem.wmchannel.mrchb)) work.append(rs) def convert_bytes_to_freq(bytes): real_freq = 0 for byte in bytes: real_freq = (real_freq * 10) + byte return chirp_common.format_freq(real_freq * 10) def my_validate(value): _vhf_lower = int(_mem.limits.vhf.lower) _vhf_upper = int(_mem.limits.vhf.upper) _vhf2_lower = int(_mem.limits.vhf2.lower) _vhf2_upper = int(_mem.limits.vhf2.upper) _uhf_lower = int(_mem.limits.uhf.lower) _uhf_upper = int(_mem.limits.uhf.upper) value = chirp_common.parse_freq(value) msg = ("Can't be less than %i.0000") if value > 99000000 and value < _vhf_lower * 1000000: raise InvalidValueError(msg % (_vhf_lower)) msg = ("Can't be between %i.9975-%i.0000") if (_vhf_upper + 1) * 1000000 <= value and \ value < _vhf2_lower * 1000000: raise InvalidValueError(msg % (_vhf_upper, _vhf2_lower)) if (_vhf2_upper + 1) * 1000000 <= value and \ value < _uhf_lower * 1000000: raise InvalidValueError(msg % (_vhf2_upper, _uhf_lower)) msg = ("Can't be greater than %i.9975") if value > 99000000 and value >= (_uhf_upper + 1) * 1000000: raise InvalidValueError(msg % (_uhf_upper)) return chirp_common.format_freq(value) def apply_freq(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 10 for i in range(7, -1, -1): obj.freq[i] = value % 10 value /= 10 val1a = RadioSettingValueString(0, 10, convert_bytes_to_freq(_mem.vfo.a.freq)) val1a.set_validate_callback(my_validate) rs = RadioSetting("vfo.a.freq", "VFO A Frequency", val1a) rs.set_apply_callback(apply_freq, _mem.vfo.a) work.append(rs) val1b = RadioSettingValueString(0, 10, convert_bytes_to_freq(_mem.vfo.b.freq)) val1b.set_validate_callback(my_validate) rs = RadioSetting("vfo.b.freq", "VFO B Frequency", val1b) rs.set_apply_callback(apply_freq, _mem.vfo.b) work.append(rs) rs = RadioSetting( "vfo.a.sftd", "VFO A Shift", RadioSettingValueList(LIST_SHIFTD, LIST_SHIFTD[_mem.vfo.a.sftd])) work.append(rs) rs = RadioSetting( "vfo.b.sftd", "VFO B Shift", RadioSettingValueList(LIST_SHIFTD, LIST_SHIFTD[_mem.vfo.b.sftd])) work.append(rs) def convert_bytes_to_offset(bytes): real_offset = 0 for byte in bytes: real_offset = (real_offset * 10) + byte return chirp_common.format_freq(real_offset * 1000) def apply_offset(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 1000 for i in range(5, -1, -1): obj.offset[i] = value % 10 value /= 10 val1a = RadioSettingValueString( 0, 10, convert_bytes_to_offset(_mem.vfo.a.offset)) rs = RadioSetting("vfo.a.offset", "VFO A Offset", val1a) rs.set_apply_callback(apply_offset, _mem.vfo.a) work.append(rs) val1b = RadioSettingValueString( 0, 10, convert_bytes_to_offset(_mem.vfo.b.offset)) rs = RadioSetting("vfo.b.offset", "VFO B Offset", val1b) rs.set_apply_callback(apply_offset, _mem.vfo.b) work.append(rs) rs = RadioSetting( "vfo.a.txpower", "VFO A Power", RadioSettingValueList(LIST_TXPOWER, LIST_TXPOWER[_mem.vfo.a.txpower])) work.append(rs) rs = RadioSetting( "vfo.b.txpower", "VFO B Power", RadioSettingValueList(LIST_TXPOWER, LIST_TXPOWER[_mem.vfo.b.txpower])) work.append(rs) rs = RadioSetting( "vfo.a.widenarr", "VFO A Bandwidth", RadioSettingValueList(LIST_BANDWIDTH, LIST_BANDWIDTH[_mem.vfo.a.widenarr])) work.append(rs) rs = RadioSetting( "vfo.b.widenarr", "VFO B Bandwidth", RadioSettingValueList(LIST_BANDWIDTH, LIST_BANDWIDTH[_mem.vfo.b.widenarr])) work.append(rs) rs = RadioSetting( "vfo.a.scode", "VFO A S-CODE", RadioSettingValueList(LIST_SCODE, LIST_SCODE[_mem.vfo.a.scode])) work.append(rs) rs = RadioSetting( "vfo.b.scode", "VFO B S-CODE", RadioSettingValueList(LIST_SCODE, LIST_SCODE[_mem.vfo.b.scode])) work.append(rs) rs = RadioSetting( "vfo.a.step", "VFO A Tuning Step", RadioSettingValueList(LIST_STEP, LIST_STEP[_mem.vfo.a.step])) work.append(rs) rs = RadioSetting( "vfo.b.step", "VFO B Tuning Step", RadioSettingValueList(LIST_STEP, LIST_STEP[_mem.vfo.b.step])) work.append(rs) # broadcast FM settings _fm_presets = self._memobj.fm_presets if _fm_presets <= 108.0 * 10 - 650: preset = _fm_presets / 10.0 + 65 elif _fm_presets >= 65.0 * 10 and _fm_presets <= 108.0 * 10: preset = _fm_presets / 10.0 else: preset = 76.0 rs = RadioSetting("fm_presets", "FM Preset(MHz)", RadioSettingValueFloat(65, 108.0, preset, 0.1, 1)) fm_preset.append(rs) # DTMF encode settings for i in range(0, 15): _codeobj = self._memobj.pttid[i].code _code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 16, _code, False) val.set_charset(DTMF_CHARS) rs = RadioSetting("pttid/%i.code" % i, "Signal Code %i" % (i + 1), val) def apply_code(setting, obj): code = [] for j in range(0, 16): try: code.append(DTMF_CHARS.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.code = code rs.set_apply_callback(apply_code, self._memobj.pttid[i]) dtmfe.append(rs) if _mem.ani.dtmfon > 0xC3: val = 0x03 else: val = _mem.ani.dtmfon rs = RadioSetting( "ani.dtmfon", "DTMF Speed (on)", RadioSettingValueList(LIST_DTMFSPEED, LIST_DTMFSPEED[val])) dtmfe.append(rs) if _mem.ani.dtmfoff > 0xC3: val = 0x03 else: val = _mem.ani.dtmfoff rs = RadioSetting( "ani.dtmfoff", "DTMF Speed (off)", RadioSettingValueList(LIST_DTMFSPEED, LIST_DTMFSPEED[val])) dtmfe.append(rs) _codeobj = self._memobj.ani.code _code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 7, _code, False) val.set_charset(DTMF_CHARS) rs = RadioSetting("ani.code", "ANI Code", val) def apply_code(setting, obj): code = [] for j in range(0, 7): try: code.append(DTMF_CHARS.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.code = code rs.set_apply_callback(apply_code, self._memobj.ani) dtmfe.append(rs) rs = RadioSetting( "ani.aniid", "When to send ANI ID", RadioSettingValueList(LIST_PTTID, LIST_PTTID[_mem.ani.aniid])) dtmfe.append(rs) # DTMF decode settings rs = RadioSetting("ani.mastervice", "Master and Vice ID", RadioSettingValueBoolean(_mem.ani.mastervice)) dtmfd.append(rs) _codeobj = _mem.ani.masterid _code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 5, _code, False) val.set_charset(DTMF_CHARS) rs = RadioSetting("ani.masterid", "Master Control ID", val) def apply_code(setting, obj): code = [] for j in range(0, 5): try: code.append(DTMF_CHARS.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.masterid = code rs.set_apply_callback(apply_code, self._memobj.ani) dtmfd.append(rs) rs = RadioSetting("ani.minspection", "Master Inspection", RadioSettingValueBoolean(_mem.ani.minspection)) dtmfd.append(rs) rs = RadioSetting("ani.mmonitor", "Master Monitor", RadioSettingValueBoolean(_mem.ani.mmonitor)) dtmfd.append(rs) rs = RadioSetting("ani.mstun", "Master Stun", RadioSettingValueBoolean(_mem.ani.mstun)) dtmfd.append(rs) rs = RadioSetting("ani.mkill", "Master Kill", RadioSettingValueBoolean(_mem.ani.mkill)) dtmfd.append(rs) rs = RadioSetting("ani.mrevive", "Master Revive", RadioSettingValueBoolean(_mem.ani.mrevive)) dtmfd.append(rs) _codeobj = _mem.ani.viceid _code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 5, _code, False) val.set_charset(DTMF_CHARS) rs = RadioSetting("ani.viceid", "Vice Control ID", val) def apply_code(setting, obj): code = [] for j in range(0, 5): try: code.append(DTMF_CHARS.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.viceid = code rs.set_apply_callback(apply_code, self._memobj.ani) dtmfd.append(rs) rs = RadioSetting("ani.vinspection", "Vice Inspection", RadioSettingValueBoolean(_mem.ani.vinspection)) dtmfd.append(rs) rs = RadioSetting("ani.vmonitor", "Vice Monitor", RadioSettingValueBoolean(_mem.ani.vmonitor)) dtmfd.append(rs) rs = RadioSetting("ani.vstun", "Vice Stun", RadioSettingValueBoolean(_mem.ani.vstun)) dtmfd.append(rs) rs = RadioSetting("ani.vkill", "Vice Kill", RadioSettingValueBoolean(_mem.ani.vkill)) dtmfd.append(rs) rs = RadioSetting("ani.vrevive", "Vice Revive", RadioSettingValueBoolean(_mem.ani.vrevive)) dtmfd.append(rs) _codeobj = _mem.ani.inspection _code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 8, _code, False) val.set_charset(DTMF_CHARS) rs = RadioSetting("ani.inspection", "Inspection Code", val) def apply_code(setting, obj): code = [] for j in range(0, 8): try: code.append(DTMF_CHARS.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.inspection = code rs.set_apply_callback(apply_code, self._memobj.ani) dtmfd.append(rs) _codeobj = _mem.ani.monitor _code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 8, _code, False) val.set_charset(DTMF_CHARS) rs = RadioSetting("ani.monitor", "Monitor Code", val) def apply_code(setting, obj): code = [] for j in range(0, 8): try: code.append(DTMF_CHARS.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.monitor = code rs.set_apply_callback(apply_code, self._memobj.ani) dtmfd.append(rs) _codeobj = _mem.ani.alarmcode _code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 8, _code, False) val.set_charset(DTMF_CHARS) rs = RadioSetting("ani.alarm", "Alarm Code", val) def apply_code(setting, obj): code = [] for j in range(0, 8): try: code.append(DTMF_CHARS.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.alarmcode = code rs.set_apply_callback(apply_code, self._memobj.ani) dtmfd.append(rs) _codeobj = _mem.ani.stun _code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 8, _code, False) val.set_charset(DTMF_CHARS) rs = RadioSetting("ani.stun", "Stun Code", val) def apply_code(setting, obj): code = [] for j in range(0, 8): try: code.append(DTMF_CHARS.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.stun = code rs.set_apply_callback(apply_code, self._memobj.ani) dtmfd.append(rs) _codeobj = _mem.ani.kill _code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 8, _code, False) val.set_charset(DTMF_CHARS) rs = RadioSetting("ani.kill", "Kill Code", val) def apply_code(setting, obj): code = [] for j in range(0, 8): try: code.append(DTMF_CHARS.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.kill = code rs.set_apply_callback(apply_code, self._memobj.ani) dtmfd.append(rs) _codeobj = _mem.ani.revive _code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 8, _code, False) val.set_charset(DTMF_CHARS) rs = RadioSetting("ani.revive", "Revive Code", val) def apply_code(setting, obj): code = [] for j in range(0, 8): try: code.append(DTMF_CHARS.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.revive = code rs.set_apply_callback(apply_code, self._memobj.ani) dtmfd.append(rs) def apply_dmtf_listvalue(setting, obj): LOG.debug("Setting value: " + str(setting.value) + " from list") val = str(setting.value) index = LIST_DTMF_SPECIAL_DIGITS.index(val) val = LIST_DTMF_SPECIAL_VALUES[index] obj.set_value(val) if _mem.ani.groupcode in LIST_DTMF_SPECIAL_VALUES: idx = LIST_DTMF_SPECIAL_VALUES.index(_mem.ani.groupcode) else: idx = LIST_DTMF_SPECIAL_VALUES.index(0x0B) rs = RadioSetting( "ani.groupcode", "Group Code", RadioSettingValueList(LIST_DTMF_SPECIAL_DIGITS, LIST_DTMF_SPECIAL_DIGITS[idx])) rs.set_apply_callback(apply_dmtf_listvalue, _mem.ani.groupcode) dtmfd.append(rs) if _mem.ani.spacecode in LIST_DTMF_SPECIAL_VALUES: idx = LIST_DTMF_SPECIAL_VALUES.index(_mem.ani.spacecode) else: idx = LIST_DTMF_SPECIAL_VALUES.index(0x0C) rs = RadioSetting( "ani.spacecode", "Space Code", RadioSettingValueList(LIST_DTMF_SPECIAL_DIGITS, LIST_DTMF_SPECIAL_DIGITS[idx])) rs.set_apply_callback(apply_dmtf_listvalue, _mem.ani.spacecode) dtmfd.append(rs) if _mem.ani.resettime > 0x9F: val = 0x4F else: val = _mem.ani.resettime rs = RadioSetting( "ani.resettime", "Reset Time", RadioSettingValueList(LIST_RESETTIME, LIST_RESETTIME[val])) dtmfd.append(rs) if _mem.ani.delayproctime > 0x27: val = 0x04 else: val = _mem.ani.delayproctime rs = RadioSetting( "ani.delayproctime", "Delay Processing Time", RadioSettingValueList(LIST_DELAYPROCTIME, LIST_DELAYPROCTIME[val])) dtmfd.append(rs) # Service settings for band in ["vhf", "uhf"]: for index in range(0, 10): key = "squelch.%s.sql%i" % (band, index) if band == "vhf": _obj = self._memobj.squelch.vhf elif band == "uhf": _obj = self._memobj.squelch.uhf val = RadioSettingValueInteger( 0, 123, getattr(_obj, "sql%i" % (index))) if index == 0: val.set_mutable(False) name = "%s Squelch %i" % (band.upper(), index) rs = RadioSetting(key, name, val) service.append(rs) return top
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic") autodial = RadioSettingGroup("autodial", "AutoDial") keymaps = RadioSettingGroup("keymaps", "KeyMaps") top = RadioSettingGroup("top", "All Settings", basic, keymaps, autodial) rs = RadioSetting("beep", "Beep", RadioSettingValueBoolean(_settings.beep)) basic.append(rs) rs = RadioSetting("lock", "Lock", RadioSettingValueBoolean(_settings.lock)) basic.append(rs) rs = RadioSetting("ars", "Auto Repeater Shift", RadioSettingValueBoolean(_settings.ars)) basic.append(rs) rs = RadioSetting("txpwrsave", "TX Power Save", RadioSettingValueBoolean(_settings.txpwrsave)) basic.append(rs) rs = RadioSetting("txnarrow", "TX Narrow", RadioSettingValueBoolean(_settings.txnarrow)) basic.append(rs) options = ["Off", "S-3", "S-5", "S-Full"] rs = RadioSetting( "rfsqlvl", "RF Squelch Level", RadioSettingValueList(options, options[_settings.rfsqlvl])) basic.append(rs) options = ["Off", "Band A", "Band B", "Both"] rs = RadioSetting( "pttlock", "PTT Lock", RadioSettingValueList(options, options[_settings.pttlock])) basic.append(rs) rs = RadioSetting("cwid_en", "CWID Enable", RadioSettingValueBoolean(_settings.cwid_en)) basic.append(rs) cwid = RadioSettingValueString(0, 7, self._decode_cwid(_settings.cwid)) cwid.set_charset(FT90_CWID_CHARS) rs = RadioSetting("cwid", "CWID", cwid) basic.append(rs) options = ["OFF"] + map(str, range(1, 12 + 1)) rs = RadioSetting( "apo", "APO time (hrs)", RadioSettingValueList(options, options[_settings.apo])) basic.append(rs) options = ["Off"] + map(str, range(1, 60 + 1)) rs = RadioSetting( "tot", "Time Out Timer (mins)", RadioSettingValueList(options, options[_settings.tot])) basic.append(rs) options = ["off", "Auto/TX", "Auto", "TX"] rs = RadioSetting( "fancontrol", "Fan Control", RadioSettingValueList(options, options[_settings.fancontrol])) basic.append(rs) keyopts = [ "Scan Up", "Scan Down", "Repeater", "Reverse", "Tone Burst", "Tx Power", "Home Ch", "VFO/MR", "Tone", "Priority" ] rs = RadioSetting( "key_lt", "Left Key", RadioSettingValueList(keyopts, keyopts[_settings.key_lt])) keymaps.append(rs) rs = RadioSetting( "key_rt", "Right Key", RadioSettingValueList(keyopts, keyopts[_settings.key_rt])) keymaps.append(rs) rs = RadioSetting( "key_p1", "P1 Key", RadioSettingValueList(keyopts, keyopts[_settings.key_p1])) keymaps.append(rs) rs = RadioSetting( "key_p2", "P2 Key", RadioSettingValueList(keyopts, keyopts[_settings.key_p2])) keymaps.append(rs) rs = RadioSetting( "key_acc", "ACC Key", RadioSettingValueList(keyopts, keyopts[_settings.key_acc])) keymaps.append(rs) options = map(str, range(0, 12 + 1)) rs = RadioSetting( "lcdcontrast", "LCD Contrast", RadioSettingValueList(options, options[_settings.lcdcontrast])) basic.append(rs) options = ["off", "d4", "d3", "d2", "d1"] rs = RadioSetting( "dimmer", "Dimmer", RadioSettingValueList(options, options[_settings.dimmer])) basic.append(rs) options = ["TRX Normal", "RX Reverse", "TX Reverse", "TRX Reverse"] rs = RadioSetting( "dcsmode", "DCS Mode", RadioSettingValueList(options, options[_settings.dcsmode])) basic.append(rs) options = ["50 ms", "100 ms"] rs = RadioSetting( "dtmfspeed", "DTMF Speed", RadioSettingValueList(options, options[_settings.dtmfspeed])) autodial.append(rs) options = ["50 ms", "250 ms", "450 ms", "750 ms", "1 sec"] rs = RadioSetting( "dtmftxdelay", "DTMF TX Delay", RadioSettingValueList(options, options[_settings.dtmftxdelay])) autodial.append(rs) options = map(str, range(1, 8 + 1)) rs = RadioSetting( "dtmf_active", "DTMF Active", RadioSettingValueList(options, options[_settings.dtmf_active])) autodial.append(rs) # setup 8 dtmf autodial entries for i in map(str, range(1, 9)): objname = "dtmf" + i dtmfsetting = getattr(_settings, objname) dtmflen = getattr(_settings, objname + "_len") dtmfstr = self._bbcd2dtmf(dtmfsetting, dtmflen) dtmf = RadioSettingValueString(0, 16, dtmfstr) dtmf.set_charset(FT90_DTMF_CHARS + list(" ")) rs = RadioSetting(objname, objname.upper(), dtmf) autodial.append(rs) return top
def get_memory(self, number): _mem = self._memobj.memory[number - 1] mem = chirp_common.Memory() mem.number = number if _mem.get_raw().startswith("\xFF\xFF\xFF\xFF"): mem.empty = True return mem mem.freq = int(_mem.rx_freq) * 10 txfreq = int(_mem.tx_freq) * 10 if self._is_txinh(_mem): mem.duplex = "off" mem.offset = 0 elif txfreq == mem.freq: mem.duplex = "" elif abs(txfreq - mem.freq) > 70000000: mem.duplex = "split" mem.offset = txfreq elif txfreq < mem.freq: mem.duplex = "-" mem.offset = mem.freq - txfreq elif txfreq > mem.freq: mem.duplex = "+" mem.offset = txfreq - mem.freq txmode, txval, txpol = self._decode_tone(_mem.tx_tone) rxmode, rxval, rxpol = self._decode_tone(_mem.rx_tone) chirp_common.split_tone_decode( mem, (txmode, txval, txpol), (rxmode, rxval, rxpol)) mem.name = str(self._memobj.names[number - 1].name) mem.name = mem.name.replace("\xFF", " ").rstrip() mem.skip = not _mem.scan and "S" or "" mem.mode = _mem.isnarrow and "NFM" or "FM" mem.power = POWER_LEVELS[1 - _mem.ishighpower] mem.extra = RadioSettingGroup("extra", "Extra Settings") rs = RadioSetting("pttid", "PTT ID", RadioSettingValueList(PTTID_LIST, PTTID_LIST[_mem.pttid])) mem.extra.append(rs) rs = RadioSetting("vox", "VOX", RadioSettingValueBoolean(_mem.vox)) mem.extra.append(rs) rs = RadioSetting("bcl", "Busy Channel Lockout", RadioSettingValueList(BCL_LIST, BCL_LIST[_mem.bcl])) mem.extra.append(rs) rs = RadioSetting("scramble_code", "Scramble Code", RadioSettingValueList( CODES_LIST, CODES_LIST[_mem.scramble_code])) mem.extra.append(rs) return mem
def get_memory(self, number): mem = chirp_common.Memory() _mem = self._memobj.channels[number - 1] _nam = self._memobj.names[number - 1] mem.number = number bitpos = (1 << ((number - 1) % 8)) bytepos = ((number - 1) / 8) _scn = self._memobj.scanflags[bytepos] _usd = self._memobj.usedflags[bytepos] isused = bitpos & int(_usd) isscan = bitpos & int(_scn) if not isused: mem.empty = True return mem mem.freq = int(_mem.rxfreq) * 10 # We'll consider any blank (i.e. 0MHz frequency) to be empty if mem.freq == 0: mem.empty = True return mem if _mem.rxfreq.get_raw() == "\xFF\xFF\xFF\xFF": mem.empty = True return mem if _mem.get_raw() == ("\xFF" * 16): LOG.debug("Initializing empty memory") _mem.set_raw("\x00" * 16) # Freq and offset mem.freq = int(_mem.rxfreq) * 10 # tx freq can be blank if _mem.get_raw()[4] == "\xFF": # TX freq not set mem.offset = 0 mem.duplex = "off" else: # TX freq set offset = (int(_mem.txfreq) * 10) - mem.freq if offset != 0: if _split(self.get_features(), mem.freq, int(_mem.txfreq) * 10): mem.duplex = "split" mem.offset = int(_mem.txfreq) * 10 elif offset < 0: mem.offset = abs(offset) mem.duplex = "-" elif offset > 0: mem.offset = offset mem.duplex = "+" else: mem.offset = 0 for char in _nam.name: if str(char) == "\xFF": char = " " mem.name += str(char) mem.name = mem.name.rstrip() mem.mode = _mem.isnarrow and "NFM" or "FM" rxtone = txtone = None txtone = self.decode_tone(_mem.txtone) rxtone = self.decode_tone(_mem.rxtone) chirp_common.split_tone_decode(mem, txtone, rxtone) mem.power = RT23_POWER_LEVELS[_mem.highpower] if not isscan: mem.skip = "S" mem.extra = RadioSettingGroup("Extra", "extra") rs = RadioSetting("bcl", "BCL", RadioSettingValueBoolean(_mem.bcl)) mem.extra.append(rs) rs = RadioSetting( "pttid", "PTT ID", RadioSettingValueList(LIST_PTTID, LIST_PTTID[_mem.pttid])) mem.extra.append(rs) rs = RadioSetting( "signaling", "Optional Signaling", RadioSettingValueList(LIST_SIGNALING, LIST_SIGNALING[_mem.signaling])) mem.extra.append(rs) return mem
def get_settings(self): _settings = self._memobj.settings _mem = self._memobj basic = RadioSettingGroup("basic", "Basic Settings") advanced = RadioSettingGroup("advanced", "Advanced Settings") other = RadioSettingGroup("other", "Other Settings") workmode = RadioSettingGroup("workmode", "Workmode Settings") fmradio = RadioSettingGroup("fmradio", "FM Radio Settings") top = RadioSettings(basic, advanced, other, workmode, fmradio) save = RadioSetting("save", "Battery Saver", RadioSettingValueBoolean(_settings.save)) basic.append(save) vox = RadioSetting( "vox", "VOX Gain", RadioSettingValueList(LIST_VOX, LIST_VOX[_settings.vox])) basic.append(vox) squelch = RadioSetting( "squelch", "Squelch Level", RadioSettingValueInteger(0, 9, _settings.squelch)) basic.append(squelch) relay = RadioSetting("relay", "Repeater", RadioSettingValueBoolean(_settings.relay)) basic.append(relay) tot = RadioSetting( "tot", "Time-out timer", RadioSettingValueList(LIST_TOT, LIST_TOT[_settings.tot])) basic.append(tot) beep = RadioSetting("beep", "Key Beep", RadioSettingValueBoolean(_settings.beep)) basic.append(beep) color = RadioSetting( "color", "Background Color", RadioSettingValueList(LIST_COLOR, LIST_COLOR[_settings.color - 1])) basic.append(color) vot = RadioSetting( "vot", "VOX Delay Time", RadioSettingValueList(LIST_VOT, LIST_VOT[_settings.vot])) basic.append(vot) dwait = RadioSetting("dwait", "Dual Standby", RadioSettingValueBoolean(_settings.dwait)) basic.append(dwait) led = RadioSetting( "led", "Background Light", RadioSettingValueList(LIST_LED, LIST_LED[_settings.led])) basic.append(led) voice = RadioSetting( "voice", "Voice Prompt", RadioSettingValueList(LIST_VOICE, LIST_VOICE[_settings.voice])) basic.append(voice) roger = RadioSetting("roger", "Roger Beep", RadioSettingValueBoolean(_settings.roger)) basic.append(roger) autolk = RadioSetting("autolk", "Auto Key Lock", RadioSettingValueBoolean(_settings.autolk)) basic.append(autolk) opnset = RadioSetting( "opnset", "Open Mode Set", RadioSettingValueList(LIST_OPNSET, LIST_OPNSET[_settings.opnset])) basic.append(opnset) 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 ponmsg = RadioSetting( "poweron_msg.line1", "Power-On Message", RadioSettingValueString(0, 7, _filter(_msg.line1))) basic.append(ponmsg) scans = RadioSetting( "scans", "Scan Mode", RadioSettingValueList(LIST_SCANS, LIST_SCANS[_settings.scans])) basic.append(scans) dw = RadioSetting("dw", "FM Radio Dual Watch", RadioSettingValueBoolean(_settings.dw)) basic.append(dw) name = RadioSetting("name", "Display Names", RadioSettingValueBoolean(_settings.name)) basic.append(name) rptrl = RadioSetting( "rptrl", "Repeater TX Delay", RadioSettingValueList(LIST_RPTRL, LIST_RPTRL[_settings.rptrl])) basic.append(rptrl) rptspk = RadioSetting("rptspk", "Repeater Speaker", RadioSettingValueBoolean(_settings.rptspk)) basic.append(rptspk) rptptt = RadioSetting("rptptt", "Repeater PTT Switch", RadioSettingValueBoolean(_settings.rptptt)) basic.append(rptptt) rptmod = RadioSetting( "rptmod", "Repeater Mode", RadioSettingValueList(LIST_RPTMOD, LIST_RPTMOD[_settings.rptmod])) basic.append(rptmod) volmod = RadioSetting( "volmod", "Volume Mode", RadioSettingValueList(LIST_VOLMOD, LIST_VOLMOD[_settings.volmod])) basic.append(volmod) dst = RadioSetting("dst", "DTMF Side Tone", RadioSettingValueBoolean(_settings.dst)) basic.append(dst) txsel = RadioSetting( "txsel", "Priority TX Channel", RadioSettingValueList(LIST_TXSEL, LIST_TXSEL[_settings.txsel])) basic.append(txsel) ste = RadioSetting("ste", "Squelch Tail Eliminate", RadioSettingValueBoolean(_settings.ste)) basic.append(ste) # advanced if _settings.pf1 > 0x0A: val = 0x00 else: val = _settings.pf1 pf1 = RadioSetting("pf1", "PF1 Key", RadioSettingValueList(LIST_PFKEY, LIST_PFKEY[val])) advanced.append(pf1) if _settings.pf2 > 0x0A: val = 0x00 else: val = _settings.pf2 pf2 = RadioSetting("pf2", "PF2 Key", RadioSettingValueList(LIST_PFKEY, LIST_PFKEY[val])) advanced.append(pf2) # other _limit = str(int(_mem.limits.vhf.lower) / 10) val = RadioSettingValueString(0, 3, _limit) val.set_mutable(False) rs = RadioSetting("limits.vhf.lower", "VHF low", val) other.append(rs) _limit = str(int(_mem.limits.vhf.upper) / 10) val = RadioSettingValueString(0, 3, _limit) val.set_mutable(False) rs = RadioSetting("limits.vhf.upper", "VHF high", val) other.append(rs) _limit = str(int(_mem.limits.uhf.lower) / 10) val = RadioSettingValueString(0, 3, _limit) val.set_mutable(False) rs = RadioSetting("limits.uhf.lower", "UHF low", val) other.append(rs) _limit = str(int(_mem.limits.uhf.upper) / 10) val = RadioSettingValueString(0, 3, _limit) val.set_mutable(False) rs = RadioSetting("limits.uhf.upper", "UHF high", val) other.append(rs) # work mode vfomr_a = RadioSetting( "vfomr_a", "Display Mode A", RadioSettingValueList(LIST_VFOMR, LIST_VFOMR[_settings.vfomr_a])) workmode.append(vfomr_a) vfomr_b = RadioSetting( "vfomr_b", "Display Mode B", RadioSettingValueList(LIST_VFOMR, LIST_VFOMR[_settings.vfomr_b])) workmode.append(vfomr_b) mrcha = RadioSetting("mrcha", "Channel # A", RadioSettingValueInteger(1, 128, _settings.mrcha)) workmode.append(mrcha) mrchb = RadioSetting("mrchb", "Channel # B", RadioSettingValueInteger(1, 128, _settings.mrchb)) workmode.append(mrchb) # fm radio vfomr_fm = RadioSetting( "vfomr_fm", "FM Radio Display Mode", RadioSettingValueList(LIST_VFOMRFM, LIST_VFOMRFM[_settings.vfomr_fm])) fmradio.append(vfomr_fm) fmch = RadioSetting("fmch", "FM Radio Channel #", RadioSettingValueInteger(1, 25, _settings.fmch)) fmradio.append(fmch) return top
def get_settings(self): _msg = self._memobj.welcome_msg _oem = self._memobj.oem_info _settings = self._memobj.settings cfg_grp = RadioSettingGroup("cfg_grp", "Function Setup") oem_grp = RadioSettingGroup("oem_grp", "OEM Info") group = RadioSettings(cfg_grp, oem_grp) def _filter(name): filtered = "" for char in str(name): if char in chirp_common.CHARSET_ASCII: filtered += char else: filtered += " " return filtered # # Function Setup # rs = RadioSetting("welcome_msg.line1", "Welcome Message 1", RadioSettingValueString(0, 6, _filter(_msg.line1))) cfg_grp.append(rs) rs = RadioSetting("welcome_msg.line2", "Welcome Message 2", RadioSettingValueString(0, 6, _filter(_msg.line2))) cfg_grp.append(rs) rs = RadioSetting( "display", "Display Mode", RadioSettingValueList(DISPLAY, DISPLAY[_settings.display])) cfg_grp.append(rs) rs = RadioSetting( "upvfomr", "Up VFO/MR", RadioSettingValueList(VFOMR, VFOMR[_settings.upvfomr])) cfg_grp.append(rs) rs = RadioSetting( "dnvfomr", "Down VFO/MR", RadioSettingValueList(VFOMR, VFOMR[_settings.dnvfomr])) cfg_grp.append(rs) rs = RadioSetting( "upwork", "Up Work Mode", RadioSettingValueList(WORKMODE, WORKMODE[_settings.upwork])) cfg_grp.append(rs) rs = RadioSetting( "upmrbank", "Up MR Bank", RadioSettingValueList(MRBANK, MRBANK[_settings.upmrbank])) cfg_grp.append(rs) rs = RadioSetting("upmrch", "Up MR Channel", RadioSettingValueInteger(0, 200, _settings.upmrch)) cfg_grp.append(rs) rs = RadioSetting( "dnwork", "Down Work Mode", RadioSettingValueList(WORKMODE, WORKMODE[_settings.dnwork])) cfg_grp.append(rs) rs = RadioSetting( "dnmrbank", "Down MR Bank", RadioSettingValueList(MRBANK, MRBANK[_settings.dnmrbank])) cfg_grp.append(rs) rs = RadioSetting("dnmrch", "Down MR Channel", RadioSettingValueInteger(0, 200, _settings.dnmrch)) cfg_grp.append(rs) rs = RadioSetting("main", "Main", RadioSettingValueList(MAIN, MAIN[_settings.main])) cfg_grp.append(rs) rs = RadioSetting("pause", "Scan Pause Time", RadioSettingValueList(PAUSE, PAUSE[_settings.pause])) cfg_grp.append(rs) rs = RadioSetting("stop", "Function Keys Stop Time", RadioSettingValueList(STOP, STOP[_settings.stop])) cfg_grp.append(rs) rs = RadioSetting( "backlight", "Backlight", RadioSettingValueList(BACKLIGHT, BACKLIGHT[_settings.backlight])) cfg_grp.append(rs) rs = RadioSetting("color", "Backlight Color", RadioSettingValueList(COLOR, COLOR[_settings.color])) cfg_grp.append(rs) rs = RadioSetting( "vdisplay", "Vice-Machine Display", RadioSettingValueList(VDISPLAY, VDISPLAY[_settings.vdisplay])) cfg_grp.append(rs) rs = RadioSetting( "voxlevel", "Vox Level", RadioSettingValueList(VOXLEVEL, VOXLEVEL[_settings.voxlevel])) cfg_grp.append(rs) rs = RadioSetting( "voxdelay", "Vox Delay", RadioSettingValueList(VOXDELAY, VOXDELAY[_settings.voxdelay])) cfg_grp.append(rs) rs = RadioSetting("tot", "Time Out Timer", RadioSettingValueList(TOT, TOT[_settings.tot])) cfg_grp.append(rs) rs = RadioSetting("tbst", "Tone Burst", RadioSettingValueList(TBST, TBST[_settings.tbst])) cfg_grp.append(rs) rs = RadioSetting("monikey", "MONI Key Function", RadioSettingValueList(MONI, MONI[_settings.monikey])) cfg_grp.append(rs) if self.MODEL == "TERMN-8R": rs = RadioSetting( "pf1key", "PF1 Key Function", RadioSettingValueList(PFKEYT, PFKEYT[_settings.pf1key])) cfg_grp.append(rs) rs = RadioSetting( "pf2key", "PF2 Key Function", RadioSettingValueList(PFKEYT, PFKEYT[_settings.pf2key])) cfg_grp.append(rs) if self.MODEL == "OBLTR-8R": rs = RadioSetting( "pf1key", "PF1 Key Function", RadioSettingValueList(PFKEYO, PFKEYO[_settings.pf1key])) cfg_grp.append(rs) rs = RadioSetting( "fmam", "PF2 Key Function", RadioSettingValueList(PFKEYO, PFKEYO[_settings.fmam])) cfg_grp.append(rs) rs = RadioSetting("apo", "Automatic Power Off", RadioSettingValueList(APO, APO[_settings.apo])) cfg_grp.append(rs) rs = RadioSetting("save", "Power Save", RadioSettingValueList(SAVE, SAVE[_settings.save])) cfg_grp.append(rs) rs = RadioSetting("tail", "Tail Eliminator Type", RadioSettingValueList(TAIL, TAIL[_settings.tail])) cfg_grp.append(rs) rs = RadioSetting( "fmvfomr", "FM VFO/MR", RadioSettingValueList(VFOMR, VFOMR[_settings.fmvfomr])) cfg_grp.append(rs) rs = RadioSetting("fmmrch", "FM MR Channel", RadioSettingValueInteger(0, 100, _settings.fmmrch)) cfg_grp.append(rs) rs = RadioSetting("noaa", "NOAA", RadioSettingValueList(NOAA, NOAA[_settings.noaa])) cfg_grp.append(rs) rs = RadioSetting( "noaach", "NOAA Channel", RadioSettingValueList(NOAACH, NOAACH[_settings.noaach])) cfg_grp.append(rs) rs = RadioSetting( "part95", "PART95", RadioSettingValueList(PART95, PART95[_settings.part95])) cfg_grp.append(rs) rs = RadioSetting("gmrs", "GMRS", RadioSettingValueList(GMRS, GMRS[_settings.gmrs])) cfg_grp.append(rs) rs = RadioSetting("murs", "MURS", RadioSettingValueList(MURS, MURS[_settings.murs])) cfg_grp.append(rs) for i in range(0, 9): val = self._memobj.banklink[i].bank rs = RadioSetting("banklink/%i.bank" % i, "Bank Link %i" % (i + 1), RadioSettingValueBoolean(val)) cfg_grp.append(rs) val = self._memobj.banklink[9].bank rs = RadioSetting("banklink/9.bank", "Bank Link 0", RadioSettingValueBoolean(val)) cfg_grp.append(rs) rs = RadioSetting("allband", "All Band", RadioSettingValueBoolean(_settings.allband)) cfg_grp.append(rs) rs = RadioSetting("alarmoff", "Alarm Function Off", RadioSettingValueBoolean(_settings.alarmoff)) cfg_grp.append(rs) rs = RadioSetting("beep", "Beep", RadioSettingValueBoolean(_settings.beep)) cfg_grp.append(rs) rs = RadioSetting("radio", "Radio", RadioSettingValueBoolean(_settings.radio)) cfg_grp.append(rs) if self.MODEL == "TERMN-8R": rs = RadioSetting("keylock", "Keylock", RadioSettingValueBoolean(_settings.keylock)) cfg_grp.append(rs) rs = RadioSetting("fastscan", "Fast Scan", RadioSettingValueBoolean(_settings.fastscan)) cfg_grp.append(rs) if self.MODEL == "OBLTR-8R": # "pf2key" is used for OBLTR-8R "keylock" rs = RadioSetting("pf2key", "Keylock", RadioSettingValueBoolean(_settings.pf2key)) cfg_grp.append(rs) rs = RadioSetting("fastscano", "Fast Scan", RadioSettingValueBoolean(_settings.fastscano)) cfg_grp.append(rs) rs = RadioSetting("uplink", "Up Bank Link Select", RadioSettingValueBoolean(_settings.uplink)) cfg_grp.append(rs) rs = RadioSetting("downlink", "Down Bank Link Select", RadioSettingValueBoolean(_settings.downlink)) cfg_grp.append(rs) # # OEM info # val = RadioSettingValueString(0, 7, _filter(_oem.model)) val.set_mutable(False) rs = RadioSetting("oem_info.model", "Model", val) oem_grp.append(rs) val = RadioSettingValueString(0, 9, _filter(_oem.date)) val.set_mutable(False) rs = RadioSetting("oem_info.date", "Date", val) oem_grp.append(rs) val = RadioSettingValueString(0, 16, _filter(_oem.dealer)) val.set_mutable(False) rs = RadioSetting("oem_info.dealer", "Dealer Code", val) oem_grp.append(rs) val = RadioSettingValueString(0, 9, _filter(_oem.stockdate)) val.set_mutable(False) rs = RadioSetting("oem_info.stockdate", "Stock Date", val) oem_grp.append(rs) val = RadioSettingValueString(0, 9, _filter(_oem.selldate)) val.set_mutable(False) rs = RadioSetting("oem_info.selldate", "Sell Date", val) oem_grp.append(rs) return group
def get_settings(self): """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_memory(self, number): """Get the mem representation from the radio image""" bitpos = (1 << (number % 8)) bytepos = (number / 8) _mem = self._memory_obj()[number] _names = self._name_obj()[number] _scn = self._scan_obj()[bytepos] _usd = self._used_obj()[bytepos] isused = bitpos & int(_usd) isscan = bitpos & int(_scn) # Create a high-level memory object to return to the UI mem = chirp_common.Memory() # Memory number mem.number = number if not isused: mem.empty = True return mem # Freq and offset mem.freq = int(_mem.rxfreq) * 10 # tx freq can be blank if _mem.get_raw()[4] == "\xFF": # TX freq not set mem.offset = 0 mem.duplex = "off" else: # TX feq set offset = (int(_mem.txfreq) * 10) - mem.freq if offset < 0: mem.offset = abs(offset) mem.duplex = "-" elif offset > 0: mem.offset = offset mem.duplex = "+" else: mem.offset = 0 # skip if not isscan: mem.skip = "S" # name TAG of the channel mem.name = str(_names.name).strip("\xFF") # power mem.power = POWER_LEVELS[int(_mem.txp)] # wide/narrow mem.mode = MODES[int(_mem.wn)] # tone data rxtone = txtone = None txtone = self.decode_tone(_mem.txtone) rxtone = self.decode_tone(_mem.rxtone) chirp_common.split_tone_decode(mem, txtone, rxtone) # Extra mem.extra = RadioSettingGroup("extra", "Extra") bcl = RadioSetting("bcl", "Busy channel lockout", RadioSettingValueBoolean(bool(_mem.bcl))) mem.extra.append(bcl) revert = RadioSetting("revert", "Revert", RadioSettingValueBoolean(bool(_mem.revert))) mem.extra.append(revert) dname = RadioSetting("dname", "Display name", RadioSettingValueBoolean(bool(_mem.dname))) mem.extra.append(dname) return mem
def get_memory(self, number): """Get the mem representation from the radio image""" _mem = self._memobj.memory[number - 1] _tone = self._memobj.tone[number - 1] _ch = self._memobj.ch_settings[number - 1] # Create a high-level memory object to return to the UI mem = chirp_common.Memory() # Memory number mem.number = number if _mem.get_raw()[0] == "\xFF" or not self.get_active(number - 1): mem.empty = True # but is not enough, you have to crear the memory in the mmap # to get it ready for the sync_out process _mem.set_raw("\xFF" * 8) return mem # Freq and offset mem.freq = int(_mem.rxfreq) * 10 # tx freq can be blank if _mem.get_raw()[4] == "\xFF": # TX freq not set mem.offset = 0 mem.duplex = "off" else: # TX feq set offset = (int(_mem.txfreq) * 10) - mem.freq if offset < 0: mem.offset = abs(offset) mem.duplex = "-" elif offset > 0: mem.offset = offset mem.duplex = "+" else: mem.offset = 0 # power mem.power = POWER_LEVELS[_ch.power] # wide/marrow mem.mode = MODES[_ch.wide] # skip mem.skip = self.get_scan(number - 1) # tone data rxtone = txtone = None txtone = self.decode_tone(_tone.tx_tone) rxtone = self.decode_tone(_tone.rx_tone) chirp_common.split_tone_decode(mem, txtone, rxtone) # Extra # bank and number in the channel mem.extra = RadioSettingGroup("extra", "Extra") bl = RadioSetting("busy_lock", "Busy Channel lock", RadioSettingValueBoolean( not bool(_ch.busy_lock))) mem.extra.append(bl) return mem
def _get_settings(self): _settings = self._memobj.settings _vfoa = self._memobj.vfoa _vfob = self._memobj.vfob cfg_grp = RadioSettingGroup("cfg_grp", "Configuration") vfoa_grp = RadioSettingGroup("vfoa_grp", "VFO A Settings") vfob_grp = RadioSettingGroup("vfob_grp", "VFO B Settings") key_grp = RadioSettingGroup("key_grp", "Key Settings") lmt_grp = RadioSettingGroup("lmt_grp", "Frequency Limits") uhf_lmt_grp = RadioSettingGroup("uhf_lmt_grp", "UHF") vhf_lmt_grp = RadioSettingGroup("vhf_lmt_grp", "VHF") oem_grp = RadioSettingGroup("oem_grp", "OEM Info") lmt_grp.append(uhf_lmt_grp) lmt_grp.append(vhf_lmt_grp) group = RadioSettings(cfg_grp, vfoa_grp, vfob_grp, key_grp, lmt_grp, oem_grp) # # Configuration Settings # rs = RadioSetting("channel_menu", "Menu available in channel mode", RadioSettingValueBoolean(_settings.channel_menu)) cfg_grp.append(rs) rs = RadioSetting( "ponmsg", "Poweron message", RadioSettingValueList(PONMSG_LIST, PONMSG_LIST[_settings.ponmsg])) cfg_grp.append(rs) rs = RadioSetting("voice", "Voice Guide", RadioSettingValueBoolean(_settings.voice)) cfg_grp.append(rs) rs = RadioSetting( "language", "Language", RadioSettingValueList(LANGUAGE_LIST, LANGUAGE_LIST[_settings.language])) cfg_grp.append(rs) rs = RadioSetting( "timeout", "Timeout Timer", RadioSettingValueList(TIMEOUT_LIST, TIMEOUT_LIST[_settings.timeout])) cfg_grp.append(rs) rs = RadioSetting("toalarm", "Timeout Alarm", RadioSettingValueInteger(0, 10, _settings.toalarm)) cfg_grp.append(rs) rs = RadioSetting( "roger_beep", "Roger Beep", RadioSettingValueList(ROGER_LIST, ROGER_LIST[_settings.roger_beep])) cfg_grp.append(rs) rs = RadioSetting("power_save", "Power save", RadioSettingValueBoolean(_settings.power_save)) cfg_grp.append(rs) rs = RadioSetting("autolock", "Autolock", RadioSettingValueBoolean(_settings.autolock)) cfg_grp.append(rs) rs = RadioSetting("keylock", "Keypad Lock", RadioSettingValueBoolean(_settings.keylock)) cfg_grp.append(rs) rs = RadioSetting("beep", "Keypad Beep", RadioSettingValueBoolean(_settings.beep)) cfg_grp.append(rs) rs = RadioSetting("stopwatch", "Stopwatch", RadioSettingValueBoolean(_settings.stopwatch)) cfg_grp.append(rs) rs = RadioSetting( "backlight", "Backlight", RadioSettingValueList(BACKLIGHT_LIST, BACKLIGHT_LIST[_settings.backlight])) cfg_grp.append(rs) rs = RadioSetting( "dtmf_st", "DTMF Sidetone", RadioSettingValueList(DTMFST_LIST, DTMFST_LIST[_settings.dtmf_st])) cfg_grp.append(rs) rs = RadioSetting("ani_sw", "ANI-ID Switch", RadioSettingValueBoolean(_settings.ani_sw)) cfg_grp.append(rs) rs = RadioSetting( "ptt_id", "PTT-ID Delay", RadioSettingValueList(PTTID_LIST, PTTID_LIST[_settings.ptt_id])) cfg_grp.append(rs) rs = RadioSetting( "ring_time", "Ring Time", RadioSettingValueList(LIST_10, LIST_10[_settings.ring_time])) cfg_grp.append(rs) rs = RadioSetting( "scan_rev", "Scan Mode", RadioSettingValueList(SCANMODE_LIST, SCANMODE_LIST[_settings.scan_rev])) cfg_grp.append(rs) rs = RadioSetting( "vox", "VOX", RadioSettingValueList(LIST_10, LIST_10[_settings.vox])) cfg_grp.append(rs) rs = RadioSetting("prich_sw", "Priority Channel Switch", RadioSettingValueBoolean(_settings.prich_sw)) cfg_grp.append(rs) rs = RadioSetting("pri_ch", "Priority Channel", RadioSettingValueInteger(1, 999, _settings.pri_ch)) cfg_grp.append(rs) rs = RadioSetting( "rpt_mode", "Radio Mode", RadioSettingValueList(RPTMODE_LIST, RPTMODE_LIST[_settings.rpt_mode])) cfg_grp.append(rs) rs = RadioSetting( "rpt_set", "Repeater Setting", RadioSettingValueList(RPTSET_LIST, RPTSET_LIST[_settings.rpt_set])) cfg_grp.append(rs) rs = RadioSetting("rpt_spk", "Repeater Mode Speaker", RadioSettingValueBoolean(_settings.rpt_spk)) cfg_grp.append(rs) rs = RadioSetting("rpt_ptt", "Repeater PTT", RadioSettingValueBoolean(_settings.rpt_ptt)) cfg_grp.append(rs) rs = RadioSetting( "dtmf_tx_time", "DTMF Tx Duration", RadioSettingValueList(DTMF_TIMES, DTMF_TIMES[_settings.dtmf_tx_time])) cfg_grp.append(rs) rs = RadioSetting( "dtmf_interval", "DTMF Interval", RadioSettingValueList(DTMF_TIMES, DTMF_TIMES[_settings.dtmf_interval])) cfg_grp.append(rs) rs = RadioSetting( "alert", "Alert Tone", RadioSettingValueList(ALERTS_LIST, ALERTS_LIST[_settings.alert])) cfg_grp.append(rs) rs = RadioSetting("rpt_tone", "Repeater Tone", RadioSettingValueBoolean(_settings.rpt_tone)) cfg_grp.append(rs) rs = RadioSetting( "rpt_hold", "Repeater Hold Time", RadioSettingValueList(HOLD_TIMES, HOLD_TIMES[_settings.rpt_hold])) cfg_grp.append(rs) rs = RadioSetting("scan_det", "Scan DET", RadioSettingValueBoolean(_settings.scan_det)) cfg_grp.append(rs) rs = RadioSetting( "sc_qt", "SC-QT", RadioSettingValueList(SCQT_LIST, SCQT_LIST[_settings.sc_qt])) cfg_grp.append(rs) rs = RadioSetting( "smuteset", "SubFreq Mute", RadioSettingValueList(SMUTESET_LIST, SMUTESET_LIST[_settings.smuteset])) cfg_grp.append(rs) # # VFO A Settings # rs = RadioSetting( "workmode_a", "VFO A Workmode", RadioSettingValueList(WORKMODE_LIST, WORKMODE_LIST[_settings.workmode_a])) vfoa_grp.append(rs) rs = RadioSetting("work_cha", "VFO A Channel", RadioSettingValueInteger(1, 999, _settings.work_cha)) vfoa_grp.append(rs) rs = RadioSetting( "vfoa.rxfreq", "VFO A Rx Frequency", RadioSettingValueInteger(134000000, 520000000, _vfoa.rxfreq * 10, 5000)) vfoa_grp.append(rs) rs = RadioSetting( "vfoa.txoffset", "VFO A Tx Offset", RadioSettingValueInteger(0, 520000000, _vfoa.txoffset * 10, 5000)) vfoa_grp.append(rs) # u16 rxtone; # u16 txtone; rs = RadioSetting( "vfoa.power", "VFO A Power", RadioSettingValueList(POWER_LIST, POWER_LIST[_vfoa.power])) vfoa_grp.append(rs) # shift_dir:2 rs = RadioSetting( "vfoa.iswide", "VFO A NBFM", RadioSettingValueList(BANDWIDTH_LIST, BANDWIDTH_LIST[_vfoa.iswide])) vfoa_grp.append(rs) rs = RadioSetting( "vfoa.mute_mode", "VFO A Mute", RadioSettingValueList(SPMUTE_LIST, SPMUTE_LIST[_vfoa.mute_mode])) vfoa_grp.append(rs) rs = RadioSetting( "vfoa.step", "VFO A Step (kHz)", RadioSettingValueList(STEP_LIST, STEP_LIST[_vfoa.step])) vfoa_grp.append(rs) rs = RadioSetting( "vfoa.squelch", "VFO A Squelch", RadioSettingValueList(LIST_10, LIST_10[_vfoa.squelch])) vfoa_grp.append(rs) rs = RadioSetting("bcl_a", "Busy Channel Lock-out A", RadioSettingValueBoolean(_settings.bcl_a)) vfoa_grp.append(rs) # # VFO B Settings # rs = RadioSetting( "workmode_b", "VFO B Workmode", RadioSettingValueList(WORKMODE_LIST, WORKMODE_LIST[_settings.workmode_b])) vfob_grp.append(rs) rs = RadioSetting("work_chb", "VFO B Channel", RadioSettingValueInteger(1, 999, _settings.work_chb)) vfob_grp.append(rs) rs = RadioSetting( "vfob.rxfreq", "VFO B Rx Frequency", RadioSettingValueInteger(134000000, 520000000, _vfob.rxfreq * 10, 5000)) vfob_grp.append(rs) rs = RadioSetting( "vfob.txoffset", "VFO B Tx Offset", RadioSettingValueInteger(0, 520000000, _vfob.txoffset * 10, 5000)) vfob_grp.append(rs) # u16 rxtone; # u16 txtone; rs = RadioSetting( "vfob.power", "VFO B Power", RadioSettingValueList(POWER_LIST, POWER_LIST[_vfob.power])) vfob_grp.append(rs) # shift_dir:2 rs = RadioSetting( "vfob.iswide", "VFO B NBFM", RadioSettingValueList(BANDWIDTH_LIST, BANDWIDTH_LIST[_vfob.iswide])) vfob_grp.append(rs) rs = RadioSetting( "vfob.mute_mode", "VFO B Mute", RadioSettingValueList(SPMUTE_LIST, SPMUTE_LIST[_vfob.mute_mode])) vfob_grp.append(rs) rs = RadioSetting( "vfob.step", "VFO B Step (kHz)", RadioSettingValueList(STEP_LIST, STEP_LIST[_vfob.step])) vfob_grp.append(rs) rs = RadioSetting( "vfob.squelch", "VFO B Squelch", RadioSettingValueList(LIST_10, LIST_10[_vfob.squelch])) vfob_grp.append(rs) rs = RadioSetting("bcl_b", "Busy Channel Lock-out B", RadioSettingValueBoolean(_settings.bcl_b)) vfob_grp.append(rs) # # Key Settings # _msg = str(_settings.dispstr).split("\0")[0] val = RadioSettingValueString(0, 15, _msg) val.set_mutable(True) rs = RadioSetting("dispstr", "Display Message", val) key_grp.append(rs) dtmfchars = "0123456789" _codeobj = _settings.ani_code _code = "".join([dtmfchars[x] for x in _codeobj if int(x) < 0x0A]) val = RadioSettingValueString(3, 6, _code, False) val.set_charset(dtmfchars) rs = RadioSetting("ani_code", "ANI Code", val) def apply_ani_id(setting, obj): value = [] for j in range(0, 6): try: value.append(dtmfchars.index(str(setting.value)[j])) except IndexError: value.append(0xFF) obj.ani_code = value rs.set_apply_callback(apply_ani_id, _settings) key_grp.append(rs) rs = RadioSetting( "pf1_func", "PF1 Key function", RadioSettingValueList(PF1KEY_LIST, PF1KEY_LIST[_settings.pf1_func])) key_grp.append(rs) rs = RadioSetting( "pf3_func", "PF3 Key function", RadioSettingValueList(PF3KEY_LIST, PF3KEY_LIST[_settings.pf3_func])) key_grp.append(rs) # # Limits settings # rs = RadioSetting( "uhf_limits.rx_start", "UHF RX Lower Limit", RadioSettingValueInteger(400000000, 520000000, self._memobj.uhf_limits.rx_start * 10, 5000)) uhf_lmt_grp.append(rs) rs = RadioSetting( "uhf_limits.rx_stop", "UHF RX Upper Limit", RadioSettingValueInteger(400000000, 520000000, self._memobj.uhf_limits.rx_stop * 10, 5000)) uhf_lmt_grp.append(rs) rs = RadioSetting( "uhf_limits.tx_start", "UHF TX Lower Limit", RadioSettingValueInteger(400000000, 520000000, self._memobj.uhf_limits.tx_start * 10, 5000)) uhf_lmt_grp.append(rs) rs = RadioSetting( "uhf_limits.tx_stop", "UHF TX Upper Limit", RadioSettingValueInteger(400000000, 520000000, self._memobj.uhf_limits.tx_stop * 10, 5000)) uhf_lmt_grp.append(rs) rs = RadioSetting( "vhf_limits.rx_start", "VHF RX Lower Limit", RadioSettingValueInteger(134000000, 174997500, self._memobj.vhf_limits.rx_start * 10, 5000)) vhf_lmt_grp.append(rs) rs = RadioSetting( "vhf_limits.rx_stop", "VHF RX Upper Limit", RadioSettingValueInteger(134000000, 174997500, self._memobj.vhf_limits.rx_stop * 10, 5000)) vhf_lmt_grp.append(rs) rs = RadioSetting( "vhf_limits.tx_start", "VHF TX Lower Limit", RadioSettingValueInteger(134000000, 174997500, self._memobj.vhf_limits.tx_start * 10, 5000)) vhf_lmt_grp.append(rs) rs = RadioSetting( "vhf_limits.tx_stop", "VHF TX Upper Limit", RadioSettingValueInteger(134000000, 174997500, self._memobj.vhf_limits.tx_stop * 10, 5000)) vhf_lmt_grp.append(rs) # # OEM info # def _decode(lst): _str = ''.join( [chr(c) for c in lst if chr(c) in chirp_common.CHARSET_ASCII]) return _str def do_nothing(setting, obj): return _str = _decode(self._memobj.oem_info.model) val = RadioSettingValueString(0, 15, _str) val.set_mutable(False) rs = RadioSetting("oem_info.model", "Model", val) rs.set_apply_callback(do_nothing, _settings) oem_grp.append(rs) _str = _decode(self._memobj.oem_info.oem1) val = RadioSettingValueString(0, 15, _str) val.set_mutable(False) rs = RadioSetting("oem_info.oem1", "OEM String 1", val) rs.set_apply_callback(do_nothing, _settings) oem_grp.append(rs) _str = _decode(self._memobj.oem_info.oem2) val = RadioSettingValueString(0, 15, _str) val.set_mutable(False) rs = RadioSetting("oem_info.oem2", "OEM String 2", val) rs.set_apply_callback(do_nothing, _settings) oem_grp.append(rs) _str = _decode(self._memobj.oem_info.version) val = RadioSettingValueString(0, 15, _str) val.set_mutable(False) rs = RadioSetting("oem_info.version", "Software Version", val) rs.set_apply_callback(do_nothing, _settings) oem_grp.append(rs) _str = _decode(self._memobj.oem_info.date) val = RadioSettingValueString(0, 15, _str) val.set_mutable(False) rs = RadioSetting("oem_info.date", "OEM Date", val) rs.set_apply_callback(do_nothing, _settings) oem_grp.append(rs) return group
def get_settings(self): """Translate the bit in the mem_struct into settings in the UI""" sett = self._memobj.settings # basic features of the radio basic = RadioSettingGroup("basic", "Basic Settings") # buttons fkeys = RadioSettingGroup("keys", "Front keys config") top = RadioSettings(basic, fkeys) # Basic val = RadioSettingValueString(0, 35, self._VARIANT) val.set_mutable(False) mod = RadioSetting("not.mod", "Radio version", val) basic.append(mod) tot = RadioSetting("settings.tot", "Time Out Timer (TOT)", RadioSettingValueList(TOT, TOT[int(sett.tot)])) basic.append(tot) minvol = RadioSetting("settings.min_vol", "Minimum volume", RadioSettingValueList(VOL, VOL[int(sett.min_vol)])) basic.append(minvol) ptone = RadioSetting("settings.poweron_tone", "Power On tone", RadioSettingValueBoolean( bool(sett.poweron_tone))) basic.append(ptone) sprog = RadioSetting("settings.dealer_tuning", "Dealer Tuning", RadioSettingValueBoolean( bool(sett.dealer_tuning))) basic.append(sprog) clone = RadioSetting("settings.clone", "Allow clone", RadioSettingValueBoolean( bool(sett.clone))) basic.append(clone) # front keys mon = RadioSetting("settings.kMON", "MON", RadioSettingValueList(KEYS.values(), KEYS.values()[KEYS.keys().index( int(sett.kMON))])) fkeys.append(mon) a = RadioSetting("settings.kA", "A", RadioSettingValueList(KEYS.values(), KEYS.values()[KEYS.keys().index( int(sett.kA))])) fkeys.append(a) scn = RadioSetting("settings.kSCN", "SCN", RadioSettingValueList(KEYS.values(), KEYS.values()[KEYS.keys().index( int(sett.kSCN))])) fkeys.append(scn) da = RadioSetting("settings.kDA", "D/A", RadioSettingValueList(KEYS.values(), KEYS.values()[KEYS.keys().index( int(sett.kDA))])) fkeys.append(da) return top
def add_radio_bool(radio_setting_group, mem_field, ui_name, current, doc=None): setting = RadioSetting(mem_field, ui_name, RadioSettingValueBoolean(bool(current))) radio_setting_group.append(setting)
def get_settings(self): _settings = self._memobj.settings _mem = self._memobj basic = RadioSettingGroup("basic", "Basic Settings") dtmf = RadioSettingGroup("dtmf", "DTMF Settings") top = RadioSettings(basic, dtmf) if _settings.k1shortp > 5: val = 4 else: val = _settings.k1shortp rs = RadioSetting( "k1shortp", "Key 1 Short Press", RadioSettingValueList(LIST_SHORT_PRESS, LIST_SHORT_PRESS[val])) basic.append(rs) if _settings.k1longp > 5: val = 5 else: val = _settings.k1longp rs = RadioSetting( "k1longp", "Key 1 Long Press", RadioSettingValueList(LIST_LONG_PRESS, LIST_LONG_PRESS[val])) basic.append(rs) if _settings.k2shortp > 5: val = 1 else: val = _settings.k2shortp rs = RadioSetting( "k2shortp", "Key 2 Short Press", RadioSettingValueList(LIST_SHORT_PRESS, LIST_SHORT_PRESS[val])) basic.append(rs) if _settings.k2longp > 5: val = 3 else: val = _settings.k2longp rs = RadioSetting( "k2longp", "Key 2 Long Press", RadioSettingValueList(LIST_LONG_PRESS, LIST_LONG_PRESS[val])) basic.append(rs) rs = RadioSetting("vox", "VOX", RadioSettingValueBoolean(not _settings.vox)) basic.append(rs) if _settings.voxg > 8: val = 4 else: val = _settings.voxg + 1 rs = RadioSetting("voxg", "VOX Gain", RadioSettingValueInteger(1, 9, val)) basic.append(rs) rs = RadioSetting( "voxd", "VOX Delay Time", RadioSettingValueList(LIST_VOXDELAY, LIST_VOXDELAY[_settings.voxd])) basic.append(rs) rs = RadioSetting("voxi", "VOX Inhibit on Receive", RadioSettingValueBoolean(_settings.voxi)) basic.append(rs) if _settings.squelch > 9: val = 5 else: val = _settings.squelch rs = RadioSetting("squelch", "Squelch Level", RadioSettingValueInteger(0, 9, val)) basic.append(rs) if _settings.voice == 3: val = 1 else: val = _settings.voice rs = RadioSetting("voice", "Voice Prompts", RadioSettingValueList(LIST_VOICE, LIST_VOICE[val])) basic.append(rs) rs = RadioSetting("tone", "Tone", RadioSettingValueBoolean(_settings.tone)) basic.append(rs) rs = RadioSetting("lovoltnotx", "TX Inhibit (when battery < 6 volts)", RadioSettingValueBoolean(_settings.lovoltnotx)) basic.append(rs) rs = RadioSetting("hivoltnotx", "TX Inhibit (when battery > 9 volts)", RadioSettingValueBoolean(_settings.hivoltnotx)) basic.append(rs) if _settings.tot > 0x28: val = 6 else: val = _settings.tot rs = RadioSetting( "tot", "Time-out Timer[s]", RadioSettingValueList(LIST_TIMEOUTTIMER, LIST_TIMEOUTTIMER[val])) basic.append(rs) if _settings.save < 3: val = 0 else: val = _settings.save - 3 rs = RadioSetting("save", "Battery Saver", RadioSettingValueList(LIST_SAVE, LIST_SAVE[val])) basic.append(rs) rs = RadioSetting( "ssave", "Super Battery Saver[s]", RadioSettingValueList(LIST_SSAVE, LIST_SSAVE[_settings.ssave])) basic.append(rs) rs = RadioSetting("fmradio", "Broadcast FM", RadioSettingValueBoolean(_settings.fmradio)) basic.append(rs) if _settings.scanspeed > 8: val = 4 else: val = _settings.scanspeed rs = RadioSetting( "scanspeed", "Scan Speed[ms]", RadioSettingValueList(LIST_SCANSPEED, LIST_SCANSPEED[val])) basic.append(rs) if _settings.scandelay > 27: val = 12 else: val = _settings.scandelay rs = RadioSetting( "scandelay", "Scan Droupout Delay Time[s]", RadioSettingValueList(LIST_SCANDELAY, LIST_SCANDELAY[val])) basic.append(rs) if _mem.dtmf.dtmfspd > 11: val = 2 else: val = _mem.dtmf.dtmfspd + 4 rs = RadioSetting("dtmf.dtmfspd", "DTMF Speed[digit/s]", RadioSettingValueInteger(4, 15, val)) dtmf.append(rs) if _mem.dtmf.digtime > 10: val = 0 else: val = _mem.dtmf.digtime rs = RadioSetting( "dtmf.digtime", "1st Digit Time[ms]", RadioSettingValueList(LIST_DIGTIME, LIST_DIGTIME[val])) dtmf.append(rs) if _mem.dtmf.digdelay > 9: val = 0 else: val = _mem.dtmf.digdelay rs = RadioSetting( "dtmf.digdelay", "1st Digit Delay[ms]", RadioSettingValueList(LIST_DIGDELAY, LIST_DIGDELAY[val])) dtmf.append(rs) rs = RadioSetting( "dtmf.starhash", "* and # Time[ms]", RadioSettingValueList(LIST_STARHASH, LIST_STARHASH[_mem.dtmf.starhash])) dtmf.append(rs) rs = RadioSetting( "dtmf.codespace", "Code Space Time[ms]", RadioSettingValueList(LIST_CODESPACE, LIST_CODESPACE[_mem.dtmf.codespace])) dtmf.append(rs) rs = RadioSetting("dtmf.sidetone", "DTMF Sidetone", RadioSettingValueBoolean(_mem.dtmf.sidetone)) dtmf.append(rs) # setup pttid entries for i in range(0, 2): objname = "code" + str(i + 1) names = ["PTT ID(BOT)", "PTT ID(EOT)"] strname = str(names[i]) dtmfsetting = getattr(_mem.dtmf, objname) dtmflen = getattr(_mem.dtmf, objname + "_len") dtmfstr = self._bbcd2dtmf(dtmfsetting, dtmflen) code = RadioSettingValueString(0, 16, dtmfstr) code.set_charset(DTMF_CHARSET + list(" ")) rs = RadioSetting("dtmf." + objname, strname, code) dtmf.append(rs) def _filter(name): filtered = "" for char in str(name): if char in NUMERIC_CHARSET: filtered += char else: filtered += " " return filtered # setup id code entry codesetting = getattr(_mem.dtmf, "idcode") codestr = self._bbcd2num(codesetting, 6) code = RadioSettingValueString(0, 6, _filter(codestr)) code.set_charset(NUMERIC_CHARSET + list(" ")) rs = RadioSetting("dtmf.idcode", "ID Code", code) dtmf.append(rs) if _mem.dtmf.groupcode > 6: val = 0 else: val = _mem.dtmf.groupcode rs = RadioSetting( "dtmf.groupcode", "Group Code", RadioSettingValueList(LIST_GROUPCODE, LIST_GROUPCODE[val])) dtmf.append(rs) if _mem.dtmf.resettime > 60: val = 0 else: val = _mem.dtmf.resettime rs = RadioSetting( "dtmf.resettime", "Auto Reset Time[s]", RadioSettingValueList(LIST_RESETTIME, LIST_RESETTIME[_mem.dtmf.resettime])) dtmf.append(rs) rs = RadioSetting("dtmf.txdecode", "TX Decode", RadioSettingValueBoolean(_mem.dtmf.txdecode)) dtmf.append(rs) rs = RadioSetting( "dtmf.decodeto", "Decode Time Out[ms]", RadioSettingValueList(LIST_DECODETO, LIST_DECODETO[_mem.dtmf.decodeto])) dtmf.append(rs) rs = RadioSetting("dtmf.decodetone", "Decode Tone", RadioSettingValueBoolean(_mem.dtmf.decodetone)) dtmf.append(rs) rs = RadioSetting("dtmf.resettone", "Reset Tone", RadioSettingValueBoolean(_mem.dtmf.resettone)) dtmf.append(rs) rs = RadioSetting( "dtmf.stuntype", "Stun Type", RadioSettingValueList(LIST_STUNTYPE, LIST_STUNTYPE[_mem.dtmf.stuntype])) dtmf.append(rs) # setup stun entry objname = "code3" strname = "Stun Code" dtmfsetting = getattr(_mem.dtmf, objname) dtmflen = getattr(_mem.dtmf, objname + "_len") dtmfstr = self._bbcd2dtmf(dtmfsetting, dtmflen) code = RadioSettingValueString(0, 10, dtmfstr) code.set_charset(DTMF_CHARSET + list(" ")) rs = RadioSetting("dtmf." + objname, strname, code) dtmf.append(rs) return top
def _get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic") arts = RadioSettingGroup("arts", "ARTS") dtmf = RadioSettingGroup("dtmf", "DTMF") wires = RadioSettingGroup("wires", "WIRES") misc = RadioSettingGroup("misc", "Misc") top = RadioSettings(basic, arts, dtmf, wires, misc) # BASIC val = RadioSettingValueList(self._APO, self._APO[_settings.auto_power_off]) rs = RadioSetting("auto_power_off", "Auto Power Off", val) basic.append(rs) val = RadioSettingValueList(self._BEEP_LEVEL, self._BEEP_LEVEL[_settings.beep_level]) rs = RadioSetting("beep_level", "Beep Level", val) basic.append(rs) val = RadioSettingValueList(self._DIM_LEVEL, self._DIM_LEVEL[_settings.lcd_dimmer]) rs = RadioSetting("lcd_dimmer", "Dimmer Level", val) basic.append(rs) val = RadioSettingValueList(self._LAMP, self._LAMP[_settings.lamp]) rs = RadioSetting("lamp", "Keypad Lamp", val) basic.append(rs) val = RadioSettingValueList(self._LOCK, self._LOCK[_settings.lock]) rs = RadioSetting("lock", "Lock", val) basic.append(rs) val = RadioSettingValueList(self._NUM_1_9, self._NUM_1_9[_settings.mic_gain]) rs = RadioSetting("mic_gain", "Mic Gain", val) basic.append(rs) val = RadioSettingValueList( self._OPEN_MSG, self._OPEN_MSG[_settings.open_message_mode]) rs = RadioSetting("open_message_mode", "Open Message Mode", val) basic.append(rs) val = RadioSettingValueString( 0, 6, self._decode_chars(_settings.open_message)) val.set_charset(CHARSET) rs = RadioSetting("open_message", "Opening Message", val) basic.append(rs) passstr = "" for c in _settings.password: if c < len(PASS_CHARSET): passstr += PASS_CHARSET[c] val = RadioSettingValueString(0, 4, passstr) val.set_charset(PASS_CHARSET) rs = RadioSetting("password", "Password", val) basic.append(rs) val = RadioSettingValueList(self._RESUME, self._RESUME[_settings.resume]) rs = RadioSetting("resume", "Scan Resume", val) basic.append(rs) val = RadioSettingValueList(self._MONI_TCALL, self._MONI_TCALL[_settings.moni_tcall]) rs = RadioSetting("moni_tcall", "MONI/T-CALL switch", val) basic.append(rs) rs = RadioSetting("scan_lamp", "Scan Lamp", RadioSettingValueBoolean(_settings.scan_lamp)) basic.append(rs) rs = RadioSetting("beep", "Keypad Beep", RadioSettingValueBoolean(_settings.beep)) basic.append(rs) rs = RadioSetting("busy_led", "Busy LED", RadioSettingValueBoolean(_settings.busy_led)) basic.append(rs) rs = RadioSetting("bclo", "Busy Channel Lock-Out", RadioSettingValueBoolean(_settings.bclo)) basic.append(rs) rs = RadioSetting("wx_alert", "WX Alert", RadioSettingValueBoolean(_settings.wx_alert)) basic.append(rs) rs = RadioSetting("att", "Attenuator", RadioSettingValueBoolean(_settings.att)) basic.append(rs) # ARTS val = RadioSettingValueList(self._ARTS_INT, self._ARTS_INT[_settings.arts_interval]) rs = RadioSetting("arts_interval", "ARTS Interval", val) arts.append(rs) val = RadioSettingValueList(self._ARTSBEEP, self._ARTSBEEP[_settings.arts_beep]) rs = RadioSetting("arts_beep", "ARTS Beep", val) arts.append(rs) rs = RadioSetting("arts_cwid", "ARTS Send CWID", RadioSettingValueBoolean(_settings.arts_cwid)) arts.append(rs) val = RadioSettingValueString( 0, 16, self._decode_chars(_settings.arts_cwid_alpha)) val.set_charset(CHARSET) rs = RadioSetting("arts_cwid_alpha", "ARTS CW ID", val) arts.append(rs) # DTMF val = RadioSettingValueList(self._MAN_AUTO, self._MAN_AUTO[_settings.dtmf_autodial]) rs = RadioSetting("dtmf_autodial", "DTMF Autodial", val) dtmf.append(rs) val = RadioSettingValueList(self._NUM_0_9, self._NUM_0_9[_settings.last_dtmf]) rs = RadioSetting("last_dtmf", "Last DTMF Memory Set", val) dtmf.append(rs) for i in range(10): name = "dtmf_" + str(i) dtmfsetting = self._memobj.dtmf[i] dtmfstr = "" for c in dtmfsetting.memory: if c < len(DTMFCHARSET): dtmfstr += DTMFCHARSET[c] dtmfentry = RadioSettingValueString(0, 16, dtmfstr) rs = RadioSetting(name, name.upper(), dtmfentry) dtmf.append(rs) # WIRES val = RadioSettingValueList(self._INT_CD, self._INT_CD[_settings.internet_code]) rs = RadioSetting("internet_code", "Internet Code", val) wires.append(rs) val = RadioSettingValueList(self._INT_MD, self._INT_MD[_settings.internet_mode]) rs = RadioSetting("internet_mode", "Internet Link Connection mode", val) wires.append(rs) val = RadioSettingValueList(self._MAN_AUTO, self._MAN_AUTO[_settings.int_autodial]) rs = RadioSetting("int_autodial", "Internet Autodial", val) wires.append(rs) val = RadioSettingValueList( self._NUM_0_63, self._NUM_0_63[_settings.last_internet_dtmf]) rs = RadioSetting("last_internet_dtmf", "Last Internet DTMF Memory Set", val) wires.append(rs) for i in range(64): name = "wires_dtmf_" + str(i) dtmfsetting = self._memobj.internet_dtmf[i] dtmfstr = "" for c in dtmfsetting.memory: if c < len(DTMFCHARSET): dtmfstr += DTMFCHARSET[c] dtmfentry = RadioSettingValueString(0, 8, dtmfstr) rs = RadioSetting(name, name.upper(), dtmfentry) wires.append(rs) # MISC val = RadioSettingValueList(self._BELL, self._BELL[_settings.bell]) rs = RadioSetting("bell", "CTCSS/DCS Bell", val) misc.append(rs) val = RadioSettingValueList( self._CH_CNT, self._CH_CNT[_settings.channel_counter_width]) rs = RadioSetting("channel_counter_width", "Channel Counter Search Width", val) misc.append(rs) val = RadioSettingValueList(self._EMERGENCY, self._EMERGENCY[_settings.emergency]) rs = RadioSetting("emergency", "Emergency alarm", val) misc.append(rs) val = RadioSettingValueList(self._ON_TIMER, self._ON_TIMER[_settings.on_timer]) rs = RadioSetting("on_timer", "On Timer", val) misc.append(rs) rs = RadioSetting( "pager_answer_back", "Pager Answer Back", RadioSettingValueBoolean(_settings.pager_answer_back)) misc.append(rs) val = RadioSettingValueList(self._NUM_1_50, self._NUM_1_50[_settings.pager_rx_tone1]) rs = RadioSetting("pager_rx_tone1", "Pager RX Tone 1", val) misc.append(rs) val = RadioSettingValueList(self._NUM_1_50, self._NUM_1_50[_settings.pager_rx_tone2]) rs = RadioSetting("pager_rx_tone2", "Pager RX Tone 2", val) misc.append(rs) val = RadioSettingValueList(self._NUM_1_50, self._NUM_1_50[_settings.pager_tx_tone1]) rs = RadioSetting("pager_tx_tone1", "Pager TX Tone 1", val) misc.append(rs) val = RadioSettingValueList(self._NUM_1_50, self._NUM_1_50[_settings.pager_tx_tone2]) rs = RadioSetting("pager_tx_tone2", "Pager TX Tone 2", val) misc.append(rs) val = RadioSettingValueList(self._PTT_DELAY, self._PTT_DELAY[_settings.ptt_delay]) rs = RadioSetting("ptt_delay", "PTT Delay", val) misc.append(rs) val = RadioSettingValueList(self._RF_SQL, self._RF_SQL[_settings.rf_squelch]) rs = RadioSetting("rf_squelch", "RF Squelch", val) misc.append(rs) val = RadioSettingValueList(self._RX_SAVE, self._RX_SAVE[_settings.rx_save]) rs = RadioSetting("rx_save", "RX Save", val) misc.append(rs) val = RadioSettingValueList(self._TOT, self._TOT[_settings.tx_timeout]) rs = RadioSetting("tx_timeout", "TOT", val) misc.append(rs) val = RadioSettingValueList(self._WAKEUP, self._WAKEUP[_settings.wakeup]) rs = RadioSetting("wakeup", "Wakeup", val) misc.append(rs) rs = RadioSetting("edge_beep", "Band-Edge Beep", RadioSettingValueBoolean(_settings.edge_beep)) misc.append(rs) val = RadioSettingValueList(self._VFO_MODE, self._VFO_MODE[_settings.vfo_mode]) rs = RadioSetting("vfo_mode", "VFO Band Edge Limiting", val) misc.append(rs) rs = RadioSetting("tone_search_mute", "Tone Search Mute", RadioSettingValueBoolean(_settings.tone_search_mute)) misc.append(rs) val = RadioSettingValueList(self._TS_SPEED, self._TS_SPEED[_settings.ts_speed]) rs = RadioSetting("ts_speed", "Tone Search Speed", val) misc.append(rs) rs = RadioSetting("dmr_wrt", "Direct Memory Recall Overwrite", RadioSettingValueBoolean(_settings.dmr_wrt)) misc.append(rs) rs = RadioSetting("tx_saver", "TX Battery Saver", RadioSettingValueBoolean(_settings.tx_saver)) misc.append(rs) val = RadioSettingValueList(self._SMART_SEARCH, self._SMART_SEARCH[_settings.smart_search]) rs = RadioSetting("smart_search", "Smart Search", val) misc.append(rs) val = RadioSettingValueList(self._HOME_REV, self._HOME_REV[_settings.home_rev]) rs = RadioSetting("home_rev", "HM/RV(EMG)R/H key", val) misc.append(rs) val = RadioSettingValueList(self._MEM_W_MD, self._MEM_W_MD[_settings.memory_method]) rs = RadioSetting("memory_method", "Memory Write Method", val) misc.append(rs) return top
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic") sound = RadioSettingGroup("sound", "Sound") dtmf = RadioSettingGroup("dtmf", "DTMF") arts = RadioSettingGroup("arts", "ARTS") eai = RadioSettingGroup("eai", "Emergency") msg = RadioSettingGroup("msg", "Messages") top = RadioSettings(basic, sound, arts, dtmf, eai, msg) basic.append(RadioSetting( "att_wx", "Attenuation WX", RadioSettingValueBoolean(_settings.att_wx))) basic.append(RadioSetting( "att_marine", "Attenuation Marine", RadioSettingValueBoolean(_settings.att_marine))) basic.append(RadioSetting( "att_broadcast", "Attenuation Broadcast", RadioSettingValueBoolean(_settings.att_broadcast))) basic.append(RadioSetting( "ars", "Auto Repeater Shift", RadioSettingValueBoolean(_settings.ars))) basic.append(RadioSetting( "home_vfo", "Home->VFO", RadioSettingValueBoolean(_settings.home_vfo))) basic.append(RadioSetting( "bclo", "Busy Channel Lockout", RadioSettingValueBoolean(_settings.bclo))) basic.append(RadioSetting( "busyled", "Busy LED", RadioSettingValueBoolean(_settings.busy_led))) basic.append(RadioSetting( "fast_tone_search", "Fast Tone search", RadioSettingValueBoolean(_settings.fast_tone_search))) basic.append(RadioSetting( "priority_revert", "Priority Revert", RadioSettingValueBoolean(_settings.priority_revert))) basic.append(RadioSetting( "protect_memory", "Protect memory", RadioSettingValueBoolean(_settings.protect_memory))) basic.append(RadioSetting( "scan_lamp", "Scan Lamp", RadioSettingValueBoolean(_settings.scan_lamp))) basic.append(RadioSetting( "split_tone", "Split tone", RadioSettingValueBoolean(_settings.split_tone))) basic.append(RadioSetting( "tone_search_mute", "Tone search mute", RadioSettingValueBoolean(_settings.tone_search_mute))) basic.append(RadioSetting( "txsave", "TX save", RadioSettingValueBoolean(_settings.txsave))) basic.append(RadioSetting( "wx_alert", "WX Alert", RadioSettingValueBoolean(_settings.wx_alert))) opts = ["Bar Int", "Bar Ext"] basic.append(RadioSetting( "am_antenna", "AM antenna", RadioSettingValueList(opts, opts[_settings.am_antenna]))) opts = ["Ext Ant", "Earphone"] basic.append(RadioSetting( "fm_antenna", "FM antenna", RadioSettingValueList(opts, opts[_settings.fm_antenna]))) opts = ["off"] + ["%0.1f" % (t / 60.0) for t in range(30, 750, 30)] basic.append(RadioSetting( "apo", "APO time (hrs)", RadioSettingValueList(opts, opts[_settings.apo]))) opts = ["+/- 5 MHZ", "+/- 10 MHZ", "+/- 50 MHZ", "+/- 100 MHZ"] basic.append(RadioSetting( "channel_counter", "Channel counter", RadioSettingValueList(opts, opts[_settings.channel_counter]))) opts = ["0.3", "0.5", "0.7", "1.0", "1.5"] basic.append(RadioSetting( "fw_key_timer", "FW key timer (s)", RadioSettingValueList(opts, opts[_settings.fw_key_timer]))) opts = ["Home", "Reverse"] basic.append(RadioSetting( "hm_rv", "HM/RV key", RadioSettingValueList(opts, opts[_settings.hm_rv]))) opts = ["%d" % t for t in range(2, 11)] + ["continuous", "off"] basic.append(RadioSetting( "lamp", "Lamp Timer (s)", RadioSettingValueList(opts, opts[_settings.lamp]))) basic.append(RadioSetting( "lock", "Lock", RadioSettingValueBoolean(_settings.lock))) opts = ["key", "ptt", "key+ptt"] basic.append(RadioSetting( "lock_mode", "Lock mode", RadioSettingValueList(opts, opts[_settings.lock_mode]))) opts = ["10", "20", "50", "100"] basic.append(RadioSetting( "mem_ch_step", "Memory Chan step", RadioSettingValueList(opts, opts[_settings.mem_ch_step]))) opts = ["lower", "next"] basic.append(RadioSetting( "mem_storage", "Memory storage mode", RadioSettingValueList(opts, opts[_settings.mem_storage]))) opts = ["%d" % t for t in range(1, 10)] basic.append(RadioSetting( "mic_gain", "Mic gain", RadioSettingValueList(opts, opts[_settings.mic_gain]))) opts = ["monitor", "tone call"] basic.append(RadioSetting( "moni_tcall", "Moni/TCall button", RadioSettingValueList(opts, opts[_settings.moni_tcall]))) opts = ["off"] + \ ["%02d:%02d" % (t / 60, t % 60) for t in range(10, 1450, 10)] basic.append(RadioSetting( "on_timer", "On Timer (hrs)", RadioSettingValueList(opts, opts[_settings.on_timer]))) opts2 = ["off"] + \ ["0.%d" % t for t in range(1, 10)] + \ ["%1.1f" % (t / 10.0) for t in range(10, 105, 5)] basic.append(RadioSetting( "priority_time", "Priority time", RadioSettingValueList(opts2, opts2[_settings.priority_time]))) opts = ["off", "20", "50", "100", "200"] basic.append(RadioSetting( "ptt_delay", "PTT delay (ms)", RadioSettingValueList(opts, opts[_settings.ptt_delay]))) basic.append(RadioSetting( "rx_save", "RX save (s)", RadioSettingValueList(opts2, opts2[_settings.rx_save]))) basic.append(RadioSetting( "scan_restart", "Scan restart (s)", RadioSettingValueList(opts2, opts2[_settings.scan_restart]))) opts = ["%1.1f" % (t / 10.0) for t in range(20, 105, 5)] + \ ["busy", "hold"] basic.append(RadioSetting( "scan_resume", "Scan resume (s)", RadioSettingValueList(opts, opts[_settings.scan_resume]))) opts = ["single", "continuous"] basic.append(RadioSetting( "smart_search", "Smart search", RadioSettingValueList(opts, opts[_settings.smart_search]))) opts = ["off"] + ["TRX %d" % t for t in range(1, 11)] + ["hold"] + \ ["TX %d" % t for t in range(1, 11)] basic.append(RadioSetting( "sub_rx_timer", "Sub RX timer", RadioSettingValueList(opts, opts[_settings.sub_rx_timer]))) opts = ["C", "F"] basic.append(RadioSetting( "temp_unit", "Temperature unit", RadioSettingValueList(opts, opts[_settings.temp_unit]))) opts = ["off"] + ["%1.1f" % (t / 10.0) for t in range(5, 105, 5)] basic.append(RadioSetting( "tot", "Time-out timer (mins)", RadioSettingValueList(opts, opts[_settings.tot]))) opts = ["all", "band"] basic.append(RadioSetting( "vfo_mode", "VFO mode", RadioSettingValueList(opts, opts[_settings.vfo_mode]))) opts = ["off"] + ["%d" % t for t in range(5, 65, 5)] + ["EAI"] basic.append(RadioSetting( "wake_up", "Wake up (s)", RadioSettingValueList(opts, opts[_settings.wake_up]))) opts = ["hold", "3 secs"] basic.append(RadioSetting( "vol_key_mode", "Volume key mode", RadioSettingValueList(opts, opts[_settings.vol_key_mode]))) # subgroup programmable keys opts = ["INTNET", "INT MR", "Set Mode (my key)"] basic.append(RadioSetting( "internet_key", "Internet key", RadioSettingValueList(opts, opts[_settings.internet_key]))) keys = ["Antenna AM", "Antenna FM", "Antenna Attenuator", "Auto Power Off", "Auto Repeater Shift", "ARTS Beep", "ARTS Interval", "Busy Channel Lockout", "Bell Ringer", "Bell Select", "Bank Name", "Band Edge Beep", "Beep Level", "Beep Select", "Beep User", "Busy LED", "Channel Counter", "Clock Shift", "CW ID", "CW Learning", "CW Pitch", "CW Training", "DC Voltage", "DCS Code", "DCS Reverse", "DTMF A/M", "DTMF Delay", "DTMF Set", "DTMF Speed", "EAI Timer", "Emergency Alarm", "Ext Menu", "FW Key", "Half Deviation", "Home/Reverse", "Home > VFO", "INT Code", "INT Conn Mode", "INT A/M", "INT Set", "INT Key", "INTNET", "Lamp", "LED Light", "Lock", "Moni/T-Call", "Mic Gain", "Memory Display", "Memory Write Mode", "Memory Channel Step", "Memory Name Write", "Memory Protect", "Memory Skip", "Message List", "Message Reg", "Message Set", "On Timer", "Open Message", "Pager Answer Back", "Pager Receive Code", "Pager Transmit Code", "Pager Frequency", "Priority Revert", "Priority Timer", "Password", "PTT Delay", "Repeater Shift Direction", "Repeater Shift", "Receive Mode", "Smart Search", "Save Rx", "Save Tx", "Scan Lamp", "Scan Resume", "Scan Restart", "Speaker Out", "Squelch Level", "Squelch Type", "Squelch S Meter", "Squelch Split Tone", "Step", "Stereo", "Sub Rx", "Temp", "Tone Frequency", "Time Out Timer", "Tone Search Mute", "Tone Search Speed", "VFO Band", "VFO Skip", "Volume Mode", "Wake Up", "Weather Alert"] rs = RadioSetting( "my_key", "My key", RadioSettingValueList(keys, keys[_settings.my_key - 16])) # TODO: fix keys list isnt exactly right order # leave disabled in settings for now # basic.append(rs) # sound tab sound.append(RadioSetting( "band_edge_beep", "Band edge beep", RadioSettingValueBoolean(_settings.band_edge_beep))) opts = ["off", "key+scan", "key"] sound.append(RadioSetting( "beep_mode", "Beep mode", RadioSettingValueList(opts, opts[_settings.beep_mode]))) _volumes = self._memobj.volumes opts = map(str, range(0, 33)) sound.append(RadioSetting( "speaker_vol", "Speaker volume", RadioSettingValueList(opts, opts[_volumes.speaker]))) sound.append(RadioSetting( "earphone_vol", "Earphone volume", RadioSettingValueList(opts, opts[_volumes.earphone]))) opts = ["auto", "speaker"] sound.append(RadioSetting( "fm_speaker_out", "FM Speaker out", RadioSettingValueList(opts, opts[_settings.fm_speaker_out]))) opts = ["mono", "stereo"] sound.append(RadioSetting( "fm_broadcast_mode", "FM broadcast mode", RadioSettingValueList( opts, opts[_settings.fm_broadcast_mode]))) opts = map(str, range(16)) sound.append(RadioSetting( "sql_fm", "Squelch level (FM)", RadioSettingValueList(opts, opts[_settings.sql_fm]))) opts = map(str, range(9)) sound.append(RadioSetting( "sql_wfm", "Squelch level (WFM)", RadioSettingValueList(opts, opts[_settings.sql_wfm]))) opts = map(str, range(16)) sound.append(RadioSetting( "radio_am_sql", "Squelch level (Broadcast Radio AM)", RadioSettingValueList(opts, opts[_settings.radio_am_sql]))) opts = map(str, range(9)) sound.append(RadioSetting( "radio_fm_sql", "Squelch level (Broadcast Radio FM)", RadioSettingValueList(opts, opts[_settings.radio_fm_sql]))) # dtmf tab opts = ["manual", "auto"] dtmf.append(RadioSetting( "dtmf_autodialer", "DTMF autodialer mode", RadioSettingValueList(opts, opts[_settings.dtmf_autodialer]))) opts = ["50", "250", "450", "750", "1000"] dtmf.append(RadioSetting( "dtmf_delay", "DTMF delay (ms)", RadioSettingValueList(opts, opts[_settings.dtmf_delay]))) opts = ["50", "100"] dtmf.append(RadioSetting( "dtmf_speed", "DTMF speed (ms)", RadioSettingValueList(opts, opts[_settings.dtmf_speed]))) opts = map(str, range(10)) dtmf.append(RadioSetting( "dtmf_chan_active", "DTMF active", RadioSettingValueList( opts, opts[_settings.dtmf_chan_active]))) 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] LOG.debug(dtmfstr) dtmfentry = RadioSettingValueString(0, 16, dtmfstr) dtmfentry.set_charset(DTMFCHARSET + list(" ")) rs = RadioSetting(name, name.upper(), dtmfentry) dtmf.append(rs) # arts tab arts.append(RadioSetting( "arts", "ARTS", RadioSettingValueBoolean(_settings.arts))) opts = ["off", "in range", "always"] arts.append(RadioSetting( "arts_beep", "ARTS beep", RadioSettingValueList(opts, opts[_settings.arts_beep]))) opts = ["15", "25"] arts.append(RadioSetting( "arts_interval", "ARTS interval", RadioSettingValueList(opts, opts[_settings.arts_interval]))) arts.append(RadioSetting( "arts_cwid_enable", "CW ID", RadioSettingValueBoolean(_settings.arts_cwid_enable))) cwid = RadioSettingValueString( 0, 16, self._decode_chars(_settings.arts_cwid.get_value())) cwid.set_charset(CHARSET) arts.append(RadioSetting("arts_cwid", "CW ID", cwid)) # EAI tab eai.append(RadioSetting( "emergency_eai", "EAI", RadioSettingValueBoolean(_settings.emergency_eai))) opts = ["interval %dm" % t for t in range(1, 10)] + \ ["interval %dm" % t for t in range(10, 55, 5)] + \ ["continuous %dm" % t for t in range(1, 10)] + \ ["continuous %dm" % t for t in range(10, 55, 5)] eai.append(RadioSetting( "emergency_eai_time", "EAI time", RadioSettingValueList( opts, opts[_settings.emergency_eai_time]))) opts = ["beep", "strobe", "beep+strobe", "beam", "beep+beam", "cw", "beep+cw", "cwt"] eai.append(RadioSetting( "emergency_signal", "emergency signal", RadioSettingValueList( opts, opts[_settings.emergency_signal]))) # msg tab opts = ["off", "dc voltage", "message"] msg.append(RadioSetting( "openmsg_mode", "Opening message mode", RadioSettingValueList(opts, opts[_settings.openmsg_mode]))) openmsg = RadioSettingValueString( 0, 6, self._decode_chars(_settings.openmsg.get_value())) openmsg.set_charset(CHARSET) msg.append(RadioSetting("openmsg", "Opening Message", openmsg)) return top
def get_memory(self, number): _mem = self._memory_obj()[number - 1] mem = chirp_common.Memory() mem.number = number if _mem.get_raw()[0] == "\xff": mem.empty = True return mem mem.freq = int(_mem.rxfreq) * 10 if _mem.txfreq == 0xFFFFFFFF: # TX freq not set mem.duplex = "off" mem.offset = 0 elif int(_mem.rxfreq) == int(_mem.txfreq): mem.duplex = "" mem.offset = 0 elif _split(self.get_features(), mem.freq, int(_mem.txfreq) * 10): mem.duplex = "split" mem.offset = int(_mem.txfreq) * 10 else: mem.duplex = int(_mem.rxfreq) > int(_mem.txfreq) and "-" or "+" mem.offset = abs(int(_mem.rxfreq) - int(_mem.txfreq)) * 10 for char in _mem.name[:_mem.namelen]: mem.name += chr(char) dtcs_pol = ["N", "N"] if _mem.rxtone == 0x3FFF: rxmode = "" elif _mem.is_rxdigtone == 0: # CTCSS rxmode = "Tone" mem.ctone = int(_mem.rxtone) / 10.0 else: # Digital rxmode = "DTCS" mem.rx_dtcs = self._get_dcs(_mem.rxtone) if _mem.rxdtcs_pol == 1: dtcs_pol[1] = "R" if _mem.txtone == 0x3FFF: txmode = "" elif _mem.is_txdigtone == 0: # CTCSS txmode = "Tone" mem.rtone = int(_mem.txtone) / 10.0 else: # Digital txmode = "DTCS" mem.dtcs = self._get_dcs(_mem.txtone) if _mem.txdtcs_pol == 1: dtcs_pol[0] = "R" if txmode == "Tone" and not rxmode: mem.tmode = "Tone" elif txmode == rxmode and txmode == "Tone" and mem.rtone == mem.ctone: mem.tmode = "TSQL" elif txmode == rxmode and txmode == "DTCS" and mem.dtcs == mem.rx_dtcs: mem.tmode = "DTCS" elif rxmode or txmode: mem.tmode = "Cross" mem.cross_mode = "%s->%s" % (txmode, rxmode) mem.dtcs_polarity = "".join(dtcs_pol) mem.mode = _mem.wide and "FM" or "NFM" mem.power = POWER_LEVELS[_mem.power] # Extra mem.extra = RadioSettingGroup("extra", "Extra") if _mem.recvmode == 0xFF: val = 0x00 else: val = _mem.recvmode recvmode = RadioSetting( "recvmode", "Receiving mode", RadioSettingValueList(LIST_RECVMODE, LIST_RECVMODE[val])) mem.extra.append(recvmode) if _mem.botsignal == 0xFF: val = 0x00 else: val = _mem.botsignal botsignal = RadioSetting( "botsignal", "Launch signaling", RadioSettingValueList(LIST_SIGNAL, LIST_SIGNAL[val])) mem.extra.append(botsignal) if _mem.eotsignal == 0xFF: val = 0x00 else: val = _mem.eotsignal rx = RadioSettingValueList(LIST_SIGNAL, LIST_SIGNAL[val]) eotsignal = RadioSetting("eotsignal", "Transmit end signaling", rx) mem.extra.append(eotsignal) rx = RadioSettingValueBoolean(bool(_mem.compandor)) compandor = RadioSetting("compandor", "Compandor", rx) mem.extra.append(compandor) rx = RadioSettingValueBoolean(bool(_mem.scrambler)) scrambler = RadioSetting("scrambler", "Scrambler", rx) mem.extra.append(scrambler) return mem
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic") dtmf = RadioSettingGroup("dtmf", "DTMF") arts = RadioSettingGroup("arts", "ARTS") top = RadioSettingGroup("top", "All Settings", basic, arts, dtmf) options = [ "off", "30m", "1h", "3h", "5h", "8h" ] rs = RadioSetting("apo", "APO time (hrs)", RadioSettingValueList(options, options[_settings.apo])) basic.append(rs) rs = RadioSetting("ars", "Auto Repeater Shift", RadioSettingValueBoolean(_settings.ars)) basic.append(rs) rs = RadioSetting("att", "Attenuation", RadioSettingValueBoolean(_settings.att)) basic.append(rs) rs = RadioSetting("bclo", "Busy Channel Lockout", RadioSettingValueBoolean(_settings.bclo)) basic.append(rs) rs = RadioSetting("beep", "Beep", RadioSettingValueBoolean(_settings.beep)) basic.append(rs) options = [ "off", "1", "3", "5", "8", "cont"] rs = RadioSetting("bell", "Bell", RadioSettingValueList(options, options[_settings.bell])) basic.append(rs) rs = RadioSetting("busyled", "Busy LED", RadioSettingValueBoolean(_settings.busyled)) basic.append(rs) options = [ "5", "10", "50", "100" ] rs = RadioSetting("chcounter", "Channel Counter (MHz)", RadioSettingValueList(options, options[_settings.chcounter])) basic.append(rs) rs = RadioSetting("dcsrev", "DCS Reverse", RadioSettingValueBoolean(_settings.dcsrev)) basic.append(rs) options = map(str, range(0,12+1)) rs = RadioSetting("dimmer", "Dimmer", RadioSettingValueList(options, options[_settings.dimmer])) basic.append(rs) rs = RadioSetting("edgebeep", "Edge Beep", RadioSettingValueBoolean(_settings.edgebeep)) basic.append(rs) options = [ "beep", "strobe", "bp+str", "beam", "bp+beam", "cw", "bp+cw" ] rs = RadioSetting("emergmode", "Emergency Mode", RadioSettingValueList(options, options[_settings.emergmode])) basic.append(rs) options = ["Home", "Reverse"] rs = RadioSetting("hmrv", "HM/RV key", RadioSettingValueList(options, options[_settings.hmrv])) basic.append(rs) options = ["My Menu", "Internet"] rs = RadioSetting("internet_key", "Internet key", RadioSettingValueList(options, options[_settings.internet_key])) basic.append(rs) options = ["1 APO","2 AR BEP","3 AR INT","4 ARS","5 ATT","6 BCLO","7 BEEP","8 BELL", "9 BSYLED","10 CH CNT","11 CK SFT","12 CW ID","13 DC VLT","14 DCS CD","15 DCS RV", "16 DIMMER","17 DTMF","18 DTMF S","19 EDG BP","20 EMG S","21 HLFDEV","22 HM/RV", "23 INT MD","24 LAMP","25 LOCK","26 M/T-CL","27 MW MD","28 NAME","29 NM SET", "30 OPNMSG","31 RESUME","32 RF SQL","33 RPT","34 RX MD","35 RXSAVE","36 S SCH", "37 SCNLMP","38 SHIFT","39 SKIP","40 SPLIT","41 SQL","42 SQL TYP","43 STEP", "44 TN FRQ","45 TOT","46 TXSAVE","47 VFO MD", "48 TR SQL (JAPAN)", "48 WX ALT"] rs = RadioSetting("mymenu", "My Menu function", RadioSettingValueList(options, options[_settings.mymenu - 9])) basic.append(rs) options = ["wires", "link"] rs = RadioSetting("internet_mode", "Internet mode", RadioSettingValueList(options, options[_settings.internet_mode])) basic.append(rs) options = ["key", "cont", "off"] rs = RadioSetting("lamp", "Lamp mode", RadioSettingValueList(options, options[_settings.lamp])) basic.append(rs) options = ["key", "dial", "key+dial", "ptt", "key+ptt", "dial+ptt", "all"] rs = RadioSetting("lock", "Lock mode", RadioSettingValueList(options, options[_settings.lock])) basic.append(rs) options = ["monitor", "tone call"] rs = RadioSetting("moni_tcall", "MONI key", RadioSettingValueList(options, options[_settings.moni_tcall])) basic.append(rs) options = ["lower", "next"] rs = RadioSetting("mwmode", "Memory write mode", RadioSettingValueList(options, options[_settings.mwmode])) basic.append(rs) options = map(str, range(0,15+1)) rs = RadioSetting("nfm_sql", "NFM Sql", RadioSettingValueList(options, options[_settings.nfm_sql])) basic.append(rs) options = map(str, range(0,8+1)) rs = RadioSetting("wfm_sql", "WFM Sql", RadioSettingValueList(options, options[_settings.wfm_sql])) basic.append(rs) options = ["off", "dc", "msg"] rs = RadioSetting("openmsgmode", "Opening message", RadioSettingValueList(options, options[_settings.openmsgmode])) basic.append(rs) openmsg = RadioSettingValueString(0, 6, self._decode_chars(_settings.openmsg.get_value())) openmsg.set_charset(CHARSET) rs = RadioSetting("openmsg", "Opening Message", openmsg) basic.append(rs) options = ["3s","5s","10s","busy","hold"] rs = RadioSetting("resume", "Resume", RadioSettingValueList(options, options[_settings.resume])) basic.append(rs) options = ["off"] + map(str,range(1,9+1)) rs = RadioSetting("rfsql", "RF Sql", RadioSettingValueList(options,options[_settings.rfsql])) basic.append(rs) options = ["off","200ms","300ms","500ms","1s","2s"] rs = RadioSetting("rxsave", "RX pwr save", RadioSettingValueList(options, options[_settings.rxsave])) basic.append(rs) options = ["single","cont"] rs = RadioSetting("smartsearch", "Smart search", RadioSettingValueList(options, options[_settings.smartsearch])) basic.append(rs) rs = RadioSetting("scan_lamp", "Scan lamp", RadioSettingValueBoolean(_settings.scan_lamp)) basic.append(rs) rs = RadioSetting("split", "Split", RadioSettingValueBoolean(_settings.split)) basic.append(rs) options = ["off","1","3","5","10"] rs = RadioSetting("tot", "TOT (mins)", RadioSettingValueList(options, options[_settings.tot])) basic.append(rs) rs = RadioSetting("txsave", "TX pwr save", RadioSettingValueBoolean(_settings.txsave)) basic.append(rs) options = ["all", "band"] rs = RadioSetting("vfomode", "VFO mode", RadioSettingValueList(options, options[_settings.vfomode])) basic.append(rs) rs = RadioSetting("wx_alert", "WX Alert", RadioSettingValueBoolean(_settings.wx_alert)) basic.append(rs) #todo: priority channel #todo: handle WX ch labels # arts settings (ar beep, ar int, cwid en, cwid field) options = ["15s", "25s"] rs = RadioSetting("artsinterval", "ARTS Interval", RadioSettingValueList(options, options[_settings.artsinterval])) arts.append(rs) options = ["off", "in range", "always"] rs = RadioSetting("artsbeep", "ARTS Beep", RadioSettingValueList(options, options[_settings.artsbeep])) arts.append(rs) rs = RadioSetting("cwid_en", "CWID Enable", RadioSettingValueBoolean(_settings.cwid_en)) arts.append(rs) cwid = RadioSettingValueString(0, 16, self._decode_chars(_settings.cwid.get_value())) cwid.set_charset(CHARSET) rs = RadioSetting("cwid", "CWID", cwid) arts.append(rs) # setup dtmf options = ["manual", "auto"] rs = RadioSetting("dtmfmode", "DTMF mode", RadioSettingValueList(options, options[_settings.dtmfmode])) dtmf.append(rs) for i in range(0,8+1): name = "dtmf" + str(i+1) dtmfsetting = self._memobj.dtmf[i] #dtmflen = getattr(_settings, objname + "_len") dtmfstr = "" for c in dtmfsetting.digits: if c < len(DTMFCHARSET): dtmfstr += DTMFCHARSET[c] if CHIRP_DEBUG: print dtmfstr dtmfentry = RadioSettingValueString(0, 16, dtmfstr) dtmfentry.set_charset(DTMFCHARSET + list(" ")) rs = RadioSetting(name, name.upper(), dtmfentry) dtmf.append(rs) return top
def get_settings(self): """Translate the bit in the mem_struct into settings in the UI""" # Define mem struct write-back shortcuts _sets = self._memobj.settings _vfoa = self._memobj.upper.vfoa _vfob = self._memobj.lower.vfob _lims = self._memobj.hello_lims _codes = self._memobj.codes _dtmf = self._memobj.dtmf_tab basic = RadioSettingGroup("basic", "Basic Settings") a_band = RadioSettingGroup("a_band", "VFO A-Upper Settings") b_band = RadioSettingGroup("b_band", "VFO B-Lower Settings") codes = RadioSettingGroup("codes", "Codes & DTMF Groups") lims = RadioSettingGroup("lims", "PowerOn & Freq Limits") group = RadioSettings(basic, a_band, b_band, lims, codes) # Basic Settings bnd_mode = RadioSetting( "settings.init_bank", "TDR Band Default", RadioSettingValueList(LIST_TDR_DEF, LIST_TDR_DEF[_sets.init_bank])) basic.append(bnd_mode) volume = RadioSetting("settings.volume", "Volume", RadioSettingValueInteger(0, 20, _sets.volume)) basic.append(volume) val = _vfoa.bpower # 2bits values 0,1,2= Low, Mid, High rx = RadioSettingValueList(LIST_BPOWER, LIST_BPOWER[val]) powera = RadioSetting("upper.vfoa.bpower", "Power (Upper)", rx) basic.append(powera) val = _vfob.bpower rx = RadioSettingValueList(LIST_BPOWER, LIST_BPOWER[val]) powerb = RadioSetting("lower.vfob.bpower", "Power (Lower)", rx) basic.append(powerb) def my_word2raw(setting, obj, atrb, mlt=10): """Callback function to convert UI floating value to u16 int""" if str(setting.value) == "Off": frq = 0x0FFFF else: frq = int(float(str(setting.value)) * float(mlt)) if frq == 0: frq = 0xFFFF setattr(obj, atrb, frq) return def my_adjraw(setting, obj, atrb, fix): """Callback: add or subtract fix from value.""" vx = int(str(setting.value)) value = vx + int(fix) if value < 0: value = 0 if atrb == "frq_chn_mode" and int(str(setting.value)) == 2: value = vx * 2 # Special handling for frq_chn_mode setattr(obj, atrb, value) return def my_dbl2raw(setting, obj, atrb, flg=1): """Callback: convert from freq 146.7600 to 14760000 U32.""" value = chirp_common.parse_freq(str(setting.value)) / 10 # flg=1 means 0 becomes ff, else leave as possible 0 if flg == 1 and value == 0: value = 0xFFFFFFFF setattr(obj, atrb, value) return def my_val_list(setting, obj, atrb): """Callback:from ValueList with non-sequential, actual values.""" value = int(str(setting.value)) # Get the integer value if atrb == "tot": value = int(value / 30) # 30 second increments setattr(obj, atrb, value) return def my_spcl(setting, obj, atrb): """Callback: Special handling based on atrb.""" if atrb == "frq_chn_mode": idx = LIST_VFOMODE.index(str(setting.value)) # Returns 0 or 1 value = idx * 2 # Set bit 1 setattr(obj, atrb, value) return def my_tone_strn(obj, is_atr, pol_atr, tone_atr): """Generate the CTCS/DCS tone code string.""" vx = int(getattr(obj, tone_atr)) if vx == 16383 or vx == 0: return "Off" # 16383 is all bits set if getattr(obj, is_atr) == 0: # Simple CTCSS code tstr = str(vx / 10.0) else: # DCS if getattr(obj, pol_atr) == 0: tstr = "D{:03x}R".format(vx) else: tstr = "D{:03x}N".format(vx) return tstr def my_set_tone(setting, obj, is_atr, pol_atr, tone_atr): """Callback- create the tone setting from string code.""" sx = str(setting.value) # '131.8' or 'D231N' or 'Off' if sx == "Off": isx = 1 polx = 1 tonx = 0x3FFF elif sx[0] == "D": # DCS isx = 1 if sx[4] == "N": polx = 1 else: polx = 0 tonx = int(sx[1:4], 16) else: # CTCSS isx = 0 polx = 0 tonx = int(float(sx) * 10.0) setattr(obj, is_atr, isx) setattr(obj, pol_atr, polx) setattr(obj, tone_atr, tonx) return val = _sets.fm_freq / 10.0 if val == 0: val = 88.9 # 0 is not valid rx = RadioSettingValueFloat(65, 108.0, val, 0.1, 1) rs = RadioSetting("settings.fm_freq", "FM Broadcast Freq (MHz)", rx) rs.set_apply_callback(my_word2raw, _sets, "fm_freq") basic.append(rs) wtled = RadioSetting( "settings.wtled", "Standby LED Color", RadioSettingValueList(LIST_COLOR, LIST_COLOR[_sets.wtled])) basic.append(wtled) rxled = RadioSetting( "settings.rxled", "RX LED Color", RadioSettingValueList(LIST_COLOR, LIST_COLOR[_sets.rxled])) basic.append(rxled) txled = RadioSetting( "settings.txled", "TX LED Color", RadioSettingValueList(LIST_COLOR, LIST_COLOR[_sets.txled])) basic.append(txled) ledsw = RadioSetting( "settings.ledsw", "Back light mode", RadioSettingValueList(LIST_LEDSW, LIST_LEDSW[_sets.ledsw])) basic.append(ledsw) beep = RadioSetting("settings.beep", "Beep", RadioSettingValueBoolean(bool(_sets.beep))) basic.append(beep) ring = RadioSetting( "settings.ring", "Ring", RadioSettingValueList(LIST_RING, LIST_RING[_sets.ring])) basic.append(ring) bcl = RadioSetting("settings.bcl", "Busy channel lockout", RadioSettingValueBoolean(bool(_sets.bcl))) basic.append(bcl) if _vfoa.sql == 0xFF: val = 0x04 else: val = _vfoa.sql sqla = RadioSetting("upper.vfoa.sql", "Squelch (Upper)", RadioSettingValueInteger(0, 9, val)) basic.append(sqla) if _vfob.sql == 0xFF: val = 0x04 else: val = _vfob.sql sqlb = RadioSetting("lower.vfob.sql", "Squelch (Lower)", RadioSettingValueInteger(0, 9, val)) basic.append(sqlb) tmp = str(int(_sets.tot) * 30) # 30 sec step counter rs = RadioSetting("settings.tot", "Transmit Timeout (Secs)", RadioSettingValueList(LIST_TIMEOUT, tmp)) rs.set_apply_callback(my_val_list, _sets, "tot") basic.append(rs) tmp = str(int(_sets.sig_freq)) rs = RadioSetting("settings.sig_freq", "Single Signaling Tone (Htz)", RadioSettingValueList(LIST_SSF, tmp)) rs.set_apply_callback(my_val_list, _sets, "sig_freq") basic.append(rs) tmp = str(int(_sets.dtmf_txms)) rs = RadioSetting("settings.dtmf_txms", "DTMF Tx Duration (mSecs)", RadioSettingValueList(LIST_DTMFTX, tmp)) rs.set_apply_callback(my_val_list, _sets, "dtmf_txms") basic.append(rs) rs = RadioSetting("settings.rptr_mode", "Repeater Mode", RadioSettingValueBoolean(bool(_sets.rptr_mode))) basic.append(rs) # UPPER BAND SETTINGS # Freq Mode, convert bit 1 state to index pointer val = _vfoa.frq_chn_mode / 2 rx = RadioSettingValueList(LIST_VFOMODE, LIST_VFOMODE[val]) rs = RadioSetting("upper.vfoa.frq_chn_mode", "Default Mode", rx) rs.set_apply_callback(my_spcl, _vfoa, "frq_chn_mode") a_band.append(rs) val = _vfoa.chan_num + 1 # Add 1 for 1-128 displayed rs = RadioSetting("upper.vfoa.chan_num", "Initial Chan", RadioSettingValueInteger(1, 128, val)) rs.set_apply_callback(my_adjraw, _vfoa, "chan_num", -1) a_band.append(rs) val = _vfoa.rxfreq / 100000.0 if (val < 136.0 or val > 176.0): val = 146.520 # 2m calling rs = RadioSetting("upper.vfoa.rxfreq ", "Default Recv Freq (MHz)", RadioSettingValueFloat(136.0, 176.0, val, 0.001, 5)) rs.set_apply_callback(my_dbl2raw, _vfoa, "rxfreq") a_band.append(rs) tmp = my_tone_strn(_vfoa, "is_rxdigtone", "rxdtcs_pol", "rx_tone") rs = RadioSetting("rx_tone", "Default Recv CTCSS (Htz)", RadioSettingValueList(LIST_CTCSS, tmp)) rs.set_apply_callback(my_set_tone, _vfoa, "is_rxdigtone", "rxdtcs_pol", "rx_tone") a_band.append(rs) rx = RadioSettingValueList(LIST_RECVMODE, LIST_RECVMODE[_vfoa.rx_mode]) rs = RadioSetting("upper.vfoa.rx_mode", "Default Recv Mode", rx) a_band.append(rs) tmp = my_tone_strn(_vfoa, "is_txdigtone", "txdtcs_pol", "tx_tone") rs = RadioSetting("tx_tone", "Default Xmit CTCSS (Htz)", RadioSettingValueList(LIST_CTCSS, tmp)) rs.set_apply_callback(my_set_tone, _vfoa, "is_txdigtone", "txdtcs_pol", "tx_tone") a_band.append(rs) rs = RadioSetting( "upper.vfoa.launch_sig", "Launch Signaling", RadioSettingValueList(LIST_SIGNAL, LIST_SIGNAL[_vfoa.launch_sig])) a_band.append(rs) rx = RadioSettingValueList(LIST_SIGNAL, LIST_SIGNAL[_vfoa.tx_end_sig]) rs = RadioSetting("upper.vfoa.tx_end_sig", "Xmit End Signaling", rx) a_band.append(rs) rx = RadioSettingValueList(LIST_BW, LIST_BW[_vfoa.fm_bw]) rs = RadioSetting("upper.vfoa.fm_bw", "Wide/Narrow Band", rx) a_band.append(rs) rx = RadioSettingValueBoolean(bool(_vfoa.cmp_nder)) rs = RadioSetting("upper.vfoa.cmp_nder", "Compandor", rx) a_band.append(rs) rs = RadioSetting("upper.vfoa.scrm_blr", "Scrambler", RadioSettingValueBoolean(bool(_vfoa.scrm_blr))) a_band.append(rs) rx = RadioSettingValueList(LIST_SHIFT, LIST_SHIFT[_vfoa.shift]) rs = RadioSetting("upper.vfoa.shift", "Xmit Shift", rx) a_band.append(rs) val = _vfoa.offset / 100000.0 rs = RadioSetting("upper.vfoa.offset", "Xmit Offset (MHz)", RadioSettingValueFloat(0, 100.0, val, 0.001, 3)) # Allow zero value rs.set_apply_callback(my_dbl2raw, _vfoa, "offset", 0) a_band.append(rs) tmp = str(_vfoa.step / 100.0) rs = RadioSetting("step", "Freq step (KHz)", RadioSettingValueList(LIST_STEPS, tmp)) rs.set_apply_callback(my_word2raw, _vfoa, "step", 100) a_band.append(rs) # LOWER BAND SETTINGS val = _vfob.frq_chn_mode / 2 rx = RadioSettingValueList(LIST_VFOMODE, LIST_VFOMODE[val]) rs = RadioSetting("lower.vfob.frq_chn_mode", "Default Mode", rx) rs.set_apply_callback(my_spcl, _vfob, "frq_chn_mode") b_band.append(rs) val = _vfob.chan_num + 1 rs = RadioSetting("lower.vfob.chan_num", "Initial Chan", RadioSettingValueInteger(0, 127, val)) rs.set_apply_callback(my_adjraw, _vfob, "chan_num", -1) b_band.append(rs) val = _vfob.rxfreq / 100000.0 if (val < 400.0 or val > 480.0): val = 446.0 # UHF calling rs = RadioSetting("lower.vfob.rxfreq ", "Default Recv Freq (MHz)", RadioSettingValueFloat(400.0, 480.0, val, 0.001, 5)) rs.set_apply_callback(my_dbl2raw, _vfob, "rxfreq") b_band.append(rs) tmp = my_tone_strn(_vfob, "is_rxdigtone", "rxdtcs_pol", "rx_tone") rs = RadioSetting("rx_tone", "Default Recv CTCSS (Htz)", RadioSettingValueList(LIST_CTCSS, tmp)) rs.set_apply_callback(my_set_tone, _vfob, "is_rxdigtone", "rxdtcs_pol", "rx_tone") b_band.append(rs) rx = RadioSettingValueList(LIST_RECVMODE, LIST_RECVMODE[_vfob.rx_mode]) rs = RadioSetting("lower.vfob.rx_mode", "Default Recv Mode", rx) b_band.append(rs) tmp = my_tone_strn(_vfob, "is_txdigtone", "txdtcs_pol", "tx_tone") rs = RadioSetting("tx_tone", "Default Xmit CTCSS (Htz)", RadioSettingValueList(LIST_CTCSS, tmp)) rs.set_apply_callback(my_set_tone, _vfob, "is_txdigtone", "txdtcs_pol", "tx_tone") b_band.append(rs) rx = RadioSettingValueList(LIST_SIGNAL, LIST_SIGNAL[_vfob.launch_sig]) rs = RadioSetting("lower.vfob.launch_sig", "Launch Signaling", rx) b_band.append(rs) rx = RadioSettingValueList(LIST_SIGNAL, LIST_SIGNAL[_vfob.tx_end_sig]) rs = RadioSetting("lower.vfob.tx_end_sig", "Xmit End Signaling", rx) b_band.append(rs) rx = RadioSettingValueList(LIST_BW, LIST_BW[_vfob.fm_bw]) rs = RadioSetting("lower.vfob.fm_bw", "Wide/Narrow Band", rx) b_band.append(rs) rs = RadioSetting("lower.vfob.cmp_nder", "Compandor", RadioSettingValueBoolean(bool(_vfob.cmp_nder))) b_band.append(rs) rs = RadioSetting("lower.vfob.scrm_blr", "Scrambler", RadioSettingValueBoolean(bool(_vfob.scrm_blr))) b_band.append(rs) rx = RadioSettingValueList(LIST_SHIFT, LIST_SHIFT[_vfob.shift]) rs = RadioSetting("lower.vfob.shift", "Xmit Shift", rx) b_band.append(rs) val = _vfob.offset / 100000.0 rs = RadioSetting("lower.vfob.offset", "Xmit Offset (MHz)", RadioSettingValueFloat(0, 100.0, val, 0.001, 3)) rs.set_apply_callback(my_dbl2raw, _vfob, "offset", 0) b_band.append(rs) tmp = str(_vfob.step / 100.0) rs = RadioSetting("step", "Freq step (KHz)", RadioSettingValueList(LIST_STEPS, tmp)) rs.set_apply_callback(my_word2raw, _vfob, "step", 100) b_band.append(rs) # PowerOn & Freq Limits Settings def chars2str(cary, knt): """Convert raw memory char array to a string: NOT a callback.""" stx = "" for char in cary[:knt]: stx += chr(char) return stx def my_str2ary(setting, obj, atrba, atrbc): """Callback: convert 7-char string to char array with count.""" ary = "" knt = 7 for j in range(6, -1, -1): # Strip trailing spaces if str(setting.value)[j] == "" or str(setting.value)[j] == " ": knt = knt - 1 else: break for j in range(0, 7, 1): if j < knt: ary += str(setting.value)[j] else: ary += chr(0xFF) setattr(obj, atrba, ary) setattr(obj, atrbc, knt) return tmp = chars2str(_lims.hello1, _lims.hello1_cnt) rs = RadioSetting("hello_lims.hello1", "Power-On Message 1", RadioSettingValueString(0, 7, tmp)) rs.set_apply_callback(my_str2ary, _lims, "hello1", "hello1_cnt") lims.append(rs) tmp = chars2str(_lims.hello2, _lims.hello2_cnt) rs = RadioSetting("hello_lims.hello2", "Power-On Message 2", RadioSettingValueString(0, 7, tmp)) rs.set_apply_callback(my_str2ary, _lims, "hello2", "hello2_cnt") lims.append(rs) # VALID_BANDS = [(136000000, 176000000),400000000, 480000000)] lval = _lims.vhf_low / 100000.0 uval = _lims.vhf_high / 100000.0 if lval >= uval: lval = 144.0 uval = 158.0 rs = RadioSetting("hello_lims.vhf_low", "Lower VHF Band Limit (MHz)", RadioSettingValueFloat(136.0, 176.0, lval, 0.001, 3)) rs.set_apply_callback(my_dbl2raw, _lims, "vhf_low") lims.append(rs) rs = RadioSetting("hello_lims.vhf_high", "Upper VHF Band Limit (MHz)", RadioSettingValueFloat(136.0, 176.0, uval, 0.001, 3)) rs.set_apply_callback(my_dbl2raw, _lims, "vhf_high") lims.append(rs) lval = _lims.uhf_low / 100000.0 uval = _lims.uhf_high / 100000.0 if lval >= uval: lval = 420.0 uval = 470.0 rs = RadioSetting("hello_lims.uhf_low", "Lower UHF Band Limit (MHz)", RadioSettingValueFloat(400.0, 480.0, lval, 0.001, 3)) rs.set_apply_callback(my_dbl2raw, _lims, "uhf_low") lims.append(rs) rs = RadioSetting("hello_lims.uhf_high", "Upper UHF Band Limit (MHz)", RadioSettingValueFloat(400.0, 480.0, uval, 0.001, 3)) rs.set_apply_callback(my_dbl2raw, _lims, "uhf_high") lims.append(rs) # Codes and DTMF Groups Settings def make_dtmf(ary, knt): """Generate the DTMF code 1-8, NOT a callback.""" tmp = "" if knt > 0 and knt != 0xff: for val in ary[:knt]: if val > 0 and val <= 9: tmp += chr(val + 48) elif val == 0x0a: tmp += "0" elif val == 0x0d: tmp += "A" elif val == 0x0e: tmp += "B" elif val == 0x0f: tmp += "C" elif val == 0x00: tmp += "D" elif val == 0x0b: tmp += "*" elif val == 0x0c: tmp += "#" else: msg = ("Invalid Character. Must be: 0-9,A,B,C,D,*,#") raise InvalidValueError(msg) return tmp def my_dtmf2raw(setting, obj, atrba, atrbc, syz=7): """Callback: DTMF Code; sends 5 or 7-byte string.""" draw = [] knt = syz for j in range(syz - 1, -1, -1): # Strip trailing spaces if str(setting.value)[j] == "" or str(setting.value)[j] == " ": knt = knt - 1 else: break for j in range(0, syz): bx = str(setting.value)[j] obx = ord(bx) dig = 0x0ff if j < knt and knt > 0: # (Else) is pads if bx == "0": dig = 0x0a elif bx == "A": dig = 0x0d elif bx == "B": dig = 0x0e elif bx == "C": dig = 0x0f elif bx == "D": dig = 0x00 elif bx == "*": dig = 0x0b elif bx == "#": dig = 0x0c elif obx >= 49 and obx <= 57: dig = obx - 48 else: msg = ("Must be: 0-9,A,B,C,D,*,#") raise InvalidValueError(msg) # - End if/elif/else for bx # - End if J<=knt draw.append(dig) # Generate string of bytes # - End for j setattr(obj, atrba, draw) setattr(obj, atrbc, knt) return tmp = make_dtmf(_codes.native_id_code, _codes.native_id_cnt) rs = RadioSetting("codes.native_id_code", "Native ID Code", RadioSettingValueString(0, 7, tmp)) rs.set_apply_callback(my_dtmf2raw, _codes, "native_id_code", "native_id_cnt", 7) codes.append(rs) tmp = make_dtmf(_codes.master_id_code, _codes.master_id_cnt) rs = RadioSetting("codes.master_id_code", "Master Control ID Code", RadioSettingValueString(0, 7, tmp)) rs.set_apply_callback(my_dtmf2raw, _codes, "master_id_code", "master_id_cnt", 7) codes.append(rs) tmp = make_dtmf(_codes.alarm_code, _codes.alarm_cnt) rs = RadioSetting("codes.alarm_code", "Alarm Code", RadioSettingValueString(0, 5, tmp)) rs.set_apply_callback(my_dtmf2raw, _codes, "alarm_code", "alarm_cnt", 5) codes.append(rs) tmp = make_dtmf(_codes.id_disp_code, _codes.id_disp_cnt) rs = RadioSetting("codes.id_disp_code", "Identify Display Code", RadioSettingValueString(0, 5, tmp)) rs.set_apply_callback(my_dtmf2raw, _codes, "id_disp_code", "id_disp_cnt", 5) codes.append(rs) tmp = make_dtmf(_codes.revive_code, _codes.revive_cnt) rs = RadioSetting("codes.revive_code", "Revive Code", RadioSettingValueString(0, 5, tmp)) rs.set_apply_callback(my_dtmf2raw, _codes, "revive_code", "revive_cnt", 5) codes.append(rs) tmp = make_dtmf(_codes.stun_code, _codes.stun_cnt) rs = RadioSetting("codes.stun_code", "Remote Stun Code", RadioSettingValueString(0, 5, tmp)) rs.set_apply_callback(my_dtmf2raw, _codes, "stun_code", "stun_cnt", 5) codes.append(rs) tmp = make_dtmf(_codes.kill_code, _codes.kill_cnt) rs = RadioSetting("codes.kill_code", "Remote KILL Code", RadioSettingValueString(0, 5, tmp)) rs.set_apply_callback(my_dtmf2raw, _codes, "kill_code", "kill_cnt", 5) codes.append(rs) tmp = make_dtmf(_codes.monitor_code, _codes.monitor_cnt) rs = RadioSetting("codes.monitor_code", "Monitor Code", RadioSettingValueString(0, 5, tmp)) rs.set_apply_callback(my_dtmf2raw, _codes, "monitor_code", "monitor_cnt", 5) codes.append(rs) val = _codes.state_now if val > 2: val = 0 rx = RadioSettingValueList(LIST_STATE, LIST_STATE[val]) rs = RadioSetting("codes.state_now", "Current State", rx) codes.append(rs) dtm = make_dtmf(_dtmf.dtmf1, _dtmf.dtmf1_cnt) rs = RadioSetting("dtmf_tab.dtmf1", "DTMF1 String", RadioSettingValueString(0, 7, dtm)) rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf1", "dtmf1_cnt") codes.append(rs) dtm = make_dtmf(_dtmf.dtmf2, _dtmf.dtmf2_cnt) rs = RadioSetting("dtmf_tab.dtmf2", "DTMF2 String", RadioSettingValueString(0, 7, dtm)) rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf2", "dtmf2_cnt") codes.append(rs) dtm = make_dtmf(_dtmf.dtmf3, _dtmf.dtmf3_cnt) rs = RadioSetting("dtmf_tab.dtmf3", "DTMF3 String", RadioSettingValueString(0, 7, dtm)) rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf3", "dtmf3_cnt") codes.append(rs) dtm = make_dtmf(_dtmf.dtmf4, _dtmf.dtmf4_cnt) rs = RadioSetting("dtmf_tab.dtmf4", "DTMF4 String", RadioSettingValueString(0, 7, dtm)) rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf4", "dtmf4_cnt") codes.append(rs) dtm = make_dtmf(_dtmf.dtmf5, _dtmf.dtmf5_cnt) rs = RadioSetting("dtmf_tab.dtmf5", "DTMF5 String", RadioSettingValueString(0, 7, dtm)) rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf5", "dtmf5_cnt") codes.append(rs) dtm = make_dtmf(_dtmf.dtmf6, _dtmf.dtmf6_cnt) rs = RadioSetting("dtmf_tab.dtmf6", "DTMF6 String", RadioSettingValueString(0, 7, dtm)) rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf6", "dtmf6_cnt") codes.append(rs) dtm = make_dtmf(_dtmf.dtmf7, _dtmf.dtmf7_cnt) rs = RadioSetting("dtmf_tab.dtmf7", "DTMF7 String", RadioSettingValueString(0, 7, dtm)) rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf7", "dtmf7_cnt") codes.append(rs) dtm = make_dtmf(_dtmf.dtmf8, _dtmf.dtmf8_cnt) rs = RadioSetting("dtmf_tab.dtmf8", "DTMF8 String", RadioSettingValueString(0, 7, dtm)) rs.set_apply_callback(my_dtmf2raw, _dtmf, "dtmf8", "dtmf8_cnt") codes.append(rs) return group # END get_settings()
def get_settings(self): _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_extra(self, _mem, mem): mem.extra = RadioSettingGroup("extra", "Extra") dig = RadioSetting("isdigital", "Digital", RadioSettingValueBoolean(bool(_mem.isdigital))) dig.set_doc("Digital/Packet mode enabled") mem.extra.append(dig)
def get_settings(self): _set = self._memobj.settings basic = RadioSettingGroup('basic', 'Basic') adv = RadioSettingGroup('advanced', 'Advanced') dtmf = RadioSettingGroup('dtmf', 'DTMF') choice_settings = { 'savemode': ['Off', 'Mode 1', 'Mode 2', 'Mode 3'], 'vox': ['Off'] + ['%i' % i for i in range(1, 11)], 'backlight': ['Off'] + ['%i' % i for i in range(1, 11)], 'timeout': ['Off'] + ['%i' % i for i in range(15, 615, 15)], 'language': ['English', 'Chinese'], 'dtmfst': ['OFF', 'KB Side Tone', 'ANI Side Tone', 'KB ST+ANI ST', 'Both'], 'scanmode': ['TO', 'CO', 'SE'], 'pttid': ['Off', 'BOT', 'EOT', 'Both'], 'cha_disp': ['CH+Name', 'CH+Freq'], 'chb_disp': ['CH+Name', 'CH+Freq'], 'alarm_mode': ['Site', 'Tone', 'Code'], 'txundertdr': ['Off', 'Band A', 'Band B'], 'rptnoiseclr': ['Off'] + ['%i' % i for i in range(100, 1001, 100)], 'rptnoisedet': ['Off'] + ['%i' % i for i in range(100, 1001, 100)], 'workmode': ['VFO', 'Chan'], } basic_settings = ['timeout', 'vox', 'backlight', 'language', 'cha_disp', 'chb_disp', 'workmode'] titles = { 'savemode': 'Save Mode', 'vox': 'VOX', 'backlight': 'Auto Backlight', 'timeout': 'Time Out Timer (s)', 'language': 'Language', 'dtmfst': 'DTMF-ST', 'scanmode': 'Scan Mode', 'pttid': 'PTT-ID', 'cha_disp': 'Channel A Display', 'chb_disp': 'Channel B Display', 'alarm_mode': 'Alarm Mode', 'txundertdr': 'TX Under TDR', 'rptnoiseclr': 'RPT Noise Clear (ms)', 'rptnoisedet': 'RPT Noise Detect (ms)', 'workmode': 'Work Mode', } basic.append( RadioSetting('squelch', 'Squelch Level', RadioSettingValueInteger(0, 9, int(_set.squelch)))) adv.append( RadioSetting('pttdelay', 'PTT Delay', RadioSettingValueInteger(0, 30, int(_set.pttdelay)))) adv.append( RadioSetting('tdr', 'TDR', RadioSettingValueBoolean( int(_set.tdr)))) adv.append( RadioSetting('beep', 'Beep', RadioSettingValueBoolean( int(_set.beep)))) basic.append( RadioSetting('voice', 'Voice Enable', RadioSettingValueBoolean( int(_set.voice)))) adv.append( RadioSetting('bcl', 'BCL', RadioSettingValueBoolean( int(_set.bcl)))) adv.append( RadioSetting('autolock', 'Auto Lock', RadioSettingValueBoolean( int(_set.autolock)))) adv.append( RadioSetting('alarmsound', 'Alarm Sound', RadioSettingValueBoolean( int(_set.alarmsound)))) adv.append( RadioSetting('tailnoiseclear', 'Tail Noise Clear', RadioSettingValueBoolean( int(_set.tailnoiseclear)))) adv.append( RadioSetting('roger', 'Roger', RadioSettingValueBoolean( int(_set.roger)))) adv.append( RadioSetting('fmradio', 'FM Radio Disabled', RadioSettingValueBoolean( int(_set.fmradio)))) adv.append( RadioSetting('kblock', 'KB Lock', RadioSettingValueBoolean( int(_set.kblock)))) for key in sorted(choice_settings): choices = choice_settings[key] title = titles[key] if key in basic_settings: group = basic else: group = adv val = int(getattr(_set, key)) try: cur = choices[val] except IndexError: LOG.error('Value %i for %s out of range for list (%i): %s' % ( val, key, len(choices), choices)) raise group.append( RadioSetting(key, title, RadioSettingValueList( choices, choices[val]))) for i in range(1, 16): cur = ''.join( DTMFCHARS[i] for i in self._memobj.dtmfgroup[i - 1].code if int(i) < 0xF) dtmf.append( RadioSetting( 'dtmf.code@%i' % i, 'DTMF Group %i' % i, RadioSettingValueString(0, 5, cur, autopad=False, charset=DTMFCHARS))) cur = ''.join( '%X' % i for i in self._memobj.anicode.code if int(i) < 0xE) dtmf.append( RadioSetting( 'anicode.code', 'ANI Code', RadioSettingValueString(0, 5, cur, autopad=False, charset=DTMFCHARS))) anicode = self._memobj.anicode dtmf.append( RadioSetting( 'anicode.groupcode', 'Group Code', RadioSettingValueList( list(DTMFCHARS), DTMFCHARS[int(anicode.groupcode)]))) dtmf.append( RadioSetting( 'anicode.releasetosend', 'Release To Send', RadioSettingValueBoolean( int(anicode.releasetosend)))) dtmf.append( RadioSetting( 'anicode.presstosend', 'Press To Send', RadioSettingValueBoolean( int(anicode.presstosend)))) cur = int(anicode.dtmfspeedon) * 10 + 80 dtmf.append( RadioSetting( 'anicode.dtmfspeedon', 'DTMF Speed (on time in ms)', RadioSettingValueInteger(60, 2000, cur, 10))) cur = int(anicode.dtmfspeedoff) * 10 + 80 dtmf.append( RadioSetting( 'anicode.dtmfspeedoff', 'DTMF Speed (off time in ms)', RadioSettingValueInteger(60, 2000, cur, 10))) top = RadioSettings(basic, adv, dtmf) return top
def get_settings(self): """Translate the MEM_FORMAT structs into settings in the UI""" # Define mem struct write-back shortcuts _sets = self._memobj.settings _cmnt = self._memobj.comment _wxch = self._memobj.abwx _dtm = self._memobj.dtmfcode _pses = self._memobj.pgmscanedge _bklk = self._memobj.banklink basic = RadioSettingGroup("basic", "Basic Settings") mickey = RadioSettingGroup("mickey", "Microphone Keys") bluet = RadioSettingGroup("bluet", "Bluetooth") disp = RadioSettingGroup("disp", "Display") sound = RadioSettingGroup("sound", "Sounds") dtmf = RadioSettingGroup("dtmf", "DTMF Codes") abset = RadioSettingGroup("abset", "A/B Band Settings") edges = RadioSettingGroup("edges", "Program Scan Edges") pslnk = RadioSettingGroup("pslnk", "Program Scan Links") other = RadioSettingGroup("other", "Other Settings") group = RadioSettings(basic, disp, sound, mickey, dtmf, abset, bluet, edges, pslnk, other) def mic_keys(setting, obj, atrb): """ Callback to set subset of mic key options """ stx = str(setting.value) value = MICKEYOPTS.index(stx) setattr(obj, atrb, value) return def hex_val(setting, obj, atrb): """ Callback to store string as hex values """ value = int(str(setting.value), 16) setattr(obj, atrb, value) return def unpack_str(codestr): """Convert u8 DTMF array to a string: NOT a callback.""" stx = "" for i in range(0, 24): # unpack up to ff if codestr[i] != 0xff: if codestr[i] == 0x0E: stx += "#" elif codestr[i] == 0x0F: stx += "*" else: stx += format(int(codestr[i]), '0X') return stx def pack_chars(setting, obj, atrb, ndx): """Callback to build 0-9,A-D,*# nibble array from string""" # String will be f padded to 24 bytes # Chars are stored as hex values ary = [] stx = str(setting.value).upper() stx = stx.strip() # trim spaces # Remove illegal characters first sty = "" for j in range(0, len(stx)): if stx[j] in DTMF_CHARS: sty += stx[j] for j in range(0, 24): if j < len(sty): if sty[j] == "#": chrv = 0xE elif sty[j] == "*": chrv = 0xF else: chrv = int(sty[j], 16) else: # pad to 24 bytes chrv = 0xFF ary.append(chrv) # append byte setattr(obj[ndx], atrb, ary) return def myset_comment(setting, obj, atrb, knt): """ Callback to create space-padded char array""" stx = str(setting.value) for i in range(0, knt): if i > len(stx): str.append(0x20) setattr(obj, atrb, stx) return def myset_psnam(setting, obj, ndx, atrb, knt): """ Callback to generate space-padded, uppercase char array """ # This sub also is specific to object arrays stx = str(setting.value).upper() for i in range(0, knt): if i > len(stx): str.append(0x20) setattr(obj[ndx], atrb, stx) return def myset_frqflgs(setting, obj, ndx, flg, frq): """ Callback to gen flag/freq pairs """ vfrq = float(str(setting.value)) vfrq = int(vfrq * 1000000) vflg = 0x10 if vfrq % 6250 == 0: vflg = 0x08 vfrq = int(vfrq / 6250) elif vfrq % 5000 == 0: vflg = 0 vfrq = int(vfrq / 5000) else: vfrq = int(vfrq / 8333) setattr(obj[ndx], flg, vflg) setattr(obj[ndx], frq, vfrq) return def banklink(ary): """ Sub to generate A-J string from 2-byte bit pattern """ stx = "" for kx in range(0, 10): if kx < 8: val = ary[0] msk = 1 << kx else: val = ary[1] msk = 1 << (kx - 8) if val & msk: stx += chr(kx + 65) else: stx += "_" return stx def myset_banklink(setting, obj, atrb): """Callback to create 10-bit, u8[2] array from 10 char string""" stx = str(setting.value).upper() ary = [0, 0] for kx in range(0, 10): if stx[kx] == chr(kx + 65): if kx < 8: ary[0] = ary[0] + (1 << kx) else: ary[1] = ary[1] + (1 << (kx - 8)) setattr(obj, atrb, ary) return def myset_tsopt(setting, obj, ndx, atrb, bx): """ Callback to set scan Edge tstep """ stx = str(setting.value) flg = 0 if stx == "-": val = 0xff else: if bx == 1: # Air band if stx == "Auto": val = 0xe elif stx == "25k": val = 8 elif stx == "8.33k": val = 2 else: # VHF or UHF optx = [ "-", "5k", "6.25k", "10k", "12.5k", "15k", "20k", "25k", "30k", "50k" ] val = optx.index(stx) + 1 setattr(obj[ndx], atrb, val) # and set flag setattr(obj[ndx], "flag", flg) return def myset_mdopt(setting, obj, ndx, atrb, bx): """ Callback to set Scan Edge mode """ stx = str(setting.value) if stx == "-": val = 0xf elif stx == "FM": val = 0 else: val = 1 setattr(obj[ndx], atrb, val) return def myset_bitmask(setting, obj, ndx, atrb, knt): """ Callback to gnerate byte-array bitmask from string""" # knt is BIT count to process lsx = str(setting.value).strip().split(",") for kx in range(0, len(lsx)): try: lsx[kx] = int(lsx[kx]) except Exception: lsx[kx] = -99 # will nop ary = [0, 0, 0, 0xfe] for kx in range(0, knt): if kx < 8: if kx in lsx: ary[0] += 1 << kx elif kx >= 8 and kx < 16: if kx in lsx: ary[1] += 1 << (kx - 8) elif kx >= 16 and kx < 24: if kx in lsx: ary[2] += 1 << (kx - 16) else: if kx in lsx: # only bit 25 ary[3] += 1 setattr(obj[ndx], atrb, ary) return # --- Basic options = ["Off", "S-Meter Squelch", "ATT"] rx = RadioSettingValueList(options, options[_sets.sqlatt]) rset = RadioSetting("settings.sqlatt", "Squelch/ATT", rx) basic.append(rset) options = ["Short", "Long"] rx = RadioSettingValueList(options, options[_sets.sqldly]) rset = RadioSetting("settings.sqldly", "Squelch Delay", rx) basic.append(rset) rx = RadioSettingValueBoolean(bool(_sets.pttlock)) rset = RadioSetting("settings.pttlock", "PTT Lockout", rx) basic.append(rset) rx = RadioSettingValueBoolean(bool(_sets.bcl)) rset = RadioSetting("settings.bcl", "Busy Channel Lockout", rx) basic.append(rset) options = ["Off", "1m", "3m", "5m", "10m", "15m", "30m"] rx = RadioSettingValueList(options, options[_sets.tot]) rset = RadioSetting("settings.tot", "Tx Timeout", rx) basic.append(rset) val = int(_sets.vfohome) if val == 0xffff: val = 0 val = val / 1000000.0 rx = RadioSettingValueFloat(0.0, 550.0, val, 0.005, 4) rx.set_mutable(False) rset = RadioSetting("settings.vfohome", "Home VFO (Read-Only)", rx) basic.append(rset) val = _sets.homech if val == 0xffff: val = -1 rx = RadioSettingValueInteger(-1, 999, val) rx.set_mutable(False) rset = RadioSetting("settings.homech", "Home Channel (Read-Only)", rx) basic.append(rset) options = ["1", "2", "3", "4"] rx = RadioSettingValueList(options, options[_sets.micgain]) rset = RadioSetting("settings.micgain", "Microphone Gain", rx) basic.append(rset) _bmem = self._memobj.initmem rx = RadioSettingValueInteger(0, 999, _bmem.left_memory) rset = RadioSetting("initmem.left_memory", "Left Bank Initial Mem Chan", rx) basic.append(rset) rx = RadioSettingValueInteger(0, 999, _bmem.right_memory) rset = RadioSetting("initmem.right_memory", "Right Bank Initial Mem Chan", rx) basic.append(rset) stx = "" for i in range(0, 16): stx += chr(_cmnt.com[i]) stx = stx.rstrip() rx = RadioSettingValueString(0, 16, stx) rset = RadioSetting("comment.com", "Comment (16 chars)", rx) rset.set_apply_callback(myset_comment, _cmnt, "com", 16) basic.append(rset) # --- Other rset = RadioSetting("drv_clone_speed", "Use Hi-Speed Clone", RadioSettingValueBoolean(self._can_hispeed)) other.append(rset) options = ["Single", "All", "Ham"] rx = RadioSettingValueList(options, options[_sets.actband]) rset = RadioSetting("settings.actband", "Active Band", rx) other.append(rset) options = ["Slow", "Mid", "Fast", "Auto"] rx = RadioSettingValueList(options, options[_sets.fanspeed]) rset = RadioSetting("settings.fanspeed", "Fan Speed", rx) other.append(rset) rx = RadioSettingValueBoolean(bool(_sets.dialspdup)) rset = RadioSetting("settings.dialspdup", "Dial Speed-Up", rx) other.append(rset) options = ["Off", "On(Dup)", "On(Dup+Tone)"] rx = RadioSettingValueList(options, options[_sets.autorptr]) rset = RadioSetting("settings.autorptr", "Auto Repeater", rx) other.append(rset) rx = RadioSettingValueBoolean(bool(_sets.rmtmic)) rset = RadioSetting("settings.rmtmic", "One-Touch PTT (Remote Mic)", rx) other.append(rset) options = ["Low", "Mid", "High"] rx = RadioSettingValueList(options, options[_sets.vhfpower]) rset = RadioSetting("settings.vhfpower", "VHF Power Default", rx) other.append(rset) rx = RadioSettingValueList(options, options[_sets.uhfpower]) rset = RadioSetting("settings.uhfpower", "UHF Power Default", rx) other.append(rset) rx = RadioSettingValueBoolean(bool(_sets.toneburst)) rset = RadioSetting("settings.toneburst", "1750 Htz Tone Burst", rx) other.append(rset) rx = RadioSettingValueBoolean(bool(_sets.ifxchg)) rset = RadioSetting("settings.ifxchg", "IF Exchange", rx) other.append(rset) rx = RadioSettingValueBoolean(bool(_sets.rpthangup)) rset = RadioSetting("settings.rpthangup", "Repeater Hang up Timeout", rx) other.append(rset) stx = str(_sets.civaddr)[2:] # Hex value rx = RadioSettingValueString(1, 2, stx) rset = RadioSetting("settings.civaddr", "CI-V Address (90)", rx) rset.set_apply_callback(hex_val, _sets, "civaddr") other.append(rset) options = ["1200", "2400", "4800", "9600", "19200", "Auto"] rx = RadioSettingValueList(options, options[_sets.civbaud]) rset = RadioSetting("settings.civbaud", "CI-V Baud Rate (bps)", rx) other.append(rset) rx = RadioSettingValueBoolean(bool(_sets.civtcvr)) rset = RadioSetting("settings.civtcvr", "CI-V Transceive", rx) other.append(rset) # A/B Band Settings options = ["Off", "On", "Bell"] rx = RadioSettingValueList(options, options[_sets.aprichn]) rset = RadioSetting("settings.aprichn", "A Band: VFO Priority Watch Mode", rx) abset.append(rset) options = [ "2", "4", "6", "8", "10", "12", "14", "16", "18", "20", "Hold" ] rx = RadioSettingValueList(options, options[_sets.ascanpause]) rset = RadioSetting("settings.ascanpause", "-- A Band: Scan Pause Time (Secs)", rx) abset.append(rset) options = ["0", "1", "2", "3", "4", "5", "Hold"] rx = RadioSettingValueList(options, options[_sets.ascanresume]) rset = RadioSetting("settings.ascanresume", "-- A Band: Scan Resume Time (Secs)", rx) abset.append(rset) options = ["5", "10", "15"] rx = RadioSettingValueList(options, options[_sets.atmpskiptym]) rset = RadioSetting("settings.atmpskiptym", "-- A Band: Temp Skip Time (Secs)", rx) abset.append(rset) rx = RadioSettingValueBoolean(bool(_sets.aprgskpscn)) rset = RadioSetting("settings.aprgskpscn", "-- A Band: Program Skip Scan", rx) abset.append(rset) rx = RadioSettingValueString(10, 10, banklink(_bklk.alnk)) rset = RadioSetting("banklink.alnk", "-- A Band Banklink (use _ to skip)", rx) rset.set_apply_callback(myset_banklink, _bklk, "alnk") abset.append(rset) rx = RadioSettingValueBoolean(bool(_sets.awxalert)) rset = RadioSetting("settings.awxalert", "-- A Band: Weather Alert", rx) abset.append(rset) # Use list for Wx chans since chan 1 = index 0 options = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"] rx = RadioSettingValueList(options, options[_wxch.awxchan]) rset = RadioSetting("abwx.awxchan", "-- A Band: Weather Channel", rx) abset.append(rset) options = ["Off", "On", "Bell"] rx = RadioSettingValueList(options, options[_sets.bprichn]) rset = RadioSetting("settings.bprichn", "B Band: VFO Priority Watch Mode", rx) abset.append(rset) options = [ "2", "4", "6", "8", "10", "12", "14", "16", "18", "20", "Hold" ] rx = RadioSettingValueList(options, options[_sets.bscanpause]) rset = RadioSetting("settings.bscanpause", "-- B Band: Scan Pause Time (Secs)", rx) abset.append(rset) options = ["0", "1", "2", "3", "4", "5", "Hold"] rx = RadioSettingValueList(options, options[_sets.bscanresume]) rset = RadioSetting("settings.bscanresume", "-- B Band: Scan Resume Time (Secs)", rx) abset.append(rset) options = ["5", "10", "15"] rx = RadioSettingValueList(options, options[_sets.btmpskiptym]) rset = RadioSetting("settings.btmpskiptym", "-- B Band: Temp Skip Time (Secs)", rx) abset.append(rset) rx = RadioSettingValueBoolean(bool(_sets.bprgskpscn)) rset = RadioSetting("settings.bprgskpscn", "-- B Band: Program Skip Scan", rx) abset.append(rset) rx = RadioSettingValueString(10, 10, banklink(_bklk.blnk)) rset = RadioSetting("banklink.blnk", "-- B Band Banklink (use _ to skip)", rx) rset.set_apply_callback(myset_banklink, _bklk, "blnk") abset.append(rset) rx = RadioSettingValueBoolean(bool(_sets.bwxalert)) rset = RadioSetting("settings.bwxalert", "-- B Band: Weather Alert", rx) abset.append(rset) options = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"] rx = RadioSettingValueList(options, options[_wxch.bwxchan]) rset = RadioSetting("abwx.bwxchan", "-- B Band: Weather Channel", rx) abset.append(rset) # --- Microphone Keys # The Mic keys get wierd: stored values are indecis to the full # options list, but only a subset is valid... shortopts = [ "Off", "Monitor", "MR (Ch 0)", "MR (Ch 1)", "Band/Bank", "Scan", "Temp Skip", "Mode", "Low", "Dup", "Priority", "Tone", "MW", "Mute", "DTMF Direct", "T-Call" ] ptr = shortopts.index(MICKEYOPTS[_sets.mickyrxf1]) rx = RadioSettingValueList(shortopts, shortopts[ptr]) rset = RadioSetting("settings.mickyrxf1", "During Rx/Standby [F-1]", rx) rset.set_apply_callback(mic_keys, _sets, "mickyrxf1") mickey.append(rset) ptr = shortopts.index(MICKEYOPTS[_sets.mickyrxf2]) rx = RadioSettingValueList(shortopts, shortopts[ptr]) rset = RadioSetting("settings.mickyrxf2", "During Rx/Standby [F-2]", rx) rset.set_apply_callback(mic_keys, _sets, "mickyrxf2") mickey.append(rset) options = ["Off", "Low", "T-Call"] # NOT a subset of MICKEYOPTS rx = RadioSettingValueList(options, options[_sets.mickytxf1]) rset = RadioSetting("settings.mickytxf1", "During Tx [F-1]", rx) mickey.append(rset) rx = RadioSettingValueList(options, options[_sets.mickytxf2]) rset = RadioSetting("settings.mickytxf2", "During Tx [F-2]", rx) mickey.append(rset) # These next two get the full options list rx = RadioSettingValueList(MICKEYOPTS, MICKEYOPTS[_sets.mickyrxup]) rset = RadioSetting("settings.mickyrxup", "During Rx/Standby [Up]", rx) mickey.append(rset) rx = RadioSettingValueList(MICKEYOPTS, MICKEYOPTS[_sets.mickyrxdn]) rset = RadioSetting("settings.mickyrxdn", "During Rx/Standby [Down]", rx) mickey.append(rset) options = ["Off", "Low", "T-Call"] rx = RadioSettingValueList(options, options[_sets.mickytxup]) rset = RadioSetting("settings.mickytxup", "During Tx [Up]", rx) mickey.append(rset) rx = RadioSettingValueList(options, options[_sets.mickytxdn]) rset = RadioSetting("settings.mickytxdn", "During Tx [Down]", rx) mickey.append(rset) # --- Bluetooth rx = RadioSettingValueBoolean(bool(_sets.btoothon)) rset = RadioSetting("settings.btoothon", "Bluetooth", rx) bluet.append(rset) rx = RadioSettingValueBoolean(bool(_sets.btoothauto)) rset = RadioSetting("settings.btoothauto", "Auto Connect", rx) bluet.append(rset) options = ["Headset Only", "Headset & Speaker"] rx = RadioSettingValueList(options, options[_sets.bthdset]) rset = RadioSetting("settings.bthdset", "Headset Audio", rx) bluet.append(rset) options = [ "Normal", "Microphone", "PTT (Audio:Main)", "PTT(Audio:Controller)" ] rx = RadioSettingValueList(options, options[_sets.bthfctn]) rset = RadioSetting("settings.bthfctn", "Headset Function", rx) bluet.append(rset) rx = RadioSettingValueBoolean(bool(_sets.bthvox)) rset = RadioSetting("settings.bthvox", "Vox", rx) bluet.append(rset) options = ["Off", "1.0", "2", "3", "4", "5", "6", "7", "8", "9", "10"] rx = RadioSettingValueList(options, options[_sets.bthvoxlvl]) rset = RadioSetting("settings.bthvoxlvl", "Vox Level", rx) bluet.append(rset) options = ["0.5", "1.0", "1.5", "2.0", "2.5", "3.0"] rx = RadioSettingValueList(options, options[_sets.bthvoxdly]) rset = RadioSetting("settings.bthvoxdly", "Vox Delay (Secs)", rx) bluet.append(rset) options = ["Off", "1", "2", "3", "4", "5", "10", "15"] rx = RadioSettingValueList(options, options[_sets.bthvoxtot]) rset = RadioSetting("settings.bthvoxtot", "Vox Time-Out (Mins)", rx) bluet.append(rset) rx = RadioSettingValueBoolean(bool(_sets.bthhdpsav)) rset = RadioSetting("settings.bthhdpsav", "ICOM Headset Power-Save", rx) bluet.append(rset) rx = RadioSettingValueBoolean(bool(_sets.bth1ptt)) rset = RadioSetting("settings.bth1ptt", "ICOM Headset One-Touch PTT", rx) bluet.append(rset) rx = RadioSettingValueBoolean(bool(_sets.bthpttbeep)) rset = RadioSetting("settings.bthpttbeep", "ICOM Headset PTT Beep", rx) bluet.append(rset) rx = RadioSettingValueBoolean(bool(_sets.bthcustbeep)) rset = RadioSetting("settings.bthcustbeep", "ICOM Headset Custom Key Beep", rx) bluet.append(rset) rx = RadioSettingValueList(MICKEYOPTS, MICKEYOPTS[_sets.bthplaykey]) rset = RadioSetting("settings.bthplaykey", "ICOM Headset Custom Key [Play]", rx) bluet.append(rset) rx = RadioSettingValueList(MICKEYOPTS, MICKEYOPTS[_sets.bthfwdkey]) rset = RadioSetting("settings.bthfwdkey", "ICOM Headset Custom Key [Fwd]", rx) bluet.append(rset) rx = RadioSettingValueList(MICKEYOPTS, MICKEYOPTS[_sets.bthrwdkey]) rset = RadioSetting("settings.bthrwdkey", "ICOM Headset Custom Key [Rwd]", rx) bluet.append(rset) # ---- Display options = ["1: Dark", "2", "3", "4: Bright"] rx = RadioSettingValueList(options, options[_sets.backlight]) rset = RadioSetting("settings.backlight", "Backlight Level", rx) disp.append(rset) options = ["Off", "Auto-Off", "Auto-1", "Auto-2", "Auto-3"] rx = RadioSettingValueList(options, options[_sets.autodim]) rset = RadioSetting("settings.autodim", "Auto Dimmer", rx) disp.append(rset) options = ["5", "10"] rx = RadioSettingValueList(options, options[_sets.autodimtot]) rset = RadioSetting("settings.autodimtot", "Auto-Dimmer Timeout (Secs)", rx) disp.append(rset) options = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"] rx = RadioSettingValueList(options, options[_sets.contrast]) rset = RadioSetting("settings.contrast", "LCD Contrast", rx) disp.append(rset) rx = RadioSettingValueBoolean(bool(_sets.openmsg)) rset = RadioSetting("settings.openmsg", "Opening Message", rx) disp.append(rset) rx = RadioSettingValueBoolean(bool(_sets.memname)) rset = RadioSetting("settings.memname", "Memory Names", rx) disp.append(rset) options = ["CH ID", "Frequency"] rx = RadioSettingValueList(options, options[_sets.airbandch]) rset = RadioSetting("settings.airbandch", "Air Band Display", rx) disp.append(rset) # -- Sounds rx = RadioSettingValueInteger(0, 9, _sets.beeplvl) rset = RadioSetting("settings.beeplvl", "Beep Level", rx) sound.append(rset) rx = RadioSettingValueBoolean(bool(_sets.homebeep)) rset = RadioSetting("settings.homebeep", "Home Chan Beep", rx) sound.append(rset) rx = RadioSettingValueBoolean(bool(_sets.keybeep)) rset = RadioSetting("settings.keybeep", "Key Touch Beep", rx) sound.append(rset) rx = RadioSettingValueBoolean(bool(_sets.bandedgbeep)) rset = RadioSetting("settings.bandedgbeep", "Band Edge Beep", rx) sound.append(rset) rx = RadioSettingValueBoolean(bool(_sets.scanstpbeep)) rset = RadioSetting("settings.scanstpbeep", "Scan Stop Beep", rx) sound.append(rset) options = ["Off", "Mute", "Beep", "Mute & Beep"] rx = RadioSettingValueList(options, options[_sets.subandmute]) rset = RadioSetting("settings.subandmute", "Sub Band Mute", rx) sound.append(rset) # --- DTMF Codes options = ["100", "200", "300", "500"] rx = RadioSettingValueList(options, options[_sets.dtmfspd]) rset = RadioSetting("settings.dtmfspd", "DTMF Speed (mSecs)", rx) dtmf.append(rset) for kx in range(0, 16): stx = unpack_str(_dtm[kx].codes) rx = RadioSettingValueString(0, 24, stx) # NOTE the / to indicate indexed array rset = RadioSetting("dtmfcode/%d.codes" % kx, "DTMF Code %X" % kx, rx) rset.set_apply_callback(pack_chars, _dtm, "codes", kx) dtmf.append(rset) # --- Program Scan Edges for kx in range(0, 25): stx = "" for i in range(0, 6): stx += chr(_pses[kx].name[i]) stx = stx.rstrip() rx = RadioSettingValueString(0, 6, stx) rset = RadioSetting("pgmscanedge/%d.name" % kx, "Program Scan %d Name" % kx, rx) rset.set_apply_callback(myset_psnam, _pses, kx, "name", 6) edges.append(rset) # Freq's use the multiplier flags fmult = 5000.0 if _pses[kx].loflags == 0x10: fmult = 8333 if _pses[kx].loflags == 0x08: fmult = 6250.0 flow = (int(_pses[kx].lofreq) * fmult) / 1000000.0 flow = round(flow, 4) fmult = 5000.0 if _pses[kx].hiflags == 0x10: fmult = 8333 if _pses[kx].hiflags == 0x08: fmult = 6250.0 fhigh = (int(_pses[kx].hifreq) * fmult) / 1000000.0 fhigh = round(fhigh, 4) if (flow > 0) and (flow >= fhigh): # reverse em val = flow flow = fhigh fhigh = val rx = RadioSettingValueFloat(0, 550.0, flow, 0.010, 3) rset = RadioSetting("pgmscanedge/%d.lofreq" % kx, "-- Scan %d Low Limit" % kx, rx) rset.set_apply_callback(myset_frqflgs, _pses, kx, "loflags", "lofreq") edges.append(rset) rx = RadioSettingValueFloat(0, 550.0, fhigh, 0.010, 3) rset = RadioSetting("pgmscanedge/%d.hifreq" % kx, "-- Scan %d High Limit" % kx, rx) rset.set_apply_callback(myset_frqflgs, _pses, kx, "hiflags", "hifreq") edges.append(rset) # Tstep and Mode depend on the bands ndxt = 0 ndxm = 0 bxnd = 0 tsopt = [ "-", "5k", "6.25k", "10k", "12.5k", "15k", "20k", "25k", "30k", "50k" ] mdopt = ["-", "FM", "FM-N"] if fhigh > 0: if fhigh < 135.0: # Air band bxnd = 1 tsopt = ["-", "8.33k", "25k", "Auto"] ndxt = _pses[kx].tstp if ndxt == 0xe: # Auto ndxt = 3 elif ndxt == 8: # 25k ndxt = 2 elif ndxt == 2: # 8.33k ndxt = 1 else: ndxt = 0 mdopt = ["-"] elif (flow >= 137.0) and (fhigh <= 174.0): # VHF ndxt = _pses[kx].tstp - 1 ndxm = _pses[kx].mode + 1 bxnd = 2 elif (flow >= 375.0) and (fhigh <= 550.0): # UHF ndxt = _pses[kx].tstp - 1 ndxm = _pses[kx].mode + 1 bxnd = 3 else: # Mixed, ndx's = 0 default tsopt = ["-"] mdopt = ["-"] bxnd = 4 if (ndxt > 9) or (ndxt < 0): ndxt = 0 # trap ff if ndxm > 2: ndxm = 0 # end if fhigh > 0 rx = RadioSettingValueList(tsopt, tsopt[ndxt]) rset = RadioSetting("pgmscanedge/%d.tstp" % kx, "-- Scan %d Freq Step" % kx, rx) rset.set_apply_callback(myset_tsopt, _pses, kx, "tstp", bxnd) edges.append(rset) rx = RadioSettingValueList(mdopt, mdopt[ndxm]) rset = RadioSetting("pgmscanedge/%d.mode" % kx, "-- Scan %d Mode" % kx, rx) rset.set_apply_callback(myset_mdopt, _pses, kx, "mode", bxnd) edges.append(rset) # End for kx # --- Program Scan Links _psln = self._memobj.pslnam _pslg = self._memobj.pslgrps for kx in range(0, 10): stx = "" for i in range(0, 6): stx += chr(_psln[kx].nam[i]) stx = stx.rstrip() rx = RadioSettingValueString(0, 6, stx) rset = RadioSetting("pslnam/%d.nam" % kx, "Program Scan Link %d Name" % kx, rx) rset.set_apply_callback(myset_psnam, _psln, kx, "nam", 6) pslnk.append(rset) for px in range(0, 25): # Generate string numeric representation of 4-byte bitmask stx = "" for nx in range(0, 25): if nx < 8: if (_pslg[kx].msk[0] & (1 << nx)): stx += "%0d, " % nx elif (nx >= 8) and (nx < 16): if (_pslg[kx].msk[1] & (1 << (nx - 8))): sstx += "%0d, " % nx elif (nx >= 16) and (nx < 24): if (_pslg[kx].msk[2] & (1 << (nx - 16))): stx += "%0d, " % nx elif (nx >= 24): if (_pslg[kx].msk[3] & (1 << (nx - 24))): stx += "%0d, " % nx rx = RadioSettingValueString(0, 80, stx) rset = RadioSetting("pslgrps/%d.msk" % kx, "--- Scan Link %d Scans" % kx, rx) rset.set_apply_callback(myset_bitmask, _pslg, kx, "msk", 25) pslnk.append(rset) # end for px # End for kx return group # END get_settings()
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic Settings") fm = RadioSettingGroup("fm", "FM Radio") adv = RadioSettingGroup("adv", "Advanced Settings") group = RadioSettings(basic, fm, adv) # ## Basic Settings rs = RadioSetting( "tx_pwr", "TX Power", RadioSettingValueList(POWER_LIST, POWER_LIST[_settings.tx_pwr])) basic.append(rs) rs = RadioSetting("channel", "Active Channel", RadioSettingValueInteger(1, 20, _settings.channel)) basic.append(rs) rs = RadioSetting("squelch", "Squelch Level", RadioSettingValueInteger(0, 9, _settings.squelch)) basic.append(rs) rs = RadioSetting("vox", "VOX Level", RadioSettingValueInteger(0, 9, _settings.vox)) basic.append(rs) # volume validation, as the OEM software set 0xFF on write _volume = _settings.volume if _volume > 7: _volume = 7 rs = RadioSetting("volume", "Volume Level", RadioSettingValueInteger(0, 7, _volume)) basic.append(rs) rs = RadioSetting( "scantype", "Scan Type", RadioSettingValueList(SCAN_TYPE_LIST, SCAN_TYPE_LIST[_settings.scantype])) basic.append(rs) rs = RadioSetting( "timeout", "Time Out Timer (seconds)", RadioSettingValueList(TOT_LIST, TOT_LIST[_settings.timeout])) basic.append(rs) rs = RadioSetting( "voice", "Voice Prompt", RadioSettingValueList(LANGUAGE_LIST, LANGUAGE_LIST[_settings.voice])) basic.append(rs) rs = RadioSetting( "alarm", "Alarm Time", RadioSettingValueList(TIMER_LIST, TIMER_LIST[_settings.alarm])) basic.append(rs) rs = RadioSetting( "backlight", "Backlight", RadioSettingValueList(BACKLIGHT_LIST, BACKLIGHT_LIST[_settings.backlight])) basic.append(rs) rs = RadioSetting("blo", "Busy Lockout", RadioSettingValueBoolean(_settings.blo)) basic.append(rs) rs = RadioSetting("ste", "Squelch Tail Eliminate", RadioSettingValueBoolean(_settings.ste)) basic.append(rs) rs = RadioSetting("batsave", "Battery Save", RadioSettingValueBoolean(_settings.batsave)) basic.append(rs) rs = RadioSetting("lock", "Key Lock", RadioSettingValueBoolean(_settings.lock)) basic.append(rs) rs = RadioSetting("beep", "Key Beep", RadioSettingValueBoolean(_settings.beep)) basic.append(rs) # ## FM Settings rs = RadioSetting("fm_funct", "FM Function", RadioSettingValueBoolean(_settings.fm_funct)) fm.append(rs) rs = RadioSetting( "fmrange", "FM Range", RadioSettingValueList(FM_RANGE_LIST, FM_RANGE_LIST[_settings.fmrange])) fm.append(rs) # callbacks for the FM VFO def apply_fm_freq(setting, obj): setattr(obj, setting.get_name(), int(setting.value.get_value() * 10) - 650) _fm_vfo = int(_settings.fm_vfo) * 0.1 + 65 rs = RadioSetting("fm_vfo", "FM Station", RadioSettingValueFloat(65, 108, _fm_vfo)) rs.set_apply_callback(apply_fm_freq, _settings) fm.append(rs) # ## Advanced def apply_limit(setting, obj): setattr(obj, setting.get_name(), int(setting.value) * 10) rs = RadioSetting( "vhfl", "VHF Low Limit", RadioSettingValueInteger(130, 174, int(_settings.vhfl) / 10)) rs.set_apply_callback(apply_limit, _settings) adv.append(rs) rs = RadioSetting( "vhfh", "VHF High Limit", RadioSettingValueInteger(130, 174, int(_settings.vhfh) / 10)) rs.set_apply_callback(apply_limit, _settings) adv.append(rs) rs = RadioSetting( "uhfl", "UHF Low Limit", RadioSettingValueInteger(400, 520, int(_settings.uhfl) / 10)) rs.set_apply_callback(apply_limit, _settings) adv.append(rs) rs = RadioSetting( "uhfh", "UHF High Limit", RadioSettingValueInteger(400, 520, int(_settings.uhfh) / 10)) rs.set_apply_callback(apply_limit, _settings) adv.append(rs) rs = RadioSetting( "relaym", "Relay Mode", RadioSettingValueList(RELAY_MODE_LIST, RELAY_MODE_LIST[_settings.relaym])) adv.append(rs) return group
def get_memory(self, number): """Get the mem representation from the radio image""" _mem = self._memobj.memory[number - 1] # Create a high-level memory object to return to the UI mem = chirp_common.Memory() # Memory number mem.number = number if _mem.get_raw()[0] == "\xFF": mem.empty = True # but is not enough, you have to clear the memory in the mmap # to get it ready for the sync_out process, just in case _mem.set_raw("\xFF" * 16) # set the channel to inactive state self.set_active(number - 1, False) return mem # Freq and offset mem.freq = int(_mem.rxfreq) * 10 # tx freq can be blank if _mem.get_raw()[4] == "\xFF" or int(_mem.txen) == 255: # TX freq not set mem.offset = 0 mem.duplex = "off" else: # TX feq set offset = (int(_mem.txfreq) * 10) - mem.freq if offset < 0: mem.offset = abs(offset) mem.duplex = "-" elif offset > 0: mem.offset = offset mem.duplex = "+" else: mem.offset = 0 # power mem.power = POWER_LEVELS[int(_mem.power)] # skip mem.skip = self.get_scan(number - 1) # tone data rxtone = txtone = None txtone = self.decode_tone(_mem.tx_tone) rxtone = self.decode_tone(_mem.rx_tone) chirp_common.split_tone_decode(mem, txtone, rxtone) # Extra # bank and number in the channel mem.extra = RadioSettingGroup("extra", "Extra") bl = RadioSetting("busy", "Busy Channel lock", RadioSettingValueBoolean(not bool(_mem.busy))) mem.extra.append(bl) sf = RadioSetting("shift", "Beat Shift", RadioSettingValueBoolean(not bool(_mem.shift))) mem.extra.append(sf) return mem