CHIRP

# Copyright 2013 Dan Smith <dsmith@danplanet.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/>.

import os

import struct

import time

from chirp import bitwise

from chirp import chirp_common

from chirp import directory

from chirp import errors

from chirp import memmap

from chirp import util

"""

 Description: Chirp Data Structure of the Memory Map for TYT TH-9000/VHF 2Meter 144-148Mhz Radio

 Version: 0.6

 Date: 9/28/2013

 Status: Imcomplete

    - This is the initial, incomplete version of the channel data structure. 

    - The memory map looks a lot like the Anytone 5888 model, however, these does appear to be significant differences.

Overall Memory Map:

    Memory Map (Range 0x0100-3FF0, step 0x10):

        Field                   Start  End  Size   

                                (hex)  (hex) (hex)  

        1 Channel Set Flag        0100  011F   20 

        2 Channel Skip Flag       0120  013F   20 

        3 Blank/Unknown           0140  01EF   B0 

        4 Unknown                 01F0  01FF   10

        5 TX/RX Range             0200  020F   10    

        6 Bootup Passwd           0210  021F   10 

        7 Options, Radio          0220  023F   20

        8 Unknown                 0240  019F   

        9 Channel Bank            2000  38FF 1900  

             Channel 000          2000  201F   20  

             Channel 001          2020  202F   20  

             ... 

             Channel 199          38E0  38FF   20 

        10 Blank/Unknown          3900  3FFF  6FF  14592  16383    1792   

            Total Map Size           16128 (2^8 = 16384)

   Protocol for Upload Sequence, Only Writes shown:

   1) Start 

      "Program"                   50 52 4F 47 52 41 4D

      0x02                        02

      "R\0x01\0x40\x10"           52 01 40 10  (?means "Read" address 1040, 16 bytes, but doesn't match write data field) 

   2) Write Records, Loop from address 0100 to 3900, step 0x10

     "W"<address><length><data><checksum>"\0x06"   57 .. .. 10 ..(*16)  .. 06  (write record of 16 bytes)  

       header[4 bytes]:

         command[1] = Write ("W")

         address[2] = 0100 to 3900

         length[1] = 0x10 (16 bytes length)

       data[16 bytes]:

         data[16] = 16 byte payload

       end[2 bytes]:

         checksum[1] = 1 byte,  uses digit check checksum ( sum of header and data bytes, modulo 256)

         end of record[1] = 0x06 (ascii ACK char)

   3) END

     "END"   45 4E 44

"""

"""

  TH9000/VHF  memory map 

  section: 1 and 2:  Channel Set/Skip Flags

    Channel Set (starts 0x100) : Channel Set  bit is value 0 if a memory location in the channel bank is active.

    Channel Skip (starts 0x120): Channel Skip bit is value 0 if a memory location in the channel bank is active.

    Both flag maps are a total 24 bytes in length, aligned on 32 byte records.

    bit = 0 channel set/no skip,  1 is channel not set/skip

    to index a channel:

        cbyte = channel / 8 ;

        cbit  = channel % 8 ;

        setflag  = csetflag[cbyte].c[cbit] ;

        skipflag = cskipflag[cbyte].c[cbit] ;

    channel range is 0-199, range is 32 bytes (last 7 unknown)

"""

mem_format = """

#seekto 0x0100;

struct {

   bit c[8];

} csetflag[24];

struct {

   u8 unknown0100[7] ;

}

#seekto 0x0120

struct {

   bit c[8];

} cskipflag[24] ;

struct {

   u8 unknown0120[7] ;

}

"""

"""

  TH9000/VHF  memory map 

  section: 5  TX/RX Range

     used to set the TX/RX range of the radio (e.g.  144-148Mhz for 2 meter)

     possible to set range to 136-172Mhz for tx/rx 

"""

mem_format = """

#seekto 0x0200;

struct {

    bbcd txrangelow[4];

    bbcd txrangehi[4];

    bbcd rxrangelow[4];

    bbcd rxrangehi[4];

}

"""

"""

  TH9000/VHF  memory map 

  section: 6  bootup_passwd

     used to set bootup passwd (see boot_passwd checkbox option)

  options - bootup password

  bytes:bit   type                 description

  ---------------------------------------------------------------------------

  6         u8 bootup_passwd[6]     bootup passwd, 6 chars, numberic chars 30-39 , see boot_passwd checkbox to set

  10        u8 unknown;  

"""

mem_format = mem_format + """

#seekto 0x0210

struct {

   u8 bootup_passwd[6];

   u8 unknown2010[10];

};

"""

"""

  TH9000/VHF  memory map 

  section: 7  Radio Options  

        used to set a number of radio options 

  bytes:bit   type                 description

  ---------------------------------------------------------------------------

  1         u8 display_mode     display mode, range 0-2, 0=freq,1=channel,2=name (selecting name affects vfo_mr)

  1         u8 vfo_mr;          vfo_mr , 0=vfo, mr=1 

  1         u8 unknown;  

  1         u8 squelch;         squelch level, range 0-19, hex for menu

  1         u8 unknown[2]; 

  1         u8 channel_lock;    if display_mode[channel] selected, then lock=1,no lock =0

  1         u8 unknown; 

  1         u8 bg_brightness ;  background brightness, range 0-21, hex, menu index 

  1         u8 unknown;     

  1         u8 bg_color ;       bg color, menu index,  blue 0 , orange 1, purple 2

  1         u8 tbst_freq ;      tbst freq , menu 0 = 1750Hz, 1=2100 , 2=1000 , 3=1450hz 

  1         u8 timeout_timer;   timeout timer, hex, value = minutes, 0= no timeout

  1         u8 unknown; 

  1         u8 auto_power_off;   auto power off, range 0-3, off,30min, 1hr, 2hr, hex menu index

  1         u8 voice_prompt;     voice prompt, value 0,1 , Beep ON = 1, Beep Off = 2

"""

mem_format = mem_format + """

#seekto 0x0220

struct {

   u8 display_mode; 

   u8 vfo_mr; 

   u8 unknown0220A; 

   u8 squelch; 

   u8 unknown0220B[2]; 

   u8 channel_lock; 

   u8 unknown0220C; 

   u8 bg_brightness; 

   u8 unknown0220D; 

   u8 bg_color;

   u8 tbst_freq;

   u8 timeout_timer;

   u8 unknown0220E;

   u8 auto_power_off;

   u8 voice_prompt; 

};

"""

"""

  description of function setup options, starting at 0x0230

  bytes:bit   type                 description

  ---------------------------------------------------------------------------

  1         u8  // 0

   :4       unknown:6

   :1       elim_sql_tail:1   eliminate squelsh tail when no ctcss checkbox (1=checked)

   :1       sql_key_function  "squelch off" 1 , "squelch momentary off" 0 , menu index

  2         u8 unknown[2] /1-2  

  1         u8 // 3

   :4       unknown:4

   :1       inhibit_init_ops:1 //bit 5

   :1       unknownD:1

   :1       inhibit_setup_bg_chk:1 //bit 7

   :1       unknown:1

  1         u8 tail_elim_type    menu , (off=0,120=1,180=2),  // 4

  1         u8 choose_tx_power    menu , (60w=0,25w=1) // 5

  2         u8 unknown[2]; // 6-7 

  1         u8 bootup_passwd_flag  checkbox 1=on, 0=off // 8

  7         u8 unknown[7]; // 9-F 

"""

mem_format = mem_format + """

#seekto 0x0230

struct {

   u8 unknown0230A:6,

      elim_sql_tail:1,

      sql_key_function:1;

   u8 unknown0230B[2];

   u8 unknown0230C:4, 

      inhibit_init_ops:1,

      unknown0230D:1,

      inhibit_setup_bg_chk,

      unknown0230E:1;

   u8 tail_elim_type;

   u8 choose_tx_power;

   u8 unknown0230F[2];

   u8 bootup_passwd_flag;

   u8 unknown0230G[7];

};

"""

"""

  TH9000/VHF  memory map 

  section: 9  Channel Bank

         description of channel bank (200 channels , range 0-199)

         Each 32 Byte (0x20 hex)  record:

  bytes:bit   type                 description

  ---------------------------------------------------------------------------

  4         bbcd freq[4]        receive frequency in packed binary coded decimal  

  4         bbcd offset[4]      transmit offset in packed binary coded decimal (note: plus/minus direction set by 'duplex' field)

  1         u8

   :4       unknown:4

   :4       tune_step:4         tuning step, menu index value from 0-9

  1         u8

   :4       unknown:4          not yet decoded, used for DCS coding?

   :2       channel_width:2     channel spacing, menu index value from 0-3

   :1       reverse:1           reverse flag, 0=off, 1=on (reverses tx and rx freqs)

   :1       txoff:1             transmitt off flag, 0=transmit , 1=do not transmit 

  1         u8

   :1       talkaround:1        talkaround flag, 0=off, 1=on (bypasses repeater) 

   :1       compander:1         compander flag, 0=off, 1=on (turns on/off voice compander option)  

   :2       unknown:2          

   :2       power:2             tx power setting, value range 0-2, 0=hi,1=med,2=lo 

   :2       duplex:2            duplex settings, 0=simplex,1= minus(-) offset, 2= plus (+) offset (see offset field) 

  1         u8 

   :4       unknown:4

   :2       rxtmode:2           rx tone mode, value range 0-2, 0=none, 1=CTCSS, 2=DCS  (ctcss tone in field rxtone)

   :2       txtmode:2           tx tone mode, value range 0-2, 0=none, 1=CTCSS, 3=DCS  (ctcss tone in field txtone)

  1         u8 

   :2       unknown:2

   :6       txtone:6            tx ctcss tone, menu index

  1         u8 

   :2       unknown:2 

   :6       rxtone:6            rx ctcss tone, menu index

  1         u8 txcode           ?, not used for ctcss

  1         u8 rxcode           ?, not used for ctcss

  3         u8 unknown[3]

  7         char name[7]        7 byte char string for channel name

  1         u8 

   :6       unknown:6,

   :2       busychannellockout:2 busy channel lockout option , 0=off, 1=repeater, 2=busy  (lock out tx if channel busy)

  4         u8 unknownI[4];

  1         u8 

   :7       unknown:7 

   :1       scrambler:1         scrambler flag, 0=off, 1=on (turns on tyt scrambler option)

"""

mem_format = mem_format + """

#seekto 0x2000;

struct memory {

  bbcd freq[4];

  bbcd offset[4];

  u8 unknown2000A:4,

     tune_step:4;

  u8 unknown2000B:4,

     channel_width:2,

     reverse:1,

     txoff:1;

  u8 talkaround:1,

     compander:1,

     unknown2000C:2,

     power:2,

     duplex:2;

  u8 unknown2000D:4,

     rxtmode:2,

     txtmode:2;

  u8 unknown2000E:2,

     txtone:6;

  u8 unknown2000F:2,

     rxtone:6;

  u8 txcode;

  u8 rxcode;

  u8 unknown2000G[3];

  char name[7];

  u8 unknown2000H:6,

     busychannellockout:2;

  u8 unknown2000I[4];

  u8 unknown2000J:7,

     scrambler:1; 

};

struct memory memory[200] ;

"""

def _debug(string):   

    if "CHIRP_DEBUG" in os.environ or True:

        print string

def _echo_write(radio, data):

    try:

        radio.pipe.write(data)

        radio.pipe.read(len(data))

    except Exception, e:

        print "Error writing to radio: %s" % e

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

def _read(radio, length):

    try:

        data = radio.pipe.read(length)

    except Exception, e:

        print "Error reading from radio: %s" % e

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

    if len(data) != length:

        print "Short read from radio (%i, expected %i)" % (len(data),

                                                           length)

        print util.hexprint(data)

        raise errors.RadioError("Short read from radio")

    return data

def _ident(radio):

    radio.pipe.setTimeout(1)

    _echo_write(radio, "PROGRAM")

    response = radio.pipe.read(3)

    if response != "QX\x06":

        print "Response was:\n%s" % util.hexprint(response)

        raise errors.RadioError("Unsupported model")

    _echo_write(radio, "\x02")

    response = radio.pipe.read(16)

    _debug(util.hexprint(response))

    if response[1:8] != "ITH-9000":

        print "Response was:\n%s" % util.hexprint(response)

        raise errors.RadioError("Unsupported model")

def _finish(radio):

    endframe = "\x45\x4E\x44"

    _echo_write(radio, endframe)

    result = radio.pipe.read(1)

    if result != "\x06":

        print "Got:\n%s" % util.hexprint(result)

        raise errors.RadioError("Radio did not finish cleanly")

def _checksum(data):

    cs = 0

    for byte in data:

        cs += ord(byte)

    return cs % 256

def _send(radio, cmd, addr, length, data=None):

    frame = struct.pack(">cHb", cmd, addr, length)

    if data:

        frame += data

        frame += chr(_checksum(frame[1:]))

        frame += "\x06"

    _echo_write(radio, frame)

    _debug("Sent:\n%s" % util.hexprint(frame))

    if data:

        result = radio.pipe.read(1)

        if result != "\x06":

            print "Ack was: %s" % repr(result)

            raise errors.RadioError("Radio did not accept block at %04x" % addr)

        return

    result = _read(radio, length + 6)

    _debug("Got:\n%s" % util.hexprint(result))

    header = result[0:4]

    data = result[4:-2]

    ack = result[-1]

    if ack != "\x06":

        print "Ack was: %s" % repr(ack)

        raise errors.RadioError("Radio NAK'd block at %04x" % addr)

    _cmd, _addr, _length = struct.unpack(">cHb", header)

    if _addr != addr or _length != _length:

        print "Expected/Received:"

        print " Length: %02x/%02x" % (length, _length)

        print " Addr: %04x/%04x" % (addr, _addr)

        raise errors.RadioError("Radio send unexpected block")

    cs = _checksum(result[1:-2])

    if cs != ord(result[-2]):

        print "Calculated: %02x" % cs

        print "Actual:     %02x" % ord(result[-2])

        raise errors.RadioError("Block at 0x%04x failed checksum" % addr)

    return data

def _download(radio):

    _ident(radio)

    memobj = None

    data = ""

    for start, end in radio._ranges:

        for addr in range(start, end, 0x10):

            block = _send(radio, 'R', addr, 0x10)

            data += block

            status = chirp_common.Status()

            status.cur = len(data)

            status.max = end

            status.msg = "Cloning from radio"

            radio.status_fn(status)

    memobj = bitwise.parse(_mem_format, data)

    _finish(radio)

    return memmap.MemoryMap(data)

def _upload(radio):

    _ident(radio)

    for start, end in radio._ranges:

        for addr in range(start, end, 0x10):

            block = radio._mmap[addr:addr + 0x10]

            _send(radio, 'W', addr, len(block), block)

            status = chirp_common.Status()

            status.cur = addr

            status.max = end

            status.msg = "Cloning to radio"

            radio.status_fn(status)

    _finish(radio)

@directory.register

class TytTh9000VHFRadio(chirp_common.CloneModeRadio,

                         chirp_common.ExperimentalRadio):

    """TYT TH-9000 VHF"""

    VENDOR = "TYT"

    MODEL = "TH9000"

    BAUD_RATE = 9600

    # May try to mirror the OEM behavior later

    _ranges = [

        (0x0100, 0x3FF0),

        ]

    @classmethod

    def get_experimental_warning(cls):

        return "FOO"

    def get_features(self):

        rf = chirp_common.RadioFeatures()

        rf.valid_bands = [(136000000)]

        rf.valid_characters = chirp_common.CHARSET_UPPER_NUMERIC

        rf.valid_name_length = 7

        rf.memory_bounds = (0, 199)

        return rf

    @classmethod

    def match_model(cls, filedata, filename):

        return filedata[0x21:0x28] == "ITH-9000"