# HG changeset patch # User Zach Welch zach@mandolincreekfarm.com # Fake Node ID 9859baf4234e7136fcafc090adcfc88d3340b285

Fix style issues in some drivers (#2355)

diff --git a/chirp/drivers/alinco.py b/chirp/drivers/alinco.py index 9c70125..31bbbea 100644 --- a/chirp/drivers/alinco.py +++ b/chirp/drivers/alinco.py @@ -19,6 +19,7 @@ from chirp.settings import RadioSettingValueBoolean, RadioSettings

import time

+ DRX35_MEM_FORMAT = """ #seekto 0x0120; u8 used_flags[25]; @@ -67,6 +68,7 @@ RLENGTH = 2 + 5 + 32 + 2

STEPS = [5.0, 10.0, 12.5, 15.0, 20.0, 25.0, 30.0]

+ def isascii(data): for byte in data: if (ord(byte) < ord(" ") or ord(byte) > ord("~")) and \ @@ -74,6 +76,7 @@ def isascii(data): return False return True

+ def tohex(data): if isascii(data): return repr(data) @@ -82,6 +85,7 @@ def tohex(data): string += "%02X" % ord(byte) return string

+ class AlincoStyleRadio(chirp_common.CloneModeRadio): """Base class for all known Alinco radios""" _memsize = 0 @@ -204,12 +208,13 @@ class AlincoStyleRadio(chirp_common.CloneModeRadio): def get_raw_memory(self, number): return repr(self._memobj.memory[number])

+ DUPLEX = ["", "-", "+"] TMODES = ["", "Tone", "", "TSQL"] + [""] * 12 TMODES[12] = "DTCS" DCS_CODES = { - "Alinco" : chirp_common.DTCS_CODES, - "Jetstream" : [17] + chirp_common.DTCS_CODES, + "Alinco": chirp_common.DTCS_CODES, + "Jetstream": [17] + chirp_common.DTCS_CODES, }

CHARSET = (["\x00"] * 0x30) + \ @@ -217,6 +222,7 @@ CHARSET = (["\x00"] * 0x30) + \ [chr(x + ord("A")) for x in range(0, 26)] + [" "] + \ list("\x00" * 128)

+ def _get_name(_mem): name = "" for i in _mem.name: @@ -225,6 +231,7 @@ def _get_name(_mem): name += CHARSET[i] return name

+ def _set_name(mem, _mem): name = [0x00] * 7 j = 0 @@ -251,6 +258,7 @@ ALINCO_TONES.remove(206.5) ALINCO_TONES.remove(229.1) ALINCO_TONES.remove(254.1)

+ class DRx35Radio(AlincoStyleRadio): """Base class for the DR-x35 radios""" _range = [(118000000, 155000000)] @@ -385,6 +393,7 @@ class DRx35Radio(AlincoStyleRadio):

self._set_extra(_mem, mem)

+ @directory.register class DR03Radio(DRx35Radio): """Alinco DR03""" @@ -400,6 +409,7 @@ class DR03Radio(DRx35Radio): return len(filedata) == cls._memsize and \ filedata[0x64] == chr(0x00) and filedata[0x65] == chr(0x28)

+ @directory.register class DR06Radio(DRx35Radio): """Alinco DR06""" @@ -414,7 +424,8 @@ class DR06Radio(DRx35Radio): def match_model(cls, filedata, filename): return len(filedata) == cls._memsize and \ filedata[0x64] == chr(0x00) and filedata[0x65] == chr(0x50) - + + @directory.register class DR135Radio(DRx35Radio): """Alinco DR135""" @@ -430,6 +441,7 @@ class DR135Radio(DRx35Radio): return len(filedata) == cls._memsize and \ filedata[0x64] == chr(0x01) and filedata[0x65] == chr(0x44)

+ @directory.register class DR235Radio(DRx35Radio): """Alinco DR235""" @@ -445,6 +457,7 @@ class DR235Radio(DRx35Radio): return len(filedata) == cls._memsize and \ filedata[0x64] == chr(0x02) and filedata[0x65] == chr(0x22)

+ @directory.register class DR435Radio(DRx35Radio): """Alinco DR435""" @@ -460,6 +473,7 @@ class DR435Radio(DRx35Radio): return len(filedata) == cls._memsize and \ filedata[0x64] == chr(0x04) and filedata[0x65] == chr(0x00)

+ @directory.register class DJ596Radio(DRx35Radio): """Alinco DJ596""" @@ -477,6 +491,7 @@ class DJ596Radio(DRx35Radio): return len(filedata) == cls._memsize and \ filedata[0x64] == chr(0x45) and filedata[0x65] == chr(0x01)

+ @directory.register class JT220MRadio(DRx35Radio): """Jetstream JT220""" @@ -492,6 +507,7 @@ class JT220MRadio(DRx35Radio): return len(filedata) == cls._memsize and \ filedata[0x60:0x64] == "2009"

+ @directory.register class DJ175Radio(DRx35Radio): """Alinco DJ175""" diff --git a/chirp/drivers/anytone.py b/chirp/drivers/anytone.py index b7d722b..8755708 100644 --- a/chirp/drivers/anytone.py +++ b/chirp/drivers/anytone.py @@ -27,6 +27,7 @@ from chirp import util from chirp.settings import RadioSettingGroup, RadioSetting, RadioSettings, \ RadioSettingValueList, RadioSettingValueString, RadioSettingValueBoolean

+ LOG = logging.getLogger(__name__)

_mem_format = """ @@ -74,12 +75,12 @@ struct memory {

#seekto 0x0030; struct { - char serial[16]; + char serial[16]; } serial_no;

#seekto 0x0050; struct { - char date[16]; + char date[16]; } version;

#seekto 0x0280; @@ -110,6 +111,7 @@ struct memory memory[758]; struct memory memblk2[10]; """

+ class FlagObj(object): def __init__(self, flagobj, which): self._flagobj = flagobj @@ -155,18 +157,22 @@ class FlagObj(object): def __repr__(self): return repr(self._flagobj)

+ def _is_loc_used(memobj, loc): return memobj.flags[loc / 2].get_raw() != "\xFF"

+ def _addr_to_loc(addr): return (addr - 0x2000) / 32

+ def _should_send_addr(memobj, addr): if addr < 0x2000 or addr >= 0x7EC0: return True else: return _is_loc_used(memobj, _addr_to_loc(addr))

+ def _echo_write(radio, data): try: radio.pipe.write(data) @@ -175,6 +181,7 @@ def _echo_write(radio, data): print "Error writing to radio: %s" % e raise errors.RadioError("Unable to write to radio")

+ def _read(radio, length): try: data = radio.pipe.read(length) @@ -191,6 +198,7 @@ def _read(radio, length):

valid_model = ['QX588UV', 'HR-2040', 'DB-50M\x00', 'DB-750X']

+ def _ident(radio): radio.pipe.setTimeout(1) _echo_write(radio, "PROGRAM") @@ -205,6 +213,7 @@ def _ident(radio): print "Response was:\n%s" % util.hexprint(response) raise errors.RadioError("Unsupported model")

+ def _finish(radio): endframe = "\x45\x4E\x44" _echo_write(radio, endframe) @@ -213,12 +222,14 @@ def _finish(radio): print "Got:\n%s" % util.hexprint(result) raise errors.RadioError("Radio did not finish cleanly")

+ def _checksum(data): cs = 0 for byte in data: cs += ord(byte) return cs % 256

+ def _send(radio, cmd, addr, length, data=None): frame = struct.pack(">cHb", cmd, addr, length) if data: @@ -231,8 +242,8 @@ def _send(radio, cmd, addr, length, data=None): result = radio.pipe.read(1) if result != "\x06": print "Ack was: %s" % repr(result) - raise errors.RadioError("Radio did not accept block at %04x" % \ - addr) + raise errors.RadioError( + "Radio did not accept block at %04x" % addr) return result = _read(radio, length + 6) LOG.debug("Got:\n%s" % util.hexprint(result)) @@ -255,6 +266,7 @@ def _send(radio, cmd, addr, length, data=None): raise errors.RadioError("Block at 0x%04x failed checksum" % addr) return data

+ def _download(radio): _ident(radio)

@@ -282,6 +294,7 @@ def _download(radio):

return memmap.MemoryMap(data)

+ def _upload(radio): _ident(radio)

@@ -302,6 +315,7 @@ def _upload(radio):

_finish(radio)

+ TONES = [62.5] + list(chirp_common.TONES) TMODES = ['', 'Tone', 'DTCS', ''] DUPLEXES = ['', '-', '+', ''] @@ -527,6 +541,7 @@ class AnyTone5888UVRadio(chirp_common.CloneModeRadio, def match_model(cls, filedata, filename): return cls._file_ident in filedata[0x20:0x40]

+ @directory.register class IntekHR2040Radio(AnyTone5888UVRadio): """Intek HR-2040""" @@ -534,6 +549,7 @@ class IntekHR2040Radio(AnyTone5888UVRadio): MODEL = "HR-2040" _file_ident = "HR-2040"

+ @directory.register class PolmarDB50MRadio(AnyTone5888UVRadio): """Polmar DB-50M""" @@ -541,6 +557,7 @@ class PolmarDB50MRadio(AnyTone5888UVRadio): MODEL = "DB-50M" _file_ident = "DB-50M"

+ @directory.register class PowerwerxDB750XRadio(AnyTone5888UVRadio): """Powerwerx DB-750X""" diff --git a/tools/cpep8.blacklist b/tools/cpep8.blacklist index d877a24..b90eb3f 100644 --- a/tools/cpep8.blacklist +++ b/tools/cpep8.blacklist @@ -1,8 +1,6 @@ # cpep8.blacklist: The list of files that do not meet PEP8 standards. # DO NOT ADD NEW FILES!! Instead, fix the code to be compliant. # Over time, this list should shrink and (eventually) be eliminated. -./chirp/drivers/alinco.py -./chirp/drivers/anytone.py ./chirp/drivers/ap510.py ./chirp/drivers/baofeng_uv3r.py ./chirp/drivers/bjuv55.py

# HG changeset patch # User Zach Welch zach@mandolincreekfarm.com # Fake Node ID 31a8fe92d77abb5ced11e7f79a964eefba9de694

Fix style issues in baofeng_uv3r.py (#2355)

diff --git a/chirp/drivers/baofeng_uv3r.py b/chirp/drivers/baofeng_uv3r.py index c98ab37..7b5ac60 100644 --- a/chirp/drivers/baofeng_uv3r.py +++ b/chirp/drivers/baofeng_uv3r.py @@ -24,6 +24,7 @@ from chirp.settings import RadioSetting, RadioSettingGroup, \ RadioSettingValueInteger, RadioSettingValueString, \ RadioSettingValueFloat, RadioSettings

+ def _uv3r_prep(radio): radio.pipe.write("\x05PROGRAM") ack = radio.pipe.read(1) @@ -40,6 +41,7 @@ def _uv3r_prep(radio): if radio.pipe.read(1) != "\x06": raise errors.RadioError("Radio did not ACK ident")

+ def uv3r_prep(radio): """Do the UV3R identification dance""" for _i in range(0, 10): @@ -50,6 +52,7 @@ def uv3r_prep(radio):

raise e

+ def uv3r_download(radio): """Talk to a UV3R and do a download""" try: @@ -60,6 +63,7 @@ def uv3r_download(radio): except Exception, e: raise errors.RadioError("Failed to communicate with radio: %s" % e)

+ def uv3r_upload(radio): """Talk to a UV3R and do an upload""" try: @@ -70,6 +74,7 @@ def uv3r_upload(radio): except Exception, e: raise errors.RadioError("Failed to communicate with radio: %s" % e)

+ UV3R_MEM_FORMAT = """ #seekto 0x0010; struct { @@ -183,6 +188,7 @@ UV3R_POWER_LEVELS = [chirp_common.PowerLevel("High", watts=2.00), chirp_common.PowerLevel("Low", watts=0.50)] UV3R_DTCS_POL = ["NN", "NR", "RN", "RR"]

+ @directory.register class UV3RRadio(chirp_common.CloneModeRadio): """Baofeng UV-3R""" @@ -359,8 +365,9 @@ class UV3RRadio(chirp_common.CloneModeRadio): basic.append(rs)

rs = RadioSetting("backlight", "LCD Back Light", - RadioSettingValueList(BACKLIGHT_LIST, - BACKLIGHT_LIST[_settings.backlight])) + RadioSettingValueList( + BACKLIGHT_LIST, + BACKLIGHT_LIST[_settings.backlight])) basic.append(rs)

rs = RadioSetting("beep", "Keypad Beep", @@ -376,8 +383,8 @@ class UV3RRadio(chirp_common.CloneModeRadio): basic.append(rs)

rs = RadioSetting("ste", "Squelch Tail Eliminate", - RadioSettingValueList(STE_LIST, - STE_LIST[_settings.ste])) + RadioSettingValueList( + STE_LIST, STE_LIST[_settings.ste])) basic.append(rs)

rs = RadioSetting("save", "Battery Saver", @@ -385,13 +392,13 @@ class UV3RRadio(chirp_common.CloneModeRadio): basic.append(rs)

rs = RadioSetting("timeout", "Time Out Timer", - RadioSettingValueList(TIMEOUT_LIST, - TIMEOUT_LIST[_settings.timeout])) + RadioSettingValueList( + TIMEOUT_LIST, TIMEOUT_LIST[_settings.timeout])) basic.append(rs)

rs = RadioSetting("scanm", "Scan Mode", - RadioSettingValueList(SCANM_LIST, - SCANM_LIST[_settings.scanm])) + RadioSettingValueList( + SCANM_LIST, SCANM_LIST[_settings.scanm])) basic.append(rs)

rs = RadioSetting("relaym", "Repeater Sound Response", @@ -407,13 +414,13 @@ class UV3RRadio(chirp_common.CloneModeRadio): basic.append(rs)

rs = RadioSetting("pri_ch", "Priority Channel", - RadioSettingValueList(PRI_CH_LIST, - PRI_CH_LIST[_settings.pri_ch])) + RadioSettingValueList( + PRI_CH_LIST, PRI_CH_LIST[_settings.pri_ch])) basic.append(rs)

rs = RadioSetting("ch_flag", "Display Mode", - RadioSettingValueList(CH_FLAG_LIST, - CH_FLAG_LIST[_settings.ch_flag])) + RadioSettingValueList( + CH_FLAG_LIST, CH_FLAG_LIST[_settings.ch_flag])) basic.append(rs)

_limit = int(self._memobj.limits.lower_vhf) / 10 @@ -421,6 +428,7 @@ class UV3RRadio(chirp_common.CloneModeRadio): _limit = 144 rs = RadioSetting("limits.lower_vhf", "VHF Lower Limit (115-239 MHz)", RadioSettingValueInteger(115, 235, _limit)) + def apply_limit(setting, obj): value = int(setting.value) * 10 obj.lower_vhf = value @@ -432,6 +440,7 @@ class UV3RRadio(chirp_common.CloneModeRadio): _limit = 146 rs = RadioSetting("limits.upper_vhf", "VHF Upper Limit (115-239 MHz)", RadioSettingValueInteger(115, 235, _limit)) + def apply_limit(setting, obj): value = int(setting.value) * 10 obj.upper_vhf = value @@ -443,6 +452,7 @@ class UV3RRadio(chirp_common.CloneModeRadio): _limit = 420 rs = RadioSetting("limits.lower_uhf", "UHF Lower Limit (200-529 MHz)", RadioSettingValueInteger(200, 529, _limit)) + def apply_limit(setting, obj): value = int(setting.value) * 10 obj.lower_uhf = value @@ -454,6 +464,7 @@ class UV3RRadio(chirp_common.CloneModeRadio): _limit = 450 rs = RadioSetting("limits.upper_uhf", "UHF Upper Limit (200-529 MHz)", RadioSettingValueInteger(200, 529, _limit)) + def apply_limit(setting, obj): value = int(setting.value) * 10 obj.upper_uhf = value @@ -464,95 +475,97 @@ class UV3RRadio(chirp_common.CloneModeRadio): group.append(vfo_preset)

def convert_bytes_to_freq(bytes): - real_freq = 0 - real_freq = bytes - return chirp_common.format_freq(real_freq * 10) + real_freq = 0 + real_freq = bytes + return chirp_common.format_freq(real_freq * 10)

def apply_vhf_freq(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 10 obj.vhf.freq = value

- val = RadioSettingValueString(0, 10, - convert_bytes_to_freq(int(_vfo.vhf.freq))) + val = RadioSettingValueString( + 0, 10, convert_bytes_to_freq(int(_vfo.vhf.freq))) rs = RadioSetting("vfo.vhf.freq", "VHF RX Frequency (115.00000-236.00000)", val) rs.set_apply_callback(apply_vhf_freq, _vfo) vfo_preset.append(rs)

rs = RadioSetting("vfo.vhf.duplex", "Shift Direction", - RadioSettingValueList(DUPLEX_LIST, - DUPLEX_LIST[_vfo.vhf.duplex])) + RadioSettingValueList( + DUPLEX_LIST, DUPLEX_LIST[_vfo.vhf.duplex])) vfo_preset.append(rs)

def convert_bytes_to_offset(bytes): - real_offset = 0 - real_offset = bytes - return chirp_common.format_freq(real_offset * 10000) + real_offset = 0 + real_offset = bytes + return chirp_common.format_freq(real_offset * 10000)

def apply_vhf_offset(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 10000 obj.vhf.offset = value

- val = RadioSettingValueString(0, 10, - convert_bytes_to_offset(int(_vfo.vhf.offset))) + val = RadioSettingValueString( + 0, 10, convert_bytes_to_offset(int(_vfo.vhf.offset))) rs = RadioSetting("vfo.vhf.offset", "Offset (0.00-37.995)", val) rs.set_apply_callback(apply_vhf_offset, _vfo) vfo_preset.append(rs)

rs = RadioSetting("vfo.vhf.power", "Power Level", - RadioSettingValueList(POWER_LIST, - POWER_LIST[_vfo.vhf.power])) + RadioSettingValueList( + POWER_LIST, POWER_LIST[_vfo.vhf.power])) vfo_preset.append(rs)

rs = RadioSetting("vfo.vhf.bandwidth", "Bandwidth", - RadioSettingValueList(BANDWIDTH_LIST, - BANDWIDTH_LIST[_vfo.vhf.bandwidth])) + RadioSettingValueList( + BANDWIDTH_LIST, + BANDWIDTH_LIST[_vfo.vhf.bandwidth])) vfo_preset.append(rs)

rs = RadioSetting("vfo.vhf.step", "Step", - RadioSettingValueList(STEP_LIST, - STEP_LIST[_vfo.vhf.step])) + RadioSettingValueList( + STEP_LIST, STEP_LIST[_vfo.vhf.step])) vfo_preset.append(rs)

def apply_uhf_freq(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 10 obj.uhf.freq = value

- val = RadioSettingValueString(0, 10, - convert_bytes_to_freq(int(_vfo.uhf.freq))) + val = RadioSettingValueString( + 0, 10, convert_bytes_to_freq(int(_vfo.uhf.freq))) rs = RadioSetting("vfo.uhf.freq", - "UHF RX Frequency (200.00000-529.00000)", val) + "UHF RX Frequency (200.00000-529.00000)", val) rs.set_apply_callback(apply_uhf_freq, _vfo) vfo_preset.append(rs)

rs = RadioSetting("vfo.uhf.duplex", "Shift Direction", - RadioSettingValueList(DUPLEX_LIST, - DUPLEX_LIST[_vfo.uhf.duplex])) + RadioSettingValueList( + DUPLEX_LIST, DUPLEX_LIST[_vfo.uhf.duplex])) vfo_preset.append(rs)

def apply_uhf_offset(setting, obj): value = chirp_common.parse_freq(str(setting.value)) / 10000 obj.uhf.offset = value

- val = RadioSettingValueString(0, 10, - convert_bytes_to_offset(int(_vfo.uhf.offset))) + val = RadioSettingValueString( + 0, 10, convert_bytes_to_offset(int(_vfo.uhf.offset))) rs = RadioSetting("vfo.uhf.offset", "Offset (0.00-69.995)", val) rs.set_apply_callback(apply_uhf_offset, _vfo) vfo_preset.append(rs)

rs = RadioSetting("vfo.uhf.power", "Power Level", - RadioSettingValueList(POWER_LIST, - POWER_LIST[_vfo.uhf.power])) + RadioSettingValueList( + POWER_LIST, POWER_LIST[_vfo.uhf.power])) vfo_preset.append(rs)

rs = RadioSetting("vfo.uhf.bandwidth", "Bandwidth", - RadioSettingValueList(BANDWIDTH_LIST, - BANDWIDTH_LIST[_vfo.uhf.bandwidth])) + RadioSettingValueList( + BANDWIDTH_LIST, + BANDWIDTH_LIST[_vfo.uhf.bandwidth])) vfo_preset.append(rs)

rs = RadioSetting("vfo.uhf.step", "Step", - RadioSettingValueList(STEP_LIST, - STEP_LIST[_vfo.uhf.step])) + RadioSettingValueList( + STEP_LIST, STEP_LIST[_vfo.uhf.step])) vfo_preset.append(rs)

fm_preset = RadioSettingGroup("fm_preset", "FM Radio Presets") @@ -566,8 +579,8 @@ class UV3RRadio(chirp_common.CloneModeRadio): used = False preset = 65 rs = RadioSetting("fm_presets_%1i" % i, "FM Preset %i" % (i + 1), - RadioSettingValueBoolean(used), - RadioSettingValueFloat(65, 108, preset, 0.1, 1)) + RadioSettingValueBoolean(used), + RadioSettingValueFloat(65, 108, preset, 0.1, 1)) fm_preset.append(rs)

return group @@ -576,7 +589,7 @@ class UV3RRadio(chirp_common.CloneModeRadio): _settings = self._memobj.settings for element in settings: if not isinstance(element, RadioSetting): - if element.get_name() == "fm_preset" : + if element.get_name() == "fm_preset": self._set_fm_preset(element) else: self.set_settings(element) @@ -625,7 +638,6 @@ class UV3RRadio(chirp_common.CloneModeRadio): print element.get_name() raise

- @classmethod def match_model(cls, filedata, filename): return len(filedata) == 3648 diff --git a/tools/cpep8.blacklist b/tools/cpep8.blacklist index 63b46cc..255e3b0 100644 --- a/tools/cpep8.blacklist +++ b/tools/cpep8.blacklist @@ -1,7 +1,6 @@ # cpep8.blacklist: The list of files that do not meet PEP8 standards. # DO NOT ADD NEW FILES!! Instead, fix the code to be compliant. # Over time, this list should shrink and (eventually) be eliminated. -./chirp/drivers/baofeng_uv3r.py ./chirp/drivers/bjuv55.py ./chirp/drivers/ft1802.py ./chirp/drivers/ft2800.py

# HG changeset patch # User Zach Welch zach@mandolincreekfarm.com # Fake Node ID 8caf00e2d67395f50defcb95fa1b8197131f1595

Fix style issues in yaesu_clone.py (#2355)

diff --git a/chirp/drivers/yaesu_clone.py b/chirp/drivers/yaesu_clone.py index e8ec732..ddaa1d2 100644 --- a/chirp/drivers/yaesu_clone.py +++ b/chirp/drivers/yaesu_clone.py @@ -13,30 +13,35 @@ # You should have received a copy of the GNU General Public License # along with this program. If not, see http://www.gnu.org/licenses/.

-CMD_ACK = 0x06 +import time +import os +import logging +from textwrap import dedent

from chirp import chirp_common, util, memmap, errors -import time, os, logging -from textwrap import dedent

LOG = logging.getLogger(__name__)

+CMD_ACK = 0x06 + + def _safe_read(pipe, count): buf = "" first = True for _i in range(0, 60): buf += pipe.read(count - len(buf)) - #print "safe_read: %i/%i\n" % (len(buf), count) + # print "safe_read: %i/%i\n" % (len(buf), count) if buf: if first and buf[0] == chr(CMD_ACK): - #print "Chewed an ack" - buf = buf[1:] # Chew an echo'd ack if using a 2-pin cable + # print "Chewed an ack" + buf = buf[1:] # Chew an echo'd ack if using a 2-pin cable first = False if len(buf) == count: break print util.hexprint(buf) return buf

+ def _chunk_read(pipe, count, status_fn): block = 32 data = "" @@ -44,15 +49,16 @@ def _chunk_read(pipe, count, status_fn): data += pipe.read(block) if data: if data[0] == chr(CMD_ACK): - data = data[1:] # Chew an echo'd ack if using a 2-pin cable - #print "Chewed an ack" + data = data[1:] # Chew an echo'd ack if using a 2-pin cable + # print "Chewed an ack" status = chirp_common.Status() status.msg = "Cloning from radio" status.max = count status.cur = len(data) status_fn(status) LOG.debug("Read %i/%i" % (len(data), count)) - return data + return data +

def __clone_in(radio): pipe = radio.pipe @@ -79,12 +85,14 @@ def __clone_in(radio):

return memmap.MemoryMap(data)

+ def _clone_in(radio): try: return __clone_in(radio) except Exception, e: raise errors.RadioError("Failed to communicate with the radio: %s" % e)

+ def _chunk_write(pipe, data, status_fn, block): delay = 0.03 count = 0 @@ -92,7 +100,7 @@ def _chunk_write(pipe, data, status_fn, block): chunk = data[i:i+block] pipe.write(chunk) count += len(chunk) - LOG.debug("@_chunk_write, count: %i, blocksize: %i" % (count,block)) + LOG.debug("@_chunk_write, count: %i, blocksize: %i" % (count, block)) time.sleep(delay)

status = chirp_common.Status() @@ -100,7 +108,8 @@ def _chunk_write(pipe, data, status_fn, block): status.max = len(data) status.cur = count status_fn(status) - + + def __clone_out(radio): pipe = radio.pipe block_lengths = radio._block_lengths @@ -132,16 +141,18 @@ def __clone_out(radio): radio.status_fn, radio._block_size) pos += block

- pipe.read(pos) # Chew the echo if using a 2-pin cable + pipe.read(pos) # Chew the echo if using a 2-pin cable

print "Clone completed in %i seconds" % (time.time() - start)

+ def _clone_out(radio): try: return __clone_out(radio) except Exception, e: raise errors.RadioError("Failed to communicate with the radio: %s" % e)

+ class YaesuChecksum: """A Yaesu Checksum Object""" def __init__(self, start, stop, address=None): @@ -172,6 +183,7 @@ class YaesuChecksum: self._stop, self._address)

+ class YaesuCloneModeRadio(chirp_common.CloneModeRadio): """Base class for all Yaesu clone-mode radios""" _block_lengths = [8, 65536] @@ -194,7 +206,7 @@ class YaesuCloneModeRadio(chirp_common.CloneModeRadio): 3. Prepare radio for clone. 4. Press the key to receive the image.""")) return rp - + def _checksums(self): """Return a list of checksum objects that need to be calculated""" return [] diff --git a/tools/cpep8.blacklist b/tools/cpep8.blacklist index 029afc5..d957f1c 100644 --- a/tools/cpep8.blacklist +++ b/tools/cpep8.blacklist @@ -61,4 +61,3 @@ ./chirp/drivers/vxa700.py ./chirp/drivers/wouxun.py ./chirp/drivers/wouxun_common.py -./chirp/drivers/yaesu_clone.py

# HG changeset patch # User Zach Welch zach@mandolincreekfarm.com # Fake Node ID 09ea08bd2891750679e12d7df4cc689ed12f19c6

Fix style issues in wouxum.py (#2355)

diff --git a/chirp/drivers/wouxun.py b/chirp/drivers/wouxun.py index 2a73f0a..dc03314 100644 --- a/chirp/drivers/wouxun.py +++ b/chirp/drivers/wouxun.py @@ -28,47 +28,49 @@ from textwrap import dedent

LOG = logging.getLogger(__name__)

-FREQ_ENCODE_TABLE = [ 0x7, 0xa, 0x0, 0x9, 0xb, 0x2, 0xe, 0x1, 0x3, 0xf ] - +FREQ_ENCODE_TABLE = [0x7, 0xa, 0x0, 0x9, 0xb, 0x2, 0xe, 0x1, 0x3, 0xf] + + def encode_freq(freq): """Convert frequency (4 decimal digits) to wouxun format (2 bytes)""" enc = 0 div = 1000 for i in range(0, 4): enc <<= 4 - enc |= FREQ_ENCODE_TABLE[ (freq/div) % 10 ] + enc |= FREQ_ENCODE_TABLE[(freq/div) % 10] div /= 10 return enc

+ def decode_freq(data): """Convert from wouxun format (2 bytes) to frequency (4 decimal digits)""" freq = 0 shift = 12 for i in range(0, 4): freq *= 10 - freq += FREQ_ENCODE_TABLE.index( (data>>shift) & 0xf ) + freq += FREQ_ENCODE_TABLE.index((data >> shift) & 0xf) shift -= 4 # print "data %04x freq %d shift %d" % (data, freq, shift) return freq

+ @directory.register class KGUVD1PRadio(chirp_common.CloneModeRadio, - chirp_common.ExperimentalRadio): + chirp_common.ExperimentalRadio): """Wouxun KG-UVD1P,UV2,UV3""" VENDOR = "Wouxun" MODEL = "KG-UVD1P" _model = "KG669V" - + _querymodel = ("HiWOUXUN\x02", "PROGUV6X\x02") - - CHARSET = list("0123456789") + [chr(x + ord("A")) \ - for x in range(0, 26)] + list("?+-") + + CHARSET = list("0123456789") + \ + [chr(x + ord("A")) for x in range(0, 26)] + list("?+-")

POWER_LEVELS = [chirp_common.PowerLevel("High", watts=5.00), chirp_common.PowerLevel("Low", watts=1.00)] - - valid_freq = [(136000000, 175000000), (216000000, 520000000)]

+ valid_freq = [(136000000, 175000000), (216000000, 520000000)]

_MEM_FORMAT = """ #seekto 0x0010; @@ -90,7 +92,7 @@ class KGUVD1PRadio(chirp_common.CloneModeRadio, iswidex:1, _0_unknown_2:4; } memory[199]; - + #seekto 0x0842; u16 fm_presets_0[9];

@@ -203,12 +205,12 @@ class KGUVD1PRadio(chirp_common.CloneModeRadio, def get_prompts(cls): rp = chirp_common.RadioPrompts() rp.experimental = \ - ('This version of the Wouxun driver allows you to modify the ' - 'frequency range settings of your radio. This has been tested ' - 'and reports from other users indicate that it is a safe ' - 'thing to do. However, modifications to this value may have ' - 'unintended consequences, including damage to your device. ' - 'You have been warned. Proceed at your own risk!') + ('This version of the Wouxun driver allows you to modify the ' + 'frequency range settings of your radio. This has been tested ' + 'and reports from other users indicate that it is a safe ' + 'thing to do. However, modifications to this value may have ' + 'unintended consequences, including damage to your device. ' + 'You have been warned. Proceed at your own risk!') rp.pre_download = _(dedent("""\ 1. Turn radio off. 2. Connect cable to mic/spkr connector. @@ -224,7 +226,7 @@ class KGUVD1PRadio(chirp_common.CloneModeRadio, 5. Ensure that the radio is tuned to channel with no activity. 6. Click OK to upload image to device.""")) return rp - + @classmethod def _get_querymodel(cls): if isinstance(cls._querymodel, str): @@ -248,8 +250,8 @@ class KGUVD1PRadio(chirp_common.CloneModeRadio, time.sleep(1) continue if resp[2:8] != self._model: - raise Exception("I can't talk to this model (%s)" % - util.hexprint(resp)) + raise Exception("I can't talk to this model (%s)" % + util.hexprint(resp)) return if len(resp) == 0: raise Exception("Radio not responding") @@ -262,7 +264,8 @@ class KGUVD1PRadio(chirp_common.CloneModeRadio, time.sleep(0.05) ack = self.pipe.read(1) if ack != "\x06": - raise Exception("Radio refused transfer mode") + raise Exception("Radio refused transfer mode") + def _download(self): """Talk to an original wouxun and do a download""" try: @@ -285,7 +288,6 @@ class KGUVD1PRadio(chirp_common.CloneModeRadio, except Exception, e: raise errors.RadioError("Failed to communicate with radio: %s" % e)

- def sync_in(self): self._mmap = self._download() self.process_mmap() @@ -303,8 +305,8 @@ class KGUVD1PRadio(chirp_common.CloneModeRadio, # offset 0x0010, like the radio actually stores it. So, # if we find one of those old ones, convert it to the new # format, padding 16 bytes of 0xFF in front. - self._mmap = memmap.MemoryMap(("\xFF" * 16) + \ - self._mmap.get_packed()[8:8184]) + self._mmap = memmap.MemoryMap( + ("\xFF" * 16) + self._mmap.get_packed()[8:8184]) self._memobj = bitwise.parse(self._MEM_FORMAT, self._mmap)

def get_features(self): @@ -342,57 +344,58 @@ class KGUVD1PRadio(chirp_common.CloneModeRadio, group = RadioSettings(cfg_s, freq_ranges, fm_preset)

rs = RadioSetting("menu_available", "Menu Available", - RadioSettingValueBoolean( - self._memobj.settings.menu_available)) + RadioSettingValueBoolean( + self._memobj.settings.menu_available)) cfg_s.append(rs)

rs = RadioSetting("vhf_rx_start", "1st band RX Lower Limit (MHz)", - RadioSettingValueInteger(50, 174, - decode_freq( - self._memobj.freq_ranges.vhf_rx_start))) + RadioSettingValueInteger( + 50, 174, decode_freq( + self._memobj.freq_ranges.vhf_rx_start))) freq_ranges.append(rs) rs = RadioSetting("vhf_rx_stop", "1st band RX Upper Limit (MHz)", - RadioSettingValueInteger(50, 174, - decode_freq( - self._memobj.freq_ranges.vhf_rx_stop))) + RadioSettingValueInteger( + 50, 174, decode_freq( + self._memobj.freq_ranges.vhf_rx_stop))) freq_ranges.append(rs) rs = RadioSetting("uhf_rx_start", "2nd band RX Lower Limit (MHz)", - RadioSettingValueInteger(136, 520, - decode_freq( - self._memobj.freq_ranges.uhf_rx_start))) + RadioSettingValueInteger( + 136, 520, decode_freq( + self._memobj.freq_ranges.uhf_rx_start))) freq_ranges.append(rs) rs = RadioSetting("uhf_rx_stop", "2nd band RX Upper Limit (MHz)", - RadioSettingValueInteger(136, 520, - decode_freq( - self._memobj.freq_ranges.uhf_rx_stop))) + RadioSettingValueInteger( + 136, 520, decode_freq( + self._memobj.freq_ranges.uhf_rx_stop))) freq_ranges.append(rs) rs = RadioSetting("vhf_tx_start", "1st band TX Lower Limit (MHz)", - RadioSettingValueInteger(50, 174, - decode_freq( - self._memobj.freq_ranges.vhf_tx_start))) + RadioSettingValueInteger( + 50, 174, decode_freq( + self._memobj.freq_ranges.vhf_tx_start))) freq_ranges.append(rs) rs = RadioSetting("vhf_tx_stop", "1st TX Upper Limit (MHz)", - RadioSettingValueInteger(50, 174, - decode_freq( - self._memobj.freq_ranges.vhf_tx_stop))) + RadioSettingValueInteger( + 50, 174, decode_freq( + self._memobj.freq_ranges.vhf_tx_stop))) freq_ranges.append(rs) rs = RadioSetting("uhf_tx_start", "2st band TX Lower Limit (MHz)", - RadioSettingValueInteger(136, 520, - decode_freq( - self._memobj.freq_ranges.uhf_tx_start))) + RadioSettingValueInteger( + 136, 520, decode_freq( + self._memobj.freq_ranges.uhf_tx_start))) freq_ranges.append(rs) rs = RadioSetting("uhf_tx_stop", "2st band TX Upper Limit (MHz)", - RadioSettingValueInteger(136, 520, - decode_freq( - self._memobj.freq_ranges.uhf_tx_stop))) + RadioSettingValueInteger( + 136, 520, decode_freq( + self._memobj.freq_ranges.uhf_tx_stop))) freq_ranges.append(rs) - + # tell the decoded ranges to UI - self.valid_freq = [ - (decode_freq(self._memobj.freq_ranges.vhf_rx_start) * 1000000, - (decode_freq(self._memobj.freq_ranges.vhf_rx_stop)+1) * 1000000), - (decode_freq(self._memobj.freq_ranges.uhf_rx_start) * 1000000, - (decode_freq(self._memobj.freq_ranges.uhf_rx_stop)+1) * 1000000)] + freq_ranges = self._memobj.freq_ranges + self.valid_freq = \ + [(decode_freq(freq_ranges.vhf_rx_start) * 1000000, + (decode_freq(freq_ranges.vhf_rx_stop) + 1) * 1000000), + (decode_freq(freq_ranges.uhf_rx_start) * 1000000, + (decode_freq(freq_ranges.uhf_rx_stop) + 1) * 1000000)]

def _filter(name): filtered = "" @@ -406,167 +409,179 @@ class KGUVD1PRadio(chirp_common.CloneModeRadio, # add some radio specific settings options = ["Off", "Welcome", "V bat"] rs = RadioSetting("ponmsg", "Poweron message", - RadioSettingValueList(options, - options[self._memobj.settings.ponmsg])) + RadioSettingValueList( + options, options[self._memobj.settings.ponmsg])) cfg_s.append(rs) rs = RadioSetting("strings.welcome1", "Power-On Message 1", - RadioSettingValueString(0, 6, - _filter(self._memobj.strings.welcome1))) + RadioSettingValueString( + 0, 6, _filter(self._memobj.strings.welcome1))) cfg_s.append(rs) rs = RadioSetting("strings.welcome2", "Power-On Message 2", - RadioSettingValueString(0, 6, - _filter(self._memobj.strings.welcome2))) + RadioSettingValueString( + 0, 6, _filter(self._memobj.strings.welcome2))) cfg_s.append(rs) rs = RadioSetting("strings.single_band", "Single Band Message", - RadioSettingValueString(0, 6, - _filter(self._memobj.strings.single_band))) + RadioSettingValueString( + 0, 6, _filter(self._memobj.strings.single_band))) cfg_s.append(rs) - options = ["Channel", "ch/freq","Name", "VFO"] + options = ["Channel", "ch/freq", "Name", "VFO"] rs = RadioSetting("vfo_a_ch_disp", "VFO A Channel disp mode", - RadioSettingValueList(options, - options[self._memobj.settings.vfo_a_ch_disp])) + RadioSettingValueList( + options, + options[self._memobj.settings.vfo_a_ch_disp])) cfg_s.append(rs) rs = RadioSetting("vfo_b_ch_disp", "VFO B Channel disp mode", - RadioSettingValueList(options, - options[self._memobj.settings.vfo_b_ch_disp])) + RadioSettingValueList( + options, + options[self._memobj.settings.vfo_b_ch_disp])) cfg_s.append(rs) options = ["5.0", "6.25", "10.0", "12.5", "25.0", "50.0", "100.0"] rs = RadioSetting("vfo_a_fr_step", "VFO A Frequency Step", - RadioSettingValueList(options, - options[self._memobj.settings.vfo_a_fr_step])) + RadioSettingValueList( + options, + options[self._memobj.settings.vfo_a_fr_step])) cfg_s.append(rs) rs = RadioSetting("vfo_b_fr_step", "VFO B Frequency Step", - RadioSettingValueList(options, - options[self._memobj.settings.vfo_b_fr_step])) + RadioSettingValueList( + options, + options[self._memobj.settings.vfo_b_fr_step])) cfg_s.append(rs) rs = RadioSetting("vfo_a_squelch", "VFO A Squelch", - RadioSettingValueInteger(0, 9, - self._memobj.settings.vfo_a_squelch)) + RadioSettingValueInteger( + 0, 9, self._memobj.settings.vfo_a_squelch)) cfg_s.append(rs) rs = RadioSetting("vfo_b_squelch", "VFO B Squelch", - RadioSettingValueInteger(0, 9, - self._memobj.settings.vfo_b_squelch)) + RadioSettingValueInteger( + 0, 9, self._memobj.settings.vfo_b_squelch)) cfg_s.append(rs) rs = RadioSetting("vfo_a_cur_chan", "VFO A current channel", - RadioSettingValueInteger(1, 128, - self._memobj.settings.vfo_a_cur_chan)) + RadioSettingValueInteger( + 1, 128, self._memobj.settings.vfo_a_cur_chan)) cfg_s.append(rs) rs = RadioSetting("vfo_b_cur_chan", "VFO B current channel", - RadioSettingValueInteger(1, 128, - self._memobj.settings.vfo_b_cur_chan)) + RadioSettingValueInteger( + 1, 128, self._memobj.settings.vfo_b_cur_chan)) cfg_s.append(rs) rs = RadioSetting("priority_chan", "Priority channel", - RadioSettingValueInteger(0, 199, - self._memobj.settings.priority_chan)) + RadioSettingValueInteger( + 0, 199, self._memobj.settings.priority_chan)) cfg_s.append(rs) rs = RadioSetting("power_save", "Power save", - RadioSettingValueBoolean( - self._memobj.settings.power_save)) + RadioSettingValueBoolean( + self._memobj.settings.power_save)) cfg_s.append(rs) options = ["Off", "Scan", "Lamp", "SOS", "Radio"] rs = RadioSetting("pf1_function", "PF1 Function select", - RadioSettingValueList(options, - options[self._memobj.settings.pf1_function])) + RadioSettingValueList( + options, + options[self._memobj.settings.pf1_function])) cfg_s.append(rs) options = ["Off", "Begin", "End", "Both"] rs = RadioSetting("roger_beep", "Roger beep select", - RadioSettingValueList(options, - options[self._memobj.settings.roger_beep])) + RadioSettingValueList( + options, + options[self._memobj.settings.roger_beep])) cfg_s.append(rs) options = ["%s" % x for x in range(15, 615, 15)] + transmit_time_out = options[self._memobj.settings.transmit_time_out] rs = RadioSetting("transmit_time_out", "TX Time-out Timer", - RadioSettingValueList(options, - options[self._memobj.settings.transmit_time_out])) + RadioSettingValueList( + options, transmit_time_out)) cfg_s.append(rs) rs = RadioSetting("tx_time_out_alert", "TX Time-out Alert", - RadioSettingValueInteger(0, 10, - self._memobj.settings.tx_time_out_alert)) + RadioSettingValueInteger( + 0, 10, self._memobj.settings.tx_time_out_alert)) cfg_s.append(rs) rs = RadioSetting("vox", "Vox", - RadioSettingValueInteger(0, 10, - self._memobj.settings.vox)) + RadioSettingValueInteger( + 0, 10, self._memobj.settings.vox)) cfg_s.append(rs) options = ["Off", "Chinese", "English"] rs = RadioSetting("voice", "Voice", - RadioSettingValueList(options, - options[self._memobj.settings.voice])) + RadioSettingValueList( + options, options[self._memobj.settings.voice])) cfg_s.append(rs) rs = RadioSetting("beep", "Beep", - RadioSettingValueBoolean( - self._memobj.settings.beep)) + RadioSettingValueBoolean( + self._memobj.settings.beep)) cfg_s.append(rs) rs = RadioSetting("ani_id_enable", "ANI id enable", - RadioSettingValueBoolean( - self._memobj.settings.ani_id_enable)) + RadioSettingValueBoolean( + self._memobj.settings.ani_id_enable)) cfg_s.append(rs) rs = RadioSetting("ani_id_tx_delay", "ANI id tx delay", - RadioSettingValueInteger(0, 30, - self._memobj.settings.ani_id_tx_delay)) + RadioSettingValueInteger( + 0, 30, self._memobj.settings.ani_id_tx_delay)) cfg_s.append(rs) options = ["Off", "Key", "ANI", "Key+ANI"] rs = RadioSetting("ani_id_sidetone", "ANI id sidetone", - RadioSettingValueList(options, - options[self._memobj.settings.ani_id_sidetone])) + RadioSettingValueList( + options, + options[self._memobj.settings.ani_id_sidetone])) cfg_s.append(rs) options = ["Time", "Carrier", "Search"] rs = RadioSetting("scan_mode", "Scan mode", - RadioSettingValueList(options, - options[self._memobj.settings.scan_mode])) + RadioSettingValueList( + options, + options[self._memobj.settings.scan_mode])) cfg_s.append(rs) rs = RadioSetting("kbd_lock", "Keyboard lock", - RadioSettingValueBoolean( - self._memobj.settings.kbd_lock)) + RadioSettingValueBoolean( + self._memobj.settings.kbd_lock)) cfg_s.append(rs) rs = RadioSetting("auto_lock_kbd", "Auto lock keyboard", - RadioSettingValueBoolean( - self._memobj.settings.auto_lock_kbd)) + RadioSettingValueBoolean( + self._memobj.settings.auto_lock_kbd)) cfg_s.append(rs) rs = RadioSetting("auto_backlight", "Auto backlight", - RadioSettingValueBoolean( - self._memobj.settings.auto_backlight)) + RadioSettingValueBoolean( + self._memobj.settings.auto_backlight)) cfg_s.append(rs) options = ["CH A", "CH B"] rs = RadioSetting("sos_ch", "SOS CH", - RadioSettingValueList(options, - options[self._memobj.settings.sos_ch])) + RadioSettingValueList( + options, + options[self._memobj.settings.sos_ch])) cfg_s.append(rs) rs = RadioSetting("stopwatch", "Stopwatch", - RadioSettingValueBoolean( - self._memobj.settings.stopwatch)) + RadioSettingValueBoolean( + self._memobj.settings.stopwatch)) cfg_s.append(rs) rs = RadioSetting("dual_band_receive", "Dual band receive", - RadioSettingValueBoolean( - self._memobj.settings.dual_band_receive)) + RadioSettingValueBoolean( + self._memobj.settings.dual_band_receive)) cfg_s.append(rs) options = ["VFO A", "VFO B"] rs = RadioSetting("current_vfo", "Current VFO", - RadioSettingValueList(options, - options[self._memobj.settings.current_vfo])) + RadioSettingValueList( + options, + options[self._memobj.settings.current_vfo])) cfg_s.append(rs)

options = ["Dual", "Single"] rs = RadioSetting("sd_available", "Single/Dual Band", - RadioSettingValueList(options, - options[self._memobj.settings.sd_available])) + RadioSettingValueList( + options, + options[self._memobj.settings.sd_available])) cfg_s.append(rs)

_pwd = self._memobj.settings.mode_password rs = RadioSetting("mode_password", "Mode password (000000 disabled)", - RadioSettingValueInteger(0, 9, _pwd[0]), - RadioSettingValueInteger(0, 9, _pwd[1]), - RadioSettingValueInteger(0, 9, _pwd[2]), - RadioSettingValueInteger(0, 9, _pwd[3]), - RadioSettingValueInteger(0, 9, _pwd[4]), - RadioSettingValueInteger(0, 9, _pwd[5])) + RadioSettingValueInteger(0, 9, _pwd[0]), + RadioSettingValueInteger(0, 9, _pwd[1]), + RadioSettingValueInteger(0, 9, _pwd[2]), + RadioSettingValueInteger(0, 9, _pwd[3]), + RadioSettingValueInteger(0, 9, _pwd[4]), + RadioSettingValueInteger(0, 9, _pwd[5])) cfg_s.append(rs) _pwd = self._memobj.settings.reset_password rs = RadioSetting("reset_password", "Reset password (000000 disabled)", - RadioSettingValueInteger(0, 9, _pwd[0]), - RadioSettingValueInteger(0, 9, _pwd[1]), - RadioSettingValueInteger(0, 9, _pwd[2]), - RadioSettingValueInteger(0, 9, _pwd[3]), - RadioSettingValueInteger(0, 9, _pwd[4]), - RadioSettingValueInteger(0, 9, _pwd[5])) + RadioSettingValueInteger(0, 9, _pwd[0]), + RadioSettingValueInteger(0, 9, _pwd[1]), + RadioSettingValueInteger(0, 9, _pwd[2]), + RadioSettingValueInteger(0, 9, _pwd[3]), + RadioSettingValueInteger(0, 9, _pwd[4]), + RadioSettingValueInteger(0, 9, _pwd[5])) cfg_s.append(rs)

dtmfchars = "0123456789 *#ABCD" @@ -575,6 +590,7 @@ class KGUVD1PRadio(chirp_common.CloneModeRadio, val = RadioSettingValueString(0, 6, _code, False) val.set_charset(dtmfchars) rs = RadioSetting("settings.ani_id_content", "PTT-ID Code", val) + def apply_ani_id(setting, obj): value = [] for j in range(0, 6): @@ -589,26 +605,26 @@ class KGUVD1PRadio(chirp_common.CloneModeRadio, for i in range(0, 9): if self._memobj.fm_presets_0[i] != 0xFFFF: used = True - preset = self._memobj.fm_presets_0[i]/10.0+76 + preset = self._memobj.fm_presets_0[i] / 10.0 + 76 else: used = False preset = 76 - rs = RadioSetting("fm_presets_0_%1i" % i, - "Team 1 Location %i" % (i+1), - RadioSettingValueBoolean(used), - RadioSettingValueFloat(76, 108, preset, 0.1, 1)) + rs = RadioSetting("fm_presets_0_%1i" % i, + "Team 1 Location %i" % (i + 1), + RadioSettingValueBoolean(used), + RadioSettingValueFloat(76, 108, preset, 0.1, 1)) fm_preset.append(rs) for i in range(0, 9): if self._memobj.fm_presets_1[i] != 0xFFFF: used = True - preset = self._memobj.fm_presets_1[i]/10.0+76 + preset = self._memobj.fm_presets_1[i] / 10.0 + 76 else: used = False preset = 76 - rs = RadioSetting("fm_presets_1_%1i" % i, - "Team 2 Location %i" % (i+1), - RadioSettingValueBoolean(used), - RadioSettingValueFloat(76, 108, preset, 0.1, 1)) + rs = RadioSetting("fm_presets_1_%1i" % i, + "Team 2 Location %i" % (i + 1), + RadioSettingValueBoolean(used), + RadioSettingValueFloat(76, 108, preset, 0.1, 1)) fm_preset.append(rs)

return group @@ -616,9 +632,9 @@ class KGUVD1PRadio(chirp_common.CloneModeRadio, def set_settings(self, settings): for element in settings: if not isinstance(element, RadioSetting): - if element.get_name() == "freq_ranges" : + if element.get_name() == "freq_ranges": self._set_freq_settings(element) - elif element.get_name() == "fm_preset" : + elif element.get_name() == "fm_preset": self._set_fm_preset(element) else: self.set_settings(element) @@ -720,8 +736,8 @@ class KGUVD1PRadio(chirp_common.CloneModeRadio, # always set it even if no dtcs is used mem.dtcs_polarity = "%s%s" % (tpol or "N", rpol or "N")

- LOG.debug("Got TX %s (%i) RX %s (%i)" % (txmode, _mem.tx_tone, - rxmode, _mem.rx_tone)) + LOG.debug("Got TX %s (%i) RX %s (%i)" % + (txmode, _mem.tx_tone, rxmode, _mem.rx_tone))

def _is_txinh(self, _mem): raw_tx = "" @@ -779,8 +795,8 @@ class KGUVD1PRadio(chirp_common.CloneModeRadio,

options = ["NFM", "FM"] iswidex = RadioSetting("iswidex", "Mode TX(KG-UV6X)", - RadioSettingValueList(options, - options[_mem.iswidex])) + RadioSettingValueList( + options, options[_mem.iswidex])) iswidex.set_doc("Mode TX") mem.extra.append(iswidex)

@@ -801,7 +817,6 @@ class KGUVD1PRadio(chirp_common.CloneModeRadio, else: tx_mode = rx_mode = mem.tmode

- if tx_mode == "DTCS": _mem.tx_tone = mem.tmode != "DTCS" and \ _set_dcs(mem.dtcs, mem.dtcs_polarity[0]) or \ @@ -819,8 +834,8 @@ class KGUVD1PRadio(chirp_common.CloneModeRadio, else: _mem.rx_tone = 0xFFFF

- LOG.debug("Set TX %s (%i) RX %s (%i)" % (tx_mode, _mem.tx_tone, - rx_mode, _mem.rx_tone)) + LOG.debug("Set TX %s (%i) RX %s (%i)" % + (tx_mode, _mem.tx_tone, rx_mode, _mem.rx_tone))

def set_memory(self, mem): _mem = self._memobj.memory[mem.number - 1] @@ -873,7 +888,7 @@ class KGUVD1PRadio(chirp_common.CloneModeRadio, filedata[0x60:0x64] != "2009" and \ filedata[0x1f77:0x1f7d] == "\xff\xff\xff\xff\xff\xff" and \ filedata[0x0d70:0x0d80] == "\xff\xff\xff\xff\xff\xff\xff\xff" \ - "\xff\xff\xff\xff\xff\xff\xff\xff": + "\xff\xff\xff\xff\xff\xff\xff\xff": # those areas are (seems to be) unused return True # Old-style image (CHIRP 0.1.11) @@ -882,13 +897,14 @@ class KGUVD1PRadio(chirp_common.CloneModeRadio, return True return False

+ @directory.register class KGUV6DRadio(KGUVD1PRadio): """Wouxun KG-UV6 (D and X variants)""" MODEL = "KG-UV6" - + _querymodel = ("HiWXUVD1\x02", "HiKGUVD1\x02") - + _MEM_FORMAT = """ #seekto 0x0010; struct { @@ -1009,7 +1025,7 @@ class KGUV6DRadio(KGUVD1PRadio): _2_unknown_4:4; u8 pad[2]; } vfo_settings[2]; - + #seekto 0x0f82; u16 fm_presets_0[9];

@@ -1043,7 +1059,6 @@ class KGUV6DRadio(KGUVD1PRadio): u16 fm_presets_1[9]; """

- def get_features(self): rf = KGUVD1PRadio.get_features(self) rf.memory_bounds = (1, 199) @@ -1056,57 +1071,58 @@ class KGUV6DRadio(KGUVD1PRadio): group = RadioSettings(cfg_s, freq_ranges, fm_preset)

rs = RadioSetting("menu_available", "Menu Available", - RadioSettingValueBoolean( - self._memobj.settings.menu_available)) + RadioSettingValueBoolean( + self._memobj.settings.menu_available)) cfg_s.append(rs)

rs = RadioSetting("vhf_rx_start", "VHF RX Lower Limit (MHz)", - RadioSettingValueInteger(1, 1000, - decode_freq( - self._memobj.freq_ranges.vhf_rx_start))) + RadioSettingValueInteger( + 1, 1000, decode_freq( + self._memobj.freq_ranges.vhf_rx_start))) freq_ranges.append(rs) rs = RadioSetting("vhf_rx_stop", "VHF RX Upper Limit (MHz)", - RadioSettingValueInteger(1, 1000, - decode_freq( - self._memobj.freq_ranges.vhf_rx_stop))) + RadioSettingValueInteger( + 1, 1000, decode_freq( + self._memobj.freq_ranges.vhf_rx_stop))) freq_ranges.append(rs) rs = RadioSetting("uhf_rx_start", "UHF RX Lower Limit (MHz)", - RadioSettingValueInteger(1, 1000, - decode_freq( - self._memobj.freq_ranges.uhf_rx_start))) + RadioSettingValueInteger( + 1, 1000, decode_freq( + self._memobj.freq_ranges.uhf_rx_start))) freq_ranges.append(rs) rs = RadioSetting("uhf_rx_stop", "UHF RX Upper Limit (MHz)", - RadioSettingValueInteger(1, 1000, - decode_freq( - self._memobj.freq_ranges.uhf_rx_stop))) + RadioSettingValueInteger( + 1, 1000, decode_freq( + self._memobj.freq_ranges.uhf_rx_stop))) freq_ranges.append(rs) rs = RadioSetting("vhf_tx_start", "VHF TX Lower Limit (MHz)", - RadioSettingValueInteger(1, 1000, - decode_freq( - self._memobj.freq_ranges.vhf_tx_start))) + RadioSettingValueInteger( + 1, 1000, decode_freq( + self._memobj.freq_ranges.vhf_tx_start))) freq_ranges.append(rs) rs = RadioSetting("vhf_tx_stop", "VHF TX Upper Limit (MHz)", - RadioSettingValueInteger(1, 1000, - decode_freq( - self._memobj.freq_ranges.vhf_tx_stop))) + RadioSettingValueInteger( + 1, 1000, decode_freq( + self._memobj.freq_ranges.vhf_tx_stop))) freq_ranges.append(rs) rs = RadioSetting("uhf_tx_start", "UHF TX Lower Limit (MHz)", - RadioSettingValueInteger(1, 1000, - decode_freq( - self._memobj.freq_ranges.uhf_tx_start))) + RadioSettingValueInteger( + 1, 1000, decode_freq( + self._memobj.freq_ranges.uhf_tx_start))) freq_ranges.append(rs) rs = RadioSetting("uhf_tx_stop", "UHF TX Upper Limit (MHz)", - RadioSettingValueInteger(1, 1000, - decode_freq( - self._memobj.freq_ranges.uhf_tx_stop))) + RadioSettingValueInteger( + 1, 1000, decode_freq( + self._memobj.freq_ranges.uhf_tx_stop))) freq_ranges.append(rs) - + # tell the decoded ranges to UI - self.valid_freq = [ - (decode_freq(self._memobj.freq_ranges.vhf_rx_start) * 1000000, - (decode_freq(self._memobj.freq_ranges.vhf_rx_stop)+1) * 1000000), - (decode_freq(self._memobj.freq_ranges.uhf_rx_start) * 1000000, - (decode_freq(self._memobj.freq_ranges.uhf_rx_stop)+1) * 1000000)] + freq_ranges = self._memobj.freq_ranges + self.valid_freq = \ + [(decode_freq(freq_ranges.vhf_rx_start) * 1000000, + (decode_freq(freq_ranges.vhf_rx_stop) + 1) * 1000000), + (decode_freq(freq_ranges.uhf_rx_start) * 1000000, + (decode_freq(freq_ranges.uhf_rx_stop) + 1) * 1000000)]

def _filter(name): filtered = "" @@ -1120,173 +1136,185 @@ class KGUV6DRadio(KGUVD1PRadio): # add some radio specific settings options = ["Off", "Welcome", "V bat", "N/A(KG-UV6X)"] rs = RadioSetting("ponmsg", "Poweron message", - RadioSettingValueList(options, - options[self._memobj.settings.ponmsg])) + RadioSettingValueList( + options, options[self._memobj.settings.ponmsg])) cfg_s.append(rs) rs = RadioSetting("strings.welcome1", "Power-On Message 1", - RadioSettingValueString(0, 6, - _filter(self._memobj.strings.welcome1))) + RadioSettingValueString( + 0, 6, _filter(self._memobj.strings.welcome1))) cfg_s.append(rs) rs = RadioSetting("strings.welcome2", "Power-On Message 2", - RadioSettingValueString(0, 6, - _filter(self._memobj.strings.welcome2))) + RadioSettingValueString( + 0, 6, _filter(self._memobj.strings.welcome2))) cfg_s.append(rs) rs = RadioSetting("strings.single_band", "Single Band Message", - RadioSettingValueString(0, 6, - _filter(self._memobj.strings.single_band))) + RadioSettingValueString( + 0, 6, _filter(self._memobj.strings.single_band))) cfg_s.append(rs) - options = ["Channel", "ch/freq","Name", "VFO"] + options = ["Channel", "ch/freq", "Name", "VFO"] rs = RadioSetting("vfo_a_ch_disp", "VFO A Channel disp mode", - RadioSettingValueList(options, - options[self._memobj.settings.vfo_a_ch_disp])) + RadioSettingValueList( + options, + options[self._memobj.settings.vfo_a_ch_disp])) cfg_s.append(rs) rs = RadioSetting("vfo_b_ch_disp", "VFO B Channel disp mode", - RadioSettingValueList(options, - options[self._memobj.settings.vfo_b_ch_disp])) + RadioSettingValueList( + options, + options[self._memobj.settings.vfo_b_ch_disp])) cfg_s.append(rs) options = \ ["2.5", "5.0", "6.25", "10.0", "12.5", "25.0", "50.0", "100.0"] rs = RadioSetting("vfo_a_fr_step", "VFO A Frequency Step", - RadioSettingValueList(options, - options[self._memobj.settings.vfo_a_fr_step])) + RadioSettingValueList( + options, + options[self._memobj.settings.vfo_a_fr_step])) cfg_s.append(rs) rs = RadioSetting("vfo_b_fr_step", "VFO B Frequency Step", - RadioSettingValueList(options, - options[self._memobj.settings.vfo_b_fr_step])) + RadioSettingValueList( + options, + options[self._memobj.settings.vfo_b_fr_step])) cfg_s.append(rs) rs = RadioSetting("vfo_a_squelch", "VFO A Squelch", - RadioSettingValueInteger(0, 9, - self._memobj.settings.vfo_a_squelch)) + RadioSettingValueInteger( + 0, 9, self._memobj.settings.vfo_a_squelch)) cfg_s.append(rs) rs = RadioSetting("vfo_b_squelch", "VFO B Squelch", - RadioSettingValueInteger(0, 9, - self._memobj.settings.vfo_b_squelch)) + RadioSettingValueInteger( + 0, 9, self._memobj.settings.vfo_b_squelch)) cfg_s.append(rs) rs = RadioSetting("vfo_a_cur_chan", "VFO A current channel", - RadioSettingValueInteger(1, 199, - self._memobj.settings.vfo_a_cur_chan)) + RadioSettingValueInteger( + 1, 199, self._memobj.settings.vfo_a_cur_chan)) cfg_s.append(rs) rs = RadioSetting("vfo_b_cur_chan", "VFO B current channel", - RadioSettingValueInteger(1, 199, - self._memobj.settings.vfo_b_cur_chan)) + RadioSettingValueInteger( + 1, 199, self._memobj.settings.vfo_b_cur_chan)) cfg_s.append(rs) rs = RadioSetting("priority_chan", "Priority channel", - RadioSettingValueInteger(0, 199, - self._memobj.settings.priority_chan)) + RadioSettingValueInteger( + 0, 199, self._memobj.settings.priority_chan)) cfg_s.append(rs) rs = RadioSetting("power_save", "Power save", - RadioSettingValueBoolean( - self._memobj.settings.power_save)) + RadioSettingValueBoolean( + self._memobj.settings.power_save)) cfg_s.append(rs) options = ["Off", "Scan", "Lamp", "SOS", "Radio"] rs = RadioSetting("pf1_function", "PF1 Function select", - RadioSettingValueList(options, - options[self._memobj.settings.pf1_function])) + RadioSettingValueList( + options, + options[self._memobj.settings.pf1_function])) cfg_s.append(rs) options = ["Off", "Radio", "fr/ch", "Rpt", "Stopwatch", "Lamp", "SOS"] rs = RadioSetting("pf2_function", "PF2 Function select", - RadioSettingValueList(options, - options[self._memobj.settings.pf2_function])) + RadioSettingValueList( + options, + options[self._memobj.settings.pf2_function])) cfg_s.append(rs) options = ["Off", "Begin", "End", "Both"] rs = RadioSetting("roger_beep", "Roger beep select", - RadioSettingValueList(options, - options[self._memobj.settings.roger_beep])) + RadioSettingValueList( + options, + options[self._memobj.settings.roger_beep])) cfg_s.append(rs) options = ["%s" % x for x in range(15, 615, 15)] + transmit_time_out = options[self._memobj.settings.transmit_time_out] rs = RadioSetting("transmit_time_out", "TX Time-out Timer", - RadioSettingValueList(options, - options[self._memobj.settings.transmit_time_out])) + RadioSettingValueList( + options, transmit_time_out)) cfg_s.append(rs) rs = RadioSetting("tx_time_out_alert", "TX Time-out Alert", - RadioSettingValueInteger(0, 10, - self._memobj.settings.tx_time_out_alert)) + RadioSettingValueInteger( + 0, 10, self._memobj.settings.tx_time_out_alert)) cfg_s.append(rs) rs = RadioSetting("vox", "Vox", - RadioSettingValueInteger(0, 10, - self._memobj.settings.vox)) + RadioSettingValueInteger( + 0, 10, self._memobj.settings.vox)) cfg_s.append(rs) options = ["Off", "Chinese", "English"] rs = RadioSetting("voice", "Voice", - RadioSettingValueList(options, - options[self._memobj.settings.voice])) + RadioSettingValueList( + options, options[self._memobj.settings.voice])) cfg_s.append(rs) rs = RadioSetting("beep", "Beep", - RadioSettingValueBoolean( - self._memobj.settings.beep)) + RadioSettingValueBoolean( + self._memobj.settings.beep)) cfg_s.append(rs) rs = RadioSetting("ani_id_enable", "ANI id enable", - RadioSettingValueBoolean( - self._memobj.settings.ani_id_enable)) + RadioSettingValueBoolean( + self._memobj.settings.ani_id_enable)) cfg_s.append(rs) rs = RadioSetting("ani_id_tx_delay", "ANI id tx delay", - RadioSettingValueInteger(0, 30, - self._memobj.settings.ani_id_tx_delay)) + RadioSettingValueInteger( + 0, 30, self._memobj.settings.ani_id_tx_delay)) cfg_s.append(rs) options = ["Off", "Key", "ANI", "Key+ANI"] rs = RadioSetting("ani_id_sidetone", "ANI id sidetone", - RadioSettingValueList(options, - options[self._memobj.settings.ani_id_sidetone])) + RadioSettingValueList( + options, + options[self._memobj.settings.ani_id_sidetone])) cfg_s.append(rs) options = ["Time", "Carrier", "Search"] rs = RadioSetting("scan_mode", "Scan mode", - RadioSettingValueList(options, - options[self._memobj.settings.scan_mode])) + RadioSettingValueList( + options, + options[self._memobj.settings.scan_mode])) cfg_s.append(rs) rs = RadioSetting("kbd_lock", "Keyboard lock", - RadioSettingValueBoolean( - self._memobj.settings.kbd_lock)) + RadioSettingValueBoolean( + self._memobj.settings.kbd_lock)) cfg_s.append(rs) rs = RadioSetting("auto_lock_kbd", "Auto lock keyboard", - RadioSettingValueBoolean( - self._memobj.settings.auto_lock_kbd)) + RadioSettingValueBoolean( + self._memobj.settings.auto_lock_kbd)) cfg_s.append(rs) rs = RadioSetting("auto_backlight", "Auto backlight", - RadioSettingValueBoolean( - self._memobj.settings.auto_backlight)) + RadioSettingValueBoolean( + self._memobj.settings.auto_backlight)) cfg_s.append(rs) options = ["CH A", "CH B"] rs = RadioSetting("sos_ch", "SOS CH", - RadioSettingValueList(options, - options[self._memobj.settings.sos_ch])) + RadioSettingValueList( + options, options[self._memobj.settings.sos_ch])) cfg_s.append(rs) rs = RadioSetting("stopwatch", "Stopwatch", - RadioSettingValueBoolean( - self._memobj.settings.stopwatch)) + RadioSettingValueBoolean( + self._memobj.settings.stopwatch)) cfg_s.append(rs) rs = RadioSetting("dual_band_receive", "Dual band receive", - RadioSettingValueBoolean( - self._memobj.settings.dual_band_receive)) + RadioSettingValueBoolean( + self._memobj.settings.dual_band_receive)) cfg_s.append(rs) options = ["VFO A", "VFO B"] rs = RadioSetting("current_vfo", "Current VFO", - RadioSettingValueList(options, - options[self._memobj.settings.current_vfo])) + RadioSettingValueList( + options, + options[self._memobj.settings.current_vfo])) cfg_s.append(rs)

options = ["Dual", "Single"] rs = RadioSetting("sd_available", "Single/Dual Band", - RadioSettingValueList(options, - options[self._memobj.settings.sd_available])) + RadioSettingValueList( + options, + options[self._memobj.settings.sd_available])) cfg_s.append(rs)

_pwd = self._memobj.settings.mode_password rs = RadioSetting("mode_password", "Mode password (000000 disabled)", - RadioSettingValueInteger(0, 9, _pwd[0]), - RadioSettingValueInteger(0, 9, _pwd[1]), - RadioSettingValueInteger(0, 9, _pwd[2]), - RadioSettingValueInteger(0, 9, _pwd[3]), - RadioSettingValueInteger(0, 9, _pwd[4]), - RadioSettingValueInteger(0, 9, _pwd[5])) + RadioSettingValueInteger(0, 9, _pwd[0]), + RadioSettingValueInteger(0, 9, _pwd[1]), + RadioSettingValueInteger(0, 9, _pwd[2]), + RadioSettingValueInteger(0, 9, _pwd[3]), + RadioSettingValueInteger(0, 9, _pwd[4]), + RadioSettingValueInteger(0, 9, _pwd[5])) cfg_s.append(rs) _pwd = self._memobj.settings.reset_password rs = RadioSetting("reset_password", "Reset password (000000 disabled)", - RadioSettingValueInteger(0, 9, _pwd[0]), - RadioSettingValueInteger(0, 9, _pwd[1]), - RadioSettingValueInteger(0, 9, _pwd[2]), - RadioSettingValueInteger(0, 9, _pwd[3]), - RadioSettingValueInteger(0, 9, _pwd[4]), - RadioSettingValueInteger(0, 9, _pwd[5])) + RadioSettingValueInteger(0, 9, _pwd[0]), + RadioSettingValueInteger(0, 9, _pwd[1]), + RadioSettingValueInteger(0, 9, _pwd[2]), + RadioSettingValueInteger(0, 9, _pwd[3]), + RadioSettingValueInteger(0, 9, _pwd[4]), + RadioSettingValueInteger(0, 9, _pwd[5])) cfg_s.append(rs)

dtmfchars = "0123456789 *#ABCD" @@ -1295,6 +1323,7 @@ class KGUV6DRadio(KGUVD1PRadio): val = RadioSettingValueString(0, 6, _code, False) val.set_charset(dtmfchars) rs = RadioSetting("settings.ani_id_content", "ANI Code", val) + def apply_ani_id(setting, obj): value = [] for j in range(0, 6): @@ -1313,10 +1342,10 @@ class KGUV6DRadio(KGUVD1PRadio): else: used = False preset = 76 - rs = RadioSetting("fm_presets_0_%1i" % i, - "Team 1 Location %i" % (i+1), - RadioSettingValueBoolean(used), - RadioSettingValueFloat(76, 108, preset, 0.1, 1)) + rs = RadioSetting("fm_presets_0_%1i" % i, + "Team 1 Location %i" % (i+1), + RadioSettingValueBoolean(used), + RadioSettingValueFloat(76, 108, preset, 0.1, 1)) fm_preset.append(rs) for i in range(0, 9): if self._memobj.fm_presets_1[i] != 0xFFFF: @@ -1325,10 +1354,10 @@ class KGUV6DRadio(KGUVD1PRadio): else: used = False preset = 76 - rs = RadioSetting("fm_presets_1_%1i" % i, - "Team 2 Location %i" % (i+1), - RadioSettingValueBoolean(used), - RadioSettingValueFloat(76, 108, preset, 0.1, 1)) + rs = RadioSetting("fm_presets_1_%1i" % i, + "Team 2 Location %i" % (i+1), + RadioSettingValueBoolean(used), + RadioSettingValueFloat(76, 108, preset, 0.1, 1)) fm_preset.append(rs)

return group @@ -1336,9 +1365,9 @@ class KGUV6DRadio(KGUVD1PRadio): def set_settings(self, settings): for element in settings: if not isinstance(element, RadioSetting): - if element.get_name() == "freq_ranges" : + if element.get_name() == "freq_ranges": self._set_freq_settings(element) - elif element.get_name() == "fm_preset" : + elif element.get_name() == "fm_preset": self._set_fm_preset(element) else: self.set_settings(element) @@ -1392,14 +1421,14 @@ class KGUV6DRadio(KGUVD1PRadio): return True return False

+ @directory.register -class KG816Radio(KGUVD1PRadio, - chirp_common.ExperimentalRadio): +class KG816Radio(KGUVD1PRadio, chirp_common.ExperimentalRadio): """Wouxun KG-816""" MODEL = "KG-816"

_querymodel = "HiWOUXUN\x02" - + _MEM_FORMAT = """ #seekto 0x0010; struct { @@ -1420,7 +1449,7 @@ class KG816Radio(KGUVD1PRadio, iswidex:1, _0_unknown_2:4; } memory[199]; - + #seekto 0x0d70; struct { u16 vhf_rx_start; @@ -1435,10 +1464,9 @@ class KG816Radio(KGUVD1PRadio,

#seekto 0x1010; struct { - u8 name[6]; - u8 pad[10]; + u8 name[6]; + u8 pad[10]; } names[199]; - """

@classmethod @@ -1448,62 +1476,62 @@ class KG816Radio(KGUVD1PRadio, 'organization of KGUVD1 but uses 199 memories. ' 'it has been reported to work but ' 'proceed at your own risk!') - + def get_features(self): rf = KGUVD1PRadio.get_features(self) - rf.memory_bounds = (1, 199) # this is the only known difference + rf.memory_bounds = (1, 199) # this is the only known difference return rf

def get_settings(self): - freq_ranges = RadioSettingGroup("freq_ranges", + freq_ranges = RadioSettingGroup("freq_ranges", "Freq Ranges (read only)") group = RadioSettings(freq_ranges)

rs = RadioSetting("vhf_rx_start", "vhf rx start", - RadioSettingValueInteger(66, 520, - decode_freq( - self._memobj.freq_ranges.vhf_rx_start))) + RadioSettingValueInteger( + 66, 520, decode_freq( + self._memobj.freq_ranges.vhf_rx_start))) freq_ranges.append(rs) rs = RadioSetting("vhf_rx_stop", "vhf rx stop", - RadioSettingValueInteger(66, 520, - decode_freq( - self._memobj.freq_ranges.vhf_rx_stop))) + RadioSettingValueInteger( + 66, 520, decode_freq( + self._memobj.freq_ranges.vhf_rx_stop))) freq_ranges.append(rs) rs = RadioSetting("uhf_rx_start", "uhf rx start", - RadioSettingValueInteger(66, 520, - decode_freq( - self._memobj.freq_ranges.uhf_rx_start))) + RadioSettingValueInteger( + 66, 520, decode_freq( + self._memobj.freq_ranges.uhf_rx_start))) freq_ranges.append(rs) rs = RadioSetting("uhf_rx_stop", "uhf rx stop", - RadioSettingValueInteger(66, 520, - decode_freq( - self._memobj.freq_ranges.uhf_rx_stop))) + RadioSettingValueInteger( + 66, 520, decode_freq( + self._memobj.freq_ranges.uhf_rx_stop))) freq_ranges.append(rs) rs = RadioSetting("vhf_tx_start", "vhf tx start", - RadioSettingValueInteger(66, 520, - decode_freq( - self._memobj.freq_ranges.vhf_tx_start))) + RadioSettingValueInteger( + 66, 520, decode_freq( + self._memobj.freq_ranges.vhf_tx_start))) freq_ranges.append(rs) rs = RadioSetting("vhf_tx_stop", "vhf tx stop", - RadioSettingValueInteger(66, 520, - decode_freq( - self._memobj.freq_ranges.vhf_tx_stop))) + RadioSettingValueInteger( + 66, 520, decode_freq( + self._memobj.freq_ranges.vhf_tx_stop))) freq_ranges.append(rs) rs = RadioSetting("uhf_tx_start", "uhf tx start", - RadioSettingValueInteger(66, 520, - decode_freq( - self._memobj.freq_ranges.uhf_tx_start))) + RadioSettingValueInteger( + 66, 520, decode_freq( + self._memobj.freq_ranges.uhf_tx_start))) freq_ranges.append(rs) rs = RadioSetting("uhf_tx_stop", "uhf tx stop", - RadioSettingValueInteger(66, 520, - decode_freq( - self._memobj.freq_ranges.uhf_tx_stop))) + RadioSettingValueInteger( + 66, 520, decode_freq( + self._memobj.freq_ranges.uhf_tx_stop))) freq_ranges.append(rs) - + # tell the decoded ranges to UI - self.valid_freq = [ - (decode_freq(self._memobj.freq_ranges.vhf_rx_start) * 1000000, - (decode_freq(self._memobj.freq_ranges.vhf_rx_stop)+1) * 1000000)] + self.valid_freq = \ + [(decode_freq(self._memobj.freq_ranges.vhf_rx_start) * 1000000, + (decode_freq(self._memobj.freq_ranges.vhf_rx_stop)+1) * 1000000)]

return group

@@ -1513,7 +1541,7 @@ class KG816Radio(KGUVD1PRadio, filedata[0x60:0x64] != "2009" and \ filedata[0x1f77:0x1f7d] == "\xff\xff\xff\xff\xff\xff" and \ filedata[0x0d70:0x0d80] != "\xff\xff\xff\xff\xff\xff\xff\xff" \ - "\xff\xff\xff\xff\xff\xff\xff\xff": + "\xff\xff\xff\xff\xff\xff\xff\xff": return True return False

diff --git a/tools/cpep8.blacklist b/tools/cpep8.blacklist index 84b4135..3d41ee2 100644 --- a/tools/cpep8.blacklist +++ b/tools/cpep8.blacklist @@ -59,4 +59,3 @@ ./chirp/drivers/vx7.py ./chirp/drivers/vx8.py ./chirp/drivers/vxa700.py -./chirp/drivers/wouxun.py

# HG changeset patch # User Zach Welch zach@mandolincreekfarm.com # Fake Node ID 05e9272663483d41cd79d133f7b165e7955c4ff5

Fix style issues in uv5r.py (#2355)

diff --git a/chirp/drivers/uv5r.py b/chirp/drivers/uv5r.py index 646d6e2..2f6ddad 100644 --- a/chirp/drivers/uv5r.py +++ b/chirp/drivers/uv5r.py @@ -107,9 +107,9 @@ struct { u8 mdfa; u8 mdfb; u8 bcl; - u8 autolk; // NOTE: The UV-6 calls this byte voxenable, but the UV-5R calls - // it autolk. Since this is a minor difference, it will be referred - // to by the wrong name for the UV-6. + u8 autolk; // NOTE: The UV-6 calls this byte voxenable, but the UV-5R + // calls it autolk. Since this is a minor difference, it will + // be referred to by the wrong name for the UV-6. u8 sftd; u8 unknown6[3]; u8 wtled; @@ -279,10 +279,10 @@ struct { vhf_220_radio = "\x02"

BASETYPE_UV5R = ["BFS", "BFB", "N5R-2", "BTS"] -BASETYPE_F11 = ["USA"] +BASETYPE_F11 = ["USA"] BASETYPE_UV82 = ["US2S", "B82S", "BF82"] -BASETYPE_BJ55 = ["BJ55"] # needed for for the Baojie UV-55 in bjuv55.py -BASETYPE_UV6 = ["BF1"] +BASETYPE_BJ55 = ["BJ55"] # needed for for the Baojie UV-55 in bjuv55.py +BASETYPE_UV6 = ["BF1"] BASETYPE_KT980HP = ["BFP3V3 B"] BASETYPE_F8HP = ["BFP3V3 F", "N5R-3", "N5R3"] BASETYPE_LIST = BASETYPE_UV5R + BASETYPE_F11 + BASETYPE_UV82 + \ @@ -320,38 +320,39 @@ VOX_LIST = ["OFF"] + ["%s" % x for x in range(1, 11)] WORKMODE_LIST = ["Frequency", "Channel"]

SETTING_LISTS = { - "almod" : ALMOD_LIST, - "aniid" : PTTID_LIST, - "displayab" : AB_LIST, - "dtmfst" : DTMFST_LIST, - "dtmfspeed" : DTMFSPEED_LIST, - "mdfa" : MODE_LIST, - "mdfb" : MODE_LIST, - "ponmsg" : PONMSG_LIST, - "pttid" : PTTID_LIST, - "rogerrx" : ROGERRX_LIST, - "rpste" : RPSTE_LIST, - "rxled" : COLOR_LIST, - "save" : SAVE_LIST, - "scode" : PTTIDCODE_LIST, - "screv" : RESUME_LIST, - "sftd" : SHIFTD_LIST, - "stedelay" : STEDELAY_LIST, - "step" : STEP_LIST, - "step291" : STEP291_LIST, - "tdrab" : TDRAB_LIST, - "tdrch" : TDRCH_LIST, - "timeout" : TIMEOUT_LIST, - "txled" : COLOR_LIST, - "txpower" : TXPOWER_LIST, - "txpower3" : TXPOWER3_LIST, - "voice" : VOICE_LIST, - "vox" : VOX_LIST, - "widenarr" : BANDWIDTH_LIST, - "workmode" : WORKMODE_LIST, - "wtled" : COLOR_LIST + "almod": ALMOD_LIST, + "aniid": PTTID_LIST, + "displayab": AB_LIST, + "dtmfst": DTMFST_LIST, + "dtmfspeed": DTMFSPEED_LIST, + "mdfa": MODE_LIST, + "mdfb": MODE_LIST, + "ponmsg": PONMSG_LIST, + "pttid": PTTID_LIST, + "rogerrx": ROGERRX_LIST, + "rpste": RPSTE_LIST, + "rxled": COLOR_LIST, + "save": SAVE_LIST, + "scode": PTTIDCODE_LIST, + "screv": RESUME_LIST, + "sftd": SHIFTD_LIST, + "stedelay": STEDELAY_LIST, + "step": STEP_LIST, + "step291": STEP291_LIST, + "tdrab": TDRAB_LIST, + "tdrch": TDRCH_LIST, + "timeout": TIMEOUT_LIST, + "txled": COLOR_LIST, + "txpower": TXPOWER_LIST, + "txpower3": TXPOWER3_LIST, + "voice": VOICE_LIST, + "vox": VOX_LIST, + "widenarr": BANDWIDTH_LIST, + "workmode": WORKMODE_LIST, + "wtled": COLOR_LIST }

+ def _do_status(radio, block): status = chirp_common.Status() status.msg = "Cloning" @@ -359,6 +360,7 @@ def _do_status(radio, block): status.max = radio.get_memsize() radio.status_fn(status)

+ def validate_orig(ident): try: ver = int(ident[4:7]) @@ -367,27 +369,32 @@ def validate_orig(ident): except ValueError: raise errors.RadioError("Radio reported invalid version string")

+ def validate_291(ident): if ident[4:7] != "\x30\x04\x50": raise errors.RadioError("Radio version not supported")

UV5R_MODEL_ORIG = "\x50\xBB\xFF\x01\x25\x98\x4D" -UV5R_MODEL_291 = "\x50\xBB\xFF\x20\x12\x07\x25" -UV5R_MODEL_F11 = "\x50\xBB\xFF\x13\xA1\x11\xDD" +UV5R_MODEL_291 = "\x50\xBB\xFF\x20\x12\x07\x25" +UV5R_MODEL_F11 = "\x50\xBB\xFF\x13\xA1\x11\xDD" UV5R_MODEL_UV82 = "\x50\xBB\xFF\x20\x13\x01\x05" -UV5R_MODEL_UV6 = "\x50\xBB\xFF\x20\x12\x08\x23" -UV5R_MODEL_UV6_ORIG = "\x50\xBB\xFF\x12\x03\x98\x4D" +UV5R_MODEL_UV6 = "\x50\xBB\xFF\x20\x12\x08\x23" +UV5R_MODEL_UV6_ORIG = "\x50\xBB\xFF\x12\x03\x98\x4D" +

def _upper_band_from_data(data): return data[0x03:0x04]

+ def _upper_band_from_image(radio): return _upper_band_from_data(radio.get_mmap())

+ def _firmware_version_from_data(data, version_start, version_stop): version_tag = data[version_start:version_stop] return version_tag

+ def _firmware_version_from_image(radio): version = _firmware_version_from_data(radio.get_mmap(), radio._fw_ver_file_start, @@ -395,15 +402,18 @@ def _firmware_version_from_image(radio): LOG.debug("_firmware_version_from_image: " + util.hexprint(version)) return version

+ def _special_block_from_data(data, special_block_start, special_block_stop): special_block_tag = data[special_block_start:special_block_stop] return special_block_tag

+ def _special_block_from_image(radio): special_block = _special_block_from_data(radio.get_mmap(), 0x0CFA, 0x0D01) LOG.debug("_special_block_from_image: " + util.hexprint(special_block)) return special_block

+ def _do_ident(radio, magic): serial = radio.pipe serial.setTimeout(1) @@ -431,6 +441,7 @@ def _do_ident(radio, magic):

return ident

+ def _read_block(radio, start, size): msg = struct.pack(">BHB", ord("S"), start, size) radio.pipe.write(msg) @@ -460,6 +471,7 @@ def _read_block(radio, start, size):

return chunk

+ def _get_radio_firmware_version(radio): if radio.MODEL == "BJ-UV55": block = _read_block(radio, 0x1FF0, 0x40) @@ -471,11 +483,13 @@ def _get_radio_firmware_version(radio): version = block[48:62] return version

+ def _get_radio_special_block(radio): block = _read_block(radio, 0xCF0, 0x40) special_block = block[2:9] return special_block

+ def _ident_radio(radio): for magic in radio._idents: error = None @@ -490,6 +504,7 @@ def _ident_radio(radio): raise error raise errors.RadioError("Radio did not respond")

+ def _do_download(radio): data = _ident_radio(radio)

@@ -512,6 +527,7 @@ def _do_download(radio): LOG.debug("done.") return memmap.MemoryMap(data)

+ def _send_block(radio, addr, data): msg = struct.pack(">BHB", ord("X"), addr, len(data)) radio.pipe.write(msg + data) @@ -520,6 +536,7 @@ def _send_block(radio, addr, data): if ack != "\x06": raise errors.RadioError("Radio refused to accept block 0x%04x" % addr)

+ def _do_upload(radio): ident = _ident_radio(radio) radio_upper_band = ident[3:4] @@ -554,7 +571,7 @@ def _do_upload(radio):

if len(radio.get_mmap().get_packed()) == 0x1808: print "Old image, not writing aux block" - return # Old image, no aux block + return # Old image, no aux block

if image_version != radio_version: msg = ("Upload finished, but the 'Other Settings' " @@ -580,6 +597,7 @@ UV5R_DTCS = sorted(chirp_common.DTCS_CODES + [645]) UV5R_CHARSET = chirp_common.CHARSET_UPPER_NUMERIC + \ "!@#$%^&*()+-=[]:";'<>?,./"

+ # Uncomment this to actually register this radio in CHIRP @directory.register class BaofengUV5R(chirp_common.CloneModeRadio, @@ -597,8 +615,8 @@ class BaofengUV5R(chirp_common.CloneModeRadio, _vhf_range = (136000000, 174000000) _220_range = (220000000, 260000000) _uhf_range = (400000000, 520000000) - _mem_params = ( 0x1828 # poweron_msg offset - ) + _mem_params = (0x1828 # poweron_msg offset + ) # offset of fw version in image file _fw_ver_file_start = 0x1838 _fw_ver_file_stop = 0x1846 @@ -606,12 +624,13 @@ class BaofengUV5R(chirp_common.CloneModeRadio, @classmethod def get_prompts(cls): rp = chirp_common.RadioPrompts() - rp.experimental = ('Due to the fact that the manufacturer continues to ' - 'release new versions of the firmware with obscure and ' - 'hard-to-track changes, this driver may not work with ' - 'your device. Thus far and to the best knowledge of the ' - 'author, no UV-5R radios have been harmed by using CHIRP. ' - 'However, proceed at your own risk!') + rp.experimental = \ + ('Due to the fact that the manufacturer continues to ' + 'release new versions of the firmware with obscure and ' + 'hard-to-track changes, this driver may not work with ' + 'your device. Thus far and to the best knowledge of the ' + 'author, no UV-5R radios have been harmed by using CHIRP. ' + 'However, proceed at your own risk!') rp.pre_download = _(dedent("""\ 1. Turn radio off. 2. Connect cable to mic/spkr connector. @@ -737,7 +756,7 @@ class BaofengUV5R(chirp_common.CloneModeRadio,

for char in _nam.name: if str(char) == "\xFF": - char = " " # The UV-5R software may have 0xFF mid-name + char = " " # The UV-5R software may have 0xFF mid-name mem.name += str(char) mem.name = mem.name.rstrip()

@@ -790,15 +809,15 @@ class BaofengUV5R(chirp_common.CloneModeRadio, if not _mem.scan: mem.skip = "S"

- if self.MODEL == "KT-980HP" or self.MODEL == "BF-F8HP": + if self.MODEL == "KT-980HP" or self.MODEL == "BF-F8HP": levels = UV5R_POWER_LEVELS3 else: levels = UV5R_POWER_LEVELS try: mem.power = levels[_mem.lowpower] except IndexError: - print "Radio reported invalid power level %s (in %s)" % ( - _mem.power, levels) + print "Radio reported invalid power level %s (in %s)" % \ + (_mem.power, levels) mem.power = levels[0]

mem.mode = _mem.wide and "FM" or "NFM" @@ -986,13 +1005,13 @@ class BaofengUV5R(chirp_common.CloneModeRadio, basic.append(rs)

rs = RadioSetting("save", "Battery Saver", - RadioSettingValueList(SAVE_LIST, - SAVE_LIST[_settings.save])) + RadioSettingValueList( + SAVE_LIST, SAVE_LIST[_settings.save])) basic.append(rs)

rs = RadioSetting("vox", "VOX Sensitivity", - RadioSettingValueList(VOX_LIST, - VOX_LIST[_settings.vox])) + RadioSettingValueList( + VOX_LIST, VOX_LIST[_settings.vox])) advanced.append(rs)

if self.MODEL == "UV-6": @@ -1014,9 +1033,8 @@ class BaofengUV5R(chirp_common.CloneModeRadio,

if self.MODEL == "UV-6": rs = RadioSetting("tdrch", "Dual Watch Channel", - RadioSettingValueList(TDRCH_LIST, - TDRCH_LIST[ - _settings.tdrch])) + RadioSettingValueList( + TDRCH_LIST, TDRCH_LIST[_settings.tdrch])) advanced.append(rs)

rs = RadioSetting("tdrab", "Dual Watch TX Priority", @@ -1024,9 +1042,8 @@ class BaofengUV5R(chirp_common.CloneModeRadio, advanced.append(rs) else: rs = RadioSetting("tdrab", "Dual Watch TX Priority", - RadioSettingValueList(TDRAB_LIST, - TDRAB_LIST[ - _settings.tdrab])) + RadioSettingValueList( + TDRAB_LIST, TDRAB_LIST[_settings.tdrab])) advanced.append(rs)

if self.MODEL == "UV-6": @@ -1039,8 +1056,8 @@ class BaofengUV5R(chirp_common.CloneModeRadio, else: val = _settings.almod rs = RadioSetting("almod", "Alarm Mode", - RadioSettingValueList(ALMOD_LIST, - ALMOD_LIST[val])) + RadioSettingValueList( + ALMOD_LIST, ALMOD_LIST[val])) advanced.append(rs)

rs = RadioSetting("beep", "Beep", @@ -1048,9 +1065,8 @@ class BaofengUV5R(chirp_common.CloneModeRadio, basic.append(rs)

rs = RadioSetting("timeout", "Timeout Timer", - RadioSettingValueList(TIMEOUT_LIST, - TIMEOUT_LIST[ - _settings.timeout])) + RadioSettingValueList( + TIMEOUT_LIST, TIMEOUT_LIST[_settings.timeout])) basic.append(rs)

if self._is_orig() and self._my_version() < 251: @@ -1059,25 +1075,24 @@ class BaofengUV5R(chirp_common.CloneModeRadio, advanced.append(rs) else: rs = RadioSetting("voice", "Voice", - RadioSettingValueList(VOICE_LIST, - VOICE_LIST[ - _settings.voice])) + RadioSettingValueList( + VOICE_LIST, VOICE_LIST[_settings.voice])) advanced.append(rs)

rs = RadioSetting("screv", "Scan Resume", - RadioSettingValueList(RESUME_LIST, - RESUME_LIST[_settings.screv])) + RadioSettingValueList( + RESUME_LIST, RESUME_LIST[_settings.screv])) advanced.append(rs)

if self.MODEL != "UV-6": rs = RadioSetting("mdfa", "Display Mode (A)", - RadioSettingValueList(MODE_LIST, - MODE_LIST[_settings.mdfa])) + RadioSettingValueList( + MODE_LIST, MODE_LIST[_settings.mdfa])) basic.append(rs)

rs = RadioSetting("mdfb", "Display Mode (B)", - RadioSettingValueList(MODE_LIST, - MODE_LIST[_settings.mdfb])) + RadioSettingValueList( + MODE_LIST, MODE_LIST[_settings.mdfb])) basic.append(rs)

rs = RadioSetting("bcl", "Busy Channel Lockout", @@ -1095,21 +1110,18 @@ class BaofengUV5R(chirp_common.CloneModeRadio,

if self.MODEL != "UV-6": rs = RadioSetting("wtled", "Standby LED Color", - RadioSettingValueList(COLOR_LIST, - COLOR_LIST[ - _settings.wtled])) + RadioSettingValueList( + COLOR_LIST, COLOR_LIST[_settings.wtled])) basic.append(rs)

rs = RadioSetting("rxled", "RX LED Color", - RadioSettingValueList(COLOR_LIST, - COLOR_LIST[ - _settings.rxled])) + RadioSettingValueList( + COLOR_LIST, COLOR_LIST[_settings.rxled])) basic.append(rs)

rs = RadioSetting("txled", "TX LED Color", - RadioSettingValueList(COLOR_LIST, - COLOR_LIST[ - _settings.txled])) + RadioSettingValueList( + COLOR_LIST, COLOR_LIST[_settings.txled])) basic.append(rs)

if self.MODEL == "UV-82": @@ -1117,9 +1129,9 @@ class BaofengUV5R(chirp_common.CloneModeRadio, RadioSettingValueBoolean(_settings.roger)) basic.append(rs) rs = RadioSetting("rogerrx", "Roger Beep (RX)", - RadioSettingValueList(ROGERRX_LIST, - ROGERRX_LIST[ - _settings.rogerrx])) + RadioSettingValueList( + ROGERRX_LIST, + ROGERRX_LIST[_settings.rogerrx])) basic.append(rs) else: rs = RadioSetting("roger", "Roger Beep", @@ -1131,13 +1143,13 @@ class BaofengUV5R(chirp_common.CloneModeRadio, advanced.append(rs)

rs = RadioSetting("rpste", "Squelch Tail Eliminate (repeater)", - RadioSettingValueList(RPSTE_LIST, - RPSTE_LIST[_settings.rpste])) + RadioSettingValueList( + RPSTE_LIST, RPSTE_LIST[_settings.rpste])) advanced.append(rs)

rs = RadioSetting("rptrl", "STE Repeater Delay", - RadioSettingValueList(STEDELAY_LIST, - STEDELAY_LIST[_settings.rptrl])) + RadioSettingValueList( + STEDELAY_LIST, STEDELAY_LIST[_settings.rptrl])) advanced.append(rs)

if self.MODEL != "UV-6": @@ -1197,28 +1209,27 @@ class BaofengUV5R(chirp_common.CloneModeRadio, if self.MODEL != "UV-6": _msg = self._memobj.sixpoweron_msg rs = RadioSetting("sixpoweron_msg.line1", "6+Power-On Message 1", - RadioSettingValueString(0, 7, _filter( - _msg.line1))) + RadioSettingValueString( + 0, 7, _filter(_msg.line1))) other.append(rs) rs = RadioSetting("sixpoweron_msg.line2", "6+Power-On Message 2", - RadioSettingValueString(0, 7, _filter( - _msg.line2))) + RadioSettingValueString( + 0, 7, _filter(_msg.line2))) other.append(rs)

_msg = self._memobj.poweron_msg rs = RadioSetting("poweron_msg.line1", "Power-On Message 1", - RadioSettingValueString(0, 7, _filter( - _msg.line1))) + RadioSettingValueString( + 0, 7, _filter(_msg.line1))) other.append(rs) rs = RadioSetting("poweron_msg.line2", "Power-On Message 2", - RadioSettingValueString(0, 7, _filter( - _msg.line2))) + RadioSettingValueString( + 0, 7, _filter(_msg.line2))) other.append(rs)

rs = RadioSetting("ponmsg", "Power-On Message", - RadioSettingValueList(PONMSG_LIST, - PONMSG_LIST[ - _settings.ponmsg])) + RadioSettingValueList( + PONMSG_LIST, PONMSG_LIST[_settings.ponmsg])) other.append(rs)

if self._is_orig(): @@ -1259,15 +1270,14 @@ class BaofengUV5R(chirp_common.CloneModeRadio, group.append(workmode)

rs = RadioSetting("displayab", "Display", - RadioSettingValueList(AB_LIST, - AB_LIST[ - _settings.displayab])) + RadioSettingValueList( + AB_LIST, AB_LIST[_settings.displayab])) workmode.append(rs)

rs = RadioSetting("workmode", "VFO/MR Mode", - RadioSettingValueList(WORKMODE_LIST, - WORKMODE_LIST[ - _settings.workmode])) + RadioSettingValueList( + WORKMODE_LIST, + WORKMODE_LIST[_settings.workmode])) workmode.append(rs)

rs = RadioSetting("keylock", "Keypad Lock", @@ -1285,10 +1295,10 @@ class BaofengUV5R(chirp_common.CloneModeRadio, workmode.append(rs)

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) + 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) @@ -1319,20 +1329,20 @@ class BaofengUV5R(chirp_common.CloneModeRadio, workmode.append(rs)

rs = RadioSetting("vfoa.sftd", "VFO A Shift", - RadioSettingValueList(SHIFTD_LIST, - SHIFTD_LIST[_vfoa.sftd])) + RadioSettingValueList( + SHIFTD_LIST, SHIFTD_LIST[_vfoa.sftd])) workmode.append(rs)

rs = RadioSetting("vfob.sftd", "VFO B Shift", - RadioSettingValueList(SHIFTD_LIST, - SHIFTD_LIST[_vfob.sftd])) + RadioSettingValueList( + SHIFTD_LIST, SHIFTD_LIST[_vfob.sftd])) workmode.append(rs)

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) + 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 @@ -1340,89 +1350,84 @@ class BaofengUV5R(chirp_common.CloneModeRadio, obj.offset[i] = value % 10 value /= 10

- val1a = RadioSettingValueString(0, 10, - convert_bytes_to_offset( - _vfoa.offset)) - rs = RadioSetting("vfoa.offset", "VFO A Offset (0.00-69.95)", val1a) + val1a = RadioSettingValueString( + 0, 10, convert_bytes_to_offset(_vfoa.offset)) + rs = RadioSetting("vfoa.offset", + "VFO A Offset (0.00-69.95)", val1a) rs.set_apply_callback(apply_offset, _vfoa) workmode.append(rs)

- val1b = RadioSettingValueString(0, 10, - convert_bytes_to_offset( - _vfob.offset)) - rs = RadioSetting("vfob.offset", "VFO B Offset (0.00-69.95)", val1b) + val1b = RadioSettingValueString( + 0, 10, convert_bytes_to_offset(_vfob.offset)) + rs = RadioSetting("vfob.offset", + "VFO B Offset (0.00-69.95)", val1b) rs.set_apply_callback(apply_offset, _vfob) workmode.append(rs)

if self.MODEL == "KT-980HP" or self.MODEL == "BF-F8HP": rs = RadioSetting("vfoa.txpower3", "VFO A Power", - RadioSettingValueList(TXPOWER3_LIST, - TXPOWER3_LIST[ - _vfoa.txpower3])) + RadioSettingValueList( + TXPOWER3_LIST, + TXPOWER3_LIST[_vfoa.txpower3])) workmode.append(rs)

rs = RadioSetting("vfob.txpower3", "VFO B Power", - RadioSettingValueList(TXPOWER3_LIST, - TXPOWER3_LIST[ - _vfob.txpower3])) + RadioSettingValueList( + TXPOWER3_LIST, + TXPOWER3_LIST[_vfob.txpower3])) workmode.append(rs) else: rs = RadioSetting("vfoa.txpower", "VFO A Power", - RadioSettingValueList(TXPOWER_LIST, - TXPOWER_LIST[ - _vfoa.txpower])) + RadioSettingValueList( + TXPOWER_LIST, + TXPOWER_LIST[_vfoa.txpower])) workmode.append(rs)

rs = RadioSetting("vfob.txpower", "VFO B Power", - RadioSettingValueList(TXPOWER_LIST, - TXPOWER_LIST[ - _vfob.txpower])) + RadioSettingValueList( + TXPOWER_LIST, + TXPOWER_LIST[_vfob.txpower])) workmode.append(rs)

- rs = RadioSetting("vfoa.widenarr", "VFO A Bandwidth", - RadioSettingValueList(BANDWIDTH_LIST, - BANDWIDTH_LIST[ - _vfoa.widenarr])) + RadioSettingValueList( + BANDWIDTH_LIST, + BANDWIDTH_LIST[_vfoa.widenarr])) workmode.append(rs)

rs = RadioSetting("vfob.widenarr", "VFO B Bandwidth", - RadioSettingValueList(BANDWIDTH_LIST, - BANDWIDTH_LIST[ - _vfob.widenarr])) + RadioSettingValueList( + BANDWIDTH_LIST, + BANDWIDTH_LIST[_vfob.widenarr])) workmode.append(rs)

rs = RadioSetting("vfoa.scode", "VFO A PTT-ID", - RadioSettingValueList(PTTIDCODE_LIST, - PTTIDCODE_LIST[ - _vfoa.scode])) + RadioSettingValueList( + PTTIDCODE_LIST, PTTIDCODE_LIST[_vfoa.scode])) workmode.append(rs)

rs = RadioSetting("vfob.scode", "VFO B PTT-ID", - RadioSettingValueList(PTTIDCODE_LIST, - PTTIDCODE_LIST[ - _vfob.scode])) + RadioSettingValueList( + PTTIDCODE_LIST, PTTIDCODE_LIST[_vfob.scode])) workmode.append(rs)

if not self._is_orig(): rs = RadioSetting("vfoa.step", "VFO A Tuning Step", - RadioSettingValueList(STEP291_LIST, - STEP291_LIST[ - _vfoa.step])) + RadioSettingValueList( + STEP291_LIST, STEP291_LIST[_vfoa.step])) workmode.append(rs) rs = RadioSetting("vfob.step", "VFO B Tuning Step", - RadioSettingValueList(STEP291_LIST, - STEP291_LIST[ - _vfob.step])) + RadioSettingValueList( + STEP291_LIST, STEP291_LIST[_vfob.step])) workmode.append(rs) else: rs = RadioSetting("vfoa.step", "VFO A Tuning Step", - RadioSettingValueList(STEP_LIST, - STEP_LIST[_vfoa.step])) + RadioSettingValueList( + STEP_LIST, STEP_LIST[_vfoa.step])) workmode.append(rs) rs = RadioSetting("vfob.step", "VFO B Tuning Step", - RadioSettingValueList(STEP_LIST, - STEP_LIST[_vfob.step])) + RadioSettingValueList( + STEP_LIST, STEP_LIST[_vfob.step])) workmode.append(rs)

fm_preset = RadioSettingGroup("fm_preset", "FM Radio Preset") @@ -1433,7 +1438,7 @@ class BaofengUV5R(chirp_common.CloneModeRadio, else: preset = 76.0 rs = RadioSetting("fm_presets", "FM Preset(MHz)", - RadioSettingValueFloat(65, 116.1, preset, 0.1, 1)) + RadioSettingValueFloat(65, 116.1, preset, 0.1, 1)) fm_preset.append(rs)

dtmf = RadioSettingGroup("dtmf", "DTMF Settings") @@ -1447,6 +1452,7 @@ class BaofengUV5R(chirp_common.CloneModeRadio, val.set_charset(dtmfchars) rs = RadioSetting("pttid/%i.code" % i, "PTT ID Code %i" % (i + 1), val) + def apply_code(setting, obj): code = [] for j in range(0, 5): @@ -1463,6 +1469,7 @@ class BaofengUV5R(chirp_common.CloneModeRadio, val = RadioSettingValueString(0, 5, _code, False) val.set_charset(dtmfchars) rs = RadioSetting("ani.code", "ANI Code", val) + def apply_code(setting, obj): code = [] for j in range(0, 5): @@ -1484,6 +1491,7 @@ class BaofengUV5R(chirp_common.CloneModeRadio, val = RadioSettingValueString(0, 3, _code, False) val.set_charset(dtmfchars) rs = RadioSetting("ani.alarmcode", "Alarm Code", val) + def apply_code(setting, obj): alarmcode = [] for j in range(0, 3): @@ -1518,7 +1526,6 @@ class BaofengUV5R(chirp_common.CloneModeRadio, DTMFSPEED_LIST[val])) dtmf.append(rs)

- #if not self._is_orig(): if not self._my_version() < 291: service = RadioSettingGroup("service", "Service Settings") group.append(service) @@ -1531,8 +1538,10 @@ class BaofengUV5R(chirp_common.CloneModeRadio, elif band == "uhf": _obj = self._memobj.squelch_new.uhf name = "%s Squelch %i" % (band.upper(), index) - rs = RadioSetting(key, name, RadioSettingValueInteger( - 0, 123, getattr(_obj, "sql%i" % (index)))) + rs = RadioSetting(key, name, + RadioSettingValueInteger( + 0, 123, + getattr(_obj, "sql%i" % (index)))) service.append(rs)

return group @@ -1550,7 +1559,7 @@ class BaofengUV5R(chirp_common.CloneModeRadio, _settings = self._memobj.settings for element in settings: if not isinstance(element, RadioSetting): - if element.get_name() == "fm_preset" : + if element.get_name() == "fm_preset": self._set_fm_preset(element) else: self.set_settings(element) @@ -1594,6 +1603,7 @@ class BaofengUV5R(chirp_common.CloneModeRadio, print element.get_name() raise

+ @directory.register class BaofengF11Radio(BaofengUV5R): VENDOR = "Baofeng" @@ -1605,6 +1615,7 @@ class BaofengF11Radio(BaofengUV5R): # Override this for F11 to always return False return False

+ @directory.register class BaofengUV82Radio(BaofengUV5R): MODEL = "UV-82" @@ -1617,6 +1628,7 @@ class BaofengUV82Radio(BaofengUV5R): # Override this for UV82 to always return False return False

+ @directory.register class BaofengUV6Radio(BaofengUV5R): """Baofeng UV-6/UV-7""" @@ -1648,6 +1660,7 @@ class BaofengUV6Radio(BaofengUV5R): # Override this for UV6 to always return False return False

+ @directory.register class IntekKT980Radio(BaofengUV5R): VENDOR = "Intek" @@ -1666,6 +1679,7 @@ class IntekKT980Radio(BaofengUV5R): # Override this for KT980HP to always return False return False

+ @directory.register class BaofengBFF8HPRadio(BaofengUV5R): VENDOR = "Baofeng" diff --git a/tools/cpep8.blacklist b/tools/cpep8.blacklist index 0e9f07d..cb22466 100644 --- a/tools/cpep8.blacklist +++ b/tools/cpep8.blacklist @@ -48,7 +48,6 @@ ./chirp/drivers/tk8102.py ./chirp/drivers/tmv71.py ./chirp/drivers/tmv71_ll.py -./chirp/drivers/uv5r.py ./chirp/drivers/uvb5.py ./chirp/drivers/vx170.py ./chirp/drivers/vx2.py

# HG changeset patch # User Zach Welch zach@mandolincreekfarm.com # Fake Node ID 65001f06deb9ab778e50659a30ca3f804f53ea25

Fix style issues in rfinder.py (#2355)

diff --git a/chirp/drivers/rfinder.py b/chirp/drivers/rfinder.py index a82bc21..ee0bc79 100644 --- a/chirp/drivers/rfinder.py +++ b/chirp/drivers/rfinder.py @@ -18,7 +18,6 @@ import hashlib import re

from math import pi, cos, acos, sin, atan2 - from chirp import chirp_common, CHIRP_VERSION

EARTH_RADIUS = 3963.1 @@ -47,18 +46,22 @@ SCHEMA = [ "DOC_ID", ]

+ def deg2rad(deg): """Convert degrees to radians""" return deg * (pi / 180)

+ def rad2deg(rad): """Convert radians to degrees""" return rad / (pi / 180)

+ def dm2deg(degrees, minutes): """Convert degrees and minutes to decimal degrees""" return degrees + (minutes / 60.0)

+ def deg2dm(decdeg): """Convert decimal degrees to degrees and minutes""" degrees = int(decdeg) @@ -66,6 +69,7 @@ def deg2dm(decdeg):

return degrees, minutes

+ def nmea2deg(nmea, direction="N"): """Convert NMEA-encoded value to float""" deg = int(nmea) / 100 @@ -81,35 +85,37 @@ def nmea2deg(nmea, direction="N"):

return dm2deg(deg, minutes) * sign

+ def deg2nmea(deg): """Convert degrees to a NMEA-encoded value""" degrees, minutes = deg2dm(deg)

return (degrees * 100) + minutes

+ def meters2feet(meters): """Convert meters to feet""" return meters * 3.2808399

+ def feet2meters(feet): """Convert feet to meters""" return feet * 0.3048

+ def distance(lat_a, lon_a, lat_b, lon_b): """Calculate the distance between two points""" lat_a = deg2rad(lat_a) lon_a = deg2rad(lon_a) - + lat_b = deg2rad(lat_b) lon_b = deg2rad(lon_b) - + earth_radius = EARTH_RADIUS - - tmp = (cos(lat_a) * cos(lon_a) * \ - cos(lat_b) * cos(lon_b)) + \ - (cos(lat_a) * sin(lon_a) * \ - cos(lat_b) * sin(lon_b)) + \ - (sin(lat_a) * sin(lat_b)) + + tmp = (cos(lat_a) * cos(lon_a) * cos(lat_b) * cos(lon_b)) + \ + (cos(lat_a) * sin(lon_a) * cos(lat_b) * sin(lon_b)) + \ + (sin(lat_a) * sin(lat_b))

# Correct round-off error (which is just *silly*) if tmp > 1: @@ -121,6 +127,7 @@ def distance(lat_a, lon_a, lat_b, lon_b):

return dist * earth_radius

+ def bearing(lat_a, lon_a, lat_b, lon_b): """Calculate the bearing between two points""" lat_me = deg2rad(lat_a) @@ -135,6 +142,7 @@ def bearing(lat_a, lon_a, lat_b, lon_b):

return (bear + 360) % 360

+ def fuzzy_to(lat_a, lon_a, lat_b, lon_b): """Calculate a fuzzy distance to a point""" bear = bearing(lat_a, lon_a, lat_b, lon_b) @@ -155,6 +163,7 @@ def fuzzy_to(lat_a, lon_a, lat_b, lon_b):

return direction

+ class RFinderParser: """Parser for RFinder's data format""" def __init__(self, lat, lon): @@ -168,18 +177,18 @@ class RFinderParser: print user print pw args = { - "email" : urllib.quote_plus(user), - "pass" : hashlib.new("md5", pw).hexdigest(), - "lat" : "%7.5f" % coords[0], - "lon" : "%7.5f" % coords[1], + "email": urllib.quote_plus(user), + "pass": hashlib.new("md5", pw).hexdigest(), + "lat": "%7.5f" % coords[0], + "lon": "%7.5f" % coords[1], "radius": "%i" % radius, - "vers" : "CH%s" % CHIRP_VERSION, + "vers": "CH%s" % CHIRP_VERSION, }

- _url = "https://www.rfinder.net/query.php?%s" % (\ - "&".join(["%s=%s" % (k,v) for k,v in args.items()])) + _url = "https://www.rfinder.net/query.php?%s" % \ + ("&".join(["%s=%s" % (k, v) for k, v in args.items()]))

- print "Query URL: %s" % _url + print "Query URL: %s" % _url

f = urllib.urlopen(_url) data = f.read() @@ -247,7 +256,8 @@ class RFinderParser: number += 1 self.__memories.append(mem) except Exception, e: - import traceback, sys + import traceback + import sys traceback.print_exc(file=sys.stdout) print "Error in received data, cannot continue" print e @@ -259,6 +269,7 @@ class RFinderParser: """Return the Memory objects associated with the fetched data""" return self.__memories

+ class RFinderRadio(chirp_common.NetworkSourceRadio): """A network source radio that supports the RFinder repeater directory""" VENDOR = "ITWeRKS" @@ -266,13 +277,13 @@ class RFinderRadio(chirp_common.NetworkSourceRadio):

def __init__(self, *args, **kwargs): chirp_common.NetworkSourceRadio.__init__(self, *args, **kwargs) - + self._lat = 0 self._lon = 0 self._user = "" self._pass = "" self._miles = 25 - + self._rfp = None

def set_params(self, (lat, lon), miles, email, password): @@ -290,7 +301,7 @@ class RFinderRadio(chirp_common.NetworkSourceRadio): self._pass, (self._lat, self._lon), self._miles)) - + def get_features(self): if not self._rfp: self.do_fetch() @@ -309,6 +320,7 @@ class RFinderRadio(chirp_common.NetworkSourceRadio):

return self._rfp.get_memories()[number-1]

+ def _test(): rfp = RFinderParser() data = rfp.fetch_data("KK7DS", "dsmith@danplanet.com", diff --git a/tools/cpep8.blacklist b/tools/cpep8.blacklist index 0669c24..2fbf1ce 100644 --- a/tools/cpep8.blacklist +++ b/tools/cpep8.blacklist @@ -38,7 +38,6 @@ ./chirp/drivers/kyd.py ./chirp/drivers/leixen.py ./chirp/drivers/puxing.py -./chirp/drivers/rfinder.py ./chirp/drivers/th9800.py ./chirp/drivers/th_uv3r.py ./chirp/drivers/th_uv3r25.py

# HG changeset patch # User Zach Welch zach@mandolincreekfarm.com # Fake Node ID 82ef06f999fe0ce91ce2fa6d389e6c40edefcb17

Fix style issues in puxing.py (#2355)

diff --git a/chirp/drivers/puxing.py b/chirp/drivers/puxing.py index ddfee1a..1295123 100644 --- a/chirp/drivers/puxing.py +++ b/chirp/drivers/puxing.py @@ -20,6 +20,7 @@ import os from chirp import util, chirp_common, bitwise, errors, directory from chirp.drivers.wouxun import wipe_memory, do_download, do_upload

+ def _puxing_prep(radio): radio.pipe.write("\x02PROGRA") ack = radio.pipe.read(1) @@ -36,6 +37,7 @@ def _puxing_prep(radio): if radio.pipe.read(1) != "\x06": raise Exception("Radio did not ACK ident")

+ def puxing_prep(radio): """Do the Puxing PX-777 identification dance""" for _i in range(0, 10): @@ -46,6 +48,7 @@ def puxing_prep(radio):

raise e

+ def puxing_download(radio): """Talk to a Puxing PX-777 and do a download""" try: @@ -56,6 +59,7 @@ def puxing_download(radio): except Exception, e: raise errors.RadioError("Failed to communicate with radio: %s" % e)

+ def puxing_upload(radio): """Talk to a Puxing PX-777 and do an upload""" try: @@ -68,7 +72,7 @@ def puxing_upload(radio):

POWER_LEVELS = [chirp_common.PowerLevel("High", watts=5.00), chirp_common.PowerLevel("Low", watts=1.00)] - + PUXING_CHARSET = list("0123456789") + \ [chr(x + ord("A")) for x in range(0, 26)] + \ list("- ") @@ -118,13 +122,13 @@ struct { # 460-520: 0xF7

PUXING_MODELS = { - 328 : 0x38, - 338 : 0x39, - 777 : 0x3A, + 328: 0x38, + 338: 0x39, + 777: 0x3A, }

PUXING_777_BANDS = [ - ( 67000000, 72000000), + (67000000, 72000000), (136000000, 174000000), (240000000, 260000000), (350000000, 390000000), @@ -136,6 +140,7 @@ PUXING_777_BANDS = [ (460000000, 520000000), ]

+ @directory.register class Puxing777Radio(chirp_common.CloneModeRadio): """Puxing PX-777""" @@ -177,9 +182,9 @@ class Puxing777Radio(chirp_common.CloneModeRadio): if self._memobj.model.limits == 0xEE: rf.valid_bands = [PUXING_777_BANDS[1]] else: - raise Exception("Unsupported band limits 0x%02x for PX-777" % \ - (self._memobj.model.limits) + - " submodel 328 - PLEASE REPORT THIS ERROR TO DEVELOPERS!!") + raise Exception("Unsupported band limits 0x%02x for PX-777" % + (self._memobj.model.limits) + " submodel 328" + " - PLEASE REPORT THIS ERROR TO DEVELOPERS!!")

return rf

@@ -193,12 +198,10 @@ class Puxing777Radio(chirp_common.CloneModeRadio): @classmethod def match_model(cls, filedata, filename): # There are PX-777 that says to be model 328 ... - return len(filedata) == 3168 and ( - ord(filedata[0x080B]) == PUXING_MODELS[777] or ( - ord(filedata[0x080B]) == PUXING_MODELS[328] and - ord(filedata[0x080A]) == 0xEE - ) - ) + return (len(filedata) == 3168 and + (ord(filedata[0x080B]) == PUXING_MODELS[777] or + (ord(filedata[0x080B]) == PUXING_MODELS[328] and + ord(filedata[0x080A]) == 0xEE)))

def get_memory(self, number): _mem = self._memobj.memory[number - 1] @@ -230,7 +233,7 @@ class Puxing777Radio(chirp_common.CloneModeRadio): tp, tx = "N", None else: tp, tx = _get_dtcs(int(txfield)) - + if rxfield[0].get_raw() == "\xFF": rp, rx = "N", None else: @@ -267,7 +270,7 @@ class Puxing777Radio(chirp_common.CloneModeRadio): mem.mode = "NFM"

if _is_no_tone(_mem.tx_tone): - pass # No tone + pass # No tone elif int(_mem.tx_tone) > 8000 or \ (not _is_no_tone(_mem.rx_tone) and int(_mem.rx_tone) > 8000): mem.tmode = "DTCS" @@ -304,13 +307,11 @@ class Puxing777Radio(chirp_common.CloneModeRadio): _mem.skip = mem.skip != "S" _mem.iswide = mem.mode != "NFM"

- _mem.rx_tone[0].set_raw("\xFF") _mem.rx_tone[1].set_raw("\xFF") _mem.tx_tone[0].set_raw("\xFF") _mem.tx_tone[1].set_raw("\xFF")

- if mem.tmode == "DTCS": _mem.tx_tone = int("%x" % int("%i" % (mem.dtcs), 16)) _mem.rx_tone = int("%x" % int("%i" % (mem.dtcs), 16)) @@ -344,6 +345,7 @@ class Puxing777Radio(chirp_common.CloneModeRadio): except IndexError: raise Exception("Character `%s' not supported")

+ def puxing_2r_prep(radio): """Do the Puxing 2R identification dance""" radio.pipe.setTimeout(0.2) @@ -356,6 +358,7 @@ def puxing_2r_prep(radio): ident = radio.pipe.read(16) print "Radio ident: %s (%i)" % (repr(ident), len(ident))

+ def puxing_2r_download(radio): """Talk to a Puxing 2R and do a download""" try: @@ -366,6 +369,7 @@ def puxing_2r_download(radio): except Exception, e: raise errors.RadioError("Failed to communicate with radio: %s" % e)

+ def puxing_2r_upload(radio): """Talk to a Puxing 2R and do an upload""" try: @@ -399,6 +403,7 @@ PX2R_POWER_LEVELS = [chirp_common.PowerLevel("Low", watts=1.0), chirp_common.PowerLevel("High", watts=2.0)] PX2R_CHARSET = "0123456789- ABCDEFGHIJKLMNOPQRSTUVWXYZ +"

+ @directory.register class Puxing2RRadio(chirp_common.CloneModeRadio): """Puxing PX-2R""" @@ -494,7 +499,7 @@ class Puxing2RRadio(chirp_common.CloneModeRadio): if mem.tmode == "DTCS": _mem.tx_tone = chirp_common.DTCS_CODES.index(mem.dtcs) + 0x33 _mem.rx_tone = chirp_common.DTCS_CODES.index(mem.dtcs) + 0x33 - _mem.txdtcsinv = mem.dtcs_polarity[0] == "R" + _mem.txdtcsinv = mem.dtcs_polarity[0] == "R" _mem.rxdtcsinv = mem.dtcs_polarity[1] == "R" elif mem.tmode in ["Tone", "TSQL"]: _mem.tx_tone = chirp_common.TONES.index(mem.rtone) + 1 @@ -511,4 +516,3 @@ class Puxing2RRadio(chirp_common.CloneModeRadio):

def get_raw_memory(self, number): return repr(self._memobj.memory[number-1]) - diff --git a/tools/cpep8.blacklist b/tools/cpep8.blacklist index 6fec7bd..81de4c1 100644 --- a/tools/cpep8.blacklist +++ b/tools/cpep8.blacklist @@ -36,7 +36,6 @@ ./chirp/drivers/kguv8d.py ./chirp/drivers/kyd.py ./chirp/drivers/leixen.py -./chirp/drivers/puxing.py ./chirp/drivers/th9800.py ./chirp/drivers/th_uv3r.py ./chirp/drivers/th_uv3r25.py

# HG changeset patch # User Zach Welch zach@mandolincreekfarm.com # Fake Node ID 445fc1c6509b16e97d78be88493a2ca2f3f787c5

Fix style issues in kyd.py (#2355)

diff --git a/chirp/drivers/kyd.py b/chirp/drivers/kyd.py index e188df9..a6db68a 100644 --- a/chirp/drivers/kyd.py +++ b/chirp/drivers/kyd.py @@ -49,7 +49,7 @@ struct { u8 voice; // Voice Annunciation u8 tot; // Time-out Timer u8 totalert; // Time-out Timer Pre-alert - u8 unknown1[2]; + u8 unknown1[2]; u8 squelch; // Squelch Level u8 save; // Battery Saver u8 beep; // Beep @@ -78,14 +78,15 @@ VOX_LIST = ["OFF"] + ["%s" % x for x in range(1, 17)] VOXDELAY_LIST = ["0.3", "0.5", "1.0", "1.5", "2.0", "3.0"]

SETTING_LISTS = { - "bcl" : BCL_LIST, - "tot" : TIMEOUTTIMER_LIST, - "totalert" : TOTALERT_LIST, - "voice" : VOICE_LIST, - "vox" : VOX_LIST, - "voxdelay" : VOXDELAY_LIST, + "bcl": BCL_LIST, + "tot": TIMEOUTTIMER_LIST, + "totalert": TOTALERT_LIST, + "voice": VOICE_LIST, + "vox": VOX_LIST, + "voxdelay": VOXDELAY_LIST, }

+ def _nc630a_enter_programming_mode(radio): serial = radio.pipe

@@ -121,6 +122,7 @@ def _nc630a_enter_programming_mode(radio): if ack != CMD_ACK: raise errors.RadioError("Radio refused to enter programming mode")

+ def _nc630a_exit_programming_mode(radio): serial = radio.pipe try: @@ -128,6 +130,7 @@ def _nc630a_exit_programming_mode(radio): except: raise errors.RadioError("Radio refused to exit programming mode")

+ def _nc630a_read_block(radio, block_addr, block_size): serial = radio.pipe

@@ -153,6 +156,7 @@ def _nc630a_read_block(radio, block_addr, block_size):

return block_data

+ def _nc630a_write_block(radio, block_addr, block_size): serial = radio.pipe

@@ -170,6 +174,7 @@ def _nc630a_write_block(radio, block_addr, block_size): raise errors.RadioError("Failed to send block " "to radio at %04x" % block_addr)

+ def do_download(radio): print "download" _nc630a_enter_programming_mode(radio) @@ -196,6 +201,7 @@ def do_download(radio):

return memmap.MemoryMap(data)

+ def do_upload(radio): status = chirp_common.Status() status.msg = "Uploading to radio" @@ -213,6 +219,7 @@ def do_upload(radio):

_nc630a_exit_programming_mode(radio)

+ @directory.register class NC630aRadio(chirp_common.CloneModeRadio): """KYD NC-630A""" @@ -299,8 +306,8 @@ class NC630aRadio(chirp_common.CloneModeRadio): if mem.tmode == "DTCS": mem.dtcs_polarity = "%s%s" % (tpol, rpol)

- LOG.debug("Got TX %s (%i) RX %s (%i)" % (txmode, _mem.tx_tone, - rxmode, _mem.rx_tone)) + LOG.debug("Got TX %s (%i) RX %s (%i)" % + (txmode, _mem.tx_tone, rxmode, _mem.rx_tone))

def get_memory(self, number): bitpos = (1 << ((number - 1) % 8)) @@ -345,8 +352,8 @@ class NC630aRadio(chirp_common.CloneModeRadio): mem.extra = RadioSettingGroup("Extra", "extra")

rs = RadioSetting("bcl", "Busy Channel Lockout", - RadioSettingValueList(BCL_LIST, - BCL_LIST[_mem.bcl])) + RadioSettingValueList( + BCL_LIST, BCL_LIST[_mem.bcl])) mem.extra.append(rs)

return mem @@ -366,11 +373,10 @@ class NC630aRadio(chirp_common.CloneModeRadio): else: tx_mode = rx_mode = mem.tmode

- if tx_mode == "DTCS": _mem.tx_tone = mem.tmode != "DTCS" and \ - _set_dcs(mem.dtcs, mem.dtcs_polarity[0]) or \ - _set_dcs(mem.rx_dtcs, mem.dtcs_polarity[0]) + _set_dcs(mem.dtcs, mem.dtcs_polarity[0]) or \ + _set_dcs(mem.rx_dtcs, mem.dtcs_polarity[0]) elif tx_mode: _mem.tx_tone = tx_mode == "Tone" and \ int(mem.rtone * 10) or int(mem.ctone * 10) @@ -384,8 +390,8 @@ class NC630aRadio(chirp_common.CloneModeRadio): else: _mem.rx_tone = 0xFFFF

- LOG.debug("Set TX %s (%i) RX %s (%i)" % (tx_mode, _mem.tx_tone, - rx_mode, _mem.rx_tone)) + LOG.debug("Set TX %s (%i) RX %s (%i)" % + (tx_mode, _mem.tx_tone, rx_mode, _mem.rx_tone))

def set_memory(self, mem): bitpos = (1 << ((mem.number - 1) % 8)) @@ -435,23 +441,25 @@ class NC630aRadio(chirp_common.CloneModeRadio): top = RadioSettings(basic)

rs = RadioSetting("tot", "Time-out timer", - RadioSettingValueList(TIMEOUTTIMER_LIST, - TIMEOUTTIMER_LIST[_settings.tot])) + RadioSettingValueList( + TIMEOUTTIMER_LIST, + TIMEOUTTIMER_LIST[_settings.tot])) basic.append(rs)

rs = RadioSetting("totalert", "TOT Pre-alert", - RadioSettingValueList(TOTALERT_LIST, - TOTALERT_LIST[_settings.totalert])) + RadioSettingValueList( + TOTALERT_LIST, + TOTALERT_LIST[_settings.totalert])) basic.append(rs)

rs = RadioSetting("vox", "VOX Gain", - RadioSettingValueList(VOX_LIST, - VOX_LIST[_settings.vox])) + RadioSettingValueList( + VOX_LIST, VOX_LIST[_settings.vox])) basic.append(rs)

rs = RadioSetting("voice", "Voice Annumciation", - RadioSettingValueList(VOICE_LIST, - VOICE_LIST[_settings.voice])) + RadioSettingValueList( + VOICE_LIST, VOICE_LIST[_settings.voice])) basic.append(rs)

rs = RadioSetting("squelch", "Squelch Level", @@ -459,8 +467,9 @@ class NC630aRadio(chirp_common.CloneModeRadio): basic.append(rs)

rs = RadioSetting("voxdelay", "VOX Delay", - RadioSettingValueList(VOXDELAY_LIST, - VOXDELAY_LIST[_settings.voxdelay])) + RadioSettingValueList( + VOXDELAY_LIST, + VOXDELAY_LIST[_settings.voxdelay])) basic.append(rs)

rs = RadioSetting("beep", "Beep", diff --git a/tools/cpep8.blacklist b/tools/cpep8.blacklist index 743448c..a2fe563 100644 --- a/tools/cpep8.blacklist +++ b/tools/cpep8.blacklist @@ -34,7 +34,6 @@ ./chirp/drivers/kenwood_itm.py ./chirp/drivers/kenwood_live.py ./chirp/drivers/kguv8d.py -./chirp/drivers/kyd.py ./chirp/drivers/th9800.py ./chirp/drivers/th_uv3r.py ./chirp/drivers/th_uv3r25.py

# HG changeset patch # User Zach Welch zach@mandolincreekfarm.com # Fake Node ID 552614e54a36cd930ee142fa1221c832b96720cb

Fix style issues in kenwood_hmk.py (#2355)

diff --git a/chirp/drivers/kenwood_hmk.py b/chirp/drivers/kenwood_hmk.py index cff0162..7e76f33 100644 --- a/chirp/drivers/kenwood_hmk.py +++ b/chirp/drivers/kenwood_hmk.py @@ -19,10 +19,12 @@ import csv from chirp import chirp_common, errors, directory from chirp.drivers import generic_csv

+ class OmittedHeaderError(Exception): """An internal exception to indicate that a header was omitted""" pass

+ @directory.register class HMKRadio(generic_csv.CSVRadio): """Kenwood HMK format""" @@ -51,18 +53,18 @@ class HMKRadio(generic_csv.CSVRadio): }

ATTR_MAP = { - "!!Ch" : (int, "number"), - "M.Name" : (str, "name"), - "Rx Freq." : (chirp_common.parse_freq, "freq"), - "Shift/Split" : (lambda v: HMKRadio.DUPLEX_MAP[v], "duplex"), - "Offset" : (chirp_common.parse_freq, "offset"), - "T/CT/DCS" : (lambda v: HMKRadio.TMODE_MAP[v], "tmode"), - "TO Freq." : (float, "rtone"), - "CT Freq." : (float, "ctone"), - "DCS Code" : (int, "dtcs"), - "Mode" : (str, "mode"), - "Rx Step" : (float, "tuning_step"), - "L.Out" : (lambda v: HMKRadio.SKIP_MAP[v], "skip"), + "!!Ch": (int, "number"), + "M.Name": (str, "name"), + "Rx Freq.": (chirp_common.parse_freq, "freq"), + "Shift/Split": (lambda v: HMKRadio.DUPLEX_MAP[v], "duplex"), + "Offset": (chirp_common.parse_freq, "offset"), + "T/CT/DCS": (lambda v: HMKRadio.TMODE_MAP[v], "tmode"), + "TO Freq.": (float, "rtone"), + "CT Freq.": (float, "ctone"), + "DCS Code": (int, "dtcs"), + "Mode": (str, "mode"), + "Rx Step": (float, "tuning_step"), + "L.Out": (lambda v: HMKRadio.SKIP_MAP[v], "skip"), }

def load(self, filename=None): @@ -90,10 +92,10 @@ class HMKRadio(generic_csv.CSVRadio): continue

if len(header) > len(line): - print "Line %i has %i columns, expected %i" % (lineno, - len(line), - len(header)) - self.errors.append("Column number mismatch on line %i" % lineno) + print "Line %i has %i columns, expected %i" % \ + (lineno, len(line), len(header)) + self.errors.append("Column number mismatch on line %i" % + lineno) continue

# hmk stores Tx Freq. in its own field, but Chirp expects the Tx @@ -103,7 +105,7 @@ class HMKRadio(generic_csv.CSVRadio): line[header.index('Offset')] = line[header.index('Tx Freq.')]

# fix EU decimal - line = [i.replace(',','.') for i in line] + line = [i.replace(',', '.') for i in line]

try: mem = self._parse_csv_data_line(header, line) diff --git a/chirp/drivers/kenwood_itm.py b/chirp/drivers/kenwood_itm.py index a5fc8c2..a0fec83 100644 --- a/chirp/drivers/kenwood_itm.py +++ b/chirp/drivers/kenwood_itm.py @@ -19,10 +19,12 @@ import csv from chirp import chirp_common, errors, directory from chirp.drivers import generic_csv

+ class OmittedHeaderError(Exception): """An internal exception to indicate that a header was omitted""" pass

+ @directory.register class ITMRadio(generic_csv.CSVRadio): """Kenwood ITM format""" @@ -31,9 +33,9 @@ class ITMRadio(generic_csv.CSVRadio): FILE_EXTENSION = "itm"

ATTR_MAP = { - "CH" : (int, "number"), - "RXF" : (chirp_common.parse_freq, "freq"), - "NAME" : (str, "name"), + "CH": (int, "number"), + "RXF": (chirp_common.parse_freq, "freq"), + "NAME": (str, "name"), }

def _clean_duplex(self, headers, line, mem): @@ -51,7 +53,7 @@ class ITMRadio(generic_csv.CSVRadio): mem.offset = txfreq

return mem - + def _clean_number(self, headers, line, mem): zone = int(generic_csv.get_datum_by_header(headers, line, "ZN")) mem.number = zone * 100 + mem.number @@ -100,14 +102,14 @@ class ITMRadio(generic_csv.CSVRadio): break

if len(header) > len(line): - print "Line %i has %i columns, expected %i" % (lineno, - len(line), - len(header)) - self.errors.append("Column number mismatch on line %i" % lineno) + print "Line %i has %i columns, expected %i" % \ + (lineno, len(line), len(header)) + self.errors.append("Column number mismatch on line %i" % + lineno) continue

# fix EU decimal - line = [i.replace(',','.') for i in line] + line = [i.replace(',', '.') for i in line]

try: mem = self._parse_csv_data_line(header, line) diff --git a/chirp/drivers/kenwood_live.py b/chirp/drivers/kenwood_live.py index 6cac1c9..f440b17 100644 --- a/chirp/drivers/kenwood_live.py +++ b/chirp/drivers/kenwood_live.py @@ -19,21 +19,17 @@ import sys import time import logging

-LOG = logging.getLogger(__name__) - -NOCACHE = os.environ.has_key("CHIRP_NOCACHE") - -if __name__ == "__main__": - import sys - sys.path.insert(0, "..") - from chirp import chirp_common, errors, directory, util from chirp.settings import RadioSetting, RadioSettingGroup, \ RadioSettingValueInteger, RadioSettingValueBoolean, \ RadioSettingValueString, RadioSettingValueList, RadioSettings

-DUPLEX = { 0 : "", 1 : "+", 2 : "-" } -MODES = { 0 : "FM", 1 : "AM" } +LOG = logging.getLogger(__name__) + +NOCACHE = "CHIRP_NOCACHE" in os.environ + +DUPLEX = {0: "", 1: "+", 2: "-"} +MODES = {0: "FM", 1: "AM"} STEPS = list(chirp_common.TUNING_STEPS) STEPS.append(100.0)

@@ -41,6 +37,7 @@ THF6_MODES = ["FM", "WFM", "AM", "LSB", "USB", "CW"]

LOCK = threading.Lock()

+ def command(ser, cmd, *args): """Send @cmd to radio via @ser""" global LOCK @@ -67,6 +64,8 @@ def command(ser, cmd, *args): return result.strip()

LAST_BAUD = 9600 + + def get_id(ser): """Get the ID of the radio attached to @ser""" global LAST_BAUD @@ -86,6 +85,7 @@ def get_id(ser):

raise errors.RadioError("No response from radio")

+ def get_tmode(tone, ctcss, dcs): """Get the tone mode based on the values of the tone, ctcss, dcs""" if dcs and int(dcs) == 1: @@ -97,10 +97,12 @@ def get_tmode(tone, ctcss, dcs): else: return ""

+ def iserr(result): """Returns True if the @result from a radio is an error""" return result in ["N", "?"]

+ class KenwoodLiveRadio(chirp_common.LiveRadio): """Base class for all live-mode kenwood radios""" BAUD_RATE = 9600 @@ -151,9 +153,9 @@ class KenwoodLiveRadio(chirp_common.LiveRadio):

def get_memory(self, number): if number < 0 or number > self._upper: - raise errors.InvalidMemoryLocation( \ + raise errors.InvalidMemoryLocation( "Number must be between 0 and %i" % self._upper) - if self.__memcache.has_key(number) and not NOCACHE: + if number in self.__memcache and not NOCACHE: return self.__memcache[number]

result = command(self.pipe, *self._cmd_get_memory(number)) @@ -180,7 +182,7 @@ class KenwoodLiveRadio(chirp_common.LiveRadio): _zero, _loc, mem.name = value.split(",") else: _loc, mem.name = value.split(",") - + if mem.duplex == "" and self._kenwood_split: result = command(self.pipe, *self._cmd_get_split(number)) if " " in result: @@ -204,7 +206,7 @@ class KenwoodLiveRadio(chirp_common.LiveRadio):

def set_memory(self, memory): if memory.number < 0 or memory.number > self._upper: - raise errors.InvalidMemoryLocation( \ + raise errors.InvalidMemoryLocation( "Number must be between 0 and %i" % self._upper)

spec = self._make_mem_spec(memory) @@ -218,22 +220,22 @@ class KenwoodLiveRadio(chirp_common.LiveRadio): memory.name = memory.name.rstrip() self.__memcache[memory.number] = memory else: - raise errors.InvalidDataError("Radio refused name %i: %s" %\ - (memory.number, - repr(memory.name))) + raise errors.InvalidDataError("Radio refused name %i: %s" % + (memory.number, + repr(memory.name))) else: raise errors.InvalidDataError("Radio refused %i" % memory.number)

- if memory.duplex == "split" and self._kenwood_split: + if memory.duplex == "split" and self._kenwood_split: spec = ",".join(self._make_split_spec(memory)) result = command(self.pipe, *self._cmd_set_split(memory.number, spec)) if iserr(result): - raise errors.InvalidDataError("Radio refused %i" % \ - memory.number) + raise errors.InvalidDataError("Radio refused %i" % + memory.number)

def erase_memory(self, number): - if not self.__memcache.has_key(number): + if number not in self.__memcache: return

resp = command(self.pipe, *self._cmd_set_memory(number, "")) @@ -242,31 +244,33 @@ class KenwoodLiveRadio(chirp_common.LiveRadio): del self.__memcache[number]

TH_D7_SETTINGS = { - "BAL" : ["4:0", "3:1", "2:2", "1:3", "0:4"], - "BEP" : ["Off", "Key", "Key+Data", "All"], - "BEPT" : ["Off", "Mine", "All New"], # D700 has fourth "All" - "DS" : ["Data Band", "Both Bands"], - "DTB" : ["A", "B"], - "DTBA" : ["A", "B", "A:TX/B:RX"], # D700 has fourth A:RX/B:TX - "DTX" : ["Manual", "PTT", "Auto"], - "ICO" : ["Kenwood", "Runner", "House", "Tent", "Boat", "SSTV", + "BAL": ["4:0", "3:1", "2:2", "1:3", "0:4"], + "BEP": ["Off", "Key", "Key+Data", "All"], + "BEPT": ["Off", "Mine", "All New"], # D700 has fourth "All" + "DS": ["Data Band", "Both Bands"], + "DTB": ["A", "B"], + "DTBA": ["A", "B", "A:TX/B:RX"], # D700 has fourth A:RX/B:TX + "DTX": ["Manual", "PTT", "Auto"], + "ICO": ["Kenwood", "Runner", "House", "Tent", "Boat", "SSTV", "Plane", "Speedboat", "Car", "Bicycle"], - "MNF" : ["Name", "Frequency"], - "PKSA" : ["1200", "9600"], - "POSC" : ["Off Duty", "Enroute", "In Service", "Returning", + "MNF": ["Name", "Frequency"], + "PKSA": ["1200", "9600"], + "POSC": ["Off Duty", "Enroute", "In Service", "Returning", "Committed", "Special", "Priority", "Emergency"], - "PT" : ["100ms", "200ms", "500ms", "750ms", "1000ms", "1500ms", "2000ms"], - "SCR" : ["Time", "Carrier", "Seek"], - "SV" : ["Off", "0.2s", "0.4s", "0.6s", "0.8s", "1.0s", + "PT": ["100ms", "200ms", "500ms", "750ms", + "1000ms", "1500ms", "2000ms"], + "SCR": ["Time", "Carrier", "Seek"], + "SV": ["Off", "0.2s", "0.4s", "0.6s", "0.8s", "1.0s", "2s", "3s", "4s", "5s"], - "TEMP" : ["F", "C"], - "TXI" : ["30sec", "1min", "2min", "3min", "4min", "5min", + "TEMP": ["F", "C"], + "TXI": ["30sec", "1min", "2min", "3min", "4min", "5min", "10min", "20min", "30min"], - "UNIT" : ["English", "Metric"], - "WAY" : ["Off", "6 digit NMEA", "7 digit NMEA", "8 digit NMEA", + "UNIT": ["English", "Metric"], + "WAY": ["Off", "6 digit NMEA", "7 digit NMEA", "8 digit NMEA", "9 digit NMEA", "6 digit Magellan", "DGPS"], }

+ class KenwoodOldLiveRadio(KenwoodLiveRadio): _kenwood_valid_tones = list(chirp_common.OLD_TONES)

@@ -282,6 +286,7 @@ class KenwoodOldLiveRadio(KenwoodLiveRadio):

return KenwoodLiveRadio.set_memory(self, memory)

+ @directory.register class THD7Radio(KenwoodOldLiveRadio): """Kenwood TH-D7""" @@ -301,7 +306,8 @@ class THD7Radio(KenwoodOldLiveRadio): rf.valid_duplexes = ["", "-", "+", "split"] rf.valid_modes = MODES.values() rf.valid_tmodes = ["", "Tone", "TSQL"] - rf.valid_characters = chirp_common.CHARSET_ALPHANUMERIC + "/.-+*)('&%$#! ~}|{" + rf.valid_characters = \ + chirp_common.CHARSET_ALPHANUMERIC + "/.-+*)('&%$#! ~}|{" rf.valid_name_length = 7 rf.memory_bounds = (1, self._upper) return rf @@ -313,17 +319,17 @@ class THD7Radio(KenwoodOldLiveRadio): else: duplex = 0 offset = 0 - - spec = ( \ + + spec = ( "%011i" % mem.freq, "%X" % STEPS.index(mem.tuning_step), "%i" % duplex, "0", "%i" % (mem.tmode == "Tone"), "%i" % (mem.tmode == "TSQL"), - "", # DCS Flag + "", # DCS Flag "%02i" % (self._kenwood_valid_tones.index(mem.rtone) + 1), - "", # DCS Code + "", # DCS Code "%02i" % (self._kenwood_valid_tones.index(mem.ctone) + 1), "%09i" % offset, "%i" % util.get_dict_rev(MODES, mem.mode), @@ -380,7 +386,7 @@ class THD7Radio(KenwoodOldLiveRadio):

def _kenwood_set_int(self, cmd, value, digits=1): return self._kenwood_set(cmd, ("%%0%ii" % digits) % value) - + def get_settings(self): aux = RadioSettingGroup("aux", "Aux") tnc = RadioSettingGroup("tnc", "TNC") @@ -391,7 +397,7 @@ class THD7Radio(KenwoodOldLiveRadio): aux, tnc, save, display, dtmf) sky = RadioSettingGroup("sky", "SkyCommand") aprs = RadioSettingGroup("aprs", "APRS") - + top = RadioSettings(radio, aprs, sky)

bools = [("AMR", aprs, "APRS Message Auto-Reply"), @@ -399,7 +405,7 @@ class THD7Radio(KenwoodOldLiveRadio): ("ARO", aux, "Automatic Repeater Offset"), ("BCN", aprs, "Beacon"), ("CH", radio, "Channel Mode Display"), - #("DIG", aprs, "APRS Digipeater"), + # ("DIG", aprs, "APRS Digipeater"), ("DL", all, "Dual"), ("LK", all, "Lock"), ("LMP", all, "Lamp"), @@ -420,7 +426,7 @@ class THD7Radio(KenwoodOldLiveRadio): ("DTB", tnc, "Data Band"), ("DTBA", aprs, "APRS Data Band"), ("DTX", aprs, "APRS Data TX"), - #("ICO", aprs, "APRS Icon"), + # ("ICO", aprs, "APRS Icon"), ("MNF", all, "Memory Display Mode"), ("PKSA", aprs, "APRS Packet Speed"), ("POSC", aprs, "APRS Position Comment"), @@ -428,7 +434,7 @@ class THD7Radio(KenwoodOldLiveRadio): ("SV", save, "Battery Save"), ("TEMP", aprs, "APRS Temperature Units"), ("TXI", aprs, "APRS Transmit Interval"), - #("UNIT", aprs, "APRS Display Units"), + # ("UNIT", aprs, "APRS Display Units"), ("WAY", aprs, "Waypoint Mode"), ]

@@ -453,7 +459,7 @@ class THD7Radio(KenwoodOldLiveRadio): ("PP", aprs, "APRS Path", 32), ("SCC", sky, "SkyCommand Callsign", 8), ("SCT", sky, "SkyCommand To Callsign", 8), - #("STAT", aprs, "APRS Status Text", 32), + # ("STAT", aprs, "APRS Status Text", 32), ] for setting, group, name, length in strings: _cmd, value = self._kenwood_get(setting) @@ -478,19 +484,21 @@ class THD7Radio(KenwoodOldLiveRadio): digits = 2 else: digits = 1 - self._kenwood_set_int(element.get_name(), element.value, digits) + self._kenwood_set_int(element.get_name(), + element.value, digits) elif isinstance(element.value, RadioSettingValueString): self._kenwood_set(element.get_name(), str(element.value)) else: print "Unknown type %s" % element.value

+ @directory.register class THD7GRadio(THD7Radio): """Kenwood TH-D7G""" MODEL = "TH-D7G"

def get_features(self): - rf = super(THD7GRadio,self).get_features() + rf = super(THD7GRadio, self).get_features() rf.valid_name_length = 8 return rf

@@ -523,7 +531,7 @@ class TMD700Radio(KenwoodOldLiveRadio): duplex = util.get_dict_rev(DUPLEX, mem.duplex) else: duplex = 0 - spec = ( \ + spec = ( "%011i" % mem.freq, "%X" % STEPS.index(mem.tuning_step), "%i" % duplex, @@ -563,12 +571,13 @@ class TMD700Radio(KenwoodOldLiveRadio):

return mem

+ @directory.register class TMV7Radio(KenwoodOldLiveRadio): """Kenwood TM-V7""" MODEL = "TM-V7"

- mem_upper_limit = 200 # Will be updated + mem_upper_limit = 200 # Will be updated

def get_features(self): rf = chirp_common.RadioFeatures() @@ -586,7 +595,7 @@ class TMV7Radio(KenwoodOldLiveRadio): return rf

def _make_mem_spec(self, mem): - spec = ( \ + spec = ( "%011i" % mem.freq, "%X" % STEPS.index(mem.tuning_step), "%i" % util.get_dict_rev(DUPLEX, mem.duplex), @@ -642,34 +651,38 @@ class TMV7Radio(KenwoodOldLiveRadio): try: self.erase_memory(loc) except Exception: - pass # V7A Can't delete just yet + pass # V7A Can't delete just yet

return True

def _detect_split(self): return 50

+ class TMV7RadioSub(TMV7Radio): """Base class for the TM-V7 sub devices""" def __init__(self, pipe): TMV7Radio.__init__(self, pipe) self._detect_split()

+ class TMV7RadioVHF(TMV7RadioSub): """TM-V7 VHF subdevice""" VARIANT = "VHF" _vfo = 0

+ class TMV7RadioUHF(TMV7RadioSub): """TM-V7 UHF subdevice""" VARIANT = "UHF" _vfo = 1

+ @directory.register class TMG707Radio(TMV7Radio): """Kenwood TM-G707""" MODEL = "TM-G707" - + def get_features(self): rf = TMV7Radio.get_features(self) rf.has_sub_devices = False @@ -679,7 +692,10 @@ class TMG707Radio(TMV7Radio): (800000000, 999000000)] return rf

-THG71_STEPS = [ 5, 6.25, 10, 12.5, 15, 20, 25, 30, 50, 100 ] + +THG71_STEPS = [5, 6.25, 10, 12.5, 15, 20, 25, 30, 50, 100] + + @directory.register class THG71Radio(TMV7Radio): """Kenwood TH-G71""" @@ -693,11 +709,11 @@ class THG71Radio(TMV7Radio): rf.has_sub_devices = False rf.valid_bands = [(118000000, 174000000), (320000000, 470000000), - (800000000, 945000000)] + (800000000, 945000000)] return rf

def _make_mem_spec(self, mem): - spec = ( \ + spec = ( "%011i" % mem.freq, "%X" % THG71_STEPS.index(mem.tuning_step), "%i" % util.get_dict_rev(DUPLEX, mem.duplex), @@ -730,13 +746,14 @@ class THG71Radio(TMV7Radio): mem.offset = 0 return mem

- + THF6A_STEPS = [5.0, 6.25, 8.33, 9.0, 10.0, 12.5, 15.0, 20.0, 25.0, 30.0, 50.0, 100.0]

THF6A_DUPLEX = dict(DUPLEX) THF6A_DUPLEX[3] = "split"

+ @directory.register class THF6ARadio(KenwoodLiveRadio): """Kenwood TH-F6""" @@ -814,7 +831,7 @@ class THF6ARadio(KenwoodLiveRadio): offset = 0 else: print "Bug: unsupported duplex `%s'" % mem.duplex - spec = ( \ + spec = ( "%011i" % mem.freq, "%X" % THF6A_STEPS.index(mem.tuning_step), "%i" % duplex, @@ -831,6 +848,7 @@ class THF6ARadio(KenwoodLiveRadio):

return spec

+ @directory.register class THF7ERadio(THF6ARadio): """Kenwood TH-F7""" @@ -850,11 +868,12 @@ D710_TONES.remove(189.9) D710_TONES.remove(196.6) D710_TONES.remove(199.5)

+ @directory.register class TMD710Radio(KenwoodLiveRadio): """Kenwood TM-D710""" MODEL = "TM-D710" - + _upper = 999 _kenwood_valid_tones = list(D710_TONES)

@@ -867,7 +886,7 @@ class TMD710Radio(KenwoodLiveRadio): rf.valid_modes = D710_MODES rf.valid_duplexes = D710_DUPLEX rf.valid_tuning_steps = D710_STEPS - rf.valid_characters = chirp_common.CHARSET_ASCII.replace(',','') + rf.valid_characters = chirp_common.CHARSET_ASCII.replace(',', '') rf.valid_name_length = 8 rf.valid_skips = D710_SKIP rf.memory_bounds = (0, 999) @@ -909,37 +928,38 @@ class TMD710Radio(KenwoodLiveRadio): mem.duplex = "split" mem.offset = int(spec[13]) # Unknown - mem.skip = D710_SKIP[int(spec[15])] # Memory Lockout + mem.skip = D710_SKIP[int(spec[15])] # Memory Lockout

return mem

def _make_mem_spec(self, mem): - spec = ( \ + spec = ( "%010i" % mem.freq, "%X" % D710_STEPS.index(mem.tuning_step), - "%i" % (0 if mem.duplex == "split" else \ - D710_DUPLEX.index(mem.duplex)), - "0", # Reverse + "%i" % (0 if mem.duplex == "split" + else D710_DUPLEX.index(mem.duplex)), + "0", # Reverse "%i" % (mem.tmode == "Tone" and 1 or 0), "%i" % (mem.tmode == "TSQL" and 1 or 0), "%i" % (mem.tmode == "DTCS" and 1 or 0), "%02i" % (self._kenwood_valid_tones.index(mem.rtone)), "%02i" % (self._kenwood_valid_tones.index(mem.ctone)), "%03i" % (chirp_common.DTCS_CODES.index(mem.dtcs)), - "%08i" % (0 if mem.duplex == "split" else mem.offset), # Offset + "%08i" % (0 if mem.duplex == "split" else mem.offset), # Offset "%i" % D710_MODES.index(mem.mode), - "%010i" % (mem.offset if mem.duplex == "split" else 0), # TX Freq - "0", # Unknown - "%i" % D710_SKIP.index(mem.skip), # Memory Lockout + "%010i" % (mem.offset if mem.duplex == "split" else 0), # TX Freq + "0", # Unknown + "%i" % D710_SKIP.index(mem.skip), # Memory Lockout )

return spec

+ @directory.register class THD72Radio(TMD710Radio): """Kenwood TH-D72""" MODEL = "TH-D72 (live mode)" - HARDWARE_FLOW = sys.platform == "darwin" # only OS X driver needs hw flow + HARDWARE_FLOW = sys.platform == "darwin" # only OS X driver needs hw flow

def _parse_mem_spec(self, spec): mem = chirp_common.Memory() @@ -965,17 +985,17 @@ class THD72Radio(TMD710Radio): mem.duplex = "split" mem.offset = int(spec[15]) # Lockout - mem.skip = D710_SKIP[int(spec[17])] # Memory Lockout + mem.skip = D710_SKIP[int(spec[17])] # Memory Lockout

return mem

def _make_mem_spec(self, mem): - spec = ( \ + spec = ( "%010i" % mem.freq, "%X" % D710_STEPS.index(mem.tuning_step), - "%i" % (0 if mem.duplex == "split" else \ - D710_DUPLEX.index(mem.duplex)), - "0", # Reverse + "%i" % (0 if mem.duplex == "split" + else D710_DUPLEX.index(mem.duplex)), + "0", # Reverse "%i" % (mem.tmode == "Tone" and 1 or 0), "%i" % (mem.tmode == "TSQL" and 1 or 0), "%i" % (mem.tmode == "DTCS" and 1 or 0), @@ -984,20 +1004,22 @@ class THD72Radio(TMD710Radio): "%02i" % (self._kenwood_valid_tones.index(mem.ctone)), "%03i" % (chirp_common.DTCS_CODES.index(mem.dtcs)), "0", - "%08i" % (0 if mem.duplex == "split" else mem.offset), # Offset + "%08i" % (0 if mem.duplex == "split" else mem.offset), # Offset "%i" % D710_MODES.index(mem.mode), - "%010i" % (mem.offset if mem.duplex == "split" else 0), # TX Freq - "0", # Unknown - "%i" % D710_SKIP.index(mem.skip), # Memory Lockout + "%010i" % (mem.offset if mem.duplex == "split" else 0), # TX Freq + "0", # Unknown + "%i" % D710_SKIP.index(mem.skip), # Memory Lockout )

return spec

+ @directory.register class TMV71Radio(TMD710Radio): """Kenwood TM-V71""" MODEL = "TM-V71"

+ @directory.register class TMD710GRadio(TMD710Radio): """Kenwood TM-D710G""" @@ -1016,17 +1038,18 @@ class TMD710GRadio(TMD710Radio): THK2_DUPLEX = ["", "+", "-"] THK2_MODES = ["FM", "NFM"] THK2_TONES = list(chirp_common.TONES) -THK2_TONES.remove(159.8) # ?? -THK2_TONES.remove(165.5) # ?? -THK2_TONES.remove(171.3) # ?? -THK2_TONES.remove(177.3) # ?? -THK2_TONES.remove(183.5) # ?? -THK2_TONES.remove(189.9) # ?? -THK2_TONES.remove(196.6) # ?? -THK2_TONES.remove(199.5) # ?? +THK2_TONES.remove(159.8) # ?? +THK2_TONES.remove(165.5) # ?? +THK2_TONES.remove(171.3) # ?? +THK2_TONES.remove(177.3) # ?? +THK2_TONES.remove(183.5) # ?? +THK2_TONES.remove(189.9) # ?? +THK2_TONES.remove(196.6) # ?? +THK2_TONES.remove(199.5) # ??

THK2_CHARS = chirp_common.CHARSET_UPPER_NUMERIC + "-/"

+ @directory.register class THK2Radio(KenwoodLiveRadio): """Kenwood TH-K2""" @@ -1068,7 +1091,7 @@ class THK2Radio(KenwoodLiveRadio):

mem.number = int(spec[0]) mem.freq = int(spec[1]) - #mem.tuning_step = + # mem.tuning_step = mem.duplex = THK2_DUPLEX[int(spec[3])] if int(spec[5]): mem.tmode = "Tone" @@ -1091,32 +1114,32 @@ class THK2Radio(KenwoodLiveRadio): except ValueError: raise errors.UnsupportedToneError()

- spec = ( \ + spec = ( "%010i" % mem.freq, "0", - "%i" % THK2_DUPLEX.index(mem.duplex), + "%i" % THK2_DUPLEX.index(mem.duplex), "0", - "%i" % int(mem.tmode == "Tone"), - "%i" % int(mem.tmode == "TSQL"), - "%i" % int(mem.tmode == "DTCS"), - "%02i" % rti, - "%02i" % cti, - "%03i" % chirp_common.DTCS_CODES.index(mem.dtcs), - "%08i" % mem.offset, - "%i" % THK2_MODES.index(mem.mode), + "%i" % int(mem.tmode == "Tone"), + "%i" % int(mem.tmode == "TSQL"), + "%i" % int(mem.tmode == "DTCS"), + "%02i" % rti, + "%02i" % cti, + "%03i" % chirp_common.DTCS_CODES.index(mem.dtcs), + "%08i" % mem.offset, + "%i" % THK2_MODES.index(mem.mode), "0", "%010i" % 0, "0", - "%i" % int(mem.skip == "S") + "%i" % int(mem.skip == "S") ) return spec - +

@directory.register class TM271Radio(THK2Radio): """Kenwood TM-271""" MODEL = "TM-271" - + def get_features(self): rf = chirp_common.RadioFeatures() rf.can_odd_split = False @@ -1146,12 +1169,14 @@ class TM271Radio(THK2Radio): def _cmd_set_memory_name(self, number, name): return "MN", "%03i,%s" % (number, name)

+ @directory.register class TM281Radio(TM271Radio): """Kenwood TM-281""" MODEL = "TM-281" # seems that this is a perfect clone of TM271 with just a different model

+ def do_test(): """Dev test""" mem = chirp_common.Memory() @@ -1161,20 +1186,25 @@ def do_test(): mem.offset = 146000000

tc = THF6ARadio + class FakeSerial: """Faked serial line""" buf = "" + def write(self, buf): """Write""" self.buf = buf + def read(self, count): """Read""" if self.buf[:2] == "ID": return "ID %s\r" % tc.MODEL return self.buf + def setTimeout(self, foo): """Set Timeout""" pass + def setBaudrate(self, foo): """Set Baudrate""" pass @@ -1182,11 +1212,12 @@ def do_test(): radio = tc(FakeSerial()) radio.set_memory(mem)

+ @directory.register class TM471Radio(THK2Radio): """Kenwood TM-471""" MODEL = "TM-471" - + def get_features(self): rf = chirp_common.RadioFeatures() rf.can_odd_split = False @@ -1216,6 +1247,7 @@ class TM471Radio(THK2Radio): def _cmd_set_memory_name(self, number, name): return "MN", "%03i,%s" % (number, name)

+ def do_test(): """Dev test""" mem = chirp_common.Memory() @@ -1225,20 +1257,25 @@ def do_test(): mem.offset = 442000000

tc = THF6ARadio + class FakeSerial: """Faked serial line""" buf = "" + def write(self, buf): """Write""" self.buf = buf + def read(self, count): """Read""" if self.buf[:2] == "ID": return "ID %s\r" % tc.MODEL return self.buf + def setTimeout(self, foo): """Set Timeout""" pass + def setBaudrate(self, foo): """Set Baudrate""" pass @@ -1246,6 +1283,6 @@ def do_test(): radio = tc(FakeSerial()) radio.set_memory(mem)

+ if __name__ == "__main__": do_test() - diff --git a/tools/cpep8.blacklist b/tools/cpep8.blacklist index 0b9c455..96facb4 100644 --- a/tools/cpep8.blacklist +++ b/tools/cpep8.blacklist @@ -29,9 +29,6 @@ ./chirp/drivers/id31.py ./chirp/drivers/id800.py ./chirp/drivers/id880.py -./chirp/drivers/kenwood_hmk.py -./chirp/drivers/kenwood_itm.py -./chirp/drivers/kenwood_live.py ./chirp/drivers/kguv8d.py ./chirp/drivers/th9800.py ./chirp/drivers/th_uv3r.py

# HG changeset patch # User Zach Welch zach@mandolincreekfarm.com # Fake Node ID 7d34ed196547bcae7332f25b6c38518a497c6c55

Fix style issues in id31.py (#2355)

diff --git a/chirp/drivers/id31.py b/chirp/drivers/id31.py index 7c91b02..66325d7 100644 --- a/chirp/drivers/id31.py +++ b/chirp/drivers/id31.py @@ -94,6 +94,7 @@ DTCS_POLARITY = ["NN", "NR", "RN", "RR"] TUNING_STEPS = [5.0, 6.25, 0, 0, 10.0, 12.5, 15.0, 20.0, 25.0, 30.0, 50.0, 100.0, 125.0, 200.0]

+ def _decode_call(_call): # Why Icom, why? call = "" @@ -107,6 +108,7 @@ def _decode_call(_call): call += chr(acc) return call

+ def _encode_call(call): _call = [0x00] * 7 for i in range(0, 7): @@ -115,9 +117,10 @@ def _encode_call(call): _call[i-1] |= (val & 0xFF00) >> 8 _call[i] = val _call[6] |= (ord(call[7]) & 0x7F) - + return _call

+ def _get_freq(_mem): freq = int(_mem.freq) offs = int(_mem.offset) @@ -131,6 +134,7 @@ def _get_freq(_mem):

return (freq * mult), (offs * mult)

+ def _set_freq(_mem, freq, offset): if chirp_common.is_fractional_step(freq): mult = 6250 @@ -142,6 +146,7 @@ def _set_freq(_mem, freq, offset): _mem.freq = (freq / mult) | flag _mem.offset = (offset / mult)

+ class ID31Bank(icf.IcomBank): """A ID-31 Bank""" def get_name(self): @@ -152,6 +157,7 @@ class ID31Bank(icf.IcomBank): _banks = self._model._radio._memobj.bank_names _banks[self.index].name = str(name).ljust(16)[:16]

+ @directory.register class ID31Radio(icf.IcomCloneModeRadio, chirp_common.IcomDstarSupport): """Icom ID-31""" @@ -250,7 +256,7 @@ class ID31Radio(icf.IcomCloneModeRadio, chirp_common.IcomDstarSupport): mem.skip = "P" if _skp & bit: mem.skip = "S" - + return mem

def set_memory(self, memory): @@ -277,8 +283,8 @@ class ID31Radio(icf.IcomCloneModeRadio, chirp_common.IcomDstarSupport): _mem.dtcs = chirp_common.DTCS_CODES.index(memory.dtcs) _mem.dtcs_polarity = DTCS_POLARITY.index(memory.dtcs_polarity) _mem.tune_step = TUNING_STEPS.index(memory.tuning_step) - _mem.mode = next(i for i, mode in self.MODES.items() \ - if mode == memory.mode) + _mem.mode = next(i for i, mode in self.MODES.items() + if mode == memory.mode)

if isinstance(memory, chirp_common.DVMemory): _mem.urcall = _encode_call(memory.dv_urcall.ljust(8)) @@ -288,15 +294,15 @@ class ID31Radio(icf.IcomCloneModeRadio, chirp_common.IcomDstarSupport): raise Exception("BUG")

if memory.skip == "S": - _skp |= bit + _skp |= bit _psk &= ~bit elif memory.skip == "P": _skp &= ~bit - _psk |= bit + _psk |= bit else: _skp &= ~bit _psk &= ~bit - + def get_urcall_list(self): calls = [] for i in range(0, 200): diff --git a/tools/cpep8.blacklist b/tools/cpep8.blacklist index 42c4364..63ab2ed 100644 --- a/tools/cpep8.blacklist +++ b/tools/cpep8.blacklist @@ -26,7 +26,6 @@ ./chirp/drivers/icw32.py ./chirp/drivers/icx8x.py ./chirp/drivers/icx8x_ll.py -./chirp/drivers/id31.py ./chirp/drivers/id800.py ./chirp/drivers/id880.py ./chirp/drivers/th9800.py

# HG changeset patch # User Zach Welch zach@mandolincreekfarm.com # Fake Node ID eadd858b79e8a8bf9f3620114a9298f2a00ed284

Fix style issues in icomciv.py (#2355)

diff --git a/chirp/drivers/icomciv.py b/chirp/drivers/icomciv.py index fd9090f..04ff53e 100644 --- a/chirp/drivers/icomciv.py +++ b/chirp/drivers/icomciv.py @@ -1,5 +1,6 @@

-import struct, logging +import struct +import logging from chirp.drivers import icf from chirp import chirp_common, util, errors, bitwise, directory from chirp.memmap import MemoryMap @@ -55,6 +56,7 @@ u8 unknown[11]; char name[9]; """

+ class Frame: """Base class for an ICF frame""" _cmd = 0x00 @@ -81,8 +83,8 @@ class Frame: raw = struct.pack("BBBBBB", 0xFE, 0xFE, src, dst, self._cmd, self._sub) raw += str(self._data) + chr(0xFD)

- LOG.debug("%02x -> %02x (%i):\n%s" % (src, dst, - len(raw), util.hexprint(raw))) + LOG.debug("%02x -> %02x (%i):\n%s" % + (src, dst, len(raw), util.hexprint(raw)))

serial.write(raw) if willecho: @@ -117,6 +119,7 @@ class Frame: def get_obj(self): raise errors.RadioError("Generic frame has no structure")

+ class MemFrame(Frame): """A memory frame""" _cmd = 0x1A @@ -138,13 +141,14 @@ class MemFrame(Frame):

def get_obj(self): """Return a bitwise parsed object""" - self._data = MemoryMap(str(self._data)) # Make sure we're assignable + self._data = MemoryMap(str(self._data)) # Make sure we're assignable return bitwise.parse(MEM_FORMAT, self._data)

def initialize(self): """Initialize to sane values""" self._data = MemoryMap("".join(["\x00"] * (self.get_obj().size() / 8)))

+ class MultiVFOMemFrame(MemFrame): """A memory frame for radios with multiple VFOs""" def set_location(self, loc, vfo=1): @@ -152,14 +156,16 @@ class MultiVFOMemFrame(MemFrame): self._data = struct.pack(">BH", vfo, int("%04i" % loc, 16))

def get_obj(self): - self._data = MemoryMap(str(self._data)) # Make sure we're assignable + self._data = MemoryMap(str(self._data)) # Make sure we're assignable return bitwise.parse(MEM_VFO_FORMAT, self._data)

+ class DupToneMemFrame(MemFrame): def get_obj(self): self._data = MemoryMap(str(self._data)) return bitwise.parse(mem_duptone_format, self._data)

+ class IcomCIVRadio(icf.IcomLiveRadio): """Base class for ICOM CIV-based radios""" BAUD_RATE = 19200 @@ -191,7 +197,7 @@ class IcomCIVRadio(icf.IcomLiveRadio): icf.IcomLiveRadio.__init__(self, *args, **kwargs)

self._classes = { - "mem" : MemFrame, + "mem": MemFrame, }

if self.pipe: @@ -199,16 +205,16 @@ class IcomCIVRadio(icf.IcomLiveRadio): print "Interface echo: %s" % self._willecho self.pipe.setTimeout(1)

- #f = Frame() - #f.set_command(0x19, 0x00) - #self._send_frame(f) + # f = Frame() + # f.set_command(0x19, 0x00) + # self._send_frame(f) # - #res = f.read(self.pipe) - #if res: + # res = f.read(self.pipe) + # if res: # print "Result: %x->%x (%i)" % (res[0], res[1], len(f.get_data())) # print util.hexprint(f.get_data()) # - #self._id = f.get_data()[0] + # self._id = f.get_data()[0] self._rf = chirp_common.RadioFeatures()

self._initialize() @@ -281,8 +287,8 @@ class IcomCIVRadio(icf.IcomLiveRadio): self._send_frame(f) return

- #f.set_data(MemoryMap(self.get_raw_memory(mem.number))) - #f.initialize() + # f.set_data(MemoryMap(self.get_raw_memory(mem.number))) + # f.initialize()

memobj = f.get_obj() memobj.number = mem.number @@ -307,6 +313,7 @@ class IcomCIVRadio(icf.IcomLiveRadio): f = self._recv_frame() print "Result:\n%s" % util.hexprint(f.get_data())

+ @directory.register class Icom7200Radio(IcomCIVRadio): """Icom IC-7200""" @@ -329,6 +336,7 @@ class Icom7200Radio(IcomCIVRadio): self._rf.valid_skips = [] self._rf.memory_bounds = (1, 200)

+ @directory.register class Icom7000Radio(IcomCIVRadio): """Icom IC-7000""" @@ -355,6 +363,7 @@ class Icom7000Radio(IcomCIVRadio): self._rf.valid_characters = chirp_common.CHARSET_ASCII self._rf.memory_bounds = (1, 99)

+ @directory.register class Icom746Radio(IcomCIVRadio): """Icom IC-746""" @@ -383,11 +392,12 @@ class Icom746Radio(IcomCIVRadio): self._rf.memory_bounds = (1, 99)

CIV_MODELS = { - (0x76, 0xE0) : Icom7200Radio, - (0x70, 0xE0) : Icom7000Radio, - (0x46, 0xE0) : Icom746Radio, + (0x76, 0xE0): Icom7200Radio, + (0x70, 0xE0): Icom7000Radio, + (0x46, 0xE0): Icom746Radio, }

+ def probe_model(ser): """Probe the radio attatched to @ser for its model""" f = Frame() diff --git a/tools/cpep8.blacklist b/tools/cpep8.blacklist index bc99216..3b7a604 100644 --- a/tools/cpep8.blacklist +++ b/tools/cpep8.blacklist @@ -19,7 +19,6 @@ ./chirp/drivers/ic9x_icf_ll.py ./chirp/drivers/ic9x_ll.py ./chirp/drivers/icf.py -./chirp/drivers/icomciv.py ./chirp/drivers/icq7.py ./chirp/drivers/ict70.py ./chirp/drivers/ict8.py

# HG changeset patch # User Zach Welch zach@mandolincreekfarm.com # Fake Node ID f3550aa0750a46d1deb15f3a58d6c540d391318d

Fix style issues in thuv1f.py (#2355)

diff --git a/chirp/drivers/thuv1f.py b/chirp/drivers/thuv1f.py index c5ac91f..73ec10c 100644 --- a/chirp/drivers/thuv1f.py +++ b/chirp/drivers/thuv1f.py @@ -22,6 +22,7 @@ from chirp.settings import RadioSetting, RadioSettingGroup, \ RadioSettingValueBoolean, RadioSettingValueString, \ RadioSettings

+ def uvf1_identify(radio): """Do identify handshake with TYT TH-UVF1""" radio.pipe.write("PROG333") @@ -37,6 +38,7 @@ def uvf1_identify(radio): raise errors.RadioError("Radio did not ack identification") return ident

+ def uvf1_download(radio): """Download from TYT TH-UVF1""" data = uvf1_identify(radio) @@ -63,6 +65,7 @@ def uvf1_download(radio):

return memmap.MemoryMap(data)

+ def uvf1_upload(radio): """Upload to TYT TH-UVF1""" data = uvf1_identify(radio) @@ -91,6 +94,7 @@ def uvf1_upload(radio): # End of clone? radio.pipe.write("\x45")

+ THUV1F_MEM_FORMAT = """ struct mem { bbcd rx_freq[4]; @@ -170,6 +174,7 @@ PTTID_LIST = ["Off", "BOT", "EOT", "Both"] BCL_LIST = ["Off", "CSQ", "QT/DQT"] CODES_LIST = [x for x in range(1, 9)]

+ @directory.register class TYTTHUVF1Radio(chirp_common.CloneModeRadio): """TYT TH-UVF1""" @@ -307,9 +312,8 @@ class TYTTHUVF1Radio(chirp_common.CloneModeRadio): txmode, txval, txpol = self._decode_tone(_mem.tx_tone) rxmode, rxval, rxpol = self._decode_tone(_mem.rx_tone)

- chirp_common.split_tone_decode(mem, - (txmode, txval, txpol), - (rxmode, rxval, rxpol)) + chirp_common.split_tone_decode( + mem, (txmode, txval, txpol), (rxmode, rxval, rxpol))

mem.name = str(self._memobj.names[number - 1].name) mem.name = mem.name.replace("\xFF", " ").rstrip() @@ -335,8 +339,8 @@ class TYTTHUVF1Radio(chirp_common.CloneModeRadio): mem.extra.append(rs)

rs = RadioSetting("scramble_code", "Scramble Code", - RadioSettingValueList(CODES_LIST, - CODES_LIST[_mem.scramble_code])) + RadioSettingValueList( + CODES_LIST, CODES_LIST[_mem.scramble_code])) mem.extra.append(rs)

return mem @@ -382,7 +386,7 @@ class TYTTHUVF1Radio(chirp_common.CloneModeRadio): def get_settings(self): _settings = self._memobj.settings

- group = RadioSettingGroup("basic", "Basic"); + group = RadioSettingGroup("basic", "Basic") top = RadioSettings(group)

group.append( @@ -396,7 +400,7 @@ class TYTTHUVF1Radio(chirp_common.CloneModeRadio):

group.append( RadioSetting("squelch", "Squelch Level", - RadioSettingValueInteger(0, 9, _settings.squelch))) + RadioSettingValueInteger(0, 9, _settings.squelch)))

group.append( RadioSetting("vox_level", "VOX Level", diff --git a/tools/cpep8.blacklist b/tools/cpep8.blacklist index 16d6347..26dab82 100644 --- a/tools/cpep8.blacklist +++ b/tools/cpep8.blacklist @@ -30,7 +30,6 @@ ./chirp/drivers/th_uv3r25.py ./chirp/drivers/th_uvf8d.py ./chirp/drivers/thd72.py -./chirp/drivers/thuv1f.py ./chirp/drivers/tmv71.py ./chirp/drivers/tmv71_ll.py ./chirp/drivers/vx170.py