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
