CHIRP

# Copyright 2018 by Rick DeWitt (aa0rd@yahoo.com) V1.0

# Issues 9719 for FTM-6000 and 11137 for FTM-200

# Note: 'TESTME' flags are intended for use with future sub-models

# FTM-100, FTM-300 and FTM-500 can probably be supported

#

# 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/>.

"""FTM-6000 Yaesu Radio Driver"""

from chirp.drivers import yaesu_clone

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

from chirp.settings import RadioSetting, RadioSettingGroup, \

    RadioSettingValueInteger, RadioSettingValueList, \

    RadioSettingValueBoolean, RadioSettingValueString, \

    RadioSettingValueFloat, RadioSettings

import time

import struct

import logging

import math

import sys

LOG = logging.getLogger(__name__)

CMD_ACK = b'\x06'

class Ftm6000RAlias(chirp_common.Alias):

    Vendor = "Yaesu"

    MODEL = "FTM-6000R"

@directory.register

class FTM6000Radio(yaesu_clone.YaesuCloneModeRadio):

    """Yaesu FTM-6000"""

    FTM200 = False

    TESTME = False

    NEEDS_COMPAT_SERIAL = False

    BAUD_RATE = 38400

    COM_BITS = 8

    COM_PRTY = 'N'

    COM_STOP = 1

    MODEL = "FTM-6000"

    NAME_LEN = 6        # Valid Name Length

    ALIASES = [Ftm6000RAlias]

    MODES = ["FM", "AM", "NFM"]

    TMODES = ["", "Tone", "TSQL", "TSQL-R", "DTCS", "Cross"]

    CROSS_MODES = ["->DTCS", "Tone->DTCS", "DTCS->Tone"]

    DUPLEX = ["", "off", "-", "+", "split"]

    T_STEPS = [2.5, 5.0, 6.25, 10.0, 12.5, 15.0, 20.0, 25.0, 50.0, 100.0]

    VALID_BANDS = [(108000000, 137000000),

                   (137000000, 174000000),

                   (174000000, 400000000),

                   (400000000, 480000000),

                   (480000000, 999999999)]

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

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

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

    SKIPS = ["", "S"]

    # No lowercase,{} or ~

    CHARSET = [chr(x) for x in list(range(ord(" "), ord("_") + 1)) +

               [ord("|")]]

    DTMF_CHARS = list("0123456789ABCD*#")

    MEM_FORMAT = """

        struct memdat {         // 16 bytes per chan

          u8 used:1,            // 00

             skip:2,

             unk1:2,

             band:3;

          u8 clks:1,            // 01

             xx:1,

             mode:2,

             duplex:4;

          u24 freq;            // 02-04

          u8 tmode:4,           // 05

             step:4;

          u24 frqtx;            // 06-08

          u8 power:2,           // 09

             rtone:6;

          u8 clktyp:1,          // 0A,

             dtcs:7;

          u8 prfreq;            // 0B

          u16 offset;           // 0C-0D 0-99.95 MHz in 0.5 steps 06.0 is 00 0c

          u8 unk3;              // 0E

          u8 unk4;              // 0F

        };

        struct tag {

          u8 chname[16];

        };

        struct pmgx {

          u8 za;                // 0x00

          u8 fb;                // 0xff

          u16 chnp;             // 0-based pmg channel number

        };

        struct {                // In 1st block

            u8 id[6];

        } model;

        #seekto 0x080;

        struct memdat vfo_air;      // 080

        struct memdat vfo_144;      // 090

        struct memdat vfo_vhf;      // 0a0

        struct memdat vfo_430;      // 0b0

        struct memdat vfo_uhf;      // 0c0

        struct memdat unkc1[5];     // 0d0 - 0110  repeats vfo entries

        u8 120[16];                 // 0x120  all ff

        struct memdat home;         // 0x130

        u8 ff2[64];                 // 0x140 - 0x17f; ff's'

        struct memdat unkc2;        // 0x180 possible last chan accessed?

        #seekto 0x200;

        struct {

            u8 20axd[14];           // 0x200 - 0x20d

            u8 xm0au:5,             // 0x20e

               bell:3;

            u8 xm0bu:6,             // 020f

               lcd:2;

            u8 210xd[14];           // 0210 - 021d

            u8 21ea:5,

               bellb:3;

            u8 wrxdid;              // 21f

            u8 220x1[2];            // 220 -221

            u8 fkp1;                // 0x222: FTM-200 keypad quick access 1

            u8 fhm1;                // 0x223: FTM-200 home qa 1

            u8 fkp2;

            u8 fhm2;

            u8 fkp3;

            u8 fhm3;

            u8 fkp4;

            u8 fhm4;                // 0x229

            u8 22axf[6];

            u8 230x7[8];            // 230-237

            u24 wrxvfrq;

            u8 23b;

            u24 wrxufrq;

            u8 23f;

            u8 240a:6,

               wrxbsel:1,

               240b:1;

            u8 241x7[7];            // 24-247

            u8 csign[10];           // 248 - 251

            u8 pgrcdr1;             // 0252

            u8 pgrcdr2;

            u8 pgrcdt1;

            u8 pgrcdt2;             // 0255

            u8 256a:7,

               compass:1;

            u8 257a:7,

               usbcamsz:1;

            u8 258a:6,

               usbcamql:2;

            u8 259;

            u8 25a;

            u8 25ba:4,

               wrxpop:4;

            u8 25c;

            u8 micgain;             // 25d

            u8 25e;

            u8 micp1;               // 25f

            u8 micp2;               // 260

            u8 micp3;

            u8 micp4;

            u8 263xf[13];           // 0x263 - 026f

            u8 270xf[16];           // 0x270 - 27f

        } micset;

        struct {

            u8 codes[16];            // 0x280-30f

        } dtmfcode[9];

        #seekto 0x400;

        struct {

            u8 400a:7,               // 0400

               aprbupo:1;

            u8 401a:7,

              aprbudi:1;

            u8 402a:6,

               aprbusp:2;

            u8 403a:7,              // 0403

               aprbual:1;

            u8 404a:5,

               aprbubo:3;

            u8 405a:7,

               aprbutp:1;

            u8 406a:7,

               aprburn:1;

            u8 407a:5,

               aprbuwd:3;

            u8 aprcsgn[6];          // 0408-040d

            u8 aprcsfx;

            u8 400f;

            u8 410a:3,

              aprltns:1,

              410b:4;

            u8 aprlad;              // 0411

            u8 aprlam;

            u16 aprlas;             // 0413-0414

            u8 415a:3,

               aprlgew:1,

               415b:4;

            u8 aprlgd;

            u8 aprlgm;

            u16 aprlgs;

            u8 aprrcsn[6];          // 041a-41f

            u8 aprrcfx;             // 0420

            u8 421;

            u8 aprsym1[2];          // 0422, 423

            u8 aprsym2[2];

            u8 aprsym3[2];

            u8 aprsym4a;

            u8 aprsym4b;            // 0429

            u16 aprbfrl;            // 042a & 042b

            u8 42ca:4,

               aprsym:4;

            u8 42da:4,              // 042d

               aprdig:4;

            u8 42ea:4,

               aprstxi:4;

            u8 aprsrate;            // 042f

            u8 aprslow;             // 0430

            u8 431a:5,

               aprbamb:3;

            u8 432a:4,

               aprcmt:4;

            u8 aprspro:1,           // 0433

               aprbaut:1,

               433b:1,

               aprsdcy:1,

               aprspdc:1,

               aprsalt:1,

               433c:1,

               aprrply:1;

            u8 434a:1,              // 0434

               dspda:1,             // FTM-200 APRS

               pktspd:1,            // Both

               434b:3,

               aprmut:1,

               aprson:1;

            u8 435a:2,

               datsql:1,

               435b:5;

            u8 436a:5,

               bcnstat:3;

            u8 437a:4,            // 0x437

               bcntxra:4;

            u8 438a:1,

               aprbfot:1,

               aprbfst:1,

               aprbfit:1,

               aprbfob:1,

               aprbfwx:1,

               aprbfpo:1,

               aprbfme:1;

            u8 439a:7,

               aprbrtb:1;

            u8 43aa:7,

               aprbrtm:1;

            u8 43ba:7,

               aprbrrb:1;

            u8 43ca:7,

               aprbrrm:1;

            u8 43da:7,

               aprbrmp:1;

            u8 43ea:7,

               aprbrcr:1;

            u8 aprbrrr;             // 043f

            u8 440a:7,

               aprbrmv:1;

            u8 441a:7,

               aprmpos:1;

            u8 442;

            u8 443a:4,

               dbsela:4;

            u8 444a:4,

               dbseld:4;

            u8 aprpopb;              // 0445

            u8 aprpopm;

            u8 447a:4,

               aprtxd:4;

            u8 448a:4,

               comout:4;

            u8 449a:4,

               comspd:4;

            u8 44aa:5,

               bcnsmart:3;

            u8 typ1val0;            // 044b -> 045f

            u8 typ1val1;            // Smart Beaconing type settings

            u8 typ1val2;

            u8 typ1val3;

            u8 typ1val4;

            u8 typ1val5;

            u8 typ1val6;

            u8 typ2val0;

            u8 typ2val1;

            u8 typ2val2;

            u8 typ2val3;

            u8 typ2val4;

            u8 typ2val5;

            u8 typ2val6;

            u8 typ3val0;

            u8 typ3val1;

            u8 typ3val2;

            u8 typ3val3;

            u8 typ3val4;

            u8 typ3val5;

            u8 typ3val6;        // 045f

            u8 460a:4,

               aprstxn:4;

            u8 461a:1,

               aprmpkt:1,

               aprbfan:1,

               461b:5;

            u8 462a:4,

               comwpf:4;

            u8 463a:4,

                comflt:4;

            u8 464;

            u8 465;

            u8 466;

            u8 467;

            u8 468;

            u8 469;

            u8 46a;

            u8 46b;

            u8 46c;

            u8 46da:5,

               aprvlrt:3;

            u8 aprtsql;

            u8 aprvdcs;             // 046f

            u8 470a:6,

               aprsfs:2;

            u8 471a:4,

               aprsff:4;

            u8 472xf[14];           // -> 047f

            u8 aprrtxt[64];         // 0480 - 04BF

        } wierd;

        #seekto 0x500;

        struct {

            u8 grp1[9];

            u8 509;

            u8 grp2[9];

            u8 514;

            u8 grp3[9];

            u8 51d;

            u8 grp4[9];

            u8 527;

            u8 grp5[9];

            u8 532;

            u8 grp6[9];

            u8 53b;

            u8 blt1[9];

            u8 545;

            u8 blt2[9];

            u8 554;

            u8 blt3[9];

            u8 559;

        } aprsmsg;

        #seekto 0x580;

        struct {          // FMT-6000 Menu item Fntcn mode set table

            u8 shbyt;     // FTM-200 Digipath, RingerCS data

        } share1[256];    // -> 0x67f

        struct {            // 0x680

            u8 txt1[16];

            u8 txt2[16];

            u8 txt3[16];

            u8 txt4[16];

            u8 txt5[16];

            u8 txt6[16];

            u8 txt7[16];

            u8 txt8[16];

        } aprstxt;

        struct memdat main[999];    // 0x700 16 bytes each, up to 4570

        struct memdat pms[100];     // up to 0x4bb0

        struct memdat unkc3[5];     // unknown, up to 0x4c00

        #seekto 0x4c10;

        struct pmgx pmg[6];         // 6th element is change record

        #seekto 0x6980;

        struct {                    // WIRES-X Messages

            u8 msg01[128];

            u8 msg02[128];

            u8 msg03[128];

            u8 msg04[128];

            u8 msg05[128];

            u8 msg06[128];

            u8 msg07[128];

            u8 msg08[128];

            u8 msg09[128];

            u8 msg10[128];

        } wrxmsg;

        struct {                    // 0x6e80

            u8 c1[16];

            u8 c2[16];

            u8 c3[16];

            u8 c4[16];

            u8 c5[16];

        } wrxcat;

        #seekto 0x7d00;

        struct {                    // --> 07e3f

            u8 msg[60];

            u8 mode;

            u8 nax[3];

        } bcntxt[5];

        #seekto 0xff00;

        struct tag names[999];      // 16 bytes each, up to 0x13d6f (83055.)

        struct tag pms_name[100];   // 13d70 - 143af

        #seekto 0x17f00;

        struct {                    // Settings

            u8 f00xf[16];           // 17f00-0f

            u8 f10xf[16];           // 17f10-1f

            u8 f20;                 // 17f20

            u8 f21a:7,

               unit:1;

            u8 f22;

            u8 f23;

            u8 f24a:2,              // 17f24

                apo:5,

                apo1:1;

            u8 bclo:1,              // 17f25

                f25a:4,

                arts_int:1,

                arts_mode:2;

            u8 f26:4,              // 17f26

                airb:1,

                vhfb:1,

                uhfb:1,

                otrb:1;

            u8 f27;

            u8 tzone;

            u8 f29a:6,

               fvsvol:2;

            u8 f2au:4,              // 17f2a

               tot:4;

            u8 f2b;

            u8 f2c;

            u8 f2d:6,

               dspmode:2;

            u8 f2ea:6,

               fvsanc:2;

            u8 f2fa:6,              // 17f2f

               gpsdtm:1,

               f2fb:1;

            u8 lastmnu;             // 17f30

            u8 f31;                 // 17f31

            u8 f1key;               // 17f32

            u8 f33;

            u8 f34;

            u8 f35a:4,

               gpslog:4;

            u8 f36a:6,

               voxsen:2;            // FTM-200

            u8 f37a:5,

               voxdly:3;

            u8 f38a:6,              // 17f38

               audrec:2;

            u8 lastfunc;            // 17f39

            u8 f3a:6,               // 17f3a

               lcd_clr:2;

            u8 f3bxf[5];            // 17f3b-3f

            u8 f40x2[3];            // 7f40-42

            u8 a_chan;              // FTM-200 17f43

            u8 f44;

            u8 f45u:5,              // 17f45

               scnrsm:3;

            u8 f46;

            u8 f47;

            u8 f48u:4,              // 17f48

                sql:4;

            u8 f49:4,

                scnrsm2a:4;         // FTM-200 A

            u8 f4a;                 // 17f4a

            u8 f4ba:4,

               scndria:4;

            u8 f4c;

            u8 f4d;

            u8 f4e;

            u8 f4f;

            u8 f50x2[3];            // 17f50-52

            u8 b_chan;              // FTM-200 17f53

            u8 f54;

            u8 f55;

            u8 f56;

            u8 f57;

            u8 f58;

            u8 f59:4,

               scnrsm2b:4;         // FTM-200 B

            u8 f5a;                // 17f5a

            u8 f5ba:4,

               scndrib:4;

            u8 f5c;

            u8 f5d;

            u8 f5e;

            u8 f5f;

            u8 f60;                 // 17f60

            u8 f61;

            u8 scndrm1:1,           // 17f62

               wxalrt:1,

               f62b:5,

               dwrvt:1;

            u8 f63a:7,              // 17f63

               sqlexp1:1;

            u8 f64a:5,              // 17f64

               rpt_ars:1,

               f64b:2;

            u8 f65a:2,

               bscope:1,

               f65b:5;

            u8 f66;

            u8 f67;

            u8 f68a:3,

               wrxstb:1,

               f68b:1,

               locinfo:1,

               wrxdvw:1,

               f68c:1;

            u8 f69;

            u8 f6aa:4,

               audmic:1,

               f6ab:2,

               btsave:1;

            u8 wrxloc:1,            // 17f6b

               fvslan:1,

               f6bb:2,

               beep1:1,            // Stupid split beep: this is Off/Low

               fvsrxm:1,

               f6bc:2;

            u8 gpsdev:1,            // 17f6c

               memlist:1,

               wrxrng:1,

               wrxrwf:1,

               wrxsrch:1,

               f6cb:2,

               scndrm2:1;

            u8 bskpax:3,           // 17f6d

               bskpa0:1,

               bskpa4:1,

               bskpa3:1,

               bskpa2:1,

               bskpa1:1;

            u8 f6e;

            u8 f6f;

            u8 f70;                // 17f70

            u8 f71;

            u8 f72a:7,

               dwrvtb:1;

            u8 f73a:7,

               sqlexp2:1;

            u8 f74a:5,

               rpt_arsb:1,

               f74b:2;

            u8 f75a:2,

                bscopeb:1,

                f75b:5;

            u8 f76;

            u8 f77;

            u8 f78a:5,              // 17f78

               dtmf_auto:1,

               bton:1,

               btaud:1;

            u8 f79a:3,              // 17f79

               timefmt:1,

               datefmt:4;

            u8 f7aa:3,

               beep2:1,             // Split beep: High

               f7ab:3,

               fvsrec:1;

            u8 f7ba:6,

               wrxams:2;

            u8 f7c;

            u8 bskpbx:3,           // 17f7d

               bskpb0:1,

               bskpb4:1,

               bskpb3:1,

               bskpb2:1,

               bskpb1:1;

            u8 f7e;

            u8 f7f;

            u8 f80[16];             // 17f80

            u8 f90[16];             // 17f90

            u8 fA0[16];             // 17fA0

            u8 fB0[16];             // 17fB0

            u8 FC0[16];             // 17fC0

            u8 FD0[16];             // 17fD0

            u8 FE0[16];             // 17fE0

            u8 FF0[16];             // 17fF0

        } setts;

    """

    @classmethod

    def get_prompts(cls):

        rp = chirp_common.RadioPrompts()

        rp.info = (

            "The duplex setting 'split' allows for non-standard offsets "

            "by configuring both a\n"

            "receive and transmit frequency. Set the receive frequency, "

            "then the duplex mode,\n"

            "then the desired transmit frequency as the offset.\n"

            "The offset value of a split channel is the transmit frequency, "

            "and can be modified.\n"

            "PMS (Programmable Memory Channel Scan) pairs are displayed "

            "as memory channels 1000-1099.\n"

            "The Clock Shift Function can be set in the Properties "

            "> Extra tab.\n"

            "The radio special tone modes (REV, PR, PAGER) can also be set "

            "in the Properties > Extra tab,\n"

            "but will be displayed as Tone in CHIRP.")

        if cls.FTM200:

            rp.pre_download = (

                "(OK then TX)\n"

                "With the USB cable connected to the radio rear data port, "

                "and the radio powered off-\n"

                "1. Long-Press F-Menu.\n"

                "2. Rotate the dial knob to menu 116: 'This -> Other'.\n"

                "3. Press the dial knob.\n"

                "4. Rotate to select OK, but don't press yet.\n"

                "5. Press the OK button below.\n"

                "6. Press the dial knob to begin sending data.\n"

                "7. Wait for Complete.\n")

            rp.pre_upload = (

                "(Rx then OK)\n"

                "With the USB cable connected to the radio rear data port, "

                "and the radio powered off-\n"

                "1. Long-Press F-Menu.\n"

                "2. Rotate the dial knob to menu 117: 'Other -> This'.\n"

                "3. Press the dial knob.\n"

                "4. Rotate to select OK, and press the knob.\n"

                "5. Press the OK button below.\n"

                "6. Wait for Complete.\n")

        else:

            rp.pre_download = (

                "(OK then TX)\n"

                "With the USB cable connected to the radio rear data port, "

                "and the radio powered off-\n"

                "1. Press both the power ON and F1 keys.\n"

                "2. Press the dial knob.\n"

                "3. Rotate the dial to show CLN TX.\n"

                "4. Press the OK button below/\n"

                "5. Press the dial knob to begin sending data.\n"

                "6. Wait for Complete.\n"

                "7. Long-press the power On button to leave the clone mode.")

            rp.pre_upload = (

                "(Rx then OK)\n"

                "With the USB cable connected to the radio rear data port, "

                "and the radio powered off-\n"

                "1. Press both the power ON and F1 keys.\n"

                "2. Press the dial knob, CLN RX is displayed.\n"

                "3. Press the dial knob again to put the radio in the "

                "receiving state.\n"

                "4. Press the OK button below.\n"

                "5. Wait for Complete.\n"

                "6. Long-press the power On button to leave the clone mode.")

        return rp

    def _read(self, blck, blsz):

        # be very patient at first block

        if blck == 0:

            attempts = 60

        else:

            attempts = 5

        for _i in range(0, attempts):

            data = self.pipe.read(blsz)

            if data:

                break

            time.sleep(0.5)

        if len(data) == blsz:

            LOG.debug("Received block %s, sub %s" % (hex(data[0]),

                      hex(data[1])))

            checksum = data[blsz - 1]

            cs = 0

            for i in data[:-1]:

                cs = (cs + i) % 256

            if cs != checksum:

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

                                (checksum, cs, blck))

            # Remove the 2-byte block header and checksum

            data = data[2:blsz - 1]

        else:

            raise Exception("Unable to read block %i expected %i got %i"

                            % (blck, blsz, len(data)))

        return data

    def _clone_in(self):

        # Be very patient with the radio

        self.pipe.timeout = 2

        self.pipe.baudrate = self.BAUD_RATE

        self.pipe.bytesize = self.COM_BITS

        self.pipe.parity = self.COM_PRTY

        self.pipe.stopbits = self.COM_STOP

        self.pipe.rtscts = False

        data = b""

        status = chirp_common.Status()

        status.msg = "Cloning from radio"

        nblocks = 768

        status.max = nblocks - 1

        blksz = 131

        for block in range(0, nblocks):     # SPS - reads to nblocks-1

            LOG.debug("Reading packet %d" % block)

            data += self._read(block, blksz)

            self.pipe.write(CMD_ACK)

            status.cur = block

            self.status_fn(status)

        return memmap.MemoryMapBytes(data)

    def _write(self, nblk, nsub, pntr, bksz, zblk):

        LOG.debug("Block %02X %02X" % (nblk, nsub))

        if self.TESTME:

            LOG.warning("Block %02X %02X" % (nblk, nsub))

        data = struct.pack('B', nblk)

        data += struct.pack('B', nsub)

        if zblk:

            blkdat = bytearray(bksz)    # All Zeros

        else:

            blkdat = self.get_mmap()[pntr:pntr + bksz]

        data += blkdat

        cs = 0

        for i in data:

            cs = (cs + i) % 256

        LOG.debug("Checksum %s" % hex(cs))

        if self.TESTME:

            LOG.warning("Checksum %s" % hex(cs))

        data += struct.pack('B', cs)

        LOG.debug("Writing %d bytes:\n%s" % (len(data),

                                             util.hexprint(data)))

        if self.TESTME:      # Dont send data yet

            LOG.warning("Writing %d bytes:\n%s" % (len(data),

                                                   util.hexprint(data)))

            buf = CMD_ACK

        else:

            self.pipe.write(data)

            buf = self.pipe.read(1)

        if not buf or buf[:1] != CMD_ACK:

            time.sleep(0.5)

            buf = self.pipe.read(1)

        if not buf or buf[:1] != CMD_ACK:

            return False

        return True

    def _clone_out(self):

        self.pipe.baudrate = self.BAUD_RATE

        self.pipe.bytesize = self.COM_BITS

        self.pipe.parity = self.COM_PRTY

        self.pipe.stopbits = self.COM_STOP

        self.pipe.rtscts = False

        status = chirp_common.Status()

        status.msg = "Cloning to radio"

        blksz = 128     # actual data; excluding block, sub, checksum

        pkt = 0

        pos = 0

        block = 0

        wrtzero = False        # Special last block flag

        nblocks = 767          # last block number

        status.max = nblocks - 2

        # This sucker took FOREVER to figure out the repeating block

        # + sub-block + special EoD numbering!

        while pkt <= nblocks:

            LOG.debug("Writing packet #: %d." % pkt)

            if self.TESTME:

                LOG.warning("Writing packet #: %d , pos %x." % (pkt, pos))

            time.sleep(0.01)

            sub2 = True

            sublk = 0

            if pkt == 0:

                block = pkt

                sub2 = False

            elif pkt == 1:

                block = pkt

            elif pkt == 7:          # Block 04 00 is skipped !!??

                block = 0x04

                sublk = 0x80

                sub2 = False        # block increments to 05 00

            elif pkt == 510:        # Reset to block 0

                block = 0

            elif pkt == 766:

                block = 0xff

                sublk = 0xfd

                sub2 = False

            elif pkt == 767:

                block = 0xff

                sublk = 0xfe

                sub2 = False

                # pkt 767, block ff fe must be all zeros!!???

                wrtzero = True

            rslt = self._write(block, sublk, pos, blksz, wrtzero)

            if rslt and sub2:       # write same block, new sublk

                sublk = 0x80

                pkt += 1

                pos += blksz

                LOG.debug("Writing packet #: %.d" % pkt)

                if self.TESTME:

                    LOG.warning("Writing packet #: %d , pos %x." % (pkt, pos))

                rslt = self._write(block, sublk, pos, blksz, wrtzero)

            if not rslt:

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

                                (block, sublk))

            pos += blksz

            block += 1

            pkt += 1

            status.cur = pkt

            self.status_fn(status)

        return

    def sync_in(self):

        try:

            self._mmap = self._clone_in()

        except errors.RadioError:

            raise

        except Exception as e:

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

                                    % e)

        self.process_mmap()

    def sync_out(self):

        try:

            self._clone_out()

        except errors.RadioError:

            raise

        except Exception as e:

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

                                    % e)

    def process_mmap(self):

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

    def get_features(self):

        rf = chirp_common.RadioFeatures()

        rf.has_dtcs_polarity = False

        rf.has_bank = False

        rf.has_dtcs = True

        rf.has_cross = True

        rf.has_tuning_step = True

        rf.has_ctone = False                    # Common Tones

        rf.has_rx_dtcs = False                  # Common codes

        rf.has_settings = True

        rf.can_odd_split = True

        rf.valid_modes = [x for x in self.MODES if x in chirp_common.MODES]

        rf.valid_tmodes = self.TMODES

        rf.valid_cross_modes = self.CROSS_MODES

        rf.valid_duplexes = self.DUPLEX

        rf.valid_tuning_steps = self.T_STEPS

        rf.valid_bands = self.VALID_BANDS

        rf.valid_power_levels = self.POWER_LEVELS

        rf.valid_characters = "".join(self.CHARSET)

        rf.valid_name_length = self.NAME_LEN

        rf.memory_bounds = (1, 1099)

        rf.valid_skips = self.SKIPS

        return rf

    def get_raw_memory(self, number):

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

    def validate_memory(self, mem):

        msgs = yaesu_clone.YaesuCloneModeRadio.validate_memory(self, mem)

        return msgs

    def filter_name(self, namsx):

        """Name must be <= NAME_LEN and contain only CHARSET chars"""

        tx = namsx.strip()

        sx = ""

        if self.FTM200 is False:

            tx = tx.upper()

        for i in range(0, len(tx)):

            if i >= self.NAME_LEN:

                break

            if tx[i] in self.CHARSET:

                sx += tx[i]

            else:

                sx = "?"

        return sx

    def _freqdcode(self, frqb):

        """Decode .0025 Mhz upper 2 MSB of freq"""

        # frqb is u24: 2bits suffix, 22 bits bcd

        sx = "%06X" % frqb

        v0 = int(sx[0], 16) * 625

        v1 = int(sx[1])     # 100 Mhz

        v2 = int(sx[2:4])   # 10 Mhz

        v3 = int(sx[4:])    # 100 Khz

        vx = (v1 * 10000) + (v2 * 100) + v3

        vx = vx * 10000 + v0

        return vx

    def _freqncode(self, frq):

        """Encode .0625 Mhz in upper MSB of u24 bcd freq"""

        v0 = frq % 10000    # .025 value

        bx = v0 // 625

        bx = bx * 0x100000

        vx = int((frq - v0) / 10000)

        sx = "%06d" % vx    # Ex: 012345 for frq = 123.45 MHz

        v1 = int("0x" + sx[0:2], 16)

        v2 = int("0x" + sx[2:4], 16)

        v3 = int("0x" + sx[4:], 16)

        frqb = bx + v1 * 0x10000 + v2 * 0x100 + v3

        return frqb

    def _b2s(self, bary, term=0xff):

        """Convert byte array into string """

        strx = ""

        for i in bary:

            if i == term:

                break

            strx += chr(i)

        return strx

    def _s2b(self, setting, obj, atrb, mxk, pad=0xff, upc=True):

        """Callback: Convert string to byte array, pad to mxk chars"""

        sx = str(setting.value)

        sx = sx.strip()

        if upc:

            sx = sx.upper()

        ary = b""

        v1 = len(sx)

        for vx in range(0, mxk):

            if vx < v1:

                ary += bytes(sx[vx], 'utf-8')

            else:

                ary += pad.to_bytes(1, sys.byteorder)

        setattr(obj, atrb, ary)

        return

    def _c2u8(self, setting, obj, atrb):

        """Callback: Convert single char string to u8"""

        b0 = str(setting.value)

        vx = ord(b0)

        setattr(obj, atrb, vx)

        return

    def get_memory(self, number):

        mem = chirp_common.Memory()

        if number < 1000:      # channel memory

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

            _tag = self._memobj.names[number - 1]

        else:

            _mem = self._memobj.pms[number - 1000]

            _tag = self._memobj.pms_name[number - 1000]

        mem.number = number

        if mem.number == 1:

            mem.immutable += ["empty"]

        if not _mem.used:

            mem.empty = True

            return mem

        mem.freq = self._freqdcode(_mem.freq)

        mem.rtone = chirp_common.TONES[_mem.rtone]

        mem.mode = self.MODES[_mem.mode]

        mem.duplex = self.DUPLEX[_mem.duplex]

        if (_mem.duplex == 4):          # Split mode

            mem.offset = self._freqdcode(_mem.frqtx)

        else:

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

        # Re-map funky radio tone and cross-modes

        tmd = _mem.tmode   # 0,1,2

        cmx = 0

        if _mem.tmode == 3:     # DCS

            tmd = 5             # Cross

            cmx = 0             # -> DTCS

        if _mem.tmode == 4:     # Rev Tone

            tmd = 3             # TSQL-R

        if _mem.tmode == 5:     # PR Freq

            tmd = 1

        if _mem.tmode == 6:     # Pager

            tmd = 1

        if _mem.tmode == 7:     # Tx DTCS, Open RX

            tmd = 4             # DTCS

        elif _mem.tmode == 8:   # Tone - DCS

            tmd = 5             # Cross

            cmx = 1             # Tone -> DTCS

        elif _mem.tmode == 9:   # D CD-> Tone

            tmd = 5             # Cross

            cmx = 2             # DTCS->Tone

        mem.tmode = self.TMODES[tmd]

        mem.cross_mode = self.CROSS_MODES[cmx]

        mem.skip = self.SKIPS[_mem.skip]

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

        vx = _mem.power

        mem.power = self.POWER_LEVELS[vx]

        mem.tuning_step = self.T_STEPS[_mem.step]

        tx = self._b2s(_tag.chname, 0xff).strip()

        if self.FTM200 is False:

            tx = tx.upper()

        mem.name = tx

        # Echo name string back into memory.

        # In case it got loaded flakey in radio; trailing spaces

        for i in range(0, self.NAME_LEN):