def do_rerun(args):
serial = AsciiSerial(args.serial_port, baudrate=args.baudrate)
handler = expect.Handler(serial)
print('Restarting the Simba Xvisor guest.')
serial.write(CTRL_X_Q)
handler.send('')
serial.flushInput()
handler.expect('XVisor# ')
time.sleep(0.1)
handler.send('guest reset simba')
handler.expect('XVisor# ')
time.sleep(0.1)
handler.send('guest kick simba')
handler.expect('XVisor# ')
time.sleep(0.1)
handler.send('vserial bind simba/uart0')
line = ''
while line != SUCCESS:
line = ''
while not line.endswith('\n'):
try:
line += serial.read_byte().decode('ascii').strip('\r')
except UnicodeDecodeError:
pass
line = line.replace('[simba/uart0] ', '').rstrip()
print(line)
def do_upload(args):
serial = AsciiSerial(args.serial_port, baudrate=args.baudrate)
handler = expect.Handler(serial)
print('Entering the U-Boot... ')
serial.write(CTRL_X_Q)
handler.send('')
serial.flushInput()
handler.send('reset')
handler.expect('Hit any key to stop autoboot:')
handler.send('')
handler.expect('U-Boot>')
commands = [
'setenv ipaddr 192.168.0.200', 'setenv serverip 192.168.0.4',
'tftpboot 0x200000 uvmm.bin', 'tftpboot 0x800000 board.dtb',
'tftpboot 0x2000000 udisk.img'
]
for command in commands:
handler.send(command)
handler.expect('U-Boot>')
handler.send('bootm 0x200000 0x2000000 0x800000')
handler.expect('simba: Kicked')
def test_expect_return_value(self):
"""Verify the return value from the expect function.
"""
foobar = expect.Handler(StringIO('barfoo'))
match = foobar.expect(r'foo|bar')
self.assertEqual(match, 'bar')
match = foobar.expect(r'foo|bar')
self.assertEqual(match, 'foo')
def test_eol(self):
"""End of line testing.
"""
iostream = StringIO()
handler = expect.Handler(iostream, eol='\r\n')
handler.send('')
self.assertEqual(iostream.getvalue(), '\r\n')
handler.send('', send_eol=False)
self.assertEqual(iostream.getvalue(), '\r\n')
def test_break_condition(self):
"""Verify that the expect function throws an exception
when the break condition is met.
"""
# The StringIO object returns '' when EOF is encountered.
iostream = StringIO()
handler = expect.Handler(iostream)
with self.assertRaises(RuntimeError) as e:
handler.expect(r'foo')
print(e)
def main():
"""Main function.
"""
parser = argparse.ArgumentParser()
# The default run script arguments.
parser.add_argument("--port", default="/dev/arduino")
parser.add_argument("--baudrate", type=int, default=38400)
parser.add_argument("--timeout", type=int, default=10)
parser.add_argument("--pattern")
parser.add_argument("--pattern-success")
parser.add_argument("--dtr", type=int, default=0)
parser.add_argument("--rts", type=int, default=0)
parser.add_argument('--server-ip-address',
default='192.168.0.7',
help='Server ip address.')
args = parser.parse_args()
dev_serial = serial.Serial(args.port, baudrate=args.baudrate, timeout=1.0)
dev_serial.dtr = args.dtr
dev_serial.rts = args.rts
dev = expect.Handler(dev_serial, break_conditions=[])
status = 0
print()
print("INFO: TIMEOUT = {}".format(args.timeout))
print()
try:
test.test_udp(args.server_ip_address, dev, args.timeout)
test.test_tcp(args.server_ip_address, dev, args.timeout)
test.test_tcp_write_close(args.server_ip_address, dev, args.timeout)
test.test_tcp_sizes(args.server_ip_address, dev, args.timeout)
finally:
print(dev.iostream.read(dev.iostream.in_waiting))
try:
report = dev.expect(args.pattern, timeout=args.timeout)
print()
except:
print()
status = 1
else:
if not re.match(args.pattern_success, report):
status = 1
print
sys.exit(status)
def main():
"""Main function.
"""
parser = argparse.ArgumentParser()
# The default run script arguments.
parser.add_argument("--port", default="/dev/arduino")
parser.add_argument("--baudrate", type=int, default=38400)
parser.add_argument("--timeout", type=int, default=10)
parser.add_argument("--pattern")
parser.add_argument("--pattern-success")
parser.add_argument("--dtr", type=int, default=0)
parser.add_argument("--rts", type=int, default=0)
parser.add_argument('--server-ip-address',
default='192.168.0.5',
help='Server ip address.')
args = parser.parse_args()
dev_serial = serial.Serial(args.port, baudrate=args.baudrate, timeout=1.0)
# Boot from Flash.
dev_serial.rts = 0
# Hold the chip in reset.
dev_serial.dtr = 1
time.sleep(0.5)
# Let go of the reset.
dev_serial.dtr = 0
dev = expect.Handler(dev_serial, break_conditions=[])
status = 0
print()
print("INFO: TIMEOUT = {}".format(args.timeout))
print()
try:
test.mosquitto(args.server_ip_address, dev, args.timeout)
finally:
print(dev.iostream.read(dev.iostream.in_waiting))
try:
report = dev.expect(args.pattern, timeout=args.timeout)
print()
except:
print()
status = 1
else:
if not re.match(args.pattern_success, report):
status = 1
print()
sys.exit(status)
def main():
"""Main function.
"""
parser = argparse.ArgumentParser()
parser.add_argument("--port", default="/dev/arduino")
parser.add_argument("--control-port")
parser.add_argument("--baudrate", type=int, default=115200)
parser.add_argument("--timeout", type=int, default=10)
parser.add_argument("--pattern")
parser.add_argument("--pattern-success")
args = parser.parse_args()
serial_connection = serial.Serial(args.port,
baudrate=args.baudrate,
timeout=1.0)
# Set FAB low to boot from flash.
if args.control_port:
control_port_connection = serial.Serial(args.control_port)
# Set RESET high.
control_port_connection.rts = False
control_port_connection.dtr = True
time.sleep(0.01)
# Toggle RESET.
control_port_connection.rts = True
time.sleep(0.005)
control_port_connection.rts = False
time.sleep(0.01)
dev = expect.Handler(serial_connection, break_conditions=[])
status = 0
print
print "INFO: TIMEOUT = {}".format(args.timeout)
try:
print
report = dev.expect(args.pattern, timeout=args.timeout)
print
except:
print
status = 1
else:
if not re.match(args.pattern_success, report):
status = 1
print
sys.exit(status)
def test_no_split(self):
"""Verify that the expect function can match over multiple lines.
"""
class Handler(StringIo):
INDATA = """
foo
bar
"""
handler = expect.Handler(Handler(), split_pattern=None)
handler.expect(r'foo\nbar')
def test_expect_timeout(self):
"""Test expect timeout functionality.
"""
class Handler(object):
def read(self, count=1):
time.sleep(0.2)
return "1"
handler = expect.Handler(Handler())
with self.assertRaises(expect.ExpectTimeoutError) as e:
handler.expect(r"no match", timeout=0.1)
print(e)
def main():
"""Main function.
"""
parser = argparse.ArgumentParser()
parser.add_argument("--port", default="/dev/arduino")
parser.add_argument("--timeout", type=int, default=10)
parser.add_argument("--pattern")
parser.add_argument("--pattern-success")
args = parser.parse_args()
dev_serial = serial.Serial(args.port, timeout=3.0)
dev = expect.Handler(dev_serial, break_conditions=[])
# Wait for the board to start.
sys.stdout.write("Waiting for the serial port '{}' to show up... ".format(
args.port))
attempt = 1
while attempt < 20:
try:
serial.Serial(args.port, baudrate=38400).close()
print("done.")
break
except:
time.sleep(0.5)
attempt += 1
else:
print("failed.")
sys.exit(1)
status = 0
print("INFO: TIMEOUT = {}".format(args.timeout))
print()
try:
report = dev.expect(args.pattern, timeout=args.timeout)
print()
except:
print()
status = 1
else:
if not re.match(args.pattern_success, report):
status = 1
print()
sys.exit(status)
def test_uboot(self):
"""U-boot communication example.
"""
class UBoot(StringIo):
INDATA = """
Booting in 3 seconds...
Booting in 2 seconds...
u-boot> fatload mmc 0 0x3000000 uImage
u-boot> fatload mmc 0 0x2A00000 devicetree.dtb
u-boot> fatload mmc 0 0x2000000 uramdisk.image.gz
u-boot> bootm 0x3000000 0x2000000 0x2A00000
...
~ $
"""
OUTDATA = """
fatload mmc 0 0x3000000 uImage
fatload mmc 0 0x2A00000 devicetree.dtb
fatload mmc 0 0x2000000 uramdisk.image.gz
bootm 0x3000000 0x2000000 0x2A00000
"""
prompt = r'u-boot> '
# create the handler object and start to communicate with u-boot
uboot = expect.Handler(UBoot())
uboot.expect(r'Booting in \d+ seconds...')
uboot.send('')
uboot.expect(prompt)
uboot.send('fatload mmc 0 0x3000000 uImage')
uboot.expect(prompt)
uboot.send('fatload mmc 0 0x2A00000 devicetree.dtb')
uboot.expect(prompt)
uboot.send('fatload mmc 0 0x2000000 uramdisk.image.gz')
uboot.expect(prompt)
uboot.send('bootm 0x3000000 0x2000000 0x2A00000')
uboot.expect(r'~ \$')
self.assertEqual(uboot.iostream.out_stream.getvalue(), UBoot.OUTDATA)
sys.stdout.flush()
def main():
"""Main function.
"""
parser = argparse.ArgumentParser()
parser.add_argument("--port", default="/dev/arduino")
parser.add_argument("--baudrate", type=int, default=38400)
parser.add_argument("--timeout", type=int, default=10)
parser.add_argument("--pattern")
parser.add_argument("--pattern-success")
parser.add_argument("--dtr", type=int, default=0)
parser.add_argument("--rts", type=int, default=0)
args = parser.parse_args()
dev_serial = serial.Serial(args.port, baudrate=args.baudrate, timeout=1.0)
dev_serial.dtr = args.dtr
dev_serial.rts = args.rts
dev = expect.Handler(dev_serial, break_conditions=[])
status = 0
print
print "INFO: TIMEOUT = {}".format(args.timeout)
try:
print
report = dev.expect(args.pattern, timeout=args.timeout)
print
except:
print
status = 1
else:
if not re.match(args.pattern_success, report):
status = 1
print
sys.exit(status)
def main():
"""Main function.
"""
parser = argparse.ArgumentParser()
parser.add_argument("--port", default="/dev/arduino")
parser.add_argument("--baudrate", type=int, default=38400)
parser.add_argument("--reset-mode",
type=str,
choices=["rts", "dtr", "none"],
default="none")
parser.add_argument("--timeout", type=int, default=10)
parser.add_argument("--pattern")
parser.add_argument("--pattern-success")
args = parser.parse_args()
dev_serial = serial.Serial(args.port, baudrate=args.baudrate, timeout=1.0)
if args.reset_mode == "rts":
print("Reset via RTS")
# Boot from Flash.
dev_serial.dtr = 0
# Hold the chip in reset.
dev_serial.rts = 1
time.sleep(0.5)
# Let go of the reset.
dev_serial.rts = 0
elif args.reset_mode == "dtr":
print("Reset via DTR")
# Boot from Flash.
dev_serial.rts = 0
# Hold the chip in reset.
dev_serial.dtr = 1
time.sleep(0.5)
# Let go of the reset.
dev_serial.dtr = 0
else:
dev_serial.dtr = 0
dev_serial.rts = 0
dev = expect.Handler(dev_serial, break_conditions=[])
status = 0
print()
print("INFO: TIMEOUT = {}".format(args.timeout))
try:
print()
report = dev.expect(args.pattern, timeout=args.timeout)
print()
except:
print()
status = 1
else:
if args.pattern_success is not None and \
not re.match(args.pattern_success, report):
status = 1
print()
sys.exit(status)
