Project

General

Profile

Bug #10503 » icv80.py

e8c3bb82 - Dan Smith, 04/08/2023 03:55 PM

 
# Copyright 2008 Dan Smith <dsmith at danplanet.com>
#
# 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
from chirp import chirp_common, memmap, bitwise, errors, directory
from chirp.settings import RadioSetting, RadioSettingGroup, \
RadioSettingValueInteger, RadioSettingValueList, \
RadioSettingValueBoolean, RadioSettingValueString, \
RadioSettingValueFloat, RadioSettings

LOG = logging.getLogger(__name__)


ICV80_MEM_FORMAT = """

#seekto 0x0000;
struct {
ul16 freq;
ul16 offset;
char name[5];
u8 unknown0:2,
rtone:6;
u8 unknown1:2,
ctone:6;
u8 unknown2:1,
dtcs:7;
u8 unknown3:5,
tuning_step:3;
u8 unknown4:2,
mode:1,
reverse_duplex:1,
duplex:2,
mult:2;
u8 unknown6:2,
dtcs_polarity:2,
unknown8:2,
tmode:2;
u8 unknown8:5,
tx_inhibit:1,
power:2;
} memory[208];

#seekto 0x0cf0;
u8 skip[32];

#seekto 0x0d10;
u8 unused[32];

#seekto 0x0e50;
struct {
u8 unknown1:6,
beep:2;
u8 unknown2:3,
tot:5;
u8 unknown3;
u8 unknown4:6,
auto_pwr_off:2;
u8 unknown5:6,
lockout:2;
u8 unknown6:7,
squelch_delay:1;
u8 unknown7_0;
u8 unknown7_1:6,
mem_display1:2;
u8 unknown8:6,
mem_display2:2; // CS stores the display value here as well
u8 unknown9:7,
dial_func:1;
u8 unknown10:7,
lcd:1;
u8 unknown11:5,
pwr_save:3;
u8 unknown12:7,
sel_speed:1;
u8 unknown13:6,
mic_mode:2;
u8 unknown14:6,
battery_save:2;
u8 unknown15;
u8 unknown16:6,
resume:2;
u8 unknown17:5,
func_mode:3;
u8 unknown18:6,
backlight:2;
u8 unknown19;
u8 unknown:4,
vox_gain:4;
u8 unknown20:6,
mic_gain:2;
u8 unknown21:5
vox_delay:3;
u8 unknown22:4,
vox_tot:4;
u8 unknown23[2];
u8 unknown24:6,
edge:2;
u8 unknown25;
u8 unknown26:7,
auto_low_pwr:1;
u8 unknown27[3];

} settings;


"""

SPECIAL_CHANNELS = {
"1A": 200, "1B": 201,
"2A": 202, "2B": 203,
"3A": 204, "3B": 205,
"C": 206,
}

TMODES = ["", "Tone", "TSQL", "DTCS"]
MODES = ["FM", "NFM"]
SKIPS = ["", "S"]
DUPLEXES = ["", "-", "+"]
DTCS_POLARITY = ["NN", "NR", "RN", "RR"]
TUNING_STEPS = [5.0, 10.0, 12.5, 15.0, 20.0, 25.0, 30.0, 50.0]
POWER_LEVELS = [
chirp_common.PowerLevel("High", watts=5.5),
chirp_common.PowerLevel("Low", watts=0.5),
chirp_common.PowerLevel("Mid", watts=2.5)
]


@directory.register
class ICV80Radio(icf.IcomCloneModeRadio, chirp_common.ExperimentalRadio):
"""Icom IC-V80"""
VENDOR = "Icom"
MODEL = "IC-V80"

_model = "\x32\x54\x00\x01"
_memsize = 0x0E80
_endframe = "Icom Inc\x2e7C"
_can_hispeed = True
_ranges = [(0x0000, 0x0CE0, 32),
(0x0CE0, 0x0D40, 16),
(0x0D40, 0x0E00, 32),
(0x0E00, 0x0E20, 16),
(0x0E20, 0x0E60, 32),
(0x0E60, 0x0E70, 16),
(0x0E70, 0x0E72, 2),
(0x0E72, 0x0E77, 5),
(0x0E77, 0x0E78, 1),
(0x0E78, 0x0E80, 8),
]

@classmethod
def get_prompts(cls):
rp = chirp_common.RadioPrompts()
rp.experimental = ("This radio driver is currently under development, "
"and not all the features or functions may work as"
"expected. You should proceed with caution.")
return rp

def get_features(self):
rf = chirp_common.RadioFeatures()

rf.memory_bounds = (0, 199)
rf.valid_modes = MODES
rf.valid_tmodes = TMODES
rf.valid_duplexes = DUPLEXES
rf.valid_tuning_steps = TUNING_STEPS
rf.valid_power_levels = POWER_LEVELS
rf.valid_skips = SKIPS
rf.valid_name_length = 5
rf.valid_special_chans = sorted(SPECIAL_CHANNELS.keys())
rf.valid_bands = [(136000000, 174000000)]
rf.has_ctone = True
rf.has_offset = True
rf.has_bank = False
rf.has_settings = True

return rf

def process_mmap(self):
self._memobj = bitwise.parse(ICV80_MEM_FORMAT, self._mmap)

def get_settings(self):
_settings = self._memobj.settings

setmode = RadioSettingGroup("setmode", "Set Mode")
display = RadioSettingGroup("display", "Display")
sounds = RadioSettingGroup("sounds", "Sounds")
scan = RadioSettingGroup("scan", "Scan")
settings = RadioSettings(setmode, display, sounds, scan)

# TOT
opts = ["Off"] + ["%d min" % t for t in range(1, 31)]
setmode.append(
RadioSetting(
"tot", "Time out Timer",
RadioSettingValueList(opts, opts[_settings.tot])))

# Lockout
opts = ["Off", "Rpt", "Busy"]
setmode.append(
RadioSetting(
"lockout", "Lockout",
RadioSettingValueList(opts, opts[_settings.lockout])))

# Auto Power Off
opts = ["Off", "30 min", "1 hr", "2 hrs"]
setmode.append(
RadioSetting(
"auto_pwr_off", "Auto Power Off",
RadioSettingValueList(opts, opts[_settings.auto_pwr_off])))

# Power Save
opts = ["Off", "1:2", "1:8", "1:16", "Auto"]
setmode.append(
RadioSetting(
"pwr_save", "Power Save",
RadioSettingValueList(opts, opts[_settings.pwr_save])))

# Battery Save
opts = ["Off", "Ni-MH", "Li-Ion"]
setmode.append(
RadioSetting(
"battery_save", "Battery Save",
RadioSettingValueList(opts, opts[_settings.battery_save])))

# Auto Low Power
opts = ["Off", "On"]
setmode.append(
RadioSetting(
"auto_low_pwr", "Auto Low Power",
RadioSettingValueList(opts, opts[_settings.auto_low_pwr])))

# Squelch Delay
opts = ["Short", "Long"]
setmode.append(
RadioSetting(
"squelch_delay", "Squelch Delay",
RadioSettingValueList(opts, opts[_settings.squelch_delay])))

# MIC Simple Mode
opts = ["Simple", "Normal 1", "Normal 2"]
setmode.append(
RadioSetting(
"mic_mode", "Mic Simple Mode",
RadioSettingValueList(opts, opts[_settings.mic_mode])))

# MIC Gain
opts = ["1", "2", "3", "4"]
setmode.append(
RadioSetting(
"mic_gain", "Mic Gain",
RadioSettingValueList(opts, opts[_settings.mic_gain])))

# VOX Gain
opts = ["Off"] + ["%d" % t for t in range(1, 11)]
setmode.append(
RadioSetting(
"vox_gain", "VOX Gain",
RadioSettingValueList(opts, opts[_settings.vox_gain])))

# VOX Delay
opts = ["0.5 sec", "1.0 sec", "1.5 sec", "2.0 sec", "2.5 sec",
"3.0 sec"]
setmode.append(
RadioSetting(
"vox_delay", "VOX Delay",
RadioSettingValueList(opts, opts[_settings.vox_delay])))

# VOX Time out Timer
opts = ["Off", "1 min", "2 min", "3 min", "4 min", "5 min", "10 min",
"15 min"]
setmode.append(
RadioSetting(
"vox_tot", "VOX Time-Out Timer",
RadioSettingValueList(opts, opts[_settings.vox_tot])))

# Select Speed
opts = ["Manual", "Auto"]
setmode.append(
RadioSetting(
"sel_speed", "Select Speed",
RadioSettingValueList(opts, opts[_settings.sel_speed])))

# Dial Function
opts = ["Audio Volume", "Tuning Dial"]
setmode.append(
RadioSetting(
"dial_func", "Dial Function",
RadioSettingValueList(opts, opts[_settings.dial_func])))

# Function Mode
opts = ["0 sec", "1 sec", "2 sec", "3 sec", "Manual"]
setmode.append(
RadioSetting(
"func_mode", "Function Mode",
RadioSettingValueList(opts, opts[_settings.func_mode])))

# Backlight
opts = ["Off", "On", "Auto"]
display.append(
RadioSetting(
"backlight", "Backlight",
RadioSettingValueList(opts, opts[_settings.backlight])))

# LCD Contrast
opts = ["Low", "Auto"]
display.append(
RadioSetting(
"lcd", "LCD Contrast",
RadioSettingValueList(opts, opts[_settings.lcd])))

# Memory Display
opts = ["Frequency", "Channel", "Name"]
display.append(
RadioSetting(
"mem_display1", "Memory Display",
RadioSettingValueList(opts, opts[_settings.mem_display1])))

# Beep
opts = ["Off", "1", "2", "3"]
sounds.append(
RadioSetting(
"beep", "Beep",
RadioSettingValueList(opts, opts[_settings.beep])))

# Edge
opts = ["All", "P1", "P2", "P3"]
scan.append(
RadioSetting(
"edge", "Edge",
RadioSettingValueList(opts, opts[_settings.edge])))

# Resume
opts = ["T-5", "T-10", "T-15", "P-2"]
scan.append(
RadioSetting(
"resume", "Resume",
RadioSettingValueList(opts, opts[_settings.resume])))

return settings

def set_settings(self, settings):
_settings = self._memobj.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")
element.run_apply_callback()
else:
setting = element.get_name()
LOG.debug("Setting %s = %s" % (setting, element.value))
setattr(_settings, setting, element.value)
# This appears to need to be mirrored?
if element.get_name() == 'mem_display1':
_settings.mem_display2 = _settings.mem_display1
except Exception as e:
LOG.debug(element.get_name())
raise

def _get_memory(self, number, extd_number=None):
bit = 1 << (number % 8)
byte = number // 8

_mem = self._memobj.memory[number]
_unused = self._memobj.unused[byte]
_skip = self._memobj.skip[byte]

mem = chirp_common.Memory(number)

if extd_number is not None:
mem.extd_number = extd_number
mem.immutable = ["name", "number", "extd_number", "skip"]
if extd_number == "C":
_unused = False

if (_unused & bit):
mem.empty = True
return mem

if int(_mem.mult):
mult = 6250
else:
mult = 5000
mem.freq = int(_mem.freq) * mult
mem.offset = int(_mem.offset) * mult
if mem.extd_number == "":
mem.name = str(_mem.name).rstrip()
mem.skip = (_skip & bit) and "S" or ""
mem.duplex = DUPLEXES[_mem.duplex]
mem.power = POWER_LEVELS[_mem.power]
mem.tuning_step = TUNING_STEPS[_mem.tuning_step]
mem.mode = MODES[_mem.mode]
mem.tmode = TMODES[_mem.tmode]
mem.rtone = chirp_common.TONES[_mem.rtone]
mem.ctone = chirp_common.TONES[_mem.ctone]
mem.dtcs = chirp_common.DTCS_CODES[_mem.dtcs]
mem.dtcs_polarity = DTCS_POLARITY[_mem.dtcs_polarity]

# Reverse duplex
mem.extra = RadioSettingGroup("extra", "Extra")
rev = RadioSetting("reverse_duplex", "Reverse duplex",
RadioSettingValueBoolean(bool(_mem.reverse_duplex)))
rev.set_doc("Reverse duplex")
mem.extra.append(rev)

# Tx inhibit
tx_inhibit = RadioSetting("tx_inhibit", "TX inhibit",
RadioSettingValueBoolean(
bool(not _mem.tx_inhibit)))
tx_inhibit.set_doc("TX inhibit")
mem.extra.append(tx_inhibit)

return mem

def get_memory(self, number):
extd_number = None
if isinstance(number, str):
try:
extd_number = number
number = SPECIAL_CHANNELS[number]
except KeyError:
raise errors.InvalidMemoryLocation(
"Unknown channel %s" % number)

return self._get_memory(number, extd_number)

def _fill_memory(self, mem):
number = mem.number
_mem = self._memobj.memory[number]

# zero-fill
_mem.freq = 146010000 // 5000
_mem.offset = 600000 // 5000
_mem.name = str("").ljust(5)
_mem.duplex = 0x0
_mem.reverse_duplex = 0x0
_mem.tx_inhibit = 0x1
_mem.power = 0x0
_mem.tuning_step = 0x0
_mem.mode = 0x0
_mem.tmode = 0x0
_mem.rtone = 0x8
_mem.ctone = 0x8
_mem.dtcs = 0x0
_mem.dtcs_polarity = 0x0

for setting in mem.extra:
setattr(_mem, setting.get_name(), setting.value)

def set_memory(self, mem):
bit = 1 << (mem.number % 8)
byte = mem.number // 8

_mem = self._memobj.memory[mem.number]
_unused = self._memobj.unused[byte]
_skip = (mem.extd_number == "") and self._memobj.skip[byte] or None
assert(_mem)

if mem.empty:
self._fill_memory(mem)
_unused |= bit
if _skip is not None:
_skip |= bit
return

_mem.set_raw(b'\x00' * 15)

if chirp_common.required_step(mem.freq) == 12.5:
mult = 6250
else:
mult = 5000
_mem.mult = 0 if mult == 5000 else 3
_mem.freq = mem.freq // mult
_mem.offset = int(mem.offset) // mult
_mem.name = str(mem.name).ljust(5)
_mem.duplex = DUPLEXES.index(mem.duplex)
power = mem.power or POWER_LEVELS[0]
_mem.power = POWER_LEVELS.index(power)
_mem.tuning_step = TUNING_STEPS.index(mem.tuning_step)
_mem.mode = MODES.index(mem.mode)
_mem.tmode = TMODES.index(mem.tmode)
_mem.rtone = chirp_common.TONES.index(mem.rtone)
_mem.ctone = chirp_common.TONES.index(mem.ctone)
_mem.dtcs = chirp_common.DTCS_CODES.index(mem.dtcs)
_mem.dtcs_polarity = DTCS_POLARITY.index(mem.dtcs_polarity)

# Set used
_unused &= ~bit

# Set skip
if _skip is not None:
if mem.skip == "S":
_skip |= bit
else:
_skip &= ~bit

def get_raw_memory(self, number):
return repr(self._memobj.memory[number])
(3-3/3)