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 import chirp_common, bitwise, memmap, directory, errors, util, yaesu_clone

from chirp.settings import RadioSetting, RadioSettingGroup, \

    RadioSettingValueInteger, RadioSettingValueList, \

    RadioSettingValueBoolean, RadioSettingValueString

import time, os, traceback, string, re

from textwrap import dedent

if os.getenv("CHIRP_DEBUG"):

    CHIRP_DEBUG = True

else:

    CHIRP_DEBUG=False

CMD_ACK = chr(0x06)

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

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

FT90_TMODES = ["", "Tone", "TSQL", "", "DTCS"] # idx 3 (Bell) not supported yet

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.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 = "\x8E\xF6"

    _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)."""))

        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] == chr(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.setTimeout(4)

        start = time.time()

        data = ""

        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)

        print "Clone completed in %i seconds, blocks read: %i" % (time.time() - start, blocknum)

        return memmap.MemoryMap(data)

    def _clone_out(self):

        looppredelay = 0.4

        looppostdelay = 1.9

        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 = chr(blocknum)

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

            checksumbyte = chr(checksum.get_calculated(self.get_mmap()))

            if CHIRP_DEBUG:

                print "Block %i - will send from %i to %i byte " % \

                    (blocknum, pos, pos + blocksize)

                print util.hexprint(blocknumbyte)

                print util.hexprint(payloadbytes)

                print 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

            if CHIRP_DEBUG:

                print "bytes echoed: "

                print util.hexprint(tmp)

            # radio is slow to write/ack:

            time.sleep(looppostdelay) 

            buf = self.pipe.read(1)

            if CHIRP_DEBUG:

                print "ack recd:"

                print 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)

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

    def sync_in(self):

        try:

            self._mmap = self._clone_in()

        except errors.RadioError:

            raise

        except Exception, 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, 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 = ""

        if CHIRP_DEBUG:

            print "@ +_decode_cwid:"

        for byte in cwidarr.get_value():

            char = int(byte)

            if CHIRP_DEBUG:

                print 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 = ""

        if CHIRP_DEBUG:

            print "@ _encode_cwid:"

        for char in cwidarr.get_value():

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

        if CHIRP_DEBUG:

            print cwid

        return cwid

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

        # doing bbcd, but with support for ABCD*#

        if CHIRP_DEBUG:

            print bcdarr.get_value()

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

        if CHIRP_DEBUG:

            print "@_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))

        if CHIRP_DEBUG:

            print "@_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 = RadioSettingGroup("top", "All Settings", 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"] + map(str, range(1, 12+1))

        rs = RadioSetting("apo", "APO time (hrs)",

                          RadioSettingValueList(options,

                                        options[_settings.apo]))

        basic.append(rs)

        options = ["Off"] + map(str, 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 = map(str, 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 = map(str,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 map(str, range(1,9)):

            objname = "dtmf" + 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)

                if CHIRP_DEBUG:

                    print "Setting %s(%s) <= %s" % (setting,

                                    oldval, newval)

                setattr(_settings, setting, newval)

            except Exception, e:

                print element.get_name()

                raise