def test_import_bank(self):
dst_mem = chirp_common.Memory()
dst_mem.number = 1
src_mem = chirp_common.Memory()
src_mem.number = 2
dst_radio = FakeRadio(None)
src_radio = FakeRadio(None)
dst_bm = chirp_common.BankModel(dst_radio)
src_bm = chirp_common.BankModel(src_radio)
dst_banks = [chirp_common.Bank(dst_bm, 0, 'A'),
chirp_common.Bank(dst_bm, 1, 'B'),
chirp_common.Bank(dst_bm, 2, 'C'),
]
src_banks = [chirp_common.Bank(src_bm, 1, '1'),
chirp_common.Bank(src_bm, 2, '2'),
chirp_common.Bank(src_bm, 3, '3'),
]
self.mox.StubOutWithMock(dst_radio, 'get_mapping_models')
self.mox.StubOutWithMock(src_radio, 'get_mapping_models')
self.mox.StubOutWithMock(dst_bm, 'get_mappings')
self.mox.StubOutWithMock(src_bm, 'get_mappings')
self.mox.StubOutWithMock(dst_bm, 'get_memory_mappings')
self.mox.StubOutWithMock(src_bm, 'get_memory_mappings')
self.mox.StubOutWithMock(dst_bm, 'remove_memory_from_mapping')
self.mox.StubOutWithMock(dst_bm, 'add_memory_to_mapping')
dst_radio.get_mapping_models().AndReturn([dst_bm])
dst_bm.get_mappings().AndReturn(dst_banks)
src_radio.get_mapping_models().AndReturn([src_bm])
src_bm.get_mappings().AndReturn(src_banks)
src_bm.get_memory_mappings(src_mem).AndReturn([src_banks[0]])
dst_bm.get_memory_mappings(dst_mem).AndReturn([dst_banks[1]])
dst_bm.remove_memory_from_mapping(dst_mem, dst_banks[1])
dst_bm.add_memory_to_mapping(dst_mem, dst_banks[0])
self.mox.ReplayAll()
import_logic.import_bank(dst_radio, src_radio, dst_mem, src_mem)
def get_memory(self, number):
_mem, _nam = self._get_memobjs(number)
mem = chirp_common.Memory()
if isinstance(number, str):
mem.number = self.SPECIALS[number]
mem.extd_number = number
else:
mem.number = number
if _mem.freq.get_raw(asbytes=True)[0] == 0xff:
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, "tx"),
self._decode_tone(_mem, "rx"))
if 'step' in _mem and _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 _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):
"""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, number):
mem = chirp_common.Memory()
if isinstance(number, str):
# pms channel
mem.number = 1001 + SPECIALS.index(number)
mem.extd_number = number
mem.immutable = ["number", "extd_number", "name", "skip"]
_mem = self._memobj.pms[mem.number - 1001]
_nam = _skp = None
elif number > 1000:
# pms channel
mem.number = number
mem.extd_number = SPECIALS[number - 1001]
mem.immutable = ["number", "extd_number", "name", "skip"]
_mem = self._memobj.pms[mem.number - 1001]
_nam = _skp = None
else:
mem.number = number
_mem = self._memobj.memory[mem.number - 1]
_nam = self._memobj.names[mem.number - 1]
_skp = self._memobj.flags[(mem.number - 1) / 4]
if not _mem.used:
mem.empty = True
return mem
mem.freq = _decode_freq(_mem.freq)
mem.offset = int(_mem.offset) * 50000
mem.duplex = DUPLEX[_mem.duplex]
if mem.duplex == "split":
if int(_mem.tx_freq) == 0:
mem.duplex = "off"
else:
mem.offset = _decode_freq(_mem.tx_freq)
mem.tmode = TMODES[_mem.tmode]
mem.rtone = chirp_common.TONES[_mem.tone]
mem.dtcs = chirp_common.DTCS_CODES[_mem.dtcs]
mem.power = POWER_LEVELS[_mem.power]
mem.mode = _mem.isam and "AM" or _mem.isnarrow and "NFM" or "FM"
mem.tuning_step = STEPS[_mem.step]
if _skp is not None:
skip = _skp["skip%i" % ((mem.number - 1) % 4)]
mem.skip = SKIPS[skip]
if _nam is not None:
if _nam.use_name and _nam.valid:
mem.name = _decode_name(_nam.name).rstrip()
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 = RT26_POWER_LEVELS[_mem.highpower]
if _mem.skip:
mem.skip = "S"
mem.extra = RadioSettingGroup("Extra", "extra")
rs = RadioSetting("bcl", "BCL", RadioSettingValueBoolean(not _mem.bcl))
mem.extra.append(rs)
rs = RadioSetting("epilogue", "Epilogue(STE)",
RadioSettingValueBoolean(_mem.epilogue))
mem.extra.append(rs)
val = 3 - _mem.pttid
rs = RadioSetting("pttid", "PTT ID",
RadioSettingValueList(LIST_PTTID, LIST_PTTID[val]))
mem.extra.append(rs)
return mem
def get_memory(self, number):
number = _resolve_memory_number(number)
bitpos = (1 << (number % 8))
bytepos = number / 8
_mem = self._memobj.memory[number]
_used = self._memobj.used_flags[bytepos]
is_used = ((_used & bitpos) == 0)
if is_used and MODES[_mem.mode] == "DV":
mem = chirp_common.DVMemory()
mem.dv_urcall = str(_mem.urcall).rstrip()
mem.dv_rpt1call = str(_mem.r1call).rstrip()
mem.dv_rpt2call = str(_mem.r2call).rstrip()
else:
mem = chirp_common.Memory()
mem.number = number
if number < 500:
_skip = self._memobj.skip_flags[bytepos]
_pskip = self._memobj.pskip_flags[bytepos]
if _skip & bitpos:
mem.skip = "S"
elif _pskip & bitpos:
mem.skip = "P"
else:
mem.extd_number = util.get_dict_rev(_get_special(), number)
mem.immutable = ["number", "skip", "bank", "bank_index",
"extd_number"]
if not is_used:
mem.empty = True
return mem
mem.freq = int(_mem.freq)
mem.offset = int(_mem.offset)
mem.rtone = chirp_common.TONES[_mem.rtone]
mem.ctone = chirp_common.TONES[_mem.ctone]
mem.tmode = TMODES[_mem.tmode]
mem.duplex = DUPLEX[_mem.duplex]
mem.mode = MODES[_mem.mode]
mem.dtcs = chirp_common.DTCS_CODES[_mem.dtcs]
mem.dtcs_polarity = DTCSP[_mem.dtcs_polarity]
if _mem.tune_step > 8:
mem.tuning_step = 5.0 # Sometimes TS is garbage?
else:
mem.tuning_step = chirp_common.TUNING_STEPS[_mem.tune_step]
mem.name = str(_mem.name).rstrip()
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_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_normal(self, number):
_mem = self._memobj.memory[number-1]
used = (self._memobj.visible[(number-1)/8] >> (number-1)%8) & 0x01
valid = (self._memobj.filled[(number-1)/8] >> (number-1)%8) & 0x01
mem = chirp_common.Memory()
mem.number = number
if not used:
mem.empty = True
if not valid:
return mem
return self._get_memory(mem, _mem)
def get_memory(self, number):
_mem = self._memobj.memory[number]
_flag = self._memobj.flags[number / 2]
nibble = (number % 2) and "odd" or "even"
visible = _flag["%s_visible" % nibble]
valid = _flag["%s_valid" % nibble]
pskip = _flag["%s_pskip" % nibble]
skip = _flag["%s_skip" % nibble]
mem = chirp_common.Memory()
mem.number = number
if not visible:
mem.empty = True
if not valid:
mem.empty = True
return mem
mem.freq = chirp_common.fix_rounded_step(int(_mem.freq) * 1000)
mem.offset = chirp_common.fix_rounded_step(int(_mem.offset) * 1000)
mem.duplex = DUPLEX[_mem.duplex]
mem.tuning_step = _mem.step_changed and STEPS[
_mem.tune_step] or STEPS[0]
if _mem.tmode < TMODES.index("Cross"):
mem.tmode = TMODES[_mem.tmode]
mem.cross_mode = CROSS_MODES[0]
else:
mem.tmode = "Cross"
mem.cross_mode = CROSS_MODES[_mem.tmode - TMODES.index("Cross")]
mem.rtone = chirp_common.TONES[_mem.tone]
mem.dtcs = chirp_common.DTCS_CODES[_mem.dtcs]
for i in _mem.name:
if i == 0xFF:
break
if i & 0x80 == 0x80:
# first bit in name is "show name"
mem.name += CHARSET[0x80 ^ int(i)]
else:
mem.name += CHARSET[i]
mem.name = mem.name.rstrip()
mem.mode = _mem.narrow and "NFM" or "FM"
mem.skip = pskip and "P" or skip and "S" or ""
mem.power = POWER_LEVELS[_mem.power]
mem.extra = RadioSettingGroup("extra", "Extra Settings")
rs = RadioSetting("clk_shift", "Clock Shift",
RadioSettingValueBoolean(_mem.clk_shift))
mem.extra.append(rs)
return mem
def clean_mem():
m = chirp_common.Memory()
m.number = rf.memory_bounds[0]
try:
m.mode = rf.valid_modes[0]
except IndexError:
pass
if rf.valid_bands:
m.freq = rf.valid_bands[0][0] + 600000
else:
m.freq = 146520000
if m.freq < 30000000 and "AM" in rf.valid_modes:
m.mode = "AM"
return m
def _parse_mem_spec(self, spec):
mem = chirp_common.Memory()
mem.number = int(spec[2])
mem.freq = int(spec[3])
mem.tuning_step = STEPS[int(spec[4], 16)]
mem.duplex = DUPLEX[int(spec[5])]
if int(spec[7]):
mem.tmode = "Tone"
elif int(spec[8]):
mem.tmode = "TSQL"
mem.rtone = self._kenwood_valid_tones[int(spec[10]) - 1]
mem.ctone = self._kenwood_valid_tones[int(spec[12]) - 1]
return mem
def get_memory(self, number):
bytepos = number / 8
bitpos = 1 << (number % 8)
_mem = self._memobj.memory[number]
_used = self._memobj.used_flags[bytepos]
is_used = ((_used & bitpos) == 0)
if is_used and MODES[_mem.mode] == "DV":
mem = chirp_common.DVMemory()
mem.dv_urcall = decode_call(str(_mem.urcall))
mem.dv_rpt1call = decode_call(str(_mem.r1call))
mem.dv_rpt2call = decode_call(str(_mem.r2call))
else:
mem = chirp_common.Memory()
mem.number = number
if number < 1000:
_skip = self._memobj.skip_flags[bytepos]
_pskip = self._memobj.pskip_flags[bytepos]
if _skip & bitpos:
mem.skip = "S"
elif _pskip & bitpos:
mem.skip = "P"
else:
pass # FIXME: Special memories
if not is_used:
mem.empty = True
return mem
mem.freq = _get_freq(_mem)
mem.offset = (_mem.offset * 5) * 1000
mem.rtone = chirp_common.TONES[_mem.rtone]
mem.ctone = chirp_common.TONES[_mem.ctone]
mem.tmode = TMODES[_mem.tmode]
mem.duplex = DUPLEX[_mem.duplex]
mem.mode = MODES[_mem.mode]
mem.dtcs = chirp_common.DTCS_CODES[_mem.dtcs]
mem.dtcs_polarity = DTCSP[_mem.dtcs_polarity]
if _mem.tune_step >= len(STEPS):
mem.tuning_step = 5.0
else:
mem.tuning_step = STEPS[_mem.tune_step]
mem.name = str(_mem.name).rstrip()
return mem
def get_memory(self, number):
if isinstance(number, str):
number = _get_special()[number]
_mem = self._memobj.memory[number]
_flag = self._memobj.flags[number]
if _mem.mode_dv and not _flag.empty:
mem = chirp_common.DVMemory()
mem.dv_urcall = \
str(self._memobj.urcalls[_mem.urcall].call).rstrip()
mem.dv_rpt1call = \
str(self._memobj.rptcalls[_mem.r1call].call).rstrip()
mem.dv_rpt2call = \
str(self._memobj.rptcalls[_mem.r2call].call).rstrip()
else:
mem = chirp_common.Memory()
mem.number = number
if number < 200:
mem.skip = _flag.skip and "S" or ""
else:
mem.extd_number = util.get_dict_rev(_get_special(), number)
mem.immutable = [
"number", "skip", "bank", "bank_index", "extd_number"
]
if _flag.empty:
mem.empty = True
mem.power = POWER_LEVELS[0]
return mem
mult = _mem.is_625 and 6250 or 5000
mem.freq = (_mem.freq * mult)
mem.offset = (_mem.offset * mult)
mem.rtone = chirp_common.TONES[_mem.rtone]
mem.ctone = chirp_common.TONES[_mem.ctone]
mem.tmode = TMODES[_mem.tmode]
mem.duplex = DUPLEX[_mem.duplex]
mem.mode = _mem.mode_dv and "DV" or _mem.mode_am and "AM" or "FM"
if _mem.mode_narrow:
mem.mode = "N%s" % mem.mode
mem.dtcs = chirp_common.DTCS_CODES[_mem.dtcs]
mem.dtcs_polarity = DTCSP[_mem.dtcs_polarity]
mem.tuning_step = STEPS[_mem.tuning_step]
mem.name = str(_mem.name).replace("\x0E", "").rstrip()
mem.power = POWER_LEVELS[_mem.power]
return mem
def get_memory(self, number):
"""Convert raw channel data (_mem) into UI columns (mem)"""
mem = chirp_common.Memory()
if number > 99 and number < 110:
return # Don't show VFO edges as mem chans
_mem = self._memobj.ch_mem[number]
mem.number = number
mnx = ""
for char in _mem.name:
mnx += chr(char)
mem.name = mnx.strip()
mem.name = mem.name.upper()
if _mem.rxfreq == 0:
mem.empty = True
return mem
mem.empty = False
mem.freq = int(_mem.rxfreq)
mem.duplex = TS480_DUPLEX[0] # None by default
mem.offset = 0
if _mem.rxfreq < _mem.txfreq: # + shift
mem.duplex = TS480_DUPLEX[2]
mem.offset = _mem.txfreq - _mem.rxfreq
if _mem.rxfreq > _mem.txfreq: # - shift
mem.duplex = TS480_DUPLEX[1]
mem.offset = _mem.rxfreq - _mem.txfreq
if _mem.txfreq == 0:
# leave offset alone, or run_tests will bomb
mem.duplex = TS480_DUPLEX[0]
mx = _mem.xmode - 1 # CAT modes start at 1
if _mem.xmode == 9: # except there is no xmode 9
mx = 7
mem.mode = TS480_MODES[mx]
mem.tmode = ""
mem.cross_mode = "Tone->Tone"
mem.ctone = TS480_TONES[_mem.ctone]
mem.rtone = TS480_TONES[_mem.rtone]
if _mem.tmode == 1:
mem.tmode = "Tone"
elif _mem.tmode == 2:
mem.tmode = "TSQL"
elif _mem.tmode == 3:
mem.tmode = "Cross"
mem.skip = TS480_SKIP[_mem.skip]
# Tuning step depends on mode
options = [0.5, 1.0, 2.5, 5.0, 10.0] # SSB/CS/FSK
if _mem.xmode == 4 or _mem.xmode == 5: # AM/FM
options = TS480_TUNE_STEPS[3:]
mem.tuning_step = options[_mem.step]
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 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(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 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 = NC630A_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)
return mem
def _get_special_60m(self, number):
mem = chirp_common.Memory()
mem.number = self.SPECIAL_60M[number]
mem.extd_number = number
_mem = self._memobj.sixtymeterchannels[-self.LAST_SPECIAL60M_INDEX +
mem.number]
mem = self._get_memory(mem, _mem)
mem.immutable = ["number", "skip", "rtone", "ctone",
"extd_number", "name", "dtcs", "tmode", "cross_mode",
"dtcs_polarity", "power", "duplex", "offset",
"comment", "empty"]
return mem
def get_memory(self, number):
mem = chirp_common.Memory()
if isinstance(number, str):
if number == "C":
number = _get_special()[number]
_mem = self._memobj.call[0]
else:
number = _get_special()[number]
_mem = self._memobj.special[number - 500]
empty = False
else:
number -= 1
_mem = self._memobj.memory[number]
_emt = self._memobj.usedflags[number / 8].flagbits
empty = (1 << (number % 8)) & int(_emt)
if not empty:
mem.name = str(_mem.name).rstrip()
_skp = self._memobj.skipflags[number / 8].flagbits
isskip = (1 << (number % 8)) & int(_skp)
mem.number = number + 1
if number <= 100:
mem.skip = isskip and "S" or ""
else:
mem.extd_number = util.get_dict_rev(_get_special(), number)
mem.immutable = ["number", "skip", "extd_number"]
if empty:
mem.empty = True
return mem
mem.freq = _get_freq(_mem)
mem.offset = _get_offset(_mem)
mem.rtone = chirp_common.TONES[_mem.rtone]
mem.ctone = chirp_common.TONES[_mem.ctone]
mem.tmode = TMODES[_mem.tmode]
mem.duplex = DUPLEX[_mem.duplex]
mem.extra = RadioSettingGroup("Extra", "extra")
rs = RadioSetting("anm", "Alphanumeric Name",
RadioSettingValueBoolean(_mem.anm))
mem.extra.append(rs)
return mem
def get_memory(self, number):
"""Convert raw channel data (_mem) into UI columns (mem)"""
mem = chirp_common.Memory()
_mem = self._memobj.ch_mem[number]
mem.number = number
# --- Correct old img file loads with +/- offsets ---
if (_mem.txfreq != 0) and (_mem.rxfreq != _mem.txfreq):
_mem.split = 1
mnx = ""
for char in _mem.name:
mnx += chr(char)
mem.name = mnx.strip()
mem.name = mem.name.upper()
if _mem.rxfreq == 0:
mem.empty = True
return mem
mem.empty = False
mem.freq = int(_mem.rxfreq)
mem.duplex = TS480_DUPLEX[0] # None by default
mem.offset = 0
if _mem.split: # NO +/- Offsets, just split
mem.duplex = TS480_DUPLEX[1]
mem.offset = _mem.txfreq
elif _mem.txfreq == 0:
# leave offset alone, or run_tests will bomb
mem.duplex = TS480_DUPLEX[0]
mx = _mem.xmode - 1 # CAT modes start at 1
if _mem.xmode == 9: # except there is no xmode 9
mx = 7
mem.mode = TS480_MODES[mx]
mem.tmode = ""
mem.cross_mode = "Tone->Tone"
mem.ctone = TS480_TONES[_mem.ctone]
mem.rtone = TS480_TONES[_mem.rtone]
if _mem.tmode == 1:
mem.tmode = "Tone"
elif _mem.tmode == 2:
mem.tmode = "TSQL"
elif _mem.tmode == 3:
mem.tmode = "Cross"
mem.skip = TS480_SKIP[_mem.skip]
# Tuning step depends on mode
options = [0.5, 1.0, 2.5, 5.0, 10.0] # SSB/CS/FSK
if _mem.xmode == 4 or _mem.xmode == 5: # AM/FM
options = TS480_TUNE_STEPS[3:]
mem.tuning_step = options[_mem.step]
return mem
def _get_special(self, number):
mem = chirp_common.Memory()
mem.number = self.SPECIAL_MEMORIES[number]
mem.extd_number = number
if mem.number in range(self.FIRST_VFOA_INDEX,
self.LAST_VFOA_INDEX - 1,
-1):
_mem = self._memobj.vfoa[-self.LAST_VFOA_INDEX + mem.number]
immutable = ["number", "skip", "extd_number",
"name", "dtcs_polarity", "power", "comment"]
elif mem.number in range(self.FIRST_VFOB_INDEX,
self.LAST_VFOB_INDEX - 1,
-1):
_mem = self._memobj.vfob[-self.LAST_VFOB_INDEX + mem.number]
immutable = ["number", "skip", "extd_number",
"name", "dtcs_polarity", "power", "comment"]
elif mem.number in range(-2, -6, -1):
_mem = self._memobj.home[5 + mem.number]
immutable = ["number", "skip", "extd_number",
"name", "dtcs_polarity", "power", "comment"]
elif mem.number == -1:
_mem = self._memobj.qmb
immutable = ["number", "skip", "extd_number",
"name", "dtcs_polarity", "power", "comment"]
elif mem.number in self.SPECIAL_PMS.values():
bitindex = -self.LAST_PMS_INDEX + mem.number
used = (self._memobj.pmsvisible >> bitindex) & 0x01
valid = (self._memobj.pmsfilled >> bitindex) & 0x01
if not used:
mem.empty = True
if not valid:
mem.empty = True
return mem
_mem = self._memobj.pms[-self.LAST_PMS_INDEX + mem.number]
immutable = ["number", "skip", "rtone", "ctone", "extd_number",
"dtcs", "tmode", "cross_mode", "dtcs_polarity",
"power", "duplex", "offset", "comment"]
else:
raise Exception("Sorry, special memory index %i " % mem.number +
"unknown you hit a bug!!")
mem = self._get_memory(mem, _mem)
mem.immutable = immutable
return mem
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 _mem(self, rf):
m = chirp_common.Memory()
m.freq = rf.valid_bands[0][0] + 1000000
if m.freq < 30000000 and "AM" in rf.valid_modes:
m.mode = "AM"
else:
try:
m.mode = rf.valid_modes[0]
except IndexError:
pass
for i in range(*rf.memory_bounds):
m.number = i
if not self._wrapper.do("validate_memory", m):
return m
raise TestSkippedError("No mutable memory locations found")
def get_memory(self, number):
# Get a low-level memory object mapped to the image
_mem = self._memobj.memory[number]
# Create a high-level memory object to return to the UI
mem = chirp_common.Memory()
mem.number = number # Set the memory number
# Convert your low-level frequency to Hertz
mem.freq = int(_mem.freq)
mem.name = str(_mem.name).rstrip() # Set the alpha tag
# We'll consider any blank (i.e. 0MHz frequency) to be empty
if mem.freq == 0:
mem.empty = True
return mem
def get_memory(self, number):
mem = chirp_common.Memory()
mem_item = self.memobj.tv_memory[number]
mem.freq = self.freq_icom2chirp(mem_item.freq)
if self.memobj.tv_channel_skip[number] == 1:
mem.empty = True
mem.mode = TV_MODE[0]
else:
mem.empty = False
mem.name = str(mem_item.name).rstrip("\x00 ")
mem.mode = TV_MODE[mem_item.mode]
mem.skip = self.get_skip(number)
mem.number = number
return mem
def get_memory(self, number):
_mem, _flg = self._get_memobjs(number)
mem = chirp_common.Memory()
mem.number = number
if _flg.get() == 0x0F:
mem.empty = True
return mem
mem.freq = int(_mem.freq) * 100
# compensate for 6.25 and 12.5 kHz tuning steps, add 500 Hz if needed
lastdigit = int(_mem.freq) % 10
if (lastdigit == 2 or lastdigit == 7):
mem.freq += 50
mem.offset = int(_mem.offset) * 100
mem.name = str(_mem.name).rstrip()
mem.duplex = DUPLEXES[_mem.duplex]
mem.mode = _mem.is_am and "AM" or MODES[_mem.channel_width]
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))
mem.skip = _flg.get_skip() and "S" or _flg.get_pskip() and "P" or ""
mem.power = POWER_LEVELS[_mem.power]
return mem
def get_memory(self, number):
mem = chirp_common.Memory()
if isinstance(number, str):
mem.number = len(self._memobj.memory) + SPECIALS.index(number) + 1
mem.extd_number = number
_mem = self._memobj.special[mem.number - len(self._memobj.memory) -
1]
_flg = self._memobj.specialflag[mem.number -
len(self._memobj.memory) - 1]
elif number > len(self._memobj.memory):
mem.number = number
mem.extd_number = SPECIALS[number - len(self._memobj.memory) - 1]
_mem = self._memobj.special[mem.number - len(self._memobj.memory) -
1]
_flg = self._memobj.specialflag[mem.number -
len(self._memobj.memory) - 1]
else:
mem.number = number
_mem = self._memobj.memory[mem.number - 1]
_flg = self._memobj.flag[mem.number - 1]
if not _flg.visible:
mem.empty = True
if not _flg.used:
mem.empty = True
return mem
mem.freq = chirp_common.fix_rounded_step(int(_mem.freq) * 1000)
mem.duplex = DUPLEX[_mem.duplex]
mem.name = self.filter_name(str(_mem.name).rstrip())
mem.mode = MODES[_mem.mode]
if mem.mode == "FM" and _mem.half_deviation:
mem.mode = "NFM"
mem.tuning_step = STEPS[_mem.tuning_step]
mem.offset = int(_mem.offset) * 1000
mem.power = POWER_LEVELS[3 - _mem.power]
mem.tmode = TMODES[_mem.tmode & 0x3] # masked so bad mems can be read
if mem.duplex == "split":
mem.offset = chirp_common.fix_rounded_step(mem.offset)
mem.rtone = mem.ctone = chirp_common.OLD_TONES[_mem.tone]
mem.dtcs = chirp_common.DTCS_CODES[_mem.dtcs]
mem.skip = _flg.pskip and "P" or _flg.skip and "S" or ""
return mem
def get_memory(self, number):
mem = chirp_common.Memory()
if isinstance(number, str):
# special channel
_mem = getattr(self._memobj, number)
mem.number = -len(FT90_SPECIAL) + FT90_SPECIAL.index(number)
mem.extd_number = number
if re.match('^pms', mem.extd_number):
# enable pms_XY channel flag
_special_enables = self._memobj.special_enables
mem.empty = not getattr(_special_enables,
mem.extd_number + "_enable")
else:
# regular memory
_mem = self._memobj.memory[number - 1]
mem.number = number
mem.empty = not self._get_chan_enable(number)
if mem.empty:
return mem # bail out, do not parse junk
mem.freq = _mem.rxfreq * 10
mem.offset = _mem.txfreqoffset * 10
if not _mem.tmode < len(FT90_TMODES):
_mem.tmode = 0
mem.tmode = FT90_TMODES[_mem.tmode]
mem.rtone = FT90_TONES[_mem.tone]
mem.dtcs = chirp_common.DTCS_CODES[_mem.dcstone]
mem.mode = FT90_MODES[_mem.mode]
mem.duplex = FT90_DUPLEX[_mem.shift]
if mem.freq / 1000000 > 300:
mem.power = FT90_POWER_LEVELS_UHF[_mem.power]
else:
mem.power = FT90_POWER_LEVELS_VHF[_mem.power]
# radio has a known bug with 5khz step and squelch
if _mem.step == 0 or _mem.step > len(FT90_STEPS) - 1:
_mem.step = 2
mem.tuning_step = FT90_STEPS[_mem.step]
mem.skip = _mem.skip and "S" or ""
if not all(char in chirp_common.CHARSET_ASCII
for char in str(_mem.name)):
# dont display blank/junk name
mem.name = ""
else:
mem.name = str(_mem.name)
return mem