Project

General

Profile

Bug #10304 » icx90.py

Dan Smith, 01/23/2023 08:40 PM

 
# -*- coding: utf-8 -*-
# Copyright 2018-2020 Jaroslav Škarvada <jskarvad@redhat.com>
# Based on various code from the CHIRP

# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.

import logging

from chirp.drivers import icf
import struct
from chirp import chirp_common, bitwise, errors, directory
from chirp.memmap import MemoryMap
from chirp.settings import RadioSetting, RadioSettingGroup, \
RadioSettingValueInteger, RadioSettingValueList, \
RadioSettingValueBoolean, RadioSettingValueString, \
RadioSettingValueFloat, InvalidValueError, RadioSettings
import argparse

ICX90_MEM_FORMAT = """
struct mem_item {
ul24 freq;
u8 dtcs_polarity:2,
unknown_1:2,
offset_freq_mult:1,
unknown_2:2,
freq_mult:1;
u8 unknown_3:1,
duplex:2,
mode:2,
tone_mode:3;
ul16 offset_freq;
u8 dtcs;
u8 tx_tone_lo:4,
tune_step:4;
u8 rx_tone:6,
tx_tone_hi:2;
char name[6];
};
struct bank_item {
u8 invisible_channel:1,
prog_skip:1,
mem_skip:1,
bank_index:5;
u8 bank_channel;
};
struct tv_mem_item {
u8 fixed:7,
mode:1;
ul24 freq;
char name[4];
};

struct mem_item memory[500];
struct mem_item scan_edges[50];
struct bank_item banks[500];
u8 unknown_4[120];
struct mem_item vfo_a_band[10];
struct mem_item vfo_b_band[10];
struct mem_item call_channels[5];
struct tv_mem_item tv_memory[68];
u8 unknown_5[35];
ul16 mem_channel;
u8 autodial;
u8 unknown_6[8];
u8 unknown_7:6,
skip_scan:1,
unknown_8:1;
u8 squelch_level;
struct {
char dtmf_digits[16];
} dtmf_codes[10];
u8 tv_channel_skip[68];
u8 unknown_9[128];
u8 scan_resume;
u8 scan_pause;
u8 unknown_10;
u8 beep_volume;
u8 beep;
u8 backlight;
u8 busy_led;
u8 auto_power_off;
u8 power_save;
u8 monitor;
u8 dial_speedup;
u8 unknown_11;
u8 auto_repeater;
u8 dtmf_speed;
u8 hm_75a_function;
u8 wx_alert;
u8 expand_1;
u8 scan_stop_beep;
u8 scan_stop_light;
u8 unknown_12;
u8 light_position;
u8 light_color;
u8 unknown_13;
u8 band_edge_beep;
u8 auto_power_on;
u8 key_lock;
u8 ptt_lock;
u8 lcd_contrast;
u8 opening_message;
u8 expand_2;
u8 unknown_14;
u8 busy_lockout;
u8 timeout_timer;
u8 active_band;
u8 split;
u8 fm_narrow;
u8 morse_code_enable;
u8 morse_code_speed;
u8 unknown_15[22];
char opening_message_text[6];
u8 unknown_16[186];
u8 unknown_17:4,
tune_step:4;
u8 unknown_18[4];
u8 band_selected;
u8 unknown_19[2];
u8 unknown_20:2,
attenuator:1,
vfo:1,
power:1,
dial_select:1,
memory_name:1,
memory_display:1;
u8 unknown_21[2];
u8 mode:4,
unknown_22:4;
u8 unknown_23[9];
char alpha_tag[6];
u8 vfo_scan;
u8 memory_scan;
u8 unknown_24;
u8 tv_channel;
u8 wx_channel;
char comment[16];
"""

LOG = logging.getLogger(__name__)

# in bytes
MEM_ITEM_SIZE = 16
TV_MEM_ITEM_SIZE = 8

BANK_INDEX = ["A", "B", "C", "D", "E", "F", "G", "H", "J", "L", "N", "O",
"P", "Q", "R", "T", "U", "Y"]
MEM_NUM = 500
BANKS = 18
BANK_NUM = 100
BANK_INDEX_NUM = len(BANK_INDEX)
DTMF_AUTODIAL_NUM = 10
DTMF_DIGITS_NUM = 16
OPENING_MESSAGE_LEN = 6
COMMENT_LEN = 16
BANDS=10
TV_CHANNELS=68

CHARSET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789()*+-,/|= "
NAME_LENGTH = 6
TV_NAME_LENGTH = 4
DUPLEX = ["", "-", "+", ""]
DTCS_POLARITY = ["NN", "NR", "RN", "RR"]
TONE_MODE = ["", "Tone", "TSQL", "DTCS"]
TUNE_STEP = [5.0, 6.25, 8.33, 9.0, 10.0, 12.5, 15.0, 20.0, 25.0, 30.0, 50.0, 100.0, 200.0]
TUNE_STEP_STR = [str(x) for x in TUNE_STEP]
MODE = ["FM", "WFM", "AM"]
TV_MODE = ["WFM", "AM"]

SQUELCH_LEVEL = ["Open", "Auto", "Level 1", "Level 2", "Level 3", "Level 4", "Level 5",
"Level 6", "Level 7", "Level 8", "Level 9"]
AUTODIAL = ["Tone call", "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7", "D8", "D9"]
DTMF_SPEED = ["100 ms", "200 ms", "300 ms", "400 ms"]
SCAN_RESUME = ["0 s", "1 s", "2 s", "3 s", "4 s", "5 s", "Hold"]
SCAN_PAUSE = ["2 s", "4 s", "6 s", "8 s", "10 s", "12 s", "14 s", "16 s", "18 s", "20 s", "Hold"]
BEEP_VOLUME = ["Volume", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12",
"13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25",
"26", "27", "28", "29", "30", "31"]
BACKLIGHT = ["Off", "On", "Auto"]
AUTO_POWER_OFF = ["Off", "30 min", "60 min", "90 min", "120 min"]
POWER_SAVE = ["Off", "1:1", "1:4", "1:8", "1:16", "Auto"]
MONITOR = ["Push", "Hold"]
AUTO_REPEATER = ["Off", "Duplex only", "Duplex & tone"]
HM_75A_FUNCTION = ["Simple", "Normal 1", "Normal 2"]
LIGHT_POSITION = ["LCD", "Key", "All"]
LIGHT_COLOR = ["Green", "Orange", "Red"]
AUTO_POWER_ON = ["Off", "00:30", "01:00", "01:30", "02:00", "02:30", "03:00", "03:30", "04:00",
"04:30", "05:00", "05:30", "06:00", "06:30", "07:00", "07:30", "08:00",
"08:30", "09:00", "09:30", "10:00", "10:30", "11:00", "11:30", "12:00",
"12:30", "13:00", "13:30", "14:00", "14:30", "15:00", "15:30", "16:00",
"16:30", "17:00", "17:30", "18:00", "18:30", "19:00", "19:30", "20:00",
"20:30", "21:00", "21:30", "22:00", "22:30", "23:00", "23:30", "24:00"]
KEY_LOCK = ["Normal", "No squelch", "No volume", "All"]
LCD_CONTRAST = ["1", "2", "3", "4"]
TIMEOUT_TIMER = ["Off", "1 min", "3 min", "5 min", "10 min"]
ACTIVE_BAND = ["All", "Single"]
MORSE_CODE_SPEED = ["10 WPM", "15 WPM", "20 WPM", "25 WPM"]
WX_CHANNEL = ["WX01", "WX02", "WX03", "WX04", "WX05", "WX06", "WX07", "WX08", "WX09", "WX10"]
MEMORY_DISPLAY = ["Channel", "Bank"]
DIAL_SELECT = ["Normal", "Volume"]
POWER = ["High", "Low"]
VFO = ["A", "B"]
OPERATION_MODE = ["VFO", "Memory", "Call channel", "TV"]
VFO_SCAN = ["All", "Band", "P0", "P1", "P2", "P3", "P4", "P5", "P6", "P7", "P8",
"P9", "P10", "P11", "P12", "P13", "P14", "P15", "P16", "P17", "P18",
"P19", "P20", "P21", "P22", "P23", "P24"]
MEMORY_SCAN = ["All", "Bank", "Sel BC", "Sel 5 MHz", "Sel 50 MHz", "Sel WFM", "Sel Air",
"Sel 144 MHz", "Sel 220 MHz", "Sel 300 MHz", "Sel 440 MHz", "Sel 800 MHz"]

class ICx90BankModel(icf.IcomIndexedBankModel):
bank_index = BANK_INDEX

def get_mappings(self):
banks = []

if (self._radio._num_banks != len(type(self).bank_index)):
raise Exception("Invalid number of banks %d, supported only %d banks" %
(self._radio._num_banks, len(type(self).bank_index)))

for i in range(0, self._radio._num_banks):
index = type(self).bank_index[i]
bank = self._radio._bank_class(self, index, "BANK-%s" % index)
bank.index = i
banks.append(bank)

return banks

class ICT90_Alias(chirp_common.Alias):
VENDOR = "Icom"
MODEL = "IC-T90"

@directory.register
class ICx90Radio(icf.IcomCloneModeRadio):
"""Icom IC-E/T90"""
VENDOR = "Icom"
MODEL = "IC-E90"
# read clone response after each clone frame is sent
# MUNCH_CLONE_RESP = True

ALIASES = [ICT90_Alias]

_model = "\x25\x07\x00\x01"
_memsize = 0x2d40
_endframe = "Icom Inc."

_ranges = [(0x0000, 0x2d40, 32)]
_num_banks = BANKS
_bank_index_bounds = (0, BANK_NUM - 1)
_can_hispeed = False

def __init__(self, pipe):
icf.IcomCloneModeRadio.__init__(self, pipe)

def special_add(self, key, item_type, num, unique_idx):
item = {}
item["item_type"] = item_type
item["num"] = num
item["uidx"] = unique_idx
self.special[key] = item

def init_special(self):
self.special = {}
i = 0
# program scan edges
for x in range(25):
self.special_add("Scan edge: %02dA" % x, "scan_edge", x * 2, i)
self.special_add("Scan edge: %02dB" % x, "scan_edge", x * 2 + 1, i + 1)
i += 2
# call channels
for x in range(5):
self.special_add("Call ch: %d" % x, "call_chan", x, i)
i += 1
# VFO A
for x in range(10):
self.special_add("VFO A: %d" % x, "vfo_a", x, i)
i += 1
# VFO B
for x in range(10):
self.special_add("VFO B: %d" % x, "vfo_b", x, i)
i += 1

def get_sub_devices(self):
return [ICx90Radio_ham(self._mmap), ICx90Radio_tv(self._mmap)]

def clear_bank(self, loc):
# it seems that empty invisible channel which isn't in bank is defined in bank_item by bytes 0x9f 0x00,
# i.e. it has invisible_channel == 1
# it seems that non-empty visible channel which isn't in bank is defined in bank_item by bytes 0x1f 0x00,
# i.e. it has invisible_channel == 0
# so do not touch the invisible_channel (the bit 7 of the first byte) here and only
# set the rest of the bits
self.memobj.banks[loc].bank_index = 0x1f
self.memobj.banks[loc].prog_skip = 0
self.memobj.banks[loc].mem_skip = 0
self.memobj.banks[loc].bank_channel = 0

# it seems the bank driver has different terminology about bank number and index
# so in fact _get_bank and _set_bank are about indexes (i.e index in the array
# of bank names - A .. Y
# and _get_bank_index and _set_bank_index are about positions in the bank (0..99)
def _get_bank(self, loc):
i = self.memobj.banks[loc].bank_index
return i if i < BANK_INDEX_NUM else None

def _set_bank(self, loc, bank):
if bank is None:
self.clear_bank(loc)
else:
self.memobj.banks[loc].bank_index = bank
# it seems if invisible_channel == 1 the channel is invisible (deleted)
# so set it explicitly as visible
self.memobj.banks[loc].invisible_channel = 0

def _get_bank_index(self, loc):
i = self.memobj.banks[loc].bank_channel
return i if i < BANK_NUM else None

def _set_bank_index(self, loc, index):
self.memobj.banks[loc].bank_channel = index

def get_features(self):
self.init_special()
rf = chirp_common.RadioFeatures()
rf.has_settings = True
rf.has_name = True
rf.has_bank = True
rf.has_bank_index = True
rf.has_bank_names = False
rf.can_delete = True
rf.has_ctone = True
rf.has_dtcs = True
rf.has_dtcs_polarity = True
rf.has_tuning_step = True
rf.has_comment = False
rf.memory_bounds = (0, MEM_NUM - 1)
rf.has_sub_devices = True
rf.valid_characters = CHARSET
rf.valid_modes = list(MODE)
rf.valid_tmodes = list(TONE_MODE)
rf.valid_duplexes = list(DUPLEX)[:-1]
rf.valid_tuning_steps = list(TUNE_STEP)
rf.valid_bands = [(495000, 999990000)]
rf.valid_skips = ["", "S", "P"]
rf.valid_name_length = NAME_LENGTH
rf.valid_special_chans = sorted(self.special.keys())

return rf

def map_dtmf_chirp2icom(self, item):
item = str(item).upper()
if item == "*":
item = "E"
elif item == "#":
item = "F"
elif item == " ":
return 0xff
try:
ret = int(item, 16)
except ValueError:
raise errors.InvalidDataError("invalid DTMF number '%s'" % item)
return ret

def dtmf_chirp2icom(self, dtmf):
return "".join(map(self.map_dtmf_chirp2icom, str(dtmf).rjust(DTMF_DIGITS_NUM)))

def map_dtmf_icom2chirp(self, item):
item = ord(item)
if item == 0xff:
return " "
else:
item &= 0x0f
if item < 10:
return str(item)
else:
return ["A", "B", "C", "D", "*", "#"][item - 10]

def dtmf_icom2chirp(self, dtmf):
return "".join(map(self.map_dtmf_icom2chirp, str(dtmf)))

def apply_dtmf_autodial(self, setting, obj):
obj = self.dtmf_chirp2icom(setting.value)

def get_settings(self):
try:
_squelch = 1
basic = RadioSettingGroup("basic", "Basic")
expand_1 = RadioSettingGroup("expand_1", "Expand 1")
expand_2 = RadioSettingGroup("expand_2", "Expand 2")
dtmf_autodial = RadioSettingGroup("dtmf_autodial", "DTMF autodial")
group = RadioSettings(basic, expand_1, expand_2, dtmf_autodial)

# basic
basic.append(RadioSetting("mem_channel", "Current memory channel",
RadioSettingValueInteger(0, MEM_NUM - 1, self.memobj.mem_channel)))
basic.append(RadioSetting("squelch_level", "Squelch level",
RadioSettingValueList(SQUELCH_LEVEL,
SQUELCH_LEVEL[self.memobj.squelch_level])))
basic.append(RadioSetting("scan_resume", "Scan resume",
RadioSettingValueList(SCAN_RESUME,
SCAN_RESUME[self.memobj.scan_resume])))
basic.append(RadioSetting("scan_pause", "Scan pause",
RadioSettingValueList(SCAN_PAUSE,
SCAN_PAUSE[self.memobj.scan_pause])))
basic.append(RadioSetting("beep_volume", "Beep audio",
RadioSettingValueList(BEEP_VOLUME,
BEEP_VOLUME[self.memobj.beep_volume])))
basic.append(RadioSetting("beep", "Operation beep",
RadioSettingValueBoolean(self.memobj.beep)))
basic.append(RadioSetting("backlight", "LCD backlight",
RadioSettingValueList(BACKLIGHT,
BACKLIGHT[self.memobj.backlight])))
basic.append(RadioSetting("busy_led", "Busy LED",
RadioSettingValueBoolean(self.memobj.busy_led)))
basic.append(RadioSetting("auto_power_off", "Auto power off",
RadioSettingValueList(AUTO_POWER_OFF,
AUTO_POWER_OFF[self.memobj.auto_power_off])))
basic.append(RadioSetting("power_save", "Power save",
RadioSettingValueList(POWER_SAVE,
POWER_SAVE[self.memobj.power_save])))
basic.append(RadioSetting("monitor", "Monitor",
RadioSettingValueList(MONITOR,
MONITOR[self.memobj.monitor])))
basic.append(RadioSetting("dial_speedup", "Dial speedup",
RadioSettingValueBoolean(self.memobj.dial_speedup)))
basic.append(RadioSetting("auto_repeater", "Auto repeater",
RadioSettingValueList(AUTO_REPEATER,
AUTO_REPEATER[self.memobj.auto_repeater])))
basic.append(RadioSetting("hm_75a_function", "HM-75A function",
RadioSettingValueList(HM_75A_FUNCTION,
HM_75A_FUNCTION[self.memobj.hm_75a_function])))
basic.append(RadioSetting("wx_alert", "WX alert",
RadioSettingValueBoolean(self.memobj.wx_alert)))
basic.append(RadioSetting("wx_channel", "Current WX channel",
RadioSettingValueList(WX_CHANNEL,
WX_CHANNEL[self.memobj.wx_channel])))
basic.append(RadioSetting("comment", "Comment",
RadioSettingValueString(0, COMMENT_LEN,
str(self.memobj.comment),
autopad = True)))
basic.append(RadioSetting("tune_step", "Current tune step",
RadioSettingValueList(TUNE_STEP_STR,
TUNE_STEP_STR[self.memobj.tune_step])))
basic.append(RadioSetting("band_selected", "Selected band",
RadioSettingValueInteger(0, BANDS - 1, self.memobj.band_selected)))
basic.append(RadioSetting("memory_display", "Memory display",
RadioSettingValueList(MEMORY_DISPLAY,
MEMORY_DISPLAY[self.memobj.memory_display])))
basic.append(RadioSetting("memory_name", "Memory name",
RadioSettingValueBoolean(self.memobj.memory_name)))
basic.append(RadioSetting("dial_select", "Dial select",
RadioSettingValueList(DIAL_SELECT,
DIAL_SELECT[self.memobj.dial_select])))
basic.append(RadioSetting("power", "RF power",
RadioSettingValueList(POWER,
POWER[self.memobj.power])))
basic.append(RadioSetting("vfo", "Current VFO",
RadioSettingValueList(VFO,
VFO[self.memobj.vfo])))
basic.append(RadioSetting("attenuator", "RF attenuator",
RadioSettingValueBoolean(self.memobj.attenuator)))
basic.append(RadioSetting("skip_scan", "Skip scan",
RadioSettingValueBoolean(self.memobj.skip_scan)))
# TODO: this needs to be reverse engineered, because the following commented
# code does not seem correct
# basic.append(RadioSetting("mode", "Current mode",
# RadioSettingValueList(OPERATION_MODE,
# OPERATION_MODE[self.memobj.mode])))
basic.append(RadioSetting("vfo_scan", "VFO scan",
RadioSettingValueList(VFO_SCAN,
VFO_SCAN[self.memobj.vfo_scan])))
basic.append(RadioSetting("memory_scan", "Memory scan",
RadioSettingValueList(MEMORY_SCAN,
MEMORY_SCAN[self.memobj.memory_scan])))
basic.append(RadioSetting("tv_channel", "Current TV channel",
RadioSettingValueInteger(0, TV_CHANNELS - 1, self.memobj.tv_channel)))

# DTMF auto dial
dtmf_autodial.append(RadioSetting("autodial", "Autodial",
RadioSettingValueList(AUTODIAL,
AUTODIAL[self.memobj.autodial])))
dtmf_autodial.append(RadioSetting("dtmf_speed", "Speed",
RadioSettingValueList(DTMF_SPEED,
DTMF_SPEED[self.memobj.dtmf_speed])))
for x in range(DTMF_AUTODIAL_NUM):
rs = RadioSetting("dtmf_codes[%d].dtmf_digits" % x, "DTMF autodial: %d" % x,
RadioSettingValueString(0, DTMF_DIGITS_NUM,
self.dtmf_icom2chirp(self.memobj.dtmf_codes[x].dtmf_digits),
autopad = True, charset = "0123456789ABCD*#abcd "))
rs.set_apply_callback(self.apply_dtmf_autodial, self.memobj.dtmf_codes[x].dtmf_digits)
dtmf_autodial.append(rs)

# expand 1
expand_1.append(RadioSetting("expand_1", "Expand 1",
RadioSettingValueBoolean(self.memobj.expand_1)))
expand_1.append(RadioSetting("scan_stop_beep", "Scan stop beep",
RadioSettingValueBoolean(self.memobj.scan_stop_beep)))
expand_1.append(RadioSetting("scan_stop_light", "Scan stop light",
RadioSettingValueBoolean(self.memobj.scan_stop_light)))
expand_1.append(RadioSetting("light_postion", "Light position",
RadioSettingValueList(LIGHT_POSITION,
LIGHT_POSITION[self.memobj.light_position])))
expand_1.append(RadioSetting("light_color", "Light color",
RadioSettingValueList(LIGHT_COLOR,
LIGHT_COLOR[self.memobj.light_color])))
expand_1.append(RadioSetting("band_edge_beep", "Band edge beep",
RadioSettingValueBoolean(self.memobj.band_edge_beep)))
expand_1.append(RadioSetting("auto_power_on", "Auto power on",
RadioSettingValueList(AUTO_POWER_ON,
AUTO_POWER_ON[self.memobj.auto_power_on])))
expand_1.append(RadioSetting("key_lock", "Key lock",
RadioSettingValueList(KEY_LOCK,
KEY_LOCK[self.memobj.key_lock])))
expand_1.append(RadioSetting("ptt_lock", "PTT lock",
RadioSettingValueBoolean(self.memobj.ptt_lock)))
expand_1.append(RadioSetting("lcd_contrast", "LCD contrast",
RadioSettingValueList(LCD_CONTRAST,
LCD_CONTRAST[self.memobj.lcd_contrast])))
expand_1.append(RadioSetting("opening_message", "Opening message",
RadioSettingValueBoolean(self.memobj.opening_message)))
expand_1.append(RadioSetting("opening_message_text", "Opening message",
RadioSettingValueString(0, OPENING_MESSAGE_LEN,
str(self.memobj.opening_message_text),
autopad = True, charset = CHARSET)))

# expand 2
expand_2.append(RadioSetting("expand_2", "Expand 2",
RadioSettingValueBoolean(self.memobj.expand_2)))
expand_2.append(RadioSetting("busy_lockout", "Busy lock out",
RadioSettingValueBoolean(self.memobj.busy_lockout)))
expand_2.append(RadioSetting("timeout_timer", "Timeout timer",
RadioSettingValueList(TIMEOUT_TIMER,
TIMEOUT_TIMER[self.memobj.timeout_timer])))
expand_2.append(RadioSetting("active_band", "Active band",
RadioSettingValueList(ACTIVE_BAND,
ACTIVE_BAND[self.memobj.active_band])))
expand_2.append(RadioSetting("fm_narrow", "FM narrow",
RadioSettingValueBoolean(self.memobj.fm_narrow)))
expand_2.append(RadioSetting("split", "Split",
RadioSettingValueBoolean(self.memobj.split)))
expand_2.append(RadioSetting("morse_code_enable", "Morse code synthesizer",
RadioSettingValueBoolean(self.memobj.morse_code_enable)))
expand_2.append(RadioSetting("morse_code_speed", "Morse code speed",
RadioSettingValueList(MORSE_CODE_SPEED,
MORSE_CODE_SPEED[self.memobj.morse_code_speed])))

return group
except:
import traceback
LOG.error("Failed to parse settings: %s", traceback.format_exc())
return None

def set_settings(self, settings):
for element in settings:
if not isinstance(element, RadioSetting):
self.set_settings(element)
continue
if not element.changed():
continue
try:
if element.has_apply_callback():
LOG.debug("Using apply callback")
try:
element.run_apply_callback()
except NotImplementedError as e:
LOG.error("icx90: %s", e)
continue

# Find the object containing setting.
obj = self.memobj
bits = element.get_name().split(".")
setting = bits[-1]
for name in bits[:-1]:
if name.endswith("]"):
name, index = name.split("[")
index = int(index[:-1])
obj = getattr(obj, name)[index]
else:
obj = getattr(obj, name)

try:
old_val = getattr(obj, setting)
LOG.debug("Setting %s(%r) <= %s" % (
element.get_name(), old_val, element.value))
setattr(obj, setting, element.value)
except AttributeError as e:
LOG.error("Setting %s is not in the memory map: %s" %
(element.get_name(), e))
except Exception as e:
LOG.debug(element.get_name())
raise

def process_mmap(self):
self.memobj = bitwise.parse(ICX90_MEM_FORMAT, self._mmap)

def get_raw_memory(self, number):
(mem_item, special, unique_idx) = self.get_mem_item(number)
return repr(mem_item)

def sync_in(self):
icf.IcomCloneModeRadio.sync_in(self)
self.process_mmap()

def sync_out(self):
icf.IcomCloneModeRadio.sync_out(self)

def freq_chirp2icom(self, freq):
if chirp_common.is_fractional_step(freq):
mult = 6250
multr = 1
else:
mult = 5000
multr = 0

return (freq / mult, multr)

def freq_icom2chirp(self, freq, mult):
return freq * (6250 if mult else 5000)

def get_skip(self, number):
bank_item = self.memobj.banks[number]
if bank_item.prog_skip:
return "P"
elif bank_item.mem_skip:
return "S"
return ""

def set_skip(self, number, skip):
bank_item = self.memobj.banks[number]
if skip == "P":
bank_item.prog_skip = 1
bank_item.mem_skip = 1
elif skip == "S":
bank_item.prog_skip = 0
bank_item.mem_skip = 1
elif skip == "":
bank_item.prog_skip = 0
bank_item.mem_skip = 0
else:
raise errors.InvalidDataError("skip '%s' not supported" % skip)

# returns (memobj.mem_item, is_special_channel, unique_idx)
def get_mem_item(self, number):
try:
item_type = self.special[number]["item_type"]
num = self.special[number]["num"]
unique_idx = self.special[number]["uidx"]
if item_type == "scan_edge":
return (self.memobj.scan_edges[num], True, unique_idx)
elif item_type == "call_chan":
return (self.memobj.call_channels[num], True, unique_idx)
elif item_type == "vfo_a":
return (self.memobj.vfo_a_band[num], True, unique_idx)
elif item_type == "vfo_b":
return (self.memobj.vfo_b_band[num], True, unique_idx)
else:
raise errors.InvalidDataError("unknown special channel type '%s'" % item_type)
except KeyError:
return (self.memobj.memory[number], False, number)

def get_raw_memory(self, number):
(mem_item, special, unique_idx) = self.get_mem_item(number)
return repr(mem_item)

def get_memory(self, number):
mem = chirp_common.Memory()

(mem_item, special, unique_idx) = self.get_mem_item(number)

freq = self.freq_icom2chirp(mem_item.freq, mem_item.freq_mult)
if freq == 0:
mem.empty = True
else:
mem.empty = False
mem.freq = freq
if special:
mem.name = " " * NAME_LENGTH
else:
mem.name = str(mem_item.name).rstrip("\x00 ")
mem.rtone = chirp_common.TONES[(mem_item.tx_tone_hi << 4) + mem_item.tx_tone_lo]
mem.ctone = chirp_common.TONES[mem_item.rx_tone]
mem.dtcs = chirp_common.DTCS_CODES[mem_item.dtcs]
mem.dtcs_polarity = DTCS_POLARITY[mem_item.dtcs_polarity]
mem.offset = self.freq_icom2chirp(mem_item.offset_freq, mem_item.offset_freq_mult)
mem.duplex = DUPLEX[mem_item.duplex]
mem.tmode = TONE_MODE[mem_item.tone_mode]
mem.tuning_step = TUNE_STEP[mem_item.tune_step]
mem.mode = MODE[mem_item.mode]
if not special:
mem.skip = self.get_skip(number)
if special:
mem.extd_number = number
mem.number = -len(self.special) + unique_idx
else:
mem.number = number

return mem

def set_memory(self, memory):
(mem_item, special, unique_idx) = self.get_mem_item(memory.number)
if memory.empty:
mem_item.set_raw("\x00" * MEM_ITEM_SIZE)
self.clear_bank(memory.number)
self.memobj.banks[memory.number].invisible_channel = 1
else:
(mem_item.freq, mem_item.freq_mult) = self.freq_chirp2icom(memory.freq)
if special:
mem_item.name = " " * NAME_LENGTH
else:
self.memobj.banks[memory.number].invisible_channel = 0

for x in range(NAME_LENGTH):
try:
mem_item.name[x] = str(memory.name[x])
except IndexError:
mem_item.name[x] = " "
mem_item.tx_tone_hi = chirp_common.TONES.index(memory.rtone) >> 4
mem_item.tx_tone_lo = chirp_common.TONES.index(memory.rtone) & 0x0f
mem_item.rx_tone = chirp_common.TONES.index(memory.ctone)
mem_item.dtcs = chirp_common.DTCS_CODES.index(memory.dtcs)
mem_item.dtcs_polarity = DTCS_POLARITY.index(memory.dtcs_polarity)
(mem_item.offset_freq, mem_item.offset_freq_mult) = self.freq_chirp2icom(memory.offset)
mem_item.duplex = DUPLEX.index(memory.duplex)
mem_item.tone_mode = TONE_MODE.index(memory.tmode)
mem_item.tune_step = TUNE_STEP.index(memory.tuning_step)
mem_item.mode = MODE.index(memory.mode)
if not special:
self.set_skip(memory.number, memory.skip)

def get_bank_model(self):
return ICx90BankModel(self)

class ICx90Radio_ham(ICx90Radio):

def get_features(self):
rf = ICx90Radio.get_features(self)
rf.has_sub_devices = False

return rf

class ICx90Radio_tv(ICx90Radio):
VARIANT = "TV"

def get_features(self):
rf = chirp_common.RadioFeatures()
rf.has_settings = True
rf.has_name = True
rf.has_bank = False
rf.has_bank_index = False
rf.has_bank_names = False
rf.can_delete = True
rf.has_ctone = False
rf.has_dtcs = False
rf.has_dtcs_polarity = False
rf.has_tuning_step = False
rf.has_comment = False
rf.has_sub_devices = False
rf.memory_bounds = (0, TV_CHANNELS - 1)
rf.valid_characters = CHARSET
rf.valid_modes = list(TV_MODE)
rf.valid_tmodes = []
rf.valid_duplexes = [""]
rf.valid_tuning_steps = []
rf.valid_bands = [(46750000, 957750000)]
rf.valid_skips = ["", "S"]
rf.valid_name_length = TV_NAME_LENGTH
rf.valid_special_chans = []

return rf

def get_bank_model(self):
return None

def freq_chirp2icom(self, freq):
return freq / 5000

def freq_icom2chirp(self, freq):
return freq * 5000

def get_skip(self, number):
if self.memobj.tv_channel_skip[number] == 2:
return "S"
return ""

def set_skip(self, number, skip):
if skip == "S":
self.memobj.tv_channel_skip[number] = 2
elif skip == "":
self.memobj.tv_channel_skip[number] = 0
else:
raise errors.InvalidDataError("skip '%s' not supported" % skip)

def get_raw_memory(self, number):
return repr(self.memobj.tv_memory[number])

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 set_memory(self, memory):
mem_item = self.memobj.tv_memory[memory.number]
if memory.empty:
self.memobj.tv_channel_skip[memory.number] = 1
mem_item.set_raw("\x00" * TV_MEM_ITEM_SIZE)
else:
mem_item.freq = self.freq_chirp2icom(memory.freq)
for x in range(TV_NAME_LENGTH):
try:
mem_item.name[x] = str(memory.name[x])
except IndexError:
mem_item.name[x] = " "

mem_item.mode = TV_MODE.index(memory.mode)
self.set_skip(memory.number, memory.skip)

def dump_banks(icx90, template_file):
mb = icx90.get_features().memory_bounds
with open(template_file, "w") as f:
for mi in range(mb[0], mb[1] + 1):
mem = icx90.get_memory(mi)
bank = icx90._get_bank(mi)
if bank is not None:
bank = BANK_INDEX[bank]
bank_pos = icx90._get_bank_index(mi)
if not mem.empty and bank is not None and bank_pos is not None:
f.write("%s;%s;%d\n" % (mem.name, bank, bank_pos))

def read_template_file(template_file):
banks_templ = {}
with open(template_file, "r") as f:
for line in f:
l = line.split(";")
l[1] = BANK_INDEX.index(l[1])
banks_templ[l[0]] = l[1:]
return banks_templ

def reorder_banks(icx90, preserve_position, preserve_unknown, banks_templ):
banks_cnt = []
mb = icx90.get_features().memory_bounds
for i in range(0, BANKS):
banks_cnt.append(0)
for mi in range(mb[0], mb[1] + 1):
mem = icx90.get_memory(mi)
if preserve_unknown:
bank = icx90._get_bank(mi)
bank_pos = icx90._get_bank_index(mi)
else:
bank = None
bank_pos = 0
if not mem.empty:
if mem.name in banks_templ:
bank = int(banks_templ[mem.name][0])
if preserve_position:
bank_pos = int(banks_templ[mem.name][1])
else:
bank_pos = banks_cnt[bank]
banks_cnt[bank] += 1
print("%s\t-> %s, %02d" % (mem.name, BANK_INDEX[bank], bank_pos))
# explicitly set non empty channel as visible
icx90.memobj.banks[mi].invisible_channel = 0
if bank >= BANKS or bank_pos >= BANK_NUM:
bank = None
bank_pos = 0
icx90._set_bank(mi, bank)
icx90._set_bank_index(mi, bank_pos)

if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Icom IC-E90 banks handling helper.")
parser.add_argument("icx90_img_file", help="IC-X90 IMG file.")
parser.add_argument("template_file", help="Banks template file.")
parser.add_argument("-r", "--read-banks", action="store_true",
help="Read banks content and store it to template file.")
parser.add_argument("-f", "--fix-banks", action="store_true",
help="Fix banks content, reorder channels in banks according to the provided template file and write it to IMG file.")
parser.add_argument("-p", "--preserve-position", action="store_true",
help="Preserve bank position as in the template file if possible, otherwise put channels to banks according their position in the memory.")
parser.add_argument("-u", "--preserve-unknown", action="store_true",
help="Preserve channels in banks if they aren't in the template file and don't conflicts with the template file, otherwise remove them from the banks.")
parser.add_argument("-b", "--backup_img", action="store_true",
help="Backup IMG file before changing it.")

args = vars(parser.parse_args())

options_ok = True
try:
icx90_img_file = str(args.pop("icx90_img_file"))
template_file = str(args.pop("template_file"))
except KeyError:
options_ok = False

if options_ok and (args["read_banks"] or args["fix_banks"]):
icx90 = ICx90Radio(icx90_img_file)
if args["read_banks"]:
dump_banks(icx90, template_file)
elif args["fix_banks"]:
banks_templ = read_template_file(template_file)
if args["backup_img"]:
icx90.save_mmap(icx90_img_file + ".bak")
reorder_banks(icx90, args["preserve_position"], args["preserve_unknown"], banks_templ)
icx90.save_mmap(icx90_img_file)
else:
parser.print_help()
(3-3/7)