|
# Copyright 2019 Dan Clemmensen <DanClemmensen@Gmail.com>
|
|
#
|
|
# test the serial io code from ft4.py
|
|
# 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/>.
|
|
"""
|
|
Unit test for ft4.py serial io.
|
|
unit-test module has stubs for averything in CHIRP that is needed by the
|
|
serial FT4 serial i/o functions. I copied those functions into this module
|
|
I don't know how to do real Python debugging. I'm trying to make this compatible
|
|
with both Python 2 and Python 3.
|
|
"""
|
|
import serial
|
|
import os
|
|
import time
|
|
import struct
|
|
|
|
class Util:
|
|
def hexprint(self, msg): #given bytes, return UTF-8 hex string
|
|
return u"".join(u"%02x"% x for x in bytearray(msg))
|
|
|
|
class Log:
|
|
def debug(self, msg):
|
|
print ("Debug: " + msg + "\n")
|
|
|
|
class Errors(Exception):
|
|
def RadioError(self,msg):
|
|
return(msg)
|
|
|
|
util = Util()
|
|
LOG = Log()
|
|
errors = Errors()
|
|
|
|
|
|
# Begin Serial transfer utilities for the SCU-35 cable.
|
|
|
|
# The serial transfer protocol was implemented here after snooping the wire.
|
|
# After it was implemented, we noticed that it is identical to the protocol
|
|
# implemented in th9000.py. A non-echo version is implemented in anytone_ht.py.
|
|
#
|
|
# The pipe.read and pipe.write functions use bytes, not strings. The serial
|
|
# transfer utilities operate only to move data between the memory object and
|
|
# the serial port. The code runs on either Python 2 or Python3, so some
|
|
# constructs could be better optimized for one or the other, but not both.
|
|
|
|
|
|
def checkSum8(data):
|
|
"""
|
|
Calculate the 8 bit checksum of buffer
|
|
Input: buffer - bytes
|
|
returns: integer
|
|
"""
|
|
return sum(x for x in bytearray(data)) & 0xFF
|
|
|
|
|
|
def sendcmd(pipe, cmd, response_len):
|
|
"""
|
|
send a command bytelist to radio,receive and return the resulting bytelist.
|
|
Input: pipe - serial port object to use
|
|
cmd - bytes to send
|
|
response_len - number of bytes of expected response,
|
|
not including the ACK.
|
|
This cable is "two-wire": The TxD and RxD are "or'ed" so we receive
|
|
whatever we send and then whatever response the radio sends. We check the
|
|
echo and strip it, returning only the radio's response.
|
|
We also check and strip the ACK character at the end of the response.
|
|
"""
|
|
pipe.write(cmd)
|
|
echo = pipe.read(len(cmd))
|
|
if echo != cmd:
|
|
msg = "Bad echo. Sent:" + util.hexprint(cmd) + ", "
|
|
msg += "Received:" + util.hexprint(echo)
|
|
LOG.debug(msg)
|
|
raise errors.RadioError("Incorrect echo on serial port.")
|
|
if response_len > 0:
|
|
response = pipe.read(response_len)
|
|
else:
|
|
response = b""
|
|
ack = pipe.read(1)
|
|
if ack != b'\x06':
|
|
LOG.debug("missing ack: expected 0x06, got" + util.hexprint(ack))
|
|
raise errors.RadioError("Incorrect ACK on serial port.")
|
|
return response
|
|
|
|
|
|
def getblock(pipe, addr):
|
|
"""
|
|
read a single 16-byte block from the radio
|
|
send the command and check the response
|
|
returns the 16-byte bytearray
|
|
"""
|
|
cmd = struct.pack(">cHb", b"R", addr, 16)
|
|
response = sendcmd(pipe, cmd, 21)
|
|
if (response[0] != b"W"[0]) or (response[1:4] != cmd[1:4]):
|
|
msg = "Bad response. Sent:" + util.hexprint(cmd) + ", "
|
|
msg += b"Received:" + util.hexprint(response)
|
|
LOG.debug(msg)
|
|
raise errors.RadioError("Incorrect response to read.")
|
|
if checkSum8(response[1:20]) != bytearray(response)[20]:
|
|
LOG.debug(b"Bad checksum: " + util.hexprint(response))
|
|
raise errors.RadioError("bad block checksum.")
|
|
return response[4:20]
|
|
|
|
|
|
def do_download(radio):
|
|
"""
|
|
Read memory from the radio.
|
|
send "PROGRAM" to command the radio into clone mode,
|
|
read the initial string (version?)
|
|
read the memory blocks
|
|
send "END"
|
|
"""
|
|
pipe = radio.pipe # Get the serial port connection
|
|
|
|
if b"QX" != sendcmd(pipe, b"PROGRAM", 2):
|
|
raise errors.RadioError("expected QX from radio.")
|
|
version = sendcmd(pipe, b'\x02', 15)
|
|
data = b""
|
|
for _i in range(radio.numblocks):
|
|
data += getblock(pipe, 16 * _i)
|
|
sendcmd(pipe, b"END", 0)
|
|
return (version, data)
|
|
|
|
|
|
def putblock(pipe, addr, data):
|
|
"""
|
|
write a single 16-byte block to the radio
|
|
send the command and check the response
|
|
"""
|
|
chkstr = struct.pack(">Hb", addr, 16) + data
|
|
msg = b'W' + chkstr + struct.pack('B', checkSum8(chkstr)) + b'\x06'
|
|
sendcmd(pipe, msg, 0)
|
|
|
|
|
|
def do_upload(radio):
|
|
"""
|
|
Write memory image to radio
|
|
send "PROGRAM" to command the radio into clone mode,
|
|
write the memory blocks. Skip the first block
|
|
send "END"
|
|
"""
|
|
pipe = radio.pipe # Get the serial port connection
|
|
|
|
if b"QX" != sendcmd(pipe, b"PROGRAM", 2):
|
|
raise errors.RadioError("expected QX from radio.")
|
|
data = radio.get_mmap()
|
|
sendcmd(pipe, b'\x02', 15)
|
|
for _i in range(1, radio.numblocks):
|
|
putblock(pipe, 16*_i, data[16*_i:16*(_i+1)])
|
|
sendcmd(pipe, b"END", 0)
|
|
return
|
|
# End serial transfer utilities
|
|
|
|
# stub radio class for test
|
|
class Radio(object):
|
|
BAUDRATE = 9600
|
|
|
|
def __init__(self, port=None, imgFN=None,numblocks=0x215):
|
|
"""
|
|
imgFN: image file name
|
|
port: Serial Port name ie com? or /dev/ttyUSB0?
|
|
"""
|
|
|
|
self.port = port
|
|
self.imgFN = imgFN
|
|
|
|
self.pipe = None #Current I/O device file or port
|
|
self.memMap = None
|
|
self.numblocks = numblocks
|
|
self.mem_map_size = 16 * numblocks +15
|
|
|
|
def openPort(self, port=None, to=4):
|
|
"""
|
|
Open serial port set parameters
|
|
raise exception not valid
|
|
"""
|
|
self.close()
|
|
|
|
if port is None:
|
|
port = self.port # maybe None
|
|
|
|
try:
|
|
self.pipe = serial.Serial(port, 9600, timeout=to)
|
|
self.pipe.dtr = True
|
|
self.pipe.flushInput()
|
|
self.pipe.flushOutput()
|
|
except (serial.SerialException, ValueError) as e:
|
|
raise e
|
|
|
|
def get_mmap(self):
|
|
return self.memMap
|
|
|
|
def close(self):
|
|
"""
|
|
close any open port/file
|
|
"""
|
|
try:
|
|
self.pipe.close()
|
|
except:
|
|
pass
|
|
finally:
|
|
self.pipe = None
|
|
|
|
UPLOAD = False
|
|
def test():
|
|
print("Power On Radio")
|
|
time.sleep(3)
|
|
io=Radio(r'/dev/ttyUSB0',None,0x215) #FT-4 on Linux
|
|
io.openPort()
|
|
version, data=do_download(io)
|
|
io.memMap = data
|
|
io.close()
|
|
print(b"Version=" + version)
|
|
with open(r'./dump.ft4', 'wb') as f:
|
|
f.write(data)
|
|
f.close()
|
|
print("Wrote raw image to ./dump.ft4")
|
|
if UPLOAD:
|
|
print("Power Radio off and back on")
|
|
time.sleep(3)
|
|
io.openPort()
|
|
print("sending to radio")
|
|
do_upload(io)
|
|
print("transfer complete")
|
|
|
|
# main program
|
|
if __name__ =="__main__":
|
|
test()
|
|
|
|
|
