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(pipe, vfo, number): """Get a memory object for @vfo and @number via @pipe""" rframe = get_memory_frame(pipe, vfo, number) if len(rframe.get_payload()) < 1: raise errors.InvalidMemoryLocation("No response from radio") if rframe.get_payload()[3] == '\xff': raise errors.InvalidMemoryLocation("Radio says location is empty") mf = IC92MemoryFrame() mf.from_frame(rframe) return mf.get_memory()
def get_memory(self, number): if isinstance(number, str): try: number = THD72_SPECIAL[number] except KeyError: raise errors.InvalidMemoryLocation("Unknown channel %s" % number) if number < 0 or number > (max(THD72_SPECIAL.values()) + 1): raise errors.InvalidMemoryLocation( "Number must be between 0 and 999") _mem = self._memobj.memory[number] flag = self._memobj.flag[number] mem = chirp_common.Memory() mem.number = number if number > 999: mem.extd_number = THD72_SPECIAL_REV[number] if flag.disabled == 0xf: mem.empty = True return mem mem.name = self.get_channel_name(number) mem.freq = int(_mem.freq) mem.tmode = TMODES[int(_mem.tone_mode)] mem.rtone = chirp_common.TONES[_mem.rtone] mem.ctone = chirp_common.TONES[_mem.ctone] mem.dtcs = chirp_common.DTCS_CODES[_mem.dtcs] mem.duplex = DUPLEX[int(_mem.duplex)] mem.offset = int(_mem.offset) mem.mode = MODES[int(_mem.mode)] if number < 999: mem.skip = chirp_common.SKIP_VALUES[int(flag.skip)] mem.cross_mode = chirp_common.CROSS_MODES[_mem.cross_mode] if number > 999: mem.cross_mode = chirp_common.CROSS_MODES[0] mem.immutable = ["number", "bank", "extd_number", "cross_mode"] if number >= 1020 and number < 1030: mem.immutable += [ "freq", "offset", "tone", "mode", "tmode", "ctone", "skip" ] # FIXME: ALL else: mem.immutable += ["name"] return mem
def get_memory(map, number): if number < 0 or number > (max(V71_SPECIAL.values()) + 1): raise errors.InvalidMemoryLocation("Number must be between 0 and 999") mem = chirp_common.Memory() mem.number = number if number > 999: mem.extd_number = V71_SPECIAL_REV[number] if not get_used(map, number): mem.empty = True return mem mmap = get_raw_mem(map, number) mem.freq = get_freq(mmap) mem.name = get_name(map, number) mem.tmode = get_tmode(mmap) mem.rtone = get_tone(mmap, POS_RTONE) mem.ctone = get_tone(mmap, POS_CTONE) mem.dtcs = get_dtcs(mmap) mem.duplex = get_duplex(mmap) mem.offset = get_offset(mmap) mem.mode = get_mode(mmap) if number < 999: mem.skip = get_skip(map, number) if number > 999: mem.immutable = ["number", "bank", "extd_number", "name"] if number > 1020 and number < 1030: mem.immutable += ["freq"] # FIXME: ALL return mem
def set_memory(self, memory): if memory.number < 0 or memory.number > self._upper: raise errors.InvalidMemoryLocation( "Number must be between 0 and %i" % self._upper) spec = self._make_mem_spec(memory) spec = ",".join(spec) r1 = command(self.pipe, *self._cmd_set_memory(memory.number, spec)) if not iserr(r1): time.sleep(0.5) r2 = command( self.pipe, *self._cmd_set_memory_name(memory.number, memory.name)) if not iserr(r2): memory.name = memory.name.rstrip() self._memcache[memory.number] = memory else: raise errors.InvalidDataError( "Radio refused name %i: %s" % (memory.number, repr(memory.name))) else: raise errors.InvalidDataError("Radio refused %i" % memory.number) if memory.duplex == "split" and self._kenwood_split: spec = ",".join(self._make_split_spec(memory)) result = command(self.pipe, *self._cmd_set_split(memory.number, spec)) if iserr(result): raise errors.InvalidDataError("Radio refused %i" % memory.number)
def get_memory(self, number): if number > self._upper: raise errors.InvalidMemoryLocation("Number must be <400") mem = ic9x_icf_ll.get_memory(self._mmap, 850 + number) mem.number = number return mem
def _get_mems_until_hole(self, start, endokay=False, all=False): mems = [] llimit, ulimit = self.rthread.radio.get_features().memory_bounds pos = start while pos <= ulimit: self.status( _("Looking for a free spot ({number})").format(number=pos), 0) try: mem = self.rthread.radio.get_memory(pos) if mem.empty and not all: break except errors.InvalidMemoryLocation: break mems.append(mem) pos += 1 if pos > ulimit and not endokay: raise errors.InvalidMemoryLocation(_("No space to insert a row")) LOG.debug("Found a hole: %i" % pos) return mems
def set_memory(self, memory): if memory.number < 0 or memory.number > self._upper: raise errors.InvalidMemoryLocation( "Number must be between 0 and %i" % self._upper) spec = self._make_mem_spec(memory) spec = "".join(spec) r1 = command(self.pipe, *self._cmd_set_memory(memory.number, spec)) if not iserr(r1): memory.name = memory.name.rstrip() self._memcache[memory.number] = memory # if we're tuned to the channel, reload it r1 = command(self.pipe, *self._cmd_cur_memory(memory.number)) if not iserr(r1): pattern = re.compile("MC([0-9]{3})") match = pattern.search(r1) if match is not None: cur_mem = int(match.group(1)) if cur_mem == memory.number: cur_mem = \ command(self.pipe, *self._cmd_recall_memory(memory.number)) else: raise errors.InvalidDataError("Radio refused %i" % memory.number) # FIXME if memory.duplex == "split" and self._kenwood_split: spec = "".join(self._make_split_spec(memory)) result = command(self.pipe, *self._cmd_set_split(memory.number, spec)) if iserr(result): raise errors.InvalidDataError("Radio refused %i" % memory.number)
def set_memory(map, mem): if mem.number < 0 or mem.number > (max(V71_SPECIAL.values()) + 1): raise errors.InvalidMemoryLocation("Number must be between 0 and 999") mmap = memmap.MemoryMap(get_raw_mem(map, mem.number)) if not get_used(map, mem.number): initialize(mmap) set_freq(mmap, mem.freq) if mem.number < 999: set_name(map, mem.number, mem.name) set_tmode(mmap, mem.tmode) set_tone(mmap, mem.rtone, POS_RTONE) set_tone(mmap, mem.ctone, POS_CTONE) set_dtcs(mmap, mem.dtcs) set_duplex(mmap, mem.duplex) set_offset(mmap, mem.offset) set_mode(mmap, mem.mode) base = get_mem_offset(mem.number) map[base] = mmap.get_packed() set_used(map, mem.number, mem.freq) if mem.number < 999: set_skip(map, mem.number, mem.skip) return map
def get_memory(self, number): if isinstance(number, str): try: number = tmv71_ll.V71_SPECIAL[number] except KeyError: raise errors.InvalidMemoryLocation("Unknown channel %s" % number) return tmv71_ll.get_memory(self._mmap, number)
def set_memory(self, mem): if mem.number != 0: raise errors.InvalidMemoryLocation("AP510 has only one slot") self._mmap.freq = "%8.4f" % (mem.freq / 1000000.0) if mem.power: try: self._mmap.tx_power = str(POWER_LEVELS.index(mem.power)) except NotImplementedError: pass
def get_memory(self, number): if number != 0: raise errors.InvalidMemoryLocation("Repeaters have only one slot") mem = chirp_common.Memory() mem.number = 0 mem.freq = get_freq(self.pipe) mem.name = "TX/RX" mem.mode = "DV" mem.offset = 0.0 mem.immutable = RP_IMMUTABLE return mem
def get_memory(self, number): if not self._mmap: self.sync_in() assert (self._mmap) if isinstance(number, str): try: number = SPECIAL[number] except KeyError: raise errors.InvalidMemoryLocation("Unknown channel %s" % number) return self._get_memory(number)
def set_memory(self, mem): LOG.debug("set_memory(%d)" % mem.number) if mem.number < 0 or mem.number > (max(THD72_SPECIAL.values()) + 1): raise errors.InvalidMemoryLocation( "Number must be between 0 and 999") # weather channels can only change name, nothing else if mem.number >= 1020 and mem.number < 1030: self.set_channel_name(mem.number, mem.name) return flag = self._memobj.flag[mem.number] self.add_dirty_block(self._memobj.flag[mem.number]) # only delete non-WX channels was_empty = flag.disabled == 0xf if mem.empty: flag.disabled = 0xf return flag.disabled = 0 _mem = self._memobj.memory[mem.number] self.add_dirty_block(_mem) if was_empty: self.initialize(_mem) _mem.freq = mem.freq if mem.number < 999: self.set_channel_name(mem.number, mem.name) _mem.tone_mode = TMODES_REV[mem.tmode] _mem.rtone = chirp_common.TONES.index(mem.rtone) _mem.ctone = chirp_common.TONES.index(mem.ctone) _mem.dtcs = chirp_common.DTCS_CODES.index(mem.dtcs) _mem.cross_mode = chirp_common.CROSS_MODES.index(mem.cross_mode) _mem.duplex = DUPLEX_REV[mem.duplex] _mem.offset = mem.offset _mem.mode = MODES_REV[mem.mode] prog_vfo = get_prog_vfo(mem.freq) flag.prog_vfo = prog_vfo _mem.unknown1 = _mem.unknown2 = UNKNOWN_LOOKUP[prog_vfo] if mem.number < 999: flag.skip = chirp_common.SKIP_VALUES.index(mem.skip)
def get_memory(self, number): if number != 0: raise errors.InvalidMemoryLocation("AP510 has only one slot") mem = chirp_common.Memory() mem.number = 0 mem.freq = float(self._mmap.freq) * 1000000 mem.name = "TX/RX" mem.mode = "FM" mem.offset = 0.0 try: mem.power = POWER_LEVELS[int(self._mmap.tx_power)] except NotImplementedError: mem.power = POWER_LEVELS[1] mem.immutable = RP_IMMUTABLE return mem
def get_memory(self, number): if not self._mmap: self.sync_in() if self._isuhf: base = 400 else: base = 0 if isinstance(number, str): try: number = icx8x_ll.ICx8x_SPECIAL[number] except KeyError: raise errors.InvalidMemoryLocation("Unknown channel %s" % number) return icx8x_ll.get_memory(self._mmap, number, base)
def _from_csv(cls, _line): line = _line.strip() if line.startswith("Location"): raise errors.InvalidMemoryLocation("Non-CSV line") vals = line.split(SEPCHAR) if len(vals) < 11: raise errors.InvalidDataError("CSV format error " + "(14 columns expected)") if vals[10] == "DV": mem = DVMemory() else: mem = Memory() mem.really_from_csv(vals) return mem
def get_memory(self, number): if isinstance(number, str): try: number = ID800_SPECIAL[number] + 1 # Because we subtract below except KeyError: raise errors.InvalidMemoryLocation("Unknown channel %s" % number) _mem = self._memobj.memory[number - 1] _flg = self._memobj.flags[number - 1] if MODES[_mem.mode] == "DV": urcalls = self.get_urcall_list() rptcalls = self.get_repeater_call_list() mem = chirp_common.DVMemory() mem.dv_urcall = urcalls[_mem.urcall] mem.dv_rpt1call = rptcalls[_mem.rpt1call] mem.dv_rpt2call = rptcalls[_mem.rpt2call] mem.dv_code = _mem.digital_code else: mem = chirp_common.Memory() mem.number = number if _flg.empty: mem.empty = True return mem mult = _mem.mult_flag and 6250 or 5000 mem.freq = _mem.freq * mult mem.offset = _mem.offset * 5000 mem.duplex = DUPLEX[_mem.duplex] mem.mode = MODES[_mem.mode] mem.tmode = TMODES[_mem.tmode] mem.rtone = chirp_common.TONES[_mem.rtone] mem.ctone = chirp_common.TONES[_mem.ctone] mem.dtcs = chirp_common.DTCS_CODES[_mem.dtcs] mem.dtcs_polarity = DTCS_POL[_mem.dtcs_polarity] mem.tuning_step = STEPS[_mem.tuning_step] mem.name = get_name(_mem) mem.skip = _flg.pskip and "P" or _flg.skip and "S" or "" return mem
def get_memory(self, number): if number < 0 or number > self._upper: raise errors.InvalidMemoryLocation( "Number must be between 0 and %i" % self._upper) if number in self._memcache and not NOCACHE: return self._memcache[number] result = command(self.pipe, *self._cmd_get_memory(number)) if result == "N" or result == "E": mem = chirp_common.Memory() mem.number = number mem.empty = True self._memcache[mem.number] = mem return mem elif " " not in result: LOG.error("Not sure what to do with this: `%s'" % result) raise errors.RadioError("Unexpected result returned from radio") value = result.split(" ")[1] spec = value.split(",") mem = self._parse_mem_spec(spec) self._memcache[mem.number] = mem result = command(self.pipe, *self._cmd_get_memory_name(number)) if " " in result: value = result.split(" ", 1)[1] if value.count(",") == 2: _zero, _loc, mem.name = value.split(",") else: _loc, mem.name = value.split(",") if mem.duplex == "" and self._kenwood_split: result = command(self.pipe, *self._cmd_get_split(number)) if " " in result: value = result.split(" ", 1)[1] self._parse_split_spec(mem, value.split(",")) return mem
def get_memory(self, number): if isinstance(number, str): try: number = IC9X_SPECIAL[self.vfo][number] except KeyError: raise errors.InvalidMemoryLocation("Unknown channel %s" % number) if number < -2 or number > 999: raise errors.InvalidValueError("Number must be between 0 and 999") if number in self.__memcache: return self.__memcache[number] self._lock.acquire() try: self._maybe_send_magic() mem = ic9x_ll.get_memory(self.pipe, self.vfo, number) except errors.InvalidMemoryLocation: mem = chirp_common.Memory() mem.number = number if number < self._upper: mem.empty = True except: self._lock.release() raise self._lock.release() if number > self._upper or number < 0: mem.extd_number = util.get_dict_rev(IC9X_SPECIAL, [self.vfo][number]) mem.immutable = [ "number", "skip", "bank", "bank_index", "extd_number" ] self.__memcache[mem.number] = mem return mem
def set_memory(self, memory): if memory.number < 0 or memory.number > self._upper: raise errors.InvalidMemoryLocation( "Number must be between 0 and %i" % self._upper) if memory.number > 90: if memory.duplex == TS850_DUPLEX[0]: memory.duplex = TS850_DUPLEX[1] memory.offset = memory.freq else: if memory.freq > memory.offset: temp = memory.freq memory.freq = memory.offset memory.offset = temp # Clear out memory contents to prevent errors spec = self._make_base_spec(memory, 0) spec = "".join(spec) result = command(self.pipe, *self._cmd_set_memory(memory.number, spec)) if iserr(result): raise errors.InvalidDataError("Radio refused %i" % memory.number) # If we have a split set the transmit frequency first. if memory.duplex == TS850_DUPLEX[1]: spec = "".join(self._make_split_spec(memory)) result = command(self.pipe, *self._cmd_set_split(memory.number, spec)) if iserr(result): raise errors.InvalidDataError("Radio refused %i" % memory.number) spec = self._make_mem_spec(memory) spec = "".join(spec) result = command(self.pipe, *self._cmd_set_memory(memory.number, spec)) if iserr(result): raise errors.InvalidDataError("Radio refused %i" % memory.number)
def get_memory(self, number): if number < 0 or number > self._upper: raise errors.InvalidMemoryLocation( "Number must be between 0 and %i" % self._upper) if number in self._memcache and not NOCACHE: return self._memcache[number] result = command(self.pipe, *self._cmd_get_memory(number)) if result == "N": mem = chirp_common.Memory() mem.number = number mem.empty = True self._memcache[mem.number] = mem return mem mem = self._parse_mem_spec(result) self._memcache[mem.number] = mem # check for split frequency operation if mem.duplex == "" and self._kenwood_split: result = command(self.pipe, *self._cmd_get_split(number)) self._parse_split_spec(mem, result) return mem
def get_memory(self, number): if number > self._upper: raise errors.InvalidMemoryLocation("Number must be <800") return ic9x_icf_ll.get_memory(self._mmap, number)
def get_memory(self, number): try: return self.memories[number] except: raise errors.InvalidMemoryLocation("No such memory %s" % number)
def set_memory(self, mem): if mem.number != 0: raise errors.InvalidMemoryLocation("Repeaters have only one slot") set_freq(self.pipe, mem.freq)
def get_memory(doc, number): """Extract a Memory object from @doc""" ctx = doc.xpathNewContext() base = "//radio/memories/memory[@location=%i]" % number fields = ctx.xpathEval(base) if len(fields) > 1: raise errors.RadioError("%i memories claiming to be %i" % (len(fields), number)) elif len(fields) == 0: raise errors.InvalidMemoryLocation("%i does not exist" % number) memnode = fields[0] def _get(ext): path = base + ext result = ctx.xpathEval(path) if result: return result[0].getContent() else: return "" if _get("/mode/text()") == "DV": mem = chirp_common.DVMemory() mem.dv_urcall = _get("/dv/urcall/text()") mem.dv_rpt1call = _get("/dv/rpt1call/text()") mem.dv_rpt2call = _get("/dv/rpt2call/text()") try: mem.dv_code = _get("/dv/digitalCode/text()") except ValueError: mem.dv_code = 0 else: mem = chirp_common.Memory() mem.number = int(memnode.prop("location")) mem.name = _get("/longName/text()") mem.freq = chirp_common.parse_freq(_get("/frequency/text()")) mem.rtone = float(_get("/squelch[@id='rtone']/tone/text()")) mem.ctone = float(_get("/squelch[@id='ctone']/tone/text()")) mem.dtcs = int(_get("/squelch[@id='dtcs']/code/text()"), 10) mem.dtcs_polarity = _get("/squelch[@id='dtcs']/polarity/text()") try: sql = _get("/squelchSetting/text()") if sql == "rtone": mem.tmode = "Tone" elif sql == "ctone": mem.tmode = "TSQL" elif sql == "dtcs": mem.tmode = "DTCS" else: mem.tmode = "" except IndexError: mem.tmode = "" dmap = {"positive": "+", "negative": "-", "none": ""} dupx = _get("/duplex/text()") mem.duplex = dmap.get(dupx, "") mem.offset = chirp_common.parse_freq(_get("/offset/text()")) mem.mode = _get("/mode/text()") mem.tuning_step = float(_get("/tuningStep/text()")) skip = _get("/skip/text()") if skip == "none": mem.skip = "" else: mem.skip = skip # FIXME: bank support in .chirp files needs to be re-written # bank_id = _get("/bank/@bankId") # if bank_id: # mem.bank = int(bank_id) # bank_index = _get("/bank/@bankIndex") # if bank_index: # mem.bank_index = int(bank_index) return mem