CHIRP

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

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

#

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

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

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

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

from chirp.drivers import yaesu_clone

from chirp import chirp_common, bitwise, memmap, directory, errors, util

from chirp.settings import RadioSetting, RadioSettingGroup, \

    RadioSettingValueInteger, RadioSettingValueList, \

    RadioSettingValueBoolean, RadioSettingValueString, \

    RadioSettings

import time

import os

import traceback

import string

import re

import logging

from textwrap import dedent

LOG = logging.getLogger(__name__)

CMD_ACK = b'\x06'

FT90_STEPS = [5.0, 10.0, 12.5, 15.0, 20.0, 25.0, 50.0]

FT90_MODES = ["AM", "FM", "Auto"]

# idx 3 (Bell) not supported yet

FT90_TMODES = ["", "Tone", "TSQL", "", "DTCS"]

FT90_TONES = list(chirp_common.TONES)

for tone in [165.5, 171.3, 177.3]:

    FT90_TONES.remove(tone)

FT90_POWER_LEVELS_VHF = [chirp_common.PowerLevel("Hi", watts=50),

                         chirp_common.PowerLevel("Mid1", watts=20),

                         chirp_common.PowerLevel("Mid2", watts=10),

                         chirp_common.PowerLevel("Low", watts=5)]

FT90_POWER_LEVELS_UHF = [chirp_common.PowerLevel("Hi", watts=35),

                         chirp_common.PowerLevel("Mid1", watts=20),

                         chirp_common.PowerLevel("Mid2", watts=10),

                         chirp_common.PowerLevel("Low", watts=5)]

FT90_DUPLEX = ["", "-", "+", "split"]

FT90_CWID_CHARS = list(string.digits) + list(string.ascii_uppercase) \

                  + list(" ")

FT90_DTMF_CHARS = list("0123456789ABCD*#")

FT90_SPECIAL = ["vfo_vhf", "home_vhf", "vfo_uhf", "home_uhf",

                "pms_1L", "pms_1U", "pms_2L", "pms_2U"]

@directory.register

class FT90Radio(yaesu_clone.YaesuCloneModeRadio):

    VENDOR = "Yaesu"

    MODEL = "FT-90"

    ID = b"\x8E\xF6"

    NEEDS_COMPAT_SERIAL = False

    _memsize = 4063

    # block 03 (200 Bytes long) repeats 18 times; channel memories

    _block_lengths = [2, 232, 24] + ([200] * 18) + [205]

    mem_format = """

u16 id;

#seekto 0x22;

struct {

    u8 dtmf_active;

    u8 dtmf1_len;

    u8 dtmf2_len;

    u8 dtmf3_len;

    u8 dtmf4_len;

    u8 dtmf5_len;

    u8 dtmf6_len;

    u8 dtmf7_len;

    u8 dtmf8_len;

    u8 dtmf1[8];

    u8 dtmf2[8];

    u8 dtmf3[8];

    u8 dtmf4[8];

    u8 dtmf5[8];

    u8 dtmf6[8];

    u8 dtmf7[8];

    u8 dtmf8[8];

    char cwid[7];

    u8 unk1;

    u8 scan1:2,

       beep:1,

       unk3:3,

       rfsqlvl:2;

    u8 unk4:2,

       scan2:1,

       cwid_en:1,

       txnarrow:1,

       dtmfspeed:1,

       pttlock:2;

    u8 dtmftxdelay:3,

       fancontrol:2,

       unk5:3;

    u8 dimmer:3,

       unk6:1,

       lcdcontrast:4;

    u8 dcsmode:2,

       unk16:2,

       tot:4;

    u8 unk14;

    u8 unk8:1,

       ars:1,

       lock:1,

       txpwrsave:1,

       apo:4;

    u8 unk15;

    u8 unk9:4,

       key_lt:4;

    u8 unk10:4,

       key_rt:4;

    u8 unk11:4,

       key_p1:4;

    u8 unk12:4,

       key_p2:4;

    u8 unk13:4,

       key_acc:4;

} settings;

struct mem_struct {

    u8 mode:2,

       isUhf1:1,

       unknown1:2,

       step:3;

    u8 artsmode:2,

       unknown2:1,

       isUhf2:1

       power:2,

       shift:2;

    u8 skip:1,

       showname:1,

       unknown3:1,

       isUhfHi:1,

       unknown4:1,

       tmode:3;

    u32 rxfreq;

    u32 txfreqoffset;

    u8 UseDefaultName:1,

       ars:1,

       tone:6;

    u8 packetmode:1,

       unknown5:1,

       dcstone:6;

    char name[7];

};

#seekto 0x86;

struct mem_struct vfo_vhf;

struct mem_struct home_vhf;

struct mem_struct vfo_uhf;

struct mem_struct home_uhf;

#seekto 0xEB;

u8 chan_enable[23];

#seekto 0x101;

struct {

    u8 pms_2U_enable:1,

       pms_2L_enable:1,

       pms_1U_enable:1,

       pms_1L_enable:1,

       unknown6:4;

} special_enables;

#seekto 0x102;

struct mem_struct memory[180];

#seekto 0xf12;

struct mem_struct pms_1L;

struct mem_struct pms_1U;

struct mem_struct pms_2L;

struct mem_struct pms_2U;

#seekto 0x0F7B;

struct  {

    char demomsg1[50];

    char demomsg2[50];

} demomsg;

"""

    @classmethod

    def get_prompts(cls):

        rp = chirp_common.RadioPrompts()

        rp.pre_download = _(dedent("""\

1. Turn radio off.

2. Connect mic and hold [ACC] on mic while powering on.

    ("CLONE" will appear on the display)

3. Replace mic with PC programming cable.

4. <b>After clicking OK</b>, press the [SET] key to send image."""))

        rp.pre_upload = _(dedent("""\

1. Turn radio off.

2. Connect mic and hold [ACC] on mic while powering on.

    ("CLONE" will appear on the display)

3. Replace mic with PC programming cable.

4. Press the [DISP/SS] key

    ("R" will appear on the lower left of LCD)."""))

        rp.display_pre_upload_prompt_before_opening_port = False

        return rp

    @classmethod

    def match_model(cls, filedata, filename):

        return len(filedata) == cls._memsize

    def get_features(self):

        rf = chirp_common.RadioFeatures()

        rf.has_settings = True

        rf.has_ctone = False

        rf.has_bank = False

        rf.has_dtcs_polarity = False

        rf.has_dtcs = True

        rf.valid_modes = FT90_MODES

        rf.valid_tmodes = FT90_TMODES

        rf.valid_duplexes = FT90_DUPLEX

        rf.valid_tuning_steps = FT90_STEPS

        rf.valid_power_levels = FT90_POWER_LEVELS_VHF

        rf.valid_name_length = 7

        rf.valid_characters = chirp_common.CHARSET_ASCII

        rf.valid_skips = ["", "S"]

        rf.valid_special_chans = FT90_SPECIAL

        rf.memory_bounds = (1, 180)

        rf.valid_bands = [(100000000, 230000000),

                          (300000000, 530000000),

                          (810000000, 999975000)]

        return rf

    def _read(self, blocksize, blocknum):

        data = self.pipe.read(blocksize+2)

        # chew echo'd ack

        self.pipe.write(CMD_ACK)

        time.sleep(0.02)

        self.pipe.read(1)  # chew echoed ACK from 1-wire serial

        if len(data) == blocksize + 2 and data[0] == blocknum:

            checksum = yaesu_clone.YaesuChecksum(1, blocksize)

            if checksum.get_existing(data) != checksum.get_calculated(data):

                raise Exception("Checksum Failed [%02X<>%02X] block %02X, "

                                "data len: %i" %

                                (checksum.get_existing(data),

                                 checksum.get_calculated(data),

                                 blocknum, len(data)))

            data = data[1:blocksize + 1]  # Chew blocknum and checksum

        else:

            raise Exception("Unable to read blocknum %02X "

                            "expected blocksize %i got %i." %

                            (blocknum, blocksize+2, len(data)))

        return data

    def _clone_in(self):

        # Be very patient with the radio

        self.pipe.timeout = 4

        start = time.time()

        data = b""

        blocknum = 0

        status = chirp_common.Status()

        status.msg = "Cloning..."

        self.status_fn(status)

        status.max = len(self._block_lengths)

        for blocksize in self._block_lengths:

            data += self._read(blocksize, blocknum)

            blocknum += 1

            status.cur = blocknum

            self.status_fn(status)

        LOG.info("Clone completed in %i seconds, blocks read: %i" %

                 (time.time() - start, blocknum))

        return memmap.MemoryMapBytes(data)

    def _clone_out(self):

        looppredelay = 0.4

        looppostdelay = 1.9

        self.pipe.timeout = 4

        start = time.time()

        blocknum = 0

        pos = 0

        status = chirp_common.Status()

        status.msg = "Cloning to radio..."

        self.status_fn(status)

        status.max = len(self._block_lengths)

        for blocksize in self._block_lengths:

            checksum = yaesu_clone.YaesuChecksum(pos, pos+blocksize-1)

            blocknumbyte = bytes([blocknum])

            payloadbytes = self.get_mmap()[pos:pos+blocksize]

            checksumbyte = bytes([checksum.get_calculated(self.get_mmap())])

            LOG.debug("Block %i - will send from %i to %i byte " %

                      (blocknum, pos, pos + blocksize))

            LOG.debug(util.hexprint(blocknumbyte))

            LOG.debug(util.hexprint(payloadbytes))

            LOG.debug(util.hexprint(checksumbyte))

            # send wrapped bytes

            time.sleep(looppredelay)

            self.pipe.write(blocknumbyte)

            self.pipe.write(payloadbytes)

            self.pipe.write(checksumbyte)

            tmp = self.pipe.read(blocksize + 2)  # chew echo

            LOG.debug("bytes echoed: ")

            LOG.debug(util.hexprint(tmp))

            # radio is slow to write/ack:

            time.sleep(looppostdelay)

            buf = self.pipe.read(1)

            LOG.debug("ack recd:")

            LOG.debug(util.hexprint(buf))

            if buf != CMD_ACK:

                raise Exception("Radio did not ack block %i" % blocknum)

            pos += blocksize

            blocknum += 1

            status.cur = blocknum

            self.status_fn(status)

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

    def sync_in(self):

        try:

            self._mmap = self._clone_in()

        except errors.RadioError:

            raise

        except Exception as e:

            trace = traceback.format_exc()

            raise errors.RadioError(

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

        self.process_mmap()

    def sync_out(self):

        try:

            self._clone_out()

        except errors.RadioError:

            raise

        except Exception as e:

            trace = traceback.format_exc()

            raise errors.RadioError(

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

    def process_mmap(self):

        self._memobj = bitwise.parse(self.mem_format, self._mmap)

    def _get_chan_enable(self, number):

        number = number - 1

        bytepos = number // 8

        bitpos = number % 8

        chan_enable = self._memobj.chan_enable[bytepos]

        if chan_enable & (1 << bitpos):

            return True

        else:

            return False

    def _set_chan_enable(self, number, enable):

        number = number - 1

        bytepos = number // 8

        bitpos = number % 8

        chan_enable = self._memobj.chan_enable[bytepos]

        if enable:

            chan_enable = chan_enable | (1 << bitpos)  # enable

        else:

            chan_enable = chan_enable & ~(1 << bitpos)  # disable

        self._memobj.chan_enable[bytepos] = chan_enable

    def get_memory(self, number):

        mem = chirp_common.Memory()

        if isinstance(number, str):

            # special channel

            _mem = getattr(self._memobj, number)

            mem.number = - len(FT90_SPECIAL) + FT90_SPECIAL.index(number)

            mem.extd_number = number

            if re.match('^pms', mem.extd_number):

                # enable pms_XY channel flag

                _special_enables = self._memobj.special_enables

                mem.empty = not getattr(_special_enables,

                                        mem.extd_number + "_enable")

        else:

            # regular memory

            _mem = self._memobj.memory[number-1]

            mem.number = number

            mem.empty = not self._get_chan_enable(number)

        if mem.empty:

            return mem  # bail out, do not parse junk

        mem.freq = _mem.rxfreq * 10

        mem.offset = _mem.txfreqoffset * 10

        if not _mem.tmode < len(FT90_TMODES):

            _mem.tmode = 0

        mem.tmode = FT90_TMODES[_mem.tmode]

        mem.rtone = FT90_TONES[_mem.tone]

        mem.dtcs = chirp_common.DTCS_CODES[_mem.dcstone]

        mem.mode = FT90_MODES[_mem.mode]

        mem.duplex = FT90_DUPLEX[_mem.shift]

        if mem.freq / 1000000 > 300:

            mem.power = FT90_POWER_LEVELS_UHF[_mem.power]

        else:

            mem.power = FT90_POWER_LEVELS_VHF[_mem.power]

        # radio has a known bug with 5khz step and squelch

        if _mem.step == 0 or _mem.step > len(FT90_STEPS)-1:

            _mem.step = 2

        mem.tuning_step = FT90_STEPS[_mem.step]

        mem.skip = _mem.skip and "S" or ""

        if not all(char in chirp_common.CHARSET_ASCII

                   for char in str(_mem.name)):

            # dont display blank/junk name

            mem.name = ""

        else:

            mem.name = str(_mem.name)

        return mem

    def get_raw_memory(self, number):

        return repr(self._memobj.memory[number-1])

    def set_memory(self, mem):

        if mem.number < 0:      # special channels

            _mem = getattr(self._memobj, mem.extd_number)

            if re.match('^pms', mem.extd_number):

                # enable pms_XY channel flag

                _special_enables = self._memobj.special_enables

                setattr(_special_enables, mem.extd_number + "_enable", True)

        else:

            _mem = self._memobj.memory[mem.number - 1]

            self._set_chan_enable(mem.number, not mem.empty)

        _mem.skip = mem.skip == "S"

        # radio has a known bug with 5khz step and dead squelch

        if not mem.tuning_step or mem.tuning_step == FT90_STEPS[0]:

            _mem.step = 2

        else:

            _mem.step = FT90_STEPS.index(mem.tuning_step)

        _mem.rxfreq = mem.freq / 10

        # vfo will unlock if not in right band?

        if mem.freq > 300000000:

            # uhf

            _mem.isUhf1 = 1

            _mem.isUhf2 = 1

            if mem.freq > 810000000:

                # uhf hiband

                _mem.isUhfHi = 1

            else:

                _mem.isUhfHi = 0

        else:

            # vhf

            _mem.isUhf1 = 0

            _mem.isUhf2 = 0

            _mem.isUhfHi = 0

        _mem.txfreqoffset = mem.offset / 10

        _mem.tone = FT90_TONES.index(mem.rtone)

        _mem.tmode = FT90_TMODES.index(mem.tmode)

        _mem.mode = FT90_MODES.index(mem.mode)

        _mem.shift = FT90_DUPLEX.index(mem.duplex)

        _mem.dcstone = chirp_common.DTCS_CODES.index(mem.dtcs)

        _mem.step = FT90_STEPS.index(mem.tuning_step)

        _mem.shift = FT90_DUPLEX.index(mem.duplex)

        if mem.power:

            _mem.power = FT90_POWER_LEVELS_VHF.index(mem.power)

        else:

            _mem.power = 3  # default to low power

        if (len(mem.name) == 0):

            _mem.name = bytearray.fromhex("80ffffffffffff")

            _mem.showname = 0

        else:

            _mem.name = str(mem.name).ljust(7)

            _mem.showname = 1

            _mem.UseDefaultName = 0

    def _decode_cwid(self, cwidarr):

        cwid = ""

        LOG.debug("@ +_decode_cwid:")

        for byte in cwidarr.get_value():

            char = int(byte)

            LOG.debug(char)

            # bitwise wraps in quotes! get rid of those

            if char < len(FT90_CWID_CHARS):

                cwid += FT90_CWID_CHARS[char]

        return cwid

    def _encode_cwid(self, cwidarr):

        cwid = ""

        LOG.debug("@ _encode_cwid:")

        for char in cwidarr.get_value():

            cwid += chr(FT90_CWID_CHARS.index(char))

        LOG.debug(cwid)

        return cwid

    def _bbcd2dtmf(self, bcdarr, strlen=16):

        # doing bbcd, but with support for ABCD*#

        LOG.debug(bcdarr.get_value())

        string = ''.join("%02X" % b for b in bcdarr)

        LOG.debug("@_bbcd2dtmf, received: %s" % string)

        string = string.replace('E', '*').replace('F', '#')

        if strlen <= 16:

            string = string[:strlen]

        return string

    def _dtmf2bbcd(self, dtmf):

        dtmfstr = dtmf.get_value()

        dtmfstr = dtmfstr.replace('*', 'E').replace('#', 'F')

        dtmfstr = str.ljust(dtmfstr.strip(), 16, "0")

        bcdarr = list(bytearray.fromhex(dtmfstr))

        LOG.debug("@_dtmf2bbcd, sending: %s" % bcdarr)

        return bcdarr

    def get_settings(self):

        _settings = self._memobj.settings

        basic = RadioSettingGroup("basic", "Basic")

        autodial = RadioSettingGroup("autodial", "AutoDial")

        keymaps = RadioSettingGroup("keymaps", "KeyMaps")

        top = RadioSettings(basic, keymaps, autodial)

        rs = RadioSetting(

                "beep", "Beep",

                RadioSettingValueBoolean(_settings.beep))

        basic.append(rs)

        rs = RadioSetting(

                "lock", "Lock",

                RadioSettingValueBoolean(_settings.lock))

        basic.append(rs)

        rs = RadioSetting(

                "ars", "Auto Repeater Shift",

                RadioSettingValueBoolean(_settings.ars))

        basic.append(rs)

        rs = RadioSetting(

                "txpwrsave", "TX Power Save",

                RadioSettingValueBoolean(_settings.txpwrsave))

        basic.append(rs)

        rs = RadioSetting(

                "txnarrow", "TX Narrow",

                RadioSettingValueBoolean(_settings.txnarrow))

        basic.append(rs)

        options = ["Off", "S-3", "S-5", "S-Full"]

        rs = RadioSetting(

                "rfsqlvl", "RF Squelch Level",

                RadioSettingValueList(options, options[_settings.rfsqlvl]))

        basic.append(rs)

        options = ["Off", "Band A", "Band B", "Both"]

        rs = RadioSetting(

                "pttlock", "PTT Lock",

                RadioSettingValueList(options, options[_settings.pttlock]))

        basic.append(rs)

        rs = RadioSetting(

                "cwid_en", "CWID Enable",

                RadioSettingValueBoolean(_settings.cwid_en))

        basic.append(rs)

        cwid = RadioSettingValueString(0, 7, self._decode_cwid(_settings.cwid))

        cwid.set_charset(FT90_CWID_CHARS)

        rs = RadioSetting("cwid", "CWID", cwid)

        basic.append(rs)

        options = ["OFF"] + [str(x) for x in (range(1, 12+1))]

        rs = RadioSetting(

                "apo", "APO time (hrs)",

                RadioSettingValueList(options, options[_settings.apo]))

        basic.append(rs)

        options = ["Off"] + [str(x) for x in (range(1, 60+1))]

        rs = RadioSetting(

                "tot", "Time Out Timer (mins)",

                RadioSettingValueList(options, options[_settings.tot]))

        basic.append(rs)

        options = ["off", "Auto/TX", "Auto", "TX"]

        rs = RadioSetting(

                "fancontrol", "Fan Control",

                RadioSettingValueList(options, options[_settings.fancontrol]))

        basic.append(rs)

        keyopts = ["Scan Up", "Scan Down", "Repeater", "Reverse", "Tone Burst",

                   "Tx Power", "Home Ch", "VFO/MR", "Tone", "Priority"]

        rs = RadioSetting(

                "key_lt", "Left Key",

                RadioSettingValueList(keyopts, keyopts[_settings.key_lt]))

        keymaps.append(rs)

        rs = RadioSetting(

                "key_rt", "Right Key",

                RadioSettingValueList(keyopts, keyopts[_settings.key_rt]))

        keymaps.append(rs)

        rs = RadioSetting(

                "key_p1", "P1 Key",

                RadioSettingValueList(keyopts, keyopts[_settings.key_p1]))

        keymaps.append(rs)

        rs = RadioSetting(

                "key_p2", "P2 Key",

                RadioSettingValueList(keyopts, keyopts[_settings.key_p2]))

        keymaps.append(rs)

        rs = RadioSetting(

                "key_acc", "ACC Key",

                RadioSettingValueList(keyopts, keyopts[_settings.key_acc]))

        keymaps.append(rs)

        options = [str(x) for x in range(0, 12+1)]

        rs = RadioSetting(

                "lcdcontrast", "LCD Contrast",

                RadioSettingValueList(options, options[_settings.lcdcontrast]))

        basic.append(rs)

        options = ["off", "d4", "d3", "d2", "d1"]

        rs = RadioSetting(

                "dimmer", "Dimmer",

                RadioSettingValueList(options, options[_settings.dimmer]))

        basic.append(rs)

        options = ["TRX Normal", "RX Reverse", "TX Reverse", "TRX Reverse"]

        rs = RadioSetting(

                "dcsmode", "DCS Mode",

                RadioSettingValueList(options, options[_settings.dcsmode]))

        basic.append(rs)

        options = ["50 ms", "100 ms"]

        rs = RadioSetting(

                "dtmfspeed", "DTMF Speed",

                RadioSettingValueList(options, options[_settings.dtmfspeed]))

        autodial.append(rs)

        options = ["50 ms", "250 ms", "450 ms", "750 ms", "1 sec"]

        rs = RadioSetting(

                "dtmftxdelay", "DTMF TX Delay",

                RadioSettingValueList(options, options[_settings.dtmftxdelay]))

        autodial.append(rs)

        options = [str(x) for x in range(1, 8 + 1)]

        rs = RadioSetting(

                "dtmf_active", "DTMF Active",

                RadioSettingValueList(options, options[_settings.dtmf_active]))

        autodial.append(rs)

        # setup 8 dtmf autodial entries

        for i in range(1, 9):

            objname = "dtmf" + str(i)

            dtmfsetting = getattr(_settings, objname)

            dtmflen = getattr(_settings, objname + "_len")

            dtmfstr = self._bbcd2dtmf(dtmfsetting, dtmflen)

            dtmf = RadioSettingValueString(0, 16, dtmfstr)

            dtmf.set_charset(FT90_DTMF_CHARS + list(" "))

            rs = RadioSetting(objname, objname.upper(), dtmf)

            autodial.append(rs)

        return top

    def set_settings(self, uisettings):

        _settings = self._memobj.settings

        for element in uisettings:

            if not isinstance(element, RadioSetting):

                self.set_settings(element)

                continue

            if not element.changed():

                continue

            try:

                setting = element.get_name()

                oldval = getattr(_settings, setting)

                newval = element.value

                if setting == "cwid":

                    newval = self._encode_cwid(newval)

                if re.match('dtmf\d', setting):

                    # set dtmf length field and then get bcd dtmf

                    dtmfstrlen = len(str(newval).strip())

                    setattr(_settings, setting + "_len", dtmfstrlen)

                    newval = self._dtmf2bbcd(newval)

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

                setattr(_settings, setting, newval)

            except Exception as e:

                LOG.debug(element.get_name())

                raise