def set_memory(self, mem):
# Get a low-level memory object mapped to the image
_mem = self._memobj.memory[mem.number]
if mem.empty:
_mem.set_raw("\xff" * (_mem.size() / 8))
_mem.empty = 0x00
else:
_mem.empty = self._get_empty_flag(mem.freq, mem.mode)
_mem.freq = mem.freq
_mem.mode = self.MODES.index(mem.mode)
_mem.step = self.STEPS.index(mem.tuning_step)
_mem.offset = mem.offset
_mem.duplex = self.DUPLEX.index(mem.duplex)
if mem.tmode == "Cross":
_mem.squelch_type = self.TMODES.index("TSQL")
try:
_mem.tx_tone = ALINCO_TONES.index(mem.rtone) + 1
except ValueError:
raise errors.UnsupportedToneError(
"This radio does not support tone %.1fHz" % mem.rtone)
try:
_mem.rx_tone = ALINCO_TONES.index(mem.ctone) + 1
except ValueError:
raise errors.UnsupportedToneError(
"This radio does not support tone %.1fHz" % mem.ctone)
elif mem.tmode == "TSQL":
_mem.squelch_type = self.TMODES.index("TSQL")
# Note how the same TSQL tone is copied to both memory
# locaations
try:
_mem.tx_tone = ALINCO_TONES.index(mem.ctone) + 1
_mem.rx_tone = ALINCO_TONES.index(mem.ctone) + 1
except ValueError:
raise errors.UnsupportedToneError(
"This radio does not support tone %.1fHz" % mem.ctone)
else:
_mem.squelch_type = self.TMODES.index(mem.tmode)
try:
_mem.tx_tone = ALINCO_TONES.index(mem.rtone) + 1
except ValueError:
raise errors.UnsupportedToneError(
"This radio does not support tone %.1fHz" % mem.rtone)
try:
_mem.rx_tone = ALINCO_TONES.index(mem.ctone) + 1
except ValueError:
raise errors.UnsupportedToneError(
"This radio does not support tone %.1fHz" % mem.ctone)
_mem.dcs = DCS_CODES[self.VENDOR].index(mem.dtcs)
_mem.skip = (mem.skip == "S")
_mem.name = "\x00".join(mem.name).ljust(32, "\x00")
_mem.unknown1 = 0x3e001c
_mem.unknown2 = 0x0000000a
_mem.unknown3 = 0x00000000
_mem.unknown4 = 0x00000000
def set_memory(self, memory):
supported_tones = list(chirp_common.OLD_TONES)
supported_tones.remove(69.3)
if memory.rtone not in supported_tones:
raise errors.UnsupportedToneError("This radio does not support " +
"tone %.1fHz" % memory.rtone)
if memory.ctone not in supported_tones:
raise errors.UnsupportedToneError("This radio does not support " +
"tone %.1fHz" % memory.ctone)
return KenwoodLiveRadio.set_memory(self, memory)
def set_memory(self, mem):
if mem.number > len(self._memobj.memory):
_mem = self._memobj.special[mem.number - len(self._memobj.memory) -
1]
_flg = self._memobj.specialflag[mem.number -
len(self._memobj.memory) - 1]
else:
_mem = self._memobj.memory[mem.number - 1]
_flg = self._memobj.flag[mem.number - 1]
# initialize new channel to safe defaults
if not mem.empty and not _flg.used:
_flg.used = True
_mem.unknown1 = 0x00
_mem.unknown2 = 0x0
_mem.unknown3 = 0x0
_mem.unknown4 = 0x0000
_mem.unknown5 = 0x0
_mem.unknown6 = 0x0
_mem.unknown7 = 0x00
_mem.unknown8 = 0x00
_mem.cpu_shift = 0x0
_mem.sp_rx1 = 0x0
_mem.sp_rx2 = 0x0
_mem.icon = 12 # file cabinet icon
if mem.empty and _flg.used and not _flg.visible:
_flg.used = False
return
_flg.visible = not mem.empty
if mem.empty:
self._wipe_memory_banks(mem)
return
_mem.freq = int(mem.freq / 1000)
_mem.duplex = DUPLEX.index(mem.duplex)
_mem.name = mem.name.ljust(8)
if mem.mode == "NFM":
_mem.mode = MODES.index("FM")
_mem.half_deviation = 1
else:
_mem.mode = MODES.index(mem.mode)
_mem.half_deviation = 0
_mem.tuning_step = STEPS.index(mem.tuning_step)
_mem.offset = int(mem.offset / 1000)
if mem.power:
_mem.power = 3 - POWER_LEVELS.index(mem.power)
else:
_mem.power = 0
_mem.tmode = TMODES.index(mem.tmode)
try:
_mem.tone = chirp_common.OLD_TONES.index(mem.rtone)
except ValueError:
raise errors.UnsupportedToneError(
("This radio does not support tone %s" % mem.rtone))
_mem.dtcs = chirp_common.DTCS_CODES.index(mem.dtcs)
_flg.skip = mem.skip == "S"
_flg.pskip = mem.skip == "P"
def _make_mem_spec(self, mem):
try:
rti = self._kenwood_valid_tones.index(mem.rtone)
cti = self._kenwood_valid_tones.index(mem.ctone)
except ValueError:
raise errors.UnsupportedToneError()
spec = ( \
"%010i" % mem.freq,
"0",
"%i" % THK2_DUPLEX.index(mem.duplex),
"0",
"%i" % int(mem.tmode == "Tone"),
"%i" % int(mem.tmode == "TSQL"),
"%i" % int(mem.tmode == "DTCS"),
"%02i" % rti,
"%02i" % cti,
"%03i" % chirp_common.DTCS_CODES.index(mem.dtcs),
"%08i" % mem.offset,
"%i" % THK2_MODES.index(mem.mode),
"0",
"%010i" % 0,
"0",
"%i" % int(mem.skip == "S")
)
return spec
def ctcss_tone_bits_to_val(tone_byte):
# TODO use the custom setting 0x33 and ref the custom ctcss
# field
tone_byte = int(tone_byte)
if tone_byte in TONE_MAP_VAL_TO_TONE:
return TONE_MAP_VAL_TO_TONE[tone_byte]
elif tone_byte == TONE_CUSTOM_CTCSS:
LOG.info('custom ctcss not implemented (yet?).')
else:
raise errors.UnsupportedToneError('unknown ctcss tone value: %02x' %
tone_byte)
def set_memory(self, mem):
_mem = self._memobj.memory[mem.number]
_skp = self._memobj.skips[mem.number / 8]
_usd = self._memobj.used_flags[mem.number / 8]
bit = (0x80 >> (mem.number % 8))
if self._get_used(mem.number) and not mem.empty:
# Initialize the memory
_mem.set_raw("\x00" * 32)
self._set_used(mem.number, not mem.empty)
if mem.empty:
return
_mem.freq = mem.freq / 100
try:
_tone = mem.rtone
_mem.rtone = self._valid_tones.index(mem.rtone)
_tone = mem.ctone
_mem.ctone = self._valid_tones.index(mem.ctone)
except ValueError:
raise errors.UnsupportedToneError("This radio does not support " +
"tone %.1fHz" % _tone)
_mem.duplex = DUPLEX.index(mem.duplex)
_mem.offset = mem.offset / 100
_mem.tmode = TMODES.index(mem.tmode)
_mem.dtcs_tx = DCS_CODES[self.VENDOR].index(mem.dtcs)
_mem.dtcs_rx = DCS_CODES[self.VENDOR].index(mem.dtcs)
_mem.step = STEPS.index(mem.tuning_step)
_mem.isnarrow = mem.mode == "NFM"
self._set_power(_mem, mem)
if mem.skip:
_skp |= bit
else:
_skp &= ~bit
_mem.name = _set_name(mem, _mem)
self._set_extra(_mem, mem)
def set_memory(self, mem):
_mem = self._memobj.memory[mem.number - 1]
_flg = self._memobj.flag[mem.number - 1]
_flg_repeat = self._memobj.flag_repeat[mem.number - 1]
if mem.empty:
_flg.used = False
return
if (len(mem.name) == 0):
_mem.name = [0x24] * 4
_mem.showname = 0
else:
_mem.showname = 1
for i in range(0, 4):
_mem.name[i] = CHARSET.index(mem.name.ljust(4)[i])
_mem.freq = int(mem.freq / 1000)
_mem.duplex = DUPLEX.index(mem.duplex)
_mem.offset = int(mem.offset / 1000)
_mem.mode = MODES.index(mem.mode)
_mem.tuning_step = TUNING_STEPS.index(mem.tuning_step)
if mem.power:
if (mem.power == POWER_LEVELS[0]):
# low power level is not changed when high power is selected
_mem.ishighpower = 0x01
if (_mem.power == 3):
# Set low power to L3 (0x02) if it is
# set to 3 (new object default)
LOG.debug("SETTING DEFAULT?")
_mem.power = 0x02
else:
_mem.ishighpower = 0x00
_mem.power = 3 - POWER_LEVELS.index(mem.power)
else:
_mem.ishighpower = 0x01
_mem.power = 0x02
_mem.tmode = TMODES.index(mem.tmode)
try:
_mem.tone = TONES.index(mem.rtone)
except ValueError:
raise errors.UnsupportedToneError(
("This radio does not support tone %s" % mem.rtone))
_mem.dtcs = chirp_common.DTCS_CODES.index(mem.dtcs)
_flg.skip = SKIP_VALUES.index(mem.skip)
# initialize new channel to safe defaults
if not mem.empty and not _flg.used:
_flg.used = True
_flg.mask = True # Mask = True to be visible on radio
_mem.unknown1 = 0x00
_mem.unknown2 = 0x00
_mem.unknown3 = 0x00
_mem.unknown4 = 0x00
_mem.unknown5 = 0x00
_mem.unknown6 = 0x00
_mem.codememno = 0x02 # Not implemented in chirp
_mem.codeorpage = 0x00 # Not implemented in chirp
# Duplicate flags to repeated part in memory
_flg_repeat.skip = _flg.skip
_flg_repeat.mask = _flg.mask
_flg_repeat.used = _flg.used
def ctcss_code_val_to_bits(tone_value):
if tone_value in TONE_MAP_TONE_TO_VAL:
return TONE_MAP_TONE_TO_VAL[tone_value]
else:
raise errors.UnsupportedToneError('Tone %f not supported' % tone_value)
