[hamradio-commits] [chirp] 01/06: Imported Upstream version 20160415

Iain R. Learmonth irl at moszumanska.debian.org
Fri Apr 15 15:37:08 UTC 2016


This is an automated email from the git hooks/post-receive script.

irl pushed a commit to branch master
in repository chirp.

commit 5fe7ea0f5ef41f738666aaecb905eb89413973df
Author: Iain R. Learmonth <irl at debian.org>
Date:   Fri Apr 15 16:00:00 2016 +0100

    Imported Upstream version 20160415
---
 PKG-INFO               |   2 +-
 chirp/__init__.py      |   2 +-
 chirp/drivers/btech.py | 606 ++++++++++++++++++++++++++++++++++++++++++++++++-
 3 files changed, 601 insertions(+), 9 deletions(-)

diff --git a/PKG-INFO b/PKG-INFO
index 87068e2..46ae445 100644
--- a/PKG-INFO
+++ b/PKG-INFO
@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: chirp
-Version: daily-20160402
+Version: daily-20160415
 Summary: UNKNOWN
 Home-page: UNKNOWN
 Author: UNKNOWN
diff --git a/chirp/__init__.py b/chirp/__init__.py
index 181425a..c9d93c9 100644
--- a/chirp/__init__.py
+++ b/chirp/__init__.py
@@ -17,7 +17,7 @@ import os
 import sys
 from glob import glob
 
-CHIRP_VERSION="daily-20160402"
+CHIRP_VERSION="daily-20160415"
 
 module_dir = os.path.dirname(sys.modules["chirp"].__file__)
 __all__ = []
diff --git a/chirp/drivers/btech.py b/chirp/drivers/btech.py
index 67ed1f3..26c3c0e 100644
--- a/chirp/drivers/btech.py
+++ b/chirp/drivers/btech.py
@@ -26,7 +26,7 @@ from chirp import bitwise, errors, util
 from chirp.settings import RadioSettingGroup, RadioSetting, \
     RadioSettingValueBoolean, RadioSettingValueList, \
     RadioSettingValueString, RadioSettingValueInteger, \
-    RadioSettings
+    RadioSettings, InvalidValueError
 from textwrap import dedent
 
 MEM_FORMAT = """
@@ -54,6 +54,98 @@ struct {
      pttid:2;
 } memory[200];
 
+#seekto 0x0E00;
+struct {
+  u8 tdr;
+  u8 unknown1;
+  u8 sql;
+  u8 unknown2[2];
+  u8 tot;
+  u8 apo;           // BTech radios use this as the Auto Power Off time
+                    // other radios use this as pre-Time Out Alert
+  u8 unknown3;
+  u8 abr;
+  u8 beep;
+  u8 unknown4[4];
+  u8 dtmfst;
+  u8 unknown5[2];
+  u8 prisc;
+  u8 prich;
+  u8 screv;
+  u8 unknown6[2];
+  u8 pttid;
+  u8 pttlt;
+  u8 unknown7;
+  u8 emctp;
+  u8 emcch;
+  u8 ringt;
+  u8 unknown8;
+  u8 camdf;
+  u8 cbmdf;
+  u8 sync;          // BTech radios use this as the display sync setting
+                    // other radios use this as the auto keypad lock setting
+  u8 ponmsg;
+  u8 wtled;
+  u8 rxled;
+  u8 txled;
+  u8 unknown9[5];
+  u8 anil;
+  u8 reps;
+  u8 repm;
+  u8 tdrab;
+  u8 ste;
+  u8 rpste;
+  u8 rptdl;
+} settings;
+
+#seekto 0x0E80;
+struct {
+  u8 unknown1;
+  u8 vfomr;
+  u8 keylock;
+  u8 unknown2;
+  u8 unknown3:4,
+     vfomren:1,
+     unknown4:1,
+     reseten:1,
+     menuen:1;
+  u8 unknown5[11];
+  u8 dispab;
+  u8 mrcha;
+  u8 mrchb;
+  u8 menu;
+} settings2;
+
+#seekto 0x0EC0;
+struct {
+  char line1[6];
+  char line2[6];
+} poweron_msg;
+
+struct settings_vfo {
+  u8 freq[8];
+  u8 unknown1;
+  u8 offset[4];
+  u8 unknown2[3];
+  ul16 rxtone;
+  ul16 txtone;
+  u8 scode;
+  u8 spmute;
+  u8 optsig;
+  u8 scramble;
+  u8 wide;
+  u8 power;
+  u8 shiftd;
+  u8 step;
+  u8 unknown3[4];
+};
+
+#seekto 0x0F00;
+struct {
+  struct settings_vfo a;
+  struct settings_vfo b;
+} vfo;
+
 #seekto 0x1000;
 struct {
   char name[6];
@@ -84,6 +176,11 @@ struct {
   u8 uhf_high[3];
 } ranges220;
 
+#seekto 0x3F70;
+struct {
+  char fp[6];
+} fingerprint;
+
 """
 
 # A note about the memmory in these radios
@@ -106,6 +203,30 @@ NAME_LENGTH = 6
 PTTID_LIST = ["OFF", "BOT", "EOT", "BOTH"]
 PTTIDCODE_LIST = ["%s" % x for x in range(1, 16)]
 OPTSIG_LIST = ["OFF", "DTMF", "2TONE", "5TONE"]
+SPMUTE_LIST = ["Tone/DTCS", "Tone/DTCS and Optsig", "Tone/DTCS or Optsig"]
+
+LIST_TOT = ["%s sec" % x for x in range(15, 615, 15)]
+LIST_TOA = ["Off"] + ["%s seconds" % x for x in range(1, 11)]
+LIST_APO = ["Off"] + ["%s minutes" % x for x in range(30, 330, 30)]
+LIST_ABR = ["Off"] + ["%s seconds" % x for x in range(1, 51)]
+LIST_DTMFST = ["OFF", "Keyboard", "ANI", "Keyboad + ANI"]
+LIST_SCREV = ["TO (timeout)", "CO (carrier operated)", "SE (search)"]
+LIST_EMCTP = ["TX alarm sound", "TX ANI", "Both"]
+LIST_RINGT = ["Off"] + ["%s seconds" % x for x in range(1, 10)]
+LIST_MDF = ["Frequency", "Channel", "Name"]
+LIST_PONMSG = ["Full", "Message", "Battery voltage"]
+LIST_COLOR = ["Off", "Blue", "Orange", "Purple"]
+LIST_REPS = ["1000 Hz", "1450 Hz", "1750 Hz", "2100Hz"]
+LIST_REPM = ["Off", "Carrier", "CTCSS or DCS", "Tone", "DTMF"]
+LIST_RPTDL = ["Off"] + ["%s ms" % x for x in range(1, 10)]
+LIST_ANIL = ["3", "4", "5"]
+LIST_AB = ["A", "B"]
+LIST_VFOMR = ["Frequency", "Channel"]
+LIST_SHIFT = ["Off", "+", "-"]
+LIST_TXP = ["High", "Low"]
+LIST_WIDE = ["Wide", "Narrow"]
+STEPS = [2.5, 5.0, 6.25, 10.0, 12.5, 25.0]
+LIST_STEP = [str(x) for x in STEPS]
 
 # This is a general serial timeout for all serial read functions.
 # Practice has show that about 0.7 sec will be enough to cover all radios.
@@ -364,6 +485,9 @@ def _do_ident(radio, status, upload=False):
     # some radios needs a extra read and check for a code on it, this ones
     # has the check value in the _id2 var, others simply False
     if radio._id2 is not False:
+        # lower the timeout here as this radios are reseting due to timeout
+        radio.pipe.setTimeout(0.05)
+
         # query & receive the extra ID
         _send(radio, _make_frame("S", 0x3DF0, 16))
         id2 = _rawrecv(radio, 21)
@@ -400,7 +524,6 @@ def _do_ident(radio, status, upload=False):
             #
             # we just check for a response and last byte being a ACK, that is
             # the common stone for all radios (3 so far)
-            radio.pipe.setTimeout(0.1)
             ack = _rawrecv(radio, 2)
 
             # checking
@@ -610,7 +733,7 @@ class BTech(chirp_common.CloneModeRadio, chirp_common.ExperimentalRadio):
         global POWER_LEVELS
 
         rf = chirp_common.RadioFeatures()
-        rf.has_settings = False
+        rf.has_settings = True
         rf.has_bank = False
         rf.has_tuning_step = False
         rf.can_odd_split = True
@@ -818,10 +941,6 @@ class BTech(chirp_common.CloneModeRadio, chirp_common.ExperimentalRadio):
         # Extra
         mem.extra = RadioSettingGroup("extra", "Extra")
 
-        spmute = RadioSetting("spmute", "Speaker mute",
-                              RadioSettingValueBoolean(bool(_mem.spmute)))
-        mem.extra.append(spmute)
-
         scramble = RadioSetting("scramble", "Scramble",
                                 RadioSettingValueBoolean(bool(_mem.scramble)))
         mem.extra.append(scramble)
@@ -849,6 +968,12 @@ class BTech(chirp_common.CloneModeRadio, chirp_common.ExperimentalRadio):
                                   OPTSIG_LIST[_mem.optsig]))
         mem.extra.append(optsig)
 
+        spmute = RadioSetting("spmute", "Speaker mute",
+                              RadioSettingValueList(
+                                  SPMUTE_LIST,
+                                  SPMUTE_LIST[_mem.spmute]))
+        mem.extra.append(spmute)
+
         return mem
 
     def set_memory(self, mem):
@@ -927,6 +1052,473 @@ class BTech(chirp_common.CloneModeRadio, chirp_common.ExperimentalRadio):
 
         return mem
 
+    def get_settings(self):
+        """Translate the bit in the mem_struct into settings in the UI"""
+        _mem = self._memobj
+        basic = RadioSettingGroup("basic", "Basic Settings")
+        advanced = RadioSettingGroup("advanced", "Advanced Settings")
+        other = RadioSettingGroup("other", "Other Settings")
+        work = RadioSettingGroup("work", "Work Mode Settings")
+        top = RadioSettings(basic, advanced, other, work)
+
+        # Basic
+        tdr = RadioSetting("settings.tdr", "Transceiver dual receive",
+                           RadioSettingValueBoolean(_mem.settings.tdr))
+        basic.append(tdr)
+
+        sql = RadioSetting("settings.sql", "Squelch level",
+                           RadioSettingValueInteger(0, 9, _mem.settings.sql))
+        basic.append(sql)
+
+        tot = RadioSetting("settings.tot", "Time out timer",
+                           RadioSettingValueList(LIST_TOT, LIST_TOT[
+                               _mem.settings.tot]))
+        basic.append(tot)
+
+        if self.MODEL in ("UV-2501", "UV-2501+220", "UV-5001"):
+            apo = RadioSetting("settings.apo", "Auto power off timer",
+                               RadioSettingValueList(LIST_APO, LIST_APO[
+                                   _mem.settings.apo]))
+            basic.append(apo)
+        else:
+            toa = RadioSetting("settings.apo", "Time out alert timer",
+                               RadioSettingValueList(LIST_TOA, LIST_TOA[
+                                   _mem.settings.apo]))
+            basic.append(toa)
+
+        abr = RadioSetting("settings.abr", "Backlight timer",
+                           RadioSettingValueList(LIST_ABR, LIST_ABR[
+                               _mem.settings.abr]))
+        basic.append(abr)
+
+        beep = RadioSetting("settings.beep", "Key beep",
+                            RadioSettingValueBoolean(_mem.settings.beep))
+        basic.append(beep)
+
+        dtmfst = RadioSetting("settings.dtmfst", "DTMF side tone",
+                              RadioSettingValueList(LIST_DTMFST, LIST_DTMFST[
+                                  _mem.settings.dtmfst]))
+        basic.append(dtmfst)
+
+        prisc = RadioSetting("settings.prisc", "Priority scan",
+                             RadioSettingValueBoolean(_mem.settings.prisc))
+        basic.append(prisc)
+
+        prich = RadioSetting("settings.prich", "Priority channel",
+                             RadioSettingValueInteger(0, 199,
+                                 _mem.settings.prich))
+        basic.append(prich)
+
+        screv = RadioSetting("settings.screv", "Scan resume method",
+                             RadioSettingValueList(LIST_SCREV, LIST_SCREV[
+                                 _mem.settings.screv]))
+        basic.append(screv)
+
+        pttlt = RadioSetting("settings.pttlt", "PTT transmit delay",
+                             RadioSettingValueInteger(0, 30, 
+                                 _mem.settings.pttlt))
+        basic.append(pttlt)
+
+        emctp = RadioSetting("settings.emctp", "Alarm mode",
+                             RadioSettingValueList(LIST_EMCTP, LIST_EMCTP[
+                                 _mem.settings.emctp]))
+        basic.append(emctp)
+
+        emcch = RadioSetting("settings.emcch", "Alarm channel",
+                             RadioSettingValueInteger(0, 199, 
+                                 _mem.settings.emcch))
+        basic.append(emcch)
+
+        ringt = RadioSetting("settings.ringt", "Ring time",
+                             RadioSettingValueList(LIST_RINGT, LIST_RINGT[
+                                 _mem.settings.ringt]))
+        basic.append(ringt)
+
+        camdf = RadioSetting("settings.camdf", "Display mode A",
+                             RadioSettingValueList(LIST_MDF, LIST_MDF[
+                                 _mem.settings.camdf]))
+        basic.append(camdf)
+
+        cbmdf = RadioSetting("settings.cbmdf", "Display mode B",
+                             RadioSettingValueList(LIST_MDF, LIST_MDF[
+                                 _mem.settings.cbmdf]))
+        basic.append(cbmdf)
+
+        if self.MODEL in ("UV-2501", "UV-2501+220", "UV-5001"):
+           sync = RadioSetting("settings.sync", "A/B channel sync",
+                               RadioSettingValueBoolean(_mem.settings.sync))
+           basic.append(sync)
+        else:
+           autolk = RadioSetting("settings.sync", "Auto keylock",
+                                 RadioSettingValueBoolean(_mem.settings.sync))
+           basic.append(autolk)
+
+        ponmsg = RadioSetting("settings.ponmsg", "Power-on message",
+                              RadioSettingValueList(LIST_PONMSG, LIST_PONMSG[
+                                  _mem.settings.ponmsg]))
+        basic.append(ponmsg)
+
+        wtled = RadioSetting("settings.wtled", "Standby backlight Color",
+                             RadioSettingValueList(LIST_COLOR, LIST_COLOR[
+                                 _mem.settings.wtled]))
+        basic.append(wtled)
+
+        rxled = RadioSetting("settings.rxled", "RX backlight Color",
+                             RadioSettingValueList(LIST_COLOR, LIST_COLOR[
+                                 _mem.settings.rxled]))
+        basic.append(rxled)
+
+        txled = RadioSetting("settings.txled", "TX backlight Color",
+                             RadioSettingValueList(LIST_COLOR, LIST_COLOR[
+                                 _mem.settings.txled]))
+        basic.append(txled)
+
+        anil = RadioSetting("settings.anil", "ANI length",
+                            RadioSettingValueList(LIST_ANIL, LIST_ANIL[
+                                _mem.settings.anil]))
+        basic.append(anil)
+
+        reps = RadioSetting("settings.reps", "Relay signal (tone burst)",
+                            RadioSettingValueList(LIST_REPS, LIST_REPS[
+                                _mem.settings.reps]))
+        basic.append(reps)
+
+        repm = RadioSetting("settings.repm", "Relay condition",
+                            RadioSettingValueList(LIST_REPM, LIST_REPM[
+                                _mem.settings.repm]))
+        basic.append(repm)
+
+        if self.MODEL in ("UV-2501", "UV-2501+220", "UV-5001"):
+            tdrab = RadioSetting("settings.tdrab", "TDR return time",
+                                 RadioSettingValueList(LIST_ABR, LIST_ABR[
+                                     _mem.settings.tdrab]))
+            basic.append(tdrab)
+
+            ste = RadioSetting("settings.ste", "Squelch tail eliminate",
+                               RadioSettingValueBoolean(_mem.settings.ste))
+            basic.append(ste)
+
+            rpste = RadioSetting("settings.rpste", "Repeater STE",
+                                 RadioSettingValueList(LIST_RINGT, LIST_RINGT[
+                                     _mem.settings.rpste]))
+            basic.append(rpste)
+
+            rptdl = RadioSetting("settings.rptdl", "Repeater STE delay",
+                                 RadioSettingValueList(LIST_RPTDL, LIST_RPTDL[
+                                     _mem.settings.rptdl]))
+            basic.append(rptdl)
+
+        # Advanced
+        def _filter(name):
+            filtered = ""
+            for char in str(name):
+                if char in VALID_CHARS:
+                    filtered += char
+                else:
+                    filtered += " "
+            return filtered
+
+        _msg = self._memobj.poweron_msg
+        line1 = RadioSetting("poweron_msg.line1", "Power-on message line 1",
+                             RadioSettingValueString(0, 6, _filter(
+                                 _msg.line1)))
+        advanced.append(line1)
+        line2 = RadioSetting("poweron_msg.line2", "Power-on message line 2",
+                             RadioSettingValueString(0, 6, _filter(
+                                 _msg.line2)))
+        advanced.append(line2)
+
+        if self.MODEL in ("UV-2501", "UV-5001"):
+            vfomren = RadioSetting("settings2.vfomren", "VFO/MR switching",
+                                   RadioSettingValueBoolean(
+                                       not _mem.settings2.vfomren))
+            advanced.append(vfomren)
+
+            reseten = RadioSetting("settings2.reseten", "RESET",
+                                   RadioSettingValueBoolean(
+                                       _mem.settings2.reseten))
+            advanced.append(reseten)
+
+            menuen = RadioSetting("settings2.menuen", "Menu",
+                                  RadioSettingValueBoolean(
+                                      _mem.settings2.menuen))
+            advanced.append(menuen)
+
+        # Other
+        def convert_bytes_to_limit(bytes):
+            limit = ""
+            for byte in bytes:
+                if byte < 10:
+                    limit += chr(byte + 0x30)
+                else:
+                    break
+            return limit
+
+        if "+220" in self.MODEL:
+            _ranges = self._memobj.ranges220
+            ranges = "ranges220"
+        else:
+            _ranges = self._memobj.ranges
+            ranges = "ranges"
+
+        _limit = convert_bytes_to_limit(_ranges.vhf_low)
+        val = RadioSettingValueString(0, 3, _limit)
+        val.set_mutable(False)
+        vhf_low = RadioSetting("%s.vhf_low" % ranges, "VHF low", val)
+        other.append(vhf_low)
+
+        _limit = convert_bytes_to_limit(_ranges.vhf_high)
+        val = RadioSettingValueString(0, 3, _limit)
+        val.set_mutable(False)
+        vhf_high = RadioSetting("%s.vhf_high" % ranges, "VHF high", val)
+        other.append(vhf_high)
+
+        if "+220" in self.MODEL:
+            _limit = convert_bytes_to_limit(_ranges.vhf2_low)
+            val = RadioSettingValueString(0, 3, _limit)
+            val.set_mutable(False)
+            vhf2_low = RadioSetting("%s.vhf2_low" % ranges, "VHF2 low", val)
+            other.append(vhf2_low)
+
+            _limit = convert_bytes_to_limit(_ranges.vhf2_high)
+            val = RadioSettingValueString(0, 3, _limit)
+            val.set_mutable(False)
+            vhf2_high = RadioSetting("%s.vhf2_high" % ranges, "VHF2 high", val)
+            other.append(vhf2_high)
+
+        _limit = convert_bytes_to_limit(_ranges.uhf_low)
+        val = RadioSettingValueString(0, 3, _limit)
+        val.set_mutable(False)
+        uhf_low = RadioSetting("%s.uhf_low" % ranges, "UHF low", val)
+        other.append(uhf_low)
+
+        _limit = convert_bytes_to_limit(_ranges.uhf_high)
+        val = RadioSettingValueString(0, 3, _limit)
+        val.set_mutable(False)
+        uhf_high = RadioSetting("%s.uhf_high" % ranges, "UHF high", val)
+        other.append(uhf_high)
+
+        val = RadioSettingValueString(0, 6, _filter(_mem.fingerprint.fp))
+        val.set_mutable(False)
+        fp = RadioSetting("fingerprint.fp", "Fingerprint", val)
+        other.append(fp)
+
+        # Work
+        dispab = RadioSetting("settings2.dispab", "Display",
+                              RadioSettingValueList(LIST_AB,LIST_AB[
+                                  _mem.settings2.dispab]))
+        work.append(dispab)
+
+        vfomr = RadioSetting("settings2.vfomr", "VFO/MR mode",
+                             RadioSettingValueList(LIST_VFOMR,LIST_VFOMR[
+                                 _mem.settings2.vfomr]))
+        work.append(vfomr)
+
+        keylock = RadioSetting("settings2.keylock", "Keypad lock",
+                           RadioSettingValueBoolean(_mem.settings2.keylock))
+        work.append(keylock)
+
+        mrcha = RadioSetting("settings2.mrcha", "MR A channel",
+                             RadioSettingValueInteger(0, 199,
+                                 _mem.settings2.mrcha))
+        work.append(mrcha)
+
+        mrchb = RadioSetting("settings2.mrchb", "MR B channel",
+                             RadioSettingValueInteger(0, 199,
+                                 _mem.settings2.mrchb))
+        work.append(mrchb)
+
+        def convert_bytes_to_freq(bytes):
+            real_freq = 0
+            for byte in bytes:
+                real_freq = (real_freq * 10) + byte
+            return chirp_common.format_freq(real_freq * 10)
+
+        def my_validate(value):
+            value = chirp_common.parse_freq(value)
+            print value
+            if 180000000 <= value and value < 210000000:
+                msg = ("Can't be between 180.00000-210.00000")
+                raise InvalidValueError(msg)
+            elif 231000000 <= value and value < 400000000:
+                msg = ("Can't be between 231.00000-400.00000")
+                raise InvalidValueError(msg)
+            elif 210000000 <= value and value < 231000000 \
+                and "+220" not in self.MODEL:
+                msg = ("Can't be between 180.00000-400.00000")
+                raise InvalidValueError(msg)
+            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
+
+        val1a = RadioSettingValueString(0, 10, convert_bytes_to_freq(
+                                        _mem.vfo.a.freq))
+        val1a.set_validate_callback(my_validate)
+        vfoafreq = RadioSetting("vfo.a.freq", "VFO A frequency", val1a)
+        vfoafreq.set_apply_callback(apply_freq, _mem.vfo.a)
+        work.append(vfoafreq)
+
+        val1b = RadioSettingValueString(0, 10, convert_bytes_to_freq(
+                                        _mem.vfo.b.freq))
+        val1b.set_validate_callback(my_validate)
+        vfobfreq = RadioSetting("vfo.b.freq", "VFO B frequency", val1b)
+        vfobfreq.set_apply_callback(apply_freq, _mem.vfo.b)
+        work.append(vfobfreq)
+
+        vfoashiftd = RadioSetting("vfo.a.shiftd", "VFO A shift",
+                                  RadioSettingValueList(LIST_SHIFT, LIST_SHIFT[
+                                      _mem.vfo.a.shiftd]))
+        work.append(vfoashiftd)
+
+        vfobshiftd = RadioSetting("vfo.b.shiftd", "VFO B shift",
+                                  RadioSettingValueList(LIST_SHIFT, LIST_SHIFT[
+                                      _mem.vfo.b.shiftd]))
+        work.append(vfobshiftd)
+
+        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 * 10000)
+
+        def apply_offset(setting, obj):
+            value = chirp_common.parse_freq(str(setting.value)) / 10000
+            for i in range(3, -1, -1):
+                obj.offset[i] = value % 10
+                value /= 10
+
+        val1a = RadioSettingValueString(0, 10, convert_bytes_to_offset(
+                                        _mem.vfo.a.offset))
+        vfoaoffset = RadioSetting("vfo.a.offset",
+                                  "VFO A offset (0.00-99.95)", val1a)
+        vfoaoffset.set_apply_callback(apply_offset, _mem.vfo.a)
+        work.append(vfoaoffset)
+
+        val1b = RadioSettingValueString(0, 10, convert_bytes_to_offset(
+                                        _mem.vfo.b.offset))
+        vfoboffset = RadioSetting("vfo.b.offset",
+                                  "VFO B offset (0.00-99.95)", val1b)
+        vfoboffset.set_apply_callback(apply_offset, _mem.vfo.b)
+        work.append(vfoboffset)
+
+        vfoatxp = RadioSetting("vfo.a.power", "VFO A power",
+                                RadioSettingValueList(LIST_TXP,LIST_TXP[
+                                    _mem.vfo.a.power]))
+        work.append(vfoatxp)
+
+        vfobtxp = RadioSetting("vfo.b.power", "VFO B power",
+                                RadioSettingValueList(LIST_TXP,LIST_TXP[
+                                    _mem.vfo.b.power]))
+        work.append(vfobtxp)
+
+        vfoawide = RadioSetting("vfo.a.wide", "VFO A bandwidth",
+                                RadioSettingValueList(LIST_WIDE,LIST_WIDE[
+                                    _mem.vfo.a.wide]))
+        work.append(vfoawide)
+
+        vfobwide = RadioSetting("vfo.b.wide", "VFO B bandwidth",
+                                RadioSettingValueList(LIST_WIDE,LIST_WIDE[
+                                    _mem.vfo.b.wide]))
+        work.append(vfobwide)
+
+        vfoastep = RadioSetting("vfo.a.step", "VFO A step",
+                                RadioSettingValueList(LIST_STEP,LIST_STEP[
+                                    _mem.vfo.a.step]))
+        work.append(vfoastep)
+
+        vfobstep = RadioSetting("vfo.b.step", "VFO B step",
+                                RadioSettingValueList(LIST_STEP,LIST_STEP[
+                                    _mem.vfo.b.step]))
+        work.append(vfobstep)
+
+        vfoaoptsig = RadioSetting("vfo.a.optsig", "VFO A optional signal",
+                                  RadioSettingValueList(OPTSIG_LIST,
+                                      OPTSIG_LIST[_mem.vfo.a.optsig]))
+        work.append(vfoaoptsig)
+
+        vfoboptsig = RadioSetting("vfo.b.optsig", "VFO B optional signal",
+                                  RadioSettingValueList(OPTSIG_LIST,
+                                      OPTSIG_LIST[_mem.vfo.b.optsig]))
+        work.append(vfoboptsig)
+
+        vfoaspmute = RadioSetting("vfo.a.spmute", "VFO A speaker mute",
+                                  RadioSettingValueList(SPMUTE_LIST,
+                                      SPMUTE_LIST[_mem.vfo.a.spmute]))
+        work.append(vfoaspmute)
+
+        vfobspmute = RadioSetting("vfo.b.spmute", "VFO B speaker mute",
+                                  RadioSettingValueList(SPMUTE_LIST,
+                                      SPMUTE_LIST[_mem.vfo.b.spmute]))
+        work.append(vfobspmute)
+
+        vfoascr = RadioSetting("vfo.a.scramble", "VFO A scramble",
+                               RadioSettingValueBoolean(_mem.vfo.a.scramble))
+        work.append(vfoascr)
+
+        vfobscr = RadioSetting("vfo.b.scramble", "VFO B scramble",
+                               RadioSettingValueBoolean(_mem.vfo.b.scramble))
+        work.append(vfobscr)
+
+        vfoascode = RadioSetting("vfo.a.scode", "VFO A PTT-ID",
+                                 RadioSettingValueList(PTTIDCODE_LIST,
+                                     PTTIDCODE_LIST[_mem.vfo.a.scode]))
+        work.append(vfoascode)
+
+        vfobscode = RadioSetting("vfo.b.scode", "VFO B PTT-ID",
+                                 RadioSettingValueList(PTTIDCODE_LIST,
+                                     PTTIDCODE_LIST[_mem.vfo.b.scode]))
+        work.append(vfobscode)
+
+        pttid = RadioSetting("settings.pttid", "PTT ID",
+                             RadioSettingValueList(PTTID_LIST,
+                                 PTTID_LIST[_mem.settings.pttid]))
+        work.append(pttid)
+
+        return top
+
+    def set_settings(self, settings):
+        _settings = self._memobj.settings
+        for element in settings:
+            if not isinstance(element, RadioSetting):
+                if element.get_name() == "fm_preset":
+                    self._set_fm_preset(element)
+                else:
+                    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 == "vfomren":
+                        setattr(obj, setting, not int(element.value))
+                    elif element.value.get_mutable():
+                        LOG.debug("Setting %s = %s" % (setting, element.value))
+                        setattr(obj, setting, element.value)
+                except Exception, e:
+                    LOG.debug(element.get_name())
+                    raise
+
     @classmethod
     def match_model(cls, filedata, filename):
         match_size = False

-- 
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-hamradio/chirp.git



More information about the pkg-hamradio-commits mailing list