def get_settings(self): _mem = self._memobj basic = RadioSettingGroup("basic", "Basic") top = RadioSettings(basic) def _f(val): string = "" for char in str(val): if char == "\xFF": break string += char return string line1 = RadioSetting( "messages.line1", "Message Line 1", RadioSettingValueString(0, 32, _f(_mem.messages.line1), autopad=False)) basic.append(line1) line2 = RadioSetting( "messages.line2", "Message Line 2", RadioSettingValueString(0, 32, _f(_mem.messages.line2), autopad=False)) basic.append(line2) return top
def _get_display_settings(self): menu = RadioSettingGroup("display", "Display") display_settings = self._memobj.settings val = RadioSettingValueString( 0, 8, str(display_settings.power_on_msg).rstrip("\xFF")) rs = RadioSetting("display.power_on_msg", "Power on message", val) rs.set_apply_callback(self.apply_power_on_msg, display_settings) menu.append(rs) val = RadioSettingValueList( self._LCD_CONTRAST, self._LCD_CONTRAST[display_settings.contrast - 1]) rs = RadioSetting("display.contrast", "LCD Contrast", val) rs.set_apply_callback(self.apply_lcd_contrast, display_settings) menu.append(rs) val = RadioSettingValueList( self._LAMP_CONTROL, self._LAMP_CONTROL[display_settings.lamp_control]) rs = RadioSetting("display.lamp_control", "Lamp Control", val) rs.set_apply_callback(self.apply_lamp_control, display_settings) menu.append(rs) val = RadioSettingValueList( self._LAMP_TIMER, self._LAMP_TIMER[display_settings.lamp_timer - 2]) rs = RadioSetting("display.lamp_timer", "Lamp Timer", val) rs.set_apply_callback(self.apply_lamp_timer, display_settings) menu.append(rs) return menu
def get_memory(self, number): _mem = self._memobj.memory[number - 1] _nam = self._memobj.chan_names[number - 1] def _is_empty(): for i in range(0, 4): if _mem.rx_freq[i].get_raw() != "\xFF": return False return True mem = chirp_common.Memory() mem.number = number if _is_empty(): mem.empty = True return mem mem.freq = int(_mem.rx_freq) * 10 if int(_mem.rx_freq) == int(_mem.tx_freq): mem.duplex = "" mem.offset = 0 else: mem.duplex = int(_mem.rx_freq) > int(_mem.tx_freq) and "-" or "+" mem.offset = abs(int(_mem.rx_freq) - int(_mem.tx_freq)) * 10 mem.mode = _mem.w_n and "FM" or "NFM" self._get_tone(_mem, mem) mem.power = POWER_LEVELS[_mem.power] mem.extra = RadioSettingGroup("Extra", "extra") rs = RadioSetting( "lout", "Lock out", RadioSettingValueList(OFF_ON_LIST, OFF_ON_LIST[_mem.lout])) mem.extra.append(rs) rs = RadioSetting( "busy_loc", "Busy lock", RadioSettingValueList(BUSYLOCK_LIST, BUSYLOCK_LIST[_mem.busy_loc])) mem.extra.append(rs) rs = RadioSetting( "scan_add", "Scan add", RadioSettingValueList(NO_YES_LIST, NO_YES_LIST[_mem.scan_add])) mem.extra.append(rs) #TODO: Show name channel ## count = 0 ## for i in _nam.chan_name: ## if i == 0xFF: ## break ## try: ## mem.name += IP620_CHARSET[i] ## except Exception: ## LOG.error("Unknown name char %i: 0x%02x (mem %i)" % ## (count, i, number - 1)) ## mem.name += " " ## count += 1 ## mem.name = mem.name.rstrip() return mem
def get_memory(self, number): _mem = self._memobj.memory[number - 1] mem = chirp_common.Memory() mem.number = number if _mem.get_raw().startswith("\xFF\xFF\xFF\xFF"): mem.empty = True return mem mem.freq = int(_mem.rx_freq) * 10 txfreq = int(_mem.tx_freq) * 10 if self._is_txinh(_mem): mem.duplex = "off" mem.offset = 0 elif txfreq == mem.freq: mem.duplex = "" elif abs(txfreq - mem.freq) > 70000000: mem.duplex = "split" mem.offset = txfreq elif txfreq < mem.freq: mem.duplex = "-" mem.offset = mem.freq - txfreq elif txfreq > mem.freq: mem.duplex = "+" mem.offset = txfreq - mem.freq txmode, txval, txpol = self._decode_tone(_mem.tx_tone) rxmode, rxval, rxpol = self._decode_tone(_mem.rx_tone) chirp_common.split_tone_decode(mem, (txmode, txval, txpol), (rxmode, rxval, rxpol)) mem.name = str(self._memobj.names[number - 1].name) mem.name = mem.name.replace("\xFF", " ").rstrip() mem.skip = not _mem.scan and "S" or "" mem.mode = _mem.isnarrow and "NFM" or "FM" mem.power = POWER_LEVELS[1 - _mem.ishighpower] mem.extra = RadioSettingGroup("extra", "Extra Settings") rs = RadioSetting( "pttid", "PTT ID", RadioSettingValueList(PTTID_LIST, PTTID_LIST[_mem.pttid])) mem.extra.append(rs) rs = RadioSetting("vox", "VOX", RadioSettingValueBoolean(_mem.vox)) mem.extra.append(rs) rs = RadioSetting("bcl", "Busy Channel Lockout", RadioSettingValueList(BCL_LIST, BCL_LIST[_mem.bcl])) mem.extra.append(rs) rs = RadioSetting( "scramble_code", "Scramble Code", RadioSettingValueList(CODES_LIST, CODES_LIST[_mem.scramble_code])) mem.extra.append(rs) return mem
def get_memory(self, number): bitpos = (1 << ((number - 1) % 8)) bytepos = ((number - 1) / 8) LOG.debug("bitpos %s" % bitpos) LOG.debug("bytepos %s" % bytepos) _mem = self._memobj.memory[number - 1] _skp = self._memobj.skipflags[bytepos] mem = chirp_common.Memory() mem.number = number mem.freq = int(_mem.rxfreq) * 10 # We'll consider any blank (i.e. 0MHz frequency) to be empty if mem.freq == 0: mem.empty = True return mem if _mem.rxfreq.get_raw() == "\xFF\xFF\xFF\xFF": mem.freq = 0 mem.empty = True return mem if _mem.get_raw() == ("\xFF" * 16): LOG.debug("Initializing empty memory") _mem.set_raw("\x00" * 13 + "\x30\x8F\xF8") if int(_mem.rxfreq) == int(_mem.txfreq): mem.duplex = "" mem.offset = 0 else: mem.duplex = int(_mem.rxfreq) > int(_mem.txfreq) and "-" or "+" mem.offset = abs(int(_mem.rxfreq) - int(_mem.txfreq)) * 10 mem.mode = _mem.wide and "FM" or "NFM" self._get_tone(_mem, mem) mem.power = RT21_POWER_LEVELS[_mem.highpower] mem.skip = "" if (_skp & bitpos) else "S" LOG.debug("mem.skip %s" % mem.skip) mem.extra = RadioSettingGroup("Extra", "extra") rs = RadioSetting("bcl", "Busy Channel Lockout", RadioSettingValueList(BCL_LIST, BCL_LIST[_mem.bcl])) mem.extra.append(rs) rs = RadioSetting( "scramble_type", "Scramble Type", RadioSettingValueList(SCRAMBLE_LIST, SCRAMBLE_LIST[_mem.scramble_type - 8])) mem.extra.append(rs) return mem
def get_memory(self, number): _mem, _nam = self._get_memobjs(number) mem = chirp_common.Memory() if isinstance(number, str): mem.number = SPECIALS[number] mem.extd_number = number else: mem.number = number if _mem.freq.get_raw()[0] == "\xFF": mem.empty = True return mem mem.freq = int(_mem.freq) * 10 mem.offset = int(_mem.offset) * 10 chirp_common.split_tone_decode( mem, self._decode_tone(_mem.txtone, _mem.txpol), self._decode_tone(_mem.rxtone, _mem.rxpol)) if _mem.step > 0x05: _mem.step = 0x00 mem.duplex = DUPLEX[_mem.duplex] mem.mode = _mem.isnarrow and "NFM" or "FM" mem.skip = "" if _mem.scanadd else "S" mem.power = POWER_LEVELS[_mem.highpower] if mem.freq == mem.offset and mem.duplex == "-": mem.duplex = "off" mem.offset = 0 if _nam: for char in _nam: try: mem.name += CHARSET[char] except IndexError: break mem.name = mem.name.rstrip() mem.extra = RadioSettingGroup("Extra", "extra") rs = RadioSetting("bcl", "BCL", RadioSettingValueBoolean(_mem.bcl)) mem.extra.append(rs) rs = RadioSetting("revfreq", "Reverse Duplex", RadioSettingValueBoolean(_mem.revfreq)) mem.extra.append(rs) rs = RadioSetting("pttid", "PTT ID", RadioSettingValueBoolean(_mem.pttid)) mem.extra.append(rs) rs = RadioSetting("compander", "Compander", RadioSettingValueBoolean(_mem.compander)) mem.extra.append(rs) return mem
def get_memory(self, number): _mem = self._memobj.memory[number - 1] mem = chirp_common.Memory() mem.number = number mem.freq = int(_mem.rxfreq) * 10 # We'll consider any blank (i.e. 0MHz frequency) to be empty if mem.freq == 0: mem.empty = True return mem if _mem.rxfreq.get_raw() == "\xFF\xFF\xFF\xFF": mem.freq = 0 mem.empty = True return mem if int(_mem.rxfreq) == int(_mem.txfreq): mem.duplex = "" mem.offset = 0 else: mem.duplex = int(_mem.rxfreq) > int(_mem.txfreq) and "-" or "+" mem.offset = abs(int(_mem.rxfreq) - int(_mem.txfreq)) * 10 mem.mode = _mem.wide and "FM" or "NFM" rxtone = txtone = None txtone = self.decode_tone(_mem.txtone) rxtone = self.decode_tone(_mem.rxtone) chirp_common.split_tone_decode(mem, txtone, rxtone) mem.power = RT1_POWER_LEVELS[_mem.highpower] if _mem.skip: mem.skip = "S" mem.extra = RadioSettingGroup("Extra", "extra") rs = RadioSetting("bcl", "BCL", RadioSettingValueBoolean(not _mem.bcl)) mem.extra.append(rs) rs = RadioSetting("epilogue", "Epilogue(STE)", RadioSettingValueBoolean(not _mem.epilogue)) mem.extra.append(rs) rs = RadioSetting("compander", "Compander", RadioSettingValueBoolean(not _mem.compander)) mem.extra.append(rs) rs = RadioSetting("scramble", "Scramble", RadioSettingValueBoolean(not _mem.scramble)) mem.extra.append(rs) return mem
def get_memory(self, number): _mem = self._memobj.memory[number - 1] mem = chirp_common.Memory() mem.number = number bit = 1 << ((number - 1) % 8) byte = (number - 1) / 8 if self._memobj.emptyflags[byte] & bit: mem.empty = True return mem mem.freq = _mem.rx_freq * 10 mem.offset = abs(_mem.rx_freq - _mem.tx_freq) * 10 if _mem.tx_freq == _mem.rx_freq: mem.duplex = "" elif _mem.tx_freq < _mem.rx_freq: mem.duplex = "-" elif _mem.tx_freq > _mem.rx_freq: mem.duplex = "+" mem.mode = _mem.iswide and "FM" or "NFM" self._decode_tone(mem, _mem) mem.skip = (self._memobj.skipflags[byte] & bit) and "S" or "" for char in _mem.name: try: c = THUV3R_CHARSET[char] except: c = "" mem.name += c mem.name = mem.name.rstrip() mem.power = self.POWER_LEVELS[not _mem.power_high] mem.extra = RadioSettingGroup("extra", "Extra Settings") rs = RadioSetting("bclo_n", "Busy Channel Lockout", RadioSettingValueBoolean(not _mem.bclo_n)) mem.extra.append(rs) rs = RadioSetting("vox_n", "VOX", RadioSettingValueBoolean(not _mem.vox_n)) mem.extra.append(rs) rs = RadioSetting("tail", "Squelch Tail Elimination", RadioSettingValueBoolean(_mem.tail)) mem.extra.append(rs) rs = RadioSetting( "voice_mode", "Voice Mode", RadioSettingValueList(VOICE_MODE_LIST, VOICE_MODE_LIST[_mem.voice_mode - 1])) mem.extra.append(rs) return mem
def get_memory(self, number): """Return a Memory object for the memory at location @number""" try: rmem = self._memobj.memory[number - 1] except KeyError: raise errors.InvalidMemoryLocation('Unknown channel %s' % number) if number < 1 or number > self.CHANNELS: raise errors.InvalidMemoryLocation( 'Channel number must be 1 and %s' % self.CHANNELS) mem = chirp_common.Memory() mem.number = number mem.freq = int(rmem.rxfreq) * 10 # A blank (0MHz) or 0xFFFFFFFF frequency is considered empty if mem.freq == 0 or rmem.rxfreq.get_raw() == '\xFF\xFF\xFF\xFF': LOG.debug('empty channel %d', number) mem.freq = 0 mem.empty = True return mem if rmem.txfreq.get_raw() == '\xFF\xFF\xFF\xFF': mem.duplex = 'off' mem.offset = 0 elif int(rmem.rxfreq) == int(rmem.txfreq): mem.duplex = '' mem.offset = 0 else: mem.duplex = '-' if int(rmem.rxfreq) > int(rmem.txfreq) else '+' mem.offset = abs(int(rmem.rxfreq) - int(rmem.txfreq)) * 10 mem.mode = 'NFM' if rmem.narrow else 'FM' mem.skip = 'S' if rmem.skip else '' mem.power = self.X3P_POWER_LEVELS[rmem.highpower] txtone = self._decode_tone(rmem.txtone) rxtone = self._decode_tone(rmem.rxtone) chirp_common.split_tone_decode(mem, txtone, rxtone) mem.extra = RadioSettingGroup('Extra', 'extra') mem.extra.append( RadioSetting('bcl', 'Busy Channel Lockout', RadioSettingValueBoolean(current=(not rmem.bcl)))) mem.extra.append( RadioSetting( 'scramble', 'Scramble', RadioSettingValueBoolean(current=(not rmem.scramble)))) mem.extra.append( RadioSetting( 'compander', 'Compander', RadioSettingValueBoolean(current=(not rmem.compander)))) return mem
def _get_memory(self, number): bit = 1 << (number % 8) byte = int(number / 8) mem = chirp_common.Memory() mem.number = number _mem = self._memobj.memory[number] if number < 200: _usd = self._memobj.used[byte] _skp = self._memobj.skips[byte] else: mem.extd_number = SPECIAL_REV[number] mem.immutable = ["name", "number", "extd_number", "skip"] _usd = self._memobj.used[byte] if (number <= 206) else None _skp = None if _usd is not None and (_usd & bit): mem.empty = True return mem mem.freq = _mem.freq mem.offset = int(_mem.offset) if number < 200: mem.name = str(_mem.name).rstrip() mem.rtone = chirp_common.TONES[_mem.rtone] mem.ctone = chirp_common.TONES[_mem.ctone] mem.dtcs = chirp_common.DTCS_CODES[_mem.dtcs] mem.tuning_step = TUNING_STEPS[_mem.tuning_step] mem.mode = MODES[_mem.mode] mem.duplex = DUPLEXES[_mem.duplex] mem.dtcs_polarity = DTCS_POLARITY[_mem.dtcs_polarity] mem.tmode = TMODES[_mem.tmode] mem.power = POWER_LEVELS[_mem.power] # Extras mem.extra = RadioSettingGroup("extra", "Extra") rev = RadioSetting("rev", "Reverse duplex", RadioSettingValueBoolean(bool(_mem.rev))) rev.set_doc("Reverse duplex") mem.extra.append(rev) tx = RadioSetting("tx", "Tx permission", RadioSettingValueBoolean(bool(_mem.tx))) tx.set_doc("Tx permission") mem.extra.append(tx) if _skp is not None: mem.skip = (_skp & bit) and "S" or "" return mem
def _get_ost(self, parent): tones = chirp_common.TONES[:] def apply_tone(setting, index, which): if str(setting.value) == 'Off': val = 0xFFFF else: val = int(float(str(setting.value)) * 10) setattr(self._memobj.ost_tones[index], '%stone' % which, val) def _tones(): return ['Off'] + [str(x) for x in tones] for i in range(0, 40): _ost = self._memobj.ost_tones[i] ost = RadioSettingGroup('ost%i' % i, 'OST %i' % (i + 1)) cur = str(_ost.name).rstrip('\x00') name = RadioSetting('name%i' % i, 'Name', RadioSettingValueString(0, 12, cur)) ost.append(name) if _ost.rxtone == 0xFFFF: cur = 'Off' else: cur = round(int(_ost.rxtone) / 10.0, 1) if cur not in tones: LOG.debug('Non-standard OST rx tone %i %s' % (i, cur)) tones.append(cur) tones.sort() rx = RadioSetting('rxtone%i' % i, 'RX Tone', RadioSettingValueList(_tones(), str(cur))) rx.set_apply_callback(apply_tone, i, 'rx') ost.append(rx) if _ost.txtone == 0xFFFF: cur = 'Off' else: cur = round(int(_ost.txtone) / 10.0, 1) if cur not in tones: LOG.debug('Non-standard OST tx tone %i %s' % (i, cur)) tones.append(cur) tones.sort() tx = RadioSetting('txtone%i' % i, 'TX Tone', RadioSettingValueList(_tones(), str(cur))) tx.set_apply_callback(apply_tone, i, 'tx') ost.append(tx) parent.append(ost)
def get_memory(self, number): """Extract a high-level memory object from the low-level memory map, This is called to populate a memory in the UI""" # Get a low-level memory object mapped to the image _mem = self._memobj.memory[number - 1] # Create a high-level memory object to return to the UI mem = chirp_common.Memory() # number mem.number = number # empty if _mem.get_raw()[0] == "\xFF": mem.empty = True return mem # rx freq mem.freq = int(_mem.rx_freq) * 10 # checking if tx freq is empty, this is "possible" on the # original soft after a warning, and radio is happy with it if _mem.tx_freq.get_raw() == "\xFF\xFF\xFF\xFF": mem.duplex = "off" mem.offset = 0 else: rx = int(_mem.rx_freq) * 10 tx = int(_mem.tx_freq) * 10 if tx == rx: mem.offset = 0 mem.duplex = "" else: mem.duplex = rx > tx and "-" or "+" mem.offset = abs(tx - rx) # tone data txtone = self._decode_tone(_mem.tx_tone) rxtone = self._decode_tone(_mem.rx_tone) chirp_common.split_tone_decode(mem, txtone, rxtone) # Extra setting group, FD-268 don't uset it at all # FD-288's & others do it? mem.extra = RadioSettingGroup("extra", "Extra") busy = RadioSetting("Busy", "Busy Channel Lockout", RadioSettingValueBoolean( bool(_mem.busy_lock))) mem.extra.append(busy) scramble = RadioSetting("Scrambler", "Scrambler Option", RadioSettingValueBoolean( bool(_mem.scrambler))) mem.extra.append(scramble) # return mem return mem
def _get_memory(self, mem, _mem): mem.freq = int(_mem.freq) * 10 mem.offset = int(_mem.offset) * 10 self._get_duplex(mem, _mem) mem.mode = self.MODES[_mem.mode] if mem.mode == "FM": if _mem.is_fm_narrow == 1: mem.mode = "NFM" mem.tuning_step = self.STEPSFM[_mem.fm_step] elif mem.mode == "AM": mem.tuning_step = self.STEPSAM[_mem.am_step] elif mem.mode == "CW" or mem.mode == "CWR": if _mem.is_cwdig_narrow == 1: mem.mode = "N" + mem.mode mem.tuning_step = self.STEPSSSB[_mem.ssb_step] else: try: mem.tuning_step = self.STEPSSSB[_mem.ssb_step] except IndexError: pass mem.skip = _mem.skip and "S" or "" self._get_tmode(mem, _mem) if _mem.tag_on_off == 1: for i in _mem.name: if i == 0xFF: break if chr(i) in self.CHARSET: mem.name += chr(i) else: # radio have some graphical chars that are not supported # we replace those with a * print "Replacing char %x with *" % i mem.name += "*" mem.name = mem.name.rstrip() else: mem.name = "" mem.extra = RadioSettingGroup("extra", "Extra") ipo = RadioSetting("ipo", "IPO", RadioSettingValueBoolean(bool(_mem.ipo))) ipo.set_doc("Bypass preamp") mem.extra.append(ipo) att = RadioSetting("att", "ATT", RadioSettingValueBoolean(bool(_mem.att))) att.set_doc("10dB front end attenuator") mem.extra.append(att) return mem
def get_memory(self, number): _mem = self._memobj.memory[number - 1] mem = chirp_common.Memory() mem.number = number if _mem.get_raw()[:4] == "\xFF\xFF\xFF\xFF": mem.empty = True return mem mem.freq = int(_mem.rx_freq) * 10 offset = (int(_mem.tx_freq) * 10) - mem.freq if offset < 0: mem.offset = abs(offset) mem.duplex = "-" elif offset > 0: mem.offset = offset mem.duplex = "+" else: mem.offset = 0 self._get_tone(_mem, mem) mem.power = POWER_LEVELS[_mem.highpower] mem.mode = MODES[_mem.wide] mem.skip = not _mem.scan and "S" or "" mem.extra = RadioSettingGroup("all", "All Settings") bcl = RadioSetting("bcl", "Busy Channel Lockout", RadioSettingValueBoolean(bool(_mem.bcl))) mem.extra.append(bcl) beat = RadioSetting("beatshift", "Beat Shift", RadioSettingValueBoolean(bool(_mem.beatshift))) mem.extra.append(beat) pttid = RadioSetting("pttid", "PTT ID", RadioSettingValueList(PTTID, PTTID[_mem.pttid])) mem.extra.append(pttid) signal = RadioSetting("signaling", "Signaling", RadioSettingValueList(SIGNAL, SIGNAL[ _mem.signaling & 0x01])) mem.extra.append(signal) return mem
def get_memory(self, number): _mem = self._memobj.memory[number - 1] mem = chirp_common.Memory() mem.number = number mem.freq = int(_mem.rxfreq) * 10 # We'll consider any blank (i.e. 0MHz frequency) to be empty if mem.freq == 0: mem.empty = True return mem if _mem.rxfreq.get_raw() == "\xFF\xFF\xFF\xFF": mem.freq = 0 mem.empty = True return mem if _mem.txfreq.get_raw() == "\xFF\xFF\xFF\xFF": mem.duplex = "off" mem.offset = 0 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.mode = not _mem.narrow and "FM" or "NFM" mem.skip = _mem.skip and "S" or "" txtone = self._decode_tone(_mem.txtone) rxtone = self._decode_tone(_mem.rxtone) chirp_common.split_tone_decode(mem, txtone, rxtone) mem.extra = RadioSettingGroup("Extra", "extra") rs = RadioSetting("bcl", "Busy Channel Lockout", RadioSettingValueBoolean(not _mem.bcl)) mem.extra.append(rs) rs = RadioSetting("scramble", "Scramble", RadioSettingValueBoolean(not _mem.scramble)) mem.extra.append(rs) rs = RadioSetting("compander", "Compander", RadioSettingValueBoolean(not _mem.compander)) mem.extra.append(rs) return mem
def decode_sql(self, mem, chan): """ examine the radio channel fields and determine the correct CHIRP CSV values for tmode, cross_mode, and sql_override """ mem.extra = RadioSettingGroup("Extra", "extra") extra_modes = ["(None)", "PAGER"] value = extra_modes[chan.sql_type == 6] valuelist = RadioSettingValueList(extra_modes, value) rs = RadioSetting("sql_override", "Squelch override", valuelist) mem.extra.append(rs) if chan.sql_type == 6: return sql_map = RADIO_TMODES[chan.sql_type] ndx = 0 if len(sql_map[0]) > 1: # the sql_type is TSQL or DCS, so there are multiple UI mappings x = getattr(chan, sql_map[1]) r = getattr(chan, sql_map[2]) ndx = self.LOOKUP.index([x == 0, r == 0]) if ndx == 3 and x == r: ndx = 4 mem.tmode = sql_map[0][ndx][0] cross = sql_map[0][ndx][1] if cross: mem.cross_mode = cross if chan.rx_ctcss: mem.ctone = TONE_MAP[chan.rx_ctcss] if chan.tx_ctcss: mem.rtone = TONE_MAP[chan.tx_ctcss] if chan.tx_dcs: mem.dtcs = DTCS_MAP[chan.tx_dcs] if chan.rx_dcs: mem.rx_dtcs = DTCS_MAP[chan.rx_dcs]
def get_settings(self): top = FT817Radio.get_settings(self) basic = top["basic"] rs = RadioSetting("emergency", "Emergency", RadioSettingValueBoolean(self._memobj.settings.emergency)) basic.append(rs) return top
def get_memory(self, number): if not self._repeaters: self.do_fetch() repeater = self._repeaters[number] mem = chirp_common.Memory() mem.number = number mem.name = repeater.get('city') mem.freq = chirp_common.parse_freq(repeater.get('frequency')) offset = chirp_common.parse_freq(repeater.get('offset', '0')) if offset > 0: mem.duplex = "+" elif offset < 0: mem.duplex = "-" else: mem.duplex = "" mem.offset = abs(offset) mem.mode = 'DMR' mem.comment = repeater.get('map_info') mem.extra = RadioSettingGroup("Extra", "extra") rs = RadioSetting( "color_code", "Color Code", RadioSettingValueList( range(16), int(repeater.get('color_code', 0)))) mem.extra.append(rs) return mem
def get_prog(i, val_list, valndx, sname, longname, f_apply): k = str(i + 1) val = val_list[valndx] valuelist = RadioSettingValueList(val_list, val) rs = RadioSetting(sname + k, longname + k, valuelist) rs.set_apply_callback(f_apply, i, self._memobj) group.append(rs)
def add_radio_setting(radio_setting_group, mem_field, ui_name, option_map, current, doc=None): setting = RadioSetting(mem_field, ui_name, RadioSettingValueMap(option_map, current)) if doc is not None: setting.set_doc(doc) radio_setting_group.append(setting)
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 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_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): _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_memory(self, number): _mem = self._memobj.memory[number] _flag = self._memobj.flags[number] mem = chirp_common.Memory() mem.number = number if _flag.empty: mem.empty = True return mem mult = int(TUNING_STEPS[_mem.tuning_step] * 1000) mem.freq = (_mem.frequency * mult) mem.offset = (_mem.offset * mult) mem.name = str(_mem.name).rstrip() mem.rtone = chirp_common.TONES[_mem.repeater_tone] mem.ctone = chirp_common.TONES[_mem.ctcss_tone] mem.dtcs = chirp_common.DTCS_CODES[_mem.dtcs_code] mem.tuning_step = TUNING_STEPS[_mem.tuning_step] mem.tmode = TONE_MODES[_mem.tone_mode] mem.mode = "NFM" if _mem.mode_narrow else "FM" mem.dtcs_polarity = DTCS_POLARITY[_mem.dtcs_polarity] mem.duplex = DUPLEX[_mem.duplex] mem.skip = "S" if _flag.skip else "" mem.power = POWER_LEVELS[_mem.power] # Reverse duplex mem.extra = RadioSettingGroup("extra", "Extra") rev = RadioSetting("reverse_duplex", "Reverse duplex", RadioSettingValueBoolean(bool(_mem.reverse_duplex))) rev.set_doc("Reverse duplex") mem.extra.append(rev) # Tx inhibit tx_inhibit = RadioSetting( "tx_inhibit", "TX inhibit", RadioSettingValueBoolean(bool(_mem.tx_inhibit))) tx_inhibit.set_doc("TX inhibit") mem.extra.append(tx_inhibit) # Memory display style opt = ["Frequency", "Label"] dsp = RadioSetting("display_style", "Display style", RadioSettingValueList(opt, opt[_mem.display_style])) dsp.set_doc("Memory display style") mem.extra.append(dsp) return mem
def _get_dtmf_settings(self): menu = RadioSettingGroup("dtmf_settings", "DTMF") dtmf = self._memobj.scan_settings val = RadioSettingValueList( self._DTMF_MODE, self._DTMF_MODE[dtmf.dtmf_mode]) rs = RadioSetting("scan_settings.dtmf_mode", "DTMF Mode", val) menu.append(rs) val = RadioSettingValueList( self._DTMF_DELAY, self._DTMF_DELAY[dtmf.dtmf_delay]) rs = RadioSetting( "scan_settings.dtmf_delay", "DTMF Delay", val) menu.append(rs) val = RadioSettingValueList( self._DTMF_SPEED, self._DTMF_SPEED[dtmf.dtmf_speed]) rs = RadioSetting( "scan_settings.dtmf_speed", "DTMF Speed", val) menu.append(rs) for i in range(10): name = "dtmf_%02d" % (i + 1) if i == 9: name = "dtmf_%02d" % 0 dtmfsetting = self._memobj.dtmf[i] dtmfstr = "" for c in dtmfsetting.memory: if c == 0xFF: break if c < len(FT70_DTMF_CHARS): dtmfstr += FT70_DTMF_CHARS[c] dtmfentry = RadioSettingValueString(0, 16, dtmfstr) dtmfentry.set_charset( FT70_DTMF_CHARS + list("abcdef ")) # Allow input in lowercase, space ? validation fails otherwise rs = RadioSetting(name, name.upper(), dtmfentry) rs.set_apply_callback(self.apply_dtmf, i) menu.append(rs) return menu
def get_string_setting(self, obj, valid_chars, desc1, desc2, group): content = '' maxlen = len(obj) for x in range(0, maxlen): content += chr(obj[x]) val = RadioSettingValueString(0, maxlen, content, True, valid_chars) rs = RadioSetting(desc1, desc2, val) rs.set_apply_callback(self.apply_str_to_bytearray, obj) group.append(rs)
def _get_aprs_smartbeacon(self): menu = RadioSettingGroup("aprs_smartbeacon", "APRS SmartBeacon") aprs = self._memobj.aprs val = RadioSettingValueList( self._SMARTBEACON_PROFILE, self._SMARTBEACON_PROFILE[aprs.active_smartbeaconing]) rs = RadioSetting("aprs.active_smartbeaconing", "SmartBeacon profile", val) menu.append(rs) for profile in range(3): pfx = "type%d" % (profile + 1) path = "aprs.smartbeaconing_profile[%d]" % profile prof = aprs.smartbeaconing_profile[profile] low_val = RadioSettingValueInteger(2, 30, prof.low_speed_mph) high_val = RadioSettingValueInteger(3, 70, prof.high_speed_mph) low_val.get_max = lambda: min(30, int(high_val.get_value()) - 1) rs = RadioSetting("%s.low_speed_mph" % path, "%s Low Speed (mph)" % pfx, low_val) menu.append(rs) rs = RadioSetting("%s.high_speed_mph" % path, "%s High Speed (mph)" % pfx, high_val) menu.append(rs) val = RadioSettingValueInteger(1, 100, prof.slow_rate_min) rs = RadioSetting("%s.slow_rate_min" % path, "%s Slow rate (minutes)" % pfx, val) menu.append(rs) val = RadioSettingValueInteger(10, 180, prof.fast_rate_sec) rs = RadioSetting("%s.fast_rate_sec" % path, "%s Fast rate (seconds)" % pfx, val) menu.append(rs) val = RadioSettingValueInteger(5, 90, prof.turn_angle) rs = RadioSetting("%s.turn_angle" % path, "%s Turn angle (degrees)" % pfx, val) menu.append(rs) val = RadioSettingValueInteger(1, 255, prof.turn_slop) rs = RadioSetting("%s.turn_slop" % path, "%s Turn slop" % pfx, val) menu.append(rs) val = RadioSettingValueInteger(5, 180, prof.turn_time_sec) rs = RadioSetting("%s.turn_time_sec" % path, "%s Turn time (seconds)" % pfx, val) menu.append(rs) return menu
def get_settings(self): _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