def _get_display_settings(self): menu = RadioSettingGroup("display", "Display") display_settings = self._memobj.settings val = RadioSettingValueString( 0, 8, str(display_settings.power_on_msg).rstrip("\xFF")) rs = RadioSetting("display.power_on_msg", "Power on message", val) rs.set_apply_callback(self.apply_power_on_msg, display_settings) menu.append(rs) val = RadioSettingValueList( self._LCD_CONTRAST, self._LCD_CONTRAST[display_settings.contrast - 1]) rs = RadioSetting("display.contrast", "LCD Contrast", val) rs.set_apply_callback(self.apply_lcd_contrast, display_settings) menu.append(rs) val = RadioSettingValueList( self._LAMP_CONTROL, self._LAMP_CONTROL[display_settings.lamp_control]) rs = RadioSetting("display.lamp_control", "Lamp Control", val) rs.set_apply_callback(self.apply_lamp_control, display_settings) menu.append(rs) val = RadioSettingValueList( self._LAMP_TIMER, self._LAMP_TIMER[display_settings.lamp_timer - 2]) rs = RadioSetting("display.lamp_timer", "Lamp Timer", val) rs.set_apply_callback(self.apply_lamp_timer, display_settings) menu.append(rs) return menu
def get_memory(self, number): _mem = self._memobj.memory[number - 1] _nam = self._memobj.chan_names[number - 1] def _is_empty(): for i in range(0, 4): if _mem.rx_freq[i].get_raw() != "\xFF": return False return True mem = chirp_common.Memory() mem.number = number if _is_empty(): mem.empty = True return mem mem.freq = int(_mem.rx_freq) * 10 if int(_mem.rx_freq) == int(_mem.tx_freq): mem.duplex = "" mem.offset = 0 else: mem.duplex = int(_mem.rx_freq) > int(_mem.tx_freq) and "-" or "+" mem.offset = abs(int(_mem.rx_freq) - int(_mem.tx_freq)) * 10 mem.mode = _mem.w_n and "FM" or "NFM" self._get_tone(_mem, mem) mem.power = POWER_LEVELS[_mem.power] mem.extra = RadioSettingGroup("Extra", "extra") rs = RadioSetting( "lout", "Lock out", RadioSettingValueList(OFF_ON_LIST, OFF_ON_LIST[_mem.lout])) mem.extra.append(rs) rs = RadioSetting( "busy_loc", "Busy lock", RadioSettingValueList(BUSYLOCK_LIST, BUSYLOCK_LIST[_mem.busy_loc])) mem.extra.append(rs) rs = RadioSetting( "scan_add", "Scan add", RadioSettingValueList(NO_YES_LIST, NO_YES_LIST[_mem.scan_add])) mem.extra.append(rs) #TODO: Show name channel ## count = 0 ## for i in _nam.chan_name: ## if i == 0xFF: ## break ## try: ## mem.name += IP620_CHARSET[i] ## except Exception: ## LOG.error("Unknown name char %i: 0x%02x (mem %i)" % ## (count, i, number - 1)) ## mem.name += " " ## count += 1 ## mem.name = mem.name.rstrip() return mem
def get_memory(self, number): _mem = self._memobj.memory[number - 1] mem = chirp_common.Memory() mem.number = number if _mem.get_raw().startswith("\xFF\xFF\xFF\xFF"): mem.empty = True return mem mem.freq = int(_mem.rx_freq) * 10 txfreq = int(_mem.tx_freq) * 10 if self._is_txinh(_mem): mem.duplex = "off" mem.offset = 0 elif txfreq == mem.freq: mem.duplex = "" elif abs(txfreq - mem.freq) > 70000000: mem.duplex = "split" mem.offset = txfreq elif txfreq < mem.freq: mem.duplex = "-" mem.offset = mem.freq - txfreq elif txfreq > mem.freq: mem.duplex = "+" mem.offset = txfreq - mem.freq txmode, txval, txpol = self._decode_tone(_mem.tx_tone) rxmode, rxval, rxpol = self._decode_tone(_mem.rx_tone) chirp_common.split_tone_decode(mem, (txmode, txval, txpol), (rxmode, rxval, rxpol)) mem.name = str(self._memobj.names[number - 1].name) mem.name = mem.name.replace("\xFF", " ").rstrip() mem.skip = not _mem.scan and "S" or "" mem.mode = _mem.isnarrow and "NFM" or "FM" mem.power = POWER_LEVELS[1 - _mem.ishighpower] mem.extra = RadioSettingGroup("extra", "Extra Settings") rs = RadioSetting( "pttid", "PTT ID", RadioSettingValueList(PTTID_LIST, PTTID_LIST[_mem.pttid])) mem.extra.append(rs) rs = RadioSetting("vox", "VOX", RadioSettingValueBoolean(_mem.vox)) mem.extra.append(rs) rs = RadioSetting("bcl", "Busy Channel Lockout", RadioSettingValueList(BCL_LIST, BCL_LIST[_mem.bcl])) mem.extra.append(rs) rs = RadioSetting( "scramble_code", "Scramble Code", RadioSettingValueList(CODES_LIST, CODES_LIST[_mem.scramble_code])) mem.extra.append(rs) return mem
def get_memory(self, number): bitpos = (1 << ((number - 1) % 8)) bytepos = ((number - 1) / 8) LOG.debug("bitpos %s" % bitpos) LOG.debug("bytepos %s" % bytepos) _mem = self._memobj.memory[number - 1] _skp = self._memobj.skipflags[bytepos] mem = chirp_common.Memory() mem.number = number mem.freq = int(_mem.rxfreq) * 10 # We'll consider any blank (i.e. 0MHz frequency) to be empty if mem.freq == 0: mem.empty = True return mem if _mem.rxfreq.get_raw() == "\xFF\xFF\xFF\xFF": mem.freq = 0 mem.empty = True return mem if _mem.get_raw() == ("\xFF" * 16): LOG.debug("Initializing empty memory") _mem.set_raw("\x00" * 13 + "\x30\x8F\xF8") if int(_mem.rxfreq) == int(_mem.txfreq): mem.duplex = "" mem.offset = 0 else: mem.duplex = int(_mem.rxfreq) > int(_mem.txfreq) and "-" or "+" mem.offset = abs(int(_mem.rxfreq) - int(_mem.txfreq)) * 10 mem.mode = _mem.wide and "FM" or "NFM" self._get_tone(_mem, mem) mem.power = RT21_POWER_LEVELS[_mem.highpower] mem.skip = "" if (_skp & bitpos) else "S" LOG.debug("mem.skip %s" % mem.skip) mem.extra = RadioSettingGroup("Extra", "extra") rs = RadioSetting("bcl", "Busy Channel Lockout", RadioSettingValueList(BCL_LIST, BCL_LIST[_mem.bcl])) mem.extra.append(rs) rs = RadioSetting( "scramble_type", "Scramble Type", RadioSettingValueList(SCRAMBLE_LIST, SCRAMBLE_LIST[_mem.scramble_type - 8])) mem.extra.append(rs) return mem
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic Settings") top = RadioSettings(basic) rs = RadioSetting("settings.squelch", "Squelch Level", RadioSettingValueInteger(0, 9, _settings.squelch)) basic.append(rs) rs = RadioSetting( "settings.timeout", "Timeout Timer", RadioSettingValueList(TIMEOUT_LIST, TIMEOUT_LIST[_settings.timeout])) basic.append(rs) rs = RadioSetting( "settings.scanmode", "Scan Mode", RadioSettingValueList(SCANMODE_LIST, SCANMODE_LIST[_settings.scanmode])) basic.append(rs) rs = RadioSetting( "settings.voice", "Voice Prompts", RadioSettingValueList(VOICE_LIST, VOICE_LIST[_settings.voice])) basic.append(rs) rs = RadioSetting( "settings.voxgain", "VOX Level", RadioSettingValueList(VOX_LIST, VOX_LIST[_settings.voxgain])) basic.append(rs) rs = RadioSetting( "settings.voxdelay", "VOX Delay Time", RadioSettingValueList(VOXDELAY_LIST, VOXDELAY_LIST[_settings.voxdelay])) basic.append(rs) rs = RadioSetting("settings.save", "Battery Save", RadioSettingValueBoolean(_settings.save)) basic.append(rs) rs = RadioSetting("settings.beep", "Beep Tone", RadioSettingValueBoolean(_settings.beep)) basic.append(rs) def _filter(name): filtered = "" for char in str(name): if char in VALID_CHARS: filtered += char else: filtered += " " return filtered return top
def _get_ost(self, parent): tones = chirp_common.TONES[:] def apply_tone(setting, index, which): if str(setting.value) == 'Off': val = 0xFFFF else: val = int(float(str(setting.value)) * 10) setattr(self._memobj.ost_tones[index], '%stone' % which, val) def _tones(): return ['Off'] + [str(x) for x in tones] for i in range(0, 40): _ost = self._memobj.ost_tones[i] ost = RadioSettingGroup('ost%i' % i, 'OST %i' % (i + 1)) cur = str(_ost.name).rstrip('\x00') name = RadioSetting('name%i' % i, 'Name', RadioSettingValueString(0, 12, cur)) ost.append(name) if _ost.rxtone == 0xFFFF: cur = 'Off' else: cur = round(int(_ost.rxtone) / 10.0, 1) if cur not in tones: LOG.debug('Non-standard OST rx tone %i %s' % (i, cur)) tones.append(cur) tones.sort() rx = RadioSetting('rxtone%i' % i, 'RX Tone', RadioSettingValueList(_tones(), str(cur))) rx.set_apply_callback(apply_tone, i, 'rx') ost.append(rx) if _ost.txtone == 0xFFFF: cur = 'Off' else: cur = round(int(_ost.txtone) / 10.0, 1) if cur not in tones: LOG.debug('Non-standard OST tx tone %i %s' % (i, cur)) tones.append(cur) tones.sort() tx = RadioSetting('txtone%i' % i, 'TX Tone', RadioSettingValueList(_tones(), str(cur))) tx.set_apply_callback(apply_tone, i, 'tx') ost.append(tx) parent.append(ost)
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic Settings") top = RadioSettings(basic) rs = RadioSetting( "squelchlevel", "Squelch level", RadioSettingValueInteger(0, 9, _settings.squelchlevel)) basic.append(rs) rs = RadioSetting( "timeouttimer", "Timeout timer", RadioSettingValueList(TIMEOUTTIMER_LIST, TIMEOUTTIMER_LIST[_settings.timeouttimer])) basic.append(rs) rs = RadioSetting( "scanmode", "Scan mode", RadioSettingValueList(SCANMODE_LIST, SCANMODE_LIST[_settings.scanmode])) basic.append(rs) rs = RadioSetting( "voiceprompt", "Voice prompt", RadioSettingValueList(VOICE_LIST, VOICE_LIST[_settings.voiceprompt])) basic.append(rs) rs = RadioSetting( "voxlevel", "Vox level", RadioSettingValueList(VOXLEVEL_LIST, VOXLEVEL_LIST[_settings.voxlevel])) basic.append(rs) rs = RadioSetting( "voxdelay", "VOX delay", RadioSettingValueList(VOXDELAY_LIST, VOXDELAY_LIST[_settings.voxdelay])) basic.append(rs) rs = RadioSetting("batterysaver", "Battery saver", RadioSettingValueBoolean(_settings.batterysaver)) basic.append(rs) rs = RadioSetting("beep", "Beep", RadioSettingValueBoolean(_settings.beep)) basic.append(rs) return top
def get_memory(self, number): _mem = self._memobj.memory[number - 1] mem = chirp_common.Memory() mem.number = number if _mem.get_raw()[:4] == "\xFF\xFF\xFF\xFF": mem.empty = True return mem mem.freq = int(_mem.rx_freq) * 10 offset = (int(_mem.tx_freq) * 10) - mem.freq if offset < 0: mem.offset = abs(offset) mem.duplex = "-" elif offset > 0: mem.offset = offset mem.duplex = "+" else: mem.offset = 0 self._get_tone(_mem, mem) mem.power = POWER_LEVELS[_mem.highpower] mem.mode = MODES[_mem.wide] mem.skip = not _mem.scan and "S" or "" mem.extra = RadioSettingGroup("all", "All Settings") bcl = RadioSetting("bcl", "Busy Channel Lockout", RadioSettingValueBoolean(bool(_mem.bcl))) mem.extra.append(bcl) beat = RadioSetting("beatshift", "Beat Shift", RadioSettingValueBoolean(bool(_mem.beatshift))) mem.extra.append(beat) pttid = RadioSetting("pttid", "PTT ID", RadioSettingValueList(PTTID, PTTID[_mem.pttid])) mem.extra.append(pttid) signal = RadioSetting("signaling", "Signaling", RadioSettingValueList(SIGNAL, SIGNAL[ _mem.signaling & 0x01])) mem.extra.append(signal) return mem
def get_prog(i, val_list, valndx, sname, longname, f_apply): k = str(i + 1) val = val_list[valndx] valuelist = RadioSettingValueList(val_list, val) rs = RadioSetting(sname + k, longname + k, valuelist) rs.set_apply_callback(f_apply, i, self._memobj) group.append(rs)
def get_memory(self, number): if not self._repeaters: self.do_fetch() repeater = self._repeaters[number] mem = chirp_common.Memory() mem.number = number mem.name = repeater.get('city') mem.freq = chirp_common.parse_freq(repeater.get('frequency')) offset = chirp_common.parse_freq(repeater.get('offset', '0')) if offset > 0: mem.duplex = "+" elif offset < 0: mem.duplex = "-" else: mem.duplex = "" mem.offset = abs(offset) mem.mode = 'DMR' mem.comment = repeater.get('map_info') mem.extra = RadioSettingGroup("Extra", "extra") rs = RadioSetting( "color_code", "Color Code", RadioSettingValueList( range(16), int(repeater.get('color_code', 0)))) mem.extra.append(rs) return mem
def decode_sql(self, mem, chan): """ examine the radio channel fields and determine the correct CHIRP CSV values for tmode, cross_mode, and sql_override """ mem.extra = RadioSettingGroup("Extra", "extra") extra_modes = ["(None)", "PAGER"] value = extra_modes[chan.sql_type == 6] valuelist = RadioSettingValueList(extra_modes, value) rs = RadioSetting("sql_override", "Squelch override", valuelist) mem.extra.append(rs) if chan.sql_type == 6: return sql_map = RADIO_TMODES[chan.sql_type] ndx = 0 if len(sql_map[0]) > 1: # the sql_type is TSQL or DCS, so there are multiple UI mappings x = getattr(chan, sql_map[1]) r = getattr(chan, sql_map[2]) ndx = self.LOOKUP.index([x == 0, r == 0]) if ndx == 3 and x == r: ndx = 4 mem.tmode = sql_map[0][ndx][0] cross = sql_map[0][ndx][1] if cross: mem.cross_mode = cross if chan.rx_ctcss: mem.ctone = TONE_MAP[chan.rx_ctcss] if chan.tx_ctcss: mem.rtone = TONE_MAP[chan.tx_ctcss] if chan.tx_dcs: mem.dtcs = DTCS_MAP[chan.tx_dcs] if chan.rx_dcs: mem.rx_dtcs = DTCS_MAP[chan.rx_dcs]
def _get_battery_settings(self): menu = RadioSettingGroup("battery", "Battery") battery_settings = self._memobj.settings val = RadioSettingValueList( self._BATTERY_SAVER, self._BATTERY_SAVER[battery_settings.battery_saver]) rs = RadioSetting("battery.battery_saver", "Battery Saver", val) rs.set_apply_callback(self.apply_battery_saver, battery_settings) menu.append(rs) val = RadioSettingValueList(self._APO, self._APO[battery_settings.APO]) rs = RadioSetting("battery.APO", "Auto Power Off", val) rs.set_apply_callback(self.apply_APO, battery_settings) menu.append(rs) return menu
def _get_audio_settings(self): menu = RadioSettingGroup("audio", "Audio") audio_settings = self._memobj.settings val = RadioSettingValueList( self._AUDIO_BALANCE, self._AUDIO_BALANCE[audio_settings.balance]) rs = RadioSetting("audio.balance", "Balance", val) rs.set_apply_callback(self.apply_balance, audio_settings) menu.append(rs) val = RadioSettingValueList(self._KEY_BEEP, self._KEY_BEEP[audio_settings.key_beep]) rs = RadioSetting("audio.key_beep", "Key Beep", val) rs.set_apply_callback(self.apply_key_beep, audio_settings) menu.append(rs) return menu
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic Settings") top = RadioSettings(basic) rs = RadioSetting( "tot", "Time-out timer", RadioSettingValueList(TIMEOUTTIMER_LIST, TIMEOUTTIMER_LIST[_settings.tot])) basic.append(rs) rs = RadioSetting( "totalert", "TOT Pre-alert", RadioSettingValueList(TOTALERT_LIST, TOTALERT_LIST[_settings.totalert])) basic.append(rs) rs = RadioSetting( "vox", "VOX Gain", RadioSettingValueList(VOX_LIST, VOX_LIST[_settings.vox])) basic.append(rs) rs = RadioSetting( "voice", "Voice Annumciation", RadioSettingValueList(VOICE_LIST, VOICE_LIST[_settings.voice])) basic.append(rs) rs = RadioSetting("squelch", "Squelch Level", RadioSettingValueInteger(0, 9, _settings.squelch)) basic.append(rs) rs = RadioSetting( "voxdelay", "VOX Delay", RadioSettingValueList(VOXDELAY_LIST, VOXDELAY_LIST[_settings.voxdelay])) basic.append(rs) rs = RadioSetting("beep", "Beep", RadioSettingValueBoolean(_settings.beep)) basic.append(rs) rs = RadioSetting("save", "Battery Saver", RadioSettingValueBoolean(_settings.save)) basic.append(rs) return top
def _get_dtmf_settings(self): menu = RadioSettingGroup("dtmf_settings", "DTMF") dtmf = self._memobj.scan_settings val = RadioSettingValueList( self._DTMF_MODE, self._DTMF_MODE[dtmf.dtmf_mode]) rs = RadioSetting("scan_settings.dtmf_mode", "DTMF Mode", val) menu.append(rs) val = RadioSettingValueList( self._DTMF_DELAY, self._DTMF_DELAY[dtmf.dtmf_delay]) rs = RadioSetting( "scan_settings.dtmf_delay", "DTMF Delay", val) menu.append(rs) val = RadioSettingValueList( self._DTMF_SPEED, self._DTMF_SPEED[dtmf.dtmf_speed]) rs = RadioSetting( "scan_settings.dtmf_speed", "DTMF Speed", val) menu.append(rs) for i in range(10): name = "dtmf_%02d" % (i + 1) if i == 9: name = "dtmf_%02d" % 0 dtmfsetting = self._memobj.dtmf[i] dtmfstr = "" for c in dtmfsetting.memory: if c == 0xFF: break if c < len(FT70_DTMF_CHARS): dtmfstr += FT70_DTMF_CHARS[c] dtmfentry = RadioSettingValueString(0, 16, dtmfstr) dtmfentry.set_charset( FT70_DTMF_CHARS + list("abcdef ")) # Allow input in lowercase, space ? validation fails otherwise rs = RadioSetting(name, name.upper(), dtmfentry) rs.set_apply_callback(self.apply_dtmf, i) menu.append(rs) return menu
def get_memory(self, number): _mem = self._memobj.memory[number - 1] mem = chirp_common.Memory() mem.number = number bit = 1 << ((number - 1) % 8) byte = (number - 1) / 8 if self._memobj.emptyflags[byte] & bit: mem.empty = True return mem mem.freq = _mem.rx_freq * 10 mem.offset = abs(_mem.rx_freq - _mem.tx_freq) * 10 if _mem.tx_freq == _mem.rx_freq: mem.duplex = "" elif _mem.tx_freq < _mem.rx_freq: mem.duplex = "-" elif _mem.tx_freq > _mem.rx_freq: mem.duplex = "+" mem.mode = _mem.iswide and "FM" or "NFM" self._decode_tone(mem, _mem) mem.skip = (self._memobj.skipflags[byte] & bit) and "S" or "" for char in _mem.name: try: c = THUV3R_CHARSET[char] except: c = "" mem.name += c mem.name = mem.name.rstrip() mem.power = self.POWER_LEVELS[not _mem.power_high] mem.extra = RadioSettingGroup("extra", "Extra Settings") rs = RadioSetting("bclo_n", "Busy Channel Lockout", RadioSettingValueBoolean(not _mem.bclo_n)) mem.extra.append(rs) rs = RadioSetting("vox_n", "VOX", RadioSettingValueBoolean(not _mem.vox_n)) mem.extra.append(rs) rs = RadioSetting("tail", "Squelch Tail Elimination", RadioSettingValueBoolean(_mem.tail)) mem.extra.append(rs) rs = RadioSetting( "voice_mode", "Voice Mode", RadioSettingValueList(VOICE_MODE_LIST, VOICE_MODE_LIST[_mem.voice_mode - 1])) mem.extra.append(rs) return mem
def get_settings(self): """ Return a RadioSettings list containing one or more RadioSettingGroup or RadioSetting objects. These represent general settings that can be adjusted on the radio. """ cur = self._memobj.settings basic = RadioSettingGroup('basic', 'Basic Settings') rs = RadioSetting( 'squelchlevel', 'Squelch level', RadioSettingValueInteger(minval=0, maxval=9, current=cur.squelchlevel)) basic.append(rs) rs = RadioSetting( 'timeouttimer', 'Timeout timer', RadioSettingValueList( options=self.TIMEOUTTIMER_LIST, current=self.TIMEOUTTIMER_LIST[cur.timeouttimer])) basic.append(rs) rs = RadioSetting( 'voiceprompt', 'Voice prompt', RadioSettingValueList(options=self.VOICE_LIST, current=self.VOICE_LIST[cur.voiceprompt])) basic.append(rs) rs = RadioSetting( 'voxlevel', 'Vox level', RadioSettingValueList(options=self.VOXLEVEL_LIST, current=self.VOXLEVEL_LIST[cur.voxlevel])) basic.append(rs) rs = RadioSetting( 'voxdelay', 'VOX delay', RadioSettingValueList(options=self.VOXDELAY_LIST, current=self.VOXDELAY_LIST[cur.voxdelay])) basic.append(rs) basic.append( RadioSetting('batterysaver', 'Battery saver', RadioSettingValueBoolean(current=cur.batterysaver))) basic.append( RadioSetting('beep', 'Beep', RadioSettingValueBoolean(current=cur.beep))) return RadioSettings(basic)
def _get_gm_settings(self): menu = RadioSettingGroup("first_settings", "Group Monitor") # 24 GM RNG Select the beep option while receiving digital GM information. OFF / IN RNG /ALWAYS first_settings = self._memobj.first_settings val = RadioSettingValueList(self._GM_RING, self._GM_RING[first_settings.gm_ring]) rs = RadioSetting("first_settings.gm_ring", "GM Ring", val) menu.append(rs) # 25 GM INT Set the transmission interval of digital GM information. OFF / NORMAL / LONG scan_settings = self._memobj.scan_settings val = RadioSettingValueList( self._GM_INTERVAL, self._GM_INTERVAL[scan_settings.gm_interval]) rs = RadioSetting("scan_settings.gm_interval", "GM Interval", val) menu.append(rs) return menu
def _pure_choice_setting(self, settings_key, name, choices, default='Off'): if default is not None: choices = [default] + choices s = RadioSetting( settings_key, name, RadioSettingValueList( choices, get_choice(self._memobj.settings, settings_key, choices, default))) s.set_apply_callback(set_choice, self._memobj.settings, settings_key, choices, default) return s
def _get_display_settings(self): menu = RadioSettingGroup("display_settings", "Display") scan_settings = self._memobj.scan_settings val = RadioSettingValueList(self._LAMP_KEY, self._LAMP_KEY[scan_settings.lamp]) rs = RadioSetting("scan_settings.lamp", "Lamp", val) menu.append(rs) val = RadioSettingValueList(self._LCD_DIMMER, self._LCD_DIMMER[scan_settings.lcd_dimmer]) rs = RadioSetting("scan_settings.lcd_dimmer", "LCD Dimmer", val) menu.append(rs) opening_message = self._memobj.opening_message val = RadioSettingValueList( self._OPENING_MESSAGE, self._OPENING_MESSAGE[opening_message.flag]) rs = RadioSetting("opening_message.flag", "Opening Msg Mode", val) menu.append(rs) return menu
def _get_aprs_smartbeacon(self): menu = RadioSettingGroup("aprs_smartbeacon", "APRS SmartBeacon") aprs = self._memobj.aprs val = RadioSettingValueList( self._SMARTBEACON_PROFILE, self._SMARTBEACON_PROFILE[aprs.active_smartbeaconing]) rs = RadioSetting("aprs.active_smartbeaconing", "SmartBeacon profile", val) menu.append(rs) for profile in range(3): pfx = "type%d" % (profile + 1) path = "aprs.smartbeaconing_profile[%d]" % profile prof = aprs.smartbeaconing_profile[profile] low_val = RadioSettingValueInteger(2, 30, prof.low_speed_mph) high_val = RadioSettingValueInteger(3, 70, prof.high_speed_mph) low_val.get_max = lambda: min(30, int(high_val.get_value()) - 1) rs = RadioSetting("%s.low_speed_mph" % path, "%s Low Speed (mph)" % pfx, low_val) menu.append(rs) rs = RadioSetting("%s.high_speed_mph" % path, "%s High Speed (mph)" % pfx, high_val) menu.append(rs) val = RadioSettingValueInteger(1, 100, prof.slow_rate_min) rs = RadioSetting("%s.slow_rate_min" % path, "%s Slow rate (minutes)" % pfx, val) menu.append(rs) val = RadioSettingValueInteger(10, 180, prof.fast_rate_sec) rs = RadioSetting("%s.fast_rate_sec" % path, "%s Fast rate (seconds)" % pfx, val) menu.append(rs) val = RadioSettingValueInteger(5, 90, prof.turn_angle) rs = RadioSetting("%s.turn_angle" % path, "%s Turn angle (degrees)" % pfx, val) menu.append(rs) val = RadioSettingValueInteger(1, 255, prof.turn_slop) rs = RadioSetting("%s.turn_slop" % path, "%s Turn slop" % pfx, val) menu.append(rs) val = RadioSettingValueInteger(5, 180, prof.turn_time_sec) rs = RadioSetting("%s.turn_time_sec" % path, "%s Turn time (seconds)" % pfx, val) menu.append(rs) return menu
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic") settings = RadioSettings(basic) display = ["Frequency", "Channel", "Name"] rs = RadioSetting("display", "Display", RadioSettingValueList(display, display[_settings.display])) basic.append(rs) apo = ["Off"] + ['%.1f hour(s)' % (0.5 * x) for x in range(1, 25)] rs = RadioSetting("apo", "Automatic Power Off", RadioSettingValueList(apo, apo[_settings.apo])) basic.append(rs) def filter(s): s_ = "" for i in range(0, 8): c = str(s[i]) s_ += (c if c in chirp_common.CHARSET_ASCII else "") return s_ rs = RadioSetting("welcome", "Welcome Message", RadioSettingValueString(0, 8, filter(_settings.welcome))) basic.append(rs) rs = RadioSetting("beep", "Beep Enabled", RadioSettingValueBoolean(_settings.beep)) basic.append(rs) mute = ["Off", "TX", "RX", "TX/RX"] rs = RadioSetting("mute", "Sub Band Mute", RadioSettingValueList(mute, mute[_settings.mute])) basic.append(rs) return settings
def get_memory(self, number): _mem = self._memobj.memory[number - 1] mem = chirp_common.Memory() mem.number = number mem.freq = int(_mem.rxfreq) * 10 # We'll consider any blank (i.e. 0MHz frequency) to be empty if mem.freq == 0: mem.empty = True return mem if _mem.rxfreq.get_raw() == "\xFF\xFF\xFF\xFF": mem.freq = 0 mem.empty = True return mem if int(_mem.rxfreq) == int(_mem.txfreq): mem.duplex = "" mem.offset = 0 else: mem.duplex = int(_mem.rxfreq) > int(_mem.txfreq) and "-" or "+" mem.offset = abs(int(_mem.rxfreq) - int(_mem.txfreq)) * 10 mem.mode = _mem.wide and "FM" or "NFM" rxtone = txtone = None txtone = self.decode_tone(_mem.txtone) rxtone = self.decode_tone(_mem.rxtone) chirp_common.split_tone_decode(mem, txtone, rxtone) mem.power = RT26_POWER_LEVELS[_mem.highpower] if _mem.skip: mem.skip = "S" mem.extra = RadioSettingGroup("Extra", "extra") rs = RadioSetting("bcl", "BCL", RadioSettingValueBoolean(not _mem.bcl)) mem.extra.append(rs) rs = RadioSetting("epilogue", "Epilogue(STE)", RadioSettingValueBoolean(_mem.epilogue)) mem.extra.append(rs) val = 3 - _mem.pttid rs = RadioSetting("pttid", "PTT ID", RadioSettingValueList(LIST_PTTID, LIST_PTTID[val])) mem.extra.append(rs) return mem
def _get_extra(self, _mem): group = RadioSettingGroup('extra', 'Extra') s = RadioSetting('bcl', 'Busy Channel Lockout', RadioSettingValueBoolean(_mem.bcl)) group.append(s) s = RadioSetting('fhss', 'FHSS', RadioSettingValueBoolean(_mem.fhss)) group.append(s) # pttid, signal cur = PTTID[int(_mem.pttid)] s = RadioSetting('pttid', 'PTTID', RadioSettingValueList(PTTID, cur)) group.append(s) cur = SIGNAL[int(_mem.signal)] s = RadioSetting('signal', 'Signal', RadioSettingValueList(SIGNAL, cur)) group.append(s) return group
def _get_scan_settings(self): menu = RadioSettingGroup("scan_settings", "Scan") scan_settings = self._memobj.scan_settings # 23 DW RVT Turn the "Priority Channel Revert" feature ON or OFF during Dual Receive. val = RadioSettingValueList(self._OFF_ON, self._OFF_ON[scan_settings.dw_rt]) rs = RadioSetting("scan_settings.dw_rt", "Dual Watch Priority Channel Revert", val) menu.append(rs) # 21 DW INT Set the priority memory channel monitoring interval during Dual Receive. 0.1S - 5.0S - 10.0S val = RadioSettingValueList( self._SCAN_RESTART, self._SCAN_RESTART[scan_settings.dw_interval]) rs = RadioSetting("scan_settings.dw_interval", "Dual Watch Interval", val) menu.append(rs) # 22 DW RSM Configure the scan stop mode settings for Dual Receive. 2.0S - 10.0 S / BUSY / HOLD first_settings = self._memobj.first_settings val = RadioSettingValueList( self._SCAN_RESUME, self._SCAN_RESUME[first_settings.dw_resume_interval]) rs = RadioSetting("first_settings.dw_resume_interval", "Dual Watch Resume Interval", val) menu.append(rs) # 51 SCN.LMP Set the scan lamp ON or OFF when scanning stops. OFF / ON val = RadioSettingValueList(self._OFF_ON, self._OFF_ON[scan_settings.scan_lamp]) rs = RadioSetting("scan_settings.scan_lamp", "Scan Lamp", val) menu.append(rs) # 53 SCN.STR Set the scanning restart time. 0.1 S - 2.0 S - 10.0 S val = RadioSettingValueList( self._SCAN_RESTART, self._SCAN_RESTART[scan_settings.scan_restart]) rs = RadioSetting("scan_settings.scan_restart", "Scan Restart", val) menu.append(rs) # Scan Width Section # 50 SCV.WTH Set the VFO scan frequency range. BAND / ALL - NOT FOUND! # Scan Resume Section # 52 SCN.RSM Configure the scan stop mode settings. 2.0 S - 5.0 S - 10.0 S / BUSY / HOLD first_settings = self._memobj.first_settings val = RadioSettingValueList( self._SCAN_RESUME, self._SCAN_RESUME[first_settings.scan_resume]) rs = RadioSetting("first_settings.scan_resume", "Scan Resume", val) menu.append(rs) return menu
def get_settings(self): _settings = self._memobj.settings setmode = RadioSettingGroup("setmode", "General Settings") settings = RadioSettings(setmode) # LCD Backlight opts = ["Off", "On", "Auto"] setmode.append( RadioSetting("lcd", "LCD Backlight", RadioSettingValueList(opts, opts[_settings.lcd]))) # Mic Gain rs = RadioSetting("mic", "Mic Gain", RadioSettingValueInteger(1, 4, _settings.mic + 1)) def apply_mic(s, obj): setattr(obj, s.get_name(), int(s.value) - 1) rs.set_apply_callback(apply_mic, self._memobj.settings) setmode.append(rs) # Dial Assignment opts = ["Volume", "Tuning"] setmode.append( RadioSetting( "dial_assignment", "Dial Assignment", RadioSettingValueList(opts, opts[_settings.dial_assignment]))) # Display Type opts = ["Frequency", "Channel", "Name"] setmode.append( RadioSetting( "disp_type", "Display Type", RadioSettingValueList(opts, opts[_settings.disp_type]))) return settings
def get_memory(self, number): _mem = self._memobj.memory[number] _flag = self._memobj.flags[number] mem = chirp_common.Memory() mem.number = number if _flag.empty: mem.empty = True return mem mult = int(TUNING_STEPS[_mem.tuning_step] * 1000) mem.freq = (_mem.frequency * mult) mem.offset = (_mem.offset * mult) mem.name = str(_mem.name).rstrip() mem.rtone = chirp_common.TONES[_mem.repeater_tone] mem.ctone = chirp_common.TONES[_mem.ctcss_tone] mem.dtcs = chirp_common.DTCS_CODES[_mem.dtcs_code] mem.tuning_step = TUNING_STEPS[_mem.tuning_step] mem.tmode = TONE_MODES[_mem.tone_mode] mem.mode = "NFM" if _mem.mode_narrow else "FM" mem.dtcs_polarity = DTCS_POLARITY[_mem.dtcs_polarity] mem.duplex = DUPLEX[_mem.duplex] mem.skip = "S" if _flag.skip else "" mem.power = POWER_LEVELS[_mem.power] # Reverse duplex mem.extra = RadioSettingGroup("extra", "Extra") rev = RadioSetting("reverse_duplex", "Reverse duplex", RadioSettingValueBoolean(bool(_mem.reverse_duplex))) rev.set_doc("Reverse duplex") mem.extra.append(rev) # Tx inhibit tx_inhibit = RadioSetting( "tx_inhibit", "TX inhibit", RadioSettingValueBoolean(bool(_mem.tx_inhibit))) tx_inhibit.set_doc("TX inhibit") mem.extra.append(tx_inhibit) # Memory display style opt = ["Frequency", "Label"] dsp = RadioSetting("display_style", "Display style", RadioSettingValueList(opt, opt[_mem.display_style])) dsp.set_doc("Memory display style") mem.extra.append(dsp) return mem
def get_settings(self): _settings = self._memobj.settings groups = RadioSettings() for description in self.class_group_descs: groupname, title, parms = description group = RadioSettingGroup(groupname, title) groups.append(group) for parm in parms: param, title, opts = parm try: if isinstance(opts, list): # setting is a single value from the list objval = getattr(_settings, param) value = opts[objval] valuelist = RadioSettingValueList(opts, value) group.append(RadioSetting(param, title, valuelist)) else: # setting needs special handling. opts[0] is a # function name opts[0](self, group, parm) except Exception as e: LOG.debug("%s: cannot set %s to %s" % (e, param, repr(objval))) return groups
def get_settings(self): common = RadioSettingGroup("common", "Common Settings") band = RadioSettingGroup("band", "Band dependent Settings") arts = RadioSettingGroup("arts", "Auto Range Transponder System (ARTS)") dtmf = RadioSettingGroup("dtmf", "DTMF Settings") mic_button = RadioSettingGroup("mic_button", "Microphone Buttons") setmode = RadioSettings(common, band, arts, dtmf, mic_button) _overlay = self._memobj.overlay # numbers and names of settings refer to the way they're # presented in the set menu, as well as the list starting on # page 49 of the manual # 1 Automatic Power Off opts = [ "Off", "30 Min", "1 Hour", "1.5 Hours", "2 Hours", "2.5 Hours", "3 Hours", "3.5 Hours", "4 Hours", "4.5 Hours", "5 Hours", "5.5 Hours", "6 Hours", "6.5 Hours", "7 Hours", "7.5 Hours", "8 Hours", "8.5 Hours", "9 Hours", "9.5 Hours", "10 Hours", "10.5 Hours", "11 Hours", "11.5 Hours", "12 Hours", ] common.append( RadioSetting("apo", "Automatic Power Off", RadioSettingValueList(opts, opts[_overlay.apo]))) # 2 Automatic Repeater Shift function opts = ["Off", "On"] band.append( RadioSetting("ars_vhf", "Automatic Repeater Shift VHF", RadioSettingValueList(opts, opts[_overlay.ars_vhf]))) band.append( RadioSetting("ars_uhf", "Automatic Repeater Shift UHF", RadioSettingValueList(opts, opts[_overlay.ars_uhf]))) # 3 Selects the ARTS mode. # -> Only useful to set it on the radio directly # 4 Enables/disables the key/button beeper. opts = ["Off", "On"] common.append( RadioSetting("beep", "Key/Button Beep", RadioSettingValueList(opts, opts[_overlay.beep]))) # 5 Enables/disables the CW IDer during ARTS operation. opts = ["Off", "On"] arts.append( RadioSetting("cwid", "Enables/Disables the CW ID", RadioSettingValueList(opts, opts[_overlay.cwid]))) # 6 Callsign during ARTS operation. cwidw = _overlay.cwidw.get_raw() cwidw = cwidw.rstrip('\x00') val = RadioSettingValueString(0, 6, cwidw) val.set_charset(CHARSET) rs = RadioSetting("cwidw", "CW Identifier Callsign", val) def apply_cwid(setting): value_string = setting.value.get_value() _overlay.cwidw.set_value(value_string) rs.set_apply_callback(apply_cwid) arts.append(rs) # 7 Front panel display's illumination level. opts = ["0: Off", "1: Max", "2", "3", "4", "5", "6", "7: Min"] common.append( RadioSetting("dim", "Display Illumination", RadioSettingValueList(opts, opts[_overlay.dim]))) # 8 Setting the DCS code number. # Note: This Menu item can be set independently for each band, # and independently in each memory. # 9 Activates the DCS Code Search # -> Only useful if set on radio itself # 10 Selects 'Normal' or 'Inverted' DCS coding. opts = ["TRX Normal", "RX Reversed", "TX Reversed", "TRX Reversed"] band.append( RadioSetting("dcsnr_vhf", "DCS coding VHF", RadioSettingValueList(opts, opts[_overlay.dcsnr_vhf]))) band.append( RadioSetting("dcsnr_uhf", "DCS coding UHF", RadioSettingValueList(opts, opts[_overlay.dcsnr_uhf]))) # 11 Selects the 'sub' band display format opts = [ "Frequency", "Off / Sub Band disabled", "DC Input Voltage", "CW ID" ] common.append( RadioSetting("disp", "Sub Band Display Format", RadioSettingValueList(opts, opts[_overlay.disp]))) # 12 Setting the DTMF Autodialer delay time opts = ["50 ms", "250 ms", "450 ms", "750 ms", "1 s"] dtmf.append( RadioSetting("dtmfd", "Autodialer delay time", RadioSettingValueList(opts, opts[_overlay.dtmfd]))) # 13 Setting the DTMF Autodialer sending speed opts = ["50 ms", "75 ms", "100 ms"] dtmf.append( RadioSetting("dtmfs", "Autodialer sending speed", RadioSettingValueList(opts, opts[_overlay.dtmfs]))) # 14 Current DTMF Autodialer memory rs = RadioSetting("dtmfw", "Current Autodialer memory", RadioSettingValueInteger(1, 16, _overlay.dtmfw + 1)) def apply_dtmfw(setting): _overlay.dtmfw = setting.value.get_value() - 1 rs.set_apply_callback(apply_dtmfw) dtmf.append(rs) # DTMF Memory for i in range(16): dtmf_string = "" for j in range(16): dtmf_char = '' dtmf_int = int(self._memobj.dtmf_mem[i].dtmf[j]) if dtmf_int < 10: dtmf_char = str(dtmf_int) elif dtmf_int == 14: dtmf_char = '*' elif dtmf_int == 15: dtmf_char = '#' elif dtmf_int == 255: break dtmf_string += dtmf_char radio_setting_value_string = RadioSettingValueString( 0, 16, dtmf_string) radio_setting_value_string.set_charset(DTMF_CHARSET) rs = RadioSetting("dtmf_{0:02d}".format(i), "DTMF Mem " + str(i + 1), radio_setting_value_string) def apply_dtmf(setting, index): radio_setting_value_string = setting.value.get_value().rstrip() j = 0 for dtmf_char in radio_setting_value_string: dtmf_int = 255 if dtmf_char in "0123456789": dtmf_int = int(dtmf_char) elif dtmf_char == '*': dtmf_int = 14 elif dtmf_char == '#': dtmf_int = 15 if dtmf_int < 255: self._memobj.dtmf_mem[index].dtmf[j] = dtmf_int j += 1 if j < 16: self._memobj.dtmf_mem[index].dtmf[j] = 255 rs.set_apply_callback(apply_dtmf, i) dtmf.append(rs) # 16 Enables/disables the PTT switch lock opts = ["Off", "Band A", "Band B", "Both"] common.append( RadioSetting("lockt", "PTT switch lock", RadioSettingValueList(opts, opts[_overlay.lockt]))) # 17 Selects the Microphone type to be used opts = ["MH-42", "MH-48"] common.append( RadioSetting("mic", "Microphone type", RadioSettingValueList(opts, opts[_overlay.mic]))) # 18 Reduces the audio level on the sub receiver when the # main receiver is active opts = ["Off", "On"] common.append( RadioSetting("mute", "Mute Sub Receiver", RadioSettingValueList(opts, opts[_overlay.mute]))) # 20 - 23 Programming the microphones button assignment buttons = [ "ACC / P1", "P / P2", "P1 / P3", "P2 / P4", ] opts_button = [ "Low", "Tone", "MHz", "Rev", "Home", "Band", "VFO / Memory", "Sql Off", "1750 Hz Tone Call", "Repeater", "Priority" ] for i, button in enumerate(buttons): rs = RadioSetting( "button" + str(i), button, RadioSettingValueList(opts_button, opts_button[_overlay.button[i]])) def apply_button(setting, index): value_string = setting.value.get_value() value_int = opts_button.index(value_string) _overlay.button[index] = value_int rs.set_apply_callback(apply_button, i) mic_button.append(rs) # 24 Adjusts the RF SQL threshold level opts = ["Off", "S-1", "S-5", "S-9", "S-FULL"] band.append( RadioSetting( "rf_sql_vhf", "RF Sql VHF", RadioSettingValueList(opts, opts[_overlay.rf_sql_vhf]))) band.append( RadioSetting( "rf_sql_uhf", "RF Sql UHF", RadioSettingValueList(opts, opts[_overlay.rf_sql_uhf]))) # 25 Selects the Scan-Resume mode opts = ["Busy", "Time"] band.append( RadioSetting("scan_vhf", "Scan-Resume VHF", RadioSettingValueList(opts, opts[_overlay.scan_vhf]))) band.append( RadioSetting("scan_uhf", "Scan-Resume UHF", RadioSettingValueList(opts, opts[_overlay.scan_uhf]))) # 28 Defining the audio path to the external speaker opts = ["Off", "Band A", "Band B", "Both"] common.append( RadioSetting( "speaker_cnt", "External Speaker", RadioSettingValueList(opts, opts[_overlay.speaker_cnt]))) # 31 Sets the Time-Out Timer opts = ["Off", "Band A", "Band B", "Both"] common.append( RadioSetting("tot", "TX Time-Out [Min.] (0 = Off)", RadioSettingValueInteger(0, 30, _overlay.tot))) # 32 Reducing the MIC Gain (and Deviation) opts = ["Off", "On"] band.append( RadioSetting("txnar_vhf", "TX Narrowband VHF", RadioSettingValueList(opts, opts[_overlay.txnar_vhf]))) band.append( RadioSetting("txnar_uhf", "TX Narrowband UHF", RadioSettingValueList(opts, opts[_overlay.txnar_uhf]))) # 33 Enables/disables the VFO Tracking feature opts = ["Off", "On"] common.append( RadioSetting("vfotr", "VFO Tracking", RadioSettingValueList(opts, opts[_overlay.vfotr]))) # 34 Selects the receiving mode on the VHF band opts = ["Inhibit (only FM)", "AM", "Auto"] common.append( RadioSetting("am", "AM Mode", RadioSettingValueList(opts, opts[_overlay.am]))) # Current Band opts = ["VHF", "UHF"] common.append( RadioSetting( "current_band", "Current Band", RadioSettingValueList(opts, opts[_overlay.current_band]))) # Show number of VHF and UHF channels val = RadioSettingValueString(0, 7, str(int(self._memobj.nb_mem_used_vhf))) val.set_mutable(False) rs = RadioSetting("num_chan_vhf", "Number of VHF channels", val) common.append(rs) val = RadioSettingValueString(0, 7, str(int(self._memobj.nb_mem_used_uhf))) val.set_mutable(False) rs = RadioSetting("num_chan_uhf", "Number of UHF channels", val) common.append(rs) return setmode
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic Settings") group = RadioSettings(basic) rs = RadioSetting("ch", "Channel Indication Mode", RadioSettingValueBoolean(_settings.ch)) basic.append(rs) rs = RadioSetting("expand", "Expanded Settings Mode", RadioSettingValueBoolean(_settings.expand)) basic.append(rs) rs = RadioSetting("beep", "Beep Tones", RadioSettingValueBoolean(_settings.beep)) basic.append(rs) rs = RadioSetting( "autorp", "Auto Repeater Function", RadioSettingValueList(AUTORP_LIST, AUTORP_LIST[_settings.autorp])) basic.append(rs) rs = RadioSetting("ritfunct", "RIT Runction", RadioSettingValueBoolean(_settings.ritfunct)) basic.append(rs) rs = RadioSetting("rit", "RIT Shift (KHz)", RadioSettingValueInteger(-7, 7, _settings.rit)) basic.append(rs) rs = RadioSetting("lock", "Lock", RadioSettingValueBoolean(_settings.lock)) basic.append(rs) rs = RadioSetting( "lockgroup", "Lock Group", RadioSettingValueList(LOCKGROUP_LIST, LOCKGROUP_LIST[_settings.lockgroup])) basic.append(rs) rs = RadioSetting( "squelch", "Squelch", RadioSettingValueList(SQUELCH_LIST, SQUELCH_LIST[_settings.squelch])) basic.append(rs) rs = RadioSetting( "monitor", "Monitor Switch Function", RadioSettingValueList(MONITOR_LIST, MONITOR_LIST[_settings.monitor])) basic.append(rs) rs = RadioSetting( "light", "Display Backlighting", RadioSettingValueList(LIGHT_LIST, LIGHT_LIST[_settings.light])) basic.append(rs) rs = RadioSetting( "priority", "Priority Watch Operation", RadioSettingValueList(PRIORITY_LIST, PRIORITY_LIST[_settings.priority])) basic.append(rs) rs = RadioSetting("p_scan", "Frequency Skip Function", RadioSettingValueBoolean(_settings.p_scan)) basic.append(rs) rs = RadioSetting( "bnk_scan", "Memory Bank Scan Selection", RadioSettingValueList(BANKSCAN_LIST, BANKSCAN_LIST[_settings.bnk_scan])) basic.append(rs) rs = RadioSetting( "edge", "Band Edge Scan Selection", RadioSettingValueList(EDGE_LIST, EDGE_LIST[_settings.edge])) basic.append(rs) rs = RadioSetting( "pause", "Scan Pause Time", RadioSettingValueList(PAUSE_LIST, PAUSE_LIST[_settings.pause])) basic.append(rs) rs = RadioSetting( "resume", "Scan Resume Time", RadioSettingValueList(RESUME_LIST, RESUME_LIST[_settings.resume])) basic.append(rs) rs = RadioSetting("p_save", "Power Saver", RadioSettingValueBoolean(_settings.p_save)) basic.append(rs) rs = RadioSetting( "ap_off", "Auto Power-off Function", RadioSettingValueList(APOFF_LIST, APOFF_LIST[_settings.ap_off])) basic.append(rs) rs = RadioSetting("speed", "Dial Speed Acceleration", RadioSettingValueBoolean(_settings.speed)) basic.append(rs) rs = RadioSetting( "d_sel", "Dial Select Step", RadioSettingValueList(D_SEL_LIST, D_SEL_LIST[_settings.d_sel])) basic.append(rs) return group