chirp-20261030/ 0000755 0001750 0001750 00000000000 15271057530 012037 5 ustar hibby hibby chirp-20261030/COPYING 0000644 0001750 0001750 00000104513 14411666130 013073 0 ustar hibby hibby GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc.
Copyright (C)
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 Copyright (C)
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
.
chirp-20261030/MANIFEST.in 0000644 0001750 0001750 00000000506 14665027664 013611 0 ustar hibby hibby include chirp/share/*.desktop
include chirp/share/*.metainfo.xml
include chirp/share/*.png
include chirp/share/*.svg
include chirp/share/*.ico
include chirp/share/*.1
include chirp/stock_configs/*
include chirp/locale/*/LC_MESSAGES/*.mo
exclude chirp/locale/*
include COPYING
include *requirements.txt
graft tests
graft tools
chirp-20261030/PKG-INFO 0000644 0001750 0001750 00000000755 15271057530 013143 0 ustar hibby hibby Metadata-Version: 2.4
Name: chirp
Version: 20261030
Summary: A cross-platform cross-radio programming tool
Home-page: https://chirp.danplanet.com
Requires-Python: >=3.10,<4
License-File: COPYING
Requires-Dist: pyserial
Requires-Dist: requests
Requires-Dist: yattag
Requires-Dist: suds
Requires-Dist: lark
Provides-Extra: wx
Requires-Dist: wxPython; extra == "wx"
Dynamic: home-page
Dynamic: license-file
Dynamic: provides-extra
Dynamic: requires-dist
Dynamic: requires-python
Dynamic: summary
chirp-20261030/README.md 0000644 0001750 0001750 00000000331 14665027664 013326 0 ustar hibby hibby # CHIRP Project
This is the official git repository for the
__[CHIRP](https://www.chirpmyradio.com)__ project.
When submitting PRs, please see [this file](.github/pull_request_template.md)
for rules and guidelines.
chirp-20261030/chirp/ 0000755 0001750 0001750 00000000000 15271057527 013152 5 ustar hibby hibby chirp-20261030/chirp/__init__.py 0000644 0001750 0001750 00000000040 15271057526 015254 0 ustar hibby hibby CHIRP_VERSION = "next-20261030"
chirp-20261030/chirp/bandplan.py 0000644 0001750 0001750 00000016656 14767271777 015337 0 ustar hibby hibby # Copyright 2013 Sean Burford
#
# 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
#
# 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
#
# 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
#
# 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
#
# 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
#
# 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
#
# 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
#
# 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
# Copyright 2023 Jacek Lipkowski
# Copyright 2025 Thibaut Berg
#
# 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
#
# 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 ' % (
ident, ','.join('%s=%r' % item for item in vals))
def debug_diff(self, other, delim='/'):
my_ident, my_vals = self.debug_dump()
my_vals = dict(my_vals)
om_ident, om_vals = other.debug_dump()
om_vals = dict(om_vals)
diffs = []
if my_ident != om_ident:
diffs.append('ident=%s%s%s' % (my_ident, delim, om_ident))
for k in sorted(my_vals.keys() | om_vals.keys()):
myval = my_vals.get(k, '')
omval = om_vals.get(k, '')
if myval != omval:
diffs.append('%s=%r%s%r' % (k, myval, delim, omval))
return ','.join(diffs)
def debug_dump(self):
vals = [(k, v) for k, v in self.__dict__.items()
if k not in ('extra', 'number', 'extd_number')]
for extra in self.extra:
vals.append(('extra.%s' % extra.get_name(), str(extra.value)))
if self.extd_number:
ident = '%s(%i)' % (self.extd_number, self.number)
else:
ident = str(self.number)
return ident, vals
def dupe(self):
"""Return a deep copy of @self"""
mem = self.__class__()
for k, v in list(self.__dict__.items()):
mem.__dict__[k] = v
return mem
def clone(self, source):
"""Absorb all of the properties of @source"""
for k, v in list(source.__dict__.items()):
self.__dict__[k] = v
CSV_FORMAT = ["Location", "Name", "Frequency",
"Duplex", "Offset", "Tone",
"rToneFreq", "cToneFreq", "DtcsCode",
"DtcsPolarity", "RxDtcsCode",
"CrossMode",
"Mode", "TStep",
"Skip", "Power", "Comment",
"URCALL", "RPT1CALL", "RPT2CALL", "DVCODE"]
def __setattr__(self, name, val):
if not hasattr(self, name):
raise ValueError("No such attribute `%s'" % name)
if name in self.immutable:
raise ImmutableValueError("Field %s is not " % name +
"mutable on this memory")
if name in self._valid_map:
valid = self._valid_map[name]
if callable(valid):
if not valid(val):
raise ValueError("`%s' is not a valid value for `%s'" % (
val, name))
elif val not in self._valid_map[name]:
raise ValueError("`%s' is not in valid list: %s" %
(val, self._valid_map[name]))
self.__dict__[name] = val
def format_freq(self):
"""Return a properly-formatted string of this memory's frequency"""
return format_freq(self.freq)
def parse_freq(self, freqstr):
"""Set the frequency from a string"""
self.freq = parse_freq(freqstr)
return self.freq
def __str__(self):
if self.tmode == "Tone":
tenc = "*"
else:
tenc = " "
if self.tmode == "TSQL":
tsql = "*"
else:
tsql = " "
if self.tmode == "DTCS":
dtcs = "*"
else:
dtcs = " "
if self.duplex == "":
dup = "/"
else:
dup = self.duplex
return \
"Memory %s: %s%s%s %s (%s) r%.1f%s c%.1f%s d%03i%s%s [%.2f]" % \
(self.number if self.extd_number == "" else self.extd_number,
format_freq(self.freq),
dup,
format_freq(self.offset),
self.mode,
self.name,
self.rtone,
tenc,
self.ctone,
tsql,
self.dtcs,
dtcs,
self.dtcs_polarity,
self.tuning_step)
def to_csv(self):
"""Return a CSV representation of this memory"""
return [
"%i" % self.number,
"%s" % self.name,
format_freq(self.freq),
"%s" % self.duplex,
format_freq(self.offset),
"%s" % self.tmode,
"%.1f" % self.rtone,
"%.1f" % self.ctone,
"%03i" % self.dtcs,
"%s" % self.dtcs_polarity,
"%03i" % self.rx_dtcs,
"%s" % self.cross_mode,
"%s" % self.mode,
"%.2f" % self.tuning_step,
"%s" % self.skip,
"%s" % self.power,
"%s" % self.comment,
"", "", "", ""]
@classmethod
def _from_csv(cls, _line):
line = _line.strip()
if line.startswith("Location"):
raise errors.InvalidMemoryLocation("Non-CSV line")
vals = line.split(SEPCHAR)
if len(vals) < 11:
raise errors.InvalidDataError("CSV format error " +
"(14 columns expected)")
if vals[10] == "DV":
mem = DVMemory()
else:
mem = Memory()
mem.really_from_csv(vals)
return mem
def really_from_csv(self, vals):
"""Careful parsing of split-out @vals"""
try:
self.number = int(vals[0])
except Exception:
raise errors.InvalidDataError(
"Location '%s' is not a valid integer" % vals[0])
self.name = vals[1]
try:
self.freq = to_MHz(float(vals[2]))
except Exception:
raise errors.InvalidDataError("Frequency is not a valid number")
if vals[3].strip() in ["+", "-", ""]:
self.duplex = vals[3].strip()
else:
raise errors.InvalidDataError("Duplex is not +,-, or empty")
try:
self.offset = to_MHz(float(vals[4]))
except Exception:
raise errors.InvalidDataError("Offset is not a valid number")
self.tmode = vals[5]
if self.tmode not in TONE_MODES:
raise errors.InvalidDataError("Invalid tone mode `%s'" %
self.tmode)
try:
self.rtone = float(vals[6])
except Exception:
raise errors.InvalidDataError("rTone is not a valid number")
if self.rtone not in TONES:
raise errors.InvalidDataError("rTone is not valid")
try:
self.ctone = float(vals[7])
except Exception:
raise errors.InvalidDataError("cTone is not a valid number")
if self.ctone not in TONES:
raise errors.InvalidDataError("cTone is not valid")
try:
self.dtcs = int(vals[8], 10)
except Exception:
raise errors.InvalidDataError("DTCS code is not a valid number")
if self.dtcs not in DTCS_CODES:
raise errors.InvalidDataError("DTCS code is not valid")
if vals[9] in ["NN", "NR", "RN", "RR"]:
self.dtcs_polarity = vals[9]
else:
raise errors.InvalidDataError("DtcsPolarity is not valid")
try:
self.rx_dtcs = int(vals[10], 10)
except Exception:
raise errors.InvalidDataError("DTCS Rx code is not a valid number")
if self.rx_dtcs not in DTCS_CODES:
raise errors.InvalidDataError("DTCS Rx code is not valid")
self.cross_mode = vals[11]
if vals[12] in MODES:
self.mode = vals[12]
else:
raise errors.InvalidDataError("Mode %r is not valid" % vals[10])
try:
self.tuning_step = float(vals[13])
except Exception:
raise errors.InvalidDataError("Tuning step is invalid")
try:
self.skip = vals[14]
except Exception:
raise errors.InvalidDataError("Skip value is not valid")
return True
class DVMemory(Memory):
"""A Memory with D-STAR attributes"""
dv_urcall: str = "CQCQCQ"
dv_rpt1call: str = ""
dv_rpt2call: str = ""
dv_code: int = 0
def __str__(self):
string = Memory.__str__(self)
string += " <%s,%s,%s>" % (self.dv_urcall,
self.dv_rpt1call,
self.dv_rpt2call)
return string
def to_csv(self):
return [
"%i" % self.number,
"%s" % self.name,
format_freq(self.freq),
"%s" % self.duplex,
format_freq(self.offset),
"%s" % self.tmode,
"%.1f" % self.rtone,
"%.1f" % self.ctone,
"%03i" % self.dtcs,
"%s" % self.dtcs_polarity,
"%s" % self.mode,
"%.2f" % self.tuning_step,
"%s" % self.skip,
"%s" % self.comment,
"%s" % self.dv_urcall,
"%s" % self.dv_rpt1call,
"%s" % self.dv_rpt2call,
"%i" % self.dv_code]
def really_from_csv(self, vals):
Memory.really_from_csv(self, vals)
self.dv_urcall = vals[15].rstrip()[:8]
self.dv_rpt1call = vals[16].rstrip()[:8]
self.dv_rpt2call = vals[17].rstrip()[:8]
try:
self.dv_code = int(vals[18].strip())
except Exception:
self.dv_code = 0
def FrozenMemory(source, strict=True):
class _FrozenMemory(source.__class__):
def __init__(self, source):
self.__dict__['_frozen'] = False
for k, v in source.__dict__.items():
if k == '_frozen':
continue
try:
setattr(self, k, v)
except ValueError:
pass
self.__dict__['_frozen'] = True
for i in self.extra:
i.set_frozen()
def __setattr__(self, k, v):
if self._frozen:
# This should really be an error, but we have a number of
# drivers that make modifications during set_memory(). If we
# are not being strict, then we just log a warning.
caller = inspect.getframeinfo(inspect.stack()[1][0])
LOG.warning(
'%s@%i: Illegal set on attribute %s - Fix this driver!' % (
caller.filename, caller.lineno, k))
if strict:
raise errors.FrozenMemoryError(
_('Internal driver error: Attempt to modify '
'frozen memory; Please report this as a bug using '
'"Report or update a bug" in the Help menu'))
super().__setattr__(k, v)
def dupe(self):
m = Memory()
m.clone(self)
delattr(m, '_frozen')
return m
return _FrozenMemory(source)
class MemoryMapping(object):
"""Base class for a memory mapping"""
def __init__(self, model, index, name):
self._model = model
self._index = index
self._name = name
def __str__(self):
return self.get_name()
def __repr__(self):
return "%s-%s" % (self.__class__.__name__, self._index)
def get_name(self):
"""Returns the mapping name"""
return self._name
def get_index(self):
"""Returns the immutable index (string or int)"""
return self._index
def __eq__(self, other):
return self.get_index() == other.get_index()
class MappingModel(object):
"""Base class for a memory mapping model"""
def __init__(self, radio, name):
self._radio = radio
self._name = name
def get_name(self):
return self._name
def get_num_mappings(self):
"""Returns the number of mappings in the model (should be
callable without consulting the radio"""
raise NotImplementedError()
def get_mappings(self):
"""Return a list of mappings"""
raise NotImplementedError()
def add_memory_to_mapping(self, memory, mapping):
"""Add @memory to @mapping."""
raise NotImplementedError()
def remove_memory_from_mapping(self, memory, mapping):
"""Remove @memory from @mapping.
Shall raise exception if @memory is not in @bank"""
raise NotImplementedError()
def get_mapping_memories(self, mapping):
"""Return a list of memories in @mapping"""
raise NotImplementedError()
def get_memory_mappings(self, memory):
"""Return a list of mappings that @memory is in"""
raise NotImplementedError()
class Bank(MemoryMapping):
"""Base class for a radio's Bank"""
class NamedBank(Bank):
"""A bank that can have a name"""
def set_name(self, name):
"""Changes the user-adjustable bank name"""
self._name = name
class BankModel(MappingModel):
"""A bank model where one memory is in zero or one banks at any point"""
def __init__(self, radio, name='Banks'):
super(BankModel, self).__init__(radio, name)
class StaticBank(Bank):
pass
class StaticBankModel(BankModel):
MSG = 'This radio has fixed banks and does not allow reassignment'
channelAlwaysHasBank = True
"""A BankModel that shows a static mapping but does not allow changes."""
def __init__(self, radio, name='Banks', banks=10):
super().__init__(radio, name=name)
self._num_banks = banks
self._rf = radio.get_features()
self._banks = []
for i in range(self._num_banks):
self._banks.append(StaticBank(self, i + 1, 'Bank'))
def get_num_mappings(self):
return self._num_banks
def get_mappings(self):
return self._banks
def get_mapping_memories(self, bank):
lo, hi = self._rf.memory_bounds
count = (hi - lo + 1) / self._num_banks
offset = lo + ((bank.get_index() - 1) * count)
return [self._radio.get_memory(offset + i) for i in range(count)]
def get_memory_mappings(self, memory):
lo, hi = self._rf.memory_bounds
mems = hi - lo + 1
count = mems // self._num_banks
return [self._banks[(memory.number - lo) // count]]
def remove_memory_from_mapping(self, memory, mapping):
raise errors.RadioFixedBanks()
def add_memory_to_mapping(self, memory, mapping):
raise errors.RadioFixedBanks()
class MappingModelIndexInterface:
"""Interface for mappings with index capabilities"""
def get_index_bounds(self):
"""Returns a tuple (lo,hi) of the min and max mapping indices"""
raise NotImplementedError()
def get_memory_index(self, memory, mapping):
"""Returns the index of @memory in @mapping"""
raise NotImplementedError()
def set_memory_index(self, memory, mapping, index):
"""Sets the index of @memory in @mapping to @index"""
raise NotImplementedError()
def get_next_mapping_index(self, mapping):
"""Returns the next available mapping index in @mapping, or raises
Exception if full"""
raise NotImplementedError()
class MTOBankModel(BankModel):
"""A bank model where one memory can be in multiple banks at once """
pass
def console_status(status):
"""Write a status object to the console"""
import logging
from chirp import logger
if not logger.is_visible(logging.WARN):
return
import sys
import os
sys.stdout.write("\r%s" % status)
if status.cur == status.max:
sys.stdout.write(os.linesep)
class RadioPrompts:
"""Radio prompt strings"""
info = None
experimental = None
pre_download = None
pre_upload = None
display_pre_upload_prompt_before_opening_port = True
def BOOLEAN(v):
assert v in (True, False)
def LIST(v):
assert hasattr(v, '__iter__')
def LIST_NONZERO_INT(v):
assert all(x > 0 for x in v)
def INT(min=0, max=None):
def checkint(v):
assert isinstance(v, int)
assert v >= min
if max is not None:
assert v <= max
return checkint
def STRING(v):
assert isinstance(v, str)
def NTUPLE(size):
def checktuple(v):
assert len(v) == size
return checktuple
def TONELIST(v):
assert all(VALIDTONE(x) for x in v)
class RadioFeatures:
"""Radio Feature Flags"""
_valid_map = {
# General
"has_bank_index": BOOLEAN,
"has_dtcs": BOOLEAN,
"has_rx_dtcs": BOOLEAN,
"has_dtcs_polarity": BOOLEAN,
"has_mode": BOOLEAN,
"has_offset": BOOLEAN,
"has_name": BOOLEAN,
"has_bank": BOOLEAN,
"has_bank_names": BOOLEAN,
"has_tuning_step": BOOLEAN,
"has_ctone": BOOLEAN,
"has_cross": BOOLEAN,
"has_infinite_number": BOOLEAN,
"has_nostep_tuning": BOOLEAN,
"has_comment": BOOLEAN,
"has_settings": BOOLEAN,
"has_variable_power": BOOLEAN,
"has_dynamic_subdevices": BOOLEAN,
# Attributes
"valid_modes": LIST,
"valid_tmodes": LIST,
"valid_duplexes": LIST,
"valid_tuning_steps": LIST_NONZERO_INT,
"valid_bands": LIST,
"valid_skips": LIST,
"valid_power_levels": LIST,
"valid_characters": STRING,
"valid_name_length": INT(),
"valid_cross_modes": LIST,
"valid_tones": TONELIST,
"valid_dtcs_pols": LIST,
"valid_dtcs_codes": LIST,
"valid_special_chans": LIST,
"has_sub_devices": BOOLEAN,
"memory_bounds": NTUPLE(2),
"can_odd_split": BOOLEAN,
"can_delete": BOOLEAN,
# D-STAR
"requires_call_lists": BOOLEAN,
"has_implicit_calls": BOOLEAN,
}
def __setattr__(self, name, val):
if name.startswith("_"):
self.__dict__[name] = val
return
elif name not in list(self._valid_map.keys()):
raise ValueError("No such attribute `%s'" % name)
try:
self._valid_map[name](val)
except AssertionError:
raise ValueError('Invalid value %r for attribute %r' % (
val, name))
self.__dict__[name] = val
def __getattr__(self, name):
raise AttributeError("pylint is confused by RadioFeatures")
def init(self, attribute, default, doc=None):
"""Initialize a feature flag @attribute with default value @default,
and documentation string @doc"""
self.__setattr__(attribute, default)
self.__docs[attribute] = doc
def get_doc(self, attribute):
"""Return the description of @attribute"""
return self.__docs[attribute]
def __init__(self):
self.__docs = {}
self.init("has_bank_index", False,
"Indicates that memories in a bank can be stored in " +
"an order other than in main memory")
self.init("has_dtcs", True,
"Indicates that DTCS tone mode is available")
self.init("has_rx_dtcs", False,
"Indicates that radio can use two different " +
"DTCS codes for rx and tx")
self.init("has_dtcs_polarity", True,
"Indicates that the DTCS polarity can be changed")
self.init("has_mode", True,
"Indicates that multiple emission modes are supported")
self.init("has_offset", True,
"Indicates that the TX offset memory property is supported")
self.init("has_name", True,
"Indicates that an alphanumeric memory name is supported")
self.init("has_bank", True,
"Indicates that memories may be placed into banks")
self.init("has_bank_names", False,
"Indicates that banks may be named")
self.init("has_tuning_step", True,
"Indicates that memories store their tuning step")
self.init("has_ctone", True,
"Indicates that the radio keeps separate tone frequencies " +
"for repeater and CTCSS operation")
self.init("has_cross", False,
"Indicates that the radios supports different tone modes " +
"on transmit and receive")
self.init("has_infinite_number", False,
"Indicates that the radio is not constrained in the " +
"number of memories that it can store")
self.init("has_nostep_tuning", False,
"Indicates that the radio does not require a valid " +
"tuning step to store a frequency")
self.init("has_comment", False,
"Indicates that the radio supports storing a comment " +
"with each memory")
self.init("has_settings", False,
"Indicates that the radio supports general settings")
self.init("has_variable_power", False,
"Indicates the radio supports any power level between the "
"min and max in valid_power_levels")
self.init("has_dynamic_subdevices", False,
"Indicates the radio has a non-static list of subdevices")
self.init("valid_modes", list(MODES),
"Supported emission (or receive) modes")
self.init("valid_tmodes", [],
"Supported tone squelch modes")
self.init("valid_duplexes", ["", "+", "-"],
"Supported duplex modes")
self.init("valid_tuning_steps", list(COMMON_TUNING_STEPS),
"Supported tuning steps")
self.init("valid_bands", [],
"Supported frequency ranges")
self.init("valid_skips", ["", "S"],
"Supported memory scan skip settings")
self.init("valid_power_levels", [],
"Supported power levels")
self.init("valid_characters", CHARSET_UPPER_NUMERIC,
"Supported characters for a memory's alphanumeric tag")
self.init("valid_name_length", 6,
"The maximum number of characters in a memory's " +
"alphanumeric tag")
self.init("valid_cross_modes", list(CROSS_MODES),
"Supported tone cross modes")
self.init("valid_tones", list(TONES),
"Support Tones")
self.init("valid_dtcs_pols", ["NN", "RN", "NR", "RR"],
"Supported DTCS polarities")
self.init("valid_dtcs_codes", list(DTCS_CODES),
"Supported DTCS codes")
self.init("valid_special_chans", [],
"Supported special channel names")
self.init("has_sub_devices", False,
"Indicates that the radio behaves as two semi-independent " +
"devices")
self.init("memory_bounds", (0, 1),
"The minimum and maximum channel numbers")
self.init("can_odd_split", False,
"Indicates that the radio can store an independent " +
"transmit frequency")
self.init("can_delete", True,
"Indicates that the radio can delete memories")
self.init("requires_call_lists", True,
"[D-STAR] Indicates that the radio requires all callsigns " +
"to be in the master list and cannot be stored " +
"arbitrarily in each memory channel")
self.init("has_implicit_calls", False,
"[D-STAR] Indicates that the radio has an implied " +
"callsign at the beginning of the master URCALL list")
def is_a_feature(self, name):
"""Returns True if @name is a valid feature flag name"""
return name in list(self._valid_map.keys())
def __getitem__(self, name):
return self.__dict__[name]
@property
def concise_bands(self):
pp_range_strings = [
format_freq(lo).rstrip('0').rstrip('.') +
'-' +
format_freq(hi).rstrip('0').rstrip('.') +
'MHz'
for lo, hi in self.valid_bands]
return ', '.join(pp_range_strings)
def validate_memory(self, mem):
"""Return a list of warnings and errors that will be encountered
if trying to set @mem on the current radio.
An Error will abort the edit, while a Warning will allow it. Both
will show a message to the user. Use Errors to reject things that
need to be. A Warning is useful to alert the user that something
will be fixed/changed/coerced by the driver and that they should
expect it to look different than what they entered. Use these
sparingly as they can be very annoying to the user if they happen
on every edit.
NOTE: This method MAY NOT modify @mem in any way. It is not a hook
to make changes, it is for _validation_ of the memory before it is
sent to the driver's set_memory() method.
"""
msgs = []
lo, hi = self.memory_bounds
if not self.has_infinite_number and \
(mem.number < lo or mem.number > hi) and \
mem.extd_number not in self.valid_special_chans:
msg = ValidationWarning("Location %i is out of range" % mem.number)
msgs.append(msg)
if (self.valid_modes and
mem.mode not in self.valid_modes and
'mode' not in mem.immutable and
mem.mode != "Auto"):
msg = ValidationError("Mode %s not supported" % mem.mode)
msgs.append(msg)
if self.valid_tmodes and mem.tmode not in self.valid_tmodes:
msg = ValidationError("Tone mode %s not supported" % mem.tmode)
msgs.append(msg)
else:
if mem.tmode == "Cross":
if self.valid_cross_modes and \
mem.cross_mode not in self.valid_cross_modes:
msg = ValidationError("Cross tone mode %s not supported" %
mem.cross_mode)
msgs.append(msg)
if self.valid_tones and mem.rtone not in self.valid_tones:
msg = ValidationError("Tone %.1f not supported" % mem.rtone)
msgs.append(msg)
if self.valid_tones and mem.ctone not in self.valid_tones:
msg = ValidationError("Tone %.1f not supported" % mem.ctone)
msgs.append(msg)
if self.has_dtcs_polarity and \
mem.dtcs_polarity not in self.valid_dtcs_pols:
msg = ValidationError("DTCS Polarity %s not supported" %
mem.dtcs_polarity)
msgs.append(msg)
if self.valid_dtcs_codes and \
mem.dtcs not in self.valid_dtcs_codes:
msg = ValidationError("DTCS Code %03i not supported" % mem.dtcs)
msgs.append(msg)
if self.valid_dtcs_codes and \
mem.rx_dtcs not in self.valid_dtcs_codes:
msg = ValidationError("DTCS Code %03i not supported" % mem.rx_dtcs)
msgs.append(msg)
if self.valid_duplexes and mem.duplex not in self.valid_duplexes:
msg = ValidationError("Duplex %s not supported" % mem.duplex)
msgs.append(msg)
ts = mem.tuning_step
if self.valid_tuning_steps and ts not in self.valid_tuning_steps and \
not self.has_nostep_tuning:
msg = ValidationError("Tuning step %.2f not supported" % ts)
msgs.append(msg)
if self.valid_bands:
valid = False
for lo, hi in self.valid_bands:
if lo <= mem.freq < hi:
valid = True
break
if not valid:
msg = ValidationError(
("Frequency {freq} is out "
"of supported ranges {ranges}").format(
freq=format_freq(mem.freq),
ranges=self.concise_bands))
msgs.append(msg)
if self.valid_bands and \
self.valid_duplexes and \
mem.duplex in ["split", "-", "+"]:
if mem.duplex == "split":
freq = mem.offset
elif mem.duplex == "-":
freq = mem.freq - mem.offset
elif mem.duplex == "+":
freq = mem.freq + mem.offset
valid = False
for lo, hi in self.valid_bands:
if lo <= freq < hi:
valid = True
break
if not valid:
msg = ValidationError(
("Tx freq {freq} is out "
"of supported range").format(freq=format_freq(freq)))
msgs.append(msg)
if mem.power and self.valid_power_levels:
if self.has_variable_power:
if (mem.power < min(self.valid_power_levels) or
mem.power > max(self.valid_power_levels)):
msg = ValidationWarning(
"Power level %s is out of radio's range" % mem.power)
msgs.append(msg)
else:
if mem.power not in self.valid_power_levels:
msg = ValidationWarning(
"Power level %s not supported" % mem.power)
msgs.append(msg)
if self.valid_tuning_steps and not self.has_nostep_tuning:
try:
required_step(mem.freq, self.valid_tuning_steps)
except errors.InvalidDataError as e:
msgs.append(ValidationError(e))
if self.valid_characters:
for char in mem.name:
if char not in self.valid_characters:
msgs.append(ValidationWarning("Name character " +
"`%s'" % char +
" not supported"))
break
if is_airband(mem.freq):
try:
fix_rounded_step(mem.freq)
except errors.InvalidDataError as e:
msgs.append(ValidationError(
'%s: %s' % (format_freq(mem.freq), e)))
return msgs
class ValidationMessage(str):
"""Base class for Validation Errors and Warnings"""
pass
class ValidationWarning(ValidationMessage):
"""A non-fatal warning during memory validation"""
pass
class ValidationError(ValidationMessage):
"""A fatal error during memory validation"""
pass
def split_validation_msgs(msgs):
"""Split a list of msgs into warnings,errors"""
return ([x for x in msgs if isinstance(x, ValidationWarning)],
[x for x in msgs if isinstance(x, ValidationError)])
class Alias(object):
VENDOR = "Unknown"
MODEL = "Unknown"
VARIANT = ""
class Radio(Alias):
"""Base class for all Radio drivers"""
BAUD_RATE = 9600
# Whether or not we should use RTS/CTS flow control
HARDWARE_FLOW = False
# Whether or not we should assert DTR when opening the serial port
WANTS_DTR = True
# Whether or not we should assert RTS when opening the serial port
WANTS_RTS = True
ALIASES = []
NEEDS_COMPAT_SERIAL = False
FORMATS: list[str] = []
def status_fn(self, status):
"""Deliver @status to the UI"""
console_status(status)
def __init__(self, pipe):
self.errors = []
self.pipe = pipe
def get_features(self) -> RadioFeatures:
"""Return a RadioFeatures object for this radio"""
return RadioFeatures()
@classmethod
def get_name(cls) -> str:
"""Return a printable name for this radio"""
return "%s %s" % (cls.VENDOR, cls.MODEL)
@classmethod
def get_prompts(cls) -> RadioPrompts:
"""Return a set of strings for use in prompts"""
return RadioPrompts()
def set_pipe(self, pipe) -> None:
"""Set the serial object to be used for communications"""
self.pipe = pipe
def get_memory(self, number: int | str) -> Memory:
"""Return a Memory object for the memory at location @number
Constructs and returns a generic Memory object for the given location
in the radio's memory. The memory should accurately represent what is
actually stored in the radio as closely as possible. If the radio
does not support changing some attributes of the location in question,
the Memory.immutable list should be set appropriately.
NB: No changes to the radio's memory should occur as a result of
calling get_memory().
"""
raise NotImplementedError()
def erase_memory(self, number: int | str) -> None:
"""Erase memory at location @number"""
mem = Memory()
if isinstance(number, str):
mem.extd_number = number
else:
mem.number = number
mem.empty = True
self.set_memory(mem)
def get_memories(self, lo=None, hi=None):
"""Get all the memories between @lo and @hi"""
pass
def set_memory(self, memory: Memory) -> None:
"""Set the memory object @memory
This method should copy generic attributes from @memory to the
radio's memory. It should not modify @memory and it should reproduce
the generic attributes on @memory in the radio's memory as faithfully
as the radio allows. Attributes that can't be copied exactly should
be warned in validate_memory() with ValidationWarnings if a
substitution will be made, or ValidationError if truly incompatible.
In the latter case, set_memory() will not be called.
"""
raise NotImplementedError()
def get_mapping_models(self):
"""Returns a list of MappingModel objects (or an empty list)"""
if hasattr(self, "get_bank_model"):
# FIXME: Backwards compatibility for old bank models
bank_model = self.get_bank_model()
if bank_model:
return [bank_model]
return []
def get_raw_memory(self, number: int | str) -> str:
"""Return a raw string describing the memory at @number"""
return 'Memory<%r>' % number
def filter_name(self, name: str) -> str:
"""Filter @name to just the length and characters supported"""
rf = self.get_features()
if rf.valid_characters == rf.valid_characters.upper():
# Radio only supports uppercase, so help out here
name = name.upper()
return "".join([x for x in name[:rf.valid_name_length]
if x in rf.valid_characters])
def get_sub_devices(self) -> list[Alias]:
"""Return a list of sub-device Radio objects, if
RadioFeatures.has_sub_devices is True"""
return []
def validate_memory(self, mem: Memory) -> list[ValidationMessage]:
"""Return a list of warnings and errors that will be encountered
if trying to set @mem on the current radio"""
rf = self.get_features()
return rf.validate_memory(mem)
def get_settings(self):
"""Returns a RadioSettings list containing one or more
RadioSettingGroup or RadioSetting objects. These represent general
setting knobs and dials that can be adjusted on the radio. If this
function is implemented, the has_settings RadioFeatures flag should
be True and set_settings() must be implemented as well."""
pass
def set_settings(self, settings):
"""Accepts the top-level RadioSettingGroup returned from get_settings()
and adjusts the values in the radio accordingly. This function expects
the entire RadioSettingGroup hierarchy returned from get_settings().
If this function is implemented, the has_settings RadioFeatures flag
should be True and get_settings() must be implemented as well."""
pass
@classmethod
def supports_format(cls, fmt: str) -> bool:
"""Returns true if file format @fmt is supported by this radio.
This really should not be overridden by implementations
without a good reason (like excluding one).
"""
return fmt in cls.FORMATS
def check_set_memory_immutable_policy(self, existing: Memory, new: Memory):
"""Checks whether or not a new memory will violate policy.
Some radios have complex requirements for which fields of which
memories can be modified at any given point. For the most part, radios
require certain physical memory slots to have immutable fields
(such as labels on call channels), and this default implementation
checks that policy. However, other radios have more fine-grained
rules in order to comply with FCC type acceptance, which requires
overriding this behavior.
** This should almost never be overridden in your driver.
** This must not communicate with the radio, if implemented on a live-
mode driver.
"""
for field in existing.immutable:
if getattr(existing, field) != getattr(new, field):
raise ImmutableValueError(
'Field %s is not mutable on this memory' % field)
class ExternalMemoryProperties:
"""A mixin class that provides external memory property support.
This is for use by drivers that have some way of storing additional
memory properties externally (i.e. in metadata or a separate region)
that cannot be loaded/updated during get_memory()/set_memory().
Implementing this is much less ideal than supporting those properties
directly, so this should only be used when absolutely necessary.
"""
def get_memory_extra(self, memory):
"""Update @memory with extra fields.
This is called after get_memory() and is passed the result
for augmentation from external storage.
"""
return memory
def set_memory_extra(self, memory):
"""Update external storage of properties from @memory.
This is called after set_memory() with the same memory object
to record additional properties in external storage.
"""
pass
def erase_memory_extra(self, number):
"""Erase external storage for @memory.
This is called after erase_memory() to clear external storage
for memory @number.
"""
pass
def link_device_metadata(self, devices):
"""Link sub-device metadata with parent.
This is called after get_sub_devices() to make sure that the
sub-device instances use a reference into the main radio's
metadata. In most cases, this does not need to be overridden.
"""
# Link metadata of the sub-devices into the main by variant name
# so that they are both included in a later save of the parent.
for sub in devices:
self._metadata.setdefault(sub.VARIANT, {})
sub._metadata = self._metadata[sub.VARIANT]
class FileBackedRadio(Radio):
"""A file-backed radio stores its data in a file"""
FILE_EXTENSION = 'dat'
def save(self, filename):
"""Save the radio's memory map to @filename"""
pass
def load(self, filename):
"""Load the radio's memory map object from @filename"""
pass
def class_detected_models_attribute(cls):
return 'DETECTED_MODELS_%s' % cls.__name__
class DetectableInterface:
@classmethod
def detect_from_serial(cls, pipe):
"""Communicate with the radio via serial to determine proper class
Returns an in implementation of CloneModeRadio if detected, or raises
RadioError if not. If NotImplemented is raised, we assume that no
detection is possible or necessary.
"""
detected = getattr(cls, class_detected_models_attribute(cls), None)
assert detected is None, (
'Class has detected models but no detect_from_serial() '
'implementation')
raise NotImplementedError()
@classmethod
def detected_models(cls, include_self=True):
detected = getattr(cls, class_detected_models_attribute(cls), [])
# Only include this class if it is registered
if include_self and hasattr(cls, '_DETECTED_BY'):
extra = [cls]
else:
extra = []
return extra + list(detected)
@classmethod
def is_detected(cls):
return getattr(cls, '_DETECTED_BY', None) is not None
@classmethod
def detect_model(cls, detected_cls):
detected_attr = class_detected_models_attribute(cls)
if getattr(cls, detected_attr, None) is None:
setattr(cls, detected_attr, [])
getattr(cls, detected_attr).append(detected_cls)
@classmethod
def is_minor_variant(cls):
return getattr(cls, '_MINOR_VARIANT', False)
class CloneModeRadio(FileBackedRadio, ExternalMemoryProperties,
DetectableInterface):
"""A clone-mode radio does a full memory dump in and out and we store
an image of the radio into an image file"""
FILE_EXTENSION = "img"
MAGIC = b'\x00\xffchirp\xeeimg\x00\x01'
_memsize = 0
def __init__(self, pipe):
self.errors = []
self._mmap = None
self._memobj = None
self._metadata = {}
if isinstance(pipe, str):
self.pipe = None
self.load_mmap(pipe)
elif isinstance(pipe, memmap.MemoryMapBytes):
self.pipe = None
self._mmap = pipe
self.process_mmap()
else:
FileBackedRadio.__init__(self, pipe)
def get_memsize(self):
"""Return the radio's memory size"""
return self._memsize
@classmethod
def match_model(cls, filedata, filename):
"""Given contents of a stored file (@filedata), return True if
this radio driver handles the represented model
NOTE: This should not be implemented by new drivers UNLESS you need
to recognize a non-CHIRP-native file format, such as files from the
OEM software or similar. Those must be registered via
directory.register_format() in order to be properly recognized.
"""
return False
def sync_in(self):
"""Initiate a radio-to-PC clone operation"""
pass
def sync_out(self):
"""Initiate a PC-to-radio clone operation"""
pass
def save(self, filename):
"""Save the radio's memory map to @filename"""
self.save_mmap(filename)
def load(self, filename):
"""Load the radio's memory map object from @filename"""
self.load_mmap(filename)
def process_mmap(self):
"""Process a newly-loaded or downloaded memory map"""
pass
@classmethod
def _strip_metadata(cls, raw_data):
try:
idx = raw_data.index(cls.MAGIC)
except ValueError:
LOG.debug('Image data has no metadata blob')
return raw_data, {}
# Find the beginning of the base64 blob
raw_metadata = raw_data[idx + len(cls.MAGIC):]
metadata = {}
try:
metadata = json.loads(base64.b64decode(raw_metadata).decode())
except ValueError as e:
LOG.error('Failed to parse decoded metadata blob: %s' % e)
except TypeError as e:
LOG.error('Failed to decode metadata blob: %s' % e)
if metadata:
LOG.debug('Loaded metadata: %s' % metadata)
return raw_data[:idx], metadata
def _make_metadata(self):
# Always generate these directly from our in-memory state
base = {
'rclass': self.__class__.__name__,
'vendor': self.VENDOR,
'model': self.MODEL,
'variant': self.VARIANT,
'chirp_version': CHIRP_VERSION,
}
# Any other properties take a back seat to the above
extra = {k: v for k, v in self._metadata.items() if k not in base}
extra.update(base)
return base64.b64encode(json.dumps(extra).encode())
def load_mmap(self, filename):
"""Load the radio's memory map from @filename"""
mapfile = open(filename, "rb")
data = mapfile.read()
if self.MAGIC in data:
data, self._metadata = self._strip_metadata(data)
if ('chirp_version' in self._metadata and
is_version_newer(self._metadata.get('chirp_version'))):
LOG.warning('Image is from version %s but we are %s' % (
self._metadata.get('chirp_version'), CHIRP_VERSION))
if self.NEEDS_COMPAT_SERIAL:
self._mmap = memmap.MemoryMap(data)
else:
self._mmap = memmap.MemoryMapBytes(bytes(data))
mapfile.close()
self.process_mmap()
def save_mmap(self, filename):
"""
try to open a file and write to it
If IOError raise a File Access Error Exception
"""
try:
mapfile = open(filename, "wb")
mapfile.write(self._mmap.get_byte_compatible().get_packed())
if filename.lower().endswith(".img"):
mapfile.write(self.MAGIC)
mapfile.write(self._make_metadata())
mapfile.close()
except IOError:
raise Exception("File Access Error")
def get_mmap(self):
"""Return the radio's memory map object"""
return self._mmap
@property
def metadata(self):
return dict(self._metadata)
@metadata.setter
def metadata(self, values):
self._metadata.update(values)
def get_memory_extra(self, memory):
rf = self.get_features()
if not rf.has_comment and isinstance(memory.number, int):
self._metadata.setdefault('mem_extra', {})
try:
memory.comment = self._metadata['mem_extra'].get(
'%04i_comment' % memory.number, '')
except ImmutableValueError:
pass
return memory
def set_memory_extra(self, memory):
rf = self.get_features()
if not rf.has_comment and isinstance(memory.number, int):
self._metadata.setdefault('mem_extra', {})
key = '%04i_comment' % memory.number
if not memory.comment:
self._metadata['mem_extra'].pop(key, None)
else:
self._metadata['mem_extra'][key] = memory.comment
def erase_memory_extra(self, number):
rf = self.get_features()
if not rf.has_comment and isinstance(number, int):
self._metadata.setdefault('mem_extra', {})
self._metadata['mem_extra'].pop('%04i_comment' % number, None)
class LiveRadio(Radio, DetectableInterface):
"""Base class for all Live-Mode radios"""
pass
class NetworkSourceRadio(Radio):
"""Base class for all radios based on a network source"""
def do_fetch(self):
"""Fetch the source data from the network"""
pass
class IcomDstarSupport:
"""Base interface for radios supporting Icom's D-STAR technology"""
MYCALL_LIMIT = (1, 1)
URCALL_LIMIT = (1, 1)
RPTCALL_LIMIT = (1, 1)
def get_urcall_list(self):
"""Return a list of URCALL callsigns"""
return []
def get_repeater_call_list(self):
"""Return a list of RPTCALL callsigns"""
return []
def get_mycall_list(self):
"""Return a list of MYCALL callsigns"""
return []
def set_urcall_list(self, calls):
"""Set the URCALL callsign list"""
pass
def set_repeater_call_list(self, calls):
"""Set the RPTCALL callsign list"""
pass
def set_mycall_list(self, calls):
"""Set the MYCALL callsign list"""
pass
class ExperimentalRadio:
"""Interface for experimental radios"""
@classmethod
def get_experimental_warning(cls):
return ("This radio's driver is marked as experimental and may " +
"be unstable or unsafe to use.")
class Status:
"""Clone status object for conveying clone progress to the UI"""
name = "Job"
msg = "Unknown"
max = 100
cur = 0
def __str__(self):
try:
pct = (self.cur / float(self.max)) * 100
nticks = int(pct) // 10
ticks = "=" * nticks
except ValueError:
pct = 0.0
ticks = "?" * 10
return "|%-10s| %2.1f%% %s" % (ticks, pct, self.msg)
def is_fractional_step(freq):
"""Returns True if @freq requires a 12.5 kHz or 6.25 kHz step"""
return not is_5_0(freq) and (is_12_5(freq) or is_6_25(freq))
def is_5_0(freq):
"""Returns True if @freq is reachable by a 5 kHz step"""
return (freq % 5000) == 0
def is_10_0(freq):
"""Returns True if @freq is reachable by a 10 kHz step"""
return (freq % 10000) == 0
def is_12_5(freq):
"""Returns True if @freq is reachable by a 12.5 kHz step"""
return (freq % 12500) == 0
def is_6_25(freq):
"""Returns True if @freq is reachable by a 6.25 kHz step"""
return (freq % 6250) == 0
def is_2_5(freq):
"""Returns True if @freq is reachable by a 2.5 kHz step"""
return (freq % 2500) == 0
def is_8_33(freq):
"""Returns True if @freq is reachable by a 8.33 kHz step"""
return (freq % 25000) in [8330, 8333, 16660, 16666]
def is_1_0(freq):
"""Returns True if @freq is reachable by a 1.0 kHz step"""
return (freq % 1000) == 0
def is_0_5(freq):
"""Returns True if @freq is reachable by a 0.5 kHz step"""
return (freq % 500) == 0
def make_is(stephz):
def validator(freq):
return freq % stephz == 0
return validator
def required_step(freq, allowed=None):
"""Returns the simplest tuning step that is required to reach @freq"""
if allowed is None:
allowed = [5.0, 10.0, 12.5, 6.25, 2.5, 1.0, 0.5, 8.33, 0.25]
special = {8.33: is_8_33}
for step in allowed:
if step in special:
validate = special[step]
else:
validate = make_is(int(step * 1000))
if validate(freq):
LOG.debug('Chose step %s for %s' % (step, format_freq(freq)))
return step
raise errors.InvalidDataError("Unable to find a supported " +
"tuning step for %s" % format_freq(freq))
def is_airband(freq):
"""Returns True if @freq is in the airband range"""
return in_range(freq, [(to_MHz(108), to_MHz(137))])
def fix_rounded_step(freq):
"""Some radios imply the last bit of 12.5 kHz and 6.25 kHz step
frequencies. Take the base @freq and return the corrected one"""
allowed = [12.5, 6.25]
if is_airband(freq):
# Airband can be 25kHz or 8.33kHz (25k / 3) steps
# https://en.wikipedia.org/wiki/Airband
if freq % 25000:
# This must be 8.33kHz. The goal here is to find the closest
# 8.33k-aligned channel and return that.
# In the 8.33kHz channel scheme, there are "channel names" that
# look like 5kHz-aligned frequencies within the 25kHz regular
# channels, which don't match the actual frequency being used
# (which is 8.33kHz-aligned). We need to be able to detect those
# and return the correct actual frequency, as well as allow
# matching the actual frequencies themselves.
# The "base frequency" is the 25kHz-aligned channel frequency that
# has been divided into three 8.33kHz channels.
base = freq // 25000 * 25000
orig = freq
# This is a channel name if it is 5kHz-aligned and equal-or-above
# the base frequency. Adjust down for the lower channel and up for
# the upper (no adjustment for the middle one) so that the channel
# matching below will find the right closest option.
ch_index = (freq - base) / 5000
if ch_index == 1.0:
# Lower of the three, bump down
freq -= (25000 // 3)
elif ch_index == 3.0:
# Upper of the three, bump up
freq += (25000 // 3)
elif ch_index >= 4.0 and ch_index == int(ch_index):
# This is 5kHz-aligned but not one of the three sub-channels,
# thus this is one of the gaps in the channel numbers. Refuse
# it so that it's clear to the user.
raise errors.InvalidDataError(
_('Aircraft frequencies must be aligned to 25kHz, 8.33kHz'
', be or a valid channel'))
# These are the three possible 8.33kHz-aligned channels within
# this 25kHz block.
channels = [base + (25000 // 3) * i for i in range(0, 3)]
# Find the closest one to the original frequency
best = min(channels, key=lambda x: abs(x - freq))
LOG.debug('833: Orig %s Channels %s best %s adjusted %s diffs %s '
'chindex %s' % (
orig, channels, best, freq,
[x - freq for x in channels], ch_index))
return best
else:
return freq
try:
required_step(freq + 500, allowed=allowed)
return freq + 500
except errors.InvalidDataError:
pass
try:
required_step(freq + 250, allowed=allowed)
return freq + 250
except errors.InvalidDataError:
pass
try:
required_step(freq + 750, allowed=allowed)
return float(freq + 750)
except errors.InvalidDataError:
pass
try:
required_step(freq + 330, allowed=allowed)
return float(freq + 330)
except errors.InvalidDataError:
pass
try:
required_step(freq + 660, allowed=allowed)
return float(freq + 660)
except errors.InvalidDataError:
pass
# These radios can all resolve 5kHz, so make sure what we are left with
# is 5kHz-aligned, else we refuse below.
try:
required_step(freq, allowed=[5.0])
return freq
except errors.InvalidDataError:
pass
raise errors.InvalidDataError("Unable to correct rounded frequency " +
format_freq(freq))
def _name(name, len, just_upper):
"""Justify @name to @len, optionally converting to all uppercase"""
if just_upper:
name = name.upper()
return name.ljust(len)[:len]
def name6(name, just_upper=True):
"""6-char name"""
return _name(name, 6, just_upper)
def name8(name, just_upper=False):
"""8-char name"""
return _name(name, 8, just_upper)
def name16(name, just_upper=False):
"""16-char name"""
return _name(name, 16, just_upper)
def to_GHz(val):
"""Convert @val in GHz to Hz"""
return int(val * 1000000000)
def to_MHz(val):
"""Convert @val in MHz to Hz"""
return int(val * 1000000)
def to_kHz(val):
"""Convert @val in kHz to Hz"""
return int(val * 1000)
def from_GHz(val):
"""Convert @val in Hz to GHz"""
return val // 1000000000
def from_MHz(val):
"""Convert @val in Hz to MHz"""
return val // 1000000
def from_kHz(val):
"""Convert @val in Hz to kHz"""
return val // 1000
def split_to_offset(mem, rxfreq, txfreq):
"""Set the freq, offset, and duplex fields of a memory based on
a separate rx/tx frequency.
"""
mem.freq = rxfreq
if abs(txfreq - rxfreq) > to_MHz(70):
mem.offset = txfreq
mem.duplex = 'split'
else:
offset = txfreq - rxfreq
if offset < 0:
mem.duplex = '-'
elif offset > 0:
mem.duplex = '+'
mem.offset = abs(offset)
def split_tone_decode(mem, txtone, rxtone):
"""
Set tone mode and values on @mem based on txtone and rxtone specs like:
None, None, None
"Tone", 123.0, None
"DTCS", 23, "N"
"""
txmode, txval, txpol = txtone
rxmode, rxval, rxpol = rxtone
mem.dtcs_polarity = "%s%s" % (txpol or "N", rxpol or "N")
if not txmode and not rxmode:
# No tone
return
if txmode == "Tone" and not rxmode:
mem.tmode = "Tone"
mem.rtone = txval
return
if txmode == rxmode == "Tone" and txval == rxval:
# TX and RX same tone -> TSQL
mem.tmode = "TSQL"
mem.ctone = txval
return
if txmode == rxmode == "DTCS" and txval == rxval:
mem.tmode = "DTCS"
mem.dtcs = txval
return
mem.tmode = "Cross"
mem.cross_mode = "%s->%s" % (txmode or "", rxmode or "")
if txmode == "Tone":
mem.rtone = txval
elif txmode == "DTCS":
mem.dtcs = txval
if rxmode == "Tone":
mem.ctone = rxval
elif rxmode == "DTCS":
mem.rx_dtcs = rxval
def split_tone_encode(mem):
"""
Returns TX, RX tone specs based on @mem like:
None, None, None
"Tone", 123.0, None
"DTCS", 23, "N"
"""
txmode = ''
rxmode = ''
txval = None
rxval = None
if mem.tmode == "Tone":
txmode = "Tone"
txval = mem.rtone
elif mem.tmode == "TSQL":
txmode = rxmode = "Tone"
txval = rxval = mem.ctone
elif mem.tmode == "DTCS":
txmode = rxmode = "DTCS"
txval = rxval = mem.dtcs
elif mem.tmode == "Cross":
txmode, rxmode = mem.cross_mode.split("->", 1)
if txmode == "Tone":
txval = mem.rtone
elif txmode == "DTCS":
txval = mem.dtcs
if rxmode == "Tone":
rxval = mem.ctone
elif rxmode == "DTCS":
rxval = mem.rx_dtcs
if txmode == "DTCS":
txpol = mem.dtcs_polarity[0]
else:
txpol = None
if rxmode == "DTCS":
rxpol = mem.dtcs_polarity[1]
else:
rxpol = None
return ((txmode, txval, txpol),
(rxmode, rxval, rxpol))
def sanitize_string(astring, validcharset=CHARSET_ASCII, replacechar='*'):
myfilter = ''.join(
[
[replacechar, chr(x)][chr(x) in validcharset]
for x in range(256)
])
return astring.translate(myfilter)
def is_version_newer(version):
"""Return True if version is newer than ours"""
def get_version(v):
if v.startswith('daily-'):
_, stamp = v.split('-', 1)
ver = (int(stamp),)
elif '.' in v:
ver = tuple(int(p) for p in v.split('.'))
else:
ver = (0,)
LOG.debug('Parsed version %r to %r' % (v, ver))
return ver
from chirp import CHIRP_VERSION
try:
version = get_version(version)
except ValueError as e:
LOG.error('Failed to parse version %r: %s' % (version, e))
version = (0,)
try:
my_version = get_version(CHIRP_VERSION)
except ValueError as e:
LOG.error('Failed to parse my version %r: %s' % (CHIRP_VERSION, e))
my_version = (0,)
return version > my_version
def http_user_agent():
ver = sys.version_info
return 'chirp/%s (Python %i.%i.%i on %s)' % (
CHIRP_VERSION,
ver.major, ver.minor, ver.micro,
sys.platform)
def urlretrieve(url, fn):
"""Grab an URL and save it in a specified file"""
import urllib.request
import urllib.error
headers = {
'User-Agent': http_user_agent(),
}
req = urllib.request.Request(url, headers=headers)
resp = urllib.request.urlopen(req)
with open(fn, 'wb') as f:
f.write(resp.read())
def mem_from_tsv(tsv_text):
fields = tsv_text.split('\t')
if len(fields) < 13:
raise ValueError('Not enough fields to be a memory')
mem = Memory()
mem.really_from_csv(fields)
print('Parsed %s from tsv' % mem)
return mem
def mem_from_text(text):
if text.count('\t') > 10:
# Seems like plausible TSV, return if it parses
try:
return mem_from_tsv(text)
except Exception:
pass
m = Memory()
freqs = re.findall(r'\b(\d{1,3}\.\d{2,6})\b', text)
if not freqs:
raise ValueError('Unable to find a frequency')
m.freq = parse_freq(freqs[0])
offset = re.search(r'([+-])\s*(\d\.\d{1,3}|\d)\b', text)
duplex = re.search(r'\W([+-])\W', text[text.index(freqs[0]):])
if len(freqs) > 1 and not offset:
split_to_offset(m, m.freq, parse_freq(freqs[1]))
else:
if offset:
m.duplex = offset.group(1)
m.offset = parse_freq(offset.group(2))
# Only look for the first +/- after the frequency, which would be
# by far the most common arrangement
if offset is None and duplex:
m.duplex = duplex.group(1)
tones = re.findall(r'\b(\d{2,3}\.\d|D\d{3})\b', text)
if tones and len(tones) <= 2:
txrx = []
for val in tones:
if '.' in val:
mode = 'Tone'
tone = float(val)
elif 'D' in val:
mode = 'DTCS'
tone = int(val[1:])
else:
continue
txrx.append((mode, tone, 'N'))
if len(txrx) == 1:
txrx.append(('', 88.5, 'N'))
split_tone_decode(m, txrx[0], txrx[1])
return m
def mem_to_text(mem):
pieces = [format_freq(mem.freq)]
if mem.duplex == 'split':
pieces.append(format_freq(mem.offset))
elif mem.duplex in ('-', '+'):
pieces.append('%s%i.%3.3s' % (mem.duplex,
mem.offset / 1000000,
'%03i' % (mem.offset % 1000000)))
txrx = split_tone_encode(mem)
for mode, tone, pol in txrx:
if mode == 'Tone':
pieces.append('%.1f' % tone)
elif mode == 'DTCS':
pieces.append('D%03i' % tone)
return '[%s]' % '/'.join(pieces)
def in_range(freq, ranges):
"""Check if freq is in any of the provided ranges"""
for lo, hi in ranges:
if lo <= freq <= hi:
return True
return False
def is_split(bands, freq1, freq2):
"""Check if two freqs are in the same band from a list of bands
Returns False if the two freqs are in the same band (not split)
or True if they are in separate bands (split)"""
# determine if the two freqs are in the same band
for low, high in bands:
if freq1 >= low and freq1 <= high and \
freq2 >= low and freq2 <= high:
# if the two freqs are on the same Band this is not a split
return False
# if you get here is because the freq pairs are split
return True
chirp-20261030/chirp/cli/ 0000755 0001750 0001750 00000000000 15271057527 013721 5 ustar hibby hibby chirp-20261030/chirp/cli/__init__.py 0000644 0001750 0001750 00000000000 14411666130 016007 0 ustar hibby hibby chirp-20261030/chirp/cli/experttune.py 0000644 0001750 0001750 00000022210 15017704131 016457 0 ustar hibby hibby #!/usr/bin/env python3
import argparse
import contextlib
import logging
import random
import serial
import time
import sys
from chirp import bitwise
from chirp.drivers import icomciv
from chirp import memmap
LOG = logging.getLogger()
# Note these are only the frequencies from the chart that fit into the
# US band edges.
BANDS = {
160: [i for i in range(1805, 2005, 20)],
80: [i for i in range(3510, 4010, 10)],
40: [i for i in range(7013, 7313, 25)],
30: [10125],
20: [i for i in range(14025, 14325, 50)],
17: [18075, 18125, 18165],
15: [i for i in range(21025, 21475, 50)],
12: [24891, 24963],
10: [i for i in range(28050, 29750, 100)],
6: [i for i in range(50125, 54125, 250)],
}
class BitwiseFrame(icomciv.Frame):
_fmt = ''
_datalen = 0
_querycmd: int | None = None
def __init__(self):
super().__init__()
self._data = memmap.MemoryMapBytes(b'\x00' * self._datalen)
self.parse()
def parse(self):
self._obj = bitwise.parse(self._fmt, self._data)
@classmethod
def get(cls, radio):
f = icomciv.Frame()
f.set_command(cls._querycmd or cls._cmd, cls._sub)
radio._send_frame(f)
r = radio._recv_frame(frame=cls())
# If we used a different command to query, reset the received frame
# to the one we'd use for the setting
r._cmd = cls._cmd
return r
class SetFreqFrame(BitwiseFrame):
_datalen = 5
_cmd = 0x05
_querycmd = 0x03
_sub = None
_fmt = 'lbcd freq[5];'
@property
def freq(self):
return self._obj.freq // 1000
@freq.setter
def freq(self, khz):
self._obj.freq = khz * 1000
class SetModeFrame(BitwiseFrame):
_datalen = 2
_cmd = 0x06
_querycmd = 0x04
_sub = None
_fmt = 'u8 mode; u8 filter;'
_modes = [
('LSB', 0),
('USB', 1),
('AM', 2),
('CW', 3),
('RTTY', 4),
('FM', 5),
('CW-R', 7),
('RTTY-R', 8),
('PSK', 12),
('PSK-R', 17),
]
@property
def mode(self):
for mode, index in self._modes:
if index == self._obj.mode:
return mode
raise RuntimeError('Unsupported mode %i' % self._obj.mode)
@mode.setter
def mode(self, mode):
self._obj.filter = 1
for m, index in self._modes:
if mode == m:
self._obj.mode = index
return
raise RuntimeError('Unsupported mode %s' % mode)
@property
def filter(self):
return int(self._obj.filter)
class BKINFrame(BitwiseFrame):
_datalen = 1
_cmd = 0x16
_sub = 0x47
_fmt = 'u8 mode;'
_modes = ('off', 'semi', 'full')
@property
def mode(self):
return self._modes[self._obj.mode]
@mode.setter
def mode(self, mode):
self._obj.mode = self._modes.index(mode)
class CWSpeedFrame(BitwiseFrame):
_datalen = 2
_cmd = 0x14
_sub = 0x0C
_fmt = 'bbcd speed[2];'
@property
def speed(self):
return 48 * self._obj.speed // 255
@speed.setter
def speed(self, wpm):
self._obj.speed = int((wpm / 48) * 255)
class PowerFrame(BitwiseFrame):
_datalen = 2
_cmd = 0x15
_sub = 0x11
_fmt = 'bbcd power[2];'
@classmethod
def get(cls, radio):
f = icomciv.Frame()
f.set_command(cls._cmd, cls._sub)
radio._send_frame(f)
f = radio._recv_frame(frame=cls())
f.parse()
return f
@property
def power(self):
return int(100 * int(self._obj.power) / 212)
@power.setter
def power(self, power):
self._obj.power = 212 * (power / 100)
class Demo:
def __init__(self, s=None):
self._last_command = 0
def _send_frame(self, f):
self._last_command = f._cmd
def _recv_frame(self, frame=None):
if frame is None:
frame = PowerFrame()
if self._last_command == 0x15:
frame.power = random.randint(0, 10) * 10
else:
frame.set_command(0xFB, None)
return frame
def setup(port, rcls):
LOG.debug('Connecting to %s' % port)
s = serial.Serial(port, timeout=1)
LOG.debug('Starting radio')
radio = rcls(s)
LOG.debug('Detecting baudrate')
radio._detect_baudrate()
LOG.debug('Connected')
return radio
def set_freq(radio, khz, mode):
f = SetFreqFrame()
f.freq = khz
radio._send_frame(f)
r = radio._recv_frame()
assert r._cmd == 0xFB
LOG.debug('Set frequency to %i kHz', khz)
f = SetModeFrame()
f.mode = mode
radio._send_frame(f)
r = radio._recv_frame()
assert r._cmd == 0xFB
LOG.debug('Set mode to %s', mode)
def interactive_next(current):
print()
print('Options:')
print('r: Retry this frequency')
print('x: Exit immediately')
print('[enter]: Continue to the next frequency')
i = input('> ').lower()
if i == '':
return True
elif i == 'r':
return False
elif i == 'x':
raise RuntimeError('Abort')
def auto_next(current):
print()
return True
def send_id(radio, call):
f = SetModeFrame()
f.mode = 'CW'
radio._send_frame(f)
r = radio._recv_frame()
assert r._cmd == 0xFB
LOG.debug('Set mode to CW')
f = BKINFrame()
f.mode = 'full'
radio._send_frame(f)
r = radio._recv_frame()
assert r._cmd == 0xFB
LOG.debug('Set BK-IN to full')
f = CWSpeedFrame()
f.speed = 22
radio._send_frame(f)
r = radio._recv_frame()
assert r._cmd == 0xFB
LOG.debug('Set key speed to 22WPM')
f = icomciv.Frame()
f.set_command(0x17, 0x40)
f.set_data(b'DE %s' % call.upper().encode())
radio._send_frame(f)
r = radio._recv_frame()
if r._cmd != 0xFB:
print('Radio does not support CWID - ID manually now')
else:
print('Sending id %s' % call)
time.sleep(len(call) + 2)
LOG.debug('Sent ID')
def wait_for_power(radio, fn):
po = None
maxl = 0
while po is None or not fn(po):
po = PowerFrame.get(radio).power
line = sys.stdout.write('Po: |%-10s| %3iW\r' % ('=' * (po // 10), po))
maxl = max(maxl, line)
time.sleep(0.5)
sys.stdout.write('%s\r' % (' ' * maxl))
def wait_for_tune(radio):
print('Transmit to tune now (waiting for key)')
wait_for_power(radio, lambda po: po > 0)
print('Keyed, waiting for completion')
wait_for_power(radio, lambda po: po == 0)
print('Done')
@contextlib.contextmanager
def restore_settings(radio):
if not isinstance(radio, Demo):
settings = [
SetModeFrame.get(radio),
SetFreqFrame.get(radio),
BKINFrame.get(radio),
CWSpeedFrame.get(radio),
]
else:
settings = []
try:
yield
finally:
LOG.debug('Restoring previous settings')
for f in settings:
radio._send_frame(f)
radio._recv_frame()
def tune_loop(radio, bands, call, next_fn):
for band in bands:
for freq in BANDS[band]:
done = False
while not done:
print('Changing to %i kHz' % freq)
set_freq(radio, freq, 'RTTY')
time.sleep(1)
wait_for_tune(radio)
time.sleep(2)
if call:
send_id(radio, call)
try:
done = next_fn(freq)
except RuntimeError:
return 0
def main():
# More of these may work, but these are known to work
radios = {
'7200': icomciv.Icom7200Radio,
'7300': icomciv.Icom7300Radio,
'7610': icomciv.Icom7610Radio,
'Demo': Demo,
}
p = argparse.ArgumentParser(description=(
'A simple tool to automate running through the required frequencies '
'to tune an SPE Expert linear.'))
p.add_argument('radio', choices=radios,
help='Radio model')
p.add_argument('port', help='Serial port for CAT control')
p.add_argument('--bands', help=('Comma-separated list of bands '
'to tune (160, 80, etc)'))
p.add_argument('--call', help='Callsign for CW ID after each step')
p.add_argument('--next',
choices=['interactive', 'auto'],
default='interactive',
help='Next step strategy')
p.add_argument('--debug', action='store_true',
help='Enable verbose debugging')
args = p.parse_args()
logging.basicConfig(level=logging.DEBUG if args.debug else logging.INFO)
next_fn = globals()['%s_next' % args.next]
try:
bands = [int(i) for i in args.bands.split(',')]
for band in bands:
assert band in BANDS
except (ValueError, AssertionError):
print('Invalid band input. Must be one or more of %s' % (
','.join(str(i) for i in BANDS.keys())))
return 1
if args.radio == 'Demo':
radio = Demo()
else:
radio = setup(args.port, radios[args.radio])
with restore_settings(radio):
tune_loop(radio, bands, args.call, next_fn)
if __name__ == '__main__':
try:
sys.exit(main())
except KeyboardInterrupt:
pass
chirp-20261030/chirp/cli/main.py 0000644 0001750 0001750 00000034033 15270732464 015221 0 ustar hibby hibby #!/usr/bin/env python3
#
# Copyright 2008 Dan Smith
#
# 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
# Copyright 2012 Tom Hayward
#
# 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
# 2016 Matt Weyland
#
# 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
#
# 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
#
# 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
# Copyright 2021 Jim Unroe
#
# 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 2 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
#
# 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
#
# 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
#
# 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 7H", self._memobj[self.ATTR_MAP['smartbeacon']]))
))
def set_smartbeacon(self, d):
self._memobj[self.ATTR_MAP['smartbeacon']] = \
struct.pack(">7H",
encode_base100(d['lowspeed']),
encode_base100(d['slowrate']),
encode_base100(d['highspeed']),
encode_base100(d['fastrate']),
encode_base100(d['turnslope']),
encode_base100(d['turnangle']),
encode_base100(d['turntime']),
)
class AP510Memory20141215(AP510Memory):
"""Compatible with firmware version 20141215"""
ATTR_MAP = dict(list(AP510Memory.ATTR_MAP.items()) + list({
'tx_volume': '21', # 1-6
'rx_volume': '22', # 1-9
'tx_power': '23', # 1: 1 watt, 0: 0.5 watt
'tx_serial_ui_out': '24',
'path1': '25',
'path2': '26',
'path3': '27', # like "WIDE1 1" else "0"
'multiple': '28',
'auto_on': '29',
}.items()))
def get_multiple(self):
return dict(zip(
(
'mice_message', # conveniently matches APRS spec Mic-E messages
'voltage', # voltage in comment
'temperature', # temperature in comment
'tfx', # not sure what the TF/X toggle does
'squelch', # squelch level 0-8 (0 = disabled)
'blueled', # 0: squelch LED on GPS lock
# 1: light LED on GPS lock
'telemetry', # 1: enable
'telemetry_every', # two-digit int
'timeslot_enable', # 1: enable Is this implemented in firmware?
'timeslot', # int 00-59
'dcd', # 0: Blue LED displays squelch,
# 1: Blue LED displays software DCD
'tf_card' # 0: KML, 1: WPL
), map(int, chunks(self._memobj[self.ATTR_MAP['multiple']],
(1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1)))
))
def set_multiple(self, d):
self._memobj[self.ATTR_MAP['multiple']] = "%(mice_message)1d" \
"%(voltage)1d" \
"%(temperature)1d" \
"%(tfx)1d" \
"%(squelch)1d" \
"%(blueled)1d" \
"%(telemetry)1d" \
"%(telemetry_every)02d" \
"%(timeslot_enable)1d" \
"%(timeslot)02d" \
"%(dcd)1d" \
"%(tf_card)1d" % d
def get_smartbeacon(self):
# raw: 18=0100300060010240028005
# chunks: 18=010 0300 060 010 240 028 005
return dict(zip((
'lowspeed',
'slowrate',
'highspeed',
'fastrate',
'turnslope',
'turnangle',
'turntime',
), map(int, chunks(
self._memobj[self.ATTR_MAP['smartbeacon']],
(3, 4, 3, 3, 3, 3, 3)))
))
def set_smartbeacon(self, d):
self._memobj[self.ATTR_MAP['smartbeacon']] = "%(lowspeed)03d" \
"%(slowrate)04d" \
"%(highspeed)03d" \
"%(fastrate)03d" \
"%(turnslope)03d" \
"%(turnangle)03d" \
"%(turntime)03d" % d
PTT_DELAY = ['60 ms', '120 ms', '180 ms', '300 ms', '480 ms',
'600 ms', '1000 ms']
OUTPUT = ['KISS', 'Waypoint out', 'UI out']
PATH = [
'(None)',
'WIDE1-1',
'WIDE1-1,WIDE2-1',
'WIDE1-1,WIDE2-2',
'TEMP1-1',
'TEMP1-1,WIDE 2-1',
'WIDE2-1',
]
TABLE = r"/\#&0>AW^_acnsuvz"
SYMBOL = "".join(map(chr, range(ord("!"), ord("~")+1)))
BEACON = ['manual', 'auto', 'auto + manual', 'smart', 'smart + manual']
ALIAS = ['WIDE1-N', 'WIDE2-N', 'WIDE1-N + WIDE2-N']
CHARSET = "".join(map(chr, range(0, 256)))
MICE_MESSAGE = ['Emergency', 'Priority', 'Special', 'Committed', 'Returning',
'In Service', 'En Route', 'Off Duty']
TF_CARD = ['WPL', 'KML']
POWER_LEVELS = [chirp_common.PowerLevel("0.5 watt", watts=0.50),
chirp_common.PowerLevel("1 watt", watts=1.00)]
RP_IMMUTABLE = ["number", "skip", "bank", "extd_number", "name", "rtone",
"ctone", "dtcs", "tmode", "dtcs_polarity", "skip", "duplex",
"offset", "mode", "tuning_step", "bank_index"]
@directory.register
class AP510Radio(chirp_common.CloneModeRadio):
"""Sainsonic AP510"""
BAUD_RATE = 9600
VENDOR = "Sainsonic"
MODEL = "AP510"
NEEDS_COMPAT_SERIAL = True
_model = b"AVRT5"
mem_upper_limit = 0
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.has_settings = True
rf.valid_modes = ["FM"]
rf.valid_tmodes = [""]
rf.valid_characters = ""
rf.valid_duplexes = [""]
rf.valid_name_length = 0
rf.valid_power_levels = POWER_LEVELS
rf.valid_skips = []
rf.valid_tuning_steps = []
rf.has_bank = False
rf.has_ctone = False
rf.has_dtcs = False
rf.has_dtcs_polarity = False
rf.has_mode = False
rf.has_name = False
rf.has_offset = False
rf.has_tuning_step = False
rf.valid_bands = [(136000000, 174000000)]
rf.memory_bounds = (0, 0)
return rf
def sync_in(self):
try:
data = download(self)
except errors.RadioError:
raise
except Exception as e:
raise errors.RadioError("Failed to communicate with radio: %s" % e)
# _mmap isn't a Chirp MemoryMap, but since AP510Memory implements
# get_packed(), the standard Chirp save feature works.
if data.startswith('\r\n00=%s 20141215' % self._model):
self._mmap = AP510Memory20141215(data)
else:
self._mmap = AP510Memory(data)
def process_mmap(self):
self._mmap.process_data()
def sync_out(self):
try:
upload(self)
except errors.RadioError:
raise
except Exception as e:
raise errors.RadioError("Failed to communicate with radio: %s" % e)
def load_mmap(self, filename):
"""Load the radio's memory map from @filename"""
mapfile = open(filename, "rb")
data = mapfile.read()
if data.startswith('\r\n00=%s 20141215' % self._model):
self._mmap = AP510Memory20141215(data)
else:
self._mmap = AP510Memory(data)
mapfile.close()
def get_raw_memory(self, number):
return self._mmap.get_packed()
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 set_memory(self, mem):
if mem.number != 0:
raise errors.InvalidMemoryLocation("AP510 has only one slot")
self._mmap.freq = "%8.4f" % (mem.freq / 1000000.0)
if mem.power:
try:
self._mmap.tx_power = str(POWER_LEVELS.index(mem.power))
except NotImplementedError:
pass
def get_settings(self):
china = RadioSettingGroup("china", "China Map Fix")
smartbeacon = RadioSettingGroup("smartbeacon", "Smartbeacon")
aprs = RadioSettingGroup("aprs", "APRS", china, smartbeacon)
digipeat = RadioSettingGroup("digipeat", "Digipeat")
system = RadioSettingGroup("system", "System")
settings = RadioSettings(aprs, digipeat, system)
aprs.append(RadioSetting("callsign", "Callsign",
RadioSettingValueString(0, 6, self._mmap.callsign[:6])))
aprs.append(RadioSetting("ssid", "SSID", RadioSettingValueInteger(
0, 15, ord(self._mmap.callsign[6]) - 0x30)))
pttdelay = PTT_DELAY[int(self._mmap.pttdelay) - 1]
aprs.append(RadioSetting("pttdelay", "PTT Delay",
RadioSettingValueList(PTT_DELAY, pttdelay)))
output = OUTPUT[int(self._mmap.output) - 1]
aprs.append(RadioSetting("output", "Output",
RadioSettingValueList(OUTPUT, output)))
aprs.append(RadioSetting("mice", "Mic-E",
RadioSettingValueBoolean(strbool(self._mmap.mice))))
try:
mice_msg = MICE_MESSAGE[int(self._mmap.multiple['mice_message'])]
aprs.append(RadioSetting("mice_message", "Mic-E Message",
RadioSettingValueList(MICE_MESSAGE, mice_msg)))
except NotImplementedError:
pass
try:
aprs.append(RadioSetting("path1", "Path 1",
RadioSettingValueString(0, 6, self._mmap.path1[:6],
autopad=True,
charset=CHARSET)))
ssid1 = ord(self._mmap.path1[6]) - 0x30
aprs.append(RadioSetting("ssid1", "SSID 1",
RadioSettingValueInteger(0, 7, ssid1)))
aprs.append(RadioSetting("path2", "Path 2",
RadioSettingValueString(0, 6, self._mmap.path2[:6],
autopad=True,
charset=CHARSET)))
ssid2 = ord(self._mmap.path2[6]) - 0x30
aprs.append(RadioSetting("ssid2", "SSID 2",
RadioSettingValueInteger(0, 7, ssid2)))
aprs.append(RadioSetting("path3", "Path 3",
RadioSettingValueString(0, 6, self._mmap.path3[:6],
autopad=True,
charset=CHARSET)))
ssid3 = ord(self._mmap.path3[6]) - 0x30
aprs.append(RadioSetting("ssid3", "SSID 3",
RadioSettingValueInteger(0, 7, ssid3)))
except NotImplementedError:
aprs.append(RadioSetting("path", "Path",
RadioSettingValueList(
PATH,
current_index=int(self._mmap.path))))
aprs.append(RadioSetting("table", "Table or Overlay",
RadioSettingValueList(TABLE, self._mmap.symbol[1])))
aprs.append(RadioSetting("symbol", "Symbol",
RadioSettingValueList(SYMBOL, self._mmap.symbol[0])))
aprs.append(RadioSetting("beacon", "Beacon Mode",
RadioSettingValueList(
BEACON,
current_index=int(self._mmap.beacon) - 1)))
aprs.append(RadioSetting("rate", "Beacon Rate (seconds)",
RadioSettingValueInteger(10, 9999, self._mmap.rate)))
aprs.append(RadioSetting("comment", "Comment",
RadioSettingValueString(0, 34, self._mmap.comment,
autopad=False, charset=CHARSET)))
try:
voltage = self._mmap.multiple['voltage']
aprs.append(RadioSetting("voltage", "Voltage in comment",
RadioSettingValueBoolean(voltage)))
temperature = self._mmap.multiple['temperature']
aprs.append(RadioSetting("temperature", "Temperature in comment",
RadioSettingValueBoolean(temperature)))
except NotImplementedError:
pass
aprs.append(RadioSetting("status", "Status", RadioSettingValueString(
0, 34, self._mmap.status, autopad=False, charset=CHARSET)))
try:
telemetry = self._mmap.multiple['telemetry']
aprs.append(RadioSetting("telemetry", "Telemetry",
RadioSettingValueBoolean(telemetry)))
telemetry_every = self._mmap.multiple['telemetry_every']
aprs.append(RadioSetting("telemetry_every", "Telemetry every",
RadioSettingValueInteger(1, 99, telemetry_every)))
timeslot_enable = self._mmap.multiple['telemetry']
aprs.append(RadioSetting("timeslot_enable", "Timeslot",
RadioSettingValueBoolean(timeslot_enable)))
timeslot = self._mmap.multiple['timeslot']
aprs.append(RadioSetting("timeslot", "Timeslot (second of minute)",
RadioSettingValueInteger(0, 59, timeslot)))
except NotImplementedError:
pass
fields = [
("chinamapfix", "China map fix",
RadioSettingValueBoolean(strbool(self._mmap.chinamapfix[0]))),
("chinalat", "Lat",
RadioSettingValueInteger(
-45, 45, ord(self._mmap.chinamapfix[2]) - 80)),
("chinalon", "Lon",
RadioSettingValueInteger(
-45, 45, ord(self._mmap.chinamapfix[1]) - 80)),
]
for field in fields:
china.append(RadioSetting(*field))
try:
# Sometimes when digipeat is disabled, alias is 0xFF
alias = ALIAS[int(self._mmap.digipeat[1]) - 1]
except ValueError:
alias = ALIAS[0]
fields = [
("digipeat", "Digipeat",
RadioSettingValueBoolean(strbool(self._mmap.digipeat[0]))),
("alias", "Digipeat Alias",
RadioSettingValueList(
ALIAS, alias)),
("virtualgps", "Static Position",
RadioSettingValueBoolean(strbool(self._mmap.virtualgps[0]))),
("btext", "Static Position BTEXT", RadioSettingValueString(
0, 27, self._mmap.virtualgps[1:], autopad=False,
charset=CHARSET)),
]
for field in fields:
digipeat.append(RadioSetting(*field))
sb = self._mmap.smartbeacon
fields = [
("lowspeed", "Low Speed"),
("highspeed", "High Speed"),
("slowrate", "Slow Rate (seconds)"),
("fastrate", "Fast Rate (seconds)"),
("turnslope", "Turn Slope"),
("turnangle", "Turn Angle"),
("turntime", "Turn Time (seconds)"),
]
for field in fields:
smartbeacon.append(RadioSetting(
field[0], field[1],
RadioSettingValueInteger(0, 9999, sb[field[0]])
))
system.append(RadioSetting("version", "Version (read-only)",
RadioSettingValueString(0, 14, self._mmap.version)))
system.append(RadioSetting("autooff", "Auto off (after 90 minutes)",
RadioSettingValueBoolean(strbool(self._mmap.autooff))))
system.append(RadioSetting("beep", "Beep on transmit",
RadioSettingValueBoolean(strbool(self._mmap.beep))))
system.append(RadioSetting("highaltitude", "High Altitude",
RadioSettingValueBoolean(
strbool(self._mmap.highaltitude))))
system.append(RadioSetting("busywait",
"Wait for clear channel before transmit",
RadioSettingValueBoolean(
strbool(self._mmap.busywait))))
try:
system.append(RadioSetting("tx_volume", "Transmit volume",
RadioSettingValueList(
map(str, range(1, 7)), self._mmap.tx_volume)))
system.append(RadioSetting("rx_volume", "Receive volume",
RadioSettingValueList(
map(str, range(1, 10)), self._mmap.rx_volume)))
system.append(RadioSetting("squelch", "Squelch",
RadioSettingValueList(
map(str, range(0, 9)),
str(self._mmap.multiple['squelch']))))
system.append(RadioSetting("tx_serial_ui_out", "Tx serial UI out",
RadioSettingValueBoolean(
strbool(self._mmap.tx_serial_ui_out))))
system.append(RadioSetting("auto_on", "Auto-on with 5V input",
RadioSettingValueBoolean(
strbool(self._mmap.auto_on[0]))))
system.append(RadioSetting(
"auto_on_delay",
"Auto-off delay after 5V lost (seconds)",
RadioSettingValueInteger(
0, 9999, int(self._mmap.auto_on[1:]))
))
system.append(RadioSetting("tfx", "TF/X",
RadioSettingValueBoolean(
self._mmap.multiple['tfx'])))
system.append(RadioSetting("blueled", "Light blue LED on GPS lock",
RadioSettingValueBoolean(
self._mmap.multiple['blueled'])))
system.append(RadioSetting("dcd", "Blue LED shows software DCD",
RadioSettingValueBoolean(
self._mmap.multiple['dcd'])))
system.append(RadioSetting("tf_card", "TF card format",
RadioSettingValueList(
TF_CARD,
current_index=(
int(self._mmap.multiple['tf_card'])))))
except NotImplementedError:
pass
return settings
def set_settings(self, settings):
for setting in settings:
if not isinstance(setting, RadioSetting):
self.set_settings(setting)
continue
if not setting.changed():
continue
try:
name = setting.get_name()
if name == "callsign":
self.set_callsign(callsign=setting.value)
elif name == "ssid":
self.set_callsign(ssid=int(setting.value))
elif name == "pttdelay":
self._mmap.pttdelay = PTT_DELAY.index(
str(setting.value)) + 1
elif name == "output":
self._mmap.output = OUTPUT.index(str(setting.value)) + 1
elif name in ('mice', 'autooff', 'beep', 'highaltitude',
'busywait', 'tx_serial_ui_out'):
setattr(self._mmap, name, boolstr(setting.value))
elif name == "mice_message":
multiple = self._mmap.multiple
multiple['mice_message'] = MICE_MESSAGE.index(
str(setting.value))
self._mmap.multiple = multiple
elif name == "path":
self._mmap.path = PATH.index(str(setting.value))
elif name == "path1":
self._mmap.path1 = "%s%s" % (
setting.value, self._mmap.path1[6])
elif name == "ssid1":
self._mmap.path1 = "%s%s" % (
self._mmap.path1[:6], setting.value)
elif name == "path2":
self._mmap.path2 = "%s%s" % (
setting.value, self._mmap.path2[6])
elif name == "ssid2":
self._mmap.path2 = "%s%s" % (
self._mmap.path2[:6], setting.value)
elif name == "path3":
self._mmap.path3 = "%s%s" % (
setting.value, self._mmap.path3[6])
elif name == "ssid3":
self._mmap.path3 = "%s%s" % (
self._mmap.path3[:6], setting.value)
elif name == "table":
self.set_symbol(table=setting.value)
elif name == "symbol":
self.set_symbol(symbol=setting.value)
elif name == "beacon":
self._mmap.beacon = BEACON.index(str(setting.value)) + 1
elif name == "rate":
self._mmap.rate = "%04d" % setting.value
elif name == "comment":
self._mmap.comment = str(setting.value)
elif name == "voltage":
multiple = self._mmap.multiple
multiple['voltage'] = int(setting.value)
self._mmap.multiple = multiple
elif name == "temperature":
multiple = self._mmap.multiple
multiple['temperature'] = int(setting.value)
self._mmap.multiple = multiple
elif name == "status":
self._mmap.status = str(setting.value)
elif name in ("telemetry", "telemetry_every",
"timeslot_enable", "timeslot",
"tfx", "blueled", "dcd"):
multiple = self._mmap.multiple
multiple[name] = int(setting.value)
self._mmap.multiple = multiple
elif name == "chinamapfix":
self.set_chinamapfix(enable=setting.value)
elif name == "chinalat":
self.set_chinamapfix(lat=int(setting.value))
elif name == "chinalon":
self.set_chinamapfix(lon=int(setting.value))
elif name == "digipeat":
self.set_digipeat(enable=setting.value)
elif name == "alias":
self.set_digipeat(
alias=str(ALIAS.index(str(setting.value)) + 1))
elif name == "virtualgps":
self.set_virtualgps(enable=setting.value)
elif name == "btext":
self.set_virtualgps(btext=str(setting.value))
elif name == "lowspeed":
self.set_smartbeacon(lowspeed=int(setting.value))
elif name == "highspeed":
self.set_smartbeacon(highspeed=int(setting.value))
elif name == "slowrate":
self.set_smartbeacon(slowrate=int(setting.value))
elif name == "fastrate":
self.set_smartbeacon(fastrate=int(setting.value))
elif name == "turnslope":
self.set_smartbeacon(turnslope=int(setting.value))
elif name == "turnangle":
self.set_smartbeacon(turnangle=int(setting.value))
elif name == "turntime":
self.set_smartbeacon(turntime=int(setting.value))
elif name in ("tx_volume", "rx_volume", "squelch"):
setattr(self._mmap, name, "%1d" % setting.value)
elif name == "auto_on":
self._mmap.auto_on = "%s%05d" % (
bool(setting.value) and '1' or 'i',
int(self._mmap.auto_on[1:]))
elif name == "auto_on_delay":
self._mmap.auto_on = "%s%05d" % (
self._mmap.auto_on[0], setting.value)
elif name == "tf_card":
multiple = self._mmap.multiple
multiple['tf_card'] = TF_CARD.index(str(setting.value))
self._mmap.multiple = multiple
except Exception:
LOG.debug(setting.get_name())
raise
def set_callsign(self, callsign=None, ssid=None):
if callsign is None:
callsign = self._mmap.callsign[:6]
if ssid is None:
ssid = ord(self._mmap.callsign[6]) - 0x30
self._mmap.callsign = str(callsign) + chr(ssid + 0x30)
def set_symbol(self, table=None, symbol=None):
if table is None:
table = self._mmap.symbol[1]
if symbol is None:
symbol = self._mmap.symbol[0]
self._mmap.symbol = str(symbol) + str(table)
def set_chinamapfix(self, enable=None, lat=None, lon=None):
if enable is None:
enable = strbool(self._mmap.chinamapfix[0])
if lat is None:
lat = ord(self._mmap.chinamapfix[2]) - 80
if lon is None:
lon = ord(self._mmap.chinamapfix[1]) - 80
self._mmapchinamapfix = boolstr(enable) + chr(lon + 80) + chr(lat + 80)
def set_digipeat(self, enable=None, alias=None):
if enable is None:
enable = strbool(self._mmap.digipeat[0])
if alias is None:
alias = self._mmap.digipeat[1]
self._mmap.digipeat = boolstr(enable) + alias
def set_virtualgps(self, enable=None, btext=None):
if enable is None:
enable = strbool(self._mmap.virtualgps[0])
if btext is None:
btext = self._mmap.virtualgps[1:]
self._mmap.virtualgps = boolstr(enable) + btext
def set_smartbeacon(self, **kwargs):
sb = self._mmap.smartbeacon
sb.update(kwargs)
if sb['lowspeed'] > sb['highspeed']:
raise InvalidValueError("Low speed must be less than high speed")
if sb['slowrate'] < sb['fastrate']:
raise InvalidValueError("Slow rate must be greater than fast rate")
self._mmap.smartbeacon = sb
@classmethod
def match_model(cls, filedata, filename):
return filedata.startswith(b'\r\n00=' + cls._model)
chirp-20261030/chirp/drivers/ar8200.py 0000644 0001750 0001750 00000172437 15250742640 016126 0 ustar hibby hibby # Copyright 2026 Darius Rad
#
# 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 ---)$|.*)'
for retry in range(retries):
self.pipe.write(cmd.encode('ascii'))
LOG.debug("tx {}".format(cmd.strip()))
for n in range(lines if cache else 1):
res = self.pipe.readline().decode('ascii', errors='replace')
res = res.strip()
LOG.debug("rx {}".format(res))
m = re.match(pattern, res)
if not m:
LOG.error("Unexpected response from radio: {} -> {}"
"".format(cmd.strip(), res))
break
if cache:
if varlist and m['empty']:
m = True
break
if m.lastindex > 0:
LOG.debug("command cache {} -> {}".format(m[1], m[0]))
self._command_cache[m[1]] = m[0]
else:
if cache:
m = True
else:
for n in range(lines - 1):
res = self.pipe.readline().strip()
LOG.debug("rx {}".format(res))
if m:
break
LOG.debug("Retrying...")
time.sleep(retry_wait)
retry_wait *= 2
retry_wait = min(retry_wait, 5)
self._pipe_reset()
else:
m = None
if old_timeout is not None:
self.pipe.timeout = old_timeout
return m
def _command_read_WM(self, bank, retries=5):
retry_wait = .25
cmd = 'WM{}\r'.format(bank)
for n in range(retries):
self.pipe.write(cmd.encode('ascii'))
LOG.debug("tx {}".format(cmd.strip()))
ret = ()
for b in (bank, bank.lower()):
res = self.pipe.readline().decode('ascii', errors='replace')
res = res.strip()
LOG.debug("rx {}".format(res))
mat = re.match('WM ([A-Ja-j])([01])', res)
if not mat or mat[1] != b:
LOG.error("Unexpected response from radio: {} -> {}"
"".format(cmd.strip(), res))
break
ret += (bool(int(mat[2])),)
else:
return ret
LOG.debug("Retrying...")
time.sleep(retry_wait)
retry_wait *= 2
retry_wait = min(retry_wait, 5)
self._pipe_reset()
return None
def _command_update_cache(self, cmd, lines=10, varlist=False, retries=5):
return self._command(cmd=cmd, lines=lines, cache=True,
varlist=varlist, retries=retries)
def _command_delete_cache(self, key, pattern=False):
if not pattern:
self._command_cache.pop(key, None)
else:
r = re.compile(key)
for k in list(filter(r.match, self._command_cache.keys())):
self._command_cache.pop(k, None)
def _command_cached(self, key, pattern, retries=5):
retry_wait = .25
for n in range(retries):
if key not in self._command_cache:
cmd = re.match('(OL|MX|QM|GM|GS|PR|GR)', key)
if not cmd:
LOG.debug("Response not found in cache: {}".format(key))
return None
if cmd[1] == 'OL':
for n in range(5):
self._command_update_cache('OL')
elif cmd[1] == 'MX':
bank = key[2]
size = self._scan_bank_size(bank)
self._command_update_cache('MA{}'.format(bank))
for n in range(-(size // -10) - 1):
self._command_update_cache('MA')
elif cmd[1] == 'QM':
self._command_update_cache('QM')
elif cmd[1] in ('GM', 'GS'):
self._command_update_cache(cmd[1], 2)
elif cmd[1] == 'PR':
for n in range(100 if key[2] == 'V' else 50):
cachekey = '{}{:02d}'.format(key[:3], n)
val = '{} ---'.format(cachekey)
self._command_cache[cachekey] = val
self._command_update_cache(
key[:3], 100 if key[2] == 'V' else 50, varlist=True)
elif cmd[1] == 'GR':
self._command_update_cache('GR', 100, varlist=True)
else:
LOG.debug("Response not found in cache: {}".format(key))
return None
if key in self._command_cache:
res = re.match(pattern, self._command_cache[key])
if res:
return res
LOG.debug("Unexpected result from radio {}"
"".format(self._command_cache[key]))
del self._command_cache[key]
else:
LOG.debug("Response not found in cache: {}".format(key))
LOG.debug("Retrying...")
time.sleep(retry_wait)
retry_wait *= 2
return None
def _scan_bank_size(self, bank):
if bank not in self._SCAN_BANKS:
return None
if bank.upper() not in self._scan_bank_sizes:
res = self._command('MW{}'.format(bank.upper()),
'MW [A-J]:([1-9]0) [a-j]:([1-9]0)')
self._scan_bank_sizes[bank.upper()] = int(res[1])
if bank.isupper():
return self._scan_bank_sizes[bank]
else:
return 100 - self._scan_bank_sizes[bank.upper()]
def _get_ol_list_uncached(self):
self._OL_LIST = [0]
for n in range(1, 48):
res = self._command_cached('OL{:02d}'.format(n),
'OL([0-4][0-9]) RF(0[0-9]{7}00)')
if n != int(res[1]):
raise errors.RadioError(
"Unexpected result returned from radio")
self._OL_LIST.append(int(res[2]))
LOG.info("Offset frequency {} is {}".format(n, res[2]))
return self._OL_LIST
def _get_ol_list(self, locked=False):
if self._OL_LIST:
return self._OL_LIST
if locked:
with self.LOCK:
return self._get_ol_list_uncached()
else:
return self._get_ol_list_uncached()
def _set_pp(self, number):
(region, bank, chan) = self._decode_number(number)
self._command('PP{}{:02d}'.format(bank, chan))
def _get_gr_list(self):
if isinstance(self._GR_LIST, list):
return self._GR_LIST
self._GR_LIST = []
for n in range(100):
res = self._command_cached(
'GR{:02d}'.format(n),
('GR(?P[0-9]{2}) (?:(?P---)$|'
'MX(?P[A-Ja-j])(?P[0-9]{2}))'))
if not res:
break
if n != int(res['num']):
raise errors.RadioError(
"Unexpected result returned from radio")
self._GR_LIST.append((res['bank'], int(res['chan'])))
LOG.info("Select scan entry {} is {}{:02d}"
"".format(n, res['bank'], int(res['chan'])))
return self._GR_LIST
def _save_gs(self):
if self._GS:
return
res = self._command('GS', 'GS([0-9])', 2)
self._GS = int(res[1])
def _restore_gs(self):
self._command('GS{}'.format(self._GS))
def _invalidate_scan_bank_size(self):
self._scan_bank_sizes = {}
def _invalidate_ol_list(self):
self._OL_LIST = None
self._command_delete_cache('OL([0-9]{2})', True)
def _invalidate_gr_list(self):
self._GR_LIST = None
self._command_delete_cache('GR([0-9]{2})', True)
def _invalidate_memory(self, region=None, bank=None, chan=None,
number=None, emptyonly=False):
if number is not None:
(region, bank, chan) = self._decode_number(number)
else:
number = self._encode_number(region, bank, chan)
if number in self._memcache:
if emptyonly and not self._memcache[number].empty:
return
del self._memcache[number]
if region == 'qm':
self._command_delete_cache('QM{:1d}'.format(chan), True)
elif region == 'scan':
self._command_delete_cache('MX{}{:02d}'.format(bank, chan), True)
elif region == 'pass':
self._command_delete_cache('PR{}{:02d}'.format(bank, chan), True)
elif region == 'search':
# commands not cached
pass
def get_memory(self, number):
if number in self._memcache:
return self._memcache[number]
with self.LOCK:
return self._get_memory_unlocked(number)
def _get_memory_unlocked(self, number):
mem = chirp_common.Memory()
mem.extra = RadioSettingGroup('extra', 'Extra')
AM_LIST = ['AM', 'NAM', 'WAM']
extra_am = RadioSettingValueList(AM_LIST)
rs = RadioSetting('am', 'AM Mode', extra_am)
mem.extra.append(rs)
lv = min(list(zip(*self._rf.valid_bands))[0]) / 1000000
uv = max(list(zip(*self._rf.valid_bands))[1]) / 1000000
extra_upper = RadioSettingValueFloat(lv, uv, lv, 0.00005, 5)
rs = RadioSetting('upper', 'Upper Frequency', extra_upper)
mem.extra.append(rs)
extra_adjust = RadioSettingValueFloat(0, 999.95, 0, 0.05, 2)
rs = RadioSetting('adjust', 'Step Adjust', extra_adjust)
mem.extra.append(rs)
extra_att = RadioSettingValueBoolean(False)
rs = RadioSetting('att', 'Attenuator', extra_att)
mem.extra.append(rs)
extra_limit = RadioSettingValueBoolean(False)
rs = RadioSetting('limit', 'Noise Limiter', extra_limit)
mem.extra.append(rs)
extra_protect = RadioSettingValueBoolean(False)
rs = RadioSetting('protect', 'Protect', extra_protect)
mem.extra.append(rs)
extra_select = RadioSettingValueBoolean(False)
rs = RadioSetting('select', 'Select Scan', extra_select)
mem.extra.append(rs)
extra_selectindex = RadioSettingValueInteger(0, 99, 0)
rs = RadioSetting('selectindex', 'Select Scan Index',
extra_selectindex)
mem.extra.append(rs)
if isinstance(number, str):
mem.number = self._SPECIAL_CHANS[number]
mem.extd_number = number
else:
mem.number = number
(region, bank, chan) = self._decode_number(mem.number)
if region is None:
raise errors.InvalidMemoryLocation(
"No such memory {}".format(number))
if region == 'vfo':
if chan == self._SPECIAL_CHANS['VFO']:
self._command('VF')
mem.name = 'VFO'
elif chan == self._SPECIAL_CHANS['VFO-A']:
self._command('VA')
mem.name = 'VFO-A'
elif chan == self._SPECIAL_CHANS['VFO-B']:
self._command('VB')
mem.name = 'VFO-B'
ol_list = self._get_ol_list()
res = self._command(
'RX',
('V[ABF] RF(?P[0-9]{10}) '
'ST(?P[0-9]{6})(?P[+]?) AU(?P[01]) '
'MD(?P[0-8]) AT(?P[01])'))
if not res:
pass
else:
mem.freq = int(res['freq'])
if int(res['auto']):
mem.mode = 'Auto'
else:
radio_mode = [mode[0] for mode in self._MODES
if mode[1] == int(res['mode'])][0]
if radio_mode in self._AM_MODES:
mem.mode = 'AM'
extra_am.set_value(radio_mode)
else:
mem.mode = radio_mode
mem.tuning_step = float(res['step']) / 1000
extra_att.set_value(int(res['att']))
res = self._command('OF', 'OF([0-4][0-9])([ +-])')
mem.offset = ol_list[int(res[1])] if res else 0
mem.duplex = res[2] if res and res[2] in ('+', '-') else ''
res = self._command('SH', 'SH([0-9]{6})([+]?)')
if res:
extra_adjust.set_value(
int(res[1]) / 1000 if res[2] == '+' else 0)
res = self._command('NL', 'NL([01])')
if res:
extra_limit.set_value(int(res[1]))
extra_protect.set_mutable(False)
extra_upper.set_mutable(False)
mem.immutable += ['name', 'skip', 'extra.upper', 'extra.protect',
'extra.select']
elif region == 'qm':
res = self._command_cached('QM{:1d}'.format(chan),
'QM([0-9]) RF([0-9]{10})')
if not res:
mem.empty = True
else:
if chan != int(res[1]):
raise errors.RadioError(
"Unexpected result returned from radio")
mem.freq = int(res[2])
mem.name = 'QM{:1d}'.format(chan)
extra_am.set_mutable(False)
extra_upper.set_mutable(False)
extra_adjust.set_mutable(False)
extra_att.set_mutable(False)
extra_limit.set_mutable(False)
extra_protect.set_mutable(False)
mem.immutable += ['empty', 'freq', 'name', 'offset', 'mode',
'tuning_step', 'skip', 'duplex', 'extra.upper',
'extra.adjust', 'extra.att', 'extra.limit',
'extra.protect', 'extra.select']
elif region == 'scan':
ol_list = self._get_ol_list()
gr_list = self._get_gr_list()
res = self._command_cached(
'MX{}{:02d}'.format(bank, chan),
('MX(?P[A-Ja-j])(?P[0-9]{2}) '
'(?:(?P---)$|MP(?P[01]) RF(?P[0-9]{10}) '
'ST(?P[0-9]{6})(?P[+]?) AU(?P[01]) '
'MD(?P[0-8]) AT(?P[01]) TM(?P.{0,12}))'))
if not res:
pass
elif res['empty']:
mem.empty = True
else:
if res['bank'] != bank or int(res['chan']) != chan:
raise errors.RadioError(
"Unexpected result returned from radio")
mem.freq = int(res['freq'])
mem.name = res['name']
if int(res['auto']):
mem.mode = 'Auto'
else:
radio_mode = [mode[0] for mode in self._MODES
if mode[1] == int(res['mode'])][0]
if radio_mode in self._AM_MODES:
mem.mode = 'AM'
extra_am.set_value(radio_mode)
else:
mem.mode = radio_mode
mem.tuning_step = float(res['step']) / 1000
mem.skip = 'S' if int(res['pass']) else ''
extra_att.set_value(int(res['att']))
if not self._SKIP_SELECT:
self._command('MR{}{:02d}'.format(bank, chan))
res = self._command('OF', 'OF([0-4][0-9])([ +-])')
mem.offset = ol_list[int(res[1])] if res else 0
mem.duplex = res[2] if res and res[2] in ('+', '-') else ''
res = self._command('SH', 'SH([0-9]{6})([+]?)')
if res:
extra_adjust.set_value(
int(res[1]) / 1000 if res[2] == '+' else 0)
res = self._command('NL', 'NL([01])')
if res:
extra_limit.set_value(int(res[1]))
res = self._command('PC', 'PC([01])')
if res:
extra_protect.set_value(int(res[1]))
if (bank, chan) in gr_list:
extra_select.set_value(True)
extra_selectindex.set_value(
gr_list.index((bank, chan)))
else:
mem.immutable += ['extra.select']
else:
extra_adjust.set_mutable(False)
extra_limit.set_mutable(False)
extra_protect.set_mutable(False)
mem.immutable += ['offset', 'duplex', 'extra.adjust',
'extra.limit', 'extra.protect',
'extra.select']
extra_upper.set_mutable(False)
mem.immutable += ['extra.upper']
elif region == 'pass':
res = self._command_cached(
'PR{}{:02d}'.format(bank, chan),
('PR(?P[A-Ta-tV])(?P[0-9]{2}) '
'(?:(?P---)$|(?P[0-9]{10}))'))
if not res or res['empty']:
mem.empty = True
else:
if res['bank'] != bank or int(res['chan']) != chan:
raise errors.RadioError(
"Unexpected result returned from radio")
mem.freq = int(res['freq'])
mem.name = 'PR{}{:02d}'.format(bank, chan)
mem.immutable += ['freq']
mem.tuning_step = 20.0
mem.skip = 'S'
extra_am.set_mutable(False)
extra_upper.set_mutable(False)
extra_adjust.set_mutable(False)
extra_att.set_mutable(False)
extra_limit.set_mutable(False)
extra_protect.set_mutable(False)
mem.immutable += ['name', 'offset', 'mode', 'tuning_step', 'skip',
'duplex', 'extra.upper', 'extra.adjust',
'extra.att', 'extra.limit', 'extra.protect',
'extra.select']
elif region == 'search':
ol_list = self._get_ol_list()
res = self._command(
'SR{}'.format(bank),
('SR(?P[A-Ta-t]) (?:(?P---)$|'
'SL(?P[0-9]{10}) SU(?P[0-9]{10}) '
'ST(?P[0-9]{6})(?P[+]?) AU(?P[01]) '
'MD(?P[0-8]) AT(?P[01]) TT(?P.{0,12}))'))
if not res:
pass
elif res['empty']:
mem.empty = True
else:
if res['bank'] != bank:
raise errors.RadioError(
"Unexpected result returned from radio")
mem.freq = int(res['lower'])
mem.name = res['name']
if int(res['auto']):
mem.mode = 'Auto'
else:
radio_mode = [mode[0] for mode in self._MODES
if mode[1] == int(res['mode'])][0]
if radio_mode in self._AM_MODES:
mem.mode = 'AM'
extra_am.set_value(radio_mode)
else:
mem.mode = radio_mode
mem.tuning_step = float(res['step']) / 1000
extra_upper.set_value(int(res['upper']) / 1000000)
extra_att.set_value(int(res['att']))
self._save_gs()
self._command('GS0')
self._command('SS{}'.format(bank))
res = self._command('OF', 'OF([0-4][0-9])([ +-])')
mem.offset = ol_list[int(res[1])] if res else 0
mem.duplex = res[2] if res and res[2] in ('+', '-') else ''
res = self._command('SH', 'SH([0-9]{6})([+]?)')
if res:
v = int(res[1]) / 1000 if res[2] == '+' else 0
extra_adjust.set_value(v)
res = self._command('NL', 'NL([01])')
if res:
extra_limit.set_value(int(res[1]))
res = self._command('BP', 'BP([01])')
if res:
extra_protect.set_value(int(res[1]))
self._restore_gs()
self._command('VF')
mem.immutable += ['skip', 'extra.select']
else:
mem.empty = True
extra_select.set_mutable(False)
mem.immutable += ['extra.selectindex', 'tmode', 'rtone']
self._memcache[mem.number] = mem
return mem
def validate_memory(self, memory):
msgs = []
ol_list = self._get_ol_list(True)
(region, bank, chan) = self._decode_number(memory.number)
if region in ('scan', 'search'):
if memory.offset not in ol_list:
msg = chirp_common.ValidationWarning(
"Offset frequency is not valid, see table in settings "
"for valid values")
msgs.append(msg)
if memory.tuning_step == 0.0 or memory.tuning_step >= 1000.0 or \
(int(memory.tuning_step * 1000) % 50) != 0:
msg = chirp_common.ValidationWarning(
"Tuning step must be non-zero, less than 1000 kHz, and "
"divisible by 0.05 kHz")
msgs.append(msg)
if 'adjust' in memory.extra:
if float(memory.extra['adjust'].value) >= memory.tuning_step:
msg = chirp_common.ValidationWarning(
"Step adjust must be smaller than tuning step")
msgs.append(msg)
if region == 'search' and 'upper' in memory.extra:
upper = int(float(memory.extra['upper'].value) * 1000000)
if memory.freq > upper:
msg = chirp_common.ValidationWarning(
"Upper search frequency is not greater than lower "
"frequency")
msgs.append(msg)
valid = False
for (lv, uv) in self._rf.valid_bands:
if upper >= lv and upper <= uv:
valid = True
break
if not valid:
msg = chirp_common.ValidationError(
"Upper search frequency {} is not in a valid band"
"".format(float(memory.extra['upper'].value)))
msgs.append(msg)
if region == 'pass':
if memory.skip != 'S':
msg = chirp_common.ValidationWarning(
"Search pass frequencies must be marked skip")
msgs.append(msg)
msg = chirp_common.ValidationWarning(
"Memories must be refreshed after modifying pass channels")
msgs.append(msg)
return msgs + super().validate_memory(memory)
def set_memory(self, memory):
with self.LOCK:
return self._set_memory_unlocked(memory)
def _set_memory_unlocked(self, memory):
self._invalidate_memory(number=memory.number)
(region, bank, chan) = self._decode_number(memory.number)
if region is None:
raise errors.InvalidMemoryLocation(
"No such memory {}".format(memory.number))
if region == 'vfo':
if chan == self._SPECIAL_CHANS['VFO']:
self._command('VF')
elif chan == self._SPECIAL_CHANS['VFO-A']:
self._command('VA')
elif chan == self._SPECIAL_CHANS['VFO-B']:
self._command('VB')
ol_list = self._get_ol_list()
freq = memory.freq
auto = int(memory.mode == 'Auto')
step = int(memory.tuning_step * 1000)
if memory.mode == 'Auto':
mode = 0
elif memory.mode == 'AM':
ammode = memory.extra['am'] if 'am' in memory.extra else 'AM'
mode = [mode[1] for mode in self._MODES
if mode[0] == ammode][0]
else:
mode = [mode[1] for mode in self._MODES
if mode[0] == memory.mode][0]
att = int(memory.extra['att'].value) \
if 'att' in memory.extra else 0
duplex = memory.duplex if memory.duplex in ('+', '-') else ''
offset = ol_list.index(memory.offset) \
if duplex and memory.offset in ol_list else 0
adjust = float(memory.extra['adjust'].value) \
if 'adjust' in memory.extra else 0
limit = int(memory.extra['limit'].value) \
if 'limit' in memory.extra else 0
self._command('RF{:010d}'.format(freq))
self._command('AT{:1d}'.format(att))
self._command('AU{:1d}'.format(auto))
if not auto:
self._command('MD{:1d}'.format(mode))
self._command('ST{:06d}'.format(step))
self._command('OF{:02d}{}'.format(offset, duplex))
# step tuning enable can only be toggled, so get the
# current value first
toggle = ''
res = self._command('SH', 'SH([0-9]{6})([+]?)')
if res:
toggle = '+' if (res[2] == '+') != (adjust > 0) else ''
self._command('SH{:06d}{}'.format(int(adjust * 1000), toggle))
self._command('NL{:1d}'.format(limit))
elif region == 'qm':
raise errors.InvalidDataError(
"Quick memory locations are read-only")
elif region == 'scan':
self._command_delete_cache('MX{:1}{:02d}'.format(bank, chan))
ol_list = self._get_ol_list()
gr_list = self._get_gr_list()
freq = memory.freq
auto = int(memory.mode == 'Auto')
step = int(memory.tuning_step * 1000)
if memory.mode == 'Auto':
mode = 0
elif memory.mode == 'AM':
ammode = memory.extra['am'] if 'am' in memory.extra else 'AM'
mode = [mode[1] for mode in self._MODES
if mode[0] == ammode][0]
else:
mode = [mode[1] for mode in self._MODES
if mode[0] == memory.mode][0]
att = int(memory.extra['att'].value) \
if 'att' in memory.extra else 0
duplex = memory.duplex if memory.duplex in ('+', '-') else ''
offset = ol_list.index(memory.offset) \
if duplex and memory.offset in ol_list else 0
adjust = float(memory.extra['adjust'].value) \
if 'adjust' in memory.extra else 0
limit = int(memory.extra['limit'].value) \
if 'limit' in memory.extra else 0
protect = int(memory.extra['protect'].value) \
if 'protect' in memory.extra else 0
select = int(memory.extra['select'].value) \
if 'select' in memory.extra else 0
name = memory.name
mp = 1 if memory.skip == 'S' else 0
offsetstr = 'OF{:02d}{} '.format(offset, duplex) \
if not self._SKIP_SELECT else ''
res = self._command(
('MX{}{:02d} RF{:010d} MP{:1d} ST{:06d} MD{:1d} AT{:1d} '
'{}AU{:1d} TM{:12}'.format(bank, chan, freq, mp, step, mode,
att, offsetstr, auto, name)),
'(?:$|{:c}{:c})'.format(0x13, 0x11))
if not res:
raise errors.InvalidDataError(
"Radio refused {}".format(memory.number))
if not self._SKIP_SELECT:
self._command('MR{}{:02d}'.format(bank, chan))
if not auto:
# step tuning enable can only be toggled, so get
# the current value first
toggle = ''
res = self._command('SH', 'SH([0-9]{6})([+]?)')
if res:
toggle = '+' if (res[2] == '+') != (adjust > 0) else ''
self._command(
'SH{:06d}{}'.format(int(adjust * 1000), toggle))
self._command('NL{:1d}'.format(limit))
self._command('PC{:1d}'.format(protect))
if not select and (bank, chan) in gr_list:
self._command(
'GD{:02d}'.format(gr_list.index((bank, chan))))
self._invalidate_gr_list()
elif region == 'pass':
self._command_delete_cache('PR{}[0-9]{{2}}'.format(bank), True)
freq = memory.freq
res = self._command('PW{}{:010d}'.format(bank, freq))
if not res:
raise errors.InvalidDataError(
"Radio refused {}".format(memory.number))
for n in range(100 if bank == 'V' else 50):
self._invalidate_memory(region, bank, n, emptyonly=True)
elif region == 'search':
self._command_delete_cache('SR{}'.format(bank))
ol_list = self._get_ol_list()
lower = memory.freq
upper = int(float(memory.extra['upper'].value) * 1000000) \
if 'upper' in memory.extra else lower
auto = int(memory.mode == 'Auto')
step = int(memory.tuning_step * 1000)
if memory.mode == 'Auto':
mode = 0
elif memory.mode == 'AM':
ammode = memory.extra['am'] if 'am' in memory.extra else 'AM'
mode = [mode[1] for mode in self._MODES
if mode[0] == ammode][0]
else:
mode = [mode[1] for mode in self._MODES
if mode[0] == memory.mode][0]
att = int(memory.extra['att'].value) \
if 'att' in memory.extra else 0
duplex = memory.duplex if memory.duplex in ('+', '-') else ''
offset = ol_list.index(memory.offset) \
if duplex and memory.offset in ol_list else 0
adjust = float(memory.extra['adjust'].value) \
if 'adjust' in memory.extra else 0
limit = int(memory.extra['limit'].value) \
if 'limit' in memory.extra else 0
protect = int(memory.extra['protect'].value) \
if 'protect' in memory.extra else 0
name = memory.name
# correct lower/upper out of order
if lower > upper:
(lower, upper) = (upper, lower)
# fix out of range
lower = max(lower, min(list(zip(*self._rf.valid_bands))[0]))
upper = min(upper, max(list(zip(*self._rf.valid_bands))[1]))
res = self._command(
'SE{} SL{:010d} SU{:010d} ST{:06d} MD{:1d} AT{:1d} '
'OF{:02d}{:1} AU{:1d} TT{:12}'.format(bank, lower, upper, step,
mode, att, offset,
duplex, auto, name))
if not res:
raise errors.InvalidDataError(
"Radio refused {}".format(memory.number))
self._save_gs()
self._command('GS0')
self._command('SS{}'.format(bank))
if not auto:
# step tuning enable can only be toggled, so get the
# current value first
toggle = ''
res = self._command('SH', 'SH([0-9]{6})([+]?)')
if res:
toggle = '+' if (res[2] == '+') != (adjust > 0) else ''
self._command('SH{:06d}{}'.format(int(adjust * 1000), toggle))
self._command('NL{:1d}'.format(limit))
self._command('BP{:1d}'.format(protect))
self._restore_gs()
self._command('VF')
def erase_memory(self, number):
with self.LOCK:
return self._erase_memory_unlocked(number)
def _erase_memory_unlocked(self, number):
if isinstance(number, str):
if number not in self._SPECIAL_CHANS:
return
number = self._SPECIAL_CHANS[number]
if number not in self._memcache:
return
(region, bank, chan) = self._decode_number(number)
if region == 'qm':
raise errors.InvalidDataError(
"Quick memory locations are read-only")
elif region == 'scan':
self._command_delete_cache('MX{}{:02d}'.format(bank, chan))
self._command('MR{}{:02d}'.format(bank, chan))
self._command('MQ{:02d}'.format(chan))
elif region == 'pass':
self._command_delete_cache('PR{}[0-9]{{2}}'.format(bank), True)
self._command('PD{}{:02d}'.format(bank, chan))
for n in range(chan, 100 if bank == 'V' else 50):
self._invalidate_memory(region, bank, n)
elif region == 'search':
self._command_delete_cache('SR{}'.format(bank))
self._command('QS{}'.format(bank))
del self._memcache[number]
def get_settings(self):
with self.LOCK:
return self._get_settings_unlocked()
def _get_settings_unlocked(self):
main = RadioSettingGroup('main', 'Main')
vfo = RadioSettingGroup('vfo', 'VFO')
freq = RadioSettingGroup('freq', 'Offset')
scan = RadioSettingGroup('scan', 'Scan')
search = RadioSettingGroup('search', 'Search')
scanbankprotect = RadioSettingGroup('scanbankprotect',
'Scan Bank Protect')
top = RadioSettings(main, vfo, freq, scan, search, scanbankprotect)
res = self._command('VR', 'VR([0-9]+)')
rs = RadioSetting('VR', 'Firmware Version',
RadioSettingValueString(0, 4, res[1]))
rs.value.set_mutable(False)
main.append(rs)
res = self._command('AF', 'AF([01])')
rs = RadioSetting('AF', 'Automatic Frequency Control',
RadioSettingValueBoolean(int(res[1])))
rs.set_apply_callback(
lambda x: self._command('AF{}'.format(int(x.value))))
main.append(rs)
res = self._command('AP', 'AP([0-9][.][0-9])')
rs = RadioSetting(
'AP', 'Automatic Power Off (hours)',
RadioSettingValueFloat(0, 9.5, float(res[1]), 0.5, 1))
rs.set_apply_callback(
lambda x: self._command('AP{}'.format(int(x.value))))
main.append(rs)
res = self._command('DT', 'DT([01])')
rs = RadioSetting('DT', 'Display Frequency Text',
RadioSettingValueBoolean(int(res[1])))
rs.set_apply_callback(
lambda x: self._command('DT{}'.format(int(x.value))))
main.append(rs)
res = self._command('LB', 'LB([0-9]{2})')
rs = RadioSetting('LB', 'LCD Contrast',
RadioSettingValueInteger(0, 31, res[1]))
rs.set_apply_callback(
lambda x: self._command('LB{:02d}'.format(int(x.value))))
main.append(rs)
# OM supports options for standard, no, and custom message,
# but the code here always sets the configured text as a
# custom message.
res = self._command('OM', 'OM([012]) (.{0,48})')
rs = RadioSetting('OM', 'Opening Message',
RadioSettingValueString(0, 48, res[2]))
rs.set_apply_callback(
lambda x: self._command('OM2 {}'.format(str(x.value))))
main.append(rs)
res = self._command('PA', 'PA([0-9]{2})')
rs = RadioSetting('PA', 'Power Save Delay (seconds)',
RadioSettingValueInteger(0, 99, res[1]))
rs.set_apply_callback(
lambda x: self._command('PA{:02d}'.format(int(x.value))))
main.append(rs)
res = self._command('PI', 'PI([1-9].[05])')
rs = RadioSetting(
'PI', 'Power Save Interval (seconds)',
RadioSettingValueFloat(1.0, 9.5, float(res[1]), 0.5, 1))
rs.set_apply_callback(
lambda x: self._command(
'PI{:02d}'.format(int(float(x.value) * 10))))
main.append(rs)
res = self._command('PP', 'PP([A-Ja-j])([0-9]{2})')
rs = RadioSetting(
'PP', 'Priority Scan Channel',
RadioSettingValueInteger(
0, self._SCAN_MEMORIES - 1,
self._encode_number('scan', res[1], int(res[2]))))
rs.set_apply_callback(lambda x: self._set_pp(int(x.value)))
main.append(rs)
res = self._command('TI', 'TI([01][0-9])')
rs = RadioSetting('TI', 'Priority Interval (seconds)',
RadioSettingValueInteger(1, 19, res[1]))
rs.set_apply_callback(
lambda x: self._command('TI{:02d}'.format(int(x.value))))
main.append(rs)
res = self._command('VL', 'VL([0-9])')
rs = RadioSetting('VL', 'Beep Volume',
RadioSettingValueInteger(0, 9, res[1]))
rs.set_apply_callback(
lambda x: self._command('VL{}'.format(int(x.value))))
main.append(rs)
res = self._command('WP', 'WP([01])')
rs = RadioSetting('WP', 'Write Protect',
RadioSettingValueBoolean(int(res[1])))
rs.set_apply_callback(
lambda x: self._command('WP{}'.format(int(x.value))))
main.append(rs)
# vfo settings
res = self._command('DA', 'DA[ +]([012][0-9]{2})')
rs = RadioSetting('DA', 'Dial Audio Squelch',
RadioSettingValueInteger(0, 255, res[1]))
rs.set_apply_callback(
lambda x: self._command('DA{:03d}'.format(int(x.value))))
vfo.append(rs)
res = self._command('DB', 'DB[ +]([012][0-9]{2})')
rs = RadioSetting('DB', 'Dial Level Squelch',
RadioSettingValueInteger(0, 255, res[1]))
rs.set_apply_callback(
lambda x: self._command('DB{:03d}'.format(int(x.value))))
vfo.append(rs)
res = self._command('DD', 'DD([0-9][.][0-9])')
rs = RadioSetting('DDFF', 'Dial Search Hold',
RadioSettingValueBoolean(res[1] == 'FF'))
vfo.append(rs)
value = float(res[1]) if res[1] != 'FF' else 0
rs = RadioSetting('DD', 'Dial Delay (seconds)',
RadioSettingValueFloat(0, 9.9, value, 0.1, 1))
vfo.append(rs)
res = self._command('DP', 'DP([0-9]{2})')
rs = RadioSetting('DP', 'Dial Pause (seconds)',
RadioSettingValueInteger(0, 60, res[1]))
rs.set_apply_callback(
lambda x: self._command('DP{:02d}'.format(int(x.value))))
vfo.append(rs)
VT_MAP = [('Off', 0), ('On, auto-store to bank J', 1),
('On, erase bank J', 2)]
res = self._command('VT', 'VT([012])')
rs = RadioSetting('VT', 'VFO Auto-store',
RadioSettingValueMap(VT_MAP, int(res[1])))
rs.set_apply_callback(
lambda x: self._command('VT{}'.format(int(x.value))))
vfo.append(rs)
# frequency offsets
# 0 means off, 20-47 are read-only
ol_list = self._get_ol_list()
for n in range(0, 48):
rs = RadioSetting(
'OL{:02d}'.format(n),
'Offset Frequency {} (MHz)'.format(n),
RadioSettingValueFloat(
0.0, 999.9999, ol_list[n] / 1000000, 0.0001, 4))
rs.value.set_mutable(n > 0 and n < 20)
rs.set_apply_callback(
lambda x, y: self._command(
('OL{:02d} {:010d}'
''.format(y, int(float(x.value) * 1000000)))), n)
rs.set_warning("Memories must be refreshed after changing "
"offset frequencies.")
freq.append(rs)
# scan settings
grp = RadioSettingSubGroup('scan general', 'Scan General')
scan.append(grp)
res = self._command('GM', 'GM([0-9])', 2)
sel = int(res[1])
rs = RadioSetting('GM', 'Selected Scan Group',
RadioSettingValueInteger(0, 9, sel))
rs.set_apply_callback(
lambda x: self._command('GM{}'.format(int(x.value))))
grp.append(rs)
grp = RadioSettingSubGroup('TB', 'Scan Bank Name')
scan.append(grp)
for bank in self._SCAN_BANKS:
res = self._command('TB{}'.format(bank), 'TB([A-Ja-j])(.{0,8})')
rs = RadioSetting('TB{}'.format(bank), 'Bank {} Name'.format(bank),
RadioSettingValueString(0, 8, res[2]))
rs.set_apply_callback(
lambda x, y: self._command(
'TB{}{:8}'.format(y, str(x.value))), bank)
grp.append(rs)
grp = RadioSettingSubGroup('MW', 'Scan Bank Size')
scan.append(grp)
MW_MAP = [('10/90', 10), ('20/80', 20), ('30/70', 30), ('40/60', 40),
('50/50', 50), ('60/40', 60), ('70/30', 70), ('80/20', 80),
('90/10', 90)]
for bank in self._SCAN_BANKS[::2]:
rs = RadioSetting(
'MW{}'.format(bank), 'Bank {}/{}'.format(bank, bank.lower()),
RadioSettingValueMap(MW_MAP, self._scan_bank_size(bank)))
rs.set_apply_callback(
lambda x, y: self._command(
'MW{}{:2d}'.format(y, int(x.value)), timeout=600), bank)
rs.set_warning("Resizing scan banks takes a significant amount of "
"time (one minute or longer). Memories must be "
"refreshed after changing scan bank size.")
grp.append(rs)
for group in range(10):
grp = RadioSettingSubGroup(
'GM{}'.format(group), 'Scan Group {}'.format(group))
scan.append(grp)
self._command('GM{}'.format(group))
res = self._command_cached(
'GM{:1d}'.format(group),
('GM(?P[0-9]) XD(?P[0-9][.][0-9]) '
'XB (?P[012][0-9]{2}) XA (?P[012][0-9]{2}) '
'XP(?P[0-9]{2}) XM(?P[0-8F])'))
if not res:
continue
rs = RadioSetting('XA{}'.format(group), 'Scan Audio Squelch',
RadioSettingValueInteger(0, 255, res['audio']))
rs.value.set_mutable(group != 0)
grp.append(rs)
rs = RadioSetting('XB{}'.format(group), 'Scan Level Squelch',
RadioSettingValueInteger(0, 255, res['level']))
rs.value.set_mutable(group != 0)
grp.append(rs)
rs = RadioSetting(
'XD{}'.format(group), 'Scan Delay (seconds)',
RadioSettingValueFloat(0, 9.9, float(res['delay']), 0.1, 1))
rs.value.set_mutable(group != 0)
grp.append(rs)
rs = RadioSetting('XP{}'.format(group), 'Scan Pause (seconds)',
RadioSettingValueInteger(0, 99, res['pause']))
rs.value.set_mutable(group != 0)
grp.append(rs)
rs = RadioSetting(
'XM{}'.format(group), 'Scan Mode',
RadioSettingValueMap(self._MODES, int(res['mode'], 16)))
rs.value.set_mutable(group != 0)
grp.append(rs)
res = self._command_cached('BM', 'BM ([A-Ja-j-]{20})')
for bank in self._SCAN_BANKS:
rs = RadioSetting(
'BM{}{}'.format(group, bank), 'Bank {}'.format(bank),
RadioSettingValueBoolean(bank in res[1]))
rs.value.set_mutable(group != 0)
grp.append(rs)
self._command('GM{}'.format(sel))
# search settings
grp = RadioSettingSubGroup('search general', 'Search General')
search.append(grp)
res = self._command('GS', 'GS([0-9])', 2)
sel = int(res[1])
rs = RadioSetting('GS', 'Selected Search Group',
RadioSettingValueInteger(0, 9, sel))
rs.set_apply_callback(
lambda x: self._command('GS{}'.format(int(x.value))))
grp.append(rs)
self._save_gs()
for group in range(10):
grp = RadioSettingSubGroup('GS{}'.format(group),
'Search Group {}'.format(group))
search.append(grp)
self._command('GS{}'.format(group))
res = self._command_cached(
'GS{:1d}'.format(group),
('GS(?P[0-9]) SD(?P[0-9][.][0-9]) '
'SB (?P[012][0-9]{2}) SA (?P[012][0-9]{2}) '
'SP(?P[0-9]{2}) AS(?P[012])'))
if not res:
continue
rs = RadioSetting('SA{}'.format(group), 'Search Audio Squelch',
RadioSettingValueInteger(0, 255, res['audio']))
rs.value.set_mutable(group != 0)
grp.append(rs)
rs = RadioSetting('SB{}'.format(group), 'Search Level Squelch',
RadioSettingValueInteger(0, 255, res['level']))
rs.value.set_mutable(group != 0)
grp.append(rs)
if group != 0:
rs = RadioSetting(
'SD{}FF'.format(group), 'Search Hold',
RadioSettingValueBoolean(res['delay'] == 'FF'))
grp.append(rs)
value = float(res['delay']) if res['delay'] != 'FF' else 0
rs = RadioSetting('SD{}'.format(group), 'Search Delay (seconds)',
RadioSettingValueFloat(0, 9.9, value, 0.1, 1))
rs.value.set_mutable(group != 0)
grp.append(rs)
rs = RadioSetting('SP{}'.format(group), 'Search Pause (seconds)',
RadioSettingValueInteger(0, 99, res['pause']))
rs.value.set_mutable(group != 0)
grp.append(rs)
rs = RadioSetting('AS{}'.format(group), 'Search Auto-store',
RadioSettingValueMap(VT_MAP, int(res['auto'])))
rs.value.set_mutable(group != 0)
grp.append(rs)
res = self._command_cached('BS', 'BS ([A-Ta-t-]{40})')
for bank in self._SEARCH_BANKS:
rs = RadioSetting(
'BS{}{}'.format(group, bank), 'Bank {}'.format(bank),
RadioSettingValueBoolean(bank in res[1]))
rs.value.set_mutable(group != 0)
grp.append(rs)
self._restore_gs()
# scan bank protect
for bank in self._SCAN_BANKS[::2]:
res = self._command_read_WM(bank)
for (b, v) in list(zip((bank, bank.lower()), res)):
rs = RadioSetting(
'WM{}'.format(b), 'Scan Bank {} Protect'.format(b),
RadioSettingValueBoolean(v))
rs.set_apply_callback(
lambda x, y: self._command(
'WM{}{}'.format(y, int(x.value))), b)
scanbankprotect.append(rs)
return top
def _apply_settings_callbacks(self, settings):
for element in settings:
if not isinstance(element, RadioSetting):
self._apply_settings_callbacks(element)
elif element.changed() and element.has_apply_callback():
LOG.debug("running callback for {}".format(element))
element.run_apply_callback()
def set_settings(self, settings):
with self.LOCK:
return self._set_settings_unlocked(settings)
def _set_settings_unlocked(self, settings):
self._apply_settings_callbacks(settings)
setdict = {}
for element in settings:
if isinstance(element, RadioSettingGroup):
setdict[element.get_name()] = element
if setdict['vfo']['DDFF'].value.changed() or \
setdict['vfo']['DD'].value.changed():
if int(setdict['vfo']['DDFF'].value):
self._command('DDFF')
else:
v = int(float(setdict['vfo']['DD'].value) * 10)
self._command('DD{:02d}'.format(v))
# BM/BS flags can only be cleared or toggled, so clear all
# first, then toggle the flags which are set
for group in range(1, 10):
parent = setdict['scan']['GM{}'.format(group)]
self._command('GM{}'.format(group))
if parent['XA{}'.format(group)].value.changed():
v = int(parent['XA{}'.format(group)].value)
self._command('XA{:03d}'.format(v))
if parent['XB{}'.format(group)].value.changed():
v = int(parent['XB{}'.format(group)].value)
self._command('XB{:03d}'.format(v))
if parent['XD{}'.format(group)].value.changed():
v = int(float(parent['XD{}'.format(group)].value) * 10)
self._command('XD{:02d}'.format(v))
if parent['XP{}'.format(group)].value.changed():
v = int(parent['XP{}'.format(group)].value)
self._command('XP{:02d}'.format(v))
if parent['XM{}'.format(group)].value.changed():
v = int(parent['XM{}'.format(group)].value)
self._command('XM{:01x}'.format(v))
if any(parent['BM{}{}'.format(group, bank)].value.changed()
for bank in self._SCAN_BANKS):
v = ''
for bank in self._SCAN_BANKS:
if int(parent['BM{}{}'.format(group, bank)].value):
v += bank
self._command('BM%%')
self._command('BM{}'.format(v), 'BM [A-Ja-j-]{20}')
v = int(setdict['scan']['scan general']['GM'].value)
self._command('GM{}'.format(v))
for group in range(1, 10):
parent = setdict['search']['GS{}'.format(group)]
self._command('GS{}'.format(group))
if parent['SA{}'.format(group)].value.changed():
v = int(parent['SA{}'.format(group)].value)
self._command('SA{:03d}'.format(v))
if parent['SB{}'.format(group)].value.changed():
v = int(parent['SB{}'.format(group)].value)
self._command('SB{:03d}'.format(v))
if parent['SD{}FF'.format(group)].value.changed() or \
parent['SD{}'.format(group)].value.changed():
if int(parent['SD{}FF'.format(group)].value):
self._command('SDFF')
else:
v = int(float(parent['SD{}'.format(group)].value) * 10)
self._command('SD{:02d}'.format(v))
if parent['SP{}'.format(group)].value.changed():
v = int(parent['SP{}'.format(group)].value)
self._command('SP{:02d}'.format(v))
if parent['AS{}'.format(group)].value.changed():
v = int(parent['AS{}'.format(group)].value)
self._command('AS{}'.format(v))
if any(parent['BS{}{}'.format(group, bank)].value.changed()
for bank in self._SEARCH_BANKS):
v = ''
for bank in self._SEARCH_BANKS:
if int(parent['BS{}{}'.format(group, bank)].value):
v += bank
self._command('BS%%')
self._command('BS{}'.format(v), 'BS [A-Ta-t-]{40}')
v = int(setdict['search']['search general']['GS'].value)
self._command('GS{}'.format(v))
for n in range(1, 20):
if setdict['freq']['OL{:02d}'.format(n)].value.changed():
self._invalidate_ol_list()
for n in range(self._SCAN_MEMORIES):
self._invalidate_memory(number=n)
for bank in self._SEARCH_BANKS:
self._invalidate_memory('search', bank, None)
break
changed = False
for bank in self._SCAN_BANKS[::2]:
if setdict['scan']['MW']['MW{}'.format(bank)].value.changed():
changed = True
for b in (bank.upper(), bank.lower()):
for n in range(self._scan_bank_size(b)):
self._invalidate_memory('scan', b, n)
if changed:
self._invalidate_scan_bank_size()
chirp-20261030/chirp/drivers/baofeng_common.py 0000644 0001750 0001750 00000071172 15172631605 020156 0 ustar hibby hibby # Copyright 2016:
# * Jim Unroe KC9HI,
#
# 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 2 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
#
# 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 2 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 > 24 or start >= end:
raise errors.RadioError('Unexpected codeplug range from radio')
firmware = info[1].decode('ascii', 'replace')
if firmware not in TESTED_FIRMWARE:
LOG.warning('DM-32UV firmware %s has not been tested with this '
'driver (tested: %s)', firmware,
', '.join(TESTED_FIRMWARE))
return firmware, start, end
def _enter_program(link):
if link.xfer(b'G\x00\x00\x00\x00\x01', 0x106)[0] != ord('S'):
raise errors.RadioError('Unexpected reply to G')
link.send(b'\xFF\xFF\xFF\xFF\x0C')
if link.xfer(b'PROGRAM', 1) != b'\x06':
raise errors.RadioError('Radio refused programming mode')
link.xfer(b'\x02', 8)
if link.xfer(b'\x06', 1) != b'\x06':
raise errors.RadioError('Radio did not acknowledge')
def _scan(link, start, end, radio, status):
"""Tag of every page: ({tag: [addresses]}, [free page addresses])."""
pages = list(range(start, end + 1 - PAGE + 1, PAGE))
where = collections.defaultdict(list)
for i, addr in enumerate(pages):
tag = link.read_block(addr + PAGE - 1, 1, timeout=0.5)[0]
if 0x80 <= tag < 0xFF:
# No page tag has bit 7 set (they go up to 0x7c); a bad cable
# sets it, which would make a page look missing.
raise _garbled('Implausible page tag %02x at %06x' % (
tag, addr))
where[tag].append(addr)
status.cur = i
radio.status_fn(status)
return where, where.pop(0xFF, [])
def do_download(radio):
link = _Link(radio.pipe)
firmware, start, end = _identify(link)
LOG.info('DM-32UV firmware %s, codeplug %06x-%06x', firmware, start, end)
_enter_program(link)
status = chirp_common.Status()
status.msg = 'Scanning flash pages'
status.max = (end + 1 - start) // PAGE + len(IMAGE_TAGS)
where, _free = _scan(link, start, end, radio, status)
status.msg = 'Cloning from radio'
base = status.cur + 1
image = bytearray(b'\xFF' * (len(IMAGE_TAGS) * PAGE))
for i, tag in enumerate(IMAGE_TAGS):
if len(where.get(tag, [])) > 1:
LOG.warning('Radio has %d pages with tag %02x; using the first. '
'Upload will refuse until the radio has tidied up.',
len(where[tag]), tag)
if where.get(tag):
data = link.read_block(where[tag][0], PAGE)
image[i * PAGE:(i + 1) * PAGE] = data
status.cur = base + i
radio.status_fn(status)
radio._metadata['dm32uv_firmware'] = firmware
return memmap.MemoryMapBytes(bytes(image))
def _write_page(link, addr, data, start, end):
"""Write one whole page with W, then read it back to check it.
The protocol has no checksums and the firmware doesn't verify writes,
so anything other than an ACK and an exact read-back stops the upload.
"""
if (len(data) != PAGE or addr % PAGE or addr < start or
addr + PAGE - 1 > end or data[-1] in NEVER_WRITE):
raise errors.RadioError('Refusing unsafe write at %06x' % addr)
link.send(b'W' + struct.pack(' 1]
if dupes:
raise errors.RadioError(
'The radio has more than one page with tag %s; not writing' %
', '.join('%02x' % t for t in dupes))
status.msg = 'Cloning to radio'
base = status.cur + 1
written = 0
for i, tag in enumerate(UPLOAD_TAGS):
slot = IMAGE_TAGS.index(tag) * PAGE
want = image[slot:slot + PAGE - 1] + bytes([tag])
# A slot is in use if it holds data, or if it came from the radio
# (tag byte set) and has since been emptied, e.g. all its channels
# deleted: then the radio's page must be emptied too.
if (image[slot:slot + PAGE - 1] != b'\xFF' * (PAGE - 1) or
image[slot + PAGE - 1] == tag and where.get(tag)):
if where.get(tag):
addr = where[tag][0]
current = link.read_block(addr, PAGE)
if tag == ZONE_TAG0:
want = _follow_display(want, current, radio_zone, zones)
elif tag == 0x04:
want = bytearray(want)
want[0x80] = (want[0x80] & ~WORK_STATE_MASK & 0xFF |
current[0x80] & WORK_STATE_MASK)
want = bytes(want)
if current == want:
addr = None
elif free:
addr = free.pop(0)
else:
raise errors.RadioError('No free page left on the radio')
if addr is not None:
_write_page(link, addr, want, start, end)
written += 1
status.cur = base + i
radio.status_fn(status)
return written
# --- Tones ------------------------------------------------------------------
def _shown(name):
"""A name as CHIRP can show it: characters outside its charset as '?'."""
return ''.join(c if c in chirp_common.CHARSET_ASCII else '?'
for c in name)
def _edited(value, old):
"""The name to store for a setting that showed `old`: `old` itself,
byte for byte, unless the user changed it."""
value = str(value).strip()
return old if value == _shown(old).strip() else value
def _name_bytes(name, length):
return name.encode('latin-1', 'replace')[:length].ljust(length, b'\x00')
def _cached(method):
"""Cache a lookup on the image until the driver next changes it (see
DM32UV._forget). Callers must not modify the result."""
@functools.wraps(method)
def wrapper(self, *args):
cache = self.__dict__.setdefault('_lookups', {})
key = (method.__name__,) + args
if key not in cache:
cache[key] = method(self, *args)
return cache[key]
return wrapper
class DM32UVZone(chirp_common.NamedBank):
"""A zone on the radio; its index is the zone number minus 1.
One zone after the last existing one is offered as "New zone"; adding
a channel to it creates it (see DM32UVZoneModel)."""
def _zone(self):
return self._model._radio._zone(self.index + 1)
def get_name(self):
name = str(self._zone().name).rstrip('\x00\xFF ')
if self.index + 1 > self._model._radio._zone_count() and (
not name or not name.isprintable()):
return 'New zone'
return name
def set_name(self, name):
self._zone().name = str(name)[:16].ljust(16, '\x00')
class DM32UVZoneModel(chirp_common.MTOBankModel):
"""The radio's zones. A channel can be in several zones; the order of
channels in a zone is kept, new ones are added at the end.
Zones are numbered 1..count without gaps, so the only zone that can be
created is count + 1: it is offered as a spare, and becomes a real zone
when a channel is added to it. A last zone left empty is removed."""
def __init__(self, radio):
super().__init__(radio, 'Zones')
def get_num_mappings(self):
return min(self._radio._zone_count() + 1, ZONE_COUNT)
def get_mappings(self):
zones = []
for i in range(self.get_num_mappings()):
zone = DM32UVZone(self, '%i' % (i + 1), 'Zone %i' % (i + 1))
zone.index = i
zones.append(zone)
return zones
def add_memory_to_mapping(self, memory, bank):
z = bank.index + 1
if z > self._radio._zone_count():
self._radio._create_zone(z)
members = self._radio._zone_members(z)
if memory.number in members:
return
if len(members) >= ZONE_MEMBERS:
raise errors.RadioError('Zone %s is full (%i channels)' % (
bank.get_name(), ZONE_MEMBERS))
self._radio._set_zone_members(bank.index + 1,
members + [memory.number])
def remove_memory_from_mapping(self, memory, bank):
members = self._radio._zone_members(bank.index + 1)
if memory.number not in members:
raise Exception('Memory %i is not in zone %s' % (
memory.number, bank.get_name()))
self._radio._set_zone_members(
bank.index + 1, [m for m in members if m != memory.number])
self._radio._drop_empty_last_zone()
def get_mapping_memories(self, bank):
return [self._radio.get_memory(n)
for n in self._radio._zone_members(bank.index + 1)]
def get_memory_mappings(self, memory):
zones = []
for z in self._radio._zone_index().get(memory.number, []):
zone = DM32UVZone(self, '%i' % z, 'Zone %i' % z)
zone.index = z - 1
zones.append(zone)
return zones
@directory.register
class DM32UV(chirp_common.CloneModeRadio):
"""Baofeng DM-32UV"""
VENDOR = 'Baofeng'
MODEL = 'DM-32UV'
BAUD_RATE = 115200
_memsize = len(IMAGE_TAGS) * PAGE
@classmethod
def get_prompts(cls):
rp = chirp_common.RadioPrompts()
rp.experimental = (
'This driver is experimental. Upload writes channels, zones, '
'DMR lists, scan lists and radio settings. Passwords, encryption '
'keys and the factory calibration are left as they are on the '
'radio. A radio with a password set is refused.')
rp.pre_download = (
'Switch the radio on and connect the programming cable.\n\n'
'The radio returns to normal by itself a few seconds after '
'the download.')
rp.pre_upload = (
'Before the first upload, download from the radio and save the '
'image as a backup.\n\n'
'Upload writes only the pages that differ from the radio and '
'checks each one by reading it back. It takes about a minute '
'plus a few seconds per changed page.')
return rp
@classmethod
def detect_from_serial(cls, pipe):
"""Check that the connected radio is a DM-32UV."""
_check_model(_search(_Link(pipe)))
return cls
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.memory_bounds = (1, CH_COUNT)
rf.has_bank = True
rf.has_bank_names = True
rf.has_ctone = True
rf.has_cross = True
rf.has_rx_dtcs = True
rf.has_dtcs_polarity = True
rf.has_settings = True
rf.can_odd_split = True
rf.valid_modes = ['FM', 'NFM', 'DMR']
rf.valid_tmodes = ['', 'Tone', 'TSQL', 'DTCS', 'Cross']
rf.valid_cross_modes = ['Tone->Tone', 'DTCS->', '->DTCS', 'Tone->DTCS',
'DTCS->Tone', '->Tone', 'DTCS->DTCS']
rf.valid_duplexes = ['', '-', '+', 'split', 'off']
rf.valid_power_levels = POWER_LEVELS
rf.valid_bands = [(136000000, 174000000), (400000000, 480000000)]
rf.valid_tuning_steps = STEPS
# Frequencies are stored to 10 Hz, independent of the step.
rf.has_nostep_tuning = True
rf.valid_skips = []
rf.valid_name_length = 16
rf.valid_characters = chirp_common.CHARSET_ASCII
return rf
def sync_in(self):
try:
self._mmap = do_download(self)
except errors.RadioError:
raise
except Exception as e:
LOG.exception('Download failed')
raise errors.RadioError('Failed to download from radio: %s' % e)
self.process_mmap()
def sync_out(self):
try:
do_upload(self)
except errors.RadioError:
raise
except Exception as e:
LOG.exception('Upload failed')
raise errors.RadioError('Failed to upload to radio: %s' % e)
def process_mmap(self):
self._memobj = bitwise.parse(MEM_FORMAT, self._mmap)
self._forget()
def _forget(self):
"""Drop cached lookups; called whenever the image changes."""
self._lookups = {}
def _chan(self, number):
page, index = channel_offset(number)
return getattr(self._memobj, 'page%d' % page)[index]
def get_bank_model(self):
return DM32UVZoneModel(self)
def _zone(self, z):
page, index = zone_offset(z)
return getattr(self._memobj, 'zpage%d' % page)[index]
def _zone_count(self):
count = int(self._memobj.zone_hdr.count)
return 0 if count > ZONE_COUNT else count
def _zone_members(self, z):
if z > self._zone_count():
return [] # the spare zone, or erased flash
zone = self._zone(z)
count = min(int(zone.count), ZONE_MEMBERS)
return [int(m) for m in zone.members[0:count]
if 1 <= int(m) <= CH_COUNT]
@_cached
def _zone_index(self):
"""{channel: [zones it is in]}"""
index = collections.defaultdict(list)
for z in range(1, self._zone_count() + 1):
for m in self._zone_members(z):
if z not in index[m]:
index[m].append(z)
return dict(index)
def _set_zone_members(self, z, members):
self._forget()
zone = self._zone(z)
for i in range(ZONE_MEMBERS):
zone.members[i] = members[i] if i < len(members) else 0
zone.count = len(members)
def _create_zone(self, z):
"""Make zone z (which must be count + 1) an empty, named zone."""
if z != self._zone_count() + 1 or z > ZONE_COUNT:
raise errors.RadioError('Zones must be created in order')
self._forget()
zone = self._zone(z)
name = str(zone.name).rstrip('\x00\xFF ')
if not name or not name.isprintable():
zone.name = ('Zone %i' % z).ljust(16, '\x00')
self._set_zone_members(z, [])
self._memobj.zone_hdr.count = z
def _zone_list(self):
"""[(name, [members])] for zones 1..count."""
return [(str(self._zone(z).name).split('\x00')[0].split('\xFF')[0],
self._zone_members(z))
for z in range(1, self._zone_count() + 1)]
def _set_zone_list(self, zones, remap):
"""Rewrite zones 1..len(zones); remap = {old zone: new zone} for the
radio's current-zone pointers (a zone not in it was deleted)."""
self._forget()
old_count = self._zone_count()
for z, (name, members) in enumerate(zones, 1):
zone = self._zone(z)
if str(zone.name).split('\x00')[0].split('\xFF')[0] != name:
zone.name.set_raw(_name_bytes(name, 16))
self._set_zone_members(z, members)
for z in range(len(zones) + 1, old_count + 1):
self._zone(z).name.set_raw(b'\xFF' * 16)
self._set_zone_members(z, [])
hdr = self._memobj.zone_hdr
hdr.count = len(zones)
for zone_f, pos_f in (('a_zone', 'a_pos'), ('b_zone', 'b_pos')):
new = remap.get(int(getattr(hdr, zone_f)))
if not new:
new = 1
setattr(hdr, pos_f, 1)
setattr(hdr, zone_f, new)
members = len(zones[new - 1][1]) if zones else 0
if not 1 <= int(getattr(hdr, pos_f)) <= max(members, 1):
setattr(hdr, pos_f, 1)
def _drop_empty_last_zone(self):
count = self._zone_count()
if count > 1 and not self._zone_members(count):
self._forget()
self._zone(count).name.set_raw(b'\xFF' * 16)
self._memobj.zone_hdr.count = count - 1
def _count(self):
count = int(self._memobj.ch_count)
return 0 if count > CH_COUNT else count
# --- raw page access (DMR lists live outside the bitwise layout) ---------
def _page(self, tag):
base = IMAGE_TAGS.index(tag) * PAGE
return base, self._mmap.get(base, PAGE)
def _put(self, tag, offset, data):
base = IMAGE_TAGS.index(tag) * PAGE
assert offset + len(data) <= PAGE - 1
self._forget()
self._mmap.set(base + offset, bytes(data))
self._mmap.set(base + PAGE - 1, bytes([tag])) # the page now exists
@staticmethod
def _text(raw):
text = raw.split(b'\xFF')[0].split(b'\x00')[0]
return text.decode('latin-1')
# --- radio IDs -----------------------------------------------------------
@_cached
def _radio_ids(self):
"""[(dmr_id, name)] for radio IDs 1..count."""
_base, page = self._page(RADIOID_TAG)
count = page[0] if page[0] <= RADIOID_MAX else 0
return [(int.from_bytes(page[16 * n:16 * n + 3], 'little'),
self._text(page[16 * n + 3:16 * n + 3 + RADIOID_NAME]))
for n in range(1, count + 1)]
def _set_radio_ids(self, entries):
self._put(RADIOID_TAG, 0, bytes([len(entries)]))
for n in range(1, RADIOID_MAX + 1):
if n <= len(entries):
dmr_id, name = entries[n - 1]
rec = (dmr_id.to_bytes(3, 'little') +
_name_bytes(name, RADIOID_NAME) + b'\x00')
else:
rec = b'\x00' * 16
self._put(RADIOID_TAG, 16 * n, rec)
# --- contacts ------------------------------------------------------------
def _contact_loc(self, k):
return (CONTACT_REC_TAG0 + (k - 1) // CONTACT_PER_PAGE,
((k - 1) % CONTACT_PER_PAGE) * CONTACT_REC)
@_cached
def _contacts(self):
"""{slot: (name, dmr_id, call_type index)} for used contact slots."""
_base, index = self._page(CONTACT_INDEX_TAG)
pages = {}
contacts = {}
for k in range(1, CONTACT_MAX + 1):
if index[0x10 + (k - 1) // 8] >> ((k - 1) % 8) & 1:
continue # free slot
tag, off = self._contact_loc(k)
if tag not in pages:
pages[tag] = self._page(tag)[1]
rec = pages[tag][off:off + CONTACT_REC]
ctype = rec[0x16] - 3 if 3 <= rec[0x16] <= 5 else 0
contacts[k] = (self._text(rec[2:2 + CONTACT_NAME]),
int.from_bytes(rec[0x13:0x16], 'little'), ctype)
return contacts
def _set_contacts(self, contacts):
"""Write {slot: (name, id, type)} and rebuild the index page the way
the CPS does (0x474c00): counts, free bitmap, name- and ID-sorted
lists of (slot | call type code << 12)."""
_base, index = self._page(CONTACT_INDEX_TAG)
index = bytearray(index if index[0x10:0x74] != b'\xFF' * 100 or
index[0:2] != b'\xFF\xFF' else b'\x00' * PAGE)
for k, (name, dmr_id, ctype) in contacts.items():
tag, off = self._contact_loc(k)
old = self._page(tag)[1][off:off + CONTACT_REC]
keep = old if old != b'\xFF' * CONTACT_REC else b'\x00' * 24
name_b = _name_bytes(name, CONTACT_NAME)
if self._text(keep[2:2 + CONTACT_NAME]) == name:
name_b = keep[2:2 + CONTACT_NAME] # keep the radio's padding
rec = (keep[0:2] + name_b + b'\x00' +
dmr_id.to_bytes(3, 'little') + bytes([ctype + 3]) +
keep[0x17:0x18])
self._put(tag, off, rec)
bitmap = bytearray(b'\xFF' * 100)
for k in contacts:
bitmap[(k - 1) // 8] &= ~(1 << ((k - 1) % 8)) & 0xFF
index[0:2] = len(contacts).to_bytes(2, 'little')
groups = sum(1 for c in contacts.values() if c[2] == 1)
index[2:4] = groups.to_bytes(2, 'little')
index[4] = sum(1 for c in contacts.values() if c[2] == 2)
index[0x10:0x74] = bitmap
index[0x100:PAGE - 1] = b'\xFF' * (PAGE - 1 - 0x100)
def entry(k):
code = (contacts[k][2] + 3) << 4
return bytes([k & 0xFF, (k >> 8) & 0xF | code])
for pos, k in enumerate(sorted(contacts, key=lambda k: (
contacts[k][0].encode(), k))):
index[0x100 + 2 * pos:0x102 + 2 * pos] = entry(k)
for pos, k in enumerate(sorted(contacts, key=lambda k: (
contacts[k][1], k))):
index[0x740 + 2 * pos:0x742 + 2 * pos] = entry(k)
self._put(CONTACT_INDEX_TAG, 0, index[:PAGE - 1])
def _txc_loc(self, n):
if n < 0x800:
return TXC_TAGS[0], 2 * (n - 1)
if n in (CH_COUNT + 1, CH_COUNT + 2): # VFO A, B
return TXC_TAGS[1], 0xFFA + 2 * (n - CH_COUNT - 1)
return TXC_TAGS[1], 2 * (n & 0x7FF)
def _tx_contact(self, n):
tag, off = self._txc_loc(n)
hi, lo = self._page(tag)[1][off:off + 2]
value = (hi >> 4) << 8 | lo
return 0 if value > CONTACT_MAX else value
def _set_tx_contact(self, n, contact, digital):
tag, off = self._txc_loc(n)
hi = self._page(tag)[1][off]
hi = 0 if hi == 0xFF else hi & 0x0E
self._put(tag, off, bytes([(contact >> 8) << 4 | hi | int(digital),
contact & 0xFF]))
# --- RX group lists ------------------------------------------------------
@_cached
def _rx_groups(self):
"""{n: (name, [member IDs])} for used groups."""
_base, page = self._page(RXG_TAG)
groups = {}
for n in range(1, RXG_MAX + 1):
if page[:4] == b'\xFF' * 4 or not page[(n - 1) // 8] >> (
(n - 1) % 8) & 1:
continue
base = RXG_REC * n - 0x5C
members = [int.from_bytes(page[base + RXG_NAME + 3 * j:][:3],
'little') for j in range(RXG_MEMBERS)]
groups[n] = (self._text(page[base:base + RXG_NAME]),
[m for m in members if 0 < m <= ALL_CALL_ID])
return groups
def _set_rx_groups(self, groups):
_base, page = self._page(RXG_TAG)
head = bytearray(page[:0x10] if page[:4] != b'\xFF' * 4
else b'\x00' * 0x10)
head[0:4] = b'\x00' * 4
for n in groups:
head[(n - 1) // 8] |= 1 << ((n - 1) % 8)
self._put(RXG_TAG, 0, head)
for n in range(1, RXG_MAX + 1):
base = RXG_REC * n - 0x5C
name, members = groups.get(n, ('', []))
data = _name_bytes(name, RXG_NAME)
for j in range(RXG_MEMBERS):
m = members[j] if j < len(members) else 0
data += m.to_bytes(3, 'little')
self._put(RXG_TAG, base, data)
# --- scan lists ----------------------------------------------------------
@_cached
def _scan_lists(self):
"""[(name, [channels], options bytes +0x0c..+0x17)] for 1..count."""
_base, page = self._page(SCAN_TAG)
count = page[0] if page[0] <= SCAN_MAX else 0
lists = []
for n in range(1, count + 1):
rec = page[SCAN_REC * n - 0x38:][:SCAN_REC]
k = min(rec[0x0B], SCAN_MEMBERS)
members = [int.from_bytes(rec[0x18 + 2 * i:0x1A + 2 * i],
'little') for i in range(k)]
lists.append((self._text(rec[:SCAN_NAME]),
[m for m in members if 1 <= m <= CH_COUNT],
rec[0x0C:0x18]))
return lists
def _set_scan_lists(self, lists):
default = lists[0][2] if lists else SCAN_DEFAULT_OPTS
old_count = len(self._scan_lists())
self._put(SCAN_TAG, 0, bytes([len(lists)]))
for n in range(1, SCAN_MAX + 1):
base = SCAN_REC * n - 0x38
if n > len(lists):
if n <= old_count: # a list that was removed
self._put(SCAN_TAG, base, b'\x00' * SCAN_REC)
continue
name, members, opts = lists[n - 1]
opts = bytearray(opts if len(opts) == 12 else default)
members = members[:SCAN_MEMBERS]
designed = int.from_bytes(opts[3:5], 'little')
if members and designed not in members:
opts[3:5] = members[0].to_bytes(2, 'little')
rec = (_name_bytes(name, SCAN_NAME) +
bytes([len(members)]) + bytes(opts) +
b''.join(m.to_bytes(2, 'little') for m in members) +
b'\x00' * (2 * (SCAN_MEMBERS - len(members))))
self._put(SCAN_TAG, base, rec[:SCAN_REC])
def _remove_from_scan_lists(self, number):
lists = self._scan_lists()
new = []
for name, members, opts in lists:
members = [m for m in members if m != number]
if not members and int.from_bytes(opts[3:5], 'little') == number:
# the designed channel; the factory lists use channel 1
opts = opts[:3] + SCAN_DEFAULT_OPTS[3:5] + opts[5:]
new.append((name, members, opts))
if new != lists:
self._set_scan_lists(new)
# --- Settings tab: DMR lists ---------------------------------------------
def get_settings(self):
dmr = RadioSettingGroup('dmr', 'DMR lists')
ids = RadioSettingGroup('radio_ids', 'Radio IDs')
entries = self._radio_ids()
for n in range(1, min(len(entries) + 8, RADIOID_MAX) + 1):
dmr_id, name = entries[n - 1] if n <= len(entries) else (0, '')
ids.append(RadioSetting(
'rid_%d_id' % n, 'Radio ID %d: DMR ID (0 = unused)' % n,
RadioSettingValueInteger(0, DMR_ID_MAX,
min(dmr_id, DMR_ID_MAX))))
ids.append(RadioSetting(
'rid_%d_name' % n, 'Radio ID %d: name' % n,
RadioSettingValueString(0, RADIOID_NAME, _shown(name),
autopad=False)))
contacts = RadioSettingGroup('contacts', 'Contacts')
used = self._contacts()
free = [k for k in range(1, CONTACT_MAX + 1) if k not in used]
for k in sorted(used) + free[:10]:
name, dmr_id, ctype = used.get(k, ('', 1, 1))
contacts.append(RadioSetting(
'con_%d_name' % k, 'Contact %d: name (empty = unused)' % k,
RadioSettingValueString(0, CONTACT_NAME, _shown(name),
autopad=False)))
contacts.append(RadioSetting(
'con_%d_id' % k, 'Contact %d: DMR ID' % k,
RadioSettingValueInteger(1, ALL_CALL_ID, max(dmr_id, 1))))
contacts.append(RadioSetting(
'con_%d_type' % k, 'Contact %d: call type' % k,
RadioSettingValueList(CALL_TYPES, current_index=ctype)))
groups = RadioSettingGroup('rx_groups', 'RX group lists')
by_id = {c[1]: _shown(c[0]) for c in used.values()}
# CHIRP keeps showing this tree after later edits, so remember the
# names shown here: a member name stays valid after a rename.
self._shown_contact_ids = {_shown(c[0]): c[1] for c in used.values()}
existing = self._rx_groups()
spare = [n for n in range(1, RXG_MAX + 1) if n not in existing][:3]
for n in sorted(existing) + spare:
name, members = existing.get(n, ('', []))
groups.append(RadioSetting(
'rxg_%d_name' % n, 'RX group %d: name (empty = unused)' % n,
RadioSettingValueString(0, RXG_NAME, _shown(name),
autopad=False)))
groups.append(RadioSetting(
'rxg_%d_members' % n,
'RX group %d: contacts (names or IDs, comma separated)' % n,
RadioSettingValueString(
0, 600, ', '.join(by_id.get(m, str(m)) for m in members),
autopad=False, charset=chirp_common.CHARSET_ASCII)))
dmr.append(ids)
dmr.append(contacts)
dmr.append(groups)
scan = RadioSettingGroup('scan', 'Scan lists')
lists = self._scan_lists()
for n in range(1, min(len(lists) + 1, SCAN_MAX) + 1):
name, members, opts = lists[n - 1] if n <= len(lists) else (
'', [], bytes(12))
scan.append(RadioSetting(
'scan_%d_name' % n, 'Scan list %d: name (empty = unused)' % n,
RadioSettingValueString(0, SCAN_NAME, _shown(name),
autopad=False)))
scan.append(RadioSetting(
'scan_%d_members' % n,
'Scan list %d: channels (numbers, comma separated)' % n,
RadioSettingValueString(0, 100, ', '.join(map(str, members)),
autopad=False)))
scan.append(RadioSetting(
'scan_%d_ctc' % n, 'Scan list %d: CTC scan mode' % n,
RadioSettingValueList(SCAN_CTC_MODES, current_index=min(
opts[0] & 0xF, len(SCAN_CTC_MODES) - 1))))
scan.append(RadioSetting(
'scan_%d_tx' % n, 'Scan list %d: scan TX mode' % n,
RadioSettingValueList(SCAN_TX_MODES, current_index=min(
opts[0] >> 4, len(SCAN_TX_MODES) - 1))))
zones = RadioSettingGroup('zones', 'Zones')
zlist = self._zone_list()
zones.append(RadioSetting(
'zone_order', 'Zone order (zone numbers, comma separated; '
'reopen the image before using the Banks tab again)',
RadioSettingValueString(0, ZONE_ORDER_MAX, ', '.join(
str(z) for z in range(1, len(zlist) + 1)), autopad=False)))
for z, (name, members) in enumerate(zlist, 1):
zones.append(RadioSetting(
'zone_%d_name' % z, 'Zone %d: name' % z,
RadioSettingValueString(0, 16, _shown(name),
autopad=False)))
zones.append(RadioSetting(
'zone_%d_members' % z,
'Zone %d: channels in order (empty = delete zone)' % z,
RadioSettingValueString(0, 400, ', '.join(map(str, members)),
autopad=False)))
groups_out = [dmr, scan, zones]
if self._has_page(DTMF_TAG):
groups_out.append(self._dtmf_contacts_group())
if self._has_page(SIGNAL_TAG):
groups_out.append(self._tt_encode_group())
groups_out.append(self._ft_special_group())
radio = self._radio_settings()
if len(radio):
groups_out.insert(0, radio)
return RadioSettings(*groups_out)
def _tt_encode(self):
"""[(name, single tone, tone 1, tone 2)] of two-tone encode
entries 1..count (tones in 0.1 Hz)."""
count = int(self._memobj.tt_encode_count)
count = count if 1 <= count <= TT_ENCODE else 1 # as the CPS
out = []
for e in list(self._memobj.tt_encode)[:count]:
raw = e.name.get_raw()
name = raw.decode('utf-16-le', 'replace').split('\x00')[0]
if raw[:2] == b'\xFF\xFF':
name = ''
out.append((name, bool(e.single_tone), int(e.tone1),
int(e.tone2)))
return out
def _tt_encode_group(self):
group = RadioSettingGroup('tt_encode', 'Two-tone encode')
entries = self._tt_encode()
for n in range(1, min(len(entries) + 4, TT_ENCODE) + 1):
name, single, t1, t2 = entries[n - 1] if n <= len(entries) \
else ('', False, 0, 0)
group.append(RadioSetting(
'tte_%d_name' % n, 'Encode %d: name (empty = unused)' % n,
RadioSettingValueString(0, 16, _shown(name), autopad=False)))
group.append(RadioSetting(
'tte_%d_single' % n, 'Encode %d: send' % n,
RadioSettingValueList(['Dual Tone', 'Single Tone'],
current_index=int(single))))
for k, tone in ((1, t1), (2, t2)):
group.append(RadioSetting(
'tte_%d_tone%d' % (n, k), 'Encode %d: tone %d (Hz)' % (
n, k),
RadioSettingValueString(
0, 7, '%.1f' % (tone / 10)
if TT_HZ[0] <= tone <= TT_HZ[1] else '',
autopad=False, charset='0123456789.')))
return group
def _set_tt_encode(self, values):
old = self._tt_encode()
new = list(old)
for n in range(1, TT_ENCODE + 1):
if 'tte_%d_name' % n not in values:
continue
o = old[n - 1] if n <= len(old) else ('', False, 0, 0)
name = _edited(values['tte_%d_name' % n], o[0])
tones = []
for k in (1, 2):
text = str(values['tte_%d_tone%d' % (n, k)]).strip()
shown = '%.1f' % (o[1 + k] / 10) \
if TT_HZ[0] <= o[1 + k] <= TT_HZ[1] else ''
tones.append(o[1 + k] if text == shown else _parse_hz(
text, TT_HZ, 'Two-tone encode %d, tone %d' % (n, k)))
single = str(values['tte_%d_single' % n]) == 'Single Tone'
while len(new) < n:
new.append(('', False, 0, 0))
new[n - 1] = (name, single, tones[0], tones[1])
while len(new) > 1 and not new[-1][0]:
new.pop()
if new == old:
return
self._forget()
for n, (name, single, t1, t2) in enumerate(new, 1):
e = self._memobj.tt_encode[n - 1]
if n > len(old) or old[n - 1][0] != name:
e.name.set_raw(
name.encode('utf-16-le')[:32].ljust(32, b'\x00'))
if n > len(old) and e.get_raw()[0x20:] == b'\xFF' * 8:
e.set_raw(e.get_raw()[:0x20] + b'\xFE\xFF' + b'\xFF' * 6)
e.single_tone = int(single)
e.tone1, e.tone2 = t1, t2
for n in range(len(new) + 1, len(old) + 1):
self._memobj.tt_encode[n - 1].set_raw(b'\x00' * 0x20 +
b'\xFF' * 8)
self._memobj.tt_encode_count = len(new)
def _ft_special(self):
"""[{field: shown value}] of the 32 five-tone special calls."""
out = []
for e in self._memobj.ft_special:
types, stored = FT_SPECIAL_TYPES
t = int(e.type)
out.append({
'type': types[stored.index(t)] if t in stored else 'Off',
'code': _dtmf_text(e.code.get_raw(), CODE_CHARS['hex']),
'delimiter': FT_DELIMITERS[int(e.delimiter)]
if int(e.delimiter) < len(FT_DELIMITERS) else
FT_DELIMITERS[0],
'standard': FT_STANDARDS[int(e.standard)]
if int(e.standard) < len(FT_STANDARDS) else FT_STANDARDS[0],
'tone_long': FT_TONE_LONG[0][int(e.tone_long) - 3]
if 3 <= int(e.tone_long) < 3 + len(FT_TONE_LONG[0])
else FT_TONE_LONG[0][0],
'data': _dtmf_text(e.data.get_raw(), CODE_CHARS['hex']),
'name': self._text(e.name.get_raw()),
})
return out
def _ft_special_group(self):
group = RadioSettingGroup('ft_special', 'Five-tone special calls')
hexchars = CODE_CHARS['hex'] + CODE_CHARS['hex'].lower()
calls = self._ft_special()
used = [n for n, c in enumerate(calls, 1) if c['type'] != 'Off']
spare = [n for n in range(1, FT_SPECIAL + 1) if n not in used][:3]
for n in used + spare:
c = calls[n - 1]
label = 'Special call %d: ' % n
for key, text, value in (
('type', 'call type (Off = unused)', _pick(
FT_SPECIAL_TYPES[0], c['type'])),
('name', 'name', RadioSettingValueString(
0, 16, _shown(c['name']), autopad=False)),
('code', 'other side code', RadioSettingValueString(
0, 5, c['code'], autopad=False, charset=hexchars)),
('delimiter', 'middle delimiter', _pick(
FT_DELIMITERS, c['delimiter'])),
('standard', 'decode standard', _pick(
FT_STANDARDS, c['standard'])),
('tone_long', 'tone long', _pick(
FT_TONE_LONG[0], c['tone_long'])),
('data', 'data transmission', RadioSettingValueString(
0, 16, c['data'], autopad=False, charset=hexchars))):
group.append(RadioSetting('fts_%d_%s' % (n, key),
label + text, value))
return group
def _set_ft_special(self, values):
calls = self._ft_special()
for n in range(1, FT_SPECIAL + 1):
if 'fts_%d_type' % n not in values:
continue
c, e = calls[n - 1], self._memobj.ft_special[n - 1]
new = {k: str(values['fts_%d_%s' % (n, k)]).strip()
for k in c}
if new['name'] == _shown(c['name']).strip():
new['name'] = c['name']
for k in ('code', 'data'):
new[k] = new[k].upper()
if new == c:
continue
self._forget()
if new['type'] != c['type']:
types, stored = FT_SPECIAL_TYPES
e.type = stored[types.index(new['type'])]
if new['code'] != c['code']:
e.code.set_raw(_dtmf_bytes(new['code'], 5, CODE_CHARS['hex']))
if new['data'] != c['data']:
e.data.set_raw(_dtmf_bytes(new['data'], 16,
CODE_CHARS['hex']))
if new['name'] != c['name']:
e.name.set_raw((new['name'].encode('latin-1', 'replace')[:16]
+ b'\x00')[:16].ljust(16, b'\xFF'))
if new['delimiter'] != c['delimiter']:
e.delimiter = FT_DELIMITERS.index(new['delimiter'])
if new['standard'] != c['standard']:
e.standard = FT_STANDARDS.index(new['standard'])
if new['tone_long'] != c['tone_long']:
e.tone_long = FT_TONE_LONG[0].index(new['tone_long']) + 3
def _has_page(self, tag):
return self._page(tag)[1][:PAGE - 1] != b'\xFF' * (PAGE - 1)
def _dtmf_contacts(self):
"""[(name, number)] of DTMF (analog) contacts 1..count."""
count = int(self._memobj.dtmf_contact_count)
count = count if count <= DTMF_CONTACTS else 0
return [(self._text(c.name.get_raw()),
_dtmf_text(c.number.get_raw(), '0123456789'))
for c in list(self._memobj.dtmf_contacts)[:count]]
def _dtmf_contacts_group(self):
group = RadioSettingGroup('dtmf_contacts', 'DTMF contacts')
contacts = self._dtmf_contacts()
for n in range(1, min(len(contacts) + 4, DTMF_CONTACTS) + 1):
name, number = contacts[n - 1] if n <= len(contacts) else ('', '')
group.append(RadioSetting(
'dtc_%d_name' % n, 'DTMF contact %d: name' % n,
RadioSettingValueString(0, 16, _shown(name), autopad=False)))
group.append(RadioSetting(
'dtc_%d_number' % n, 'DTMF contact %d: number (up to 5 '
'digits)' % n,
RadioSettingValueString(0, 5, number, autopad=False,
charset='0123456789')))
return group
def _set_dtmf_contacts(self, values):
old = self._dtmf_contacts()
new = list(old)
for n in range(1, DTMF_CONTACTS + 1):
if 'dtc_%d_name' % n not in values:
continue
old_name = old[n - 1][0] if n <= len(old) else ''
name = _edited(values['dtc_%d_name' % n], old_name)
number = str(values['dtc_%d_number' % n]).strip()
while len(new) < n:
new.append(('', ''))
new[n - 1] = (name, number)
while new and not new[-1][0]:
new.pop()
for n, (name, number) in enumerate(new, 1):
if not name:
raise errors.InvalidValueError(
'DTMF contact %d: a name is needed (only the last '
'contacts can be removed)' % n)
if new == old:
return
self._forget()
for n, (name, number) in enumerate(new, 1):
c = self._memobj.dtmf_contacts[n - 1]
if n > len(old) or old[n - 1][0] != name:
c.name.set_raw(_name_bytes(name, 16))
if n > len(old) or old[n - 1][1] != number:
c.number.set_raw(_dtmf_bytes(number, 5, '0123456789'))
if n > len(old) and c.unknown.get_raw() == b'\xFF' * 11:
c.unknown.set_raw(b'\x00' * 11)
for n in range(len(new) + 1, len(old) + 1):
self._memobj.dtmf_contacts[n - 1].set_raw(b'\xFF' * 0x20)
self._memobj.dtmf_contact_count = len(new)
def _radio_settings(self):
top = RadioSettingGroup('radio', 'Radio settings')
for title, entries in RADIO_SETTINGS:
group = RadioSettingGroup('radio_%s' % title.lower().replace(
' ', '_'), title)
for sname, field, label, kind, extra in entries:
if not self._has_page(STRUCT_TAGS.get(sname, 0x04)):
continue
obj = getattr(self._memobj, sname)
name = 'set_%s_%s' % (sname, field)
if kind == 'bool':
value = RadioSettingValueBoolean(bool(getattr(obj,
field)))
elif kind == 'text':
text = str(getattr(obj, field))
text = text.split('\x00')[0].split('\xFF')[0]
text = ''.join(c for c in text
if c in chirp_common.CHARSET_ASCII)
value = RadioSettingValueString(0, extra, text,
autopad=False)
elif kind == 'coord':
value = RadioSettingValueString(
0, 12, _parse_coord(getattr(obj, field).get_raw()),
autopad=False)
elif kind == 'int':
lo, hi = extra
number = int(getattr(obj, field))
value = RadioSettingValueInteger(
lo, hi, number if lo <= number <= hi else lo)
elif kind == 'channel':
name = 'set_%s_%s_%d' % (sname, field, extra + 1)
value = self._channel_choice(
int(getattr(obj, field)[extra]))
elif kind == 'hz':
tenths = int(getattr(obj, field))
value = RadioSettingValueString(
0, 7, '%.1f' % (tenths / 10)
if extra[0] <= tenths <= extra[1] else '',
autopad=False, charset='0123456789.')
elif kind == 'dtmf':
value = RadioSettingValueString(
0, extra, _dtmf_text(getattr(obj, field).get_raw()),
autopad=False, charset=DTMF_CHARS + 'abcd')
elif kind in ('digits', 'hex'):
chars = CODE_CHARS[kind]
value = RadioSettingValueString(
0, extra, _dtmf_text(getattr(obj, field).get_raw(),
chars),
autopad=False, charset=chars + chars.lower())
else:
options, offset = extra
index = _list_index(int(getattr(obj, field)), offset)
value = RadioSettingValueList(options, current_index=(
index if 0 <= index < len(options) else 0))
group.append(RadioSetting(name, label, value))
if len(group):
top.append(group)
return top
def _channel_choice(self, value):
"""Report channel choice: the current channel, or a digital one."""
options = ['Current Channel'] + self._digital_channels()
current = 'Current Channel' if not value else '%d: %s' % (
value, self._channel_names().get(value, '(empty)'))
if current not in options:
options.append(current)
return RadioSettingValueList(options,
current_index=options.index(current))
@_cached
def _channel_names(self):
"""{number: name} of the channels in use."""
names = {}
for n in range(1, self._count() + 1):
_mem = self._chan(n)
if _mem.rxfreq.get_raw() not in (b'\xFF' * 4, b'\x00' * 4):
names[n] = _shown(str(_mem.name).rstrip('\x00\xFF '))
return names
@_cached
def _digital_channels(self):
names = self._channel_names()
return ['%d: %s' % (n, names[n]) for n in names
if self._chan(n).chtype in (1, 3)]
@staticmethod
def _set_coord(field, label, limit, text):
"""Store a coordinate typed on the Settings tab, if it changed."""
if text == _parse_coord(field.get_raw()):
return
if not text:
field.set_raw(b'\x00' * 9)
return
try:
value = float(text)
except ValueError:
value = -1
if not 0 <= value <= limit:
raise errors.InvalidValueError(
'%s must be a number from 0 to %d' % (label, limit))
field.set_raw(_format_coord(value, limit).encode())
def set_settings(self, settings):
values = {}
def walk(group):
for element in group:
if isinstance(element, RadioSetting):
values[element.get_name()] = element.value
else:
walk(element)
walk(settings)
for title, entries in RADIO_SETTINGS:
for sname, field, label, kind, extra in entries:
name = 'set_%s_%s' % (sname, field)
if kind == 'channel':
name = 'set_%s_%s_%d' % (sname, field, extra + 1)
if name not in values:
continue
obj = getattr(self._memobj, sname)
if kind == 'coord':
self._set_coord(getattr(obj, field), label, extra,
str(values[name]).strip())
elif kind == 'int':
lo, hi = extra
number = int(getattr(obj, field))
new = int(values[name])
if new != (number if lo <= number <= hi else lo):
setattr(obj, field, new)
elif kind == 'channel':
choice = str(values[name])
new = int(choice.split(':')[0]) if ':' in choice else 0
if new != int(getattr(obj, field)[extra]):
getattr(obj, field)[extra] = new
elif kind == 'bool':
setattr(obj, field, int(bool(values[name])))
elif kind == 'text':
text = str(values[name]).rstrip()
old = str(getattr(obj, field)).split('\x00')[0]
if text != old.split('\xFF')[0]:
setattr(obj, field, text[:extra].ljust(extra, '\x00'))
elif kind == 'hz':
tenths = int(getattr(obj, field))
text = str(values[name]).strip()
shown = '%.1f' % (tenths / 10) \
if extra[0] <= tenths <= extra[1] else ''
if text != shown:
setattr(obj, field, _parse_hz(text, extra, label))
elif kind in CODE_CHARS:
chars = CODE_CHARS[kind]
raw = getattr(obj, field)
text = str(values[name]).strip().upper()
if text != _dtmf_text(raw.get_raw(), chars):
if kind == 'digits':
# the CPS pads with leading zeros (0x47be70)
raw.set_raw(bytes(chars.index(c) for c in
text.rjust(extra, '0')))
else:
raw.set_raw(_dtmf_bytes(text, extra, chars))
else:
options, offset = extra
new = options.index(str(values[name]))
shown = _list_index(int(getattr(obj, field)), offset)
if not 0 <= shown < len(options):
shown = 0 # displayed as the first option
if new != shown: # don't rewrite what wasn't changed
setattr(obj, field, _list_stored(new, offset))
self._forget()
if self._has_page(DTMF_TAG):
self._set_dtmf_contacts(values)
if self._has_page(SIGNAL_TAG):
self._set_tt_encode(values)
self._set_ft_special(values)
# Radio IDs: keep the ones with an ID, in order; renumber channels.
old = self._radio_ids()
kept, remap = [], {}
for n in range(1, RADIOID_MAX + 1):
if 'rid_%d_id' % n not in values:
if n <= len(old):
kept.append(old[n - 1])
remap[n] = len(kept)
continue
dmr_id = int(values['rid_%d_id' % n])
old_id, old_name = old[n - 1] if n <= len(old) else (0, '')
if dmr_id == min(old_id, DMR_ID_MAX):
dmr_id = old_id # shown clamped, not changed
if dmr_id:
kept.append((dmr_id, _edited(values['rid_%d_name' % n],
old_name)))
remap[n] = len(kept)
if [e for e in kept] != old or any(k != v for k, v in remap.items()):
self._set_radio_ids(kept)
for number in range(1, self._count() + 1):
_mem = self._chan(number)
if int(_mem.radio_id):
_mem.radio_id = remap.get(int(_mem.radio_id), 0)
# Contacts: an empty name frees the slot.
old_contacts = self._contacts()
contacts = dict(old_contacts)
# RX group members are shown by name; accept the names shown when
# the settings were read and those from before this edit too (a
# renamed contact keeps its ID).
by_name = dict(getattr(self, '_shown_contact_ids', {}))
by_name.update({_shown(c[0]): c[1] for c in contacts.values()})
for k in range(1, CONTACT_MAX + 1):
if 'con_%d_name' % k not in values:
continue
old_name, old_id, _t = contacts.get(k, ('', 1, 0))
name = _edited(values['con_%d_name' % k], old_name)
if name:
ctype = CALL_TYPES.index(str(values['con_%d_type' % k]))
dmr_id = int(values['con_%d_id' % k])
if dmr_id == max(old_id, 1):
dmr_id = old_id # shown clamped, not changed
contacts[k] = (name, dmr_id, ctype)
else:
contacts.pop(k, None)
if contacts != old_contacts:
self._set_contacts(contacts)
for number in range(1, self._count() + 1):
if self._tx_contact(number) and \
self._tx_contact(number) not in contacts:
self._set_tx_contact(number, 0,
self._chan(number).chtype in (1, 3))
# RX groups: members by contact name or number.
by_name.update({_shown(c[0]): c[1] for c in contacts.values()})
old_groups = self._rx_groups()
groups = dict(old_groups)
for n in range(1, RXG_MAX + 1):
if 'rxg_%d_name' % n not in values:
continue
name = _edited(values['rxg_%d_name' % n],
groups.get(n, ('', []))[0])
if not name:
groups.pop(n, None)
continue
members = []
for item in str(values['rxg_%d_members' % n]).split(','):
item = item.strip()
if not item:
continue
if item in by_name:
members.append(by_name[item])
elif item.isdigit() and 0 < int(item) <= ALL_CALL_ID:
members.append(int(item))
else:
raise errors.InvalidValueError(
'RX group %s: unknown contact %r' % (name, item))
if len(members) > RXG_MEMBERS:
raise errors.InvalidValueError(
'RX group %s: at most %d contacts' % (name, RXG_MEMBERS))
groups[n] = (name, members)
if groups != old_groups:
self._set_rx_groups(groups)
# Zones: names, member order, deletion, zone order.
if 'zone_order' in values:
old = self._zone_list()
edited = {}
for z, (name, members) in enumerate(old, 1):
name = _edited(values.get('zone_%d_name' % z, _shown(name)),
name)
text = values.get('zone_%d_members' % z)
if text is not None:
members = []
for item in str(text).split(','):
item = item.strip()
if not item:
continue
if not item.isdigit() or not \
1 <= int(item) <= self._count():
raise errors.InvalidValueError(
'Zone %s: %r is not a channel in use' % (
name, item))
members.append(int(item))
if len(members) > ZONE_MEMBERS:
raise errors.InvalidValueError(
'Zone %s: at most %d channels' % (
name, ZONE_MEMBERS))
if members:
edited[z] = (name, members)
order = []
for item in str(values['zone_order']).split(','):
item = item.strip()
if not item:
continue
if not item.isdigit() or int(item) not in range(
1, len(old) + 1) or int(item) in order:
raise errors.InvalidValueError(
'Zone order: %r is not a zone number' % item)
order.append(int(item))
order = [z for z in order if z in edited] + [
z for z in edited if z not in order]
if not order:
raise errors.InvalidValueError('At least one zone must remain')
new = [edited[z] for z in order]
if new != old:
self._set_zone_list(new, {z: i for i, z in enumerate(
order, 1)})
# Scan lists: an empty name removes the list; lists stay numbered
# 1..count, so channels pointing at a later list are renumbered.
old = self._scan_lists()
new, remap = [], {}
for n in range(1, SCAN_MAX + 1):
if 'scan_%d_name' % n not in values:
if n <= len(old):
new.append(old[n - 1])
remap[n] = len(new)
continue
name = _edited(values['scan_%d_name' % n],
old[n - 1][0] if n <= len(old) else '')
if not name:
continue
members = []
for item in str(values['scan_%d_members' % n]).split(','):
item = item.strip()
if not item:
continue
if not item.isdigit() or not 1 <= int(item) <= CH_COUNT:
raise errors.InvalidValueError(
'Scan list %s: %r is not a channel number' % (
name, item))
members.append(int(item))
if len(members) > SCAN_MEMBERS:
raise errors.InvalidValueError(
'Scan list %s: at most %d channels' % (name, SCAN_MEMBERS))
opts = bytearray(old[n - 1][2] if n <= len(old) else (
old[0][2] if old else SCAN_DEFAULT_OPTS))
tx_mode = SCAN_TX_MODES.index(str(values['scan_%d_tx' % n]))
ctc_mode = SCAN_CTC_MODES.index(str(values['scan_%d_ctc' % n]))
opts[0] = tx_mode << 4 | ctc_mode
new.append((name, members, bytes(opts)))
remap[n] = len(new)
if new != old:
self._set_scan_lists(new)
for number in range(1, self._count() + 1):
_mem = self._chan(number)
if int(_mem.scanlist):
_mem.scanlist = remap.get(int(_mem.scanlist), 0)
def get_raw_memory(self, number):
return repr(self._chan(number))
def get_memory(self, number):
_mem = self._chan(number)
mem = chirp_common.Memory()
mem.number = number
rx = _mem.rxfreq.get_raw()
if number > self._count() or rx in (b'\xFF' * 4, b'\x00' * 4):
mem.empty = True
return mem
mem.freq = int(_mem.rxfreq) * 10
if _mem.txfreq.get_raw() == b'\xFF' * 4:
mem.duplex = 'off'
else:
chirp_common.split_to_offset(mem, mem.freq,
int(_mem.txfreq) * 10)
mem.name = str(_mem.name).rstrip('\x00\xFF ')
digital = _mem.chtype in (1, 3)
mem.mode = 'DMR' if digital else ('FM' if _mem.wide else 'NFM')
mem.power = POWER_LEVELS[min(int(_mem.power), 2)]
if _mem.step < len(STEPS):
mem.tuning_step = STEPS[_mem.step]
if not digital:
TONE_MODEL.get_tone(_mem, mem)
mem.extra = self._get_extra(_mem, number)
return mem
@_cached
def _dmr_names(self, kind):
"""{index: name} of the entries in one of the DMR_LISTS."""
tag, first, size, length, count = DMR_LISTS[kind]
_base, page = self._page(tag)
names = {}
for n in range(1, count + 1):
name = self._text(page[first + (n - 1) * size:][:length])
if name:
names[n] = name
return names
@_cached
def _choice_names(self, kind):
"""({index: shown name}, name of 0) for _dmr_choice."""
if kind == 'radio_id':
names = {n: '%s (%d)' % (name, dmr_id) for n, (dmr_id, name)
in enumerate(self._radio_ids(), 1)}
none = 'Default'
elif kind == 'tx_contact':
names = {k: c[0] for k, c in self._contacts().items()}
none = 'None'
elif kind == 'rxgroup':
names = {n: g[0] for n, g in self._rx_groups().items()}
none = 'None'
elif kind == 'scanlist':
names = {n: sl[0] for n, sl in enumerate(self._scan_lists(), 1)}
none = 'None'
else:
names, none = self._dmr_names(kind), 'None'
return {n: _shown(name) for n, name in names.items()}, none
def _dmr_choice(self, kind, value):
"""A RadioSettingValueList for a DMR list index (0 = none)."""
names, none = self._choice_names(kind)
options = [none] + ['%d: %s' % kv for kv in sorted(names.items())]
current = none if not value else '%d: %s' % (
value, names.get(value, '(unnamed)'))
if current not in options:
options.append(current)
return RadioSettingValueList(options,
current_index=options.index(current))
def _get_extra(self, _mem, number):
extra = RadioSettingGroup('extra', 'Extra')
extra.append(RadioSetting(
'chtype', 'Channel type',
RadioSettingValueList(CHTYPES, current_index=min(
int(_mem.chtype), len(CHTYPES) - 1))))
extra.append(RadioSetting(
'colorcode', 'Color code (DMR)',
RadioSettingValueInteger(0, 15, int(_mem.colorcode))))
extra.append(RadioSetting(
'timeslot', 'Time slot (DMR)',
RadioSettingValueList(['1', '2'],
current_index=int(_mem.timeslot))))
extra.append(RadioSetting(
'tx_contact', 'TX contact (DMR)',
self._dmr_choice('tx_contact', self._tx_contact(number))))
extra.append(RadioSetting(
'radio_id', 'Radio ID (DMR)',
self._dmr_choice('radio_id', int(_mem.radio_id))))
extra.append(RadioSetting(
'rxgroup', 'RX group list (DMR)',
self._dmr_choice('rxgroup', int(_mem.rxgroup))))
extra.append(RadioSetting(
'encrypt', 'Encryption (DMR)',
RadioSettingValueBoolean(bool(_mem.encrypt))))
extra.append(RadioSetting(
'privacy', 'Encryption key (DMR)',
self._dmr_choice('privacy', int(_mem.privacy))))
extra.append(RadioSetting(
'scanlist', 'Scan list',
self._dmr_choice('scanlist', int(_mem.scanlist))))
extra.append(RadioSetting(
'squelch', 'Squelch level',
RadioSettingValueInteger(0, 9, min(int(_mem.squelch), 9))))
extra.append(RadioSetting(
'forbid_tx', 'Forbid TX',
RadioSettingValueBoolean(bool(_mem.forbid_tx))))
extra.append(RadioSetting(
'forbid_talkaround', 'Forbid talkaround',
RadioSettingValueBoolean(bool(_mem.forbid_talkaround))))
admit = TX_ADMIT[_mem.chtype in (1, 3)]
extra.append(RadioSetting(
'tx_admit', 'TX admit',
RadioSettingValueList(admit, current_index=min(
int(_mem.tx_admit), len(admit) - 1))))
for name, (label, options) in LIST_EXTRAS.items():
extra.append(RadioSetting(
name, label, RadioSettingValueList(options, current_index=min(
int(getattr(_mem, name)), len(options) - 1))))
extra.append(RadioSetting(
'emerg_system', 'Emergency system (DMR)',
self._dmr_choice('emergency', int(_mem.emerg_system))))
for name, label in BOOL_EXTRAS:
extra.append(RadioSetting(
name, label,
RadioSettingValueBoolean(bool(getattr(_mem, name)))))
return extra
def set_memory(self, mem):
_mem = self._chan(mem.number)
if mem.empty:
_mem.set_raw(b'\xFF' * CH_SIZE)
self._update_tx_contact(mem.number, 0, False)
# Zones must not point at a channel that no longer exists.
for z in range(1, self._zone_count() + 1):
members = self._zone_members(z)
if mem.number in members:
self._set_zone_members(
z, [m for m in members if m != mem.number])
self._drop_empty_last_zone()
self._remove_from_scan_lists(mem.number)
if mem.number == self._count():
count = mem.number - 1
while count and self.get_memory(count).empty:
count -= 1
self._memobj.ch_count = count
return
if _mem.get_raw() in (b'\xFF' * CH_SIZE, b'\x00' * CH_SIZE):
# Defaults as on the channels the radio came with.
_mem.set_raw(b'\xFF' * 16 + b'\x00' * 8 + bytes.fromhex(
'0000000030000000' '00ffffffff000000' '0000000000000000'))
if mem.number > self._count():
# Channels skipped over become part of 1..count: make sure they
# are empty, not left-over template data (factory records past
# the count hold e.g. 400.000 MHz and would show up).
for gap in range(self._count() + 1, mem.number):
self._chan(gap).set_raw(b'\xFF' * CH_SIZE)
self._memobj.ch_count = mem.number
_mem.name = mem.name.ljust(16, '\x00')[:16]
_mem.rxfreq = mem.freq // 10
if mem.duplex == 'off':
_mem.txfreq.fill_raw(b'\xFF')
elif mem.duplex == 'split':
_mem.txfreq = mem.offset // 10
elif mem.duplex == '+':
_mem.txfreq = (mem.freq + mem.offset) // 10
elif mem.duplex == '-':
_mem.txfreq = (mem.freq - mem.offset) // 10
else:
_mem.txfreq = mem.freq // 10
digital = mem.mode == 'DMR'
if digital and _mem.chtype not in (1, 3):
_mem.chtype = 1
elif not digital and _mem.chtype not in (0, 2):
_mem.chtype = 0
_mem.wide = mem.mode == 'FM'
_mem.power = POWER_LEVELS.index(mem.power) if mem.power else 2
if mem.tuning_step in STEPS:
_mem.step = STEPS.index(mem.tuning_step)
TONE_MODEL.set_tone(mem, _mem)
tx_contact = self._tx_contact(mem.number)
# Values shown clamped (e.g. squelch 12 as 9) stay as they are
# unless the user changed them.
shown = {s.get_name(): str(s.value)
for s in self._get_extra(_mem, mem.number)}
for setting in mem.extra:
name = setting.get_name()
if shown.get(name) == str(setting.value):
continue
if name == 'chtype':
# Keep the analog/digital choice consistent with the mode.
value = CHTYPES.index(str(setting.value))
if (value in (1, 3)) == digital:
_mem.chtype = value
elif name == 'timeslot':
_mem.timeslot = int(str(setting.value)) - 1
elif name == 'tx_admit':
value = str(setting.value)
options = TX_ADMIT[_mem.chtype in (1, 3)]
if value not in options: # mode changed: other list
options = TX_ADMIT[_mem.chtype not in (1, 3)]
_mem.tx_admit = options.index(value)
elif name in LIST_EXTRAS:
setattr(_mem, name,
LIST_EXTRAS[name][1].index(str(setting.value)))
elif name in ('tx_contact', 'radio_id', 'rxgroup', 'privacy',
'emerg_system', 'scanlist'):
choice = str(setting.value)
value = int(choice.split(':')[0]) if ':' in choice else 0
if name == 'tx_contact':
tx_contact = value
else:
setattr(_mem, name, value)
else:
setattr(_mem, name, int(setting.value))
self._update_tx_contact(mem.number, tx_contact, _mem.chtype in (1, 3))
def _update_tx_contact(self, number, contact, digital):
"""Write the TX contact table only if something changes, so a page
the radio doesn't have isn't created for nothing."""
tag, off = self._txc_loc(number)
hi, lo = self._page(tag)[1][off:off + 2]
if (hi, lo) == (0xFF, 0xFF) and not contact:
return
if self._tx_contact(number) != contact or (hi & 1) != int(digital):
self._set_tx_contact(number, contact, digital)
chirp-20261030/chirp/drivers/baofeng_uv17.py 0000644 0001750 0001750 00000036124 15125715007 017463 0 ustar hibby hibby # Copyright 2023:
# * Sander van der Wel,
#
# 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 2 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 > 4 & 0xf) * 10 + (blocknr & 0xf)
memory_map += [blocknr]
baofeng_uv17Pro._sendmagic(radio, b"\x06", 1)
return memory_map
def _download(radio):
"""Get the memory map"""
if not radio._DETECTED_BY:
# The GA510v2 (at least) is detected, and thus has already done ident
baofeng_uv17Pro._do_ident(radio)
data = b""
memory_map = _get_memory_map(radio)
status = chirp_common.Status()
status.cur = 0
status.max = radio.MEM_TOTAL // radio.BLOCK_SIZE
status.msg = "Cloning from radio..."
radio.status_fn(status)
for block_number in radio.BLOCK_O_READ:
if block_number not in memory_map:
# Memory block not found.
LOG.error('Block %i (0x%x) not in memory map: %s',
block_number, block_number, memory_map)
raise errors.RadioError('Radio memory is corrupted. ' +
'Fix this by uploading a backup image ' +
'to the radio.')
block_index = memory_map.index(block_number) + 1
start_addr = block_index * 0x1000
for addr in range(start_addr, start_addr + 0x1000,
radio.BLOCK_SIZE):
frame = radio._make_read_frame(addr, radio.BLOCK_SIZE)
radio.pipe.log('Reading addr %04x' % addr)
baofeng_common._rawsend(radio, frame)
d = baofeng_common._rawrecv(radio, radio.BLOCK_SIZE + 5)
data += d[5:]
status.cur = len(data) // radio.BLOCK_SIZE
status.msg = "Cloning from radio..."
radio.status_fn(status)
baofeng_uv17Pro._sendmagic(radio, b"\x06", 1)
return data
def _upload(radio):
"""Upload procedure"""
baofeng_uv17Pro._do_ident(radio)
memory_map = _get_memory_map(radio)
status = chirp_common.Status()
status.cur = 0
status.max = radio.WRITE_MEM_TOTAL // radio.BLOCK_SIZE
status.msg = "Cloning to radio..."
radio.status_fn(status)
for block_number in radio.BLOCK_ORDER:
# Choose a block number if memory map is corrupt
# This can happen when the upload process was interrupted
if block_number not in memory_map:
memory_map[memory_map.index(165)] = block_number
block_index = memory_map.index(block_number) + 1
start_addr = block_index * 0x1000
data_start_addr = radio.BLOCK_ORDER.index(block_number) * 0x1000
for addr in range(start_addr, start_addr + 0x1000,
radio.BLOCK_SIZE):
# sending the data
data_addr = data_start_addr + addr - start_addr
data = radio.get_mmap()[data_addr:data_addr + radio.BLOCK_SIZE]
frame = radio._make_frame(b"W", addr, radio.BLOCK_SIZE, data)
radio.pipe.log('Sending addr %04x' % addr)
baofeng_common._rawsend(radio, frame)
# receiving the response
ack = baofeng_common._rawrecv(radio, 1)
if ack != b"\x06":
msg = "Bad ack writing block 0x%04x" % addr
raise errors.RadioError(msg)
# UI Update
status.cur = (data_addr) // radio.BLOCK_SIZE
status.msg = "Cloning to radio..."
radio.status_fn(status)
@directory.register
class UV17(baofeng_uv17Pro.UV17Pro):
"""Baofeng UV-17"""
VENDOR = "Baofeng"
MODEL = "UV-17"
download_function = _download
upload_function = _upload
MODES = ["FM", "NFM"]
BLOCK_ORDER = [16, 17, 18, 19, 24, 25, 26, 4, 6]
# Add extra read blocks (e.g. calibration block 2) to the end here:
BLOCK_O_READ = list(BLOCK_ORDER)
MEM_TOTAL = 0x9000
WRITE_MEM_TOTAL = 0x9000
BLOCK_SIZE = 0x40
BAUD_RATE = 57600
_idents = [b"PSEARCH"]
_magics = [(b"PASSSTA", 3),
(b"SYSINFO", 1),
(b"\x56\x00\x00\x0A\x0D", 13),
(b"\x06", 1),
(b"\x56\x00\x10\x0A\x0D", 13),
(b"\x06", 1),
(b"\x56\x00\x20\x0A\x0D", 13),
(b"\x06", 1)]
_magic_memsize = [(b"\x56\x00\x00\x00\x0A", 11)]
_radio_memsize = 0xffff
_magics2 = [(b"\x06", 1),
(b"\xFF\xFF\xFF\xFF\x0C\x55\x56\x31\x35\x39\x39\x39", 1),
(b"\02", 8),
(b"\x06", 1)]
_fingerprint = b"\x06" + b"UV15999"
_scode_offset = 1
_mem_positions = ()
_tri_band = False
POWER_LEVELS = [chirp_common.PowerLevel("Low", watts=1.00),
chirp_common.PowerLevel("High", watts=5.00)]
LENGTH_NAME = 11
VALID_BANDS = [baofeng_uv17Pro.UV17Pro._vhf_range,
baofeng_uv17Pro.UV17Pro._uhf_range]
SCODE_LIST = ["%s" % x for x in range(1, 16)]
SQUELCH_LIST = ["Off"] + list("123456789")
LIST_POWERON_DISPLAY_TYPE = ["Full", "Message", "Voltage"]
LIST_TIMEOUT = ["Off"] + ["%s sec" % x for x in range(15, 615, 15)]
LIST_VOICE = ["Chinese", "English"]
LIST_BACKLIGHT_TIMER = ["Always On"] + ["%s sec" % x for x in range(1, 11)]
LIST_MODE = ["Name", "Frequency"]
CHANNELS = 999
CHANNEL_DEF = """
struct channel {
lbcd rxfreq[4];
lbcd txfreq[4];
u8 unused1;
ul16 rxtone;
ul16 txtone;
u8 unknown1:1,
bcl:1,
pttid:2,
unknown2:1,
wide:1,
lowpower:1,
unknown:1;
u8 scode:4,
unknown3:3,
scan:1;
u8 unknown4;
};
"""
MEM_DEFS = """
struct channelname {
char name[11];
};
struct settings {
u8 powerondistype;
u8 unknown0[15];
char boottext1[10];
u8 unknown1[6];
char boottext2[10];
u8 unknown2[22];
u8 tot;
u8 squelch;
u8 vox;
u8 powersave: 4,
unknown3:2,
voice: 1,
voicesw: 1;
u8 backlight;
u8 beep:1,
autolock:1,
unknown4:1,
tail:1,
scanmode:2,
dtmfst:2;
u8 unknown5:1,
dualstandby:1,
roger:1,
unknown6:3,
fmenable:1,
unknown7:1;
u8 unknown8[9];
u8 unknown9:6,
chbdistype:1,
chadistype:1;
};
struct ani {
u8 unknown[5];
u8 code[5];
};
struct pttid {
u8 code[5];
};
"""
MEM_LAYOUT = """
#seekto 0x0030;
struct {
struct channel mem[252];
} mem1;
#seek 0x10;
struct {
struct channel mem[255];
} mem2;
#seek 0x10;
struct {
struct channel mem[255];
} mem3;
#seek 0x10;
struct {
struct channel mem[237];
} mem4;
#seekto 0x7000;
struct settings settings;
struct vfo {
lbcd rxfreq[4];
lbcd txfreq[4];
u8 unused1;
ul16 rxtone;
ul16 txtone;
u8 unknown1:1,
bcl:1,
pttid:2,
unknown2:1,
wide:1,
lowpower:1,
unknown:1;
u8 scode:4,
unknown3:3,
scan:1;
u8 unknown4;
};
#seekto 0x0010;
struct {
struct vfo a;
struct vfo b;
} vfo;
#seekto 0x4000;
struct channelname names1[372];
#seek 0x4;
struct channelname names2[372];
#seek 0x4;
struct channelname names3[255];
#seekto 0x8000;
struct pttid pttid[15];
struct ani ani;
"""
MEM_FORMAT = CHANNEL_DEF + MEM_DEFS + MEM_LAYOUT
def _make_frame(self, cmd, addr, length, data=""):
"""Pack the info in the header format"""
frame = struct.pack("B", length)
# add the data if set
if len(data) != 0:
frame += data
# return the data
return frame
def get_settings(self):
"""Translate the bit in the mem_struct into settings in the UI"""
_mem = self._memobj
basic = RadioSettingGroup("basic", "Basic Settings")
dtmfe = RadioSettingGroup("dtmfe", "DTMF Encode Settings")
top = RadioSettings(basic, dtmfe)
self.get_settings_common_basic(basic, _mem)
def _filter(name):
filtered = ""
for char in str(name):
if char in chirp_common.CHARSET_ASCII:
filtered += char
else:
filtered += " "
return filtered
rs = RadioSetting("settings.boottext1", "Power-On Message 1",
RadioSettingValueString(
0, 10, _filter(self._memobj.settings.boottext1)))
basic.append(rs)
rs = RadioSetting("settings.boottext2", "Power-On Message 2",
RadioSettingValueString(
0, 10, _filter(self._memobj.settings.boottext2)))
basic.append(rs)
if _mem.settings.powersave > 0x04:
val = 0x00
else:
val = _mem.settings.powersave
rs = RadioSetting("settings.powersave", "Battery Saver",
RadioSettingValueList(
LIST_SAVE, current_index=val))
basic.append(rs)
rs = RadioSetting("settings.scanmode", "Scan Mode",
RadioSettingValueList(
LIST_SCANMODE,
current_index=_mem.settings.scanmode))
basic.append(rs)
rs = RadioSetting(
"settings.dtmfst", "DTMF Sidetone",
RadioSettingValueList(
LIST_DTMFST, current_index=_mem.settings.dtmfst))
basic.append(rs)
rs = RadioSetting("settings.fmenable", "Enable FM radio",
RadioSettingValueBoolean(_mem.settings.fmenable))
basic.append(rs)
self.get_settings_common_dtmf(dtmfe, _mem)
return top
def decode_tone(self, val):
pol = "N"
mode = ""
if val in [0, 0xFFFF]:
xval = 0
elif (val & 0x8000) > 0:
mode = "DTCS"
xval = (val & 0x0f) + (val >> 4 & 0xf)\
* 10 + (val >> 8 & 0xf) * 100
if (val & 0xC000) == 0xC000:
pol = "R"
else:
mode = "Tone"
xval = int((val & 0x0f) + (val >> 4 & 0xf) * 10 +
(val >> 8 & 0xf) * 100 + (val >> 12 & 0xf)
* 1000) / 10.0
return mode, xval, pol
def _get_raw_memory(self, number):
# The flash memory contains page_numbers
# This is probably to do wear leveling on the memory
# These numbers are needed, but make the channel memory
# not continuous.
number = number - 1
if number >= 762:
_mem = self._memobj.mem4.mem[number - 762]
return _mem
if number >= 507:
_mem = self._memobj.mem3.mem[number - 507]
return _mem
if number >= 252:
_mem = self._memobj.mem2.mem[number - 252]
return _mem
_mem = self._memobj.mem1.mem[number]
return _mem
def get_raw_memory(self, number):
return repr(self._get_raw_memory(number))
def get_channel_name(self, number):
number = number - 1
if number >= 744:
_name = self._memobj.names3[number - 744]
return _name
if number >= 372:
_name = self._memobj.names2[number - 372]
return _name
_name = self._memobj.names1[number]
return _name
def get_memory(self, number):
_mem = self._get_raw_memory(number)
_nam = self.get_channel_name(number)
mem = chirp_common.Memory()
mem.number = number
self.get_memory_common(_mem, _nam.name, mem)
return mem
def encode_tone(self, memtone, mode, tone, pol):
if mode == "Tone":
xtone = '%04i' % (tone * 10)
memtone.set_value((int(xtone[0]) << 12) + (int(xtone[1]) << 8) +
(int(xtone[2]) << 4) + int(xtone[3]))
elif mode == "TSQL":
xtone = '%04i' % (tone * 10)
memtone.set_value((int(tone[0]) << 12) + (int(xtone[1]) << 8) +
(int(xtone[2]) << 4) + int(xtone[3]))
elif mode == "DTCS":
xtone = str(int(tone)).rjust(4, '0')
memtone.set_value((0x8000 + (int(xtone[0]) << 12) +
(int(xtone[1]) << 8) + (int(xtone[2]) << 4) +
int(xtone[3])))
else:
memtone.set_value(0)
if mode == "DTCS" and pol == "R":
memtone.set_value(memtone + 0x4000)
def set_memory(self, mem):
_mem = self._get_raw_memory(mem.number)
_nam = self.get_channel_name(mem.number)
if mem.empty:
_mem.set_raw(b"\xff" * 16)
return
_mem.set_raw(b"\x00" * 16)
_namelength = self.get_features().valid_name_length
_nam.name = mem.name[:_namelength].ljust(11, '\x00')
self.set_memory_common(mem, _mem)
@directory.register
class UV13Pro(UV17):
VENDOR = "Baofeng"
MODEL = "UV-13Pro"
_radio_memsize = 0x31fff
chirp-20261030/chirp/drivers/baofeng_uv17Pro.py 0000644 0001750 0001750 00000303164 15270732464 020154 0 ustar hibby hibby # Copyright 2023:
# * Sander van der Wel,
#
# 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 2 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
#
# 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
#
# 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 2 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
#
# This driver is a community effort as I don't have the radio on my hands, so
# I was only the director of the orchestra, without the players this may never
# came true, so special thanks to the following hams for their contribution:
# - Henk van der Laan, PA3CQN
# - Setting Discovery.
# - Special channels for RELAY and EMERGENCY.
# - Harold Hankins
# - Memory limits, testing & bug hunting.
# - Dmitry Milkov
# - Testing & bug hunting.
# - Many others participants in the issue page on Chirp's site.
#
# 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 2 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
#
# 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 2 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
#
# 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 2 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 not the mic connector .\n"
"4. Click OK.\n")
rp.experimental = _(
'This is experimental support for BJ-9900 '
'which is still under development.\n'
'Please ensure you have a good backup with OEM software.\n'
'Also please send in bug and enhancement requests!\n'
'You have been warned. Proceed at your own risk!')
return rp
def _read(self, addr, blocksize):
# read a single block
msg = struct.pack(">4sHH", b"READ", addr, blocksize)
LOG.debug("sending " + util.hexprint(msg))
self.pipe.write(msg)
block = self.pipe.read(blocksize)
LOG.debug("received " + util.hexprint(block))
if len(block) != blocksize:
raise errors.RadioError(
("Unable to read block at addr %04X expected"
" %i got %i bytes") % (addr, blocksize, len(block)))
return block
def _clone_in(self):
start = time.time()
data = b""
status = chirp_common.Status()
status.msg = _("Cloning from radio")
status.max = self._memsize
for addr_from, addr_to, blocksize in self._blocks:
for addr in range(addr_from, addr_to, blocksize):
data += self._read(addr, blocksize)
status.cur = len(data)
self.status_fn(status)
LOG.info("Clone completed in %i seconds" % (time.time() - start))
# This driver will accept any amount of garbage, and fails tests
# as a result. This assertion appears correct based on the file
# data matching below. However, untested as of 2024-Feb.
assert data[-2:] == b'\r\n', 'Unrecognized radio image'
return memmap.MemoryMapBytes(data)
def _write(self, addr, block):
# write a single block
msg = struct.pack(">4sHH", b"WRIE", addr, len(block)) + block
LOG.debug("sending " + util.hexprint(msg))
self.pipe.write(msg)
data = self.pipe.read(1)
LOG.debug("received " + util.hexprint(data))
if data != CMD_ACK:
raise errors.RadioError(
"Radio refused to accept block 0x%04x" % addr)
def _clone_out(self):
start = time.time()
status = chirp_common.Status()
status.msg = _("Cloning to radio")
status.max = self._memsize
pos = 0
for addr_from, addr_to, blocksize in self._blocks:
for addr in range(addr_from, addr_to, blocksize):
self._write(addr, self._mmap[pos:(pos + blocksize)])
pos += blocksize
status.cur = pos
self.status_fn(status)
LOG.info("Clone completed in %i seconds" % (time.time() - start))
def sync_in(self):
try:
self._mmap = self._clone_in()
except errors.RadioError:
raise
except Exception as e:
raise errors.RadioError("Failed to communicate with radio: %s" % e)
self.process_mmap()
def sync_out(self):
try:
self._clone_out()
except errors.RadioError:
raise
except Exception as e:
raise errors.RadioError("Failed to communicate with radio: %s" % e)
def process_mmap(self):
if len(self._mmap) == self._datsize:
self._mmap = memmap.MemoryMapBytes([
chr(int(self._mmap.get(i, 2), 16))
for i in range(0, self._datsize, 2)
if self._mmap.get(i, 2) != b"\r\n"
])
try:
self._memobj = bitwise.parse(
self.MEM_FORMAT % self._memstart, self._mmap)
except AttributeError:
# main variant have no _memstart attribute
return
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.has_bank = False
rf.has_dtcs_polarity = True
rf.has_nostep_tuning = False
rf.valid_modes = list(self.MODES)
rf.valid_tmodes = list(self.TMODES)
rf.valid_cross_modes = list(self.CROSS_MODES)
rf.valid_duplexes = list(self.DUPLEX)
rf.has_tuning_step = False
rf.valid_tuning_steps = list(self.STEPS)
rf.valid_bands = self.VALID_BANDS
rf.valid_skips = [""]
rf.valid_power_levels = self.POWER_LEVELS
rf.valid_characters = "".join(self.CHARSET)
rf.valid_name_length = 7
rf.memory_bounds = (1, 128)
rf.can_odd_split = True
rf.has_settings = False
rf.has_cross = True
rf.has_ctone = True
rf.has_rx_dtcs = True
rf.has_sub_devices = self.VARIANT == ""
return rf
def get_sub_devices(self):
return [BJ9900RadioLeft(self._mmap), BJ9900RadioRight(self._mmap)]
def get_raw_memory(self, number):
return repr(self._memobj.memory[number - 1])
def set_memory(self, mem):
_mem = self._memobj.memory[mem.number - 1]
if mem.empty:
_mem.fill_raw(b"\xff")
_mem.namelen = 0
return
_mem.rxfreq = mem.freq / 10
if mem.duplex == "split":
_mem.txfreq = mem.offset // 10
elif mem.duplex == "+":
_mem.txfreq = (mem.freq + mem.offset) // 10
elif mem.duplex == "-":
_mem.txfreq = (mem.freq - mem.offset) // 10
else:
_mem.txfreq = mem.freq // 10
_mem.namelen = len(mem.name)
_mem.name = mem.name.ljust(7)
rxmode = ""
txmode = ""
if mem.tmode == "Tone":
txmode = "Tone"
elif mem.tmode == "TSQL":
rxmode = "Tone"
txmode = "TSQL"
elif mem.tmode == "DTCS":
rxmode = "DTCSSQL"
txmode = "DTCS"
elif mem.tmode == "Cross":
txmode, rxmode = mem.cross_mode.split("->", 1)
if rxmode == "":
_mem.rxdtcs_pol = 1
_mem.is_rxdigtone = 1
_mem.rxtone = 0x3FFF
elif rxmode == "Tone":
_mem.rxdtcs_pol = 0
_mem.is_rxdigtone = 0
_mem.rxtone = int(mem.ctone * 10)
elif rxmode == "DTCSSQL":
_mem.rxdtcs_pol = 1 if mem.dtcs_polarity[1] == "R" else 0
_mem.is_rxdigtone = 1
_mem.rxtone = mem.dtcs
elif rxmode == "DTCS":
_mem.rxdtcs_pol = 1 if mem.dtcs_polarity[1] == "R" else 0
_mem.is_rxdigtone = 1
_mem.rxtone = mem.rx_dtcs
if txmode == "":
_mem.txdtcs_pol = 1
_mem.is_txdigtone = 1
_mem.txtone = 0x3FFF
elif txmode == "Tone":
_mem.txdtcs_pol = 0
_mem.is_txdigtone = 0
_mem.txtone = int(mem.rtone * 10)
elif txmode == "TSQL":
_mem.txdtcs_pol = 0
_mem.is_txdigtone = 0
_mem.txtone = int(mem.ctone * 10)
elif txmode == "DTCS":
_mem.txdtcs_pol = 1 if mem.dtcs_polarity[0] == "R" else 0
_mem.is_txdigtone = 1
_mem.txtone = mem.dtcs
if (mem.power):
_mem.power = self.POWER_LEVELS.index(mem.power)
_mem.wide = self.MODES.index(mem.mode)
# not supported yet
_mem.compandor = 0
_mem.pttid = 0
_mem.txdtmf = 0
_mem.rxdtmf = 0
_mem.spmute = 0
# set to mimic radio behaviour
_mem.unknown3 = 0
def get_memory(self, number):
_mem = self._memobj.memory[number - 1]
mem = chirp_common.Memory()
mem.number = number
if _mem.get_raw()[0] == 0xFF:
mem.empty = True
return mem
mem.freq = int(_mem.rxfreq) * 10
if int(_mem.rxfreq) == int(_mem.txfreq) or _mem.txfreq == 0xFFFFFFFF:
mem.duplex = ""
mem.offset = 0
elif abs(int(_mem.rxfreq) * 10 - int(_mem.txfreq) * 10) > 70000000:
mem.duplex = "split"
mem.offset = int(_mem.txfreq) * 10
else:
mem.duplex = int(_mem.rxfreq) > int(_mem.txfreq) and "-" or "+"
mem.offset = abs(int(_mem.rxfreq) - int(_mem.txfreq)) * 10
mem.name = str(_mem.name)[:_mem.namelen]
dtcs_pol = ["N", "N"]
if _mem.rxtone == 0x3FFF:
rxmode = ""
elif _mem.is_rxdigtone == 0:
# ctcss
rxmode = "Tone"
mem.ctone = int(_mem.rxtone) / 10.0
else:
# digital
rxmode = "DTCS"
mem.rx_dtcs = int(_mem.rxtone & 0x3FFF)
if _mem.rxdtcs_pol == 1:
dtcs_pol[1] = "R"
if _mem.txtone == 0x3FFF:
txmode = ""
elif _mem.is_txdigtone == 0:
# ctcss
txmode = "Tone"
mem.rtone = int(_mem.txtone) / 10.0
else:
# digital
txmode = "DTCS"
mem.dtcs = int(_mem.txtone & 0x3FFF)
if _mem.txdtcs_pol == 1:
dtcs_pol[0] = "R"
if txmode == "Tone" and not rxmode:
mem.tmode = "Tone"
elif txmode == rxmode and txmode == "Tone" and mem.rtone == mem.ctone:
mem.tmode = "TSQL"
elif txmode == rxmode and txmode == "DTCS" and mem.dtcs == mem.rx_dtcs:
mem.tmode = "DTCS"
elif rxmode or txmode:
mem.tmode = "Cross"
mem.cross_mode = "%s->%s" % (txmode, rxmode)
mem.dtcs_polarity = "".join(dtcs_pol)
mem.power = self.POWER_LEVELS[_mem.power]
mem.mode = self.MODES[_mem.wide]
return mem
@classmethod
def match_model(cls, filedata, filename):
return len(filedata) == cls._memsize or \
(len(filedata) == cls._datsize and filedata[-4:] == b"\r\n\r\n")
class BJ9900RadioLeft(BJ9900Radio):
"""Baojie BJ-9900 Left VFO subdevice"""
VARIANT = "Left"
_memstart = 0x0
class BJ9900RadioRight(BJ9900Radio):
"""Baojie BJ-9900 Right VFO subdevice"""
VARIANT = "Right"
_memstart = 0xC00
chirp-20261030/chirp/drivers/bjuv55.py 0000644 0001750 0001750 00000050004 14670320477 016320 0 ustar hibby hibby # Copyright 2013 Jens Jensen AF5MI
# Based on work by Jim Unroe, Dan Smith, et al.
# Special thanks to Mats SM0BTP for equipment donation.
#
# 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 2 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
#
# 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 2 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
# * Jim Unroe KC9HI,
#
# 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 2 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
#
# 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 2 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
# - Derived from ./ft1802.py Copyright 2012 Tom Hayward
#
# 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 After clicking OK , press the [MHz(SET)] key to send"
" image.\n")
rp.pre_upload = _(
"1. Turn radio off.\n"
"2. Connect cable to mic jack.\n"
"3. Press and hold in the [MHz], [LOW], and [D/MR] keys\n"
" while turning the radio on.\n"
"4. Press the [D/MR(MW)] key (\"--WAIT--\" will appear on the"
" LCD).\n")
return rp
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.memory_bounds = (0, 129)
rf.can_odd_split = False
rf.has_ctone = False
rf.has_tuning_step = True
rf.has_dtcs_polarity = False
rf.has_bank = False
rf.valid_tuning_steps = STEPS
rf.valid_modes = MODES
rf.valid_tmodes = TMODES
rf.valid_bands = [(137000000, 174000000)]
rf.valid_power_levels = POWER_LEVELS
rf.valid_duplexes = DUPLEX
rf.valid_skips = ["", "S", "P"]
rf.valid_name_length = 6
rf.valid_characters = CHARSET
rf.has_cross = False
return rf
def _checksums(self):
return [yaesu_clone.YaesuChecksum(0, self._memsize-2)]
def process_mmap(self):
self._memobj = bitwise.parse(MEM_FORMAT, self._mmap)
def get_raw_memory(self, number):
return repr(self._memobj.memory[number]) + \
repr(self._memobj.flags[number])
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 set_memory(self, mem):
_mem = self._memobj.memory[mem.number]
_flag = self._memobj.flags[mem.number]
valid = _flag["valid"]
visible = _flag["visible"]
if not mem.empty and not valid:
_flag["valid"] = True
_mem.unknown1a = 0x00
_mem.clk_shift = 0x00
_mem.unknown1b = 0x00
_mem.unknown2a = 0x00
_mem.unknown2b = 0x00
_mem.unknown3 = 0x00
_mem.unknown4a = 0x00
_mem.unknown4b = 0x00
_mem.unknown4c = 0x00
_mem.unknown4d = 0x00
_mem.unknown5a = 0x00
if mem.empty and valid and not visible:
_flag["valid"] = False
return
_flag["visible"] = not mem.empty
if mem.empty:
return
_flag["valid"] = True
_mem.freq = mem.freq / 1000
_mem.offset = mem.offset / 100000
_mem.duplex = DUPLEX.index(mem.duplex)
_mem.tune_step = STEPS.index(mem.tuning_step)
_mem.tmode = TMODES.index(mem.tmode)
_mem.tone = chirp_common.TONES.index(mem.rtone)
_mem.name = [0xFF] * 6
for i in range(0, len(mem.name)):
try:
_mem.name[i] = CHARSET.index(mem.name[i])
except IndexError:
raise Exception("Character `%s' not supported")
_mem.narrow = MODES.index(mem.mode)
_mem.power = 3 if mem.power is None else POWER_LEVELS.index(mem.power)
_flag["pskip"] = mem.skip == "P"
_flag["skip"] = mem.skip == "S"
for element in mem.extra:
setattr(_mem, element.get_name(), element.value)
chirp-20261030/chirp/drivers/ft1802.py 0000644 0001750 0001750 00000020154 14665027664 016135 0 ustar hibby hibby # Copyright 2012 Tom Hayward
#
# 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 After clicking OK , press the [MHz(SET)] key to send"
" image.\n")
rp.pre_upload = _(
"1. Turn radio off.\n"
"2. Connect cable to mic jack.\n"
"3. Press and hold in the [LOW(A/N)] key while turning the radio"
" on.\n"
"4. Press the [D/MR(MW)] key (\"--WAIT--\" will appear on the"
" LCD).\n")
return rp
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.memory_bounds = (0, 199)
rf.can_odd_split = True
rf.has_ctone = False
rf.has_tuning_step = True
rf.has_dtcs_polarity = False # in radio settings, not per memory
rf.has_bank = False # has banks, but not implemented
rf.valid_tuning_steps = STEPS
rf.valid_modes = MODES
rf.valid_tmodes = TMODES
rf.valid_bands = [(137000000, 174000000)]
rf.valid_power_levels = POWER_LEVELS
rf.valid_duplexes = DUPLEX
rf.valid_skips = ["", "S", "P"]
rf.valid_name_length = 6
rf.valid_characters = CHARSET
rf.has_cross = True
rf.valid_cross_modes = list(CROSS_MODES)
return rf
def _checksums(self):
return [yaesu_clone.YaesuChecksum(0, self._memsize-2)]
def process_mmap(self):
self._memobj = bitwise.parse(MEM_FORMAT, self._mmap)
def get_raw_memory(self, number):
return repr(self._memobj.memory[number]) + \
repr(self._memobj.flags[number/2])
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 set_memory(self, mem):
_mem = self._memobj.memory[mem.number]
_flag = self._memobj.flags[mem.number/2]
nibble = (mem.number % 2) and "odd" or "even"
valid = _flag["%s_valid" % nibble]
visible = _flag["%s_visible" % nibble]
if not mem.empty and not valid:
_flag["%s_valid" % nibble] = True
_mem.unknown1a = 0x00
_mem.clk_shift = 0x00
_mem.unknown1b = 0x00
_mem.unknown2a = 0x00
_mem.unknown2b = 0x00
_mem.unknown3 = 0x00
_mem.unknown4 = 0x00
if mem.empty and valid and not visible:
_flag["%s_valid" % nibble] = False
return
_flag["%s_visible" % nibble] = not mem.empty
if mem.empty:
return
_flag["%s_valid" % nibble] = True
_mem.freq = mem.freq / 1000
_mem.offset = mem.offset / 1000
_mem.duplex = DUPLEX.index(mem.duplex)
_mem.tune_step = STEPS.index(mem.tuning_step)
_mem.step_changed = mem.tuning_step != STEPS[0]
if mem.tmode != "Cross":
_mem.tmode = TMODES.index(mem.tmode)
else:
_mem.tmode = TMODES.index("Cross") + \
CROSS_MODES.index(mem.cross_mode)
_mem.tone = chirp_common.TONES.index(mem.rtone)
_mem.dtcs = chirp_common.DTCS_CODES.index(mem.dtcs)
_mem.name = [0xFF] * 6
for i in range(0, len(mem.name)):
try:
_mem.name[i] = CHARSET.index(mem.name[i])
except IndexError:
raise Exception("Character `%s' not supported")
if _mem.name[0] != 0xFF:
_mem.name[0] += 0x80 # show name instead of frequency
_mem.narrow = MODES.index(mem.mode)
_mem.power = 3 if mem.power is None else POWER_LEVELS.index(mem.power)
_flag["%s_pskip" % nibble] = mem.skip == "P"
_flag["%s_skip" % nibble] = mem.skip == "S"
for element in mem.extra:
setattr(_mem, element.get_name(), element.value)
chirp-20261030/chirp/drivers/ft1d.py 0000644 0001750 0001750 00000264635 15250742640 016052 0 ustar hibby hibby # Copyright 2010 Dan Smith
# Copyright 2014 Angus Ainslie
# Copyright 2023,2025 Declan Rieb
# Sections of digital settings applied from ft70.py, thus
# Copyright 2017 Nicolas Pike
#
# 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 [-+NESW]?)(?P[\d]+)[\s\.,]*"
r"(?P[\d]*)[\s\']*(?P[\d]*)")
_RX_BAUD = ("off", "1200 baud", "9600 baud")
_TX_DELAY = ("100ms", "150ms", "200ms", "250ms", "300ms",
"400ms", "500ms", "750ms", "1000ms")
_WIND_UNITS = ("m/s", "mph")
_RAIN_UNITS = ("mm", "inch")
_TEMP_UNITS = ("C", "F")
_ALT_UNITS = ("m", "ft")
_DIST_UNITS = ("km", "mile")
_POS_UNITS = ("dd.mmmm'", "dd mm'ss\"")
_SPEED_UNITS = ("km/h", "knot", "mph")
_TIME_SOURCE = ("manual", "GPS")
_TZ = ("-13:00", "-13:30", "-12:00", "-12:30", "-11:00", "-11:30",
"-10:00", "-10:30", "-09:00", "-09:30", "-08:00", "-08:30",
"-07:00", "-07:30", "-06:00", "-06:30", "-05:00", "-05:30",
"-04:00", "-04:30", "-03:00", "-03:30", "-02:00", "-02:30",
"-01:00", "-01:30", "-00:00", "-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")
_BEACON_TYPE = ("Off", "Interval", "SmartBeaconing")
_SMARTBEACON_PROFILE = ("Off", "Type 1", "Type 2", "Type 3")
_BEACON_INT = ("30s", "1m", "2m", "3m", "5m", "10m", "15m",
"20m", "30m", "60m")
_DIGI_PATHS = ("OFF", "WIDE1-1", "WIDE1-1, WIDE2-1", "Digi Path 4",
"Digi Path 5", "Digi Path 6", "Digi Path 7", "Digi Path 8")
_MSG_GROUP_NAMES = ("Message Group 1", "Message Group 2",
"Message Group 3", "Message Group 4",
"Message Group 5", "Message Group 6",
"Message Group 7", "Message Group 8")
_POSITIONS = ("GPS", "Manual Latitude/Longitude",
"Manual Latitude/Longitude", "P1", "P2", "P3", "P4",
"P5", "P6", "P7", "P8", "P9")
_FLASH = ("OFF", "2 seconds", "4 seconds", "6 seconds", "8 seconds",
"10 seconds", "20 seconds", "30 seconds", "60 seconds",
"CONTINUOUS", "every 2 seconds", "every 3 seconds",
"every 4 seconds", "every 5 seconds", "every 6 seconds",
"every 7 seconds", "every 8 seconds", "every 9 seconds",
"every 10 seconds", "every 20 seconds", "every 30 seconds",
"every 40 seconds", "every 50 seconds", "every minute",
"every 2 minutes", "every 3 minutes", "every 4 minutes",
"every 5 minutes", "every 6 minutes", "every 7 minutes",
"every 8 minutes", "every 9 minutes", "every 10 minutes")
_BEEP_SELECT = ("Off", "Key+Scan", "Key")
_SQUELCH = ["%d" % x for x in range(0, 16)]
_VOLUME = ["%d" % x for x in range(0, 33)]
_OPENING_MESSAGE = ("Off", "DC", "Message", "Normal")
_SCAN_RESUME = ["%.1fs" % (0.5 * x) for x in range(4, 21)] + \
["Busy", "Hold"]
_SCAN_RESTART = ["%.1fs" % (0.1 * x) for x in range(1, 10)] + \
["%.1fs" % (0.5 * x) for x in range(2, 21)]
_LAMP_KEY = ["Key %d sec" % x
for x in range(2, 11)] + ["Continuous", "OFF"]
_LCD_CONTRAST = ["Level %d" % x for x in range(1, 16)]
_LCD_DIMMER = ["Level %d" % x for x in range(1, 7)]
_TOT_TIME = ["Off"] + ["%.1f min" % (0.5 * x) for x in range(1, 21)]
_OFF_ON = ("Off", "On")
_VOL_MODE = ("Normal", "Auto Back")
_DTMF_MODE = ("Manual", "Auto")
_DTMF_SPEED = ("50ms", "100ms")
_DTMF_DELAY = ("50ms", "250ms", "450ms", "750ms", "1000ms")
_MY_SYMBOL = ("/[ Person", "/b Bike", "/> Car", "User selected")
_BACKTRACK_STATUS = ("Valid", "Invalid")
_NS_HEMI = ("N", "S")
_WE_HEMI = ("W", "E")
_APRS_HIGH_SPEED_MAX = 70
_MIC_GAIN = ("Level %d" % i for i in range(1, 10))
_AMS_TX_MODE = ("TX Auto", "TX DIGITAL", "TX FM")
_VW_MODE = ("On", "Off")
_DIG_POP_UP = ("Off", "2sec", "4sec", "6sec", "8sec", "10sec",
"20sec", "30sec", "60sec", "Continuous")
_STANDBY_BEEP = ("On", "Off")
_ON_OFF = ("On", "Off")
_TEMP_CF = ("Centigrade", "Fahrenheit")
_APO_SELECT = ("Off", "0.5H", "1.0H", "1.5H", "2.0H", "2.5H",
"3.0H", "3.5H", "4.0H", "4.5H", "5.0H",
"5.5H", "6.0H", "6.5H", "7.0H", "7.5H", "8.0H",
"8.5H", "9.0H", "9.5H", "10.0H", "10.5H",
"11.0H", "11.5H", "12.0H")
_MONI_TCALL = ("Monitor", "Tone-CALL")
_HOME_REV = ("Home", "Reverse")
_LOCK = ("KEY", "DIAL", "Key+Dial", "PTT", "Key+PTT", "Dial+PTT", "ALL")
_PTT_DELAY = ("Off", "20 ms", "50 ms", "100 ms", "200 ms")
_BEEP_LEVEL = ("Level %i" % i for i in range(1, 7))
_SET_MODE = ("Level %i" % i for i in range(1, 8))
_RX_SAVE = ("OFF", "0.2s", ".3s", ".4s", ".5s", ".6s",
".7s", ".8s", ".9s", "1.0s", "1.5s",
"2.0s", "2.5s", "3.0s", "3.5s", "4.0s", "4.5s",
"5.0s", "5.5s", "6.0s", "6.5s", "7.0s",
"7.5s", "8.0s", "8.5s", "9.0s", "10.0s", "15s",
"20s", "25s", "30s", "35s", "40s", "45s", "50s", "55s",
"60s")
_VFO_MODE = ("ALL", "BAND")
_VFO_SCAN_MODE = ("BAND", "ALL")
_MEMORY_SCAN_MODE = ("BAND", "ALL")
_RX_BAUD = ("off", "1200 baud", "9600 baud")
_TX_DELAY = ("100ms", "150ms", "200ms", "250ms", "300ms",
"400ms", "500ms", "750ms", "1000ms")
_WIND_UNITS = ("m/s", "mph")
_RAIN_UNITS = ("mm", "inch")
_TEMP_UNITS = ("C", "F")
_ALT_UNITS = ("m", "ft")
_DIST_UNITS = ("km", "mile")
_POS_UNITS = ("dd.mmmm'", "dd mm'ss\"")
_SPEED_UNITS = ("km/h", "knot", "mph")
_TIME_SOURCE = ("manual", "GPS")
_TZ = ("-13:00", "-13:30", "-12:00", "-12:30", "-11:00", "-11:30",
"-10:00", "-10:30", "-09:00", "-09:30", "-08:00", "-08:30",
"-07:00", "-07:30", "-06:00", "-06:30", "-05:00", "-05:30",
"-04:00", "-04:30", "-03:00", "-03:30", "-02:00", "-02:30",
"-01:00", "-01:30", "-00:00", "-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")
_BEACON_TYPE = ("Off", "Interval", "SmartBeaconing")
_SMARTBEACON_PROFILE = ("Off", "Type 1", "Type 2", "Type 3")
_BEACON_INT = ("30s", "1m", "2m", "3m", "5m", "10m", "15m",
"20m", "30m", "60m")
_DIGI_PATHS = ("OFF", "WIDE1-1", "WIDE1-1, WIDE2-1", "Digi Path 4",
"Digi Path 5", "Digi Path 6", "Digi Path 7", "Digi Path 8")
_MSG_GROUP_NAMES = ("Message Group 1", "Message Group 2",
"Message Group 3", "Message Group 4",
"Message Group 5", "Message Group 6",
"Message Group 7", "Message Group 8")
_POSITIONS = ("GPS", "Manual Latitude/Longitude",
"Manual Latitude/Longitude", "P1", "P2", "P3", "P4",
"P5", "P6", "P7", "P8", "P9")
_FLASH = ("OFF", "2 seconds", "4 seconds", "6 seconds", "8 seconds",
"10 seconds", "20 seconds", "30 seconds", "60 seconds",
"CONTINUOUS", "every 2 seconds", "every 3 seconds",
"every 4 seconds", "every 5 seconds", "every 6 seconds",
"every 7 seconds", "every 8 seconds", "every 9 seconds",
"every 10 seconds", "every 20 seconds", "every 30 seconds",
"every 40 seconds", "every 50 seconds", "every minute",
"every 2 minutes", "every 3 minutes", "every 4 minutes",
"every 5 minutes", "every 6 minutes", "every 7 minutes",
"every 8 minutes", "every 9 minutes", "every 10 minutes")
_BEEP_SELECT = ("Off", "Key+Scan", "Key")
_SQUELCH = ["%d" % x for x in range(0, 16)]
_VOLUME = ["%d" % x for x in range(0, 33)]
_DG_ID = ["%d" % x for x in range(0, 100)]
_GM_RING = ("OFF", "IN RING", "ALWAYS")
_GM_INTERVAL = ("LONG", "NORMAL", "OFF")
_MYCALL_CHR_SET = list(string.ascii_uppercase) + \
list(string.digits) + ['-', '/']
@classmethod
def match_model(cls, filedata, filename):
if filename.endswith(cls._adms_ext):
return True
else:
return super().match_model(filedata, filename)
@classmethod
def get_prompts(cls):
rp = chirp_common.RadioPrompts()
rp.pre_download = _(
"1. Turn radio off.\n"
"2. Connect cable to DATA terminal.\n"
"3. Press and hold in the [F] key while turning the radio on\n"
" (\"CLONE\" will appear on the display).\n"
"4. After clicking OK , press the [BAND] key to send"
" image.\n")
rp.pre_upload = _(
"1. Turn radio off.\n"
"2. Connect cable to DATA terminal.\n"
"3. Press and hold in the [F] key while turning the radio on\n"
" (\"CLONE\" will appear on the display).\n"
"4. Press the [Dx] key (\"-WAIT-\" will appear on the LCD).\n")
return rp
def process_mmap(self):
_mf = SETTINGS_FORMAT + MEM_FORMAT + DIGITAL_FORMAT + CHECKSUM_FORMAT
self._memobj = bitwise.parse(_mf % self._mem_params, self._mmap)
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.has_dtcs_polarity = False
rf.valid_modes = list(MODES) + ['NFM', 'DN']
rf.valid_tmodes = list(TMODES)
rf.valid_duplexes = list(DUPLEX)
rf.valid_tuning_steps = [x for x in STEPS if x]
rf.valid_bands = [(500000, 999900000)]
rf.valid_skips = SKIPS
rf.valid_power_levels = POWER_LEVELS
rf.valid_characters = "".join(CHARSET)
rf.valid_name_length = 16
rf.memory_bounds = (1, 900)
rf.can_odd_split = True
rf.has_ctone = False
rf.has_bank_names = True
rf.has_settings = True
rf.valid_special_chans = [name for s in SPECIALS for name in s[1]]
return rf
def get_raw_memory(self, number):
return "\n".join([repr(self._memobj.memory[number - 1]),
repr(self._memobj.flag[number - 1])])
def _checksums(self):
return [yaesu_clone.YaesuChecksum(0x064A, 0x06C8),
yaesu_clone.YaesuChecksum(0x06CA, 0x0748),
yaesu_clone.YaesuChecksum(0x074A, 0x07C8),
yaesu_clone.YaesuChecksum(0x07CA, 0x0848),
yaesu_clone.YaesuChecksum(0x0000, 0x1FDC9)]
@staticmethod
def _add_ff_pad(val: str, length: int) -> str:
_fill = b'\xff' if isinstance(val, bytes | bytearray) else '\xff'
return val.ljust(length, _fill)[:length]
@classmethod
def _strip_ff_pads(cls, messages):
result = []
for msg_text in messages:
result.append(str(msg_text).rstrip("\xFF"))
return result
# Called with a "memref" index to CHIRP memory (int or str)
# and optionally with a "extref" extended name.
# Find and return the corresponding memobj
# Returns:
# Corresponding radio memory object
# Corresponding radio alag structure (if any)
# index into the specific memory object structure (int) ndx
# overall index into memory & specials (int) num
# an indicator of the specific radio object structure (str)
def slotloc(self, memref, extref=None):
array = None
num = memref
ename = ""
mstr = isinstance(memref, str)
specials = ALLNAMES
extr = False
if extref is not None:
extr = extref in specials
if mstr or extr: # named special?
ename = memref
num = self.MAX_MEM_SLOT + 1
# num = -1
sname = memref if mstr else extref
# Find name of appropriate memory and index into that memory
for x in self.class_specials:
try:
ndx = x[1].index(sname)
array = x[0]
break
except Exception:
num += len(x[1])
# num -= len(x[1])
if array is None:
raise IndexError("Unknown special %s" % memref)
num += ndx
# num -= ndx
elif memref > self.MAX_MEM_SLOT: # numbered special
ename = extref
ndx = memref - (self.MAX_MEM_SLOT + 1)
# Find name of appropriate memory and index into that memory
# But assumes specials are in reverse-quantity order
for x in self.class_specials:
if ndx < len(x[1]):
array = x[0]
break
ndx -= len(x[1])
if array is None:
raise IndexError("Unknown memref number %s" % memref)
else:
array = "memory"
ndx = memref - 1
_flag = self._memobj.flag[ndx]
if array == "Skip":
_flag = self._memobj.flagskp[ndx]
elif array == "PMS":
_flag = self._memobj.flagPMS[ndx]
elif array == "Home":
_flag = None
_mem = getattr(self._memobj, array)[ndx]
return (_mem, _flag, ndx, num, array, ename)
# Build CHIRP version (mem) of radio's memory (_mem)
def get_memory(self, number):
_mem, _flag, ndx, num, array, ename = self.slotloc(number)
mem = chirp_common.Memory()
mem.number = num
if array == "Home":
mem.empty = False
mem.extd_number = ename
mem.name = self._decode_label(_mem)
mem.immutable += ["empty", "number", "extd_number", "skip"]
elif array != "memory":
mem.extd_number = ename
mem.immutable += ["name", "extd_number"]
else:
mem.name = self._decode_label(_mem)
if _flag is not None:
mem.skip = _flag.pskip and "P" or _flag.skip and "S" or ""
mem.empty = False
if not _flag.used:
mem.empty = True
if not _flag.valid:
mem.empty = True
if mem.empty:
mem.freq = 0
mem.offset = 0
mem.duplex = ""
mem.power = POWER_LEVELS[0]
mem.mode = "FM"
mem.tuning_step = STEPS[0]
else:
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 else ""
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)
self._get_mem_extra(mem, _mem)
return mem
def _get_mem_extra(self, mem, _mem):
mem.extra = RadioSettingGroup('Extra', 'extra')
ams = _mem.digmode == 1
rs = RadioSetting('ysf_ams', 'AMS mode',
RadioSettingValueBoolean(ams))
mem.extra.append(rs)
def _set_mem_extra(self, mem, _mem):
if 'ysf_ams' in mem.extra:
# We only set AMS if the memory mode is DN. If it is FM,
# then that takes precedence as "analog-only".
if mem.mode == 'DN':
orig = int(_mem.digmode)
_mem.digmode = int(mem.extra['ysf_ams'].value) and 1 or 2
LOG.debug('Changed digmode from %i to %i' % (
orig, _mem.digmode))
def _decode_label(self, mem):
charset = ''.join(CHARSET).ljust(256, '.')
return str(mem.label).rstrip("\xFF").translate(charset)
def _encode_label(self, mem):
label = "".join([chr(CHARSET.index(x))
for x in mem.name.rstrip()]).encode()
return self._add_ff_pad(label, 16)
def _encode_charsetbits(self, mem):
# We only speak English here in chirpville
return 0x0000
def _decode_power_level(self, mem):
return POWER_LEVELS[3 - mem.power]
def _encode_power_level(self, mem):
if mem.power is None:
return 3 # Choose lowest power
else:
return 3 - POWER_LEVELS.index(mem.power)
def _decode_mode(self, mem):
mode = MODES[mem.mode]
if mode == 'FM' and int(mem.digmode):
# DN mode is FM with a digital flag. Since digmode can be AMS or
# DN, either will be called 'DN' in chirp
return 'DN'
if mode == 'FM' and int(mem.mode_alt):
return 'NFM'
else:
return mode
def _encode_mode(self, mem):
mode = mem.mode
if mode == 'NFM':
# Narrow is handled by a separate flag
mode = 'FM'
elif mode == 'DN':
# DN mode is FM with a digital flag
mode = 'FM'
return MODES.index(mode)
def _get_tmode(self, mem, _mem):
mem.tmode = TMODES[_mem.tone_mode]
def _set_tmode(self, _mem, mem):
_mem.tone_mode = TMODES.index(mem.tmode)
def _set_mode(self, _mem, mem):
_mem.mode_alt = mem.mode == 'NFM'
if mem.mode == 'DN' and int(_mem.digmode) == 0:
# If we are going to DN mode, default to AMS
LOG.debug('New mode DN, setting AMS')
if 'ysf_ams' not in mem.extra:
_mem.digmode = 1
else:
# If we have the extra setting, use that, since it will be
# applied at the end of set_memory() and we want it to apply
# the right value.
mem.extra['ysf_ams'].value = True
elif mem.mode == 'FM' and int(_mem.digmode):
# If we are going back to FM, that means analog-only, so AMS
# is disabled
LOG.debug('New mode FM, disabling AMS')
_mem.digmode = 0
_mem.mode = self._encode_mode(mem)
bm = self.get_bank_model()
for bank in bm.get_memory_mappings(mem):
bm.remove_memory_from_mapping(mem, bank)
def _debank(self, mem):
bm = self.get_bank_model()
for bank in bm.get_memory_mappings(mem):
bm.remove_memory_from_mapping(mem, bank)
def validate_memory(self, mem):
# Only check the home registers for appropriate bands
msgs = super().validate_memory(mem)
ndx = mem.number - ALLNAMES.index("Home1") - self.MAX_MEM_SLOT - 1
if 10 >= ndx >= 0:
f = VALID_BANDS[ndx]
if not(f[0] < mem.freq < f[1]):
msgs.append(chirp_common.ValidationError(
"Frequency outside of band for Home%2d" %
(ndx + 1)))
return msgs
# Modify radio's memory (_mem) corresponding to CHIRP version at 'mem'
def set_memory(self, mem):
_mem, flag, ndx, num, regtype, ename = self.slotloc(mem.number,
mem.extd_number)
if mem.empty:
self._wipe_memory(_mem)
if flag is not None:
flag.used = False
return
_mem.power = self._encode_power_level(mem)
_mem.tone = chirp_common.TONES.index(mem.rtone)
self._set_tmode(_mem, mem)
_mem.dcs = chirp_common.DTCS_CODES.index(mem.dtcs)
_mem.tune_step = STEPS.index(mem.tuning_step)
# duplex "off" is equivalent to "" and may show up in tox test.
if mem.duplex is None:
_mem.duplex = DUPLEX.index("")
else:
_mem.duplex = DUPLEX.index(mem.duplex)
self._set_mode(_mem, mem)
if flag is not None:
if mem.freq < 30000000 or \
(mem.freq > 88000000 and mem.freq < 108000000) or \
mem.freq > 580000000:
flag.nosubvfo = True # Masked from VFO B
else:
flag.nosubvfo = False # Available in both VFOs
if regtype != "Home":
self._debank(mem)
ndx = num - 1
flag.used = not mem.empty
flag.valid = True
flag.skip = mem.skip == "S"
flag.pskip = mem.skip == "P"
freq = mem.freq
_mem.freq = int(freq / 1000)
_mem.offset = int(mem.offset / 1000)
_mem.label = self._encode_label(mem)
_mem.charsetbits = self._encode_charsetbits(mem)
self._set_mem_extra(mem, _mem)
return
@classmethod
def _wipe_memory(cls, mem):
mem.set_raw("\x00" * (mem.size() // 8))
mem.unknown1 = 0x05
def get_bank_model(self):
return FT1BankModel(self)
@classmethod
def _digi_path_to_str(cls, path):
path_cmp = []
for entry in path.entry:
callsign = str(entry.callsign).rstrip("\xFF")
if not callsign:
break
path_cmp.append("%s-%d" % (callsign, entry.ssid))
return ",".join(path_cmp)
@staticmethod
def _latlong_sanity(sign, l_d, l_m, l_s, is_lat):
if sign not in (0, 1):
sign = 0
if is_lat:
d_max = 90
else:
d_max = 180
if l_d < 0 or l_d > d_max:
l_d = 0
l_m = 0
l_s = 0
if l_m < 0 or l_m > 60:
l_m = 0
l_s = 0
if l_s < 0 or l_s > 60:
l_s = 0
return sign, l_d, l_m, l_s
@classmethod
def _latlong_to_str(cls, sign, l_d, l_m, l_s, is_lat, to_sexigesimal=True):
sign, l_d, l_m, l_s = cls._latlong_sanity(sign, l_d, l_m, l_s, is_lat)
mult = sign and -1 or 1
if to_sexigesimal:
return "%d,%d'%d\"" % (mult * l_d, l_m, l_s)
return "%0.5f" % (mult * l_d + (l_m / 60.0) + (l_s / (60.0 * 60.0)))
@classmethod
def _str_to_latlong(cls, lat_long, is_lat):
sign = 0
result = [0, 0, 0]
lat_long = lat_long.strip()
if not lat_long:
return 1, 0, 0, 0
try:
# DD.MMMMM is the simple case, try that first.
val = float(lat_long)
if val < 0:
sign = 1
val = abs(val)
result[0] = int(val)
result[1] = int(val * 60) % 60
result[2] = int(val * 3600) % 60
except ValueError:
# Try DD MM'SS" if DD.MMMMM failed.
match = cls._SG_RE.match(lat_long.strip())
if match:
if match.group("sign") and (match.group("sign") in "SE-"):
sign = 1
else:
sign = 0
if match.group("d"):
result[0] = int(match.group("d"))
if match.group("m"):
result[1] = int(match.group("m"))
if match.group("s"):
result[2] = int(match.group("s"))
elif len(lat_long) > 4:
raise Exception("Lat/Long should be DD MM'SS\" or DD.MMMMM")
return cls._latlong_sanity(sign, result[0], result[1], result[2],
is_lat)
def _get_aprs_settings(self):
menu = RadioSettingGroup("aprs_top", "APRS")
menu.append(self._get_aprs_general_settings())
menu.append(self._get_aprs_rx_settings())
menu.append(self._get_aprs_tx_settings())
menu.append(self._get_aprs_smartbeacon())
menu.append(self._get_aprs_msgs())
menu.append(self._get_aprs_beacons())
return menu
def _get_aprs_general_settings(self):
menu = RadioSettingGroup("aprs_general", "APRS General")
aprs = self._memobj.aprs
val = RadioSettingValueString(
0, 6, str(aprs.my_callsign.callsign).rstrip("\xFF"))
rs = RadioSetting("aprs.my_callsign.callsign", "My Callsign", val)
rs.set_apply_callback(self.apply_callsign, aprs.my_callsign)
menu.append(rs)
val = RadioSettingValueList(
chirp_common.APRS_SSID,
current_index=aprs.my_callsign.ssid)
rs = RadioSetting("aprs.my_callsign.ssid", "My SSID", val)
menu.append(rs)
val = RadioSettingValueList(self._MY_SYMBOL,
current_index=aprs.selected_my_symbol)
rs = RadioSetting("aprs.selected_my_symbol", "My Symbol", val)
menu.append(rs)
symbols = list(chirp_common.APRS_SYMBOLS)
selected = aprs.custom_symbol
if aprs.custom_symbol >= len(chirp_common.APRS_SYMBOLS):
symbols.append("%d" % aprs.custom_symbol)
selected = len(symbols) - 1
val = RadioSettingValueList(symbols, current_index=selected)
rs = RadioSetting("aprs.custom_symbol_text", "User Selected Symbol",
val)
rs.set_apply_callback(self.apply_custom_symbol, aprs)
menu.append(rs)
val = RadioSettingValueList(
chirp_common.APRS_POSITION_COMMENT,
current_index=aprs.selected_position_comment)
rs = RadioSetting("aprs.selected_position_comment", "Position Comment",
val)
menu.append(rs)
latitude = self._latlong_to_str(aprs.latitude_sign,
aprs.latitude_degree,
aprs.latitude_minute,
aprs.latitude_second,
True, aprs.aprs_units_position_mmss)
longitude = self._latlong_to_str(aprs.longitude_sign,
aprs.longitude_degree,
aprs.longitude_minute,
aprs.longitude_second,
False, aprs.aprs_units_position_mmss)
# TODO: Rebuild this when aprs_units_position_mmss changes.
# TODO: Rebuild this when latitude/longitude change.
# TODO: Add saved positions p1 - p10 to memory map.
position_str = list(self._POSITIONS)
# position_str[1] = "%s %s" % (latitude, longitude)
# position_str[2] = "%s %s" % (latitude, longitude)
val = RadioSettingValueList(position_str,
current_index=aprs.selected_position)
rs = RadioSetting("aprs.selected_position", "My Position", val)
menu.append(rs)
val = RadioSettingValueString(0, 10, latitude)
rs = RadioSetting("latitude", "Manual Latitude", val)
rs.set_apply_callback(self.apply_lat_long, aprs)
menu.append(rs)
val = RadioSettingValueString(0, 11, longitude)
rs = RadioSetting("longitude", "Manual Longitude", val)
rs.set_apply_callback(self.apply_lat_long, aprs)
menu.append(rs)
val = RadioSettingValueList(
self._TIME_SOURCE, current_index=aprs.set_time_manually)
rs = RadioSetting("aprs.set_time_manually", "Time Source", val)
menu.append(rs)
val = RadioSettingValueList(self._TZ, current_index=aprs.timezone)
rs = RadioSetting("aprs.timezone", "Timezone", val)
menu.append(rs)
val = RadioSettingValueList(self._SPEED_UNITS,
current_index=aprs.aprs_units_speed)
rs = RadioSetting("aprs.aprs_units_speed", "APRS Speed Units", val)
menu.append(rs)
val = RadioSettingValueList(self._SPEED_UNITS,
current_index=aprs.gps_units_speed)
rs = RadioSetting("aprs.gps_units_speed", "GPS Speed Units", val)
menu.append(rs)
val = RadioSettingValueList(
self._ALT_UNITS, current_index=aprs.aprs_units_altitude_ft)
rs = RadioSetting("aprs.aprs_units_altitude_ft", "APRS Altitude Units",
val)
menu.append(rs)
val = RadioSettingValueList(
self._ALT_UNITS, current_index=aprs.gps_units_altitude_ft)
rs = RadioSetting("aprs.gps_units_altitude_ft", "GPS Altitude Units",
val)
menu.append(rs)
val = RadioSettingValueList(
self._POS_UNITS, current_index=aprs.aprs_units_position_mmss)
rs = RadioSetting("aprs.aprs_units_position_mmss",
"APRS Position Format", val)
menu.append(rs)
val = RadioSettingValueList(
self._POS_UNITS, current_index=aprs.gps_units_position_sss)
rs = RadioSetting("aprs.gps_units_position_sss",
"GPS Position Format", val)
menu.append(rs)
val = RadioSettingValueList(
self._DIST_UNITS, current_index=aprs.aprs_units_distance_m)
rs = RadioSetting("aprs.aprs_units_distance_m", "APRS Distance Units",
val)
menu.append(rs)
val = RadioSettingValueList(self._WIND_UNITS,
current_index=aprs.aprs_units_wind_mph)
rs = RadioSetting("aprs.aprs_units_wind_mph", "APRS Wind Speed Units",
val)
menu.append(rs)
val = RadioSettingValueList(
self._RAIN_UNITS, current_index=aprs.aprs_units_rain_inch)
rs = RadioSetting("aprs.aprs_units_rain_inch", "APRS Rain Units", val)
menu.append(rs)
val = RadioSettingValueList(
self._TEMP_UNITS, current_index=aprs.aprs_units_temperature_f)
rs = RadioSetting("aprs.aprs_units_temperature_f",
"APRS Temperature Units", val)
menu.append(rs)
return menu
def _get_aprs_msgs(self):
menu = RadioSettingGroup("aprs_msg", "APRS Messages")
aprs_msg = self._memobj.aprs_message_pkt
for index in range(0, 60):
if aprs_msg[index].flag != 255:
astring = bitwise.get_string(aprs_msg[index].dst_callsign)\
.partition("\xFF")[0]
val = RadioSettingValueString(
0, 9, chirp_common.sanitize_string(astring) +
"-%d" % aprs_msg[index].dst_callsign_ssid)
val.set_mutable(False)
rs = RadioSetting(
"aprs_msg.dst_callsign%d" % index,
"Dst Callsign %d" % index, val)
menu.append(rs)
astring = bitwise.get_string(aprs_msg[index].path_and_body)\
.partition("\xFF")[0]
val = RadioSettingValueString(
0, 66, chirp_common.sanitize_string(astring))
val.set_mutable(False)
rs = RadioSetting(
"aprs_msg.path_and_body%d" % index, "Body", val)
menu.append(rs)
return menu
def _get_aprs_beacons(self):
menu = RadioSettingGroup("aprs_beacons", "APRS Beacons")
aprs_beacon = self._memobj.aprs_beacon_pkt
aprs_meta = self._memobj.aprs_beacon_meta
for index in range(0, 60):
# There is probably a more pythonesque way to do this
scl = int(aprs_meta[index].sender_callsign[0])
dcl = int(aprs_beacon[index].dst_callsign[0])
if scl not in (255, 0): # ignore if empty send call
_c = chirp_common.sanitize_string(
bitwise.get_string(aprs_meta[index].sender_callsign))
val = RadioSettingValueString(0, 9, _c)
val.set_mutable(False)
rs = RadioSetting(
"aprs_beacon.src_callsign%d" % index,
"SRC Callsign %d" % index, val)
menu.append(rs)
if dcl not in (255, 0): # ignore if empty dest call
val = chirp_common.sanitize_string(
bitwise.get_string(aprs_beacon[index].dst_callsign))
val = RadioSettingValueString(0, 9, val)
val.set_mutable(False)
rs = RadioSetting(
"aprs_beacon.dst_callsign%d" % index,
"DST Callsign %d" % index, val)
menu.append(rs)
date = "%02d/%02d/%02d" % (
aprs_meta[index].date[0],
aprs_meta[index].date[1],
aprs_meta[index].date[2])
val = RadioSettingValueString(0, 8, date)
val.set_mutable(False)
rs = RadioSetting("aprs_beacon.date%d" % index, "Date", val)
menu.append(rs)
time = "%02d:%02d" % (
aprs_meta[index].time[0],
aprs_meta[index].time[1])
val = RadioSettingValueString(0, 5, time)
val.set_mutable(False)
rs = RadioSetting("aprs_beacon.time%d" % index, "Time", val)
menu.append(rs)
if dcl not in (255, 0): # ignore if empty dest call
path = bitwise.get_string(aprs_beacon[index].path)\
.replace("\x00", " ")
path = chirp_common.sanitize_string(str(path).strip()
.replace("\xE0", "*"))
val = RadioSettingValueString(0, 32, path)
val.set_mutable(False)
rs = RadioSetting(
"aprs_beacon.path%d" % index, "Digipath", val)
menu.append(rs)
body = bitwise.get_string(aprs_beacon[index].body)\
.rstrip("\xFF")
# checksum = body[-2:]
body = chirp_common.sanitize_string(body)
try:
val = RadioSettingValueString(0, 134, body.strip())
except Exception as e:
LOG.error("Error in APRS beacon at index %s", index)
raise e
val.set_mutable(False)
rs = RadioSetting("aprs_beacon.body%d" % index, "Body", val)
menu.append(rs)
return menu
def _get_aprs_rx_settings(self):
menu = RadioSettingGroup("aprs_rx", "APRS Receive")
aprs = self._memobj.aprs
val = RadioSettingValueList(self._RX_BAUD, current_index=aprs.rx_baud)
rs = RadioSetting("aprs.rx_baud", "Modem RX", val)
menu.append(rs)
val = RadioSettingValueBoolean(aprs.aprs_mute)
rs = RadioSetting("aprs.aprs_mute", "APRS Mute", val)
menu.append(rs)
if self._has_af_dual:
val = RadioSettingValueBoolean(aprs.af_dual)
rs = RadioSetting("aprs.af_dual", "AF Dual", val)
menu.append(rs)
val = RadioSettingValueBoolean(aprs.ring_msg)
rs = RadioSetting("aprs.ring_msg", "Ring on Message RX", val)
menu.append(rs)
val = RadioSettingValueBoolean(aprs.ring_beacon)
rs = RadioSetting("aprs.ring_beacon", "Ring on Beacon RX", val)
menu.append(rs)
val = RadioSettingValueList(self._FLASH,
current_index=aprs.flash_msg)
rs = RadioSetting("aprs.flash_msg", "Flash on personal message", val)
menu.append(rs)
if self._has_vibrate:
val = RadioSettingValueList(self._FLASH,
current_index=aprs.vibrate_msg)
rs = RadioSetting("aprs.vibrate_msg",
"Vibrate on personal message", val)
menu.append(rs)
val = RadioSettingValueList(self._FLASH[:10],
current_index=aprs.flash_bln)
rs = RadioSetting("aprs.flash_bln", "Flash on bulletin message", val)
menu.append(rs)
if self._has_vibrate:
val = RadioSettingValueList(self._FLASH[:10],
current_index=aprs.vibrate_bln)
rs = RadioSetting("aprs.vibrate_bln",
"Vibrate on bulletin message", val)
menu.append(rs)
val = RadioSettingValueList(self._FLASH[:10],
current_index=aprs.flash_grp)
rs = RadioSetting("aprs.flash_grp", "Flash on group message", val)
menu.append(rs)
if self._has_vibrate:
val = RadioSettingValueList(self._FLASH[:10],
current_index=aprs.vibrate_grp)
rs = RadioSetting("aprs.vibrate_grp",
"Vibrate on group message", val)
menu.append(rs)
filter_val = [m.padded_string for m in aprs.msg_group]
filter_val = self._strip_ff_pads(filter_val)
for index, filter_text in enumerate(filter_val):
val = RadioSettingValueString(0, 9, filter_text)
rs = RadioSetting("aprs.msg_group_%d" % index,
"Message Group %d" % (index + 1), val)
menu.append(rs)
rs.set_apply_callback(self.apply_ff_padded_string,
aprs.msg_group[index])
# TODO: Use filter_val as the list entries and update it on edit.
val = RadioSettingValueList(
self._MSG_GROUP_NAMES,
current_index=aprs.selected_msg_group)
rs = RadioSetting("aprs.selected_msg_group", "Selected Message Group",
val)
menu.append(rs)
val = RadioSettingValueBoolean(aprs.filter_mic_e)
rs = RadioSetting("aprs.filter_mic_e", "Receive Mic-E Beacons", val)
menu.append(rs)
val = RadioSettingValueBoolean(aprs.filter_position)
rs = RadioSetting("aprs.filter_position", "Receive Position Beacons",
val)
menu.append(rs)
val = RadioSettingValueBoolean(aprs.filter_weather)
rs = RadioSetting("aprs.filter_weather", "Receive Weather Beacons",
val)
menu.append(rs)
val = RadioSettingValueBoolean(aprs.filter_object)
rs = RadioSetting("aprs.filter_object", "Receive Object Beacons", val)
menu.append(rs)
val = RadioSettingValueBoolean(aprs.filter_item)
rs = RadioSetting("aprs.filter_item", "Receive Item Beacons", val)
menu.append(rs)
val = RadioSettingValueBoolean(aprs.filter_status)
rs = RadioSetting("aprs.filter_status", "Receive Status Beacons", val)
menu.append(rs)
val = RadioSettingValueBoolean(aprs.filter_other)
rs = RadioSetting("aprs.filter_other", "Receive Other Beacons", val)
menu.append(rs)
return menu
def _get_aprs_tx_settings(self):
menu = RadioSettingGroup("aprs_tx", "APRS Transmit")
aprs = self._memobj.aprs
beacon_type = (aprs.tx_smartbeacon << 1) | aprs.tx_interval_beacon
val = RadioSettingValueList(self._BEACON_TYPE,
current_index=beacon_type)
rs = RadioSetting("aprs.transmit", "TX Beacons", val)
rs.set_apply_callback(self.apply_beacon_type, aprs)
menu.append(rs)
val = RadioSettingValueList(self._TX_DELAY,
current_index=aprs.tx_delay)
rs = RadioSetting("aprs.tx_delay", "TX Delay", val)
menu.append(rs)
val = RadioSettingValueList(self._BEACON_INT,
current_index=aprs.beacon_interval)
rs = RadioSetting("aprs.beacon_interval", "Beacon Interval", val)
menu.append(rs)
desc = []
status = [m.padded_string for m in self._memobj.aprs_beacon_status_txt]
status = self._strip_ff_pads(status)
for index, msg_text in enumerate(status):
val = RadioSettingValueString(0, 60, msg_text)
desc.append("Beacon Status Text %d" % (index + 1))
rs = RadioSetting("aprs_beacon_status_txt_%d" % index, desc[-1],
val)
rs.set_apply_callback(self.apply_ff_padded_string,
self._memobj.aprs_beacon_status_txt[index])
menu.append(rs)
val = RadioSettingValueList(
desc, current_index=aprs.selected_beacon_status_txt)
rs = RadioSetting("aprs.selected_beacon_status_txt",
"Beacon Status Text", val)
menu.append(rs)
message_macro = [m.padded_string for m in aprs.message_macro]
message_macro = self._strip_ff_pads(message_macro)
for index, msg_text in enumerate(message_macro):
val = RadioSettingValueString(0, 16, msg_text)
rs = RadioSetting("aprs.message_macro_%d" % index,
"Message Macro %d" % (index + 1), val)
rs.set_apply_callback(self.apply_ff_padded_string,
aprs.message_macro[index])
menu.append(rs)
path_str = list(self._DIGI_PATHS)
path_str[3] = self._digi_path_to_str(aprs.digi_path_3_6[0])
val = RadioSettingValueString(0, 22, path_str[3])
rs = RadioSetting("aprs.digi_path_3", "Digi Path 4 (2 entries)", val)
rs.set_apply_callback(self.apply_digi_path, aprs.digi_path_3_6[0])
menu.append(rs)
path_str[4] = self._digi_path_to_str(aprs.digi_path_3_6[1])
val = RadioSettingValueString(0, 22, path_str[4])
rs = RadioSetting("aprs.digi_path_4", "Digi Path 5 (2 entries)", val)
rs.set_apply_callback(self.apply_digi_path, aprs.digi_path_3_6[1])
menu.append(rs)
path_str[5] = self._digi_path_to_str(aprs.digi_path_3_6[2])
val = RadioSettingValueString(0, 22, path_str[5])
rs = RadioSetting("aprs.digi_path_5", "Digi Path 6 (2 entries)", val)
rs.set_apply_callback(self.apply_digi_path, aprs.digi_path_3_6[2])
menu.append(rs)
path_str[6] = self._digi_path_to_str(aprs.digi_path_3_6[3])
val = RadioSettingValueString(0, 22, path_str[6])
rs = RadioSetting("aprs.digi_path_6", "Digi Path 7 (2 entries)", val)
rs.set_apply_callback(self.apply_digi_path, aprs.digi_path_3_6[3])
menu.append(rs)
path_str[7] = self._digi_path_to_str(aprs.digi_path_7)
val = RadioSettingValueString(0, 88, path_str[7])
rs = RadioSetting("aprs.digi_path_7", "Digi Path 8 (8 entries)", val)
rs.set_apply_callback(self.apply_digi_path, aprs.digi_path_7)
menu.append(rs)
# Show friendly messages for empty slots rather than blanks.
# TODO: Rebuild this when digi_path_[34567] change.
# path_str[3] = path_str[3] or self._DIGI_PATHS[3]
# path_str[4] = path_str[4] or self._DIGI_PATHS[4]
# path_str[5] = path_str[5] or self._DIGI_PATHS[5]
# path_str[6] = path_str[6] or self._DIGI_PATHS[6]
# path_str[7] = path_str[7] or self._DIGI_PATHS[7]
path_str[3] = self._DIGI_PATHS[3]
path_str[4] = self._DIGI_PATHS[4]
path_str[5] = self._DIGI_PATHS[5]
path_str[6] = self._DIGI_PATHS[6]
path_str[7] = self._DIGI_PATHS[7]
val = RadioSettingValueList(path_str,
current_index=aprs.selected_digi_path)
rs = RadioSetting("aprs.selected_digi_path", "Selected Digi Path", val)
menu.append(rs)
return menu
def _get_aprs_smartbeacon(self):
menu = RadioSettingGroup("aprs_smartbeacon", "APRS SmartBeacon")
aprs = self._memobj.aprs
val = RadioSettingValueList(
self._SMARTBEACON_PROFILE,
current_index=aprs.active_smartbeaconing)
rs = RadioSetting("aprs.active_smartbeaconing", "SmartBeacon profile",
val)
menu.append(rs)
for profile in range(3):
pfx = "type%d" % (profile + 1)
path = "aprs.smartbeaconing_profile[%d]" % profile
prof = aprs.smartbeaconing_profile[profile]
low_val = RadioSettingValueInteger(2, 30, prof.low_speed_mph)
high_val = RadioSettingValueInteger(3, self._APRS_HIGH_SPEED_MAX,
prof.high_speed_mph)
low_val.get_max = lambda: min(30, int(high_val.get_value()) - 1)
rs = RadioSetting("%s.low_speed_mph" % path,
"%s Low Speed (mph)" % pfx, low_val)
menu.append(rs)
rs = RadioSetting("%s.high_speed_mph" % path,
"%s High Speed (mph)" % pfx, high_val)
menu.append(rs)
val = RadioSettingValueInteger(1, 100, prof.slow_rate_min)
rs = RadioSetting("%s.slow_rate_min" % path,
"%s Slow rate (minutes)" % pfx, val)
menu.append(rs)
val = RadioSettingValueInteger(10, 180, prof.fast_rate_sec)
rs = RadioSetting("%s.fast_rate_sec" % path,
"%s Fast rate (seconds)" % pfx, val)
menu.append(rs)
val = RadioSettingValueInteger(5, 90, prof.turn_angle)
rs = RadioSetting("%s.turn_angle" % path,
"%s Turn angle (degrees)" % pfx, val)
menu.append(rs)
val = RadioSettingValueInteger(1, 255, prof.turn_slop)
rs = RadioSetting("%s.turn_slop" % path,
"%s Turn slop" % pfx, val)
menu.append(rs)
val = RadioSettingValueInteger(5, 180, prof.turn_time_sec)
rs = RadioSetting("%s.turn_time_sec" % path,
"%s Turn time (seconds)" % pfx, val)
menu.append(rs)
return menu
def _get_digital_settings(self):
topmenu = RadioSettingGroup("digital_settings", "Digital")
menu = RadioSettingGroup("settings", "Digital Modes")
topmenu.append(menu)
GMmenu = RadioSettingGroup("first_settings", "Group Monitor(GM)")
topmenu.append(GMmenu)
WXmenu = RadioSettingGroup("WiresX_settings", "Wires-X")
topmenu.append(WXmenu)
# MYCALL
mycall = self._memobj.my_call
mycallstr = bitwise.get_string(mycall.callsign).rstrip("\xff\00 ")
mycalle = RadioSettingValueString(0, 10, mycallstr, False,
charset=self._MYCALL_CHR_SET)
rs = RadioSetting('mycall.callsign',
'MYCALL', mycalle)
rs.set_apply_callback(self.apply_mycall, mycall)
menu.append(rs)
# Short Press AMS button AMS TX Mode
digital_settings = self._memobj.digital_settings
val = RadioSettingValueList(
self._AMS_TX_MODE,
current_index=digital_settings.ams_tx_mode)
rs = RadioSetting("digital_settings.ams_tx_mode",
"AMS TX Mode", val)
menu.append(rs)
# 16 DIG VW Turn the VW mode selection ON or OFF.
val = RadioSettingValueList(
self._VW_MODE,
current_index=digital_settings.vw_mode)
rs = RadioSetting("digital_settings.vw_mode", "VW Mode", val)
menu.append(rs)
# TX DG-ID Long Press Mode Key, Dial
val = RadioSettingValueList(
self._DG_ID,
current_index=digital_settings.tx_dg_id)
rs = RadioSetting("digital_settings.tx_dg_id",
"TX DG-ID", val)
menu.append(rs)
# RX DG-ID Long Press Mode Key, Mode Key to select, Dial
val = RadioSettingValueList(
self._DG_ID,
current_index=digital_settings.rx_dg_id)
rs = RadioSetting("digital_settings.rx_dg_id",
"RX DG-ID", val)
menu.append(rs)
# 15 DIG.POP Call sign display pop up time
digital_settings_more = self._memobj.digital_settings_more
val = RadioSettingValueList(
self._DIG_POP_UP,
current_index=(
0 if digital_settings_more.digital_popup == 0
else digital_settings_more.digital_popup - 9))
rs = RadioSetting("digital_settings_more.digital_popup",
"Digital Popup", val)
rs.set_apply_callback(self.apply_digital_popup,
digital_settings_more)
menu.append(rs)
# 07 BEP.STB Standby Beep in the digital C4FM mode. On/Off
val = RadioSettingValueList(
self._STANDBY_BEEP,
current_index=digital_settings.standby_beep)
rs = RadioSetting("digital_settings.standby_beep",
"Standby Beep", val)
menu.append(rs)
# GM settings
# 24 GM RNG Select the beep option
first_settings = self._memobj.first_settings
val = RadioSettingValueList(
self._GM_RING,
current_index=first_settings.gm_ring)
rs = RadioSetting("first_settings.gm_ring", "GM Ring", val)
GMmenu.append(rs)
# 25 GM INT transmission interval of digital GM info
scan_settings = self._memobj.scan_settings
val = RadioSettingValueList(
self._GM_INTERVAL,
current_index=scan_settings.gm_interval)
rs = RadioSetting("scan_settings.gm_interval",
"GM Interval", val)
GMmenu.append(rs)
m = self._memobj.GM
for i in range(0, 10):
cname = "GM[%d].message" % i
msg = str(m[i].message).rstrip("\xff)")
val = RadioSettingValueString(0, 32, msg)
rs = RadioSetting(cname, "GM Message%2d" % (i + 1),
val)
GMmenu.append(rs)
# WiresX settings
wxc = self._memobj.WiresX_settings
for i in range(5):
WXCmenu = RadioSettingSubGroup(
f"WiresX_settings.Category[{i}].RoomsPerCategory",
f"Category{i + 1} Rooms")
WXmenu.append(WXCmenu)
cname = f"WiresX_settings.Category[{i}].name"
c = str(wxc.Category[i].name).rstrip('\xff').ljust(16)
val = RadioSettingValueString(0, 16, c)
rs = RadioSetting(cname, f"Category {i+1: 2d} Name", val)
WXCmenu.append(rs)
r = wxc.RoomsPerCategory[i]
for j in range(20):
cn = str(r.Rooms[j].name).strip('\xff').ljust(16)
val = RadioSettingValueString(0, 16, cn)
cname = f"WiresX_settings.RoomsPerCategory[{i}]."\
f"Rooms[{j}].name"
dname = f"Category {i + 1} Room{j + 1: 02d}"
rs = RadioSetting(cname, dname + ' Designation', val)
WXCmenu.append(rs)
idn = str(r.Rooms[j].ID).strip('\xff').ljust(5)
val = RadioSettingValueString(0, 5, idn)
vname = f"WiresX_settings.RoomsPerCategory[{i}].Rooms[{j}].ID"
rs = RadioSetting(vname, dname + " YSF Number",
val)
WXCmenu.append(rs)
pass
return topmenu
def _get_dtmf_settings(self):
menu = RadioSettingGroup("dtmf_settings", "DTMF")
dtmf = self._memobj.scan_settings
val = RadioSettingValueList(
self._DTMF_MODE,
current_index=dtmf.dtmf_mode)
rs = RadioSetting("scan_settings.dtmf_mode", "DTMF Mode", val)
menu.append(rs)
val = RadioSettingValueList(
self._DTMF_SPEED,
current_index=dtmf.dtmf_speed)
rs = RadioSetting(
"scan_settings.dtmf_speed", "DTMF AutoDial Speed", val)
menu.append(rs)
val = RadioSettingValueList(
self._DTMF_DELAY,
current_index=dtmf.dtmf_delay)
rs = RadioSetting(
"scan_settings.dtmf_delay", "DTMF AutoDial Delay", val)
menu.append(rs)
for i in range(10):
name = "dtmf_%02d" % i
dtmfsetting = self._memobj.dtmf[i]
dtmfstr = ""
for c in dtmfsetting.memory:
if c == 0xFF:
break
if c < len(FT1_DTMF_CHARS):
dtmfstr += FT1_DTMF_CHARS[c]
dtmfentry = RadioSettingValueString(0, 16, dtmfstr)
dtmfentry.set_charset(FT1_DTMF_CHARS + list("abcd "))
rs = RadioSetting(name, name.upper(), dtmfentry)
rs.set_apply_callback(self.apply_dtmf, i)
menu.append(rs)
return menu
def _get_misc_settings(self):
menu = RadioSettingGroup("misc_settings", "Misc")
scan_settings = self._memobj.scan_settings
val = RadioSettingValueList(
self._LCD_DIMMER,
current_index=scan_settings.lcd_dimmer)
rs = RadioSetting("scan_settings.lcd_dimmer", "LCD Dimmer", val)
menu.append(rs)
val = RadioSettingValueList(
self._LCD_CONTRAST,
current_index=scan_settings.lcd_contrast - 1)
rs = RadioSetting("scan_settings.lcd_contrast", "LCD Contrast",
val)
rs.set_apply_callback(self.apply_lcd_contrast, scan_settings)
menu.append(rs)
val = RadioSettingValueList(
self._LAMP_KEY,
current_index=scan_settings.lamp)
rs = RadioSetting("scan_settings.lamp", "Lamp", val)
menu.append(rs)
beep_select = self._memobj.beep_settings.beep_select
val = RadioSettingValueList(
self._BEEP_SELECT,
current_index=beep_select)
rs = RadioSetting("beep_settings.beep_select", "Beep Select", val)
menu.append(rs)
opening_message = self._memobj.opening_message
val = RadioSettingValueList(
self._OPENING_MESSAGE,
current_index=opening_message.flag)
rs = RadioSetting("opening_message.flag", "Opening Msg Mode",
val)
menu.append(rs)
rs = self._decode_opening_message(opening_message)
menu.append(rs)
return menu
def _decode_opening_message(self, opening_message) -> RadioSetting:
msg = ""
for i in opening_message.message.padded_yaesu:
if i == 0xFF:
break
msg += CHARSET[i & 0x7F]
val = RadioSettingValueString(0, 16, msg)
rs = RadioSetting("opening_message.message.padded_yaesu",
"Opening Message", val)
rs.set_apply_callback(self.apply_ff_padded_yaesu,
opening_message.message)
return rs
def backtrack_ll_validate(self, number, min, max):
if str(number).lstrip('0').strip().isdigit() and \
int(str(number).lstrip('0')) <= max and \
int(str(number).lstrip('0')) >= min:
return True
return False
@staticmethod
def zero_pad(number, length):
"""
Applies a leading zero pad of length `length` to `number`
"""
return str(number).rjust(length, "0")
def _get_backtrack_settings(self):
menu = RadioSettingGroup("backtrack", "Backtrack")
for i in range(3):
prefix = ''
if i == 0:
prefix = "Star "
if i == 1:
prefix = "L1 "
if i == 2:
prefix = "L2 "
bt_idx = "backtrack[%d]" % i
bt = self._memobj.backtrack[i]
val = RadioSettingValueList(
self._BACKTRACK_STATUS,
current_index=0 if bt.status == 1 else 1)
rs = RadioSetting(
"%s.status" % bt_idx,
prefix + "status", val)
rs.set_apply_callback(self.apply_backtrack_status, bt)
menu.append(rs)
if bt.status == 1 and int(bt.year) < 100:
val = RadioSettingValueInteger(0, 99, bt.year)
else:
val = RadioSettingValueInteger(0, 99, 0)
rs = RadioSetting(
"%s.year" % bt_idx,
prefix + "year", val)
menu.append(rs)
if bt.status == 1 and int(bt.mon) <= 12:
val = RadioSettingValueInteger(0, 12, bt.mon)
else:
val = RadioSettingValueInteger(0, 12, 0)
rs = RadioSetting(
"%s.mon" % bt_idx,
prefix + "month", val)
menu.append(rs)
if bt.status == 1:
val = RadioSettingValueInteger(0, 31, bt.day)
else:
val = RadioSettingValueInteger(0, 31, 0)
rs = RadioSetting(
"%s.day" % bt_idx,
prefix + "day", val)
menu.append(rs)
if bt.status == 1:
val = RadioSettingValueInteger(0, 23, bt.hour)
else:
val = RadioSettingValueInteger(0, 23, 0)
rs = RadioSetting(
"%s.hour" % bt_idx,
prefix + "hour", val)
menu.append(rs)
if bt.status == 1:
val = RadioSettingValueInteger(0, 59, bt.min)
else:
val = RadioSettingValueInteger(0, 59, 0)
rs = RadioSetting(
"%s.min" % bt_idx,
prefix + "min", val)
menu.append(rs)
if bt.status == 1 and \
(str(bt.NShemi) == 'N' or str(bt.NShemi) == 'S'):
val = RadioSettingValueString(0, 1, str(bt.NShemi))
else:
val = RadioSettingValueString(0, 1, ' ')
rs = RadioSetting(
"%s.NShemi" % bt_idx,
prefix + "NS hemisphere", val)
rs.set_apply_callback(self.apply_NShemi, bt)
menu.append(rs)
if bt.status == 1 and self.backtrack_ll_validate(bt.lat, 0, 90):
val = RadioSettingValueString(
0, 3, self.zero_pad(bt.lat, 3))
else:
val = RadioSettingValueString(0, 3, ' ')
rs = RadioSetting("%s.lat" % bt_idx, prefix + "Latitude", val)
rs.set_apply_callback(self.apply_bt_lat, bt)
menu.append(rs)
if bt.status == 1 and \
self.backtrack_ll_validate(bt.lat_min, 0, 59):
val = RadioSettingValueString(
0, 2, self.zero_pad(bt.lat_min, 2))
else:
val = RadioSettingValueString(0, 2, ' ')
rs = RadioSetting(
"%s.lat_min" % bt_idx,
prefix + "Latitude Minutes", val)
rs.set_apply_callback(self.apply_bt_lat_min, bt)
menu.append(rs)
if bt.status == 1 and \
self.backtrack_ll_validate(bt.lat_dec_sec, 0, 9999):
val = RadioSettingValueString(
0, 4, self.zero_pad(bt.lat_dec_sec, 4))
else:
val = RadioSettingValueString(0, 4, ' ')
rs = RadioSetting(
"%s.lat_dec_sec" % bt_idx,
prefix + "Latitude Decimal Seconds", val)
rs.set_apply_callback(self.apply_bt_lat_dec_sec, bt)
menu.append(rs)
if bt.status == 1 and \
(str(bt.WEhemi) == 'W' or str(bt.WEhemi) == 'E'):
val = RadioSettingValueString(
0, 1, str(bt.WEhemi))
else:
val = RadioSettingValueString(0, 1, ' ')
rs = RadioSetting(
"%s.WEhemi" % bt_idx,
prefix + "WE hemisphere", val)
rs.set_apply_callback(self.apply_WEhemi, bt)
menu.append(rs)
if bt.status == 1 and self.backtrack_ll_validate(bt.lon, 0, 180):
val = RadioSettingValueString(
0, 3, self.zero_pad(bt.lon, 3))
else:
val = RadioSettingValueString(0, 3, ' ')
rs = RadioSetting("%s.lon" % bt_idx, prefix + "Longitude", val)
rs.set_apply_callback(self.apply_bt_lon, bt)
menu.append(rs)
if bt.status == 1 and \
self.backtrack_ll_validate(bt.lon_min, 0, 59):
val = RadioSettingValueString(
0, 2, self.zero_pad(bt.lon_min, 2))
else:
val = RadioSettingValueString(0, 2, ' ')
rs = RadioSetting(
"%s.lon_min" % bt_idx,
prefix + "Longitude Minutes", val)
rs.set_apply_callback(self.apply_bt_lon_min, bt)
menu.append(rs)
if bt.status == 1 and \
self.backtrack_ll_validate(bt.lon_dec_sec, 0, 9999):
val = RadioSettingValueString(
0, 4, self.zero_pad(bt.lon_dec_sec, 4))
else:
val = RadioSettingValueString(0, 4, ' ')
rs = RadioSetting(
"%s.lon_dec_sec" % bt_idx,
prefix + "Longitude Decimal Seconds", val)
rs.set_apply_callback(self.apply_bt_lon_dec_sec, bt)
menu.append(rs)
return menu
def _get_scan_settings(self):
menu = RadioSettingGroup("scan_settings", "Scan")
scan_settings = self._memobj.scan_settings
val = RadioSettingValueList(
self._VOL_MODE,
current_index=scan_settings.vol_mode)
rs = RadioSetting("scan_settings.vol_mode", "Volume Mode", val)
menu.append(rs)
vfoa = self._memobj.vfo_info[0]
val = RadioSettingValueList(
self._VOLUME,
current_index=vfoa.volume)
rs = RadioSetting("vfo_info[0].volume", "VFO A Volume", val)
rs.set_apply_callback(self.apply_volume, 0)
menu.append(rs)
vfob = self._memobj.vfo_info[1]
val = RadioSettingValueList(
self._VOLUME,
current_index=vfob.volume)
rs = RadioSetting("vfo_info[1].volume", "VFO B Volume", val)
rs.set_apply_callback(self.apply_volume, 1)
menu.append(rs)
squelch = self._memobj.squelch
val = RadioSettingValueList(
self._SQUELCH,
current_index=squelch.vfo_a)
rs = RadioSetting("squelch.vfo_a", "VFO A Squelch", val)
menu.append(rs)
val = RadioSettingValueList(
self._SQUELCH,
current_index=squelch.vfo_b)
rs = RadioSetting("squelch.vfo_b", "VFO B Squelch", val)
menu.append(rs)
val = RadioSettingValueList(
self._SCAN_RESTART,
current_index=scan_settings.scan_restart)
rs = RadioSetting("scan_settings.scan_restart", "Scan Restart", val)
menu.append(rs)
val = RadioSettingValueList(
self._SCAN_RESUME,
current_index=scan_settings.scan_resume)
rs = RadioSetting("scan_settings.scan_resume", "Scan Resume", val)
menu.append(rs)
val = RadioSettingValueList(
self._OFF_ON,
current_index=scan_settings.busy_led)
rs = RadioSetting("scan_settings.busy_led", "Busy LED", val)
menu.append(rs)
val = RadioSettingValueList(
self._OFF_ON,
current_index=scan_settings.scan_lamp)
rs = RadioSetting("scan_settings.scan_lamp", "Scan Lamp", val)
menu.append(rs)
val = RadioSettingValueList(
self._TOT_TIME,
current_index=scan_settings.tot)
rs = RadioSetting("scan_settings.tot", "Transmit Timeout (TOT)", val)
menu.append(rs)
return menu
def _get_settings(self):
top = RadioSettings(self._get_aprs_settings(),
self._get_digital_settings(),
self._get_dtmf_settings(),
self._get_misc_settings(),
self._get_scan_settings(),
self._get_backtrack_settings())
return top
def get_settings(self):
try:
return self._get_settings()
except:
import traceback
LOG.error("Failed to parse settings: %s", traceback.format_exc())
return None
@staticmethod
def apply_custom_symbol(setting, obj):
# Ensure new value falls within known bounds, otherwise leave it as
# it's a custom value from the radio that's outside our list.
if setting.value.get_value() in chirp_common.APRS_SYMBOLS:
setattr(obj, "custom_symbol",
chirp_common.APRS_SYMBOLS.index(setting.value.get_value()))
@classmethod
def _apply_callsign(cls, callsign, obj, default_ssid=None):
ssid = default_ssid
dash_index = callsign.find("-")
if dash_index >= 0:
ssid = callsign[dash_index + 1:]
callsign = callsign[:dash_index]
try:
ssid = int(ssid) % 16
except ValueError:
ssid = default_ssid
setattr(obj, "callsign", cls._add_ff_pad(callsign.encode(), 6))
if ssid is not None:
setattr(obj, "ssid", ssid)
def apply_beacon_type(cls, setting, obj):
beacon_type = str(setting.value.get_value())
beacon_index = cls._BEACON_TYPE.index(beacon_type)
tx_smartbeacon = beacon_index >> 1
tx_interval_beacon = beacon_index & 1
if tx_interval_beacon:
setattr(obj, "tx_interval_beacon", 1)
setattr(obj, "tx_smartbeacon", 0)
elif tx_smartbeacon:
setattr(obj, "tx_interval_beacon", 0)
setattr(obj, "tx_smartbeacon", 1)
else:
setattr(obj, "tx_interval_beacon", 0)
setattr(obj, "tx_smartbeacon", 0)
# digital settings callback routines
def apply_digital_popup(cls, setting, obj):
rawval = setting.value.get_value()
val = 0 if cls._DIG_POP_UP.index(rawval) == 0 \
else cls._DIG_POP_UP.index(rawval) + 9
obj.digital_popup = val
def apply_mycall(cls, setting, obj):
cs = setting.value.get_value()
if cs[0] in ('-', '/'):
raise InvalidValueError("First character of"
" call sign can't be - or /: {0:s}"
.format(cs))
else:
obj.callsign = cls._add_ff_pad(cs.rstrip(), 10)
@classmethod
def apply_callsign(cls, setting, obj, default_ssid=None):
# Uppercase, strip SSID then FF pad to max string length.
callsign = setting.value.get_value().upper()
cls._apply_callsign(callsign, obj, default_ssid)
def apply_digi_path(self, setting, obj):
# Parse and map to aprs.digi_path_4_7[0-3] or aprs.digi_path_8
# and FF terminate.
path = str(setting.value.get_value())
callsigns = [c.strip() for c in path.split(",")]
for index in range(len(obj.entry)):
try:
self._apply_callsign(callsigns[index], obj.entry[index], 0)
except IndexError:
self._apply_callsign("", obj.entry[index], 0)
if len(callsigns) > len(obj.entry):
raise Exception("This path only supports %d entries" % (index + 1))
@classmethod
def apply_ff_padded_string(cls, setting, obj):
# FF pad.
val = setting.value.get_value()
max_len = getattr(obj, "padded_string").size() // 8
val = str(val).rstrip()
setattr(obj, "padded_string", cls._add_ff_pad(val, max_len))
@classmethod
def apply_lat_long(cls, setting, obj):
name = setting.get_name()
is_latitude = name.endswith("latitude")
lat_long = setting.value.get_value().strip()
sign, l_d, l_m, l_s = cls._str_to_latlong(lat_long, is_latitude)
LOG.debug("%s: %d %d %d %d" % (name, sign, l_d, l_m, l_s))
setattr(obj, "%s_sign" % name, sign)
setattr(obj, "%s_degree" % name, l_d)
setattr(obj, "%s_minute" % name, l_m)
setattr(obj, "%s_second" % name, l_s)
def set_settings(self, settings):
_mem = self._memobj
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("ft1d.set_settings: %s", e)
continue
# Find the object containing setting.
obj = _mem
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:
LOG.debug(f'Trouble setting "{element.get_name()}"')
raise
def apply_ff_padded_yaesu(cls, setting, obj):
# FF pad yaesus custom string format.
rawval = setting.value.get_value()
max_len = getattr(obj, "padded_yaesu").size() // 8
rawval = str(rawval).rstrip()
val = [CHARSET.index(x) for x in rawval]
for x in range(len(val), max_len):
val.append(0xFF)
obj.padded_yaesu = val
def apply_volume(cls, setting, vfo):
val = setting.value.get_value()
cls._memobj.vfo_info[(vfo * 2)].volume = val
cls._memobj.vfo_info[(vfo * 2) + 1].volume = val
def apply_lcd_contrast(cls, setting, obj):
rawval = setting.value.get_value()
val = cls._LCD_CONTRAST.index(rawval) + 1
obj.lcd_contrast = val
def apply_dtmf(cls, setting, i):
rawval = setting.value.get_value().upper().rstrip()
val = [FT1_DTMF_CHARS.index(x) for x in rawval]
for x in range(len(val), 16):
val.append(0xFF)
cls._memobj.dtmf[i].memory = val
def apply_backtrack_status(cls, setting, obj):
status = setting.value.get_value()
if status == 'Valid':
val = 1
else:
val = 8
setattr(obj, "status", val)
def apply_NShemi(cls, setting, obj):
hemi = setting.value.get_value().upper()
if hemi != 'N' and hemi != 'S':
hemi = ' '
setattr(obj, "NShemi", hemi)
def apply_WEhemi(cls, setting, obj):
hemi = setting.value.get_value().upper()
if hemi != 'W' and hemi != 'E':
hemi = ' '
setattr(obj, "WEhemi", hemi)
def apply_bt_lat(cls, setting, obj):
val = setting.value.get_value()
val = cls.zero_pad(val, 3)
setattr(obj, "lat", val)
def apply_bt_lat_min(cls, setting, obj):
val = setting.value.get_value()
val = cls.zero_pad(val, 2)
setattr(obj, "lat_min", val)
def apply_bt_lat_dec_sec(cls, setting, obj):
val = setting.value.get_value()
val = cls.zero_pad(val, 4)
setattr(obj, "lat_dec_sec", val)
def apply_bt_lon(cls, setting, obj):
val = setting.value.get_value()
val = cls.zero_pad(val, 3)
setattr(obj, "lon", val)
def apply_bt_lon_min(cls, setting, obj):
val = setting.value.get_value()
val = cls.zero_pad(val, 2)
setattr(obj, "lon_min", val)
def apply_bt_lon_dec_sec(cls, setting, obj):
val = setting.value.get_value()
val = cls.zero_pad(val, 4)
setattr(obj, "lon_dec_sec", val)
def load_mmap(self, filename):
if filename.lower().endswith(self._adms_ext):
with open(filename, 'rb') as f:
self._adms_header = f.read(0x16)
LOG.debug('ADMS Header:\n%s',
util.hexprint(self._adms_header))
self._mmap = memmap.MemoryMapBytes(self._model + f.read())
LOG.info('Loaded ADMS file')
self.process_mmap()
else:
chirp_common.CloneModeRadio.load_mmap(self, filename)
def save_mmap(self, filename):
if filename.lower().endswith(self._adms_ext):
if not hasattr(self, '_adms_header'):
raise Exception('Unable to save .img to %s' % self._adms_ext)
with open(filename, 'wb') as f:
f.write(self._adms_header)
f.write(self._mmap.get_packed()[5:])
LOG.info('Wrote file')
else:
chirp_common.CloneModeRadio.save_mmap(self, filename)
chirp-20261030/chirp/drivers/ft2800.py 0000644 0001750 0001750 00000024405 14665027664 016137 0 ustar hibby hibby # Copyright 2011 Dan Smith
#
# 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 After clicking OK , "
"press the MHz key on the radio to send"
" image.\n"
" (\"TX\" will appear on the LCD). \n")
rp.pre_upload = _(
"1. Turn radio off.\n"
"2. Connect cable\n"
"3. Press and hold in the MHz, Low, and D/MR keys on the radio "
"while turning it on\n"
"4. Radio is in clone mode when TX/RX is flashing\n"
"5. Press the Low key on the radio "
"(\"RX\" will appear on the LCD).\n"
"6. Click OK.")
return rp
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.memory_bounds = (0, 199)
rf.has_ctone = False
rf.has_tuning_step = False
rf.has_dtcs_polarity = False
rf.has_bank = False
rf.valid_tuning_steps = [5.0, 10.0, 12.5, 15.0,
20.0, 25.0, 50.0, 100.0]
rf.valid_modes = MODES
rf.valid_tmodes = TMODES
rf.valid_bands = [(137000000, 174000000)]
rf.valid_power_levels = POWER_LEVELS
rf.valid_duplexes = DUPLEX
rf.valid_skips = ["", "S", "P"]
rf.valid_name_length = 6
rf.valid_characters = CHARSET
return rf
def sync_in(self):
self.pipe.parity = "E"
self.pipe.timeout = 1
start = time.time()
try:
self._mmap = _download(self)
except errors.RadioError:
raise
except Exception as e:
LOG.exception('Failed download')
raise errors.RadioError("Failed to communicate with radio: %s" % e)
LOG.info("Downloaded in %.2f sec" % (time.time() - start))
self.process_mmap()
def sync_out(self):
self.pipe.timeout = 1
self.pipe.parity = "E"
start = time.time()
try:
_upload(self)
except errors.RadioError:
raise
except Exception as e:
LOG.exception('Failed upload')
raise errors.RadioError("Failed to communicate with radio: %s" % e)
LOG.info("Uploaded in %.2f sec" % (time.time() - start))
def process_mmap(self):
self._memobj = bitwise.parse(MEM_FORMAT, self._mmap)
def get_raw_memory(self, number):
return repr(self._memobj.memory[number])
def get_memory(self, number):
_mem = self._memobj.memory[number]
_nam = self._memobj.names[number]
mem = chirp_common.Memory()
mem.number = number
if _mem.get_raw(asbytes=False)[0] == "\xFF":
mem.empty = True
return mem
mem.freq = int(_mem.freq) * 10
mem.offset = int(_mem.offset) * 100000
mem.duplex = DUPLEX[_mem.duplex]
mem.tmode = TMODES[_mem.tmode]
mem.rtone = chirp_common.TONES[_mem.tone]
mem.dtcs = chirp_common.DTCS_CODES[_mem.dtcs]
mem.name = str(_nam.name).rstrip()
mem.mode = _mem.isnarrow and "NFM" or "FM"
mem.skip = _mem.pskip and "P" or _mem.skip and "S" or ""
mem.power = POWER_LEVELS[_mem.power]
return mem
def set_memory(self, mem):
_mem = self._memobj.memory[mem.number]
_nam = self._memobj.names[mem.number]
if mem.empty:
_mem.set_raw("\xFF" * (_mem.size() // 8))
return
if _mem.get_raw(asbytes=False)[0] == "\xFF":
# Empty -> Non-empty, so initialize
_mem.set_raw("\x00" * (_mem.size() // 8))
# initializing unknowns
_mem.unknown1 = (0xFF, 0xFF, 0xFF, 0xFF)
_mem.unknown2 = (0x00, 0x00)
_mem.unknown3 = 0x01
_mem.unknown4 = 0x3C
_mem.freq = mem.freq / 10
_mem.offset = mem.offset / 100000
_mem.duplex = DUPLEX.index(mem.duplex)
_mem.tmode = TMODES.index(mem.tmode)
_mem.tone = chirp_common.TONES.index(mem.rtone)
_mem.dtcs = chirp_common.DTCS_CODES.index(mem.dtcs)
_mem.isnarrow = MODES.index(mem.mode)
_mem.pskip = mem.skip == "P"
_mem.skip = mem.skip == "S"
if mem.power:
_mem.power = POWER_LEVELS.index(mem.power)
else:
_mem.power = 0
_nam.name = mem.name.ljust(6)[:6]
@classmethod
def match_model(cls, filedata, filename):
return len(filedata) == cls._memsize
chirp-20261030/chirp/drivers/ft2900.py 0000644 0001750 0001750 00000123542 14670320477 016134 0 ustar hibby hibby # Copyright 2011 Dan Smith
#
# FT-2900-specific modifications by Richard Cochran,
# Initial work on settings by Chris Fosnight,
#
# 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 After clicking OK , press \"SET MHz\" to send image.\n")
rp.pre_upload = _(
"1. Turn Radio off.\n"
"2. Connect data cable.\n"
"3. While holding \"A/N LOW\" button, turn radio on.\n"
"4. Press \"MW D/MR\" to receive image.\n"
"5. Make sure display says \"-WAIT-\" (see note below if not)\n"
"6. Click OK to dismiss this dialog and start transfer.\n"
"Note: if you don't see \"-WAIT-\" at step 5, try cycling\n"
" power and pressing and holding red \"*L\" button to"
" unlock\n"
" radio, then start back at step 1.\n")
return rp
# the FT2900E is the European version of the radio, almost identical
# to the R (USA) version, except for the model number and ID Block. We
# create and register a class for it, with only the needed overrides
# NOTE: Disabled until detection is fixed
# @directory.register
class FT2900ERadio(FT2900Radio):
"""Yaesu FT-2900E"""
MODEL = "FT-2900E/1900E"
VARIANT = "E"
IDBLOCK = b"\x56\x43\x32\x33\x00\x02\x41\x02\x01\x01"
# This class is for the TX Modified FT-1900/FT-2900 (MARS/CAP Mod).
# Enabling out of band TX changes the header received by CHIRP
@directory.register
class FT2900ModRadio(FT2900Radio):
"""Yaesu FT-2900Mod"""
MODEL = "FT-2900R/1900R(TXMod)"
VARIANT = "Opened Xmit"
IDBLOCK = b"\x56\x43\x32\x33\x00\x02\xc7\x01\x01\x01"
@classmethod
def match_model(cls, filedata, filename):
return False
chirp-20261030/chirp/drivers/ft2d.py 0000644 0001750 0001750 00000017604 15250742640 016043 0 ustar hibby hibby # Copyright 2010 Dan Smith
# Portions Copyright 2017 Wade Simmons
# Copyright 2017 Declan Rieb
#
# 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 After clicking OK here in Chirp ,\n"
" press the [Send] screen button.\n")
rp.pre_upload = _(
"1. Turn radio off.\n"
"2. Connect cable to DATA terminal.\n"
"3. Press and hold in [DISP] key while turning on radio\n"
" (\"CLONE\" will appear on radio LCD).\n"
"4. Press [RECEIVE] screen button\n"
" (\"-WAIT-\" will appear on radio LCD).\n"
"5. Finally, press OK button below.\n")
return rp
def get_features(self): # AFAICT only TMODES & memory bounds are different
rf = super(FT2D, self).get_features()
rf.valid_tmodes = list(TMODES)
rf.memory_bounds = (1, self.MAX_MEM_SLOTS)
return rf
def get_bank_model(self): # here only to launch the bank model
return FT2BankModel(self)
def _decode_label(self, mem):
return str(mem.label).rstrip("\xFF")
def _encode_label(self, mem):
label = mem.name.rstrip().encode('ascii', 'ignore')
return self._add_ff_pad(label, 16)
def _decode_opening_message(self, opening_message):
msg = ""
for i in opening_message.message.padded_yaesu:
if i == 0xFF:
break
msg += chr(int(i))
val = RadioSettingValueString(0, 16, msg)
rs = RadioSetting("opening_message.message.padded_yaesu",
"Opening Message", val)
rs.set_apply_callback(self._apply_opening_message,
opening_message.message.padded_yaesu)
return rs
def _apply_opening_message(self, setting, obj):
data = self._add_ff_pad(setting.value.get_value().rstrip(), 16)
val = []
for i in data:
val.append(ord(i))
self._memobj.opening_message.message.padded_yaesu = val
@directory.register
class FT2Dv2(FT2D):
"""Yaesu FT-2D v2 firmware"""
VARIANT = "Rv2"
_model = b"AH60G"
@directory.register
class FT3D(FT2D):
"""Yaesu FT-3D"""
MODEL = "FT3D"
VARIANT = "R"
_adms_ext = '.ft3d'
_model = b"AH72M"
FORMATS = [directory.register_format('FT3D ADMS-11', '*.ft3d')]
def load_mmap(self, filename):
if filename.lower().endswith(self._adms_ext):
with open(filename, 'rb') as f:
self._adms_header = f.read(0x18C)
if b'ADMS11, Version=1.0.0.0' not in self._adms_header:
raise errors.ImageDetectFailed(
'Unsupported version found in ADMS file')
LOG.debug('ADMS Header:\n%s',
util.hexprint(self._adms_header))
self._mmap = memmap.MemoryMapBytes(f.read())
LOG.info('Loaded ADMS-11 file at offset 0x18C')
self.process_mmap()
else:
chirp_common.CloneModeRadio.load_mmap(self, filename)
def save_mmap(self, filename):
if filename.lower().endswith(self._adms_ext):
if not hasattr(self, '_adms_header'):
raise Exception(f'Unable to save .img to {self._adms_ext}')
with open(filename, 'wb') as f:
f.write(self._adms_header)
f.write(self._mmap.get_packed())
LOG.info('Wrote ADMS-11 file')
else:
chirp_common.CloneModeRadio.save_mmap(self, filename)
@directory.register
class FT5D(FT2D):
"""Yaesu FT-5D"""
MODEL = "FT5D"
VARIANT = "R"
_adms_ext = '.ft5d'
_model = b"AH82M"
FORMATS = [directory.register_format('FT5D ADMS-14', '*.ft5d')]
def load_mmap(self, filename):
if filename.lower().endswith(self._adms_ext):
with open(filename, 'rb') as f:
self._adms_header = f.read(0x18C)
if b'ADMS14, Version=1.0.' not in self._adms_header:
raise errors.ImageDetectFailed(
'Unsupported version found in ADMS file')
LOG.debug('ADMS Header:\n%s',
util.hexprint(self._adms_header))
self._mmap = memmap.MemoryMapBytes(f.read())
LOG.info('Loaded ADMS-14 file at offset 0x18C')
self.process_mmap()
else:
chirp_common.CloneModeRadio.load_mmap(self, filename)
def save_mmap(self, filename):
if filename.lower().endswith(self._adms_ext):
if not hasattr(self, '_adms_header'):
raise Exception(f'Unable to save .img to {self._adms_ext}')
with open(filename, 'wb') as f:
f.write(self._adms_header)
f.write(self._mmap.get_packed())
LOG.info('Wrote ADMS-14 file')
else:
chirp_common.CloneModeRadio.save_mmap(self, filename)
chirp-20261030/chirp/drivers/ft4.py 0000644 0001750 0001750 00000162142 15266622247 015706 0 ustar hibby hibby # Copyright 2019 Dan Clemmensen
# Derives loosely from two sources released under GPLv2:
# ./template.py, Copyright 2012 Dan Smith
# ./ft60.py, Copyright 2011 Dan Smith
# Edited 2020, 2023 Bernhard Hailer AE6YN
#
# 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 for Yaesu processes
#
# 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 After clicking OK here, press the [C.S.] key to\n"
" send image.\n")
rp.pre_upload = _(
"1. Turn radio off.\n"
"2. Connect cable to ACC jack.\n"
"3. Press and hold in the [MODE <] and [MODE >] keys"
" while\n"
" turning the radio on (\"CLONE MODE\" will appear on the\n"
" display).\n"
"4. Click OK here.\n"
" (\"Receiving\" will appear on the LCD).\n")
return rp
def _read(self, block, blocknum):
# be very patient at first block
if blocknum == 0:
attempts = 60
else:
attempts = 5
for _i in range(0, attempts):
data = self.pipe.read(block + 2) # Blocknum, data,checksum
if data:
break
time.sleep(0.5)
if not data:
if blocknum == 0:
raise errors.RadioNoResponse()
raise errors.RadioError("No response reading block %02X" % blocknum)
if len(data) == block + 2 and data[0] == blocknum:
checksum = yaesu_clone.YaesuChecksum(1, block)
if checksum.get_existing(data) != \
checksum.get_calculated(data):
raise Exception("Checksum Failed [%02X<>%02X] block %02X" %
(checksum.get_existing(data),
checksum.get_calculated(data), blocknum))
# Remove the block number and checksum
data = data[1:block + 1]
elif self.FT450:
# unique FT450 (and 450AT?) vs D, only 2 bytes in first block
if blocknum == 0 and len(data) == 4:
checksum = yaesu_clone.YaesuChecksum(1, block - 2)
if checksum.get_existing(data) != \
checksum.get_calculated(data):
raise Exception("Checksum Failed [%02X<>%02X] block %02X" %
(checksum.get_existing(data),
checksum.get_calculated(data), blocknum))
# Remove the block number and checksum
data = data[1:block - 2 + 1]
# pad the data to the correct 450d size
data += b" "
else:
# FT450, but bad block
raise Exception("Unable to read block %i expected %i got %i"
% (blocknum, block + 2, len(data)))
else:
# Use this info to decode a new Yaesu model
# Not an old FT450 or 450AT
raise Exception("Unable to read block %i expected %i got %i"
% (blocknum, block + 2, len(data)))
return data
def _clone_in(self):
# Be very patient with the radio
self.pipe.timeout = 2
self.pipe.baudrate = self.BAUD_RATE
self.pipe.bytesize = self.COM_BITS
self.pipe.parity = self.COM_PRTY
self.pipe.stopbits = self.COM_STOP
self.pipe.rtscts = False
start = time.time()
data = b""
blocks = 0
status = chirp_common.Status()
status.msg = _("Cloning from radio")
nblocks = len(self._block_lengths) + 100 # Block 8 repeats
status.max = nblocks
for block in self._block_lengths:
if blocks == 8:
# repeated read of block 8 same size (chan memory area)
repeat = 101
else:
repeat = 1
for _i in range(0, repeat):
data += self._read(block, blocks)
self.pipe.write(CMD_ACK)
blocks += 1
status.cur = blocks
self.status_fn(status)
data += self.MODEL.encode()
return memmap.MemoryMapBytes(data)
def _clone_out(self):
self.pipe.baudrate = self.BAUD_RATE
self.pipe.bytesize = self.COM_BITS
self.pipe.parity = self.COM_PRTY
self.pipe.stopbits = self.COM_STOP
self.pipe.rtscts = False
delay = 0.5
start = time.time()
blocks = 0
pos = 0
status = chirp_common.Status()
status.msg = _("Cloning to radio")
status.max = len(self._block_lengths) + 100
for block in self._block_lengths:
if blocks == 8:
repeat = 101
else:
repeat = 1
for _i in range(0, repeat):
time.sleep(0.01)
# If this is a 450 model, we need to send just the first two model bytes
# in block 0 and just checksum that part
if self.FT450 and blocks == 0:
checksum = yaesu_clone.YaesuChecksum(pos, pos + block - 2 - 1)
else:
checksum = yaesu_clone.YaesuChecksum(pos, pos + block - 1)
LOG.debug("Sending block %s" % hex(blocks))
self.pipe.write(struct.pack('B', blocks))
if self.FT450 and blocks == 0:
blkdat = self.get_mmap()[pos:pos + block - 2]
else:
blkdat = self.get_mmap()[pos:pos + block]
LOG.debug("Sending %d bytes:\n%s"
% (len(blkdat), util.hexprint(blkdat)))
self.pipe.write(blkdat)
xs = checksum.get_calculated(self.get_mmap())
LOG.debug("Sending checksum %s" % hex(xs))
self.pipe.write(struct.pack('B', xs))
buf = self.pipe.read(1)
if not buf or buf[:1] != CMD_ACK:
time.sleep(delay)
buf = self.pipe.read(1)
if not buf:
if blocks == 0:
raise errors.RadioNoResponse()
raise errors.RadioError("Radio did not ack block %i" % blocks)
if buf[:1] != CMD_ACK:
raise Exception(_("Radio did not ack block %i") % blocks)
pos += block
blocks += 1
status.cur = blocks
self.status_fn(status)
def sync_in(self):
try:
self._mmap = self._clone_in()
except errors.RadioError:
raise
except Exception as e:
raise errors.RadioError("Failed to communicate with radio: %s"
% e)
self.process_mmap()
def sync_out(self):
try:
self._clone_out()
except errors.RadioError:
raise
except Exception as e:
raise errors.RadioError("Failed to communicate with radio: %s"
% e)
def process_mmap(self):
self._memobj = bitwise.parse(self.MEM_FORMAT, self._mmap)
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.has_bank = False
rf.has_dtcs = False
rf.valid_modes = [x for x in self.MODES if x in chirp_common.MODES]
rf.valid_tmodes = list(self.TMODES)
rf.valid_duplexes = list(self.DUPLEX)
rf.valid_tuning_steps = list(T_STEPS)
rf.valid_bands = self.VALID_BANDS
rf.valid_power_levels = []
rf.valid_characters = "".join(self.CHARSET)
rf.valid_name_length = 7
rf.valid_skips = []
rf.valid_special_chans = sorted(self.SPECIAL_MEMORIES.keys())
rf.memory_bounds = (1, 500)
rf.has_ctone = True
rf.has_settings = True
rf.has_cross = True
rf.has_nostep_tuning = True
return rf
def get_raw_memory(self, number):
return repr(self._memobj.memory[number - 1])
def _get_tmode(self, mem, _mem):
mem.tmode = self.TMODES[_mem.tmode]
mem.rtone = chirp_common.TONES[_mem.tone]
mem.ctone = mem.rtone
def _set_duplex(self, mem, _mem):
_mem.duplex = self.DUPLEX.index(mem.duplex)
def get_memory(self, number):
if isinstance(number, str):
return self._get_special(number)
elif number < 0:
# I can't stop delete operation from losing extd_number but
# I know how to get it back
return self._get_special(self.SPECIAL_MEMORIES_REV[number])
else:
return self._get_normal(number)
def set_memory(self, memory):
# If this is called due to a delete request on the gui,
# then the memory passed might be passed as a str,
# since the special memories have string tags on the GUI and not
# numbers. Convert these back to the int for the specials
if isinstance(memory.number, str):
numeric_number = self.SPECIAL_MEMORIES[memory.number]
return self._set_special(memory, mem_number=numeric_number)
if memory.number < 0:
return self._set_special(memory)
else:
return self._set_normal(memory)
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", "extd_number", "name", "power"]
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", "extd_number", "name", "power"]
elif mem.number in range(-4, -6, -1): # 2 Home Chans
_mem = self._memobj.home[5 + mem.number]
immutable = ["number", "extd_number", "name", "power"]
elif mem.number == -3:
_mem = self._memobj.qmb
immutable = ["number", "extd_number", "name", "power"]
elif mem.number == -2:
_mem = self._memobj.mtqmb
immutable = ["number", "extd_number", "name", "power"]
elif mem.number == -1:
_mem = self._memobj.mtune
immutable = ["number", "extd_number", "name", "power"]
elif mem.number in self.SPECIAL_PMS.values():
# ft450 does NOT use the pmsvisible or pmsfilled fields,
# it uses the next 4 bits after the 500 normal memories
# in the main visible and filled settings area.
if self.FT450:
pmsnum = 501 + (-self.LAST_PMS_INDEX) + mem.number
used = (self._memobj.visible[(pmsnum - 1) // 8] >> \
(pmsnum - 1) % 8) & 0x01
valid = (self._memobj.filled[(pmsnum - 1) // 8] >> \
(pmsnum - 1) % 8) & 0x01
else:
bitindex = (-self.LAST_PMS_INDEX) + mem.number
used = (self._memobj.pmsvisible >> bitindex) & 0x01
valid = (self._memobj.pmsfilled >> bitindex) & 0x01
# You can clear the PMS memories on the FT450
# using the CLAR button and then they do not display.
if not used:
mem.empty = True
if not valid:
mem.empty = True
return mem
mx = (-self.LAST_PMS_INDEX) + mem.number
_mem = self._memobj.pms[mx]
mx = mx + 1
immutable = ["number", "rtone", "ctone", "extd_number",
"tmode", "cross_mode",
"power", "duplex", "offset"]
elif mem.number in self.SPECIAL_60M.values():
mx = (-self.LAST_60M_INDEX) + mem.number
_mem = self._memobj.m60[mx]
mx = mx + 1
immutable = ["number", "rtone", "ctone", "extd_number",
"tmode", "cross_mode",
"frequency", "power", "duplex", "offset"]
else:
raise Exception("Sorry, you can't edit that special"
" memory channel %i." % mem.number)
mem = self._get_memory(mem, _mem)
mem.immutable = immutable
return mem
def _set_special(self, mem, mem_number=None):
number = mem_number if mem_number is not None else mem.number
if mem.empty and number not in self.SPECIAL_PMS.values():
# can't delete special memories! But can delete PMS mems
raise errors.RadioError("Sorry, special memory can't be deleted")
cur_mem = self._get_special(self.SPECIAL_MEMORIES_REV[number])
if number in range(self.FIRST_VFOA_INDEX,
self.LAST_VFOA_INDEX - 1, -1):
_mem = self._memobj.vfoa[-self.LAST_VFOA_INDEX + number]
elif number in range(self.FIRST_VFOB_INDEX,
self.LAST_VFOB_INDEX - 1, -1):
_mem = self._memobj.vfob[-self.LAST_VFOB_INDEX + number]
elif number in range(-4, -6, -1):
_mem = self._memobj.home[5 + number]
elif number == -3:
_mem = self._memobj.qmb
elif number == -2:
_mem = self._memobj.mtqmb
elif number == -1:
_mem = self._memobj.mtune
elif number in self.SPECIAL_PMS.values():
# ft450 does NOT use the pmsvisible or pmsfilled fields,
# it uses the next 4 bits after the 500 normal memories
# in the main visible and filled settings area.
if self.FT450:
pmsnum = 501 + (-self.LAST_PMS_INDEX) + number
wasused = (self._memobj.visible[(pmsnum - 1) // 8] >>
(pmsnum - 1) % 8) & 0x01
wasvalid = (self._memobj.filled[(pmsnum - 1) // 8] >>
(pmsnum - 1) % 8) & 0x01
if mem.empty:
if wasvalid and not wasused:
self._memobj.filled[(pmsnum - 1) // 8] &= \
~(1 << (pmsnum - 1) % 8)
self._memobj.visible[(pmsnum - 1) // 8] &= \
~(1 << (pmsnum - 1) % 8)
return
self._memobj.visible[(pmsnum - 1) // 8] |= 1 << (pmsnum - 1) \
% 8
self._memobj.filled[(pmsnum - 1) // 8] |= 1 << (pmsnum - 1) \
% 8
_mem = self._memobj.pms[-self.LAST_PMS_INDEX + number]
else: #self.FT450
bitindex = (-self.LAST_PMS_INDEX) + number
wasused = (self._memobj.pmsvisible >> bitindex) & 0x01
wasvalid = (self._memobj.pmsfilled >> bitindex) & 0x01
if mem.empty:
if wasvalid and not wasused:
# pylint get confused by &= operator
self._memobj.pmsfilled = self._memobj.pmsfilled & \
~ (1 << bitindex)
# pylint get confused by &= operator
self._memobj.pmsvisible = self._memobj.pmsvisible & \
~ (1 << bitindex)
return
# pylint get confused by |= operator
self._memobj.pmsvisible = self._memobj.pmsvisible | 1 << bitindex
self._memobj.pmsfilled = self._memobj.pmsfilled | 1 << bitindex
_mem = self._memobj.pms[-self.LAST_PMS_INDEX + number]
else:
raise errors.RadioError("Sorry, you can't edit"
" that special memory.")
for key in cur_mem.immutable:
if key != "extd_number":
if cur_mem.__dict__[key] != mem.__dict__[key]:
raise errors.RadioError("Editing field `%s' " % key +
"is not supported on this channel")
self._set_memory(mem, _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 or _mem.freq == 0xffffffff:
return mem
if mem.number == 1:
mem.immutable = ['empty']
return self._get_memory(mem, _mem)
def _set_normal(self, mem):
_mem = self._memobj.memory[mem.number - 1]
wasused = (self._memobj.visible[(mem.number - 1) // 8] >>
(mem.number - 1) % 8) & 0x01
wasvalid = (self._memobj.filled[(mem.number - 1) // 8] >>
(mem.number - 1) % 8) & 0x01
if mem.empty:
if mem.number == 1:
raise Exception("Sorry, can't delete first memory")
if wasvalid and not wasused:
self._memobj.filled[(mem.number - 1) // 8] &= \
~(1 << (mem.number - 1) % 8)
_mem.set_raw("\xFF" * (_mem.size() // 8)) # clean up
self._memobj.visible[(mem.number - 1) // 8] &= \
~(1 << (mem.number - 1) % 8)
return
if not wasvalid:
_mem.set_raw("\x00" * (_mem.size() // 8)) # clean up
self._memobj.visible[(mem.number - 1) // 8] |= 1 << (mem.number - 1) \
% 8
self._memobj.filled[(mem.number - 1) // 8] |= 1 << (mem.number - 1) \
% 8
self._set_memory(mem, _mem)
def _get_memory(self, mem, _mem):
mem.freq = int(_mem.freq)
mem.offset = int(_mem.offset)
mem.duplex = self.DUPLEX[_mem.duplex]
# Mode gets tricky with dual (USB+DATA) options
# WDC on FT450, the high bit of the nybble really
# means something else, but I don't know
# what it is. IE Sometimes LSB comes in as 1, sometime 8...
vx = _mem.mode
vx_data = 3 # Assume N/A unless reset below
if vx == 0: # LSB
pass
elif vx == 1: # USB
pass
elif vx == 2: # USB CW (CW)
pass
elif vx == 3: # AM
pass
elif vx == 4: # FM/NFM
if _mem.mode2 == 1:
vx = 6
else:
vx = 4
pass
elif vx == 5: # USER\L
# This looks different from FT450D
if self.FT450:
vx = 5 # set to new "DIG"
vx_data = 1
else:
# on 450D only 5 used for dig modes, no 13
if _mem.mode2 == 0: # RTTY
vx = 5 # Set to new "DIG"
vx_data = 2 # RTTY
elif _mem.mode2 == 1: # USER-L
vx = 5 # set to new "DIG"
vx_data = 0
elif _mem.mode2 == 2: # USER-U variant
vx = 5 # Set to new "DIG"
vx_data = 1 # USER-U with Split?
elif vx == 8: # LSB
vx = 0
elif vx == 9: # USB
vx = 1
elif vx == 10: # LSB CW (CWR)
vx = 7 # CWR
elif vx == 13:
if _mem.mode2 == 0: # RTTY
vx = 5 # Set to new "DIG"
vx_data = 2 # RTTY
elif _mem.mode2 == 1: # USER-L
vx = 5 # set to new "DIG"
vx_data = 0
elif _mem.mode2 == 2: # USER-U variant
vx = 5 # Set to new "DIG"
vx_data = 1 # USER-U with Split?
else:
LOG.error("unknown combo of mem.mode 13 and mem mode 2: %s %s",
vx,_mem.mode2)
else:
LOG.error("unknown _mem.mode value : %s", vx)
try:
mem.mode = self.MODES[vx]
except ValueError:
LOG.error('The FT-450 driver is broken for unsupported modes')
if mem.mode == "FM" or mem.mode == "NFM":
mem.tuning_step = self.STEPSFM[_mem.fm_step]
elif mem.mode == "AM":
mem.tuning_step = self.STEPSAM[_mem.am_step]
elif mem.mode[:2] == "CW":
mem.tuning_step = self.STEPSSSB[_mem.ssb_step]
else:
try:
mem.tuning_step = self.STEPSSSB[_mem.ssb_step]
except IndexError:
pass
self._get_tmode(mem, _mem)
if _mem.tag_on_off == 2:
for i in _mem.name:
if i == 0xFF:
break
if chr(i) in self.CHARSET:
mem.name += chr(i)
else:
# radio has some graphical chars that are not supported
# we replace those with a *
LOG.info("Replacing char %x with *" % i)
mem.name += "*"
mem.name = mem.name.rstrip()
else:
mem.name = ""
mem.extra = RadioSettingGroup("extra", "Extra")
# add a new field to handle the new sub-modes if dig
options = DATA_MODES
rs = RadioSetting("data_modes", "DATA MODE",
RadioSettingValueList(options,
current_index=vx_data))
rs.set_doc(_("Selects the data mode a DIG channel uses. RTTY is FSK "
"radioteletype keyed by a terminal unit or RTTY "
"software, while USER-L and USER-U carry audio based "
"data modes such as packet on the lower or upper "
"sideband. N/A is for channels that are not in DIG "
"mode."))
mem.extra.append(rs)
rs = RadioSetting("ipo", "IPO",
RadioSettingValueBoolean(bool(_mem.ipo)))
rs.set_doc(_("Intercept point optimization. Bypasses the receiver's "
"RF preamplifier so that the incoming signal goes "
"straight to the first mixer. This gives up some "
"sensitivity in exchange for better handling of strong "
"signals and high noise levels."))
mem.extra.append(rs)
rs = RadioSetting("att", "ATT",
RadioSettingValueBoolean(bool(_mem.att)))
rs.set_doc(_("Reduces all incoming signals by 20 dB, for use when "
"extremely strong nearby stations or high noise levels "
"degrade reception. Between 30 kHz and 1.7 MHz the radio "
"always attenuates, whatever this setting."))
mem.extra.append(rs)
rs = RadioSetting("cnturon", "Contour Filter",
RadioSettingValueBoolean(_mem.cnturon))
rs.set_doc(_("Turns on the DSP contour filter, which gently cuts or "
"boosts one part of the receive passband. Cutting "
"suppresses interference or excessive components of a "
"signal, boosting brings out the components that make it "
"easier to understand."))
mem.extra.append(rs)
options = ["Peak", "Null"]
rs = RadioSetting("cnturpk", "Contour Filter Mode",
RadioSettingValueList(options,
current_index=_mem.cnturpk))
rs.set_doc(_("Chooses whether the contour filter boosts (Peak) or "
"cuts (Null) the part of the passband it is set to."))
mem.extra.append(rs)
options = ["Low", "High"]
rs = RadioSetting("cnturgn", "Contour Filter Gain",
RadioSettingValueList(options,
current_index=_mem.cnturgn))
rs.set_doc(_("Sets how strongly the contour filter boosts or cuts. "
"Low gives a gentle effect, High a stronger one."))
mem.extra.append(rs)
options = ["-2", "-1", "Center", "+1", "+2"]
rs = RadioSetting("cnturmd", "Contour Filter Notch",
RadioSettingValueList(options,
current_index=_mem.cnturmd))
rs.set_doc(_("Moves the part of the passband the contour filter acts "
"on, from -2 at the low end through Center to +2 at the "
"high end."))
mem.extra.append(rs)
rs = RadioSetting("notch", "Notch Filter",
RadioSettingValueBoolean(_mem.notch))
rs.set_doc(_("Turns on the IF notch filter, a narrow and deep filter "
"that removes a single interfering carrier or whistle "
"from inside the receive passband."))
mem.extra.append(rs)
vx = 1
options = ["<-", "Center", "+>"]
if _mem.notch_pos < 0:
vx = 0
if _mem.notch_pos > 0:
vx = 2
rs = RadioSetting("notch_pos", "Notch Position",
RadioSettingValueList(options, current_index=vx))
rs.set_doc(_("Places the IF notch filter below the center of the "
"passband, at the center or above it. The exact notch "
"frequency is fine tuned on the radio with the DSP/SEL "
"knob."))
mem.extra.append(rs)
stx, options = filters_for_mode(mem.mode)
vx = getattr(_mem, stx)
rs = RadioSetting("bpfilter", "IF Bandpass Filter Width",
RadioSettingValueList(all_filters(), options[vx]))
rs.set_doc(_("Sets the width of the DSP IF filter. A narrower filter "
"rejects interference close to the signal, a wider one "
"sounds more natural when the band is quiet. The widths "
"depend on the mode: 1.8, 2.4 or 3.0 kHz for SSB, 300 "
"Hz, 500 Hz or 2.4 kHz for CW, 300 Hz, 2.4 or 3.0 kHz "
"for DIG, 3.0, 6.0 or 9.0 kHz for AM, and 2.5 or 5.0 kHz "
"for FM. A width the mode does not offer is replaced "
"with the closest one it does."))
mem.extra.append(rs)
rs = RadioSetting("dnr_on", "DSP Noise Reduction",
RadioSettingValueBoolean(bool(_mem.dnr_on)))
rs.set_doc(_("Turns on the DSP digital noise reduction, which reduces "
"random background noise on the HF and 50 MHz bands. It "
"is especially effective on SSB."))
mem.extra.append(rs)
options = ["Off", "1", "2", "3", "4", "5", "6", "7",
"8", "9", "10", "11"]
rs = RadioSetting("dnr_val", "DSP Noise Reduction Alg",
RadioSettingValueList(options,
current_index=_mem.dnr_val))
rs.set_doc(_("Selects which of the eleven noise reduction algorithms "
"is used. Each one is designed for a different kind of "
"noise, so try them in turn to find the one that best "
"suppresses the noise currently heard. Off also turns "
"DSP Noise Reduction off."))
mem.extra.append(rs)
return mem # end get_memory
def _set_memory(self, mem, _mem):
if len(mem.name) > 0:
_mem.tag_on_off = 2
else:
_mem.tag_on_off = 1
self._set_duplex(mem, _mem)
_mem.mode2 = 0
tmpmemmode = str(mem.mode)
if mem.mode == "DIG":
_mem.mode = 5 # We'll set _mode2 from extra data_modes
elif tmpmemmode == "CWR":
_mem.mode = 10
# 450 looks different
if self.FT450:
_mem.mode2 = 2
else:
_mem.mode2 = 0
elif tmpmemmode == "CW":
_mem.mode = 2
# 450 looks different
if self.FT450:
_mem.mode2 = 2
else:
_mem.mode2 = 0
elif tmpmemmode == "NFM":
_mem.mode = 4
_mem.mode2 = 1
elif tmpmemmode == "FM":
_mem.mode = 4
_mem.mode2 = 2
elif tmpmemmode == "LSB":
_mem.mode = 0
# 450 looks different
if self.FT450:
_mem.mode2 = 2
else:
_mem.mode2 = 0
elif tmpmemmode == "USB":
_mem.mode = 1
if self.FT450:
_mem.mode2 = 2
else:
_mem.mode2 = 0
elif tmpmemmode == "AM":
_mem.mode = 3
if self.FT450:
_mem.mode2 = 2
else:
_mem.mode2 = 0
else: # SHOULD NOT OCCUR
_mem.mode = self.MODES.index(mem.mode)
_mem.mode2 = 0
try:
_mem.ssb_step = self.STEPSSSB.index(mem.tuning_step)
except ValueError:
pass
try:
_mem.am_step = self.STEPSAM.index(mem.tuning_step)
except ValueError:
pass
try:
_mem.fm_step = self.STEPSFM.index(mem.tuning_step)
except ValueError:
pass
_mem.freq = mem.freq
_mem.uprband = 0
if mem.freq >= 33000000:
_mem.uprband = 1
_mem.offset = mem.offset
_mem.tmode = self.TMODES.index(mem.tmode)
_mem.tone = chirp_common.TONES.index(mem.rtone)
_mem.tunerok = 0 # Dont know what these two do...
_mem.tunerbad = 0
for i in range(0, 7):
_mem.name[i] = ord(mem.name.ljust(7)[i])
for setting in mem.extra:
if setting.get_name() == "notch_pos":
vx = 0 # Override list string with signed value
stx = str(setting.value)
if stx == "<-":
vx = -13
if stx == "+>":
vx = 12
setattr(_mem, "notch_pos", vx)
elif setting.get_name() == "dnr_val":
stx = str(setting.value) # Convert string to int
vx = 0
if stx != "Off":
vx = int(stx)
else:
setattr(_mem, "dnr_on", 0)
setattr(_mem, setting.get_name(), vx)
elif setting.get_name() == "data_modes":
if tmpmemmode == "DIG":
stx = str(setting.value)
if stx == "USER-L":
if self.FT450:
_mem.mode = 13
_mem.mode2 = 1
else:
_mem.mode = 5
_mem.mode2 = 1
elif stx == "USER-U":
_mem.mode = 5
_mem.mode2 = 2
elif stx == "RTTY":
if self.FT450:
_mem.mode = 13
_mem.mode2 = 0
else:
_mem.mode = 5
_mem.mode2 = 0
elif stx == "N/A":
_mem.mode = 5
_mem.mode2 = 2
else:
LOG.error("In _set_memory invalid digital data type %s", stx)
elif setting.get_name() == "bpfilter":
element, options = filters_for_mode(mem.mode)
if str(setting.value) in options:
setattr(_mem, element, options.index(str(setting.value)))
else:
default = closest_filter(options, str(setting.value))
LOG.warning('Memory specified filter width of %s for '
'mode %s which is not in allowed list of '
'%s. Defaulting to %s',
str(setting.value), mem.mode,
','.join(options), default)
setattr(_mem, element, options.index(default))
else:
setattr(_mem, setting.get_name(), setting.value)
def _invert_me(self, setting, obj, atrb):
"""Callback: from inverted logic 1-bit booleans"""
invb = not setting.value
setattr(obj, atrb, invb)
return
def _chars2str(self, cary, knt):
"""Convert raw memory char array to a string: NOT a callback."""
stx = ""
for char in cary[0:knt]:
stx += chr(int(char))
return stx
def _my_str2ary(self, setting, obj, atrba, knt):
"""Callback: convert string to fixed-length char array.."""
ary = ""
for j in range(0, knt, 1):
chx = ord(str(setting.value)[j])
if chx < 32 or chx > 125: # strip non-printing
ary += " "
else:
ary += str(setting.value)[j]
setattr(obj, atrba, ary)
return
def get_settings(self):
_settings = self._memobj.settings
_beacon = self._memobj.beacontext
gen = RadioSettingGroup("gen", "General")
cw = RadioSettingGroup("cw", "CW")
pnlcfg = RadioSettingGroup("pnlcfg", "Panel buttons")
pnlset = RadioSettingGroup("pnlset", "Panel settings")
voxdat = RadioSettingGroup("voxdat", "VOX and Data")
mic = RadioSettingGroup("mic", "Microphone")
mybands = RadioSettingGroup("mybands", "My Bands")
mymodes = RadioSettingGroup("mymodes", "My Modes")
top = RadioSettings(gen, cw, pnlcfg, pnlset, voxdat, mic,
mymodes, mybands)
self._do_general_settings(gen)
self._do_cw_settings(cw)
self._do_panel_buttons(pnlcfg)
self._do_panel_settings(pnlset)
self._do_vox_settings(voxdat)
self._do_mic_settings(mic)
self._do_mymodes_settings(mymodes)
self._do_mybands_settings(mybands)
return top
def _do_general_settings(self, tab):
_settings = self._memobj.settings
rs = RadioSetting("ext_mnu", "Extended menu",
RadioSettingValueBoolean(_settings.ext_mnu))
rs.set_doc(_("Shows all 62 items of the radio's Menu Mode. When off, "
"the menu on the radio offers only the 16 most often "
"used items."))
tab.append(rs)
# Issue #8183 bugfix
rs = RadioSetting("apo", "APO time (Hrs)",
RadioSettingValueInteger(0, 12, _settings.apo))
rs.set_doc(_("Turns the radio off automatically once no button, knob "
"or microphone key has been used and nothing has been "
"transmitted for the selected number of hours. APO "
"flashes on the display and a tone sounds in the last "
"minute before the radio switches off. 0 disables "
"automatic power off."))
tab.append(rs)
options = ["%i" % i for i in range(0, 21)]
options[0] = "Off"
rs = RadioSetting("tot", "TX 'TOT' time-out (mins)",
RadioSettingValueList(options,
current_index=_settings.tot))
rs.set_doc(_("Limits how long a single transmission may last. When "
"the time runs out the radio stops transmitting until "
"PTT is released, which prevents overheating and stops a "
"stuck PTT from blocking the channel for everyone else."))
tab.append(rs)
bx = not _settings.cat_rts # Convert from Enable=0
rs = RadioSetting("cat_rts", "CAT RTS flow control",
RadioSettingValueBoolean(bx))
rs.set_apply_callback(self._invert_me, _settings, "cat_rts")
rs.set_doc(_("Enables the RTS line of the CAT jack. Turn it off when "
"the computer or cable does not provide RTS. A radio "
"that follows the frequency of another radio set to "
"F-TRANS also needs it off."))
tab.append(rs)
options = ["0", "100ms", "1000ms", "3000ms"]
rs = RadioSetting("cat_tot", "CAT Timeout",
RadioSettingValueList(options,
current_index=_settings.cat_tot))
rs.set_doc(_("Sets the time-out timer for computer control commands "
"arriving on the CAT jack. Command input that continues "
"for longer than this time is cut off. The radio shows "
"the shortest setting as 10 ms."))
tab.append(rs)
options = ["4800", "9600", "19200", "38400", "Data"]
rs = RadioSetting("catrate", "CAT rate",
RadioSettingValueList(options,
current_index=_settings.catrate))
rs.set_doc(_("Sets the baud rate of the CAT jack, which must match "
"the computer control software. Data turns the CAT jack "
"into an RTTY interface instead: RTTY software keys the "
"FSK shift through the serial data input and uses RTS as "
"PTT."))
tab.append(rs)
rs = RadioSetting("mem_grp", "Mem groups",
RadioSettingValueBoolean(_settings.mem_grp))
rs.set_doc(_("Divides the 500 regular memory channels into ten groups "
"of 50, numbered M-01-01 to M-10-50. Channels are then "
"selected and scanned one group at a time."))
tab.append(rs)
rs = RadioSetting("scn_res", "Resume scan (secs)",
RadioSettingValueInteger(0, 10, _settings.scn_res))
rs.set_doc(_("Sets when the scan resumes after it has paused on a "
"signal. 1 to 10 resumes after that many seconds, 0 "
"selects BUSY, which waits until the signal has gone. In "
"SSB, CW and SSB based data modes the scanner instead "
"steps slowly across a signal, giving you time to stop "
"it."))
tab.append(rs)
rs = RadioSetting("clk_sft", "CPU clock shift",
RadioSettingValueBoolean(_settings.clk_sft))
rs.set_doc(_("Shifts the frequency of the radio's CPU clock slightly. "
"Only use it to move an internally generated spurious "
"signal, or birdie, off a frequency you want to listen "
"on."))
tab.append(rs)
rs = RadioSetting("split", "TX/RX Frequency Split",
RadioSettingValueBoolean(_settings.split))
rs.set_doc(_("Turns on split frequency operation: the radio receives "
"on VFO-A and transmits on VFO-B, or the other way "
"round. The two VFOs may use different modes and even "
"different bands."))
tab.append(rs)
rs = RadioSetting("qspl_f", "Quick-Split freq offset (kHz)",
RadioSettingValueInteger(-20, 20, _settings.qspl_f))
rs.set_doc(_("Sets the offset Quick Split applies. Holding SPLIT/STEP "
"for a second sets the transmit VFO to the receive "
"frequency plus this offset, in the same mode as the "
"receive VFO, and turns split operation on."))
tab.append(rs)
rs = RadioSetting("emergen", "Alaska Emergency Mem 5167.5 kHz",
RadioSettingValueBoolean(_settings.emergen))
rs.set_doc(_("Enables transmit and receive on the Alaska emergency "
"channel, 5167.5 kHz, which then appears as MEM-EMG in "
"Memory mode. It may only be used by stations in or "
"within 92.6 km of Alaska, and only for emergency "
"communications involving the immediate protection of "
"life or property."))
tab.append(rs)
rs = RadioSetting("stby_beep", "PTT release 'Standby' beep",
RadioSettingValueBoolean(_settings.stby_beep))
rs.set_doc(_("Transmits a short beep when PTT is released, before the "
"radio returns to receive, to tell other stations that "
"your transmission has ended."))
tab.append(rs)
options = ["ATAS", "EXT ATU", "INT ATU", "INTRATU", "F-TRANS"]
rs = RadioSetting("tuner", "Antenna Tuner",
RadioSettingValueList(options,
current_index=_settings.tuner))
rs.set_doc(_("Selects what the TUNE button controls. ATAS is the "
"optional ATAS-100/-120 active-tuning antenna, EXT ATU "
"the optional FC-40 external tuner, and INT ATU the "
"built-in tuner acting on the transmit signal only, "
"while INTRATU puts the built-in tuner in the receive "
"path as well. F-TRANS instead sends this radio's "
"frequency to a second radio of the same model whenever "
"TUNE is pressed, for single operator two radio (SO2R) "
"operation."))
tab.append(rs)
rs = RadioSetting("rfpower", "RF power (watts)",
RadioSettingValueInteger(5, 100, _settings.rfpower))
rs.set_doc(_("Sets the transmit power in watts. Use the lowest power "
"that provides reliable communication, and a half to a "
"third of full power for data transmissions longer than "
"a few minutes."))
tab.append(rs) # End of _do_general_settings
def _do_cw_settings(self, cw): # - - - CW - - -
_settings = self._memobj.settings
_beacon = self._memobj.beacontext
rs = RadioSetting("cw_dly", "CW break-in delay (ms * 10)",
RadioSettingValueInteger(0, 300, _settings.cw_dly))
rs.set_doc(_("Sets how long the transmitter stays on after you stop "
"sending in semi break-in CW, in steps of 10 ms, so 25 "
"means 250 ms. A longer delay suits operators who pause "
"often while sending. The radio can also be set to FULL, "
"full break-in, which lets you hear between the "
"characters you send."))
cw.append(rs)
options = ["%i Hz" % i for i in range(400, 801, 100)]
rs = RadioSetting("cwpitch", "CW pitch",
RadioSettingValueList(options,
current_index=_settings.cwpitch))
rs.set_doc(_("Sets the pitch of the CW sidetone, which is also the "
"offset of the transmitted carrier and the center of the "
"CW receive filter. Tuning a station in until its tone "
"matches the sidetone puts you on its frequency."))
cw.append(rs)
rs = RadioSetting("cwspeed", "CW speed (wpm)",
RadioSettingValueInteger(4, 60, _settings.cwspeed))
rs.set_doc(_("Sets the sending speed of the built-in electronic keyer "
"in words per minute. The radio can also show it in "
"characters per minute, five times the wpm value. With a "
"CW QSK delay of 25 ms keep it at 50 wpm or below, and "
"with 30 ms at 42 wpm or below, or the radio cannot "
"transmit."))
cw.append(rs)
options = ["1:%1.1f" % (i / 10) for i in range(25, 46, 1)]
rs = RadioSetting("cwweigt", "CW weight",
RadioSettingValueList(options,
current_index=_settings.cwweigt))
rs.set_doc(_("Sets the dot to dash ratio of the built-in electronic "
"keyer. At 1:3.0, the standard weighting, a dash lasts "
"three times as long as a dot."))
cw.append(rs)
options = ["15ms", "20ms", "25ms", "30ms"]
rs = RadioSetting("cw_qsk", "CW delay before TX in QSK mode",
RadioSettingValueList(options,
current_index=_settings.cw_qsk))
rs.set_doc(_("Sets the delay between closing the key and the carrier "
"being transmitted in QSK operation with the built-in "
"keyer. At 25 ms keep the CW speed at 50 wpm or below, "
"and at 30 ms at 42 wpm or below, or the radio cannot "
"transmit."))
cw.append(rs)
rs = RadioSetting("cwstone_sgn", "CW sidetone volume Linked",
RadioSettingValueBoolean(_settings.cwstone_sgn))
rs.set_doc(_("Makes the CW sidetone volume follow the AF GAIN knob, "
"offset by the CW sidetone linked volume. When off, the "
"sidetone plays at the CW sidetone fixed volume whatever "
"the AF GAIN setting."))
cw.append(rs)
rs = RadioSetting("cwstone_lnk", "CW sidetone linked volume",
RadioSettingValueInteger(-50, 50,
_settings.cwstone_lnk))
rs.set_doc(_("Sets the sidetone volume relative to the receive audio "
"level set by AF GAIN, when CW sidetone volume Linked is "
"on. 0 makes the sidetone as loud as the received audio, "
"negative values make it quieter and positive values "
"louder."))
cw.append(rs)
rs = RadioSetting("cwstone_fix", "CW sidetone fixed volume",
RadioSettingValueInteger(0, 100,
_settings.cwstone_fix))
rs.set_doc(_("Sets the CW sidetone volume, from 0 to 100, used when "
"CW sidetone volume Linked is off."))
cw.append(rs)
options = ["Numeric", "Alpha", "Mixed"]
rs = RadioSetting("cwtrain", "CW Training mode",
RadioSettingValueList(options,
current_index=_settings.cwtrain))
rs.set_doc(_("Selects the characters the CW training feature sends: "
"digits only, letters only, or both mixed. Training "
"plays random five character Morse groups through the "
"sidetone at the CW speed, without transmitting."))
cw.append(rs)
rs = RadioSetting("cw_auto", "CW key jack- auto CW mode",
RadioSettingValueBoolean(_settings.cw_auto))
rs.set_doc(_("Lets the KEY jack send CW while the radio is in SSB "
"mode, so you can answer a station in CW without "
"changing mode. When off, the KEY jack only works in CW "
"mode."))
cw.append(rs)
options = ["Normal", "Reverse"]
rs = RadioSetting("cw_key", "CW paddle wiring",
RadioSettingValueList(options,
current_index=_settings.cw_key))
rs.set_doc(_("Swaps the dot and dash sides of a keyer paddle without "
"rewiring it, for example for a left-handed operator. "
"Normal sends dots from the plug tip and dashes from the "
"ring, Reverse the other way round."))
cw.append(rs)
rs = RadioSetting("beacon_time", "CW beacon Tx interval (secs)",
RadioSettingValueInteger(0, 255,
_settings.beacon_time))
rs.set_doc(_("Sets the pause in seconds between repeats of a CW "
"beacon message. 0 turns the repeat off, so that each "
"message is sent once per button press, as with a CW "
"message keyer."))
cw.append(rs)
tmp = self._chars2str(_beacon.t1, 40)
rs = RadioSetting("t1", "CW Beacon Line 1",
RadioSettingValueString(0, 40, tmp))
rs.set_apply_callback(self._my_str2ary, _beacon, "t1", 40)
rs.set_doc(_("CW beacon message 1, up to 40 characters, sent in CW "
"mode by the PLAY1 function of a programmable button. "
"The radio can send A to Z, 0 to 9, /, space and @."))
cw.append(rs)
tmp = self._chars2str(_beacon.t2, 40)
rs = RadioSetting("t2", "CW Beacon Line 2",
RadioSettingValueString(0, 40, tmp))
rs.set_apply_callback(self._my_str2ary, _beacon, "t2", 40)
rs.set_doc(_("CW beacon message 2, up to 40 characters, sent in CW "
"mode by the PLAY2 function of a programmable button. "
"The radio can send A to Z, 0 to 9, /, space and @."))
cw.append(rs)
tmp = self._chars2str(_beacon.t3, 40)
rs = RadioSetting("t3", "CW Beacon Line 3",
RadioSettingValueString(0, 40, tmp))
rs.set_apply_callback(self._my_str2ary, _beacon, "t3", 40)
rs.set_doc(_("CW beacon message 3, up to 40 characters, sent in CW "
"mode by the PLAY3 function of a programmable button. "
"The radio can send A to Z, 0 to 9, /, space and @."))
cw.append(rs) # END _do_cw_settings
def _do_panel_settings(self, pnlset): # - - - Panel settings
_settings = self._memobj.settings
bx = not _settings.amfmdial # Convert from Enable=0
rs = RadioSetting("amfmdial", "AM&FM Dial",
RadioSettingValueBoolean(bx))
rs.set_apply_callback(self._invert_me, _settings, "amfmdial")
rs.set_doc(_("Lets the MAIN DIAL knob change the frequency in AM and "
"FM modes. When off, the MAIN DIAL does not tune in "
"these modes."))
pnlset.append(rs)
options = ["440 Hz", "880 Hz", "1760 Hz"]
rs = RadioSetting("beepton", "Beep frequency",
RadioSettingValueList(options,
current_index=_settings.beepton))
rs.set_doc(_("Sets the pitch of the beep the radio sounds to confirm "
"button presses."))
pnlset.append(rs)
rs = RadioSetting("beepvol_sgn", "Beep volume Linked",
RadioSettingValueBoolean(_settings.beepvol_sgn))
rs.set_doc(_("Makes the beep volume follow the AF GAIN knob, offset "
"by the Linked beep volume. When off, the beep plays at "
"the Fixed beep volume whatever the AF GAIN setting."))
pnlset.append(rs)
rs = RadioSetting("beepvol_lnk", "Linked beep volume",
RadioSettingValueInteger(-50, 50,
_settings.beepvol_lnk))
rs.set_doc(_("Sets the beep volume relative to the receive audio "
"level set by AF GAIN, when Beep volume Linked is on. 0 "
"makes the beep as loud as the received audio, negative "
"values make it quieter and positive values louder."))
pnlset.append(rs)
rs = RadioSetting("beepvol_fix", "Fixed beep volume",
RadioSettingValueInteger(0, 100,
_settings.beepvol_fix))
rs.set_doc(_("Sets the beep volume, from 0 to 100, used when Beep "
"volume Linked is off."))
pnlset.append(rs)
rs = RadioSetting("cont", "LCD Contrast",
RadioSettingValueInteger(1, 24, _settings.cont))
rs.set_doc(_("Sets the contrast of the display, from 1 to 24. "
"Changing it here has not been seen to have a visible "
"effect on the radio."))
pnlset.append(rs)
rs = RadioSetting("dimmer", "LCD Dimmer",
RadioSettingValueInteger(1, 8, _settings.dimmer))
rs.set_doc(_("Sets the brightness of the display illumination, from 1 "
"to 8."))
pnlset.append(rs)
options = ["RF-Gain", "Squelch"]
rs = RadioSetting("sql_rfg", "Squelch/RF-Gain",
RadioSettingValueList(options,
current_index=_settings.sql_rfg))
rs.set_doc(_("Chooses what the SQL/RF GAIN knob controls. RF-Gain "
"sets the gain of the receiver's RF and IF stages, "
"Squelch mutes the receiver while no signal is present. "
"Scanning needs Squelch, because the scanner stops on "
"signals strong enough to open the squelch."))
pnlset.append(rs)
options = ["Frequencies", "Panel", "All"]
rs = RadioSetting("lockmod", "Lock Mode",
RadioSettingValueList(options,
current_index=_settings.lockmod))
rs.set_doc(_("Selects what the LOCK button locks. Frequencies locks "
"the controls that change the frequency, including the "
"microphone UP, DWN and FAST keys. Panel locks all front "
"panel keys and knobs, and All locks both the front "
"panel and the microphone keys. POWER and LOCK always "
"remain usable."))
pnlset.append(rs)
options = ["Dial", "SEL"]
rs = RadioSetting("clar_btn", "CLAR button control",
RadioSettingValueList(options,
current_index=_settings.clar_btn))
rs.set_doc(_("Chooses which knob sets the clarifier offset after CLAR "
"is pressed: the MAIN DIAL or the DSP/SEL knob. The "
"clarifier shifts the receive frequency without changing "
"the transmit frequency."))
pnlset.append(rs)
if _settings.dialstp_mode == 0: # AM/FM
options = ["SSB/CW:1Hz", "SSB/CW:10Hz", "SSB/CW:20Hz"]
else:
options = ["AM/FM:100Hz", "AM/FM:200Hz"]
rs = RadioSetting("dialstp", "Dial tuning step",
RadioSettingValueList(options,
current_index=_settings.dialstp))
rs.set_doc(_("Sets how far the frequency moves for each step of the "
"MAIN DIAL knob: 1, 10 or 20 Hz in SSB and CW, 100 or "
"200 Hz in AM and FM."))
pnlset.append(rs)
options = ["0.5secs", "1.0secs", "1.5secs", "2.0secs"]
rs = RadioSetting("keyhold", "Buttons hold-to-activate time",
RadioSettingValueList(options,
current_index=_settings.keyhold))
rs.set_doc(_("Sets how long a button has to be held to activate its "
"press and hold function. A shorter press activates the "
"button's normal function."))
pnlset.append(rs)
rs = RadioSetting("m_tune", "Memory tune",
RadioSettingValueBoolean(_settings.m_tune))
rs.set_doc(_("Allows tuning away from a recalled memory or Home "
"channel with the MAIN DIAL, as with a VFO. The stored "
"channel does not change unless you write the new "
"settings to it."))
pnlset.append(rs)
rs = RadioSetting("peakhold", "S-Meter display hold (1sec)",
RadioSettingValueBoolean(_settings.peakhold))
rs.set_doc(_("Holds the peak S-meter reading for one second, which "
"makes the meter easier to read."))
pnlset.append(rs)
options = ["CW Sidetone", "CW Speed", "100 kHz step", "1 MHz Step",
"Mic Gain", "RF Power"]
rs = RadioSetting("seldial", "SEL dial 2nd function (push)",
RadioSettingValueList(options,
current_index=_settings.seldial))
rs.set_doc(_("Assigns the second function the DSP/SEL knob takes on "
"after it is pressed briefly: adjusting the CW sidetone "
"volume, the CW keyer speed, the microphone gain or the "
"RF power, or tuning in 100 kHz or 1 MHz steps."))
pnlset.append(rs)
# End _do_panel_settings
def _do_panel_buttons(self, pnlcfg): # - - - Current Panel Config
_settings = self._memobj.settings
rs = RadioSetting("pnl_cs", "C.S. Function",
RadioSettingValueList(self.FUNC_LIST,
current_index=_settings.pnl_cs))
rs.set_doc(_("Assigns one of the radio's functions to the front panel "
"C.S/VOICE button, for example MONI to listen to your "
"own transmission, SWR to transmit a 10 W carrier and "
"measure the antenna SWR, or PLAY1 to send CW beacon "
"message 1. Choices named after a front panel button act "
"like that button."))
pnlcfg.append(rs)
rs = RadioSetting("nb", "Noise blanker",
RadioSettingValueBoolean(_settings.nb))
rs.set_doc(_("Turns on the IF noise blanker, which reduces short "
"pulses of noise such as those from vehicle ignition "
"systems."))
pnlcfg.append(rs)
# The old FT450 uses different codes for the AGC setting, and only uses the
# last 3 bits of the AGC definition. The two upper bits appear to always be x"11"
# We will mask this in the routine that processes the agc value
if self.FT450:
options = ["Auto", "Fast", "Slow", "UNK3", "UNK4", "UNK5", "OFF", "UNK7"]
# mask off the two upper bits of the agc settings value
FT450agc = _settings.agc & int('0x7',16)
rs = RadioSetting("agc", "AGC",
RadioSettingValueList(options,
current_index=FT450agc))
else:
options = ["Auto", "Fast", "Slow", "Auto/Fast", "Auto/Slow", "?5?"]
rs = RadioSetting("agc", "AGC",
RadioSettingValueList(options,
current_index=_settings.agc))
rs.set_doc(_("Selects how quickly the automatic gain control lets the "
"receiver recover after a strong signal. Fast suits CW "
"and data, Slow suits SSB and AM, and Auto picks Slow "
"for SSB and AM and Fast for the other modes. With AGC "
"off the S-meter no longer moves and strong signals are "
"likely to distort."))
pnlcfg.append(rs)
rs = RadioSetting("keyer", "Keyer",
RadioSettingValueBoolean(_settings.keyer))
rs.set_doc(_("Turns on the built-in electronic CW keyer, for a keyer "
"paddle plugged into the KEY jack. Turn it off to use a "
"straight key or an external keyer."))
pnlcfg.append(rs)
rs = RadioSetting("fast", "Fast step",
RadioSettingValueBoolean(_settings.fast))
rs.set_doc(_("Speeds up tuning: the MAIN DIAL knob tunes ten times "
"faster and the DSP/SEL knob twice as fast."))
pnlcfg.append(rs)
rs = RadioSetting("lock", "Lock (per Lock Mode)",
RadioSettingValueBoolean(_settings.lock))
rs.set_doc(_("Locks the controls selected by Lock Mode against "
"accidental changes, as the LOCK button does."))
pnlcfg.append(rs)
options = ["PO", "ALC", "SWR"]
rs = RadioSetting("mtr_mode", "S-Meter mode",
RadioSettingValueList(options,
current_index=_settings.mtr_mode))
rs.set_doc(_("Selects what the meter shows while transmitting: PO the "
"average power output, ALC the relative ALC voltage, or "
"SWR the standing wave ratio of the antenna. While "
"receiving it always shows the signal strength."))
pnlcfg.append(rs)
# End _do_panel_Buttons
def _do_vox_settings(self, voxdat): # - - VOX and DATA Settings
_settings = self._memobj.settings
rs = RadioSetting("vox_dly", "VOX delay (x 100 ms)",
RadioSettingValueInteger(1, 30, _settings.vox_dly))
rs.set_doc(_("Sets how long the transmitter stays on after you stop "
"speaking in VOX operation, in steps of 100 ms, so 5 "
"means 500 ms. A longer delay keeps short pauses in your "
"speech from switching the radio back to receive."))
voxdat.append(rs)
rs = RadioSetting("vox_gain", "VOX Gain",
RadioSettingValueInteger(0, 100,
_settings.vox_gain))
rs.set_doc(_("Sets the VOX sensitivity. Too sensitive a setting keys "
"the transmitter on the noise around the radio, too "
"insensitive a setting fails to pick up your voice. 1 is "
"the least sensitive setting and 100 the most."))
voxdat.append(rs)
rs = RadioSetting("dig_vox", "Digital VOX Gain",
RadioSettingValueInteger(0, 100,
_settings.dig_vox))
rs.set_doc(_("Sets the VOX sensitivity used in DIG mode, so that the "
"audio from the data equipment switches the transmitter "
"on without a PTT line. 0 turns VOX off in DIG mode."))
voxdat.append(rs)
rs = RadioSetting("d_disp", "User-L/U freq offset (Hz)",
RadioSettingValueInteger(-3000, 30000,
_settings.d_disp, 10))
rs.set_doc(_("Shifts the frequency shown on the display in the USER-L "
"and USER-U data modes by this many hertz. The radio "
"accepts -3000 to +3000 Hz."))
voxdat.append(rs)
options = ["170 Hz", "200 Hz", "425 Hz", "850 Hz"]
rs = RadioSetting("rty_sft", "RTTY FSK Freq Shift",
RadioSettingValueList(options,
current_index=_settings.rty_sft))
rs.set_doc(_("Sets the frequency shift between the mark and space "
"tones in FSK RTTY. Most amateur RTTY uses 170 Hz."))
voxdat.append(rs)
options = ["1275 Hz", "2125 Hz"]
rs = RadioSetting("rty_ton", "RTTY FSK Mark tone",
RadioSettingValueList(options,
current_index=_settings.rty_ton))
rs.set_doc(_("Selects the mark tone for RTTY: 2125 Hz for high tone "
"operation or 1275 Hz for low tone operation."))
voxdat.append(rs)
options = ["Normal", "Reverse"]
rs = RadioSetting("rtyrpol", "RTTY Mark/Space RX polarity",
RadioSettingValueList(options,
current_index=_settings.rtyrpol))
rs.set_doc(_("Swaps the mark and space tones when receiving RTTY. Try "
"Reverse if a station with a good signal cannot be "
"decoded."))
voxdat.append(rs)
rs = RadioSetting("rtytpol", "RTTY Mark/Space TX polarity",
RadioSettingValueList(options,
current_index=_settings.rtytpol))
rs.set_doc(_("Swaps the mark and space tones of your transmitted RTTY "
"signal."))
voxdat.append(rs)
# End _do_vox_settings
def _do_mic_settings(self, mic): # - - MIC Settings
_settings = self._memobj.settings
rs = RadioSetting("mic_eq", "Mic Equalizer",
RadioSettingValueInteger(0, 9, _settings.mic_eq))
rs.set_doc(_("Selects one of ten DSP equalizer curves for your "
"transmitted voice. 0 is flat, 1 to 3 reduce the low, "
"middle or high frequencies, and 4 to 6 boost the high, "
"middle or low frequencies. 7 boosts the lows and "
"reduces the highs, 8 reduces the lows and boosts the "
"middle, and 9 reduces the lows and boosts the highs."))
mic.append(rs)
options = ["Low", "Normal", "High"]
rs = RadioSetting("micgain", "Mic Gain",
RadioSettingValueList(options,
current_index=_settings.micgain))
rs.set_doc(_("Sets the microphone gain for SSB, AM and FM. Use Low "
"with a microphone that has a high output, Normal with "
"the supplied hand microphone and High with a microphone "
"that has a low output. The speech processor is off at "
"Low and on at the other settings."))
mic.append(rs)
rs = RadioSetting("micscan", "Mic scan enabled",
RadioSettingValueBoolean(_settings.micscan))
rs.set_doc(_("When on, holding the microphone UP or DWN key for about "
"a second starts a scan that continues after the key is "
"released. When off, the radio only scans while the key "
"is held down."))
mic.append(rs)
rs = RadioSetting("pm_dwn", "Mic Down button function",
RadioSettingValueList(self.FUNC_LIST,
current_index=_settings.pm_dwn))
rs.set_doc(_("Assigns one of the radio's functions to the DWN key of "
"the microphone. DOWN, its normal function, steps the "
"frequency or memory channel down."))
mic.append(rs)
rs = RadioSetting("pm_fst", "Mic Fast button function",
RadioSettingValueList(self.FUNC_LIST,
current_index=_settings.pm_fst))
rs.set_doc(_("Assigns one of the radio's functions to the FST key of "
"the microphone. FAST, its normal function, speeds up "
"tuning like the front panel FAST button."))
mic.append(rs)
rs = RadioSetting("pm_up", "Mic Up button function",
RadioSettingValueList(self.FUNC_LIST,
current_index=_settings.pm_up))
rs.set_doc(_("Assigns one of the radio's functions to the UP key of "
"the microphone. UP, its normal function, steps the "
"frequency or memory channel up."))
mic.append(rs)
# End _do_mic_settings
def _do_mymodes_settings(self, mymodes): # - - MYMODES
_settings = self._memobj.settings # Inverted Logic requires callback
doc = _("Includes %s in the modes the MODE buttons step through. Turn "
"off the modes you never use to reach the others with fewer "
"presses.")
bx = not _settings.mym_lsb
rs = RadioSetting("mym_lsb", "LSB", RadioSettingValueBoolean(bx))
rs.set_apply_callback(self._invert_me, _settings, "mym_lsb")
rs.set_doc(doc % "LSB")
mymodes.append(rs)
bx = not _settings.mym_usb
rs = RadioSetting("mym_usb", "USB", RadioSettingValueBoolean(bx))
rs.set_apply_callback(self._invert_me, _settings, "mym_usb")
rs.set_doc(doc % "USB")
mymodes.append(rs)
bx = not _settings.mym_cw
rs = RadioSetting("mym_cw", "CW", RadioSettingValueBoolean(bx))
rs.set_apply_callback(self._invert_me, _settings, "mym_cw")
rs.set_doc(doc % "CW")
mymodes.append(rs)
bx = not _settings.mym_am
rs = RadioSetting("mym_am", "AM", RadioSettingValueBoolean(bx))
rs.set_apply_callback(self._invert_me, _settings, "mym_am")
rs.set_doc(doc % "AM")
mymodes.append(rs)
bx = not _settings.mym_fm
rs = RadioSetting("mym_fm", "FM", RadioSettingValueBoolean(bx))
rs.set_apply_callback(self._invert_me, _settings, "mym_fm")
rs.set_doc(doc % "FM")
mymodes.append(rs)
bx = not _settings.mym_data
rs = RadioSetting("mym_data", "DATA", RadioSettingValueBoolean(bx))
rs.set_apply_callback(self._invert_me, _settings, "mym_data")
rs.set_doc(doc % "DATA")
mymodes.append(rs)
# End _do_mymodes_settings
def _do_mybands_settings(self, mybands): # - - MYBANDS Settings
_settings = self._memobj.settings # Inverted Logic requires callback
doc = _("Includes the %s band in the bands the BAND buttons step "
"through. Turn off the bands you never use to reach the "
"others with fewer presses.")
bx = not _settings.myb_1_8
rs = RadioSetting("myb_1_8", "1.8 MHz", RadioSettingValueBoolean(bx))
rs.set_apply_callback(self._invert_me, _settings, "myb_1_8")
rs.set_doc(doc % "1.8 MHz")
mybands.append(rs)
bx = not _settings.myb_3_5
rs = RadioSetting("myb_3_5", "3.5 MHz", RadioSettingValueBoolean(bx))
rs.set_apply_callback(self._invert_me, _settings, "myb_3_5")
rs.set_doc(doc % "3.5 MHz")
mybands.append(rs)
bx = not _settings.myb_7
rs = RadioSetting("myb_7", "7 MHz", RadioSettingValueBoolean(bx))
rs.set_apply_callback(self._invert_me, _settings, "myb_7")
rs.set_doc(doc % "7 MHz")
mybands.append(rs)
bx = not _settings.myb_10
rs = RadioSetting("myb_10", "10 MHz", RadioSettingValueBoolean(bx))
rs.set_apply_callback(self._invert_me, _settings, "myb_10")
rs.set_doc(doc % "10 MHz")
mybands.append(rs)
bx = not _settings.myb_14
rs = RadioSetting("myb_14", "14 MHz", RadioSettingValueBoolean(bx))
rs.set_apply_callback(self._invert_me, _settings, "myb_14")
rs.set_doc(doc % "14 MHz")
mybands.append(rs)
bx = not _settings.myb_18
rs = RadioSetting("myb_18", "18 MHz", RadioSettingValueBoolean(bx))
rs.set_apply_callback(self._invert_me, _settings, "myb_18")
rs.set_doc(doc % "18 MHz")
mybands.append(rs)
bx = not _settings.myb_21
rs = RadioSetting("myb_21", "21 MHz", RadioSettingValueBoolean(bx))
rs.set_apply_callback(self._invert_me, _settings, "myb_21")
rs.set_doc(doc % "21 MHz")
mybands.append(rs)
bx = not _settings.myb_24
rs = RadioSetting("myb_24", "24 MHz", RadioSettingValueBoolean(bx))
rs.set_apply_callback(self._invert_me, _settings, "myb_24")
rs.set_doc(doc % "24 MHz")
mybands.append(rs)
bx = not _settings.myb_28
rs = RadioSetting("myb_28", "28 MHz", RadioSettingValueBoolean(bx))
rs.set_apply_callback(self._invert_me, _settings, "myb_28")
rs.set_doc(doc % "28 MHz")
mybands.append(rs)
bx = not _settings.myb_50
rs = RadioSetting("myb_50", "50 MHz", RadioSettingValueBoolean(bx))
rs.set_apply_callback(self._invert_me, _settings, "myb_50")
rs.set_doc(doc % "50 MHz")
mybands.append(rs)
# End _do_mybands_settings
def set_settings(self, settings):
_settings = self._memobj.settings
_mem = self._memobj
for element in settings:
if not isinstance(element, RadioSetting):
self.set_settings(element)
continue
else:
try:
name = element.get_name()
if "." in name:
bits = name.split(".")
obj = self._memobj
for bit in bits[: -1]:
if "/" in bit:
bit, index = bit.split("/", 1)
index = int(index)
obj = getattr(obj, bit)[index]
else:
obj = getattr(obj, bit)
setting = bits[-1]
else:
obj = _settings
setting = element.get_name()
if element.has_apply_callback():
LOG.debug("Using apply callback")
element.run_apply_callback()
elif element.value.get_mutable():
LOG.debug("Setting %s = %s" % (setting, element.value))
setattr(obj, setting, element.value)
except Exception:
LOG.debug(element.get_name())
raise
def validate_memory(self, mem):
msgs = super().validate_memory(mem)
if 'bpfilter' in mem.extra:
_, options = filters_for_mode(mem.mode)
bpfilter = str(mem.extra['bpfilter'].value)
if bpfilter not in options:
msgs.append(chirp_common.ValidationWarning(
('Filter width %s is not allowed for mode %s - '
'the closest suitable option %s will be used') % (
bpfilter, mem.mode,
closest_filter(options, bpfilter))))
return msgs
@directory.register
class FT450Radio(FT450DRadio):
"""Yaesu FT-450"""
FT450 = True
MODEL = "FT-450"
@classmethod
def match_model(cls, filedata, filename):
return False
chirp-20261030/chirp/drivers/ft50.py 0000644 0001750 0001750 00000051141 15154752252 015757 0 ustar hibby hibby # Copyright 2011 Dan Smith
#
# 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 After clicking OK , press the [PTT] switch to send"
" image.\n")
rp.pre_upload = _(
"1. Turn radio off.\n"
"2. Connect cable to MIC/SP jack.\n"
"3. Press and hold [PTT] & Knob while turning the\n"
" radio on.\n"
"4. Press the [MONI] switch (\"WAIT\" will appear on the LCD).\n"
"5. Press OK.\n")
return rp
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.memory_bounds = (1, 100)
rf.valid_duplexes = DUPLEX
rf.valid_tmodes = TMODES
rf.valid_power_levels = POWER_LEVELS
rf.valid_tuning_steps = TUNING_STEPS
rf.valid_power_levels = POWER_LEVELS
rf.valid_characters = "".join(CHARSET)
rf.valid_name_length = 4
rf.valid_modes = MODES
# Specials not yet implemented
# rf.valid_special_chans = SPECIALS
rf.valid_bands = [(76000000, 200000000),
(300000000, 540000000),
(590000000, 999000000)]
# rf.can_odd_split = True
rf.has_ctone = False
rf.has_bank = False
rf.has_settings = True
rf.has_dtcs_polarity = False
return rf
def _checksums(self):
return [yaesu_clone.YaesuChecksum(0x0000, 0xE89)]
def process_mmap(self):
self._memobj = bitwise.parse(MEM_FORMAT, self._mmap)
def get_raw_memory(self, number):
return repr(self._memobj.memory[number - 1])
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 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 _decode_cwid(self, inarr):
LOG.debug("@_decode_chars, type: %s" % type(inarr))
LOG.debug(inarr)
outstr = ""
for i in inarr:
if i == 0xFF:
break
outstr += CHARSET[i & 0x7F]
LOG.debug(outstr)
return outstr.rstrip()
def _encode_cwid(self, instr, length=16):
LOG.debug("@_encode_chars, type: %s" % type(instr))
LOG.debug(instr)
outarr = []
instr = str(instr)
for i in range(0, length):
if i < len(instr):
outarr.append(CHARSET.index(instr[i]))
else:
outarr.append(0xFF)
return outarr
def get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic")
dtmf = RadioSettingGroup("dtmf", "DTMF Code & Paging")
arts = RadioSettingGroup("arts", "ARTS")
autodial = RadioSettingGroup("autodial", "AutoDial")
top = RadioSettings(basic, autodial, arts, dtmf)
rs = RadioSetting(
"squelch", "Squelch",
RadioSettingValueInteger(0, 15, _settings.squelch))
basic.append(rs)
rs = RadioSetting(
"keybeep", "Keypad Beep",
RadioSettingValueBoolean(_settings.keybeep))
basic.append(rs)
rs = RadioSetting(
"scnl", "Scan Lamp",
RadioSettingValueBoolean(_settings.scnl))
basic.append(rs)
options = ["off", "30m", "1h", "3h", "5h", "8h"]
rs = RadioSetting(
"apo", "APO time (hrs)",
RadioSettingValueList(options, current_index=_settings.apo))
basic.append(rs)
options = ["off", "1m", "2.5m", "5m", "10m"]
rs = RadioSetting(
"timeout", "Time Out Timer",
RadioSettingValueList(
options, current_index=_settings.timeout))
basic.append(rs)
options = ["key", "dial", "key+dial", "ptt",
"key+ptt", "dial+ptt", "all"]
rs = RadioSetting(
"lock", "Lock mode",
RadioSettingValueList(options, current_index=_settings.lock))
basic.append(rs)
options = ["off", "0.2", "0.3", "0.5", "1.0", "2.0"]
rs = RadioSetting(
"rxsave", "RX Save (sec)",
RadioSettingValueList(options, current_index=_settings.rxsave))
basic.append(rs)
options = ["5sec", "key", "tgl"]
rs = RadioSetting(
"lamp", "Lamp mode",
RadioSettingValueList(options, current_index=_settings.lamp))
basic.append(rs)
options = ["off", "1", "3", "5", "8", "rpt"]
rs = RadioSetting(
"bell", "Bell Repetitions",
RadioSettingValueList(options, current_index=_settings.bell))
basic.append(rs)
rs = RadioSetting(
"cwid_en", "CWID Enable",
RadioSettingValueBoolean(_settings.cwid_en))
arts.append(rs)
cwid = RadioSettingValueString(
0, 16, self._decode_cwid(_settings.cwid.get_value()))
cwid.set_charset(CHARSET)
rs = RadioSetting("cwid", "CWID", cwid)
arts.append(rs)
options = ["off", "rx", "tx", "trx"]
rs = RadioSetting(
"artsmode", "ARTS Mode",
RadioSettingValueList(
options, current_index=_settings.artsmode))
arts.append(rs)
options = ["off", "in range", "always"]
rs = RadioSetting(
"artsbeep", "ARTS Beep",
RadioSettingValueList(
options, current_index=_settings.artsbeep))
arts.append(rs)
for i in range(0, 8):
dialsettings = _settings.autodial[i]
dialstr = ""
for c in dialsettings.digits:
if c < len(DTMFCHARSET):
dialstr += DTMFCHARSET[c]
dialentry = RadioSettingValueString(0, 16, dialstr)
dialentry.set_charset(DTMFCHARSET + list(" "))
rs = RadioSetting("autodial" + str(i+1),
"AutoDial " + str(i+1), dialentry)
autodial.append(rs)
dialstr = ""
for c in _settings.autodial9_ro.digits:
if c < len(DTMFCHARSET):
dialstr += DTMFCHARSET[c]
dialentry = RadioSettingValueString(0, 32, dialstr)
dialentry.set_mutable(False)
rs = RadioSetting("autodial9_ro", "AutoDial 9 (read only)", dialentry)
autodial.append(rs)
options = ["50ms", "100ms"]
rs = RadioSetting(
"pagingspeed", "Paging Speed",
RadioSettingValueList(
options, current_index=_settings.pagingspeed))
dtmf.append(rs)
options = ["250ms", "450ms", "750ms", "1000ms"]
rs = RadioSetting(
"pagingdelay", "Paging Delay",
RadioSettingValueList(
options, current_index=_settings.pagingdelay))
dtmf.append(rs)
options = ["off", "1", "3", "5", "8", "rpt"]
rs = RadioSetting(
"pagingbell", "Paging Bell Repetitions",
RadioSettingValueList(
options, current_index=_settings.pagingbell))
dtmf.append(rs)
options = ["off", "ans", "for"]
rs = RadioSetting(
"paginganswer", "Paging Answerback",
RadioSettingValueList(options,
current_index=_settings.paginganswer))
dtmf.append(rs)
rs = RadioSetting(
"code_dec_c_en", "Paging Code C Decode Enable",
RadioSettingValueBoolean(_settings.code_dec_c_en))
dtmf.append(rs)
_str = str(_settings.pagingcodec_ro)
code = RadioSettingValueString(0, 3, _str)
code.set_charset(NUMERIC_CHARSET + list(" "))
code.set_mutable(False)
rs = RadioSetting("pagingcodec_ro", "Paging Code C (read only)", code)
dtmf.append(rs)
rs = RadioSetting(
"code_dec_p_en", "Paging Code P Decode Enable",
RadioSettingValueBoolean(_settings.code_dec_p_en))
dtmf.append(rs)
_str = str(_settings.pagingcodep)
code = RadioSettingValueString(0, 3, _str)
code.set_charset(NUMERIC_CHARSET + list(" "))
rs = RadioSetting("pagingcodep", "Paging Code P", code)
dtmf.append(rs)
for i in range(0, 6):
num = str(i+1)
name = "code_dec_" + num + "_en"
rs = RadioSetting(
name, "Paging Code " + num + " Decode Enable",
RadioSettingValueBoolean(getattr(_settings, name)))
dtmf.append(rs)
_str = str(_settings.pagingcode[i].digits)
code = RadioSettingValueString(0, 3, _str)
code.set_charset(NUMERIC_CHARSET + list(" "))
rs = RadioSetting("pagingcode" + num, "Paging Code " + num, code)
dtmf.append(rs)
return top
def set_settings(self, uisettings):
for element in uisettings:
if not isinstance(element, RadioSetting):
self.set_settings(element)
continue
if not element.changed():
continue
try:
setting = element.get_name()
_settings = self._memobj.settings
if re.match(r'autodial\d', setting):
# set autodial fields
dtmfstr = str(element.value).strip()
newval = []
for i in range(0, 16):
if i < len(dtmfstr):
newval.append(DTMFCHARSET.index(dtmfstr[i]))
else:
newval.append(0xFF)
LOG.debug(newval)
idx = int(setting[-1:]) - 1
_settings = self._memobj.settings.autodial[idx]
_settings.digits = newval
continue
if (setting == "pagingcodep"):
_settings.pagingcodep = int(element.value)
continue
if re.match(r'pagingcode\d', setting):
idx = int(setting[-1:]) - 1
_settings.pagingcode[idx].digits = int(element.value)
continue
newval = element.value
oldval = getattr(_settings, setting)
if setting == "cwid":
newval = self._encode_cwid(newval)
LOG.debug("Setting %s(%s) <= %s" % (setting, oldval, newval))
setattr(_settings, setting, newval)
except Exception:
LOG.debug(element.get_name())
raise
@classmethod
def match_model(cls, filedata, filename):
return len(filedata) == cls._memsize
def sync_out(self):
self.update_checksums()
return _clone_out(self)
def _clone_out(radio):
try:
return __clone_out(radio)
except Exception as e:
raise errors.RadioError("Failed to communicate with the radio: %s" % e)
def __clone_out(radio):
pipe = radio.pipe
pipe.timeout = 1
block_lengths = radio._block_lengths
total_written = 0
def _status():
status = chirp_common.Status()
status.msg = "Cloning to radio"
status.max = sum(block_lengths)
status.cur = total_written
radio.status_fn(status)
start = time.time()
blocks = 0
pos = 0
for block in radio._block_lengths:
blocks += 1
data = radio.get_mmap()[pos:pos + block]
# LOG.debug("Sending block: %s" % util.hexprint(data))
recvd = b""
# Radio echos every block received
for byte in data:
time.sleep(0.01)
pipe.write(bytes([byte]))
# flush & sleep so don't loose ack
pipe.flush()
time.sleep(0.015)
recvd += pipe.read(1) # chew the echo
# LOG.debug("Echo was %s" % util.hexprint(recvd))
LOG.debug("Bytes sent: %i" % len(data))
# Radio does not ack last block
if (blocks < 8):
buf = pipe.read(block)
LOG.debug("ACK attempt: " + util.hexprint(buf))
if buf and buf[0] != yaesu_clone.CMD_ACK:
buf = pipe.read(block)
if not buf or buf[-1] != yaesu_clone.CMD_ACK:
raise errors.RadioError("Radio did not ack block %i" % blocks)
total_written += len(data)
_status()
pos += block
pipe.read(pos) # Chew the echo if using a 2-pin cable
LOG.debug("Clone completed in %i seconds" % (time.time() - start))
chirp-20261030/chirp/drivers/ft60.py 0000644 0001750 0001750 00000065212 15172631605 015762 0 ustar hibby hibby # Copyright 2011 Dan Smith
#
# 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 After clicking OK , hold the [PTT] switch\n"
" for one second to send image.\n")
rp.pre_upload = _(
"1. Turn radio off.\n"
"2. Connect cable to MIC/SP jack.\n"
"3. Press and hold in the [MONI] switch while turning the\n"
" radio on.\n"
"4. Rotate the DIAL job to select \"F8 CLONE\".\n"
"5. Press the [F/W] key momentarily.\n"
"6. Press the [MONI] switch (\"--RX--\" will appear on the"
" LCD).\n")
return rp
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.memory_bounds = (1, 1000)
rf.valid_duplexes = DUPLEX[1:]
rf.valid_tmodes = [x for x in TMODES if '->' not in x] + ['Cross']
rf.valid_cross_modes = ['Tone->DTCS', 'DTCS->Tone', 'DTCS->']
rf.valid_power_levels = POWER_LEVELS
rf.valid_tuning_steps = STEPS
rf.valid_skips = SKIPS
rf.valid_special_chans = SPECIALS
rf.valid_characters = CHARSET
rf.valid_name_length = 6
rf.valid_modes = ["FM", "NFM", "AM"]
rf.valid_bands = [(108000000, 520000000), (700000000, 999990000)]
rf.can_odd_split = True
rf.has_ctone = False
rf.has_bank = True
rf.has_settings = True
rf.has_dtcs_polarity = False
return rf
def get_bank_model(self):
return FT60BankModel(self)
def _checksums(self):
return [yaesu_clone.YaesuChecksum(0x0000, 0x6FC7)]
def sync_in(self):
try:
self._mmap = _download(self)
except errors.RadioError:
raise
except Exception as e:
raise errors.RadioError("Failed to communicate with radio: %s" % e)
self.process_mmap()
self.check_checksums()
def sync_out(self):
self.update_checksums()
try:
_upload(self)
except errors.RadioError:
raise
except Exception as e:
raise errors.RadioError("Failed to communicate with radio: %s" % e)
def process_mmap(self):
self._memobj = bitwise.parse(MEM_FORMAT, self._mmap)
def get_settings(self):
_settings = self._memobj.settings
repeater = RadioSettingGroup("repeater", "Repeater Settings")
ctcss = RadioSettingGroup("ctcss", "CTCSS/DCS/DTMF Settings")
arts = RadioSettingGroup("arts", "ARTS Settings")
scan = RadioSettingGroup("scan", "Scan Settings")
power = RadioSettingGroup("power", "Power Saver Settings")
wires = RadioSettingGroup("wires", "WiRES(tm) Settings")
eai = RadioSettingGroup("eai", "EAI/EPCS Settings")
switch = RadioSettingGroup("switch", "Switch/Knob Settings")
misc = RadioSettingGroup("misc", "Miscellaneous Settings")
mbls = RadioSettingGroup("banks", "Memory Bank Link Scan")
setmode = RadioSettings(repeater, ctcss, arts, scan, power,
wires, eai, switch, misc, mbls)
# APO
opts = ["OFF"] + ["%0.1f" % (x * 0.5) for x in range(1, 24 + 1)]
misc.append(
RadioSetting(
"apo", "Automatic Power Off",
RadioSettingValueList(opts, current_index=_settings.apo)))
# AR.BEP
opts = ["OFF", "INRANG", "ALWAYS"]
arts.append(
RadioSetting(
"ar_bep", "ARTS Beep",
RadioSettingValueList(opts, current_index=_settings.ar_bep)))
# AR.INT
opts = ["25 SEC", "15 SEC"]
arts.append(
RadioSetting(
"ar_int", "ARTS Polling Interval",
RadioSettingValueList(opts, current_index=_settings.ar_int)))
# ARS
opts = ["OFF", "ON"]
repeater.append(
RadioSetting(
"ars", "Automatic Repeater Shift",
RadioSettingValueList(opts, current_index=_settings.ars)))
# BCLO
opts = ["OFF", "ON"]
misc.append(RadioSetting(
"bclo", "Busy Channel Lock-Out",
RadioSettingValueList(opts, current_index=_settings.bclo)))
# BEEP
opts = ["OFF", "KEY", "KEY+SC"]
rs = RadioSetting(
"beep_key", "Enable the Beeper",
RadioSettingValueList(
opts, current_index=_settings.beep_key + _settings.beep_sc))
def apply_beep(s, obj):
setattr(obj, "beep_key",
(int(s.value) & 1) or ((int(s.value) >> 1) & 1))
setattr(obj, "beep_sc", (int(s.value) >> 1) & 1)
rs.set_apply_callback(apply_beep, self._memobj.settings)
switch.append(rs)
# BELL
opts = ["OFF", "1T", "3T", "5T", "8T", "CONT"]
ctcss.append(
RadioSetting(
"bell", "Bell Repetitions",
RadioSettingValueList(
opts, current_index=_settings.bell)))
# BSY.LED
opts = ["ON", "OFF"]
misc.append(
RadioSetting(
"bsy_led", "Busy LED",
RadioSettingValueList(
opts, current_index=_settings.bsy_led)))
# DCS.NR
opts = ["TR/X N", "RX R", "TX R", "T/RX R"]
ctcss.append(
RadioSetting(
"dcs_nr", "\"Inverted\" DCS Code Decoding",
RadioSettingValueList(
opts, current_index=_settings.dcs_nr)))
# DT.DLY
opts = ["50 ms", "100 ms", "250 ms", "450 ms", "750 ms", "1000 ms"]
ctcss.append(
RadioSetting(
"dt_dly", "DTMF Autodialer Delay Time",
RadioSettingValueList(
opts, current_index=_settings.dt_dly)))
# DT.SPD
opts = ["50 ms", "100 ms"]
ctcss.append(
RadioSetting(
"dt_spd", "DTMF Autodialer Sending Speed",
RadioSettingValueList(
opts, current_index=_settings.dt_spd)))
# DT.WRT
for i in range(0, 9):
dtmf = self._memobj.dtmf[i]
str = ""
for c in dtmf.memory:
if c == 0xFF:
break
if c < len(DTMF_CHARS):
str += DTMF_CHARS[c]
val = RadioSettingValueString(0, 16, str, False)
val.set_charset(DTMF_CHARS + list("abcd"))
rs = RadioSetting("dtmf_%i" % i,
"DTMF Autodialer Memory %i" % (i + 1), val)
def apply_dtmf(s, obj):
str = s.value.get_value().upper().rstrip()
val = [DTMF_CHARS.index(x) for x in str]
for x in range(len(val), 16):
val.append(0xFF)
obj.memory = val
rs.set_apply_callback(apply_dtmf, dtmf)
ctcss.append(rs)
# EDG.BEP
opts = ["OFF", "ON"]
misc.append(
RadioSetting(
"edg_bep", "Band Edge Beeper",
RadioSettingValueList(
opts, current_index=_settings.edg_bep)))
# I.NET
opts = ["OFF", "COD", "MEM"]
rs = RadioSetting("inet", "Internet Link Connection",
RadioSettingValueList(
opts, current_index=_settings.inet - 1))
def apply_inet(s, obj):
setattr(obj, s.get_name(), int(s.value) + 1)
rs.set_apply_callback(apply_inet, self._memobj.settings)
wires.append(rs)
# INT.CD
opts = ["CODE 0", "CODE 1", "CODE 2", "CODE 3", "CODE 4",
"CODE 5", "CODE 6", "CODE 7", "CODE 8", "CODE 9",
"CODE A", "CODE B", "CODE C", "CODE D", "CODE E", "CODE F"]
wires.append(
RadioSetting(
"int_cd", "Access Number for WiRES(TM)",
RadioSettingValueList(
opts, current_index=_settings.int_cd)))
# INT.MR
opts = ["d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9"]
wires.append(
RadioSetting(
"int_mr", "Access Number (DTMF) for Non-WiRES(TM)",
RadioSettingValueList(
opts, current_index=_settings.int_mr)))
# LAMP
opts = ["KEY", "5SEC", "TOGGLE"]
switch.append(
RadioSetting(
"lamp", "Lamp Mode",
RadioSettingValueList(
opts, current_index=_settings.lamp)))
# LOCK
opts = ["LK KEY", "LKDIAL", "LK K+D", "LK PTT",
"LK P+K", "LK P+D", "LK ALL"]
rs = RadioSetting("lock", "Control Locking",
RadioSettingValueList(
opts, current_index=_settings.lock - 1))
def apply_lock(s, obj):
setattr(obj, s.get_name(), int(s.value) + 1)
rs.set_apply_callback(apply_lock, self._memobj.settings)
switch.append(rs)
# M/T-CL
opts = ["MONI", "T-CALL"]
switch.append(
RadioSetting(
"mt_cl", "MONI Switch Function",
RadioSettingValueList(
opts, current_index=_settings.mt_cl)))
# PAG.ABK
opts = ["OFF", "ON"]
eai.append(
RadioSetting(
"pag_abk", "Paging Answer Back",
RadioSettingValueList(
opts, current_index=_settings.pag_abk)))
# RESUME
opts = ["TIME", "HOLD", "BUSY"]
scan.append(
RadioSetting(
"resume", "Scan Resume Mode",
RadioSettingValueList(
opts, current_index=_settings.resume)))
# REV/HM
opts = ["REV", "HOME"]
switch.append(
RadioSetting(
"rev_hm", "HM/RV Key Function",
RadioSettingValueList(
opts, current_index=_settings.rev_hm)))
# RF.SQL
opts = ["OFF", "S-1", "S-2", "S-3", "S-4", "S-5", "S-6",
"S-7", "S-8", "S-FULL"]
misc.append(
RadioSetting(
"rf_sql", "RF Squelch Threshold",
RadioSettingValueList(
opts, current_index=_settings.rf_sql)))
# PRI.RVT
opts = ["OFF", "ON"]
scan.append(
RadioSetting(
"pri_rvt", "Priority Revert",
RadioSettingValueList(
opts, current_index=_settings.pri_rvt)))
# RXSAVE
opts = ["OFF", "200 ms", "300 ms", "500 ms", "1 s", "2 s"]
power.append(
RadioSetting(
"rxsave", "Receive Mode Battery Savery Interval",
RadioSettingValueList(
opts, current_index=_settings.rxsave)))
# S.SRCH
opts = ["SINGLE", "CONT"]
misc.append(
RadioSetting(
"ssrch", "Smart Search Sweep Mode",
RadioSettingValueList(
opts, current_index=_settings.ssrch)))
# SCN.MD
opts = ["MEM", "ONLY"]
scan.append(
RadioSetting(
"scn_md", "Memory Scan Channel Selection Mode",
RadioSettingValueList(
opts, current_index=_settings.scn_md)))
# SCN.LMP
opts = ["OFF", "ON"]
scan.append(
RadioSetting(
"scn_lmp", "Scan Lamp",
RadioSettingValueList(
opts, current_index=_settings.scn_lmp)))
# TOT
opts = ["OFF"] + ["%dMIN" % (x) for x in range(1, 30 + 1)]
misc.append(
RadioSetting(
"tot", "Timeout Timer",
RadioSettingValueList(
opts, current_index=_settings.tot)))
# TX.LED
opts = ["ON", "OFF"]
misc.append(
RadioSetting(
"tx_led", "TX LED",
RadioSettingValueList(
opts, current_index=_settings.tx_led)))
# TXSAVE
opts = ["OFF", "ON"]
power.append(
RadioSetting(
"txsave", "Transmitter Battery Saver",
RadioSettingValueList(
opts, current_index=_settings.txsave)))
# VFO.BND
opts = ["BAND", "ALL"]
misc.append(
RadioSetting(
"vfo_bnd", "VFO Band Edge Limiting",
RadioSettingValueList(
opts, current_index=_settings.vfo_bnd)))
# WX.ALT
opts = ["OFF", "ON"]
scan.append(
RadioSetting(
"wx_alt", "Weather Alert Scan",
RadioSettingValueList(
opts, current_index=_settings.wx_alt)))
# MBS
for i in range(0, 10):
opts = ["OFF", "ON"]
mbs = (self._memobj.mbs >> i) & 1
rs = RadioSetting("mbs%i" % i, "Bank %s Scan" % (i + 1),
RadioSettingValueList(opts, current_index=mbs))
def apply_mbs(s, index):
if int(s.value):
self._memobj.mbs |= (1 << index)
else:
self._memobj.mbs &= ~(1 << index)
rs.set_apply_callback(apply_mbs, i)
mbls.append(rs)
return setmode
def set_settings(self, uisettings):
_settings = self._memobj.settings
for element in uisettings:
if not isinstance(element, RadioSetting):
self.set_settings(element)
continue
if not element.changed():
continue
try:
name = element.get_name()
value = element.value
if element.has_apply_callback():
LOG.debug("Using apply callback")
element.run_apply_callback()
else:
obj = getattr(_settings, name)
setattr(_settings, name, value)
LOG.debug("Setting %s: %s" % (name, value))
except Exception:
LOG.debug(element.get_name())
raise
def get_raw_memory(self, number):
return repr(self._memobj.memory[number - 1]) + \
repr(self._memobj.flags[(number - 1) / 4]) + \
repr(self._memobj.names[number - 1])
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)
tmode = TMODES[_mem.tmode]
if '->' in tmode:
mem.tmode = 'Cross'
mem.cross_mode = tmode
else:
mem.tmode = 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 set_memory(self, mem):
if mem.number > 1000:
# pms channel
_mem = self._memobj.pms[mem.number - 1001]
_nam = _skp = None
else:
_mem = self._memobj.memory[mem.number - 1]
_nam = self._memobj.names[mem.number - 1]
_skp = self._memobj.flags[(mem.number - 1) / 4]
assert (_mem)
if mem.empty:
_mem.used = False
return
if not _mem.used:
_mem.set_raw("\x00" * 16)
_mem.used = 1
_mem.freq, flags = _encode_freq(mem.freq)
_mem.freq[0].set_bits(flags)
if mem.duplex == "split":
_mem.tx_freq, flags = _encode_freq(mem.offset)
_mem.tx_freq[0].set_bits(flags)
_mem.offset = 0
elif mem.duplex == "off":
_mem.tx_freq = 0
_mem.offset = 0
else:
_mem.tx_freq = 0
_mem.offset = mem.offset / 50000
_mem.duplex = DUPLEX.index(mem.duplex)
if mem.tmode == 'Cross':
_mem.tmode = TMODES.index(mem.cross_mode)
else:
_mem.tmode = TMODES.index(mem.tmode)
_mem.tone = chirp_common.TONES.index(mem.rtone)
_mem.dtcs = chirp_common.DTCS_CODES.index(mem.dtcs)
_mem.power = mem.power and POWER_LEVELS.index(mem.power) or 0
_mem.isnarrow = mem.mode == "NFM"
_mem.isam = mem.mode == "AM"
_mem.step = STEPS.index(mem.tuning_step)
if _skp is not None:
_skp["skip%i" % ((mem.number - 1) % 4)] = SKIPS.index(mem.skip)
if _nam is not None:
_nam.name = _encode_name(mem.name)
_nam.use_name = mem.name.strip() and True or False
_nam.valid = _nam.use_name
chirp-20261030/chirp/drivers/ft70.py 0000644 0001750 0001750 00000132416 14722311450 015755 0 ustar hibby hibby # Copyright 2010 Dan Smith
# Copyright 2017 Nicolas Pike
#
# 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 After clicking OK , press the [BAND] key.\n")
rp.pre_upload = _(
"1. Turn radio on.\n"
"2. Connect cable to DATA terminal.\n"
"3. Unclip battery.\n"
"4. Press and hold in the [AMS] key and power key while clipping"
" \n in back battery the "
"(\"ADMS\" will appear on the display).\n"
"5. Press the [MODE] key (\"-WAIT-\" will appear on the LCD).\n"
"Then click OK ")
return rp
def process_mmap(self):
mem_format = (MEM_SETTINGS_FORMAT + MEM_FORMAT + MEM_CALLSIGN_FORMAT +
MEM_SETTINGS_FORMAT_HI + MEM_CHECKSUM_FORMAT)
self._memobj = bitwise.parse(mem_format % self._mem_params, self._mmap)
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.has_dtcs_polarity = False
rf.valid_modes = list(MODES)
rf.valid_tmodes = list(TMODES)
rf.valid_duplexes = list(DUPLEX)
rf.valid_tuning_steps = [x for x in STEPS if x]
rf.valid_bands = [(500000, 999900000)]
rf.valid_skips = SKIPS
rf.valid_power_levels = POWER_LEVELS
rf.valid_characters = "".join(CHARSET).upper()
rf.valid_name_length = 6
rf.memory_bounds = (1, 900)
rf.can_odd_split = True
rf.has_ctone = False
rf.has_bank_names = True
rf.has_settings = True
return rf
def get_raw_memory(self, number):
return "\n".join([repr(self._memobj.memory[number - 1]),
repr(self._memobj.flag[number - 1])])
def _checksums(self):
return [yaesu_clone.YaesuChecksum(0x0000, 0xFEC9)] # The whole file -2 bytes
@staticmethod
def _add_ff_pad(val, length):
return val.ljust(length, "\xFF")[:length]
@classmethod
def _strip_ff_pads(cls, messages):
result = []
for msg_text in messages:
result.append(str(msg_text).rstrip("\xFF"))
return result
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 _decode_label(self, mem):
return str(mem.label).rstrip("\xFF")
def _encode_label(self, mem):
return self._add_ff_pad(mem.name.rstrip(), 6)
def _encode_charsetbits(self, mem):
# We only speak English here in chirpville
return [0x00, 0x00]
def _decode_power_level(self, mem): # 3 High 2 Mid 1 Low
return POWER_LEVELS[3 - mem.power]
def _encode_power_level(self, mem):
return 3 - POWER_LEVELS.index(mem.power)
def _decode_mode(self, mem):
mode = MODES[mem.mode]
if mode == 'FM' and int(mem.deviation):
return 'NFM'
else:
return mode
def _encode_mode(self, mem):
mode = mem.mode
if mode == 'NFM':
# Narrow is handled by a separate flag
mode = 'FM'
return MODES.index(mode)
def _get_tmode(self, mem, _mem):
mem.tmode = TMODES[_mem.tone_mode]
def _set_tmode(self, _mem, mem):
_mem.tone_mode = TMODES.index(mem.tmode)
def _set_mode(self, _mem, mem):
_mem.deviation = mem.mode == 'NFM'
_mem.mode = self._encode_mode(mem)
def _debank(self, mem):
bm = self.get_bank_model()
for bank in bm.get_memory_mappings(mem):
bm.remove_memory_from_mapping(mem, bank)
def set_memory(self, mem):
_mem = self._memobj.memory[mem.number - 1]
flag = self._memobj.flag[mem.number - 1]
self._debank(mem)
if not mem.empty and not flag.valid:
self._wipe_memory(_mem)
if mem.empty and flag.valid and not flag.used:
flag.valid = False
return
flag.used = not mem.empty
flag.valid = flag.used
if mem.empty:
return
if mem.freq < 30000000 or \
(mem.freq > 88000000 and mem.freq < 108000000) or \
mem.freq > 580000000:
flag.nosubvfo = True # Masked from VFO B
else:
flag.nosubvfo = False # Available in both VFOs
_mem.freq = int(mem.freq / 1000)
_mem.offset = int(mem.offset / 1000)
_mem.tone = chirp_common.TONES.index(mem.rtone)
self._set_tmode(_mem, mem)
_mem.duplex = DUPLEX.index(mem.duplex)
self._set_mode(_mem, mem)
_mem.dcs = chirp_common.DTCS_CODES.index(mem.dtcs)
_mem.tune_step = STEPS.index(mem.tuning_step)
if mem.power:
_mem.power = self._encode_power_level(mem)
else:
_mem.power = 3 # Set 3 - High power as the default
_mem.label = self._encode_label(mem)
charsetbits = self._encode_charsetbits(mem)
_mem.charsetbits[0], _mem.charsetbits[1] = charsetbits
flag.skip = mem.skip == "S"
flag.pskip = mem.skip == "P"
_mem.display_tag = 1 # Always Display Memory Name (For the moment..)
@classmethod
def _wipe_memory(cls, mem):
mem.set_raw("\x00" * (mem.size() // 8))
mem.unknown1 = 0x05
def get_bank_model(self):
return FT70BankModel(self)
def _get_dtmf_settings(self):
menu = RadioSettingGroup("dtmf_settings", "DTMF")
dtmf = self._memobj.scan_settings
val = RadioSettingValueList(
self._DTMF_MODE,
current_index=dtmf.dtmf_mode)
rs = RadioSetting("scan_settings.dtmf_mode", "DTMF Mode", val)
menu.append(rs)
val = RadioSettingValueList(
self._DTMF_DELAY,
current_index=dtmf.dtmf_delay)
rs = RadioSetting(
"scan_settings.dtmf_delay", "DTMF Delay", val)
menu.append(rs)
val = RadioSettingValueList(
self._DTMF_SPEED,
current_index=dtmf.dtmf_speed)
rs = RadioSetting(
"scan_settings.dtmf_speed", "DTMF Speed", val)
menu.append(rs)
for i in range(10):
name = "dtmf_%02d" % (i + 1)
if i == 9:
name = "dtmf_%02d" % 0
dtmfsetting = self._memobj.dtmf[i]
dtmfstr = ""
for c in dtmfsetting.memory:
if c == 0xFF:
break
if c < len(FT70_DTMF_CHARS):
dtmfstr += FT70_DTMF_CHARS[c]
dtmfentry = RadioSettingValueString(0, 16, dtmfstr)
dtmfentry.set_charset(
FT70_DTMF_CHARS + list("abcdef ")) # Allow input in lowercase, space ? validation fails otherwise
rs = RadioSetting(name, name.upper(), dtmfentry)
rs.set_apply_callback(self.apply_dtmf, i)
menu.append(rs)
return menu
def _get_display_settings(self):
menu = RadioSettingGroup("display_settings", "Display")
scan_settings = self._memobj.scan_settings
val = RadioSettingValueList(
self._LAMP_KEY,
current_index=scan_settings.lamp)
rs = RadioSetting("scan_settings.lamp", "Lamp", val)
menu.append(rs)
val = RadioSettingValueList(
self._LCD_DIMMER,
current_index=scan_settings.lcd_dimmer)
rs = RadioSetting("scan_settings.lcd_dimmer", "LCD Dimmer", val)
menu.append(rs)
opening_message = self._memobj.opening_message
val = RadioSettingValueList(
self._OPENING_MESSAGE,
current_index=opening_message.flag)
rs = RadioSetting("opening_message.flag", "Opening Msg Mode", val)
menu.append(rs)
return menu
def _get_config_settings(self):
menu = RadioSettingGroup("config_settings", "Config")
scan_settings = self._memobj.scan_settings
# 02 APO Set the length of time until the transceiver turns off automatically.
first_settings = self._memobj.first_settings
val = RadioSettingValueList(
self._APO_SELECT,
current_index=first_settings.apo)
rs = RadioSetting("first_settings.apo", "APO", val)
menu.append(rs)
# 03 BCLO Turns the busy channel lockout function on/off.
val = RadioSettingValueList(
self._OFF_ON,
current_index=scan_settings.bclo)
rs = RadioSetting("scan_settings.bclo", "Busy Channel Lockout", val)
menu.append(rs)
# 04 BEEP Sets the beep sound function.
beep_settings = self._memobj.beep_settings
val = RadioSettingValueList(
self._BEEP_SELECT,
current_index=beep_settings.beep_select)
rs = RadioSetting("beep_settings.beep_select", "Beep", val)
menu.append(rs)
# 05 BEP.LVL Beep volume setting LEVEL1 - LEVEL4 - LEVEL7
val = RadioSettingValueList(
self._BEEP_LEVEL,
current_index=beep_settings.beep_level)
rs = RadioSetting("beep_settings", "Beep Level", val)
menu.append(rs)
# 06 BEP.Edg Sets the beep sound ON or OFF when a band edge is encountered.
val = RadioSettingValueList(
self._OFF_ON,
current_index=scan_settings.beep_edge)
rs = RadioSetting("scan_settings.beep_edge", "Beep Band Edge", val)
menu.append(rs)
# 10 Bsy.LED Turn the MODE/STATUS Indicator ON or OFF while receiving signals.
val = RadioSettingValueList(
self._ON_OFF,
current_index=scan_settings.busy_led)
rs = RadioSetting("scan_settings.busy_led", "Busy LED", val)
menu.append(rs)
# 26 HOME/REV Select the function of the [HOME/REV] key.
val = RadioSettingValueList(
self._HOME_REV,
current_index=scan_settings.home_rev)
rs = RadioSetting("scan_settings.home_rev", "HOME/REV", val)
menu.append(rs)
# 27 HOME->VFO Turn transfer VFO to the Home channel ON or OFF.
val = RadioSettingValueList(
self._OFF_ON,
current_index=scan_settings.home_vfo)
rs = RadioSetting("scan_settings.home_vfo", "Home->VFO", val)
menu.append(rs)
# 30 LOCK Configure the lock mode setting. KEY / DIAL / K+D / PTT / K+P / D+P / ALL
val = RadioSettingValueList(
self._LOCK,
current_index=scan_settings.lock)
rs = RadioSetting("scan_settings.lock", "Lock Mode", val)
menu.append(rs)
# 32 Mon/T-Call Select the function of the [MONI/T-CALL] switch.
val = RadioSettingValueList(
self._MONI_TCALL,
current_index=scan_settings.moni)
rs = RadioSetting("scan_settings.moni", "MONI/T-CALL", val)
menu.append(rs)
# 42 PTT.DLY Set the PTT delay time. OFF / 20 ms / 50 ms / 100 ms / 200 ms
val = RadioSettingValueList(
self._PTT_DELAY,
current_index=scan_settings.ptt_delay)
rs = RadioSetting("scan_settings.ptt_delay", "PTT Delay", val)
menu.append(rs)
# 45 RPT.ARS Turn the ARS function on/off.
val = RadioSettingValueList(
self._OFF_ON,
current_index=scan_settings.ars)
rs = RadioSetting("scan_settings.ars", "ARS", val)
menu.append(rs)
# 48 RX.SAVE Set the battery save time. OFF / 0.2 s - 60.0 s
val = RadioSettingValueList(
self._RX_SAVE,
current_index=scan_settings.rx_save)
rs = RadioSetting("scan_settings.rx_save", "RX SAVE", val)
menu.append(rs)
# 60 VFO.MOD Set the frequency setting range in the VFO mode by DIAL knob. ALL / BAND
val = RadioSettingValueList(
self._VFO_MODE,
current_index=scan_settings.vfo_mode)
rs = RadioSetting("scan_settings.vfo_mode", "VFO MODE", val)
menu.append(rs)
# 56 TOT Set the timeout timer.
val = RadioSettingValueList(
self._TOT_TIME,
current_index=scan_settings.tot)
rs = RadioSetting("scan_settings.tot", "Transmit Timeout (TOT)", val)
menu.append(rs)
# 31 MCGAIN Adjust the microphone gain level
val = RadioSettingValueList(
self._MIC_GAIN,
current_index=scan_settings.mic_gain)
rs = RadioSetting("scan_settings.mic_gain", "Mic Gain", val)
menu.append(rs)
# VOLUME Adjust the volume level
scan_settings_2 = self._memobj.scan_settings_2
val = RadioSettingValueList(
self._VOLUME,
current_index=scan_settings_2.volume)
rs = RadioSetting("scan_settings_2.volume", "Volume", val)
menu.append(rs)
# Squelch F key, Hold Monitor, Dial to adjust squelch level
squelch_settings = self._memobj.squelch_settings
val = RadioSettingValueList(
self._SQUELCH,
current_index=squelch_settings.squelch)
rs = RadioSetting("squelch_settings.squelch", "Squelch", val)
menu.append(rs)
return menu
def _get_digital_settings(self):
menu = RadioSettingGroup("digital_settings", "Digital")
# MYCALL
mycall = self._memobj.my_call
mycallstr = str(mycall.callsign).rstrip("\xFF")
mycallentry = RadioSettingValueString(0, 10, mycallstr, False, charset=self._MYCALL_CHR_SET)
rs = RadioSetting('mycall.callsign', 'MYCALL', mycallentry)
rs.set_apply_callback(self.apply_mycall, mycall)
menu.append(rs)
# Short Press AMS button AMS TX Mode
digital_settings = self._memobj.digital_settings
val = RadioSettingValueList(
self._AMS_TX_MODE,
current_index=digital_settings.ams_tx_mode)
rs = RadioSetting("digital_settings.ams_tx_mode", "AMS TX Mode", val)
menu.append(rs)
# 16 DIG VW Turn the VW mode selection ON or OFF.
val = RadioSettingValueList(
self._VW_MODE,
current_index=digital_settings.vw_mode)
rs = RadioSetting("digital_settings.vw_mode", "VW Mode", val)
menu.append(rs)
# TX DG-ID Long Press Mode Key, Dial
val = RadioSettingValueList(
self._DG_ID,
current_index=digital_settings.tx_dg_id)
rs = RadioSetting("digital_settings.tx_dg_id", "TX DG-ID", val)
menu.append(rs)
# RX DG-ID Long Press Mode Key, Mode Key to select, Dial
val = RadioSettingValueList(
self._DG_ID,
current_index=digital_settings.rx_dg_id)
rs = RadioSetting("digital_settings.rx_dg_id", "RX DG-ID", val)
menu.append(rs)
# 15 DIG.POP Call sign display pop up time
# 00 OFF 00
# 0A 2s 10
# 0B 4s 11
# 0C 6s 12
# 0D 8s 13
# 0E 10s 14
# 0F 20s 15
# 10 30s 16
# 11 60s 17
# 12 CONT 18
digital_settings_more = self._memobj.digital_settings_more
val = RadioSettingValueList(
self._DIG_POP_UP,
current_index=0 if digital_settings_more.digital_popup == 0 else digital_settings_more.digital_popup - 9)
rs = RadioSetting("digital_settings_more.digital_popup", "Digital Popup", val)
rs.set_apply_callback(self.apply_digital_popup, digital_settings_more)
menu.append(rs)
# 07 BEP.STB Standby Beep in the digital C4FM mode. On/Off
val = RadioSettingValueList(
self._STANDBY_BEEP,
current_index=digital_settings.standby_beep)
rs = RadioSetting("digital_settings.standby_beep", "Standby Beep", val)
menu.append(rs)
return menu
def _get_gm_settings(self):
menu = RadioSettingGroup("first_settings", "Group Monitor")
# 24 GM RNG Select the beep option while receiving digital GM information. OFF / IN RNG /ALWAYS
first_settings = self._memobj.first_settings
val = RadioSettingValueList(
self._GM_RING,
current_index=first_settings.gm_ring)
rs = RadioSetting("first_settings.gm_ring", "GM Ring", val)
menu.append(rs)
# 25 GM INT Set the transmission interval of digital GM information. OFF / NORMAL / LONG
scan_settings = self._memobj.scan_settings
val = RadioSettingValueList(
self._GM_INTERVAL,
current_index=scan_settings.gm_interval)
rs = RadioSetting("scan_settings.gm_interval", "GM Interval", val)
menu.append(rs)
return menu
def _get_scan_settings(self):
menu = RadioSettingGroup("scan_settings", "Scan")
scan_settings = self._memobj.scan_settings
# 23 DW RVT Turn the "Priority Channel Revert" feature ON or OFF during Dual Receive.
val = RadioSettingValueList(
self._OFF_ON,
current_index=scan_settings.dw_rt)
rs = RadioSetting("scan_settings.dw_rt", "Dual Watch Priority Channel Revert", val)
menu.append(rs)
# 21 DW INT Set the priority memory channel monitoring interval during Dual Receive. 0.1S - 5.0S - 10.0S
val = RadioSettingValueList(
self._SCAN_RESTART,
current_index=scan_settings.dw_interval)
rs = RadioSetting("scan_settings.dw_interval", "Dual Watch Interval", val)
menu.append(rs)
# 22 DW RSM Configure the scan stop mode settings for Dual Receive. 2.0S - 10.0 S / BUSY / HOLD
first_settings = self._memobj.first_settings
val = RadioSettingValueList(
self._SCAN_RESUME,
current_index=first_settings.dw_resume_interval)
rs = RadioSetting("first_settings.dw_resume_interval", "Dual Watch Resume Interval", val)
menu.append(rs)
# 51 SCN.LMP Set the scan lamp ON or OFF when scanning stops. OFF / ON
val = RadioSettingValueList(
self._OFF_ON,
current_index=scan_settings.scan_lamp)
rs = RadioSetting("scan_settings.scan_lamp", "Scan Lamp", val)
menu.append(rs)
# 53 SCN.STR Set the scanning restart time. 0.1 S - 2.0 S - 10.0 S
val = RadioSettingValueList(
self._SCAN_RESTART,
current_index=scan_settings.scan_restart)
rs = RadioSetting("scan_settings.scan_restart", "Scan Restart", val)
menu.append(rs)
# Scan Width Section
# 50 SCV.WTH Set the VFO scan frequency range. BAND / ALL - NOT FOUND!
# Scan Resume Section
# 52 SCN.RSM Configure the scan stop mode settings. 2.0 S - 5.0 S - 10.0 S / BUSY / HOLD
first_settings = self._memobj.first_settings
val = RadioSettingValueList(
self._SCAN_RESUME,
current_index=first_settings.scan_resume)
rs = RadioSetting("first_settings.scan_resume", "Scan Resume", val)
menu.append(rs)
return menu
def _get_settings(self):
top = RadioSettings(
self._get_config_settings(),
self._get_digital_settings(),
self._get_display_settings(),
self._get_dtmf_settings(),
self._get_gm_settings(),
self._get_scan_settings()
)
return top
def get_settings(self):
try:
return self._get_settings()
except:
import traceback
LOG.error("Failed to parse settings: %s", traceback.format_exc())
return None
@classmethod
def apply_ff_padded_string(cls, setting, obj):
setattr(obj, "padded_string", cls._add_ff_pad(setting.value.get_value().rstrip(), 6))
def set_settings(self, settings):
_mem = self._memobj
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(e)
continue
# Find the object containing setting.
obj = _mem
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:
LOG.debug(element.get_name())
raise
def apply_volume(cls, setting, vfo):
val = setting.value.get_value()
cls._memobj.vfo_info[(vfo * 2)].volume = val
cls._memobj.vfo_info[(vfo * 2) + 1].volume = val
def apply_dtmf(cls, setting, i):
rawval = setting.value.get_value().upper().rstrip()
val = [FT70_DTMF_CHARS.index(x) for x in rawval]
for x in range(len(val), 16):
val.append(0xFF)
cls._memobj.dtmf[i].memory = val
def apply_digital_popup(cls, setting, obj):
rawval = setting.value.get_value()
val = 0 if cls._DIG_POP_UP.index(rawval) == 0 else cls._DIG_POP_UP.index(rawval) + 9
obj.digital_popup = val
def apply_mycall(cls, setting, obj):
cs = setting.value.get_value()
if cs[0] in ('-', '/'):
raise InvalidValueError("First character of call sign can't be - or /: {0:s}".format(cs))
else:
obj.callsign = cls._add_ff_pad(cs.rstrip(), 10)
def load_mmap(self, filename):
if filename.lower().endswith(self._adms_ext):
with open(filename, 'rb') as f:
self._adms_header = f.read(0xED)
if b'=ADMS10, Version=1.0.1.0' not in self._adms_header:
raise errors.ImageDetectFailed(
'Unsupported version found in ADMS file')
LOG.debug('ADMS Header:\n%s',
util.hexprint(self._adms_header))
self._mmap = memmap.MemoryMapBytes(self._model + f.read())
LOG.info('Loaded ADMS file')
self.process_mmap()
else:
chirp_common.CloneModeRadio.load_mmap(self, filename)
def save_mmap(self, filename):
if filename.lower().endswith(self._adms_ext):
if not hasattr(self, '_adms_header'):
raise Exception('Unable to save .img to %s' % self._adms_ext)
with open(filename, 'wb') as f:
f.write(self._adms_header)
f.write(self._mmap.get_packed()[5:])
LOG.info('Wrote file')
else:
chirp_common.CloneModeRadio.save_mmap(self, filename)
chirp-20261030/chirp/drivers/ft7100.py 0000644 0001750 0001750 00000115732 15266622247 016135 0 ustar hibby hibby # Copyright 2011 Dan Smith
#
# FT-2900-specific modifications by Richard Cochran,
# Initial work on settings by Chris Fosnight,
# FT-7100-specific modifications by Bruno Maire,
#
# 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 After clicking OK , press \"TONE\" to send image.\n")
rp.pre_upload = _(
"1. Turn Radio off.\n"
"2. Connect data cable.\n"
"3. While holding \"TONE\" and \"REV\" buttons, turn radio on.\n"
"4. Press \"REV\" to receive image.\n"
"5. Make sure display says \"CLONE RX\" and green led is"
" blinking\n"
"6. Click OK to start transfer.\n")
return rp
def get_sub_devices(self):
if not self.VARIANT:
return [FT7100RadioVHF(self._mmap),
FT7100RadioUHF(self._mmap)]
else:
return []
class FT7100RadioVHF(FT7100Radio):
VARIANT = "VHF Band"
def get_features(self):
LOG.debug("VHF get_features")
upper_vhf_limit = self._get_upper_vhf_limit()
rf = FT7100Radio.get_features(self)
rf.memory_bounds = (1, upper_vhf_limit)
# Normally this band supports 120 + 10 memories. 1 based for chirpw
rf.valid_bands = [(108000000, 180000001)] # Supports 2-meters tx
rf.valid_modes = MODES_VHF
rf.valid_special_chans = ['VFO', 'Home']
rf.has_sub_devices = False
return rf
def get_memory(self, number):
LOG.debug("get_memory VHF Number: %s", number)
if isinstance(number, int):
if number >= 0:
mem = FT7100Radio.get_memory(self, number + 0 - 1)
else:
mem = FT7100Radio.get_memory(self, number)
mem.number = number
else:
mem = FT7100Radio.get_memory(self, number + '-VHF')
mem.extd_number = number
mem.immutable = ["number", "extd_number", "skip"]
return mem
def set_memory(self, mem):
LOG.debug("set_memory VHF Number: %s", mem.number)
# We modify memory, so dupe() it to avoid changing our caller's
# version
mem = mem.dupe()
if isinstance(mem.number, int):
if mem.number >= 0:
mem.number += -1
else:
mem.number += '-VHF'
super(FT7100RadioVHF, self).set_memory(mem)
return
class FT7100RadioUHF(FT7100Radio):
VARIANT = "UHF Band"
def get_features(self):
LOG.debug("UHF get_features")
upper_uhf_limit = self._get_upper_uhf_limit()
rf = FT7100Radio.get_features(self)
rf.memory_bounds = (1, upper_uhf_limit)
# Normally this band supports 120 + 10 memories. 1 based for chirpw
rf.valid_bands = [(320000000, 999990000)] # Supports 70-centimeters tx
# The radio can retain AM on UHF memories, although it ignores it.
# Keep it readable/valid so existing images remain round-trippable.
rf.valid_modes = MODES_UHF + ["AM"]
rf.valid_special_chans = ['VFO', 'Home']
rf.has_sub_devices = False
return rf
def get_memory(self, number):
LOG.debug("get_memory UHF Number: %s", number)
upper_vhf_limit = self._get_upper_vhf_limit()
if isinstance(number, int):
if number >= 0:
mem = FT7100Radio.get_memory(self, number + 10 +
upper_vhf_limit - 1)
else:
mem = FT7100Radio.get_memory(self, number)
mem.number = number
else:
mem = FT7100Radio.get_memory(self, number + '-UHF')
mem.extd_number = number
mem.immutable = ["number", "extd_number", "skip"]
return mem
def set_memory(self, mem):
LOG.debug("set_memory UHF Number: %s", mem.number)
# We modify memory, so dupe() it to avoid changing our caller's
# version
mem = mem.dupe()
upper_vhf_limit = self._get_upper_vhf_limit()
if isinstance(mem.number, int):
if mem.number >= 0:
mem.number += upper_vhf_limit - 1 + 10
else:
mem.number += '-UHF'
super(FT7100RadioUHF, self).set_memory(mem)
return
chirp-20261030/chirp/drivers/ft7800.py 0000644 0001750 0001750 00000121600 15172631605 016125 0 ustar hibby hibby # Copyright 2010 Dan Smith
#
# 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 After clicking OK , press the [V/M(MW)] key to send"
" image.\n")
rp.pre_upload = _(
"1. Turn radio off.\n"
"2. Connect cable to DATA jack.\n"
"3. Press and hold in the [MHz(PRI)] key while turning the\n"
" radio on.\n"
"4. Rotate the DIAL job to select \"F-7 CLONE\".\n"
"5. Press and hold in the [BAND(SET)] key. The display\n"
" will disappear for a moment, then the \"CLONE\" notation\n"
" will appear.\n"
"6. Press the [LOW(ACC)] key (\"--RX--\" will appear on the"
" display).\n")
return rp
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.memory_bounds = (1, 999)
rf.has_bank = False
rf.has_ctone = False
rf.has_dtcs_polarity = False
rf.valid_modes = self.MODES
rf.valid_tmodes = self.TMODES
rf.valid_duplexes = ["", "-", "+", "split"]
rf.valid_tuning_steps = self.STEPS
rf.valid_bands = [(108000000, 520000000), (700000000, 990000000)]
rf.valid_skips = ["", "S", "P"]
rf.valid_power_levels = self.POWER_LEVELS_VHF
rf.valid_characters = "".join(CHARSET)
rf.valid_name_length = 6
rf.can_odd_split = True
return rf
def _checksums(self):
return [yaesu_clone.YaesuChecksum(0x0000, 0x7B47)]
def sync_in(self):
start = time.time()
try:
self._mmap = _download(self)
except errors.RadioError:
raise
except Exception as e:
raise errors.RadioError("Failed to communicate with radio: %s" % e)
LOG.info("Download finished in %i seconds" % (time.time() - start))
self.check_checksums()
self.process_mmap()
def process_mmap(self):
self._memobj = bitwise.parse(MEM_FORMAT, self._mmap)
def sync_out(self):
self.update_checksums()
start = time.time()
try:
_upload(self)
except errors.RadioError:
raise
except Exception as e:
raise errors.RadioError("Failed to communicate with radio: %s" % e)
LOG.info("Upload finished in %i seconds" % (time.time() - start))
def get_raw_memory(self, number):
return repr(self._memobj.memory[number-1])
def _get_mem_offset(self, mem, _mem):
if mem.duplex == "split":
return get_freq(int(_mem.split) * 10000)
else:
return (_mem.offset * 5) * 10000
def _set_mem_offset(self, mem, _mem):
if mem.duplex == "split":
set_freq(mem.offset, _mem, "split")
else:
_mem.offset = (int(mem.offset / 10000) / 5)
def _get_mem_name(self, mem, _mem):
_nam = self._memobj.names[mem.number - 1]
name = ""
if _nam.used:
for i in str(_nam.name):
name += CHARSET[ord(i)]
return name.rstrip()
def _set_mem_name(self, mem, _mem):
_nam = self._memobj.names[mem.number - 1]
if mem.name.rstrip():
name = [chr(CHARSET.index(x)) for x in mem.name.ljust(6)[:6]]
_nam.name = "".join(name)
_nam.used = 1
_nam.enabled = 1
else:
_nam.used = 0
_nam.enabled = 0
def _get_mem_skip(self, mem, _mem):
_flg = self._memobj.flags[(mem.number - 1) / 4]
flgidx = (mem.number - 1) % 4
return SKIPS[_flg["skip%i" % flgidx]]
def _set_mem_skip(self, mem, _mem):
_flg = self._memobj.flags[(mem.number - 1) / 4]
flgidx = (mem.number - 1) % 4
_flg["skip%i" % flgidx] = SKIPS.index(mem.skip)
def _get_mem_mode(self, mem, _mem):
mem.mode = self.MODES[_mem.mode]
def _set_mem_mode(self, mem, _mem):
_mem.mode = self.MODES.index(mem.mode)
def get_memory(self, number):
_mem = self._memobj.memory[number - 1]
mem = chirp_common.Memory()
mem.number = number
mem.empty = not _mem.used
if mem.empty:
return mem
mem.freq = get_freq(int(_mem.freq) * 10000)
mem.rtone = chirp_common.TONES[_mem.tone]
mem.tmode = self.TMODES[_mem.tmode]
self._get_mem_mode(mem, _mem)
mem.dtcs = chirp_common.DTCS_CODES[_mem.dtcs]
if self.get_features().has_tuning_step:
mem.tuning_step = self.STEPS[_mem.tune_step]
mem.duplex = DUPLEX[_mem.duplex]
mem.offset = self._get_mem_offset(mem, _mem)
mem.name = self._get_mem_name(mem, _mem)
if int(mem.freq / 100) == 4:
mem.power = self.POWER_LEVELS_UHF[_mem.power]
else:
mem.power = self.POWER_LEVELS_VHF[_mem.power]
mem.skip = self._get_mem_skip(mem, _mem)
return mem
def set_memory(self, mem):
_mem = self._memobj.memory[mem.number - 1]
_mem.used = int(not mem.empty)
if mem.empty:
return
set_freq(mem.freq, _mem, "freq")
_mem.tone = chirp_common.TONES.index(mem.rtone)
_mem.tmode = self.TMODES.index(mem.tmode)
self._set_mem_mode(mem, _mem)
_mem.dtcs = chirp_common.DTCS_CODES.index(mem.dtcs)
if self.get_features().has_tuning_step:
_mem.tune_step = self.STEPS.index(mem.tuning_step)
_mem.duplex = DUPLEX.index(mem.duplex)
_mem.split = mem.duplex == "split" and int(mem.offset / 10000) or 0
if mem.power:
_mem.power = self.POWER_LEVELS_VHF.index(mem.power)
else:
_mem.power = 0
_mem.unknown5 = 0 # Make sure we don't leave garbage here
# NB: Leave offset after mem name for the 8800!
self._set_mem_name(mem, _mem)
self._set_mem_offset(mem, _mem)
self._set_mem_skip(mem, _mem)
class FT7800BankModel(chirp_common.BankModel):
"""Yaesu FT-7800/7900 bank model"""
def __init__(self, radio):
super(FT7800BankModel, self).__init__(radio)
self.__b2m_cache = defaultdict(list)
self.__m2b_cache = defaultdict(list)
def __precache(self):
if self.__b2m_cache:
return
for bank in self.get_mappings():
self.__b2m_cache[bank.index] = self._get_bank_memories(bank)
for memnum in self.__b2m_cache[bank.index]:
self.__m2b_cache[memnum].append(bank.index)
def get_num_mappings(self):
return 20
def get_mappings(self):
banks = []
for i in range(0, self.get_num_mappings()):
bank = chirp_common.Bank(self, "%i" % i, "BANK-%i" % (i + 1))
bank.index = i
banks.append(bank)
return banks
def add_memory_to_mapping(self, memory, bank):
self.__precache()
index = memory.number - 1
_bitmap = self._radio._memobj.bank_channels[bank.index]
ishft = 31 - (index % 32)
_bitmap.bitmap[index // 32] |= (1 << ishft)
self.__m2b_cache[memory.number].append(bank.index)
self.__b2m_cache[bank.index].append(memory.number)
def remove_memory_from_mapping(self, memory, bank):
self.__precache()
index = memory.number - 1
_bitmap = self._radio._memobj.bank_channels[bank.index]
ishft = 31 - (index % 32)
if not (_bitmap.bitmap[index // 32] & (1 << ishft)):
raise Exception("Memory {num} is not in bank {bank}".format(
num=memory.number, bank=bank))
_bitmap.bitmap[index // 32] &= ~(1 << ishft)
self.__b2m_cache[bank.index].remove(memory.number)
self.__m2b_cache[memory.number].remove(bank.index)
def _get_bank_memories(self, bank):
memories = []
upper = self._radio.get_features().memory_bounds[1]
c = self._radio._memobj.bank_channels[bank.index]
for i in range(0, upper):
_bitmap = c.bitmap[i // 32]
ishft = 31 - (i % 32)
if _bitmap & (1 << ishft):
memories.append(i + 1)
return memories
def get_mapping_memories(self, bank):
self.__precache()
return [self._radio.get_memory(n)
for n in self.__b2m_cache[bank.index]]
def get_memory_mappings(self, memory):
self.__precache()
_banks = self.get_mappings()
return [_banks[b] for b in self.__m2b_cache[memory.number]]
@directory.register
class FT7800Radio(FTx800Radio):
"""Yaesu FT-7800"""
MODEL = "FT-7800/7900"
_model = b"AH016"
_memsize = 31561
_block_lengths = [8, 31552, 1]
TMODES = ["", "Tone", "TSQL", "TSQL-R", "DTCS"]
def get_bank_model(self):
if not hasattr(self, '_banks'):
self._banks = FT7800BankModel(self)
return self._banks
def get_features(self):
rf = FTx800Radio.get_features(self)
rf.has_bank = True
rf.has_settings = True
return rf
def set_memory(self, memory):
if memory.empty:
self._wipe_memory_banks(memory)
FTx800Radio.set_memory(self, memory)
def get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic")
dtmf = RadioSettingGroup("dtmf", "DTMF")
arts = RadioSettingGroup("arts", "ARTS")
prog = RadioSettingGroup("prog", "Programmable Buttons")
top = RadioSettings(basic, dtmf, arts, prog)
basic.append(RadioSetting(
"priority_revert", "Priority Revert",
RadioSettingValueBoolean(_settings.priority_revert)))
basic.append(RadioSetting(
"memory_only", "Memory Only mode",
RadioSettingValueBoolean(_settings.memory_only)))
opts = ["off"] + ["%0.1f" % (t / 60.0) for t in range(30, 750, 30)]
basic.append(RadioSetting(
"apo", "APO time (hrs)",
RadioSettingValueList(opts, current_index=_settings.apo)))
basic.append(RadioSetting(
"beep_scan", "Beep: Scan",
RadioSettingValueBoolean(_settings.beep_scan)))
basic.append(RadioSetting(
"beep_edge", "Beep: Edge",
RadioSettingValueBoolean(_settings.beep_edge)))
basic.append(RadioSetting(
"beep_key", "Beep: Key",
RadioSettingValueBoolean(_settings.beep_key)))
opts = ["T/RX Normal", "RX Reverse", "TX Reverse", "T/RX Reverse"]
basic.append(
RadioSetting(
"dcs_polarity", "DCS polarity",
RadioSettingValueList(
opts, current_index=_settings.dcs_polarity)))
opts = ["off", "dim 1", "dim 2", "dim 3"]
basic.append(RadioSetting(
"dimmer", "Dimmer",
RadioSettingValueList(opts, current_index=_settings.dimmer)))
opts = ["manual", "auto", "1-auto"]
basic.append(
RadioSetting(
"hyper_write", "Hyper Write",
RadioSettingValueList(
opts, current_index=_settings.hyper_write)))
opts = ["", "key", "dial", "key+dial", "ptt",
"ptt+key", "ptt+dial", "all"]
basic.append(RadioSetting(
"lock", "Lock mode",
RadioSettingValueList(opts, current_index=_settings.lock)))
opts = ["MH-42", "MH-48"]
basic.append(
RadioSetting(
"microphone_type", "Microphone Type",
RadioSettingValueList(
opts, current_index=_settings.microphone_type)))
opts = ["off"] + ["S-%d" % n for n in range(2, 10)] + ["S-Full"]
basic.append(RadioSetting(
"rf_sql", "RF Squelch",
RadioSettingValueList(opts, current_index=_settings.rf_sql)))
opts = ["time", "hold", "busy"]
basic.append(
RadioSetting(
"scan_resume", "Scan Resume",
RadioSettingValueList(
opts, current_index=_settings.scan_resume)))
opts = ["single", "continuous"]
basic.append(
RadioSetting(
"smart_search", "Smart Search",
RadioSettingValueList(
opts, current_index=_settings.smart_search)))
opts = ["off"] + ["%d" % t for t in range(1, 31)]
basic.append(RadioSetting(
"tot", "Time-out timer (mins)",
RadioSettingValueList(opts, current_index=_settings.tot)))
# dtmf tab
opts = ["50", "100", "250", "450", "750", "1000"]
dtmf.append(
RadioSetting(
"dtmf_delay", "DTMF delay (ms)",
RadioSettingValueList(
opts, current_index=_settings.dtmf_delay)))
opts = ["50", "75", "100"]
dtmf.append(
RadioSetting(
"dtmf_speed", "DTMF speed (ms)",
RadioSettingValueList(
opts, current_index=_settings.dtmf_speed)))
for i in range(16):
name = "dtmf%02d" % i
dtmfsetting = self._memobj.dtmf[i]
dtmfstr = ""
for c in dtmfsetting.memory:
if c == 0xFF:
break
if c < len(DTMFCHARSET):
dtmfstr += DTMFCHARSET[c]
LOG.debug(dtmfstr)
dtmfentry = RadioSettingValueString(0, 16, dtmfstr)
dtmfentry.set_charset(DTMFCHARSET + list(" "))
rs = RadioSetting(name, name.upper(), dtmfentry)
dtmf.append(rs)
# arts tab
opts = ["off", "in range", "always"]
arts.append(
RadioSetting(
"arts_mode", "ARTS beep",
RadioSettingValueList(
opts, current_index=_settings.arts_mode)))
opts = ["15", "25"]
arts.append(
RadioSetting(
"arts_interval", "ARTS interval",
RadioSettingValueList(
opts, current_index=_settings.arts_interval)))
arts.append(RadioSetting(
"arts_cwid_enable", "CW ID",
RadioSettingValueBoolean(_settings.arts_cwid_enable)))
_arts_cwid = self._memobj.arts_cwid
cwid = RadioSettingValueString(
0, 16, _decode_chars(_arts_cwid.get_value()))
cwid.set_charset(CHARSET)
arts.append(RadioSetting("arts_cwid", "CW ID", cwid))
# prog buttons
opts = ["WX", "Reverse", "Repeater", "SQL Off", "Lock", "Dimmer"]
prog.append(
RadioSetting(
"prog_panel_acc", "Prog Panel - Low(ACC)",
RadioSettingValueList(
opts, current_index=_settings.prog_panel_acc)))
opts = ["Reverse", "Home"]
prog.append(
RadioSetting(
"prog_tone_vm", "TONE | V/M",
RadioSettingValueList(
opts, current_index=_settings.prog_tone_vm)))
opts = ["" for n in range(26)] + \
["Priority", "Low", "Tone", "MHz", "Reverse", "Home", "Band",
"VFO/MR", "Scan", "Sql Off", "TCall", "SSCH", "ARTS", "Tone Freq",
"DCSC", "WX", "Repeater"]
prog.append(RadioSetting(
"prog_p1", "P1",
RadioSettingValueList(opts, current_index=_settings.prog_p1)))
prog.append(RadioSetting(
"prog_p2", "P2",
RadioSettingValueList(opts, current_index=_settings.prog_p2)))
prog.append(RadioSetting(
"prog_p3", "P3",
RadioSettingValueList(opts, current_index=_settings.prog_p3)))
prog.append(RadioSetting(
"prog_p4", "P4",
RadioSettingValueList(opts, current_index=_settings.prog_p4)))
return top
def set_settings(self, uisettings):
for element in uisettings:
if not isinstance(element, RadioSetting):
self.set_settings(element)
continue
if not element.changed():
continue
try:
_settings = self._memobj.settings
setting = element.get_name()
if re.match(r'dtmf\d', setting):
# set dtmf fields
dtmfstr = str(element.value).strip()
newval = []
for i in range(0, 16):
if i < len(dtmfstr):
newval.append(DTMFCHARSET.index(dtmfstr[i]))
else:
newval.append(0xFF)
LOG.debug(newval)
idx = int(setting[-2:])
_settings = self._memobj.dtmf[idx]
_settings.memory = newval
continue
if setting == "arts_cwid":
oldval = self._memobj.arts_cwid
newval = _encode_chars(newval.get_value(), 6)
self._memobj.arts_cwid = newval
continue
# normal settings
newval = element.value
oldval = getattr(_settings, setting)
LOG.debug("Setting %s(%s) <= %s" % (setting, oldval, newval))
setattr(_settings, setting, newval)
except Exception:
LOG.debug(element.get_name())
raise
MEM_FORMAT_8800_COMMON = """
#seekto 0x0009;
struct {
bbcd vfo_left[3];
} current_state;
#seekto 0x0032;
struct {
u8 ukn32;
u8 main:1,
ukn33_a:1,
ars:1,
ukn33_b:2,
vfo_band_edge:1,
ukn33_c:2;
u8 ukn34;
u8 ukn35;
u8 ukn36;
u8 ukn37;
u8 ukn38;
u8 ukn39;
u8 apo;
u8 ukn3b;
u8 ukn3c_a:3,
arts_mode:1,
ukn3c_b:2,
lockt:2;
u8 prog_p1;
u8 prog_p2;
u8 prog_p3;
u8 prog_p4;
u8 ukn41;
u8 ukn42;
u8 arts_cwid_enable:1,
lock:1,
ukn43:4,
backlight:2;
u8 ukn44a:2,
beep:1,
ukn44b:1,
key_mod:1,
ukn44c:3;
u8 ukn45a:3,
mute:2,
ukn45b:3;
u8 ukn46a:3,
mic:1,
ukn56b:4;
u8 ukn47;
u8 arts_cwid[6];
} settings;
"""
MEM_FORMAT_8800 = """
#seekto 0x%X;
struct {
u8 used:1,
unknown1:1,
wid_nar:1,
am:1,
unknown2:1,
duplex:3;
bbcd freq[3];
u8 unknown3:1,
tune_step:3,
power:2,
tmode:2;
bbcd split[3];
u8 nameused:1,
unknown5:1,
tone:6;
u8 namevalid:1,
dtcs:7;
u8 name[6];
} memory[512];
#seekto 0x%X;
struct {
u32 bitmap[16];
} bank_channels[10];
#seekto 0x51C8;
struct {
u8 skip0:2,
skip1:2,
skip2:2,
skip3:2;
} flags[256];
#seekto 0x7B48;
u8 checksum;
"""
class FT8800BankModel(FT7800BankModel):
def get_num_mappings(self):
return 10
@directory.register
class FT8800Radio(FTx800Radio):
"""Base class for Yaesu FT-8800"""
MODEL = "FT-8800"
_model = b"AH018"
_memsize = 22217
_block_lengths = [8, 22208, 1]
_memstart = 0x0000
TMODES = ["", "Tone", "TSQL", "DTCS"]
STEPS = STEPS_8800
@classmethod
def get_prompts(cls):
rp = chirp_common.RadioPrompts()
rp.pre_download = _(
"1. Turn radio off.\n"
"2. Connect cable to DATA jack.\n"
"3. Press and hold in the \"left\" [V/M] key while turning the\n"
" radio on.\n"
"4. Rotate the \"right\" DIAL knob to select \"CLONE START\".\n"
"5. Press the [SET] key. The display will disappear\n"
" for a moment, then the \"CLONE\" notation will appear.\n"
"6. After clicking OK , press the \"left\" [V/M] key to\n"
" send image.\n")
rp.pre_upload = _(
"1. Turn radio off.\n"
"2. Connect cable to DATA jack.\n"
"3. Press and hold in the \"left\" [V/M] key while turning the\n"
" radio on.\n"
"4. Rotate the \"right\" DIAL knob to select \"CLONE START\".\n"
"5. Press the [SET] key. The display will disappear\n"
" for a moment, then the \"CLONE\" notation will appear.\n"
"6. Press the \"left\" [LOW] key (\"CLONE -RX-\" will appear"
" on\n"
" the display).\n")
return rp
def get_features(self):
rf = FTx800Radio.get_features(self)
rf.has_sub_devices = self.VARIANT == ""
rf.has_bank = True
rf.memory_bounds = (1, 512)
rf.has_settings = True
return rf
def get_sub_devices(self):
return [FT8800RadioLeft(self._mmap), FT8800RadioRight(self._mmap)]
def get_bank_model(self):
if not hasattr(self, '_banks'):
self._banks = FT8800BankModel(self)
return self._banks
def _checksums(self):
return [yaesu_clone.YaesuChecksum(0x0000, 0x56C7)]
def process_mmap(self):
if not self._memstart:
self._memobj = bitwise.parse(MEM_FORMAT_8800_COMMON, self._mmap)
return
# Memory format for the sub devices
self._memobj = bitwise.parse(MEM_FORMAT_8800 % (self._memstart,
self._bankstart),
self._mmap)
def _get_mem_offset(self, mem, _mem):
if mem.duplex == "split":
return get_freq(int(_mem.split) * 10000)
# The offset is packed into the upper two bits of the last four
# bytes of the name (?!)
val = 0
for i in _mem.name[2:6]:
val <<= 2
val |= (i & 0xC0) >> 6
return (val * 5) * 10000
def _set_mem_offset(self, mem, _mem):
if mem.duplex == "split":
set_freq(mem.offset, _mem, "split")
return
val = int(mem.offset / 10000) // 5
for i in reversed(list(range(2, 6))):
_mem.name[i] = (_mem.name[i] & 0x3F) | ((val & 0x03) << 6)
val >>= 2
def _get_mem_name(self, mem, _mem):
name = ""
if _mem.namevalid:
for i in _mem.name:
index = int(i) & 0x3F
if index < len(CHARSET):
name += CHARSET[index]
return name.rstrip()
def _set_mem_name(self, mem, _mem):
_mem.name = [CHARSET.index(x) for x in mem.name.ljust(6)[:6]]
_mem.namevalid = 1
_mem.nameused = bool(mem.name.rstrip())
def _get_mem_mode(self, mem, _mem):
if _mem.am:
mem.mode = "AM"
else:
mem.mode = "NFM" if _mem.wid_nar else "FM"
def _set_mem_mode(self, mem, _mem):
if mem.mode == "AM":
_mem.am = True
_mem.wid_nar = False
else:
_mem.am = False
_mem.wid_nar = mem.mode == "NFM"
def get_settings(self):
_settings = self._memobj.settings
_cs = self._memobj.current_state
basic = RadioSettingGroup("basic", "Basic")
dtmf = RadioSettingGroup("dtmf", "DTMF")
arts = RadioSettingGroup("arts", "ARTS")
prog = RadioSettingGroup("prog", "Programmable Buttons")
top = RadioSettings(basic, dtmf, arts, prog)
basic.append(RadioSetting(
"apo", "APO time (hrs)",
RadioSettingValueList(
["off"] + ["%0.1f" % (t / 60.0)
for t in range(30, 750, 30)],
current_index=_settings.apo)))
basic.append(RadioSetting("beep", "Beep: Key",
RadioSettingValueBoolean(_settings.beep)))
basic.append(RadioSetting("main", "Main: active device",
RadioSettingValueList(
["Right", "Left"],
current_index=_settings.main)))
basic.append(RadioSetting("backlight", "Backlight",
RadioSettingValueList(
["off", "dim 1", "dim 2", "dim 3"],
current_index=_settings.backlight)))
basic.append(RadioSetting("vfo_band_edge",
"BAND: VFO remain within band",
RadioSettingValueList(
["BND. ON", "BND. OFF"],
current_index=_settings.vfo_band_edge)))
# 123.455 -> 0812345
# 999.9875 -> 1299998
# 155.2875 -> 1215528
# 108.0000 -> 0010800
basic.append(RadioSetting("vfo_left", "VFO: left",
RadioSettingValueFloat(
0, 9**20, int(_cs.vfo_left) / 100)))
basic.append(RadioSetting("key_mod",
("key functions for “right†band function "
"switches"),
RadioSettingValueList(
["KEY1", "KEY2"],
current_index=_settings.key_mod)))
basic.append(RadioSetting("lock", "Lock: key/button",
RadioSettingValueBoolean(_settings.lock)))
basic.append(RadioSetting("lockt", "Lock: PTT",
RadioSettingValueList(
["OFF", "BAND_R", "BAND_L", "BOTH"],
current_index=_settings.lockt)))
basic.append(RadioSetting("mute", "Audio Mute",
RadioSettingValueList(
["OFF", "TX", "RX", "TX/RX"],
current_index=_settings.mute)))
basic.append(RadioSetting("mic", "Mic: type",
RadioSettingValueList(
["MH-42", "MH-48"],
current_index=_settings.mic)))
# arts tab
arts.append(RadioSetting("arts_mode", "ARTS beep",
RadioSettingValueList(
["off", "in range", "always"],
current_index=_settings.arts_mode)))
arts.append(RadioSetting("arts_cwid_enable", "CW ID Enable",
RadioSettingValueBoolean(
_settings.arts_cwid_enable)))
cwid = RadioSettingValueString(0, 16,
_decode_chars(
_settings.arts_cwid.get_value()))
cwid.set_charset(CHARSET)
arts.append(RadioSetting("arts_cwid", "CW ID", cwid))
# Prog buttons
opts = [
"Repeater",
"Priority",
"Low",
"Tone",
"MHz",
"Reverse",
"Home",
"Band",
"VFO/MR",
"Scan",
"Sql Off",
"TCall (1750Hz)",
]
for n in range(1, 5):
prog.append(
RadioSetting(
f"prog_p{n}", f"P{n}",
RadioSettingValueList(
opts,
current_index=getattr(_settings, f"prog_p{n}") - 26)))
return top
def set_settings(self, uisettings):
for element in uisettings:
if not isinstance(element, RadioSetting):
self.set_settings(element)
continue
if not element.changed():
continue
try:
_settings = self._memobj.settings
_cs = self._memobj.current_state
setting = element.get_name()
newval = element.value
if setting.startswith("vfo_"):
setattr(_cs, setting, newval * 100)
continue
if setting == "arts_cwid":
oldval = _settings.arts_cwid
newval = _encode_chars(newval.get_value(), 6)
_settings.arts_cwid = newval
continue
if setting.startswith("prog_p"):
setattr(_settings, setting, newval + 26)
continue
# normal settings
oldval = getattr(_settings, setting)
LOG.debug("Setting %s(%s) <= %s" % (setting, oldval, newval))
setattr(_settings, setting, newval)
except Exception:
LOG.debug(element.get_name())
raise
class FT8800RadioLeft(FT8800Radio):
"""Yaesu FT-8800 Left VFO subdevice"""
VARIANT = "Left"
_memstart = 0x0948
_bankstart = 0x4BC8
def get_features(self):
rf = super().get_features()
rf.has_settings = False
return rf
class FT8800RadioRight(FT8800Radio):
"""Yaesu FT-8800 Right VFO subdevice"""
VARIANT = "Right"
_memstart = 0x2948
_bankstart = 0x4BC8
def get_features(self):
rf = super().get_features()
rf.has_settings = False
return rf
MEM_FORMAT_8900 = """
#seekto 0x0708;
struct {
u8 used:1,
skip:2,
sub_used:1,
unknown2:1,
duplex:3;
bbcd freq[3];
u8 mode:2,
nameused:1,
unknown4:1,
power:2,
tmode:2;
bbcd split[3];
u8 unknown5:2,
tone:6;
u8 namevalid:1,
dtcs:7;
u8 name[6];
} memory[799];
#seekto 0x51C8;
struct {
u8 skip0:2,
skip1:2,
skip2:2,
skip3:2;
} flags[400];
#seekto 0x7B48;
u8 checksum;
"""
@directory.register
class FT8900Radio(FTx800Radio):
"""Yaesu FT-8900"""
MODEL = "FT-8900"
_model = b"AH008"
_memsize = 14793
_block_lengths = [8, 14784, 1]
MODES = ["FM", "NFM", "AM"]
TMODES = ["", "Tone", "TSQL", "DTCS"]
STEPS = STEPS
@classmethod
def get_prompts(cls):
rp = chirp_common.RadioPrompts()
rp.pre_download = _(
"1. Turn radio off.\n"
"2. Connect cable to DATA jack.\n"
"3. Press and hold in the \"left\" [V/M] key while turning the\n"
" radio on.\n"
"4. Rotate the \"right\" DIAL knob to select \"CLONE START\".\n"
"5. Press the [SET] key. The display will disappear\n"
" for a moment, then the \"CLONE\" notation will appear.\n"
"6. After clicking OK , press the \"left\" [V/M] key to\n"
" send image.\n")
rp.pre_upload = _(
"1. Turn radio off.\n"
"2. Connect cable to DATA jack.\n"
"3. Press and hold in the \"left\" [V/M] key while turning the\n"
" radio on.\n"
"4. Rotate the \"right\" DIAL knob to select \"CLONE START\".\n"
"5. Press the [SET] key. The display will disappear\n"
" for a moment, then the \"CLONE\" notation will appear.\n"
"6. Press the \"left\" [LOW] key (\"CLONE -RX-\" will appear"
" on\n"
" the display).\n")
return rp
def process_mmap(self):
self._memobj = bitwise.parse(MEM_FORMAT_8900, self._mmap)
def get_features(self):
rf = FTx800Radio.get_features(self)
rf.valid_modes = self.MODES
rf.valid_bands = [(28000000, 29700000),
(50000000, 54000000),
(108000000, 180000000),
(320000000, 480000000),
(700000000, 985000000)]
rf.memory_bounds = (1, 799)
rf.has_tuning_step = False
return rf
def _checksums(self):
return [yaesu_clone.YaesuChecksum(0x0000, 0x39C7)]
def _get_mem_offset(self, mem, _mem):
if mem.duplex == "split":
return get_freq(int(_mem.split) * 10000)
# The offset is packed into the upper two bits of the last four
# bytes of the name (?!)
val = 0
for i in _mem.name[2:6]:
val <<= 2
val |= ((i & 0xC0) >> 6)
return (val * 5) * 10000
def _set_mem_offset(self, mem, _mem):
if mem.duplex == "split":
set_freq(mem.offset, _mem, "split")
return
val = int(mem.offset / 10000) // 5
for i in reversed(list(range(2, 6))):
_mem.name[i] = (_mem.name[i] & 0x3F) | ((val & 0x03) << 6)
val >>= 2
def _get_mem_name(self, mem, _mem):
name = ""
if _mem.namevalid:
for i in _mem.name:
index = int(i) & 0x3F
if index < len(CHARSET):
name += CHARSET[index]
return name.rstrip()
def _set_mem_name(self, mem, _mem):
_mem.name = [CHARSET.index(x) for x in mem.name.ljust(6)[:6]]
_mem.namevalid = 1
_mem.nameused = bool(mem.name.rstrip())
def _get_mem_skip(self, mem, _mem):
return SKIPS[_mem.skip]
def _set_mem_skip(self, mem, _mem):
_mem.skip = SKIPS.index(mem.skip)
def set_memory(self, mem):
FT8800Radio.set_memory(self, mem)
# The 8900 has a bit flag that tells the radio whether or not
# the memory should show up on the sub (right) band
_mem = self._memobj.memory[mem.number - 1]
if mem.freq < 108000000 or mem.freq > 480000000:
_mem.sub_used = 0
else:
_mem.sub_used = 1
chirp-20261030/chirp/drivers/ft8000r.py 0000644 0001750 0001750 00000057710 15270732464 016316 0 ustar hibby hibby # Copyright 2026 FT-8000 driver contributors
#
# 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 F/W (FIRST button below the LCD) while\n'
' turning radio ON. Release when all segments blink.\n'
'3. After clicking OK , wait for download progress.\n'
' Press RPT (THIRD button below the LCD) once.\n'
'4. After completion, turn OFF, then ON normally.\n'
' Hold no buttons. Turn OFF before unplugging cable.\n')
prompts.pre_upload = (
'1. Turn radio OFF. Connect the rear DATA cable.\n'
'2. Hold F/W (FIRST button below the LCD) while\n'
' turning radio ON. Release when all segments blink.\n'
'3. Press REV (SECOND button below the LCD) once.\n'
' The display stops blinking; radio is ready to receive.\n'
'4. Click OK. Wait about 25-35 seconds for upload.\n'
' Radio restarts on success. If needed, power OFF/ON\n'
' normally without holding any buttons.\n'
'If ERR appears, stop transfer and repeat from step 1.\n')
return prompts
def get_features(self):
features = chirp_common.RadioFeatures()
features.has_sub_devices = not bool(self.VARIANT)
features.memory_bounds = (1, 50)
features.has_bank = False
features.has_name = False
features.valid_name_length = 0
features.valid_characters = ''
features.has_settings = not bool(self.VARIANT)
features.has_tuning_step = False
features.valid_tuning_steps = [5, 10, 12.5, 15, 20, 25, 50, 100, 2.5]
features.has_nostep_tuning = False
features.has_ctone = False
features.has_dtcs = False
features.has_dtcs_polarity = False
features.can_delete = True
features.valid_tmodes = list(TMODES)
features.valid_tones = list(TONES)
features.valid_skips = ['', 'S']
features.valid_modes = ['FM', 'AM']
features.valid_duplexes = ['', '+', '-', 'split']
features.can_odd_split = True
features.valid_power_levels = self._power_levels()
features.valid_special_chans = list(SPECIALS)
features.valid_bands = ([(110000000, 280000000)]
if self.VARIANT == 'Left' else
[(280000000, 550000000),
(750000000, 1000000000)])
return features
def _power_levels(self):
return [chirp_common.PowerLevel('High', watts=(
50 if self.VARIANT == 'Left' else 35)),
chirp_common.PowerLevel('Mid', watts=10),
chirp_common.PowerLevel('Low', watts=5)]
def get_sub_devices(self):
return [FT8000RLeftRadio(self._mmap), FT8000RRightRadio(self._mmap)]
def process_mmap(self):
validate_image(self._mmap.get_packed())
self._memobj = bitwise.parse(MEM_FORMAT, self._mmap)
def _inactive_side(self):
if not self._memobj.settings.same_band:
return None
return 'right' if self._memobj.settings.vhf_pair else 'left'
def _saved_states(self):
# Same-band reception uses both live receivers for one band. The
# inactive band's state is preserved in two matching saved blocks.
side = self._inactive_side()
if side is None:
return []
other = 'left' if side == 'right' else 'right'
return [getattr(self._memobj, s + '_saved') for s in (side, other)]
def _working_records(self, number):
side = self.VARIANT.lower()
if side == self._inactive_side():
states = self._saved_states()
else:
sides = (('left', 'right')
if self._inactive_side() and number != 56 else (side,))
states = [getattr(self._memobj, s) for s in sides]
working = []
for state in states:
if state.memory_tune:
continue
if state.home_mode:
selected = 55
elif state.memory_mode:
selected = int(state.current_memory) + 1
else:
selected = 56
if selected == number:
working.append(state.working)
return working
def _get_record(self, number):
number = self._memory_number(number)
side = self.VARIANT.lower()
if 1 <= number <= 50:
return getattr(self._memobj, side + '_memory')[number - 1]
if 51 <= number <= 54:
return getattr(self._memobj, side + '_pms')[number - 51]
if number in (55, 56):
if side == self._inactive_side():
state = self._saved_states()[0]
else:
state = getattr(self._memobj, side)
return state.home if number == 55 else state.vfo
raise errors.InvalidMemoryLocation('Unknown FT-8000 memory')
@staticmethod
def _memory_number(number):
if isinstance(number, str) and number in SPECIALS:
return 51 + SPECIALS.index(number)
if not isinstance(number, int):
raise errors.InvalidMemoryLocation('Unknown FT-8000 memory')
return number
@staticmethod
def _memory_extra(record, empty=False):
extra = RadioSettingGroup('extra', 'Extra')
extra.append(MemSetting('bell', 'CTCSS bell (requires TSQL/FTS-22)',
RadioSettingValueBoolean(
False if empty else record.bell)))
extra.append(MemSetting(
'masked', 'Masked (hidden on radio)',
RadioSettingValueBoolean(False if empty else record.masked)))
return extra
def get_memory(self, number):
record = self._get_record(number)
number = self._memory_number(number)
rx = int(record.freq) * 100
used = rx and (not record.masked or rx != SENTINELS[self.VARIANT])
if number >= 55:
used = bool(rx)
memory = chirp_common.Memory(number, empty=not bool(used))
memory.extra = self._memory_extra(record, empty=memory.empty)
if number > 50:
memory.extd_number = SPECIALS[number - 51]
if number >= 55:
memory.immutable = ['empty']
memory.extra['masked'].value.set_mutable(False)
if not used:
return memory
memory.freq = decode_frequency(int(record.freq))
memory.duplex = DUPLEXES[int(record.duplex)]
memory.offset = (decode_frequency(int(record.offset))
if memory.duplex == 'split' else
int(record.offset) * 100)
memory.mode = 'AM' if record.am else 'FM'
memory.tmode = {0: '', 1: 'Tone', 2: '', 3: 'TSQL'}[
int(record.tone_mode)]
if int(record.tone) < len(TONES):
memory.rtone = TONES[int(record.tone)]
else:
LOG.warning('Unknown FT-8000 tone index %i in %s memory %i',
int(record.tone), self.VARIANT, number)
memory.skip = 'S' if record.skip else ''
memory.power = self._power_levels()[
int(record.power) if int(record.power) < 3 else 0]
return memory
def _update_checksum(self):
self._memobj.checksum = checksum(self._mmap.get_packed())
def set_memory(self, memory):
record = self._get_record(memory.number)
existing = self.get_memory(memory.number)
self.check_set_memory_immutable_policy(existing, memory)
if memory.empty:
record.masked = True
record.freq = SENTINELS[self.VARIANT] // 100
self._update_checksum()
return
# The LCD uses a separate working record. Update only receivers whose
# mode and channel index select this memory, even if others match it.
working = self._working_records(memory.number)
tx = memory.freq
if memory.duplex == '+':
tx += memory.offset
elif memory.duplex == '-':
tx -= memory.offset
elif memory.duplex == 'split':
tx = memory.offset
record.freq = memory.freq // 100
record.offset = memory.offset // 100
record.duplex = DUPLEXES.index(memory.duplex)
record.rx_step = frequency_code(memory.freq)
record.tx_step = frequency_code(tx)
record.am = memory.mode == 'AM'
record.tone_mode = {'': 0, 'Tone': 1, 'TSQL': 3}[memory.tmode]
record.tone = TONES.index(memory.rtone)
record.skip = memory.skip == 'S'
record.power = (self._power_levels().index(memory.power)
if memory.power else 0)
record.masked = False
record.bell = False
if memory.extra:
for setting in memory.extra:
setting.apply_to_memobj(record)
if memory.tmode != 'TSQL':
record.bell = False
for item in working:
item.set_raw(record.get_raw())
if memory.number in (55, 56):
if self.VARIANT.lower() == self._inactive_side():
for state in self._saved_states():
item = state.home if memory.number == 55 else state.vfo
item.set_raw(record.get_raw())
elif memory.number == 55 and self._inactive_side():
for side in ('left', 'right'):
getattr(self._memobj, side).home.set_raw(
record.get_raw())
self._update_checksum()
def get_raw_memory(self, number):
return repr(self._get_record(number))
def _settings_schema(self):
schema = list(SETTINGS)
for side in ('left', 'right'):
label = side.title()
control = (side + '_saved.control'
if side == self._inactive_side() else side + '.control')
squelch = (side + '_saved.rf_sql'
if side == self._inactive_side() else side + '.rf_sql')
schema.extend([
(control + '.ars', label + ' auto repeater shift',
[0, 1], None),
(control + '.search', label + ' smart search',
[0, 1], ['One time', 'Continuous']),
(control + '.scan', label + ' scan resume',
[0, 1], ['Carrier drop', '5 seconds']),
(squelch, label + ' RF squelch',
[0, 2, 4, 6, 11], ['Off', '2 units', '4 units', '6 units',
'Full scale'])])
return schema
def get_settings(self):
common = RadioSettingGroup('common', 'Radio settings')
for path, label, values, labels in self._settings_schema():
field = self._memobj
for part in path.split('.'):
field = getattr(field, part)
raw = int(field)
if raw not in values:
value = RadioSettingValueString(0, 64, 'Unknown: 0x%X' % raw)
value.set_mutable(False)
setting = RadioSetting(path.replace('.', '_'), label, value)
elif labels is None:
value = RadioSettingValueBoolean(
bool(values.index(raw)), mem_vals=values)
setting = MemSetting(path, label, value)
else:
value = RadioSettingValueMap(list(zip(labels, values)),
mem_val=raw)
setting = MemSetting(path, label, value)
common.append(setting)
obj = self._memobj.settings
mode = (0 if not obj.same_band else 1 if obj.vhf_pair else 2)
value = RadioSettingValueString(
0, 32, ['VHF/UHF', 'VHF/VHF', 'UHF/UHF'][mode])
value.set_mutable(False)
common.append(RadioSetting('receive_mode', 'Receive mode', value))
sub_mode = (0 if not obj.sub_off else
2 if obj.sub_voltmeter else 1)
common.append(RadioSetting(
'sub_operation', 'Sub band operation', RadioSettingValueList(
['On', 'Off', 'Voltmeter'], current_index=sub_mode)))
dtmf = RadioSettingGroup('dtmf', 'DTMF autodial')
for side in ('left', 'right'):
obj = (self._saved_states()[0].dtmf
if side == self._inactive_side() else
getattr(self._memobj, side).dtmf)
count = int(obj.count)
digits = [int(x) for x in obj.digits[0:min(count, 16)]]
if count <= 16 and all(x <= 16 for x in digits):
text = ''.join('0123456789ABCD*#P'[x] for x in digits)
value = RadioSettingValueString(0, 16, text, autopad=False)
value.set_charset('0123456789ABCD*#P')
else:
value = RadioSettingValueString(
0, 80, 'Unknown: ' + bytes(digits).hex())
value.set_mutable(False)
dtmf.append(RadioSetting(side + '_dtmf', side.title() +
' DTMF digits (P = pause)', value))
return RadioSettings(common, dtmf)
def set_settings(self, settings):
# Direct settings use MemSetting. Only multi-field/encoded settings
# need special handling.
obj = self._memobj
for setting in settings.apply_to(obj):
if not setting.changed():
continue
name = setting.get_name()
if name == 'sub_operation':
index = int(setting.value)
obj.settings.sub_off = bool(index)
obj.settings.sub_voltmeter = index == 2
elif name in ('left_dtmf', 'right_dtmf'):
digits = str(setting.value).strip().upper()
dtmf = (self._saved_states()[0].dtmf
if name == str(self._inactive_side()) + '_dtmf' else
getattr(obj, name[:-5]).dtmf)
dtmf.count = len(digits)
dtmf.digits = (['0123456789ABCD*#P'.index(x) for x in digits] +
[16] * (16 - len(digits)))
else:
raise errors.InvalidValueError('Unsupported setting: ' + name)
saved = self._saved_states()
if saved:
source, mirror = saved
for field in ('ars', 'search', 'scan'):
setattr(mirror.control, field, getattr(source.control, field))
mirror.rf_sql = source.rf_sql
mirror.dtmf.set_raw(source.dtmf.get_raw())
self._update_checksum()
def _configure_pipe(self):
self.pipe.bytesize = 8
self.pipe.parity = 'N'
self.pipe.stopbits = 2
self.pipe.xonxoff = False
self.pipe.dsrdtr = False
self.pipe.timeout = 3
def _status(self, message, count):
status = chirp_common.Status()
status.msg = message
status.cur = count
status.max = IMAGE_SIZE
self.status_fn(status)
def sync_in(self):
try:
self._download()
except errors.RadioError:
raise
except Exception as error:
LOG.exception('FT-8000R download failed')
raise errors.RadioError('Download failed: %s' % error) from error
def _download(self):
self._configure_pipe()
# Yaesu requires the operator to start the transfer. Keep the same
# serial timeout throughout: changing it may flush received data.
for attempt in range(20):
first = self.pipe.read(1)
if first:
break
else:
raise errors.RadioNoResponse()
header = first + self.pipe.read(len(HEADER) - 1)
# Some captures have this fixed two-byte preamble. Read its remaining
# bytes directly; do not scan or poll an asynchronous receive buffer.
prefix = b''
if header.startswith(b'\x00\xfc'):
prefix = header[:2]
header = header[2:] + self.pipe.read(2)
if header != HEADER:
raise errors.RadioError(
'Unrecognized or incomplete FT-8000 header')
self._metadata['ft8000_download_prefix'] = prefix.hex()
data = bytearray(header)
self._status('Downloading from FT-8000', len(data))
while len(data) < IMAGE_SIZE:
count = min(64, IMAGE_SIZE - len(data))
chunk = self.pipe.read(count)
if len(chunk) != count:
raise errors.RadioError('Incomplete FT-8000 download')
data.extend(chunk)
self._status('Downloading from FT-8000', len(data))
validate_image(data)
# No per-block or final ACK: passive download is hardware-verified.
self._mmap = memmap.MemoryMapBytes(bytes(data))
self.process_mmap()
def _write_echo(self, value):
# CHIRP's SerialTrace wrapper currently discards Serial.write's count.
# In that case the required matching one-byte echo confirms the write.
count = self.pipe.write(value)
if count is not None and count != 1:
raise errors.RadioError('Incomplete serial write; upload stopped')
self.pipe.flush()
echo = self.pipe.read(1)
if not echo:
raise errors.RadioError('Missing cable echo; upload stopped')
if echo != value:
raise errors.RadioError('Unexpected cable echo; upload stopped')
def sync_out(self):
try:
self._upload()
except errors.RadioError:
raise
except Exception as error:
LOG.exception('FT-8000R upload failed')
raise errors.RadioError('Upload failed: %s' % error) from error
def _upload(self):
data = self._mmap.get_packed()
validate_image(data) # Before touching the serial port.
self._configure_pipe()
self._status('Uploading to FT-8000', 0)
for index, value in enumerate(data):
time.sleep(0.150 if index == 0 else 0.010)
self._write_echo(bytes([value]))
if index % 16 == 0 or index == IMAGE_SIZE - 1:
self._status('Uploading to FT-8000', index + 1)
time.sleep(0.150)
self._write_echo(b'\x06')
LOG.info('FT-8000 writes and echo complete; '
'verify radio display/readback')
class FT8000RLeftRadio(FT8000RRadio):
VARIANT = 'Left'
class FT8000RRightRadio(FT8000RRadio):
VARIANT = 'Right'
chirp-20261030/chirp/drivers/ft8100.py 0000644 0001750 0001750 00000023114 14720054223 016111 0 ustar hibby hibby # Copyright 2010 Eric Allen
#
# 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 After clicking OK , press \"RPT\" to send image.\n")
rp.pre_upload = _(
"1. Turn Radio off.\n"
"2. Connect data cable.\n"
"3. While holding \"F/W\" button, turn radio on.\n"
"4. Press \"REV\" to receive image.\n"
"5. Click OK to start transfer.\n")
return rp
@classmethod
def match_model(cls, data, path):
if (len(data) == cls._memsize and
data[1:10] == b'\x01\x01\x07\x08\x02\x01\x01\x00\x01'):
return True
return False
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.memory_bounds = (1, 99)
rf.has_ctone = False
rf.has_dtcs = False
rf.has_dtcs_polarity = False
rf.has_bank = False
rf.has_name = False
rf.valid_tones = list(TONES)
rf.valid_modes = list(MODES)
rf.valid_tmodes = list(TMODES)
rf.valid_duplexes = list(DUPLEX)
rf.valid_power_levels = POWER_LEVELS_VHF
rf.has_sub_devices = self.VARIANT == ''
rf.valid_tuning_steps = list(STEPS)
# This is not implemented properly, so don't expose it
rf.valid_tuning_steps.remove(12.5)
# This driver doesn't properly support the upper bound of 1300MHz
# so limit us to 999MHz
if self.VARIANT == 'VHF':
rf.valid_bands = [(110000000, 280000000)]
else:
rf.valid_bands = [(280000000, 550000000),
(750000000, 999000000)]
# This is not actually implemented, so don't expose it
# rf.valid_skips = SKIPS
rf.valid_skips = []
# TODO
# rf.valid_special_chans = SPECIALS.keys()
# TODO
# rf.has_tuning_step = False
rf.can_odd_split = True
return rf
def sync_in(self):
super(FT8100Radio, self).sync_in()
self.pipe.write(bytes([yaesu_clone.CMD_ACK]))
self.pipe.read(1)
def sync_out(self):
self.update_checksums()
return _clone_out(self)
def process_mmap(self):
if not self._memstart:
return
mem_format = MEM_FORMAT.format(memories=self._memstart,
skips=self._skipstart,
enables=self._enablestart)
self._memobj = bitwise.parse(mem_format, self._mmap)
def get_sub_devices(self):
return [FT8100RadioVHF(self._mmap), FT8100RadioUHF(self._mmap)]
def get_memory(self, number):
bit, byte = self._bit_byte(number)
_mem = self._memobj.memory[number - 1]
mem = chirp_common.Memory()
mem.number = number
mem.freq = int(_mem.freq) * 1000
if _mem.tone >= len(TONES) or _mem.duplex >= len(DUPLEX):
mem.empty = True
return mem
else:
mem.rtone = TONES[_mem.tone]
mem.tmode = TMODES[_mem.tone_enable]
mem.mode = MODES[_mem.am]
mem.duplex = DUPLEX[_mem.duplex]
mem.offset = int(_mem.offset) * 1000
if mem.freq // 100 == 4:
mem.power = POWER_LEVELS_UHF[_mem.power]
else:
mem.power = POWER_LEVELS_VHF[_mem.power]
# M01 can't be disabled
if not self._memobj.enables[byte] & bit and number != 1:
mem.empty = True
elif number == 1:
mem.immutable = ['empty']
return mem
def get_raw_memory(self, number):
return repr(self._memobj.memory[number - 1])
def set_memory(self, mem):
bit, byte = self._bit_byte(mem.number)
_mem = self._memobj.memory[mem.number - 1]
_mem.freq = mem.freq // 1000
_mem.tone = TONES.index(mem.rtone)
_mem.tone_enable = TMODES.index(mem.tmode)
_mem.am = MODES.index(mem.mode)
_mem.duplex = DUPLEX.index(mem.duplex)
_mem.offset = mem.offset // 1000
if mem.power:
_mem.power = POWER_LEVELS_VHF.index(mem.power)
else:
_mem.power = 0
if mem.empty:
self._memobj.enables[byte] &= ~bit
else:
self._memobj.enables[byte] |= bit
# TODO expose these options
_mem.baud9600 = 0
# These need to be cleared, otherwise strange things happen
_mem.unknown4 = 0
_mem.unknown4b = 0
_mem.unknown1b = 0
_mem.unknown2 = 0
def _checksums(self):
return [yaesu_clone.YaesuChecksum(0x0000, 0x0B96)]
# I didn't believe this myself, but it seems that there's a bit for
# enabling VHF M01, but no bit for UHF01, and the enables are shifted down,
# so that the first bit is for M02
def _bit_byte(self, number):
if self.VARIANT == 'VHF':
bit = 1 << ((number - 1) % 8)
byte = (number - 1) // 8
else:
bit = 1 << ((number - 2) % 8)
byte = (number - 2) // 8
return bit, byte
class FT8100RadioVHF(FT8100Radio):
"""Yaesu FT-8100 VHF subdevice"""
VARIANT = "VHF"
_memstart = 0x447
_skipstart = 0x02D
_enablestart = 0x04D
class FT8100RadioUHF(FT8100Radio):
"""Yaesu FT-8100 UHF subdevice"""
VARIANT = "UHF"
_memstart = 0x7E6
_skipstart = 0x03A
_enablestart = 0x05A
def _clone_out(radio):
try:
return __clone_out(radio)
except Exception as e:
raise errors.RadioError("Failed to communicate with the radio: %s" % e)
def __clone_out(radio):
pipe = radio.pipe
block_lengths = radio._block_lengths
total_written = 0
def _status():
status = chirp_common.Status()
status.msg = "Cloning to radio"
status.max = sum(block_lengths)
status.cur = total_written
radio.status_fn(status)
start = time.time()
pos = 0
for block in radio._block_lengths:
LOG.debug("\nSending %i-%i" % (pos, pos + block))
out = radio.get_mmap()[pos:pos + block]
# need to chew byte-by-byte here or else we lose the ACK...not sure why
for b in out:
pipe.write(bytes([b]))
pipe.read(1) # chew the echo
ack = pipe.read(1)
if ack[0] != yaesu_clone.CMD_ACK:
raise Exception("block not ack'ed: %s" % repr(ack))
total_written += len(out)
_status()
pos += block
LOG.debug("Clone completed in %i seconds" % (time.time() - start))
return True
chirp-20261030/chirp/drivers/ft817.py 0000644 0001750 0001750 00000133636 15172631605 016062 0 ustar hibby hibby #
# Copyright 2012 Filippi Marco
#
# 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 After clicking OK , press the [A] key to send image.\n")
rp.pre_upload = _(
"1. Turn radio off.\n"
"2. Connect cable to ACC jack.\n"
"3. Press and hold in the [MODE <] and [MODE >] keys"
" while\n"
" turning the radio on (\"CLONE MODE\" will appear on the\n"
" display).\n"
"4. Press the [C] key (\"RX\" will appear on the LCD).\n")
return rp
def _read(self, block, blocknum, lastblock):
# be very patient at first block
if blocknum == 0:
attempts = 60
else:
attempts = 5
for _i in range(0, attempts):
data = self.pipe.read(block + 2)
if data:
break
time.sleep(0.5)
if not data:
raise errors.RadioNoResponse()
if len(data) == block + 2 and data[0] == blocknum:
checksum = yaesu_clone.YaesuChecksum(1, block)
if checksum.get_existing(data) != \
checksum.get_calculated(data):
raise Exception("Checksum Failed [%02X<>%02X] block %02X" %
(checksum.get_existing(data),
checksum.get_calculated(data), blocknum))
# Chew away the block number and the checksum
data = data[1:block + 1]
else:
if lastblock and self._US_model:
raise Exception(_("Unable to read last block. "
"This often happens when the selected model "
"is US but the radio is a non-US one (or "
"widebanded). Please choose the correct "
"model and try again."))
else:
raise Exception("Unable to read block %02X expected %i got %i"
% (blocknum, block + 2, len(data)))
LOG.debug("Read %i" % len(data))
return data
def _clone_in(self):
# Be very patient with the radio
self.pipe.timeout = 2
start = time.time()
data = bytes(b"")
blocks = 0
status = chirp_common.Status()
status.msg = _("Cloning from radio")
nblocks = len(self._block_lengths) + 39
status.max = nblocks
for block in self._block_lengths:
if blocks == 8:
# repeated read of 40 block same size (memory area)
repeat = 40
else:
repeat = 1
for _i in range(0, repeat):
data += self._read(block, blocks, blocks == nblocks - 1)
self.pipe.write(bytes([CMD_ACK]))
blocks += 1
status.cur = blocks
self.status_fn(status)
if not self._US_model:
status.msg = _("Clone completed, checking for spurious bytes")
self.status_fn(status)
moredata = self.pipe.read(2)
if moredata:
raise Exception(
_("Radio sent data after the last awaited block, "
"this happens when the selected model is a non-US "
"but the radio is a US one. "
"Please choose the correct model and try again."))
LOG.info("Clone completed in %i seconds" % (time.time() - start))
return memmap.MemoryMapBytes(data)
def _clone_out(self):
delay = 0.5
start = time.time()
blocks = 0
pos = 0
status = chirp_common.Status()
status.msg = _("Cloning to radio")
status.max = len(self._block_lengths) + 39
mmap = self.get_mmap().get_byte_compatible()
for block in self._block_lengths:
if blocks == 8:
# repeated read of 40 block same size (memory area)
repeat = 40
else:
repeat = 1
for _i in range(0, repeat):
time.sleep(0.01)
checksum = yaesu_clone.YaesuChecksum(pos, pos + block - 1)
LOG.debug("Block %i - will send from %i to %i byte " %
(blocks, pos, pos + block))
LOG.debug(util.hexprint(chr(blocks)))
LOG.debug(util.hexprint(self.get_mmap()[pos:pos + block]))
LOG.debug(util.hexprint(chr(checksum.get_calculated(mmap))))
self.pipe.write(bytes([blocks]))
self.pipe.write(mmap[pos:pos + block])
self.pipe.write(bytes([checksum.get_calculated(
self.get_mmap())]))
buf = self.pipe.read(1)
if not buf or buf[0] != CMD_ACK:
time.sleep(delay)
buf = self.pipe.read(1)
if not buf:
raise errors.RadioNoResponse()
if buf[0] != CMD_ACK:
LOG.debug(util.hexprint(buf))
raise Exception(_("Radio did not ack block %i") % blocks)
pos += block
blocks += 1
status.cur = blocks
self.status_fn(status)
LOG.info("Clone completed in %i seconds" % (time.time() - start))
def sync_in(self):
try:
self._mmap = self._clone_in()
except errors.RadioError:
raise
except Exception as e:
raise errors.RadioError("Failed to communicate with radio: %s" % e)
self.process_mmap()
def sync_out(self):
try:
self._clone_out()
except errors.RadioError:
raise
except Exception as e:
raise errors.RadioError("Failed to communicate with radio: %s" % e)
def process_mmap(self):
self._memobj = bitwise.parse(self.MEM_FORMAT, self._mmap)
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.has_bank = False
rf.has_dtcs_polarity = False
rf.has_nostep_tuning = True
rf.valid_modes = list(set(self.MODES))
rf.valid_tmodes = list(self.TMODES)
rf.valid_duplexes = list(self.DUPLEX)
rf.valid_tuning_steps = list(self.STEPSFM)
rf.valid_bands = self.VALID_BANDS
rf.valid_skips = ["", "S"]
rf.valid_power_levels = []
rf.valid_characters = "".join(self.CHARSET)
rf.valid_name_length = 8
rf.valid_special_chans = sorted(self.SPECIAL_MEMORIES.keys())
rf.memory_bounds = (1, 200)
rf.can_odd_split = True
rf.has_ctone = False
rf.has_settings = True
return rf
def get_raw_memory(self, number):
return repr(self._memobj.memory[number - 1])
def _get_duplex(self, mem, _mem):
if _mem.is_duplex == 1:
mem.duplex = self.DUPLEX[_mem.duplex]
else:
mem.duplex = ""
def _get_tmode(self, mem, _mem):
mem.tmode = self.TMODES[_mem.tmode]
mem.rtone = chirp_common.TONES[_mem.tone]
mem.dtcs = chirp_common.DTCS_CODES[_mem.dcs]
def _set_duplex(self, mem, _mem):
_mem.duplex = self.DUPLEX.index(mem.duplex)
_mem.is_duplex = mem.duplex != ""
def _set_tmode(self, mem, _mem):
_mem.tmode = self.TMODES.index(mem.tmode)
# have to put this bit to 0 otherwise we get strange display in tone
# frequency (menu 83). See bug #88 and #163
_mem.unknown_toneflag = 0
_mem.tone = chirp_common.TONES.index(mem.rtone)
_mem.dcs = chirp_common.DTCS_CODES.index(mem.dtcs)
def get_memory(self, number):
if isinstance(number, str):
return self._get_special(number)
elif number < 0:
# I can't stop delete operation from losing extd_number but
# I know how to get it back
return self._get_special(self.SPECIAL_MEMORIES_REV[number])
else:
return self._get_normal(number)
def set_memory(self, memory):
if memory.number < 0:
return self._set_special(memory)
else:
return self._set_normal(memory)
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"]
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"]
elif mem.number in range(-2, -6, -1):
_mem = self._memobj.home[5 + mem.number]
immutable = ["number", "skip", "extd_number",
"name", "dtcs_polarity", "power"]
elif mem.number == -1:
_mem = self._memobj.qmb
immutable = ["number", "skip", "extd_number",
"name", "dtcs_polarity", "power"]
elif mem.number in list(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"]
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 _set_special(self, mem):
if mem.empty and mem.number not in list(self.SPECIAL_PMS.values()):
# can't delete special memories!
raise Exception("Sorry, special memory can't be deleted")
cur_mem = self._get_special(self.SPECIAL_MEMORIES_REV[mem.number])
# TODO add frequency range check for vfo and home memories
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]
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]
elif mem.number in range(-2, -6, -1):
_mem = self._memobj.home[5 + mem.number]
elif mem.number == -1:
_mem = self._memobj.qmb
elif mem.number in list(self.SPECIAL_PMS.values()):
# this case has to be last because 817 pms keys overlap with
# 857 derived class other special memories
bitindex = -self.LAST_PMS_INDEX + mem.number
wasused = (self._memobj.pmsvisible >> bitindex) & 0x01
wasvalid = (self._memobj.pmsfilled >> bitindex) & 0x01
if mem.empty:
if wasvalid and not wasused:
# pylint get confused by &= operator
self._memobj.pmsfilled = self._memobj.pmsfilled & \
~ (1 << bitindex)
# pylint get confused by &= operator
self._memobj.pmsvisible = self._memobj.pmsvisible & \
~ (1 << bitindex)
return
# pylint get confused by |= operator
self._memobj.pmsvisible = self._memobj.pmsvisible | 1 << bitindex
self._memobj.pmsfilled = self._memobj.pmsfilled | 1 << bitindex
_mem = self._memobj.pms[-self.LAST_PMS_INDEX + mem.number]
else:
raise Exception("Sorry, special memory index %i " % mem.number +
"unknown you hit a bug!!")
for key in cur_mem.immutable:
if key != "extd_number":
if cur_mem.__dict__[key] != mem.__dict__[key]:
raise errors.RadioError("Editing field `%s' " % key +
"is not supported on this channel")
self._set_memory(mem, _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 or _mem.freq == 0xffffffff:
return mem
if mem.number == 1:
mem.immutable = ['empty']
return self._get_memory(mem, _mem)
def _set_normal(self, mem):
_mem = self._memobj.memory[mem.number - 1]
wasused = (self._memobj.visible[(mem.number - 1) / 8] >>
(mem.number - 1) % 8) & 0x01
wasvalid = (self._memobj.filled[(mem.number - 1) / 8] >>
(mem.number - 1) % 8) & 0x01
if mem.empty:
if mem.number == 1:
# as Dan says "yaesus are not good about that :("
# if you upload an empty image you can brick your radio
raise Exception("Sorry, can't delete first memory")
if wasvalid and not wasused:
self._memobj.filled[(mem.number - 1) // 8] &= \
~(1 << (mem.number - 1) % 8)
_mem.set_raw("\xFF" * (_mem.size() // 8)) # clean up
self._memobj.visible[(mem.number - 1) // 8] &= \
~(1 << (mem.number - 1) % 8)
return
if not wasvalid:
_mem.set_raw("\x00" * (_mem.size() // 8)) # clean up
self._memobj.visible[(mem.number - 1) // 8] |= (
1 << (mem.number - 1) % 8)
self._memobj.filled[(mem.number - 1) // 8] |= (
1 << (mem.number - 1) % 8)
self._set_memory(mem, _mem)
def _get_memory(self, mem, _mem):
mem.freq = int(_mem.freq) * 10
mem.offset = int(_mem.offset) * 10
self._get_duplex(mem, _mem)
mem.mode = self.MODES[_mem.mode]
if mem.mode == "FM":
if _mem.is_fm_narrow == 1:
mem.mode = "NFM"
mem.tuning_step = self.STEPSFM[_mem.fm_step]
elif mem.mode == "AM":
mem.tuning_step = self.STEPSAM[_mem.am_step]
elif mem.mode == "CW" or mem.mode == "CWR":
if _mem.is_cwdig_narrow == 1:
mem.mode = "N" + mem.mode
mem.tuning_step = self.STEPSSSB[_mem.ssb_step]
else:
try:
mem.tuning_step = self.STEPSSSB[_mem.ssb_step]
except IndexError:
pass
mem.skip = _mem.skip and "S" or ""
self._get_tmode(mem, _mem)
if _mem.tag_on_off == 1:
for i in _mem.name:
if i == 0xFF:
break
if chr(i) in self.CHARSET:
mem.name += chr(i)
else:
# radio have some graphical chars that are not supported
# we replace those with a *
LOG.info("Replacing char %x with *" % i)
mem.name += "*"
mem.name = mem.name.rstrip()
else:
mem.name = ""
mem.extra = RadioSettingGroup("extra", "Extra")
ipo = RadioSetting("ipo", "IPO",
RadioSettingValueBoolean(bool(_mem.ipo)))
ipo.set_doc("Bypass preamp")
mem.extra.append(ipo)
att = RadioSetting("att", "ATT",
RadioSettingValueBoolean(bool(_mem.att)))
att.set_doc("10dB front end attenuator")
mem.extra.append(att)
return mem
def _set_memory(self, mem, _mem):
# not supported in chirp so I make label visible if have one
if len(mem.name) > 0:
_mem.tag_on_off = 1
else:
_mem.tag_on_off = 0
_mem.tag_default = 0 # never use default label "CH-nnn"
self._set_duplex(mem, _mem)
if mem.mode[0] == "N": # is it narrow?
_mem.mode = self.MODES.index(mem.mode[1:])
# here I suppose it's safe to set both
_mem.is_fm_narrow = _mem.is_cwdig_narrow = 1
else:
_mem.mode = self.MODES.index(mem.mode)
# here I suppose it's safe to set both
_mem.is_fm_narrow = _mem.is_cwdig_narrow = 0
i = 0
for lo, hi in self.VALID_BANDS:
if mem.freq > lo and mem.freq < hi:
break
i += 1
_mem.freq_range = i
# all this should be safe also when not in split but ...
if mem.duplex == "split":
_mem.tx_mode = _mem.mode
i = 0
for lo, hi in self.VALID_BANDS:
if mem.offset >= lo and mem.offset < hi:
break
i += 1
_mem.tx_freq_range = i
_mem.skip = mem.skip == "S"
self._set_tmode(mem, _mem)
try:
_mem.ssb_step = self.STEPSSSB.index(mem.tuning_step)
except ValueError:
pass
try:
_mem.am_step = self.STEPSAM.index(mem.tuning_step)
except ValueError:
pass
try:
_mem.fm_step = self.STEPSFM.index(mem.tuning_step)
except ValueError:
pass
_mem.rit = 0 # not supported in chirp
_mem.freq = mem.freq / 10
_mem.offset = mem.offset / 10
# there are ft857D that have problems with short labels, see bug #937
# some of the radio fill with 0xff and some with blanks
# the latter is safe for all ft8x7 radio
# so why should i do it only for some?
for i in range(0, 8):
_mem.name[i] = ord(mem.name.ljust(8)[i])
for setting in mem.extra:
setattr(_mem, setting.get_name(), setting.value)
def validate_memory(self, mem):
msgs = yaesu_clone.YaesuCloneModeRadio.validate_memory(self, mem)
lo, hi = self.VALID_BANDS[2] # this is fm broadcasting
if mem.freq >= lo and mem.freq <= hi:
if mem.mode != "FM":
msgs.append(chirp_common.ValidationError(
"Only FM is supported in this band"))
# TODO check that step is valid in current mode
return msgs
@classmethod
def match_model(cls, filedata, filename):
return len(filedata) == cls._memsize
def get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic")
cw = RadioSettingGroup("cw", "CW")
packet = RadioSettingGroup("packet", "Digital & packet")
panel = RadioSettingGroup("panel", "Panel settings")
extended = RadioSettingGroup("extended", "Extended")
antenna = RadioSettingGroup("antenna", "Antenna selection")
panelcontr = RadioSettingGroup("panelcontr", "Panel controls")
top = RadioSettings(basic, cw, packet,
panelcontr, panel, extended, antenna)
rs = RadioSetting("ars_144", "144 ARS",
RadioSettingValueBoolean(_settings.ars_144))
basic.append(rs)
rs = RadioSetting("ars_430", "430 ARS",
RadioSettingValueBoolean(_settings.ars_430))
basic.append(rs)
rs = RadioSetting("pkt9600_mic", "Packet 9600 mic level",
RadioSettingValueInteger(0, 100,
_settings.pkt9600_mic))
packet.append(rs)
options = ["enable", "disable"]
rs = RadioSetting(
"disable_amfm_dial", "AM&FM Dial",
RadioSettingValueList(
options, current_index=_settings.disable_amfm_dial))
panel.append(rs)
rs = RadioSetting("am_mic", "AM mic level",
RadioSettingValueInteger(0, 100, _settings.am_mic))
basic.append(rs)
options = ["OFF", "1h", "2h", "3h", "4h", "5h", "6h"]
rs = RadioSetting(
"apo_time", "APO time",
RadioSettingValueList(
options, current_index=_settings.apo_time))
basic.append(rs)
options = ["OFF", "Range", "All"]
rs = RadioSetting(
"arts_beep", "ARTS beep",
RadioSettingValueList(
options, current_index=_settings.arts_beep))
basic.append(rs)
options = ["OFF", "ON", "Auto"]
rs = RadioSetting(
"backlight", "Backlight",
RadioSettingValueList(
options, current_index=_settings.backlight))
panel.append(rs)
options = ["6h", "8h", "10h"]
rs = RadioSetting(
"batt_chg", "Battery charge",
RadioSettingValueList(
options, current_index=_settings.batt_chg))
basic.append(rs)
options = ["440 Hz", "880 Hz"]
rs = RadioSetting(
"beep_freq", "Beep frequency",
RadioSettingValueList(
options, current_index=_settings.beep_freq))
panel.append(rs)
rs = RadioSetting("beep_volume", "Beep volume",
RadioSettingValueInteger(0, 100,
_settings.beep_volume))
panel.append(rs)
options = ["4800", "9600", "38400"]
rs = RadioSetting(
"cat_rate", "CAT rate",
RadioSettingValueList(
options, current_index=_settings.cat_rate))
basic.append(rs)
options = ["Blue", "Amber", "Violet"]
rs = RadioSetting("color", "Color",
RadioSettingValueList(options,
current_index=_settings.color))
panel.append(rs)
rs = RadioSetting("contrast", "Contrast",
RadioSettingValueInteger(1, 12,
_settings.contrast - 1))
panel.append(rs)
rs = RadioSetting("cw_delay", "CW delay (*10 ms)",
RadioSettingValueInteger(1, 250,
_settings.cw_delay))
cw.append(rs)
rs = RadioSetting("cw_id", "CW id",
RadioSettingValueBoolean(_settings.cw_id))
cw.append(rs)
options = ["Normal", "Reverse"]
rs = RadioSetting(
"cw_paddle", "CW paddle",
RadioSettingValueList(
options, current_index=_settings.cw_paddle))
cw.append(rs)
options = ["%i Hz" % i for i in range(300, 1001, 50)]
rs = RadioSetting(
"cw_pitch", "CW pitch",
RadioSettingValueList(
options, current_index=_settings.cw_pitch))
cw.append(rs)
options = ["%i wpm" % i for i in range(4, 61)]
rs = RadioSetting(
"cw_speed", "CW speed",
RadioSettingValueList(
options, current_index=_settings.cw_speed))
cw.append(rs)
options = ["1:%1.1f" % (i / 10) for i in range(25, 46, 1)]
rs = RadioSetting(
"cw_weight", "CW weight",
RadioSettingValueList(
options, current_index=_settings.cw_weight))
cw.append(rs)
rs = RadioSetting("dig_disp", "Dig disp (*10 Hz)",
RadioSettingValueInteger(-300, 300,
_settings.dig_disp))
packet.append(rs)
rs = RadioSetting("dig_mic", "Dig mic",
RadioSettingValueInteger(0, 100,
_settings.dig_mic))
packet.append(rs)
options = ["RTTY", "PSK31-L", "PSK31-U", "USER-L", "USER-U"]
rs = RadioSetting(
"dig_mode", "Dig mode",
RadioSettingValueList(
options, current_index=_settings.dig_mode))
packet.append(rs)
rs = RadioSetting("dig_shift", "Dig shift (*10 Hz)",
RadioSettingValueInteger(-300, 300,
_settings.dig_shift))
packet.append(rs)
rs = RadioSetting("fm_mic", "FM mic",
RadioSettingValueInteger(0, 100,
_settings.fm_mic))
basic.append(rs)
options = ["Dial", "Freq", "Panel"]
rs = RadioSetting(
"lock_mode", "Lock mode",
RadioSettingValueList(
options, current_index=_settings.lock_mode))
panel.append(rs)
options = ["Fine", "Coarse"]
rs = RadioSetting(
"main_step", "Main step",
RadioSettingValueList(
options, current_index=_settings.main_step))
panel.append(rs)
rs = RadioSetting("mem_group", "Mem group",
RadioSettingValueBoolean(_settings.mem_group))
basic.append(rs)
rs = RadioSetting("mic_key", "Mic key",
RadioSettingValueBoolean(_settings.mic_key))
cw.append(rs)
rs = RadioSetting("mic_scan", "Mic scan",
RadioSettingValueBoolean(_settings.mic_scan))
basic.append(rs)
options = ["Off", "SSB", "CW"]
rs = RadioSetting(
"op_filter", "Optional filter",
RadioSettingValueList(
options, current_index=_settings.op_filter))
basic.append(rs)
rs = RadioSetting("pkt_mic", "Packet mic",
RadioSettingValueInteger(0, 100, _settings.pkt_mic))
packet.append(rs)
options = ["1200", "9600"]
rs = RadioSetting(
"pkt_rate", "Packet rate",
RadioSettingValueList(
options, current_index=_settings.pkt_rate))
packet.append(rs)
options = ["Off", "3 sec", "5 sec", "10 sec"]
rs = RadioSetting(
"resume_scan", "Resume scan",
RadioSettingValueList(
options, current_index=_settings.resume_scan))
basic.append(rs)
options = ["Cont", "Chk"]
rs = RadioSetting("scope", "Scope",
RadioSettingValueList(options,
current_index=_settings.scope))
basic.append(rs)
rs = RadioSetting("sidetone", "Sidetone",
RadioSettingValueInteger(0, 100, _settings.sidetone))
cw.append(rs)
options = ["RF-Gain", "Squelch"]
rs = RadioSetting(
"sql_rf_gain", "Squelch/RF-Gain",
RadioSettingValueList(
options, current_index=_settings.sql_rf_gain))
panel.append(rs)
rs = RadioSetting("ssb_mic", "SSB Mic",
RadioSettingValueInteger(0, 100, _settings.ssb_mic))
basic.append(rs)
options = ["%i" % i for i in range(0, 21)]
options[0] = "Off"
rs = RadioSetting(
"tot_time", "Time-out timer",
RadioSettingValueList(
options, current_index=_settings.tot_time))
basic.append(rs)
rs = RadioSetting("vox_delay", "VOX delay (*100 ms)",
RadioSettingValueInteger(1, 25, _settings.vox_delay))
basic.append(rs)
rs = RadioSetting("vox_gain", "VOX Gain",
RadioSettingValueInteger(0, 100, _settings.vox_gain))
basic.append(rs)
rs = RadioSetting("extended_menu", "Extended menu",
RadioSettingValueBoolean(_settings.extended_menu))
extended.append(rs)
options = ["Tn-Rn", "Tn-Riv", "Tiv-Rn", "Tiv-Riv"]
rs = RadioSetting("dcs_inv", "DCS coding", RadioSettingValueList(
options, current_index=_settings.dcs_inv))
extended.append(rs)
rs = RadioSetting("r_lsb_car", "LSB Rx carrier point (*10 Hz)",
RadioSettingValueInteger(-30, 30,
_settings.r_lsb_car))
extended.append(rs)
rs = RadioSetting("r_usb_car", "USB Rx carrier point (*10 Hz)",
RadioSettingValueInteger(-30, 30,
_settings.r_usb_car))
extended.append(rs)
rs = RadioSetting("t_lsb_car", "LSB Tx carrier point (*10 Hz)",
RadioSettingValueInteger(-30, 30,
_settings.t_lsb_car))
extended.append(rs)
rs = RadioSetting("t_usb_car", "USB Tx carrier point (*10 Hz)",
RadioSettingValueInteger(-30, 30,
_settings.t_usb_car))
extended.append(rs)
options = ["Hi", "L3", "L2", "L1"]
rs = RadioSetting(
"tx_power", "TX power",
RadioSettingValueList(
options, current_index=_settings.tx_power))
basic.append(rs)
options = ["Front", "Rear"]
rs = RadioSetting(
"hf_antenna", "HF",
RadioSettingValueList(
options, current_index=_settings.hf_antenna))
antenna.append(rs)
rs = RadioSetting(
"sixm_antenna", "6M",
RadioSettingValueList(
options, current_index=_settings.sixm_antenna))
antenna.append(rs)
rs = RadioSetting(
"bc_antenna", "Broadcasting",
RadioSettingValueList(
options, current_index=_settings.bc_antenna))
antenna.append(rs)
rs = RadioSetting(
"air_antenna", "Air band",
RadioSettingValueList(
options, current_index=_settings.air_antenna))
antenna.append(rs)
rs = RadioSetting(
"vhf_antenna", "VHF",
RadioSettingValueList(
options, current_index=_settings.vhf_antenna))
antenna.append(rs)
rs = RadioSetting(
"uhf_antenna", "UHF",
RadioSettingValueList(
options, current_index=_settings.uhf_antenna))
antenna.append(rs)
st = RadioSettingValueString(0, 7, ''.join([self._CALLSIGN_CHARSET[x]
for x in self._memobj.
callsign]))
st.set_charset(self._CALLSIGN_CHARSET)
rs = RadioSetting("callsign", "Callsign", st)
cw.append(rs)
rs = RadioSetting("spl", "Split",
RadioSettingValueBoolean(_settings.spl))
panelcontr.append(rs)
options = ["None", "Up", "Down", "PMS"]
rs = RadioSetting(
"scn_mode", "Scan mode",
RadioSettingValueList(
options, current_index=_settings.scn_mode))
panelcontr.append(rs)
rs = RadioSetting("pri", "Priority",
RadioSettingValueBoolean(_settings.pri))
panelcontr.append(rs)
rs = RadioSetting("dw", "Dual watch",
RadioSettingValueBoolean(_settings.dw))
panelcontr.append(rs)
rs = RadioSetting("art", "Auto-range transponder",
RadioSettingValueBoolean(_settings.art))
panelcontr.append(rs)
rs = RadioSetting("nb", "Noise blanker",
RadioSettingValueBoolean(_settings.nb))
panelcontr.append(rs)
options = ["Auto", "Fast", "Slow", "Off"]
rs = RadioSetting("agc", "AGC", RadioSettingValueList(
options, current_index=_settings.agc))
panelcontr.append(rs)
options = ["PWR", "ALC", "SWR", "MOD"]
rs = RadioSetting(
"pwr_meter_mode", "Power meter mode",
RadioSettingValueList(
options, current_index=_settings.pwr_meter_mode))
panelcontr.append(rs)
rs = RadioSetting("vox", "Vox",
RadioSettingValueBoolean(_settings.vox))
panelcontr.append(rs)
rs = RadioSetting("bk", "Semi break-in",
RadioSettingValueBoolean(_settings.bk))
cw.append(rs)
rs = RadioSetting("kyr", "Keyer",
RadioSettingValueBoolean(_settings.kyr))
cw.append(rs)
options = ["enabled", "disabled"]
rs = RadioSetting("fst", "Fast", RadioSettingValueList(
options, current_index=_settings.fst))
panelcontr.append(rs)
options = ["enabled", "disabled"]
rs = RadioSetting("lock", "Lock",
RadioSettingValueList(options,
current_index=_settings.lock))
panelcontr.append(rs)
return top
def set_settings(self, settings):
_settings = self._memobj.settings
for element in settings:
if not isinstance(element, RadioSetting):
self.set_settings(element)
continue
try:
if "." in element.get_name():
bits = element.get_name().split(".")
obj = self._memobj
for bit in bits[:-1]:
obj = getattr(obj, bit)
setting = bits[-1]
else:
obj = _settings
setting = element.get_name()
try:
LOG.debug("Setting %s(%s) <= %s" % (setting,
getattr(obj, setting),
element.value))
except AttributeError:
LOG.debug("Setting %s <= %s" % (setting, element.value))
if setting == "contrast":
setattr(obj, setting, int(element.value) + 1)
elif setting == "callsign":
self._memobj.callsign = \
[self._CALLSIGN_CHARSET_REV[x] for x in
str(element.value)]
else:
setattr(obj, setting, element.value)
except Exception:
LOG.debug(element.get_name())
raise
@directory.register
class FT817NDRadio(FT817Radio):
"""Yaesu FT-817ND"""
MODEL = "FT-817ND"
_model = ""
_memsize = 6521
# block 9 (130 Bytes long) is to be repeated 40 times
_block_lengths = [2, 40, 208, 182, 208, 182, 198, 53, 130, 118, 130]
@directory.register
class FT817NDUSRadio(FT817Radio):
"""Yaesu FT-817ND (US version)"""
# seems that radios configured for 5 MHz operations send one packet
# more than others so we have to distinguish sub models
MODEL = "FT-817ND (US)"
_model = ""
_US_model = True
_memsize = 6651
# block 9 (130 Bytes long) is to be repeated 40 times
_block_lengths = [2, 40, 208, 182, 208, 182, 198, 53, 130, 118, 130, 130]
SPECIAL_60M = {
"M-601": -42,
"M-602": -41,
"M-603": -40,
"M-604": -39,
"M-605": -38,
}
LAST_SPECIAL60M_INDEX = -42
SPECIAL_MEMORIES = dict(FT817Radio.SPECIAL_MEMORIES)
SPECIAL_MEMORIES.update(SPECIAL_60M)
SPECIAL_MEMORIES_REV = dict(list(zip(list(SPECIAL_MEMORIES.values()),
list(SPECIAL_MEMORIES.keys()))))
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", "rtone", "ctone",
"extd_number", "name", "dtcs", "tmode", "cross_mode",
"dtcs_polarity", "power", "duplex", "offset",
"empty"]
return mem
def _set_special_60m(self, mem):
if mem.empty:
# can't delete 60M memories!
raise Exception("Sorry, 60M memory can't be deleted")
cur_mem = self._get_special_60m(self.SPECIAL_MEMORIES_REV[mem.number])
for key in cur_mem.immutable:
if cur_mem.__dict__[key] != mem.__dict__[key]:
raise errors.RadioError("Editing field `%s' " % key +
"is not supported on M-60x channels")
if mem.mode not in ["USB", "LSB", "CW", "CWR", "NCW", "NCWR", "DIG"]:
raise errors.RadioError("Mode {mode} is not valid "
"in 60m channels".format(mode=mem.mode))
_mem = self._memobj.sixtymeterchannels[-self.LAST_SPECIAL60M_INDEX +
mem.number]
self._set_memory(mem, _mem)
def get_memory(self, number):
if number in self.SPECIAL_60M.keys():
return self._get_special_60m(number)
elif (isinstance(number, int) and number < 0 and
self.SPECIAL_MEMORIES_REV[number] in
list(self.SPECIAL_60M.keys())):
# I can't stop delete operation from losing extd_number but
# I know how to get it back
return self._get_special_60m(self.SPECIAL_MEMORIES_REV[number])
else:
return FT817Radio.get_memory(self, number)
def set_memory(self, memory):
if memory.number in list(self.SPECIAL_60M.values()):
return self._set_special_60m(memory)
else:
return FT817Radio.set_memory(self, memory)
def get_settings(self):
top = FT817Radio.get_settings(self)
basic = top[0]
rs = RadioSetting("emergency", "Emergency",
RadioSettingValueBoolean(
self._memobj.settings.emergency))
basic.append(rs)
return top
chirp-20261030/chirp/drivers/ft818.py 0000755 0001750 0001750 00000022742 14665027664 016073 0 ustar hibby hibby #
# Copyright 2012 Filippi Marco
# Copyright 2018 Vinny Stipo
#
# 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
#
# 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 After clicking OK ,\n"
" press the [C](SEND) key to send image.\n")
rp.pre_upload = _(
"1. Turn radio off.\n"
"2. Connect cable to ACC jack.\n"
"3. Press and hold in the [MODE <] and [MODE >] keys"
" while\n"
" turning the radio on (\"CLONE MODE\" will appear on the\n"
" display).\n"
"4. Press the [A](RCV) key (\"receiving\" will appear on the"
" LCD).\n")
return rp
def get_features(self):
rf = ft817.FT817Radio.get_features(self)
rf.has_cross = True
rf.has_ctone = True
rf.has_rx_dtcs = True
rf.valid_tmodes = list(self.TMODES_REV.keys())
rf.valid_cross_modes = list(self.CROSS_MODES_REV.keys())
return rf
def _get_duplex(self, mem, _mem):
# radio set is_duplex only for + and - but not for split
# at the same time it does not complain if we set it same way 817 does
# (so no set_duplex here)
mem.duplex = self.DUPLEX[_mem.duplex]
def _get_tmode(self, mem, _mem):
if not _mem.is_split_tone:
mem.tmode = self.TMODES[int(_mem.tmode)]
else:
mem.tmode = "Cross"
mem.cross_mode = self.CROSS_MODES[int(_mem.tmode)]
if mem.tmode == "Tone":
mem.rtone = mem.ctone = chirp_common.TONES[_mem.tone]
elif mem.tmode == "TSQL":
mem.rtone = mem.ctone = chirp_common.TONES[_mem.tone]
elif mem.tmode == "DTCS Enc": # UI does not support it yet but
# this code has already been tested
mem.dtcs = mem.rx_dtcs = chirp_common.DTCS_CODES[_mem.dcs]
elif mem.tmode == "DTCS":
mem.dtcs = mem.rx_dtcs = chirp_common.DTCS_CODES[_mem.dcs]
elif mem.tmode == "Cross":
mem.ctone = chirp_common.TONES[_mem.rxtone]
# don't want to fail for this
try:
mem.rtone = chirp_common.TONES[_mem.tone]
except IndexError:
mem.rtone = chirp_common.TONES[0]
mem.dtcs = chirp_common.DTCS_CODES[_mem.dcs]
mem.rx_dtcs = chirp_common.DTCS_CODES[_mem.rxdcs]
def _set_tmode(self, mem, _mem):
if mem.tmode != "Cross":
_mem.is_split_tone = 0
_mem.tmode = self.TMODES_REV[mem.tmode]
else:
_mem.tmode = self.CROSS_MODES_REV[mem.cross_mode]
_mem.is_split_tone = 1
if mem.tmode == "Tone":
_mem.tone = _mem.rxtone = chirp_common.TONES.index(mem.rtone)
elif mem.tmode == "TSQL":
_mem.tone = _mem.rxtone = chirp_common.TONES.index(mem.ctone)
elif mem.tmode == "DTCS Enc": # UI does not support it yet but
# this code has already been tested
_mem.dcs = _mem.rxdcs = chirp_common.DTCS_CODES.index(mem.dtcs)
elif mem.tmode == "DTCS":
_mem.dcs = _mem.rxdcs = chirp_common.DTCS_CODES.index(mem.dtcs)
elif mem.tmode == "Cross":
_mem.tone = chirp_common.TONES.index(mem.rtone)
_mem.rxtone = chirp_common.TONES.index(mem.ctone)
_mem.dcs = chirp_common.DTCS_CODES.index(mem.dtcs)
_mem.rxdcs = chirp_common.DTCS_CODES.index(mem.rx_dtcs)
# have to put this bit to 0 otherwise we get strange display in tone
# frequency (menu 83). See bug #88 and #163
_mem.unknown_toneflag = 0
# dunno if there's the same problem here but to be safe ...
_mem.unknown_rxtoneflag = 0
def get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic")
cw = RadioSettingGroup("cw", "CW")
packet = RadioSettingGroup("packet", "Digital & packet")
panel = RadioSettingGroup("panel", "Panel settings")
extended = RadioSettingGroup("extended", "Extended")
panelcontr = RadioSettingGroup("panelcontr", "Panel controls")
top = RadioSettings(basic, cw, packet,
panelcontr, panel, extended)
rs = RadioSetting("extended_menu", "Extended menu",
RadioSettingValueBoolean(_settings.extended_menu))
extended.append(rs)
rs = RadioSetting("ars_144", "144 MHz ARS",
RadioSettingValueBoolean(_settings.ars_144))
basic.append(rs)
rs = RadioSetting("ars_430", "430 MHz ARS",
RadioSettingValueBoolean(_settings.ars_430))
basic.append(rs)
options = ["enable", "disable"]
rs = RadioSetting(
"disable_amfm_dial", "AM&FM Dial",
RadioSettingValueList(
options, current_index=_settings.disable_amfm_dial))
panel.append(rs)
rs = RadioSetting("am_mic", "AM mic gain",
RadioSettingValueInteger(0, 100, _settings.am_mic))
basic.append(rs)
options = ["OFF", "1h", "2h", "3h", "4h", "5h", "6h"]
rs = RadioSetting(
"apo_time", "APO time",
RadioSettingValueList(
options, current_index=_settings.apo_time))
basic.append(rs)
options = ["OFF", "Range", "All"]
rs = RadioSetting(
"arts_beep", "ARTS beep",
RadioSettingValueList(
options, current_index=_settings.arts_beep))
basic.append(rs)
rs = RadioSetting("arts_id", "ARTS ID",
RadioSettingValueBoolean(_settings.arts_id))
extended.append(rs)
st = RadioSettingValueString(0, 10,
safe_charset_string(
self._memobj.arts_idw,
self._CALLSIGN_CHARSET)
)
st.set_charset(self._CALLSIGN_CHARSET)
rs = RadioSetting("arts_idw", "ARTS IDW", st)
extended.append(rs)
st = RadioSettingValueString(0, 40,
safe_charset_string(
self._memobj.beacon_text1,
self._BEACON_CHARSET)
)
st.set_charset(self._BEACON_CHARSET)
rs = RadioSetting("beacon_text1", "Beacon text1", st)
extended.append(rs)
st = RadioSettingValueString(0, 40,
safe_charset_string(
self._memobj.beacon_text2,
self._BEACON_CHARSET)
)
st.set_charset(self._BEACON_CHARSET)
rs = RadioSetting("beacon_text2", "Beacon text2", st)
extended.append(rs)
st = RadioSettingValueString(0, 40,
safe_charset_string(
self._memobj.beacon_text3,
self._BEACON_CHARSET)
)
st.set_charset(self._BEACON_CHARSET)
rs = RadioSetting("beacon_text3", "Beacon text3", st)
extended.append(rs)
options = ["OFF"] + ["%i sec" % i for i in range(1, 256)]
rs = RadioSetting(
"beacon_time", "Beacon time",
RadioSettingValueList(
options, current_index=_settings.beacon_time))
extended.append(rs)
options = ["440 Hz", "880 Hz", "1760 Hz"]
rs = RadioSetting(
"beep_tone", "Beep tone",
RadioSettingValueList(
options, current_index=_settings.beep_tone))
panel.append(rs)
rs = RadioSetting("beep_vol", "Beep volume",
RadioSettingValueInteger(0, 100, _settings.beep_vol))
panel.append(rs)
rs = RadioSetting("r_lsb_car", "LSB Rx carrier point (*10 Hz)",
RadioSettingValueInteger(-30, 30,
_settings.r_lsb_car))
extended.append(rs)
rs = RadioSetting("r_usb_car", "USB Rx carrier point (*10 Hz)",
RadioSettingValueInteger(-30, 30,
_settings.r_usb_car))
extended.append(rs)
rs = RadioSetting("t_lsb_car", "LSB Tx carrier point (*10 Hz)",
RadioSettingValueInteger(-30, 30,
_settings.t_lsb_car))
extended.append(rs)
rs = RadioSetting("t_usb_car", "USB Tx carrier point (*10 Hz)",
RadioSettingValueInteger(-30, 30,
_settings.t_usb_car))
extended.append(rs)
options = ["4800", "9600", "38400"]
rs = RadioSetting(
"cat_rate", "CAT rate",
RadioSettingValueList(
options, current_index=_settings.cat_rate))
basic.append(rs)
options = ["CAT", "Linear", "Tuner"]
rs = RadioSetting(
"cat_lin_tun", "CAT/LIN/TUN selection",
RadioSettingValueList(
options, current_index=_settings.cat_lin_tun))
extended.append(rs)
options = ["MAIN", "VFO/MEM", "CLAR"]
# TODO test the 3 options on non D radio
# which have only SEL and MAIN
rs = RadioSetting(
"clar_dial_sel", "Clarifier dial selection",
RadioSettingValueList(
options, current_index=_settings.clar_dial_sel))
panel.append(rs)
rs = RadioSetting("cw_auto_mode", "CW Automatic mode",
RadioSettingValueBoolean(_settings.cw_auto_mode))
cw.append(rs)
options = ["USB", "LSB", "AUTO"]
rs = RadioSetting("cw_bfo", "CW BFO", RadioSettingValueList(
options, current_index=_settings.cw_bfo))
cw.append(rs)
options = ["FULL"] + ["%i ms" % (i * 10) for i in range(3, 301)]
val = (_settings.cw_delay + _settings.cw_delay_hi * 256) - 2
rs = RadioSetting("cw_delay", "CW delay",
RadioSettingValueList(options, current_index=val))
cw.append(rs)
options = ["Normal", "Reverse"]
rs = RadioSetting(
"cw_key_rev", "CW key reverse",
RadioSettingValueList(
options, current_index=_settings.cw_key_rev))
cw.append(rs)
rs = RadioSetting("cw_paddle", "CW paddle",
RadioSettingValueBoolean(_settings.cw_paddle))
cw.append(rs)
options = ["%i Hz" % i for i in range(400, 801, 100)]
rs = RadioSetting(
"cw_pitch", "CW pitch",
RadioSettingValueList(
options, current_index=_settings.cw_pitch))
cw.append(rs)
options = ["%i ms" % i for i in range(5, 31, 5)]
rs = RadioSetting("cw_qsk", "CW QSK", RadioSettingValueList(
options, current_index=_settings.cw_qsk))
cw.append(rs)
rs = RadioSetting("cw_sidetone", "CW sidetone volume",
RadioSettingValueInteger(0, 100,
_settings.cw_sidetone))
cw.append(rs)
options = ["%i wpm" % i for i in range(4, 61)]
rs = RadioSetting(
"cw_speed", "CW speed",
RadioSettingValueList(
options, current_index=_settings.cw_speed))
cw.append(rs)
options = ["Numeric", "Alphabet", "AlphaNumeric"]
rs = RadioSetting(
"cw_training", "CW training",
RadioSettingValueList(
options, current_index=_settings.cw_training))
cw.append(rs)
options = ["1:%1.1f" % (i / 10) for i in range(25, 46, 1)]
rs = RadioSetting(
"cw_weight", "CW weight",
RadioSettingValueList(
options, current_index=_settings.cw_weight))
cw.append(rs)
options = ["Tn-Rn", "Tn-Riv", "Tiv-Rn", "Tiv-Riv"]
rs = RadioSetting("dcs_inv", "DCS inv", RadioSettingValueList(
options, current_index=_settings.dcs_inv))
extended.append(rs)
options = ["Fine", "Coarse"]
rs = RadioSetting(
"dial_step", "Dial step",
RadioSettingValueList(
options, current_index=_settings.dial_step))
panel.append(rs)
rs = RadioSetting("dig_disp", "Dig disp (*10 Hz)",
RadioSettingValueInteger(-300, 300,
_settings.dig_disp))
packet.append(rs)
rs = RadioSetting("dig_mic", "Dig gain",
RadioSettingValueInteger(0, 100,
_settings.dig_mic))
packet.append(rs)
options = ["RTTYL", "RTTYU", "PSK31-L", "PSK31-U", "USER-L", "USER-U"]
rs = RadioSetting(
"dig_mode", "Dig mode",
RadioSettingValueList(
options, current_index=_settings.dig_mode))
packet.append(rs)
rs = RadioSetting("dig_shift", "Dig shift (*10 Hz)",
RadioSettingValueInteger(-300, 300,
_settings.dig_shift))
packet.append(rs)
rs = RadioSetting("dig_vox", "Dig vox",
RadioSettingValueInteger(0, 100, _settings.dig_vox))
packet.append(rs)
options = ["ARTS", "BAND", "FIX", "MEMGRP", "MODE", "MTR", "VFO"]
rs = RadioSetting(
"disp_color", "Display color mode",
RadioSettingValueList(
options, current_index=_settings.disp_color))
panel.append(rs)
rs = RadioSetting("disp_color_arts", "Display color ARTS set",
RadioSettingValueInteger(0, 1,
_settings.disp_color_arts))
panel.append(rs)
rs = RadioSetting("disp_color_band", "Display color band set",
RadioSettingValueInteger(0, 1,
_settings.disp_color_band))
panel.append(rs)
rs = RadioSetting("disp_color_memgrp",
"Display color memory group set",
RadioSettingValueInteger(0, 1,
_settings.disp_color_memgrp)
)
panel.append(rs)
rs = RadioSetting("disp_color_mode", "Display color mode set",
RadioSettingValueInteger(0, 1,
_settings.disp_color_mode))
panel.append(rs)
rs = RadioSetting("disp_color_mtr", "Display color meter set",
RadioSettingValueInteger(0, 1,
_settings.disp_color_mtr))
panel.append(rs)
rs = RadioSetting("disp_color_vfo", "Display color VFO set",
RadioSettingValueInteger(0, 1,
_settings.disp_color_vfo))
panel.append(rs)
rs = RadioSetting("disp_color_fix", "Display color fix set",
RadioSettingValueInteger(1, 32,
_settings.disp_color_fix + 1
))
panel.append(rs)
rs = RadioSetting("disp_contrast", "Contrast",
RadioSettingValueInteger(3, 15,
_settings.disp_contrast + 2)
)
panel.append(rs)
rs = RadioSetting("disp_intensity", "Intensity",
RadioSettingValueInteger(1, 3,
_settings.disp_intensity))
panel.append(rs)
options = ["OFF", "Auto1", "Auto2", "ON"]
rs = RadioSetting(
"disp_mode", "Display backlight mode",
RadioSettingValueList(
options, current_index=_settings.disp_mode))
panel.append(rs)
options = ["60 Hz", "120 Hz", "240 Hz"]
rs = RadioSetting("dsp_bpf", "Dsp band pass filter",
RadioSettingValueList(
options, current_index=_settings.dsp_bpf))
cw.append(rs)
options = ["100 Hz", "160 Hz", "220 Hz", "280 Hz", "340 Hz", "400 Hz",
"460 Hz", "520 Hz", "580 Hz", "640 Hz", "720 Hz", "760 Hz",
"820 Hz", "880 Hz", "940 Hz", "1000 Hz"]
rs = RadioSetting(
"dsp_hpf", "Dsp hi pass filter cut off",
RadioSettingValueList(options, current_index=_settings.dsp_hpf))
basic.append(rs)
options = ["1000 Hz", "1160 Hz", "1320 Hz", "1480 Hz", "1650 Hz",
"1800 Hz", "1970 Hz", "2130 Hz", "2290 Hz", "2450 Hz",
"2610 Hz", "2770 Hz", "2940 Hz", "3100 Hz", "3260 Hz",
"3420 Hz", "3580 Hz", "3740 Hz", "3900 Hz", "4060 Hz",
"4230 Hz", "4390 Hz", "4550 Hz", "4710 Hz", "4870 Hz",
"5030 Hz", "5190 Hz", "5390 Hz", "5520 Hz", "5680 Hz",
"5840 Hz", "6000 Hz"]
rs = RadioSetting(
"dsp_lpf", "Dsp low pass filter cut off",
RadioSettingValueList(options, current_index=_settings.dsp_lpf))
basic.append(rs)
options = ["OFF", "LPF", "HPF", "BOTH"]
rs = RadioSetting(
"dsp_mic_eq", "Dsp mic equalization",
RadioSettingValueList(
options, current_index=_settings.dsp_mic_eq))
basic.append(rs)
rs = RadioSetting("dsp_nr", "DSP noise reduction level",
RadioSettingValueInteger(1, 16,
_settings.dsp_nr + 1))
basic.append(rs)
# emergency only for US model
rs = RadioSetting("fm_mic", "FM mic gain",
RadioSettingValueInteger(0, 100, _settings.fm_mic))
basic.append(rs)
rs = RadioSetting("home_vfo", "Enable HOME to VFO moving",
RadioSettingValueBoolean(_settings.home_vfo))
panel.append(rs)
options = ["Dial", "Freq", "Panel", "All"]
rs = RadioSetting(
"lock_mode", "Lock mode",
RadioSettingValueList(
options, current_index=_settings.lock_mode))
panel.append(rs)
rs = RadioSetting("mem_group", "Mem group",
RadioSettingValueBoolean(_settings.mem_group))
basic.append(rs)
options = ["CW SIDETONE", "CW SPEED", "MHz/MEM GRP", "MIC GAIN",
"NB LEVEL", "RF POWER", "STEP"]
rs = RadioSetting(
"mem_vfo_dial_mode", "Mem/VFO dial mode",
RadioSettingValueList(
options, current_index=_settings.mem_vfo_dial_mode))
panel.append(rs)
rs = RadioSetting("mic_scan", "Mic scan",
RadioSettingValueBoolean(_settings.mic_scan))
basic.append(rs)
options = ["NOR", "RMT", "CAT"]
rs = RadioSetting("mic_sel", "Mic selection",
RadioSettingValueList(
options, current_index=_settings.mic_sel))
extended.append(rs)
options = ["SIG", "CTR", "VLT", "N/A", "FS", "OFF"]
rs = RadioSetting(
"mtr_arx_sel", "Meter receive selection",
RadioSettingValueList(
options, current_index=_settings.mtr_arx_sel))
extended.append(rs)
options = ["PWR", "ALC", "MOD", "SWR", "VLT", "N/A", "OFF"]
rs = RadioSetting(
"mtr_atx_sel", "Meter transmit selection",
RadioSettingValueList(
options, current_index=_settings.mtr_atx_sel))
extended.append(rs)
rs = RadioSetting("mtr_peak_hold", "Meter peak hold",
RadioSettingValueBoolean(_settings.mtr_peak_hold))
extended.append(rs)
rs = RadioSetting("nb_level", "Noise blanking level",
RadioSettingValueInteger(0, 100, _settings.nb_level))
basic.append(rs)
st = RadioSettingValueString(0, 4,
safe_charset_string(
self._memobj.op_filter1_name,
self._CALLSIGN_CHARSET)
)
st.set_charset(self._CALLSIGN_CHARSET)
rs = RadioSetting("op_filter1_name", "Optional filter1 name", st)
extended.append(rs)
st = RadioSettingValueString(0, 4,
safe_charset_string(
self._memobj.op_filter2_name,
self._CALLSIGN_CHARSET)
)
st.set_charset(self._CALLSIGN_CHARSET)
rs = RadioSetting("op_filter2_name", "Optional filter2 name", st)
extended.append(rs)
rs = RadioSetting("pg_a", "Programmable key MFq:A",
RadioSettingValueList(self.PROGRAMMABLEOPTIONS,
current_index=_settings.pg_a))
extended.append(rs)
rs = RadioSetting("pg_b", "Programmable key MFq:B",
RadioSettingValueList(self.PROGRAMMABLEOPTIONS,
current_index=_settings.pg_b))
extended.append(rs)
rs = RadioSetting("pg_c", "Programmable key MFq:C",
RadioSettingValueList(self.PROGRAMMABLEOPTIONS,
current_index=_settings.pg_c))
extended.append(rs)
rs = RadioSetting("pg_acc", "Programmable mic key ACC",
RadioSettingValueList(
self.PROGRAMMABLEOPTIONS,
current_index=_settings.pg_acc))
extended.append(rs)
rs = RadioSetting("pg_p1", "Programmable mic key P1",
RadioSettingValueList(self.PROGRAMMABLEOPTIONS,
current_index=_settings.pg_p1))
extended.append(rs)
rs = RadioSetting("pg_p2", "Programmable mic key P2",
RadioSettingValueList(self.PROGRAMMABLEOPTIONS,
current_index=_settings.pg_p2))
extended.append(rs)
rs = RadioSetting("pkt1200", "Packet 1200 gain level",
RadioSettingValueInteger(0, 100,
_settings.pkt1200))
packet.append(rs)
rs = RadioSetting("pkt9600", "Packet 9600 gain level",
RadioSettingValueInteger(0, 100, _settings.pkt9600))
packet.append(rs)
options = ["1200", "9600"]
rs = RadioSetting(
"pkt_rate", "Packet rate",
RadioSettingValueList(
options, current_index=_settings.pkt_rate))
packet.append(rs)
rs = RadioSetting("proc_level", "Proc level",
RadioSettingValueInteger(0, 100,
_settings.proc_level))
basic.append(rs)
rs = RadioSetting("rf_power_hf", "Rf power set HF",
RadioSettingValueInteger(5, 100,
_settings.rf_power_hf))
basic.append(rs)
rs = RadioSetting("rf_power_6m", "Rf power set 6m",
RadioSettingValueInteger(5, 100,
_settings.rf_power_6m))
basic.append(rs)
rs = RadioSetting("rf_power_vhf", "Rf power set VHF",
RadioSettingValueInteger(5, 50,
_settings.rf_power_vhf))
basic.append(rs)
rs = RadioSetting("rf_power_uhf", "Rf power set UHF",
RadioSettingValueInteger(2, 20,
_settings.rf_power_uhf))
basic.append(rs)
options = ["TIME", "BUSY", "STOP"]
rs = RadioSetting(
"scan_mode", "Scan mode",
RadioSettingValueList(
options, current_index=_settings.scan_mode))
basic.append(rs)
rs = RadioSetting("scan_resume", "Scan resume",
RadioSettingValueInteger(1, 10,
_settings.scan_resume))
basic.append(rs)
rs = RadioSetting("split_tone", "Split tone enable",
RadioSettingValueBoolean(_settings.split_tone))
extended.append(rs)
options = ["RF-Gain", "Squelch"]
rs = RadioSetting(
"sql_rf_gain", "Squelch/RF-Gain",
RadioSettingValueList(
options, current_index=_settings.sql_rf_gain))
panel.append(rs)
rs = RadioSetting("ssb_mic", "SSB Mic gain",
RadioSettingValueInteger(0, 100, _settings.ssb_mic))
basic.append(rs)
options = ["Off"] + ["%i" % i for i in range(1, 21)]
rs = RadioSetting(
"tot_time", "Time-out timer",
RadioSettingValueList(
options, current_index=_settings.tot_time))
basic.append(rs)
options = ["OFF", "ATAS(HF)", "ATAS(HF&50)", "ATAS(ALL)", "TUNER"]
rs = RadioSetting(
"tuner_atas", "Tuner/ATAS device",
RadioSettingValueList(
options, current_index=_settings.tuner_atas))
extended.append(rs)
rs = RadioSetting("tx_if_filter", "Transmit IF filter",
RadioSettingValueList(
self.FILTERS,
current_index=_settings.tx_if_filter))
basic.append(rs)
rs = RadioSetting("vox_delay", "VOX delay (*100 ms)",
RadioSettingValueInteger(1, 30, _settings.vox_delay))
basic.append(rs)
rs = RadioSetting("vox_gain", "VOX Gain",
RadioSettingValueInteger(1, 100, _settings.vox_gain))
basic.append(rs)
rs = RadioSetting("xvtr_a", "Xvtr A displacement",
RadioSettingValueInteger(
-4294967295, 4294967295,
self._memobj.xvtr_a_offset *
(-1 if _settings.xvtr_a_negative else 1)))
extended.append(rs)
rs = RadioSetting("xvtr_b", "Xvtr B displacement",
RadioSettingValueInteger(
-4294967295, 4294967295,
self._memobj.xvtr_b_offset *
(-1 if _settings.xvtr_b_negative else 1)))
extended.append(rs)
options = ["OFF", "XVTR A", "XVTR B"]
rs = RadioSetting(
"xvtr_sel", "Transverter function selection",
RadioSettingValueList(
options, current_index=_settings.xvtr_sel))
extended.append(rs)
rs = RadioSetting("disp", "Display large",
RadioSettingValueBoolean(_settings.disp))
panel.append(rs)
rs = RadioSetting("nb", "Noise blanker",
RadioSettingValueBoolean(_settings.nb))
panelcontr.append(rs)
options = ["Auto", "Fast", "Slow", "Off"]
rs = RadioSetting("agc", "AGC",
RadioSettingValueList(options,
current_index=_settings.agc))
panelcontr.append(rs)
options = ["PWR", "ALC", "SWR", "MOD"]
rs = RadioSetting(
"pwr_meter_mode", "Power meter mode",
RadioSettingValueList(
options, current_index=_settings.pwr_meter_mode))
panelcontr.append(rs)
rs = RadioSetting("vox", "Vox",
RadioSettingValueBoolean(_settings.vox))
panelcontr.append(rs)
rs = RadioSetting("bk", "Semi break-in",
RadioSettingValueBoolean(_settings.bk))
cw.append(rs)
rs = RadioSetting("kyr", "Keyer",
RadioSettingValueBoolean(_settings.kyr))
cw.append(rs)
options = ["enabled", "disabled"]
rs = RadioSetting("fst", "Fast", RadioSettingValueList(
options, current_index=_settings.fst))
panelcontr.append(rs)
options = ["enabled", "disabled"]
rs = RadioSetting("lock", "Lock",
RadioSettingValueList(options,
current_index=_settings.lock))
panelcontr.append(rs)
rs = RadioSetting("scope_peakhold", "Scope max hold",
RadioSettingValueBoolean(_settings.scope_peakhold))
panelcontr.append(rs)
options = ["21", "31", "127"]
rs = RadioSetting(
"scope_width", "Scope width (channels)",
RadioSettingValueList(
options, current_index=_settings.scope_width))
panelcontr.append(rs)
rs = RadioSetting("proc", "Speech processor",
RadioSettingValueBoolean(_settings.proc))
panelcontr.append(rs)
return top
def set_settings(self, settings):
_settings = self._memobj.settings
for element in settings:
if not isinstance(element, RadioSetting):
self.set_settings(element)
continue
try:
if "." in element.get_name():
bits = element.get_name().split(".")
obj = self._memobj
for bit in bits[:-1]:
obj = getattr(obj, bit)
setting = bits[-1]
else:
obj = _settings
setting = element.get_name()
try:
LOG.debug("Setting %s(%s) <= %s" % (setting,
getattr(obj, setting), element.value))
except AttributeError:
LOG.debug("Setting %s <= %s" % (setting, element.value))
if setting == "arts_idw":
self._memobj.arts_idw = \
[self._CALLSIGN_CHARSET_REV[x]
for x in str(element.value)]
elif setting in ["beacon_text1", "beacon_text2",
"beacon_text3", "op_filter1_name",
"op_filter2_name"]:
setattr(self._memobj, setting,
[self._BEACON_CHARSET_REV[x]
for x in str(element.value)])
elif setting == "cw_delay":
val = int(element.value) + 2
setattr(obj, "cw_delay_hi", val / 256)
setattr(obj, setting, val & 0xff)
elif setting == "dig_vox":
val = int(element.value)
setattr(obj, "dig_vox_enable", int(val > 0))
setattr(obj, setting, val)
elif setting in ["disp_color_fix", "dsp_nr"]:
setattr(obj, setting, int(element.value) - 1)
elif setting == "disp_contrast":
setattr(obj, setting, int(element.value) - 2)
elif setting in ["xvtr_a", "xvtr_b"]:
val = int(element.value)
setattr(obj, setting + "_negative", int(val < 0))
setattr(self._memobj, setting + "_offset", abs(val))
else:
setattr(obj, setting, element.value)
except Exception:
LOG.debug(element.get_name())
raise
@directory.register
class FT857USRadio(FT857Radio):
"""Yaesu FT857/897 (US version)"""
# seems that radios configured for 5 MHz operations send one packet more
# than others so we have to distinguish sub models
MODEL = "FT-857/897 (US)"
_model = ""
_US_model = True
_memsize = 7481
# block 9 (140 Bytes long) is to be repeated 40 times
# should be 42 times but this way I can use original 817 functions
_block_lengths = [2, 82, 252, 196, 252, 196, 212, 55, 140, 140, 140, 38,
176, 140]
SPECIAL_60M = {
"M-601": -52,
"M-602": -51,
"M-603": -50,
"M-604": -49,
"M-605": -48,
}
LAST_SPECIAL60M_INDEX = -52
SPECIAL_MEMORIES = dict(FT857Radio.SPECIAL_MEMORIES)
SPECIAL_MEMORIES.update(SPECIAL_60M)
SPECIAL_MEMORIES_REV = dict(list(zip(list(SPECIAL_MEMORIES.values()),
list(SPECIAL_MEMORIES.keys()))))
# this is identical to the one in FT817ND_US_Radio but we inherit from 857
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", "rtone", "ctone",
"extd_number", "name", "dtcs", "tmode", "cross_mode",
"dtcs_polarity", "power", "duplex", "offset",
"empty"]
return mem
# this is identical to the one in FT817ND_US_Radio but we inherit from 857
def _set_special_60m(self, mem):
if mem.empty:
# can't delete 60M memories!
raise Exception("Sorry, 60M memory can't be deleted")
cur_mem = self._get_special_60m(self.SPECIAL_MEMORIES_REV[mem.number])
for key in cur_mem.immutable:
if cur_mem.__dict__[key] != mem.__dict__[key]:
raise errors.RadioError("Editing field `%s' " % key +
"is not supported on M-60x channels")
if mem.mode not in ["USB", "LSB", "CW", "CWR", "NCW", "NCWR", "DIG"]:
raise errors.RadioError("Mode {mode} is not valid "
"in 60m channels".format(mode=mem.mode))
_mem = self._memobj.sixtymeterchannels[-self.LAST_SPECIAL60M_INDEX +
mem.number]
self._set_memory(mem, _mem)
def get_memory(self, number):
if number in self.SPECIAL_60M:
return self._get_special_60m(number)
elif isinstance(number, int) and number < 0 and (
self.SPECIAL_MEMORIES_REV[number] in
list(self.SPECIAL_60M.keys())):
# I can't stop delete operation from losing extd_number but
# I know how to get it back
return self._get_special_60m(self.SPECIAL_MEMORIES_REV[number])
else:
return FT857Radio.get_memory(self, number)
def set_memory(self, memory):
if memory.number in list(self.SPECIAL_60M.values()):
return self._set_special_60m(memory)
else:
return FT857Radio.set_memory(self, memory)
def get_settings(self):
top = FT857Radio.get_settings(self)
basic = top[0]
rs = RadioSetting("emergency", "Emergency",
RadioSettingValueBoolean(
self._memobj.settings.emergency))
basic.append(rs)
return top
chirp-20261030/chirp/drivers/ft90.py 0000644 0001750 0001750 00000056547 15172631605 016000 0 ustar hibby hibby # Copyright 2011 Dan Smith
# Copyright 2013 Jens Jensen AF5MI
#
# 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 After clicking OK , press the [SET] key to send"
" image.\n")
rp.pre_upload = _(
"1. Turn radio off.\n"
"2. Connect mic and hold [ACC] on mic while powering on.\n"
" (\"CLONE\" will appear on the display)\n"
"3. Replace mic with PC programming cable.\n"
"4. Press the [DISP/SS] key\n"
" (\"R\" will appear on the lower left of LCD).\n")
rp.display_pre_upload_prompt_before_opening_port = False
return rp
@classmethod
def match_model(cls, filedata, filename):
return len(filedata) == cls._memsize
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.has_settings = True
rf.has_ctone = False
rf.has_bank = False
rf.has_dtcs_polarity = False
rf.has_dtcs = True
rf.can_odd_split = True
rf.valid_modes = FT90_MODES
rf.valid_tmodes = FT90_TMODES
rf.valid_duplexes = FT90_DUPLEX
rf.valid_tuning_steps = FT90_STEPS[1:]
rf.valid_power_levels = FT90_POWER_LEVELS_VHF
rf.valid_name_length = 7
rf.valid_characters = chirp_common.CHARSET_ASCII
rf.valid_skips = ["", "S"]
rf.valid_special_chans = FT90_SPECIAL
rf.valid_tones = FT90_TONES
rf.memory_bounds = (1, 180)
rf.valid_bands = [(100000000, 230000000),
(300000000, 530000000),
(810000000, 999975000)]
return rf
def _read(self, blocksize, blocknum):
data = self.pipe.read(blocksize+2)
if not data:
if blocknum == 0:
raise errors.RadioNoResponse()
raise errors.RadioError(
"No response reading block %02X" % blocknum)
# chew echo'd ack
self.pipe.write(CMD_ACK)
time.sleep(0.02)
self.pipe.read(1) # chew echoed ACK from 1-wire serial
if len(data) == blocksize + 2 and data[0] == blocknum:
checksum = yaesu_clone.YaesuChecksum(1, blocksize)
if checksum.get_existing(data) != checksum.get_calculated(data):
raise Exception("Checksum Failed [%02X<>%02X] block %02X, "
"data len: %i" %
(checksum.get_existing(data),
checksum.get_calculated(data),
blocknum, len(data)))
data = data[1:blocksize + 1] # Chew blocknum and checksum
else:
raise Exception("Unable to read blocknum %02X "
"expected blocksize %i got %i." %
(blocknum, blocksize+2, len(data)))
return data
def _clone_in(self):
# Be very patient with the radio
self.pipe.timeout = 4
start = time.time()
data = b""
blocknum = 0
status = chirp_common.Status()
status.msg = "Cloning..."
self.status_fn(status)
status.max = len(self._block_lengths)
for blocksize in self._block_lengths:
data += self._read(blocksize, blocknum)
blocknum += 1
status.cur = blocknum
self.status_fn(status)
LOG.info("Clone completed in %i seconds, blocks read: %i" %
(time.time() - start, blocknum))
return memmap.MemoryMapBytes(data)
def _clone_out(self):
looppredelay = 0.4
looppostdelay = 1.9
self.pipe.timeout = 4
start = time.time()
blocknum = 0
pos = 0
status = chirp_common.Status()
status.msg = "Cloning to radio..."
self.status_fn(status)
status.max = len(self._block_lengths)
for blocksize in self._block_lengths:
checksum = yaesu_clone.YaesuChecksum(pos, pos+blocksize-1)
blocknumbyte = bytes([blocknum])
payloadbytes = self.get_mmap()[pos:pos+blocksize]
checksumbyte = bytes([checksum.get_calculated(self.get_mmap())])
LOG.debug("Block %i - will send from %i to %i byte " %
(blocknum, pos, pos + blocksize))
LOG.debug(util.hexprint(blocknumbyte))
LOG.debug(util.hexprint(payloadbytes))
LOG.debug(util.hexprint(checksumbyte))
# send wrapped bytes
time.sleep(looppredelay)
self.pipe.write(blocknumbyte)
self.pipe.write(payloadbytes)
self.pipe.write(checksumbyte)
tmp = self.pipe.read(blocksize + 2) # chew echo
LOG.debug("bytes echoed: ")
LOG.debug(util.hexprint(tmp))
# radio is slow to write/ack:
time.sleep(looppostdelay)
buf = self.pipe.read(1)
LOG.debug("ack recd:")
LOG.debug(util.hexprint(buf))
if not buf:
if blocknum == 0:
raise errors.RadioNoResponse()
raise errors.RadioError(
"Radio did not ack block %i" % blocknum)
if buf != CMD_ACK:
raise Exception("Radio did not ack block %i" % blocknum)
pos += blocksize
blocknum += 1
status.cur = blocknum
self.status_fn(status)
LOG.info("Clone completed in %i seconds" % (time.time() - start))
def sync_in(self):
try:
self._mmap = self._clone_in()
except errors.RadioError:
raise
except Exception:
trace = traceback.format_exc()
raise errors.RadioError(
"Failed to communicate with radio: %s" % trace)
self.process_mmap()
def sync_out(self):
try:
self._clone_out()
except errors.RadioError:
raise
except Exception:
trace = traceback.format_exc()
raise errors.RadioError(
"Failed to communicate with radio: %s" % trace)
def process_mmap(self):
self._memobj = bitwise.parse(self.mem_format, self._mmap)
def _get_chan_enable(self, number):
number = number - 1
bytepos = number // 8
bitpos = number % 8
chan_enable = self._memobj.chan_enable[bytepos]
if chan_enable & (1 << bitpos):
return True
else:
return False
def _set_chan_enable(self, number, enable):
number = number - 1
bytepos = number // 8
bitpos = number % 8
chan_enable = self._memobj.chan_enable[bytepos]
if enable:
chan_enable = chan_enable | (1 << bitpos) # enable
else:
chan_enable = chan_enable & ~(1 << bitpos) # disable
self._memobj.chan_enable[bytepos] = chan_enable
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
# Disabled in 2023 because this doesn't pass tests and I'm
# not sure what it is really trying to accomplish.
# 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 5 kHz 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)):
# don't display blank/junk name
mem.name = ""
else:
mem.name = str(_mem.name).rstrip()
return mem
def get_raw_memory(self, number):
return repr(self._memobj.memory[number-1])
def set_memory(self, mem):
if mem.number < 0: # special channels
_mem = getattr(self._memobj, mem.extd_number)
if re.match('^pms', mem.extd_number):
# enable pms_XY channel flag
_special_enables = self._memobj.special_enables
setattr(_special_enables, mem.extd_number + "_enable", True)
else:
_mem = self._memobj.memory[mem.number - 1]
self._set_chan_enable(mem.number, not mem.empty)
_mem.skip = mem.skip == "S"
# radio has a known bug with 5 kHz step and dead squelch
if not mem.tuning_step or mem.tuning_step == FT90_STEPS[0]:
_mem.step = 2
else:
_mem.step = FT90_STEPS.index(mem.tuning_step)
_mem.rxfreq = mem.freq / 10
# vfo will unlock if not in right band?
if mem.freq > 300000000:
# uhf
_mem.isUhf1 = 1
_mem.isUhf2 = 1
if mem.freq > 810000000:
# uhf hiband
_mem.isUhfHi = 1
else:
_mem.isUhfHi = 0
else:
# vhf
_mem.isUhf1 = 0
_mem.isUhf2 = 0
_mem.isUhfHi = 0
_mem.txfreqoffset = mem.offset / 10
_mem.tone = FT90_TONES.index(mem.rtone)
_mem.tmode = FT90_TMODES.index(mem.tmode)
_mem.mode = FT90_MODES.index(mem.mode)
_mem.shift = FT90_DUPLEX.index(mem.duplex)
_mem.dcstone = chirp_common.DTCS_CODES.index(mem.dtcs)
_mem.step = FT90_STEPS.index(mem.tuning_step)
_mem.shift = FT90_DUPLEX.index(mem.duplex)
if mem.power:
try:
_mem.power = FT90_POWER_LEVELS_VHF.index(mem.power)
except ValueError:
_mem.power = FT90_POWER_LEVELS_UHF.index(mem.power)
else:
_mem.power = 3 # default to low power
if (len(mem.name) == 0):
_mem.name = bytearray.fromhex("80ffffffffffff")
_mem.showname = 0
else:
_mem.name = str(mem.name).ljust(7)
_mem.showname = 1
_mem.UseDefaultName = 0
def _decode_cwid(self, cwidarr):
cwid = ""
LOG.debug("@ +_decode_cwid:")
for byte in cwidarr.get_value():
char = int(byte)
LOG.debug(char)
# bitwise wraps in quotes! get rid of those
if char < len(FT90_CWID_CHARS):
cwid += FT90_CWID_CHARS[char]
return cwid
def _encode_cwid(self, cwidarr):
cwid = ""
LOG.debug("@ _encode_cwid:")
for char in cwidarr.get_value():
cwid += chr(FT90_CWID_CHARS.index(char))
LOG.debug(cwid)
return cwid
def _bbcd2dtmf(self, bcdarr, strlen=16):
# doing bbcd, but with support for ABCD*#
LOG.debug(bcdarr.get_value())
string = ''.join("%02X" % b for b in bcdarr)
LOG.debug("@_bbcd2dtmf, received: %s" % string)
string = string.replace('E', '*').replace('F', '#')
if strlen <= 16:
string = string[:strlen]
return string
def _dtmf2bbcd(self, dtmf):
dtmfstr = dtmf.get_value()
dtmfstr = dtmfstr.replace('*', 'E').replace('#', 'F')
dtmfstr = str.ljust(dtmfstr.strip(), 16, "0")
bcdarr = list(bytearray.fromhex(dtmfstr))
LOG.debug("@_dtmf2bbcd, sending: %s" % bcdarr)
return bcdarr
def get_settings(self):
_settings = self._memobj.settings
basic = RadioSettingGroup("basic", "Basic")
autodial = RadioSettingGroup("autodial", "AutoDial")
keymaps = RadioSettingGroup("keymaps", "KeyMaps")
top = RadioSettings(basic, keymaps, autodial)
rs = RadioSetting(
"beep", "Beep",
RadioSettingValueBoolean(_settings.beep))
basic.append(rs)
rs = RadioSetting(
"lock", "Lock",
RadioSettingValueBoolean(_settings.lock))
basic.append(rs)
rs = RadioSetting(
"ars", "Auto Repeater Shift",
RadioSettingValueBoolean(_settings.ars))
basic.append(rs)
rs = RadioSetting(
"txpwrsave", "TX Power Save",
RadioSettingValueBoolean(_settings.txpwrsave))
basic.append(rs)
rs = RadioSetting(
"txnarrow", "TX Narrow",
RadioSettingValueBoolean(_settings.txnarrow))
basic.append(rs)
options = ["Off", "S-3", "S-5", "S-Full"]
rs = RadioSetting(
"rfsqlvl", "RF Squelch Level",
RadioSettingValueList(
options, current_index=_settings.rfsqlvl))
basic.append(rs)
options = ["Off", "Band A", "Band B", "Both"]
rs = RadioSetting(
"pttlock", "PTT Lock",
RadioSettingValueList(
options, current_index=_settings.pttlock))
basic.append(rs)
rs = RadioSetting(
"cwid_en", "CWID Enable",
RadioSettingValueBoolean(_settings.cwid_en))
basic.append(rs)
cwid = RadioSettingValueString(0, 7, self._decode_cwid(_settings.cwid))
cwid.set_charset(FT90_CWID_CHARS)
rs = RadioSetting("cwid", "CWID", cwid)
basic.append(rs)
options = ["OFF"] + [str(x) for x in (range(1, 12+1))]
rs = RadioSetting(
"apo", "APO time (hrs)",
RadioSettingValueList(options, current_index=_settings.apo))
basic.append(rs)
options = ["Off"] + [str(x) for x in (range(1, 60+1))]
rs = RadioSetting(
"tot", "Time Out Timer (mins)",
RadioSettingValueList(options, current_index=_settings.tot))
basic.append(rs)
options = ["off", "Auto/TX", "Auto", "TX"]
rs = RadioSetting(
"fancontrol", "Fan Control",
RadioSettingValueList(
options, current_index=_settings.fancontrol))
basic.append(rs)
keyopts = ["Scan Up", "Scan Down", "Repeater", "Reverse", "Tone Burst",
"Tx Power", "Home Ch", "VFO/MR", "Tone", "Priority"]
rs = RadioSetting(
"key_lt", "Left Key",
RadioSettingValueList(keyopts, current_index=_settings.key_lt))
keymaps.append(rs)
rs = RadioSetting(
"key_rt", "Right Key",
RadioSettingValueList(keyopts, current_index=_settings.key_rt))
keymaps.append(rs)
rs = RadioSetting(
"key_p1", "P1 Key",
RadioSettingValueList(keyopts, current_index=_settings.key_p1))
keymaps.append(rs)
rs = RadioSetting(
"key_p2", "P2 Key",
RadioSettingValueList(keyopts, current_index=_settings.key_p2))
keymaps.append(rs)
rs = RadioSetting(
"key_acc", "ACC Key",
RadioSettingValueList(
keyopts, current_index=_settings.key_acc))
keymaps.append(rs)
options = [str(x) for x in range(0, 12+1)]
rs = RadioSetting(
"lcdcontrast", "LCD Contrast",
RadioSettingValueList(
options, current_index=_settings.lcdcontrast))
basic.append(rs)
options = ["off", "d4", "d3", "d2", "d1"]
rs = RadioSetting(
"dimmer", "Dimmer",
RadioSettingValueList(options, current_index=_settings.dimmer))
basic.append(rs)
options = ["TRX Normal", "RX Reverse", "TX Reverse", "TRX Reverse"]
rs = RadioSetting(
"dcsmode", "DCS Mode",
RadioSettingValueList(
options, current_index=_settings.dcsmode))
basic.append(rs)
options = ["50 ms", "100 ms"]
rs = RadioSetting(
"dtmfspeed", "DTMF Speed",
RadioSettingValueList(
options, current_index=_settings.dtmfspeed))
autodial.append(rs)
options = ["50 ms", "250 ms", "450 ms", "750 ms", "1 sec"]
rs = RadioSetting(
"dtmftxdelay", "DTMF TX Delay",
RadioSettingValueList(
options, current_index=_settings.dtmftxdelay))
autodial.append(rs)
options = [str(x) for x in range(1, 8 + 1)]
rs = RadioSetting(
"dtmf_active", "DTMF Active",
RadioSettingValueList(
options, current_index=_settings.dtmf_active))
autodial.append(rs)
# setup 8 dtmf autodial entries
for i in range(1, 9):
objname = "dtmf" + str(i)
dtmfsetting = getattr(_settings, objname)
dtmflen = getattr(_settings, objname + "_len")
dtmfstr = self._bbcd2dtmf(dtmfsetting, dtmflen)
dtmf = RadioSettingValueString(0, 16, dtmfstr)
dtmf.set_charset(FT90_DTMF_CHARS + list(" "))
rs = RadioSetting(objname, objname.upper(), dtmf)
autodial.append(rs)
return top
def set_settings(self, uisettings):
_settings = self._memobj.settings
for element in uisettings:
if not isinstance(element, RadioSetting):
self.set_settings(element)
continue
if not element.changed():
continue
try:
setting = element.get_name()
oldval = getattr(_settings, setting)
newval = element.value
if setting == "cwid":
newval = self._encode_cwid(newval)
if re.match(r'dtmf\d', setting):
# set dtmf length field and then get bcd dtmf
dtmfstrlen = len(str(newval).strip())
setattr(_settings, setting + "_len", dtmfstrlen)
newval = self._dtmf2bbcd(newval)
LOG.debug("Setting %s(%s) <= %s" % (setting, oldval, newval))
setattr(_settings, setting, newval)
except Exception:
LOG.debug(element.get_name())
raise
chirp-20261030/chirp/drivers/ftm150.py 0000644 0001750 0001750 00000112532 15270732464 016221 0 ustar hibby hibby # Copyright 2026 CHIRP contributors
#
# 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 After clicking OK here , turn the DIAL knob on the\n"
" radio to select [OK] and press it to start the transfer.\n")
rp.pre_upload = (
"Keep an SD card 'ALL' backup first.\n"
"\n"
"1. Connect the cable to the DATA jack on the back of the\n"
" radio.\n"
"2. Press and hold the [F(SETUP)] key, turn the right DIAL\n"
" knob to select [59 Other -> This], then press the DIAL\n"
" knob.\n"
"3. Turn the DIAL knob to select [OK] and press it, so the\n"
" radio waits for data.\n"
"4. Click OK here within 30 seconds.\n")
return rp
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.has_bank = False
rf.has_bank_names = False
rf.has_settings = True
rf.has_ctone = False
rf.has_dtcs = True
rf.has_dtcs_polarity = False
rf.has_cross = False
rf.has_rx_dtcs = False
rf.has_comment = False
rf.has_nostep_tuning = False
rf.can_odd_split = True
rf.can_delete = True
rf.memory_bounds = (1, 999)
rf.valid_special_chans = sorted(
SPECIAL_MEMORIES, key=_special_memory_sort_key)
# No "DN" -- the FTM-150 is analog only.
rf.valid_modes = ["FM", "NFM", "AM"]
rf.valid_tmodes = list(EDITABLE_TMODES)
rf.valid_duplexes = ["", "-", "+", "split"]
rf.valid_tuning_steps = list(STEPS)
rf.valid_skips = ["", "S"]
rf.valid_power_levels = POWER_LEVELS
rf.valid_name_length = 16
rf.valid_characters = chirp_common.CHARSET_ASCII
rf.valid_dtcs_codes = list(chirp_common.DTCS_CODES)
rf.valid_bands = [
(108000000, 174000000),
(174000000, 400000000),
# The radio accepts 480.0 itself, but nothing above it.
(400000000, 480000001),
]
return rf
def process_mmap(self):
self._memobj = bitwise.parse(MEM_FORMAT, self._mmap)
def _checksums(self):
return [yaesu_clone.YaesuChecksum(0x0000, FILE_CHECKSUM_AT - 1)]
def sync_in(self):
try:
self._mmap = ftm300d._clone_in(self)
self.update_checksums()
except errors.RadioError:
raise
except Exception as e:
LOG.exception("Failed to download from radio")
raise errors.RadioError(
"Failed to download from radio (%s)" % e)
self.process_mmap()
def sync_out(self):
# Send 0x00 in place of the file checksum, like the radio and
# ADMS-17 do, but leave the image itself intact.
checksum = self._mmap[FILE_CHECKSUM_AT]
self._mmap[FILE_CHECKSUM_AT] = b"\x00"
try:
ftm300d._clone_out(self)
except errors.RadioError:
raise
except Exception as e:
LOG.exception("Failed to upload to radio")
raise errors.RadioError(
"Failed to upload to radio (%s)" % e)
finally:
self._mmap[FILE_CHECKSUM_AT] = checksum
# -- settings: the small Set Mode tables so far. VFO A/B, HOME CH A/B
# and PMS are not here -- they are exposed as special channels in the
# Memories grid instead, see the "special channels" section above.
def get_settings(self):
top = RadioSettings()
top.append(self._get_status())
config = RadioSettingGroup("config", "Config")
top.append(config)
unit = int(self._memobj.unit)
config.append(RadioSetting(
"unit", "Display Units",
RadioSettingValueList(
ftm300d.UNIT_LABELS, current_index=unit if unit in (0, 1)
else 0)))
brightness = int(self._memobj.lcd_brightness)
config.append(RadioSetting(
"lcd_brightness", "LCD Brightness (raw value)",
RadioSettingValueString(0, 2, str(brightness))))
dtmf = RadioSettingGroup("dtmf", "DTMF Memory")
top.append(dtmf)
for i in range(9):
code = _decode_dtmf(self._memobj.dtmf[i].digits)
dtmf.append(RadioSetting(
"dtmf%d" % i, "Channel %d" % (i + 1),
RadioSettingValueString(
0, 16, code, autopad=False, charset=DTMF_CHARSET)))
signaling = RadioSettingGroup("signaling", "Signaling")
top.append(signaling)
for direction in ("rx", "tx"):
codes = getattr(self._memobj, "pager_" + direction)
for i in range(2):
code = int(codes[i])
if code >= len(PAGER_CODES):
# Out of range values are left alone rather than shown
# wrong.
continue
rs = RadioSetting(
"pager_%s%d" % (direction, i),
"Pager %s Code %d" % (direction.upper(), i + 1),
RadioSettingValueList(PAGER_CODES, current_index=code))
rs.set_doc(
"Used by channels whose Squelch override is PAGER.")
signaling.append(rs)
wx = RadioSettingGroup("wx", "WX Channel Names")
top.append(wx)
for i in range(10):
rs = RadioSetting(
"wx%d" % i, "WX-CH%02d (%s MHz)" % (i + 1, WX_FREQS[i]),
RadioSettingValueString(
0, 16, _decode_name(self._memobj.wx_names[i].text),
autopad=False))
rs.set_doc(
"Name only -- the frequency is fixed in firmware. The WX "
"bank is reachable only via a programmable key, assigned "
"to [P4] on the USA FTM-150R but to T-CALL on the "
"European FTM-150E.")
wx.append(rs)
top.append(self._get_pmg())
return top
# Operating state from block 0x0080, which the radio sends last and an
# upload restores. Read only: switching it means changing several
# bytes that depend on the active VFO. Confirmed by controlled diff:
# 0x00FB is 0x0A with PMG on and 0x00 with it off, on either VFO, and
# 0x00DF is 1 on VFO A (left on the display) and 0 on VFO B (right).
# With PMG on, the radio also sets 0x80 in byte 3 of the active VFO's
# block (0x00E0 A, 0x00F0 B), 0x01 in byte 4 of the other one, and
# clears 0x00D0 (A) or 0x00C0 (B).
def _get_status(self):
status = RadioSettingGroup("status", "Current Status")
pmg_active = int(self._memobj.pmg_active)
if pmg_active in (0x00, 0x0A):
rs = RadioSetting(
"pmg_active", "PMG active",
RadioSettingValueBoolean(pmg_active == 0x0A))
rs.value.set_mutable(False)
rs.set_doc("Uploading restores the state saved in this "
"image, whatever the radio was set to since.")
status.append(rs)
vfo_a = int(self._memobj.vfo_a_active)
if vfo_a in (0, 1):
rs = RadioSetting(
"vfo_a_active", "Active VFO",
RadioSettingValueList(
["B (right)", "A (left)"], current_index=vfo_a))
rs.value.set_mutable(False)
rs.set_doc("Uploading restores the state saved in this "
"image, whatever the radio was set to since.")
status.append(rs)
return status
def _channel_label(self, number):
if int(self._memobj.memory[number - 1].used):
name = _decode_name(self._memobj.names[number - 1].text)
else:
name = "(empty)"
return ("%d %s" % (number, name)).strip()
# PMG slots are settings, as the radio treats PMG as a list of five
# entries. A slot holding a frequency of its own is a full channel
# (offset, tone, power, ...) that a settings field cannot edit fully,
# so it is shown and kept but cannot be created or changed here. The
# intended way to add that is special channels PMG_1..PMG_5 in the
# memory grid, like VFO and HOME, with these settings still showing
# what each slot holds.
def _get_pmg(self):
pmg = RadioSettingGroup("pmg", "PMG")
channels = [self._channel_label(i + 1)
for i, rec in enumerate(self._memobj.memory)
if int(rec.used)]
for i, rec in enumerate(self._memobj.pmg):
options = [PMG_EMPTY] + channels
current = PMG_EMPTY
number = _pmg_channel(rec.get_raw())
if number is not None:
current = self._channel_label(number)
if current not in options:
# Points at a channel deleted since; kept as is.
options.append(current)
elif int(rec.used):
current = "Frequency %s MHz" % chirp_common.format_freq(
decode_freq(rec.freq))
options.insert(1, current)
rs = RadioSetting(
"pmg%d" % i, "Slot %d" % (i + 1),
RadioSettingValueList(
options, current_index=options.index(current)))
rs.set_doc(
"A memory channel, or a frequency stored in the slot "
"itself. Frequencies can only be stored on the radio. "
"Emptied slots are filled by the slots after them, as on "
"the radio.")
pmg.append(rs)
selected = int(self._memobj.pmg_selected)
slots = ["Slot %d" % (i + 1) for i in range(len(self._memobj.pmg))]
rs = RadioSetting(
"pmg_selected", "Selected slot",
RadioSettingValueList(
slots, current_index=selected if selected < len(slots)
else 0))
rs.set_doc("The slot whose name the radio shows. Follows its "
"entry when that moves up; falls back to slot 1 when "
"the selected slot is emptied.")
pmg.append(rs)
return pmg
def _set_pmg(self, pmg):
old = [rec.get_raw() for rec in self._memobj.pmg]
slots = []
moved_to = {}
selected = 0
for element in pmg:
name = element.get_name()
value = str(element.value)
if name == "pmg_selected":
selected = int(value.split()[1]) - 1
continue
if value == PMG_EMPTY:
continue
idx = int(name[len("pmg"):])
moved_to[idx] = len(slots)
raw = old[idx]
if value.startswith("Frequency "):
slots.append(raw)
continue
number = int(value.split()[0])
if _pmg_channel(raw) != number:
raw = _pmg_ref(
number, int(self._memobj.memory[number - 1].band))
slots.append(raw)
for i, rec in enumerate(self._memobj.pmg):
if i < len(slots):
rec.set_raw(slots[i])
elif old[i][0] & 0x80:
rec.set_raw(b"\x00" + old[i][1:])
# The selection follows its slot when that moves up.
self._memobj.pmg_selected = moved_to.get(selected, 0)
def set_settings(self, settings):
for element in settings:
if not isinstance(element, RadioSetting):
if element.get_name() == "pmg":
self._set_pmg(element)
else:
self.set_settings(element)
continue
name = element.get_name()
value = str(element.value)
if name == "unit":
self._memobj.unit = ftm300d.UNIT_LABELS.index(value)
elif name == "lcd_brightness":
try:
self._memobj.lcd_brightness = int(value)
except ValueError:
pass
elif name.startswith("dtmf"):
idx = int(name[len("dtmf"):])
ftm300d._set_bytes(self._memobj.dtmf[idx].digits,
_encode_dtmf(value))
elif name.startswith(("pager_rx", "pager_tx")):
codes = getattr(self._memobj, name[:-1])
codes[int(name[-1])] = PAGER_CODES.index(value)
elif name.startswith("wx"):
idx = int(name[len("wx"):])
text = value.strip()
ftm300d._set_bytes(self._memobj.wx_names[idx].text,
_encode_name(text))
self._memobj.wx_nameflags[idx] = 0x0000 if text else 0xFFFF
# -- memory channels (1-999): logic ported from ftm300d.py
def get_raw_memory(self, number):
if isinstance(number, str):
arr, _names_arr, idx, _kind = self._special_target(number)
return repr(getattr(self._memobj, arr)[idx])
if number < 0:
return self.get_raw_memory(SPECIAL_MEMORIES_REV[number])
return repr(self._memobj.memory[number - 1])
def validate_memory(self, mem):
msgs = super().validate_memory(mem)
if mem.empty:
return msgs
if mem.number in SPECIAL_MEMORIES_REV:
name = SPECIAL_MEMORIES_REV[mem.number]
_arr, _names_arr, idx, kind = self._special_target(name)
if kind != "pms" and _band_index(mem.freq) != idx:
msgs.append(chirp_common.ValidationError(
"%s only holds %s band frequencies" % (
name, SPECIAL_BANDS[idx])))
if mem.duplex == "split":
tx = mem.offset
elif mem.duplex == "-":
tx = mem.freq - mem.offset
elif mem.duplex == "+":
tx = mem.freq + mem.offset
else:
tx = mem.freq
in_tx = any(lo <= tx < hi for lo, hi in self._tx_bands)
if not in_tx:
if mem.duplex in ("-", "+", "split"):
# Only a warning: an expanded radio transmits here, and a
# stock one refuses to on its own.
msgs.append(chirp_common.ValidationWarning(
"TX frequency is outside amateur allocations "
"for this model"))
else:
msgs.append(chirp_common.ValidationWarning(
"RX-only frequency; radio will not transmit here"))
return msgs
# Shared record decode/encode, used by both regular channels and
# every special channel (VFO/HOME/PMS) below, since they're all the
# same 16-byte chanrecord layout
def _decode_chanrecord(self, mem, _mem):
mem.freq = decode_freq(_mem.freq)
mem.duplex = DUPLEX_FROM_RADIO.get(int(_mem.duplex), "")
if mem.duplex == "split":
mem.offset = decode_freq(_mem.tx_freq)
else:
mem.offset = int(_mem.offset) * 50000
mem.skip = "S" if int(_mem.skip) else ""
try:
mem.power = POWER_LEVELS[int(_mem.power)]
except IndexError:
mem.power = POWER_LEVELS[0]
try:
mem.tuning_step = STEPS[int(_mem.tune_step)]
except IndexError:
mem.tuning_step = STEPS[0]
tone_mode = int(_mem.tone_mode)
mem.tmode = TMODE_FROM_RADIO.get(tone_mode, "")
mem.extra = RadioSettingGroup("extra", "Extra")
rs = RadioSetting(
"sql_override", "Squelch override",
RadioSettingValueList(
SQL_OVERRIDES,
SQL_OVERRIDE_FROM_RADIO.get(tone_mode, SQL_OVERRIDE_NONE)))
rs.set_doc(
"PR FREQ and PAGER have no CHIRP tone mode. When one is "
"selected here, the channel uses it on the radio regardless "
"of Tone Mode. PR FREQ uses the User CTCSS frequency, PAGER "
"the pager codes under Settings -> Signaling.")
mem.extra.append(rs)
pr_freq = int(_mem.pr_freq) - PR_FREQ_MIN
if 0 <= pr_freq < len(PR_FREQS):
# Out of range values are left alone rather than shown wrong.
rs = RadioSetting(
"pr_freq", "User CTCSS",
RadioSettingValueList(PR_FREQS, current_index=pr_freq))
rs.set_doc(
"Select the idle line frequency to remove signals such "
"as idle line signals used by private railways and "
"control signals of MCA radio systems. Only used when "
"Squelch override is PR FREQ.")
mem.extra.append(rs)
rs = RadioSetting(
"clock_shift", "Clock Shift",
RadioSettingValueBoolean(bool(int(_mem.clock_shift))))
rs.set_doc(
"Shift the CPU clock frequency on this channel, to move an "
"internal spurious signal (\"birdie\") away from it.")
mem.extra.append(rs)
try:
mem.rtone = chirp_common.TONES[int(_mem.tone)]
except IndexError:
mem.rtone = 88.5
mem.ctone = mem.rtone
try:
mem.dtcs = chirp_common.DTCS_CODES[int(_mem.dcs)]
except IndexError:
mem.dtcs = 23
if int(_mem.am):
mem.mode = "AM"
elif int(_mem.narrow):
mem.mode = "NFM"
else:
mem.mode = "FM"
def _encode_chanrecord(self, _mem, mem):
_mem.used = 1
_mem.band = _band_index(mem.freq)
_mem.skip = 1 if mem.skip == "S" else 0
encode_freq(_mem.freq, mem.freq)
_mem.duplex = DUPLEX_TO_RADIO.get(mem.duplex, 0)
if mem.duplex == "split":
encode_freq(_mem.tx_freq, int(mem.offset))
_mem.offset = 0
else:
encode_freq(_mem.tx_freq, 0)
_mem.offset = (
int(round(mem.offset / 50000.0)) if mem.offset else 0)
_mem.am = 1 if mem.mode == "AM" else 0
_mem.narrow = 1 if mem.mode == "NFM" else 0
try:
_mem.tune_step = STEPS.index(mem.tuning_step)
except ValueError:
_mem.tune_step = 0
_mem.tone_mode = TMODE_TO_RADIO.get(mem.tmode, 0)
for setting in mem.extra:
if setting.get_name() == "sql_override":
override = str(setting.value)
if override in SQL_OVERRIDE_TO_RADIO:
_mem.tone_mode = SQL_OVERRIDE_TO_RADIO[override]
elif setting.get_name() == "pr_freq":
_mem.pr_freq = (
PR_FREQS.index(str(setting.value)) + PR_FREQ_MIN)
elif setting.get_name() == "clock_shift":
_mem.clock_shift = 1 if setting.value else 0
try:
_mem.tone = chirp_common.TONES.index(mem.rtone)
except ValueError:
_mem.tone = chirp_common.TONES.index(88.5)
try:
_mem.dcs = chirp_common.DTCS_CODES.index(mem.dtcs)
except ValueError:
_mem.dcs = 0
if mem.power in POWER_LEVELS:
_mem.power = POWER_LEVELS.index(mem.power)
else:
_mem.power = 0
# dispatch the regular numbered channels (1-999) vs. the special
# channels (string name, or the negative int CHIRP stores internally)
def get_memory(self, number):
if isinstance(number, str):
return self._get_special(number)
if number < 0:
return self._get_special(SPECIAL_MEMORIES_REV[number])
return self._get_normal(number)
def set_memory(self, mem):
if mem.number < 0:
return self._set_special(mem)
return self._set_normal(mem)
def _get_normal(self, number):
mem = chirp_common.Memory()
mem.number = number
_mem = self._memobj.memory[number - 1]
if not int(_mem.used):
mem.empty = True
return mem
mem.empty = False
self._decode_chanrecord(mem, _mem)
mem.name = _decode_name(self._memobj.names[number - 1].text)
return mem
def _set_normal(self, mem):
_mem = self._memobj.memory[mem.number - 1]
name_idx = mem.number - 1
if mem.empty:
_mem.set_raw(EMPTY_SLOT)
ftm300d._set_bytes(self._memobj.names[name_idx].text, b"\xff" * 16)
self._memobj.nameflags[name_idx] = 0xFFFF
return
if not int(_mem.used):
_mem.set_raw(USED_PROTOTYPE)
self._encode_chanrecord(_mem, mem)
encoded = _encode_name(mem.name)
ftm300d._set_bytes(self._memobj.names[name_idx].text, encoded)
self._memobj.nameflags[name_idx] = (
0x0000 if mem.name.strip() else 0xFFFF)
def _special_target(self, name):
"""Return (chanrecord array attr, names array attr or None, index,
kind) for a special channel name. kind is 'vfo', 'home' or 'pms'."""
for prefix, arr, names_arr, kind in (
("VFO_A", "vfo_a", None, "vfo"),
("VFO_B", "vfo_b", None, "vfo"),
("Home_A", "home_a", "home_a_names", "home"),
("Home_B", "home_b", "home_b_names", "home")):
if name.startswith(prefix + "_"):
band = name[len(prefix) + 1:]
return arr, names_arr, SPECIAL_BANDS.index(band), kind
if name.startswith(("PMS_L_", "PMS_U_")):
prefix, number = name.rsplit("_", 1)
n = int(number) if number.isdigit() else 0
if 1 <= n <= 50:
slot = (n - 1) * 2 + (0 if prefix == "PMS_L" else 1)
return "pms", "pms_names", slot, "pms"
raise errors.InvalidMemoryLocation(
"Unknown FTM-150 special channel %r" % name)
def _get_special(self, name):
arr, names_arr, idx, kind = self._special_target(name)
_mem = getattr(self._memobj, arr)[idx]
_name_obj = (getattr(self._memobj, names_arr)[idx]
if names_arr else None)
mem = chirp_common.Memory()
mem.number = SPECIAL_MEMORIES[name]
mem.extd_number = name
if kind == "pms" and not int(_mem.used):
mem.empty = True
mem.immutable = ["number", "extd_number"]
return mem
mem.empty = False
self._decode_chanrecord(mem, _mem)
if _name_obj is not None:
mem.name = _decode_name(_name_obj.text)
immutable = ["number", "extd_number"]
if _name_obj is None:
# VFO A/B have no name storage at all.
immutable.append("name")
mem.immutable = immutable
return mem
def _set_special(self, mem):
name = SPECIAL_MEMORIES_REV[mem.number]
arr, names_arr, idx, kind = self._special_target(name)
_mem = getattr(self._memobj, arr)[idx]
_name_obj = (getattr(self._memobj, names_arr)[idx]
if names_arr else None)
if mem.empty:
if kind != "pms":
raise errors.RadioError(
"%s cannot be deleted -- VFO/HOME bands always exist "
"on the radio; only PMS entries can be cleared" % name)
_mem.set_raw(EMPTY_SLOT)
if _name_obj is not None:
ftm300d._set_bytes(_name_obj.text, b"\xff" * 16)
return
if kind == "pms" and not int(_mem.used):
_mem.set_raw(USED_PROTOTYPE)
self._encode_chanrecord(_mem, mem)
if _name_obj is not None:
ftm300d._set_bytes(_name_obj.text, _encode_name(mem.name))
chirp-20261030/chirp/drivers/ftm300d.py 0000644 0001750 0001750 00000127607 15253200010 016345 0 ustar hibby hibby # Copyright 2026 CHIRP contributors
#
# 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 After clicking OK , on the radio select OK and "
"press the DIAL knob.\n")
rp.pre_upload = (
"Keep a microSD ALL backup first.\n"
"1. Connect an SCU-56 or SCU-20 to the DATA jack "
"(not the stock USB firmware cable).\n"
"2. Press and hold [F(SETUP)], select CLONE, then "
"[2 Other → This].\n"
"3. After clicking OK , on the radio select OK and "
"press the DIAL knob.\n")
return rp
def _append_mode(self, parent, suffix, title):
group = RadioSettingGroup("band_%s" % suffix, title)
parent.append(group)
group.append(MemSetting(
"fm_bandwidth_%s" % suffix, "FM Bandwidth",
RadioSettingValueList(
FM_BANDWIDTH_LABELS,
current_index=int(
getattr(self._memobj, "fm_bandwidth_%s" % suffix)))))
rx = rx_mode_from_fields(
getattr(self._memobj, "rx_auto_%s" % suffix),
getattr(self._memobj, "rx_am_%s" % suffix))
group.append(RadioSetting(
"rx_mode_%s" % suffix, "RX Mode",
RadioSettingValueList(
RX_MODE_LABELS, current_index=RX_MODE_LABELS.index(rx))))
def _append_repeater_settings(self, parent, suffix, title):
group = RadioSettingGroup("repeater_%s" % suffix, title)
parent.append(group)
group.append(MemSetting(
"rpt_ars_%s" % suffix, "ARS",
RadioSettingValueList(
ON_Off_LABELS,
current_index=int(
getattr(self._memobj, "rpt_ars_%s" % suffix)))))
group.append(MemSetting(
"rpt_shift_%s" % suffix, "Shift",
RadioSettingValueMap(
RPT_SHIFT_MAP,
mem_val=int(
getattr(self._memobj, "rpt_shift_%s" % suffix)))))
units = int(getattr(self._memobj, "rpt_shift_freq_%s" % suffix))
mhz = round(units * RPT_SHIFT_FREQ_STEP, 2)
group.append(RadioSetting(
"rpt_shift_freq_%s" % suffix, "Shift Freq",
RadioSettingValueFloat(
0.0, RPT_SHIFT_FREQ_MAX, mhz, RPT_SHIFT_FREQ_STEP, 2)))
def _append_step_settings(self, group, suffix, title):
if int(getattr(self._memobj, "step_auto_%s" % suffix)):
idx = 0
else:
idx = int(getattr(self._memobj, "vfo_step_%s" % suffix)) + 1
rs = RadioSetting(
"vfo_step_%s" % suffix, title,
RadioSettingValueList(VFO_STEP_LABELS, current_index=idx))
rs.set_doc(
"VFO mode only. In Memory mode the radio uses each "
"channel's Tuning Step.")
group.append(rs)
def _append_rx_coverage_settings(self, group, suffix, title):
group.append(MemSetting(
"rx_coverage_%s" % suffix, title,
RadioSettingValueList(
RX_COVERAGE_LABELS,
current_index=int(
getattr(self._memobj, "rx_coverage_%s" % suffix)))))
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.has_bank = False
rf.has_bank_names = False
rf.has_settings = True
rf.has_ctone = False
rf.has_dtcs = True
rf.has_dtcs_polarity = False
rf.has_cross = False
rf.has_rx_dtcs = False
rf.has_comment = False
rf.has_nostep_tuning = False
rf.can_odd_split = True
rf.can_delete = True
rf.memory_bounds = (1, 999)
rf.valid_modes = ["FM", "NFM", "AM", "DN"]
rf.valid_tmodes = ["", "Tone", "TSQL", "TSQL-R", "DTCS"]
rf.valid_duplexes = ["", "-", "+", "split"]
rf.valid_tuning_steps = list(STEPS)
rf.valid_skips = ["", "S"]
rf.valid_power_levels = POWER_LEVELS
rf.valid_name_length = 16
rf.valid_characters = chirp_common.CHARSET_ASCII
rf.valid_dtcs_codes = list(chirp_common.DTCS_CODES)
rf.valid_bands = [
(108000000, 174000000),
(174000000, 400000000),
(400000000, 480000000),
(480000000, 824000000),
(849000000, 869000000),
(894000000, 999990000),
]
return rf
def process_mmap(self):
self._memobj = bitwise.parse(MEM_FORMAT, self._mmap)
def get_settings(self):
top = RadioSettings()
config = RadioSettingGroup("config", "Config")
top.append(config)
half = timezone_from_fields(
self._memobj.tz_west, self._memobj.tz_mag)
tz_idx = half - TZ_HALF_MIN
if tz_idx < 0 or tz_idx >= len(TIMEZONE_LABELS):
tz_idx = len(TIMEZONE_LABELS)
# Two bitfields; applied as leftover in set_settings().
config.append(RadioSetting(
"timezone", "Time Zone",
RadioSettingValueList(
TIMEZONE_LABELS, current_index=tz_idx)))
date_time_format = RadioSettingGroup("date_time_format",
"Date & Time Format")
config.append(date_time_format)
date_time_format.append(MemSetting(
"date_fmt", "Date Format",
RadioSettingValueMap(
DATE_FORMAT_MAP, mem_val=int(self._memobj.date_fmt))))
date_time_format.append(MemSetting(
"time_12hr", "Time Format",
RadioSettingValueList(
TIME_FORMAT_LABELS,
current_index=int(self._memobj.time_12hr))))
repeater = RadioSettingGroup("repeater", "Repeater")
config.append(repeater)
self._append_repeater_settings(repeater, "a", "A Band")
self._append_repeater_settings(repeater, "b", "B Band")
vfo_step = RadioSettingGroup("vfo_step", "Step (VFO)")
vfo_step.set_doc(
"Tuning step in VFO mode. Auto follows the band plan. "
"Memory mode uses each channel's Tuning Step in the "
"memory editor.")
config.append(vfo_step)
self._append_step_settings(vfo_step, "a", "A Band")
self._append_step_settings(vfo_step, "b", "B Band")
rx_coverage = RadioSettingGroup("rx_coverage", "RX Coverage")
config.append(rx_coverage)
self._append_rx_coverage_settings(rx_coverage, "a", "A Band")
self._append_rx_coverage_settings(rx_coverage, "b", "B Band")
beep = beep_from_fields(
self._memobj.beep_on, self._memobj.beep_high)
config.append(RadioSetting(
"beep", "Beep",
RadioSettingValueList(
BEEP_LABELS, current_index=BEEP_LABELS.index(beep))))
config.append(MemSetting(
"clock_type_b", "Clock Type",
RadioSettingValueList(
CLOCK_TYPE_LABELS,
current_index=int(self._memobj.clock_type_b))))
config.append(MemSetting(
"unit", "Display Units",
RadioSettingValueList(
UNIT_LABELS, current_index=int(self._memobj.unit))))
config.append(MemSetting(
"apo", "APO",
RadioSettingValueMap(APO_MAP, mem_val=int(self._memobj.apo))))
config.append(MemSetting(
"tot", "TOT",
RadioSettingValueMap(TOT_MAP, mem_val=int(self._memobj.tot))))
config.append(MemSetting(
"gps_datum", "GPS Datum",
RadioSettingValueMap(
GPS_DATUM_MAP, mem_val=int(self._memobj.gps_datum))))
config.append(MemSetting(
"gps_device", "GPS Device",
RadioSettingValueList(
GPS_DEVICE_LABELS,
current_index=int(self._memobj.gps_device))))
config.append(MemSetting(
"gps_log", "GPS Log",
RadioSettingValueMap(
GPS_LOG_MAP, mem_val=int(self._memobj.gps_log))))
txrx = RadioSettingGroup("txrx", "TX/RX")
top.append(txrx)
mode = RadioSettingGroup("mode", "Mode")
self._append_mode(mode, "a", "A Band")
self._append_mode(mode, "b", "B Band")
txrx.append(mode)
digital = RadioSettingGroup("digital", "Digital")
txrx.append(digital)
digital.append(MemSetting(
"ams_tx_mode", "AMS TX Mode",
RadioSettingValueList(
AMS_TX_MODE_LABELS,
current_index=int(self._memobj.ams_tx_mode))))
digital.append(MemSetting(
"digital_popup", "Digital Popup",
RadioSettingValueMap(
DIGITAL_POPUP_MAP,
mem_val=int(self._memobj.digital_popup))))
digital.append(MemSetting(
"location_service", "Location Service",
RadioSettingValueList(
ON_Off_LABELS,
current_index=int(self._memobj.location_service))))
digital.append(MemSetting(
"standby_beep_off", "Standby Beep",
RadioSettingValueList(
STANDBY_BEEP_LABELS,
current_index=int(self._memobj.standby_beep_off))))
digital.append(MemSetting(
"digital_vw", "Digital VW",
RadioSettingValueList(
ON_Off_LABELS,
current_index=int(self._memobj.digital_vw))))
audio = RadioSettingGroup("audio", "Audio")
txrx.append(audio)
audio.append(MemSetting(
"sub_band_mute", "Sub Band Mute",
RadioSettingValueMap(
SUB_BAND_MUTE_MAP,
mem_val=int(self._memobj.sub_band_mute))))
audio.append(MemSetting(
"mic_gain", "Mic Gain",
RadioSettingValueMap(
MIC_GAIN_MAP, mem_val=int(self._memobj.mic_gain))))
vox = RadioSettingGroup("vox", "VOX")
audio.append(vox)
vox.append(MemSetting(
"vox", "VOX",
RadioSettingValueList(
VOX_LABELS, current_index=int(self._memobj.vox))))
vox.append(MemSetting(
"vox_delay", "VOX Delay",
RadioSettingValueMap(
VOX_DELAY_MAP, mem_val=int(self._memobj.vox_delay))))
recording = RadioSettingGroup("recording", "Recording")
audio.append(recording)
recording.append(MemSetting(
"recording_band", "Recording Band",
RadioSettingValueMap(
RECORDING_BAND_MAP,
mem_val=int(self._memobj.recording_band))))
recording.append(MemSetting(
"recording_mic", "Recording Mic",
RadioSettingValueList(
ON_Off_LABELS,
current_index=int(self._memobj.recording_mic))))
display = RadioSettingGroup("display", "Display")
top.append(display)
display.append(MemSetting(
"target_location", "Target Location",
RadioSettingValueList(
TARGET_LOCATION_LABELS,
current_index=int(self._memobj.target_location))))
display.append(MemSetting(
"compass", "COMPASS",
RadioSettingValueList(
COMPASS_LABELS, current_index=int(self._memobj.compass))))
display.append(MemSetting(
"band_scope", "Band Scope",
RadioSettingValueList(
BAND_SCOPE_LABELS,
current_index=int(self._memobj.band_scope))))
display.append(MemSetting(
"lcd_brightness", "LCD Brightness",
RadioSettingValueMap(
BRIGHTNESS_MAP,
mem_val=int(self._memobj.lcd_brightness))))
if int(self._memobj.display_info):
dmode_idx = int(self._memobj.display_mode) + 1
else:
dmode_idx = 0
display.append(RadioSetting(
"display_mode", "Display Mode",
RadioSettingValueList(
DISPLAY_MODE_LABELS, current_index=dmode_idx)))
ident = RadioSettingGroup("callsign", "Callsign")
top.append(ident)
ident.append(RadioSetting(
"callsign", "Radio Callsign",
RadioSettingValueString(
0, 10, self._decode_callsign(),
autopad=False, charset=CALLSIGN_CHARSET)))
aprs = RadioSettingGroup("aprs", "APRS")
top.append(aprs)
aprs.append(RadioSetting(
"aprs_call", "APRS Callsign",
RadioSettingValueString(
0, 6, self._decode_aprs_call(),
autopad=False, charset=APRS_CALL_CHARSET)))
aprs.append(MemSetting(
"aprs_ssid", "APRS SSID",
RadioSettingValueMap(
APRS_SSID_MAP, mem_val=int(self._memobj.aprs_ssid))))
aprs.append(MemSetting(
"aprs_modem", "APRS Modem",
RadioSettingValueList(
APRS_MODEM_LABELS,
current_index=int(self._memobj.aprs_modem))))
return top
def set_settings(self, settings):
leftover = settings.apply_to(self._memobj)
for element in leftover:
name = element.get_name()
value = str(element.value)
if name == "timezone":
half = TIMEZONE_LABELS.index(value) + TZ_HALF_MIN
west, mag = timezone_to_fields(half)
self._memobj.tz_west = west
self._memobj.tz_mag = mag
elif name == "beep":
on, high = beep_to_fields(value)
self._memobj.beep_on = on
if high is not None:
self._memobj.beep_high = high
elif name == "display_mode":
info, mode = display_mode_to_fields(value)
self._memobj.display_info = info
if mode is not None:
self._memobj.display_mode = mode
elif name == "rpt_shift_freq_a":
self._memobj.rpt_shift_freq_a = _rpt_shift_freq_to_radio(
value)
elif name == "rpt_shift_freq_b":
self._memobj.rpt_shift_freq_b = _rpt_shift_freq_to_radio(
value)
elif name == "vfo_step_a":
auto, nibble = vfo_step_to_fields(value)
self._memobj.step_auto_a = auto
self._memobj.vfo_step_a = nibble
elif name == "vfo_step_b":
auto, nibble = vfo_step_to_fields(value)
self._memobj.step_auto_b = auto
self._memobj.vfo_step_b = nibble
elif name == "rx_mode_a":
auto, am = rx_mode_to_fields(value)
self._memobj.rx_auto_a = auto
self._memobj.rx_am_a = am
self._memobj.rx_auto_menu_a = 1
elif name == "rx_mode_b":
auto, am = rx_mode_to_fields(value)
self._memobj.rx_auto_b = auto
self._memobj.rx_am_b = am
self._memobj.rx_auto_menu_b = 1
elif name == "callsign":
self._encode_callsign(value)
elif name == "aprs_call":
self._encode_aprs_call(value)
def _decode_callsign(self):
return _decode_padded(self._memobj.callsign, CALLSIGN_PAD)
def _encode_callsign(self, text):
data = _encode_padded(text, 10, CALLSIGN_PAD, CALLSIGN_CHARSET)
_set_bytes(self._memobj.callsign, data)
def _decode_aprs_call(self):
return _decode_padded(self._memobj.aprs_call, APRS_CALL_PAD)
def _encode_aprs_call(self, text):
data = _encode_padded(text, 6, APRS_CALL_PAD, APRS_CALL_CHARSET)
_set_bytes(self._memobj.aprs_call, data)
def sync_in(self):
try:
self._mmap = _clone_in(self)
except errors.RadioError:
raise
except Exception as e:
LOG.exception("Failed to read: %s", e)
raise errors.RadioError(
"Failed to download from radio (%s)" % e)
self.process_mmap()
def sync_out(self):
try:
_clone_out(self)
except errors.RadioError:
raise
except Exception as e:
LOG.exception("Failed to write: %s", e)
raise errors.RadioError(
"Failed to upload to radio (%s)" % e)
def get_raw_memory(self, number):
return repr(self._memobj.memory[number - 1])
def validate_memory(self, mem):
msgs = super().validate_memory(mem)
if mem.empty:
return msgs
if mem.duplex == "split":
tx = mem.offset
elif mem.duplex == "-":
tx = mem.freq - mem.offset
elif mem.duplex == "+":
tx = mem.freq + mem.offset
else:
tx = mem.freq
in_tx = any(lo <= tx < hi for lo, hi in self._tx_bands)
if not in_tx:
if mem.duplex in ("-", "+", "split"):
msgs.append(chirp_common.ValidationError(
"TX frequency is outside amateur allocations "
"for this model"))
else:
msgs.append(chirp_common.ValidationWarning(
"RX-only frequency; radio will not transmit here"))
return msgs
def _decode_name(self, number):
raw = bytes(int(x) for x in self._memobj.names[number - 1].text)
return raw.split(b"\xff")[0].split(b"\x00")[0].decode(
"ascii", "replace").rstrip()
def _encode_name(self, name):
cleaned = "".join(
c if c in chirp_common.CHARSET_ASCII else " "
for c in name)[:16]
padded = cleaned.encode("ascii", "replace")
return padded + b"\xff" * (16 - len(padded))
def _get_extra(self, mem, _mem):
extra = RadioSettingGroup("Extra", "extra")
extra.append(MemSetting(
"ams", "AMS mode",
RadioSettingValueBoolean(bool(int(_mem.ams)))))
extra.append(MemSetting(
"dgid_rx", "RX DG-ID",
RadioSettingValueInteger(0, 99, int(_mem.dgid_rx))))
extra.append(MemSetting(
"dgid_tx", "TX DG-ID",
RadioSettingValueInteger(0, 99, int(_mem.dgid_tx))))
extra.append(MemSetting(
"clock_shift", "Clock Shift",
RadioSettingValueBoolean(bool(int(_mem.clock_shift)))))
mem.extra = extra
def _apply_extra(self, mem, _mem):
for setting in mem.extra:
setting.apply_to_memobj(_mem)
# AMS extra maps to _mem.ams; DN-only is the inverse bit.
# Analog modes must not leave either digital flag set.
if mem.mode == "DN":
_mem.dn = 0 if int(_mem.ams) else 1
else:
_mem.ams = 0
_mem.dn = 0
def get_memory(self, number):
mem = chirp_common.Memory()
mem.number = number
_mem = self._memobj.memory[number - 1]
if not int(_mem.used):
mem.empty = True
return mem
mem.empty = False
mem.freq = decode_freq(_mem.freq)
mem.duplex = DUPLEX_FROM_RADIO.get(int(_mem.duplex), "")
if mem.duplex == "split":
mem.offset = decode_freq(_mem.tx_freq)
else:
mem.offset = int(_mem.offset) * 50000
mem.name = self._decode_name(number)
mem.skip = "S" if int(_mem.skip) else ""
try:
mem.power = POWER_LEVELS[int(_mem.power)]
except IndexError:
mem.power = POWER_LEVELS[0]
try:
mem.tuning_step = STEPS[int(_mem.tune_step)]
except IndexError:
mem.tuning_step = STEPS[0]
mem.tmode = TMODE_FROM_RADIO.get(int(_mem.tone_mode), "")
try:
mem.rtone = chirp_common.TONES[int(_mem.tone)]
except IndexError:
mem.rtone = 88.5
mem.ctone = mem.rtone
try:
mem.dtcs = chirp_common.DTCS_CODES[int(_mem.dcs)]
except IndexError:
mem.dtcs = 23
if int(_mem.am):
mem.mode = "AM"
elif int(_mem.narrow):
mem.mode = "NFM"
elif int(_mem.ams) or int(_mem.dn):
mem.mode = "DN"
else:
mem.mode = "FM"
self._get_extra(mem, _mem)
return mem
def set_memory(self, mem):
_mem = self._memobj.memory[mem.number - 1]
name_idx = mem.number - 1
if mem.empty:
_mem.set_raw(EMPTY_SLOT)
_set_bytes(self._memobj.names[name_idx].text, b"\xff" * 16)
self._memobj.nameflags[name_idx] = 0xFFFF
return
if not int(_mem.used):
_mem.set_raw(USED_PROTOTYPE)
_mem.used = 1
_mem.unknown2 = 1
_mem.occupied = 0xF
_mem.uhf = 1 if mem.freq >= 400000000 else 0
_mem.skip = 1 if mem.skip == "S" else 0
encode_freq(_mem.freq, mem.freq)
_mem.duplex = DUPLEX_TO_RADIO.get(mem.duplex, 0)
if mem.duplex == "split":
encode_freq(_mem.tx_freq, int(mem.offset))
_mem.offset = 0
else:
encode_freq(_mem.tx_freq, 0)
_mem.offset = int(round(mem.offset / 50000.0)) if mem.offset else 0
_mem.am = 1 if mem.mode == "AM" else 0
_mem.narrow = 1 if mem.mode == "NFM" else 0
if mem.mode != "DN":
_mem.ams = 0
_mem.dn = 0
try:
_mem.tune_step = STEPS.index(mem.tuning_step)
except ValueError:
_mem.tune_step = 0
_mem.tone_mode = TMODE_TO_RADIO.get(mem.tmode, 0)
try:
_mem.tone = chirp_common.TONES.index(mem.rtone)
except ValueError:
_mem.tone = chirp_common.TONES.index(88.5)
try:
_mem.dcs = chirp_common.DTCS_CODES.index(mem.dtcs)
except ValueError:
_mem.dcs = 0
if mem.power in POWER_LEVELS:
_mem.power = POWER_LEVELS.index(mem.power)
else:
_mem.power = 0
encoded = self._encode_name(mem.name)
_set_bytes(self._memobj.names[name_idx].text, encoded)
self._memobj.nameflags[name_idx] = (
0x0000 if mem.name.strip() else 0xFFFF)
self._apply_extra(mem, _mem)
if mem.mode == "DN" and not int(_mem.ams) and not int(_mem.dn):
_mem.ams = 1
_mem.dn = 0
chirp-20261030/chirp/drivers/ftm3200d.py 0000644 0001750 0001750 00000015056 14670320477 016447 0 ustar hibby hibby # Copyright 2010 Dan Smith
# Copyright 2017 Wade Simmons
#
# 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
#
# 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
# Copyright 2017 Wade Simmons
# FTM-7250D driver cloned from the FTM-3200 and modified by Iain White
#
# 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
# Portions copyright 2023 Dave Liske
# Portions copyright 2020 by Jiauxn Yang
#
# 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
#
# 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
#
# 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
#
# 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 2 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
#
# 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 2 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
#
# 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 2 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
#
# 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
#
# 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 2 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
# With assistance from
# KG7KMV and Bartłomiej Zieliński
# Based on the implementation of Kenwood TK-8102
import logging
import struct
from chirp import chirp_common, directory, memmap, errors, util
from chirp import bitwise
from chirp import kenwood_tone
from chirp.settings import RadioSettingGroup, RadioSetting
from chirp.settings import RadioSettingValueBoolean, RadioSettingValueList
from chirp.settings import RadioSettings
LOG = logging.getLogger(__name__)
MEM_FORMAT = """
struct {
lbcd rx_freq[4];
lbcd tx_freq[4];
ul16 rxtone;
ul16 txtone;
u8 unknown1:6,
wide:1,
highpower:1;
u8 unknown2:5,
bcl:1,
scan:1,
unknown3:1;
u8 unknown4[2];
} memory[130];
#seekto 0x0a00;
struct {
u8 abr; // 0x0a00
u8 save;
u8 ch_a_step;
u8 ch_b_step;
u8 vox_grd;
u8 ch_a_sql;
u8 ch_b_sql;
u8 roger;
u8 ch_a_v_m;
u8 ch_b_v_m;
u8 ch_a_ch_mdf;
u8 ch_b_ch_mdf;
u8 tdr;
u8 unknown5[3];
u8 unknown6[5]; // 0x0a10
u8 english;
u8 beep;
u8 voice;
u8 night_mode;
u8 abr_lv; // backlight level
u8 tot;
u8 toa;
u8 vox_dly;
u8 sc_rev;
u8 lockmode;
u8 autolock;
u8 unknown7; // 0x0a20
u8 pf1_short;
u8 pf1_long;
u8 pf2_short;
u8 pf2_long;
u8 top_short;
u8 top_long;
u8 rpt_rct;
u8 sc_qt;
u8 pri_ch;
u8 pri_scn;
u8 unknown8;
u8 aprs_rx_band;
u8 ch_a_mute;
u8 ch_b_mute;
u8 unknown9[7]; // 0x0a30
u8 tx_priority;
u8 aprs_rx_popup;
u8 aprs_rx_tone;
u8 aprs_tx_tone;
u8 unknown10;
u8 auto_lock_dly;
u8 menu_dly;
u8 beacon_exit_dly;
u8 unknown11;
u8 unknown12[2]; // 0x0a40
u8 ch_a_mem_ch;
u8 ch_b_mem_ch;
u8 unknown13[12];
} settings;
#seekto 0x1000;
struct {
char name[11];
u8 unknown[5];
} name[128];
struct {
char callsign[9];
u8 null;
} aprs;
#seekto 0x1f80;
struct {
ul32 unknown[8];
} unknown_settings;
"""
BOUNDS = [(136000000, 174000000), (400000000, 500000000)]
OFFSETS = [600000, 5000000]
MAX_CHANNELS = 128
MAX_NAME = 8
NAME_FIELD_SIZE = 11
CHUNK_SIZE = 64
MAX_ADDR = 0x2000
POWER_LEVELS = [chirp_common.PowerLevel("Low", watts=1),
chirp_common.PowerLevel("High", watts=5)]
MODES = ["FM", "NFM"]
SPECIAL_CHANNELS = ['VFO-A', 'VFO-B']
# Settings maps
ABR_LIST = [str(v) for v in range(0, 151, 5)]
STEP_LIST = ["5.0", "6.25", "10.0", "12.5", "25.0", "50.0", "100.0"]
VOX_LIST = ["OFF", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
SQL_LIST = [str(v) for v in range(0, 10)]
ROGER_LIST = ["OFF", "BEGIN", "END", "BOTH"]
MDF_LIST = ["NUM+FREQ", "NUMBER", "NAME"]
VM_LIST = ["VFO", "MEMORY"]
LANG_LIST = ["CHINESE", "ENGLISH"]
ABR_LV_LIST = [str(v) for v in range(1, 11)]
TOT_LIST = [str(v) for v in range(0, 601, 15)]
TOA_LIST = ["OFF"] + ["{} S".format(v) for v in range(1, 11)]
VOX_DLY_LIST = [str(v) for v in range(1, 11)]
SC_REV_LIST = ["TIME", "BUSY", "HOLD"]
LOCKMODE_LIST = ["KEY", "KEY+DIAL", "KEY+DIAL+PTT"]
AUTOLOCK_LIST = ["AUTO", "Manual"]
PF1_LIST = ["BACK LIGHT", "SCAN", "SQUELCH", "TORCH", "BAND A/B"]
PF2_LIST = ["BEACON", "LIST", "TORCH", "BACK LIGHT"]
TOP_LIST = ["ALERT", "REMOTE ALERT", "TORCH", "TXP", "CH MDF", "OFF_NET_KEY"]
SC_QT_LIST = ["Decode", "Encode", "Decode+Encode"]
APRS_RX_LIST = ["OFF", "BAND A", "BAND B"]
TX_PRIORITY_LIST = ["VOICE", "APRS"]
AUTOLOCK_DLY_LIST = ["{} S".format(v) for v in range(5, 31)]
BEACON_EXIT_DLY_LIST = MENU_DLY_LIST = AUTOLOCK_DLY_LIST
def make_frame(cmd, addr, length, data=b""):
if not isinstance(data, bytes):
data = data.decode("ascii")
return struct.pack(">BHB", ord(cmd), addr, length) + data
def send(radio, frame):
LOG.debug("%04i P>R: %s" % (len(frame), util.hexprint(frame)))
radio.pipe.write(frame)
def recv(radio, readdata=True):
hdr = radio.pipe.read(4)
cmd, addr, length = struct.unpack(">BHB", hdr)
if readdata:
data = radio.pipe.read(length)
LOG.debug(" PTone",
"DTCS->",
"->DTCS",
"Tone->DTCS",
"DTCS->Tone",
"->Tone",
"DTCS->DTCS"]
rf.valid_power_levels = POWER_LEVELS
rf.valid_skips = ["", "S"]
rf.valid_bands = [(136000000, 174000000), (400000000, 500000000)]
rf.valid_name_length = 8
rf.valid_special_chans = SPECIAL_CHANNELS
rf.memory_bounds = (1, self._upper)
return rf
def sync_in(self):
try:
self._mmap = do_download(self)
except errors.RadioError:
self.pipe.write(b"\x45")
raise
except Exception as e:
raise errors.RadioError("Failed to download from radio: %s" % e)
self.process_mmap()
def process_mmap(self):
self._memobj = bitwise.parse(MEM_FORMAT, self._mmap)
def sync_out(self):
try:
do_upload(self)
except errors.RadioError:
self.pipe.write(b"\x45")
raise
except Exception as e:
raise errors.RadioError("Failed to upload to radio: %s" % e)
def get_raw_memory(self, number):
return repr(self._memobj.memory[number - 1])
def get_memory(self, number):
mem = chirp_common.Memory()
if isinstance(number, str):
mem.number = MAX_CHANNELS + SPECIAL_CHANNELS.index(number) + 1
mem.extd_number = number
elif number > MAX_CHANNELS:
mem.number = number
else:
mem.number = number
_name = self._memobj.name[mem.number - 1]
_mem = self._memobj.memory[mem.number - 1]
if mem.number > MAX_CHANNELS:
mem.immutable = ['name']
else:
mem.name, _, _ = _name.name.get_raw().partition(b"\xFF")
mem.name = mem.name.decode('ascii').rstrip()
if _mem.get_raw()[:4] == b"\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._tone_model.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)
return mem
def set_memory(self, mem):
_mem = self._memobj.memory[mem.number - 1]
if mem.empty:
_mem.set_raw(b"\xFF" * 16)
return
if mem.number < 129:
_name = self._memobj.name[mem.number - 1]
_namelength = self.get_features().valid_name_length
for i in range(NAME_FIELD_SIZE):
try:
_name.name[i] = mem.name[i]
except IndexError:
_name.name[i] = "\xFF"
# clear reserved fields
_mem.unknown1 = 0xFF
_mem.unknown2 = 0xFF
_mem.unknown3 = 0xFF
_mem.unknown4 = (0xFF, 0xFF)
_mem.rx_freq = mem.freq / 10
mem_offset = mem.offset or offset_for(mem.freq)
if mem.duplex == "+":
_mem.tx_freq = (mem.freq + mem_offset) / 10
elif mem.duplex == "-":
_mem.tx_freq = (mem.freq - mem_offset) / 10
else:
_mem.tx_freq = mem.freq / 10
self._tone_model.set_tone(mem, _mem)
_mem.highpower = mem.power == POWER_LEVELS[1]
_mem.wide = mem.mode == "NFM"
_mem.scan = mem.skip != "S"
for setting in mem.extra:
setattr(_mem, setting.get_name(), setting.value)
def get_settings(self):
_mem = self._memobj
_settings = _mem.settings
basic = RadioSettingGroup("basic", "Basic")
display = RadioSettingGroup("display", "Display")
scan = RadioSettingGroup("scan", "Scan")
buttons = RadioSettingGroup("buttons", "Buttons")
vfo = RadioSettingGroup("vfo", "VFO")
advanced = RadioSettingGroup("advanced", "Advanced")
aprs = RadioSettingGroup("aprs", "APRS")
top = RadioSettings(basic, display, scan, buttons, vfo, advanced, aprs)
basic.append(
RadioSetting("save", "Power Save",
RadioSettingValueBoolean(_settings.save)))
basic.append(
RadioSetting("roger", "Roger Beep",
RadioSettingValueList(ROGER_LIST,
current_index=_settings.roger)))
basic.append(
RadioSetting("beep", "System Beep",
RadioSettingValueBoolean(_settings.beep)))
basic.append(
RadioSetting("tot", "Timeout Timer (sec)",
RadioSettingValueList(TOT_LIST,
current_index=_settings.tot)))
basic.append(
RadioSetting("toa", "Timeout Timer Alarm",
RadioSettingValueList(TOA_LIST,
current_index=_settings.toa)))
basic.append(
RadioSetting("lockmode", "Lock Mode",
RadioSettingValueList(
LOCKMODE_LIST,
current_index=_settings.lockmode)))
basic.append(
RadioSetting("autolock", "Auto Lock",
RadioSettingValueList(
AUTOLOCK_LIST,
current_index=_settings.autolock)))
basic.append(
RadioSetting("auto_lock_dly", "Auto Lock Delay",
RadioSettingValueList(
AUTOLOCK_DLY_LIST,
current_index=_settings.auto_lock_dly)))
display.append(
RadioSetting("abr", "Screen Save",
RadioSettingValueList(ABR_LIST,
current_index=_settings.abr)))
display.append(
RadioSetting("abr_lv", "Back Light Brightness",
RadioSettingValueList(ABR_LV_LIST,
current_index=_settings.abr_lv)))
display.append(
RadioSetting("night_mode", "Night Mode (Light on Dark)",
RadioSettingValueBoolean(_settings.night_mode)))
display.append(
RadioSetting("menu_dly", "Menu Delay",
RadioSettingValueList(
MENU_DLY_LIST,
current_index=_settings.menu_dly)))
display.append(
RadioSetting("english", "Language",
RadioSettingValueList(LANG_LIST,
current_index=_settings.english)))
scan.append(
RadioSetting("pri_scn", "Priority Scan",
RadioSettingValueBoolean(_settings.pri_scn)))
scan.append(
RadioSetting("pri_ch", "Priority Channel",
RadioSettingValueChannel(self, _settings.pri_ch)))
scan.append(
RadioSetting("sc_rev", "Scan Resume",
RadioSettingValueList(SC_REV_LIST,
current_index=_settings.sc_rev)))
scan.append(
RadioSetting("sc_qt", "Code Save",
RadioSettingValueList(SC_QT_LIST,
current_index=_settings.sc_qt)))
buttons.append(
RadioSetting("pf1_short", "PF1 (Side, Upper) Button Short Press",
RadioSettingValueList(PF1_LIST,
current_index=_settings.pf1_short)))
buttons.append(
RadioSetting("pf1_long", "PF1 (Side, Upper) Button Long Press",
RadioSettingValueList(PF1_LIST,
current_index=_settings.pf1_long)))
buttons.append(
RadioSetting("pf2_short", "PF2 (Side, Lower) Button Short Press",
RadioSettingValueList(PF2_LIST,
current_index=_settings.pf2_short)))
buttons.append(
RadioSetting("pf2_long", "PF2 (Side, Lower) Button Long Press",
RadioSettingValueList(PF2_LIST,
current_index=_settings.pf2_long)))
buttons.append(
RadioSetting("top_short", "Top Button Short Press",
RadioSettingValueList(TOP_LIST,
current_index=_settings.top_short)))
buttons.append(
RadioSetting("top_long", "Top Button Long Press",
RadioSettingValueList(TOP_LIST,
current_index=_settings.top_long)))
vfo.append(
RadioSetting("tdr", "VFO B Enabled",
RadioSettingValueBoolean(_settings.tdr)))
vfo.append(
RadioSetting("ch_a_step", "VFO Frequency Step (A)",
RadioSettingValueList(
STEP_LIST,
current_index=_settings.ch_a_step)))
vfo.append(
RadioSetting("ch_b_step", "VFO Frequency Step (B)",
RadioSettingValueList(
STEP_LIST,
current_index=_settings.ch_b_step)))
vfo.append(
RadioSetting("ch_a_sql", "Squelch (A)",
RadioSettingValueList(SQL_LIST,
current_index=_settings.ch_a_sql)))
vfo.append(
RadioSetting("ch_b_sql", "Squelch (B)",
RadioSettingValueList(SQL_LIST,
current_index=_settings.ch_b_sql)))
vfo.append(
RadioSetting("ch_a_mem_ch", "Memory Channel (A)",
RadioSettingValueChannel(self,
_settings.ch_a_mem_ch)))
vfo.append(
RadioSetting("ch_b_mem_ch", "Memory Channel (B)",
RadioSettingValueChannel(self,
_settings.ch_b_mem_ch)))
vfo.append(
RadioSetting("ch_a_ch_mdf", "Memory Display Format (A)",
RadioSettingValueList(
MDF_LIST,
current_index=_settings.ch_a_ch_mdf)))
vfo.append(
RadioSetting("ch_b_ch_mdf", "Memory Display Format (B)",
RadioSettingValueList(
MDF_LIST,
current_index=_settings.ch_b_ch_mdf)))
vfo.append(
RadioSetting("ch_a_v_m", "VFO/MEM (A)",
RadioSettingValueList(
VM_LIST, current_index=_settings.ch_a_v_m)))
vfo.append(
RadioSetting("ch_b_v_m", "VFO/MEM (B)",
RadioSettingValueList(
VM_LIST, current_index=_settings.ch_b_v_m)))
advanced.append(
RadioSetting("vox_grd", "VOX Sensitivity",
RadioSettingValueList(
VOX_LIST, current_index=_settings.vox_grd)))
advanced.append(
RadioSetting("vox_dly", "VOX Delay",
RadioSettingValueList(
VOX_DLY_LIST, current_index=_settings.vox_dly)))
advanced.append(
RadioSetting("voice", "Voice Assist",
RadioSettingValueBoolean(_settings.voice)))
advanced.append(
RadioSetting("rpt_rct", "RPT Roger",
RadioSettingValueBoolean(_settings.rpt_rct)))
aprs.append(
RadioSetting("aprs_rx_band", "RX Band",
RadioSettingValueList(
APRS_RX_LIST,
current_index=_settings.aprs_rx_band)))
aprs.append(
RadioSetting("ch_a_mute", "Band A Mute",
RadioSettingValueBoolean(_settings.ch_a_mute)))
aprs.append(
RadioSetting("ch_b_mute", "Band B Mute",
RadioSettingValueBoolean(_settings.ch_b_mute)))
aprs.append(
RadioSetting("tx_priority", "TX Priority",
RadioSettingValueList(
TX_PRIORITY_LIST,
current_index=_settings.tx_priority)))
aprs.append(
RadioSetting("aprs_rx_popup", "APRS Popup",
RadioSettingValueBoolean(_settings.aprs_rx_popup)))
aprs.append(
RadioSetting("aprs_rx_tone", "RX Tone",
RadioSettingValueBoolean(_settings.aprs_rx_tone)))
aprs.append(
RadioSetting("aprs_tx_tone", "TX Tone",
RadioSettingValueBoolean(_settings.aprs_tx_tone)))
aprs.append(
RadioSetting("beacon_exit_dly", "Beacon Message Delay",
RadioSettingValueList(
BEACON_EXIT_DLY_LIST,
current_index=_settings.beacon_exit_dly)))
return top
def set_settings(self, settings):
_mem = self._memobj
_settings = _mem.settings
for element in settings:
if not isinstance(element, RadioSetting):
self.set_settings(element)
continue
name = element.get_name()
value = element.value
if hasattr(_settings, name):
setattr(_settings, name, value)
chirp-20261030/chirp/drivers/hobbypcb.py 0000644 0001750 0001750 00000027520 15172631605 016773 0 ustar hibby hibby # Copyright 2016 Dan Smith
#
# 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 2 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
#
# 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
#
# 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
#
# 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
#
# 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
#
# 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 Vers 1.0
# 6/2019: Vers 1.1 Added Settings support, Rick DeWitt
# 7/2020: Vers 1.2 Fixed reversed E:* / F:# DTMF codes Issue #8159
# 9/2020: Vers 1.3 Expanded tone mode support and added py3 HAS_FUTURE
# bytes() per issue #8233. (icf.py is NOT updated)
#
# 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
#
# 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
#
# 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 ' % self.id
@property
def stale(self):
return time.time() - self._last > 4
def locked(fn):
"""Decorator for operations that talk to the radio.
Runs them with the lock and sends the magic wakeup if the timer is
expired.
"""
def _lock(self, *a, **k):
with self._lock:
LOG.debug('Locked for %s', fn.__name__)
if self._lock.stale:
LOG.debug('Doing wakeup')
self._init()
r = fn(self, *a, **k)
return r
return _lock
class IC9xBank(icf.IcomNamedBank):
"""Icom 9x Bank"""
def get_name(self):
banks = self._model._radio._ic9x_get_banks()
return banks[self.index]
def set_name(self, name):
banks = self._model._radio._ic9x_get_banks()
banks[self.index] = name
self._model._radio._ic9x_set_banks(banks)
@directory.register
class IC9xRadio(icf.IcomLiveRadio):
"""Base class for Icom IC-9x radios"""
MODEL = "IC-91/92AD"
_model = "ic9x" # Fake model info for detect.py
vfo = 0
_upper = 300
_num_banks = 26
_bank_class = IC9xBank
def _get_bank(self, loc):
mem = self.get_memory(loc)
return mem._bank
def _set_bank(self, loc, bank):
mem = self.get_memory(loc)
mem._bank = bank
self.set_memory(mem)
def _get_bank_index(self, loc):
mem = self.get_memory(loc)
return mem._bank_index
def _set_bank_index(self, loc, index):
mem = self.get_memory(loc)
mem._bank_index = index
self.set_memory(mem)
def _init(self):
"""Does the magic wakeup dance"""
self.pipe.baudrate = 4800
self.pipe.timeout = 1
for i in range(5):
buf = (b'\xfe' * 8) * 20 + (
b'\xfe\xfe\x01\x80\x19\xfd')
self.pipe.write(buf)
time.sleep(0.1)
resp = self.pipe.read(5)
if b'\x80\x01\x19' in resp:
LOG.debug('Radio responded to wakeup attempt %i' % (i + 1))
self.pipe.baudrate = 38400
while True:
r = ic9x_ll.ic9x_recv(self.pipe)
if not r:
break
LOG.debug('Got post-wakeup response: %r' % r)
return
time.sleep(1)
LOG.warning('Made %i attempts to wake radio', i + 1)
raise errors.RadioNoResponse()
def __init__(self, *args, **kwargs):
if 'lock' in kwargs:
self._lock = kwargs.pop('lock')
else:
self._lock = Lock()
super().__init__(*args, **kwargs)
self.__memcache = {}
self.__bankcache = {}
@locked
def get_memory(self, number):
if isinstance(number, str):
try:
number = IC9X_SPECIAL[self.vfo][number]
except KeyError:
raise errors.InvalidMemoryLocation(
"Unknown channel %s" % number)
if number < -2 or number > 999:
raise errors.InvalidValueError("Number must be between 0 and 999")
if number in self.__memcache:
return self.__memcache[number]
try:
mem = ic9x_ll.get_memory(self.pipe, self.vfo, number)
except errors.InvalidMemoryLocation:
mem = chirp_common.Memory()
mem.number = number
if number < self._upper:
mem.empty = True
if number > self._upper or number < 0:
mem.extd_number = util.get_dict_rev(IC9X_SPECIAL,
[self.vfo][number])
mem.immutable = ["number", "skip", "bank", "bank_index",
"extd_number"]
self.__memcache[mem.number] = mem
return mem
@locked
def get_raw_memory(self, number):
mframe = ic9x_ll.get_memory_frame(self.pipe, self.vfo, number)
return repr(bitwise.parse(ic9x_ll.MEMORY_FRAME_FORMAT, mframe))
def get_memories(self, lo=0, hi=None):
if hi is None:
hi = self._upper
memories = []
for i in range(lo, hi + 1):
try:
LOG.debug("Getting %i" % i)
mem = self.get_memory(i)
if mem:
memories.append(mem)
LOG.debug("Done: %s" % mem)
except errors.InvalidMemoryLocation:
pass
except errors.InvalidDataError as e:
LOG.error("Error talking to radio: %s" % e)
break
return memories
@locked
def set_memory(self, _memory):
# Make sure we mirror the DV-ness of the new memory we're
# setting, and that we capture the Bank value of any currently
# stored memory (unless the special type is provided) and
# communicate that to the low-level routines with the special
# subclass
if isinstance(_memory, ic9x_ll.IC9xMemory) or \
isinstance(_memory, ic9x_ll.IC9xDVMemory):
memory = _memory
else:
if isinstance(_memory, chirp_common.DVMemory):
memory = ic9x_ll.IC9xDVMemory()
else:
memory = ic9x_ll.IC9xMemory()
try:
memory.clone(ic9x_ll.get_memory(self.pipe, self.vfo,
_memory.number))
except errors.InvalidMemoryLocation:
pass
memory.clone(_memory)
if memory.empty:
ic9x_ll.erase_memory(self.pipe, self.vfo, memory.number)
else:
ic9x_ll.set_memory(self.pipe, self.vfo, memory)
memory = ic9x_ll.get_memory(self.pipe, self.vfo, memory.number)
self.__memcache[memory.number] = memory
@locked
def _ic9x_get_banks(self):
if len(list(self.__bankcache.keys())) == 26:
return [self.__bankcache[k] for k in
sorted(self.__bankcache.keys())]
banks = ic9x_ll.get_banks(self.pipe, self.vfo)
i = 0
for bank in banks:
self.__bankcache[i] = bank
i += 1
return banks
@locked
def _ic9x_set_banks(self, banks):
if len(banks) != len(list(self.__bankcache.keys())):
raise errors.InvalidDataError("Invalid bank list length (%i:%i)" %
(len(banks),
len(list(self.__bankcache.keys()))))
cached_names = [str(self.__bankcache[x])
for x in sorted(self.__bankcache.keys())]
need_update = False
for i in range(0, 26):
if banks[i] != cached_names[i]:
need_update = True
self.__bankcache[i] = banks[i]
LOG.dbeug("Updating %s: %s -> %s" %
(chr(i + ord("A")), cached_names[i], banks[i]))
if need_update:
ic9x_ll.set_banks(self.pipe, self.vfo, banks)
def get_sub_devices(self):
return [IC9xRadioA(self.pipe, lock=self._lock),
IC9xRadioB(self.pipe, lock=self._lock)]
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.has_sub_devices = True
rf.valid_special_chans = list(IC9X_SPECIAL[self.vfo].keys())
return rf
class IC9xRadioA(IC9xRadio):
"""IC9x Band A subdevice"""
VARIANT = "Band A"
vfo = 1
_upper = 849
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.has_bank = True
rf.has_bank_index = True
rf.has_bank_names = True
rf.memory_bounds = (0, self._upper)
rf.valid_modes = ["FM", "WFM", "AM"]
rf.valid_tmodes = ["", "Tone", "TSQL", "DTCS"]
rf.valid_duplexes = ["", "-", "+"]
rf.valid_tuning_steps = list(chirp_common.TUNING_STEPS)
rf.valid_bands = [(500000, 9990000000)]
rf.valid_skips = ["", "S", "P"]
rf.valid_characters = CHARSET
rf.valid_name_length = 8
return rf
class IC9xRadioB(IC9xRadio, chirp_common.IcomDstarSupport):
"""IC9x Band B subdevice"""
VARIANT = "Band B"
vfo = 2
_upper = 399
MYCALL_LIMIT = (1, 7)
URCALL_LIMIT = (1, 61)
RPTCALL_LIMIT = (1, 61)
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.has_bank = True
rf.has_bank_index = True
rf.has_bank_names = True
rf.requires_call_lists = False
rf.memory_bounds = (0, self._upper)
rf.valid_modes = ["FM", "NFM", "AM", "DV"]
rf.valid_tmodes = ["", "Tone", "TSQL", "DTCS"]
rf.valid_duplexes = ["", "-", "+"]
rf.valid_tuning_steps = list(chirp_common.TUNING_STEPS)
rf.valid_bands = [(118000000, 174000000), (350000000, 470000000)]
rf.valid_skips = ["", "S", "P"]
rf.valid_characters = CHARSET
rf.valid_name_length = 8
return rf
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__rcalls = []
self.__mcalls = []
self.__ucalls = []
@locked
def __get_call_list(self, cache, cstype, ulimit):
if cache:
return cache
calls = []
for i in range(ulimit - 1):
call = ic9x_ll.get_call(self.pipe, cstype, i+1)
calls.append(call)
return calls
@locked
def __set_call_list(self, cache, cstype, ulimit, calls):
for i in range(ulimit - 1):
blank = " " * 8
try:
acall = cache[i]
except IndexError:
acall = blank
try:
bcall = calls[i]
except IndexError:
bcall = blank
if acall == bcall:
continue # No change to this one
ic9x_ll.set_call(self.pipe, cstype, i + 1, calls[i])
return calls
def get_mycall_list(self):
self.__mcalls = self.__get_call_list(self.__mcalls,
ic9x_ll.IC92MyCallsignFrame,
self.MYCALL_LIMIT[1])
return self.__mcalls
def get_urcall_list(self):
self.__ucalls = self.__get_call_list(self.__ucalls,
ic9x_ll.IC92YourCallsignFrame,
self.URCALL_LIMIT[1])
return self.__ucalls
def get_repeater_call_list(self):
self.__rcalls = self.__get_call_list(self.__rcalls,
ic9x_ll.IC92RepeaterCallsignFrame,
self.RPTCALL_LIMIT[1])
return self.__rcalls
def set_mycall_list(self, calls):
self.__mcalls = self.__set_call_list(self.__mcalls,
ic9x_ll.IC92MyCallsignFrame,
self.MYCALL_LIMIT[1],
calls)
def set_urcall_list(self, calls):
self.__ucalls = self.__set_call_list(self.__ucalls,
ic9x_ll.IC92YourCallsignFrame,
self.URCALL_LIMIT[1],
calls)
def set_repeater_call_list(self, calls):
self.__rcalls = self.__set_call_list(self.__rcalls,
ic9x_ll.IC92RepeaterCallsignFrame,
self.RPTCALL_LIMIT[1],
calls)
def _test():
import serial
ser = IC9xRadioB(serial.Serial(port="/dev/ttyUSB1",
baudrate=38400, timeout=0.1))
print(ser.get_urcall_list())
print("-- FOO --")
ser.set_urcall_list(["K7TAY", "FOOBAR", "BAZ"])
if __name__ == "__main__":
_test()
chirp-20261030/chirp/drivers/ic9x_icf.py 0000644 0001750 0001750 00000004715 14665027664 016713 0 ustar hibby hibby # Copyright 2010 Dan Smith
#
# 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
#
# 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
#
# 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
#
# 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
#
# 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
# Derives from template.py
#
# 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 2 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
#
# 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
#
# 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
#
# 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
#
# 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
#
# 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
#
# 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
#
# 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
#
# 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
#
# 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
#
# 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
# 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
#
# 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
#
# 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
#
# 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
#
# 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
#
# 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
#
# 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
#
# 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
#
# 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 2 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
#
# 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 2 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
#
# 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 2 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
#
# 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
# Copyright 2012 Tom Hayward
#
# 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
# Copyright 2012 Tom Hayward
#
# 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
#
# 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
#
# Based on the work of Krystian Struzik
# who figured out the crypt used and made possible the
# Wuoxun KG-UV8D Plus driver, in which this work is based.
#
# 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 M0RNW
#
# 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
# Based on Ron Wellsted driver for Wouxun KG-UV8D.
# KG-UV8D Plus model has all serial data encrypted.
# Figured out how the data is encrypted and implement
# serial data encryption and decryption functions.
# The algorithm of decryption works like this:
# - the first byte of data stream is XOR by const 57h
# - each next byte is encoded by previous byte using the XOR
# including the checksum (e.g data[i - 1] xor data[i])
# I also changed the data structure to fit radio memory
# and implement set_settings function.
#
# 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
#
# Based on the work of Krystian Struzik
# who figured out the crypt used and made possible the
# Wuoxun KG-UV8D Plus driver, in which this work is based.
#
# 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
#
# 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
# KG-UV980P , KG-1000G, KG-1000G Plus unified driver using
# KG-935G, KG-UV8H, KG-UV920P, and KG-UV9D Plus drivers as resources
#
# Based on the previous work of Pavel Milanes CO7WT
# and Krystian Struzik
# who figured out the crypt used and made possible the
# Wuoxun KG-UV8D Plus driver.
#
# 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
# Updated Driver to support Wouxun KG-UV9PX
# based on prior driver for KG-UV9D Plus by
# Jim Lieb
#
# Borrowed from other chirp drivers, especially the KG-UV8D Plus
# by Krystian Struzik
#
# 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 > here because all it
turns out to be is annoying obfuscation.
This is the inverse of pkt_decode"""
# we don't care about data[0].
# It is always 0x7d and not included in checksum
op = data[1]
direction = data[2]
bytecount = data[3]
# First un-obfuscate the payload and cksum
payload = bytearray()
xorbits = 0x52
for i, byte in enumerate(data[4:]):
payload.append(xorbits ^ byte)
xorbits = byte
# Calculate the checksum starting with the 3 bytes of the header
cksum = op + direction + bytecount
for byte in payload[:-1]:
cksum += byte
# yes, a 4 bit cksum to match the encode
cksum_match = (cksum & 0xf) == payload[-1]
if (not cksum_match):
LOG.debug(
"Checksum mismatch: %x != %x; " % (cksum, payload[-1]))
return (cksum_match, op, payload[:-1])
# UI callbacks to process input for mapping UI fields to memory cells
def freq2int(val, min, max):
"""Convert a frequency as a string to a u32. Units is Hz
"""
_freq = chirp_common.parse_freq(str(val))
if _freq > max or _freq < min:
raise InvalidValueError("Frequency %s is not with in %s-%s" %
(chirp_common.format_freq(_freq),
chirp_common.format_freq(min),
chirp_common.format_freq(max)))
return _freq
def int2freq(freq):
"""
Convert a u32 frequency to a string for UI data entry/display
This is stored in the radio as units of 10 Hz which we compensate to Hz.
A value of -1 indicates , i.e. unused channel.
"""
if (int(freq) > 0):
f = chirp_common.format_freq(freq)
return f
else:
return ""
def freq2short(val, min, max):
"""Convert a frequency as a string to a u16 which is units of 10 kHz
"""
_freq = chirp_common.parse_freq(str(val))
if _freq > max or _freq < min:
raise InvalidValueError("Frequency %s is not with in %s-%s" %
(chirp_common.format_freq(_freq),
chirp_common.format_freq(min),
chirp_common.format_freq(max)))
return _freq // 100000 & 0xFFFF
def short2freq(freq):
"""
Convert a short frequency to a string for UI data entry/display
This is stored in the radio as units of 10 kHz which we
compensate to Hz.
A value of -1 indicates , i.e. unused channel.
"""
if (int(freq) > 0):
f = chirp_common.format_freq(freq * 100000)
return f
else:
return ""
def tone2short(t):
"""Convert a string tone or DCS to an encoded u16
"""
tone = str(t)
if tone == "----":
u16tone = 0x0000
elif tone[0] == 'D': # This is a DCS code
c = tone[1: -1]
code = int(c, 8)
if tone[-1] == 'I':
code |= 0x4000
u16tone = code | 0x8000
else: # This is an analog CTCSS
u16tone = int(tone[0:-2]+tone[-1]) & 0xffff # strip the '.'
return u16tone
def short2tone(tone):
""" Map a binary CTCSS/DCS to a string name for the tone
"""
if tone == 0 or tone == 0xffff:
ret = "----"
else:
code = tone & 0x3fff
if tone & 0x8000: # This is a DCS
if tone & 0x4000: # This is an inverse code
ret = "D%0.3oI" % code
else:
ret = "D%0.3oN" % code
else: # Just plain old analog CTCSS
ret = "%4.1f" % (code / 10.0)
return ret
def str2callid(val):
""" Convert caller id strings from callid2str.
"""
ascii2bin = "0123456789"
s = str(val).strip()
if len(s) < 3 or len(s) > 6:
raise InvalidValueError(
"Caller ID must be at least 3 and no more than 6 digits")
if s[0] == '0':
raise InvalidValueError(
"First digit of a Caller ID cannot be a zero '0'")
blk = bytearray()
for c in s:
if c not in ascii2bin:
raise InvalidValueError(
"Caller ID must be all digits 0x%x" % c)
b = (0xa, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9)[int(c)]
blk.append(b)
if len(blk) < 6:
blk.append(0xc) # EOL a short ID
if len(blk) < 6:
for i in range(0, (6 - len(blk))):
blk.append(0xf0)
return blk
def digits2str(digits, padding=' ', width=6):
"""Convert a password or SCC digit string to a string
Passwords are expanded to and must be 6 chars. Fill them with '0'
"""
bin2ascii = "0123456789"
digitsstr = ""
for i in range(0, 6):
b = digits[i].get_value()
if b == 0xc: # the digits EOL
break
if b >= 0xa:
raise InvalidValueError(
"Value has illegal byte 0x%x" % ord(b))
digitsstr += bin2ascii[b]
digitsstr = digitsstr.ljust(width, padding)
return digitsstr
def str2digits(val):
""" Callback for edited strings from digits2str.
"""
ascii2bin = " 0123456789"
s = str(val).strip()
if len(s) < 3 or len(s) > 6:
raise InvalidValueError(
"Value must be at least 3 and no more than 6 digits")
blk = bytearray()
for c in s:
if c not in ascii2bin:
raise InvalidValueError("Value must be all digits 0x%x" % c)
blk.append(int(c))
for i in range(len(blk), 6):
blk.append(0xc) # EOL a short ID
return blk
def name2str(name):
""" Convert a callid or scan group name to a string
Deal with fixed field padding (\0 or \0xff)
"""
namestr = ""
for i in range(0, len(name)):
b = ord(name[i].get_value())
if b != 0 and b != 0xff:
namestr += chr(b)
return namestr
def str2name(val, size=6, fillchar='\0', emptyfill='\0'):
""" Convert a string to a name. A name is a 6 element bytearray
with ascii chars.
"""
val = str(val).rstrip(' \t\r\n\0\xff')
if len(val) == 0:
name = "".ljust(size, emptyfill)
else:
name = val.ljust(size, fillchar)
return name
def pw2str(pw):
"""Convert a password string (6 digits) to a string
Passwords must be 6 digits. If it is shorter, pad right with '0'
"""
pwstr = ""
ascii2bin = "0123456789"
for i in range(0, len(pw)):
b = pw[i].get_value()
if b not in ascii2bin:
raise InvalidValueError("Value must be digits 0-9")
pwstr += b
pwstr = pwstr.ljust(6, '0')
return pwstr
def str2pw(val):
"""Store a password from UI to memory obj
If we clear the password (make it go away), change the
empty string to '000000' since the radio must have *something*
Also, fill a < 6 digit pw with 0's
"""
ascii2bin = "0123456789"
val = str(val).rstrip(' \t\r\n\0\0xff')
if len(val) == 0: # a null password
val = "000000"
for i in range(0, len(val)):
b = val[i]
if b not in ascii2bin:
raise InvalidValueError("Value must be digits 0-9")
if len(val) == 0:
pw = "".ljust(6, '\0')
else:
pw = val.ljust(6, '0')
return pw
# Helpers to replace python2 things like confused str/byte
def _hex_print(data, addrfmt=None):
"""Return a hexdump-like encoding of @data
We expect data to be a bytearray, not a string.
Expanded from borrowed code to use the first 2 bytes as the address
per comm packet format.
"""
if addrfmt is None:
addrfmt = '%(addr)03i'
addr = 0
else: # assume first 2 bytes are address
a = struct.unpack(">H", data[0:2])
addr = a[0]
data = data[2:]
block_size = 16
lines = (len(data) // block_size)
if (len(data) % block_size > 0):
lines += 1
out = ""
left = len(data)
for block in range(0, lines):
addr += block * block_size
try:
out += addrfmt % locals()
except (OverflowError, ValueError, TypeError, KeyError):
out += "%03i" % addr
out += ': '
if left < block_size:
limit = left
else:
limit = block_size
for j in range(0, block_size):
if (j < limit):
out += "%02x " % data[(block * block_size) + j]
else:
out += " "
out += " "
for j in range(0, block_size):
if (j < limit):
_byte = data[(block * block_size) + j]
if _byte >= 0x20 and _byte < 0x7F:
out += "%s" % chr(_byte)
else:
out += "."
else:
out += " "
out += "\n"
if (left > block_size):
left -= block_size
return out
# Useful UI lists
STEPS = [2.5, 5.0, 6.25, 10.0, 12.5, 25.0, 50.0, 100.0]
STEPS_9K = [2.5, 5.0, 6.25, 8.33, 10.0, 12.5, 25.0, 50.0, 100.0]
S_TONES = [str(x) for x in [1000, 1450, 1750, 2100]]
STEP_LIST = [str(x)+"kHz" for x in STEPS]
STEP_LIST_9K = [str(x)+"kHz" for x in STEPS_9K]
ROGER_LIST = ["Off", "Begin", "End", "Both"]
TIMEOUT_LIST = [str(x) + "s" for x in range(15, 601, 15)]
TOA_LIST = ["Off"] + ["%ds" % t for t in range(1, 11)]
BANDWIDTH_LIST = ["Wide", "Narrow"]
LANGUAGE_LIST = ["English", "Chinese"]
LANGUAGE_LIST2 = ["English", "Chinese-DISABLED"]
PF1KEY_LIST = ["OFF", "call id", "r-alarm", "SOS", "SF-TX"]
PF1KEY_LIST9GX = ["OFF", "call id", "r-alarm", "SOS", "SF-TX", "Scan",
"Second", "Lamp"]
PF2KEY_LIST = ["OFF", "Scan", "Second", "Lamp", "SDF-DIR", "K-lamp"]
PF2KEY_LIST9GX = ["OFF", "Scan", "Second", "Lamp", "K-lamp"]
PF3KEY_LIST2 = ["OFF", "Call ID", "R-ALARM", "SOS", "SF-TX", "Scan",
"Second", "Lamp"]
PF3KEY_LIST9GX = ["OFF", "call id", "r-alarm", "SOS", "SF-TX", "Scan",
"Second", "Lamp"]
PF3KEY_LIST = ["OFF", "Call ID", "R-ALARM", "SOS", "SF-TX"]
WORKMODE_LIST = ["VFO freq", "Channel No.", "Ch. No.+Freq.",
"Ch. No.+Name"]
BACKLIGHT_LIST = ["Off"] + ["%sS" % t for t in range(1, 31)] + \
["Always On"]
BACKLIGHT_BRIGHT_MIN = 1
BACKLIGHT_BRIGHT_MAX = 5
SAVE_MODES = ["Off", "1", "2", "3", "4"]
LOCK_MODES = ["key-lk", "key+pg", "key+ptt", "all"]
APO_TIMES = ["Off"] + ["%dm" % t for t in range(15, 151, 15)]
OFFSET_LIST = ["none", "+", "-"]
PONMSG_LIST = ["Battery Volts", "Bitmap"]
PONMSG_LIST2 = ["Battery Volts", "Bitmap-DISABLED"]
SPMUTE_LIST = ["QT", "QT*T", "QT&T"]
DTMFST_LIST = ["Off", "DT-ST", "ANI-ST", "DT-ANI"]
DTMF_TIMES = ["%d" % x for x in range(80, 501, 20)]
PTTID_LIST = ["Off", "Begin", "End", "Both"]
ID_DLY_LIST = ["%dms" % t for t in range(100, 3001, 100)]
VOX_GRDS = ["Off"] + ["%dlevel" % l for l in range(1, 11)]
VOX_DLYS = ["Off"] + ["%ds" % t for t in range(1, 5)]
RPT_KPTS = ["Off"] + ["%dms" % t for t in range(100, 5001, 100)]
ABR_LVL_MAP = [("1", 1), ("2", 2), ("3", 3), ("4", 4), ("5", 5)]
LIST_1_5 = ["%s" % x for x in range(1, 6)]
LIST_0_9 = ["%s" % x for x in range(0, 10)]
LIST_1_20 = ["%s" % x for x in range(1, 21)]
LIST_OFF_10 = ["Off"] + ["%s" % x for x in range(1, 11)]
SCANGRP_LIST = ["All"] + ["%s" % x for x in range(1, 11)]
SCANMODE_LIST = ["TO", "CO", "SE"]
SCANRANGE_LIST = ["Current band", "freq range", "ALL"]
SCQT_LIST = ["Decoder", "Encoder", "Both"]
S_MUTE_LIST = ["off", "rx mute", "tx mute", "r/t mute"]
POWER_LIST = ["Low", "Med", "High"]
RPTMODE_LIST = ["Radio/Talkie", "One direction Repeater",
"Two direction repeater"]
TONE_LIST = ["----"] + ["%s" % str(t) for t in chirp_common.TONES] + \
["D%0.3dN" % dts for dts in chirp_common.DTCS_CODES] + \
["D%0.3dI" % dts for dts in chirp_common.DTCS_CODES]
SCREEN_MODE_LIST = ["Classic", "Covert", "Day_1", "Day_2"]
ACTIVE_AREA_LIST = ["Receiver A - Top", "Receiver B - Bottom"]
TDR_LIST = ["TDR ON", "TDR OFF"]
@directory.register
class KGUV9DPlusRadio(chirp_common.CloneModeRadio,
chirp_common.ExperimentalRadio):
"""Wouxun KG-UV9D Plus"""
VENDOR = "Wouxun"
MODEL = "KG-UV9D Plus"
_model = b"KG-UV9D"
_rev = b"00" # default rev for the radio I know about...
_file_ident = b"kg-uv9d"
BAUD_RATE = 19200
@classmethod
def match_model(cls, filedata, filename):
return cls._file_ident in filedata[0x51:0x59].lower()
POWER_LEVELS = [chirp_common.PowerLevel("L", watts=1),
chirp_common.PowerLevel("M", watts=2),
chirp_common.PowerLevel("H", watts=5)]
_step_list = STEP_LIST
_valid_steps = STEPS
_mmap = ""
_tone_model = KenwoodToneModel(
dcs_base=0x8000, pol_mask=0x4000, tone_init=0x0000,
tone_flag=0x0000, dcs_enc_base=8)
def _read_record(self):
""" Read and validate the header of a radio reply.
A record is a formatted byte stream as follows:
0x7D All records start with this
opcode This is in the set of legal commands.
The radio reply matches the request
dir This is the direction, 0xFF to the radio,
0x00 from the radio.
cnt Count of bytes in payload
(not including the trailing checksum byte)
"""
# first get the header and validate it
data = bytearray(self.pipe.read(4))
if not data:
raise errors.RadioNoResponse()
if (len(data) < 4):
raise errors.RadioError('Radio sent short header')
if (data[0] != 0x7D):
raise errors.RadioError(
'Radio reply garbled (%02x)' % data[0])
if (data[1] not in cmd_name):
raise errors.RadioError(
"Unrecognized opcode (%02x)" % data[1])
if (data[2] != 0x00):
raise errors.RadioError(
"Direction incorrect. Got (%02x)" % data[2])
payload_len = data[3]
# don't forget to read the checksum byte
data.extend(self.pipe.read(payload_len + 1))
if (len(data) != (payload_len + 5)): # we got a short read
raise errors.RadioError(
"Radio reply wrong size. Wanted %d, got %d" %
((payload_len + 1), (len(data) - 4)))
return _pkt_decode(data)
def _write_record(self, cmd, payload=None):
""" Write a request packet to the radio.
"""
packet = _pkt_encode(cmd, payload)
self.pipe.write(packet)
def _identify(self):
""" Identify the radio
The ident block identifies the radio and its capabilities.
This block is always 78 bytes. The rev == '01' is the base
radio and '02' seems to be the '-Plus' version.
I don't really trust the content after the model and revision.
One would assume this is pretty much constant data but I have
seen differences between my radio and the dump named
KG-UV9D-Plus-OutOfBox-Read.txt from bug #3509. The first
five bands match the OEM windows
app except the 350-400 band. The OOB trace has the 700 MHz
band different. This is speculation at this point.
TODO: This could be smarter and reject a radio not actually
a UV9D...
"""
for _i in range(0, 10): # retry 10 times if we get junk
self._write_record(CMD_IDENT)
chksum_match, op, _resp = self._read_record()
if len(_resp) == 0:
raise errors.RadioNoResponse()
if len(_resp) != 74:
LOG.error(
"Expected and IDENT reply of 78 bytes. Got (%d)" %
len(_resp))
continue
if not chksum_match:
LOG.error("Checksum error: retrying ident...")
time.sleep(0.100)
continue
if op != CMD_IDENT:
LOG.error("Expected IDENT reply. Got (%02x)" % op)
continue
LOG.debug("Got:\n%s" % _hex_print(_resp))
(mod, rev) = struct.unpack(">7s2s", _resp[0:9])
LOG.debug("Model %s, rev %s" % (mod, rev))
if mod == self._model:
self._rev = rev
return
else:
raise Exception("Unable to identify radio")
raise Exception("All retries to identify failed")
def process_mmap(self):
if self._rev != b"02" and self._rev != b"00":
# new revision found - log it and assume same map and proceed
LOG.debug("Unrecognized model variation (%s) Using default Map" %
self._rev)
self._memobj = bitwise.parse(_MEM_FORMAT02, self._mmap)
def sync_in(self):
""" Public sync_in
Download contents of the radio. Throw errors back
to the core if the radio does not respond.
"""
try:
self._identify()
self._mmap = self._do_download()
self._write_record(CMD_HANGUP)
except errors.RadioError:
raise
except Exception as e:
LOG.exception('Unknown error during download process')
raise errors.RadioError(
"Failed to communicate with radio: %s" % e)
self.process_mmap()
def sync_out(self):
""" Public sync_out
Upload the modified memory image into the radio.
"""
try:
self._identify()
self._do_upload()
self._write_record(CMD_HANGUP)
except errors.RadioError:
raise
except Exception as e:
raise errors.RadioError(
"Failed to communicate with radio: %s" % e)
return
def _do_download(self):
""" Read the whole of radio memory in 64 byte chunks.
We load the config space followed by loading memory channels.
The radio seems to be a "clone" type and the memory channels
are actually within the config space. There are separate
commands (CMD_RCHAN, CMD_WCHAN) for reading channel memory but
these seem to be a hack that can only do 4 channels at a time.
Since the radio only supports 999, (can only support 3 chars
in the display UI?) although the vendors app reads 1000
channels, it hacks back to config writes (CMD_WCONF) for the
last 3 channels and names. We keep it simple and just read
the whole thing even though the vendor app doesn't. Channels
are separate in their app simply because the radio protocol
has read/write commands to access it. What they do is simply
marshal the frequency+mode bits in 4 channel chunks followed
by a separate chunk of for names. In config space, they are two
separate arrays 1..999. Given that this space is not a
multiple of 4, there is hackery on upload to do the writes to
config space. See upload for this.
"""
mem = bytearray(0x8000) # The radio's memory map is 32k
for addr in range(0, 0x8000, 64):
req = bytearray(struct.pack(">HB", addr, 64))
self._write_record(CMD_RCONF, req)
chksum_match, op, resp = self._read_record()
if not chksum_match:
LOG.debug(_hex_print(resp))
raise Exception(
"Checksum error while reading configuration (0x%x)" %
addr)
pa = struct.unpack(">H", resp[0:2])
pkt_addr = pa[0]
payload = resp[2:]
if op != CMD_RCONF or addr != pkt_addr:
raise Exception(
"Expected CMD_RCONF (%x) reply. Got (%02x: %x)" %
(addr, op, pkt_addr))
LOG.debug("Config read (0x%x):\n%s" %
(addr, _hex_print(resp, '0x%(addr)04x')))
# Orig Code from 9D Plus driver was len(Payload)-1:
# This Caused every 64th byte to = 00
for i in range(0, len(payload)):
mem[addr + i] = payload[i]
if self.status_fn:
status = chirp_common.Status()
status.cur = addr
status.max = 0x8000
status.msg = "Cloning from radio"
self.status_fn(status)
return memmap.MemoryMapBytes(bytes(mem))
def _do_upload(self):
"""Walk through the config map and write updated records to
the radio. The config map contains only the regions we know
about. We don't use the channel memory commands to avoid the
hackery of using config write commands to fill in the last
3 channel memory and names slots. As we discover other useful
goodies in the map, we can add more slots...
"""
if (self.MODEL == "KG-UV9PX" or self.MODEL == "KG-UV9GX"):
cfgmap = config_map2
else:
cfgmap = config_map
for start, blocksize, count in cfgmap:
end = start + (blocksize * count)
for addr in range(start, end, blocksize):
req = bytearray(struct.pack(">H", addr))
req.extend(self.get_mmap()[addr:addr + blocksize])
self._write_record(CMD_WCONF, req)
LOG.debug("Config write (0x%x):\n%s" %
(addr, _hex_print(req)))
chksum_match, op, ack = self._read_record()
LOG.debug("Config write ack [%x]\n%s" %
(addr, _hex_print(ack)))
a = struct.unpack(">H", ack) # big endian short...
ack = a[0]
if not chksum_match or op != CMD_WCONF or addr != ack:
msg = ""
if not chksum_match:
msg += "Checksum err, "
if op != CMD_WCONF:
msg += "cmd mismatch %x != %x, " % \
(op, CMD_WCONF)
if addr != ack:
msg += "ack error %x != %x, " % (addr, ack)
raise Exception("Radio did not ack block: %s error" % msg)
if self.status_fn:
status = chirp_common.Status()
status.cur = addr
status.max = 0x8000
status.msg = "Cloning to radio"
self.status_fn(status)
def get_features(self):
""" Public get_features
Return the features of this radio once we have identified
it and gotten its bits
"""
rf = chirp_common.RadioFeatures()
rf.has_settings = True
rf.has_ctone = True
rf.has_rx_dtcs = True
rf.has_cross = True
rf.has_tuning_step = False
rf.has_bank = False
rf.can_odd_split = True
rf.valid_skips = ["", "S"]
rf.valid_tmodes = ["", "Tone", "TSQL", "DTCS", "Cross"]
rf.valid_cross_modes = [
"Tone->Tone",
"Tone->DTCS",
"DTCS->Tone",
"DTCS->",
"->Tone",
"->DTCS",
"DTCS->DTCS",
]
rf.valid_modes = ["FM", "NFM", "AM"]
rf.valid_power_levels = self.POWER_LEVELS
rf.valid_name_length = 8
rf.valid_duplexes = ["", "-", "+", "split", "off"]
rf.valid_bands = [(108000000, 136000000), # Aircraft AM
(136000000, 180000000), # supports 2m
(230000000, 250000000),
(350000000, 400000000),
(400000000, 520000000), # supports 70cm
(700000000, 985000000)]
rf.valid_characters = chirp_common.CHARSET_ASCII
rf.valid_tuning_steps = self._valid_steps
rf.memory_bounds = (1, 999) # 999 memories
return rf
@classmethod
def get_prompts(cls):
rp = chirp_common.RadioPrompts()
rp.experimental = ("This radio driver is currently under development. "
"There are no known issues with it, but you should "
"proceed with caution.")
return rp
def get_raw_memory(self, number):
return repr(self._memobj.chan_blk[number - 1])
def get_memory(self, number):
""" Public get_memory
Return the channel memory referenced by number to the UI.
"""
_mem = self._memobj.chan_blk[number - 1]
_nam = self._memobj.chan_name[number - 1]
_val = self._memobj.chan_valid[number - 1]
mem = chirp_common.Memory()
mem.number = number
_valid = _mem.state
# This code attempts to robustly decipher what Wouxun considers valid
# memory locations on the 9 series radios and the factory CPS.
# It appears they use a combination of State and Rx Freq to determine
# validity rather than just the State value.
# It is possible the State value is not even used at all.
# Rather than continuously adding new Mem Valid values as they are
# found, assume any value other than 0xFF is likely valid and use
# Rx Freq to further assess validity
if _mem.rxfreq == 0xFFFFFFFF:
# Rx freq indicates empty channel memory
# assume empty regardless of _valid and proceed to next channel
if _valid not in INVALID_MEM_VALUES:
# only log if _valid indicates the channel is not invalid
LOG.debug("CH %s Rx Freq = 0xFFFFFFFF - "
"Treating chan as empty", mem.number)
mem.empty = True
_val.ch_valid = CHAN_INVALID
return mem
elif _valid in INVALID_MEM_VALUES:
# Check for 9PX case where CPS creates a valid channel with
# 0xFF for State - accept it as valid as long as Rx Freq is
# <= max value
if _mem.rxfreq > 99999999: # Max poss Value = 999.99999 MHz
LOG.debug("CH %s State invalid - Rx Frq > 999.99999 MHz: "
"Treating chan as empty", mem.number)
mem.empty = True
_val.ch_valid = CHAN_INVALID
return mem
else:
LOG.debug("CH %s State invalid - Rx Freq valid: "
"Assume chan valid", mem.number)
mem.empty = False
_val.ch_valid = CHAN_VALID
else: # State not Invalid and Rx Freq not 0xFFFFFFFF
if _mem.rxfreq > 99999999: # Max poss Value = 999.99999 MHz
LOG.debug("CH %s Invalid Rx Frq: %s MHz - "
"Treating chan as empty", mem.number,
int(_mem.rxfreq) / 100000)
mem.empty = True
_val.ch_valid = CHAN_INVALID
return mem
else:
_val.ch_valid = CHAN_VALID
mem.empty = False
mem.freq = int(_mem.rxfreq) * 10
if _mem.txfreq == 0xFFFFFFFF:
# TX freq not set
mem.duplex = "off"
mem.offset = 0
elif int(_mem.rxfreq) == int(_mem.txfreq):
mem.duplex = ""
mem.offset = 0
elif abs(int(_mem.rxfreq) * 10 - int(_mem.txfreq) * 10) > 70000000:
mem.duplex = "split"
mem.offset = int(_mem.txfreq) * 10
else:
mem.duplex = int(_mem.rxfreq) > int(_mem.txfreq) and "-" or "+"
mem.offset = abs(int(_mem.rxfreq) - int(_mem.txfreq)) * 10
mem.name = name2str(_nam.name)
self._tone_model.get_tone(_mem, mem)
mem.skip = "" if bool(_mem.scan) else "S"
mem.power = self.POWER_LEVELS[_mem.pwr]
if _mem.mod == 1:
mem.mode = "AM"
elif _mem.fm_dev == 0:
mem.mode = "FM"
else:
mem.mode = "NFM"
# qt has no home in the UI
return mem
def set_memory(self, mem):
""" Public set_memory
Inverse of get_memory. Update the radio memory image
from the mem object
"""
number = mem.number
_mem = self._memobj.chan_blk[number - 1]
_nam = self._memobj.chan_name[number - 1]
_val = self._memobj.chan_valid[number - 1]
if mem.empty:
# consider putting in a check for chan # that is empty but
# listed as one of the 2 working channels and change them
# to channel 1 to be consistent with CPS and allow
# complete deletion from radio. Otherwise,
# a deleted channel will still show on radio with no name.
# MRT implement the above working channel check
if self._memobj.a_conf.w_chan == number:
self._memobj.a_conf.w_chan = 1
if self._memobj.b_conf.w_chan == number:
self._memobj.b_conf.w_chan = 1
_mem.set_raw("\xFF" * (_mem.size() // 8))
_nam.name = str2name("", 8, '\0', '\0')
_mem.state = MEM_INVALID
_val.ch_valid = CHAN_INVALID
return
_mem.rxfreq = int(mem.freq / 10)
if mem.duplex == "off":
_mem.txfreq = 0xFFFFFFFF
elif mem.duplex == "split":
_mem.txfreq = int(mem.offset / 10)
elif mem.duplex == "+":
_mem.txfreq = int(mem.freq / 10) + int(mem.offset / 10)
elif mem.duplex == "-":
_mem.txfreq = int(mem.freq / 10) - int(mem.offset / 10)
else:
_mem.txfreq = int(mem.freq / 10)
_mem.scan = int(mem.skip != "S")
if mem.mode == "FM":
_mem.mod = 0 # make sure forced AM is off
_mem.fm_dev = 0
elif mem.mode == "NFM":
_mem.mod = 0
_mem.fm_dev = 1
elif mem.mode == "AM":
_mem.mod = 1 # AM on
_mem.fm_dev = 1 # set NFM bandwidth
else:
_mem.mod = 0
_mem.fm_dev = 0 # Catchall default is FM
# set the tone
self._tone_model.set_tone(mem, _mem)
# set the power
if mem.power:
_mem.pwr = self.POWER_LEVELS.index(mem.power)
else:
_mem.pwr = True
# Set fields we can't access via the UI table to safe defaults
_mem.qt = 0 # mute mode to QT
_mem.bit5 = 0 # clear this bit to ensure accurate CPS power level
_nam.name = str2name(mem.name, 8, '\0', '\0')
_mem.state = MEM_VALID
_val.ch_valid = CHAN_VALID
# Build the UI configuration tabs
# the channel memory tab is built by the core.
# We have no control over it
def _core_tab(self):
""" Build Core Configuration tab
Radio settings common to all modes and areas go here.
"""
s = self._memobj.settings
if (self.MODEL == "KG-UV9PX" or self.MODEL == "KG-UV9GX"):
sm = self._memobj.screen
cf = RadioSettingGroup("cfg_grp", "Configuration")
cf.append(RadioSetting("auto_am",
"Auto detect AM (Menu 53)",
RadioSettingValueBoolean(s.auto_am)))
cf.append(RadioSetting("qt_sw",
"Scan tone detect (Menu 59)",
RadioSettingValueBoolean(s.qt_sw)))
cf.append(
RadioSetting("s_mute",
"SubFreq Mute (Menu 60)",
RadioSettingValueList(S_MUTE_LIST,
current_index=s.s_mute)))
cf.append(
RadioSetting("tot",
"Transmit timeout Timer (Menu 10)",
RadioSettingValueList(TIMEOUT_LIST,
current_index=s.tot)))
cf.append(
RadioSetting("toa",
"Transmit Timeout Alarm (Menu 11)",
RadioSettingValueList(TOA_LIST,
current_index=s.toa)))
cf.append(
RadioSetting("ptt_id",
"PTT Caller ID mode (Menu 23)",
RadioSettingValueList(PTTID_LIST,
current_index=s.ptt_id)))
cf.append(
RadioSetting("id_dly",
"Caller ID Delay time (Menu 25)",
RadioSettingValueList(ID_DLY_LIST,
current_index=s.id_dly)))
cf.append(RadioSetting("voice_sw",
"Voice Guide (Menu 12)",
RadioSettingValueBoolean(s.voice_sw)))
cf.append(RadioSetting("beep",
"Keypad Beep (Menu 13)",
RadioSettingValueBoolean(s.beep)))
cf.append(
RadioSetting("s_tone",
"Side Tone (Menu 36)",
RadioSettingValueList(S_TONES,
current_index=s.s_tone)))
cf.append(
RadioSetting("ring_time",
"Ring Time (Menu 26)",
RadioSettingValueList(
LIST_OFF_10,
current_index=s.ring_time)))
cf.append(
RadioSetting("roger",
"Roger Beep (Menu 9)",
RadioSettingValueList(ROGER_LIST,
current_index=s.roger)))
cf.append(RadioSetting("blcdsw",
"Backlight (Menu 41)",
RadioSettingValueBoolean(s.blcdsw)))
cf.append(
RadioSetting("abr",
"Auto Backlight Time (Menu 1)",
RadioSettingValueList(BACKLIGHT_LIST,
current_index=s.abr)))
cf.append(
RadioSetting("abr_lvl",
"Backlight Brightness (Menu 27)",
RadioSettingValueInteger(BACKLIGHT_BRIGHT_MIN,
BACKLIGHT_BRIGHT_MAX,
s.abr_lvl)))
cf.append(RadioSetting("lock",
"Keypad Lock",
RadioSettingValueBoolean(s.lock)))
cf.append(
RadioSetting("lock_m",
"Keypad Lock Mode (Menu 35)",
RadioSettingValueList(LOCK_MODES,
current_index=s.lock_m)))
cf.append(RadioSetting("auto_lk",
"Keypad Autolock (Menu 34)",
RadioSettingValueBoolean(s.auto_lk)))
cf.append(RadioSetting("prich_sw",
"Priority Channel Scan (Menu 33)",
RadioSettingValueBoolean(s.prich_sw)))
cf.append(RadioSetting("pri_ch",
"Priority Channel (Menu 32)",
RadioSettingValueInteger(1, 999,
s.pri_ch)))
cf.append(
RadioSetting("dtmf_st",
"DTMF Sidetone (Menu 22)",
RadioSettingValueList(DTMFST_LIST,
current_index=s.dtmf_st)))
cf.append(RadioSetting("sc_qt",
"Scan QT Save Mode (Menu 38)",
RadioSettingValueList(
SCQT_LIST,
current_index=s.sc_qt)))
cf.append(
RadioSetting("apo_tmr",
"Automatic Power-off (Menu 39)",
RadioSettingValueList(APO_TIMES,
current_index=s.apo_tmr)))
cf.append( # VOX "guard" is really VOX trigger audio level
RadioSetting("vox_grd",
"VOX level (Menu 7)",
RadioSettingValueList(VOX_GRDS,
current_index=s.vox_grd)))
cf.append(
RadioSetting("vox_dly",
"VOX Delay (Menu 37)",
RadioSettingValueList(VOX_DLYS,
current_index=s.vox_dly)))
cf.append(RadioSetting("bledsw",
"Receive LED (Menu 42)",
RadioSettingValueBoolean(s.bledsw)))
if (self.MODEL == "KG-UV9PX" or self.MODEL == "KG-UV9GX"):
cf.append(RadioSetting("screen.screen_mode",
"Screen Mode (Menu 62)",
RadioSettingValueList(
SCREEN_MODE_LIST,
current_index=sm.screen_mode)))
if (self.MODEL == "KG-UV9PX" or self.MODEL == "KG-UV9GX"):
langlst = LANGUAGE_LIST2
else:
langlst = LANGUAGE_LIST
cf.append(
RadioSetting("lang",
"Menu Language (Menu 14)",
RadioSettingValueList(langlst,
current_index=s.lang)))
if (self.MODEL == "KG-UV9PX" or self.MODEL == "KG-UV9GX"):
ponmsglst = PONMSG_LIST2
else:
ponmsglst = PONMSG_LIST
cf.append(RadioSetting("ponmsg",
"Poweron message (Menu 40)",
RadioSettingValueList(
ponmsglst, current_index=s.ponmsg)))
return cf
def _repeater_tab(self):
"""Repeater mode functions
"""
s = self._memobj.settings
cf = RadioSettingGroup("repeater", "Repeater Functions")
cf.append(
RadioSetting("type_set",
"Radio Mode (Menu 43)",
RadioSettingValueList(
RPTMODE_LIST,
current_index=s.type_set)))
cf.append(RadioSetting("rpt_ptt",
"Repeater PTT (Menu 45)",
RadioSettingValueBoolean(s.rpt_ptt)))
cf.append(RadioSetting("rpt_spk",
"Repeater Mode Speaker (Menu 44)",
RadioSettingValueBoolean(s.rpt_spk)))
cf.append(
RadioSetting("rpt_kpt",
"Repeater Hold Time (Menu 46)",
RadioSettingValueList(RPT_KPTS,
current_index=s.rpt_kpt)))
cf.append(RadioSetting("rpt_rct",
"Repeater Receipt Tone (Menu 47)",
RadioSettingValueBoolean(s.rpt_rct)))
return cf
def _admin_tab(self):
"""Admin functions not present in radio menu...
These are admin functions not radio operation configuration
"""
def apply_cid(setting, obj):
c = str2callid(setting.value)
obj.code = c
def apply_scc(setting, obj):
c = str2digits(setting.value)
obj.scc = c
def apply_mode_sw(setting, obj):
pw = str2pw(setting.value)
obj.mode_sw = pw
setting.value = pw2str(obj.mode_sw)
def apply_reset(setting, obj):
pw = str2pw(setting.value)
obj.reset = pw
setting.value = pw2str(obj.reset)
def apply_wake(setting, obj):
obj.wake = int(setting.value)/10
def apply_sleep(setting, obj):
obj.sleep = int(setting.value)/10
pw = self._memobj.passwords # admin passwords
s = self._memobj.settings
cf = RadioSettingGroup("admin", "Admin Functions")
cf.append(RadioSetting("menu_avail",
"Menu available in channel mode",
RadioSettingValueBoolean(s.menu_avail)))
mode_sw = RadioSettingValueString(0, 6,
pw2str(pw.mode_sw), False)
rs = RadioSetting("passwords.mode_sw",
"Mode Switch Password", mode_sw)
rs.set_apply_callback(apply_mode_sw, pw)
cf.append(rs)
cf.append(RadioSetting("reset_avail",
"Radio Reset Available",
RadioSettingValueBoolean(s.reset_avail)))
reset = RadioSettingValueString(0, 6, pw2str(pw.reset), False)
rs = RadioSetting("passwords.reset",
"Radio Reset Password", reset)
rs.set_apply_callback(apply_reset, pw)
cf.append(rs)
cf.append(
RadioSetting("dtmf_tx",
"DTMF Tx Duration",
RadioSettingValueList(DTMF_TIMES,
current_index=s.dtmf_tx)))
cid = self._memobj.my_callid
my_callid = RadioSettingValueString(3, 6,
self.callid2str(cid.code), False)
rs = RadioSetting("my_callid.code",
"PTT Caller ID code (Menu 24)", my_callid)
rs.set_apply_callback(apply_cid, cid)
cf.append(rs)
stun = self._memobj.stun
st = RadioSettingValueString(0, 6, digits2str(stun.scc), False)
rs = RadioSetting("stun.scc", "Security code", st)
rs.set_apply_callback(apply_scc, stun)
cf.append(rs)
cf.append(
RadioSetting("settings.save_m",
"Save Mode (Menu 2)",
RadioSettingValueList(SAVE_MODES,
current_index=s.save_m)))
for i in range(0, 4):
sm = self._memobj.save[i]
wake = RadioSettingValueInteger(0, 18000, sm.wake * 10, 1)
wf = RadioSetting("save[%i].wake" % i,
"Save Mode %d Wake Time" % (i+1), wake)
wf.set_apply_callback(apply_wake, sm)
cf.append(wf)
slp = RadioSettingValueInteger(0, 18000, sm.sleep * 10, 1)
wf = RadioSetting("save[%i].sleep" % i,
"Save Mode %d Sleep Time" % (i+1), slp)
wf.set_apply_callback(apply_sleep, sm)
cf.append(wf)
_msg = str(self._memobj.display.banner).split("\0")[0]
val = RadioSettingValueString(0, 16, _msg)
val.set_mutable(True)
cf.append(RadioSetting("display.banner",
"Display Message", val))
if (self.MODEL == "KG-UV9PX" or self.MODEL == "KG-UV9GX"):
_str = str(self._memobj.oemmodel.model).split("\0")[0]
val = RadioSettingValueString(0, 10, _str)
val.set_mutable(True)
cf.append(RadioSetting("oemmodel.model",
"Custom Sub-Receiver Message", val))
val = RadioSettingValueList(
TDR_LIST,
current_index=s.tdr)
val.set_mutable(True)
cf.append(RadioSetting("tdr", "TDR", val))
val = RadioSettingValueList(
ACTIVE_AREA_LIST,
current_index=s.act_area)
val.set_mutable(True)
cf.append(RadioSetting("act_area", "Active Receiver(BAND)", val))
return cf
def _fm_tab(self):
"""FM Broadcast channels
"""
def apply_fm(setting, obj):
f = freq2short(setting.value, 76000000, 108000000)
obj.fm_freq = f
fm = RadioSettingGroup("fm_chans", "FM Broadcast")
for ch in range(0, 20):
chan = self._memobj.fm_chans[ch]
freq = RadioSettingValueString(0, 20,
short2freq(chan.fm_freq))
rs = RadioSetting("fm_%d" % (ch + 1),
"FM Channel %d" % (ch + 1), freq)
rs.set_apply_callback(apply_fm, chan)
fm.append(rs)
return fm
def _scan_grp(self):
"""Scan groups
"""
def apply_name(setting, obj):
name = str2name(setting.value, 8, '\0', '\0')
obj.name = name
def apply_start(setting, obj):
"""Do a callback to deal with RadioSettingInteger limitation
on memory address resolution
"""
obj.scan_st = int(setting.value)
def apply_end(setting, obj):
"""Do a callback to deal with RadioSettingInteger limitation
on memory address resolution
"""
obj.scan_end = int(setting.value)
sgrp = self._memobj.scn_grps
scan = RadioSettingGroup("scn_grps", "Channel Scanner Groups")
for i in range(0, 10):
s_grp = sgrp.addrs[i]
s_name = sgrp.names[i]
rs_name = RadioSettingValueString(0, 8,
name2str(s_name.name))
rs = RadioSetting("scn_grps.names[%i].name" % i,
"Group %i Name" % (i + 1), rs_name)
rs.set_apply_callback(apply_name, s_name)
scan.append(rs)
rs_st = RadioSettingValueInteger(1, 999, s_grp.scan_st)
rs = RadioSetting("scn_grps.addrs[%i].scan_st" % i,
"Starting Channel", rs_st)
rs.set_apply_callback(apply_start, s_grp)
scan.append(rs)
rs_end = RadioSettingValueInteger(1, 999, s_grp.scan_end)
rs = RadioSetting("scn_grps.addrs[%i].scan_end" % i,
"Last Channel", rs_end)
rs.set_apply_callback(apply_end, s_grp)
scan.append(rs)
return scan
def _callid_grp(self):
"""Caller IDs to be recognized by radio
This really should be a table in the UI
"""
def apply_callid(setting, obj):
c = str2callid(setting.value)
obj.cid = c
def apply_name(setting, obj):
name = str2name(setting.value, 6, '\0', '\xff')
obj.name = name
cid = RadioSettingGroup("callids", "Caller IDs")
for i in range(0, 20):
callid = self._memobj.call_ids[i]
name = self._memobj.cid_names[i]
c_name = RadioSettingValueString(0, 6, name2str(name.name))
rs = RadioSetting("cid_names[%i].name" % i,
"Caller ID %i Name" % (i + 1), c_name)
rs.set_apply_callback(apply_name, name)
cid.append(rs)
c_id = RadioSettingValueString(0, 6,
self.callid2str(callid.cid),
False)
rs = RadioSetting("call_ids[%i].cid" % i,
"Caller ID Code", c_id)
rs.set_apply_callback(apply_callid, callid)
cid.append(rs)
return cid
def _band_tab(self, area, band):
""" Build a band tab inside a VFO/Area
"""
def apply_freq(setting, lo, hi, obj):
f = freq2int(setting.value, lo, hi)
obj.freq = f/10
def apply_offset(setting, obj):
f = freq2int(setting.value, 0, 5000000)
obj.offset = f/10
def apply_enc(setting, obj):
t = tone2short(setting.value)
obj.encqt = t
def apply_dec(setting, obj):
t = tone2short(setting.value)
obj.decqt = t
if area == "a":
if band == 150:
c = self._memobj.vfo_a.band_150
lo = 108000000
hi = 180000000
elif band == 200:
c = self._memobj.vfo_a.band_200
lo = 230000000
hi = 250000000
elif band == 300:
c = self._memobj.vfo_a.band_300
lo = 350000000
hi = 400000000
elif band == 450:
c = self._memobj.vfo_a.band_450
lo = 400000000
hi = 512000000
else: # 700
c = self._memobj.vfo_a.band_700
lo = 700000000
hi = 985000000
else: # area 'b'
if band == 150:
c = self._memobj.vfo_b.band_150
lo = 136000000
hi = 180000000
else: # 450
c = self._memobj.vfo_b.band_450
lo = 400000000
hi = 512000000
prefix = "vfo_%s.band_%d" % (area, band)
bf = RadioSettingGroup(prefix, "%d MHz Band" % band)
freq = RadioSettingValueString(0, 15, int2freq(c.freq * 10))
rs = RadioSetting(prefix + ".freq", "Rx Frequency", freq)
rs.set_apply_callback(apply_freq, lo, hi, c)
bf.append(rs)
off = RadioSettingValueString(0, 15, int2freq(c.offset * 10))
rs = RadioSetting(prefix + ".offset", "Tx Offset (Menu 28)", off)
rs.set_apply_callback(apply_offset, c)
bf.append(rs)
rs = RadioSetting(prefix + ".encqt",
"Encode QT (Menu 17,19)",
RadioSettingValueList(TONE_LIST,
short2tone(c.encqt)))
rs.set_apply_callback(apply_enc, c)
bf.append(rs)
rs = RadioSetting(prefix + ".decqt",
"Decode QT (Menu 16,18)",
RadioSettingValueList(TONE_LIST,
short2tone(c.decqt)))
rs.set_apply_callback(apply_dec, c)
bf.append(rs)
bf.append(RadioSetting(prefix + ".qt",
"Mute Mode (Menu 21)",
RadioSettingValueList(SPMUTE_LIST,
current_index=c.qt)))
bf.append(RadioSetting(prefix + ".scan",
"Scan this (Menu 48)",
RadioSettingValueBoolean(c.scan)))
bf.append(RadioSetting(prefix + ".pwr",
"Power (Menu 5)",
RadioSettingValueList(
POWER_LIST, current_index=c.pwr)))
bf.append(RadioSetting(prefix + ".mod",
"AM Modulation (Menu 54)",
RadioSettingValueBoolean(c.mod)))
bf.append(RadioSetting(prefix + ".fm_dev",
"FM Deviation (Menu 4)",
RadioSettingValueList(
BANDWIDTH_LIST,
current_index=c.fm_dev)))
bf.append(
RadioSetting(prefix + ".shift",
"Frequency Shift (Menu 6)",
RadioSettingValueList(OFFSET_LIST,
current_index=c.shift)))
return bf
def _area_tab(self, area):
"""Build a VFO tab
"""
def apply_scan_st(setting, scan_lo, scan_hi, obj):
f = freq2short(setting.value, scan_lo, scan_hi)
obj.scan_st = f
def apply_scan_end(setting, scan_lo, scan_hi, obj):
f = freq2short(setting.value, scan_lo, scan_hi)
obj.scan_end = f
if area == "a":
desc = "Area A Settings"
c = self._memobj.a_conf
scan_lo = 108000000
scan_hi = 985000000
scan_rng = self._memobj.settings.a
band_list = (150, 200, 300, 450, 700)
else:
desc = "Area B Settings"
c = self._memobj.b_conf
scan_lo = 136000000
scan_hi = 512000000
scan_rng = self._memobj.settings.b
band_list = (150, 450)
prefix = "%s_conf" % area
af = RadioSettingGroup(prefix, desc)
af.append(
RadioSetting(prefix + ".w_mode",
"Workmode",
RadioSettingValueList(
WORKMODE_LIST,
current_index=c.w_mode)))
af.append(RadioSetting(prefix + ".w_chan",
"Channel",
RadioSettingValueInteger(1, 999,
c.w_chan)))
af.append(
RadioSetting(prefix + ".scan_grp",
"Scan Group (Menu 49)",
RadioSettingValueList(
SCANGRP_LIST,
current_index=c.scan_grp)))
af.append(RadioSetting(prefix + ".bcl",
"Busy Channel Lock-out (Menu 15)",
RadioSettingValueBoolean(c.bcl)))
af.append(
RadioSetting(prefix + ".sql",
"Squelch Level (Menu 8)",
RadioSettingValueList(LIST_0_9,
current_index=c.sql)))
af.append(
RadioSetting(prefix + ".cset",
"Call ID Group (Menu 52)",
RadioSettingValueList(LIST_1_20,
current_index=c.cset)))
af.append(
RadioSetting(prefix + ".step",
"Frequency Step (Menu 3)",
RadioSettingValueList(
self._step_list, current_index=c.step)))
af.append(
RadioSetting(prefix + ".scan_mode",
"Scan Mode (Menu 20)",
RadioSettingValueList(
SCANMODE_LIST,
current_index=c.scan_mode)))
af.append(
RadioSetting(prefix + ".scan_range",
"Scan Range (Menu 50)",
RadioSettingValueList(
SCANRANGE_LIST,
current_index=c.scan_range)))
st = RadioSettingValueString(0, 15,
short2freq(scan_rng.scan_st))
rs = RadioSetting("settings.%s.scan_st" % area,
"Frequency Scan Start", st)
rs.set_apply_callback(apply_scan_st, scan_lo, scan_hi, scan_rng)
af.append(rs)
end = RadioSettingValueString(0, 15,
short2freq(scan_rng.scan_end))
rs = RadioSetting("settings.%s.scan_end" % area,
"Frequency Scan End", end)
rs.set_apply_callback(apply_scan_end, scan_lo, scan_hi,
scan_rng)
af.append(rs)
# Each area has its own set of bands
for band in (band_list):
af.append(self._band_tab(area, band))
return af
def _key_tab(self):
"""Build radio key/button menu
"""
s = self._memobj.settings
if self.MODEL == "KG-UV9PX":
pfkey1 = PF1KEY_LIST
pfkey2 = PF2KEY_LIST
pfkey3 = PF3KEY_LIST2
elif (self.MODEL == "KG-UV9GX" or
self.MODEL == "KG-UV9G Pro"):
pfkey1 = PF1KEY_LIST9GX
pfkey2 = PF2KEY_LIST9GX
pfkey3 = PF3KEY_LIST9GX
else:
pfkey1 = PF1KEY_LIST
pfkey2 = PF2KEY_LIST
pfkey3 = PF3KEY_LIST
kf = RadioSettingGroup("key_grp", "Key Settings")
kf.append(RadioSetting("settings.pf1",
"PF1 Key function (Menu 55)",
RadioSettingValueList(
pfkey1,
current_index=s.pf1)))
kf.append(RadioSetting("settings.pf2",
"PF2 Key function (Menu 56)",
RadioSettingValueList(
pfkey2,
current_index=s.pf2)))
kf.append(RadioSetting("settings.pf3",
"PF3 Key function (Menu 57)",
RadioSettingValueList(
pfkey3,
current_index=s.pf3)))
return kf
def _fl_tab(self):
"""Build the frequency limits tab
"""
# The stop limits in the factory KG-UV9D Mate memory image are 1 MHz
# higher than the published specs. The settings panel will crash if
# it encounters a value outside of these ranges.
hard_limits = {
"band_150": (108000000, 181000000),
"band_450": (400000000, 513000000),
"band_300": (350000000, 401000000),
"band_700": (700000000, 987000000),
"band_200": (230000000, 251000000)
}
def apply_freq_start(setting, low, high, obj):
f = freq2short(setting.value, low, high)
obj.start = f
def apply_freq_stop(setting, low, high, obj):
"""Sets the stop limit to 1 MHz below the input value"""
# The firmware has an off-by-1MHz error with stop limits.
# If you set the stop limit to 1480 (148 MHz), you can still tune
# up to 148.99 MHz. To compensate for this,
# we subtract 10 increments of 100 MHz before storing the value.
f = freq2short(setting.value, low, high) - 10
obj.stop = f
fl = RadioSettingGroup("freq_limit_grp", "Frequency Limits")
rx = self._memobj.rx_freq_limits
tx = self._memobj.tx_freq_limits
for rx_band in rx.items():
name, limits = rx_band
start_freq = RadioSettingValueString(1,
20,
short2freq(limits.start))
start_rs = RadioSetting("rx_start_" + name,
name + " Receive Start",
start_freq)
start_rs.set_apply_callback(apply_freq_start,
hard_limits[name][0],
hard_limits[name][1],
limits)
fl.append(start_rs)
# Add 10 increments of 100 MHz before displaying to compensate for
# the firmware off-by-1MHz problem.
stop_freq = RadioSettingValueString(1,
20,
short2freq(limits.stop + 10))
stop_rs = RadioSetting("rx_stop_" + name,
name + " Receive Stop",
stop_freq)
stop_rs.set_apply_callback(apply_freq_stop,
hard_limits[name][0],
hard_limits[name][1],
limits)
fl.append(stop_rs)
for tx_band in tx.items():
name, limits = tx_band
start_freq = RadioSettingValueString(1,
20,
short2freq(limits.start))
start_rs = RadioSetting("tx_start_" + name,
name + " Transmit Start",
start_freq)
start_rs.set_apply_callback(apply_freq_start,
hard_limits[name][0],
hard_limits[name][1], limits)
fl.append(start_rs)
# Add 10 increments of 100 MHz before displaying to compensate for
# the firmware off-by-1MHz problem.
stop_freq = RadioSettingValueString(1,
20,
short2freq(limits.stop + 10))
stop_rs = RadioSetting("tx_stop_" + name,
name + " Transmit Stop",
stop_freq)
stop_rs.set_apply_callback(apply_freq_stop,
hard_limits[name][0],
hard_limits[name][1],
limits)
fl.append(stop_rs)
return fl
def _get_settings(self):
"""Build the radio configuration settings menus
"""
core_grp = self._core_tab()
fm_grp = self._fm_tab()
area_a_grp = self._area_tab("a")
area_b_grp = self._area_tab("b")
key_grp = self._key_tab()
scan_grp = self._scan_grp()
callid_grp = self._callid_grp()
admin_grp = self._admin_tab()
rpt_grp = self._repeater_tab()
freq_limit_grp = self._fl_tab()
core_grp.append(key_grp)
core_grp.append(admin_grp)
core_grp.append(rpt_grp)
core_grp.append(freq_limit_grp)
group = RadioSettings(core_grp,
area_a_grp,
area_b_grp,
fm_grp,
scan_grp,
callid_grp
)
return group
def get_settings(self):
""" Public build out linkage between radio settings and UI
"""
try:
return self._get_settings()
except Exception:
import traceback
LOG.error("Failed to parse settings: %s",
traceback.format_exc())
return None
def _is_freq(self, element):
"""This is a hack to smoke out whether we need to do
frequency translations for otherwise innocent u16s and u32s
"""
return "rxfreq" in element.get_name() or \
"txfreq" in element.get_name() or \
"scan_st" in element.get_name() or \
"scan_end" in element.get_name() or \
"offset" in element.get_name() or \
"fm_stop" in element.get_name()
def _is_limit(self, element):
return "lower_limit" in element.get_name() or\
"upper_limit" in element.get_name()
def set_settings(self, settings):
""" Public update radio settings via UI callback
A lot of this should be in common code....
"""
for element in settings:
if not isinstance(element, RadioSetting):
LOG.debug("set_settings: not instance %s" %
element.get_name())
self.set_settings(element)
continue
else:
try:
if "." in element.get_name():
bits = element.get_name().split(".")
obj = self._memobj
for bit in bits[:-1]:
# decode an array index
if "[" in bit and "]" in bit:
bit, index = bit.split("[", 1)
index, junk = index.split("]", 1)
index = int(index)
obj = getattr(obj, bit)[index]
else:
obj = getattr(obj, bit)
setting = bits[-1]
else:
obj = self._memobj.settings
setting = element.get_name()
if element.has_apply_callback():
LOG.debug("Using apply callback")
element.run_apply_callback()
else:
LOG.debug("Setting %s = %s" %
(setting, element.value))
if self._is_freq(element):
setattr(obj, setting, int(element.value)/10)
elif self._is_limit(element):
setattr(obj, setting, int(element.value)*10)
else:
setattr(obj, setting, element.value)
except Exception:
LOG.debug("set_settings: Exception with %s" %
element.get_name())
raise
def callid2str(self, cid):
"""Caller ID per MDC-1200 spec? Must be 3-6 digits (100 - 999999).
One digit (binary) per byte, terminated with '0xc'
"""
bin2ascii = " 1234567890"
cidstr = ""
for i in range(0, 6):
b = cid[i].get_value()
if b == 0xc: # the cid EOL
break
if b == 0 or b > 0xa:
raise InvalidValueError(
"Caller ID code has illegal byte 0x%x" % b)
cidstr += bin2ascii[b]
return cidstr
@directory.register
class KGUV9PXRadio(KGUV9DPlusRadio):
"""Wouxun KG-UV9PX"""
VENDOR = "Wouxun"
MODEL = "KG-UV9PX"
_model = b"KG-UV9D"
_rev = b"02" # default rev for the radio I know about...
_file_ident = b"kg-uv9px"
_valid_steps = STEPS
_step_list = STEP_LIST
@classmethod
def match_model(cls, filedata, filename):
# This model is only ever matched via metadata
return False
def process_mmap(self):
if self._rev != b"02" and self._rev != b"00":
# new revision found - log it and assume same map and proceed
LOG.debug("Unrecognized model variation (%s) Using default Map" %
self._rev)
self._memobj = bitwise.parse(_MEM_FORMAT_9PX, self._mmap)
def get_features(self):
""" Public get_features
Return the features of this radio once we have identified
it and gotten its bits
"""
rf = chirp_common.RadioFeatures()
rf.has_settings = True
rf.has_ctone = True
rf.has_rx_dtcs = True
rf.has_cross = True
rf.has_tuning_step = False
rf.has_bank = False
rf.can_odd_split = True
rf.valid_skips = ["", "S"]
rf.valid_tmodes = ["", "Tone", "TSQL", "DTCS", "Cross"]
rf.valid_cross_modes = [
"Tone->Tone",
"Tone->DTCS",
"DTCS->Tone",
"DTCS->",
"->Tone",
"->DTCS",
"DTCS->DTCS",
]
rf.valid_modes = ["FM", "NFM", "AM"]
rf.valid_power_levels = self.POWER_LEVELS
rf.valid_name_length = 8
rf.valid_duplexes = ["", "-", "+", "split", "off"]
rf.valid_bands = [(108000000, 135997500), # Aircraft AM
(136000000, 180997500), # supports 2m
(219000000, 250997500),
(350000000, 399997500),
(400000000, 512997500), # supports 70cm
(700000000, 986997500)]
rf.valid_characters = chirp_common.CHARSET_ASCII
rf.valid_tuning_steps = STEPS
rf.memory_bounds = (1, 999) # 999 memories
return rf
def callid2str(self, cid):
"""Caller ID per MDC-1200 spec? Must be 3-6 digits (100 - 999999).
One digit (binary) per byte, terminated with '0xc'
"""
bin2ascii = " 1234567890"
cidstr = ""
for i in range(0, 6):
b = cid[i].get_value()
# 9PX factory reset CID use 0x00 for 0 digit - instead of 0x0a
# remap 0x00 to 0x0a
if b == 0x00:
b = 0x0a
if b == 0xc or b == 0xf0: # the cid EOL
break
if b > 0xa:
raise InvalidValueError(
"Caller ID code has illegal byte 0x%x" % b)
cidstr += bin2ascii[b]
return cidstr
def _get_settings(self):
"""Build the radio configuration settings menus
"""
core_grp = self._core_tab()
fm_grp = self._fm_tab()
area_a_grp = self._area_tab("a")
area_b_grp = self._area_tab("b")
key_grp = self._key_tab()
scan_grp = self._scan_grp()
callid_grp = self._callid_grp()
admin_grp = self._admin_tab()
rpt_grp = self._repeater_tab()
freq_limit_grp = self._fl_tab()
core_grp.append(key_grp)
core_grp.append(admin_grp)
core_grp.append(rpt_grp)
group = RadioSettings(core_grp,
area_a_grp,
area_b_grp,
fm_grp,
scan_grp,
callid_grp,
freq_limit_grp,)
return group
def _area_tab(self, area):
"""Build a VFO tab
"""
def apply_scan_st(setting, scan_lo, scan_hi, obj):
f = freq2short(setting.value, scan_lo, scan_hi)
obj.scan_st = f
def apply_scan_end(setting, scan_lo, scan_hi, obj):
f = freq2short(setting.value, scan_lo, scan_hi)
obj.scan_end = f
if area == "a":
desc = "Receiver A Settings"
c = self._memobj.a_conf
scan_lo = 108000000
scan_hi = 985997500
scan_rng = self._memobj.settings.a
band_list = (150, 200, 300, 450, 700)
else:
desc = "Receiver B Settings"
c = self._memobj.b_conf
scan_lo = 136000000
scan_hi = 512997500
scan_rng = self._memobj.settings.b
band_list = (150, 450)
prefix = "%s_conf" % area
af = RadioSettingGroup(prefix, desc)
af.append(
RadioSetting(prefix + ".w_mode",
"Workmode",
RadioSettingValueList(
WORKMODE_LIST,
current_index=c.w_mode)))
af.append(RadioSetting(prefix + ".w_chan",
"Channel",
RadioSettingValueInteger(1, 999,
c.w_chan)))
af.append(
RadioSetting(prefix + ".scan_grp",
"Scan Group (Menu 49)",
RadioSettingValueList(
SCANGRP_LIST,
current_index=c.scan_grp)))
af.append(RadioSetting(prefix + ".bcl",
"Busy Channel Lock-out (Menu 15)",
RadioSettingValueBoolean(c.bcl)))
af.append(
RadioSetting(prefix + ".sql",
"Squelch Level (Menu 8)",
RadioSettingValueList(LIST_0_9,
current_index=c.sql)))
af.append(
RadioSetting(prefix + ".cset",
"Call ID Group (Menu 52)",
RadioSettingValueList(LIST_1_20,
current_index=c.cset)))
af.append(
RadioSetting(prefix + ".step",
"Frequency Step (Menu 3)",
RadioSettingValueList(
self._step_list, current_index=c.step)))
af.append(
RadioSetting(prefix + ".scan_mode",
"Scan Mode (Menu 20)",
RadioSettingValueList(
SCANMODE_LIST,
current_index=c.scan_mode)))
af.append(
RadioSetting(prefix + ".scan_range",
"Scan Range (Menu 50)",
RadioSettingValueList(
SCANRANGE_LIST,
current_index=c.scan_range)))
st = RadioSettingValueString(0, 15,
short2freq(scan_rng.scan_st))
rs = RadioSetting("settings.%s.scan_st" % area,
"Frequency Scan Start", st)
rs.set_apply_callback(apply_scan_st, scan_lo, scan_hi, scan_rng)
af.append(rs)
end = RadioSettingValueString(0, 15,
short2freq(scan_rng.scan_end))
rs = RadioSetting("settings.%s.scan_end" % area,
"Frequency Scan End", end)
rs.set_apply_callback(apply_scan_end, scan_lo, scan_hi,
scan_rng)
af.append(rs)
# Each area has its own set of bands
for band in (band_list):
af.append(self._band_tab(area, band))
return af
def _band_tab(self, area, band):
""" Build a band tab inside a VFO/Area
"""
def apply_freq(setting, lo, hi, obj):
f = freq2int(setting.value, lo, hi)
obj.freq = f/10
def apply_offset(setting, obj):
f = freq2int(setting.value, 0, 5000000)
obj.offset = f/10
def apply_enc(setting, obj):
t = tone2short(setting.value)
obj.encqt = t
def apply_dec(setting, obj):
t = tone2short(setting.value)
obj.decqt = t
if area == "a":
if band == 150:
c = self._memobj.vfo_a.band_150
lo = 108000000
hi = 180997500
elif band == 200:
c = self._memobj.vfo_a.band_200
lo = 219000000
hi = 250997500
elif band == 300:
c = self._memobj.vfo_a.band_300
lo = 350000000
hi = 399997500
elif band == 450:
c = self._memobj.vfo_a.band_450
lo = 400000000
hi = 512997500
else: # 700
c = self._memobj.vfo_a.band_700
lo = 700000000
hi = 986997500
else: # area 'b'
if band == 150:
c = self._memobj.vfo_b.band_150
lo = 136000000
hi = 180997500
else: # 450
c = self._memobj.vfo_b.band_450
lo = 400000000
hi = 512997500
prefix = "vfo_%s.band_%d" % (area, band)
bf = RadioSettingGroup(prefix, "%d MHz Band" % band)
freq = RadioSettingValueString(0, 15, int2freq(c.freq * 10))
rs = RadioSetting(prefix + ".freq", "Rx Frequency", freq)
rs.set_apply_callback(apply_freq, lo, hi, c)
bf.append(rs)
off = RadioSettingValueString(0, 15, int2freq(c.offset * 10))
rs = RadioSetting(prefix + ".offset", "Tx Offset (Menu 28)", off)
rs.set_apply_callback(apply_offset, c)
bf.append(rs)
rs = RadioSetting(prefix + ".encqt",
"Encode QT (Menu 17,19)",
RadioSettingValueList(TONE_LIST,
short2tone(c.encqt)))
rs.set_apply_callback(apply_enc, c)
bf.append(rs)
rs = RadioSetting(prefix + ".decqt",
"Decode QT (Menu 16,18)",
RadioSettingValueList(TONE_LIST,
short2tone(c.decqt)))
rs.set_apply_callback(apply_dec, c)
bf.append(rs)
bf.append(RadioSetting(prefix + ".qt",
"Mute Mode (Menu 21)",
RadioSettingValueList(SPMUTE_LIST,
current_index=c.qt)))
bf.append(RadioSetting(prefix + ".scan",
"Scan this (Menu 48)",
RadioSettingValueBoolean(c.scan)))
bf.append(RadioSetting(prefix + ".pwr",
"Power (Menu 5)",
RadioSettingValueList(
POWER_LIST, current_index=c.pwr)))
bf.append(RadioSetting(prefix + ".mod",
"AM Modulation (Menu 54)",
RadioSettingValueBoolean(c.mod)))
bf.append(RadioSetting(prefix + ".fm_dev",
"FM Deviation (Menu 4)",
RadioSettingValueList(
BANDWIDTH_LIST,
current_index=c.fm_dev)))
bf.append(
RadioSetting(prefix + ".shift",
"Frequency Shift (Menu 6)",
RadioSettingValueList(OFFSET_LIST,
current_index=c.shift)))
return bf
def _fl_tab(self):
freq_limit_grp = RadioSettingGroup("limits",
"Freq Limits")
limgrp = freq_limit_grp
l = self._memobj.limits
if self.MODEL == "KG-UV9PX":
val = RadioSettingValueInteger(136, 180,
(l.lim_150M_Txlower_limit) / 10.0)
rs = RadioSetting("limits.lim_150M_Txlower_limit",
"150M Tx Lower Limit (MHz)",
val)
limgrp.append(rs)
val = RadioSettingValueInteger(136, 180,
(l.lim_150M_Txupper_limit) / 10.0)
rs = RadioSetting("limits.lim_150M_Txupper_limit",
"150M Tx Upper Limit (MHz + 0.9975)",
val)
limgrp.append(rs)
val = RadioSettingValueInteger(400, 512,
(l.lim_450M_Txlower_limit) / 10.0)
rs = RadioSetting("limits.lim_450M_Txlower_limit",
"450M Tx Lower Limit (MHz)",
val)
limgrp.append(rs)
val = RadioSettingValueInteger(400, 512,
(l.lim_450M_Txupper_limit) / 10.0)
rs = RadioSetting("limits.lim_450M_Txupper_limit",
"450M Tx Upper Limit (MHz + 0.9975)",
val)
limgrp.append(rs)
val = RadioSettingValueInteger(108, 180,
(l.lim_150M_area_a_rxlower_limit) /
10.0)
rs = RadioSetting("limits.lim_150M_area_a_rxlower_limit",
"Rcvr A 150M Rx Lower Limit (MHz)",
val)
limgrp.append(rs)
val = RadioSettingValueInteger(108, 180,
(l.lim_150M_area_a_rxupper_limit) /
10.0)
rs = RadioSetting("limits.lim_150M_area_a_rxupper_limit",
"Rcvr A 150M Rx Upper Limit (MHz + 0.9975)",
val)
limgrp.append(rs)
val = RadioSettingValueInteger(136, 180,
(l.lim_150M_area_b_rxlower_limit) /
10.0)
rs = RadioSetting("limits.lim_150M_area_b_rxlower_limit",
"Rcvr B 150M Rx Lower Limit (MHz)",
val)
limgrp.append(rs)
val = RadioSettingValueInteger(136, 180,
(l.lim_150M_area_b_rxupper_limit) /
10.0)
rs = RadioSetting("limits.lim_150M_area_b_rxupper_limit",
"Rcvr B 150M Rx Upper Limit (MHz + 0.9975)",
val)
limgrp.append(rs)
val = RadioSettingValueInteger(400, 512,
(l.lim_450M_rxlower_limit) / 10.0)
rs = RadioSetting("limits.lim_450M_rxlower_limit",
"450M Rx Lower Limit (MHz)",
val)
limgrp.append(rs)
val = RadioSettingValueInteger(400, 512,
(l.lim_450M_rxupper_limit) / 10.0)
rs = RadioSetting("limits.lim_450M_rxupper_limit",
"450M Rx Upper Limit (MHz + 0.9975)",
val)
limgrp.append(rs)
val = RadioSettingValueInteger(350, 399,
(l.lim_300M_rxlower_limit) / 10.0)
rs = RadioSetting("limits.lim_300M_rxlower_limit",
"300M Rx Lower Limit (MHz)",
val)
limgrp.append(rs)
val = RadioSettingValueInteger(350, 399,
(l.lim_300M_rxupper_limit) / 10.0)
rs = RadioSetting("limits.lim_300M_rxupper_limit",
"300M Rx Upper Limit (MHz + 0.9975)",
val)
limgrp.append(rs)
val = RadioSettingValueInteger(700, 986,
(l.lim_800M_rxlower_limit) / 10.0)
rs = RadioSetting("limits.lim_800M_rxlower_limit",
"800M Rx Lower Limit (MHz)",
val)
limgrp.append(rs)
val = RadioSettingValueInteger(700, 986,
(l.lim_800M_rxupper_limit) / 10.0)
rs = RadioSetting("limits.lim_800M_rxupper_limit",
"800M Rx Upper Limit (MHz + 0.9975)",
val)
limgrp.append(rs)
val = RadioSettingValueInteger(219, 250,
(l.lim_210M_rxlower_limit) / 10.0)
rs = RadioSetting("limits.lim_210M_rxlower_limit",
"210M Rx Lower Limit (MHz)",
val)
limgrp.append(rs)
val = RadioSettingValueInteger(219, 250,
(l.lim_210M_rxupper_limit) / 10.0)
rs = RadioSetting("limits.lim_210M_rxupper_limit",
"210M Rx Upper Limit (MHz + 0.9975)",
val)
limgrp.append(rs)
return limgrp
@directory.register
class KGUV9GXRadio(KGUV9PXRadio):
"""Wouxun KG-UV9GX"""
VENDOR = "Wouxun"
MODEL = "KG-UV9GX"
_model = b"KG-UV9D"
_rev = b"02" # default rev for the radio I know about...
_valid_steps = STEPS
_step_list = STEP_LIST
@classmethod
def match_model(cls, filedata, filename):
# This model is only ever matched via metadata
return False
@directory.register
class KGUV9KRadio(KGUV9DPlusRadio):
"""Wouxun KG-UV9K"""
VENDOR = "Wouxun"
MODEL = "KG-UV9K"
_model = b"KG-UV9D"
_file_ident = b"kg-uv9k"
_rev = b"02" # default rev for the radio I know about...
_step_list = STEP_LIST_9K
_valid_steps = STEPS_9K
@classmethod
def match_model(cls, filedata, filename):
# This model is only ever matched via metadata
return False
@directory.register
class KGUV9GProRadio(KGUV9DPlusRadio):
"""Wouxun KG-UV9G Pro"""
VENDOR = "Wouxun"
MODEL = "KG-UV9G Pro"
_model = b"KG-UV9D"
_file_ident = b"kg-uv9gpro"
_rev = b"02" # default rev for the radio I know about...
_step_list = STEP_LIST
_valid_steps = STEPS
@classmethod
def match_model(cls, filedata, filename):
# This model is only ever matched via metadata
return False
chirp-20261030/chirp/drivers/ksun_m6.py 0000644 0001750 0001750 00000035500 14670320477 016566 0 ustar hibby hibby # Copyright 2012 Dan Smith
# Copyright 2024 Yuri D'Elia
#
# 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 2 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
# Copyright 2014 Dan Smith
#
# 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 2 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
# based on modification of Dan Smith's and Jim Unroe original work
#
# 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 2 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
#
# 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 2 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 BBH", hdr)
length -= 2
if readdata:
data = radio.pipe.read(length)
# LOG.debug(" PTone",
"DTCS->",
"->DTCS",
"Tone->DTCS",
"DTCS->Tone",
"->Tone",
"DTCS->DTCS"]
rf.valid_characters = chirp_common.CHARSET_ASCII
rf.valid_name_length = 7
rf.valid_power_levels = self._power_levels
rf.valid_duplexes = ["", "-", "+", "split", "off"]
rf.valid_skips = ["", "S"]
rf.valid_tuning_steps = _STEP_LIST
rf.valid_bands = [(136000000, 174000001),
(400000000, 480000000)]
rf.valid_tones = TONES
rf.valid_dtcs_codes = DTCS_CODES
rf.memory_bounds = (1, 199)
return rf
def sync_in(self):
try:
self._mmap = do_download(self)
except Exception as e:
finish(self)
raise errors.RadioError("Failed to download from radio: %s" % e)
self.process_mmap()
def process_mmap(self):
self._memobj = bitwise.parse(
MEM_FORMAT % self._mem_formatter, self._mmap)
def sync_out(self):
try:
do_upload(self)
except errors.RadioError:
finish(self)
raise
except Exception as e:
raise errors.RadioError("Failed to upload to radio: %s" % e)
def get_raw_memory(self, number):
name, mem = self._get_memobjs(number)
return repr(name) + repr(mem)
def _get_tone(self, mem, _mem):
rx_tone = tx_tone = None
tx_tmode = TMODES[_mem.tx_tmode]
rx_tmode = TMODES[_mem.rx_tmode]
if tx_tmode == "Tone":
tx_tone = TONES[_mem.tx_tone - 1]
elif tx_tmode == "DTCS":
tx_tone = DTCS_CODES[_mem.tx_tone - 1]
if rx_tmode == "Tone":
rx_tone = TONES[_mem.rx_tone - 1]
elif rx_tmode == "DTCS":
rx_tone = DTCS_CODES[_mem.rx_tone - 1]
tx_pol = _mem.tx_tmode == 0x03 and "R" or "N"
rx_pol = _mem.rx_tmode == 0x03 and "R" or "N"
chirp_common.split_tone_decode(mem, (tx_tmode, tx_tone, tx_pol),
(rx_tmode, rx_tone, rx_pol))
def _is_txinh(self, _mem):
raw_tx = b""
for i in range(0, 4):
raw_tx += _mem.tx_freq[i].get_raw()
return raw_tx == b"\xFF\xFF\xFF\xFF"
def _get_memobjs(self, number):
_mem = self._memobj.memory[number - 1]
_name = self._memobj.name[number - 1]
return _mem, _name
def get_memory(self, number):
_mem, _name = self._get_memobjs(number)
mem = chirp_common.Memory()
mem.number = number
if _mem.get_raw()[:4] == b"\xFF\xFF\xFF\xFF":
mem.empty = True
return mem
mem.freq = int(_mem.rx_freq) * 10
if self._is_txinh(_mem):
mem.duplex = "off"
mem.offset = 0
elif int(_mem.rx_freq) == int(_mem.tx_freq):
mem.duplex = ""
mem.offset = 0
elif abs(int(_mem.rx_freq) * 10 - int(_mem.tx_freq) * 10) > 70000000:
mem.duplex = "split"
mem.offset = int(_mem.tx_freq) * 10
else:
mem.duplex = int(_mem.rx_freq) > int(_mem.tx_freq) and "-" or "+"
mem.offset = abs(int(_mem.rx_freq) - int(_mem.tx_freq)) * 10
mem.name = str(_name.name).rstrip()
self._get_tone(mem, _mem)
mem.mode = MODES[_mem.mode]
powerindex = _mem.power if _mem.power < len(self._power_levels) else -1
mem.power = self._power_levels[powerindex]
mem.skip = _mem.skip and "S" or ""
mem.extra = RadioSettingGroup("Extra", "extra")
opts = ["On", "Off"]
rs = RadioSetting("blckoff", "Busy Channel Lockout",
RadioSettingValueList(
opts, current_index=_mem.blckoff))
mem.extra.append(rs)
opts = ["Off", "On"]
rs = RadioSetting("tailcut", "Squelch Tail Elimination",
RadioSettingValueList(
opts, current_index=_mem.tailcut))
mem.extra.append(rs)
apro = _mem.apro if _mem.apro < 0x5 else 0
opts = ["Off", "Compander", "Scrambler", "TX Scrambler",
"RX Scrambler"]
rs = RadioSetting("apro", "Audio Processing",
RadioSettingValueList(
opts, current_index=apro))
mem.extra.append(rs)
opts = ["On", "Off"]
rs = RadioSetting("voxoff", "VOX",
RadioSettingValueList(
opts, current_index=_mem.voxoff))
mem.extra.append(rs)
opts = ["On", "Off"]
rs = RadioSetting("pttidoff", "PTT ID",
RadioSettingValueList(
opts, current_index=_mem.pttidoff))
mem.extra.append(rs)
opts = ["On", "Off"]
rs = RadioSetting("dtmfoff", "DTMF",
RadioSettingValueList(
opts, current_index=_mem.dtmfoff))
mem.extra.append(rs)
opts = ["Name", "Frequency"]
aliasop = RadioSetting("aliasop", "Display",
RadioSettingValueList(
opts, current_index=_mem.aliasop))
mem.extra.append(aliasop)
opts = ["On", "Off"]
rs = RadioSetting("reverseoff", "Reverse Frequency",
RadioSettingValueList(
opts, current_index=_mem.reverseoff))
mem.extra.append(rs)
opts = ["On", "Off"]
rs = RadioSetting("talkaroundoff", "Talk Around",
RadioSettingValueList(
opts, current_index=_mem.talkaroundoff))
mem.extra.append(rs)
return mem
def _set_tone(self, mem, _mem):
((txmode, txtone, txpol),
(rxmode, rxtone, rxpol)) = chirp_common.split_tone_encode(mem)
_mem.tx_tmode = TMODES.index(txmode)
_mem.rx_tmode = TMODES.index(rxmode)
if txmode == "Tone":
_mem.tx_tone = TONES.index(txtone) + 1
elif txmode == "DTCS":
_mem.tx_tmode = txpol == "R" and 0x03 or 0x02
_mem.tx_tone = DTCS_CODES.index(txtone) + 1
if rxmode == "Tone":
_mem.rx_tone = TONES.index(rxtone) + 1
elif rxmode == "DTCS":
_mem.rx_tmode = rxpol == "R" and 0x03 or 0x02
_mem.rx_tone = DTCS_CODES.index(rxtone) + 1
def set_memory(self, mem):
_mem, _name = self._get_memobjs(mem.number)
if mem.empty:
_mem.set_raw(b"\xFF" * 16)
return
elif _mem.get_raw() == (b"\xFF" * 16):
_mem.set_raw(b"\xFF" * 8 + b"\xFF\x00\xFF\x00\xFF\xFE\xF0\xFC")
_mem.rx_freq = mem.freq / 10
if mem.duplex == "off":
for i in range(0, 4):
_mem.tx_freq[i].set_raw(b"\xFF")
elif mem.duplex == "split":
_mem.tx_freq = mem.offset / 10
elif mem.duplex == "+":
_mem.tx_freq = (mem.freq + mem.offset) / 10
elif mem.duplex == "-":
_mem.tx_freq = (mem.freq - mem.offset) / 10
else:
_mem.tx_freq = mem.freq / 10
self._set_tone(mem, _mem)
_mem.power = mem.power and self._power_levels.index(mem.power) or 0
_mem.mode = MODES.index(mem.mode)
_mem.skip = mem.skip == "S"
_name.name = mem.name.ljust(7)
# autoset display to name if filled, else show frequency
if mem.extra:
# mem.extra only seems to be populated when called from edit panel
aliasop = mem.extra["aliasop"]
else:
aliasop = None
if mem.name:
_mem.aliasop = False
else:
_mem.aliasop = True
for setting in mem.extra:
setattr(_mem, setting.get_name(), setting.value)
def _get_settings(self):
_settings = self._memobj.settings
_service = self._memobj.service
_msg = self._memobj.messages
cfg_grp = RadioSettingGroup("cfg_grp", "Basic Settings")
adv_grp = RadioSettingGroup("adv_grp", "Advanced Settings")
key_grp = RadioSettingGroup("key_grp", "Key Assignment")
group = RadioSettings(cfg_grp, adv_grp, key_grp)
#
# Basic Settings
#
rs = RadioSetting("apo", "Auto Power Off",
RadioSettingValueList(
APO_LIST, current_index=_settings.apo))
cfg_grp.append(rs)
rs = RadioSetting("sql", "Squelch Level",
RadioSettingValueList(
SQL_LIST, current_index=_settings.sql))
cfg_grp.append(rs)
rs = RadioSetting("scanm", "Scan Mode",
RadioSettingValueList(
SCANM_LIST, current_index=_settings.scanm))
cfg_grp.append(rs)
rs = RadioSetting("tot", "Time Out Timer",
RadioSettingValueList(
TOT_LIST, current_index=_settings.tot))
cfg_grp.append(rs)
rs = RadioSetting("step", "Step",
RadioSettingValueList(
STEP_LIST, current_index=_settings.step))
cfg_grp.append(rs)
rs = RadioSetting("monitor", "Monitor",
RadioSettingValueList(
MONITOR_LIST, current_index=_settings.monitor))
cfg_grp.append(rs)
rs = RadioSetting("vfomr", "VFO/MR",
RadioSettingValueList(
VFOMR_LIST, current_index=_settings.vfomr))
cfg_grp.append(rs)
rs = RadioSetting("mrcha", "MR/CHA",
RadioSettingValueList(
MRCHA_LIST, current_index=_settings.mrcha))
cfg_grp.append(rs)
rs = RadioSetting("vol", "Volume",
RadioSettingValueList(
VOL_LIST, current_index=_settings.vol))
cfg_grp.append(rs)
rs = RadioSetting("opendis", "Open Display",
RadioSettingValueList(
OPENDIS_LIST, current_index=_settings.opendis))
cfg_grp.append(rs)
def _filter(name):
filtered = ""
for char in str(name):
if char in chirp_common.CHARSET_ASCII:
filtered += char
else:
filtered += " "
LOG.debug("Filtered: %s" % filtered)
return filtered
rs = RadioSetting("messages.user1", "User-defined Message 1",
RadioSettingValueString(0, 7, _filter(_msg.user1)))
cfg_grp.append(rs)
rs = RadioSetting("messages.user2", "User-defined Message 2",
RadioSettingValueString(0, 7, _filter(_msg.user2)))
cfg_grp.append(rs)
val = RadioSettingValueString(0, 7, _filter(_msg.system))
val.set_mutable(False)
rs = RadioSetting("messages.system", "System Message", val)
cfg_grp.append(rs)
rs = RadioSetting("lamp", "Backlight",
RadioSettingValueList(
LAMP_LIST, current_index=_settings.lamp))
cfg_grp.append(rs)
rs = RadioSetting("keylockm", "Key Lock Mode",
RadioSettingValueList(
KEYLOCKM_LIST,
current_index=_settings.keylockm))
cfg_grp.append(rs)
rs = RadioSetting("absel", "A/B Select",
RadioSettingValueList(ABSEL_LIST,
current_index=_settings.absel))
cfg_grp.append(rs)
rs = RadioSetting("obeep", "Open Beep",
RadioSettingValueBoolean(_settings.obeep))
cfg_grp.append(rs)
rs = RadioSetting("rbeep", "Roger Beep",
RadioSettingValueBoolean(_settings.rbeep))
cfg_grp.append(rs)
rs = RadioSetting("keylock_off", "Key Lock",
RadioSettingValueBoolean(not _settings.keylock_off))
cfg_grp.append(rs)
rs = RadioSetting("ctdcsb", "CT/DCS Busy Lock",
RadioSettingValueBoolean(_settings.ctdcsb))
cfg_grp.append(rs)
rs = RadioSetting("alarm", "Alarm Key",
RadioSettingValueBoolean(_settings.alarm))
cfg_grp.append(rs)
rs = RadioSetting("save", "Battery Save",
RadioSettingValueBoolean(_settings.save))
cfg_grp.append(rs)
rs = RadioSetting("kbeep", "Key Beep",
RadioSettingValueBoolean(_settings.kbeep))
cfg_grp.append(rs)
rs = RadioSetting("reset", "Reset Enable",
RadioSettingValueBoolean(_settings.reset))
cfg_grp.append(rs)
rs = RadioSetting("smfont_off", "Small Font",
RadioSettingValueBoolean(not _settings.smfont_off))
cfg_grp.append(rs)
rs = RadioSetting("aliasen_off", "Alias Enable",
RadioSettingValueBoolean(not _settings.aliasen_off))
cfg_grp.append(rs)
rs = RadioSetting("txstop_off", "TX Stop",
RadioSettingValueBoolean(not _settings.txstop_off))
cfg_grp.append(rs)
rs = RadioSetting("dw_off", "Dual Watch",
RadioSettingValueBoolean(not _settings.dw_off))
cfg_grp.append(rs)
rs = RadioSetting("fmen_off", "FM Enable",
RadioSettingValueBoolean(not _settings.fmen_off))
cfg_grp.append(rs)
rs = RadioSetting("fmdw", "FM Dual Watch",
RadioSettingValueBoolean(_settings.fmdw))
cfg_grp.append(rs)
rs = RadioSetting("fmscan_off", "FM Scan",
RadioSettingValueBoolean(
not _settings.fmscan_off))
cfg_grp.append(rs)
rs = RadioSetting("keypadmic_off", "Keypad MIC",
RadioSettingValueBoolean(
not _settings.keypadmic_off))
cfg_grp.append(rs)
rs = RadioSetting("voxgain", "VOX Gain",
RadioSettingValueList(
VOXGAIN_LIST, current_index=_settings.voxgain))
cfg_grp.append(rs)
rs = RadioSetting("voxdt", "VOX Delay Time",
RadioSettingValueList(
VOXDT_LIST, current_index=_settings.voxdt))
cfg_grp.append(rs)
rs = RadioSetting("vir", "VOX Inhibit on Receive",
RadioSettingValueBoolean(_settings.vir))
cfg_grp.append(rs)
#
# Advanced Settings
#
val = (_settings.dtmftime) - 5
rs = RadioSetting("dtmftime", "DTMF Digit Time",
RadioSettingValueList(
DTMFTIME_LIST, current_index=val))
adv_grp.append(rs)
val = (_settings.dtmfspace) - 5
rs = RadioSetting("dtmfspace", "DTMF Digit Space Time",
RadioSettingValueList(
DTMFTIME_LIST, current_index=val))
adv_grp.append(rs)
val = (_settings.dtmfdelay) // 5
rs = RadioSetting("dtmfdelay", "DTMF 1st Digit Delay",
RadioSettingValueList(
DTMFDELAY_LIST, current_index=val))
adv_grp.append(rs)
val = (_settings.dtmfpretime) // 10 - 1
rs = RadioSetting("dtmfpretime", "DTMF Pretime",
RadioSettingValueList(
DTMFPRETIME_LIST, current_index=val))
adv_grp.append(rs)
val = (_settings.dtmfdelay2) // 5
rs = RadioSetting("dtmfdelay2", "DTMF * and # Digit Delay",
RadioSettingValueList(
DTMFDELAY2_LIST, current_index=val))
adv_grp.append(rs)
rs = RadioSetting("ackdecode", "ACK Decode",
RadioSettingValueBoolean(_settings.ackdecode))
adv_grp.append(rs)
rs = RadioSetting("dtmfst", "DTMF Sidetone",
RadioSettingValueBoolean(_settings.dtmfst))
adv_grp.append(rs)
rs = RadioSetting("service.rssi400", "Squelch Base Level (UHF)",
RadioSettingValueInteger(0, 255, _service.rssi400))
adv_grp.append(rs)
rs = RadioSetting("service.rssi136", "Squelch Base Level (VHF)",
RadioSettingValueInteger(0, 255, _service.rssi136))
adv_grp.append(rs)
#
# Key Settings
#
val = (_settings.lptime) - 5
rs = RadioSetting("lptime", "Long Press Time",
RadioSettingValueList(
LPTIME_LIST, current_index=val))
key_grp.append(rs)
rs = RadioSetting("keyp1long", "P1 Long Key",
RadioSettingValueList(
PFKEYLONG_LIST,
current_index=_settings.keyp1long))
key_grp.append(rs)
rs = RadioSetting("keyp1short", "P1 Short Key",
RadioSettingValueList(
PFKEYSHORT_LIST,
current_index=_settings.keyp1short))
key_grp.append(rs)
rs = RadioSetting("keyp2long", "P2 Long Key",
RadioSettingValueList(
PFKEYLONG_LIST,
current_index=_settings.keyp2long))
key_grp.append(rs)
rs = RadioSetting("keyp2short", "P2 Short Key",
RadioSettingValueList(
PFKEYSHORT_LIST,
current_index=_settings.keyp2short))
key_grp.append(rs)
rs = RadioSetting("keyp3long", "P3 Long Key",
RadioSettingValueList(
PFKEYLONG_LIST,
current_index=_settings.keyp3long))
key_grp.append(rs)
rs = RadioSetting("keyp3short", "P3 Short Key",
RadioSettingValueList(
PFKEYSHORT_LIST,
current_index=_settings.keyp3short))
key_grp.append(rs)
val = RadioSettingValueList(PFKEYSHORT_LIST,
current_index=_settings.keymshort)
val.set_mutable(_settings.menuen == 0)
rs = RadioSetting("keymshort", "M Short Key", val)
key_grp.append(rs)
val = RadioSettingValueBoolean(_settings.menuen)
rs = RadioSetting("menuen", "Menu Enable", val)
key_grp.append(rs)
return group
def get_settings(self):
try:
return self._get_settings()
except:
import traceback
LOG.error("Failed to parse settings: %s", traceback.format_exc())
return None
def set_settings(self, settings):
_settings = self._memobj.settings
for element in settings:
if not isinstance(element, RadioSetting):
self.set_settings(element)
continue
else:
try:
name = element.get_name()
if "." in name:
bits = name.split(".")
obj = self._memobj
for bit in bits[:-1]:
if "/" in bit:
bit, index = bit.split("/", 1)
index = int(index)
obj = getattr(obj, bit)[index]
else:
obj = getattr(obj, bit)
setting = bits[-1]
else:
obj = _settings
setting = element.get_name()
if element.has_apply_callback():
LOG.debug("Using apply callback")
element.run_apply_callback()
elif setting == "keylock_off":
setattr(obj, setting, not int(element.value))
elif setting == "smfont_off":
setattr(obj, setting, not int(element.value))
elif setting == "aliasen_off":
setattr(obj, setting, not int(element.value))
elif setting == "txstop_off":
setattr(obj, setting, not int(element.value))
elif setting == "dw_off":
setattr(obj, setting, not int(element.value))
elif setting == "fmen_off":
setattr(obj, setting, not int(element.value))
elif setting == "fmscan_off":
setattr(obj, setting, not int(element.value))
elif setting == "keypadmic_off":
setattr(obj, setting, not int(element.value))
elif setting == "dtmftime":
setattr(obj, setting, int(element.value) + 5)
elif setting == "dtmfspace":
setattr(obj, setting, int(element.value) + 5)
elif setting == "dtmfdelay":
setattr(obj, setting, int(element.value) * 5)
elif setting == "dtmfpretime":
setattr(obj, setting, (int(element.value) + 1) * 10)
elif setting == "dtmfdelay2":
setattr(obj, setting, int(element.value) * 5)
elif setting == "lptime":
setattr(obj, setting, int(element.value) + 5)
else:
LOG.debug("Setting %s = %s" % (setting, element.value))
setattr(obj, setting, element.value)
except Exception:
LOG.debug(element.get_name())
raise
@classmethod
def match_model(cls, filedata, filename):
if filedata[0x168:0x170].startswith(cls._file_ident) and \
filedata[0x170:0x178].startswith(cls._model_ident):
return True
else:
return False
@directory.register
class JetstreamJT270MRadio(LeixenVV898Radio):
"""Jetstream JT270M"""
VENDOR = "Jetstream"
MODEL = "JT270M"
ALIASES = []
_file_ident = b"JET"
_model_ident = b'LX-\x89\x85\x53'
class LT898UV(LeixenVV898Radio):
VENDOR = "LUITON"
MODEL = "LT-898UV"
@classmethod
def match_model(cls, filedata, filename):
return False
@directory.register
class JetstreamJT270MHRadio(LeixenVV898Radio):
"""Jetstream JT270MH"""
VENDOR = "Jetstream"
MODEL = "JT270MH"
_file_ident = b"Leixen"
_model_ident = b'LX-\x89\x85\x85'
_ranges = [(0x0C00, 0x2000)]
_mem_formatter = {'unknownormode': 'mode:1',
'modeorpower': 'power:2',
'chanstart': 0x0C00,
'namestart': 0x1900,
'defaults': 6}
_power_levels = [chirp_common.PowerLevel("Low", watts=5),
chirp_common.PowerLevel("Mid", watts=10),
chirp_common.PowerLevel("High", watts=25)]
# Base radio has offset zero to distinguish from sub devices
_offset = 0
def get_features(self):
rf = super(JetstreamJT270MHRadio, self).get_features()
rf.has_sub_devices = self._offset == 0
rf.memory_bounds = (1, 99)
return rf
def get_sub_devices(self):
return [JetstreamJT270MHRadioA(self._mmap),
JetstreamJT270MHRadioB(self._mmap)]
def _get_memobjs(self, number):
number = number * 2 - self._offset
_mem = self._memobj.memory[number]
_name = self._memobj.name[number]
return _mem, _name
class JetstreamJT270MHRadioA(JetstreamJT270MHRadio):
VARIANT = 'A Band'
_offset = 1
class JetstreamJT270MHRadioB(JetstreamJT270MHRadio):
VARIANT = 'B Band'
_offset = 2
@directory.register
class LeixenVV898SRadio(LeixenVV898Radio):
"""Leixen VV-898S, also VV-898E which is identical"""
VENDOR = "Leixen"
MODEL = "VV-898S"
_model_ident = b'LX-\x89\x85\x75'
_mem_formatter = {'unknownormode': 'mode:1',
'modeorpower': 'power:2',
'chanstart': 0x0D00,
'namestart': 0x19B0,
'defaults': 3}
_power_levels = [chirp_common.PowerLevel("Low", watts=5),
chirp_common.PowerLevel("Med", watts=10),
chirp_common.PowerLevel("High", watts=25)]
@directory.register
class VV898E(LeixenVV898SRadio):
'''Leixen has called this radio both 898E and S historically, ident is
identical'''
VENDOR = "Leixen"
MODEL = "VV-898E"
@classmethod
def match_model(cls, filedata, filename):
return False
@directory.register
@directory.detected_by(LeixenVV898SRadio)
class VV898SDualBank(JetstreamJT270MHRadio):
'''Newer VV898S 1.06+ firmware that features dual memory banks'''
VENDOR = "Leixen"
MODEL = "VV-898S"
VARIANT = "Dual Bank"
@classmethod
def match_model(cls, filedata, filename):
return False
@directory.register
@directory.detected_by(VV898E)
class VV898EDualBank(JetstreamJT270MHRadio):
'''Newer VV898E 1.06+ firmware that features dual memory banks'''
VENDOR = "Leixen"
MODEL = "VV-898E"
VARIANT = "Dual Bank"
@classmethod
def match_model(cls, filedata, filename):
return False
chirp-20261030/chirp/drivers/lt725uv.py 0000644 0001750 0001750 00000156752 15172631605 016445 0 ustar hibby hibby # Copyright 2016-2023:
# * Jim Unroe KC9HI,
# Modified for Baojie BJ-218: 2018
# Rick DeWitt (RJD),
# Modified for Baojie BJ-318: April 2021
# Mark Hartong, AJ4YI
# Modified for Baojie BJ-318: January 2023
# Mark Hartong, AJ4YI
# 1. Removed Experimental Warning
# 2. Added Brown & Yellow as Color Selections
# 3. Max VFO Volume Setting to 15 ( vice 10)
# Modified UHF band limits: February 2023
# Jim Unroe, KC9HI
#
# 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 2 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
#
# 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 2 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
#
# 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 2 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
#
# 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 2 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
#
# 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
#
# 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 2 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 ." %
(amount))
if d is None or len(d) != amount:
raise errors.RadioError(
"Tried to read %d bytes, but got %d bytes instead." %
(amount, len(d)))
return d
def pipewrite(pipe, data):
"""write some data, catch exceptions, validate length of data written"""
try:
n = pipe.write(data)
except Exception as e:
raise errors.RadioError(
"Tried to write %d bytes, but got an exception: %s." %
(len(data), repr(e)))
if n is None:
raise errors.RadioError(
"Tried to write %d bytes, but operation returned ." %
(len(data)))
if n != len(data):
raise errors.RadioError(
"Tried to write %d bytes, but wrote %d bytes instead." %
(len(data), n))
def attempt_initial_handshake(pipe):
"""try to do the initial handshake"""
pipewrite(pipe, HANDSHAKE_OUT)
x = piperead(pipe, len(HANDSHAKE_IN[0]))
if x in HANDSHAKE_IN:
return True
LOG.debug("Handshake failed: received: %s expected one of: %s" %
(repr(x), repr(HANDSHAKE_IN)))
return False
def initial_handshake(pipe, tries):
"""do an initial handshake attempt up to tries times"""
x = False
for i in range(tries):
x = attempt_initial_handshake(pipe)
if x:
break
if not x:
raise errors.RadioError("Initial handshake failed all ten tries.")
def mk_writecommand(addr):
"""makes a write command from an address specification"""
return pack('>cHc', b'W', addr, b'@')
def mk_readcommand(addr):
"""makes a read command from an address specification"""
return pack('>cHc', b'R', addr, b'@')
def expect_ack(pipe):
x = piperead(pipe, 1)
if x != b'\x06':
LOG.debug(
"Did not get ACK. received: %s, expected: '\\x06'" %
repr(x))
raise errors.RadioError("Did not get ACK when expected.")
def end_communications(pipe):
"""tell the radio that we are done"""
pipewrite(pipe, b'E')
expect_ack(pipe)
def read_block(pipe, addr):
"""read and return a chunk of data at specified address"""
r = mk_readcommand(addr)
w = mk_writecommand(addr)
pipewrite(pipe, r)
x = piperead(pipe, len(w))
if x != w:
raise errors.RadioError("Received data not following protocol.")
block = piperead(pipe, BLOCKSIZE)
return block
def write_block(pipe, addr, block):
"""write a chunk of data at specified address"""
w = mk_writecommand(addr)
pipewrite(pipe, w)
pipewrite(pipe, block)
expect_ack(pipe)
def show_progress(radio, blockaddr, upper, msg):
"""relay read/write information to the user through the gui"""
if radio.status_fn:
status = chirp_common.Status()
status.cur = blockaddr
status.max = upper
status.msg = msg
radio.status_fn(status)
def do_download(radio):
"""download from the radio to the memory map"""
initial_handshake(radio.pipe, 10)
memory = memmap.MemoryMapBytes(b'\xff'*0x1000)
for blockaddr in range(LOWER_READ_BOUND, UPPER_READ_BOUND, BLOCKSIZE):
LOG.debug("Reading block "+str(blockaddr))
block = read_block(radio.pipe, blockaddr)
memory.set(blockaddr, block)
show_progress(radio, blockaddr, UPPER_READ_BOUND,
"Reading radio memory... %04x" % blockaddr)
end_communications(radio.pipe)
return memory
def do_upload(radio):
"""upload from the memory map to the radio"""
memory = radio.get_mmap()
initial_handshake(radio.pipe, 10)
for blockaddr in range(LOWER_WRITE_BOUND, UPPER_WRITE_BOUND, BLOCKSIZE):
LOG.debug("Writing block "+str(blockaddr))
block = memory[blockaddr:blockaddr+BLOCKSIZE]
write_block(radio.pipe, blockaddr, block)
show_progress(radio, blockaddr, UPPER_WRITE_BOUND,
"Writing radio memory... % 04x" % blockaddr)
end_communications(radio.pipe)
def parse_tone(t):
"""
parse the tone (ctss, dtcs) part of the mmap
into more easily handled data types
"""
# [ mode, value, polarity ]
if int(t.high) == 0x3f and int(t.low) == 0xff:
return [None, None, None]
elif bool(t.digital):
t = ['DTCS',
(int(t.high) & 0x0f)*100 +
((int(t.low) & 0xf0) >> 4)*10 +
(int(t.low) & 0x0f),
['N', 'R'][bool(t.invert)]]
if t[1] not in chirp_common.DTCS_CODES:
return [None, None, None]
else:
t = ['Tone',
((int(t.high) & 0xf0) >> 4)*100 +
(int(t.high) & 0x0f)*10 +
((int(t.low) & 0xf0) >> 4) +
(int(t.low) & 0x0f)/10.0,
None]
if t[1] not in chirp_common.TONES:
return [None, None, None]
return t
def unparse_tone(t):
"""parse tone data back into the format used by the radio"""
# [ mode, value, polarity ]
if t[0] == 'Tone':
tint = int(t[1]*10)
t0, tint = tint % 10, tint // 10
t1, tint = tint % 10, tint // 10
t2, tint = tint % 10, tint // 10
high = (tint << 4) | t2
low = (t1 << 4) | t0
digital = False
invert = False
return digital, invert, high, low
elif t[0] == 'DTCS':
tint = int(t[1])
t0, tint = tint % 10, tint // 10
t1, tint = tint % 10, tint // 10
high = tint
low = (t1 << 4) | t0
digital = True
invert = t[2] == 'R'
return digital, invert, high, low
return None
def decode_halfbytes(data, mapping, length):
"""
construct a string from a datatype
where each half-byte maps to a character
"""
s = ''
for i in range(length):
if i & 1 == 0:
s += mapping[(int(data[i >> 1]) & 0xf0) >> 4]
else:
s += mapping[int(data[i >> 1]) & 0x0f]
return s
def encode_halfbytes(data, datapad, mapping, fillvalue, fieldlen):
"""encode data from a string where each character maps to a half-byte"""
if len(data) & 1:
# pad to an even length
data += datapad
o = [fillvalue] * fieldlen
for i in range(0, len(data), 2):
v = (mapping.index(data[i]) << 4) | mapping.index(data[i+1])
o[i >> 1] = v
return bytearray(util.byte_to_int(b) for b in o)
def decode_ffstring(data):
"""decode a string delimited by 0xff"""
s = ''
for b in data:
if int(b) == 0xff:
break
s += chr(int(b))
return s
def encode_ffstring(data, fieldlen):
"""right-pad to specified length with 0xff bytes"""
extra = fieldlen-len(data)
if extra > 0:
data += '\xff'*extra
return bytearray([util.byte_to_int(x) for x in data])
def decode_dtmf(data, length):
"""decode a field containing dtmf data into a string"""
if length == 0xff:
return ''
return decode_halfbytes(data, DTMF, length)
def encode_dtmf(data, length, fieldlen):
"""encode a string containing dtmf characters into a data field"""
return encode_halfbytes(data, '0', DTMF, b'\xff', fieldlen)
def decode_5tone(data):
"""decode a field containing 5-tone data into a string"""
if (int(data[2]) & 0x0f) != 0:
return ''
return decode_halfbytes(data, HEXADECIMAL, 5)
def encode_5tone(data, fieldlen):
"""encode a string containing 5-tone characters into a data field"""
return encode_halfbytes(data, '0', HEXADECIMAL, b'\xff', fieldlen)
def decode_freq(data):
"""decode frequency data for the broadcast FM radio memories"""
data_out = ''
if data[0] != 0xff:
data_out = chirp_common.format_freq(
int(decode_halfbytes(data, "0123456789", len(data)))*100000)
return data_out
def encode_freq(data, fieldlen):
"""encode frequency data for the broadcast FM radio memories"""
data_out = bytearray(b'\xff')*fieldlen
if data != '':
data_out = encode_halfbytes((('%%0%di' % (fieldlen << 1)) %
int(chirp_common.parse_freq(data)/10)),
'', '0123456789', '', fieldlen)
return data_out
def sbyn(s, n):
"""setting by name"""
return list(filter(lambda x: x.get_name() == n, s))[0]
# These helper classes provide a direct link between the value
# of the widget shown in the ui, and the setting in the memory
# map of the radio, lessening the need to write large chunks
# of code, first for populating the ui from the memory map,
# then secondly for parsing the values back.
# By supplying the memory map entry to the setting instance,
# it is possible to automatically 1) initialize the value of
# the setting, as well as 2) automatically update the memory
# value when the user changes it in the ui, without adding
# any code outside the class.
class MappedIntegerSettingValue(settings.RadioSettingValueInteger):
""""
Integer setting, with the possibility to add translation
functions between memory map <-> integer setting
"""
def __init__(self, val_mem, minval, maxval, step=1,
int_from_mem=lambda x: int(x),
mem_from_int=lambda x: x,
autowrite=True):
"""
val_mem - memory map entry for the value
minval - the minimum value allowed
maxval - maximum value allowed
step - value stepping
int_from_mem - function to convert memory entry to integer
mem_from_int - function to convert integer to memory entry
autowrite - automatically write the memory map entry
when the value is changed
"""
self._val_mem = val_mem
self._int_from_mem = int_from_mem
self._mem_from_int = mem_from_int
self._autowrite = autowrite
settings.RadioSettingValueInteger.__init__(
self,
minval, maxval, self._int_from_mem(val_mem), step)
def set_value(self, x):
settings.RadioSettingValueInteger.set_value(self, x)
if self._autowrite:
self.write_mem()
def write_mem(self):
if self.get_mutable() and self._mem_from_int is not None:
self._val_mem.set_value(self._mem_from_int(
settings.RadioSettingValueInteger.get_value(self)))
class MappedListSettingValue(settings.RadioSettingValueMap):
"""Mapped list setting"""
def __init__(self, val_mem, options, autowrite=True):
"""
val_mem - memory map entry for the value
options - either a list of strings options to present,
mapped to integers 0...n
in the memory map entry, or a list of tuples
("option description", memory map value)
int_from_mem - function to convert memory entry to integer
mem_from_int - function to convert integer to memory entry
autowrite - automatically write the memory map entry when
the value is changed
"""
self._val_mem = val_mem
self._autowrite = autowrite
options = list(options)
if not isinstance(options[0], tuple):
options = list(zip(options, range(len(options))))
settings.RadioSettingValueMap.__init__(
self,
options, mem_val=int(val_mem))
def set_value(self, value):
settings.RadioSettingValueMap.set_value(self, value)
if self._autowrite:
self.write_mem()
def write_mem(self):
if self.get_mutable():
self._val_mem.set_value(
settings.RadioSettingValueMap.get_mem_val(self))
class MappedCodedStringSettingValue(settings.RadioSettingValueString):
"""
generic base class for a number of mapped presented-as-strings
values which may need conversion between mem and string,
and may store a length value in a separate mem field
"""
def __init__(self, val_mem, len_mem, min_length, max_length,
charset=ASCIIPART, padchar=' ', autowrite=True,
str_from_mem=lambda mve, lve: str(mve[0:int(lve)]),
mem_val_from_str=lambda s, fl: s[0:fl],
mem_len_from_int=lambda l: l):
"""
val_mem - memory map entry for the value
len_mem - memory map entry for the length (or None)
min_length - length that the string will be right-padded to
max_length - maximum length of the string, set as maxlength
for the RadioSettingValueString
charset - the allowed charset
padchar - the character that will be used to pad short
strings, if not in the charset, charset[0] is used
autowrite - automatically call write_mem when the ui value
change
str_from_mem - function to convert from memory entry to string
value, form:
func(value_entry, length_entry or none) -> string
mem_val_from_str - function to convert from string value to
memory-fitting value, form:
func(string, value_entry_length) ->
value to store in value entry
mem_len_from_int - function to convert from string length to
memory-fitting value, form:
func(stringlength) -> value to store in length entry
"""
self._min_length = min_length
self._val_mem = val_mem
self._len_mem = len_mem
self._padchar = padchar
if padchar not in charset:
self._padchar = charset[0]
self._autowrite = autowrite
self._str_from_mem = str_from_mem
self._mem_val_from_str = mem_val_from_str
self._mem_len_from_int = mem_len_from_int
settings.RadioSettingValueString.__init__(
self,
0, max_length,
self._str_from_mem(self._val_mem, self._len_mem),
charset=charset, autopad=False)
def set_value(self, value):
"""
Set the value of the string, pad if below minimum length,
unless it's '' to provide a distinction between
uninitialized/reset data and needs-to-be-padded data
"""
while len(value) < self._min_length and len(value) != 0:
value += self._padchar
settings.RadioSettingValueString.set_value(self, value)
if self._autowrite:
self.write_mem()
def write_mem(self):
"""update the memory"""
if not self.get_mutable() or self._mem_val_from_str is None:
return
v = self.get_value()
l = len(v)
self._val_mem.set_value(self._mem_val_from_str(v, len(self._val_mem)))
if self._len_mem is not None and self._mem_len_from_int is not None:
self._len_mem.set_value(self._mem_len_from_int(l))
class MappedFFStringSettingValue(MappedCodedStringSettingValue):
"""
Mapped string setting, tailored for the puxing px888k,
which uses 0xff terminated strings.
"""
def __init__(self, val_mem, min_length, max_length,
charset=ASCIIPART, padchar=' ', autowrite=True):
MappedCodedStringSettingValue.__init__(
self,
val_mem, None, min_length, max_length,
charset=charset, padchar=padchar, autowrite=autowrite,
str_from_mem=lambda mve, lve: decode_ffstring(mve),
mem_val_from_str=lambda s, fl: encode_ffstring(s, fl),
mem_len_from_int=None)
class MappedDTMFStringSettingValue(MappedCodedStringSettingValue):
"""
Mapped string setting, tailored for the puxing px888k
field pairs (value and length) storing DTMF codes
"""
def __init__(self, val_mem, len_mem, min_length, max_length,
autowrite=True):
MappedCodedStringSettingValue.__init__(
self,
val_mem, len_mem, min_length, max_length,
charset=DTMF, padchar='0', autowrite=autowrite,
str_from_mem=lambda mve, lve: decode_dtmf(mve, lve),
mem_val_from_str=lambda s, fl: encode_dtmf(s, len(s), fl))
class MappedFiveToneStringSettingValue(MappedCodedStringSettingValue):
"""
Mapped string setting, tailored for the puxing px888k
fields storing 5-Tone codes
"""
def __init__(self, val_mem, autowrite=True):
MappedCodedStringSettingValue.__init__(
self,
val_mem, None, 0, 5, charset=HEXADECIMAL, padchar='0',
autowrite=autowrite,
str_from_mem=lambda mve, lve: decode_5tone(mve),
mem_val_from_str=lambda s, fl: encode_5tone(s, fl),
mem_len_from_int=None)
class MappedFreqStringSettingValue(MappedCodedStringSettingValue):
"""
Mapped string setting, tailored for the puxing px888k
fields for the broadcast FM radio frequencies
"""
def __init__(self, val_mem, autowrite=True):
MappedCodedStringSettingValue.__init__(
self,
val_mem, None, 0, 128, charset=ASCIIPART, padchar=' ',
autowrite=autowrite,
str_from_mem=lambda mve, lve: decode_freq(mve),
mem_val_from_str=lambda s, fl: encode_freq(s, fl))
# These functions lessen the amount of boilerplate on the form
# x = RadioSetting("AAA", "BBB", SomeKindOfRadioSettingValue( ... ))
# to
# x = some_kind_of_setting("AAA", "BBB", ... )
def integer_setting(k, n, *args, **kwargs):
return settings.RadioSetting(
k, n,
MappedIntegerSettingValue(*args, **kwargs))
def list_setting(k, n, *args, **kwargs):
return settings.RadioSetting(
k, n,
MappedListSettingValue(*args, **kwargs))
def ff_string_setting(k, n, *args, **kwargs):
return settings.RadioSetting(
k, n,
MappedFFStringSettingValue(*args, **kwargs))
def dtmf_string_setting(k, n, *args, **kwargs):
return settings.RadioSetting(
k, n,
MappedDTMFStringSettingValue(*args, **kwargs))
def five_tone_string_setting(k, n, *args, **kwargs):
return settings.RadioSetting(
k, n,
MappedFiveToneStringSettingValue(*args, **kwargs))
def frequency_setting(k, n, *args, **kwargs):
return settings.RadioSetting(
k, n,
MappedFreqStringSettingValue(*args, **kwargs))
@directory.register
class Puxing_PX888K_Radio(chirp_common.CloneModeRadio):
"""Puxing PX-888K"""
VENDOR = "Puxing"
MODEL = "PX-888K"
BAUD_RATE = 9600
@classmethod
def match_model(cls, filedata, filename):
if len(filedata) == UPPER_READ_BOUND:
if filedata[FILE_MAGIC[0]:FILE_MAGIC[1]] == FILE_MAGIC[2]:
return True
return False
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.has_bank_index = False
rf.has_dtcs = True
rf.has_ctone = True
rf.has_rx_dtcs = True
rf.has_dtcs_polarity = True
rf.has_mode = True
rf.has_offset = True
rf.has_name = True
rf.has_bank = False
rf.has_bank_names = False
rf.has_tuning_step = False
rf.has_cross = True
rf.has_infinite_number = False
rf.has_nostep_tuning = False
rf.has_comment = False
rf.has_settings = True
if SUPPORT_NONSPLIT_DUPLEX_ONLY:
rf.can_odd_split = False
else:
rf.can_odd_split = True
rf.valid_modes = MODES
rf.valid_tmodes = TONE_MODES
rf.valid_duplexes = DUPLEX_MODES
rf.valid_bands = BANDS
rf.valid_skips = SKIP_MODES
rf.valid_power_levels = POWER_LEVELS
rf.valid_characters = ASCIIPART
rf.valid_name_length = 6
rf.valid_cross_modes = CROSS_MODES
rf.memory_bounds = (1, 128)
rf.valid_special_chans = list(SPECIAL_CHANNELS.keys())
rf.valid_tuning_steps = [5.0, 6.25, 10.0, 12.5, 25.0]
return rf
def sync_in(self):
self._mmap = do_download(self)
self.process_mmap()
def process_mmap(self):
self._memobj = bitwise.parse(MEM_FORMAT, self._mmap)
def sync_out(self):
do_upload(self)
def _set_sane_defaults(self, data):
# thanks thayward!
data.set_raw(SANE_MEMORY_DEFAULT)
def _uninitialize(self, data, n):
if isinstance(data, bitwise.arrayDataElement):
data.set_value(b"\xff"*n)
else:
data.set_raw(b"\xff"*n)
def _get_memory_structs(self, number):
"""
fetch the correct data structs no matter
if its regular or special channels,
no matter if they're referred by name or channel index
"""
index = 2501
i = -42
designator = 'INVALID'
isregular = False
iscall = False
isvfo = False
_data = None
_name = None
_present = None
_priority = None
if number in SPECIAL_NUMBERS.keys():
index = number
# special by index
designator = SPECIAL_NUMBERS[number]
elif number in SPECIAL_CHANNELS.keys():
# special by name
index = SPECIAL_CHANNELS[number]
designator = number
elif number > 0:
# regular by number
index = number
designator = number
if index < 0:
isvfo = True
_data = self._memobj.mem.vfo_data[index+2]
elif index == 0:
iscall = True
_data = self._memobj.mem.call_channel
elif index > 0:
isregular = True
i = number - 1
_data = self._memobj.mem.channel_memory.data[i]
_name = self._memobj.mem.channel_memory.names[i].entry
_present = self._memobj.mem.channel_memory.present[
(i & 0x78) | (7-(i & 0x07))]
_priority = self._memobj.mem.channel_memory.priority[
(i & 0x78) | (7-(i & 0x07))]
if _data == bytearray(0xff)*16:
self._set_sane_defaults(_data)
return (index, designator,
_data, _name, _present, _priority,
isregular, isvfo, iscall)
def get_raw_memory(self, number):
x = self._get_memory_structs(number)
return repr(x[2])
def get_memory(self, number):
mem = chirp_common.Memory()
(index, designator,
_data, _name, _present, _priority,
isregular, isvfo, iscall) = self._get_memory_structs(number)
mem.number = index
# handle empty channels
if isregular:
if bool(_present):
mem.empty = False
mem.name = str(decode_ffstring(_name))
mem.skip = SKIP_MODES[1-int(_priority)]
else:
mem.empty = True
mem.name = ''
return mem
else:
mem.empty = False
mem.name = ''
mem.extd_number = designator
# get frequency data
mem.freq = int(_data.rx_freq)*10
mem.offset = int(_data.tx_freq)*10
# interpret frequency data
# only the vfo channels support duplex,
# memory channels operate in split mode all the time
if isvfo:
mem.duplex = DUPLEX_MODES[int(_data.duplex_sign)]
if mem.duplex == '-':
mem.offset = mem.freq - mem.offset
elif mem.duplex == '':
mem.offset = 0
elif mem.duplex == '+':
mem.offset = mem.offset - mem.freq
else:
if mem.freq == mem.offset:
mem.duplex = ''
mem.offset = 0
elif SUPPORT_NONSPLIT_DUPLEX_ONLY or \
SUPPORT_SPLIT_BUT_DEFAULT_TO_NONSPLIT_ALWAYS:
if mem.freq > mem.offset:
mem.offset = mem.freq - mem.offset
mem.duplex = '-'
elif mem.freq < mem.offset:
mem.offset = mem.offset - mem.freq
mem.duplex = '+'
else:
mem.duplex = 'split'
# get tone data
txtone = parse_tone(_data.tone[0])
rxtone = parse_tone(_data.tone[1])
chirp_common.split_tone_decode(mem, txtone, rxtone)
######################################################################
if ENABLE_DANGEROUS_EXPERIMENTAL_FEATURES:
# override certain settings based on flags
# that we have set in junk areas of the memory
# or basically, we BELIEVE this to be junk memory,
# hence why it's experimental and dangerous
if bool(_data.experimental_cross_mode_indicator) is False:
if mem.tmode == 'Tone':
mem.cross_mode = 'Tone->'
elif mem.tmode == 'TSQL':
mem.cross_mode = 'Tone->Tone'
elif mem.tmode == 'DTCS':
mem.cross_mode = 'DTCS->DTCS'
mem.tmode = 'Cross'
######################################################################
# transmit mode and power level
mem.mode = MODES[bool(_data.modulation_width)]
mem.power = POWER_LEVELS[_data.txpower]
# extra channel settings
mem.extra = settings.RadioSettingGroup(
"extra",
"extra",
list_setting("Busy channel lockout",
"BCL",
_data.bcl,
BCL_MODES),
list_setting("Swap transmit and receive frequencies",
"Tx Rx freq swap",
_data.txrx_reverse,
OFF_ON),
list_setting("Use compander",
"Use compander",
_data.compander,
OFF_ON),
list_setting("Use scrambler", "Use scrambler",
_data.use_scrambler,
NO_YES),
list_setting("Scrambler selection",
"Voice Scrambler",
_data.scrambler_type,
SCRAMBLER_MODES),
list_setting("Send ID code before and/or after transmitting",
"PTT ID",
_data.ptt_id_edge,
PTT_ID_EDGES),
list_setting("Optional signal before/after transmission, " +
"this setting overrides the PTT ID setting",
"Opt Signal",
_data.opt_signal,
OPTSIGN_MODES))
######################################################################
if ENABLE_DANGEROUS_EXPERIMENTAL_FEATURES:
# override certain settings based on flags
# that we have set in junk areas of the memory
# or basically, we BELIEVE this to be junk memory,
# hence why it's experimental and dangerous
if bool(_data.experimental_duplex_mode_indicator) is False:
# if this flag is set, this means that we in the gui
# have set the duplex mode to something
# the channel does not really support,
# such as split modes for vfo channels,
# and non-split modes for the memory channels
mem.duplex = DUPLEX_MODES[int(_data.duplex_sign)]
mem.freq = int(_data.rx_freq)*10
mem.offset = int(_data.tx_freq)*10
if isvfo:
# we want split, so we have to reconstruct it
# from -/0/+ modes
if mem.duplex == '-':
mem.offset = mem.freq - mem.offset
elif mem.duplex == '':
mem.offset = mem.freq
elif mem.duplex == '+':
mem.offset = mem.freq + mem.offset
mem.duplex = 'split'
else:
# we want -/0/+, so we have to reconstruct it
# from split modes
if mem.freq > mem.offset:
mem.offset = mem.freq - mem.offset
mem.duplex = '-'
elif mem.freq < mem.offset:
mem.offset = mem.offset - mem.freq
mem.duplex = '+'
else:
mem.offset = 0
mem.duplex = ''
######################################################################
return mem
def set_memory(self, mem):
(index, designator,
_data, _name, _present, _priority,
isregular, isvfo, iscall) = self._get_memory_structs(mem.number)
# handle empty channels
if mem.empty:
if isregular:
_present.set_value(False)
_priority.set_value(False)
self._uninitialize(_data, 16)
self._uninitialize(_name, 6)
else:
raise errors.InvalidValueError(
"Can't remove CALL and/or VFO channels!")
return
# handle regular channel stuff like name and present+priority flags
if isregular:
if not bool(_present):
self._set_sane_defaults(_data)
_name.set_value(
encode_ffstring(self.filter_name(mem.name.rstrip()),
len(_name)))
_present.set_value(True)
_priority.set_value(1-SKIP_MODES.index(mem.skip))
# frequency data
rxf = int(mem.freq/10)
txf = int(mem.offset/10)
_data.rx_freq.set_value(rxf)
if isvfo:
# fake split modes on write, for channels
# that do not support it, which are some
# (the two vfo channels)
if mem.duplex == 'split':
for band in BANDS:
rb = mem.freq in range(band[0], band[1])
tb = mem.offset in range(band[0], band[1])
if rb != tb:
raise errors.InvalidValueError(
"VFO frequencies should be on the same band")
if rxf < txf:
_data.duplex_sign.set_value(1)
_data.tx_freq.set_value(txf - rxf)
elif rxf > txf:
_data.duplex_sign.set_value(2)
_data.tx_freq.set_value(rxf-txf)
else:
_data.duplex_sign.set_value(0)
_data.tx_freq.set_value(0)
else:
_data.duplex_sign.set_value(DUPLEX_MODES.index(mem.duplex))
_data.tx_freq.set_value(txf)
######################################################################
if ENABLE_DANGEROUS_EXPERIMENTAL_FEATURES:
if mem.duplex == 'split':
_data.experimental_duplex_mode_indicator.set_value(0)
else:
_data.experimental_duplex_mode_indicator.set_value(1)
######################################################################
else:
# fake duplex modes on write, for channels
# that do not support it, which are most
# (all the memory channels)
if mem.duplex == '' or mem.duplex is None:
_data.tx_freq.set_value(rxf)
elif mem.duplex == '+':
_data.tx_freq.set_value(rxf + txf)
elif mem.duplex == '-':
_data.tx_freq.set_value(rxf - txf)
else:
_data.tx_freq.set_value(txf)
######################################################################
if ENABLE_DANGEROUS_EXPERIMENTAL_FEATURES:
if mem.duplex != 'split':
_data.experimental_duplex_mode_indicator.set_value(0)
else:
_data.experimental_duplex_mode_indicator.set_value(1)
######################################################################
# tone data
tonedata = chirp_common.split_tone_encode(mem)
for i in range(2):
dihl = unparse_tone(tonedata[i])
if dihl is not None:
_data.tone[i].digital.set_value(dihl[0])
_data.tone[i].invert.set_value(dihl[1])
_data.tone[i].high.set_value(dihl[2])
_data.tone[i].low.set_value(dihl[3])
else:
_data.tone[i].digital.set_value(1)
_data.tone[i].invert.set_value(1)
_data.tone[i].high.set_value(0x3f)
_data.tone[i].low.set_value(0xff)
######################################################################
if ENABLE_DANGEROUS_EXPERIMENTAL_FEATURES:
if mem.tmode == 'Cross' and mem.cross_mode in ['Tone->',
'Tone->Tone',
'DTCS->DTCS']:
_data.experimental_cross_mode_indicator.set_value(0)
else:
_data.experimental_cross_mode_indicator.set_value(1)
######################################################################
# transmit mode and power level
_data.modulation_width.set_value(MODES.index(mem.mode))
if str(mem.power) == 'High':
_data.txpower.set_value(1)
else:
_data.txpower = 0
def get_settings(self):
_model = self._memobj.mem.model_information
_settings = self._memobj.mem.opt_settings
_ptt_id_data = self._memobj.mem.ptt_id_data
_msk_settings = self._memobj.mem.msk_settings
_dtmf_settings = self._memobj.mem.dtmf_settings
_5tone_settings = self._memobj.mem.five_tone_settings
_broadcast = self._memobj.mem.fm_radio
# for safety reasons we are showing these as read-only
model_unit_settings = [
integer_setting("vhflo", "VHF lower bound",
_model.band_limits[0].lower_freq,
134, 176,
int_from_mem=lambda x:int(int(x)/10),
mem_from_int=None),
integer_setting("vhfhi", "VHF upper bound",
_model.band_limits[0].upper_freq,
134, 176,
int_from_mem=lambda x:int(int(x)/10),
mem_from_int=None),
integer_setting("uhflo", "UHF lower bound",
_model.band_limits[1].lower_freq,
400, 480,
int_from_mem=lambda x:int(int(x)/10),
mem_from_int=None),
integer_setting("uhfhi", "UHF upper bound",
_model.band_limits[1].upper_freq,
400, 480,
int_from_mem=lambda x:int(int(x)/10),
mem_from_int=None),
ff_string_setting("model", "Model string",
_model.model_string,
0, 6)
]
for s in model_unit_settings:
s.value.set_mutable(False)
model_unit_settings.append(ff_string_setting(
"info", "Unit Information",
self._memobj.mem.radio_information_string,
0, 16))
# tx/rx related settings
radio_channel_settings = [
list_setting("vfostep", "VFO step size",
_settings.vfo_step,
VFO_STRIDE),
list_setting("abwatch", "Main watch",
_settings.main_watch,
AB),
list_setting("watchmade", "Watch mode",
_settings.main_watch,
WATCH_MODES),
list_setting("amode", "A mode",
_settings.workmode_a,
AB_MODES),
list_setting("bmode", "B mode",
_settings.workmode_b,
AB_MODES),
integer_setting("achan", "A channel index",
_settings.channel_a,
1, 128,
int_from_mem=lambda i:i+1,
mem_from_int=lambda i:i-1),
integer_setting("bchan", "B channel index",
_settings.channel_b,
1, 128,
int_from_mem=lambda i:i+1,
mem_from_int=lambda i:i-1),
integer_setting("pchan", "Priority channel index",
_settings.priority_channel,
1, 128, int_from_mem=lambda i:i+1,
mem_from_int=lambda i:i-1),
list_setting("cactive", "Call channel active?",
_settings.call_channel_active,
NO_YES),
list_setting("scanm", "Scan mode",
_settings.scan_mode,
SCAN_MODES),
list_setting("swait", "Wait time",
_settings.wait_time,
WAIT_TIMES),
# it is unclear what this option below does,
# possibly squelch tail elimination?
list_setting("tail", "Relay without disable tail (?)",
_settings.relay_without_disable_tail,
NO_YES),
list_setting("batsav", "Battery saving mode",
_settings.battery_save,
OFF_ON),
]
# user interface related settings
interface_settings = [
list_setting("sidehold", "Side button hold action",
_settings.side_button_hold_mode,
BUTTON_MODES),
list_setting("sideclick", "Side button click action",
_settings.side_button_click_mode,
BUTTON_MODES),
list_setting("bootmt", "Boot message type",
_settings.boot_message_mode,
BOOT_MESSAGE_TYPES),
ff_string_setting("bootm", "Boot message",
_settings.boot_message,
0, 6),
list_setting("beep", "Key beep",
_settings.key_beep,
OFF_ON),
list_setting("talkback", "Menu talkback",
_settings.voice_announce,
TALKBACK),
list_setting("sidetone", "DTMF sidetone",
_settings.dtmf_sidetone,
OFF_ON),
list_setting("roger", "Roger beep",
_settings.use_roger_beep,
ROGER_BEEP),
list_setting("backlm", "Backlight mode",
_settings.backlight_mode,
BACKLIGHT_MODES),
list_setting("backlc", "Backlight color",
_settings.backlight_color,
BACKLIGHT_COLORS),
integer_setting("squelch", "Squelch level",
_settings.squelch_level,
0, 9),
list_setting("voxg", "Vox gain",
_settings.vox_gain,
VOX_GAIN),
list_setting("voxd", "Vox delay",
_settings.vox_delay,
VOX_DELAYS),
list_setting("txal", "Trinsmit time alarm",
_settings.tx_timeout,
TRANSMIT_ALARMS),
]
# settings related to tone/data sending and interpretation
data_general_settings = [
list_setting("disptt", "Display PTT ID",
_settings.dis_ptt_id,
NO_YES),
list_setting("pttidt", "PTT ID signal type",
_settings.ptt_id_type,
DATA_MODES)
]
data_msk_settings = [
ff_string_setting("bot", "MSK PTT ID (BOT)",
_ptt_id_data[0].entry,
0, 6, autowrite=False),
ff_string_setting("eot", "MSK PTT ID (EOT)",
_ptt_id_data[1].entry,
0, 6, autowrite=False),
ff_string_setting("id", "MSK ID code",
_msk_settings.id_code,
0, 4, charset=HEXADECIMAL),
list_setting("mskr", "MSK reverse",
_settings.msk_reverse,
NO_YES)
]
data_dtmf_settings = [
dtmf_string_setting("bot", "DTMF PTT ID (BOT)",
_ptt_id_data[0].entry,
_ptt_id_data[0].length,
0, 8, autowrite=False),
dtmf_string_setting("eot", "DTMF PTT ID (EOT)",
_ptt_id_data[1].entry,
_ptt_id_data[1].length,
0, 8, autowrite=False),
dtmf_string_setting("id", "DTMF ID code",
_dtmf_settings.id_code,
_dtmf_settings.id_code_length,
3, 8),
integer_setting("time", "Digit time (ms)",
_dtmf_settings.timing.digit_length,
50, 200, step=10,
int_from_mem=lambda x:x*10,
mem_from_int=lambda x:int(x/10)),
integer_setting("pause", "Inter digit time (ms)",
_dtmf_settings.timing.digit_length,
50, 200, step=10,
int_from_mem=lambda x:x*10,
mem_from_int=lambda x:int(x/10)),
integer_setting("time1", "First digit time (ms)",
_dtmf_settings.timing.digit_length,
50, 200, step=10,
int_from_mem=lambda x:x*10,
mem_from_int=lambda x:int(x/10)),
integer_setting("pause1", "First digit delay (ms)",
_dtmf_settings.timing.digit_length,
100, 1000, step=50,
int_from_mem=lambda x:x*50,
mem_from_int=lambda x:int(x/50)),
list_setting("arst", "Auto reset time",
_dtmf_settings.reset_time,
DTMF_TONE_RESET_TIME),
list_setting("grp", "Group code",
_dtmf_settings.group_code,
DTMF_GROUPS),
dtmf_string_setting("stunt", "TX Stun code",
_dtmf_settings.tx_stun_code,
_dtmf_settings.tx_stun_code_length,
3, 8),
dtmf_string_setting("cstunt", "TX Stun cancel code",
_dtmf_settings.cancel_tx_stun_code,
_dtmf_settings.cancel_tx_stun_code_length,
3, 8),
dtmf_string_setting("stunrt", "RX/TX Stun code",
_dtmf_settings.rxtx_stun_code,
_dtmf_settings.rxtx_stun_code_length,
3, 8),
dtmf_string_setting("cstunrt", "RX/TX Stun cancel code",
_dtmf_settings.cancel_rxtx_stun_code,
_dtmf_settings.cancel_rxtx_stun_code_length,
3, 8),
list_setting("altr", "Alert/Transpond",
_dtmf_settings.alert_transpond,
DTMF_ALERT_TRANSPOND),
]
data_5tone_settings = [
five_tone_string_setting("bot",
"5-Tone PTT ID (BOT)",
_ptt_id_data[0].entry,
autowrite=False),
five_tone_string_setting("eot",
"5-Tone PTT ID (EOT)",
_ptt_id_data[1].entry,
autowrite=False),
five_tone_string_setting("id",
"5-tone ID code",
_5tone_settings.id_code),
list_setting("arst", "Auto reset time",
_5tone_settings.reset_time,
TONE_RESET_TIME),
five_tone_string_setting("stunt",
"TX Stun code",
_5tone_settings.tx_stun_code),
five_tone_string_setting("cstunt",
"TX Stun cancel code",
_5tone_settings.cancel_tx_stun_code),
five_tone_string_setting("stunrt",
"RX/TX Stun code",
_5tone_settings.rxtx_stun_code),
five_tone_string_setting("cstunrt",
"RX/TX Stun cancel code",
_5tone_settings.cancel_rxtx_stun_code),
list_setting("altr", "Alert/Transpond",
_5tone_settings.alert_transpond,
FIVE_TONE_ALERT_TRANSPOND),
list_setting("std", "5-Tone standard",
_5tone_settings.tone_standard,
FIVE_TONE_STANDARDS),
]
for i in range(4):
s = ['z1', 'z2', 'c1', 'ct'][i]
l = FIVE_TONE_STANDARDS[i]
data_5tone_settings.append(
settings.RadioSettingGroup(
s, '%s settings' % l,
integer_setting("%speriod" % s, "%s Period (ms)" % l,
_5tone_settings.tone_settings[i].period,
20, 255),
list_setting("%sgrp" % s, "%s Group code" % l,
_5tone_settings.tone_settings[i].group_code,
HEXADECIMAL),
list_setting("%srpt" % s, "%s Repeat code" % l,
_5tone_settings.tone_settings[i].repeat_code,
HEXADECIMAL)))
data_msk_call_list = []
data_dtmf_call_list = []
data_5tone_call_list = []
for i in range(9):
j = i+1
data_msk_call_list.append(
ff_string_setting("ce%d" % i,
"MSK call entry %d" % j,
_msk_settings.phone_book[i].entry,
0, 4,
charset=HEXADECIMAL))
data_dtmf_call_list.append(
dtmf_string_setting("ce%d" % i,
"DTMF call entry %d" % j,
_dtmf_settings.phone_book[i].entry,
_dtmf_settings.phone_book[i].length,
0, 10))
data_5tone_call_list.append(
five_tone_string_setting("ce%d" % i,
"5-Tone call entry %d" % j,
_5tone_settings.phone_book[i].entry)),
data_settings = data_general_settings
data_settings.extend([
settings.RadioSettingGroup("MSK_s", "MSK settings",
*data_msk_settings),
settings.RadioSettingGroup("MSK_c", "MSK call list",
*data_msk_call_list),
settings.RadioSettingGroup("DTMF_s", "DTMF settings",
*data_dtmf_settings),
settings.RadioSettingGroup("DTMF_c", "DTMF call list",
*data_dtmf_call_list),
settings.RadioSettingGroup("5-Tone_s", "5-tone settings",
*data_5tone_settings),
settings.RadioSettingGroup("5-Tone_c", "5-tone call list",
*data_5tone_call_list)
])
# settings related to the various ways the radio can be locked down
locking_settings = [
list_setting("autolock", "Automatic timed keypad lock",
_settings.auto_keylock,
OFF_ON),
list_setting("lockon", "Current status of keypad lock",
_settings.keypad_lock,
INACTIVE_ACTIVE),
list_setting("nokeypad", "Disable keypad",
_settings.allow_keypad,
YES_NO),
list_setting("rxstun", "Disable receiver (rx stun)",
_settings.rx_stun,
NO_YES),
list_setting("txstun", "Disable transmitter (tx stun)",
_settings.tx_stun,
NO_YES),
]
# broadcast FM radio settings
broadcast_settings = [
list_setting("band", "Frequency interval",
_broadcast.receive_range,
BFM_BANDS),
list_setting("stride", "VFO step",
_broadcast.channel_stepping,
BFM_STRIDE),
frequency_setting("vfo", "VFO frequency (MHz)",
_broadcast.vfo_freq)
]
for i in range(10):
broadcast_settings.append(
frequency_setting("bcd%d" % i, "Memory %d frequency" % i,
_broadcast.memory[i].entry))
return settings.RadioSettings(
settings.RadioSettingGroup("model", "Model/Unit information",
*model_unit_settings),
settings.RadioSettingGroup("radio", "Radio/Channel settings",
*radio_channel_settings),
settings.RadioSettingGroup("interface", "Interface",
*interface_settings),
settings.RadioSettingGroup("data", "Data",
*data_settings),
settings.RadioSettingGroup("locking", "Locking",
*locking_settings),
settings.RadioSettingGroup("broadcast",
"Broadcast FM radio settings",
*broadcast_settings)
)
def set_settings(self, s, parent=''):
# The helper classes take care of all settings except these below,
# since it is a single instance of settings having interdependencies,
# i.e., which value that gets written to the memory depends on
# the value of another setting. The value of the ptt id type setting
# decides which of the msk/dtmf/5-tone ptt id strings are
# actually written to memory.
ds = sbyn(s, 'data')
idts = sbyn(ds, 'pttidt').value
idtv = idts.get_value()
cs = sbyn(ds, idtv+'_s')
tss = [sbyn(cs, e).value for e in ['bot', 'eot']]
for ts in tss:
ts.write_mem()
chirp-20261030/chirp/drivers/radioddity_db40g.py 0000644 0001750 0001750 00000032365 15157207431 020321 0 ustar hibby hibby # Copyright 2026 Tony Gies
#
# 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 2 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
#
# 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 2 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
#
# 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 2 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
import logging
import struct
from chirp import (
bitwise,
chirp_common,
directory,
errors,
memmap,
util,
)
from chirp.settings import (
RadioSetting,
RadioSettingGroup,
RadioSettings,
RadioSettingValueBoolean,
RadioSettingValueInteger,
RadioSettingValueList,
RadioSettingValueString,
RadioSettingValueMap,
RadioSettingValueFloat,
InvalidValueError
)
LOG = logging.getLogger(__name__)
# 'True' or 'False'
# True unlocks:
# - FM preset
# - Channel memory # preset
# - Killswitch (with revive killed radios)
# - Bands settings
# - Disable radio identification string verification
# (good to recover from a bad state)
RT490_EXPERIMENTAL = True
MEM_FORMAT_RT490 = """
struct { // Memory settings
lbcd rxfreq[4];
lbcd txfreq[4];
ul16 rxtone;
ul16 txtone;
u8 signal; // int 0->14, Signal 1->15
u8 pttid; // ['OFF', 'BOT', 'EOT', 'Both']
u8 dcp:4, // What is DCP ? FHSS ? DC-FHSS ??? TODO
power:4; // POWER_LEVELS
u8 unknown3_0:1, // Used by the driver to store AM/NAM flag
// (thank you Radtel for free space)
narrow:1, // bool true=NFM false=FM (col[7] a)
unknown3_1:1,
unknown3_2:1,
bcl:1, // bool (col[9] a2)
scan:1, // bool (col[10] a3)
tx_enable:1, // bool (col[1] a4)
learn:1; // bool ??? TODO (col[14] a5)
} memory[%(memsize)d];
// #seekto 0x1000; // Memory names (@4096)
struct {
char name[12];
u8 ffpad[4];
} memname[%(memsize)d];
// #seekto 0x2000; // GOOD DCP keys ??? TODO ?? (@8192)
struct {
u8 code[4];
} memcode[%(memsize)d]; // up to @x2400
// Filled with xFF during download (=> no need to
// fill with xFF), ready to upload
#seekto 0x3400; // Custom ANI Names (@13312)
struct {
char name[10];
u8 ffpad[6];
} custom_ani_names[10];
// Filled with xFF during download (=> no need to
// fill with xFF), ready to upload
#seekto 0x3500; // ANI Codes (@13568)
struct {
u8 anicode[6];
u8 ffpad[10];
} anicodes[60];
// Filled with xFF during download (=> no need to
// fill with xFF), ready to upload
#seekto 0x3900; // Custom channel names (@14592)
struct {
char name[10];
u8 ffpad[6];
} custom_channel_names[10];
// Filled with xFF during download (=> no need to
// fill with xFF), ready to upload
#seekto 0x3A00; // Settings (@14848)
struct {
u8 squelch; // 0: int 0 -> 9
u8 savemode; // 1: ['OFF', 'Normal', 'Super', 'Deep']
u8 vox; // 2: off=0, 1 -> 9
u8 backlight; // 3: ['OFF', '5s', '15s', '20s', '30s', '1m',
// '2m', '3m']
u8 tdr; // 4: bool
u8 timeout; // 5: n*30seconds, 0-240s
u8 beep; // 6: bool
u8 voice; // 7: bool
u8 byte_not_used_10; // 8: Always 1
u8 dtmfst; // 9: ['OFF', 'KB Side Tone', 'ANI Side Tone',
// 'KB ST + ANI ST']
u8 scanmode; // 10: ['TO', 'CO', 'SE']
u8 pttid; // 11: ['OFF', 'BOT', 'EOT', 'Both']
u8 pttiddelay; // 12: ['0', '100ms', '200ms', '400ms', '600ms',
// '800ms', '1000ms']
u8 cha_disp; // 13: ['Name', 'Freq', 'Channel ID']
u8 chb_disp; // 14: ['Name', 'Freq', 'Channel ID']
u8 bcl; // 15: bool
u8 autolock; // 0: ['OFF', '5s', '10s', 15s']
u8 alarm_mode; // 1: ['Site', 'Tone', 'Code']
u8 alarmsound; // 2: bool
u8 txundertdr; // 3: ['OFF', 'A', 'B']
u8 tailnoiseclear; // 4: [off, on]
u8 rptnoiseclear; // 5: n*100ms, 0-1000
u8 rptnoisedelay; // 6: n*100ms, 0-1000
u8 roger; // 7: bool
u8 active_channel; // 8: 0 or 1
u8 fmradio; // 9: boolean, inverted
u8 workmodeb:4, // 10:up ['VFO', 'CH Mode']
workmodea:4; // 10:down ['VFO', 'CH Mode']
u8 kblock; // 11: bool // TODO TEST WITH autolock
u8 powermsg; // 12: 0=Image / 1=Voltage
u8 byte_not_used_21; // 13: Always 0
u8 rpttone; // 14: ['1000Hz', '1450Hz', '1750Hz', '2100Hz']
u8 byte_not_used_22; // 15: pad with xFF
u8 vox_delay; // 0: [str(float(a)/10)+'s' for a in range(5,21)]
// '0.5s' to '2.0s'
u8 timer_menu_quit; // 1: ['5s', '10s', '15s', '20s', '25s', '30s',
// '35s', '40s', '45s', '50s', '60s']
u8 byte_not_used_30; // 2: pad with xFF
u8 byte_not_used_31; // 3: pad with xFF
u8 enable_killsw; // 4: bool
u8 display_ani; // 5: bool
u8 byte_not_used_32; // 6: pad with xFF
u8 enable_gps; // 7: bool
u8 scan_dcs; // 8: ['All', 'Receive', 'Transmit']
u8 ani_id; // 9: int 0-59 (ANI 1-60)
u8 rx_time; // 10: bool
u8 ffpad0[5]; // 11: Pad xFF
u8 cha_memidx; // 0: Memory index when channel A use memories
u8 byte_not_used_40;
u8 chb_memidx; // 2: Memory index when channel B use memories
u8 byte_not_used_41;
u8 ffpad1[10];
ul16 fmpreset;
} settings;
// Filled with xFF during download (=> no need to
// fill with xFF), ready to upload
struct settings_vfo_chan {
u8 rxfreq[8]; // 0
ul16 rxtone; // 8
ul16 txtone; // 10
ul16 byte_not_used0; // 12 Pad xFF
u8 sftd:4, // 14 Shift dir ['OFF', '+', '-']
signal:4; // 14 int 0->14, Signal 1->15
u8 byte_not_used1; // 15 Pad xFF
u8 power; // 16:0 POWER_LEVELS
u8 fhss:4, // 17 ['OFF', 'FHSS 1', 'FHSS 2', 'FHSS 3',
// 'FHSS 4']
narrow:4; // 17 bool true=NFM false=FM
u8 byte_not_used2; // 18 Pad xFF but received 0x00 ???
u8 freqstep; // 19:3 ['2.5 KHz', '5.0 KHz', '6.25 KHz',
// '10.0 KHz', '12.5 KHz', '20.0 KHz',
// '25.0 KHz', '50.0 KHz']
u8 byte_not_used3; // 20:4 Pad xFF but received 0x00 ??? TODO
u8 offset[6]; // 21:5 Freq NN.NNNN (without the dot) TEST TEST
u8 byte_not_used4; // 27:11 Pad xFF
u8 byte_not_used5; // 28 Pad xFF
u8 byte_not_used6; // 29 Pad xFF
u8 byte_not_used7; // 30 Pad xFF
u8 byte_not_used8; // 31:15 Pad xFF
};
// #seekto 0x3A40; // VFO A/B (@14912)
struct {
struct settings_vfo_chan vfo_a;
struct settings_vfo_chan vfo_b;
} settings_vfo;
// #seekto 0x3A80; // Side keys settings (@14976)
struct { // Values from Radio
u8 pf2_short; // { '7': 'FM', '10': 'Tx Power', '28': 'Scan',
// '29': 'Search, '1': 'PPT B' }
u8 pf2_long; // { '7': 'FM', '10': 'Tx Power', '28': 'Scan',
// '29': 'Search' }
u8 pf3_short; // {'7': 'FM', '10': 'Tx Power', '28': 'Scan',
// '29': 'Search'}
u8 ffpad; // Pad xFF
} settings_sidekeys;
struct dtmfcode {
u8 code[5]; // 5 digits DTMF
u8 ffpad[11]; // Pad xFF
};
// Filled with xFF during download (=> no need to
// fill with xFF), ready to upload
#seekto 0x3B00; // DTMF (@15104)
struct dtmfcode settings_dtmfgroup[15];
struct { // @15296+3x16
u8 byte_not_used1; // 0: Pad xFF something here
u8 byte_not_used2; // 1: Pad xFF something here
u8 byte_not_used3; // 2: Pad xFF something here
u8 byte_not_used4; // 3: Pad xFF
u8 byte_not_used5; // 4: Pad xFF
u8 unknown_dtmf; // 5: 0 TODO ???? wtf is alarmcode/alarmcall TODO
u8 pttid; // 6: [off, BOT, EOT, Both]
u8 dtmf_speed_on; // 7: ['50ms', '100ms', '200ms', '300ms', '500ms']
u8 dtmf_speed_off; // 8:0 ['50ms', '100ms', '200ms', '300ms', '500ms']
} settings_dtmf;
// Filled with xFF during download (=> no need to
// fill with xFF), ready to upload
#seekto 0x3C00; // DTMF Kill/ReLive Codes (@15360)
struct {
u8 kill_dtmf[6]; // 0: Kill DTMF
u8 ffpad1[2]; // Pad xFF
u8 revive_dtmf[6]; // 8: Revive DTMF
u8 ffpad2[2]; // Pad xFF
} settings_killswitch;
// Some unknown data between 0x3E00 and 0x3F00
#seekto 0x3F80; // Hmm hmm
struct {
u8 unknown_data_0[16];
u8 language;
u8 active; // Bool radio killed (killed=0, active=1)
u8 unknown_data_2[46];
} management_settings;
struct band {
u8 enable; // 0 bool / enable-disable Tx on band
bbcd freq_low[2]; // 1 lowest band frequency
bbcd freq_high[2]; // 3 highest band frequency
};
// #seekto 0x3FC0; // Bands settings (@16320)
struct {
struct band band136; // 0 Settings for 136MHz band
struct band band400; // 5 Settings for 400MHz band
struct band band200; // 10 Settings for 200MHz band
u8 byte_not_used1; // 15
struct band band350; // 0 Settings for 350MHz band
u8 byte_not_used2[43]; // 5
} settings_bands;
"""
CMD_ACK = b"\x06"
DTCS_CODES = tuple(sorted(chirp_common.DTCS_CODES + (645,)))
DTMFCHARS = '0123456789ABCD*#'
def _enter_programming_mode(radio):
serial = radio.pipe
exito = False
for i in range(0, 5):
serial.write(radio._magic)
ack = serial.read(1)
try:
if ack == CMD_ACK:
exito = True
break
except Exception:
LOG.debug("Attempt #%s, failed, trying again" % i)
pass
# check if we had EXITO
if exito is False:
if not ack:
raise errors.RadioNoResponse()
msg = "The radio did not accept program mode after five tries.\n"
msg += "Check you interface cable and power cycle your radio."
raise errors.RadioError(msg)
try:
serial.write(b"F")
ident = serial.read(8)
except Exception:
raise errors.RadioError("Error communicating with radio")
if not ident.startswith(radio._fingerprint) and not RT490_EXPERIMENTAL:
LOG.debug(util.hexprint(ident))
raise errors.RadioError("Radio returned unknown identification string")
def _exit_programming_mode(radio):
serial = radio.pipe
try:
serial.write(b"E")
except Exception:
raise errors.RadioError("Radio refused to exit programming mode")
def _read_block(radio, block_addr, block_size):
serial = radio.pipe
cmd = struct.pack(">cHb", b'R', block_addr, block_size)
expectedresponse = b"R" + cmd[1:]
LOG.debug("Reading block %04x..." % (block_addr))
try:
serial.write(cmd)
response = serial.read(4 + block_size)
if response[:4] != expectedresponse:
raise Exception("Error reading block %04x." % (block_addr))
block_data = response[4:]
except Exception:
raise errors.RadioError("Failed to read block at %04x" % block_addr)
return block_data
def _write_block(radio, block_addr, block_size):
serial = radio.pipe
cmd = struct.pack(">cHb", b'W', block_addr, block_size)
data = radio.get_mmap()[block_addr:block_addr + block_size]
LOG.debug("Writing Data:")
LOG.debug(util.hexprint(cmd + data))
try:
serial.write(cmd + data)
if serial.read(1) != CMD_ACK:
raise Exception("No ACK")
except Exception:
raise errors.RadioError("Failed to send block "
"to radio at %04x" % block_addr)
def do_download(radio):
LOG.debug("download")
_enter_programming_mode(radio)
data = b""
status = chirp_common.Status()
status.msg = "Cloning from radio"
status.cur = 0
status.max = radio._memsize
for addr in range(0, radio._memsize, radio.BLOCK_SIZE):
status.cur = addr + radio.BLOCK_SIZE
radio.status_fn(status)
block = _read_block(radio, addr, radio.BLOCK_SIZE)
data += block
LOG.debug("Address: %04x" % addr)
LOG.debug(util.hexprint(block))
_exit_programming_mode(radio)
return memmap.MemoryMapBytes(data)
def do_upload(radio):
status = chirp_common.Status()
status.msg = "Uploading to radio"
_enter_programming_mode(radio)
status.cur = 0
status.max = radio._memsize
for start_addr, end_addr in radio._ranges:
for addr in range(start_addr, end_addr, radio.BLOCK_SIZE):
status.cur = addr + radio.BLOCK_SIZE
radio.status_fn(status)
_write_block(radio, addr, radio.BLOCK_SIZE)
_exit_programming_mode(radio)
@directory.register
class RT490Radio(chirp_common.CloneModeRadio):
"""RADTEL RT-490"""
VENDOR = "Radtel"
MODEL = "RT-490"
BLOCK_SIZE = 0x40 # 64 bytes
BAUD_RATE = 9600
POWER_LEVELS = [chirp_common.PowerLevel("H", watts=5.00),
chirp_common.PowerLevel("L", watts=3.00)]
# magic = progmode + modelType + garbage (works with any last char)
_magic = b"PROGROMJJCCU"
# fingerprint is default band ranges of the radio
# the driver can change band ranges and fingerprint will
# change accordingly, so it is not used to verify radio id.
_fingerprint = b"\x01\x36\x01\x80\x04\x00\x05\x20"
# Ranges of memory used when uploading data to radio
# same as official software
_ranges = [
(0x0000, 0x2400),
(0x3400, 0x3C40),
(0x3FC0, 0x4000)
]
def filter_name(self, name):
return name.encode('gb2312')[:12].decode('gb2312', errors='replace')
if RT490_EXPERIMENTAL:
# Experimental driver (already heavily tested)
_ranges = [(0x0000, 0x2400), (0x3400, 0x3C40), (0x3F80, 0x4000)]
# Danger zone
# _ranges = [(0x0000, 0x2500), (0x3400, 0x3C40), (0x3E00, 0x4000)]
# 16KB of memory, download read everything
# same as official software (remark: loops if overread :))
_memsize = 16384
POWER_LEVELS_LIST = [str(i) for i in POWER_LEVELS]
FHSS_LIST = ['OFF', 'ENCRYPT 1', 'ENCRYPT 2', 'ENCRYPT 3', 'ENCRYPT 4']
DCP_LIST = ['OFF', 'DCP1', 'DCP2', 'DCP3', 'DCP4'] # Same as FHSS ?
# # Seems yes
TUNING_STEPS = [2.5, 5.0, 6.25, 10.0, 12.5, 20.0, 25.0, 50.0]
TUNING_STEPS_LIST = [str(i)+' KHz' for i in TUNING_STEPS]
SIGNAL = [str(i) for i in range(1, 16)]
PTTID = ['OFF', 'BOT', 'EOT', 'Both']
PTTIDDELAYS = ['0', '100ms', '200ms', '400ms', '600ms', '800ms', '1000ms']
DTMF_SPEEDS = ['50ms', '100ms', '200ms', '300ms', '500ms']
SIDEKEY_VALUEMAP = [('FM', 7), ('Tx Power', 10), ('Scan', 28),
('Search', 29), ('PTT B', 1)]
KEY_CHARS = '0123456789ABCDEF'
FULL_CHARSET_ASCII = ("".join([chr(x) for x in range(ord(" "),
ord("~") + 1)] + [chr(x) for x in range(128, 255)] +
[chr(0)]))
VFO_SFTD = ['OFF', '+', '-']
WORKMODES = ['VFO', 'Memory Mode']
SAVEMODES = ['OFF', 'Normal', 'Super', 'Deep']
DISPLAYMODES = ['Name', 'Freq', 'Memory ID']
SCANMODES = ['TO', 'CO', 'SE']
ALARMMODES = ['On Site', 'Send Sound', 'Send Code']
TDRTXMODES = ['OFF', 'A', 'B']
SCANDCSMODES = ['All', 'Receive', 'Transmit']
POWERMESSAGES = ['Image', 'Voltage']
FMRADIO = ['ON', 'OFF']
ENABLERADIO = ['Killed', 'Active']
CHANNELS = ['A', 'B']
TOT_LIST = ['OFF'] + [str(i*30) + "s" for i in range(1, 9)]
VOX_LIST = ['OFF'] + [str(i) for i in range(1, 9)]
BACKLIGHT_TO = ['OFF', '5s', '10s', '15s', '20s', '30s', '1m', '2m', '3m']
AUTOLOCK_TO = ['OFF', '5s', '10s', '15s']
MENUEXIT_TO = ['5s', '10s', '15s', '20s', '25s', '30s', '35s', '40s',
'45s', '50s', '60s']
SQUELCHLVLS = [str(i) for i in range(10)]
ANI_IDS = [str(i+1) for i in range(60)]
VOXDELAYLIST = [str(float(a)/10)+'s' for a in range(5, 21)]
DTMFSTLIST = ['OFF', 'DT Side Tone', 'ANI Side Tone', 'DT ST + ANI ST']
RPTTONES = ['1000Hz', '1450Hz', '1750Hz', '2100Hz']
RPTNOISE = [str(a)+'s' for a in range(11)]
_memory_size = _upper = 256 # Number of memory slots
_mem_params = (_upper-1)
_frs = _murs = _pmr = _gmrs = True
def set_settings(self, settings):
for element in settings:
if not isinstance(element, RadioSetting):
self.set_settings(element)
continue
else:
self._set_setting(element)
def _set_setting(self, setting): # WIP
_mem = self._memobj
key = setting.get_name()
val = setting.value
if key.startswith('dummy'):
return
elif key.startswith('settings_dtmfgroup.'):
if str(val) == "":
setattr(_mem.settings_dtmfgroup[int(key.split('@')[1])-1],
'code', [0xFF]*5)
else:
tmp = [DTMFCHARS.index(c) for c in str(val)]
tmp += [0xFF] * (5 - len(tmp))
setattr(_mem.settings_dtmfgroup[int(key.split('@')[1])-1],
'code', tmp)
elif key.startswith('settings.'):
if key.endswith('_memidx'):
val = int(val) - 1
if key.endswith('fmpreset'):
tmp = val.get_value() * 10
setattr(_mem.settings, key.split('.')[1], tmp)
else:
setattr(_mem.settings, key.split('.')[1], int(val))
elif key.startswith('settings_dtmf.'):
attr = key.split('.')[1]
setattr(_mem.settings_dtmf, attr, int(val))
if attr.startswith('pttid'):
setattr(_mem.settings, attr, int(val))
elif key.startswith('settings_sidekeys.'):
setattr(_mem.settings_sidekeys, key.split('.')[1], int(val))
elif key.startswith('settings_vfo.'): # TODO rx/tx tones
tmp = key.split('.')
attr = tmp[2]
vfo = tmp[1]
# LOG.debug(">>> PRE key '%s'" % key)
# LOG.debug(">>> PRE val '%s'" % val)
if attr.startswith('rxfreq'):
value = chirp_common.parse_freq(str(val)) / 10
for i in range(7, -1, -1):
_mem.settings_vfo[vfo].rxfreq[i] = value % 10
value /= 10
elif attr.startswith('offset'):
value = int(float(str(val)) * 10000)
for i in range(5, -1, -1):
_mem.settings_vfo[vfo].offset[i] = value % 10
value /= 10
else:
setattr(_mem.settings_vfo[vfo], attr, int(val))
elif key.startswith('settings_bands.'):
tmp = key.split('.')
attr = tmp[2]
band = tmp[1]
setattr(_mem.settings_bands[band], attr, int(val))
elif key.startswith('settings_killswitch.'):
attr = key.split('.')[1]
if attr.endswith('dtmf'):
if str(val) == "":
setattr(_mem.settings_killswitch, attr,
[0x01, 0x02, 0x01, 0x03, 0x01, 0x04])
else:
setattr(_mem.settings_killswitch, attr,
[DTMFCHARS.index(c) for c in str(val)])
elif attr.startswith('enable'):
setattr(_mem.settings_killswitch, attr, int(val))
else:
LOG.debug(">>> TODO key '%s'" % key)
LOG.debug(">>> TODO val '%s'" % val)
elif key.startswith('custom_') or key.startswith('anicode') \
or key.startswith('memcode'):
tmp = key.split('@')
if key.startswith('anicode'):
val = [DTMFCHARS.index(c) for c in str(val)]
val += [0xFF] * (6 - len(val))
for i in range(10):
_mem[str(tmp[0])][int(tmp[2])]["ffpad"][i] = 0xFF
elif key.startswith('memcode'):
if len(str(val)) > 0:
tmpp = str(val).zfill(6)
val = self._encode_key(tmpp)
else:
val = (0xFF, 0xFF, 0xFF, 0xFF)
if key.startswith('custom_'):
for i in range(6):
_mem[str(tmp[0])][int(tmp[2])]["ffpad"][i] = 0xFF
setattr(_mem[str(tmp[0])][int(tmp[2])], str(tmp[1]), val)
elif key.startswith('management_settings'):
setattr(_mem.management_settings, key.split('.')[1], int(val))
else:
LOG.debug(">>> TODO _set_setting key '%s'" % key)
LOG.debug(">>> TODO _set_setting val '%s'" % val)
def _get_settings_bands(self):
_mem = self._memobj
ret = RadioSettingGroup('bands', 'Bands')
bands = [('136', _mem.settings_bands.band136),
('200', _mem.settings_bands.band200),
('350', _mem.settings_bands.band350),
('400', _mem.settings_bands.band400)]
for label, band in bands:
rs = RadioSetting('settings_bands.band%s.enable' % label,
'Enable Band %s' % label,
RadioSettingValueBoolean(band.enable))
ret.append(rs)
rsi = RadioSettingValueInteger(1, 1000, band.freq_low)
# if label == '136' or label == '400':
# rsi.set_mutable(False)
rs = RadioSetting("settings_bands.band%s.freq_low" % label,
"Band %s Lower Limit (MHz) (EXPERIMENTAL)"
% label, rsi)
ret.append(rs)
rsi = RadioSettingValueInteger(1, 1000, band.freq_high)
# if label == '350':
# rsi.set_mutable(False)
rs = RadioSetting("settings_bands.band%s.freq_high" % label,
"Band %s Upper Limit (MHz) (EXPERIMENTAL)"
% label, rsi)
ret.append(rs)
return ret
def _get_settings_ks(self):
_mem = self._memobj
ret = RadioSettingGroup('killswitch', 'Killswitch')
# Kill Enable/Disable enable_killsw
rsvb = RadioSettingValueBoolean(_mem.settings.enable_killsw)
ret.append(RadioSetting('settings.enable_killsw',
'Enable Killswitch', rsvb))
# Kill DTMF
cur = ''.join(
DTMFCHARS[i]
for i in _mem.settings_killswitch.kill_dtmf if int(i) < 0xF)
ret.append(
RadioSetting('settings_killswitch.kill_dtmf', 'DTMF Kill',
RadioSettingValueString(6, 6, cur,
autopad=False,
charset=DTMFCHARS)))
# Revive DTMF
cur = ''.join(
DTMFCHARS[i]
for i in _mem.settings_killswitch.revive_dtmf if int(i) < 0xF)
ret.append(
RadioSetting('settings_killswitch.revive_dtmf', 'DTMF Revive',
RadioSettingValueString(6, 6, cur,
autopad=False,
charset=DTMFCHARS)))
# Enable/Disable entire radio
rs = RadioSettingValueString(0, 255, "Can be used to revive radio")
rs.set_mutable(False)
ret.append(RadioSetting('dummy', 'Factory reserved', rs))
tmp = 1 if int(_mem.management_settings.active) > 0 else 0
ret.append(RadioSetting('management_settings.active', 'Radio Status',
RadioSettingValueList(self.ENABLERADIO,
current_index=tmp)))
return ret
def _get_settings_dtmf(self):
_mem = self._memobj
dtmf = RadioSettingGroup('dtmf', 'DTMF')
# DTMF Group
msgs = ["Allowed chars (%s)" % DTMFCHARS,
"Input from 0 to 5 characters."
]
for msg in msgs:
rsvs = RadioSettingValueString(0, 255, msg, autopad=False)
rsvs.set_mutable(False)
rs = RadioSetting('dummy_dtmf_msg_%i' % msgs.index(msg),
'Input rule %i' % int(msgs.index(msg)+1), rsvs)
dtmf.append(rs)
for i in range(1, 16):
cur = ''.join(
DTMFCHARS[i]
for i in _mem.settings_dtmfgroup[i - 1].code if int(i) < 0xF)
dtmf.append(
RadioSetting(
'settings_dtmfgroup.code@%i' % i, 'PTT ID Code %i' % i,
RadioSettingValueString(0, 5, cur,
autopad=False,
charset=DTMFCHARS)))
# DTMF Speed (on time in ms)
dtmf_speed_on = int(_mem.settings_dtmf.dtmf_speed_on)
if dtmf_speed_on > len(self.DTMF_SPEEDS)-1:
_mem.settings_dtmf.dtmf_speed_on = 0
LOG.debug('DTMF Speed On overflow')
dtmf.append(
RadioSetting(
'settings_dtmf.dtmf_speed_on', 'DTMF Speed (on time in ms)',
RadioSettingValueList(self.DTMF_SPEEDS,
current_index=dtmf_speed_on)))
# DTMF Speed (on time in ms)
dtmf_speed_off = int(_mem.settings_dtmf.dtmf_speed_off)
if dtmf_speed_off > len(self.DTMF_SPEEDS)-1:
_mem.settings_dtmf.dtmf_speed_off = 0
LOG.debug('DTMF Speed Off overflow')
dtmf.append(
RadioSetting(
'settings_dtmf.dtmf_speed_off', 'DTMF Speed (off time in ms)',
RadioSettingValueList(self.DTMF_SPEEDS,
current_index=dtmf_speed_off)))
# PTT ID
pttid = int(_mem.settings_dtmf.pttid)
if pttid > len(self.PTTID)-1:
_mem.settings_dtmf.pttid = 0
LOG.debug('PTT ID overflow')
dtmf.append(
RadioSetting(
'settings_dtmf.pttid', 'Send DTMF Code (PTT ID)',
RadioSettingValueList(self.PTTID, current_index=pttid)))
# PTT ID Delay
pttiddelay = int(_mem.settings.pttiddelay)
if pttiddelay > len(self.PTTIDDELAYS)-1:
_mem.settings.pttiddelay = 0
LOG.debug('PTT ID Delay overflow')
rsvl = RadioSettingValueList(self.PTTIDDELAYS,
current_index=pttiddelay)
dtmf.append(RadioSetting('settings.pttiddelay',
'PTT ID Delay', rsvl))
rsvl = RadioSettingValueList(self.DTMFSTLIST,
current_index=_mem.settings.dtmfst)
dtmf.append(RadioSetting('settings.dtmfst',
'DTMF Side Tone (Required for GPS ID)', rsvl))
return dtmf
def _get_settings_sidekeys(self):
_mem = self._memobj
ret = RadioSettingGroup('sidekeys', 'Side Keys')
rsvm = RadioSettingValueMap(self.SIDEKEY_VALUEMAP,
_mem.settings_sidekeys.pf2_short)
ret.append(RadioSetting('settings_sidekeys.pf2_short',
'Side key 1 (PTT2) Short press', rsvm))
rsvm = RadioSettingValueMap(self.SIDEKEY_VALUEMAP[:-1],
_mem.settings_sidekeys.pf2_long)
ret.append(RadioSetting('settings_sidekeys.pf2_long',
'Side key 1 (PTT2) Long press', rsvm))
rsvm = RadioSettingValueMap(self.SIDEKEY_VALUEMAP[:-1],
_mem.settings_sidekeys.pf3_short)
ret.append(RadioSetting('settings_sidekeys.pf3_short',
'Side key 2 (PTT3) Short press', rsvm))
rs = RadioSettingValueString(0, 255, "MONI")
rs.set_mutable(False)
ret.append(RadioSetting('dummy', 'Side key 2 (PTT3) Long press', rs))
return ret
def _get_settings_vfo(self, vfo, chan): # WIP TODO Rx/Tx tones
_mem = self._memobj
ret = RadioSettingGroup('settings_vfo@%s' % chan.lower(),
'VFO %s Settings' % chan)
rsvl = RadioSettingValueList(self.WORKMODES,
current_index=_mem.settings[
'workmode'+chan.lower()])
ret.append(RadioSetting('settings.workmode%s' % chan.lower(),
'VFO %s Workmode' % chan, rsvl))
tmp = ''.join(DTMFCHARS[i] for i in _mem.settings_vfo[
'vfo_'+chan.lower()].rxfreq if i < 0xFF)
rsvf = RadioSettingValueFloat(66, 550, chirp_common.format_freq(
int(tmp) * 10), resolution=0.00001,
precision=5)
ret.append(RadioSetting('settings_vfo.vfo_%s.rxfreq' % chan.lower(),
'Rx Frequency', rsvf))
# TODO Rx/Tx tones
rsvl = RadioSettingValueList(self.VFO_SFTD,
current_index=_mem.settings_vfo[
'vfo_'+chan.lower()].sftd)
ret.append(RadioSetting('settings_vfo.vfo_%s.sftd' % chan.lower(),
'Freq offset direction', rsvl))
tmp = ''.join(DTMFCHARS[i] for i in _mem.settings_vfo[
'vfo_'+chan.lower()].offset if i < 0xFF)
rsvf = RadioSettingValueFloat(0, 99.9999, float(tmp) / 10000)
ret.append(RadioSetting('settings_vfo.vfo_%s.offset' % chan.lower(),
'Tx Offset', rsvf))
rsvl = RadioSettingValueList(self.SIGNAL,
current_index=_mem.settings_vfo[
'vfo_'+chan.lower()].signal)
ret.append(RadioSetting('settings_vfo.vfo_%s.signal' % chan.lower(),
'PTT ID Code (S-Code)', rsvl))
rsvl = RadioSettingValueList(self.POWER_LEVELS_LIST,
current_index=_mem.settings_vfo[
'vfo_'+chan.lower()].power)
ret.append(RadioSetting('settings_vfo.vfo_%s.power' % chan.lower(),
'Tx Power', rsvl))
rsvl = RadioSettingValueList(self.FHSS_LIST,
current_index=_mem.settings_vfo[
'vfo_'+chan.lower()].fhss)
ret.append(RadioSetting('settings_vfo.vfo_%s.fhss' % chan.lower(),
'FHSS (Encryption)', rsvl))
chanwidth = ['Wide', 'Narrow']
rsvl = RadioSettingValueList(
chanwidth,
current_index=int(_mem.settings_vfo['vfo_'+chan.lower()].narrow))
ret.append(RadioSetting('settings_vfo.vfo_%s.narrow' % chan.lower(),
'Wide / Narrow', rsvl))
rsvl = RadioSettingValueList(self.TUNING_STEPS_LIST,
current_index=_mem.settings_vfo[
'vfo_'+chan.lower()].freqstep)
ret.append(RadioSetting('settings_vfo.vfo_%s.freqstep' % chan.lower(),
'Tuning Step', rsvl))
return ret
def _get_custom_channel_names(self):
_mem = self._memobj
ret = RadioSettingGroup('ccn', 'Custom Channel Names')
msgs = ["Add custom chan names to radio",
"-> Menu 09 CH-NAME",
"Allowed chars (ASCII only)",
"Input from 0 to 10 characters."
]
for msg in msgs:
rsvs = RadioSettingValueString(0, 255, msg, autopad=False)
rsvs.set_mutable(False)
rs = RadioSetting('dummy_cnames_msg_%i' % msgs.index(msg),
'Input rule %i' % int(msgs.index(msg)+1), rsvs)
ret.append(rs)
for i in range(0, len(_mem.custom_channel_names)):
tmp = ''.join([str(j) for j in _mem.custom_channel_names[i].name
if ord(str(j)) < 0xFF and ord(str(j)) > 0x00])
rsvs = RadioSettingValueString(0, 10, tmp, autopad=True,
charset=self.FULL_CHARSET_ASCII)
ret.append(RadioSetting('custom_channel_names@name@%i' % i,
'Custom Channel Name (%i)' % i, rsvs))
return ret
def _get_custom_ani_names(self):
_mem = self._memobj
ret = RadioSettingGroup('can', 'Custom ANI Names')
msgs = ["Can be used as radio id in GPS.",
"Allowed chars (ASCII only)",
"Input from 0 to 10 characters."
]
for msg in msgs:
rsvs = RadioSettingValueString(0, 255, msg, autopad=False)
rsvs.set_mutable(False)
rs = RadioSetting('dummy_caninames_msg_%i' % msgs.index(msg),
'Input rule %i' % int(msgs.index(msg)+1), rsvs)
ret.append(rs)
for i in range(0, len(_mem.custom_ani_names)):
tmp = ''.join([str(j) for j in
_mem.custom_ani_names[i].name
if ord(str(j)) < 0xFF and ord(str(j)) > 0x00])
rsvs = RadioSettingValueString(0, 10, tmp, autopad=True,
charset=self.FULL_CHARSET_ASCII)
ret.append(RadioSetting('custom_ani_names@name@%i' % i,
'Custom ANI Name (%i)' % (i+51), rsvs))
return ret
def _get_anicodes(self):
_mem = self._memobj
ret = RadioSettingGroup('ani', 'ANI Codes')
split = len(_mem.anicodes) - len(_mem.custom_ani_names)
msgs = ["Allowed chars (%s)" % DTMFCHARS,
"Input from 0 to 6 characters."
]
for msg in msgs:
rsvs = RadioSettingValueString(0, 255, msg, autopad=False)
rsvs.set_mutable(False)
rs = RadioSetting('dummy_canic_msg_%i' % msgs.index(msg),
'Input rule %i' % int(msgs.index(msg)+1), rsvs)
ret.append(rs)
for i in range(0, split):
tmp = ''.join([DTMFCHARS[int(j)] for j in
_mem.anicodes[i].anicode if int(j) < 0xFF])
# LOG.debug("ANI Code (%i) '%s'" % (i, tmp))
rsvs = RadioSettingValueString(0, 6, tmp, autopad=False,
charset=DTMFCHARS)
ret.append(RadioSetting('anicodes@anicode@%i' % i,
'ANI-ID (%i) Code' % (i+1), rsvs))
for i in range(split, len(_mem.anicodes)):
tmp = ''.join([DTMFCHARS[int(j)] for j in
_mem.anicodes[i].anicode if int(j) < 0xFF])
tmp2 = ''.join([str(j) for j in
_mem.custom_ani_names[i-split].name
if ord(str(j)) < 0xFF and ord(str(j)) > 0x00])
# LOG.debug("ANI Code (%s) (%i) '%s'" % (tmp2, i, tmp))
rsvs = RadioSettingValueString(0, 6, tmp, autopad=False,
charset=DTMFCHARS)
ret.append(RadioSetting('anicodes@anicode@%i' % i,
'ANI-ID (%s) (%i) Code' % (tmp2, i+1), rsvs))
return ret
def _get_settings_adv(self):
_mem = self._memobj
ret = RadioSettingGroup('advanced', 'Advanced')
if RT490_EXPERIMENTAL:
rsvi = RadioSettingValueInteger(
1, self._memory_size, int(_mem.settings.cha_memidx)+1)
ret.append(RadioSetting("settings.cha_memidx",
"Channel A Memory index", rsvi))
rsvi = RadioSettingValueInteger(1, self._memory_size,
int(_mem.settings.chb_memidx)+1)
ret.append(RadioSetting("settings.chb_memidx",
"Channel B Memory index", rsvi))
ret.append(RadioSetting('settings.vox', 'VOX Sensitivity',
RadioSettingValueList(self.VOX_LIST,
current_index=_mem.settings.vox)))
ret.append(
RadioSetting(
'settings.vox_delay', 'VOX Delay',
RadioSettingValueList(
self.VOXDELAYLIST,
current_index=_mem.settings.vox_delay)))
ret.append(RadioSetting('settings.tdr', 'Dual Receive (TDR)',
RadioSettingValueBoolean(_mem.settings.tdr)))
ret.append(
RadioSetting(
'settings.txundertdr', 'Tx under TDR',
RadioSettingValueList(
self.TDRTXMODES,
current_index=_mem.settings.txundertdr)))
ret.append(RadioSetting('settings.voice', 'Menu Voice Prompts',
RadioSettingValueBoolean(_mem.settings.voice)))
ret.append(
RadioSetting(
'settings.scanmode', 'Scan Mode',
RadioSettingValueList(
self.SCANMODES, current_index=_mem.settings.scanmode)))
ret.append(RadioSetting('settings.bcl', 'Busy Channel Lockout',
RadioSettingValueBoolean(_mem.settings.bcl)))
ret.append(RadioSetting('settings.display_ani', 'Display ANI ID',
RadioSettingValueBoolean(_mem.settings.display_ani)))
ret.append(RadioSetting('settings.ani_id', 'ANI ID',
RadioSettingValueList(self.ANI_IDS,
current_index=_mem.settings.ani_id)))
ret.append(
RadioSetting(
'settings.alarm_mode', 'Alarm Mode',
RadioSettingValueList(
self.ALARMMODES,
current_index=_mem.settings.alarm_mode)))
ret.append(RadioSetting('settings.alarmsound', 'Alarm Sound',
RadioSettingValueBoolean(_mem.settings.alarmsound)))
ret.append(RadioSetting('settings.fmradio', 'Enable FM Radio',
RadioSettingValueList(self.FMRADIO,
current_index=_mem.settings.fmradio)))
if RT490_EXPERIMENTAL:
tmp = _mem.settings.fmpreset / 10.0
if tmp < 65.0 or tmp > 108.0:
tmp = 80.0
ret.append(RadioSetting("settings.fmpreset", "FM Radio Freq",
RadioSettingValueFloat(65, 108, tmp, resolution=0.1,
precision=1)))
ret.append(RadioSetting('settings.kblock', 'Enable Keyboard Lock',
RadioSettingValueBoolean(_mem.settings.kblock)))
ret.append(
RadioSetting(
'settings.autolock', 'Autolock Keyboard',
RadioSettingValueList(
self.AUTOLOCK_TO,
current_index=_mem.settings.autolock)))
ret.append(
RadioSetting(
'settings.timer_menu_quit', 'Menu Exit Time',
RadioSettingValueList(
self.MENUEXIT_TO,
current_index=_mem.settings.timer_menu_quit)))
ret.append(RadioSetting('settings.enable_gps', 'Enable GPS',
RadioSettingValueBoolean(_mem.settings.enable_gps)))
ret.append(
RadioSetting(
'settings.scan_dcs', 'CDCSS Save Modes',
RadioSettingValueList(
self.SCANDCSMODES,
current_index=_mem.settings.scan_dcs)))
ret.append(RadioSetting('settings.tailnoiseclear', 'Tail Noise Clear',
RadioSettingValueBoolean(_mem.settings.tailnoiseclear)))
ret.append(
RadioSetting(
'settings.rptnoiseclear', 'Rpt Noise Clear',
RadioSettingValueList(
self.RPTNOISE,
current_index=_mem.settings.rptnoiseclear)))
ret.append(
RadioSetting(
'settings.rptnoisedelay', 'Rpt Noise Delay',
RadioSettingValueList(
self.RPTNOISE,
current_index=_mem.settings.rptnoisedelay)))
ret.append(RadioSetting('settings.rpttone', 'Rpt Tone',
RadioSettingValueList(self.RPTTONES,
current_index=_mem.settings.rpttone)))
return ret
def _get_settings_basic(self):
_mem = self._memobj
ret = RadioSettingGroup('basic', 'Basic')
ret.append(RadioSetting('settings.squelch', 'Carrier Squelch Level',
RadioSettingValueList(self.SQUELCHLVLS,
current_index=_mem.settings.squelch)))
ret.append(
RadioSetting(
'settings.savemode', 'Battery Savemode',
RadioSettingValueList(
self.SAVEMODES, current_index=_mem.settings.savemode)))
ret.append(
RadioSetting(
'settings.backlight', 'Backlight Timeout',
RadioSettingValueList(
self.BACKLIGHT_TO,
current_index=_mem.settings.backlight)))
ret.append(RadioSetting('settings.timeout', 'Timeout Timer (TOT)',
RadioSettingValueList(self.TOT_LIST,
current_index=_mem.settings.timeout)))
ret.append(RadioSetting('settings.beep', 'Beep',
RadioSettingValueBoolean(_mem.settings.beep)))
ret.append(
RadioSetting(
'settings.active_channel', 'Active Channel',
RadioSettingValueList(
self.CHANNELS,
current_index=_mem.settings.active_channel)))
ret.append(
RadioSetting(
'settings.cha_disp', 'Channel A Display Mode',
RadioSettingValueList(
self.DISPLAYMODES,
current_index=_mem.settings.cha_disp)))
ret.append(
RadioSetting(
'settings.chb_disp', 'Channel B Display Mode',
RadioSettingValueList(
self.DISPLAYMODES,
current_index=_mem.settings.chb_disp)))
ret.append(RadioSetting('settings.roger', 'Roger Beep',
RadioSettingValueBoolean(_mem.settings.roger)))
ret.append(
RadioSetting(
'settings.powermsg', 'Power Message',
RadioSettingValueList(
self.POWERMESSAGES,
current_index=_mem.settings.powermsg)))
ret.append(RadioSetting('settings.rx_time', 'Show RX Time',
RadioSettingValueBoolean(_mem.settings.rx_time)))
ret.append(RadioSetting(
'management_settings.language',
_('Language'),
RadioSettingValueList(
['English', 'Chinese'],
current_index=_mem.management_settings.language)))
return ret
def _get_memcodes(self):
ret = RadioSettingGroup('mc', 'Memory Channel Privacy Codes')
msgs = ["Only hexadecimal chars accepted.",
"Allowed chars (%s)" % self.KEY_CHARS,
"Input from 0 to 6 characters. If code",
"length is less than 6 chars it will be",
"padded with leading zeros.",
"Ex: 1D32EB or 0F12 or AB521, etc...",
"Enable Code for the Location on the",
"'Other' tab in 'Memory Properties'."
]
for msg in msgs:
rsvs = RadioSettingValueString(0, 255, msg, autopad=False)
rsvs.set_mutable(False)
rs = RadioSetting('dummy_memcodes_msg_%i' % msgs.index(msg),
'Input rule %i' % int(msgs.index(msg)+1), rsvs)
ret.append(rs)
for i in range(self._memory_size):
code = ""
if self._memobj.memcode[i].code[3] < 0xFF:
code = self._decode_key(self._memobj.memcode[i].code)
code = code.zfill(6)
rsvs = RadioSettingValueString(0, 6, code, autopad=False,
charset=self.KEY_CHARS)
rs = RadioSetting('memcode@code@%i' % i,
'Memory Location (%i) Privacy Code' %
int(i+1), rsvs)
ret.append(rs)
return ret
def get_settings(self):
radio_settings = []
basic = self._get_settings_basic()
radio_settings.append(basic)
adv = self._get_settings_adv()
radio_settings.append(adv)
vfoa = self._get_settings_vfo(self._memobj.settings_vfo.vfo_a, 'A')
radio_settings.append(vfoa)
vfob = self._get_settings_vfo(self._memobj.settings_vfo.vfo_b, 'B')
radio_settings.append(vfob)
sk = self._get_settings_sidekeys()
radio_settings.append(sk)
dtmf = self._get_settings_dtmf()
radio_settings.append(dtmf)
ccn = self._get_custom_channel_names()
radio_settings.append(ccn)
can = self._get_custom_ani_names()
radio_settings.append(can)
ani = self._get_anicodes()
radio_settings.append(ani)
mcodes = self._get_memcodes()
radio_settings.append(mcodes)
if RT490_EXPERIMENTAL:
ks = self._get_settings_ks()
radio_settings.append(ks)
bands = self._get_settings_bands()
radio_settings.append(bands)
top = RadioSettings(*radio_settings)
return top
def get_raw_memory(self, number):
return '\n'.join([repr(self._memobj.memory[number]),
repr(self._memobj.memname[number])])
# TODO Add Code when RadioSettingValueString is fixed
def _get_extra(self, _mem, num):
group = RadioSettingGroup('extra', 'Extra')
# LOG.debug("Get extra %i" % num)
s = RadioSetting('bcl', 'Busy Channel Lockout',
RadioSettingValueBoolean(_mem.bcl))
group.append(s)
dcp = int(_mem.dcp)
if dcp > len(self.FHSS_LIST)-1:
_mem.dcp = cur = 0
LOG.debug('DCP ID / FHSS overflow for channel %d' % num)
cur = self.FHSS_LIST[dcp]
s = RadioSetting('dcp', 'FHSS (Encryption)',
RadioSettingValueList(self.FHSS_LIST, cur))
group.append(s)
# Does not work, no error, why ??? TODO
"""
code = ""
if self._memobj.memcode[num-1].code[3] < 0xFF:
code = self._decode_key(self._memobj.memcode[num-1].code)
code = code.zfill(6)
LOG.debug('CODE "%s"' % code)
s = RadioSetting('dcp_code', 'DCP code',
RadioSettingValueString(0, 6, code,
autopad=False,
charset=self.KEY_CHARS))
group.append(s) """
pttid = int(_mem.pttid)
if pttid > len(self.PTTID)-1:
_mem.pttid = cur = 0
LOG.debug('PTTID overflow for channel %d' % num)
cur = self.PTTID[pttid]
s = RadioSetting('pttid', 'Send DTMF Code (PTT ID)',
RadioSettingValueList(self.PTTID, cur))
group.append(s)
cur = self.SIGNAL[int(_mem.signal)]
s = RadioSetting('signal', 'PTT ID Code (S-Code)',
RadioSettingValueList(self.SIGNAL, cur))
group.append(s)
s = RadioSetting('learn',
'Use Memory Privacy Code as Tx/Rx DCS (Learn)',
RadioSettingValueBoolean(_mem.learn))
group.append(s)
return group
# TODO Add Code when RadioSettingValueString is fixed
def _set_extra(self, _mem, mem):
# memidx = mem.number - 1 # commented because not used
_mem.bcl = int(mem.extra['bcl'].value)
_mem.dcp = int(mem.extra['dcp'].value)
_mem.pttid = int(mem.extra['pttid'].value)
_mem.signal = int(mem.extra['signal'].value)
# self._memobj.memcode[mem.number].code = \
# self._encode_key(mem.extra['dcp_code'].value)
if (int(mem.extra['learn'].value) > 0) and \
(self._memobj.memcode[mem.number-1].code[3] == 0xA0):
_mem.learn = 1
elif (int(mem.extra['learn'].value) > 0) and \
(self._memobj.memcode[mem.number-1].code[3] != 0xA0):
_mem.learn = 0
raise InvalidValueError(
"Use Memory Privacy Code as Tx/Rx DCS (Learn) requires "
"that a memory code has been previously set for this memory."
"Go in 'Settings' -> 'Memory Channel Privacy Codes' and set "
"a code for the current memory before enabling 'Learn'.")
else:
_mem.learn = 0
def _is_txinh(self, _mem):
raw_tx = b""
for i in range(0, 4):
raw_tx += _mem.txfreq[i].get_raw()
return raw_tx == b"\xFF\xFF\xFF\xFF"
def get_memory(self, num):
memidx = num - 1
_mem = self._memobj.memory[memidx]
_nam = self._memobj.memname[memidx]
mem = chirp_common.Memory()
mem.number = num
if int(_mem.rxfreq) == 166666665:
mem.empty = True
return mem
try:
mem.name = bytes(
_nam.name.get_raw()).rstrip(b'\xFF').decode('gb2312')
except UnicodeDecodeError:
if _nam.name[0].get_raw() != b'\xFF':
LOG.error('Unable to decode name buffer %r',
_nam.name.get_raw())
mem.name = ''
mem.freq = int(_mem.rxfreq) * 10
offset = (int(_mem.txfreq) - int(_mem.rxfreq)) * 10
if self._is_txinh(_mem) or _mem.tx_enable == 0:
mem.duplex = 'off'
# _mem.txfreq = _mem.rxfreq # TODO REMOVE (force fix broken saves)
elif offset == 0:
mem.duplex = ''
mem.offset = 0
elif abs(offset) < 100000000:
mem.duplex = offset < 0 and '-' or '+'
mem.offset = abs(offset)
else:
mem.duplex = 'split'
mem.offset = int(_mem.txfreq) * 10
mem.power = self.POWER_LEVELS[_mem.power]
if _mem.unknown3_0 and _mem.narrow:
mem.mode = 'NAM'
elif _mem.unknown3_0 and not _mem.narrow:
mem.mode = 'AM'
elif not _mem.unknown3_0 and _mem.narrow:
mem.mode = 'NFM'
elif not _mem.unknown3_0 and not _mem.narrow:
mem.mode = 'FM'
else:
LOG.exception('Failed to get mode for %i' % num)
mem.skip = '' if _mem.scan else 'S'
# LOG.warning('got txtone: %s' % repr(self._decode_tone(_mem.txtone)))
# LOG.warning('got rxtone: %s' % repr(self._decode_tone(_mem.rxtone)))
txtone = self._decode_tone(_mem.txtone)
rxtone = self._decode_tone(_mem.rxtone)
chirp_common.split_tone_decode(mem, txtone, rxtone)
try:
mem.extra = self._get_extra(_mem, num)
except Exception:
LOG.exception('Failed to get extra for %i' % num)
return mem
def set_memory(self, mem):
memidx = mem.number - 1
_mem = self._memobj.memory[memidx]
_nam = self._memobj.memname[memidx]
if mem.empty:
_mem.set_raw(b'\xff' * 16)
_nam.set_raw(b'\xff' * 16)
return
if int(_mem.rxfreq) == 166666665:
LOG.debug('Initializing new memory %i' % memidx)
_mem.set_raw(b'\x00' * 16)
_nam.name.set_raw(mem.name.encode('gb2312').ljust(12, b'\xFF')[:12])
_mem.rxfreq = mem.freq / 10
_mem.tx_enable = 1
if mem.duplex == '':
_mem.txfreq = mem.freq / 10
elif mem.duplex == 'split':
_mem.txfreq = mem.offset / 10
elif mem.duplex == 'off':
_mem.tx_enable = 0
_mem.txfreq = mem.freq / 10 # Optional but keeps compat with
# vendor software
elif mem.duplex == '-':
_mem.txfreq = (mem.freq - mem.offset) / 10
elif mem.duplex == '+':
_mem.txfreq = (mem.freq + mem.offset) / 10
else:
raise errors.RadioError('Unsupported duplex mode %r' % mem.duplex)
txtone, rxtone = chirp_common.split_tone_encode(mem)
# LOG.warning('tx tone is %s' % repr(txtone))
# LOG.warning('rx tone is %s' % repr(rxtone))
_mem.txtone = self._encode_tone(*txtone)
_mem.rxtone = self._encode_tone(*rxtone)
try:
_mem.power = self.POWER_LEVELS.index(mem.power)
except ValueError:
_mem.power = 0
if int(_mem.rxfreq) < 30000000:
_mem.unknown3_0 = mem.mode in ['AM', 'NAM']
else:
_mem.unknown3_0 = 0
_mem.narrow = mem.mode[0] == 'N'
_mem.scan = mem.skip != 'S'
if mem.extra:
self._set_extra(_mem, mem)
def sync_out(self):
try:
do_upload(self)
except errors.RadioError:
# Pass through any real errors we raise
raise
except Exception:
# If anything unexpected happens, make sure we raise
# a RadioError and log the problem
LOG.exception('Unexpected error during upload')
raise errors.RadioError('Unexpected error communicating '
'with the radio')
def sync_in(self):
"""Download from radio"""
try:
data = do_download(self)
except errors.RadioError:
# Pass through any real errors we raise
raise
except Exception:
# If anything unexpected happens, make sure we raise
# a RadioError and log the problem
LOG.exception('Unexpected error during download')
raise errors.RadioError('Unexpected error communicating '
'with the radio')
self._mmap = data
self.process_mmap()
def process_mmap(self):
self._memobj = bitwise.parse(MEM_FORMAT_RT490 %
{"memsize": self._memory_size},
self._mmap)
def get_features(self): # GOOD ?
rf = chirp_common.RadioFeatures()
rf.has_settings = True
rf.has_bank = False
rf.has_cross = True
rf.has_rx_dtcs = True
rf.has_dtcs_polarity = True
rf.has_tuning_step = False
rf.can_odd_split = True
rf.has_name = True
rf.valid_name_length = 12
# We implement filter_name() ourselves
rf.valid_characters = ''
rf.valid_skips = ["", "S"]
rf.valid_tmodes = ["", "Tone", "TSQL", "DTCS", "Cross"]
rf.valid_cross_modes = ["Tone->Tone", "DTCS->", "->DTCS", "Tone->DTCS",
"DTCS->Tone", "->Tone", "DTCS->DTCS"]
rf.valid_power_levels = self.POWER_LEVELS
rf.valid_duplexes = ["", "+", "-", "split", "off"]
rf.valid_modes = ["FM", "NFM", "AM", "NAM"]
rf.memory_bounds = (1, 256)
rf.valid_tuning_steps = self.TUNING_STEPS
rf.valid_bands = [(108000000, 136000000),
(136000000, 180000000),
(200000000, 260000000),
(350000000, 400000000),
(400000000, 520000000)]
return rf
@classmethod
def get_prompts(cls):
rp = chirp_common.RadioPrompts()
rp.pre_upload = _("This driver is in development and should be "
"considered as experimental.")
rp.experimental = _("This driver is in development and should be "
"considered as experimental.")
rp.info = _("This driver is in development and should be considered "
"as experimental.")
return rp
def _encode_key(self, key):
arr = bytearray(4)
arr[3] = 160
arr[2] = self.KEY_CHARS.index(key[0]) # << 4
arr[2] = arr[2] << 4
arr[2] |= self.KEY_CHARS.index(key[1])
arr[1] = self.KEY_CHARS.index(key[2]) # << 4
arr[1] = arr[1] << 4
arr[1] |= self.KEY_CHARS.index(key[3])
arr[0] = self.KEY_CHARS.index(key[4]) # << 4
arr[0] = arr[0] << 4
arr[0] |= self.KEY_CHARS.index(key[5])
return arr
def _decode_key(self, key):
ret = ""
if key[3] == 0xA0:
ret += self.KEY_CHARS[key[2] >> 4]
ret += self.KEY_CHARS[key[2] & 0xF]
ret += self.KEY_CHARS[key[1] >> 4]
ret += self.KEY_CHARS[key[1] & 0xF]
ret += self.KEY_CHARS[key[0] >> 4]
ret += self.KEY_CHARS[key[0] & 0xF]
LOG.debug('DCP Code: "%s"' % ret)
return ret
def _decode_tone(self, toneval):
if toneval in (0, 0xFFFF):
# LOG.debug('no tone value: %s' % toneval)
return None, None, None
elif toneval < 670:
toneval = toneval - 1
index = toneval % len(DTCS_CODES)
if index != int(toneval):
pol = 'R'
# index -= 1
else:
pol = 'N'
return 'DTCS', DTCS_CODES[index], pol
else:
return 'Tone', toneval / 10.0, 'N'
def _encode_tone(self, mode, val, pol):
if not mode:
return 0x0000
elif mode == 'Tone':
return int(val * 10)
elif mode == 'DTCS':
index = DTCS_CODES.index(val)
if pol == 'R':
index += len(DTCS_CODES)
index += 1
# LOG.debug('Encoded dtcs %s/%s to %04x' % (val, pol, index))
return index
else:
raise errors.RadioError('Unsupported tone mode %r' % mode)
@directory.register
class MML8629Radio(RT490Radio):
"""MMLradio JC-8629"""
VENDOR = "MMLradio"
MODEL = "JC-8629"
@directory.register
class JJCC8629Radio(RT490Radio):
"""JJCC JC-8629"""
VENDOR = "JJCC"
MODEL = "JC-8629"
@directory.register
class SocotranJC8629Radio(RT490Radio):
"""Socotran JC-8629"""
VENDOR = "Socotran"
MODEL = "JC-8629"
@directory.register
class SocotranFB8629Radio(RT490Radio):
"""Socotran FB-8629"""
VENDOR = "Socotran"
MODEL = "FB-8629"
@directory.register
class Jianpai8629Radio(RT490Radio):
"""Jianpai 8800 Plus"""
VENDOR = "Jianpai"
MODEL = "8800_Plus"
@directory.register
class Boristone8RSRadio(RT490Radio):
"""Boristone 8RS"""
VENDOR = "Boristone"
MODEL = "8RS"
@directory.register
class AbbreeAR869Radio(RT490Radio):
"""Abbree AR-869"""
VENDOR = "Abbree"
MODEL = "AR-869"
@directory.register
class HamGeekHG590Radio(RT490Radio):
"""HamGeek HG-590"""
VENDOR = "HamGeek"
MODEL = "HG-590"
IMHEX_DESC = """
// Perfect tool for binary reverse engineering
// https://github.com/WerWolv/ImHex
// Below is the pattern
"""
IMHEX_PATTERN = """
struct memory { // Memory settings
u8 rxfreq[4];
u8 txfreq[4];
u16 rxtone;
u16 txtone;
u8 signal; // int 0->14, Signal 1->15
u8 pttid; // ['OFF', 'BOT', 'EOT', 'Both']
u8 dcp_power; // POWER_LEVELS
u8 unknown3_0_narrow_unknown3_1_bcl_scan_tx_enable_learn; // bool ??? TODO
};
struct memname {
char name[12];
padding[4];
};
struct memcode {
u8 code[4];
};
struct custom_ani_names {
char name[12];
padding[4];
};
struct anicodes {
u8 anicode[6];
padding[10];
};
struct custom_channel_names {
char name[12];
padding[4];
};
bitfield workmode {
b : 4;
a : 4;
};
struct settings {
u8 squelch; // 0: int 0 -> 9
u8 savemode; // 1: ['OFF', 'Normal', 'Super', 'Deep']
u8 vox; // 2: off=0, 1 -> 9
u8 backlight; // 3: ['OFF', '5s', '15s', '20s', '30s', '1m', '2m',
// '3m']
u8 tdr; // 4: bool
u8 timeout; // 5: n*30seconds, 0-240s
u8 beep; // 6: bool
u8 voice; // 7: bool
u8 byte_not_used_10; // 8: Always 1
u8 dtmfst; // 9: ['OFF', 'KB Side Tone', 'ANI Side Tone',
// 'KB ST + ANI ST']
u8 scanmode; // 10: ['TO', 'CO', 'SE']
u8 pttid; // 11: ['OFF', 'BOT', 'EOT', 'Both']
u8 pttiddelay; // 12: ['0', '100ms', '200ms', '400ms', '600ms',
// '800ms', '1000ms']
u8 cha_disp; // 13: ['Name', 'Freq', 'Channel ID']
u8 chb_disp; // 14: ['Name', 'Freq', 'Channel ID']
u8 bcl; // 15: bool
u8 autolock; // 0: ['OFF', '5s', '10s', 15s']
u8 alarm_mode; // 1: ['Site', 'Tone', 'Code']
u8 alarmsound; // 2: bool
u8 txundertdr; // 3: ['OFF', 'A', 'B']
u8 tailnoiseclear; // 4: [off, on]
u8 rptnoiseclear; // 5: n*100ms, 0-1000
u8 rptnoisedelay; // 6: n*100ms, 0-1000
u8 roger; // 7: bool
u8 active_channel; // 8: 0 or 1
u8 fmradio; // 9: boolean, inverted
workmode _workmode; // 10: up ['VFO', 'CH Mode']
u8 kblock; // 11: bool // TODO TEST WITH autolock
u8 powermsg; // 12: 0=Image / 1=Voltage
u8 byte_not_used_21; // 13: Always 0
u8 rpttone; // 14: ['1000Hz', '1450Hz', '1750Hz', '2100Hz']
u8 byte_not_used_22; // 15: pad with xFF
u8 vox_delay; // 0: [str(float(a)/10)+'s' for a in range(5,21)]
// '0.5s' to '2.0s'
u8 timer_menu_quit; // 1: ['5s', '10s', '15s', '20s', '25s', '30s',
// '35s', '40s', '45s', '50s', '60s']
u8 byte_not_used_30; // 2: pad with xFF
u8 byte_not_used_31; // 3: pad with xFF
u8 enable_killsw; // 4: bool
u8 display_ani; // 5: bool
u8 byte_not_used_32; // 6: pad with xFF
u8 enable_gps; // 7: bool
u8 scan_dcs; // 8: ['All', 'Receive', 'Transmit']
u8 ani_id; // 9: int 0-59 (ANI 1-60)
u8 rx_time; // 10: bool
padding[5]; // 11: Pad xFF
u8 cha_memidx; // 0: Memory index when channel A use memories
u8 byte_not_used_40;
u8 chb_memidx; // 2: Memory index when channel B use memories
u8 byte_not_used_41;
padding[10];
u16 fmpreset;
};
struct settings_vfo_chan {
u8 rxfreq[8]; // 0
u16 rxtone; // 8
u16 txtone; // 10
u16 byte_not_used0; // 12 Pad xFF
u8 sftd_signal; // 14 int 0->14, Signal 1->15
u8 byte_not_used1; // 15 Pad xFF
u8 power; // 16:0 POWER_LEVELS
u8 fhss_narrow; // 17 bool true=NFM false=FM
u8 byte_not_used2; // 18 Pad xFF but received 0x00 ???
u8 freqstep; // 19:3 ['2.5 KHz', '5.0 KHz', '6.25 KHz',
// '10.0 KHz', '12.5 KHz', '20.0 KHz',
// '25.0 KHz', '50.0 KHz']
u8 byte_not_used3; // 20:4 Pad xFF but received 0x00 ??? TODO
u8 offset[6]; // 21:5 Freq NN.NNNN (without the dot) TEST TEST
u8 byte_not_used4; // 27:11 Pad xFF
u8 byte_not_used5; // 28 Pad xFF
u8 byte_not_used6; // 29 Pad xFF
u8 byte_not_used7; // 30 Pad xFF
u8 byte_not_used8; // 31:15 Pad xFF
};
struct settings_vfo {
settings_vfo_chan vfo_a;
settings_vfo_chan vfo_b;
};
struct settings_sidekeys { // Values from Radio
u8 pf2_short; // { '7': 'FM', '10': 'Tx Power', '28': 'Scan',
// '29': 'Search, '1': 'PPT B' }
u8 pf2_long; // { '7': 'FM', '10': 'Tx Power', '28': 'Scan',
// '29': 'Search' }
u8 pf3_short; // { '7': 'FM', '10': 'Tx Power', '28': 'Scan',
// '29': 'Search' }
u8 ffpad; // Pad xFF
};
struct dtmfcode {
u8 code[5]; // 5 digits DTMF
padding[11]; // Pad xFF
};
struct settings_dtmf { // @15296+3x16
u8 byte_not_used1; // 0: Pad xFF
u8 byte_not_used2; // 1: Pad xFF
u8 byte_not_used3; // 2: Pad xFF
u8 byte_not_used4; // 3: Pad xFF
u8 byte_not_used5; // 4: Pad xFF
u8 unknown_dtmf; // 5: 0 TODO ???? wtf is alarmcode/alarmcall TODO
u8 pttid; // 6: [off, BOT, EOT, Both]
u8 dtmf_speed_on; // 7: ['50ms', '100ms', '200ms', '300ms', '500ms']
u8 dtmf_speed_off; // 8:0 ['50ms', '100ms', '200ms', '300ms', '500ms']
};
struct settings_dtmf_global {
dtmfcode settings_dtmfgroup[15];
settings_dtmf _settings_dtmf;
};
struct settings_killswitch {
u8 kill_dtmf[6]; // 0: Kill DTMF
padding[2]; // Pad xFF
u8 revive_dtmf[6]; // 8: Revive DTMF
padding[2]; // Pad xFF
};
struct management_settings {
u8 unknown_data_0[16];
u8 unknown_data_1;
u8 active; // Bool radio killed (killed=0, active=1)
padding[46];
};
struct band {
u8 enable; // 0 bool / enable-disable Tx on band
u8 freq_low[2]; // 1 lowest band frequency
u8 freq_high[2]; // 3 highest band frequency
};
struct settings_bands {
band band136; // 0 Settings for 136MHz band
band band400; // 5 Settings for 400MHz band
band band200; // 10 Settings for 200MHz band
padding[1]; // 15
band band350; // 0 Settings for 350MHz band
padding[43];// 5
};
memory mem[256] @ 0x0000;
memname mname[256] @ 0x1000;
memcode mcode[256] @ 0x2000;
custom_ani_names caninames[10] @ 0x3400;
anicodes anic[60] @ 0x3500;
custom_channel_names ccnames[10] @ 0x3900;
settings _settings @ 0x3A00;
settings_vfo _settings_vfo @ 0x3A40;
settings_sidekeys _settings_sidekeys @ 0x3A80;
settings_dtmf_global _settings_dtmf_global @ 0x3B00;
settings_killswitch _settings_killswitch @ 0x3C00;
management_settings _management_settings @ 0x3F80;
settings_bands _settings_bands @ 0x3FC0;
"""
chirp-20261030/chirp/drivers/radtel_rt620.py 0000644 0001750 0001750 00000035336 14724616660 017425 0 ustar hibby hibby # Copyright 2024:
# * Pavel Moravec, OK2MOP
#
# 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 2 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
#
# 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 2 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
# Derived from prior copyrighted work:
# Copyright 2024 Pavel Moravec, OK2MOP
# Copyright 2023 Jim Unroe
#
# CHIRP driver for Ratel RT-900 Series radios
#
# 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 2 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 combos for some modes:
# 8: Super
# OK: GMRS
# EXIT: Factory
# 2: 144-146/430-440
_RADIO_MODE_MAP = [
("Default", 0xff), ("GMRS", 0xa5),
("PMR", 0x66), ("144-146/430-440", 0x55),
("Super", 0x56), ("Factory", 0x00),
("unknown Mode 2", 0x28),
]
POWER_LEVELS = [
chirp_common.PowerLevel("High", watts=8.00),
chirp_common.PowerLevel("Middle", watts=4.00),
chirp_common.PowerLevel("Low", watts=1.00),
]
SKEY_LIST = ["Radio",
"TX Power",
"Scan",
"Search",
"NOAA",
"SOS",
"Switch AM/FM",
"Bluetooth",]
SKEY_SP_LIST = SKEY_LIST
_upper = 999 # fw 1.20 expands from 512 to 999 channels_steps,
_mem_params = (_upper # number of channels
)
_magic = b"PROGRAMBT80U"
_fingerprint = [b"\x01\x36\x01\x80\x04\x00\x05\x20",
b"\x01\x00\x01\x80\x04\x00\x05\x20",
] # fw V1.20P for RT-900 BT
_fingerprint2 = [b"\x02\x00\x02\x60\x01\x03\x30\x04",
] # fw V1.20P for RT-900 BT
_cryptsetup = (b'SEND \x01\x01\x00\x00\x00\x00\x00\x00\x00\x00' +
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
_ranges = [
(0x0000, 0x7CE0), # FW V1.20P,
# 0x7CE0 equals 999 channels of 32 bytes each
# 999 * 32 = 0x7ce0
(0x8000, 0x8040),
(0x9000, 0x9040),
(0xA000, 0xA140),
(0xD000, 0xD040), # Radio mode hidden setting
]
_calibration = (0xF000, 0xF250) # Calibration data
_memsize = 0xF250 # Including calibration data
_has_bt_denoise = True
_has_am_per_channel = True
_has_am_switch = not _has_am_per_channel
_has_single_mode = True
_has_zone_or_channel = False
_has_zone_names = False
_has_sp0 = True # spkey addresses are shifted -1
_has_hf = False
_valid_chars = chirp_common.CHARSET_ALPHANUMERIC + \
"`~!@#$%^&*()-=_+[]\\{}|;':\",./<>?"
_steps = [2.5, 5.0, 6.25, 10.0, 12.5, 20.0, 25.0, 50.0, 8.33]
_step_map = [("2.5 K", 0), ("5.0 K", 1), ("6.25 K", 2), ("8.33 K", 8),
("10.0 K", 3), ("12.5 K", 4), ("20.0 K", 5), ("25.0 K", 6),
("50.0 K", 7),]
_bandwidth_list = ["Wide (25 KHz)", "Narrow (12.5 KHz)"]
_offset_list = ["Off", "+", "-"]
_rx_modulation_list = ["FM", "AM"]
_scode_list = ["%s" % x for x in range(1, 16)]
_voicepri_list = ["Off", "ENCRY1", "ENCRY2", "ENCRY3"]
_scramble_map = [("Off", 0x00), ("On", 0x04)]
_code_list_ctcss = ["%2.1fHz" % x for x in sorted(chirp_common.TONES)]
_code_list_ctcss.insert(0, "Off")
_dcs = tuple(sorted(chirp_common.DTCS_CODES + (645,)))
_code_list_dcsn = ["D%03iN" % x for x in _dcs]
_code_list_dcsi = ["D%03iI" % x for x in _dcs]
_code_list = _code_list_ctcss + _code_list_dcsn + _code_list_dcsi
def sync_in(self):
"""Download from radio"""
try:
data = do_download(self)
except errors.RadioError:
# Pass through any real errors we raise
raise
except Exception:
# If anything unexpected happens, make sure we raise
# a RadioError and log the problem
LOG.exception('Unexpected error during download')
raise errors.RadioError('Unexpected error communicating '
'with the radio')
finally:
_exit_programming_mode(self)
self._mmap = data
self.process_mmap()
def sync_out(self):
"""Upload to radio"""
try:
do_upload(self)
except errors.RadioError:
raise
except Exception:
# If anything unexpected happens, make sure we raise
# a RadioError and log the problem
LOG.exception('Unexpected error during upload')
raise errors.RadioError('Unexpected error communicating '
'with the radio')
finally:
_exit_programming_mode(self)
def get_settings(self):
_dtmf = self._memobj.dtmf
_settings = self._memobj.settings
_radio_mode = self._memobj.opmode.radio_mode
basic = RadioSettingGroup("basic", "Basic Settings")
group = RadioSettings(basic)
# Menu 12: TOT
rs = RadioSettingValueList(TOT_LIST, current_index=_settings.tot)
rset = MemSetting("settings.tot", "Time Out Timer", rs)
rset.set_doc("Set the Time Out Timer for transmit (Seconds).")
basic.append(rset)
# Menu 00: SQL
rs = RadioSettingValueInteger(0, 9, _settings.sql)
rset = MemSetting("settings.sql", "Squelch Level", rs)
rset.set_doc("Set the receive squelch level. Setting to zero will "
"disable the squlech.")
basic.append(rset)
# Menu 13: VOX
rs = RadioSettingValueList(OFF1TO9_LIST, current_index=_settings.vox)
rset = MemSetting("settings.vox", "VOX", rs)
rset.set_doc("Set the VOX sensitivity level.")
basic.append(rset)
# Menu 39: VOX DELAY
rs = RadioSettingValueList(VOXD_LIST, current_index=_settings.voxd)
rset = MemSetting("settings.voxd", "VOX Delay", rs)
rset.set_doc("Set the VOX delay time (Seconds).")
basic.append(rset)
# Menu 15: VOICE
rs = RadioSettingValueBoolean(_settings.voice)
rset = MemSetting("settings.voice", "Voice Prompts", rs)
rset.set_doc("Set the radio voice prompts.")
basic.append(rset)
# Menu 17: LANGUAGE
rs = RadioSettingValueList(LANGUAGE_LIST,
current_index=_settings.language)
rset = MemSetting("settings.language", "Language", rs)
rset.set_doc("Set the radio menu and voice promopts language.")
basic.append(rset)
# Menu 23: ABR
rs = RadioSettingValueList(ABR_LIST, current_index=_settings.abr)
rset = MemSetting("settings.abr", "Auto BackLight", rs)
rset.set_doc("Set the radio Backlight auto switch off time (Seconds).")
basic.append(rset)
# Menu 19: SC-REV
rs = RadioSettingValueList(SCREV_LIST, current_index=_settings.screv)
rset = MemSetting("settings.screv", "Scan Resume Method", rs)
rset.set_doc("Set the Scan Resume method: TO (time scanning), "
"CO (carrier detect), SE (search scanning).")
basic.append(rset)
# Menu 10: SAVE
rs = RadioSettingValueList(SAVE_LIST,
current_index=_settings.save)
rset = MemSetting("settings.save", "Battery Save Mode", rs)
rset.set_doc("Set the Battery power save mode.")
basic.append(rset)
# Menu 42: MDF-A
rs = RadioSettingValueList(MDF_LIST, current_index=_settings.mdfa)
rset = MemSetting("settings.mdfa", "Memory Display Format A", rs)
rset.set_doc("Set A band display mode.")
basic.append(rset)
# Menu 43: MDF-B
rs = RadioSettingValueList(MDF_LIST, current_index=_settings.mdfb)
rset = MemSetting("settings.mdfb", "Memory Display Format B", rs)
rset.set_doc("Set B band display mode.")
basic.append(rset)
# Menu 33: DTMFST (DTMF ST)
rs = RadioSettingValueList(DTMFST_LIST, current_index=_settings.dtmfst)
rset = MemSetting("settings.dtmfst", "DTMF Side Tone", rs)
rset.set_doc("Set how DTMF tones are heard when a PTT ID DTMF Code "
"is sent.")
basic.append(rset)
# Menu 37: PTT-LT
rs = RadioSettingValueList(PTTLT_LIST, current_index=_settings.pttlt)
rset = MemSetting("settings.pttlt", "PTT Delay", rs)
rset.set_doc("Set the PTT delay time.")
basic.append(rset)
# Menu 36: TONE
rs = RadioSettingValueList(TONE_LIST, current_index=_settings.tone)
rset = MemSetting("settings.tone", "Tone-burst Frequency", rs)
rset.set_doc("Set the Tone-burst Frequency.")
basic.append(rset)
# Mneu 29: POWER ON MSG
rs = RadioSettingValueList(PONMSG_LIST, current_index=_settings.ponmsg)
rset = MemSetting("settings.ponmsg", "Power On Message", rs)
rset.set_doc("Set the Power On Message.")
basic.append(rset)
# Menu 46: STE
rs = RadioSettingValueBoolean(_settings.ste)
rset = MemSetting("settings.ste",
"Squelch Tail Eliminate (HT to HT)", rs)
rset.set_doc("Set the Squelch Tail Eliminate for HT to HT "
"communication.")
basic.append(rset)
# Menu 40: RP-STE
rs = RadioSettingValueList(RPSTE_LIST, current_index=_settings.rpste)
rset = MemSetting("settings.rpste",
"Squelch Tail Eliminate (repeater)", rs)
rset.set_doc("Set the Squelch Tail Eliminate time for repeater "
"communication.")
basic.append(rset)
# Menu 41: RPT-RL
rs = RadioSettingValueList(RPSTE_LIST, current_index=_settings.rptrl)
rset = MemSetting("settings.rptrl", "STE Repeater Delay", rs)
rset.set_doc("Set the delay time for Squelch Tail Eliminate "
"when using a repeater.")
basic.append(rset)
# Menu 38: MENU EXIT TIME
rs = RadioSettingValueList(MENUQUIT_LIST,
current_index=_settings.menuquit)
rset = MemSetting("settings.menuquit", "Menu Auto Quit", rs)
rset.set_doc("Set the time for the radio to automatically exit the "
"menu system.")
basic.append(rset)
# Menu 34: AUTOLOCK
rs = RadioSettingValueList(AUTOLK_LIST, current_index=_settings.autolk)
rset = MemSetting("settings.autolk", "Key Auto Lock", rs)
rset.set_doc("Set the time for the radio to automatically lock "
"the keypad.")
basic.append(rset)
# Menu 28: CTCSS SAVE MODE
rs = RadioSettingValueList(QTSAVE_LIST, current_index=_settings.qtsave)
rset = MemSetting("settings.qtsave", "QT Save Type", rs)
rset.set_doc("Set how the CTCSS/DCS codes are saved to a channel.")
basic.append(rset)
# Menu 47: AL-MODE
rs = RadioSettingValueList(ALMODE_LIST, current_index=_settings.almode)
rset = MemSetting("settings.almode", "Alarm Mode", rs)
rset.set_doc("Set how the radio will send an Alarm.")
basic.append(rset)
# Menu 11: ROGER
rs = RadioSettingValueList(ROGER_LIST, current_index=_settings.roger)
rset = MemSetting("settings.roger", "Roger", rs)
rset.set_doc("Set the Roger Beep mode for when the PTT is released.")
basic.append(rset)
# Menu 44: Alarm ON/OFF
rs = RadioSettingValueBoolean(_settings.alarmsound)
rset = MemSetting("settings.alarmsound", "Alarm Sound", rs)
rset.set_doc("Enable to allow the radio to send an alarm.")
basic.append(rset)
if self._has_hf:
s1 = "FM/AM/SSB Radio"
s2 = "Allow access to FM/AM/SSB RX channels on radio."
else:
s1 = "FM Radio"
s2 = "Allow access to FM broadcast RX channels on radio."
rs = RadioSettingValueInvertedBoolean(not _settings.fmradio)
rset = MemSetting("settings.fmradio", s1, rs)
rset.set_doc(s2)
basic.append(rset)
rs = RadioSettingValueBoolean(_settings.kblock)
rset = MemSetting("settings.kblock", "KB Lock", rs)
rset.set_doc("Enable radio keypad locked by default.")
basic.append(rset)
# Menu 16: BEEP PROMPT
rs = RadioSettingValueBoolean(_settings.beep)
rset = MemSetting("settings.beep", "Beep", rs)
rset.set_doc("Enable radio keypad Beep when pressing keys.")
basic.append(rset)
dtmf = RadioSettingGroup("dtmf", "DTMF Settings")
group.append(dtmf)
def apply_code(setting, obj, length):
code = []
for j in range(0, length):
try:
code.append(DTMF_CHARS.index(str(setting.value)[j]))
except IndexError:
code.append(0xFF)
obj.code = code
for i in range(0, 15):
_codeobj = self._memobj.pttid[i].code
_code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F])
rs = RadioSettingValueString(0, 6, _code, False)
rs.set_charset(DTMF_CHARS)
rset = RadioSetting("pttid/%i.code" % i,
"PTT-ID Code %i" % (i + 1), rs)
rset.set_apply_callback(apply_code, self._memobj.pttid[i], 6)
rset.set_doc("Set the PTT-ID % i Code DTMF sequence." % (i + 1))
dtmf.append(rset)
rs = RadioSettingValueList(DTMFSPEED_LIST,
current_index=_dtmf.dtmfon)
rset = MemSetting("dtmf.dtmfon", "DTMF Speed (On)", rs)
rset.set_doc("Set the duration for how long each DMTF tone is ON.")
dtmf.append(rset)
rs = RadioSettingValueList(DTMFSPEED_LIST,
current_index=_dtmf.dtmfoff)
rset = MemSetting("dtmf.dtmfoff", "DTMF Speed (Off)", rs)
rset.set_doc("Set the duration for how long the pause is between "
"DTMF tones.")
dtmf.append(rset)
rs = RadioSettingValueList(
PTTID_LIST, current_index=_settings.pttid)
rset = MemSetting("settings.pttid", "PTT ID", rs)
rset.set_doc("Set when the PTT-ID is to be sent.")
dtmf.append(rset)
spec = RadioSettingGroup("spec", self.MODEL + " Specific")
group.append(spec)
# secret radio mode setting (no menu). PTT + 8 for Super Mode
rs = RadioSettingValueMap(self._RADIO_MODE_MAP, _radio_mode)
rset = MemSetting("opmode.radio_mode", "Radio Operating Mode", rs)
rset.set_warning(
'This should only be used to change the operating MODE of your '
'radio if you understand the legalities and implications of '
'doing so. The change may enable the radio to transmit on '
'frequencies it is not Type Accepted to do and may be in '
'violation of FCC and other governing agency regulations.\n\n'
'It may make your saved image files incompatible with the radio '
'and non-usable until you change the radio MODE back to the '
'MODE in effect when the image file was saved. After the '
'changed image is uploaded, the radio may have to turned OFF '
'and back ON to have the MODE changes take full effect.\n'
'DO NOT attempt to edit any settings until uploading to and '
'downloading from the radio with the new operating MODE.')
rset.set_doc("Set the radio's Operating Mode.")
spec.append(rset)
if self._has_bt_denoise:
# Menu 46: Noise reduction
rs = RadioSettingValueBoolean(_settings.noise_reduction)
rset = MemSetting("settings.noise_reduction",
"Noise reduction", rs)
rset.set_doc("Set the radio's automatic Noise Reduction feature.")
spec.append(rset)
# Menu 47: Bluetooth
rs = RadioSettingValueBoolean(_settings.bluetooth)
rset = MemSetting("settings.bluetooth", "Bluetooth", rs)
rset.set_doc("Enable Bluetooth (BLE). "
"Bluetooth can be used to program the radio over a "
"BLE connection.")
spec.append(rset)
# Menu 23: PF2 Short
if self._has_sp0:
skey2_sp = _settings.skey2_sp0
key = "settings.skey2_sp0"
else:
skey2_sp = _settings.skey2_sp1
key = "settings.skey2_sp1"
rs = RadioSettingValueList(self.SKEY_SP_LIST,
current_index=skey2_sp)
rset = MemSetting(key, "PF2 Key (Short Press)", rs)
rset.set_doc("Set what a Short Press on the PF2 Key will do.")
spec.append(rset)
# Menu 24: PF2 Long
if self._has_sp0:
skey2_lp = _settings.skey2_sp1
key = "settings.skey2_sp1"
else:
skey2_lp = _settings.skey2_lp
key = "settings.skey2_lp"
rs = RadioSettingValueList(
self.SKEY_LIST, current_index=skey2_lp)
rset = MemSetting(key, "PF2 Key (Long Press)", rs)
rset.set_doc("Set what a Long Press on the PF2 Key will do.")
spec.append(rset)
# Menu 25: PF3 Short
if self._has_sp0:
skey3_sp = _settings.skey2_lp
key = "settings.skey2_lp"
else:
skey3_sp = _settings.skey3_sp
key = "settings.skey3_sp"
rs = RadioSettingValueList(
self.SKEY_LIST, current_index=skey3_sp)
rset = MemSetting(key, "PF3 Key (Short Press)", rs)
rset.set_doc("Set what a Short Press on the PF3 Key will do.")
spec.append(rset)
if self.MODEL not in ["RT-900_BT", "RT-920"]:
# Menu 50: AM/FM Mode
if self._has_am_switch:
rs = RadioSettingValueBoolean(_settings.am_mode)
rset = MemSetting("settings.am_mode", "AM Mode", rs)
rset.set_doc("Enable to set the RX modulation mode to AM.")
spec.append(rset)
# Menu 7: TDR - Dual freq standby
rs = RadioSettingValueBoolean(_settings.tdr)
rset = MemSetting("settings.tdr", "TDR - Dual frequency standby", rs)
rset.set_doc("Set Dual Frequency Standby (Dual Watch).")
spec.append(rset)
if self._has_single_mode:
# Menu 51: Single Mode - Single freq channel display
rs = RadioSettingValueBoolean(_settings.single_mode)
rset = MemSetting("settings.single_mode", "Single Mode", rs)
rset.set_doc("Set radio to display a single frequency/channel.")
spec.append(rset)
if self.MODEL in ["RT-920"]:
# Menu 53: FM Interupt
rs = RadioSettingValueBoolean(_settings.fm_interrupt)
rset = MemSetting("settings.fm_interrupt", "FM Interrupt", rs)
rset.set_doc("While using broadcast FM, "
"allow incoming RX to interrupt the FM "
"broadcast audio.")
spec.append(rset)
if self._has_zone_or_channel:
# Menu 10: Zone or Channel
rs = RadioSettingValueList(self._zone_or_channel_list,
current_index=_settings.zone_or_channel)
rset = MemSetting("settings.zone_or_channel",
"Zone or Channel", rs)
rset.set_warning(
"Changing this setting requires saving the .IMG file and "
"opening it back up to enable/disable the Banks (Zones) "
"preview tab.") # and the Zone Name sub-menu.")
rset.set_doc(
"Set Zone Mode (static banks) or Full Channel "
"(flat) memmory channel mode.")
spec.append(rset)
# VFO A/B settings
abblock = RadioSettingGroup("abblock", "VFO A/B Channel")
spec.append(abblock)
vfo = self._memobj.vfo
# Menu 21: VFO A/B BCL (Busy lock)
rs = RadioSettingValueBoolean(_settings.busy_lock)
rset = MemSetting("settings.busy_lock", "BCL", rs)
rset.set_doc("Set Busy Channel Lockout. When selected, disables PTT "
"when the current frequency is busy.")
abblock.append(rset)
# Menu 30 VFO DTMF code
rs = RadioSettingValueList(
PTTID_LIST,
current_index=_settings.pttid
)
rset = MemSetting("settings.pttid", "DTMF Code", rs)
rset.set_doc("Set when to send PTT-ID DTMF codes")
abblock.append(rset)
# Menu 42: TX-A/B
rs = RadioSettingValueList(
DUALTX_LIST, current_index=_settings.dualtx)
rset = MemSetting("settings.dualtx", "TX-A/B", rs)
rset.set_doc("Set which Band will be used for TX when PTT is pressed.")
abblock.append(rset)
# VFO A channel sub menu
achannel = RadioSettingSubGroup("achannel", "VFO A Channel")
abblock.append(achannel)
# Work Mode A
rs = RadioSettingValueList(WORKMODE_LIST,
current_index=_settings.vfomra)
rset = MemSetting("settings.vfomra", "Work Mode", rs)
rset.set_doc("Set A Band Work Mode.")
achannel.append(rset)
# VFO A Freq
def freq_validate(value):
_radio_mode = self._memobj.opmode.radio_mode
_vhf_lower = 0.0
_uhf_upper = 0.0
if _radio_mode in [0x00, 0x56, 0xff]: # Factory,Super,Default
_vhf_lower = 18.0
else:
_vhf_lower = 108.0
_vhf_upper = 299.99875
_uhf_lower = 300.0
if _radio_mode in [0x00, 0x56]: # Factory,Super
_uhf_upper = 999.99875
else:
_uhf_upper = 519.99875
value = chirp_common.parse_freq(value)
msg = ("Can't be less than %i.0000")
if value < _vhf_lower * 1000000:
raise InvalidValueError(msg % _vhf_lower)
msg = ("Can't be between %i.9975-%i.0000")
if _vhf_upper * 1000000 <= value and \
value < _uhf_lower * 1000000:
raise InvalidValueError(msg % (_vhf_upper - 1, _uhf_lower))
msg = ("Can't be greater than %i.9975")
if value > _uhf_upper * 1000000:
raise InvalidValueError(msg % (_uhf_upper - 1))
return chirp_common.format_freq(value)
def apply_freq(setting, obj):
value = chirp_common.parse_freq(str(setting.value)) / 10
for i in range(7, -1, -1):
obj.freq[i] = value % 10
value /= 10
rs = RadioSettingValueString(0, 10, bfc.bcd_decode_freq(vfo.a.freq))
rs.set_validate_callback(freq_validate)
rset = RadioSetting("vfo.a.freq", "Frequency", rs)
rset.set_apply_callback(apply_freq, vfo.a)
rset.set_doc("Set A Band VFO frequency.")
achannel.append(rset)
# Menu 01: A Step
rs = RadioSettingValueMap(self._step_map, vfo.a.step)
rset = MemSetting("vfo.a.step", "Tuning Step", rs)
rset.set_doc("Set A Band frequency Tuning Step.")
achannel.append(rset)
# Menu 02: TX Power
rs = RadioSettingValueList([str(x) for x in self.POWER_LEVELS],
current_index=vfo.a.txpower)
rset = MemSetting("vfo.a.txpower", "TX Power", rs)
rset.set_doc("Set A Band TX Power.")
achannel.append(rset)
# Menu 05: Wide/Narrow Band
rs = RadioSettingValueList(self._bandwidth_list,
current_index=vfo.a.widenarr)
rset = MemSetting("vfo.a.widenarr", "Bandwidth", rs)
rset.set_doc("Set A Band Bandwidth.")
achannel.append(rset)
# Menu 12,13: RX ctcss/dtsc
rs = RadioSettingValueList(self._code_list,
current_index=self._code_list.index
(self.decode(vfo.a.rxtone)))
rset = RadioSetting("vfo.a.rxtone", "RX CTCSS/DCS", rs)
rset.set_apply_callback(self.apply_vfo_tone,
self._memobj.vfo.a, "rxtone")
rset.set_doc("Set A Band RX CTCSS or DCS code.")
achannel.append(rset)
# Menu 14,15: TX ctcss/dtsc
rs = RadioSettingValueList(self._code_list,
current_index=self._code_list.index
(self.decode(vfo.a.txtone)))
rset = RadioSetting("vfo.a.txtone", "TX CTCSS/DCS", rs)
rset.set_apply_callback(self.apply_vfo_tone,
self._memobj.vfo.a, "txtone")
rset.set_doc("Set A Band TX CTCSS or DCS code.")
achannel.append(rset)
# Menu 16: Voice Privacy (encryption)
rs = RadioSettingValueList(self._voicepri_list,
current_index=vfo.a.voicepri)
rset = RadioSetting("vfo.a.voicepri",
"Voice Privacy - Subtone Encryption", rs)
rset.set_doc("Set A Band Voice Privacy - subtone voice encryption.")
achannel.append(rset)
def convert_bytes_to_offset(bytes):
real_offset = 0
for byte in bytes:
real_offset = (real_offset * 10) + byte
return chirp_common.format_freq(real_offset * 1000)
def apply_offset(setting, obj):
value = chirp_common.parse_freq(str(setting.value)) / 1000
for i in range(5, -1, -1):
obj.offset[i] = value % 10
value /= 10
# Menu 26: Offset
rs = RadioSettingValueString(0, 10,
convert_bytes_to_offset(vfo.a.offset))
rset = RadioSetting("vfo.a.offset", "Offset (MHz)", rs)
rset.set_apply_callback(apply_offset, vfo.a)
rset.set_doc("Set A Band TX frequency offset value.")
achannel.append(rset)
# Menu 27: Offset direction
rs = RadioSettingValueList(self._offset_list,
current_index=vfo.a.sftd)
rset = MemSetting("vfo.a.sftd", "Offset Direction", rs)
rset.set_doc("Set A Band TX frequency offset direction.")
achannel.append(rset)
# Menu 29: S-Code DTMF 1-15
rs = RadioSettingValueList(self._scode_list,
current_index=vfo.a.scode)
rset = MemSetting("vfo.a.scode", "S-CODE", rs)
rset.set_doc("Set the A Band DTMF code ID to use for PTT ID.")
achannel.append(rset)
# Menu 45: Scramble
rs = RadioSettingValueMap(self._scramble_map, vfo.a.scramble)
rset = MemSetting("vfo.a.scramble", "Scramble", rs)
rset.set_doc("Set A Band voice Scramble.")
achannel.append(rset)
# Menu 50: RX Modulation
if self._has_am_per_channel:
rs = RadioSettingValueList(self._rx_modulation_list,
current_index=vfo.a.rxmod)
rset = MemSetting("vfo.a.rxmod", "RX Modulation", rs)
rset.set_doc("Set A Band RX Modulation.")
achannel.append(rset)
# VFO B channel sub menu
bchannel = RadioSettingSubGroup("bchannel", "VFO B Channel")
abblock.append(bchannel)
# Work Mode B
rs = RadioSettingValueList(WORKMODE_LIST,
current_index=_settings.vfomrb)
rset = MemSetting("settings.vfomrb", "Work Mode", rs)
rset.set_doc("Set B Band Work Mode.")
bchannel.append(rset)
# VFO B Freq
rs = RadioSettingValueString(0, 10,
bfc.bcd_decode_freq(vfo.b.freq))
rs.set_validate_callback(freq_validate)
rset = RadioSetting("vfo.b.freq", "Frequency", rs)
rset.set_apply_callback(apply_freq, vfo.b)
rset.set_doc("Set B Band VFO frequency.")
bchannel.append(rset)
# Menu 01: B Step
rs = RadioSettingValueMap(self._step_map, vfo.b.step)
rset = MemSetting("vfo.b.step", "Tuning Step", rs)
rset.set_doc("Set B Band frequency Tuning Step.")
bchannel.append(rset)
# Menu 02: TX Power
rs = RadioSettingValueList([str(x) for x in self.POWER_LEVELS],
current_index=vfo.b.txpower)
rset = MemSetting("vfo.b.txpower", "TX Power", rs)
rset.set_doc("Set B Band TX Power.")
bchannel.append(rset)
# Menu 05: Wide/Narrow Band
rs = RadioSettingValueList(self._bandwidth_list,
current_index=vfo.b.widenarr)
rset = MemSetting("vfo.b.widenarr", "Bandwidth", rs)
rset.set_doc("Set B Band Bandwidth.")
bchannel.append(rset)
# Menu 12,13: RX ctcss/dtsc
rs = RadioSettingValueList(self._code_list,
current_index=self._code_list.index
(self.decode(vfo.b.rxtone)))
rset = RadioSetting("vfo.b.rxtone", "RX CTCSS/DCS", rs)
rset.set_apply_callback(self.apply_vfo_tone,
self._memobj.vfo.b, "rxtone")
rset.set_doc("Set B Band RX CTCSS or DCS code.")
bchannel.append(rset)
# Menu 14,15: TX ctcss/dtsc
rs = RadioSettingValueList(self._code_list,
current_index=self._code_list.index
(self.decode(vfo.b.txtone)))
rset = RadioSetting("vfo.b.txtone", "TX CTCSS/DCS", rs)
rset.set_apply_callback(self.apply_vfo_tone,
self._memobj.vfo.b, "txtone")
rset.set_doc("Set B Band TX CTCSS or DCS code.")
bchannel.append(rset)
# Menu 16: Voice Privacy (encryption)
rs = RadioSettingValueList(self._voicepri_list,
current_index=vfo.b.voicepri)
rset = MemSetting("vfo.b.voicepri",
"Voice Privacy - Subtone Encryption", rs)
rset.set_doc("Set B Band Voice Privacy - subtone voice encryption.")
bchannel.append(rset)
# Menu 26: Offset
rs = RadioSettingValueString(0, 10,
convert_bytes_to_offset(vfo.b.offset))
rset = RadioSetting("vfo.b.offset", "Offset (MHz)", rs)
rset.set_apply_callback(apply_offset, vfo.b)
rset.set_doc("Set B Band TX frequency offset value.")
bchannel.append(rset)
# Menu 27: Offset direction
rs = RadioSettingValueList(self._offset_list, current_index=vfo.b.sftd)
rset = MemSetting("vfo.b.sftd", "Offset Direction", rs)
rset.set_doc("Set B Band TX frequency offset direction.")
bchannel.append(rset)
# Menu 29: S-Code DTMF 1-15
rs = RadioSettingValueList(
self._scode_list, current_index=vfo.b.scode)
rset = MemSetting("vfo.b.scode", "S-CODE", rs)
rset.set_doc("Set the B Band DTMF code ID to use for PTT ID.")
bchannel.append(rset)
# Menu 45: Scramble
rs = RadioSettingValueMap(self._scramble_map, vfo.b.scramble)
rset = MemSetting("vfo.b.scramble", "Scramble", rs)
rset.set_doc("Set B Band voice Scramble.")
bchannel.append(rset)
# Menu 50: RX Modulation
if self._has_am_per_channel:
rs = RadioSettingValueList(self._rx_modulation_list,
current_index=vfo.b.rxmod)
rset = MemSetting("vfo.b.rxmod", "RX Modulation", rs)
rset.set_doc("Set B Band RX Modulation.")
bchannel.append(rset)
# SSB Settings, RT-920, BJ7800 Only
if self._has_hf:
ssbblock = RadioSettingGroup("ssbblock", "FM/AM/SSB Modulation")
spec.append(ssbblock)
# HF mode submenu
modes = RadioSettingSubGroup("modes", "Modes")
ssbblock.append(modes)
# SSB Work Mode
ssbwm = self._memobj.ssb_settings
rs = RadioSettingValueList(
self._ssb_workmode_list,
current_index=ssbwm.workmode
)
rset = MemSetting("ssb_settings.workmode", "Work Mode", rs)
rset.set_doc("Set HF Workmode.")
modes.append(rset)
# SSB Modulation Mode
ssb = self._memobj.ssb
rs = RadioSettingValueList(
self._ssb_modulation_list,
current_index=ssb.modulation
)
rset = MemSetting("ssb.modulation", "Modulation Mode", rs)
rset.set_doc("Set HF RX Modulation Mode.")
modes.append(rset)
# AM mode submenu
amsettings = RadioSettingSubGroup("amsettings", "AM Settings")
ssbblock.append(amsettings)
# AM Step Freq
stepfreq = self._memobj.stepfreq
rs = RadioSettingValueList(
self._am_step_freq_list,
current_index=stepfreq.am
)
rset = MemSetting("stepfreq.am", "Step Freq", rs)
rset.set_doc("Set HF AM RX Step Frequency.")
amsettings.append(rset)
# AM RX Gain
rs = RadioSettingValueList(
self._rx_gain_list,
current_index=ssb.am_rxgain
)
rset = MemSetting("ssb.am_rxgain", "RX Gain", rs)
rset.set_doc("Set HF AM RX Gain value.")
amsettings.append(rset)
# SSB mode submenu
ssbsettings = RadioSettingSubGroup("ssbsettings", "SSB Settings")
ssbblock.append(ssbsettings)
# SSB Step Freq
rs = RadioSettingValueList(
self._ssb_step_freq_list,
current_index=stepfreq.ssb
)
rset = MemSetting("stepfreq.ssb", "Step Freq", rs)
rset.set_doc("Set HF SSB RX Step Frequency.")
ssbsettings.append(rset)
# SSB RX Gain
rs = RadioSettingValueList(
self._rx_gain_list,
current_index=stepfreq.ssb_rxgain
)
rset = MemSetting("stepfreq.ssb_rxgain", "RX Gain", rs)
rset.set_doc("Set HF SSB RX Gain value.")
ssbsettings.append(rset)
return group
@classmethod
def get_prompts(cls):
rp = chirp_common.RadioPrompts()
rp.experimental = \
('This driver is a beta version ONLY for the RT-900 BT'
' running Firmware V.1.20P.\n'
'\n'
'Please save an unedited copy of your first successful\n'
'download to a CHIRP Radio Images(*.img) file.\n\n'
'PROCEED AT YOUR OWN RISK!'
)
rp.pre_download = (dedent("""\
1. Turn radio off.
2. Connect cable to mic/spkr connector.
3. Make sure connector is firmly connected.
4. Turn radio on (volume may need to be set at 100%).
5. Ensure that the radio is tuned to channel with no activity.
6. Click OK to download image from device."""))
rp.pre_upload = (dedent("""\
1. Turn radio off.
2. Connect cable to mic/spkr connector.
3. Make sure connector is firmly connected.
4. Turn radio on (volume may need to be set at 100%).
5. Ensure that the radio is tuned to channel with no activity.
6. Click OK to upload image to device."""))
return rp
def _decode_tone(self, memval):
"""Parse the tone data to decode from memval, it returns:
Mode (''|DTCS|Tone), Value (None|###), Polarity (None,N,R)"""
pol = None
if memval in [0, 0xFFFF]:
return "", None, None
elif memval >= 0x0258:
a = memval / 10.0
return "Tone", a, pol
else:
if memval > 0x69:
index = memval - 0x6A
pol = "R"
else:
index = memval - 1
pol = "N"
tone = DTCS[index]
return "DTCS", tone, pol
def _encode_tone(self, mem, memval, mode, value, pol):
"""Parse the tone data to encode from UI to mem"""
match mode:
case "" | None:
memval.fill_raw(b"\x00")
case "Tone" | "TSQL":
memval.set_value(int(value * 10))
case "DTCS":
try:
index = DTCS.index(value)
if pol == "N":
index += 1
else:
index += 0x6A
memval.set_value(index)
except ValueError:
msg = "DTCS Code '%d' is not supported" % value
LOG.error(msg)
raise errors.RadioError(msg)
case _:
raise Exception("Internal error: invalid mode '%s'" % mode)
def decode(self, code):
"""decode radio stored VFO tone code into human readable form"""
if code in [0, 0xffff]:
tone = 'Off' # Off
elif code >= 0x0258: # CTCSS
tone = "%2.1fHz" % (int(code) / 10.0)
elif code <= 0x0258: # DCS
if code > 0x69: # inverse
index = code - 0x6a
dtcs_pol = 'I'
else: # normal
index = code - 1
dtcs_pol = 'N'
tone = 'D' + "%03i" % (self._dcs[index]) + dtcs_pol
else:
msg = "Invalid tone code from radio: %s" % hex(code)
LOG.exception(msg)
raise InvalidValueError(msg)
return tone
def apply_vfo_tone(self, setting, obj, which):
"""encode VFO tone from UI into radio storable tone code
and apply to mem"""
mem = getattr(obj, which)
try:
tone = self._code_list[int(setting.value)]
if tone == "Off":
code = 0
elif tone.endswith('Hz'): # CTCSS
code = int(float(tone[0:tone.index('Hz')]) * 10)
elif tone.startswith('D'): # DCS
index = self._dcs.index(int(tone[1:4]))
if tone.endswith('I'): # inverse
code = index + 0x6a
elif tone.endswith('N'): # normal
code = index + 1
except (IndexError, ValueError):
msg = "Unknown CTCSS/DTC tone: %s" % tone
LOG.exception(msg)
raise InvalidValueError(msg)
mem.set_value(code)
def get_features(self):
rf = get_default_features(self)
rf.valid_bands = self.VALID_BANDS
rf.valid_modes = ["FM", "NFM", "AM", "NAM"] # 25kHz, 12.5kHz, AM, NAM
rf.valid_tuning_steps = self._steps
return rf
def get_raw_memory(self, number):
return repr(self._memobj.memory[number - 1])
def get_memory(self, number):
"""Get the mem representation from the radio image"""
_mem = self._memobj.memory[number - 1]
# Create a high-level memory object to return to the UI
mem = chirp_common.Memory()
# Memory number
mem.number = number
if _mem.get_raw()[:1] == b"\xff":
mem.empty = True
return mem
# Freq and offset
mem.freq = int(_mem.rxfreq) * 10
if mem.freq == 0:
mem.empty = True
# tx freq can be blank
if _mem.txfreq.get_raw() == b"\xff\xff\xff\xff":
# TX freq not set
mem.offset = 0
mem.duplex = "off"
else:
# TX freq set
offset = (int(_mem.txfreq) * 10) - mem.freq
if offset != 0:
if chirp_common.is_split(self.get_features().valid_bands,
mem.freq, int(_mem.txfreq) * 10):
mem.duplex = "split"
mem.offset = int(_mem.txfreq) * 10
elif offset < 0:
mem.offset = abs(offset)
mem.duplex = "-"
elif offset > 0:
mem.offset = offset
mem.duplex = "+"
else:
mem.offset = 0
for char in _mem.name:
if str(char) == "\xFF":
char = " " # may have 0xFF mid-name
mem.name += str(char)
mem.name = mem.name.rstrip().replace('\x00', '')
txtone = rxtone = None
txtone = self._decode_tone(_mem.txtone)
rxtone = self._decode_tone(_mem.rxtone)
chirp_common.split_tone_decode(mem, txtone, rxtone)
if not _mem.scan:
mem.skip = "S"
_levels = self.POWER_LEVELS
if _mem.txpower == TXPOWER_HIGH:
mem.power = _levels[0]
elif _mem.txpower == TXPOWER_MID:
mem.power = _levels[1]
elif _mem.txpower == TXPOWER_LOW:
mem.power = _levels[2]
else:
LOG.error('%s: get_mem: unhandled power level: 0x%02x' %
(mem.name, _mem.txpower))
mem.mode = _mem.narrow and "NFM" or "FM"
if chirp_common.in_range(
mem.freq, self._AIRBANDS
) or _mem.am_modulation == 0b1:
mem.mode = _mem.narrow and "NAM" or 'AM'
mem.extra = RadioSettingGroup("Extra", "extra")
# Encryption
rs = RadioSettingValueList(
self._voicepri_list,
current_index=_mem.encrypt
)
rset = RadioSetting("encrypt", "Voice Privacy", rs)
mem.extra.append(rset)
# Scramble
rs = RadioSettingValueMap(self._scramble_map, _mem.scramble)
rset = RadioSetting("scramble", "Scramble", rs)
mem.extra.append(rset)
# BCL (Busy Channel Lockout)
rs = RadioSettingValueBoolean(_mem.bcl)
rset = RadioSetting("bcl", "BCL", rs)
rset.set_doc("Set Busy Channel Lockout. When selected, disables PTT "
"when the current channel is busy.")
mem.extra.append(rset)
# LearnFHSS (per-channel learn / FHSS flag). The OEM CPS labels
# this column "LearnFHSS"; the open-source firmware reads the
# same bit as chFlag3.b0 / fhssFlag (Core/Radio.c).
rs = RadioSettingValueBoolean(_mem.learning)
rset = RadioSetting("learning", "Learn FHSS", rs)
rset.set_doc("Enable to allow automatic FHSS code selection.")
mem.extra.append(rset)
# FHSS Code (24-bit little-endian, range 0x000000-0x7FFFFF).
# Displayed and accepted as a 6-digit uppercase hex string, or
# blank to clear the code (raw 0xFFFFFF). Validation is hoisted
# to a module-level function so this RadioSetting stays
# picklable for clipboard copy.
rs = RadioSettingValueString(0, 6, _fhss_code_to_text(_mem.code))
rs.set_validate_callback(_validate_fhss_code)
rset = RadioSetting("fhss_code", "FHSS Code (hex)", rs)
rset.set_doc("Enter manual FHSS Code using HEX digits.")
mem.extra.append(rset)
# PTT-ID
rs = RadioSettingValueList(PTTID_LIST, current_index=_mem.pttid)
rset = RadioSetting("pttid", "PTT ID", rs)
rset.set_doc("Set when the PTT-ID is to be sent.")
mem.extra.append(rset)
# Signal (DTMF Encoder Group #)
rs = RadioSettingValueList(PTTIDCODE_LIST, current_index=_mem.scode)
rset = RadioSetting("scode", "PTT ID Code", rs)
rset.set_doc("Set the DTMF code ID to use for PTT ID.")
mem.extra.append(rset)
return mem
def set_memory(self, mem):
_mem = self._memobj.memory[mem.number - 1]
if mem.empty:
_mem.fill_raw(b"\xff")
return
_mem.set_raw("\x00" * 16 + "\xff" * 16)
_mem.rxfreq = mem.freq / 10
if mem.duplex == "off":
_mem.txfreq.fill_raw(b"\xff")
elif mem.duplex == "split":
_mem.txfreq = mem.offset / 10
elif mem.duplex == "+":
_mem.txfreq = (mem.freq + mem.offset) / 10
elif mem.duplex == "-":
_mem.txfreq = (mem.freq - mem.offset) / 10
else:
_mem.txfreq = mem.freq / 10
_namelength = self.get_features().valid_name_length
for i in range(_namelength):
try:
_mem.name[i] = mem.name[i]
except IndexError:
_mem.name[i] = "\xff"
txmode = rxmode = ''
txval = rxval = 0
txpol = rxpol = None
((txmode, txval, txpol),
(rxmode, rxval, rxpol)) = chirp_common.split_tone_encode(mem)
self._encode_tone(mem, _mem.txtone, txmode, txval, txpol)
self._encode_tone(mem, _mem.rxtone, rxmode, rxval, rxpol)
_mem.scan = mem.skip != "S"
_mem.narrow = mem.mode == "NFM"
_levels = self.POWER_LEVELS
if mem.power is None:
_mem.txpower = TXPOWER_HIGH
elif mem.power == _levels[0]:
_mem.txpower = TXPOWER_HIGH
elif mem.power == _levels[1]:
_mem.txpower = TXPOWER_MID
elif mem.power == _levels[2]:
_mem.txpower = TXPOWER_LOW
else:
LOG.error('%s: set_mem: unhandled power level: %s' %
(mem.name, mem.power))
match mem.mode:
case 'AM': # radio allows AM per channel
_mem.am_modulation = 0b1
_mem.narrow = 0b0
case "NAM": # radio allows narrow AM per channel
_mem.am_modulation = 0b1
_mem.narrow = 0b1
case 'FM':
_mem.am_modulation = 0b0
_mem.narrow = 0b0
case 'NFM':
_mem.am_modulation = 0b0
_mem.narrow = 0b1
for setting in mem.extra:
if setting.get_name() == 'fhss_code':
# Mirror OEM CPS: blank input clears Code (0xFFFFFF) and
# restores the adjacent flag byte to 0xFF; any value
# writes Code and sets the flag byte to 0xA0.
s = str(setting.value).strip()
if s == "":
_mem.code = FHSS_CODE_NULL
_mem.code_flag = FHSS_CODE_FLAG_NULL
else:
_mem.code = int(s, 16)
_mem.code_flag = FHSS_CODE_FLAG_ACTIVE
else:
setattr(_mem, setting.get_name(), setting.value)
def validate_memory(self, mem):
msgs = []
in_range = chirp_common.in_range
AM_mode = 'AM' in mem.mode
if in_range(mem.freq, self._AIRBANDS) and not AM_mode:
msgs.append(chirp_common.ValidationMessage(
_('Frequency in this range requires AM mode')))
return msgs + super().validate_memory(mem)
def set_settings(self, settings):
# apply all Memsettings
all_other_settings = settings.apply_to(self._memobj)
for setting in all_other_settings:
if setting.has_apply_callback():
# use callbacks on Radiosettings that need postprocessing
setting.run_apply_callback()
def process_mmap(self):
mem_format = MEM_FORMAT % self._mem_params
self._memobj = bitwise.parse(mem_format, self._mmap)
@directory.register
class RT900(RT900BT):
# ==========
# Notice to developers:
# The RT-900 support in this driver is currently based upon stock
# factory firmware, V0.14P
# ==========
"""Radtel RT-900 (without Bluetooth)"""
VENDOR = "Radtel"
MODEL = "RT-900"
_has_bt_denoise = False
_has_am_per_channel = False
_has_am_switch = not _has_am_per_channel
_has_single_mode = False
_has_hf = False
_upper = 999 # fw V1.14P expands from 512 to 999 channels
SKEY_LIST = ["FM Radio",
"TX Power Level",
"Scan",
"Search",
"NOAA Weather",
"SOS",
"Flashlight" # Not used in BT model
]
SKEY_SP_LIST = SKEY_LIST
def get_features(self):
rf = super().get_features()
# So far no firmware update to test new range availability yet
# rf.valid_bands = [(18000000, 1000000000)]
return rf
@classmethod
def get_prompts(cls):
rp = super().get_prompts()
rp.experimental = \
('This driver is a beta version for the RT-900'
' running Firmware V0.14P\n'
'\n'
'Please save an unedited copy of your first successful\n'
'download to a CHIRP Radio Images(*.img) file.\n\n'
'PROCEED AT YOUR OWN RISK!'
)
return rp
@directory.register
class RT910BT(RT900BT):
# ==========
# Notice to developers:
# The RT-910 BT support in this driver is currently based upon V0.24P
# firmware with 15 banks/zones of 64 channels steps.
# ==========
"""Radtel RT-910_BT 960"""
VENDOR = "Radtel"
MODEL = "RT-910_BT"
SKEY_LIST = ["Radio",
"TX Power",
"Scan",
"Search",
"NOAA",
"SOS",
"Spectrum"]
SKEY_SP_LIST = SKEY_LIST + ["PTTB"]
_upper = 960 # fw V0.24P supports 960 channels
_mem_params = (_upper, # number of channels
)
_ranges = [
(0x0000, 0x7800), # 15 zones of 64 frequencies,
# equals 960 channels of 32 bytes each
# 15 * 64 * 32 = 0x7800
(0x8000, 0x8040),
(0x9000, 0x9040),
(0xA000, 0xA140),
(0xD000, 0xD040) # Radio mode hidden setting
]
_has_bt_denoise = True
_has_am_per_channel = True
_has_am_switch = not _has_am_per_channel
_has_single_mode = False
def get_bank_model(self):
return chirp_common.StaticBankModel(self, banks=15)
def get_features(self):
rf = super().get_features()
rf.has_bank = True # Firmware V0.24P supports 15
# "static zones" of 64 frequencies
rf.valid_tuning_steps = self._steps
return rf
@classmethod
def get_prompts(cls):
rp = super().get_prompts()
rp.experimental = \
('This driver is a beta version for the RT-910 BT'
' running Firmware V0.24P\n'
'\n'
'Please save an unedited copy of your first successful\n'
'download to a CHIRP Radio Images(*.img) file.\n\n'
'PROCEED AT YOUR OWN RISK!'
)
return rp
@directory.register
class RT910(RT910BT):
# ==========
# Notice to developers:
# The RT-910 support in this driver is currently based upon V0.11
# firmware with 15 banks/zones of 64 channel steps.
# ==========
"""Radtel RT-910 960 (without Bluetooth)"""
VENDOR = "Radtel"
MODEL = "RT-910"
_upper = 960 # fw V0.11 supports 960 channels
_mem_params = (_upper, # number of channels
)
_ranges = [
(0x0000, 0x7800), # 15 zones of 64 frequencies,
# equals 960 channels of 32 bytes each
# 15 * 64 * 32 = 0x7800
(0x8000, 0x8040),
(0x9000, 0x9040),
(0xA000, 0xA140),
(0xD000, 0xD040) # Radio mode hidden setting
]
_has_bt_denoise = False
_has_am_per_channel = True
_has_am_switch = not _has_am_per_channel
_has_single_mode = True
_has_hf = False
def get_bank_model(self):
return chirp_common.StaticBankModel(self, banks=15)
@classmethod
def get_prompts(cls):
rp = super().get_prompts()
rp.experimental = \
('This driver is a beta version for the RT-910'
' Non-Bluetooth running Firmware V0.11\n'
'\n'
'Please save an unedited copy of your first successful\n'
'download to a CHIRP Radio Images(*.img) file.\n\n'
'PROCEED AT YOUR OWN RISK!'
)
return rp
class RT920Bank(chirp_common.NamedBank):
"""RT-920 Bank"""
def get_name(self):
"""decode bank name from char array into string"""
_bank = self._model._radio._memobj.zones[self._index - 1]
name = str(_bank.name).rstrip(" \n\t\x00\xff") # remove filler chars
if len(name) == 0:
name = "ZONE %i" % self._index
return name
def set_name(self, name):
"""encode bank name into \xff filled char array"""
_bank = self._model._radio._memobj.zones[self._index - 1]
_bank.name = name[:len(_bank.name)].rstrip()\
.ljust(len(_bank.name), "\xff")
class RT920BankModel(chirp_common.StaticBankModel):
"""RT-920 Bank Model"""
def __init__(self, radio, name, banks):
super(RT920BankModel, self).__init__(radio, name, banks)
self._num_banks = banks
self._rf = radio.get_features()
self._banks = []
for i in range(self._num_banks):
self._banks.append(RT920Bank(self, i + 1, "ZONE %i" % (i + 1)))
@directory.register
class RT920(RT900BT):
# ==========
# Notice to developers:
# The RT-920 support in this driver is currently based upon V0.18
# firmware with 10 banks/zones of 99 channels.
# ==========
"""Radtel RT-920"""
VENDOR = "Radtel"
MODEL = "RT-920"
_magic = b"PROGRAMBT11U" # RT-920
# step of 1.25 to allow UK CB Freqs
_steps = [1.25, 2.5, 5.0, 6.25, 8.33, 10.0, 12.5, 20.0, 25.0, 50.0]
SKEY_LIST = ["Radio",
"TX Power",
"Scan",
"Search",
"NOAA",
"SOS",
"Spectrum"]
SKEY_SP_LIST = SKEY_LIST + ["PTTB"]
_zone_or_channel_list = ["Zone Mode", "Full Channel"]
_ssb_modulation_list = [
"FM",
"AM",
"LSB",
"USB",
"CW",
]
_ssb_workmode_list = [
"VFO Mode",
"CH Mode",
]
_am_step_freq_list = [
"1K",
"5K",
"9K",
"10K",
"100K",
]
_ssb_step_freq_list = [
"1K",
"5K",
"10K",
"100K",
"500K",
"1000K",
]
_rx_gain_list = ["AGC"] + \
["%ddB" % x for x in range(0, -36, -1)]
_upper = 990 # fw V0.18 supports 990 channels
_mem_params = (_upper, # number of channels
)
_banks = 10
_ranges = [
(0x0000, 0x7BC0), # 10 zones of 99 frequencies,
# equals 990 channels of 32 bytes each
# 10 * 99 * 32 = 0x7BC0
(0x8000, 0x8040),
(0x9000, 0x9040),
(0xA000, 0xA140),
(0xB000, 0xB400), # FM, AM, HF frequencies
(0xC000, 0xC400), # FM, AM, HF names
(0xC800, 0XC8A0), # static bank names, 10 banks * 16 bytes ea = 0xA0
(0xD000, 0xD040), # Radio mode hidden setting
]
_rt920_specific_fmt = """
#seekto 0xb000;
// 2 byte fm vfo freq
struct {
ul16 freq;
} fm_vfo;
// 15ea 2 byte fm chan freq
struct {
ul16 freq;
} fm_freqs[%d];
#seekto 0xb021; // SSB settings
struct {
u8 workmode; // VFO/Ch
} ssb_settings;
#seekto 0xb022;
// 2 byte am vfo freq
struct {
ul16 freq;
} am_vfo;
// 15ea 2 byte am chan freq
struct {
ul16 freq;
} am_freqs[%d];
#seekto 0xb043; // ssb
struct {
u8 modulation; // modulation mode
u8 am_rxgain; // AM RX gain
} ssb;
#seekto 0xb045;
// 5 byte hf vfo chan
struct {
ul16 freq;
u8 bandwidth;
il16 beatfreq; // can be negitive
} hf_vfo;
// 15ea 5 byte hf chans
struct {
ul16 freq;
u8 bandwidth;
il16 beatfreq; // can be negitive
} hf_freqs[%d];
#seekto 0xb096;
struct {
u8 ssb;
u8 am;
u8 ssb_rxgain;
} stepfreq;
#seekto 0xc010; // 15ea 16 byte fm chan names
struct {
char name[12];
u8 unused[4];
} fm_names[%d];
#seekto 0xc110; // 15ea 16 byte am chan names (RT-920 fw v 0.xx)
struct {
char name[12];
u8 unused[4];
} am_names[%d];
#seekto 0xc210; // 15ea 16 byte ssb chan names (RT-920 fw v 0.xx)
struct {
char name[12];
u8 unused[4];
} hf_names[%d];
#seekto 0xC800; // 10ea 16 byte zone names (RT-920 fw V0.17)
struct {
char name[10];
u8 unused[6];
} zones[%d];
"""
_has_bt_denoise = True
_has_am_per_channel = True
_has_am_switch = not _has_am_per_channel
_has_single_mode = True
_has_zone_or_channel = True
_has_zone_names = True
_has_sp0 = False # spkey addresses are not shifted
_has_hf = True
def get_bank_model(self):
return RT920BankModel(self, "Zones", self._banks)
def get_features(self):
rf = super().get_features()
# Firmware V0.18 supports 10
# optional "static zones" of 99 frequencies
# or 990 flat chanels
if self._memobj is not None and hasattr(self._memobj, "settings"):
rf.has_bank = not self._memobj.settings.zone_or_channel
else:
rf.has_bank = False # default to flat mode if settings not init'ed
rf.has_bank_names = self._has_zone_names
rf.valid_tuning_steps = self._steps
rf.has_sub_devices = self._has_hf
return rf
def process_mmap(self):
AUX_CHANS_FM = AUX_CHANS_AM = AUX_CHANS_HF = 15
mem_format = MEM_FORMAT % self._mem_params + \
self._rt920_specific_fmt % (
AUX_CHANS_FM,
AUX_CHANS_AM,
AUX_CHANS_HF,
AUX_CHANS_FM,
AUX_CHANS_AM,
AUX_CHANS_HF,
self._banks,
)
self._memobj = bitwise.parse(mem_format, self._mmap)
@classmethod
def get_prompts(cls):
rp = super().get_prompts()
rp.experimental = \
('This driver is a beta version for the RT-920'
' running Firmware V0.18\n'
'\n'
'Please save an unedited copy of your first successful\n'
'download to a CHIRP Radio Images(*.img) file.\n\n'
'PROCEED AT YOUR OWN RISK!'
)
return rp
def get_sub_devices(self):
return [RT920VhfUfh(self._mmap),
RT920FM(self._mmap),
RT920AM(self._mmap),
RT920HF(self._mmap),
]
class RT920VhfUfh(RT920):
"""Radtel RT-920 VHF/UHF subdevice"""
VENDOR = "Radtel"
MODEL = "RT-920"
VARIANT = "VHF/UHF"
class RT920FM(RT920):
"""Radtel RT-920 FM broadcast subdevice"""
VENDOR = "Radtel"
MODEL = "RT-920"
VARIANT = "FM Broadcast"
_upper = 15
_mem_params = (_upper, # number of channels
)
_valid_bands = [(64000000, 108000000)] # in Mhz, 64.0-108 MHz
SPECIAL_CHANNELS = ["VFO"]
def get_features(self):
rf = chirp_common.RadioFeatures()
rf.valid_bands = self._valid_bands
rf.memory_bounds = (1, self._upper)
rf.can_delete = True
rf.can_odd_split = False
rf.has_bank = False
rf.has_bank_index = False
rf.has_bank_names = False
rf.has_comment = False
rf.has_cross = False
rf.has_ctone = False
rf.has_dtcs = False
rf.has_dtcs_polarity = False
rf.has_mode = True
rf.has_offset = False
rf.has_settings = False
rf.has_sub_devices = False
rf.has_tuning_step = False
rf.valid_characters = RT900._valid_chars
rf.valid_cross_modes = []
rf.valid_dtcs_codes = []
rf.valid_dtcs_pols = []
rf.valid_duplexes = []
rf.valid_modes = ["AM", "WFM", "Auto"]
rf.valid_name_length = 12
rf.valid_skips = []
rf.valid_special_chans = self.SPECIAL_CHANNELS
rf.valid_tuning_steps = [
1.0, 2.5, 5.0, 6.25, 8.33, 10.0, 12.5, 20.0, 25.0, 50.0,
]
rf.valid_tmodes = []
rf.valid_tones = []
return rf
def get_raw_memory(self, number):
if isinstance(number, str):
return repr(self._memobj.fm_vfo)
else:
return (repr(self._memobj.fm_freqs[number - 1]) +
repr(self._memobj.fm_names[number - 1]))
def get_memory(self, number):
mem = chirp_common.Memory()
if isinstance(number, str):
mem.number = self._upper + self.SPECIAL_CHANNELS.index(number) + 1
mem.extd_number = number
_mem = self._memobj.fm_vfo
else:
mem.number = number
_mem = self._memobj.fm_freqs[number - 1]
_name = self._memobj.fm_names[number - 1]
freq = int(_mem.freq) * 10000
if freq == 0:
mem.empty = True
return mem
mem.freq = freq
if mem.number > self._upper:
mem.immutable += ["name"]
else:
mem.name = str(_name.name).rstrip("\xff ")
mem.mode = "WFM"
mem.immutable += ["mode", "ctone", "rtone"]
return mem
def set_memory(self, mem):
if mem.number > self._upper:
_mem = self._memobj.fm_vfo
else:
_mem = self._memobj.fm_freqs[mem.number - 1]
_name = self._memobj.fm_names[mem.number - 1]
if mem.empty:
_mem.freq.fill_raw(b"\x00")
if mem.number <= self._upper:
_name.name.fill_raw(b"\xff")
return
_mem.freq = int(mem.freq / 10000)
if mem.number <= self._upper:
_name.name = mem.name.ljust(12, "\xff")
class RT920AM(RT920FM):
"""Radtel RT-920 AM broadcast subdevice"""
VENDOR = "Radtel"
MODEL = "RT-920"
VARIANT = "AM Broadcast"
_valid_bands = [(153000, 279000), # in Mhz, 153-279 KHz
(520000, 1710000), # 520-1710 KHz
(2300000, 26100000), # 2300-26100 KHz
]
def get_raw_memory(self, number):
if isinstance(number, str):
return repr(self._memobj.am_vfo)
else:
return (repr(self._memobj.am_freqs[number - 1]) +
repr(self._memobj.am_names[number - 1]))
def get_memory(self, number):
mem = chirp_common.Memory()
if isinstance(number, str):
mem.number = self._upper + self.SPECIAL_CHANNELS.index(number) + 1
mem.extd_number = number
_mem = self._memobj.am_vfo
else:
mem.number = number
_mem = self._memobj.am_freqs[number - 1]
_name = self._memobj.am_names[number - 1]
freq = int(_mem.freq) * 1000
if freq == 0:
mem.empty = True
return mem
mem.freq = freq
if mem.number > self._upper:
mem.immutable += ["name"]
else:
mem.name = str(_name.name).rstrip("\xff ")
mem.mode = "AM"
mem.immutable += ["mode", "ctone", "rtone"]
return mem
def set_memory(self, mem):
if mem.number > self._upper:
_mem = self._memobj.am_vfo
else:
_mem = self._memobj.am_freqs[mem.number - 1]
_name = self._memobj.am_names[mem.number - 1]
if mem.empty:
_mem.freq.fill_raw(b"\x00")
if mem.number <= self._upper:
_name.name.fill_raw(b"\xff")
return
_mem.freq = int(mem.freq / 1000)
if mem.number <= self._upper:
_name.name = mem.name.ljust(12, "\xff")
class RT920HF(RT920FM):
"""Radtel RT-920 HF LSB, USB, CW subdevice"""
VENDOR = "Radtel"
MODEL = "RT-920"
VARIANT = "HF"
_valid_bands = [(150000, 30000000)] # in Mhz, 150-30000 KHz
_ssb_bandwidth_list = [
"0.5K", "1.0K", "1.2K", "2.2K", "3.0K", "4.0K",
]
def get_raw_memory(self, number):
if isinstance(number, str):
return repr(self._memobj.hf_vfo)
else:
return (repr(self._memobj.hf_freqs[number - 1]) +
repr(self._memobj.hf_names[number - 1]))
def get_memory(self, number):
mem = chirp_common.Memory()
if isinstance(number, str):
mem.number = self._upper + self.SPECIAL_CHANNELS.index(number) + 1
mem.extd_number = number
_mem = self._memobj.hf_vfo
else:
mem.number = number
_mem = self._memobj.hf_freqs[number - 1]
_name = self._memobj.hf_names[number - 1]
freq = int(_mem.freq) * 1000
if freq == 0:
mem.empty = True
return mem
mem.freq = freq
if mem.number > self._upper:
mem.immutable += ["name"]
else:
mem.name = str(_name.name).rstrip("\xff ")
# use Modulation Mode from SSB settings to determine Mode
# defaut to LSB if AM or FM is selected as SSB Modulation Mode
_ssb_mod = self._memobj.ssb.modulation
mem.mode = "LSB" if self._ssb_modulation_list[_ssb_mod] \
in ["AM", "FM"] else \
self._ssb_modulation_list[_ssb_mod]
mem.immutable += ["mode", "ctone", "rtone"]
mem.extra = RadioSettingGroup("Extra", "extra")
# Bandwidth
rs = RadioSettingValueList(
self._ssb_bandwidth_list,
current_index=int(_mem.bandwidth)
)
rset = RadioSetting("bandwidth", "Bandwidth", rs)
rset.set_doc("SSB Channel Bandwidth (KHz).")
mem.extra.append(rset)
# Beat Freq
rs = RadioSettingValueInteger(-32760, 27240, int(_mem.beatfreq), 1)
rset = RadioSetting("beatfreq", "Beat Freq Offset (Hz)", rs)
rset.set_doc("SSB Beat Frequency Offset (Hz).")
mem.extra.append(rset)
return mem
def set_memory(self, mem):
if mem.number > self._upper:
_mem = self._memobj.hf_vfo
else:
_mem = self._memobj.hf_freqs[mem.number - 1]
_name = self._memobj.hf_names[mem.number - 1]
if mem.empty:
_mem.fill_raw(b"\x00")
if mem.number <= self._upper:
_name.name.fill_raw(b"\xff")
return
_mem.freq = int(mem.freq / 1000)
if mem.number <= self._upper:
_name.name = mem.name.ljust(12, "\xff")
for setting in mem.extra:
setattr(_mem, setting.get_name(), int(setting.value))
@directory.register
class RadioddityGS10B(RT900BT):
# ==========
# Radioddity GS-10B: RT-900 BT variant with 256 channels.
# Same magic (PROGRAMBT80U), fingerprints, and protocol as the
# RT-900 BT. Memory layout is identical but with fewer channels.
# Based on firmware V0.03.
# ==========
"""Radioddity GS-10B"""
VENDOR = "Radioddity"
MODEL = "GS-10B"
_upper = 256 # 256 channels
_has_single_mode = False
_mem_params = (_upper, # number of channels
)
_ranges = [
(0x0000, 0x2000), # 256 channels of 32 bytes each
# 256 * 32 = 0x2000
(0x8000, 0x8040),
(0x9000, 0x9040),
(0xA000, 0xA140),
(0xD000, 0xD040), # Radio mode hidden setting
]
@classmethod
def get_prompts(cls):
rp = super().get_prompts()
rp.experimental = \
('This driver is a beta version for the Radioddity GS-10B\n'
'\n'
'Please save an unedited copy of your first successful\n'
'download to a CHIRP Radio Images(*.img) file.\n\n'
'PROCEED AT YOUR OWN RISK!'
)
return rp
@directory.register
class BJ7800(RT920):
# ==========
# Notice to developers:
# The BJ7800 support in this driver is currently based upon V0.15P
# firmware with 15 banks/zones of 64 channels.
# Should also work with the SHU H28Y Pro
# ==========
"""Bajeton BJ7800"""
VENDOR = "Bajeton"
MODEL = "BJ7800"
_upper = 960 # fw V0.15P supports 960 channels
_mem_params = (_upper, # number of channels
)
_banks = 15
_ranges = [
(0x0000, 0x7800), # 15 zones of 64 frequencies,
# equals 960 channels of 32 bytes each
# 15 * 64 * 32 = 0X7800
(0x8000, 0x8040),
(0x9000, 0x9040),
(0xB000, 0xB400), # FM, AM, HF frequencies
(0xC000, 0xC400), # FM, AM, HF names
(0xA000, 0xA140),
(0xD000, 0xD040), # Radio mode hidden setting
]
_has_bt_denoise = True
_has_am_per_channel = True
_has_am_switch = not _has_am_per_channel
_has_single_mode = False
_has_zone_or_channel = False
_has_zone_names = False # dosen't have named zones like the RT-920
_has_hf = True
def get_bank_model(self):
return chirp_common.StaticBankModel(self, banks=self._banks)
def get_features(self):
rf = super().get_features()
# Firmware V0.15P supports 15
# "static zones" of 64 frequencies
# for 960 channels
rf.has_bank = True
rf.has_bank_names = self._has_zone_names
rf.valid_tuning_steps = self._steps
rf.has_sub_devices = self._has_hf
return rf
@classmethod
def get_prompts(cls):
rp = super().get_prompts()
rp.experimental = \
('This driver is a beta version for the BJ7800'
' running Firmware V0.15P\n'
'\n'
'Please save an unedited copy of your first successful\n'
'download to a CHIRP Radio Images(*.img) file.\n\n'
'PROCEED AT YOUR OWN RISK!'
)
return rp
def get_sub_devices(self):
return [BJ7800VhfUfh(self._mmap),
RT920FM(self._mmap),
RT920AM(self._mmap),
RT920HF(self._mmap),
]
class BJ7800VhfUfh(BJ7800):
"""Bajeton BJ7800 VHF/UHF subdevice"""
VENDOR = "Bajeton"
MODEL = "BJ7800"
VARIANT = "VHF/UHF"
chirp-20261030/chirp/drivers/radtel_t18.py 0000644 0001750 0001750 00000152730 15255434330 017152 0 ustar hibby hibby # Copyright 2021 Jim Unroe
#
# 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 2 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
#
# 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 2 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
#
# 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 2 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