def get_memory(self, number):
flag = self._memobj.flag[number - 1]
_mem = self._memobj.memory[number - 1]
mem = chirp_common.Memory()
mem.number = number
if not flag.used:
mem.empty = True
if not flag.valid:
mem.empty = True
return mem
mem.freq = chirp_common.fix_rounded_step(int(_mem.freq) * 1000)
mem.offset = int(_mem.offset) * 1000
mem.rtone = mem.ctone = chirp_common.TONES[_mem.tone]
mem.tmode = TMODES[_mem.tone_mode]
mem.duplex = DUPLEX[_mem.duplex]
if mem.duplex == "split":
mem.offset = chirp_common.fix_rounded_step(mem.offset)
mem.mode = MODES[_mem.mode]
mem.dtcs = chirp_common.DTCS_CODES[_mem.dcs]
mem.tuning_step = STEPS[_mem.tune_step]
mem.power = POWER_LEVELS[3 - _mem.power]
mem.skip = flag.pskip and "P" or flag.skip and "S" or ""
charset = ''.join(CHARSET).ljust(256, '.')
mem.name = str(_mem.label).rstrip("\xFF").translate(charset)
return mem
def get_memory(self, number):
_mem = self._memobj.memory[number - 1]
_flg = self._memobj.flag[number - 1]
mem = chirp_common.Memory()
mem.number = number
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()
_mem = self._memobj.memory[number - 1]
_flg = self._memobj.flag[number - 1]
mem.number = number
# if not _flg.visible:
# mem.empty = True
if not _flg.used:
mem.empty = True
return mem
for i in _mem.name:
mem.name += CHARSET[i & 0x7F]
mem.name = mem.name.rstrip()
mem.freq = chirp_common.fix_rounded_step(int(_mem.freq) * 1000)
mem.duplex = DUPLEX[_mem.duplex]
mem.offset = chirp_common.fix_rounded_step(int(_mem.offset) * 1000)
mem.rtone = mem.ctone = TONES[_mem.tone]
mem.tmode = TMODES[_mem.tmode]
mem.mode = MODES[_mem.mode]
mem.tuning_step = TUNING_STEPS[_mem.tuning_step]
mem.dtcs = chirp_common.DTCS_CODES[_mem.dtcs]
# Power is stored as 2 bits to describe the 3 low power levels
# High power is determined by a different bit.
if not _mem.ishighpower:
mem.power = POWER_LEVELS[3 - _mem.power]
else:
mem.power = POWER_LEVELS[0]
mem.skip = SKIP_VALUES[_flg.skip]
return mem
def get_memory(self, number):
flag = self._memobj.flag[number - 1]
_mem = self._memobj.memory[number - 1]
mem = chirp_common.Memory()
mem.number = number
if not flag.used:
mem.empty = True
if not flag.valid:
mem.empty = True
return mem
mem.freq = chirp_common.fix_rounded_step(int(_mem.freq) * 1000)
mem.offset = int(_mem.offset) * 1000
mem.rtone = mem.ctone = chirp_common.TONES[_mem.tone]
self._get_tmode(mem, _mem)
mem.duplex = DUPLEX[_mem.duplex]
if mem.duplex == "split":
mem.offset = chirp_common.fix_rounded_step(mem.offset)
mem.mode = self._decode_mode(_mem)
mem.dtcs = chirp_common.DTCS_CODES[_mem.dcs]
mem.tuning_step = STEPS[_mem.tune_step]
mem.power = self._decode_power_level(_mem)
mem.skip = flag.pskip and "P" or flag.skip and "S" or ""
mem.name = self._decode_label(_mem)
return mem
def get_memory(self, number):
mem = chirp_common.Memory()
_mem = self._memobj.memory[number-1]
_flg = self._memobj.flag[number-1]
mem.number = number
# if not _flg.visible:
# mem.empty = True
if not _flg.used:
mem.empty = True
return mem
for i in _mem.name:
mem.name += CHARSET[i & 0x7F]
mem.name = mem.name.rstrip()
mem.freq = chirp_common.fix_rounded_step(int(_mem.freq) * 1000)
mem.duplex = DUPLEX[_mem.duplex]
mem.offset = chirp_common.fix_rounded_step(int(_mem.offset) * 1000)
mem.rtone = mem.ctone = TONES[_mem.tone]
mem.tmode = TMODES[_mem.tmode]
mem.mode = MODES[_mem.mode]
mem.tuning_step = TUNING_STEPS[_mem.tuning_step]
mem.dtcs = chirp_common.DTCS_CODES[_mem.dtcs]
# Power is stored as 2 bits to describe the 3 low power levels
# High power is determined by a different bit.
if not _mem.ishighpower:
mem.power = POWER_LEVELS[3 - _mem.power]
else:
mem.power = POWER_LEVELS[0]
mem.skip = SKIP_VALUES[_flg.skip]
return mem
def get_memory(self, number):
flag = self._memobj.flag[number-1]
_mem = self._memobj.memory[number-1]
mem = chirp_common.Memory()
mem.number = number
if not flag.used:
mem.empty = True
if not flag.valid:
mem.empty = True
return mem
mem.freq = chirp_common.fix_rounded_step(int(_mem.freq) * 1000)
mem.offset = int(_mem.offset) * 1000
mem.rtone = mem.ctone = chirp_common.TONES[_mem.tone]
mem.tmode = TMODES[_mem.tone_mode]
mem.duplex = DUPLEX[_mem.duplex]
if mem.duplex == "split":
mem.offset = chirp_common.fix_rounded_step(mem.offset)
mem.mode = MODES[_mem.mode]
mem.dtcs = chirp_common.DTCS_CODES[_mem.dcs]
mem.tuning_step = STEPS[_mem.tune_step]
mem.power = POWER_LEVELS[3 - _mem.power]
mem.skip = flag.pskip and "P" or flag.skip and "S" or ""
charset = ''.join(CHARSET).ljust(256, '.')
mem.name = str(_mem.label).rstrip("\xFF").translate(charset)
return mem
def get_memory(self, number):
_mem = self._memobj.memory[number-1]
_flg = self._memobj.flag[number-1]
mem = chirp_common.Memory()
mem.number = number
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 = self._memobj.memory[number - 1]
_flag = self._memobj.flags[(number - 1) / 2]
nibble = ((number - 1) % 2) and "even" or "odd"
used = _flag["%s_masked" % 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 used:
mem.empty = True
if not valid:
mem.empty = True
mem.power = POWER_LEVELS[0]
return mem
mem.freq = chirp_common.fix_rounded_step(int(_mem.freq) * 1000)
mem.offset = int(_mem.offset) * 1000
mem.rtone = mem.ctone = chirp_common.TONES[_mem.tone]
if not _mem.is_split_tone:
mem.tmode = TMODES[_mem.tmode]
mem.cross_mode = CROSS_MODES[0]
else:
mem.tmode = "Cross"
mem.cross_mode = CROSS_MODES[int(_mem.tmode)]
mem.duplex = DUPLEX[_mem.duplex]
if mem.duplex == "split":
mem.offset = chirp_common.fix_rounded_step(mem.offset)
mem.mode = MODES[_mem.mode]
mem.dtcs = chirp_common.DTCS_CODES[_mem.dcs]
mem.tuning_step = STEPS[_mem.tune_step]
mem.skip = pskip and "P" or skip and "S" or ""
if _is220(mem.freq):
levels = POWER_LEVELS_220
else:
levels = POWER_LEVELS
try:
mem.power = levels[_mem.power]
except IndexError:
LOG.error("Radio reported invalid power level %s (in %s)" %
(_mem.power, levels))
mem.power = levels[0]
for i in _mem.name:
if i == "\xFF":
break
mem.name += CHARSET[i]
mem.name = mem.name.rstrip()
return mem
def get_memory(self, number):
_mem = self._memobj.memory[number-1]
_flag = self._memobj.flags[(number-1)/2]
nibble = ((number-1) % 2) and "even" or "odd"
used = _flag["%s_masked" % 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 used:
mem.empty = True
if not valid:
mem.empty = True
mem.power = POWER_LEVELS[0]
return mem
mem.freq = chirp_common.fix_rounded_step(int(_mem.freq) * 1000)
mem.offset = int(_mem.offset) * 1000
mem.rtone = mem.ctone = chirp_common.TONES[_mem.tone]
if not _mem.is_split_tone:
mem.tmode = TMODES[_mem.tmode]
mem.cross_mode = CROSS_MODES[0]
else:
mem.tmode = "Cross"
mem.cross_mode = CROSS_MODES[int(_mem.tmode)]
mem.duplex = DUPLEX[_mem.duplex]
if mem.duplex == "split":
mem.offset = chirp_common.fix_rounded_step(mem.offset)
mem.mode = MODES[_mem.mode]
mem.dtcs = chirp_common.DTCS_CODES[_mem.dcs]
mem.tuning_step = STEPS[_mem.tune_step]
mem.skip = pskip and "P" or skip and "S" or ""
if _is220(mem.freq):
levels = POWER_LEVELS_220
else:
levels = POWER_LEVELS
try:
mem.power = levels[_mem.power]
except IndexError:
print "Radio reported invalid power level %s (in %s)" % (
_mem.power, levels)
mem.power = levels[0]
for i in _mem.name:
if i == "\xFF":
break
mem.name += CHARSET[i]
mem.name = mem.name.rstrip()
return 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 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 get_memory(self, number):
_mem = self._memobj.memory[number-1]
_flg = self._memobj.flags[(number-1)/2]
nibble = ((number-1) % 2) and "even" or "odd"
used = _flg["%s_masked" % nibble]
valid = _flg["%s_valid" % nibble]
pskip = _flg["%s_pskip" % nibble]
skip = _flg["%s_skip" % nibble]
mem = chirp_common.Memory()
mem.number = number
if not used:
mem.empty = True
if not valid:
mem.empty = True
mem.power = POWER_LEVELS[0]
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.rtone = mem.ctone = chirp_common.TONES[_mem.tone & 0x3f]
mem.tmode = TMODES[_mem.tmode]
mem.duplex = DUPLEX[_mem.duplex]
mem.mode = MODES[_mem.mode]
if mem.mode == "FM" and _mem.half_deviation:
mem.mode = "NFM"
mem.dtcs = chirp_common.DTCS_CODES[_mem.dcs & 0x7f]
mem.tuning_step = STEPS[_mem.tune_step]
mem.skip = pskip and "P" or skip and "S" or ""
if mem.freq > 220000000 and mem.freq < 225000000:
mem.power = POWER_LEVELS_220[3 - _mem.power]
else:
mem.power = POWER_LEVELS[3 - _mem.power]
for i in _mem.name:
if i == 0xFF:
break
mem.name += CHARSET[i & 0x7F]
mem.name = mem.name.rstrip()
return mem
def get_memory(self, number):
_mem = self._memobj.memory[number-1]
_flg = self._memobj.flags[(number-1)/2]
nibble = ((number-1) % 2) and "even" or "odd"
used = _flg["%s_masked" % nibble]
valid = _flg["%s_valid" % nibble]
pskip = _flg["%s_pskip" % nibble]
skip = _flg["%s_skip" % nibble]
mem = chirp_common.Memory()
mem.number = number
if not used:
mem.empty = True
if not valid:
mem.empty = True
mem.power = POWER_LEVELS[0]
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.rtone = mem.ctone = chirp_common.TONES[_mem.tone & 0x3f]
mem.tmode = TMODES[_mem.tmode]
mem.duplex = DUPLEX[_mem.duplex]
mem.mode = MODES[_mem.mode]
if mem.mode == "FM" and _mem.half_deviation:
mem.mode = "NFM"
mem.dtcs = chirp_common.DTCS_CODES[_mem.dcs & 0x7f]
mem.tuning_step = STEPS[_mem.tune_step]
mem.skip = pskip and "P" or skip and "S" or ""
if mem.freq > 220000000 and mem.freq < 225000000:
mem.power = POWER_LEVELS_220[3 - _mem.power]
else:
mem.power = POWER_LEVELS[3 - _mem.power]
for i in _mem.name:
if i == 0xFF:
break
mem.name += CHARSET[i & 0x7F]
mem.name = mem.name.rstrip()
return mem
def get_memory(self, number):
_mem = self._memobj.memory[number-1]
_flag = self._memobj.flags[(number-1)/2]
nibble = ((number-1) % 2) and "even" or "odd"
used = _flag["%s_masked" % 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 used:
mem.empty = True
if not valid:
mem.empty = True
mem.power = POWER_LEVELS[0]
return mem
mem.freq = chirp_common.fix_rounded_step(int(_mem.freq) * 1000)
mem.offset = int(_mem.offset) * 1000
mem.rtone = mem.ctone = chirp_common.TONES[_mem.tone]
mem.tmode = VX2_TMODES[_mem.tmode]
mem.duplex = VX2_DUPLEX[_mem.duplex]
if mem.duplex == "split":
mem.offset = chirp_common.fix_rounded_step(mem.offset)
if _mem.txnarrow and _mem.mode == VX2_MODES.index("FM"):
# narrow + FM
mem.mode = "NFM"
else:
mem.mode = VX2_MODES[_mem.mode]
mem.dtcs = chirp_common.DTCS_CODES[_mem.dcs]
mem.tuning_step = VX2_STEPS[_mem.tune_step]
mem.skip = pskip and "P" or skip and "S" or ""
mem.power = POWER_LEVELS[~_mem.power & 0x01]
for i in _mem.name:
if i == 0xFF:
break
mem.name += CHARSET[i & 0x7F]
mem.name = mem.name.rstrip()
return mem
def get_memory(self, number):
_mem = self._memobj.memory[number]
_flag = self._memobj.flags[number]
visible = _flag["visible"]
valid = _flag["valid"]
skip = _flag["skip"]
pskip = _flag["pskip"]
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) * 100000)
mem.duplex = DUPLEX[_mem.duplex]
mem.tuning_step = STEPS[_mem.tune_step] or STEPS[0]
mem.tmode = TMODES[_mem.tmode]
mem.rtone = chirp_common.TONES[_mem.tone]
for i in _mem.name:
if i == 0xFF:
break
if i & 0x80 == 0x80:
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 get_memory(self, number):
_mem = self._memobj.memory[number]
_flag = self._memobj.flags[number]
mem = chirp_common.Memory()
mem.number = number
if self._memobj.flags_whole[number] == 0xFF:
mem.empty = True
return mem
mem.freq = int(_mem.freq) * 1000
if _mem.fractional:
mem.freq = chirp_common.fix_rounded_step(mem.freq)
mem.offset = int(_mem.offset) * 1000
try:
mem.rtone = chirp_common.TONES[_mem.rtone]
except IndexError:
mem.rtone = 88.5
try:
mem.ctone = chirp_common.TONES[_mem.ctone]
except IndexError:
mem.ctone = 88.5
try:
mem.tuning_step = STEPS[_mem.tune_step]
except IndexError:
LOG.error("Invalid tune step index %i" % _mem.tune_step)
mem.tmode = TMODES[_flag.tmode]
mem.duplex = DUPLEX[_flag.duplex]
if mem.freq < 30000000:
mem.mode = "AM"
else:
mem.mode = MODES[_flag.mode]
if _flag.pskip:
mem.skip = "P"
elif _flag.skip:
mem.skip = "S"
return mem
def get_memory(self, number):
_mem = self._memobj.memory[number]
_flag = self._memobj.flags[number]
mem = chirp_common.Memory()
mem.number = number
if self._memobj.flags_whole[number] == 0xFF:
mem.empty = True
return mem
mem.freq = int(_mem.freq) * 1000
if _mem.fractional:
mem.freq = chirp_common.fix_rounded_step(mem.freq)
mem.offset = int(_mem.offset) * 1000
try:
mem.rtone = chirp_common.TONES[_mem.rtone]
except IndexError:
mem.rtone = 88.5
try:
mem.ctone = chirp_common.TONES[_mem.ctone]
except IndexError:
mem.ctone = 88.5
try:
mem.tuning_step = STEPS[_mem.tune_step]
except IndexError:
print "Invalid tune step index %i" % _mem.tune_step
mem.tmode = TMODES[_flag.tmode]
mem.duplex = DUPLEX[_flag.duplex]
if mem.freq < 30000000:
mem.mode = "AM"
else:
mem.mode = MODES[_flag.mode]
if _flag.pskip:
mem.skip = "P"
elif _flag.skip:
mem.skip = "S"
return mem
def get_memory(self, number):
if isinstance(number, str):
number = _get_special()[number]
_mem = self._memobj.memory[number]
_flg = self._memobj.flag[number]
mem = chirp_common.Memory()
mem.number = number
if number < 100:
# Normal memories
mem.skip = _flg.skip and "S" or ""
else:
# Special memories
mem.extd_number = util.get_dict_rev(_get_special(), number)
if _flg.empty:
mem.empty = True
return mem
mem.freq = chirp_common.fix_rounded_step(int(_mem.freq) * 1000)
mem.offset = int(_mem.offset) * 100
if str(_mem.name)[0] != chr(0xFF):
mem.name = str(_mem.name).rstrip()
mem.rtone = chirp_common.TONES[_mem.rtone]
mem.ctone = chirp_common.TONES[_mem.ctone]
mem.mode = _flg.am and "AM" or "FM"
mem.duplex = DUPLEX[_flg.duplex]
mem.tmode = TONE[_flg.tmode]
if number > 100:
mem.immutable = ["number", "skip", "extd_number", "name"]
return mem
def get_memory(self, number):
if isinstance(number, str):
number = _get_special()[number]
_mem = self._memobj.memory[number]
_flg = self._memobj.flag[number]
mem = chirp_common.Memory()
mem.number = number
if number < 100:
# Normal memories
mem.skip = _flg.skip and "S" or ""
else:
# Special memories
mem.extd_number = util.get_dict_rev(_get_special(), number)
if _flg.empty:
mem.empty = True
return mem
mem.freq = chirp_common.fix_rounded_step(int(_mem.freq) * 1000)
mem.offset = int(_mem.offset) * 100
if str(_mem.name)[0] != chr(0xFF):
mem.name = str(_mem.name).rstrip()
mem.rtone = chirp_common.TONES[_mem.rtone]
mem.ctone = chirp_common.TONES[_mem.ctone]
mem.mode = _flg.am and "AM" or "FM"
mem.duplex = DUPLEX[_flg.duplex]
mem.tmode = TONE[_flg.tmode]
if number > 100:
mem.immutable = ["number", "skip", "extd_number", "name"]
return mem
def test_fix_rounded_step_750(self):
self.assertEqual(146118750, chirp_common.fix_rounded_step(146118000))
def test_fix_rounded_step_500(self):
self.assertEqual(146112500, chirp_common.fix_rounded_step(146112000))
def test_fix_rounded_step_250(self):
self.assertEqual(146106250, chirp_common.fix_rounded_step(146106000))
def test_fix_rounded_step_250(self):
self.assertEqual(146106250,
chirp_common.fix_rounded_step(146106000))
def get_memory(self, number):
_mem = self._memobj.memory[number]
_flag = self._memobj.flags[(number) / 2]
nibble = ((number) % 2) and "even" or "odd"
used = _flag["%s_masked" % nibble]
valid = _flag["%s_valid" % nibble]
pskip = _flag["%s_pskip" % nibble]
skip = _flag["%s_skip" % nibble]
mem = chirp_common.Memory()
mem.number = number
if _mem.get_raw()[0] == "\xFF" or not valid or not used:
mem.empty = True
return mem
mem.tuning_step = STEPS[_mem.step]
mem.freq = int(_mem.freq) * 1000
# compensate for 12.5 kHz tuning steps, add 500 Hz if needed
if (mem.tuning_step == 12.5):
lastdigit = int(_mem.freq) % 10
if (lastdigit == 2 or lastdigit == 7):
mem.freq += 500
mem.offset = chirp_common.fix_rounded_step(int(_mem.offset) * 1000)
mem.duplex = DUPLEX[_mem.duplex]
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 = _decode_tone(_mem.rtone)
mem.ctone = _decode_tone(_mem.ctone)
# check for unequal ctone/rtone in TSQL mode. map it as a
# cross tone mode
if mem.rtone != mem.ctone and (mem.tmode == "TSQL"
or mem.tmode == "Tone"):
mem.tmode = "Cross"
mem.cross_mode = "Tone->Tone"
mem.dtcs = _decode_dtcs(_mem.dtcs)
mem.rx_dtcs = _decode_dtcs(_mem.rx_dtcs)
# check for unequal dtcs/rx_dtcs in DTCS mode. map it as a
# cross tone mode
if mem.dtcs != mem.rx_dtcs and mem.tmode == "DTCS":
mem.tmode = "Cross"
mem.cross_mode = "DTCS->DTCS"
if (int(_mem.name[0]) & 0x80) != 0:
mem.name = _decode_name(_mem.name)
mem.mode = _mem.isnarrow and "NFM" or "FM"
mem.skip = pskip and "P" or skip and "S" or ""
mem.power = POWER_LEVELS[3 - _mem.power]
return mem
def test_fix_rounded_step_500(self):
self.assertEqual(146112500,
chirp_common.fix_rounded_step(146112000))
def test_fix_rounded_step_750(self):
self.assertEqual(146118750,
chirp_common.fix_rounded_step(146118000))
def get_memory(self, number):
_mem = self._memobj.memory[number]
_flag = self._memobj.flags[(number)/2]
nibble = ((number) % 2) and "even" or "odd"
used = _flag["%s_masked" % nibble]
valid = _flag["%s_valid" % nibble]
pskip = _flag["%s_pskip" % nibble]
skip = _flag["%s_skip" % nibble]
mem = chirp_common.Memory()
mem.number = number
if _mem.get_raw()[0] == "\xFF" or not valid or not used:
mem.empty = True
return mem
mem.tuning_step = STEPS[_mem.step]
mem.freq = int(_mem.freq) * 1000
# compensate for 12.5 kHz tuning steps, add 500 Hz if needed
if(mem.tuning_step == 12.5):
lastdigit = int(_mem.freq) % 10
if (lastdigit == 2 or lastdigit == 7):
mem.freq += 500
mem.offset = chirp_common.fix_rounded_step(int(_mem.offset) * 1000)
mem.duplex = DUPLEX[_mem.duplex]
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 = _decode_tone(_mem.rtone)
mem.ctone = _decode_tone(_mem.ctone)
# check for unequal ctone/rtone in TSQL mode. map it as a
# cross tone mode
if mem.rtone != mem.ctone and (mem.tmode == "TSQL" or
mem.tmode == "Tone"):
mem.tmode = "Cross"
mem.cross_mode = "Tone->Tone"
mem.dtcs = _decode_dtcs(_mem.dtcs)
mem.rx_dtcs = _decode_dtcs(_mem.rx_dtcs)
# check for unequal dtcs/rx_dtcs in DTCS mode. map it as a
# cross tone mode
if mem.dtcs != mem.rx_dtcs and mem.tmode == "DTCS":
mem.tmode = "Cross"
mem.cross_mode = "DTCS->DTCS"
if (int(_mem.name[0]) & 0x80) != 0:
mem.name = _decode_name(_mem.name)
mem.mode = _mem.isnarrow and "NFM" or "FM"
mem.skip = pskip and "P" or skip and "S" or ""
mem.power = POWER_LEVELS[3 - _mem.power]
return mem
def get_memory(self, number):
mem = chirp_common.Memory()
mem.number = number
_mem = self._memobj.memory[number-1]
mem.empty = _mem.empty
mem.freq = chirp_common.fix_rounded_step(int(_mem.freq_rx) * 1000)
for i in range(0, 4):
index = (_mem.name >> (i*6)) & 0x3F
mem.name += CHARSET[index]
freq_tx = chirp_common.fix_rounded_step(int(_mem.freq_tx) * 1000)
if _mem.txinhibit:
mem.duplex = "off"
elif mem.freq == freq_tx:
mem.duplex = ""
mem.offset = 0
elif 144000000 <= mem.freq < 148000000:
mem.duplex = "+" if freq_tx > mem.freq else "-"
mem.offset = abs(mem.freq - freq_tx)
else:
mem.duplex = "split"
mem.offset = freq_tx
mem.mode = _mem.narrow and "NFM" or "FM"
mem.power = POWER_LEVELS[_mem.low_power]
rtone = int(_mem.rtone)
ctone = int(_mem.ctone)
tmode_tx = tmode_rx = ""
if rtone & 0x80:
tmode_tx = "DTCS"
mem.dtcs = chirp_common.DTCS_CODES[int(rtone) - 0x80]
elif rtone:
tmode_tx = "Tone"
mem.rtone = TONES[rtone - 1]
if not ctone:
# not used, but this is a better default than 88.5
mem.ctone = TONES[rtone - 1]
if ctone & 0x80:
tmode_rx = "DTCS"
mem.rx_dtcs = chirp_common.DTCS_CODES[int(ctone) - 0x80]
elif ctone:
tmode_rx = "Tone"
mem.ctone = TONES[ctone - 1]
if tmode_tx == "Tone" and not tmode_rx:
mem.tmode = "Tone"
elif tmode_tx == tmode_rx and tmode_tx == "Tone" and \
mem.rtone == mem.ctone:
mem.tmode = "TSQL"
elif tmode_tx == tmode_rx and tmode_tx == "DTCS" and \
mem.dtcs == mem.rx_dtcs:
mem.tmode = "DTCS"
elif tmode_rx or tmode_tx:
mem.tmode = "Cross"
mem.cross_mode = "%s->%s" % (tmode_tx, tmode_rx)
mem.skip = _mem.skip and "S" or ""
return mem
def get_memory(self, number):
mem = chirp_common.Memory()
mem.number = number
_mem = self._memobj.memory[number - 1]
mem.empty = _mem.empty
mem.freq = chirp_common.fix_rounded_step(int(_mem.freq_rx) * 1000)
for i in range(0, 4):
index = (_mem.name >> (i * 6)) & 0x3F
mem.name += CHARSET[index]
freq_tx = chirp_common.fix_rounded_step(int(_mem.freq_tx) * 1000)
if _mem.txinhibit:
mem.duplex = "off"
elif mem.freq == freq_tx:
mem.duplex = ""
mem.offset = 0
elif 144000000 <= mem.freq < 148000000:
mem.duplex = "+" if freq_tx > mem.freq else "-"
mem.offset = abs(mem.freq - freq_tx)
else:
mem.duplex = "split"
mem.offset = freq_tx
mem.mode = _mem.narrow and "NFM" or "FM"
mem.power = POWER_LEVELS[_mem.low_power]
rtone = int(_mem.rtone)
ctone = int(_mem.ctone)
tmode_tx = tmode_rx = ""
if rtone & 0x80:
tmode_tx = "DTCS"
mem.dtcs = chirp_common.DTCS_CODES[int(rtone) - 0x80]
elif rtone:
tmode_tx = "Tone"
mem.rtone = TONES[rtone - 1]
if not ctone:
# not used, but this is a better default than 88.5
mem.ctone = TONES[rtone - 1]
if ctone & 0x80:
tmode_rx = "DTCS"
mem.rx_dtcs = chirp_common.DTCS_CODES[int(ctone) - 0x80]
elif ctone:
tmode_rx = "Tone"
mem.ctone = TONES[ctone - 1]
if tmode_tx == "Tone" and not tmode_rx:
mem.tmode = "Tone"
elif tmode_tx == tmode_rx and tmode_tx == "Tone" and \
mem.rtone == mem.ctone:
mem.tmode = "TSQL"
elif tmode_tx == tmode_rx and tmode_tx == "DTCS" and \
mem.dtcs == mem.rx_dtcs:
mem.tmode = "DTCS"
elif tmode_rx or tmode_tx:
mem.tmode = "Cross"
mem.cross_mode = "%s->%s" % (tmode_tx, tmode_rx)
mem.skip = _mem.skip and "S" or ""
return mem
