CHIRP

# Copyright 2013 Sean Burford <sburford@google.com>

#

# This program is free software: you can redistribute it and/or modify

                for tone in tones:

                    assert tone in chirp_common.TONES, (

                        "tone %s not one of %s" % (tone, chirp_common.TONES))

            raise ValueError("%s %s: %s" % (name, limits, e))

        self.name = name

# Copyright 2008 Dan Smith <dsmith@danplanet.com>

#

# This program is free software: you can redistribute it and/or modify

    return int(math.pow(10, (dBm - 30) / 10))

    """Represents a power level supported by a radio"""

    def __init__(self, label, watts=0, dBm=0):

    pass

    """Base class for a single radio memory"""

    freq = 0

    number = 0

        super(BankModel, self).__init__(radio, name)

    """Interface for mappings with index capabilities"""

    def get_index_bounds(self):

        sys.stdout.write(os.linesep)

    """Radio prompt strings"""

    experimental = None

    pre_download = None

BOOLEAN = [True, False]

    """Radio Feature Flags"""

    _valid_map = {

        # General

        lo, hi = self.memory_bounds

        if not self.has_infinite_number and \

                (mem.number < lo or mem.number > hi) and \

            msg = ValidationWarning("Location %i is out of range" % mem.number)

            msgs.append(msg)

        if (self.valid_modes and

            msg = ValidationError("Mode %s not supported" % mem.mode)

            msgs.append(msg)

        else:

            if mem.tmode == "Cross":

                if self.valid_cross_modes and \

                    msg = ValidationError("Cross tone mode %s not supported" %

                                          mem.cross_mode)

                    msgs.append(msg)

        if self.has_dtcs_polarity and \

            msg = ValidationError("DTCS Polarity %s not supported" %

                                  mem.dtcs_polarity)

            msgs.append(msg)

        if self.valid_dtcs_codes and \

            msg = ValidationError("DTCS Code %03i not supported" % mem.dtcs)

        if self.valid_dtcs_codes and \

            msg = ValidationError("DTCS Code %03i not supported" % mem.rx_dtcs)

        if self.valid_duplexes and mem.duplex not in self.valid_duplexes:

        if self.valid_bands and \

                self.valid_duplexes and \

            if mem.duplex == "split":

                freq = mem.offset

            elif mem.duplex == "-":

        if mem.power and \

                self.valid_power_levels and \

            msg = ValidationWarning("Power level %s not supported" % mem.power)

            msgs.append(msg)

                    msg = ValidationError("Frequency requires %.2fkHz step" %

                                          required_step(mem.freq))

                    msgs.append(msg)

                msgs.append(str(e))

        if self.valid_characters:

    def load_mmap(self, filename):

        """Load the radio's memory map from @filename"""

        self._mmap = memmap.MemoryMap(mapfile.read())

        mapfile.close()

        self.process_mmap()

        If IOError raise a File Access Error Exception

        """

        try:

            mapfile.write(self._mmap.get_packed())

            mapfile.close()

        except IOError:

        pass

    """Base interface for radios supporting Icom's D-STAR technology"""

    MYCALL_LIMIT = (1, 1)

    URCALL_LIMIT = (1, 1)

        pass

    """Interface for experimental radios"""

    @classmethod

    def get_experimental_warning(cls):

        return ("This radio's driver is marked as experimental and may " +

                "be unstable or unsafe to use.")

    """Clone status object for conveying clone progress to the UI"""

    name = "Job"

    msg = "Unknown"

    myfilter = ''.join(

        [

            [replacechar, chr(x)][chr(x) in validcharset]

        ])

    return astring.translate(myfilter)

# Copyright 2010 Dan Smith <dsmith@danplanet.com>

#

# This program is free software: you can redistribute it and/or modify

        ser.baudrate = 9600

        md = icf.get_model_data(ser)

        return _icom_model_data_to_rclass(md)

        LOG.error(e)

    # ICOM IC-91/92 Live-mode radios @ 4800/38400 baud

# Copyright 2011 Dan Smith <dsmith@danplanet.com>

#           2016 Matt Weyland <lt-betrieb@hb9uf.ch>

#

            self._mmap = self._download(self._memsize)

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

        self.process_mmap()

            self._upload(self._memsize)

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

    def get_raw_memory(self, number):

# Copyright 2013 Dan Smith <dsmith@danplanet.com>

#

# This program is free software: you can redistribute it and/or modify

    try:

        radio.pipe.write(data)

        radio.pipe.read(len(data))

        LOG.error("Error writing to radio: %s" % e)

        raise errors.RadioError("Unable to write to radio")

def _read(radio, length):

    try:

        data = radio.pipe.read(length)

        LOG.error("Error reading from radio: %s" % e)

        raise errors.RadioError("Unable to read from radio")

# Copyright 2015 Jim Unroe <rock.unroe@gmail.com>

#

# This program is free software: you can redistribute it and/or modify

def _echo_write(radio, data):

    try:

        radio.pipe.write(data)

        LOG.error("Error writing to radio: %s" % e)

        raise errors.RadioError("Unable to write to radio")

def _read(radio, length):

    try:

        data = radio.pipe.read(length)

        LOG.error("Error reading from radio: %s" % e)

        raise errors.RadioError("Unable to read from radio")

                    else:

                        LOG.debug("Setting %s = %s" % (setting, element.value))

                        setattr(obj, setting, element.value)

                    LOG.debug(element.get_name())

                    raise

# Copyright 2014 Tom Hayward <tom@tomh.us>

#

# This program is free software: you can redistribute it and/or modify

def drain(pipe):

    """Chew up any data waiting on @pipe"""

        buf = pipe.read(4096)

        if not buf:

            return

def enter_setup(pipe):

    """Put AP510 in configuration mode."""

        if x % 2:

            pipe.write("@SETUP")

        else:

        radio.pipe.write("@DISP")

    buf = ""

        buf += radio.pipe.read(1024)

        if buf.endswith("\r\n"):

            status.cur = status.max

            data = download(self)

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

        # _mmap isn't a Chirp MemoryMap, but since AP510Memory implements

            upload(self)

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

    def load_mmap(self, filename):

        """Load the radio's memory map from @filename"""

        data = mapfile.read()

        if data.startswith('\r\n00=%s 20141215' % self._model):

            self._mmap = AP510Memory20141215(data)

# Copyright 2016:

# * Jim Unroe KC9HI, <rock.unroe@gmail.com>

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""common functions for Baofeng (or similar) handheld radios"""

import time

        try:

            data = _do_ident(radio, magic)

            return data

            error = e

            time.sleep(2)

    if error:

                    elif element.value.get_mutable():

                        LOG.debug("Setting %s = %s" % (setting, element.value))

                        setattr(obj, setting, element.value)

                    LOG.debug(element.get_name())

                    raise

                    value = int(val.get_value() * 10)

                LOG.debug("Setting fm_presets = %s" % (value))

                self._memobj.fm_presets = value

                LOG.debug(element.get_name())

                raise

# Copyright 2011 Dan Smith <dsmith@danplanet.com>

#

# This program is free software: you can redistribute it and/or modify

    for _i in range(0, 10):

        try:

            return _uv3r_prep(radio)

            time.sleep(1)

    raise e

        return do_download(radio, 0x0000, 0x0E40, 0x0010)

    except errors.RadioError:

        raise

        raise errors.RadioError("Failed to communicate with radio: %s" % e)

        return do_upload(radio, 0x0000, 0x0E40, 0x0010)

    except errors.RadioError:

        raise

        raise errors.RadioError("Failed to communicate with radio: %s" % e)

                    else:

                        LOG.debug("Setting %s = %s" % (setting, element.value))

                        setattr(obj, setting, element.value)

                    LOG.debug(element.get_name())

                    raise

                LOG.debug("Setting fm_presets[%1i] = %s" % (index, value))

                setting = self._memobj.fm_presets

                setting[index] = value

                LOG.debug(element.get_name())

                raise

#

# Copyright 2015 Marco Filippi IZ3GME <iz3gme.marco@gmail.com>

#

            self._mmap = self._clone_in()

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

        self.process_mmap()

            self._clone_out()

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

    def process_mmap(self):

# Copyright 2013 Jens Jensen AF5MI <kd4tjx@yahoo.com>

# Based on work by Jim Unroe, Dan Smith, et al.

# Special thanks to Mats SM0BTP for equipment donation.

                value = int(val.get_value() * 10 - 870)

                LOG.debug("Setting fm_preset = %s" % (value))

                self._memobj.fm_preset = value

                LOG.debug(element.get_name())

                raise

# Copyright 2016-2017:

# * Pavel Milanes CO7WT, <pavelmc@gmail.com>

# * Jim Unroe KC9HI, <rock.unroe@gmail.com>

    except errors.RadioError:

        raise

        raise errors.RadioError("Error sending Magic to radio:\n%s" % e)

            _upload(self)

        except errors.RadioError:

            raise

            raise errors.RadioError("Error: %s" % e)

    def get_raw_memory(self, number):

                    elif element.value.get_mutable():

                        LOG.debug("Setting %s = %s" % (setting, element.value))

                        setattr(obj, setting, element.value)

                    LOG.debug(element.get_name())

                    raise

# Copyright 2010 Dan Smith <dsmith@danplanet.com>

# Copyright 2014 Angus Ainslie <angus@akkea.ca>

#

                except AttributeError as e:

                    LOG.error("Setting %s is not in the memory map: %s" %

                              (element.get_name(), e))

                LOG.debug(element.get_name())

                raise

# Copyright 2011 Dan Smith <dsmith@danplanet.com>

#

# This program is free software: you can redistribute it and/or modify

            self._mmap = _download(self)

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

        LOG.info("Downloaded in %.2f sec" % (time.time() - start))

        self.process_mmap()

            _upload(self)

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

        LOG.info("Uploaded in %.2f sec" % (time.time() - start))

# Copyright 2011 Dan Smith <dsmith@danplanet.com>

#

# FT-2900-specific modifications by Richard Cochran, <ag6qr@sonic.net>

            self._mmap = _download(self)

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

        LOG.info("Downloaded in %.2f sec" % (time.time() - start))

        self.process_mmap()

            _upload(self)

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

        LOG.info("Uploaded in %.2f sec" % (time.time() - start))

                    setattr(_settings, name, value)

                LOG.debug("Setting %s: %s" % (name, value))

                LOG.debug(element.get_name())

                raise

# Copyright 2011 Dan Smith <dsmith@danplanet.com>

#

# This program is free software: you can redistribute it and/or modify

def _clone_out(radio):

    try:

        return __clone_out(radio)

        raise errors.RadioError("Failed to communicate with the radio: %s" % e)

# Copyright 2011 Dan Smith <dsmith@danplanet.com>

#

# This program is free software: you can redistribute it and/or modify

            self._mmap = _download(self)

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

        self.process_mmap()

        self.check_checksums()

            _upload(self)

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

    def process_mmap(self):

                    setattr(_settings, name, value)

                LOG.debug("Setting %s: %s" % (name, value))

                LOG.debug(element.get_name())

                raise

# Copyright 2010 Dan Smith <dsmith@danplanet.com>

#

# This program is free software: you can redistribute it and/or modify

            self._mmap = _download(self)

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

        LOG.info("Download finished in %i seconds" % (time.time() - start))

        self.check_checksums()

            _upload(self)

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

        LOG.info("Upload finished in %i seconds" % (time.time() - start))

                oldval = getattr(_settings, setting)

                LOG.debug("Setting %s(%s) <= %s" % (setting, oldval, newval))

                setattr(_settings, setting, newval)

                LOG.debug(element.get_name())

                raise

# Copyright 2010 Eric Allen <eric@hackerengineer.net>

#

# This program is free software: you can redistribute it and/or modify

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import time

import os

        if _mem.duplex == DUPLEX.index("split"):

            tx_freq = int(_mem.offset) * 1000

            mem.offset = tx_freq - mem.freq

        else:

            mem.offset = int(_mem.offset) * 1000

        if not self._memobj.enables[byte] & bit and number != 1:

            mem.empty = True

        return mem

def _clone_out(radio):

    try:

        return __clone_out(radio)

        raise errors.RadioError("Failed to communicate with the radio: %s" % e)

    pos = 0

    for block in radio._block_lengths:

        if os.getenv("CHIRP_DEBUG"):

        out = radio.get_mmap()[pos:pos + block]

        # need to chew byte-by-byte here or else we lose the ACK...not sure why

        pos += block

    return True

#

# Copyright 2012 Filippi Marco <iz3gme.marco@gmail.com>

#

            self._mmap = self._clone_in()

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

        self.process_mmap()

            self._clone_out()

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

    def process_mmap(self):

# Copyright 2011 Dan Smith <dsmith@danplanet.com>

# Copyright 2013 Jens Jensen AF5MI <kd4tjx@yahoo.com>

#

            self._mmap = self._clone_in()

        except errors.RadioError:

            raise

            trace = traceback.format_exc()

            raise errors.RadioError(

                    "Failed to communicate with radio: %s" % trace)

            self._clone_out()

        except errors.RadioError:

            raise

            trace = traceback.format_exc()

            raise errors.RadioError(

                    "Failed to communicate with radio: %s" % trace)

                    newval = self._dtmf2bbcd(newval)

                LOG.debug("Setting %s(%s) <= %s" % (setting, oldval, newval))

                setattr(_settings, setting, newval)

                LOG.debug(element.get_name())

                raise

# Copyright 2013 Dan Smith <dsmith@danplanet.com>

#

# This program is free software: you can redistribute it and/or modify

            self._mmap = _clone_in(self)

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to download from radio (%s)" % e)

        self.process_mmap()

            _clone_out(self)

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to upload to radio (%s)" % e)

    def process_mmap(self):

# Copyright 2008 Dan Smith <dsmith@danplanet.com>

#

# This program is free software: you can redistribute it and/or modify

                    val = typ(val)

                if hasattr(mem, attr):

                    setattr(mem, attr, val)

                pass

                raise Exception("[%s] %s" % (attr, e))

        return self._clean(headers, line, mem)

        self._blank()

        header = f.readline().strip()

        f.seek(0, 0)

                mem = self._parse_csv_data_line(header, line)

                if mem.number is None:

                    raise Exception("Invalid Location field" % lineno)

                LOG.error("Line %i: %s", lineno, e)

                self.errors.append("Line %i: %s" % (lineno, e))

                continue

        if filename:

            self._filename = filename

        writer = csv.writer(f, delimiter=chirp_common.SEPCHAR)

        writer.writerow(chirp_common.Memory.CSV_FORMAT)

# Copyright 2008 Dan Smith <dsmith@danplanet.com>

#

# This program is free software: you can redistribute it and/or modify

    try:

        ctx = libxml2.schemaNewParserCtxt(path)

        schema = ctx.schemaParse()

        LOG.error("Unable to load schema: %s" % e)

        LOG.error("Path: %s" % path)

        raise errors.RadioError("Unable to load schema")

        if filename:

            self._filename = filename

        f.write(self.doc.serialize(format=1))

        f.close()

                    else:

                        LOG.debug("Setting %s = %s" % (setting, element.value))

                        setattr(obj, setting, element.value)

                    LOG.debug(element.get_name())

                    raise

# Copyright 2008 Dan Smith <dsmith@danplanet.com>

#

# This program is free software: you can redistribute it and/or modify

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import time

import threading

import logging

                LOG.debug("Done: %s" % mem)

            except errors.InvalidMemoryLocation:

                pass

                LOG.error("Error talking to radio: %s" % e)

                break

    import serial

    ser = IC9xRadioB(serial.Serial(port="/dev/ttyUSB1",

                                   baudrate=38400, timeout=0.1))

    ser.set_urcall_list(["K7TAY", "FOOBAR", "BAZ"])

# Copyright 2008 Dan Smith <dsmith@danplanet.com>

#

# This program is free software: you can redistribute it and/or modify

        try:

            start = buf.index("\xfe\xfe")

            end = buf[start:].index("\xfd") + start + 1

            LOG.error("No trailing bit")

            break

            frame = IC92Frame()

            frame.from_raw(framedata[2:-1])

            frames.append(frame)

            LOG.error("Broken frame: %s" % e)

        # LOG.debug("Parsed %i frames" % len(frames))

    return _ic9x_parse_frames(data)

    """IC9x frame base class"""

    def get_vfo(self):

        """Return the vfo number"""

        return ord(self._map[0])

        return response[0]

    def __setitem__(self, start, value):

    def __getitem__(self, index):

    def __getslice__(self, start, end):

class IC92GetBankFrame(IC92Frame):

# Copyright 2008 Dan Smith <dsmith@danplanet.com>

#

# This program is free software: you can redistribute it and/or modify

SAVE_PIPE = None

    """A single ICF communication frame"""

    src = 0

    dst = 0

    return frame, data[end+1:]

    """A class to make reading a stream of IcfFrames easier"""

    def __init__(self, pipe):

        self.pipe = pipe

        self.data = ""

                    frames.append(frame)

                self.data = rest

                LOG.error("Failed to parse frame (cmd=%i): %s" % (cmd, e))

                return []

            val = int("%s%s" % (bcddata[i], bcddata[i+1]), 16)

            i += 2

            data += struct.pack("B", val)

            LOG.error("Failed to parse byte: %s" % e)

            break

    """Do a full clone out of the radio's memory"""

    try:

        return _clone_from_radio(radio)

        raise errors.RadioError("Failed to communicate with the radio: %s" % e)

    global SAVE_PIPE

    # Uncomment to save out a capture of what we actually write to the radio

    md = get_model_data(radio.pipe)

    """Initiate a full memory clone out to @radio"""

    try:

        return _clone_to_radio(radio)

        raise errors.RadioError("Failed to communicate with the radio: %s" % e)

            val = int("%s%s" % (data[i], data[i+1]), 16)

            i += 2

            _mmap += struct.pack("B", val)

            LOG.debug("Failed to parse byte: %s" % e)

            break

def read_file(filename):

    """Read an ICF file and return the model string and memory data"""

    mod_str = f.readline()

    dat = f.readlines()

def is_9x_icf(filename):

    """Returns True if @filename is an IC9x ICF file"""

    mdata = f.read(8)

    f.close()

def is_icf_file(filename):

    """Returns True if @filename is an ICF file"""

    data = f.readline()

    data += f.readline()

    f.close()

# Copyright 2010 Dan Smith <dsmith@danplanet.com>

#

# This program is free software: you can redistribute it and/or modify

                    else:

                        LOG.debug("Setting %s = %s" % (setting, element.value))

                        setattr(obj, setting, element.value)

                    LOG.debug(element.get_name())

                    raise

# Copyright 2008 Dan Smith <dsmith@danplanet.com>

# Copyright 2012 Tom Hayward <tom@tomh.us>

#

        self._blank()

        for line in f:

            if line.strip() == "// Memory Channels":

                break

                mem = self._parse_csv_data_line(header, line)

                if mem.number is None:

                    raise Exception("Invalid Location field" % lineno)

                LOG.error("Line %i: %s" % (lineno, e))

                self.errors.append("Line %i: %s" % (lineno, e))

                continue

# Copyright 2008 Dan Smith <dsmith@danplanet.com>

# Copyright 2012 Tom Hayward <tom@tomh.us>

#

        self._blank()

        for line in f:

            if line.strip() == "// Conventional Data":

                break

                mem = self._parse_csv_data_line(header, line)

                if mem.number is None:

                    raise Exception("Invalid Location field" % lineno)

                LOG.error("Line %i: %s" % (lineno, e))

                self.errors.append("Line %i: %s" % (lineno, e))

                continue

# Copyright 2014 Ron Wellsted <ron@m0rnw.uk> M0RNW

#

# This program is free software: you can redistribute it and/or modify

            self._mmap = self._download()

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

        self.process_mmap()

            return self._do_download(0, 32768, 64)

        except errors.RadioError:

            raise

            LOG.exception('Unknown error during download process')

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

            self._do_upload(0, 32768, 64)

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

        return

# Copyright 2014 Jim Unroe <rock.unroe@gmail.com>

# Copyright 2014 Dan Smith <dsmith@danplanet.com>

#

                    LOG.debug("Setting %s = %s" % (setting, element.value))

                    setattr(obj, setting, element.value)

                    LOG.debug(element.get_name())

                    raise

# Copyright 2015 Lepik.stv <lepik.stv@gmail.com>

# based on modification of Dan Smith's and Jim Unroe original work

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""KYD IP-620 radios management module"""

# TODO: Power on message

            self.pipe.write("\x06")

        except errors.RadioError:

            raise

            raise errors.RadioError("Radio refused to exit programming mode: %s" % e)

    def _ip620_enter_programming_mode(self):

            _ack = self.pipe.read(1)

        except errors.RadioError:

            raise

            raise errors.RadioError("Error communicating with radio: %s" % e)

        if not _ack:

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

            _ident = self.pipe.read(8)

        except errors.RadioError:

            raise

            raise errors.RadioError("Error communicating with radio: %s" % e)

        if not _ident.startswith("\x06\x4B\x47\x36\x37\x01\x56\xF8"):

            raise errors.RadioError("Radio returned unknown identification string")

        try:

            self.pipe.write(CMD_ACK)

            _ack = self.pipe.read(1)

        except errors.RadioError:

            raise

            raise errors.RadioError("Error communicating with radio: %s" % e)

        if _ack != CMD_ACK:

            raise errors.RadioError("Radio refused to enter programming mode")

            self._mmap = self._do_download()

        except errors.RadioError:

            raise

            raise errors.RadioError("Failed to communicate with radio: %s" % e)

        self.process_mmap()

                setattr(self._memobj.settings_misc,

                        element.get_name(),

                        element.value)

                LOG.debug(element.get_name())

                raise

                    setattr(_settings_misc, setting, newval)

                else:

                    setattr(_settings, setting, newval)

                LOG.debug(element.get_name())

                raise

# Copyright 2014 Tom Hayward <tom@tomh.us>

#

# This program is free software: you can redistribute it and/or modify

                   ]

MODES = ["NFM", "FM"]

TONES = WTFTONES + chirp_common.TONES

DTCS_CODES = [17, 50, 645] + chirp_common.DTCS_CODES

DTCS_CODES.sort()

    #            util.hexprint(frame).replace("\n", "\n          ")))

    try:

        radio.pipe.write(frame)

        raise errors.RadioError("Failed to communicate with radio: %s" % e)

    def sync_in(self):

        try: