def test_xmodem_send_exceed_maximum_number_of_resend(mode, stream_data):
""" Verify send(retry=n) after 'n' transfer failures of single block. """
# given,
max_resend = 3
def getc_generator():
if mode == 'xmodem':
yield NAK
else:
# xmodem1k
yield CRC
if mode == 'xmodem':
yield ACK
for i in range(max_resend + 1):
yield None
while True:
yield ACK
mock = getc_generator()
def mock_getc(size, timeout=1):
return next(mock)
xmodem = XMODEM(getc=mock_getc, putc=dummy_putc, mode=mode)
# exercise
result = xmodem.send(stream=stream_data, retry=max_resend)
# verify
assert not result
def test_xmodem_recv_bad_checksum():
"""
Using external program for send, verify checksum fail in XMODEM.recv().
"""
# Given,
_, send_filename = tempfile.mkstemp()
try:
with open(send_filename, 'wb') as stream:
fill_binary_data(stream)
proc = subprocess.Popen(
(send_prog, '--xmodem', '--verbose', send_filename),
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
bufsize=0)
getc = functools.partial(_proc_getc_fail_16bit_checksum, proc=proc)
putc = functools.partial(_proc_putc, proc=proc)
xmodem = XMODEM(getc, putc)
recv_stream = BytesIO()
# Exercise,
status = xmodem.recv(recv_stream, timeout=5, crc_mode=1)
# Verify,
assert status == recv_stream.tell()
verify_binary_data(recv_stream, padding=b'\x1a')
proc.wait()
assert proc.returncode == 0
finally:
os.unlink(send_filename)
def upload(self, port):
import serial
from xmodem import XMODEM
import io
# In case xmodem starts acting up
# import logging
# logging.basicConfig(level=logging.DEBUG)
s = serial.Serial(port,
19200,
timeout=1,
parity=serial.PARITY_NONE,
bytesize=8,
stopbits=1,
xonxoff=0,
rtscts=0)
def getc(size, timeout=1):
return s.read(size)
def putc(data, timeout=1):
return s.write(data)
modem = XMODEM(getc, putc)
modem.send(io.BytesIO(self.input_file))
def xmodem_dl(port, baudrate, file):
ser = serial.Serial(port,baudrate,timeout=1)
def getc(size, timeout=1):
time.sleep(0.05)
return ser.read(size) or None
def putc(data, timeout=1):
time.sleep(0.05)
return ser.write(data)
putc('version\r\n')
time.sleep(0.1)
old_ver = getc(30)
print('----old FW version is:'+old_ver)
time.sleep(0.1)
putc('updata\r\n')
time.sleep(0.1)
c = getc(13)
print(c)
modem = XMODEM(getc, putc,mode = 'xmodem1k')
stream = open(file, 'rb')
state = modem.send(stream)
if state:
dl_str = getc(100)
print(dl_str)
print("--success--")
else:
dl_str = getc(10)
print("--fail--")
def test_xmodem_send_fails_once_each_packet(mode, stream_data):
""" XMODEM has retry parameter this test ensure that the number of retry for
the whole stream_data will be higher the max_resend pro packet """
# given,
max_resend = 16
def generator():
if mode == 'xmodem':
yield NAK
else:
yield CRC
while True:
yield None
yield ACK
mock = generator()
def mock_getc(size, timeout=1):
try:
# python 2
x = mock.next()
except AttributeError:
# python 3
x = next(mock)
return x
xmodem = XMODEM(getc=mock_getc, putc=dummy_putc, mode=mode)
# exercise
assert xmodem.send(stream=stream_data, retry=max_resend)
def test_xmodem_bad_mode():
# given,
mode = 'XXX'
modem = XMODEM(getc=dummy_getc, putc=dummy_putc, mode=mode)
# exercise
with pytest.raises(ValueError):
status = modem.send(BytesIO(b'dummy-stream'))
def test_xmodem_send_exceed_maximum_number_of_resend(mode, stream_data):
""" XMODEM has retry parameter this function ensure that xmodem.send() will
return False dude to the fact that resend exceeded """
# given,
max_resend = 16
def generator():
if mode == 'xmodem':
yield NAK
else:
yield CRC
if mode == 'xmodem':
yield ACK
for i in range(max_resend + 1):
yield None
while True:
yield ACK
mock = generator()
def mock_getc(size, timeout=1):
try:
# python 2
x = mock.next()
except AttributeError:
# python 3
x = next(mock)
return x
xmodem = XMODEM(getc=mock_getc, putc=dummy_putc, mode=mode)
# exercise
assert not xmodem.send(stream=stream_data, retry=max_resend)
def test_xmodem_send():
""" Using external program for receive, verify XMODEM.send(). """
# Given,
_, recv_filename = tempfile.mkstemp()
try:
proc = subprocess.Popen(
(recv_prog, '--xmodem', '--verbose', recv_filename),
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
bufsize=0)
getc = functools.partial(_proc_getc, proc=proc)
putc = functools.partial(_proc_putc, proc=proc)
xmodem = XMODEM(getc, putc, pad=b'\xbb')
stream = fill_binary_data(BytesIO())
# Exercise,
status = xmodem.send(stream, timeout=5, callback=_send_callback)
# Verify,
assert status is True
verify_binary_data(stream, padding=b'\xbb')
verify_binary_data(open(recv_filename, 'rb'), padding=b'\xbb')
proc.wait()
assert proc.returncode == 0
finally:
if os.path.isfile(recv_filename):
os.unlink(recv_filename)
def test_xmodem_dummy_fails_send(mode):
# given,
modem = XMODEM(getc=dummy_getc, putc=dummy_putc, mode=mode)
# exercise
status = modem.send(BytesIO(b'dummy-stream'))
# verify
assert not status, ("Expected value of status `False'")
def run(self):
try:
if self.tSerial.pause():
try:
if self.cmd:
# Send command and wait for ACK(\x15)
self.tSerial.write_no_wait("{}\n".format(self.cmd))
tm_bgn = time.time()
while time.time() - tm_bgn < self.timeout:
data = self.tSerial.read_no_wait()
if data and data in ["\x15", "C"]:
break
time.sleep(0.2)
else:
return
# Start xmodem send
self.modem = XMODEM(self.getc, self.putc, mode='xmodem')
with open(self.path, 'rb') as fd:
self.status = self.modem.send(fd,
callback=self.callback)
finally:
self.tSerial.resume()
finally:
self.doneUpdate.emit(self.status)
def main():
if len(sys.argv) < 3:
print("Serial or font file not specified")
return
path = sys.argv[1]
if not Path(path).exists():
print("Not found:", sys.argv[1])
return
serial = Serial(path, 115200)
serial.write(CMD)
serial.read(len(CMD))
path = sys.argv[2]
if not Path(path).exists():
return
with open(path, 'rb') as f:
def getc(size, timeout=0):
return serial.read(size)
def putc(data, timeout=0):
return serial.write(data)
def xmodem_callback(total_packets, _success_count, _fail_count):
print('%d packets sent' % total_packets, end='\r')
XMODEM(getc, putc).send(f,
retry=0,
timeout=1,
callback=xmodem_callback)
print('\nTransfer complete')
def firmwareUpdater():
def getc(size, timeout=1):
return ser.read(size) or None
def putc(data, timeout=1):
ser.write(data) or None
response.set_header('Content-Type', 'application/json')
upload = request.files.get('file')
upload.save("fw.bin", overwrite=True)
for x in range(2):
ser = serial.Serial(Serial_Port, timeout=1)
ser.write(b'RST}')
sleep(2)
ser.close()
ser = serial.Serial(Serial_Port, timeout=1)
modem = XMODEM(getc, putc)
f = open('fw.bin', 'rb')
ser.flushInput()
ser.flushOutput()
status = modem.send(f)
sleep(2)
ser.flushInput()
ser.flushOutput()
ser.write(b'b')
f.close()
ser.close()
return None
def test_xmodem_send_fails_once_each_packet(mode, stream_data):
""" Verify send(retry=n) under 'n' transfer failures of single block. """
# given,
max_resend = 1
def getc_generator():
if mode == 'xmodem':
yield NAK
else:
# xmodem1k
yield CRC
while True:
# fail
yield None
# succeed
yield ACK
mock = getc_generator()
def mock_getc(size, timeout=1):
return next(mock)
xmodem = XMODEM(getc=mock_getc, putc=dummy_putc, mode=mode)
# exercise
result = xmodem.send(stream=stream_data, retry=max_resend)
# verify
assert result
def xm_write_page(samba, page_address, data):
adrstr = hex(page_address)[2:].zfill(8)
samba.xm_init_sf(adrstr)
sendbuf = BytesIO(data)
modem = XMODEM(samba.xm_getc, samba.xm_putc)
if not modem.send(sendbuf, quiet=True):
raise IOError("XMODEM Transfer Failure")
sendbuf.close()
def __init__(self, port, speed, binpath=None, debug=False):
self.speed = speed
self.baud = self.BAUD[speed]
self.port = port
self.xm = XMODEM(self.getc, self.putc, "xmodem1k", "\xff")
self.binpath = binpath or BIN_PATH
self.tag = 0x1000
self.debug = debug
def connect(self, chip):
def getc(size, timeout=10):
ret = self.term.read(size)
return ret or None
def putc(data, timeout=10):
return self.term.write(data) # note that this ignores the timeout
self.modem = XMODEM(getc, putc, mode=self.mode)
return super().connect(chip)
def _sendfile(self, filename, callback=None):
""" Send a file to the device using xmodem. """
def getc(size, timeout=1):
self.sport.timeout = timeout
return self.sport.read(size)
def putc(data, timeout=1):
self.sport.writeTimeout = timeout
return self.sport.write(data)
def mycallback(total_packets, success_count, error_count):
if cb:
cb(total_packets, success_count, error_count, file_packets)
self.previous_line = ''
def statuscallback(total_packets, success_count, error_count,
file_packets):
#global previous_line
this_line = " %d%% %d err\r" % (total_packets * 100 /
file_packets, error_count)
if this_line != self.previous_line:
self.previous_line = this_line
sys.stdout.write(this_line)
sys.stdout.flush()
self.proc.sendline('')
self.proc.expect('=>')
self._log(2, "xmdm")
self.proc.sendline('xmdm')
sleep(1.0)
self.sport.close()
self.sport = serial.Serial(port=self.tty,
baudrate=self.baudrate,
bytesize=8,
parity='N',
stopbits=1,
timeout=None,
xonxoff=0,
rtscts=0)
modem = XMODEM(getc, putc)
if callback:
cb = callback
else:
if self.verbosity >= 1:
cb = statuscallback
else:
cb = None
file_packets = (os.path.getsize(self.filename) - 1) / 128 + 1
result = modem.send(open(filename, 'rb'), callback=mycallback)
self._log(2, "xmodem result = " + str(result))
self.proc = pexpect.fdpexpect.fdspawn(self.sport, logfile=self.logfile)
def download(outfile):
print("Starting download")
# Initiate xmodem download
exchangeCommand("dx", "CTRL+C to cancel.\r\n")
xm = XMODEM(getc, putc)
print("Downloading", end="", flush=True)
n = xm.recv(outfile, crc_mode=False, retry=102, quiet=False)
print("") # newline
print("Bytes received: " + str(n))
return n
def upload(ser,
path,
flashsize,
bootloadersize,
shouldverify=True,
destructive=False):
run = True
while run:
try:
f = open(path, "rb")
except IOError:
CHK(False, "'%s': can't open file" % path, 5)
# upload command
if destructive:
ser.write('d')
else:
ser.write('u')
def ser_write(msg, timeout=1):
ser.setWriteTimeout(timeout)
return ser.write(msg)
def ser_read(size, timeout=1):
ser.setTimeout(timeout)
return ser.read(size)
modem = XMODEM(ser_read, ser_write, pad='\xff')
modem.send(f)
f.close()
ser.setTimeout(0)
ser.setWriteTimeout(0)
if shouldverify:
run = not verify(ser, path, flashsize, bootloadersize, destructive)
if run: #verify failed
input_ok = False
while not input_ok:
tmp = raw_input("Verify failed! Retry? [Y|n]")
if len(tmp) == 0 or tmp.upper() == 'Y':
input_ok = True
elif tmp.upper() == 'N':
input_ok = True
CHK(
False,
"Verify failed! Uploaded programm may be inconsistent!",
6)
else:
run = False
# reset command
ser.write('r')
def __init__(self, connAlias, connectionData=None, logObj=None, shellPrompt=None, userPrompt=None, passPrompt=None):
from Marvell.pytoolsinfra.SysEventManager.SysEventManager import SysEventManager
self._is_inner_call = False
self.connAlias = connAlias
self._userPrompt = None
self._passprompt = None
self._shellPrompt = None
self._lastBufferTillPrompt = None
self._testlogger = None
self.testlogger = logObj
self.newlineChar = "\n"
self.generate_uid = False
self.retry_connect = True
self.timeout_between_retries = 5
self.nums_of_retries = 3
self._testlogger_additional_kwargs = {}
self._is_registered_object = SysEventManager.IsEventRegistered(EventNameEnum.COMM_CONNECTION_LOST_EVENT)
self._userName = self._password = None
self.login_after_connect = False # if True will try to login to target using input username and password
self._max_login_recursive_calls = 6
self._current_login_rec_call = 0
if connectionData is not None:
if hasattr(connectionData, "uname"):
self._userName = connectionData.uname.value
if hasattr(connectionData, "password"):
self._password = connectionData.password.value
self.get_buffer_till_pattern_interval = 0.1 # set none to read all buffer
self.cli_print_mode = False # uses to indicate if working with a cli and reduces redundant prints
# For Sending/Receiving Compressed data for LUA JSON commands
self._xmodem = XMODEM(self.getc, self.putc)
self._xmodem_buf = b''
# #################################
if shellPrompt is None:
self.shellPrompt = re.compile(r".*[#>].*\Z", re.IGNORECASE)
else:
self.shellPrompt = shellPrompt
if userPrompt is None:
self.userPrompt = re.compile(r"(user\s*name.*|.*login.*)\s*\Z", re.IGNORECASE)
else:
self.userPrompt = userPrompt
if passPrompt is None:
self.passPrompt = re.compile(r"password.*\s*\Z", re.IGNORECASE)
else:
self.passPrompt = passPrompt
def __init__(self, port_number):
self.port = config.PORT_NAME[port_number]
self.serial = serial.Serial(
port=self.port,
baudrate=115200,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE,
bytesize=serial.EIGHTBITS,
timeout=1)
# setup xmodem for image transfers
self.modem = XMODEM(self.getc, self.putc)
self.logger = app_api.logging_setup("UART")
def fw_update(self):
ser = self.myserial
modem = XMODEM(self.getc, self.putc)
# stream = open('/home/pi/share/fw/0bb_stg1_pkg1-0m_L56A0200_to_L58A0204.bin', 'rb')
stream = open('/home/pi/share/fw/0bb_stg2_L56A0200_to_L58A0204.bin', 'rb')
rmutils.write(ser, 'AT+UFWUPD=3')
rmutils.wait_urc(ser, 20, self.com_port)
modem.send(stream)
stream.close()
ser.flushOutput()
rmutils.wait_urc(ser, 20, self.com_port)
# print(stream)
rmutils.write(ser, 'AT+UFWINSTALL')
rmutils.write(ser, 'AT+UFWINSTALL?')
def download(filename):
modem = XMODEM(getc, putc)
cmd = 'upload ' + filename
send_cmd(cmd) # b'upload trend.log\n'
receive_line() # b'Start receiving now.\r\n'
stream = open(FILENAME, 'wb')
print('*Start receiving (XMODEM-CRC)')
ser.flushInput()
modem.recv(stream, crc_mode=1)
line = receive_line() # b'28822 Bytes Transmitted.\r\n'
size = int(line.split()[0])
stream.truncate(size)
stream.close()
print('*downloaded ' + filename + ' (' + str(size) + ' bytes)')
return size
def update_keyboard(keylist, port, rotation):
key_identifier = bytearray.fromhex('DEAD')
key_data = []
binary_file = 'binary_file.bin'
max_keys = 12
# key_data has (keycode, width, height, bitmap)
for keys in keylist:
key_data.append(
(keys.get_keycode(), keys.get_width(), keys.get_height(),
Image.frombytes(mode='L',
data=bytes.fromhex(keys.get_bitmap()),
size=(keys.get_width(),
keys.get_height())).rotate(rotation)))
# Generate the binary file to send
with open(
binary_file, 'wb'
) as f: # Should erase existing files when it's opened for writing
count = 0
for index, image in zip(range(max_keys), key_data):
f.write(key_identifier)
f.write(count.to_bytes(1, 'big'))
count += 1
f.write((int(image[0], 16)).to_bytes(1, 'big'))
f.write(image[1].to_bytes(1, 'big'))
f.write(image[2].to_bytes(1, 'big'))
f.write(image[3].tobytes())
# Send the file
ser = serial.Serial(port, timeout=1, baudrate=230400)
# Not reading
def getc(size, timeout=1):
return ser.read(size)
# Data to send
def putc(data, timeout=1):
ser.write(data)
time.sleep(0.001) # delay for safety reasons
modem = XMODEM(getc, putc)
stream = open(binary_file, 'rb')
send_result = modem.send(stream, timeout=2, retry=2)
ser.close()
return send_result
def upload(infile):
print("Starting upload")
time_start = datetime.datetime.now()
# Initiate xmodem download
exchangeCommand("ux", "READY. Please start uploading.\r\n", atEnd=False)
xm = XMODEM(getc, putc)
print("Uploading", end="", flush=True)
n = xm.send(infile, retry=102, quiet=False)
print("") # newline
duration = (datetime.datetime.now() - time_start).total_seconds()
if n:
print("Upload completed with success in ", duration, "seconds")
else:
print("Upload error")
return n
def xmodem_payload(fl, chunksize=0, welcome=b"boot: host: Hit 'X' for xmodem upload\n"):
poll_for_invite(welcome)
print("Sending payload")
stream = open(fl, 'rb')
modem = XMODEM(getc, putc)
if chunksize==0:
ret = modem.send(stream, retry=16)
else:
while True:
data = stream.read(chunksize)
if (not data):
break
data = io.BytesIO(data)
ret = modem.send(data, retry=16)
poll_for_invite(welcome)
print("Delivered!")
def xmodem_send(serial, stream, timeout):
rtscts = serial.rtscts
serial.rtscts = 0
# From https://pypi.org/project/xmodem/.
def getc(size, timeout=timeout):
res = serial.read(size) or None
return res
def putc(data, timeout=timeout):
res = serial.write(data) # note that this ignores the timeout
return res
xmodem = XMODEM(getc, putc)
xmodem.send(stream)
serial.rtscts = rtscts
def upload_firmware(dev, firmware_path):
sdev = serial.Serial(port=dev, baudrate=115200, bytesize=8, parity='N',stopbits=1, timeout=None, xonxoff=0, rtscts=0)
LOG.info("Uploading firmware to device %s", sdev.port)
LOG.debug("Looking for the bootloader menu")
sdev.write(b'i')
line = sdev.readline()
sleep(1.0)
while sdev.inWaiting():
line = sdev.readline()
if b'BOOTLOADER' in line:
LOG.info(line)
break
else:
raise RuntimeError("Couldn't find bootloader menu")
def getc(size, timeout=1):
return sdev.read(size)
def putc(data, timeout=1):
sdev.write(data)
LOG.debug("Sending firmware via XMODEM")
with open(firmware_path, 'rb') as firmware:
sdev.write(b'u')
LOG.debug("Waiting for CRC character")
start = time()
while time() - start < 3.0:
char = sdev.read(1)
if char == CRC:
break
else:
raise RuntimeError("Timeout waiting for CRC character")
LOG.debug("Starting XMODEM transfer.")
upload_success = XMODEM(getc, putc).send(firmware, retry=16, timeout=60*4, quiet=0)
if upload_success:
LOG.debug("Firmware uploaded to %s", sdev.port)
else:
raise RuntimeError("Error in XMODEM transfer")
# Reset module into firmware
LOG.info("New firmware uploaded and verified by module %s", sdev.port)
sdev.write(b'r')
def uploadFromFile(self, fromfile='upload.bin'):
def __read_byte(size, timeout=1):
return self.SERIAL.read(size)
def __write_byte(data, timeout=1):
return self.SERIAL.write(data)
time.sleep(0.1)
stream = open(fromfile, 'rb')
buffer = StringIO(stream.read())
stream.close()
modem = XMODEM(__read_byte, __write_byte).send(buffer, quiet=1)
buffer.close()
try:
self.execute(self.COMMAND_RESET)
except:
pass
return
def send_file(self, filename):
self.logger.warning('Sending file %s', filename)
self.cloud.network.modem.serial_port.write_timeout = 20
self.cloud.network.modem.command('+UFWUPD',
'3',
expected='ONGOING',
timeout=60)
time.sleep(5)
fd = open(filename, 'rb')
self.logger.warning('Writing file to serial port')
modem = XMODEM(self.xgetc, self.xputc)
sent_success = modem.send(fd, retry=25, timeout=90)
fd.close()
if not sent_success:
raise UpdaterException('Failed to send file via xmodem')
self.logger.debug('Done writing')
time.sleep(1)
return True
