def get_settings(self): _mem = self._memobj basic = RadioSettingGroup("basic", "Basic") top = RadioSettings(basic) def _f(val): string = "" for char in str(val): if char == "\xFF": break string += char return string line1 = RadioSetting("messages.line1", "Message Line 1", RadioSettingValueString(0, 32, _f(_mem.messages.line1), autopad=False)) basic.append(line1) line2 = RadioSetting("messages.line2", "Message Line 2", RadioSettingValueString(0, 32, _f(_mem.messages.line2), autopad=False)) basic.append(line2) return top
def make_speed_switch_setting(radio): if not radio.__class__._can_hispeed: return [] drvopts = RadioSettingGroup("drvopts", "Driver Options") rs = RadioSetting("drv_clone_speed", "Use Hi-Speed Clone", RadioSettingValueBoolean(radio._can_hispeed)) drvopts.append(rs) return drvopts
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_settings(self): top = RadioSettings() aprs = RadioSettingGroup("aprs", "APRS") top.append(aprs) myc = self._memobj.aprs_my_callsign rs = RadioSetting("aprs_my_callsign.call", "APRS My Callsign", RadioSettingValueString(0, 6, aprs_call_to_str(myc.call))) aprs.append(rs) rs = RadioSetting("aprs_my_callsign.ssid", "APRS My SSID", RadioSettingValueInteger(0, 15, myc.ssid)) aprs.append(rs) return top
def _get_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_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_settings(self): _general = self._memobj.general _info = self._memobj.info basic = RadioSettingGroup("basic", "Basic") info = RadioSettingGroup("info", "Model Info") general = RadioSettingGroup("general", "General Settings") # top = RadioSettings(identity, basic) top = RadioSettings(general) general.append(RadioSetting("dmrid", "DMR Radio ID", RadioSettingValueInteger(0, 100000000, _general.dmrid))) general.append( RadioSetting("line1", "Startup Line 1", RadioSettingValueString(0, 10, utftoasc(str(_general.line1)))) ) general.append( RadioSetting("line2", "Startup Line 2", RadioSettingValueString(0, 10, utftoasc(str(_general.line2)))) ) return top
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic Settings") fm = RadioSettingGroup("fm", "FM Radio") adv = RadioSettingGroup("adv", "Advanced Settings") group = RadioSettings(basic, fm, adv) # ## Basic Settings rs = RadioSetting("tx_pwr", "TX Power", RadioSettingValueList( POWER_LIST, POWER_LIST[_settings.tx_pwr])) basic.append(rs) rs = RadioSetting("channel", "Active Channel", RadioSettingValueInteger(1, 20, _settings.channel)) basic.append(rs) rs = RadioSetting("squelch", "Squelch Level", RadioSettingValueInteger(0, 9, _settings.squelch)) basic.append(rs) rs = RadioSetting("vox", "VOX Level", RadioSettingValueInteger(0, 9, _settings.vox)) basic.append(rs) # volume validation, as the OEM software set 0xFF on write _volume = _settings.volume if _volume > 7: _volume = 7 rs = RadioSetting("volume", "Volume Level", RadioSettingValueInteger(0, 7, _volume)) basic.append(rs) rs = RadioSetting("scantype", "Scan Type", RadioSettingValueList(SCAN_TYPE_LIST, SCAN_TYPE_LIST[ _settings.scantype])) basic.append(rs) rs = RadioSetting("timeout", "Time Out Timer (seconds)", RadioSettingValueList( TOT_LIST, TOT_LIST[_settings.timeout])) basic.append(rs) rs = RadioSetting("voice", "Voice Prompt", RadioSettingValueList( LANGUAGE_LIST, LANGUAGE_LIST[_settings.voice])) basic.append(rs) rs = RadioSetting("alarm", "Alarm Time", RadioSettingValueList( TIMER_LIST, TIMER_LIST[_settings.alarm])) basic.append(rs) rs = RadioSetting("backlight", "Backlight", RadioSettingValueList( BACKLIGHT_LIST, BACKLIGHT_LIST[_settings.backlight])) basic.append(rs) rs = RadioSetting("blo", "Busy Lockout", RadioSettingValueBoolean(_settings.blo)) basic.append(rs) rs = RadioSetting("ste", "Squelch Tail Eliminate", RadioSettingValueBoolean(_settings.ste)) basic.append(rs) rs = RadioSetting("batsave", "Battery Save", RadioSettingValueBoolean(_settings.batsave)) basic.append(rs) rs = RadioSetting("lock", "Key Lock", RadioSettingValueBoolean(_settings.lock)) basic.append(rs) rs = RadioSetting("beep", "Key Beep", RadioSettingValueBoolean(_settings.beep)) basic.append(rs) # ## FM Settings rs = RadioSetting("fm_funct", "FM Function", RadioSettingValueBoolean(_settings.fm_funct)) fm.append(rs) rs = RadioSetting("fmrange", "FM Range", RadioSettingValueList( FM_RANGE_LIST, FM_RANGE_LIST[_settings.fmrange])) fm.append(rs) # callbacks for the FM VFO def apply_fm_freq(setting, obj): setattr(obj, setting.get_name(), int(setting.value. get_value() * 10) - 650) _fm_vfo = int(_settings.fm_vfo) * 0.1 + 65 rs = RadioSetting("fm_vfo", "FM Station", RadioSettingValueFloat(65, 108, _fm_vfo)) rs.set_apply_callback(apply_fm_freq, _settings) fm.append(rs) # ## Advanced def apply_limit(setting, obj): setattr(obj, setting.get_name(), int(setting.value) * 10) rs = RadioSetting("vhfl", "VHF Low Limit", RadioSettingValueInteger(130, 174, int( _settings.vhfl) / 10)) rs.set_apply_callback(apply_limit, _settings) adv.append(rs) rs = RadioSetting("vhfh", "VHF High Limit", RadioSettingValueInteger(130, 174, int( _settings.vhfh) / 10)) rs.set_apply_callback(apply_limit, _settings) adv.append(rs) rs = RadioSetting("uhfl", "UHF Low Limit", RadioSettingValueInteger(400, 520, int( _settings.uhfl) / 10)) rs.set_apply_callback(apply_limit, _settings) adv.append(rs) rs = RadioSetting("uhfh", "UHF High Limit", RadioSettingValueInteger(400, 520, int( _settings.uhfh) / 10)) rs.set_apply_callback(apply_limit, _settings) adv.append(rs) rs = RadioSetting("relaym", "Relay Mode", RadioSettingValueList(RELAY_MODE_LIST, RELAY_MODE_LIST[_settings.relaym])) adv.append(rs) return group
def get_settings(self): _settings = self._memobj.settings 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_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_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic Settings") group = RadioSettingGroup("top", "All Settings", basic) rs = RadioSetting("ch", "Channel Indication Mode", RadioSettingValueBoolean(_settings.ch)) basic.append(rs) rs = RadioSetting("expand", "Expanded Settings Mode", RadioSettingValueBoolean(_settings.expand)) basic.append(rs) rs = RadioSetting("beep", "Beep Tones", RadioSettingValueBoolean(_settings.beep)) basic.append(rs) rs = RadioSetting("autorp", "Auto Repeater Function", RadioSettingValueList(AUTORP_LIST, AUTORP_LIST[_settings.autorp])) basic.append(rs) rs = RadioSetting("ritfunct", "RIT Runction", RadioSettingValueBoolean(_settings.ritfunct)) basic.append(rs) rs = RadioSetting("rit", "RIT Shift (KHz)", RadioSettingValueInteger(-7, 7, _settings.rit)) basic.append(rs) rs = RadioSetting("lock", "Lock", RadioSettingValueBoolean(_settings.lock)) basic.append(rs) rs = RadioSetting("lockgroup", "Lock Group", RadioSettingValueList(LOCKGROUP_LIST, LOCKGROUP_LIST[_settings.lockgroup])) basic.append(rs) rs = RadioSetting("squelch", "Squelch", RadioSettingValueList(SQUELCH_LIST, SQUELCH_LIST[_settings.squelch])) basic.append(rs) rs = RadioSetting("monitor", "Monitor Switch Function", RadioSettingValueList(MONITOR_LIST, MONITOR_LIST[_settings.monitor])) basic.append(rs) rs = RadioSetting("light", "Display Backlighting", RadioSettingValueList(LIGHT_LIST, LIGHT_LIST[_settings.light])) basic.append(rs) rs = RadioSetting("priority", "Priority Watch Operation", RadioSettingValueList(PRIORITY_LIST, PRIORITY_LIST[_settings.priority])) basic.append(rs) rs = RadioSetting("p_scan", "Frequency Skip Function", RadioSettingValueBoolean(_settings.p_scan)) basic.append(rs) rs = RadioSetting("bnk_scan", "Memory Bank Scan Selection", RadioSettingValueList(BANKSCAN_LIST, BANKSCAN_LIST[_settings.bnk_scan])) basic.append(rs) rs = RadioSetting("edge", "Band Edge Scan Selection", RadioSettingValueList(EDGE_LIST, EDGE_LIST[_settings.edge])) basic.append(rs) rs = RadioSetting("pause", "Scan Pause Time", RadioSettingValueList(PAUSE_LIST, PAUSE_LIST[_settings.pause])) basic.append(rs) rs = RadioSetting("resume", "Scan Resume Time", RadioSettingValueList(RESUME_LIST, RESUME_LIST[_settings.resume])) basic.append(rs) rs = RadioSetting("p_save", "Power Saver", RadioSettingValueBoolean(_settings.p_save)) basic.append(rs) rs = RadioSetting("ap_off", "Auto Power-off Function", RadioSettingValueList(APOFF_LIST, APOFF_LIST[_settings.ap_off])) basic.append(rs) rs = RadioSetting("speed", "Dial Speed Acceleration", RadioSettingValueBoolean(_settings.speed)) basic.append(rs) rs = RadioSetting("d_sel", "Dial Select Step", RadioSettingValueList(D_SEL_LIST, D_SEL_LIST[_settings.d_sel])) basic.append(rs) return group
def _get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic Settings") advanced = RadioSettingGroup("advanced", "Advanced Settings") group = RadioSettingGroup("top", "All Settings", basic, advanced) rs = RadioSetting("squelch", "Carrier Squelch Level", RadioSettingValueInteger(0, 9, _settings.squelch)) basic.append(rs) rs = RadioSetting("save", "Battery Saver", RadioSettingValueInteger(0, 4, _settings.save)) basic.append(rs) rs = RadioSetting("abr", "Backlight", RadioSettingValueBoolean(_settings.abr)) basic.append(rs) rs = RadioSetting("tdr", "Dual Watch (BDR)", RadioSettingValueBoolean(_settings.tdr)) advanced.append(rs) rs = RadioSetting("tdrab", "Dual Watch TX Priority", RadioSettingValueList(uv5r.TDRAB_LIST, uv5r.TDRAB_LIST[_settings.tdrab])) advanced.append(rs) rs = RadioSetting("alarm", "Alarm", RadioSettingValueBoolean(_settings.alarm)) advanced.append(rs) rs = RadioSetting("beep", "Beep", RadioSettingValueBoolean(_settings.beep)) basic.append(rs) rs = RadioSetting("timeout", "Timeout Timer", RadioSettingValueList(uv5r.TIMEOUT_LIST, uv5r.TIMEOUT_LIST[_settings.timeout])) basic.append(rs) rs = RadioSetting("screv", "Scan Resume", RadioSettingValueList(uv5r.RESUME_LIST, uv5r.RESUME_LIST[_settings.screv])) advanced.append(rs) rs = RadioSetting("mdfa", "Display Mode (A)", RadioSettingValueList(uv5r.MODE_LIST, uv5r.MODE_LIST[_settings.mdfa])) basic.append(rs) rs = RadioSetting("mdfb", "Display Mode (B)", RadioSettingValueList(uv5r.MODE_LIST, uv5r.MODE_LIST[_settings.mdfb])) basic.append(rs) rs = RadioSetting("bcl", "Busy Channel Lockout", RadioSettingValueBoolean(_settings.bcl)) advanced.append(rs) rs = RadioSetting("autolk", "Automatic Key Lock", RadioSettingValueBoolean(_settings.autolk)) advanced.append(rs) rs = RadioSetting("fmradio", "Broadcast FM Radio", RadioSettingValueBoolean(_settings.fmradio)) advanced.append(rs) rs = RadioSetting("wtled", "Standby LED Color", RadioSettingValueList(COLOR_LIST, COLOR_LIST[_settings.wtled])) basic.append(rs) rs = RadioSetting("rxled", "RX LED Color", RadioSettingValueList(COLOR_LIST, COLOR_LIST[_settings.rxled])) basic.append(rs) rs = RadioSetting("txled", "TX LED Color", RadioSettingValueList(COLOR_LIST, COLOR_LIST[_settings.txled])) basic.append(rs) rs = RadioSetting("reset", "RESET Menu", RadioSettingValueBoolean(_settings.reset)) advanced.append(rs) rs = RadioSetting("menu", "All Menus", RadioSettingValueBoolean(_settings.menu)) advanced.append(rs) if len(self._mmap.get_packed()) == 0x1808: # Old image, without aux block return group other = RadioSettingGroup("other", "Other Settings") group.append(other) def _filter(name): filtered = "" for char in str(name): if char in chirp_common.CHARSET_ASCII: filtered += char else: filtered += " " return filtered _msg = self._memobj.poweron_msg rs = RadioSetting("poweron_msg.line1", "Power-On Message 1", RadioSettingValueString(0, 7, _filter(_msg.line1))) other.append(rs) rs = RadioSetting("poweron_msg.line2", "Power-On Message 2", RadioSettingValueString(0, 7, _filter(_msg.line2))) other.append(rs) limit = "limits" vhf_limit = getattr(self._memobj, limit).vhf rs = RadioSetting("%s.vhf.lower" % limit, "VHF Lower Limit (MHz)", RadioSettingValueInteger(1, 1000, vhf_limit.lower)) other.append(rs) rs = RadioSetting("%s.vhf.upper" % limit, "VHF Upper Limit (MHz)", RadioSettingValueInteger(1, 1000, vhf_limit.upper)) other.append(rs) rs = RadioSetting("%s.vhf.enable" % limit, "VHF TX Enabled", RadioSettingValueBoolean(vhf_limit.enable)) other.append(rs) uhf_limit = getattr(self._memobj, limit).uhf rs = RadioSetting("%s.uhf.lower" % limit, "UHF Lower Limit (MHz)", RadioSettingValueInteger(1, 1000, uhf_limit.lower)) other.append(rs) rs = RadioSetting("%s.uhf.upper" % limit, "UHF Upper Limit (MHz)", RadioSettingValueInteger(1, 1000, uhf_limit.upper)) other.append(rs) rs = RadioSetting("%s.uhf.enable" % limit, "UHF TX Enabled", RadioSettingValueBoolean(uhf_limit.enable)) other.append(rs) workmode = RadioSettingGroup("workmode", "Work Mode Settings") group.append(workmode) options = ["A", "B"] rs = RadioSetting("displayab", "Display Selected", RadioSettingValueList(options, options[_settings.displayab])) workmode.append(rs) options = ["Frequency", "Channel"] rs = RadioSetting("workmode", "VFO/MR Mode", RadioSettingValueList(options, options[_settings.workmode])) workmode.append(rs) rs = RadioSetting("keylock", "Keypad Lock", RadioSettingValueBoolean(_settings.keylock)) workmode.append(rs) _mrcna = self._memobj.wmchannel.mrcha rs = RadioSetting("wmchannel.mrcha", "MR A Channel", RadioSettingValueInteger(0, 127, _mrcna)) workmode.append(rs) _mrcnb = self._memobj.wmchannel.mrchb rs = RadioSetting("wmchannel.mrchb", "MR B Channel", RadioSettingValueInteger(0, 127, _mrcnb)) workmode.append(rs) def convert_bytes_to_freq(bytes): real_freq = 0 for byte in bytes: real_freq = (real_freq * 10) + byte return chirp_common.format_freq(real_freq * 10) def my_validate(value): value = chirp_common.parse_freq(value) if 17400000 <= value and value < 40000000: raise InvalidValueError("Can't be between 174.00000-400.00000") return chirp_common.format_freq(value) def apply_freq(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 10 obj.band = value >= 40000000 for i in range(7, -1, -1): obj.freq[i] = value % 10 value /= 10 val1a = RadioSettingValueString(0, 10, convert_bytes_to_freq(self._memobj.vfoa.freq)) val1a.set_validate_callback(my_validate) rs = RadioSetting("vfoa.freq", "VFO A Frequency", val1a) rs.set_apply_callback(apply_freq, self._memobj.vfoa) workmode.append(rs) val1b = RadioSettingValueString(0, 10, convert_bytes_to_freq(self._memobj.vfob.freq)) val1b.set_validate_callback(my_validate) rs = RadioSetting("vfob.freq", "VFO B Frequency", val1b) rs.set_apply_callback(apply_freq, self._memobj.vfob) workmode.append(rs) options = ["Off", "+", "-"] rs = RadioSetting("vfoa.sftd", "VFO A Shift", RadioSettingValueList(options, options[self._memobj.vfoa.sftd])) workmode.append(rs) rs = RadioSetting("vfob.sftd", "VFO B Shift", RadioSettingValueList(options, options[self._memobj.vfob.sftd])) workmode.append(rs) def convert_bytes_to_offset(bytes): real_offset = 0 for byte in bytes: real_offset = (real_offset * 10) + byte return chirp_common.format_freq(real_offset * 10000) def apply_offset(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 10000 for i in range(3, -1, -1): obj.offset[i] = value % 10 value /= 10 val1a = RadioSettingValueString(0, 10, convert_bytes_to_offset(self._memobj.vfoa.offset)) rs = RadioSetting("vfoa.offset", "VFO A Offset (0.00-69.95)", val1a) rs.set_apply_callback(apply_offset, self._memobj.vfoa) workmode.append(rs) val1b = RadioSettingValueString(0, 10, convert_bytes_to_offset(self._memobj.vfob.offset)) rs = RadioSetting("vfob.offset", "VFO B Offset (0.00-69.95)", val1b) rs.set_apply_callback(apply_offset, self._memobj.vfob) workmode.append(rs) options = ["High", "Low"] rs = RadioSetting("vfoa.txpower", "VFO A Power", RadioSettingValueList(options, options[self._memobj.vfoa.txpower])) workmode.append(rs) rs = RadioSetting("vfob.txpower", "VFO B Power", RadioSettingValueList(options, options[self._memobj.vfob.txpower])) workmode.append(rs) options = ["Wide", "Narrow"] rs = RadioSetting("vfoa.widenarr", "VFO A Bandwidth", RadioSettingValueList(options, options[self._memobj.vfoa.widenarr])) workmode.append(rs) rs = RadioSetting("vfob.widenarr", "VFO B Bandwidth", RadioSettingValueList(options, options[self._memobj.vfob.widenarr])) workmode.append(rs) options = ["%s" % x for x in range(1, 16)] rs = RadioSetting("vfoa.scode", "VFO A PTT-ID", RadioSettingValueList(options, options[self._memobj.vfoa.scode])) workmode.append(rs) rs = RadioSetting("vfob.scode", "VFO B PTT-ID", RadioSettingValueList(options, options[self._memobj.vfob.scode])) workmode.append(rs) rs = RadioSetting("vfoa.step", "VFO A Tuning Step", RadioSettingValueList(uv5r.STEP291_LIST, uv5r.STEP291_LIST[self._memobj.vfoa.step])) workmode.append(rs) rs = RadioSetting("vfob.step", "VFO B Tuning Step", RadioSettingValueList(uv5r.STEP291_LIST, uv5r.STEP291_LIST[self._memobj.vfob.step])) workmode.append(rs) fm_preset = RadioSettingGroup("fm_preset", "FM Radio Preset") group.append(fm_preset) preset = self._memobj.fm_preset / 10.0 + 87 rs = RadioSetting("fm_preset", "FM Preset(MHz)", RadioSettingValueFloat(87, 107.5, preset, 0.1, 1)) fm_preset.append(rs) dtmf = RadioSettingGroup("dtmf", "DTMF Settings") group.append(dtmf) dtmfchars = "0123456789 *#ABCD" for i in range(0, 15): _codeobj = self._memobj.pttid[i].code _code = "".join([dtmfchars[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 5, _code, False) val.set_charset(dtmfchars) rs = RadioSetting("pttid/%i.code" % i, "PTT ID Code %i" % (i + 1), val) def apply_code(setting, obj): code = [] for j in range(0, 5): try: code.append(dtmfchars.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.code = code rs.set_apply_callback(apply_code, self._memobj.pttid[i]) dtmf.append(rs) _codeobj = self._memobj.ani.code _code = "".join([dtmfchars[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 5, _code, False) val.set_charset(dtmfchars) rs = RadioSetting("ani.code", "ANI Code", val) def apply_code(setting, obj): code = [] for j in range(0, 5): try: code.append(dtmfchars.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.code = code rs.set_apply_callback(apply_code, self._memobj.ani) dtmf.append(rs) options = ["Off", "BOT", "EOT", "Both"] rs = RadioSetting("ani.aniid", "ANI ID", RadioSettingValueList(options, options[self._memobj.ani.aniid])) dtmf.append(rs) _codeobj = self._memobj.ani.alarmcode _code = "".join([dtmfchars[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 5, _code, False) val.set_charset(dtmfchars) rs = RadioSetting("ani.alarmcode", "Alarm Code", val) def apply_code(setting, obj): alarmcode = [] for j in range(5): try: alarmcode.append(dtmfchars.index(str(setting.value)[j])) except IndexError: alarmcode.append(0xFF) obj.alarmcode = alarmcode rs.set_apply_callback(apply_code, self._memobj.ani) dtmf.append(rs) rs = RadioSetting("dtmfst", "DTMF Sidetone", RadioSettingValueList(uv5r.DTMFST_LIST, uv5r.DTMFST_LIST[_settings.dtmfst])) dtmf.append(rs) rs = RadioSetting("ani.dtmfon", "DTMF Speed (on)", RadioSettingValueList(uv5r.DTMFSPEED_LIST, uv5r.DTMFSPEED_LIST[self._memobj.ani.dtmfon])) dtmf.append(rs) rs = RadioSetting("ani.dtmfoff", "DTMF Speed (off)", RadioSettingValueList(uv5r.DTMFSPEED_LIST, uv5r.DTMFSPEED_LIST[self._memobj.ani.dtmfoff])) dtmf.append(rs) return group
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_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic Settings") top = RadioSettings(basic) # TODO: Check that all these settings actually do what they # say they do. rs = RadioSetting("voiceprompt", "Voice prompt", RadioSettingValueBoolean(_settings.voiceprompt)) basic.append(rs) rs = RadioSetting("voicelanguage", "Voice language", RadioSettingValueList( VOICE_LIST, VOICE_LIST[_settings.voicelanguage])) basic.append(rs) rs = RadioSetting("scan", "Scan", RadioSettingValueBoolean(_settings.scan)) basic.append(rs) rs = RadioSetting("settings2.scanmode", "Scan mode", RadioSettingValueList( SCANMODE_LIST, SCANMODE_LIST[self._memobj.settings2.scanmode])) basic.append(rs) rs = RadioSetting("vox", "VOX", RadioSettingValueBoolean(_settings.vox)) basic.append(rs) rs = RadioSetting("voxlevel", "VOX level", RadioSettingValueInteger( 1, 5, _settings.voxlevel + 1)) basic.append(rs) rs = RadioSetting("voxinhibitonrx", "Inhibit VOX on receive", RadioSettingValueBoolean(_settings.voxinhibitonrx)) basic.append(rs) rs = RadioSetting("lowvolinhibittx", "Low voltage inhibit transmit", RadioSettingValueBoolean(_settings.lowvolinhibittx)) basic.append(rs) rs = RadioSetting("highvolinhibittx", "High voltage inhibit transmit", RadioSettingValueBoolean(_settings.highvolinhibittx)) basic.append(rs) rs = RadioSetting("alarm", "Alarm", RadioSettingValueBoolean(_settings.alarm)) basic.append(rs) # TODO: This should probably be called “FM Broadcast Band Radio” # or something. I'm not sure if the model actually has one though. rs = RadioSetting("fmradio", "FM function", RadioSettingValueBoolean(_settings.fmradio)) basic.append(rs) rs = RadioSetting("settings2.beep", "Beep", RadioSettingValueBoolean( self._memobj.settings2.beep)) basic.append(rs) rs = RadioSetting("settings2.batterysaver", "Battery saver", RadioSettingValueBoolean( self._memobj.settings2.batterysaver)) basic.append(rs) rs = RadioSetting("settings2.squelchlevel", "Squelch level", RadioSettingValueInteger( 0, 9, self._memobj.settings2.squelchlevel)) basic.append(rs) rs = RadioSetting("settings2.sidekeyfunction", "Side key function", RadioSettingValueList( SIDEKEYFUNCTION_LIST, SIDEKEYFUNCTION_LIST[ self._memobj.settings2.sidekeyfunction])) basic.append(rs) rs = RadioSetting("settings2.timeouttimer", "Timeout timer", RadioSettingValueList( TIMEOUTTIMER_LIST, TIMEOUTTIMER_LIST[ self._memobj.settings2.timeouttimer])) basic.append(rs) return top
def _get_common2(self): settings = self._memobj.settings common2 = RadioSettingGroup('common2', 'Common 2') def apply_ponmsgtext(setting): settings.pon_msgtext = (str(setting.value)[:12].strip().ljust( 12, '\x00')) common2.append( self._pure_choice_setting('pon_msgtype', 'Power On Message Type', STARTUP_MODES)) _text = str(settings.pon_msgtext).rstrip('\x00') text = RadioSetting('settings.pon_msgtext', 'Power On Text', RadioSettingValueString(0, 12, _text)) text.set_apply_callback(apply_ponmsgtext) common2.append(text) def apply_volume(setting, key): setattr(settings, key, VOLUMES[str(setting.value)]) volumes = { 'poweron_tone': 'Power-on Tone', 'control_tone': 'Control Tone', 'warning_tone': 'Warning Tone', 'alert_tone': 'Alert Tone', 'sidetone': 'Sidetone', 'locator_tone': 'Locator Tone' } for value, name in volumes.items(): setting = getattr(settings, value) volume = RadioSetting( 'settings.%s' % value, name, RadioSettingValueList(VOLUMES.keys(), VOLUMES_REV.get(int(setting), 0))) volume.set_apply_callback(apply_volume, value) common2.append(volume) def apply_vol_level(setting, key): setattr(settings, key, int(setting.value)) levels = { 'lo_volume': 'Low Volume Level (Fixed Volume)', 'hi_volume': 'High Volume Level (Fixed Volume)', 'min_volume': 'Minimum Volume', 'max_volume': 'Maximum Volume' } for value, name in levels.items(): setting = getattr(settings, value) volume = RadioSetting( 'settings.%s' % value, name, RadioSettingValueInteger(1, 31, int(setting))) volume.set_apply_callback(apply_vol_level, value) common2.append(volume) def apply_vo(setting): val = int(setting.value) if val < 0: val = abs(val) | 0x80 settings.tone_volume_offset = val _voloffset = int(settings.tone_volume_offset) if _voloffset & 0x80: _voloffset = abs(_voloffset & 0x7F) * -1 voloffset = RadioSetting('tvo', 'Tone Volume Offset', RadioSettingValueInteger(-5, 5, _voloffset)) voloffset.set_apply_callback(apply_vo) common2.append(voloffset) def apply_mvp(setting): settings.min_vol_preset = MIN_VOL_PRESET[str(setting.value)] _volpreset = int(settings.min_vol_preset) volpreset = RadioSetting( 'mvp', 'Minimum Volume Preset', RadioSettingValueList(MIN_VOL_PRESET.keys(), MIN_VOL_PRESET_REV[_volpreset])) volpreset.set_apply_callback(apply_mvp) common2.append(volpreset) return common2
def get_settings(self): """Translate the bit in the mem_struct into settings in the UI""" sett = self._memobj.settings # basic features of the radio basic = RadioSettingGroup("basic", "Basic Settings") # keys fkeys = RadioSettingGroup("keys", "Function keys") top = RadioSettings(basic, fkeys) # Basic val = RadioSettingValueString(0, 35, self._VARIANT) val.set_mutable(False) mod = RadioSetting("not.mod", "Radio version", val) basic.append(mod) beep = RadioSetting("settings.beep", "Beep tone", RadioSettingValueBoolean(bool(sett.beep))) basic.append(beep) bsave = RadioSetting("settings.batt_save", "Battery save", RadioSettingValueBoolean(bool(sett.batt_save))) basic.append(bsave) deal = RadioSetting("settings.dealer", "Dealer & Test", RadioSettingValueBoolean(bool(sett.dealer))) basic.append(deal) add = RadioSetting("settings.add", "Del / Add feature", RadioSettingValueBoolean(bool(sett.add))) basic.append(add) # In some cases the values that follows can be 0xFF (HARD RESET) # so we need to take and validate that if int(sett.tot) == 0xff: # 120 sec sett.tot = 4 if int(sett.tot_alert) == 0xff: # 10 secs sett.tot_alert = 1 if int(sett.tot_rekey) == 0xff: # off sett.tot_rekey = 0 if int(sett.tot_reset) == 0xff: # off sett.tot_reset = 0 if int(sett.sql) == 0xff: # a confortable level ~6 sett.sql = 6 tot = RadioSetting("settings.tot", "Time Out Timer (TOT)", RadioSettingValueList(TOT, TOT[int(sett.tot)])) basic.append(tot) tota = RadioSetting( "settings.tot_alert", "TOT pre-plert", RadioSettingValueList(TOT_A, TOT_A[int(sett.tot_alert)])) basic.append(tota) totrk = RadioSetting( "settings.tot_rekey", "TOT rekey time", RadioSettingValueList(TOT_RK, TOT_RK[int(sett.tot_rekey)])) basic.append(totrk) totrs = RadioSetting( "settings.tot_reset", "TOT reset time", RadioSettingValueList(TOT_RS, TOT_RS[int(sett.tot_reset)])) basic.append(totrs) sql = RadioSetting("settings.sql", "Squelch level", RadioSettingValueList(SQL, SQL[int(sett.sql)])) basic.append(sql) # front keys m = int(sett.kMoni) if m > 3: m = 1 mon = RadioSetting("settings.kMoni", "Monitor", RadioSettingValueList(MONI, MONI[m])) fkeys.append(mon) s = int(sett.kScan) if s > 3: s = 1 scn = RadioSetting("settings.kScan", "Scan", RadioSettingValueList(SCAN, SCAN[s])) fkeys.append(scn) d = int(sett.kDial) if d > 1: d = 0 dial = RadioSetting("settings.kDial", "Dial", RadioSettingValueList(YESNO, YESNO[d])) fkeys.append(dial) t = int(sett.kTa) if t > 2: t = 2 ta = RadioSetting("settings.kTa", "Ta", RadioSettingValueList(TA, TA[t])) fkeys.append(ta) l = int(sett.kLo) if l > 1: l = 0 low = RadioSetting("settings.kLo", "Low", RadioSettingValueList(YESNO, YESNO[l])) fkeys.append(low) return top
def get_settings(self): _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): """Get the mem representation from the radio image""" _mem = self._memobj.memory[number - 1] # Create a high-level memory object to return to the UI mem = chirp_common.Memory() # Memory number mem.number = number if _mem.get_raw()[0] == "\xFF": mem.empty = True # but is not enough, you have to clear the memory in the mmap # to get it ready for the sync_out process, just in case _mem.set_raw("\xFF" * 16) # set the channel to inactive state self.set_active(number - 1, False) return mem # Freq and offset mem.freq = int(_mem.rxfreq) * 10 # tx freq can be blank if _mem.get_raw()[4] == "\xFF" or int(_mem.txen) == 255: # TX freq not set mem.offset = 0 mem.duplex = "off" else: # TX feq set offset = (int(_mem.txfreq) * 10) - mem.freq if offset < 0: mem.offset = abs(offset) mem.duplex = "-" elif offset > 0: mem.offset = offset mem.duplex = "+" else: mem.offset = 0 # power mem.power = POWER_LEVELS[int(_mem.power)] # skip mem.skip = self.get_scan(number - 1) # tone data rxtone = txtone = None txtone = self.decode_tone(_mem.tx_tone) rxtone = self.decode_tone(_mem.rx_tone) chirp_common.split_tone_decode(mem, txtone, rxtone) # Extra # bank and number in the channel mem.extra = RadioSettingGroup("extra", "Extra") bl = RadioSetting("busy", "Busy Channel lock", RadioSettingValueBoolean(not bool(_mem.busy))) mem.extra.append(bl) sf = RadioSetting("shift", "Beat Shift", RadioSettingValueBoolean(not bool(_mem.shift))) mem.extra.append(sf) return mem
def get_settings(self): """Translate the bit in the mem_struct into settings in the UI""" _mem = self._memobj basic = RadioSettingGroup("basic", "Basic Settings") advanced = RadioSettingGroup("advanced", "Advanced Settings") other = RadioSettingGroup("other", "Other Settings") work = RadioSettingGroup("work", "Work Mode Settings") fm_preset = RadioSettingGroup("fm_preset", "FM Preset") dtmfe = RadioSettingGroup("dtmfe", "DTMF Encode Settings") service = RadioSettingGroup("service", "Service Settings") top = RadioSettings(basic, advanced, other, work, fm_preset, dtmfe, service) # Basic settings if _mem.settings.squelch > 0x09: val = 0x00 else: val = _mem.settings.squelch rs = RadioSetting( "settings.squelch", "Squelch", RadioSettingValueList(LIST_OFF1TO9, LIST_OFF1TO9[val])) basic.append(rs) if _mem.settings.save > 0x04: val = 0x00 else: val = _mem.settings.save rs = RadioSetting("settings.save", "Battery Saver", RadioSettingValueList(LIST_SAVE, LIST_SAVE[val])) basic.append(rs) if _mem.settings.vox > 0x0A: val = 0x00 else: val = _mem.settings.vox rs = RadioSetting( "settings.vox", "Vox", RadioSettingValueList(LIST_OFF1TO10, LIST_OFF1TO10[val])) basic.append(rs) if _mem.settings.abr > 0x0A: val = 0x00 else: val = _mem.settings.abr rs = RadioSetting( "settings.abr", "Backlight Timeout", RadioSettingValueList(LIST_OFF1TO10, LIST_OFF1TO10[val])) basic.append(rs) rs = RadioSetting("settings.tdr", "Dual Watch", RadioSettingValueBoolean(_mem.settings.tdr)) basic.append(rs) rs = RadioSetting("settings.beep", "Beep", RadioSettingValueBoolean(_mem.settings.beep)) basic.append(rs) if _mem.settings.timeout > 0x27: val = 0x03 else: val = _mem.settings.timeout rs = RadioSetting( "settings.timeout", "Timeout Timer", RadioSettingValueList(LIST_TIMEOUT, LIST_TIMEOUT[val])) basic.append(rs) if _mem.settings.voice > 0x02: val = 0x01 else: val = _mem.settings.voice rs = RadioSetting("settings.voice", "Voice Prompt", RadioSettingValueList(LIST_VOICE, LIST_VOICE[val])) basic.append(rs) rs = RadioSetting( "settings.dtmfst", "DTMF Sidetone", RadioSettingValueList(LIST_DTMFST, LIST_DTMFST[_mem.settings.dtmfst])) basic.append(rs) if _mem.settings.screv > 0x02: val = 0x01 else: val = _mem.settings.screv rs = RadioSetting("settings.screv", "Scan Resume", RadioSettingValueList(LIST_RESUME, LIST_RESUME[val])) basic.append(rs) rs = RadioSetting( "settings.pttid", "When to send PTT ID", RadioSettingValueList(LIST_PTTID, LIST_PTTID[_mem.settings.pttid])) basic.append(rs) if _mem.settings.pttlt > 0x1E: val = 0x05 else: val = _mem.settings.pttlt rs = RadioSetting("pttlt", "PTT ID Delay", RadioSettingValueInteger(0, 50, val)) basic.append(rs) rs = RadioSetting( "settings.mdfa", "Display Mode (A)", RadioSettingValueList(LIST_MODE, LIST_MODE[_mem.settings.mdfa])) basic.append(rs) rs = RadioSetting( "settings.mdfb", "Display Mode (B)", RadioSettingValueList(LIST_MODE, LIST_MODE[_mem.settings.mdfb])) basic.append(rs) rs = RadioSetting("settings.sync", "Sync A & B", RadioSettingValueBoolean(_mem.settings.sync)) basic.append(rs) rs = RadioSetting( "settings.wtled", "Standby LED Color", RadioSettingValueList(LIST_COLOR, LIST_COLOR[_mem.settings.wtled])) basic.append(rs) rs = RadioSetting( "settings.rxled", "RX LED Color", RadioSettingValueList(LIST_COLOR, LIST_COLOR[_mem.settings.rxled])) basic.append(rs) rs = RadioSetting( "settings.txled", "TX LED Color", RadioSettingValueList(LIST_COLOR, LIST_COLOR[_mem.settings.txled])) basic.append(rs) val = _mem.settings.almod rs = RadioSetting("settings.almod", "Alarm Mode", RadioSettingValueList(LIST_ALMOD, LIST_ALMOD[val])) basic.append(rs) rs = RadioSetting("settings.dbptt", "Double PTT", RadioSettingValueBoolean(_mem.settings.dbptt)) basic.append(rs) if _mem.settings.tdrab > 0x02: val = 0x00 else: val = _mem.settings.tdrab rs = RadioSetting("settings.tdrab", "Dual Watch TX Priority", RadioSettingValueList(LIST_OFFAB, LIST_OFFAB[val])) basic.append(rs) rs = RadioSetting("settings.ste", "Squelch Tail Eliminate (HT to HT)", RadioSettingValueBoolean(_mem.settings.ste)) basic.append(rs) if _mem.settings.rpste > 0x0A: val = 0x00 else: val = _mem.settings.rpste rs = RadioSetting("settings.rpste", "Squelch Tail Eliminate (repeater)", RadioSettingValueList(LIST_RPSTE, LIST_RPSTE[val])) basic.append(rs) if _mem.settings.rptrl > 0x0A: val = 0x00 else: val = _mem.settings.rptrl rs = RadioSetting( "settings.rptrl", "STE Repeater Delay", RadioSettingValueList(LIST_STEDELAY, LIST_STEDELAY[val])) basic.append(rs) rs = RadioSetting( "settings.ponmsg", "Power-On Message", RadioSettingValueList(LIST_PONMSG, LIST_PONMSG[_mem.settings.ponmsg])) basic.append(rs) rs = RadioSetting("settings.roger", "Roger Beep", RadioSettingValueBoolean(_mem.settings.roger)) basic.append(rs) rs = RadioSetting( "settings.rtone", "Tone Burst Frequency", RadioSettingValueList(LIST_RTONE, LIST_RTONE[_mem.settings.rtone])) basic.append(rs) rs = RadioSetting( "settings.rogerrx", "Roger Beep (RX)", RadioSettingValueList(LIST_OFFAB, LIST_OFFAB[_mem.settings.rogerrx])) basic.append(rs) # Advanced settings rs = RadioSetting("settings.reset", "RESET Menu", RadioSettingValueBoolean(_mem.settings.reset)) advanced.append(rs) rs = RadioSetting("settings.menu", "All Menus", RadioSettingValueBoolean(_mem.settings.menu)) advanced.append(rs) rs = RadioSetting("settings.fmradio", "Broadcast FM Radio", RadioSettingValueBoolean(_mem.settings.fmradio)) advanced.append(rs) rs = RadioSetting("settings.alarm", "Alarm Sound", RadioSettingValueBoolean(_mem.settings.alarm)) advanced.append(rs) # Other settings def _filter(name): filtered = "" for char in str(name): if char in chirp_common.CHARSET_ASCII: filtered += char else: filtered += " " return filtered _msg = _mem.firmware_msg val = RadioSettingValueString(0, 7, _filter(_msg.line1)) val.set_mutable(False) rs = RadioSetting("firmware_msg.line1", "Firmware Message 1", val) other.append(rs) val = RadioSettingValueString(0, 7, _filter(_msg.line2)) val.set_mutable(False) rs = RadioSetting("firmware_msg.line2", "Firmware Message 2", val) other.append(rs) _msg = _mem.sixpoweron_msg val = RadioSettingValueString(0, 7, _filter(_msg.line1)) val.set_mutable(False) rs = RadioSetting("sixpoweron_msg.line1", "6+Power-On Message 1", val) other.append(rs) val = RadioSettingValueString(0, 7, _filter(_msg.line2)) val.set_mutable(False) rs = RadioSetting("sixpoweron_msg.line2", "6+Power-On Message 2", val) other.append(rs) _msg = _mem.poweron_msg rs = RadioSetting("poweron_msg.line1", "Power-On Message 1", RadioSettingValueString(0, 7, _filter(_msg.line1))) other.append(rs) rs = RadioSetting("poweron_msg.line2", "Power-On Message 2", RadioSettingValueString(0, 7, _filter(_msg.line2))) other.append(rs) # Work mode settings rs = RadioSetting( "settings.displayab", "Display", RadioSettingValueList(LIST_AB, LIST_AB[_mem.settings.displayab])) work.append(rs) rs = RadioSetting( "settings.workmode", "VFO/MR Mode", RadioSettingValueList(LIST_WORKMODE, LIST_WORKMODE[_mem.settings.workmode])) work.append(rs) rs = RadioSetting("settings.keylock", "Keypad Lock", RadioSettingValueBoolean(_mem.settings.keylock)) work.append(rs) rs = RadioSetting( "wmchannel.mrcha", "MR A Channel", RadioSettingValueInteger(0, 127, _mem.wmchannel.mrcha)) work.append(rs) rs = RadioSetting( "wmchannel.mrchb", "MR B Channel", RadioSettingValueInteger(0, 127, _mem.wmchannel.mrchb)) work.append(rs) def convert_bytes_to_freq(bytes): real_freq = 0 for byte in bytes: real_freq = (real_freq * 10) + byte return chirp_common.format_freq(real_freq * 10) def my_validate(value): value = chirp_common.parse_freq(value) msg = ("Can't be less than %i.0000") if value > 99000000 and value < 130 * 1000000: raise InvalidValueError(msg % (130)) msg = ("Can't be between %i.9975-%i.0000") if (179 + 1) * 1000000 <= value and value < 400 * 1000000: raise InvalidValueError(msg % (179, 400)) msg = ("Can't be greater than %i.9975") if value > 99000000 and value > (520 + 1) * 1000000: raise InvalidValueError(msg % (520)) return chirp_common.format_freq(value) def apply_freq(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 10 for i in range(7, -1, -1): obj.freq[i] = value % 10 value /= 10 val1a = RadioSettingValueString(0, 10, convert_bytes_to_freq(_mem.vfo.a.freq)) val1a.set_validate_callback(my_validate) rs = RadioSetting("vfo.a.freq", "VFO A Frequency", val1a) rs.set_apply_callback(apply_freq, _mem.vfo.a) work.append(rs) val1b = RadioSettingValueString(0, 10, convert_bytes_to_freq(_mem.vfo.b.freq)) val1b.set_validate_callback(my_validate) rs = RadioSetting("vfo.b.freq", "VFO B Frequency", val1b) rs.set_apply_callback(apply_freq, _mem.vfo.b) work.append(rs) rs = RadioSetting( "vfo.a.step", "VFO A Tuning Step", RadioSettingValueList(LIST_STEP, LIST_STEP[_mem.vfo.a.step])) work.append(rs) rs = RadioSetting( "vfo.b.step", "VFO B Tuning Step", RadioSettingValueList(LIST_STEP, LIST_STEP[_mem.vfo.b.step])) work.append(rs) # broadcast FM settings _fm_presets = self._memobj.fm_presets if _fm_presets <= 108.0 * 10 - 650: preset = _fm_presets / 10.0 + 65 elif _fm_presets >= 65.0 * 10 and _fm_presets <= 108.0 * 10: preset = _fm_presets / 10.0 else: preset = 76.0 rs = RadioSetting("fm_presets", "FM Preset(MHz)", RadioSettingValueFloat(65, 108.0, preset, 0.1, 1)) fm_preset.append(rs) # DTMF settings def apply_code(setting, obj, length): code = [] for j in range(0, length): try: code.append(DTMF_CHARS.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.code = code for i in range(0, 15): _codeobj = self._memobj.pttid[i].code _code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 5, _code, False) val.set_charset(DTMF_CHARS) pttid = RadioSetting("pttid/%i.code" % i, "Signal Code %i" % (i + 1), val) pttid.set_apply_callback(apply_code, self._memobj.pttid[i], 5) dtmfe.append(pttid) if _mem.ani.dtmfon > 0xC3: val = 0x03 else: val = _mem.ani.dtmfon rs = RadioSetting( "ani.dtmfon", "DTMF Speed (on)", RadioSettingValueList(LIST_DTMFSPEED, LIST_DTMFSPEED[val])) dtmfe.append(rs) if _mem.ani.dtmfoff > 0xC3: val = 0x03 else: val = _mem.ani.dtmfoff rs = RadioSetting( "ani.dtmfoff", "DTMF Speed (off)", RadioSettingValueList(LIST_DTMFSPEED, LIST_DTMFSPEED[val])) dtmfe.append(rs) _codeobj = self._memobj.ani.code _code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 5, _code, False) val.set_charset(DTMF_CHARS) rs = RadioSetting("ani.code", "ANI Code", val) rs.set_apply_callback(apply_code, self._memobj.ani, 5) dtmfe.append(rs) rs = RadioSetting( "ani.aniid", "When to send ANI ID", RadioSettingValueList(LIST_PTTID, LIST_PTTID[_mem.ani.aniid])) dtmfe.append(rs) # Service settings for band in ["vhf", "uhf"]: for index in range(0, 10): key = "squelch.%s.sql%i" % (band, index) if band == "vhf": _obj = self._memobj.squelch.vhf elif band == "uhf": _obj = self._memobj.squelch.uhf val = RadioSettingValueInteger( 0, 123, getattr(_obj, "sql%i" % (index))) if index == 0: val.set_mutable(False) name = "%s Squelch %i" % (band.upper(), index) rs = RadioSetting(key, name, val) service.append(rs) return top
def _get_zones(self): zones = RadioSettingGroup('zones', 'Zones') zone_count = RadioSetting( '_zonecount', 'Number of Zones', RadioSettingValueInteger(1, 128, len(self._zones))) zone_count.set_doc('Number of zones in the radio. ' 'Requires a save and re-load of the ' 'file to take effect. Reducing this number ' 'will DELETE memories in affected zones!') zones.append(zone_count) for i in range(len(self._zones)): zone = RadioSettingGroup('zone%i' % i, 'Zone %i' % (i + 1)) _zone = getattr(self._memobj, 'zone%i' % i).zoneinfo _name = str(_zone.name).rstrip('\x00') name = RadioSetting('name%i' % i, 'Name', RadioSettingValueString(0, 12, _name)) zone.append(name) def apply_timer(setting, key): val = int(setting.value) if val == 0: val = 0xFFFF setattr(_zone, key, val) def collapse(val): val = int(val) if val == 0xFFFF: val = 0 return val timer = RadioSetting( 'timeout', 'Time-out Timer', RadioSettingValueInteger(15, 1200, collapse(_zone.timeout))) timer.set_apply_callback(apply_timer, 'timeout') zone.append(timer) timer = RadioSetting( 'tot_alert', 'TOT Pre-Alert', RadioSettingValueInteger(0, 10, collapse(_zone.tot_alert))) timer.set_apply_callback(apply_timer, 'tot_alert') zone.append(timer) timer = RadioSetting( 'tot_rekey', 'TOT Re-Key Time', RadioSettingValueInteger(0, 60, collapse(_zone.tot_rekey))) timer.set_apply_callback(apply_timer, 'tot_rekey') zone.append(timer) timer = RadioSetting( 'tot_reset', 'TOT Reset Time', RadioSettingValueInteger(0, 15, collapse(_zone.tot_reset))) timer.set_apply_callback(apply_timer, 'tot_reset') zone.append(timer) zone.append( self._inverted_flag_setting('bcl_override', 'BCL Override', _zone)) zones.append(zone) return zones
def get_settings(self): """Translate the bit in the mem_struct into settings in the UI""" _mem = self._memobj basic = RadioSettingGroup("basic", "Basic") work = RadioSettingGroup("work", "Work Mode Settings") top = RadioSettings(basic, work) # Basic sql = RadioSetting("settings.sql", "Squelch Level", RadioSettingValueList(LIST_SQL, LIST_SQL[ _mem.settings.sql])) basic.append(sql) tot = RadioSetting("settings.tot", "Time out timer", RadioSettingValueList(LIST_TOT, LIST_TOT[ _mem.settings.tot])) basic.append(tot) power = RadioSetting("settings.power", "Actual Power", RadioSettingValueList(POWER_LEVELS, POWER_LEVELS[_mem.settings.power])) basic.append(power) key_lock = RadioSetting("settings.key", "Keyboard Lock", RadioSettingValueList(KEY_LOCK, KEY_LOCK[_mem.settings.key])) basic.append(key_lock) bw = RadioSetting("settings.bw", "Bandwidth", RadioSettingValueList(BW, BW[_mem.settings.bw])) basic.append(bw) powerrank = RadioSetting("settings.powerrank", "Power output adjust", RadioSettingValueList(POWER_RANK, POWER_RANK[_mem.settings.powerrank])) basic.append(powerrank) lamp = RadioSetting("settings.lamp", "LCD Lamp", RadioSettingValueBoolean(_mem.settings.lamp)) basic.append(lamp) lamp_auto = RadioSetting("settings.lamp_auto", "LCD Lamp auto on/off", RadioSettingValueBoolean( _mem.settings.lamp_auto)) basic.append(lamp_auto) bs = RadioSetting("settings.bs", "Battery Save", RadioSettingValueBoolean(_mem.settings.bs)) basic.append(bs) warning = RadioSetting("settings.warning", "Warning Alerts", RadioSettingValueBoolean(_mem.settings.warning)) basic.append(warning) monitor = RadioSetting("settings.monitor", "Monitor key", RadioSettingValueBoolean(_mem.settings.monitor)) basic.append(monitor) # Work mode settings wmset = RadioSetting("settings.wmem", "VFO/MR Mode", RadioSettingValueList( W_MODE, W_MODE[_mem.settings.wmem])) work.append(wmset) active_ch = RadioSetting("settings.active_ch", "Work Channel", RadioSettingValueList(ACTIVE_CH, ACTIVE_CH[_mem.settings.active_ch])) work.append(active_ch) # vfo rx validation if _mem.vfo.vrx_freq.get_raw()[0] == "\xFF": # if the vfo is not set, the UI cares about the # length of the field, so set a default LOG.debug("VFO freq not set, setting it to default %s" % self._VFO_DEFAULT) vfo = self._VFO_DEFAULT else: vfo = int(_mem.vfo.vrx_freq) * 10 vf_freq = RadioSetting("vfo.vrx_freq", "VFO frequency", RadioSettingValueString(0, 10, chirp_common.format_freq(vfo))) work.append(vf_freq) # shift works # VSHIFT = ["None", "-", "+"] sset = 0 if bool(_mem.vfo.shift_minus) is True: sset = 1 elif bool(_mem.vfo.shift_plus) is True: sset = 2 shift = RadioSetting("shift", "VFO Shift", RadioSettingValueList(VSHIFT, VSHIFT[sset])) work.append(shift) # vfo shift validation if none set it to ZERO if _mem.settings.vfo_shift.get_raw()[0] == "\xFF": # if the shift is not set, the UI cares about the # length of the field, so set to zero LOG.debug("VFO shift not set, setting it to zero") vfo_shift = 0 else: vfo_shift = int(_mem.settings.vfo_shift) * 10 offset = RadioSetting("settings.vfo_shift", "VFO Offset", RadioSettingValueString(0, 9, chirp_common.format_freq(vfo_shift))) work.append(offset) step = RadioSetting("settings.step", "VFO step", RadioSettingValueList(STEPF, STEPF[_mem.settings.step])) work.append(step) # at least for FD-268A/B it doesn't work as stated, so disabled # by now #scamble = RadioSetting("vfo.scramble", "Scramble", #RadioSettingValueList(ONOFF, #ONOFF[int(_mem.vfo.scramble)])) #work.append(scamble) #busy_lock = RadioSetting("vfo.busy_lock", "Busy Lock out", #RadioSettingValueList(ONOFF, #ONOFF[int(_mem.vfo.busy_lock)])) #work.append(busy_lock) # FD-288 Family ANI settings if "FD-288" in self.MODEL: ani_mode = RadioSetting("settings.ani_mode", "ANI ID", RadioSettingValueList(ANI, ANI[_mem.settings.ani_mode])) work.append(ani_mode) # it can't be \xFF ani_value = str(_mem.settings.ani) if ani_value == "\xFF\xFF\xFF": ani_value = "200" ani_value = "".join(x for x in ani_value if (int(x) >= 2 and int(x) <= 9)) ani = RadioSetting("settings.ani", "ANI (200-999)", RadioSettingValueString(0, 3, ani_value)) work.append(ani) return top
def get_memory(self, number): bitpos = (1 << (number % 8)) bytepos = (number / 8) _mem = self._memobj.memory[number] _skp = self._memobj.skip_flags[bytepos] _usd = self._memobj.used_flags[bytepos] mem = chirp_common.Memory() mem.number = number if _usd & bitpos: mem.empty = True return mem mem.freq = int(_mem.freq) * 100 mem.offset = int(_mem.offset) * 100 mem.name = self.filter_name(str(_mem.name).rstrip()) mem.duplex = DUPLEXES[_mem.duplex] mem.mode = MODES[_mem.channel_width] if _mem.tx_off == True: mem.duplex = "off" mem.offset = 0 rxtone = txtone = None rxmode = TMODES[_mem.rxtmode] txmode = TMODES[_mem.txtmode] if txmode == "Tone": txtone = TONES[_mem.txtone] elif txmode == "DTCS": txtone = chirp_common.ALL_DTCS_CODES[self._get_dcs_index( _mem, 'tx')] if rxmode == "Tone": rxtone = TONES[_mem.rxtone] elif rxmode == "DTCS": rxtone = chirp_common.ALL_DTCS_CODES[self._get_dcs_index( _mem, 'rx')] rxpol = _mem.rxinv and "R" or "N" txpol = _mem.txinv and "R" or "N" chirp_common.split_tone_decode(mem, (txmode, txtone, txpol), (rxmode, rxtone, rxpol)) if _skp & bitpos: mem.skip = "S" mem.power = POWER_LEVELS[_mem.power] mem.extra = RadioSettingGroup("Extra", "extra") rs = RadioSetting("bcl", "Busy Channel Lockout", RadioSettingValueList(BCLO, BCLO[_mem.bcl])) mem.extra.append(rs) rs = RadioSetting( "squelch", "Squelch", RadioSettingValueList(SQUELCH, SQUELCH[_mem.squelch])) mem.extra.append(rs) return mem
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic") autodial = RadioSettingGroup("autodial", "AutoDial") keymaps = RadioSettingGroup("keymaps", "KeyMaps") top = RadioSettings(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_common1(self): settings = self._memobj.settings common1 = RadioSettingGroup('common1', 'Common 1') common1.append( self._pure_choice_setting('sublcd', 'Sub LCD Display', SUBLCD)) def apply_clockfmt(setting): settings.clockfmt = CLOCKFMT.index(str(setting.value)) clockfmt = RadioSetting( 'clockfmt', 'Clock Format', RadioSettingValueList(CLOCKFMT, CLOCKFMT[settings.clockfmt])) clockfmt.set_apply_callback(apply_clockfmt) common1.append(clockfmt) def apply_datefmt(setting): settings.datefmt = DATEFMT.index(str(setting.value)) datefmt = RadioSetting( 'datefmt', 'Date Format', RadioSettingValueList(DATEFMT, DATEFMT[settings.datefmt])) datefmt.set_apply_callback(apply_datefmt) common1.append(datefmt) common1.append( self._pure_choice_setting('micsense', 'Mic Sense High', MICSENSE)) def apply_modereset(setting): val = int(setting.value) if val == 0: val = 0xFFFF settings.modereset = val _modereset = int(settings.modereset) if _modereset == 0xFFFF: _modereset = 0 modereset = RadioSetting('modereset', 'Mode Reset Timer', RadioSettingValueInteger(0, 300, _modereset)) modereset.set_apply_callback(apply_modereset) common1.append(modereset) inverted_flags = [('power_switch_memory', 'Power Switch Memory'), ('scrambler_memory', 'Scrambler Memory'), ('off_hook_decode', 'Off-Hook Decode'), ('ssi', 'Signal Strength Indicator'), ('ignition_sense', 'Ingnition Sense')] for key, name in inverted_flags: common1.append(self._inverted_flag_setting(key, name)) common1.append( self._pure_choice_setting('ignition_mode', 'Ignition Mode', ['Ignition & SW', 'Ignition Only'], None)) def apply_it(setting): settings.ignition_time = int(setting.value) / 600 _it = int(settings.ignition_time) * 600 it = RadioSetting('it', 'Ignition Timer (s)', RadioSettingValueInteger(10, 28800, _it)) it.set_apply_callback(apply_it) common1.append(it) return common1
def get_settings(self): """Translate the bit in the mem_struct into settings in the UI""" _mem = self._memobj basic = RadioSettingGroup("basic", "Basic Settings") other = RadioSettingGroup("other", "Other Settings") work = RadioSettingGroup("work", "Work Mode Settings") dtmf = RadioSettingGroup("dtmf", "DTMF Settings") top = RadioSettings(basic, other, work, dtmf) # Basic # Audio: A01-A04 aftone = RadioSetting( "settings.aftone", "AF tone control", RadioSettingValueList(LIST_AFTONE, LIST_AFTONE[_mem.settings.aftone])) basic.append(aftone) spkr = RadioSetting( "settings.spkr", "Speaker", RadioSettingValueList(LIST_SPKR, LIST_SPKR[_mem.settings.spkr])) basic.append(spkr) audio = RadioSetting( "settings.audio", "Stereo/Mono", RadioSettingValueList(LIST_AUDIO, LIST_AUDIO[_mem.settings.audio])) basic.append(audio) sbmute = RadioSetting( "settings.sbmute", "Sub band mute", RadioSettingValueList(LIST_SBMUTE, LIST_SBMUTE[_mem.settings.sbmute])) basic.append(sbmute) # TX/RX: B01-B08 mgain = RadioSetting( "settings.mgain", "Mic gain", RadioSettingValueList(LIST_MLNHM, LIST_MLNHM[_mem.settings.mgain])) basic.append(mgain) ptt = RadioSetting( "settings.ptt", "PTT mode", RadioSettingValueList(LIST_PTT, LIST_PTT[_mem.settings.ptt])) basic.append(ptt) # B03 (per channel) # B04 (per channel) rxexp = RadioSetting( "settings.rxexp", "RX expansion", RadioSettingValueList(LIST_RXEXP, LIST_RXEXP[_mem.settings.rxexp])) basic.append(rxexp) vox = RadioSetting( "settings.vox", "Vox", RadioSettingValueList(LIST_VOX, LIST_VOX[_mem.settings.vox])) basic.append(vox) voxs = RadioSetting( "settings.voxs", "Vox sensitivity", RadioSettingValueList(LIST_MLNHM, LIST_MLNHM[_mem.settings.voxs])) basic.append(voxs) # B08 (per channel) # Display: C01-C06 display = RadioSetting( "settings.display", "Display select", RadioSettingValueList(LIST_DISPLAY, LIST_DISPLAY[_mem.settings.display])) basic.append(display) lcdb = RadioSetting( "settings.lcdb", "LCD brightness", RadioSettingValueList(LIST_MINMAX, LIST_MINMAX[_mem.settings.lcdb])) basic.append(lcdb) color = RadioSetting( "settings.color", "LCD color", RadioSettingValueList(LIST_COLOR, LIST_COLOR[_mem.settings.color])) basic.append(color) lcdc = RadioSetting( "settings.lcdc", "LCD contrast", RadioSettingValueList(LIST_MINMAX, LIST_MINMAX[_mem.settings.lcdc])) basic.append(lcdc) btime = RadioSetting( "settings.btime", "LCD backlight time", RadioSettingValueList(LIST_BTIME, LIST_BTIME[_mem.settings.btime])) basic.append(btime) keyb = RadioSetting( "settings.keyb", "Key brightness", RadioSettingValueList(LIST_MINMAX, LIST_MINMAX[_mem.settings.keyb])) basic.append(keyb) # Memory: D01-D04 # D01 (per channel) # D02 (per channel) mrscan = RadioSetting( "settings.mrscan", "Memory scan type", RadioSettingValueList(LIST_MRSCAN, LIST_MRSCAN[_mem.settings.mrscan])) basic.append(mrscan) # D04 (per channel) # Scan: E01-E04 dwstop = RadioSetting( "settings.dwstop", "Dual watch stop", RadioSettingValueList(LIST_DWSTOP, LIST_DWSTOP[_mem.settings.dwstop])) basic.append(dwstop) scand = RadioSetting( "settings.scand", "Scan direction", RadioSettingValueList(LIST_SCAND, LIST_SCAND[_mem.settings.scand])) basic.append(scand) scanr = RadioSetting( "settings.scanr", "Scan resume", RadioSettingValueList(LIST_SCANR, LIST_SCANR[_mem.settings.scanr])) basic.append(scanr) scansb = RadioSetting("settings.scansb", "Scan stop beep", RadioSettingValueBoolean(_mem.settings.scansb)) basic.append(scansb) # System: F01-F09 apo = RadioSetting( "settings.apo", "Automatic power off [hours]", RadioSettingValueList(LIST_APO, LIST_APO[_mem.settings.apo])) basic.append(apo) ars = RadioSetting("settings.ars", "Automatic repeater shift", RadioSettingValueBoolean(_mem.settings.ars)) basic.append(ars) beep = RadioSetting( "settings.beep", "Beep volume", RadioSettingValueList(LIST_BEEP, LIST_BEEP[_mem.settings.beep])) basic.append(beep) fkey = RadioSetting( "settings.fkey", "F key", RadioSettingValueList(LIST_FKEY, LIST_FKEY[_mem.settings.fkey])) basic.append(fkey) pfkey1 = RadioSetting( "settings.pfkey1", "Mic P1 key", RadioSettingValueList(LIST_PFKEY, LIST_PFKEY[_mem.settings.pfkey1])) basic.append(pfkey1) pfkey2 = RadioSetting( "settings.pfkey2", "Mic P2 key", RadioSettingValueList(LIST_PFKEY, LIST_PFKEY[_mem.settings.pfkey2])) basic.append(pfkey2) pfkey3 = RadioSetting( "settings.pfkey3", "Mic P3 key", RadioSettingValueList(LIST_PFKEY, LIST_PFKEY[_mem.settings.pfkey3])) basic.append(pfkey3) pfkey4 = RadioSetting( "settings.pfkey4", "Mic P4 key", RadioSettingValueList(LIST_PFKEY, LIST_PFKEY[_mem.settings.pfkey4])) basic.append(pfkey4) omode = RadioSetting( "settings.omode", "Operation mode", RadioSettingValueList(LIST_AB, LIST_AB[_mem.settings.omode])) basic.append(omode) rxcoverm = RadioSetting( "settings.rxcoverm", "RX coverage - memory", RadioSettingValueList(LIST_COVERAGE, LIST_COVERAGE[_mem.settings.rxcoverm])) basic.append(rxcoverm) rxcoverv = RadioSetting( "settings.rxcoverv", "RX coverage - VFO", RadioSettingValueList(LIST_COVERAGE, LIST_COVERAGE[_mem.settings.rxcoverv])) basic.append(rxcoverv) tot = RadioSetting( "settings.tot", "Time out timer [min]", RadioSettingValueList(LIST_TOT, LIST_TOT[_mem.settings.tot])) basic.append(tot) # Timer/Clock: G01-G04 # G01 datefmt = RadioSetting( "settings.datefmt", "Date format", RadioSettingValueList(LIST_DATEFMT, LIST_DATEFMT[_mem.settings.datefmt])) basic.append(datefmt) timefmt = RadioSetting( "settings.timefmt", "Time format", RadioSettingValueList(LIST_TIMEFMT, LIST_TIMEFMT[_mem.settings.timefmt])) basic.append(timefmt) timesig = RadioSetting("settings.timesig", "Time signal", RadioSettingValueBoolean(_mem.settings.timesig)) basic.append(timesig) tz = RadioSetting( "settings.tz", "Time zone", RadioSettingValueList(LIST_TZ, LIST_TZ[_mem.settings.tz])) basic.append(tz) # Signaling: H01-H06 bell = RadioSetting( "settings.bell", "Bell ringer", RadioSettingValueList(LIST_BELL, LIST_BELL[_mem.settings.bell])) basic.append(bell) # H02 (per channel) dtmfmodenc = RadioSetting( "settings.dtmfmodenc", "DTMF mode encode", RadioSettingValueBoolean(_mem.settings.dtmfmodenc)) basic.append(dtmfmodenc) dtmfmoddec = RadioSetting( "settings.dtmfmoddec", "DTMF mode decode", RadioSettingValueBoolean(_mem.settings.dtmfmoddec)) basic.append(dtmfmoddec) # H04 (per channel) decbandsel = RadioSetting( "settings.decbandsel", "DTMF band select", RadioSettingValueList(LIST_AB, LIST_AB[_mem.settings.decbandsel])) basic.append(decbandsel) sqlexp = RadioSetting("settings.sqlexp", "SQL expansion", RadioSettingValueBoolean(_mem.settings.sqlexp)) basic.append(sqlexp) # Pkt: I01-I03 databnd = RadioSetting( "settings.databnd", "Packet data band", RadioSettingValueList(LIST_DATABND, LIST_DATABND[_mem.settings.databnd])) basic.append(databnd) dataspd = RadioSetting( "settings.dataspd", "Packet data speed", RadioSettingValueList(LIST_DATASPD, LIST_DATASPD[_mem.settings.dataspd])) basic.append(dataspd) datasql = RadioSetting( "settings.datasql", "Packet data squelch", RadioSettingValueList(LIST_DATASQL, LIST_DATASQL[_mem.settings.datasql])) basic.append(datasql) # Other dw = RadioSetting("settings.dw", "Dual watch", RadioSettingValueBoolean(_mem.settings.dw)) other.append(dw) cpuclk = RadioSetting( "settings.cpuclk", "CPU clock frequency", RadioSettingValueList(LIST_CPUCLK, LIST_CPUCLK[_mem.settings.cpuclk])) other.append(cpuclk) def _filter(name): filtered = "" for char in str(name): if char in VALID_CHARS: filtered += char else: filtered += " " return filtered line16 = RadioSetting( "poweron_msg.line16", "Power-on message", RadioSettingValueString(0, 16, _filter(_mem.poweron_msg.line16))) other.append(line16) line32 = RadioSetting( "embedded_msg.line32", "Embedded message", RadioSettingValueString(0, 32, _filter(_mem.embedded_msg.line32))) other.append(line32) # Work workmoda = RadioSetting( "settings.workmoda", "Work mode A", RadioSettingValueList(LIST_WORK, LIST_WORK[_mem.settings.workmoda])) work.append(workmoda) workmodb = RadioSetting( "settings.workmodb", "Work mode B", RadioSettingValueList(LIST_WORK, LIST_WORK[_mem.settings.workmodb])) work.append(workmodb) wbanda = RadioSetting( "settings.wbanda", "Work band A", RadioSettingValueList(LIST_WBANDA, LIST_WBANDA[(_mem.settings.wbanda) - 1])) work.append(wbanda) wbandb = RadioSetting( "settings.wbandb", "Work band B", RadioSettingValueList(LIST_WBANDB, LIST_WBANDB[(_mem.settings.wbandb) - 4])) work.append(wbandb) sqla = RadioSetting( "settings.sqla", "Squelch A", RadioSettingValueList(LIST_SQL, LIST_SQL[_mem.settings.sqla])) work.append(sqla) sqlb = RadioSetting( "settings.sqlb", "Squelch B", RadioSettingValueList(LIST_SQL, LIST_SQL[_mem.settings.sqlb])) work.append(sqlb) stepa = RadioSetting( "settings.stepa", "Auto step A", RadioSettingValueList(LIST_STEP, LIST_STEP[_mem.settings.stepa])) work.append(stepa) stepb = RadioSetting( "settings.stepb", "Auto step B", RadioSettingValueList(LIST_STEP, LIST_STEP[_mem.settings.stepb])) work.append(stepb) mrcha = RadioSetting( "settings.mrcha", "Current channel A", RadioSettingValueInteger(0, 499, _mem.settings.mrcha)) work.append(mrcha) mrchb = RadioSetting( "settings.mrchb", "Current channel B", RadioSettingValueInteger(0, 499, _mem.settings.mrchb)) work.append(mrchb) val = _mem.settings.offseta / 100.00 offseta = RadioSetting("settings.offseta", "Offset A (0-37.95)", RadioSettingValueFloat(0, 38.00, val, 0.05, 2)) work.append(offseta) val = _mem.settings.offsetb / 100.00 offsetb = RadioSetting("settings.offsetb", "Offset B (0-79.95)", RadioSettingValueFloat(0, 80.00, val, 0.05, 2)) work.append(offsetb) wpricha = RadioSetting( "settings.wpricha", "Priority channel A", RadioSettingValueInteger(0, 499, _mem.settings.wpricha)) work.append(wpricha) wprichb = RadioSetting( "settings.wprichb", "Priority channel B", RadioSettingValueInteger(0, 499, _mem.settings.wprichb)) work.append(wprichb) smode = RadioSetting( "settings.smode", "Smart function mode", RadioSettingValueList(LIST_SMODE, LIST_SMODE[_mem.settings.smode])) work.append(smode) # dtmf ttdkey = RadioSetting( "dtmf.ttdkey", "D key function", RadioSettingValueList(LIST_TTDKEY, LIST_TTDKEY[_mem.dtmf.ttdkey])) dtmf.append(ttdkey) ttdgt = RadioSetting( "dtmf.ttdgt", "Digit time", RadioSettingValueList(LIST_TT200, LIST_TT200[(_mem.dtmf.ttdgt) - 5])) dtmf.append(ttdgt) ttint = RadioSetting( "dtmf.ttint", "Interval time", RadioSettingValueList(LIST_TT200, LIST_TT200[(_mem.dtmf.ttint) - 5])) dtmf.append(ttint) tt1stdgt = RadioSetting( "dtmf.tt1stdgt", "1st digit time", RadioSettingValueList(LIST_TT200, LIST_TT200[(_mem.dtmf.tt1stdgt) - 5])) dtmf.append(tt1stdgt) tt1stdly = RadioSetting( "dtmf.tt1stdly", "1st digit delay time", RadioSettingValueList(LIST_TT1000, LIST_TT1000[(_mem.dtmf.tt1stdly) - 2])) dtmf.append(tt1stdly) ttdlyqt = RadioSetting( "dtmf.ttdlyqt", "Digit delay when use qt", RadioSettingValueList(LIST_TT1000, LIST_TT1000[(_mem.dtmf.ttdlyqt) - 2])) dtmf.append(ttdlyqt) ttsig = RadioSetting( "dtmf2.ttsig", "Signal", RadioSettingValueList(LIST_TTSIG, LIST_TTSIG[_mem.dtmf2.ttsig])) dtmf.append(ttsig) ttautorst = RadioSetting( "dtmf2.ttautorst", "Auto reset time", RadioSettingValueList(LIST_TTAUTORST, LIST_TTAUTORST[_mem.dtmf2.ttautorst])) dtmf.append(ttautorst) if _mem.dtmf2.ttgrpcode > 0x06: val = 0x00 else: val = _mem.dtmf2.ttgrpcode ttgrpcode = RadioSetting( "dtmf2.ttgrpcode", "Group code", RadioSettingValueList(LIST_TTGRPCODE, LIST_TTGRPCODE[val])) dtmf.append(ttgrpcode) ttintcode = RadioSetting( "dtmf2.ttintcode", "Interval code", RadioSettingValueList(LIST_TTINTCODE, LIST_TTINTCODE[_mem.dtmf2.ttintcode])) dtmf.append(ttintcode) if _mem.dtmf2.ttalert > 0x04: val = 0x00 else: val = _mem.dtmf2.ttalert ttalert = RadioSetting( "dtmf2.ttalert", "Alert tone/transpond", RadioSettingValueList(LIST_TTALERT, LIST_TTALERT[val])) dtmf.append(ttalert) ttautod = RadioSetting( "dtmf.ttautod", "Auto dial group", RadioSettingValueList(LIST_TTAUTOD, LIST_TTAUTOD[_mem.dtmf.ttautod])) dtmf.append(ttautod) # setup 9 dtmf autodial entries for i in map(str, range(1, 10)): objname = "code" + i strname = "Code " + str(i) dtmfsetting = getattr(_mem.dtmfcode, objname) dtmflen = getattr(_mem.dtmfcode, objname + "_len") dtmfstr = self._bbcd2dtmf(dtmfsetting, dtmflen) code = RadioSettingValueString(0, 16, dtmfstr) code.set_charset(DTMF_CHARS + list(" ")) rs = RadioSetting("dtmfcode." + objname, strname, code) dtmf.append(rs) return top
def get_settings(self): _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): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic") cw = RadioSettingGroup("cw", "CW") packet = RadioSettingGroup("packet", "Digital & packet") panel = RadioSettingGroup("panel", "Panel settings") extended = RadioSettingGroup("extended", "Extended") antenna = RadioSettingGroup("antenna", "Antenna selection") panelcontr = RadioSettingGroup("panelcontr", "Panel controls") top = RadioSettings(basic, cw, packet, panelcontr, panel, extended, antenna) rs = RadioSetting("ars_144", "144 ARS", RadioSettingValueBoolean(_settings.ars_144)) basic.append(rs) rs = RadioSetting("ars_430", "430 ARS", RadioSettingValueBoolean(_settings.ars_430)) basic.append(rs) rs = RadioSetting("pkt9600_mic", "Paket 9600 mic level", RadioSettingValueInteger(0, 100, _settings.pkt9600_mic)) packet.append(rs) options = ["enable", "disable"] rs = RadioSetting("disable_amfm_dial", "AM&FM Dial", RadioSettingValueList(options, options[ _settings.disable_amfm_dial ])) panel.append(rs) rs = RadioSetting("am_mic", "AM mic level", RadioSettingValueInteger(0, 100, _settings.am_mic)) basic.append(rs) options = ["OFF", "1h", "2h", "3h", "4h", "5h", "6h"] rs = RadioSetting("apo_time", "APO time", RadioSettingValueList(options, options[_settings.apo_time])) basic.append(rs) options = ["OFF", "Range", "All"] rs = RadioSetting("arts_beep", "ARTS beep", RadioSettingValueList(options, options[_settings.arts_beep])) basic.append(rs) options = ["OFF", "ON", "Auto"] rs = RadioSetting("backlight", "Backlight", RadioSettingValueList(options, options[_settings.backlight])) panel.append(rs) options = ["6h", "8h", "10h"] rs = RadioSetting("batt_chg", "Battery charge", RadioSettingValueList(options, options[_settings.batt_chg])) basic.append(rs) options = ["440Hz", "880Hz"] rs = RadioSetting("beep_freq", "Beep frequency", RadioSettingValueList(options, options[_settings.beep_freq])) panel.append(rs) rs = RadioSetting("beep_volume", "Beep volume", RadioSettingValueInteger(0, 100, _settings.beep_volume)) panel.append(rs) options = ["4800", "9600", "38400"] rs = RadioSetting("cat_rate", "CAT rate", RadioSettingValueList(options, options[_settings.cat_rate])) basic.append(rs) options = ["Blue", "Amber", "Violet"] rs = RadioSetting("color", "Color", RadioSettingValueList(options, options[_settings.color])) panel.append(rs) rs = RadioSetting("contrast", "Contrast", RadioSettingValueInteger(1, 12, _settings.contrast - 1)) panel.append(rs) rs = RadioSetting("cw_delay", "CW delay (*10 ms)", RadioSettingValueInteger(1, 250, _settings.cw_delay)) cw.append(rs) rs = RadioSetting("cw_id", "CW id", RadioSettingValueBoolean(_settings.cw_id)) cw.append(rs) options = ["Normal", "Reverse"] rs = RadioSetting("cw_paddle", "CW paddle", RadioSettingValueList(options, options[_settings.cw_paddle])) cw.append(rs) options = ["%i Hz" % i for i in range(300, 1001, 50)] rs = RadioSetting("cw_pitch", "CW pitch", RadioSettingValueList(options, options[_settings.cw_pitch])) cw.append(rs) options = ["%i wpm" % i for i in range(4, 61)] rs = RadioSetting("cw_speed", "CW speed", RadioSettingValueList(options, options[_settings.cw_speed])) cw.append(rs) options = ["1:%1.1f" % (i / 10) for i in range(25, 46, 1)] rs = RadioSetting("cw_weight", "CW weight", RadioSettingValueList(options, options[_settings.cw_weight])) cw.append(rs) rs = RadioSetting("dig_disp", "Dig disp (*10 Hz)", RadioSettingValueInteger(-300, 300, _settings.dig_disp)) packet.append(rs) rs = RadioSetting("dig_mic", "Dig mic", RadioSettingValueInteger(0, 100, _settings.dig_mic)) packet.append(rs) options = ["RTTY", "PSK31-L", "PSK31-U", "USER-L", "USER-U"] rs = RadioSetting("dig_mode", "Dig mode", RadioSettingValueList(options, options[_settings.dig_mode])) packet.append(rs) rs = RadioSetting("dig_shift", "Dig shift (*10 Hz)", RadioSettingValueInteger(-300, 300, _settings.dig_shift)) packet.append(rs) rs = RadioSetting("fm_mic", "FM mic", RadioSettingValueInteger(0, 100, _settings.fm_mic)) basic.append(rs) options = ["Dial", "Freq", "Panel"] rs = RadioSetting("lock_mode", "Lock mode", RadioSettingValueList(options, options[_settings.lock_mode])) panel.append(rs) options = ["Fine", "Coarse"] rs = RadioSetting("main_step", "Main step", RadioSettingValueList(options, options[_settings.main_step])) panel.append(rs) rs = RadioSetting("mem_group", "Mem group", RadioSettingValueBoolean(_settings.mem_group)) basic.append(rs) rs = RadioSetting("mic_key", "Mic key", RadioSettingValueBoolean(_settings.mic_key)) cw.append(rs) rs = RadioSetting("mic_scan", "Mic scan", RadioSettingValueBoolean(_settings.mic_scan)) basic.append(rs) options = ["Off", "SSB", "CW"] rs = RadioSetting("op_filter", "Optional filter", RadioSettingValueList(options, options[_settings.op_filter])) basic.append(rs) rs = RadioSetting("pkt_mic", "Packet mic", RadioSettingValueInteger(0, 100, _settings.pkt_mic)) packet.append(rs) options = ["1200", "9600"] rs = RadioSetting("pkt_rate", "Packet rate", RadioSettingValueList(options, options[_settings.pkt_rate])) packet.append(rs) options = ["Off", "3 sec", "5 sec", "10 sec"] rs = RadioSetting("resume_scan", "Resume scan", RadioSettingValueList(options, options[_settings.resume_scan]) ) basic.append(rs) options = ["Cont", "Chk"] rs = RadioSetting("scope", "Scope", RadioSettingValueList(options, options[_settings.scope])) basic.append(rs) rs = RadioSetting("sidetone", "Sidetone", RadioSettingValueInteger(0, 100, _settings.sidetone)) cw.append(rs) options = ["RF-Gain", "Squelch"] rs = RadioSetting("sql_rf_gain", "Squelch/RF-Gain", RadioSettingValueList(options, options[_settings.sql_rf_gain]) ) panel.append(rs) rs = RadioSetting("ssb_mic", "SSB Mic", RadioSettingValueInteger(0, 100, _settings.ssb_mic)) basic.append(rs) options = ["%i" % i for i in range(0, 21)] options[0] = "Off" rs = RadioSetting("tot_time", "Time-out timer", RadioSettingValueList(options, options[_settings.tot_time])) basic.append(rs) rs = RadioSetting("vox_delay", "VOX delay (*100 ms)", RadioSettingValueInteger(1, 25, _settings.vox_delay)) basic.append(rs) rs = RadioSetting("vox_gain", "VOX Gain", RadioSettingValueInteger(0, 100, _settings.vox_gain)) basic.append(rs) rs = RadioSetting("extended_menu", "Extended menu", RadioSettingValueBoolean(_settings.extended_menu)) extended.append(rs) options = ["Tn-Rn", "Tn-Riv", "Tiv-Rn", "Tiv-Riv"] rs = RadioSetting("dcs_inv", "DCS coding", RadioSettingValueList(options, options[_settings.dcs_inv])) extended.append(rs) rs = RadioSetting("r_lsb_car", "LSB Rx carrier point (*10 Hz)", RadioSettingValueInteger(-30, 30, _settings.r_lsb_car)) extended.append(rs) rs = RadioSetting("r_usb_car", "USB Rx carrier point (*10 Hz)", RadioSettingValueInteger(-30, 30, _settings.r_usb_car)) extended.append(rs) rs = RadioSetting("t_lsb_car", "LSB Tx carrier point (*10 Hz)", RadioSettingValueInteger(-30, 30, _settings.t_lsb_car)) extended.append(rs) rs = RadioSetting("t_usb_car", "USB Tx carrier point (*10 Hz)", RadioSettingValueInteger(-30, 30, _settings.t_usb_car)) extended.append(rs) options = ["Hi", "L3", "L2", "L1"] rs = RadioSetting("tx_power", "TX power", RadioSettingValueList(options, options[_settings.tx_power])) basic.append(rs) options = ["Front", "Rear"] rs = RadioSetting("hf_antenna", "HF", RadioSettingValueList(options, options[_settings.hf_antenna])) antenna.append(rs) rs = RadioSetting("sixm_antenna", "6M", RadioSettingValueList(options, options[_settings.sixm_antenna] )) antenna.append(rs) rs = RadioSetting("bc_antenna", "Broadcasting", RadioSettingValueList(options, options[_settings.bc_antenna])) antenna.append(rs) rs = RadioSetting("air_antenna", "Air band", RadioSettingValueList(options, options[_settings.air_antenna]) ) antenna.append(rs) rs = RadioSetting("vhf_antenna", "VHF", RadioSettingValueList(options, options[_settings.vhf_antenna]) ) antenna.append(rs) rs = RadioSetting("uhf_antenna", "UHF", RadioSettingValueList(options, options[_settings.uhf_antenna]) ) antenna.append(rs) st = RadioSettingValueString(0, 7, ''.join([self._CALLSIGN_CHARSET[x] for x in self._memobj.callsign])) st.set_charset(self._CALLSIGN_CHARSET) rs = RadioSetting("callsign", "Callsign", st) cw.append(rs) rs = RadioSetting("spl", "Split", RadioSettingValueBoolean(_settings.spl)) panelcontr.append(rs) options = ["None", "Up", "Down"] rs = RadioSetting("scn_mode", "Scan mode", RadioSettingValueList(options, options[_settings.scn_mode])) panelcontr.append(rs) rs = RadioSetting("pri", "Priority", RadioSettingValueBoolean(_settings.pri)) panelcontr.append(rs) rs = RadioSetting("dw", "Dual watch", RadioSettingValueBoolean(_settings.dw)) panelcontr.append(rs) rs = RadioSetting("art", "Auto-range transponder", RadioSettingValueBoolean(_settings.art)) panelcontr.append(rs) rs = RadioSetting("nb", "Noise blanker", RadioSettingValueBoolean(_settings.nb)) panelcontr.append(rs) options = ["Auto", "Fast", "Slow", "Off"] rs = RadioSetting("agc", "AGC", RadioSettingValueList(options, options[_settings.agc] )) panelcontr.append(rs) options = ["PWR", "ALC", "SWR", "MOD"] rs = RadioSetting("pwr_meter_mode", "Power meter mode", RadioSettingValueList(options, options[ _settings.pwr_meter_mode ])) panelcontr.append(rs) rs = RadioSetting("vox", "Vox", RadioSettingValueBoolean(_settings.vox)) panelcontr.append(rs) rs = RadioSetting("bk", "Semi break-in", RadioSettingValueBoolean(_settings.bk)) cw.append(rs) rs = RadioSetting("kyr", "Keyer", RadioSettingValueBoolean(_settings.kyr)) cw.append(rs) options = ["enabled", "disabled"] rs = RadioSetting("fst", "Fast", RadioSettingValueList(options, options[_settings.fst] )) panelcontr.append(rs) options = ["enabled", "disabled"] rs = RadioSetting("lock", "Lock", RadioSettingValueList(options, options[_settings.lock])) panelcontr.append(rs) return top
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic") settings = RadioSettings(basic) display = ["Frequency", "Channel", "Name"] rs = RadioSetting("display", "Display", RadioSettingValueList(display, display[_settings.display])) basic.append(rs) apo = ["Off"] + ['%.1f hour(s)' % (0.5 * x) for x in range(1, 25)] rs = RadioSetting("apo", "Automatic Power Off", RadioSettingValueList(apo, apo[_settings.apo])) basic.append(rs) def filter(s): s_ = "" for i in range(0, 8): c = str(s[i]) s_ += (c if c in chirp_common.CHARSET_ASCII else "") return s_ rs = RadioSetting("welcome", "Welcome Message", RadioSettingValueString(0, 8, filter(_settings.welcome))) basic.append(rs) rs = RadioSetting("beep", "Beep Enabled", RadioSettingValueBoolean(_settings.beep)) basic.append(rs) mute = ["Off", "TX", "RX", "TX/RX"] rs = RadioSetting("mute", "Sub Band Mute", RadioSettingValueList(mute, mute[_settings.mute])) basic.append(rs) return settings
def get_settings(self): """Translate the bit in the mem_struct into settings in the UI""" sett = self._memobj.settings # basic features of the radio basic = RadioSettingGroup("basic", "Basic Settings") # keys fkeys = RadioSettingGroup("keys", "Function keys") top = RadioSettings(basic, fkeys) # Basic val = RadioSettingValueString(0, 35, self._VARIANT) val.set_mutable(False) mod = RadioSetting("not.mod", "Radio version", val) basic.append(mod) beep = RadioSetting("settings.beep", "Beep tone", RadioSettingValueBoolean( bool(sett.beep))) basic.append(beep) bsave = RadioSetting("settings.batt_save", "Battery save", RadioSettingValueBoolean( bool(sett.batt_save))) basic.append(bsave) deal = RadioSetting("settings.dealer", "Dealer & Test", RadioSettingValueBoolean( bool(sett.dealer))) basic.append(deal) add = RadioSetting("settings.add", "Del / Add feature", RadioSettingValueBoolean( bool(sett.add))) basic.append(add) # In some cases the values that follows can be 0xFF (HARD RESET) # so we need to take and validate that if int(sett.tot) == 0xff: # 120 sec sett.tot = 4 if int(sett.tot_alert) == 0xff: # 10 secs sett.tot_alert = 1 if int(sett.tot_rekey) == 0xff: # off sett.tot_rekey = 0 if int(sett.tot_reset) == 0xff: # off sett.tot_reset = 0 if int(sett.sql) == 0xff: # a confortable level ~6 sett.sql = 6 tot = RadioSetting("settings.tot", "Time Out Timer (TOT)", RadioSettingValueList(TOT, TOT[int(sett.tot)])) basic.append(tot) tota = RadioSetting("settings.tot_alert", "TOT pre-plert", RadioSettingValueList(TOT_A, TOT_A[int(sett.tot_alert)])) basic.append(tota) totrk = RadioSetting("settings.tot_rekey", "TOT rekey time", RadioSettingValueList(TOT_RK, TOT_RK[int(sett.tot_rekey)])) basic.append(totrk) totrs = RadioSetting("settings.tot_reset", "TOT reset time", RadioSettingValueList(TOT_RS, TOT_RS[int(sett.tot_reset)])) basic.append(totrs) sql = RadioSetting("settings.sql", "Squelch level", RadioSettingValueList(SQL, SQL[int(sett.sql)])) basic.append(sql) # front keys m = int(sett.kMoni) if m > 3: m = 1 mon = RadioSetting("settings.kMoni", "Monitor", RadioSettingValueList(MONI, MONI[m])) fkeys.append(mon) s = int(sett.kScan) if s > 3: s = 1 scn = RadioSetting("settings.kScan", "Scan", RadioSettingValueList(SCAN, SCAN[s])) fkeys.append(scn) d = int(sett.kDial) if d > 1: d = 0 dial = RadioSetting("settings.kDial", "Dial", RadioSettingValueList(YESNO, YESNO[d])) fkeys.append(dial) t = int(sett.kTa) if t > 2: t = 2 ta = RadioSetting("settings.kTa", "Ta", RadioSettingValueList(TA, TA[t])) fkeys.append(ta) l = int(sett.kLo) if l > 1: l = 0 low = RadioSetting("settings.kLo", "Low", RadioSettingValueList(YESNO, YESNO[l])) fkeys.append(low) return top
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic") cw = RadioSettingGroup("cw", "CW") packet = RadioSettingGroup("packet", "Digital & packet") panel = RadioSettingGroup("panel", "Panel settings") extended = RadioSettingGroup("extended", "Extended") antenna = RadioSettingGroup("antenna", "Antenna selection") panelcontr = RadioSettingGroup("panelcontr", "Panel controls") top = RadioSettings(basic, cw, packet, panelcontr, panel, extended, antenna) rs = RadioSetting("ars_144", "144 ARS", RadioSettingValueBoolean(_settings.ars_144)) basic.append(rs) rs = RadioSetting("ars_430", "430 ARS", RadioSettingValueBoolean(_settings.ars_430)) basic.append(rs) rs = RadioSetting( "pkt9600_mic", "Paket 9600 mic level", RadioSettingValueInteger(0, 100, _settings.pkt9600_mic)) packet.append(rs) options = ["enable", "disable"] rs = RadioSetting( "disable_amfm_dial", "AM&FM Dial", RadioSettingValueList(options, options[_settings.disable_amfm_dial])) panel.append(rs) rs = RadioSetting("am_mic", "AM mic level", RadioSettingValueInteger(0, 100, _settings.am_mic)) basic.append(rs) options = ["OFF", "1h", "2h", "3h", "4h", "5h", "6h"] rs = RadioSetting( "apo_time", "APO time", RadioSettingValueList(options, options[_settings.apo_time])) basic.append(rs) options = ["OFF", "Range", "All"] rs = RadioSetting( "arts_beep", "ARTS beep", RadioSettingValueList(options, options[_settings.arts_beep])) basic.append(rs) options = ["OFF", "ON", "Auto"] rs = RadioSetting( "backlight", "Backlight", RadioSettingValueList(options, options[_settings.backlight])) panel.append(rs) options = ["6h", "8h", "10h"] rs = RadioSetting( "batt_chg", "Battery charge", RadioSettingValueList(options, options[_settings.batt_chg])) basic.append(rs) options = ["440Hz", "880Hz"] rs = RadioSetting( "beep_freq", "Beep frequency", RadioSettingValueList(options, options[_settings.beep_freq])) panel.append(rs) rs = RadioSetting( "beep_volume", "Beep volume", RadioSettingValueInteger(0, 100, _settings.beep_volume)) panel.append(rs) options = ["4800", "9600", "38400"] rs = RadioSetting( "cat_rate", "CAT rate", RadioSettingValueList(options, options[_settings.cat_rate])) basic.append(rs) options = ["Blue", "Amber", "Violet"] rs = RadioSetting( "color", "Color", RadioSettingValueList(options, options[_settings.color])) panel.append(rs) rs = RadioSetting( "contrast", "Contrast", RadioSettingValueInteger(1, 12, _settings.contrast - 1)) panel.append(rs) rs = RadioSetting("cw_delay", "CW delay (*10 ms)", RadioSettingValueInteger(1, 250, _settings.cw_delay)) cw.append(rs) rs = RadioSetting("cw_id", "CW id", RadioSettingValueBoolean(_settings.cw_id)) cw.append(rs) options = ["Normal", "Reverse"] rs = RadioSetting( "cw_paddle", "CW paddle", RadioSettingValueList(options, options[_settings.cw_paddle])) cw.append(rs) options = ["%i Hz" % i for i in range(300, 1001, 50)] rs = RadioSetting( "cw_pitch", "CW pitch", RadioSettingValueList(options, options[_settings.cw_pitch])) cw.append(rs) options = ["%i wpm" % i for i in range(4, 61)] rs = RadioSetting( "cw_speed", "CW speed", RadioSettingValueList(options, options[_settings.cw_speed])) cw.append(rs) options = ["1:%1.1f" % (i / 10) for i in range(25, 46, 1)] rs = RadioSetting( "cw_weight", "CW weight", RadioSettingValueList(options, options[_settings.cw_weight])) cw.append(rs) rs = RadioSetting( "dig_disp", "Dig disp (*10 Hz)", RadioSettingValueInteger(-300, 300, _settings.dig_disp)) packet.append(rs) rs = RadioSetting("dig_mic", "Dig mic", RadioSettingValueInteger(0, 100, _settings.dig_mic)) packet.append(rs) options = ["RTTY", "PSK31-L", "PSK31-U", "USER-L", "USER-U"] rs = RadioSetting( "dig_mode", "Dig mode", RadioSettingValueList(options, options[_settings.dig_mode])) packet.append(rs) rs = RadioSetting( "dig_shift", "Dig shift (*10 Hz)", RadioSettingValueInteger(-300, 300, _settings.dig_shift)) packet.append(rs) rs = RadioSetting("fm_mic", "FM mic", RadioSettingValueInteger(0, 100, _settings.fm_mic)) basic.append(rs) options = ["Dial", "Freq", "Panel"] rs = RadioSetting( "lock_mode", "Lock mode", RadioSettingValueList(options, options[_settings.lock_mode])) panel.append(rs) options = ["Fine", "Coarse"] rs = RadioSetting( "main_step", "Main step", RadioSettingValueList(options, options[_settings.main_step])) panel.append(rs) rs = RadioSetting("mem_group", "Mem group", RadioSettingValueBoolean(_settings.mem_group)) basic.append(rs) rs = RadioSetting("mic_key", "Mic key", RadioSettingValueBoolean(_settings.mic_key)) cw.append(rs) rs = RadioSetting("mic_scan", "Mic scan", RadioSettingValueBoolean(_settings.mic_scan)) basic.append(rs) options = ["Off", "SSB", "CW"] rs = RadioSetting( "op_filter", "Optional filter", RadioSettingValueList(options, options[_settings.op_filter])) basic.append(rs) rs = RadioSetting("pkt_mic", "Packet mic", RadioSettingValueInteger(0, 100, _settings.pkt_mic)) packet.append(rs) options = ["1200", "9600"] rs = RadioSetting( "pkt_rate", "Packet rate", RadioSettingValueList(options, options[_settings.pkt_rate])) packet.append(rs) options = ["Off", "3 sec", "5 sec", "10 sec"] rs = RadioSetting( "resume_scan", "Resume scan", RadioSettingValueList(options, options[_settings.resume_scan])) basic.append(rs) options = ["Cont", "Chk"] rs = RadioSetting( "scope", "Scope", RadioSettingValueList(options, options[_settings.scope])) basic.append(rs) rs = RadioSetting("sidetone", "Sidetone", RadioSettingValueInteger(0, 100, _settings.sidetone)) cw.append(rs) options = ["RF-Gain", "Squelch"] rs = RadioSetting( "sql_rf_gain", "Squelch/RF-Gain", RadioSettingValueList(options, options[_settings.sql_rf_gain])) panel.append(rs) rs = RadioSetting("ssb_mic", "SSB Mic", RadioSettingValueInteger(0, 100, _settings.ssb_mic)) basic.append(rs) options = ["%i" % i for i in range(0, 21)] options[0] = "Off" rs = RadioSetting( "tot_time", "Time-out timer", RadioSettingValueList(options, options[_settings.tot_time])) basic.append(rs) rs = RadioSetting("vox_delay", "VOX delay (*100 ms)", RadioSettingValueInteger(1, 25, _settings.vox_delay)) basic.append(rs) rs = RadioSetting("vox_gain", "VOX Gain", RadioSettingValueInteger(0, 100, _settings.vox_gain)) basic.append(rs) rs = RadioSetting("extended_menu", "Extended menu", RadioSettingValueBoolean(_settings.extended_menu)) extended.append(rs) options = ["Tn-Rn", "Tn-Riv", "Tiv-Rn", "Tiv-Riv"] rs = RadioSetting( "dcs_inv", "DCS coding", RadioSettingValueList(options, options[_settings.dcs_inv])) extended.append(rs) rs = RadioSetting( "r_lsb_car", "LSB Rx carrier point (*10 Hz)", RadioSettingValueInteger(-30, 30, _settings.r_lsb_car)) extended.append(rs) rs = RadioSetting( "r_usb_car", "USB Rx carrier point (*10 Hz)", RadioSettingValueInteger(-30, 30, _settings.r_usb_car)) extended.append(rs) rs = RadioSetting( "t_lsb_car", "LSB Tx carrier point (*10 Hz)", RadioSettingValueInteger(-30, 30, _settings.t_lsb_car)) extended.append(rs) rs = RadioSetting( "t_usb_car", "USB Tx carrier point (*10 Hz)", RadioSettingValueInteger(-30, 30, _settings.t_usb_car)) extended.append(rs) options = ["Hi", "L3", "L2", "L1"] rs = RadioSetting( "tx_power", "TX power", RadioSettingValueList(options, options[_settings.tx_power])) basic.append(rs) options = ["Front", "Rear"] rs = RadioSetting( "hf_antenna", "HF", RadioSettingValueList(options, options[_settings.hf_antenna])) antenna.append(rs) rs = RadioSetting( "sixm_antenna", "6M", RadioSettingValueList(options, options[_settings.sixm_antenna])) antenna.append(rs) rs = RadioSetting( "bc_antenna", "Broadcasting", RadioSettingValueList(options, options[_settings.bc_antenna])) antenna.append(rs) rs = RadioSetting( "air_antenna", "Air band", RadioSettingValueList(options, options[_settings.air_antenna])) antenna.append(rs) rs = RadioSetting( "vhf_antenna", "VHF", RadioSettingValueList(options, options[_settings.vhf_antenna])) antenna.append(rs) rs = RadioSetting( "uhf_antenna", "UHF", RadioSettingValueList(options, options[_settings.uhf_antenna])) antenna.append(rs) st = RadioSettingValueString( 0, 7, ''.join([self._CALLSIGN_CHARSET[x] for x in self._memobj.callsign])) st.set_charset(self._CALLSIGN_CHARSET) rs = RadioSetting("callsign", "Callsign", st) cw.append(rs) rs = RadioSetting("spl", "Split", RadioSettingValueBoolean(_settings.spl)) panelcontr.append(rs) options = ["None", "Up", "Down"] rs = RadioSetting( "scn_mode", "Scan mode", RadioSettingValueList(options, options[_settings.scn_mode])) panelcontr.append(rs) rs = RadioSetting("pri", "Priority", RadioSettingValueBoolean(_settings.pri)) panelcontr.append(rs) rs = RadioSetting("dw", "Dual watch", RadioSettingValueBoolean(_settings.dw)) panelcontr.append(rs) rs = RadioSetting("art", "Auto-range transponder", RadioSettingValueBoolean(_settings.art)) panelcontr.append(rs) rs = RadioSetting("nb", "Noise blanker", RadioSettingValueBoolean(_settings.nb)) panelcontr.append(rs) options = ["Auto", "Fast", "Slow", "Off"] rs = RadioSetting( "agc", "AGC", RadioSettingValueList(options, options[_settings.agc])) panelcontr.append(rs) options = ["PWR", "ALC", "SWR", "MOD"] rs = RadioSetting( "pwr_meter_mode", "Power meter mode", RadioSettingValueList(options, options[_settings.pwr_meter_mode])) panelcontr.append(rs) rs = RadioSetting("vox", "Vox", RadioSettingValueBoolean(_settings.vox)) panelcontr.append(rs) rs = RadioSetting("bk", "Semi break-in", RadioSettingValueBoolean(_settings.bk)) cw.append(rs) rs = RadioSetting("kyr", "Keyer", RadioSettingValueBoolean(_settings.kyr)) cw.append(rs) options = ["enabled", "disabled"] rs = RadioSetting( "fst", "Fast", RadioSettingValueList(options, options[_settings.fst])) panelcontr.append(rs) options = ["enabled", "disabled"] rs = RadioSetting( "lock", "Lock", RadioSettingValueList(options, options[_settings.lock])) panelcontr.append(rs) return top
def get_settings(self): _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_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): _settings = self._memobj.settings repeater = RadioSettingGroup("repeater", "Repeater Settings") ctcss = RadioSettingGroup("ctcss", "CTCSS/DCS/DTMF Settings") arts = RadioSettingGroup("arts", "ARTS Settings") scan = RadioSettingGroup("scan", "Scan Settings") power = RadioSettingGroup("power", "Power Saver Settings") wires = RadioSettingGroup("wires", "WiRES(tm) Settings") eai = RadioSettingGroup("eai", "EAI/EPCS Settings") switch = RadioSettingGroup("switch", "Switch/Knob Settings") misc = RadioSettingGroup("misc", "Miscellaneous Settings") mbls = RadioSettingGroup("banks", "Memory Bank Link Scan") setmode = RadioSettings(repeater, ctcss, arts, scan, power, wires, eai, switch, misc, mbls) # APO opts = ["OFF"] + ["%0.1f" % (x * 0.5) for x in range(1, 24+1)] misc.append( RadioSetting( "apo", "Automatic Power Off", RadioSettingValueList(opts, opts[_settings.apo]))) # AR.BEP opts = ["OFF", "INRANG", "ALWAYS"] arts.append( RadioSetting( "ar_bep", "ARTS Beep", RadioSettingValueList(opts, opts[_settings.ar_bep]))) # AR.INT opts = ["25 SEC", "15 SEC"] arts.append( RadioSetting( "ar_int", "ARTS Polling Interval", RadioSettingValueList(opts, opts[_settings.ar_int]))) # ARS opts = ["OFF", "ON"] repeater.append( RadioSetting( "ars", "Automatic Repeater Shift", RadioSettingValueList(opts, opts[_settings.ars]))) # BCLO opts = ["OFF", "ON"] misc.append(RadioSetting( "bclo", "Busy Channel Lock-Out", RadioSettingValueList(opts, opts[_settings.bclo]))) # BEEP opts = ["OFF", "KEY", "KEY+SC"] rs = RadioSetting( "beep_key", "Enable the Beeper", RadioSettingValueList( opts, opts[_settings.beep_key + _settings.beep_sc])) def apply_beep(s, obj): setattr(obj, "beep_key", (int(s.value) & 1) or ((int(s.value) >> 1) & 1)) setattr(obj, "beep_sc", (int(s.value) >> 1) & 1) rs.set_apply_callback(apply_beep, self._memobj.settings) switch.append(rs) # BELL opts = ["OFF", "1T", "3T", "5T", "8T", "CONT"] ctcss.append(RadioSetting("bell", "Bell Repetitions", RadioSettingValueList(opts, opts[_settings.bell]))) # BSY.LED opts = ["ON", "OFF"] misc.append(RadioSetting("bsy_led", "Busy LED", RadioSettingValueList(opts, opts[_settings.bsy_led]))) # DCS.NR opts = ["TR/X N", "RX R", "TX R", "T/RX R"] ctcss.append(RadioSetting("dcs_nr", "\"Inverted\" DCS Code Decoding", RadioSettingValueList(opts, opts[_settings.dcs_nr]))) # DT.DLY opts = ["50 MS", "100 MS", "250 MS", "450 MS", "750 MS", "1000 MS"] ctcss.append(RadioSetting("dt_dly", "DTMF Autodialer Delay Time", RadioSettingValueList(opts, opts[_settings.dt_dly]))) # DT.SPD opts = ["50 MS", "100 MS"] ctcss.append(RadioSetting("dt_spd", "DTMF Autodialer Sending Speed", RadioSettingValueList(opts, opts[_settings.dt_spd]))) # DT.WRT for i in range(0, 9): dtmf = self._memobj.dtmf[i] str = "" for c in dtmf.memory: if c == 0xFF: break if c < len(DTMF_CHARS): str += DTMF_CHARS[c] val = RadioSettingValueString(0, 16, str, False) val.set_charset(DTMF_CHARS + list("abcd")) rs = RadioSetting("dtmf_%i" % i, "DTMF Autodialer Memory %i" % (i + 1), val) def apply_dtmf(s, obj): str = s.value.get_value().upper().rstrip() val = [DTMF_CHARS.index(x) for x in str] for x in range(len(val), 16): val.append(0xFF) obj.memory = val rs.set_apply_callback(apply_dtmf, dtmf) ctcss.append(rs) # EDG.BEP opts = ["OFF", "ON"] misc.append(RadioSetting("edg_bep", "Band Edge Beeper", RadioSettingValueList(opts, opts[_settings.edg_bep]))) # I.NET opts = ["OFF", "COD", "MEM"] rs = RadioSetting("inet", "Internet Link Connection", RadioSettingValueList( opts, opts[_settings.inet - 1])) def apply_inet(s, obj): setattr(obj, s.get_name(), int(s.value) + 1) rs.set_apply_callback(apply_inet, self._memobj.settings) wires.append(rs) # INT.CD opts = ["CODE 0", "CODE 1", "CODE 2", "CODE 3", "CODE 4", "CODE 5", "CODE 6", "CODE 7", "CODE 8", "CODE 9", "CODE A", "CODE B", "CODE C", "CODE D", "CODE E", "CODE F"] wires.append(RadioSetting("int_cd", "Access Number for WiRES(TM)", RadioSettingValueList(opts, opts[_settings.int_cd]))) # INT.MR opts = ["d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9"] wires.append(RadioSetting( "int_mr", "Access Number (DTMF) for Non-WiRES(TM)", RadioSettingValueList(opts, opts[_settings.int_mr]))) # LAMP opts = ["KEY", "5SEC", "TOGGLE"] switch.append(RadioSetting("lamp", "Lamp Mode", RadioSettingValueList(opts, opts[_settings.lamp]))) # LOCK opts = ["LK KEY", "LKDIAL", "LK K+D", "LK PTT", "LP P+K", "LK P+D", "LK ALL"] rs = RadioSetting("lock", "Control Locking", RadioSettingValueList( opts, opts[_settings.lock - 1])) def apply_lock(s, obj): setattr(obj, s.get_name(), int(s.value) + 1) rs.set_apply_callback(apply_lock, self._memobj.settings) switch.append(rs) # M/T-CL opts = ["MONI", "T-CALL"] switch.append(RadioSetting("mt_cl", "MONI Switch Function", RadioSettingValueList(opts, opts[_settings.mt_cl]))) # PAG.ABK opts = ["OFF", "ON"] eai.append(RadioSetting("pag_abk", "Paging Answer Back", RadioSettingValueList(opts, opts[_settings.pag_abk]))) # RESUME opts = ["TIME", "HOLD", "BUSY"] scan.append(RadioSetting("resume", "Scan Resume Mode", RadioSettingValueList(opts, opts[_settings.resume]))) # REV/HM opts = ["REV", "HOME"] switch.append(RadioSetting("rev_hm", "HM/RV Key Function", RadioSettingValueList(opts, opts[_settings.rev_hm]))) # RF.SQL opts = ["OFF", "S-1", "S-2", "S-3", "S-4", "S-5", "S-6", "S-7", "S-8", "S-FULL"] misc.append(RadioSetting("rf_sql", "RF Squelch Threshold", RadioSettingValueList(opts, opts[_settings.rf_sql]))) # PRI.RVT opts = ["OFF", "ON"] scan.append(RadioSetting("pri_rvt", "Priority Revert", RadioSettingValueList(opts, opts[_settings.pri_rvt]))) # RXSAVE opts = ["OFF", "200 MS", "300 MS", "500 MS", "1 S", "2 S"] power.append(RadioSetting( "rxsave", "Receive Mode Batery Savery Interval", RadioSettingValueList(opts, opts[_settings.rxsave]))) # S.SRCH opts = ["SINGLE", "CONT"] misc.append(RadioSetting("ssrch", "Smart Search Sweep Mode", RadioSettingValueList(opts, opts[_settings.ssrch]))) # SCN.MD opts = ["MEM", "ONLY"] scan.append(RadioSetting( "scn_md", "Memory Scan Channel Selection Mode", RadioSettingValueList(opts, opts[_settings.scn_md]))) # SCN.LMP opts = ["OFF", "ON"] scan.append(RadioSetting("scn_lmp", "Scan Lamp", RadioSettingValueList(opts, opts[_settings.scn_lmp]))) # TOT opts = ["OFF"] + ["%dMIN" % (x) for x in range(1, 30+1)] misc.append(RadioSetting("tot", "Timeout Timer", RadioSettingValueList(opts, opts[_settings.tot]))) # TX.LED opts = ["ON", "OFF"] misc.append(RadioSetting("tx_led", "TX LED", RadioSettingValueList(opts, opts[_settings.tx_led]))) # TXSAVE opts = ["OFF", "ON"] power.append(RadioSetting("txsave", "Transmitter Battery Saver", RadioSettingValueList(opts, opts[_settings.txsave]))) # VFO.BND opts = ["BAND", "ALL"] misc.append(RadioSetting("vfo_bnd", "VFO Band Edge Limiting", RadioSettingValueList(opts, opts[_settings.vfo_bnd]))) # WX.ALT opts = ["OFF", "ON"] scan.append(RadioSetting("wx_alt", "Weather Alert Scan", RadioSettingValueList(opts, opts[_settings.wx_alt]))) # MBS for i in range(0, 10): opts = ["OFF", "ON"] mbs = (self._memobj.mbs >> i) & 1 rs = RadioSetting("mbs%i" % i, "Bank %s Scan" % (i + 1), RadioSettingValueList(opts, opts[mbs])) def apply_mbs(s, index): if int(s.value): self._memobj.mbs |= (1 << index) else: self._memobj.mbs &= ~(1 << index) rs.set_apply_callback(apply_mbs, i) mbls.append(rs) return setmode
def get_settings(self): _settings = self._memobj.settings _vfo = self._memobj.vfo basic = RadioSettingGroup("basic", "Basic Settings") group = RadioSettings(basic) rs = RadioSetting("squelch", "Squelch Level", RadioSettingValueInteger(0, 9, _settings.squelch)) basic.append(rs) rs = RadioSetting("backlight", "LCD Back Light", RadioSettingValueList( BACKLIGHT_LIST, BACKLIGHT_LIST[_settings.backlight])) basic.append(rs) rs = RadioSetting("beep", "Keypad Beep", RadioSettingValueBoolean(_settings.beep)) basic.append(rs) rs = RadioSetting("vox", "VOX Level (0=OFF)", RadioSettingValueInteger(0, 9, _settings.vox)) basic.append(rs) rs = RadioSetting("dw", "Dual Watch", RadioSettingValueBoolean(_settings.dw)) basic.append(rs) rs = RadioSetting("ste", "Squelch Tail Eliminate", RadioSettingValueList( STE_LIST, STE_LIST[_settings.ste])) basic.append(rs) rs = RadioSetting("save", "Battery Saver", RadioSettingValueBoolean(_settings.save)) basic.append(rs) rs = RadioSetting("timeout", "Time Out Timer", RadioSettingValueList( TIMEOUT_LIST, TIMEOUT_LIST[_settings.timeout])) basic.append(rs) rs = RadioSetting("scanm", "Scan Mode", RadioSettingValueList( SCANM_LIST, SCANM_LIST[_settings.scanm])) basic.append(rs) rs = RadioSetting("relaym", "Repeater Sound Response", RadioSettingValueBoolean(_settings.relaym)) basic.append(rs) rs = RadioSetting("bclo", "Busy Channel Lock Out", RadioSettingValueBoolean(_settings.bclo)) basic.append(rs) rs = RadioSetting("pri", "Priority Channel Scanning", RadioSettingValueBoolean(_settings.pri)) basic.append(rs) rs = RadioSetting("pri_ch", "Priority Channel", RadioSettingValueList( PRI_CH_LIST, PRI_CH_LIST[_settings.pri_ch])) basic.append(rs) rs = RadioSetting("ch_flag", "Display Mode", RadioSettingValueList( CH_FLAG_LIST, CH_FLAG_LIST[_settings.ch_flag])) basic.append(rs) _limit = int(self._memobj.limits.lower_vhf) / 10 if _limit < 115 or _limit > 239: _limit = 144 rs = RadioSetting("limits.lower_vhf", "VHF Lower Limit (115-239 MHz)", RadioSettingValueInteger(115, 235, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.lower_vhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) _limit = int(self._memobj.limits.upper_vhf) / 10 if _limit < 115 or _limit > 239: _limit = 146 rs = RadioSetting("limits.upper_vhf", "VHF Upper Limit (115-239 MHz)", RadioSettingValueInteger(115, 235, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.upper_vhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) _limit = int(self._memobj.limits.lower_uhf) / 10 if _limit < 200 or _limit > 529: _limit = 420 rs = RadioSetting("limits.lower_uhf", "UHF Lower Limit (200-529 MHz)", RadioSettingValueInteger(200, 529, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.lower_uhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) _limit = int(self._memobj.limits.upper_uhf) / 10 if _limit < 200 or _limit > 529: _limit = 450 rs = RadioSetting("limits.upper_uhf", "UHF Upper Limit (200-529 MHz)", RadioSettingValueInteger(200, 529, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.upper_uhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) vfo_preset = RadioSettingGroup("vfo_preset", "VFO Presets") group.append(vfo_preset) def convert_bytes_to_freq(bytes): real_freq = 0 real_freq = bytes return chirp_common.format_freq(real_freq * 10) def apply_vhf_freq(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 10 obj.vhf.freq = value val = RadioSettingValueString( 0, 10, convert_bytes_to_freq(int(_vfo.vhf.freq))) rs = RadioSetting("vfo.vhf.freq", "VHF RX Frequency (115.00000-236.00000)", val) rs.set_apply_callback(apply_vhf_freq, _vfo) vfo_preset.append(rs) rs = RadioSetting("vfo.vhf.duplex", "Shift Direction", RadioSettingValueList( DUPLEX_LIST, DUPLEX_LIST[_vfo.vhf.duplex])) vfo_preset.append(rs) def convert_bytes_to_offset(bytes): real_offset = 0 real_offset = bytes return chirp_common.format_freq(real_offset * 10000) def apply_vhf_offset(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 10000 obj.vhf.offset = value val = RadioSettingValueString( 0, 10, convert_bytes_to_offset(int(_vfo.vhf.offset))) rs = RadioSetting("vfo.vhf.offset", "Offset (0.00-37.995)", val) rs.set_apply_callback(apply_vhf_offset, _vfo) vfo_preset.append(rs) rs = RadioSetting("vfo.vhf.power", "Power Level", RadioSettingValueList( POWER_LIST, POWER_LIST[_vfo.vhf.power])) vfo_preset.append(rs) rs = RadioSetting("vfo.vhf.bandwidth", "Bandwidth", RadioSettingValueList( BANDWIDTH_LIST, BANDWIDTH_LIST[_vfo.vhf.bandwidth])) vfo_preset.append(rs) rs = RadioSetting("vfo.vhf.step", "Step", RadioSettingValueList( STEP_LIST, STEP_LIST[_vfo.vhf.step])) vfo_preset.append(rs) def apply_uhf_freq(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 10 obj.uhf.freq = value val = RadioSettingValueString( 0, 10, convert_bytes_to_freq(int(_vfo.uhf.freq))) rs = RadioSetting("vfo.uhf.freq", "UHF RX Frequency (200.00000-529.00000)", val) rs.set_apply_callback(apply_uhf_freq, _vfo) vfo_preset.append(rs) rs = RadioSetting("vfo.uhf.duplex", "Shift Direction", RadioSettingValueList( DUPLEX_LIST, DUPLEX_LIST[_vfo.uhf.duplex])) vfo_preset.append(rs) def apply_uhf_offset(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 10000 obj.uhf.offset = value val = RadioSettingValueString( 0, 10, convert_bytes_to_offset(int(_vfo.uhf.offset))) rs = RadioSetting("vfo.uhf.offset", "Offset (0.00-69.995)", val) rs.set_apply_callback(apply_uhf_offset, _vfo) vfo_preset.append(rs) rs = RadioSetting("vfo.uhf.power", "Power Level", RadioSettingValueList( POWER_LIST, POWER_LIST[_vfo.uhf.power])) vfo_preset.append(rs) rs = RadioSetting("vfo.uhf.bandwidth", "Bandwidth", RadioSettingValueList( BANDWIDTH_LIST, BANDWIDTH_LIST[_vfo.uhf.bandwidth])) vfo_preset.append(rs) rs = RadioSetting("vfo.uhf.step", "Step", RadioSettingValueList( STEP_LIST, STEP_LIST[_vfo.uhf.step])) vfo_preset.append(rs) fm_preset = RadioSettingGroup("fm_preset", "FM Radio Presets") group.append(fm_preset) for i in range(0, 16): if self._memobj.fm_presets[i] < 0x01AF: used = True preset = self._memobj.fm_presets[i] / 10.0 + 65 else: used = False preset = 65 rs = RadioSetting("fm_presets_%1i" % i, "FM Preset %i" % (i + 1), RadioSettingValueBoolean(used), RadioSettingValueFloat(65, 108, preset, 0.1, 1)) fm_preset.append(rs) return group
def get_settings(self): _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_memory(self, number): bitpos = (1 << ((number - 1) % 8)) bytepos = ((number - 1) / 8) LOG.debug("bitpos %s" % bitpos) LOG.debug("bytepos %s" % bytepos) _mem = self._memobj.memory[number - 1] mem = chirp_common.Memory() mem.number = number mem.freq = int(_mem.rx_freq) * 10 txfreq = int(_mem.tx_freq) * 10 if txfreq == mem.freq: mem.duplex = "" elif txfreq == 0: mem.duplex = "off" mem.offset = 0 # 166666665*10 is the equivalent for FF FF FF FF # stored in the TX field elif txfreq == 1666666650: mem.duplex = "off" mem.offset = 0 elif txfreq < mem.freq: mem.duplex = "-" mem.offset = mem.freq - txfreq elif txfreq > mem.freq: mem.duplex = "+" mem.offset = txfreq - mem.freq # get bandwith FM or NFM mem.mode = MODE_LIST[_mem.mode] # tone data txtone = self.decode_tone(_mem.tx_tone) rxtone = self.decode_tone(_mem.rx_tone) chirp_common.split_tone_decode(mem, txtone, rxtone) mem.power = POWER_LEVELS[_mem.power] # add extra channel settings to the OTHER tab of the properties # extra settings are unfortunately inverted mem.extra = RadioSettingGroup("extra", "Extra") scanadd = RadioSetting( "scanadd", "Scan Add", RadioSettingValueBoolean(not bool(_mem.scanadd))) scanadd.set_doc("Add channel for scanning") mem.extra.append(scanadd) bclo = RadioSetting("bclo", "Busy Lockout", RadioSettingValueBoolean(not bool(_mem.bclo))) bclo.set_doc("Busy Lockout") mem.extra.append(bclo) scramb = RadioSetting("scramb", "Scramble", RadioSettingValueBoolean(not bool(_mem.scramb))) scramb.set_doc("Scramble Audio Signal") mem.extra.append(scramb) compand = RadioSetting( "compand", "Compander", RadioSettingValueBoolean(not bool(_mem.compand))) compand.set_doc("Compress Audio for TX") mem.extra.append(compand) return mem
def get_settings(self): _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_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic") cw = RadioSettingGroup("cw", "CW") packet = RadioSettingGroup("packet", "Digital & packet") panel = RadioSettingGroup("panel", "Panel settings") extended = RadioSettingGroup("extended", "Extended") panelcontr = RadioSettingGroup("panelcontr", "Panel controls") top = RadioSettingGroup("top", "All Settings", basic, cw, packet, panelcontr, panel, extended) rs = RadioSetting("extended_menu", "Extended menu", RadioSettingValueBoolean(_settings.extended_menu)) extended.append(rs) rs = RadioSetting("ars_144", "144MHz ARS", RadioSettingValueBoolean(_settings.ars_144)) basic.append(rs) rs = RadioSetting("ars_430", "430MHz ARS", RadioSettingValueBoolean(_settings.ars_430)) basic.append(rs) options = ["enable", "disable"] rs = RadioSetting("disable_amfm_dial", "AM&FM Dial", RadioSettingValueList(options, options[_settings.disable_amfm_dial])) panel.append(rs) rs = RadioSetting("am_mic", "AM mic gain", RadioSettingValueInteger(0, 100, _settings.am_mic)) basic.append(rs) options = ["OFF", "1h", "2h", "3h", "4h", "5h", "6h"] rs = RadioSetting("apo_time", "APO time", RadioSettingValueList(options, options[_settings.apo_time])) basic.append(rs) options = ["OFF", "Range", "All"] rs = RadioSetting("arts_beep", "ARTS beep", RadioSettingValueList(options, options[_settings.arts_beep])) basic.append(rs) rs = RadioSetting("arts_id", "ARTS ID", RadioSettingValueBoolean(_settings.arts_id)) extended.append(rs) s = RadioSettingValueString(0, 10, ''.join([self._CALLSIGN_CHARSET[x] for x in self._memobj.arts_idw])) s.set_charset(self._CALLSIGN_CHARSET) rs = RadioSetting("arts_idw", "ARTS IDW", s) extended.append(rs) s = RadioSettingValueString(0, 40, ''.join([self._BEACON_CHARSET[x] for x in self._memobj.beacon_text1])) s.set_charset(self._BEACON_CHARSET) rs = RadioSetting("beacon_text1", "Beacon text1", s) extended.append(rs) s = RadioSettingValueString(0, 40, ''.join([self._BEACON_CHARSET[x] for x in self._memobj.beacon_text2])) s.set_charset(self._BEACON_CHARSET) rs = RadioSetting("beacon_text2", "Beacon text2", s) extended.append(rs) s = RadioSettingValueString(0, 40, ''.join([self._BEACON_CHARSET[x] for x in self._memobj.beacon_text3])) s.set_charset(self._BEACON_CHARSET) rs = RadioSetting("beacon_text3", "Beacon text3", s) extended.append(rs) options = ["OFF"]+["%i sec" % i for i in range(1,256)] rs = RadioSetting("beacon_time", "Beacon time", RadioSettingValueList(options, options[_settings.beacon_time])) extended.append(rs) options = ["440Hz", "880Hz", "1760Hz"] rs = RadioSetting("beep_tone", "Beep tone", RadioSettingValueList(options, options[_settings.beep_tone])) panel.append(rs) rs = RadioSetting("beep_vol", "Beep volume", RadioSettingValueInteger(0, 100, _settings.beep_vol)) panel.append(rs) rs = RadioSetting("r_lsb_car", "LSB Rx carrier point (*10 Hz)", RadioSettingValueInteger(-30, 30, _settings.r_lsb_car)) extended.append(rs) rs = RadioSetting("r_usb_car", "USB Rx carrier point (*10 Hz)", RadioSettingValueInteger(-30, 30, _settings.r_usb_car)) extended.append(rs) rs = RadioSetting("t_lsb_car", "LSB Tx carrier point (*10 Hz)", RadioSettingValueInteger(-30, 30, _settings.t_lsb_car)) extended.append(rs) rs = RadioSetting("t_usb_car", "USB Tx carrier point (*10 Hz)", RadioSettingValueInteger(-30, 30, _settings.t_usb_car)) extended.append(rs) options = ["4800", "9600", "38400"] rs = RadioSetting("cat_rate", "CAT rate", RadioSettingValueList(options, options[_settings.cat_rate])) basic.append(rs) options = ["CAT", "Linear", "Tuner"] rs = RadioSetting("cat_lin_tun", "CAT/LIN/TUN selection", RadioSettingValueList(options, options[_settings.cat_lin_tun])) extended.append(rs) options = ["MAIN", "VFO/MEM", "CLAR"] # TODO test the 3 options on non D radio # which have only SEL and MAIN rs = RadioSetting("clar_dial_sel", "Clarifier dial selection", RadioSettingValueList(options, options[_settings.clar_dial_sel])) panel.append(rs) rs = RadioSetting("cw_auto_mode", "CW Automatic mode", RadioSettingValueBoolean(_settings.cw_auto_mode)) cw.append(rs) options = ["USB", "LSB", "AUTO"] rs = RadioSetting("cw_bfo", "CW BFO", RadioSettingValueList(options, options[_settings.cw_bfo])) cw.append(rs) options = ["FULL"]+["%i ms" % (i*10) for i in range(3,301)] val = (_settings.cw_delay + _settings.cw_delay_hi * 256) - 2 rs = RadioSetting("cw_delay", "CW delay", RadioSettingValueList(options, options[val])) cw.append(rs) options = ["Normal", "Reverse"] rs = RadioSetting("cw_key_rev", "CW key reverse", RadioSettingValueList(options, options[_settings.cw_key_rev])) cw.append(rs) rs = RadioSetting("cw_paddle", "CW paddle", RadioSettingValueBoolean(_settings.cw_paddle)) cw.append(rs) options = ["%i Hz" % i for i in range(400,801,100)] rs = RadioSetting("cw_pitch", "CW pitch", RadioSettingValueList(options, options[_settings.cw_pitch])) cw.append(rs) options = ["%i ms" % i for i in range(5,31,5)] rs = RadioSetting("cw_qsk", "CW QSK", RadioSettingValueList(options, options[_settings.cw_qsk])) cw.append(rs) rs = RadioSetting("cw_sidetone", "CW sidetone volume", RadioSettingValueInteger(0, 100, _settings.cw_sidetone)) cw.append(rs) options = ["%i wpm" % i for i in range(4,61)] rs = RadioSetting("cw_speed", "CW speed", RadioSettingValueList(options, options[_settings.cw_speed])) cw.append(rs) options = ["Numeric", "Alphabet", "AlphaNumeric"] rs = RadioSetting("cw_training", "CW trainig", RadioSettingValueList(options, options[_settings.cw_training])) cw.append(rs) options = ["1:%1.1f" % (i/10) for i in range(25,46,1)] rs = RadioSetting("cw_weight", "CW weight", RadioSettingValueList(options, options[_settings.cw_weight])) cw.append(rs) options = ["Tn-Rn", "Tn-Riv", "Tiv-Rn", "Tiv-Riv"] rs = RadioSetting("dcs_inv", "DCS inv", RadioSettingValueList(options, options[_settings.dcs_inv])) extended.append(rs) options = ["Fine", "Coarse"] rs = RadioSetting("dial_step", "Dial step", RadioSettingValueList(options, options[_settings.dial_step])) panel.append(rs) rs = RadioSetting("dig_disp", "Dig disp (*10 Hz)", RadioSettingValueInteger(-300, 300, _settings.dig_disp)) packet.append(rs) rs = RadioSetting("dig_mic", "Dig gain", RadioSettingValueInteger(0, 100, _settings.dig_mic)) packet.append(rs) options = ["RTTYL", "RTTYU", "PSK31-L", "PSK31-U", "USER-L", "USER-U"] rs = RadioSetting("dig_mode", "Dig mode", RadioSettingValueList(options, options[_settings.dig_mode])) packet.append(rs) rs = RadioSetting("dig_shift", "Dig shift (*10 Hz)", RadioSettingValueInteger(-300, 300, _settings.dig_shift)) packet.append(rs) rs = RadioSetting("dig_vox", "Dig vox", RadioSettingValueInteger(0, 100, _settings.dig_vox)) packet.append(rs) options = ["ARTS", "BAND", "FIX", "MEMGRP", "MODE", "MTR", "VFO"] rs = RadioSetting("disp_color", "Display color mode", RadioSettingValueList(options, options[_settings.disp_color])) panel.append(rs) rs = RadioSetting("disp_color_arts", "Display color ARTS set", RadioSettingValueInteger(0, 1,_settings.disp_color_arts)) panel.append(rs) rs = RadioSetting("disp_color_band", "Display color band set", RadioSettingValueInteger(0, 1,_settings.disp_color_band)) panel.append(rs) rs = RadioSetting("disp_color_memgrp", "Display color memory group set", RadioSettingValueInteger(0, 1,_settings.disp_color_memgrp)) panel.append(rs) rs = RadioSetting("disp_color_mode", "Display color mode set", RadioSettingValueInteger(0, 1,_settings.disp_color_mode)) panel.append(rs) rs = RadioSetting("disp_color_mtr", "Display color meter set", RadioSettingValueInteger(0, 1,_settings.disp_color_mtr)) panel.append(rs) rs = RadioSetting("disp_color_vfo", "Display color VFO set", RadioSettingValueInteger(0, 1,_settings.disp_color_vfo)) panel.append(rs) rs = RadioSetting("disp_color_fix", "Display color fix set", RadioSettingValueInteger(1, 32,_settings.disp_color_fix+1)) panel.append(rs) rs = RadioSetting("disp_contrast", "Contrast", RadioSettingValueInteger(3, 15,_settings.disp_contrast+2)) panel.append(rs) rs = RadioSetting("disp_intensity", "Intensity", RadioSettingValueInteger(1, 3,_settings.disp_intensity)) panel.append(rs) options = ["OFF", "Auto1", "Auto2", "ON"] rs = RadioSetting("disp_mode", "Display backlight mode", RadioSettingValueList(options, options[_settings.disp_mode])) panel.append(rs) options = ["60Hz", "120Hz", "240Hz"] rs = RadioSetting("dsp_bpf", "Dsp band pass filter", RadioSettingValueList(options, options[_settings.dsp_bpf])) cw.append(rs) options = ["100Hz", "160Hz", "220Hz", "280Hz", "340Hz", "400Hz", "460Hz", "520Hz", "580Hz", "640Hz", "720Hz", "760Hz", "820Hz", "880Hz", "940Hz", "1000Hz"] rs = RadioSetting("dsp_hpf", "Dsp hi pass filter cut off", RadioSettingValueList(options, options[_settings.dsp_hpf])) basic.append(rs) options = ["1000Hz", "1160Hz", "1320Hz", "1480Hz", "1650Hz", "1800Hz", "1970Hz", "2130Hz", "2290Hz", "2450Hz", "2610Hz", "2770Hz", "2940Hz", "3100Hz", "3260Hz", "3420Hz", "3580Hz", "3740Hz", "3900Hz", "4060Hz", "4230Hz", "4390Hz", "4550Hz", "4710Hz", "4870Hz", "5030Hz", "5190Hz", "5390Hz", "5520Hz", "5680Hz", "5840Hz", "6000Hz"] rs = RadioSetting("dsp_lpf", "Dsp low pass filter cut off", RadioSettingValueList(options, options[_settings.dsp_lpf])) basic.append(rs) options = ["OFF", "LPF", "HPF", "BOTH"] rs = RadioSetting("dsp_mic_eq", "Dsp mic equalization", RadioSettingValueList(options, options[_settings.dsp_mic_eq])) basic.append(rs) rs = RadioSetting("dsp_nr", "DSP noise reduction level", RadioSettingValueInteger(1, 16, _settings.dsp_nr+1)) basic.append(rs) # emergency only for US model rs = RadioSetting("fm_mic", "FM mic gain", RadioSettingValueInteger(0, 100, _settings.fm_mic)) basic.append(rs) rs = RadioSetting("home_vfo", "Enable HOME to VFO moving", RadioSettingValueBoolean(_settings.home_vfo)) panel.append(rs) options = ["Dial", "Freq", "Panel", "All"] rs = RadioSetting("lock_mode", "Lock mode", RadioSettingValueList(options, options[_settings.lock_mode])) panel.append(rs) rs = RadioSetting("mem_group", "Mem group", RadioSettingValueBoolean(_settings.mem_group)) basic.append(rs) options = ["CW SIDETONE", "CW SPEED", "MHz/MEM GRP", "MIC GAIN", "NB LEVEL", "RF POWER", "STEP"] rs = RadioSetting("mem_vfo_dial_mode", "Mem/VFO dial mode", RadioSettingValueList(options, options[_settings.mem_vfo_dial_mode])) panel.append(rs) rs = RadioSetting("mic_scan", "Mic scan", RadioSettingValueBoolean(_settings.mic_scan)) basic.append(rs) options = ["NOR", "RMT", "CAT"] rs = RadioSetting("mic_sel", "Mic selection", RadioSettingValueList(options, options[_settings.mic_sel])) extended.append(rs) options = ["SIG", "CTR", "VLT", "N/A", "FS", "OFF"] rs = RadioSetting("mtr_arx_sel", "Meter receive selection", RadioSettingValueList(options, options[_settings.mtr_arx_sel])) extended.append(rs) options = ["PWR", "ALC", "MOD", "SWR", "VLT", "N/A", "OFF"] rs = RadioSetting("mtr_atx_sel", "Meter transmit selection", RadioSettingValueList(options, options[_settings.mtr_atx_sel])) extended.append(rs) rs = RadioSetting("mtr_peak_hold", "Meter peak hold", RadioSettingValueBoolean(_settings.mtr_peak_hold)) extended.append(rs) rs = RadioSetting("nb_level", "Noise blanking level", RadioSettingValueInteger(0, 100, _settings.nb_level)) basic.append(rs) s = RadioSettingValueString(0, 4, ''.join([self._CALLSIGN_CHARSET[x] for x in self._memobj.op_filter1_name])) s.set_charset(self._CALLSIGN_CHARSET) rs = RadioSetting("op_filter1_name", "Optional filter1 name", s) extended.append(rs) s = RadioSettingValueString(0, 4, ''.join([self._CALLSIGN_CHARSET[x] for x in self._memobj.op_filter2_name])) s.set_charset(self._CALLSIGN_CHARSET) rs = RadioSetting("op_filter2_name", "Optional filter2 name", s) extended.append(rs) rs = RadioSetting("pg_a", "Programmable key MFq:A", RadioSettingValueList(self.PROGRAMMABLEOPTIONS, self.PROGRAMMABLEOPTIONS[_settings.pg_a])) extended.append(rs) rs = RadioSetting("pg_b", "Programmable key MFq:B", RadioSettingValueList(self.PROGRAMMABLEOPTIONS, self.PROGRAMMABLEOPTIONS[_settings.pg_b])) extended.append(rs) rs = RadioSetting("pg_c", "Programmable key MFq:C", RadioSettingValueList(self.PROGRAMMABLEOPTIONS, self.PROGRAMMABLEOPTIONS[_settings.pg_c])) extended.append(rs) rs = RadioSetting("pg_acc", "Programmable mic key ACC", RadioSettingValueList(self.PROGRAMMABLEOPTIONS, self.PROGRAMMABLEOPTIONS[_settings.pg_acc])) extended.append(rs) rs = RadioSetting("pg_p1", "Programmable mic key P1", RadioSettingValueList(self.PROGRAMMABLEOPTIONS, self.PROGRAMMABLEOPTIONS[_settings.pg_p1])) extended.append(rs) rs = RadioSetting("pg_p2", "Programmable mic key P2", RadioSettingValueList(self.PROGRAMMABLEOPTIONS, self.PROGRAMMABLEOPTIONS[_settings.pg_p2])) extended.append(rs) rs = RadioSetting("pkt1200", "Packet 1200 gain level", RadioSettingValueInteger(0, 100, _settings.pkt1200)) packet.append(rs) rs = RadioSetting("pkt9600", "Packet 9600 gain level", RadioSettingValueInteger(0, 100, _settings.pkt9600)) packet.append(rs) options = ["1200", "9600"] rs = RadioSetting("pkt_rate", "Packet rate", RadioSettingValueList(options, options[_settings.pkt_rate])) packet.append(rs) rs = RadioSetting("proc_level", "Proc level", RadioSettingValueInteger(0, 100, _settings.proc_level)) basic.append(rs) rs = RadioSetting("rf_power_hf", "Rf power set HF", RadioSettingValueInteger(5, 100, _settings.rf_power_hf)) basic.append(rs) rs = RadioSetting("rf_power_6m", "Rf power set 6m", RadioSettingValueInteger(5, 100, _settings.rf_power_6m)) basic.append(rs) rs = RadioSetting("rf_power_vhf", "Rf power set VHF", RadioSettingValueInteger(5, 50, _settings.rf_power_vhf)) basic.append(rs) rs = RadioSetting("rf_power_uhf", "Rf power set UHF", RadioSettingValueInteger(2, 20, _settings.rf_power_uhf)) basic.append(rs) options = ["TIME", "BUSY", "STOP"] rs = RadioSetting("scan_mode", "Scan mode", RadioSettingValueList(options, options[_settings.scan_mode])) basic.append(rs) rs = RadioSetting("scan_resume", "Scan resume", RadioSettingValueInteger(1, 10, _settings.scan_resume)) basic.append(rs) rs = RadioSetting("split_tone", "Split tone enable", RadioSettingValueBoolean(_settings.split_tone)) extended.append(rs) options = ["RF-Gain", "Squelch"] rs = RadioSetting("sql_rf_gain", "Squelch/RF-Gain", RadioSettingValueList(options, options[_settings.sql_rf_gain])) panel.append(rs) rs = RadioSetting("ssb_mic", "SSB Mic gain", RadioSettingValueInteger(0, 100, _settings.ssb_mic)) basic.append(rs) options = ["Off"]+["%i" % i for i in range(1, 21)] rs = RadioSetting("tot_time", "Time-out timer", RadioSettingValueList(options, options[_settings.tot_time])) basic.append(rs) options = ["OFF", "ATAS(HF)", "ATAS(HF&50)", "ATAS(ALL)", "TUNER"] rs = RadioSetting("tuner_atas", "Tuner/ATAS device", RadioSettingValueList(options, options[_settings.tuner_atas])) extended.append(rs) rs = RadioSetting("tx_if_filter", "Transmit IF filter", RadioSettingValueList(self.FILTERS, self.FILTERS[_settings.tx_if_filter])) basic.append(rs) rs = RadioSetting("vox_delay", "VOX delay (*100 ms)", RadioSettingValueInteger(1, 30, _settings.vox_delay)) basic.append(rs) rs = RadioSetting("vox_gain", "VOX Gain", RadioSettingValueInteger(1, 100, _settings.vox_gain)) basic.append(rs) rs = RadioSetting("xvtr_a", "Xvtr A displacement", RadioSettingValueInteger(-4294967295, 4294967295, self._memobj.xvtr_a_offset * (-1 if _settings.xvtr_a_negative else 1))) extended.append(rs) rs = RadioSetting("xvtr_b", "Xvtr B displacement", RadioSettingValueInteger(-4294967295, 4294967295, self._memobj.xvtr_b_offset * (-1 if _settings.xvtr_b_negative else 1))) extended.append(rs) options = ["OFF", "XVTR A", "XVTR B"] rs = RadioSetting("xvtr_sel", "Transverter function selection", RadioSettingValueList(options, options[_settings.xvtr_sel])) extended.append(rs) rs = RadioSetting("disp", "Display large", RadioSettingValueBoolean(_settings.disp)) panel.append(rs) rs = RadioSetting("nb", "Noise blanker", RadioSettingValueBoolean(_settings.nb)) panelcontr.append(rs) options = ["Auto", "Fast", "Slow", "Off"] rs = RadioSetting("agc", "AGC", RadioSettingValueList(options, options[_settings.agc])) panelcontr.append(rs) options = ["PWR", "ALC", "SWR", "MOD"] rs = RadioSetting("pwr_meter_mode", "Power meter mode", RadioSettingValueList(options, options[_settings.pwr_meter_mode])) panelcontr.append(rs) rs = RadioSetting("vox", "Vox", RadioSettingValueBoolean(_settings.vox)) panelcontr.append(rs) rs = RadioSetting("bk", "Semi break-in", RadioSettingValueBoolean(_settings.bk)) cw.append(rs) rs = RadioSetting("kyr", "Keyer", RadioSettingValueBoolean(_settings.kyr)) cw.append(rs) options = ["enabled", "disabled"] rs = RadioSetting("fst", "Fast", RadioSettingValueList(options, options[_settings.fst])) panelcontr.append(rs) options = ["enabled", "disabled"] rs = RadioSetting("lock", "Lock", RadioSettingValueList(options, options[_settings.lock])) panelcontr.append(rs) rs = RadioSetting("scope_peakhold", "Scope max hold", RadioSettingValueBoolean(_settings.scope_peakhold)) panelcontr.append(rs) options = ["21", "31", "127"] rs = RadioSetting("scope_width", "Scope width (channels)", RadioSettingValueList(options, options[_settings.scope_width])) panelcontr.append(rs) rs = RadioSetting("proc", "Speech processor", RadioSettingValueBoolean(_settings.proc)) panelcontr.append(rs) return top
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic Settings") front_panel = RadioSettingGroup("front_panel", "Front Panel Settings") top = RadioSettings(basic, front_panel) # Transmit timeout opt = ['Disabled', '1 minute'] + \ [s + ' minutes' for s in map(str, range(2, 31))] rs = RadioSetting("tx_timeout", "Transmit timeout (min)", RadioSettingValueList(opt, opt[ _settings.tx_timeout ])) basic.append(rs) # Auto Repeater (USA model only) opt = ["Disabled", "Duplex Only", "Duplex and tone"] rs = RadioSetting("auto_repeater", "Auto repeater", RadioSettingValueList(opt, opt[ _settings.auto_repeater ])) basic.append(rs) # Auto Power Off opt = ["Disabled", "30 minutes", "60 minutes", "120 minutes"] rs = RadioSetting("auto_power_off", "Auto power off", RadioSettingValueList(opt, opt[ _settings.auto_power_off ])) basic.append(rs) # Squelch Delay opt = ["Short", "Long"] rs = RadioSetting("squelch_delay", "Squelch delay", RadioSettingValueList(opt, opt[ _settings.squelch_delay ])) basic.append(rs) # Squelch Type opt = ["Noise squelch", "S-meter squelch", "Squelch attenuator"] rs = RadioSetting("squelch_type", "Squelch type", RadioSettingValueList(opt, opt[ _settings.squelch_type ])) basic.append(rs) # Repeater Lockout opt = ["Disabled", "Repeater lockout", "Busy lockout"] rs = RadioSetting("repeater_lockout", "Repeater lockout", RadioSettingValueList(opt, opt[ _settings.repeater_lockout ])) basic.append(rs) # DTMF Speed opt = ["100ms interval, 5.0 cps", "200ms interval, 2.5 cps", "300ms interval, 1.6 cps", "500ms interval, 1.0 cps"] rs = RadioSetting("dtmf_speed", "DTMF speed", RadioSettingValueList(opt, opt[ _settings.dtmf_speed ])) basic.append(rs) # Scan pause timer opt = [s + ' seconds' for s in map(str, range(2, 22, 2))] + ['Hold'] rs = RadioSetting("scan_pause_timer", "Scan pause timer", RadioSettingValueList( opt, opt[_settings.scan_pause_timer])) basic.append(rs) # Scan Resume Timer opt = ['Immediate'] + \ [s + ' seconds' for s in map(str, range(1, 6))] + ['Hold'] rs = RadioSetting("scan_resume_timer", "Scan resume timer", RadioSettingValueList( opt, opt[_settings.scan_resume_timer])) basic.append(rs) # Weather Alert (USA model only) rs = RadioSetting("weather_alert", "Weather alert", RadioSettingValueBoolean(_settings.weather_alert)) basic.append(rs) # Tone Burst rs = RadioSetting("tone_burst", "Tone burst", RadioSettingValueBoolean(_settings.tone_burst)) basic.append(rs) # Memory Display Type opt = ["Frequency", "Channel", "Name"] rs = RadioSetting("display_type", "Memory display", RadioSettingValueList(opt, opt[_settings.display_type])) front_panel.append(rs) # Display backlight brightness; opt = ["1 (dimmest)", "2", "3", "4 (brightest)"] rs = RadioSetting("display_brightness", "Backlight brightness", RadioSettingValueList( opt, opt[_settings.display_brightness])) front_panel.append(rs) # Display backlight color opt = ["Amber", "Yellow", "Green"] rs = RadioSetting("display_color", "Backlight color", RadioSettingValueList(opt, opt[_settings.display_color])) front_panel.append(rs) # Display contrast opt = ["1 (lightest)", "2", "3", "4 (darkest)"] rs = RadioSetting("display_contrast", "Display contrast", RadioSettingValueList( opt, opt[_settings.display_contrast])) front_panel.append(rs) # Auto dimmer opt = ["Disabled", "Backlight off", "1 (dimmest)", "2", "3"] rs = RadioSetting("auto_dimmer", "Auto dimmer", RadioSettingValueList(opt, opt[_settings.auto_dimmer])) front_panel.append(rs) # Microphone gain opt = ["Low", "High"] rs = RadioSetting("mic_gain", "Microphone gain", RadioSettingValueList(opt, opt[_settings.mic_gain])) front_panel.append(rs) # Key press beep rs = RadioSetting("key_beep", "Key press beep", RadioSettingValueBoolean(_settings.key_beep)) front_panel.append(rs) # Voltage Display; rs = RadioSetting("voltage_display", "Voltage display", RadioSettingValueBoolean(_settings.voltage_display)) front_panel.append(rs) # TODO: Add Bank Links settings to GUI 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): """Translate the MEM_FORMAT structs into settings in the UI""" # Define mem struct write-back shortcuts _sets = self._memobj.settings _asf = self._memobj.asf _ssf = self._memobj.ssf _mex = self._memobj.exset _chm = self._memobj.ch_mem basic = RadioSettingGroup("basic", "Basic Settings") pvfo = RadioSettingGroup("pvfo", "VFO Band Edges") mena = RadioSettingGroup("mena", "Menu A") menb = RadioSettingGroup("menb", "Menu B") amode = RadioSettingGroup("amode", "Auto Mode") ssc = RadioSettingGroup("ssc", "Slow Scan") group = RadioSettings(basic, pvfo, mena, menb, amode, ssc) mhz1 = 1000000. # Callback functions def _my_readonly(setting, obj, atrb): """NOP callback, prevents writing the setting""" vx = 0 return def my_adjraw(setting, obj, atrb, fix=0, ndx=-1): """Callback for Integer add or subtract fix from value.""" vx = int(str(setting.value)) value = vx + int(fix) if value < 0: value = 0 if ndx < 0: setattr(obj, atrb, value) else: setattr(obj[ndx], atrb, value) return def my_mhz_val(setting, obj, atrb, ndx=-1): """ Callback to set freq back to Htz""" vx = float(str(setting.value)) vx = int(vx * mhz1) if ndx < 0: setattr(obj, atrb, vx) else: setattr(obj[ndx], atrb, vx) return def my_bool(setting, obj, atrb, ndx=-1): """ Callback to properly set boolean """ # set_settings is not setting [indexed] booleans??? vx = 0 if str(setting.value) == "True": vx = 1 if ndx < 0: setattr(obj, atrb, vx) else: setattr(obj[ndx], atrb, vx) return def my_asf_mode(setting, obj, nx=0): """ Callback to extract mode and create asmode, asdata """ v1 = TS480_MODES.index(str(setting.value)) v2 = 0 # asdata vx = v1 + 1 # stored as CAT values, same as xmode if v1 == 7: vx = 9 if v1 > 7: # a Data mode v2 = 1 if v1 == 8: vx = 1 # LSB elif v1 == 9: vx = 2 # USB elif v1 == 10: vx = 4 # FM setattr(obj[nx], "asdata", v2) setattr(obj[nx], "asmode", vx) return def my_fnctns(setting, obj, ndx, atrb): """ Filter only valid key function assignments """ vx = int(str(setting.value)) if vx > 79: vx = 99 # Off setattr(obj[ndx], atrb, vx) return def my_labels(kx): lbl = "%03i:" % kx # SG EX number lbl += self.EX_LBL[kx] # and the label to match return lbl # ===== BASIC GROUP ===== options = [ "TS-480HX (200W)", "TS-480SAT (100W + AT)", "Japanese 50W type", "Japanese 20W type" ] rx = RadioSettingValueString(14, 22, options[_sets.ty]) rset = RadioSetting("settings.ty", "FirmwareVersion", rx) rset.set_apply_callback(_my_readonly, _sets, "ty") basic.append(rset) rx = RadioSettingValueInteger(0, 255, _sets.ag) rset = RadioSetting("settings.ag", "AF Gain", rx) # rset.set_apply_callback(my_adjraw, _sets, "ag", -1) basic.append(rset) rx = RadioSettingValueInteger(0, 100, _sets.rg) rset = RadioSetting("settings.rg", "RF Gain", rx) # rset.set_apply_callback(my_adjraw, _sets, "rg", -1) basic.append(rset) options = ["ANT1", "ANT2"] # CAUTION: an has value of 1 or 2 rx = RadioSettingValueList(options, options[_sets.an - 1]) rset = RadioSetting("settings.an", "Antenna Selected", rx) # Add 1 to the changed value. S/b 1/2 rset.set_apply_callback(my_val_list, options, _sets, "an", 1) basic.append(rset) rx = RadioSettingValueInteger(0, 100, _sets.mg) rset = RadioSetting("settings.mg", "Microphone gain", rx) basic.append(rset) nx = 5 # Coarse step if bool(_mex[0].ex021): # Power Fine enabled in menu A nx = 1 vx = _sets.pc # Trap invalid values from run_tests.py if vx < 5: vx = 5 options = [200, 100, 50, 20] # subject to firmware rx = RadioSettingValueInteger(5, options[_sets.ty], vx, nx) sx = "TX Output power (Watts)" rset = RadioSetting("settings.pc", sx, rx) basic.append(rset) val = _sets.fa / mhz1 # valid range is for receiver rx = RadioSettingValueFloat(0.05, 60.0, val, 0.001, 3) sx = "VFO-A Frequency (MHz)" rset = RadioSetting("settings.fa", sx, rx) rset.set_apply_callback(my_mhz_val, _sets, "fa") basic.append(rset) val = _sets.fb / mhz1 rx = RadioSettingValueFloat(0.05, 60.0, val, 0.001, 3) sx = "VFO-B Frequency (MHz)" rset = RadioSetting("settings.fb", sx, rx) rset.set_apply_callback(my_mhz_val, _sets, "fb") basic.append(rset) options = ["Menu A", "Menu B"] rx = RadioSettingValueList(options, options[_sets.mf]) sx = "Menu Selected" rset = RadioSetting("settings.mf", sx, rx) rset.set_apply_callback(my_val_list, options, _sets, "mf") basic.append(rset) # ==== VFO Edges Group ================ for mx in range(100, 110): val = _chm[mx].rxfreq / mhz1 if val < 1.8: # Many operators never use this val = 1.8 # So default is 0.0 rx = RadioSettingValueFloat(1.8, 54.0, val, 0.001, 3) sx = "VFO-Band %i lower limit (MHz)" % (mx - 100) rset = RadioSetting("ch_mem.rxfreq/%d" % mx, sx, rx) rset.set_apply_callback(my_mhz_val, _chm, "rxfreq", mx) pvfo.append(rset) val = _chm[mx].txfreq / mhz1 if val < 1.8: val = 54.0 rx = RadioSettingValueFloat(1.8, 54.0, val, 0.001, 3) sx = " VFO-Band %i upper limit (MHz)" % (mx - 100) rset = RadioSetting("ch_mem.txfreq/%d" % mx, sx, rx) rset.set_apply_callback(my_mhz_val, _chm, "txfreq", mx) pvfo.append(rset) kx = _chm[mx].xmode options = [ "None", "LSB", "USB", "CW", "FM", "AM", "FSK", "CW-R", "N/A", "FSK-R" ] rx = RadioSettingValueList(options, options[kx]) sx = " VFO-Band %i Tx/Rx Mode" % (mx - 100) rset = RadioSetting("ch_mem.xmode/%d" % mx, sx, rx) rset.set_apply_callback(my_val_list, options, _chm, "xmode", 0, mx) pvfo.append(rset) # ==== Menu A/B Group ================= for mx in range(2): # A/B index sx = my_labels(0) rx = RadioSettingValueInteger(0, 4, _mex[mx].ex000) rset = RadioSetting("exset.ex000", sx, rx) if mx == 0: mena.append(rset) else: menb.append(rset) rx = RadioSettingValueInteger(0, 9, _mex[mx].ex012) sx = my_labels(12) rset = RadioSetting("exset.ex012", sx, rx) if mx == 0: mena.append(rset) else: menb.append(rset) sx = my_labels(13) rx = RadioSettingValueInteger(0, 9, _mex[mx].ex013) rset = RadioSetting("exset.ex013", sx, rx) if mx == 0: mena.append(rset) else: menb.append(rset) sx = my_labels(14) rx = RadioSettingValueInteger(0, 9, _mex[mx].ex014) rset = RadioSetting("exset.ex014", sx, rx) if mx == 0: mena.append(rset) else: menb.append(rset) options = ["250", "500", "1000"] rx = RadioSettingValueList(options, options[_mex[mx].ex003]) sx = my_labels(3) rset = RadioSetting("exset.ex003/%d" % mx, sx, rx) rset.set_apply_callback(my_val_list, options, _mex, "ex003", 0, mx) if mx == 0: mena.append(rset) else: menb.append(rset) rx = RadioSettingValueBoolean(bool(_mex[mx].ex007)) sx = my_labels(7) rset = RadioSetting("exset.ex007/%d" % mx, sx, rx) rset.set_apply_callback(my_bool, _mex, "ex007", mx) if mx == 0: mena.append(rset) else: menb.append(rset) rx = RadioSettingValueBoolean(bool(_mex[mx].ex008)) sx = my_labels(8) rset = RadioSetting("exset.ex008/%d" % mx, sx, rx) rset.set_apply_callback(my_bool, _mex, "ex008", mx) if mx == 0: mena.append(rset) else: menb.append(rset) options = ["100", "200", "300", "400", "500"] rx = RadioSettingValueList(options, options[_mex[mx].ex009]) sx = my_labels(9) rset = RadioSetting("exset.ex009/%d" % mx, sx, rx) rset.set_apply_callback(my_val_list, options, _mex, "ex009", 0, mx) if mx == 0: mena.append(rset) else: menb.append(rset) rx = RadioSettingValueBoolean(bool(_mex[mx].ex010)) sx = my_labels(10) rset = RadioSetting("exset.ex010/%d" % mx, sx, rx) rset.set_apply_callback(my_bool, _mex, "ex010", mx) if mx == 0: mena.append(rset) else: menb.append(rset) options = ["TO", "CO"] rx = RadioSettingValueList(options, options[_mex[mx].ex011]) sx = my_labels(11) rset = RadioSetting("exset.ex011/%d" % mx, sx, rx) rset.set_apply_callback(my_val_list, options, _mex, "ex011", 0, mx) if mx == 0: mena.append(rset) else: menb.append(rset) rx = RadioSettingValueBoolean(bool(_mex[mx].ex021)) sx = my_labels(21) rset = RadioSetting("exset.ex021/%d" % mx, sx, rx) rset.set_apply_callback(my_bool, _mex, "ex021", mx) if mx == 0: mena.append(rset) else: menb.append(rset) options = ["Off", "3", "5", "10", "20", "30"] rx = RadioSettingValueList(options, options[_mex[mx].ex022]) sx = my_labels(22) rset = RadioSetting("exset.ex022/%d" % mx, sx, rx) rset.set_apply_callback(my_val_list, options, _mex, "ex022", 0, mx) if mx == 0: mena.append(rset) else: menb.append(rset) rx = RadioSettingValueInteger(0, 99, _mex[mx].ex048) sx = my_labels(48) rset = RadioSetting("exset.ex048/%d" % mx, sx, rx) rset.set_apply_callback(my_fnctns, _mex, mx, "ex048") if mx == 0: mena.append(rset) else: menb.append(rset) rx = RadioSettingValueInteger(0, 99, _mex[mx].ex049) sx = my_labels(49) rset = RadioSetting("exset.ex049/%d" % mx, sx, rx) rset.set_apply_callback(my_fnctns, _mex, mx, "ex049") if mx == 0: mena.append(rset) else: menb.append(rset) rx = RadioSettingValueInteger(0, 99, _mex[mx].ex050) sx = my_labels(50) rset = RadioSetting("exset.ex050/%d" % mx, sx, rx) rset.set_apply_callback(my_fnctns, _mex, mx, "ex050") if mx == 0: mena.append(rset) else: menb.append(rset) rx = RadioSettingValueInteger(0, 99, _mex[mx].ex051) sx = my_labels(51) rset = RadioSetting("exset.ex051/%d" % mx, sx, rx) rset.set_apply_callback(my_fnctns, _mex, mx, "ex051") if mx == 0: mena.append(rset) else: menb.append(rset) rx = RadioSettingValueInteger(0, 99, _mex[mx].ex052) sx = my_labels(52) rset = RadioSetting("exset.ex052/%d" % mx, sx, rx) rset.set_apply_callback(my_fnctns, _mex, mx, "ex052") if mx == 0: mena.append(rset) else: menb.append(rset) # End of for mx loop # ==== Auto Scan Params (amode) ============== for ix in range(32): val = _asf[ix].asfreq / mhz1 rx = RadioSettingValueFloat(0.03, 60.0, val, 0.001, 3) rset = RadioSetting("asf.asfreq/%d" % ix, "Scan %02i Freq (MHz)" % ix, rx) rset.set_apply_callback(my_mhz_val, _asf, "asfreq", ix) amode.append(rset) mx = _asf[ix].asmode - 1 # Same logic as xmode if _asf[ix].asmode == 9: mx = 7 rx = RadioSettingValueList(TS480_MODES, TS480_MODES[mx]) rset = RadioSetting("asf.asmode/%d" % ix, " Mode", rx) rset.set_apply_callback(my_asf_mode, _asf, ix) amode.append(rset) # ==== Slow Scan Settings === for ix in range(10): # Chans for nx in range(5): # spots px = ((ix * 5) + nx) val = _ssf[px].ssfreq / mhz1 stx = " - - - Slot %02i Freq (MHz)" % nx if nx == 0: stx = "Slow Scan %02i, Slot 0 Freq (MHz" % ix rx = RadioSettingValueFloat(0, 54.0, val, 0.001, 3) rset = RadioSetting("ssf.ssfreq/%d" % px, stx, rx) rset.set_apply_callback(my_mhz_val, _ssf, "ssfreq", px) ssc.append(rset) return group # END get_settings()
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic") 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): _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_settings(self): _settings = self._memobj.settings _info = self._memobj.info _bandlimits = self._memobj.bandlimits basic = RadioSettingGroup("basic", "Basic") info = RadioSettingGroup("info", "Model Info") top = RadioSettings(basic, info) basic.append(RadioSetting( "beep", "Beep", RadioSettingValueBoolean(_settings.beep))) basic.append(RadioSetting( "beep_vol", "Beep Volume", RadioSettingValueInteger(0, 15, _settings.beep_vol))) basic.append(RadioSetting( "keylock", "Key Lock", RadioSettingValueBoolean(_settings.keylock))) basic.append(RadioSetting( "ani_display", "ANI Display", RadioSettingValueBoolean(_settings.ani_display))) basic.append(RadioSetting( "auto_xfer", "Auto Transfer", RadioSettingValueBoolean(_settings.auto_xfer))) basic.append(RadioSetting( "auto_contact", "Auto Contact Always Remind", RadioSettingValueBoolean(_settings.auto_contact))) basic.append(RadioSetting( "auto_am", "Auto AM", RadioSettingValueBoolean(_settings.auto_am))) basic.append(RadioSetting( "left_sql", "Left Squelch", RadioSettingValueList( SQLPRESET, SQLPRESET[_settings.left_sql]))) basic.append(RadioSetting( "right_sql", "Right Squelch", RadioSettingValueList( SQLPRESET, SQLPRESET[_settings.right_sql]))) # basic.append(RadioSetting("apo", "Auto Power off (0.1h)", # RadioSettingValueInteger(0, 20, _settings.apo))) opts = ["Off"] + ["%0.1f" % (t / 10.0) for t in range(1, 21, 1)] basic.append(RadioSetting( "apo", "Auto Power off (Hours)", RadioSettingValueList(opts, opts[_settings.apo]))) opts = ["Off", "1", "2", "3", "Full"] basic.append(RadioSetting( "backlight", "Display Backlight", RadioSettingValueList(opts, opts[_settings.backlight]))) opts = ["Off", "Right", "Left", "Both"] basic.append(RadioSetting( "pttlock", "PTT Lock", RadioSettingValueList(opts, opts[_settings.pttlock]))) opts = ["Manual", "Auto"] basic.append(RadioSetting( "hyper_chan", "Hyper Channel", RadioSettingValueList(opts, opts[_settings.hyper_chan]))) opts = ["Key 1", "Key 2"] basic.append(RadioSetting( "right_func_key", "Right Function Key", RadioSettingValueList(opts, opts[_settings.right_func_key]))) opts = ["1000Hz", "1450Hz", "1750Hz", "2100Hz"] basic.append(RadioSetting( "tbst_freq", "Tone Burst Frequency", RadioSettingValueList(opts, opts[_settings.tbst_freq]))) opts = ["Off", "TX", "RX", "TX RX"] basic.append(RadioSetting( "mute_mode", "Mute Mode", RadioSettingValueList(opts, opts[_settings.mute_mode]))) opts = ["MEM", "MSM"] scanmode = RadioSetting( "scan_mode", "Scan Mode", RadioSettingValueList(opts, opts[_settings.scan_mode])) scanmode.set_doc("MEM = Normal scan, bypass channels marked skip. " " MSM = Scan only channels marked priority.") basic.append(scanmode) opts = ["TO", "CO"] basic.append(RadioSetting( "scan_resume", "Scan Resume", RadioSettingValueList(opts, opts[_settings.scan_resume]))) opts = ["%0.1f" % (t / 10.0) for t in range(0, 51, 1)] basic.append(RadioSetting( "exit_delay", "Span Transit Exit Delay", RadioSettingValueList(opts, opts[_settings.exit_delay]))) basic.append(RadioSetting( "tot", "Time Out Timer (minutes)", RadioSettingValueInteger(0, 30, _settings.tot))) basic.append(RadioSetting( "tot_alert", "Time Out Timer Pre Alert(seconds)", RadioSettingValueInteger(0, 15, _settings.tot_alert))) basic.append(RadioSetting( "tot_rekey", "Time Out Rekey (seconds)", RadioSettingValueInteger(0, 15, _settings.tot_rekey))) basic.append(RadioSetting( "tot_reset", "Time Out Reset(seconds)", RadioSettingValueInteger(0, 15, _settings.tot_reset))) basic.append(RadioSetting( "p1", "P1 Function", RadioSettingValueList(MICKEYFUNC, MICKEYFUNC[_settings.p1]))) basic.append(RadioSetting( "p2", "P2 Function", RadioSettingValueList(MICKEYFUNC, MICKEYFUNC[_settings.p2]))) basic.append(RadioSetting( "p3", "P3 Function", RadioSettingValueList(MICKEYFUNC, MICKEYFUNC[_settings.p3]))) basic.append(RadioSetting( "p4", "P4 Function", RadioSettingValueList(MICKEYFUNC, MICKEYFUNC[_settings.p4]))) # opts = ["0", "1"] # basic.append(RadioSetting("x", "Desc", # RadioSettingValueList(opts, opts[_settings.x]))) def _filter(name): filtered = "" for char in str(name): if char in chirp_common.CHARSET_ASCII: filtered += char else: filtered += " " return filtered rsvs = RadioSettingValueString(0, 8, _filter(_info.sn)) rsvs.set_mutable(False) rs = RadioSetting("sn", "Serial Number", rsvs) info.append(rs) rsvs = RadioSettingValueString(0, 8, _filter(_info.model)) rsvs.set_mutable(False) rs = RadioSetting("model", "Model Name", rsvs) info.append(rs) rsvs = RadioSettingValueString(0, 16, _filter(_info.code)) rsvs.set_mutable(False) rs = RadioSetting("code", "Model Code", rsvs) info.append(rs) progdate = "%d/%d/%d" % (_info.prog_mon, _info.prog_day, _info.prog_yr) rsvs = RadioSettingValueString(0, 10, progdate) rsvs.set_mutable(False) rs = RadioSetting("progdate", "Last Program Date", rsvs) info.append(rs) # 9 band limits for i in range(0, 9): objname = BANDS[i] + "lorx" objnamepp = BANDS[i] + " Rx Start" # rsv = RadioSettingValueInteger(0, 100000000, # int(_bandlimits[i].lorx)) rsv = RadioSettingValueString( 0, 10, format_freq(int(_bandlimits[i].lorx)*10)) rsv.set_mutable(False) rs = RadioSetting(objname, objnamepp, rsv) info.append(rs) objname = BANDS[i] + "hirx" objnamepp = BANDS[i] + " Rx end" rsv = RadioSettingValueString( 0, 10, format_freq(int(_bandlimits[i].hirx)*10)) rsv.set_mutable(False) rs = RadioSetting(objname, objnamepp, rsv) info.append(rs) objname = BANDS[i] + "lotx" objnamepp = BANDS[i] + " Tx Start" rsv = RadioSettingValueString( 0, 10, format_freq(int(_bandlimits[i].lotx)*10)) rsv.set_mutable(False) rs = RadioSetting(objname, objnamepp, rsv) info.append(rs) objname = BANDS[i] + "hitx" objnamepp = BANDS[i] + " Tx end" rsv = RadioSettingValueString( 0, 10, format_freq(int(_bandlimits[i].hitx)*10)) rsv.set_mutable(False) rs = RadioSetting(objname, objnamepp, rsv) info.append(rs) return top
def get_settings(self): """Translate the bit in the mem_struct into settings in the UI""" _mem = self._memobj basic = RadioSettingGroup("basic", "Basic Settings") advanced = RadioSettingGroup("advanced", "Advanced Settings") other = RadioSettingGroup("other", "Other Settings") work = RadioSettingGroup("work", "Work Mode Settings") fm_preset = RadioSettingGroup("fm_preset", "FM Preset") dtmfe = RadioSettingGroup("dtmfe", "DTMF Encode Settings") service = RadioSettingGroup("service", "Service Settings") top = RadioSettings(basic, advanced, other, work, fm_preset, dtmfe, service) # Basic settings if _mem.settings.squelch > 0x09: val = 0x00 else: val = _mem.settings.squelch rs = RadioSetting("settings.squelch", "Squelch", RadioSettingValueList( LIST_OFF1TO9, LIST_OFF1TO9[val])) basic.append(rs) if _mem.settings.save > 0x04: val = 0x00 else: val = _mem.settings.save rs = RadioSetting("settings.save", "Battery Saver", RadioSettingValueList( LIST_SAVE, LIST_SAVE[val])) basic.append(rs) if _mem.settings.vox > 0x0A: val = 0x00 else: val = _mem.settings.vox rs = RadioSetting("settings.vox", "Vox", RadioSettingValueList( LIST_OFF1TO10, LIST_OFF1TO10[val])) basic.append(rs) if _mem.settings.abr > 0x0A: val = 0x00 else: val = _mem.settings.abr rs = RadioSetting("settings.abr", "Backlight Timeout", RadioSettingValueList( LIST_OFF1TO10, LIST_OFF1TO10[val])) basic.append(rs) rs = RadioSetting("settings.tdr", "Dual Watch", RadioSettingValueBoolean(_mem.settings.tdr)) basic.append(rs) rs = RadioSetting("settings.beep", "Beep", RadioSettingValueBoolean(_mem.settings.beep)) basic.append(rs) if _mem.settings.timeout > 0x27: val = 0x03 else: val = _mem.settings.timeout rs = RadioSetting("settings.timeout", "Timeout Timer", RadioSettingValueList( LIST_TIMEOUT, LIST_TIMEOUT[val])) basic.append(rs) if _mem.settings.voice > 0x02: val = 0x01 else: val = _mem.settings.voice rs = RadioSetting("settings.voice", "Voice Prompt", RadioSettingValueList( LIST_VOICE, LIST_VOICE[val])) basic.append(rs) rs = RadioSetting("settings.dtmfst", "DTMF Sidetone", RadioSettingValueList(LIST_DTMFST, LIST_DTMFST[ _mem.settings.dtmfst])) basic.append(rs) if _mem.settings.screv > 0x02: val = 0x01 else: val = _mem.settings.screv rs = RadioSetting("settings.screv", "Scan Resume", RadioSettingValueList( LIST_RESUME, LIST_RESUME[val])) basic.append(rs) rs = RadioSetting("settings.pttid", "When to send PTT ID", RadioSettingValueList(LIST_PTTID, LIST_PTTID[ _mem.settings.pttid])) basic.append(rs) if _mem.settings.pttlt > 0x1E: val = 0x05 else: val = _mem.settings.pttlt rs = RadioSetting("pttlt", "PTT ID Delay", RadioSettingValueInteger(0, 50, val)) basic.append(rs) rs = RadioSetting("settings.mdfa", "Display Mode (A)", RadioSettingValueList(LIST_MODE, LIST_MODE[ _mem.settings.mdfa])) basic.append(rs) rs = RadioSetting("settings.mdfb", "Display Mode (B)", RadioSettingValueList(LIST_MODE, LIST_MODE[ _mem.settings.mdfb])) basic.append(rs) rs = RadioSetting("settings.autolk", "Automatic Key Lock", RadioSettingValueBoolean(_mem.settings.autolk)) basic.append(rs) rs = RadioSetting("settings.wtled", "Standby LED Color", RadioSettingValueList( LIST_COLOR, LIST_COLOR[_mem.settings.wtled])) basic.append(rs) rs = RadioSetting("settings.rxled", "RX LED Color", RadioSettingValueList( LIST_COLOR, LIST_COLOR[_mem.settings.rxled])) basic.append(rs) rs = RadioSetting("settings.txled", "TX LED Color", RadioSettingValueList( LIST_COLOR, LIST_COLOR[_mem.settings.txled])) basic.append(rs) 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) # 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) 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) 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): value = chirp_common.parse_freq(value) msg = ("Can't be less than %i.0000") if value > 99000000 and value < 130 * 1000000: raise InvalidValueError(msg % (130)) msg = ("Can't be between %i.9975-%i.0000") if (179 + 1) * 1000000 <= value and value < 400 * 1000000: raise InvalidValueError(msg % (179, 400)) msg = ("Can't be greater than %i.9975") if value > 99000000 and value > (520 + 1) * 1000000: raise InvalidValueError(msg % (520)) return chirp_common.format_freq(value) def apply_freq(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 10 for i in range(7, -1, -1): obj.freq[i] = value % 10 value /= 10 val1a = RadioSettingValueString(0, 10, convert_bytes_to_freq(_mem.vfo.a.freq)) val1a.set_validate_callback(my_validate) rs = RadioSetting("vfo.a.freq", "VFO A Frequency", val1a) rs.set_apply_callback(apply_freq, _mem.vfo.a) work.append(rs) val1b = RadioSettingValueString(0, 10, convert_bytes_to_freq(_mem.vfo.b.freq)) val1b.set_validate_callback(my_validate) rs = RadioSetting("vfo.b.freq", "VFO B Frequency", val1b) rs.set_apply_callback(apply_freq, _mem.vfo.b) work.append(rs) rs = RadioSetting("vfo.a.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.txpower3", "VFO A Power", RadioSettingValueList( LIST_TXPOWER, LIST_TXPOWER[_mem.vfo.a.txpower3])) work.append(rs) rs = RadioSetting("vfo.b.txpower3", "VFO B Power", RadioSettingValueList( LIST_TXPOWER, LIST_TXPOWER[_mem.vfo.b.txpower3])) work.append(rs) rs = RadioSetting("vfo.a.widenarr", "VFO A Bandwidth", RadioSettingValueList( LIST_BANDWIDTH, LIST_BANDWIDTH[_mem.vfo.a.widenarr])) work.append(rs) rs = RadioSetting("vfo.b.widenarr", "VFO B Bandwidth", RadioSettingValueList( LIST_BANDWIDTH, LIST_BANDWIDTH[_mem.vfo.b.widenarr])) work.append(rs) rs = RadioSetting("vfo.a.scode", "VFO A S-CODE", RadioSettingValueList( LIST_SCODE, LIST_SCODE[_mem.vfo.a.scode])) work.append(rs) rs = RadioSetting("vfo.b.scode", "VFO B S-CODE", RadioSettingValueList( LIST_SCODE, LIST_SCODE[_mem.vfo.b.scode])) work.append(rs) rs = RadioSetting("vfo.a.step", "VFO A Tuning Step", RadioSettingValueList( LIST_STEP, LIST_STEP[_mem.vfo.a.step])) work.append(rs) rs = RadioSetting("vfo.b.step", "VFO B Tuning Step", RadioSettingValueList( LIST_STEP, LIST_STEP[_mem.vfo.b.step])) work.append(rs) # broadcast FM settings _fm_presets = self._memobj.fm_presets if _fm_presets <= 108.0 * 10 - 650: preset = _fm_presets / 10.0 + 65 elif _fm_presets >= 65.0 * 10 and _fm_presets <= 108.0 * 10: preset = _fm_presets / 10.0 else: preset = 76.0 rs = RadioSetting("fm_presets", "FM Preset(MHz)", RadioSettingValueFloat(65, 108.0, preset, 0.1, 1)) fm_preset.append(rs) # DTMF settings def apply_code(setting, obj, length): code = [] for j in range(0, length): try: code.append(DTMF_CHARS.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.code = code for i in range(0, 15): _codeobj = self._memobj.pttid[i].code _code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 5, _code, False) val.set_charset(DTMF_CHARS) pttid = RadioSetting("pttid/%i.code" % i, "Signal Code %i" % (i + 1), val) pttid.set_apply_callback(apply_code, self._memobj.pttid[i], 5) dtmfe.append(pttid) if _mem.ani.dtmfon > 0xC3: val = 0x03 else: val = _mem.ani.dtmfon rs = RadioSetting("ani.dtmfon", "DTMF Speed (on)", RadioSettingValueList(LIST_DTMFSPEED, LIST_DTMFSPEED[val])) dtmfe.append(rs) if _mem.ani.dtmfoff > 0xC3: val = 0x03 else: val = _mem.ani.dtmfoff rs = RadioSetting("ani.dtmfoff", "DTMF Speed (off)", RadioSettingValueList(LIST_DTMFSPEED, LIST_DTMFSPEED[val])) dtmfe.append(rs) _codeobj = self._memobj.ani.code _code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 5, _code, False) val.set_charset(DTMF_CHARS) rs = RadioSetting("ani.code", "ANI Code", val) rs.set_apply_callback(apply_code, self._memobj.ani, 5) dtmfe.append(rs) rs = RadioSetting("ani.aniid", "When to send ANI ID", RadioSettingValueList(LIST_PTTID, LIST_PTTID[_mem.ani.aniid])) dtmfe.append(rs) # Service settings for 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_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_memory(self, number): """Get the mem representation from the radio image""" bitpos = (1 << (number % 8)) bytepos = (number / 8) _mem = self._memory_obj()[number] _names = self._name_obj()[number] _scn = self._scan_obj()[bytepos] _usd = self._used_obj()[bytepos] isused = bitpos & int(_usd) isscan = bitpos & int(_scn) # Create a high-level memory object to return to the UI mem = chirp_common.Memory() # Memory number mem.number = number if not isused: mem.empty = True return mem # Freq and offset mem.freq = int(_mem.rxfreq) * 10 # tx freq can be blank if _mem.get_raw()[4] == "\xFF": # TX freq not set mem.offset = 0 mem.duplex = "off" else: # TX feq set offset = (int(_mem.txfreq) * 10) - mem.freq if offset < 0: mem.offset = abs(offset) mem.duplex = "-" elif offset > 0: mem.offset = offset mem.duplex = "+" else: mem.offset = 0 # skip if not isscan: mem.skip = "S" # name TAG of the channel mem.name = str(_names.name).strip("\xFF") # power mem.power = POWER_LEVELS[int(_mem.txp)] # wide/narrow mem.mode = MODES[int(_mem.wn)] # tone data rxtone = txtone = None txtone = self.decode_tone(_mem.txtone) rxtone = self.decode_tone(_mem.rxtone) chirp_common.split_tone_decode(mem, txtone, rxtone) # Extra mem.extra = RadioSettingGroup("extra", "Extra") bcl = RadioSetting("bcl", "Busy channel lockout", RadioSettingValueBoolean(bool(_mem.bcl))) mem.extra.append(bcl) revert = RadioSetting("revert", "Revert", RadioSettingValueBoolean(bool(_mem.revert))) mem.extra.append(revert) dname = RadioSetting("dname", "Display name", RadioSettingValueBoolean(bool(_mem.dname))) mem.extra.append(dname) return mem
def get_settings(self): _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): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic") dtmf = RadioSettingGroup("dtmf", "DTMF") arts = RadioSettingGroup("arts", "ARTS") prog = RadioSettingGroup("prog", "Programmable Buttons") top = RadioSettings(basic, dtmf, arts, prog) basic.append( RadioSetting("priority_revert", "Priority Revert", RadioSettingValueBoolean(_settings.priority_revert))) basic.append( RadioSetting("memory_only", "Memory Only mode", RadioSettingValueBoolean(_settings.memory_only))) 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]))) basic.append( RadioSetting("beep_scan", "Beep: Scan", RadioSettingValueBoolean(_settings.beep_scan))) basic.append( RadioSetting("beep_edge", "Beep: Edge", RadioSettingValueBoolean(_settings.beep_edge))) basic.append( RadioSetting("beep_key", "Beep: Key", RadioSettingValueBoolean(_settings.beep_key))) opts = ["T/RX Normal", "RX Reverse", "TX Reverse", "T/RX Reverse"] basic.append( RadioSetting( "dcs_polarity", "DCS polarity", RadioSettingValueList(opts, opts[_settings.dcs_polarity]))) opts = ["off", "dim 1", "dim 2", "dim 3"] basic.append( RadioSetting("dimmer", "Dimmer", RadioSettingValueList(opts, opts[_settings.dimmer]))) opts = ["manual", "auto", "1-auto"] basic.append( RadioSetting( "hyper_write", "Hyper Write", RadioSettingValueList(opts, opts[_settings.hyper_write]))) opts = [ "", "key", "dial", "key+dial", "ptt", "ptt+key", "ptt+dial", "all" ] basic.append( RadioSetting("lock", "Lock mode", RadioSettingValueList(opts, opts[_settings.lock]))) opts = ["MH-42", "MH-48"] basic.append( RadioSetting( "microphone_type", "Microphone Type", RadioSettingValueList(opts, opts[_settings.microphone_type]))) opts = ["off"] + ["S-%d" % n for n in range(2, 10)] + ["S-Full"] basic.append( RadioSetting("rf_sql", "RF Squelch", RadioSettingValueList(opts, opts[_settings.rf_sql]))) opts = ["time", "hold", "busy"] basic.append( RadioSetting( "scan_resume", "Scan Resume", RadioSettingValueList(opts, opts[_settings.scan_resume]))) opts = ["single", "continuous"] basic.append( RadioSetting( "smart_search", "Smart Search", RadioSettingValueList(opts, opts[_settings.smart_search]))) opts = ["off"] + ["%d" % t for t in range(1, 31)] basic.append( RadioSetting("tot", "Time-out timer (mins)", RadioSettingValueList(opts, opts[_settings.tot]))) # dtmf tab opts = ["50", "100", "250", "450", "750", "1000"] dtmf.append( RadioSetting( "dtmf_delay", "DTMF delay (ms)", RadioSettingValueList(opts, opts[_settings.dtmf_delay]))) opts = ["50", "75", "100"] dtmf.append( RadioSetting( "dtmf_speed", "DTMF speed (ms)", RadioSettingValueList(opts, opts[_settings.dtmf_speed]))) for i in range(16): name = "dtmf%02d" % i dtmfsetting = self._memobj.dtmf[i] dtmfstr = "" for c in dtmfsetting.memory: if c == 0xFF: break 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 opts = ["off", "in range", "always"] arts.append( RadioSetting( "arts_mode", "ARTS beep", RadioSettingValueList(opts, opts[_settings.arts_mode]))) 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))) _arts_cwid = self._memobj.arts_cwid cwid = RadioSettingValueString( 0, 16, self._decode_chars(_arts_cwid.get_value())) cwid.set_charset(CHARSET) arts.append(RadioSetting("arts_cwid", "CW ID", cwid)) # prog buttons opts = ["WX", "Reverse", "Repeater", "SQL Off", "Lock", "Dimmer"] prog.append( RadioSetting( "prog_panel_acc", "Prog Panel - Low(ACC)", RadioSettingValueList(opts, opts[_settings.prog_panel_acc]))) opts = ["Reverse", "Home"] prog.append( RadioSetting( "prog_tone_vm", "TONE | V/M", RadioSettingValueList(opts, opts[_settings.prog_tone_vm]))) opts = ["" for n in range(26)] + \ ["Priority", "Low", "Tone", "MHz", "Reverse", "Home", "Band", "VFO/MR", "Scan", "Sql Off", "TCall", "SSCH", "ARTS", "Tone Freq", "DCSC", "WX", "Repeater"] prog.append( RadioSetting("prog_p1", "P1", RadioSettingValueList(opts, opts[_settings.prog_p1]))) prog.append( RadioSetting("prog_p2", "P2", RadioSettingValueList(opts, opts[_settings.prog_p2]))) prog.append( RadioSetting("prog_p3", "P3", RadioSettingValueList(opts, opts[_settings.prog_p3]))) prog.append( RadioSetting("prog_p4", "P4", RadioSettingValueList(opts, opts[_settings.prog_p4]))) return top
def _get_memory(self, mem, _mem, _name): """Convert raw channel memory data into UI columns""" mem.extra = RadioSettingGroup("extra", "Extra") mem.empty = False # This function process both 'normal' and Freq up/down' entries mem.freq = int(_mem.rxfreq) * 10 if _mem.txfreq == 0xFFFFFFFF: # TX freq not set mem.duplex = "off" mem.offset = 0 elif abs(int(_mem.rxfreq) * 10 - int(_mem.txfreq) * 10) > 25000000: mem.duplex = "split" mem.offset = int(_mem.txfreq) * 10 elif 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.name = "" for i in range(6): # 0 - 6 mem.name += chr(_mem.name[i]) for i in range(10): mem.name += chr(_name.extra_name[i]) mem.name = mem.name.rstrip() # remove trailing spaces # ########## TONE ########## if _mem.txtone > 2600: # All off txmode = "" elif _mem.txtone > 511: txmode = "Tone" mem.rtone = int(_mem.txtone) / 10.0 else: # DTSC txmode = "DTCS" mem.dtcs = int(format(int(_mem.txtone), 'o')) if _mem.rxtone > 2600: rxmode = "" elif _mem.rxtone > 511: rxmode = "Tone" mem.ctone = int(_mem.rxtone) / 10.0 else: rxmode = "DTCS" mem.rx_dtcs = int(format(int(_mem.rxtone), 'o')) mem.dtcs_polarity = ("N", "R")[_mem.encodeDSCI] + ( "N", "R")[_mem.decodeDSCI] mem.tmode = "" 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) # ########## TONE ########## mem.mode = self.MODES[_mem.wide] mem.power = POWER_LEVELS[int(_mem.power)] b_lock = RadioSetting( "b_lock", "B_Lock", RadioSettingValueList(B_LOCK_LIST, B_LOCK_LIST[_mem.b_lock])) mem.extra.append(b_lock) b_lock = RadioSetting( "step", "Step", RadioSettingValueList(LIST_STEPS, LIST_STEPS[_mem.step])) mem.extra.append(b_lock) scramble_value = _mem.scramble if scramble_value >= 8: # Looks like OFF is 0x0f ** CONFIRM scramble_value = 0 scramble = RadioSetting( "scramble", "Scramble", RadioSettingValueList(SCRAMBLE_LIST, SCRAMBLE_LIST[scramble_value])) mem.extra.append(scramble) optsig = RadioSetting( "signal", "Optional signaling", RadioSettingValueList(OPTSIG_LIST, OPTSIG_LIST[_mem.signal])) mem.extra.append(optsig) rs = RadioSetting( "pttid", "PTT ID", RadioSettingValueList(PTTID_LIST, PTTID_LIST[_mem.pttid])) mem.extra.append(rs) return mem
def get_settings(self): _settings = self._memobj.settings _message = self._memobj.embedded_msg basic = RadioSettingGroup("basic", "Basic Settings") top = RadioSettings(basic) rs = RadioSetting("squelch", "Squelch Level", RadioSettingValueInteger(0, 9, _settings.squelch)) basic.append(rs) rs = RadioSetting("tot", "Time-out timer", RadioSettingValueList( TIMEOUTTIMER_LIST, TIMEOUTTIMER_LIST[_settings.tot])) basic.append(rs) rs = RadioSetting("voice", "Voice Prompts", RadioSettingValueList( VOICE_LIST, VOICE_LIST[_settings.voice])) basic.append(rs) rs = RadioSetting("pf2key", "PF2 Key", RadioSettingValueList( PF2KEY_LIST, PF2KEY_LIST[_settings.pf2key])) basic.append(rs) rs = RadioSetting("vox", "Vox", RadioSettingValueBoolean(_settings.vox)) basic.append(rs) rs = RadioSetting("voxgain", "VOX Level", RadioSettingValueList( VOX_LIST, VOX_LIST[_settings.voxgain])) basic.append(rs) rs = RadioSetting("voxdelay", "VOX Delay Time", RadioSettingValueList( VOXDELAY_LIST, VOXDELAY_LIST[_settings.voxdelay])) basic.append(rs) rs = RadioSetting("save", "Battery Save", RadioSettingValueBoolean(_settings.save)) basic.append(rs) rs = RadioSetting("beep", "Beep", RadioSettingValueBoolean(_settings.beep)) basic.append(rs) def _filter(name): filtered = "" for char in str(name): if char in VALID_CHARS: filtered += char else: filtered += " " return filtered rs = RadioSetting("embedded_msg.line1", "Embedded Message 1", RadioSettingValueString(0, 32, _filter( _message.line1))) basic.append(rs) rs = RadioSetting("embedded_msg.line2", "Embedded Message 2", RadioSettingValueString(0, 32, _filter( _message.line2))) basic.append(rs) return top
def get_settings(self): """Translate the MEM_FORMAT structs into setstuf in the UI""" _settings = self._memobj.basicsettings _settings2 = self._memobj.settings2 _workmode = self._memobj.workmodesettings basic = RadioSettingGroup("basic", "Basic Settings") group = RadioSettings(basic) # Menu 02 - TX Channel Select options = ["Last Channel", "Main Channel"] rx = RadioSettingValueList(options, options[_settings.txChSelect]) rset = RadioSetting("basicsettings.txChSelect", "Priority Transmit", rx) basic.append(rset) # Menu 03 - VOX Level rx = RadioSettingValueInteger(1, 7, _settings.voxLevel - 1) rset = RadioSetting("basicsettings.voxLevel", "Vox Level", rx) basic.append(rset) # Menu 05 - Squelch Level options = ["OFF"] + ["%s" % x for x in range(1, 10)] rx = RadioSettingValueList(options, options[_settings.sqlLevel]) rset = RadioSetting("basicsettings.sqlLevel", "Squelch Level", rx) basic.append(rset) # Menu 06 - Dual Wait rx = RadioSettingValueBoolean(_settings.dualWait) rset = RadioSetting("basicsettings.dualWait", "Dual Wait/Standby", rx) basic.append(rset) # Menu 07 - LED Mode options = ["Off", "On", "Auto"] rx = RadioSettingValueList(options, options[_settings.ledMode]) rset = RadioSetting("basicsettings.ledMode", "LED Display Mode", rx) basic.append(rset) # Menu 08 - Light options = ["%s" % x for x in range(1, 8)] rx = RadioSettingValueList(options, options[_settings.light]) rset = RadioSetting("basicsettings.light", "Background Light Color", rx) basic.append(rset) # Menu 09 - Beep rx = RadioSettingValueBoolean(_settings.beep) rset = RadioSetting("basicsettings.beep", "Keypad Beep", rx) basic.append(rset) # Menu 11 - TOT options = ["Off"] + ["%s seconds" % x for x in range(30, 300, 30)] rx = RadioSettingValueList(options, options[_settings.tot]) rset = RadioSetting("basicsettings.tot", "Transmission Time-out Timer", rx) basic.append(rset) # Menu 13 - VOX Switch rx = RadioSettingValueBoolean(_settings.voxSw) rset = RadioSetting("basicsettings.voxSw", "Vox Switch", rx) basic.append(rset) # Menu 14 - Roger rx = RadioSettingValueBoolean(_settings.roger) rset = RadioSetting("basicsettings.roger", "Roger Beep", rx) basic.append(rset) # Menu 16 - Save Mode options = ["Off", "1:1", "1:2", "1:4"] rx = RadioSettingValueList(options, options[_settings.saveMode]) rset = RadioSetting("basicsettings.saveMode", "Battery Save Mode", rx) basic.append(rset) # Menu 33 - Display Mode options = ['Frequency', 'Channel', 'Name'] rx = RadioSettingValueList(options, options[_settings.disMode]) rset = RadioSetting("basicsettings.disMode", "LED Display Mode", rx) basic.append(rset) advanced = RadioSettingGroup("advanced", "Advanced Settings") group.append(advanced) # software only options = [ '0.5S', '1.0S', '1.5S', '2.0S', '2.5S', '3.0S', '3.5S', '4.0S', '4.5S', '5.0S' ] rx = RadioSettingValueList(options, options[_settings.voxDelay]) rset = RadioSetting("basicsettings.voxDelay", "VOX Delay", rx) advanced.append(rset) # software only name = "" for i in range(15): # 0 - 15 name += chr(self._memobj.openradioname.name1[i]) name = name.rstrip() # remove trailing spaces rx = RadioSettingValueString(0, 15, name) rset = RadioSetting("openradioname.name1", "Intro Line 1", rx) advanced.append(rset) # software only name = "" for i in range(15): # 0 - 15 name += chr(self._memobj.openradioname.name2[i]) name = name.rstrip() # remove trailing spaces rx = RadioSettingValueString(0, 15, name) rset = RadioSetting("openradioname.name2", "Intro Line 2", rx) advanced.append(rset) options = ['Unlocked', 'Unknown 1', 'Unknown 2', 'EU', 'US'] # extend option list with unknown description for values 5 - 15. for ix in range(len(options), _settings2.region + 1): item_to_add = 'Unknown {region_code}'.format(region_code=ix) options.append(item_to_add) # log unknown region codes greater than 4 if _settings2.region > 4: LOG.debug( "Unknown region code: {value}".format(value=_settings2.region)) rx = RadioSettingValueList(options, options[_settings2.region]) rx.set_mutable(False) rset = RadioSetting("settings2.region", "Region", rx) advanced.append(rset) workmode = RadioSettingGroup("workmode", "Work Mode Settings") group.append(workmode) # Toggle with [#] key options = ["Frequency", "Channel"] rx = RadioSettingValueList(options, options[_workmode.vfomrmode]) rset = RadioSetting("workmodesettings.vfomrmode", "VFO/MR Mode", rx) workmode.append(rset) # Toggle with [A/B] key options = ["A", "B"] rx = RadioSettingValueList(options, options[_workmode.ab]) rset = RadioSetting("workmodesettings.ab", "A/B Select", rx) workmode.append(rset) return group # END get_settings()
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic Settings") group = RadioSettings(basic) options = ["Time", "Carrier", "Search"] rs = RadioSetting("scantype", "Scan Type", RadioSettingValueList(options, options[_settings.scantype])) basic.append(rs) options = ["Off"] + ["%s min" % x for x in range(1, 8)] rs = RadioSetting("timeout", "Time Out Timer", RadioSettingValueList( options, options[_settings.timeout])) basic.append(rs) options = ["A", "B"] rs = RadioSetting("freqmode_ab", "Frequency Mode", RadioSettingValueList( options, options[_settings.freqmode_ab])) basic.append(rs) options = ["Frequency Mode", "Channel Mode"] rs = RadioSetting("workmode_a", "Radio Work Mode(A)", RadioSettingValueList( options, options[_settings.workmode_a])) basic.append(rs) rs = RadioSetting("workmode_b", "Radio Work Mode(B)", RadioSettingValueList( options, options[_settings.workmode_b])) basic.append(rs) options = ["Frequency", "Name", "Channel"] rs = RadioSetting("mdf_a", "Display Format(F1)", RadioSettingValueList( options, options[_settings.mdf_a])) basic.append(rs) rs = RadioSetting("mdf_b", "Display Format(F2)", RadioSettingValueList( options, options[_settings.mdf_b])) basic.append(rs) rs = RadioSetting("mem_chan_a", "Mem Channel (A)", RadioSettingValueInteger( 1, 99, _settings.mem_chan_a)) basic.append(rs) rs = RadioSetting("mem_chan_b", "Mem Channel (B)", RadioSettingValueInteger( 1, 99, _settings.mem_chan_b)) basic.append(rs) options = ["Off", "BOT", "EOT", "Both"] rs = RadioSetting("pttid", "PTT-ID", RadioSettingValueList( options, options[_settings.pttid])) basic.append(rs) dtmfchars = "0123456789ABCD*#" _codeobj = self._memobj.pttid.code _code = "".join([dtmfchars[x] for x in _codeobj if int(x) < 0x1F]) val = RadioSettingValueString(0, 6, _code, False) val.set_charset(dtmfchars) rs = RadioSetting("pttid.code", "PTT-ID Code", val) def apply_code(setting, obj): code = [] for j in range(0, 6): try: code.append(dtmfchars.index(str(setting.value)[j])) except IndexError: code.append(0xFF) obj.code = code rs.set_apply_callback(apply_code, self._memobj.pttid) basic.append(rs) rs = RadioSetting("squelch", "Squelch Level", RadioSettingValueInteger(0, 9, _settings.squelch)) basic.append(rs) rs = RadioSetting("vox", "VOX Level", RadioSettingValueInteger(0, 9, _settings.vox)) basic.append(rs) options = ["Frequency Mode", "Channel Mode"] rs = RadioSetting("workmode_fm", "FM Work Mode", RadioSettingValueList( options, options[_settings.workmode_fm])) basic.append(rs) options = ["Current Frequency", "F1 Frequency", "F2 Frequency"] rs = RadioSetting("txtdr", "Dual Standby TX Priority", RadioSettingValueList(options, options[_settings.txtdr])) basic.append(rs) options = ["English", "Chinese"] rs = RadioSetting("language", "Language", RadioSettingValueList(options, options[_settings.language])) basic.append(rs) rs = RadioSetting("tdr", "Dual Standby", RadioSettingValueBoolean(_settings.tdr)) basic.append(rs) rs = RadioSetting("roger", "Roger Beep", RadioSettingValueBoolean(_settings.roger)) basic.append(rs) rs = RadioSetting("backlight", "Backlight", RadioSettingValueBoolean(_settings.backlight)) basic.append(rs) rs = RadioSetting("save_funct", "Save Mode", RadioSettingValueBoolean(_settings.save_funct)) basic.append(rs) rs = RadioSetting("fm", "FM Function", RadioSettingValueBoolean(_settings.fm)) basic.append(rs) rs = RadioSetting("beep_tone_disabled", "Beep Prompt", RadioSettingValueBoolean( not _settings.beep_tone_disabled)) basic.append(rs) rs = RadioSetting("voice_prompt", "Voice Prompt", RadioSettingValueBoolean(_settings.voice_prompt)) basic.append(rs) rs = RadioSetting("sidetone", "DTMF Side Tone", RadioSettingValueBoolean(_settings.sidetone)) basic.append(rs) rs = RadioSetting("ste_disabled", "Squelch Tail Eliminate", RadioSettingValueBoolean(not _settings.ste_disabled)) basic.append(rs) _limit = int(self._memobj.limits.lower_vhf) / 10 rs = RadioSetting("limits.lower_vhf", "VHF Lower Limit (MHz)", RadioSettingValueInteger(128, 270, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.lower_vhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) _limit = int(self._memobj.limits.upper_vhf) / 10 rs = RadioSetting("limits.upper_vhf", "VHF Upper Limit (MHz)", RadioSettingValueInteger(128, 270, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.upper_vhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) _limit = int(self._memobj.limits.lower_uhf) / 10 rs = RadioSetting("limits.lower_uhf", "UHF Lower Limit (MHz)", RadioSettingValueInteger(400, 520, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.lower_uhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) _limit = int(self._memobj.limits.upper_uhf) / 10 rs = RadioSetting("limits.upper_uhf", "UHF Upper Limit (MHz)", RadioSettingValueInteger(400, 520, _limit)) def apply_limit(setting, obj): value = int(setting.value) * 10 obj.upper_uhf = value rs.set_apply_callback(apply_limit, self._memobj.limits) basic.append(rs) fm_preset = RadioSettingGroup("fm_preset", "FM Radio Presets") group.append(fm_preset) for i in range(0, 16): if self._memobj.fm_presets[i] < 0x01AF: used = True preset = self._memobj.fm_presets[i] / 10.0 + 65 else: used = False preset = 65 rs = RadioSetting("fm_presets_%1i" % i, "FM Preset %i" % (i + 1), RadioSettingValueBoolean(used), RadioSettingValueFloat(65, 108, preset, 0.1, 1)) fm_preset.append(rs) testmode = RadioSettingGroup("testmode", "Test Mode Settings") group.append(testmode) vhfdata = ["136-139", "140-144", "145-149", "150-154", "155-159", "160-164", "165-169", "170-174"] uhfdata = ["400-409", "410-419", "420-429", "430-439", "440-449", "450-459", "460-469", "470-479"] powernamedata = ["Hi", "Lo"] powerkeydata = ["hipwr", "lopwr"] for power in range(0, 2): for index in range(0, 8): key = "test.vhf%s%i" % (powerkeydata[power], index) name = "%s Mhz %s Power" % (vhfdata[index], powernamedata[power]) rs = RadioSetting( key, name, RadioSettingValueInteger( 0, 255, getattr( self._memobj.test, "vhf%s%i" % (powerkeydata[power], index)))) testmode.append(rs) for power in range(0, 2): for index in range(0, 8): key = "test.uhf%s%i" % (powerkeydata[power], index) name = "%s Mhz %s Power" % (uhfdata[index], powernamedata[power]) rs = RadioSetting( key, name, RadioSettingValueInteger( 0, 255, getattr( self._memobj.test, "uhf%s%i" % (powerkeydata[power], index)))) testmode.append(rs) for band in ["vhf", "uhf"]: for index in range(0, 10): key = "test.%ssquelch%i" % (band, index) name = "%s Squelch %i" % (band.upper(), index) rs = RadioSetting( key, name, RadioSettingValueInteger( 0, 255, getattr( self._memobj.test, "%ssquelch%i" % (band, index)))) testmode.append(rs) return group
def get_memory(self, number): _mem = self._memobj.memory[number] _nam = self._memobj.names[number] mem = chirp_common.Memory() mem.number = number if _mem.get_raw()[0] == "\xff": mem.empty = True return mem mem.freq = int(_mem.rxfreq) * 10 if self._is_txinh(_mem): # TX freq not set mem.duplex = "off" mem.offset = 0 else: # TX freq set offset = (int(_mem.txfreq) * 10) - mem.freq if offset != 0: if _split(self.get_features(), mem.freq, int(_mem.txfreq) * 10): mem.duplex = "split" mem.offset = int(_mem.txfreq) * 10 elif offset < 0: mem.offset = abs(offset) mem.duplex = "-" elif offset > 0: mem.offset = offset mem.duplex = "+" else: mem.offset = 0 for char in _nam.name: if str(char) == "\xFF": char = " " # The OEM software may have 0xFF mid-name mem.name += str(char) mem.name = mem.name.rstrip() dtcs_pol = ["N", "N"] if _mem.txtone in [0, 0xFFFF]: txmode = "" elif _mem.txtone >= 0x0258: txmode = "Tone" mem.rtone = int(_mem.txtone) / 10.0 elif _mem.txtone <= 0x0258: txmode = "DTCS" if _mem.txtone > 0x69: index = _mem.txtone - 0x6A dtcs_pol[0] = "R" else: index = _mem.txtone - 1 mem.dtcs = self.DTCS_CODES[index] else: LOG.warn("Bug: txtone is %04x" % _mem.txtone) if _mem.rxtone in [0, 0xFFFF]: rxmode = "" elif _mem.rxtone >= 0x0258: rxmode = "Tone" mem.ctone = int(_mem.rxtone) / 10.0 elif _mem.rxtone <= 0x0258: rxmode = "DTCS" if _mem.rxtone >= 0x6A: index = _mem.rxtone - 0x6A dtcs_pol[1] = "R" else: index = _mem.rxtone - 1 mem.rx_dtcs = self.DTCS_CODES[index] else: LOG.warn("Bug: rxtone is %04x" % _mem.rxtone) if txmode == "Tone" and not rxmode: mem.tmode = "Tone" elif txmode == rxmode and txmode == "Tone" and mem.rtone == mem.ctone: mem.tmode = "TSQL" elif txmode == rxmode and txmode == "DTCS" and mem.dtcs == mem.rx_dtcs: mem.tmode = "DTCS" elif rxmode or txmode: mem.tmode = "Cross" mem.cross_mode = "%s->%s" % (txmode, rxmode) mem.dtcs_polarity = "".join(dtcs_pol) if not _mem.scan: mem.skip = "S" levels = self.POWER_LEVELS try: mem.power = levels[_mem.lowpower] except IndexError: LOG.error("Radio reported invalid power level %s (in %s)" % (_mem.power, levels)) mem.power = levels[0] mem.mode = _mem.wide and "FM" or "NFM" mem.extra = RadioSettingGroup("Extra", "extra") rs = RadioSetting("bcl", "BCL", RadioSettingValueBoolean(_mem.bcl)) mem.extra.append(rs) rs = RadioSetting( "pttid", "PTT ID", RadioSettingValueList(self.PTTID_LIST, self.PTTID_LIST[_mem.pttid])) mem.extra.append(rs) rs = RadioSetting( "scode", "S-CODE", RadioSettingValueList(self.SCODE_LIST, self.SCODE_LIST[_mem.scode])) mem.extra.append(rs) return mem
def get_settings(self): _settings = self._memobj.settings basic = RadioSettingGroup("basic", "Basic") dtmf = RadioSettingGroup("dtmf", "DTMF") arts = RadioSettingGroup("arts", "ARTS") prog = RadioSettingGroup("prog", "Programmable Buttons") top = RadioSettings(basic, dtmf, arts, prog) basic.append(RadioSetting( "priority_revert", "Priority Revert", RadioSettingValueBoolean(_settings.priority_revert))) basic.append(RadioSetting( "memory_only", "Memory Only mode", RadioSettingValueBoolean(_settings.memory_only))) 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]))) basic.append(RadioSetting( "beep_scan", "Beep: Scan", RadioSettingValueBoolean(_settings.beep_scan))) basic.append(RadioSetting( "beep_edge", "Beep: Edge", RadioSettingValueBoolean(_settings.beep_edge))) basic.append(RadioSetting( "beep_key", "Beep: Key", RadioSettingValueBoolean(_settings.beep_key))) opts = ["T/RX Normal", "RX Reverse", "TX Reverse", "T/RX Reverse"] basic.append(RadioSetting( "dcs_polarity", "DCS polarity", RadioSettingValueList(opts, opts[_settings.dcs_polarity]))) opts = ["off", "dim 1", "dim 2", "dim 3"] basic.append(RadioSetting( "dimmer", "Dimmer", RadioSettingValueList(opts, opts[_settings.dimmer]))) opts = ["manual", "auto", "1-auto"] basic.append(RadioSetting( "hyper_write", "Hyper Write", RadioSettingValueList(opts, opts[_settings.hyper_write]))) opts = ["", "key", "dial", "key+dial", "ptt", "ptt+key", "ptt+dial", "all"] basic.append(RadioSetting( "lock", "Lock mode", RadioSettingValueList(opts, opts[_settings.lock]))) opts = ["MH-42", "MH-48"] basic.append(RadioSetting( "microphone_type", "Microphone Type", RadioSettingValueList(opts, opts[_settings.microphone_type]))) opts = ["off"] + ["S-%d" % n for n in range(2, 10)] + ["S-Full"] basic.append(RadioSetting( "rf_sql", "RF Squelch", RadioSettingValueList(opts, opts[_settings.rf_sql]))) opts = ["time", "hold", "busy"] basic.append(RadioSetting( "scan_resume", "Scan Resume", RadioSettingValueList(opts, opts[_settings.scan_resume]))) opts = ["single", "continuous"] basic.append(RadioSetting( "smart_search", "Smart Search", RadioSettingValueList(opts, opts[_settings.smart_search]))) opts = ["off"] + ["%d" % t for t in range(1, 31)] basic.append(RadioSetting( "tot", "Time-out timer (mins)", RadioSettingValueList(opts, opts[_settings.tot]))) # dtmf tab opts = ["50", "100", "250", "450", "750", "1000"] dtmf.append(RadioSetting( "dtmf_delay", "DTMF delay (ms)", RadioSettingValueList(opts, opts[_settings.dtmf_delay]))) opts = ["50", "75", "100"] dtmf.append(RadioSetting( "dtmf_speed", "DTMF speed (ms)", RadioSettingValueList(opts, opts[_settings.dtmf_speed]))) for i in range(16): name = "dtmf%02d" % i dtmfsetting = self._memobj.dtmf[i] dtmfstr = "" for c in dtmfsetting.memory: if c == 0xFF: break 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 opts = ["off", "in range", "always"] arts.append(RadioSetting( "arts_mode", "ARTS beep", RadioSettingValueList(opts, opts[_settings.arts_mode]))) 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))) _arts_cwid = self._memobj.arts_cwid cwid = RadioSettingValueString( 0, 16, self._decode_chars(_arts_cwid.get_value())) cwid.set_charset(CHARSET) arts.append(RadioSetting("arts_cwid", "CW ID", cwid)) # prog buttons opts = ["WX", "Reverse", "Repeater", "SQL Off", "Lock", "Dimmer"] prog.append(RadioSetting( "prog_panel_acc", "Prog Panel - Low(ACC)", RadioSettingValueList(opts, opts[_settings.prog_panel_acc]))) opts = ["Reverse", "Home"] prog.append(RadioSetting( "prog_tone_vm", "TONE | V/M", RadioSettingValueList(opts, opts[_settings.prog_tone_vm]))) opts = ["" for n in range(26)] + \ ["Priority", "Low", "Tone", "MHz", "Reverse", "Home", "Band", "VFO/MR", "Scan", "Sql Off", "TCall", "SSCH", "ARTS", "Tone Freq", "DCSC", "WX", "Repeater"] prog.append(RadioSetting( "prog_p1", "P1", RadioSettingValueList(opts, opts[_settings.prog_p1]))) prog.append(RadioSetting( "prog_p2", "P2", RadioSettingValueList(opts, opts[_settings.prog_p2]))) prog.append(RadioSetting( "prog_p3", "P3", RadioSettingValueList(opts, opts[_settings.prog_p3]))) prog.append(RadioSetting( "prog_p4", "P4", RadioSettingValueList(opts, opts[_settings.prog_p4]))) return top
def get_settings(self): """Translate the bit in the mem_struct into settings in the UI""" _mem = self._memobj basic = RadioSettingGroup("basic", "Basic Settings") other = RadioSettingGroup("other", "Other Settings") work = RadioSettingGroup("work", "Work Mode Settings") dtmf = RadioSettingGroup("dtmf", "DTMF Settings") top = RadioSettings(basic, other, work, dtmf) # Basic # Audio: A01-A04 aftone = RadioSetting("settings.aftone", "AF tone control", RadioSettingValueList(LIST_AFTONE, LIST_AFTONE[ _mem.settings.aftone])) basic.append(aftone) spkr = RadioSetting("settings.spkr", "Speaker", RadioSettingValueList(LIST_SPKR,LIST_SPKR[ _mem.settings.spkr])) basic.append(spkr) audio = RadioSetting("settings.audio", "Stereo/Mono", RadioSettingValueList(LIST_AUDIO, LIST_AUDIO[ _mem.settings.audio])) basic.append(audio) sbmute = RadioSetting("settings.sbmute", "Sub band mute", RadioSettingValueList(LIST_SBMUTE, LIST_SBMUTE[ _mem.settings.sbmute])) basic.append(sbmute) # TX/RX: B01-B08 mgain = RadioSetting("settings.mgain", "Mic gain", RadioSettingValueList(LIST_MLNHM, LIST_MLNHM[ _mem.settings.mgain])) basic.append(mgain) ptt = RadioSetting("settings.ptt", "PTT mode", RadioSettingValueList(LIST_PTT,LIST_PTT[ _mem.settings.ptt])) basic.append(ptt) # B03 (per channel) # B04 (per channel) rxexp = RadioSetting("settings.rxexp", "RX expansion", RadioSettingValueList(LIST_RXEXP,LIST_RXEXP[ _mem.settings.rxexp])) basic.append(rxexp) vox = RadioSetting("settings.vox", "Vox", RadioSettingValueList(LIST_VOX, LIST_VOX[ _mem.settings.vox])) basic.append(vox) voxs = RadioSetting("settings.voxs", "Vox sensitivity", RadioSettingValueList(LIST_MLNHM, LIST_MLNHM[ _mem.settings.voxs])) basic.append(voxs) # B08 (per channel) # Display: C01-C06 display = RadioSetting("settings.display", "Display select", RadioSettingValueList(LIST_DISPLAY, LIST_DISPLAY[_mem.settings.display])) basic.append(display) lcdb = RadioSetting("settings.lcdb", "LCD brightness", RadioSettingValueList(LIST_MINMAX, LIST_MINMAX[ _mem.settings.lcdb])) basic.append(lcdb) color = RadioSetting("settings.color", "LCD color", RadioSettingValueList(LIST_COLOR, LIST_COLOR[ _mem.settings.color])) basic.append(color) lcdc = RadioSetting("settings.lcdc", "LCD contrast", RadioSettingValueList(LIST_MINMAX, LIST_MINMAX[ _mem.settings.lcdc])) basic.append(lcdc) btime = RadioSetting("settings.btime", "LCD backlight time", RadioSettingValueList(LIST_BTIME, LIST_BTIME[ _mem.settings.btime])) basic.append(btime) keyb = RadioSetting("settings.keyb", "Key brightness", RadioSettingValueList(LIST_MINMAX, LIST_MINMAX[ _mem.settings.keyb])) basic.append(keyb) # Memory: D01-D04 # D01 (per channel) # D02 (per channel) mrscan = RadioSetting("settings.mrscan", "Memory scan type", RadioSettingValueList(LIST_MRSCAN, LIST_MRSCAN[ _mem.settings.mrscan])) basic.append(mrscan) # D04 (per channel) # Scan: E01-E04 dwstop = RadioSetting("settings.dwstop", "Dual watch stop", RadioSettingValueList(LIST_DWSTOP, LIST_DWSTOP[ _mem.settings.dwstop])) basic.append(dwstop) scand = RadioSetting("settings.scand", "Scan direction", RadioSettingValueList(LIST_SCAND,LIST_SCAND[ _mem.settings.scand])) basic.append(scand) scanr = RadioSetting("settings.scanr", "Scan resume", RadioSettingValueList(LIST_SCANR,LIST_SCANR[ _mem.settings.scanr])) basic.append(scanr) scansb = RadioSetting("settings.scansb", "Scan stop beep", RadioSettingValueBoolean(_mem.settings.scansb)) basic.append(scansb) # System: F01-F09 apo = RadioSetting("settings.apo", "Automatic power off [hours]", RadioSettingValueList(LIST_APO, LIST_APO[ _mem.settings.apo])) basic.append(apo) ars = RadioSetting("settings.ars", "Automatic repeater shift", RadioSettingValueBoolean(_mem.settings.ars)) basic.append(ars) beep = RadioSetting("settings.beep", "Beep volume", RadioSettingValueList(LIST_BEEP,LIST_BEEP[ _mem.settings.beep])) basic.append(beep) fkey = RadioSetting("settings.fkey", "F key", RadioSettingValueList(LIST_FKEY,LIST_FKEY[ _mem.settings.fkey])) basic.append(fkey) pfkey1 = RadioSetting("settings.pfkey1", "Mic P1 key", RadioSettingValueList(LIST_PFKEY, LIST_PFKEY[ _mem.settings.pfkey1])) basic.append(pfkey1) pfkey2 = RadioSetting("settings.pfkey2", "Mic P2 key", RadioSettingValueList(LIST_PFKEY, LIST_PFKEY[ _mem.settings.pfkey2])) basic.append(pfkey2) pfkey3 = RadioSetting("settings.pfkey3", "Mic P3 key", RadioSettingValueList(LIST_PFKEY, LIST_PFKEY[ _mem.settings.pfkey3])) basic.append(pfkey3) pfkey4 = RadioSetting("settings.pfkey4", "Mic P4 key", RadioSettingValueList(LIST_PFKEY, LIST_PFKEY[ _mem.settings.pfkey4])) basic.append(pfkey4) omode = RadioSetting("settings.omode", "Operation mode", RadioSettingValueList(LIST_AB,LIST_AB[ _mem.settings.omode])) basic.append(omode) rxcoverm = RadioSetting("settings.rxcoverm", "RX coverage - memory", RadioSettingValueList(LIST_COVERAGE, LIST_COVERAGE[_mem.settings.rxcoverm])) basic.append(rxcoverm) rxcoverv = RadioSetting("settings.rxcoverv", "RX coverage - VFO", RadioSettingValueList(LIST_COVERAGE, LIST_COVERAGE[_mem.settings.rxcoverv])) basic.append(rxcoverv) tot = RadioSetting("settings.tot", "Time out timer [min]", RadioSettingValueList(LIST_TOT, LIST_TOT[ _mem.settings.tot])) basic.append(tot) # Timer/Clock: G01-G04 # G01 datefmt = RadioSetting("settings.datefmt", "Date format", RadioSettingValueList(LIST_DATEFMT, LIST_DATEFMT[_mem.settings.datefmt])) basic.append(datefmt) timefmt = RadioSetting("settings.timefmt", "Time format", RadioSettingValueList(LIST_TIMEFMT, LIST_TIMEFMT[_mem.settings.timefmt])) basic.append(timefmt) timesig = RadioSetting("settings.timesig", "Time signal", RadioSettingValueBoolean(_mem.settings.timesig)) basic.append(timesig) tz = RadioSetting("settings.tz", "Time zone", RadioSettingValueList(LIST_TZ, LIST_TZ[ _mem.settings.tz])) basic.append(tz) # Signaling: H01-H06 bell = RadioSetting("settings.bell", "Bell ringer", RadioSettingValueList(LIST_BELL, LIST_BELL[ _mem.settings.bell])) basic.append(bell) # H02 (per channel) dtmfmodenc = RadioSetting("settings.dtmfmodenc", "DTMF mode encode", RadioSettingValueBoolean( _mem.settings.dtmfmodenc)) basic.append(dtmfmodenc) dtmfmoddec = RadioSetting("settings.dtmfmoddec", "DTMF mode decode", RadioSettingValueBoolean( _mem.settings.dtmfmoddec)) basic.append(dtmfmoddec) # H04 (per channel) decbandsel = RadioSetting("settings.decbandsel", "DTMF band select", RadioSettingValueList(LIST_AB,LIST_AB[ _mem.settings.decbandsel])) basic.append(decbandsel) sqlexp = RadioSetting("settings.sqlexp", "SQL expansion", RadioSettingValueBoolean(_mem.settings.sqlexp)) basic.append(sqlexp) # Pkt: I01-I03 databnd = RadioSetting("settings.databnd", "Packet data band", RadioSettingValueList(LIST_DATABND,LIST_DATABND[ _mem.settings.databnd])) basic.append(databnd) dataspd = RadioSetting("settings.dataspd", "Packet data speed", RadioSettingValueList(LIST_DATASPD,LIST_DATASPD[ _mem.settings.dataspd])) basic.append(dataspd) datasql = RadioSetting("settings.datasql", "Packet data squelch", RadioSettingValueList(LIST_DATASQL,LIST_DATASQL[ _mem.settings.datasql])) basic.append(datasql) # Other dw = RadioSetting("settings.dw", "Dual watch", RadioSettingValueBoolean(_mem.settings.dw)) other.append(dw) cpuclk = RadioSetting("settings.cpuclk", "CPU clock frequency", RadioSettingValueList(LIST_CPUCLK,LIST_CPUCLK[ _mem.settings.cpuclk])) other.append(cpuclk) def _filter(name): filtered = "" for char in str(name): if char in VALID_CHARS: filtered += char else: filtered += " " return filtered line16 = RadioSetting("poweron_msg.line16", "Power-on message", RadioSettingValueString(0, 16, _filter( _mem.poweron_msg.line16))) other.append(line16) line32 = RadioSetting("embedded_msg.line32", "Embedded message", RadioSettingValueString(0, 32, _filter( _mem.embedded_msg.line32))) other.append(line32) # Work workmoda = RadioSetting("settings.workmoda", "Work mode A", RadioSettingValueList(LIST_WORK,LIST_WORK[ _mem.settings.workmoda])) work.append(workmoda) workmodb = RadioSetting("settings.workmodb", "Work mode B", RadioSettingValueList(LIST_WORK,LIST_WORK[ _mem.settings.workmodb])) work.append(workmodb) wbanda = RadioSetting("settings.wbanda", "Work band A", RadioSettingValueList(LIST_WBANDA, LIST_WBANDA[ (_mem.settings.wbanda) - 1])) work.append(wbanda) wbandb = RadioSetting("settings.wbandb", "Work band B", RadioSettingValueList(LIST_WBANDB, LIST_WBANDB[ (_mem.settings.wbandb) - 4])) work.append(wbandb) sqla = RadioSetting("settings.sqla", "Squelch A", RadioSettingValueList(LIST_SQL, LIST_SQL[ _mem.settings.sqla])) work.append(sqla) sqlb = RadioSetting("settings.sqlb", "Squelch B", RadioSettingValueList(LIST_SQL, LIST_SQL[ _mem.settings.sqlb])) work.append(sqlb) stepa = RadioSetting("settings.stepa", "Auto step A", RadioSettingValueList(LIST_STEP,LIST_STEP[ _mem.settings.stepa])) work.append(stepa) stepb = RadioSetting("settings.stepb", "Auto step B", RadioSettingValueList(LIST_STEP,LIST_STEP[ _mem.settings.stepb])) work.append(stepb) mrcha = RadioSetting("settings.mrcha", "Current channel A", RadioSettingValueInteger(0, 499, _mem.settings.mrcha)) work.append(mrcha) mrchb = RadioSetting("settings.mrchb", "Current channel B", RadioSettingValueInteger(0, 499, _mem.settings.mrchb)) work.append(mrchb) val = _mem.settings.offseta / 100.00 offseta = RadioSetting("settings.offseta", "Offset A (0-37.95)", RadioSettingValueFloat(0, 38.00, val, 0.05, 2)) work.append(offseta) val = _mem.settings.offsetb / 100.00 offsetb = RadioSetting("settings.offsetb", "Offset B (0-79.95)", RadioSettingValueFloat(0, 80.00, val, 0.05, 2)) work.append(offsetb) wpricha = RadioSetting("settings.wpricha", "Priority channel A", RadioSettingValueInteger(0, 499, _mem.settings.wpricha)) work.append(wpricha) wprichb = RadioSetting("settings.wprichb", "Priority channel B", RadioSettingValueInteger(0, 499, _mem.settings.wprichb)) work.append(wprichb) smode = RadioSetting("settings.smode", "Smart function mode", RadioSettingValueList(LIST_SMODE,LIST_SMODE[ _mem.settings.smode])) work.append(smode) # dtmf ttdkey = RadioSetting("dtmf.ttdkey", "D key function", RadioSettingValueList(LIST_TTDKEY, LIST_TTDKEY[ _mem.dtmf.ttdkey])) dtmf.append(ttdkey) ttdgt = RadioSetting("dtmf.ttdgt", "Digit time", RadioSettingValueList(LIST_TT200, LIST_TT200[ (_mem.dtmf.ttdgt) - 5])) dtmf.append(ttdgt) ttint = RadioSetting("dtmf.ttint", "Interval time", RadioSettingValueList(LIST_TT200, LIST_TT200[ (_mem.dtmf.ttint) - 5])) dtmf.append(ttint) tt1stdgt = RadioSetting("dtmf.tt1stdgt", "1st digit time", RadioSettingValueList(LIST_TT200, LIST_TT200[ (_mem.dtmf.tt1stdgt) - 5])) dtmf.append(tt1stdgt) tt1stdly = RadioSetting("dtmf.tt1stdly", "1st digit delay time", RadioSettingValueList(LIST_TT1000, LIST_TT1000[ (_mem.dtmf.tt1stdly) - 2])) dtmf.append(tt1stdly) ttdlyqt = RadioSetting("dtmf.ttdlyqt", "Digit delay when use qt", RadioSettingValueList(LIST_TT1000, LIST_TT1000[ (_mem.dtmf.ttdlyqt) - 2])) dtmf.append(ttdlyqt) ttsig = RadioSetting("dtmf2.ttsig", "Signal", RadioSettingValueList(LIST_TTSIG, LIST_TTSIG[ _mem.dtmf2.ttsig])) dtmf.append(ttsig) ttautorst = RadioSetting("dtmf2.ttautorst", "Auto reset time", RadioSettingValueList(LIST_TTAUTORST, LIST_TTAUTORST[_mem.dtmf2.ttautorst])) dtmf.append(ttautorst) if _mem.dtmf2.ttgrpcode > 0x06: val = 0x00 else: val = _mem.dtmf2.ttgrpcode ttgrpcode = RadioSetting("dtmf2.ttgrpcode", "Group code", RadioSettingValueList(LIST_TTGRPCODE, LIST_TTGRPCODE[val])) dtmf.append(ttgrpcode) ttintcode = RadioSetting("dtmf2.ttintcode", "Interval code", RadioSettingValueList(LIST_TTINTCODE, LIST_TTINTCODE[_mem.dtmf2.ttintcode])) dtmf.append(ttintcode) if _mem.dtmf2.ttalert > 0x04: val = 0x00 else: val = _mem.dtmf2.ttalert ttalert = RadioSetting("dtmf2.ttalert", "Alert tone/transpond", RadioSettingValueList(LIST_TTALERT, LIST_TTALERT[val])) dtmf.append(ttalert) ttautod = RadioSetting("dtmf.ttautod", "Auto dial group", RadioSettingValueList(LIST_TTAUTOD, LIST_TTAUTOD[_mem.dtmf.ttautod])) dtmf.append(ttautod) # setup 9 dtmf autodial entries for i in map(str, range(1, 10)): objname = "code" + i strname = "Code " + str(i) dtmfsetting = getattr(_mem.dtmfcode, objname) dtmflen = getattr(_mem.dtmfcode, objname + "_len") dtmfstr = self._bbcd2dtmf(dtmfsetting, dtmflen) code = RadioSettingValueString(0, 16, dtmfstr) code.set_charset(DTMF_CHARS + list(" ")) rs = RadioSetting("dtmfcode." + objname, strname, code) dtmf.append(rs) return top
def _get_settings(self): _settings = self._memobj.settings _service = self._memobj.service _msg = self._memobj.messages cfg_grp = RadioSettingGroup("cfg_grp", "Basic Settings") adv_grp = RadioSettingGroup("adv_grp", "Advanced Settings") key_grp = RadioSettingGroup("key_grp", "Key Assignment") group = RadioSettings(cfg_grp, adv_grp, key_grp) # # Basic Settings # rs = RadioSetting("apo", "Auto Power Off", RadioSettingValueList( APO_LIST, APO_LIST[_settings.apo])) cfg_grp.append(rs) rs = RadioSetting("sql", "Squelch Level", RadioSettingValueList( SQL_LIST, SQL_LIST[_settings.sql])) cfg_grp.append(rs) rs = RadioSetting("scanm", "Scan Mode", RadioSettingValueList( SCANM_LIST, SCANM_LIST[_settings.scanm])) cfg_grp.append(rs) rs = RadioSetting("tot", "Time Out Timer", RadioSettingValueList( TOT_LIST, TOT_LIST[_settings.tot])) cfg_grp.append(rs) rs = RadioSetting("step", "Step", RadioSettingValueList( STEP_LIST, STEP_LIST[_settings.step])) cfg_grp.append(rs) rs = RadioSetting("monitor", "Monitor", RadioSettingValueList( MONITOR_LIST, MONITOR_LIST[_settings.monitor])) cfg_grp.append(rs) rs = RadioSetting("vfomr", "VFO/MR", RadioSettingValueList( VFOMR_LIST, VFOMR_LIST[_settings.vfomr])) cfg_grp.append(rs) rs = RadioSetting("mrcha", "MR/CHA", RadioSettingValueList( MRCHA_LIST, MRCHA_LIST[_settings.mrcha])) cfg_grp.append(rs) rs = RadioSetting("vol", "Volume", RadioSettingValueList( VOL_LIST, VOL_LIST[_settings.vol])) cfg_grp.append(rs) rs = RadioSetting("opendis", "Open Display", RadioSettingValueList( OPENDIS_LIST, OPENDIS_LIST[_settings.opendis])) cfg_grp.append(rs) def _filter(name): filtered = "" for char in str(name): if char in chirp_common.CHARSET_ASCII: filtered += char else: filtered += " " LOG.debug("Filtered: %s" % filtered) return filtered rs = RadioSetting("messages.user1", "User-defined Message 1", RadioSettingValueString(0, 7, _filter(_msg.user1))) cfg_grp.append(rs) rs = RadioSetting("messages.user2", "User-defined Message 2", RadioSettingValueString(0, 7, _filter(_msg.user2))) cfg_grp.append(rs) val = RadioSettingValueString(0, 7, _filter(_msg.system)) val.set_mutable(False) rs = RadioSetting("messages.system", "System Message", val) cfg_grp.append(rs) rs = RadioSetting("lamp", "Backlight", RadioSettingValueList( LAMP_LIST, LAMP_LIST[_settings.lamp])) cfg_grp.append(rs) rs = RadioSetting("keylockm", "Key Lock Mode", RadioSettingValueList( KEYLOCKM_LIST, KEYLOCKM_LIST[_settings.keylockm])) cfg_grp.append(rs) rs = RadioSetting("absel", "A/B Select", RadioSettingValueList(ABSEL_LIST, ABSEL_LIST[_settings.absel])) cfg_grp.append(rs) rs = RadioSetting("obeep", "Open Beep", RadioSettingValueBoolean(_settings.obeep)) cfg_grp.append(rs) rs = RadioSetting("rbeep", "Roger Beep", RadioSettingValueBoolean(_settings.rbeep)) cfg_grp.append(rs) rs = RadioSetting("keylock_off", "Key Lock", RadioSettingValueBoolean(not _settings.keylock_off)) cfg_grp.append(rs) rs = RadioSetting("ctdcsb", "CT/DCS Busy Lock", RadioSettingValueBoolean(_settings.ctdcsb)) cfg_grp.append(rs) rs = RadioSetting("alarm", "Alarm Key", RadioSettingValueBoolean(_settings.alarm)) cfg_grp.append(rs) rs = RadioSetting("save", "Battery Save", RadioSettingValueBoolean(_settings.save)) cfg_grp.append(rs) rs = RadioSetting("kbeep", "Key Beep", RadioSettingValueBoolean(_settings.kbeep)) cfg_grp.append(rs) rs = RadioSetting("reset", "Reset Enable", RadioSettingValueBoolean(_settings.reset)) cfg_grp.append(rs) rs = RadioSetting("smfont_off", "Small Font", RadioSettingValueBoolean(not _settings.smfont_off)) cfg_grp.append(rs) rs = RadioSetting("aliasen_off", "Alias Enable", RadioSettingValueBoolean(not _settings.aliasen_off)) cfg_grp.append(rs) rs = RadioSetting("txstop_off", "TX Stop", RadioSettingValueBoolean(not _settings.txstop_off)) cfg_grp.append(rs) rs = RadioSetting("dw_off", "Dual Watch", RadioSettingValueBoolean(not _settings.dw_off)) cfg_grp.append(rs) rs = RadioSetting("fmen_off", "FM Enable", RadioSettingValueBoolean(not _settings.fmen_off)) cfg_grp.append(rs) rs = RadioSetting("fmdw", "FM Dual Watch", RadioSettingValueBoolean(_settings.fmdw)) cfg_grp.append(rs) rs = RadioSetting("fmscan_off", "FM Scan", RadioSettingValueBoolean( not _settings.fmscan_off)) cfg_grp.append(rs) rs = RadioSetting("keypadmic_off", "Keypad MIC", RadioSettingValueBoolean( not _settings.keypadmic_off)) cfg_grp.append(rs) rs = RadioSetting("voxgain", "VOX Gain", RadioSettingValueList( VOXGAIN_LIST, VOXGAIN_LIST[_settings.voxgain])) cfg_grp.append(rs) rs = RadioSetting("voxdt", "VOX Delay Time", RadioSettingValueList( VOXDT_LIST, VOXDT_LIST[_settings.voxdt])) cfg_grp.append(rs) rs = RadioSetting("vir", "VOX Inhibit on Receive", RadioSettingValueBoolean(_settings.vir)) cfg_grp.append(rs) # # Advanced Settings # val = (_settings.dtmftime) - 5 rs = RadioSetting("dtmftime", "DTMF Digit Time", RadioSettingValueList( DTMFTIME_LIST, DTMFTIME_LIST[val])) adv_grp.append(rs) val = (_settings.dtmfspace) - 5 rs = RadioSetting("dtmfspace", "DTMF Digit Space Time", RadioSettingValueList( DTMFTIME_LIST, DTMFTIME_LIST[val])) adv_grp.append(rs) val = (_settings.dtmfdelay) / 5 rs = RadioSetting("dtmfdelay", "DTMF 1st Digit Delay", RadioSettingValueList( DTMFDELAY_LIST, DTMFDELAY_LIST[val])) adv_grp.append(rs) val = (_settings.dtmfpretime) / 10 - 1 rs = RadioSetting("dtmfpretime", "DTMF Pretime", RadioSettingValueList( DTMFPRETIME_LIST, DTMFPRETIME_LIST[val])) adv_grp.append(rs) val = (_settings.dtmfdelay2) / 5 rs = RadioSetting("dtmfdelay2", "DTMF * and # Digit Delay", RadioSettingValueList( DTMFDELAY2_LIST, DTMFDELAY2_LIST[val])) adv_grp.append(rs) rs = RadioSetting("ackdecode", "ACK Decode", RadioSettingValueBoolean(_settings.ackdecode)) adv_grp.append(rs) rs = RadioSetting("dtmfst", "DTMF Sidetone", RadioSettingValueBoolean(_settings.dtmfst)) adv_grp.append(rs) rs = RadioSetting("service.rssi400", "Squelch Base Level (UHF)", RadioSettingValueInteger(0, 255, _service.rssi400)) adv_grp.append(rs) rs = RadioSetting("service.rssi136", "Squelch Base Level (VHF)", RadioSettingValueInteger(0, 255, _service.rssi136)) adv_grp.append(rs) # # Key Settings # val = (_settings.lptime) - 5 rs = RadioSetting("lptime", "Long Press Time", RadioSettingValueList( LPTIME_LIST, LPTIME_LIST[val])) key_grp.append(rs) rs = RadioSetting("keyp1long", "P1 Long Key", RadioSettingValueList( PFKEYLONG_LIST, PFKEYLONG_LIST[_settings.keyp1long])) key_grp.append(rs) rs = RadioSetting("keyp1short", "P1 Short Key", RadioSettingValueList( PFKEYSHORT_LIST, PFKEYSHORT_LIST[_settings.keyp1short])) key_grp.append(rs) rs = RadioSetting("keyp2long", "P2 Long Key", RadioSettingValueList( PFKEYLONG_LIST, PFKEYLONG_LIST[_settings.keyp2long])) key_grp.append(rs) rs = RadioSetting("keyp2short", "P2 Short Key", RadioSettingValueList( PFKEYSHORT_LIST, PFKEYSHORT_LIST[_settings.keyp2short])) key_grp.append(rs) rs = RadioSetting("keyp3long", "P3 Long Key", RadioSettingValueList( PFKEYLONG_LIST, PFKEYLONG_LIST[_settings.keyp3long])) key_grp.append(rs) rs = RadioSetting("keyp3short", "P3 Short Key", RadioSettingValueList( PFKEYSHORT_LIST, PFKEYSHORT_LIST[_settings.keyp3short])) key_grp.append(rs) val = RadioSettingValueList(PFKEYSHORT_LIST, PFKEYSHORT_LIST[_settings.keymshort]) val.set_mutable(_settings.menuen == 0) rs = RadioSetting("keymshort", "M Short Key", val) key_grp.append(rs) val = RadioSettingValueBoolean(_settings.menuen) rs = RadioSetting("menuen", "Menu Enable", val) key_grp.append(rs) return group
def _get_settings(self): _settings = self._memobj.settings _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