def test_program_btldr(self):
""" Test programming the bootloader once its sector is locked. """
unittest.skipIf(self.skip_single, 'Skipping single Piksi tests')
SECTOR = 0
ADDRESS = 0x08003FFF
if self.verbose: print "--- test_program_btldr ---"
with serial_link.get_driver(use_ftdi=False, port=self.port1) as driver:
with Handler(driver.read, driver.write) as handler:
with Bootloader(handler) as piksi_bootloader:
with Timeout(TIMEOUT_BOOT) as timeout:
if self.verbose: print "Waiting for bootloader handshake"
piksi_bootloader.handshake()
with Flash(handler, flash_type='STM',
sbp_version=piksi_bootloader.sbp_version) as piksi_flash:
# Make sure the bootloader sector is locked.
with Timeout(TIMEOUT_LOCK_SECTOR) as timeout:
if self.verbose: print "Locking STM sector:", SECTOR
piksi_flash.lock_sector(SECTOR)
# Make sure the address to test isn't already programmed.
with Timeout(TIMEOUT_READ_STM) as timeout:
byte_read = piksi_flash.read(ADDRESS, 1, block=True)
self.assertEqual('\xFF', byte_read,
"Address to program is already programmed")
# Attempt to write 0x00 to last address of the sector.
if self.verbose: print "Attempting to lock STM sector:", SECTOR
piksi_flash.program(0x08003FFF, '\x00')
with Timeout(TIMEOUT_READ_STM) as timeout:
byte_read = piksi_flash.read(0x08003FFF, 1, block=True)
self.assertEqual('\xFF', byte_read,
"Bootloader sector was programmed")
def test_get_versions(self):
""" Get Piksi bootloader/firmware/NAP version from device. """
unittest.skipIf(self.skip_single, 'Skipping single Piksi tests')
if self.verbose: print "--- test_get_versions ---"
with serial_link.get_driver(use_ftdi=False, port=self.port1) as driver:
with Handler(driver.read, driver.write) as handler:
with Bootloader(handler) as piksi_bootloader:
# Get bootloader version, print, and jump to application firmware.
with Timeout(TIMEOUT_BOOT) as timeout:
if self.verbose: print "Waiting for bootloader handshake"
piksi_bootloader.handshake()
piksi_bootloader.jump_to_app()
print "Piksi Bootloader Version:", piksi_bootloader.version
# Wait for heartbeat, get settings, print firmware/NAP versions.
heartbeat = Heartbeat()
handler.add_callback(heartbeat, SBP_MSG_HEARTBEAT)
if self.verbose: print "Waiting to receive heartbeat"
while not heartbeat.received:
time.sleep(0.1)
if self.verbose: print "Received hearbeat"
handler.remove_callback(heartbeat, SBP_MSG_HEARTBEAT)
if self.verbose: print "Getting Piksi settings"
settings = self.get_piksi_settings(handler)
if self.verbose: print "Piksi Firmware Version:", \
settings['system_info']['firmware_version']
if self.verbose: print "Piksi NAP Version:", \
settings['system_info']['nap_version']
def test_jump_to_app(self):
""" Test that we can jump to the application after programming. """
unittest.skipIf(self.skip_single, 'Skipping single Piksi tests')
if self.verbose: print "--- test_jump_to_app ---"
with serial_link.get_driver(use_ftdi=False, port=self.port1) as driver:
with Handler(driver.read, driver.write) as handler:
with Bootloader(handler) as piksi_bootloader:
if self.verbose: print "Handshaking with bootloader"
piksi_bootloader.handshake()
if self.verbose: print "Jumping to application"
piksi_bootloader.jump_to_app()
# If we succesfully jump to the application, we should receive
# Heartbeat messages.
with Timeout(TIMEOUT_BOOT) as timeout:
heartbeat = Heartbeat()
handler.add_callback(heartbeat, SBP_MSG_HEARTBEAT)
if self.verbose: print "Waiting to receive heartbeat"
while not heartbeat.received:
time.sleep(0.1)
if self.verbose: print "Received hearbeat"
handler.remove_callback(heartbeat, SBP_MSG_HEARTBEAT)
def test_erase_btldr(self):
""" Test erasing the bootloader once its sector is locked. """
unittest.skipIf(self.skip_single, 'Skipping single Piksi tests')
SECTOR = 0
if self.verbose: print "--- test_erase_btldr ---"
with serial_link.get_driver(use_ftdi=False, port=self.port1) as driver:
with Handler(driver.read, driver.write) as handler:
with Bootloader(handler) as piksi_bootloader:
with Timeout(TIMEOUT_BOOT) as timeout:
if self.verbose: print "Waiting for bootloader handshake"
piksi_bootloader.handshake()
with Flash(handler, flash_type='STM',
sbp_version=piksi_bootloader.sbp_version) as piksi_flash:
# Make sure the bootloader sector is locked.
with Timeout(TIMEOUT_LOCK_SECTOR) as timeout:
if self.verbose: print "Locking STM sector:", SECTOR
piksi_flash.lock_sector(SECTOR)
# Attempt to erase the sector.
with Timeout(TIMEOUT_ERASE_SECTOR) as timeout:
if self.verbose: print "Attempting to erase STM sector:", SECTOR
piksi_flash.erase_sector(SECTOR, warn=False)
# If the sector was successfully erased, we should timeout here
# as the bootloader will stop sending handshakes.
with Timeout(TIMEOUT_BOOT) as timeout:
if self.verbose: print "Waiting for bootloader handshake"
piksi_bootloader.handshake()
def test_flashing_wrong_sender_id(self):
""" Test flashing using an incorrect sender ID (should fail). """
unittest.skipIf(self.skip_single, 'Skipping single Piksi tests')
SECTOR = 1
SENDER_ID = 0x41
if self.verbose: print "--- test_flashing_wrong_sender_id ---"
with serial_link.get_driver(use_ftdi=False, port=self.port1) as driver:
with Handler(driver.read, driver.write) as handler:
# Verify that flash erase times out when using incorrect sender ID.
with Bootloader(handler) as piksi_bootloader:
with Timeout(TIMEOUT_BOOT) as timeout:
print "Handshaking with bootloader"
piksi_bootloader.handshake()
with Flash(handler, flash_type='STM',
sbp_version=piksi_bootloader.sbp_version) as piksi_flash:
try:
with Timeout(TIMEOUT_ERASE_SECTOR) as timeout:
if self.verbose: print "Attempting to erase sector with incorrect sender ID"
msg_buf = struct.pack("BB", piksi_flash.flash_type_byte, SECTOR)
handler.send(SBP_MSG_FLASH_ERASE, msg_buf, sender=SENDER_ID)
handler.wait(SBP_MSG_FLASH_DONE, TIMEOUT_ERASE_SECTOR+1)
raise Exception("Should have timed out but didn't")
except TimeoutError:
if self.verbose: print "Timed out as expected"
def test_flash_stm_firmware(self):
""" Test flashing STM hexfile. """
unittest.skipIf(self.skip_single, 'Skipping single Piksi tests')
if self.verbose: print "--- test_flash_stm_firmware ---"
with serial_link.get_driver(use_ftdi=False, port=self.port1) as driver:
with Handler(driver.read, driver.write) as handler:
# Wait until we receive a heartbeat or bootloader handshake so we
# know what state Piksi is in.
with Bootloader(handler) as piksi_bootloader:
with Timeout(TIMEOUT_BOOT) as timeout:
if self.verbose: print "Waiting for bootloader handshake"
piksi_bootloader.handshake()
if self.verbose: print "Received bootloader handshake"
with Flash(handler, flash_type="STM",
sbp_version=piksi_bootloader.sbp_version) as piksi_flash:
# Erase entire STM flash (except bootloader).
if self.verbose: print "Erasing STM"
with Timeout(TIMEOUT_ERASE_STM) as timeout:
for s in range(1,12):
piksi_flash.erase_sector(s)
# Write STM firmware.
with Timeout(TIMEOUT_PROGRAM_STM) as timeout:
if self.verbose:
if self.verbose: print "Programming STM"
piksi_flash.write_ihx(self.stm_fw, sys.stdout, 0x10, erase=False)
else:
piksi_flash.write_ihx(self.stm_fw, erase=False)
def test_setup(port1, port2, stm_fw, nap_fw, verbose, n_queue):
"""
Do set up before running tests. This should be called before running a
suite of TestBootloader tests. This used to be in TestBootloader.setUpClass
but the instance variables passed into TestBootloader.__init__ are not in
scope for TestBootloader.setUpClass.
Parameters
==========
port1 : string
Filepath to the COM port of the Piksi Under Test.
port2 : string
Filepath to the COM port of a Piksi connected via UART to the
Piksi Under Test.
stm_fw : intelhex.IntelHex
STM firmware to use in tests.
nap_fw : intelhex.IntelHex
NAP firmware to use in tests.
verbose : bool
Print status output.
n_queue : int
Number of flash operations to queue.
"""
if verbose: print "--- Setting up device for tests ---"
with serial_link.get_driver(use_ftdi=False, port=port1) as driver:
with Handler(driver.read, driver.write) as handler:
setup_piksi(handler, stm_fw, nap_fw, verbose)
if verbose: print ""
# Hack: Wait a bit for 'Piksi Disconnected'
# print from sbp.client.handler.Handler
time.sleep(0.1)
def main():
"""
Get configuration, get driver, get logger, and build handler and start it.
Create relevant TestState object and perform associated actions.
Modeled after serial_link main function.
"""
args = get_args()
port = args.port
baud = args.baud
timeout = args.timeout[0]
log_filename = args.log_filename[0]
interval = int(args.interval[0])
minsats = int(args.minsats[0])
# Driver with context
with sl.get_driver(args.ftdi, port, baud) as driver:
# Handler with context
with Handler(Framer(driver.read, driver.write, args.verbose)) as link:
# Logger with context
with sl.get_logger(args.log, log_filename) as logger:
# print out SBP_MSG_PRINT_DEP messages
link.add_callback(sl.printer, SBP_MSG_PRINT_DEP)
link.add_callback(sl.log_printer, SBP_MSG_LOG)
# add logger callback
Forwarder(link, logger).start()
try:
# Get device info
# Diagnostics reads out the device settings and resets the Piksi
piksi_diag = ptd.Diagnostics(link)
while not piksi_diag.heartbeat_received:
time.sleep(0.1)
# add Teststates and associated callbacks
with DropSatsState(
link,
piksi_diag.sbp_version,
interval,
minsats,
debug=args.verbose) as drop:
link.add_callback(drop.process_message)
if timeout is not None:
expire = time.time() + float(args.timeout[0])
while True:
if timeout is None or time.time() < expire:
# Wait forever until the user presses Ctrl-C
time.sleep(1)
else:
print("Timer expired!")
break
if not link.is_alive():
sys.stderr.write("ERROR: link is gone!\n")
sys.exit(1)
except KeyboardInterrupt:
# Callbacks call thread.interrupt_main(), which throw a KeyboardInterrupt
# exception. To get the proper error condition, return exit code
# of 1. Note that the finally block does get caught since exit
# itself throws a SystemExit exception.
sys.exit(1)
def main():
"""
Get configuration, get driver, and build handler and start it.
"""
args = get_args()
port = args.port[0]
baud = args.baud[0]
if args.tcp:
try:
host, port = port.split(':')
selected_driver = TCPDriver(host, int(port))
except Exception as e:
raise ValueError("Invalid host and/or port: {}".format(e))
else:
selected_driver = serial_link.get_driver(args.ftdi, port, baud)
# Driver with context
with selected_driver as driver:
# Handler with context
with Handler(Framer(driver.read, driver.write)) as link:
print("Creating Settings")
s = Settings(link)
time.sleep(1)
slist = [{
"section": "solution",
"name": "correction_age_max",
"value": "7"
}, {
"section": "solution",
"name": "elevation_mask",
"value": "5"
}]
results = s.write_all(slist, workers=10)
for (res, section, name, value) in results:
if res:
print("write_all failed for {}.{} with error value {}".
format(section, name, res))
print("solution.elevation_mask =",
s.read("solution", "elevation_mask"))
value = input('Enter new solution.elevation_mask value: ')
s.write("solution", "elevation_mask", value)
print("solution.elevation_mask =",
s.read("solution", "elevation_mask"))
l = s.read_all(workers=10)
for setting in l:
print(setting)
print("Release Settings")
s.destroy()
def main():
"""
Get configuration, get driver, get logger, and build handler and start it.
Create relevant TestState object and perform associated actions.
Modeled after serial_link main function.
"""
args = get_args()
port = args.port
baud = args.baud
timeout = args.timeout
log_filename = args.logfilename
log_dirname = args.log_dirname
if not log_filename:
log_filename = sl.logfilename()
if log_dirname:
log_filename = os.path.join(log_dirname, log_filename)
interval = int(args.interval[0])
# Driver with context
with sl.get_driver(args.ftdi, port, baud) as driver:
# Handler with context
with Handler(Framer(driver.read, driver.write, args.verbose)) as link:
# Logger with context
with sl.get_logger(args.log, log_filename, expand_json=args.expand_json) as logger:
Forwarder(link, logger).start()
try:
# Get device info
# add Teststates and associated callbacks
with CellModemTestState(link, interval, filename=args.outfile,
commanded_cycles=int(args.cycles)) as cell:
if timeout is not None:
expire = time.time() + float(args.timeout)
while True:
if timeout is None or time.time() < expire:
# Wait forever until the user presses Ctrl-C
time.sleep(1)
else:
print "Timer expired!"
break
if not link.is_alive():
sys.stderr.write("ERROR: Thread died!")
sys.exit(1)
except KeyboardInterrupt:
# Callbacks call thread.interrupt_main(), which throw a KeyboardInterrupt
# exception. To get the proper error condition, return exit code
# of 1. Note that the finally block does get caught since exit
# itself throws a SystemExit exception.
sys.exit(1)
def test_btldr_handshake_wrong_sender_id(self):
"""
Test setting Piksi into bootloader mode with an incorrect sender ID
(should fail).
"""
unittest.skipIf(self.skip_single, 'Skipping single Piksi tests')
if self.verbose: print("--- test_btldr_handshake_wrong_sender_id ---")
with serial_link.get_driver(use_ftdi=False, port=self.port1) as driver:
with Handler(driver.read, driver.write) as handler:
# Make sure device is in the application firmware.
set_app_mode(handler, self.verbose)
# Reset Piksi, and attempt to handshake into bootloader mode with an
# incorrect sender ID.
if self.verbose: print("Sending reset")
handler.send(SBP_MSG_RESET, "")
with Bootloader(handler) as piksi_bootloader:
with Timeout(TIMEOUT_BOOT) as timeout:
if self.verbose:
print(
"Waiting for bootloader handshake from device")
while not piksi_bootloader.handshake_received:
time.sleep(0.1)
if self.verbose: print("Received handshake")
if self.verbose:
print("Sending handshake with incorrect sender ID")
handler.send(SBP_MSG_BOOTLOADER_HANDSHAKE_REQ,
'\x00',
sender=0x41)
# We should receive a heartbeat if the handshake was unsuccessful.
with Timeout(TIMEOUT_BOOT) as timeout:
heartbeat = Heartbeat()
handler.add_callback(heartbeat, SBP_MSG_HEARTBEAT)
if self.verbose: print("Waiting to receive heartbeat")
while not heartbeat.received:
time.sleep(0.1)
if self.verbose: print("Received hearbeat")
handler.remove_callback(heartbeat, SBP_MSG_HEARTBEAT)
def test_program_btldr(self):
""" Test programming the bootloader once its sector is locked. """
unittest.skipIf(self.skip_single, 'Skipping single Piksi tests')
SECTOR = 0
ADDRESS = 0x08003FFF
if self.verbose: print "--- test_program_btldr ---"
with serial_link.get_driver(use_ftdi=False, port=self.port1) as driver:
with Handler(driver.read, driver.write) as handler:
with Bootloader(handler) as piksi_bootloader:
with Timeout(TIMEOUT_BOOT) as timeout:
if self.verbose:
print "Waiting for bootloader handshake"
piksi_bootloader.handshake()
with Flash(handler,
flash_type='STM',
sbp_version=piksi_bootloader.sbp_version
) as piksi_flash:
# Make sure the bootloader sector is locked.
with Timeout(TIMEOUT_LOCK_SECTOR) as timeout:
if self.verbose:
print "Locking STM sector:", SECTOR
piksi_flash.lock_sector(SECTOR)
# Make sure the address to test isn't already programmed.
with Timeout(TIMEOUT_READ_STM) as timeout:
byte_read = piksi_flash.read(ADDRESS,
1,
block=True)
self.assertEqual(
'\xFF', byte_read,
"Address to program is already programmed")
# Attempt to write 0x00 to last address of the sector.
if self.verbose:
print "Attempting to lock STM sector:", SECTOR
piksi_flash.program(0x08003FFF, '\x00')
with Timeout(TIMEOUT_READ_STM) as timeout:
byte_read = piksi_flash.read(0x08003FFF,
1,
block=True)
self.assertEqual('\xFF', byte_read,
"Bootloader sector was programmed")
def main():
"""
Get configuration, get driver, build handler, and unlock sectors.
"""
args = get_args()
port = args.port[0]
baud = args.baud[0]
# Driver with context
with serial_link.get_driver(use_ftdi=False, port=port,
baud=baud) as driver:
# Handler with context
with Handler(driver.read, driver.write) as link:
with Bootloader(link) as piksi_bootloader:
print(
"Waiting for bootloader handshake message from Piksi ...",
end=' ')
sys.stdout.flush()
try:
piksi_bootloader.handshake()
except KeyboardInterrupt:
return
print("received.")
print("Piksi Onboard Bootloader Version:",
piksi_bootloader.version)
if piksi_bootloader.sbp_version > (0, 0):
print("Piksi Onboard SBP Protocol Version:",
piksi_bootloader.sbp_version)
# Catch all other errors and exit cleanly.
try:
with Flash(link,
flash_type="STM",
sbp_version=piksi_bootloader.sbp_version
) as piksi_flash:
for s in range(0, 12):
print("\rUnlocking STM Sector", s, end=' ')
sys.stdout.flush()
piksi_flash.unlock_sector(s)
print()
except:
import traceback
traceback.print_exc()
def test_btldr_handshake_wrong_sender_id(self):
"""
Test setting Piksi into bootloader mode with an incorrect sender ID
(should fail).
"""
unittest.skipIf(self.skip_single, 'Skipping single Piksi tests')
if self.verbose: print "--- test_btldr_handshake_wrong_sender_id ---"
with serial_link.get_driver(use_ftdi=False, port=self.port1) as driver:
with Handler(driver.read, driver.write) as handler:
# Make sure device is in the application firmware.
set_app_mode(handler, self.verbose)
# Reset Piksi, and attempt to handshake into bootloader mode with an
# incorrect sender ID.
if self.verbose: print "Sending reset"
handler.send(SBP_MSG_RESET, "")
with Bootloader(handler) as piksi_bootloader:
with Timeout(TIMEOUT_BOOT) as timeout:
if self.verbose: print "Waiting for bootloader handshake from device"
while not piksi_bootloader.handshake_received:
time.sleep(0.1)
if self.verbose: print "Received handshake"
if self.verbose: print "Sending handshake with incorrect sender ID"
handler.send(SBP_MSG_BOOTLOADER_HANDSHAKE_REQ, '\x00', sender=0x41)
# We should receive a heartbeat if the handshake was unsuccessful.
with Timeout(TIMEOUT_BOOT) as timeout:
heartbeat = Heartbeat()
handler.add_callback(heartbeat, SBP_MSG_HEARTBEAT)
if self.verbose: print "Waiting to receive heartbeat"
while not heartbeat.received:
time.sleep(0.1)
if self.verbose: print "Received hearbeat"
handler.remove_callback(heartbeat, SBP_MSG_HEARTBEAT)
def test_btldr_handshake(self):
""" Test setting Piksi into bootloader mode. """
unittest.skipIf(self.skip_single, 'Skipping single Piksi tests')
if self.verbose: print "--- test_btldr_handshake ---"
with serial_link.get_driver(use_ftdi=False, port=self.port1) as driver:
with Handler(driver.read, driver.write) as handler:
with Bootloader(handler) as piksi_bootloader:
# If the Piksi bootloader successfully received our handshake, we
# should be able to receive handshakes from it indefinitely. Test
# this a few times.
if self.verbose: print "Setting Piksi into bootloader mode"
with Timeout(TIMEOUT_BOOT) as timeout:
piksi_bootloader.handshake()
if self.verbose: print "Testing bootloader handshake replies"
for i in range(10):
time.sleep(1)
with Timeout(TIMEOUT_BOOT) as timeout:
piksi_bootloader.handshake()
def test_btldr_handshake(self):
""" Test setting Piksi into bootloader mode. """
unittest.skipIf(self.skip_single, 'Skipping single Piksi tests')
if self.verbose: print "--- test_btldr_handshake ---"
with serial_link.get_driver(use_ftdi=False, port=self.port1) as driver:
with Handler(driver.read, driver.write) as handler:
with Bootloader(handler) as piksi_bootloader:
# If the Piksi bootloader successfully received our handshake, we
# should be able to receive handshakes from it indefinitely. Test
# this a few times.
if self.verbose: print "Setting Piksi into bootloader mode"
with Timeout(TIMEOUT_BOOT) as timeout:
piksi_bootloader.handshake()
if self.verbose:
print "Testing bootloader handshake replies"
for i in range(10):
time.sleep(1)
with Timeout(TIMEOUT_BOOT) as timeout:
piksi_bootloader.handshake()
def test_flashing_wrong_sender_id(self):
""" Test flashing using an incorrect sender ID (should fail). """
unittest.skipIf(self.skip_single, 'Skipping single Piksi tests')
SECTOR = 1
SENDER_ID = 0x41
if self.verbose: print("--- test_flashing_wrong_sender_id ---")
with serial_link.get_driver(use_ftdi=False, port=self.port1) as driver:
with Handler(driver.read, driver.write) as handler:
# Verify that flash erase times out when using incorrect sender ID.
with Bootloader(handler) as piksi_bootloader:
with Timeout(TIMEOUT_BOOT) as timeout:
print("Handshaking with bootloader")
piksi_bootloader.handshake()
with Flash(handler,
flash_type='STM',
sbp_version=piksi_bootloader.sbp_version
) as piksi_flash:
try:
with Timeout(TIMEOUT_ERASE_SECTOR) as timeout:
if self.verbose:
print(
"Attempting to erase sector with incorrect sender ID"
)
msg_buf = struct.pack(
"BB", piksi_flash.flash_type_byte, SECTOR)
handler.send(SBP_MSG_FLASH_ERASE,
msg_buf,
sender=SENDER_ID)
handler.wait(SBP_MSG_FLASH_DONE,
TIMEOUT_ERASE_SECTOR + 1)
raise Exception(
"Should have timed out but didn't")
except TimeoutError:
if self.verbose: print("Timed out as expected")
def test_flash_stm_firmware(self):
""" Test flashing STM hexfile. """
unittest.skipIf(self.skip_single, 'Skipping single Piksi tests')
if self.verbose: print "--- test_flash_stm_firmware ---"
with serial_link.get_driver(use_ftdi=False, port=self.port1) as driver:
with Handler(driver.read, driver.write) as handler:
# Wait until we receive a heartbeat or bootloader handshake so we
# know what state Piksi is in.
with Bootloader(handler) as piksi_bootloader:
with Timeout(TIMEOUT_BOOT) as timeout:
if self.verbose:
print "Waiting for bootloader handshake"
piksi_bootloader.handshake()
if self.verbose: print "Received bootloader handshake"
with Flash(handler,
flash_type="STM",
sbp_version=piksi_bootloader.sbp_version
) as piksi_flash:
# Erase entire STM flash (except bootloader).
if self.verbose: print "Erasing STM"
with Timeout(TIMEOUT_ERASE_STM) as timeout:
for s in range(1, 12):
piksi_flash.erase_sector(s)
# Write STM firmware.
with Timeout(TIMEOUT_PROGRAM_STM) as timeout:
if self.verbose:
if self.verbose: print "Programming STM"
piksi_flash.write_ihx(self.stm_fw,
sys.stdout,
0x10,
erase=False)
else:
piksi_flash.write_ihx(self.stm_fw, erase=False)
def test_get_versions(self):
""" Get Piksi bootloader/firmware/NAP version from device. """
unittest.skipIf(self.skip_single, 'Skipping single Piksi tests')
if self.verbose: print("--- test_get_versions ---")
with serial_link.get_driver(use_ftdi=False, port=self.port1) as driver:
with Handler(driver.read, driver.write) as handler:
with Bootloader(handler) as piksi_bootloader:
# Get bootloader version, print, and jump to application firmware.
with Timeout(TIMEOUT_BOOT) as timeout:
if self.verbose:
print("Waiting for bootloader handshake")
piksi_bootloader.handshake()
piksi_bootloader.jump_to_app()
print("Piksi Bootloader Version:",
piksi_bootloader.version)
# Wait for heartbeat, get settings, print firmware/NAP versions.
heartbeat = Heartbeat()
handler.add_callback(heartbeat, SBP_MSG_HEARTBEAT)
if self.verbose: print("Waiting to receive heartbeat")
while not heartbeat.received:
time.sleep(0.1)
if self.verbose: print("Received hearbeat")
handler.remove_callback(heartbeat, SBP_MSG_HEARTBEAT)
if self.verbose: print("Getting Piksi settings")
settings = self.get_piksi_settings(handler)
if self.verbose: print("Piksi Firmware Version:", \
settings['system_info']['firmware_version'])
if self.verbose: print("Piksi NAP Version:", \
settings['system_info']['nap_version'])
def test_erase_btldr(self):
""" Test erasing the bootloader once its sector is locked. """
unittest.skipIf(self.skip_single, 'Skipping single Piksi tests')
SECTOR = 0
if self.verbose: print("--- test_erase_btldr ---")
with serial_link.get_driver(use_ftdi=False, port=self.port1) as driver:
with Handler(driver.read, driver.write) as handler:
with Bootloader(handler) as piksi_bootloader:
with Timeout(TIMEOUT_BOOT) as timeout:
if self.verbose:
print("Waiting for bootloader handshake")
piksi_bootloader.handshake()
with Flash(handler,
flash_type='STM',
sbp_version=piksi_bootloader.sbp_version
) as piksi_flash:
# Make sure the bootloader sector is locked.
with Timeout(TIMEOUT_LOCK_SECTOR) as timeout:
if self.verbose:
print("Locking STM sector:", SECTOR)
piksi_flash.lock_sector(SECTOR)
# Attempt to erase the sector.
with Timeout(TIMEOUT_ERASE_SECTOR) as timeout:
if self.verbose:
print("Attempting to erase STM sector:",
SECTOR)
piksi_flash.erase_sector(SECTOR, warn=False)
# If the sector was successfully erased, we should timeout here
# as the bootloader will stop sending handshakes.
with Timeout(TIMEOUT_BOOT) as timeout:
if self.verbose:
print("Waiting for bootloader handshake")
piksi_bootloader.handshake()
def main():
"""
Get configuration, get driver, and build handler and start it.
"""
args = get_args()
port = args.port[0]
baud = args.baud[0]
command = args.command
return_code = 0
with serial_link.get_driver(args.ftdi, port, baud) as driver:
with Handler(Framer(driver.read, driver.write)) as link:
settings = Settings(link)
if command == 'write':
settings.write(args.section,
args.setting,
args.value,
verbose=args.verbose)
elif command == 'read':
print(
settings.read(args.section,
args.setting,
verbose=args.verbose))
elif command == 'all':
settings.read_all(verbose=True)
elif command == 'save':
settings.save()
elif command == 'reset':
settings.reset()
elif command == 'read_to_file':
settings.read_to_file(args.output, verbose=args.verbose)
elif command == 'write_from_file':
settings.write_from_file(args.filename, verbose=args.verbose)
# If saving was requested, we have done a write command, and the write was requested, we save
if command.startswith("write") and args.save_after_write:
print("Saving Settings to Flash.")
settings.save()
def main():
args = get_args()
port = args.port[0]
baud = args.baud[0]
if args.tcp:
try:
host, port = port.split(':')
selected_driver = TCPDriver(host, int(port))
except: # noqa
raise Exception('Invalid host and/or port')
else:
selected_driver = serial_link.get_driver(args.ftdi, port, baud)
# Driver with context
with selected_driver as driver:
# Handler with context
with Handler(Framer(driver.read, driver.write, args.verbose)) as link:
f = FileIO(link)
try:
if args.write:
f.write(args.write[0], open(args.write[0]).read())
elif args.read:
data = f.read(args.read[0])
if args.hex:
print(hexdump(data))
else:
print(data)
elif args.delete:
f.remove(args.delete[0])
elif args.list is not None:
print_dir_listing(f.readdir(args.list[0]))
else:
print("No command given, listing root directory:")
print_dir_listing(f.readdir())
except KeyboardInterrupt:
pass
def test_flash_nap_firmware(self):
""" Test flashing NAP hexfile. """
unittest.skipIf(self.skip_single, 'Skipping single Piksi tests')
if self.verbose: print "--- test_flash_nap_firmware ---"
with serial_link.get_driver(use_ftdi=False, port=self.port1) as driver:
with Handler(driver.read, driver.write) as handler:
with Bootloader(handler) as piksi_bootloader:
with Timeout(TIMEOUT_BOOT) as timeout:
if self.verbose: print "Waiting for bootloader handshake"
piksi_bootloader.handshake()
if self.verbose: print "Received bootloader handshake"
with Flash(handler, flash_type='M25',
sbp_version=piksi_bootloader.sbp_version) as piksi_flash:
with Timeout(TIMEOUT_WRITE_NAP) as timeout:
if self.verbose:
print "Writing firmware to NAP flash"
piksi_flash.write_ihx(self.nap_fw, sys.stdout, mod_print=0x10)
else:
piksi_flash.write_ihx(self.nap_fw)
def main():
"""
Get configuration, get driver, build handler, and unlock sectors.
"""
args = get_args()
port = args.port[0]
baud = args.baud[0]
# Driver with context
with serial_link.get_driver(use_ftdi=False, port=port, baud=baud) as driver:
# Handler with context
with Handler(driver.read, driver.write) as link:
with Bootloader(link) as piksi_bootloader:
print "Waiting for bootloader handshake message from Piksi ...",
sys.stdout.flush()
try:
piksi_bootloader.handshake()
except KeyboardInterrupt:
return
print "received."
print "Piksi Onboard Bootloader Version:", piksi_bootloader.version
if piksi_bootloader.sbp_version > (0, 0):
print "Piksi Onboard SBP Protocol Version:", piksi_bootloader.sbp_version
# Catch all other errors and exit cleanly.
try:
with Flash(link, flash_type="STM",
sbp_version=piksi_bootloader.sbp_version) as piksi_flash:
for s in range(0,12):
print "\rUnlocking STM Sector", s,
sys.stdout.flush()
piksi_flash.unlock_sector(s)
print
except:
import traceback
traceback.print_exc()
self.ports = [p for p, _, _ in s.get_ports()]
except TypeError:
pass
if not port:
port_chooser = PortChooser()
is_ok = port_chooser.configure_traits()
port = port_chooser.port
if not port or not is_ok:
print "No serial device selected!"
sys.exit(1)
else:
print "Using serial device '%s'" % port
with s.get_driver(args.ftdi, port, baud) as driver:
with sbpc.Handler(sbpc.Framer(driver.read, driver.write, args.verbose)) as link:
if os.path.isdir(log_filename):
log_filename = os.path.join(log_filename, s.LOG_FILENAME)
with s.get_logger(args.log, log_filename) as logger:
if args.reset:
link(MsgReset())
link.add_callback(logger)
log_filter = DEFAULT_LOG_LEVEL_FILTER
if args.initloglevel[0]:
log_filter = args.initloglevel[0]
if base and use_broker:
device_id = get_uuid(channel, serial_id)
with HTTPDriver(str(device_id), base) as http_driver:
with sbpc.Handler(sbpc.Framer(http_driver.read, None, args.verbose)) as slink:
slink.add_callback(swriter(link))
def main():
"""
Get configuration, get driver, get logger, and build handler and start it.
Create relevant TestState object and perform associated actions.
Modeled after serial_link main function.
"""
args = get_args()
port = args.port[0]
baud = args.baud[0]
timeout = args.timeout[0]
log_filename = args.log_filename[0]
append_log_filename = args.append_log_filename[0]
tags = args.tags[0]
interval = int(args.interval[0])
minsats = int(args.minsats[0])
# Driver with context
with sl.get_driver(args.ftdi, port, baud) as driver:
# Handler with context
with Handler(Framer(driver.read, driver.write, args.verbose)) as link:
# Logger with context
with sl.get_logger(args.log, log_filename) as logger:
# Append logger iwth context
with sl.get_append_logger(append_log_filename, tags) as append_logger:
# print out SBP_MSG_PRINT_DEP messages
link.add_callback(sl.printer, SBP_MSG_PRINT_DEP)
link.add_callback(sl.log_printer, SBP_MSG_LOG)
# add logger callback
Forwarder(link, logger).start()
# ad append logger callback
Forwarder(link, append_logger).start()
try:
# Get device info
# Diagnostics reads out the device settings and resets the Piksi
piksi_diag = ptd.Diagnostics(link)
while not piksi_diag.heartbeat_received:
time.sleep(0.1)
# add Teststates and associated callbacks
with DropSatsState(link, piksi_diag.sbp_version, interval,
minsats, debug=args.verbose) as drop:
link.add_callback(drop.process_message)
if timeout is not None:
expire = time.time() + float(args.timeout[0])
while True:
if timeout is None or time.time() < expire:
# Wait forever until the user presses Ctrl-C
time.sleep(1)
else:
print "Timer expired!"
break
if not link.is_alive():
sys.stderr.write("ERROR: Thread died!")
sys.exit(1)
except KeyboardInterrupt:
# Callbacks call thread.interrupt_main(), which throw a KeyboardInterrupt
# exception. To get the proper error condition, return exit code
# of 1. Note that the finally block does get caught since exit
# itself throws a SystemExit exception.
sys.exit(1)
def main():
warnings.simplefilter(action="ignore", category=FutureWarning)
logging.basicConfig()
args = None
parser = get_args()
try:
args = parser.parse_args()
port = args.port
baud = args.baud
show_usage = args.help
error_str = ""
except (ArgumentParserError, argparse.ArgumentError,
argparse.ArgumentTypeError) as e:
print(e)
show_usage = True
error_str = "ERROR: " + str(e)
if args and args.toolkit[0] is not None:
ETSConfig.toolkit = args.toolkit[0]
else:
ETSConfig.toolkit = 'qt4'
# Make sure that SIGINT (i.e. Ctrl-C from command line) actually stops the
# application event loop (otherwise Qt swallows KeyboardInterrupt exceptions)
signal.signal(signal.SIGINT, signal.SIG_DFL)
if show_usage:
usage_str = parser.format_help()
print(usage_str)
usage = ShowUsage(usage_str, error_str)
usage.configure_traits()
sys.exit(1)
selected_driver = None
connection_description = ""
if port and args.tcp:
# Use the TPC driver and interpret port arg as host:port
try:
host, ip_port = port.split(':')
selected_driver = TCPDriver(host, int(ip_port))
connection_description = port
except:
raise Exception('Invalid host and/or port')
sys.exit(1)
elif port and args.file:
# Use file and interpret port arg as the file
print("Using file '%s'" % port)
selected_driver = s.get_driver(args.ftdi, port, baud, args.file)
connection_description = os.path.split(port)[-1]
elif not port:
# Use the gui to get our driver
port_chooser = PortChooser(baudrate=int(args.baud))
is_ok = port_chooser.configure_traits()
ip_address = port_chooser.ip_address
ip_port = port_chooser.ip_port
port = port_chooser.port
baud = port_chooser.baudrate
mode = port_chooser.mode
# todo, update for sfw flow control if ever enabled
rtscts = port_chooser.flow_control == flow_control_options_list[1]
if rtscts:
print("using flow control")
# if the user pressed cancel or didn't select anything
if not (port or (ip_address and ip_port)) or not is_ok:
print("No Interface selected!")
sys.exit(1)
else:
# Use either TCP/IP or serial selected from gui
if mode == cnx_type_list[1]:
print("Using TCP/IP at address %s and port %d" %
(ip_address, ip_port))
selected_driver = TCPDriver(ip_address, int(ip_port))
connection_description = ip_address + ":" + str(ip_port)
else:
print("Using serial device '%s'" % port)
selected_driver = s.get_driver(args.ftdi,
port,
baud,
args.file,
rtscts=rtscts)
connection_description = os.path.split(port)[-1] + " @" + str(
baud)
else:
# Use the port passed and assume serial connection
print("Using serial device '%s'" % port)
selected_driver = s.get_driver(args.ftdi,
port,
baud,
args.file,
rtscts=args.rtscts)
connection_description = os.path.split(port)[-1] + " @" + str(baud)
with selected_driver as driver:
with sbpc.Handler(sbpc.Framer(driver.read, driver.write,
args.verbose)) as link:
if args.reset:
link(MsgReset(flags=0))
log_filter = DEFAULT_LOG_LEVEL_FILTER
if args.initloglevel[0]:
log_filter = args.initloglevel[0]
with SwiftConsole(link,
args.update,
log_filter,
cnx_desc=connection_description,
error=args.error,
json_logging=args.log,
log_dirname=args.log_dirname,
override_filename=args.logfilename,
log_console=args.log_console,
networking=args.networking,
serial_upgrade=args.serial_upgrade) as console:
console.configure_traits()
# Force exit, even if threads haven't joined
try:
os._exit(0)
except:
pass
host, port = port.split(':')
selected_driver = TCPDriver(host, int(port))
except:
raise Exception('Invalid host and/or port')
else:
if not port:
port_chooser = PortChooser()
is_ok = port_chooser.configure_traits()
port = port_chooser.port
if not port or not is_ok:
print "No serial device selected!"
sys.exit(1)
else:
print "Using serial device '%s'" % port
selected_driver = s.get_driver(args.ftdi, port, baud, args.file)
with selected_driver as driver:
with sbpc.Handler(sbpc.Framer(driver.read, driver.write,
args.verbose)) as link:
if args.reset:
link(MsgReset())
log_filter = DEFAULT_LOG_LEVEL_FILTER
if args.initloglevel[0]:
log_filter = args.initloglevel[0]
SwiftConsole(link,
args.update,
log_filter,
port=port,
error=args.error,
json_logging=args.log,
help="print extra debugging information.",
action="store_true")
parser.add_argument("-f", "--ftdi",
help="use pylibftdi instead of pyserial.",
action="store_true")
args = parser.parse_args()
port = args.port[0]
baud = args.baud[0]
settings_read = False
def callback():
global settings_read
settings_read = True
# Driver with context
with serial_link.get_driver(args.ftdi, port, baud) as driver:
# Handler with context
with Handler(driver.read, driver.write, args.verbose) as link:
sv = settings_view.SettingsView(link, read_finished_functions=[callback], gui_mode=False)
link.start()
# Give the firmware time to start up and possibly send settings.
time.sleep(10)
# Force the firmware to send settings.
global settings_read
settings_read = False
sv._settings_read_button_fired()
while not settings_read:
time.sleep(1)
def main():
"""
Get configuration, get driver, and build handler and start it.
"""
args = get_args()
port = args.port[0]
baud = args.baud[0]
use_ftdi = args.ftdi
use_m25 = args.m25
use_stm = args.stm
erase = args.erase
# Driver with context
with serial_link.get_driver(use_ftdi, port, baud) as driver:
# Handler with context
with Handler(Framer(driver.read, driver.write)) as link:
link.add_callback(serial_link.log_printer, SBP_MSG_LOG)
link.add_callback(serial_link.printer, SBP_MSG_PRINT_DEP)
# Tell Bootloader we want to write to the flash.
with Bootloader(link) as piksi_bootloader:
print(
"Waiting for bootloader handshake message from Piksi ...",
end=' ')
sys.stdout.flush()
try:
handshake_received = piksi_bootloader.handshake(
args.timeout[0])
except KeyboardInterrupt:
return
if not (handshake_received and
piksi_bootloader.handshake_received):
print("No handshake received.")
sys.exit(1)
print("received.")
print("Piksi Onboard Bootloader Version:",
piksi_bootloader.version)
if piksi_bootloader.sbp_version > (0, 0):
print("Piksi Onboard SBP Protocol Version:",
piksi_bootloader.sbp_version)
# Catch all other errors and exit cleanly.
try:
from . import flash
with flash.Flash(
link,
flash_type=("STM" if use_stm else "M25"),
sbp_version=piksi_bootloader.sbp_version,
max_queued_ops=int(
args.max_queued_ops[0])) as piksi_flash:
if erase:
for s in range(1, 12):
print("\rErasing STM Sector", s, end=' ')
sys.stdout.flush()
piksi_flash.erase_sector(s)
print()
from intelhex import IntelHex
ihx = IntelHex(args.file)
piksi_flash.write_ihx(ihx, sys.stdout, mod_print=0x10)
print("Bootloader jumping to application")
piksi_bootloader.jump_to_app()
except:
import traceback
traceback.print_exc()
self.ports = [p for p, _, _ in s.get_ports()]
except TypeError:
pass
if not port:
port_chooser = PortChooser()
is_ok = port_chooser.configure_traits()
port = port_chooser.port
if not port or not is_ok:
print "No serial device selected!"
sys.exit(1)
else:
print "Using serial device '%s'" % port
with s.get_driver(args.ftdi, port, baud) as driver:
with sbpc.Handler(sbpc.Framer(driver.read, driver.write,
args.verbose)) as link:
if os.path.isdir(log_filename):
log_filename = os.path.join(log_filename, s.LOG_FILENAME)
with s.get_logger(args.log, log_filename) as logger:
if args.reset:
link(MsgReset())
link.add_callback(logger)
log_filter = DEFAULT_LOG_LEVEL_FILTER
if args.initloglevel[0]:
log_filter = args.initloglevel[0]
if base and use_broker:
device_id = get_uuid(channel, serial_id)
with HTTPDriver(str(device_id), base) as http_driver:
with sbpc.Handler(
def test_sector_lock_unlock(self):
""" Test if we can lock / unlock sectors. """
unittest.skipIf(self.skip_single, 'Skipping single Piksi tests')
SECTOR = 1
ADDRESS = 0x08004000
if self.verbose: print "--- test_sector_lock_unlock ---"
with serial_link.get_driver(use_ftdi=False, port=self.port1) as driver:
with Handler(driver.read, driver.write) as handler:
with Bootloader(handler) as piksi_bootloader:
with Timeout(TIMEOUT_BOOT) as timeout:
if self.verbose:
print "Waiting for bootloader handshake"
piksi_bootloader.handshake()
if self.verbose: print "Handshaked with bootloader"
with Flash(handler,
flash_type='STM',
sbp_version=piksi_bootloader.sbp_version
) as piksi_flash:
try:
# Erase the sector, lock it, and attempt to write to it.
with Timeout(TIMEOUT_ERASE_SECTOR) as timeout:
if self.verbose:
print "Erasing STM sector:", SECTOR
piksi_flash.erase_sector(SECTOR)
with Timeout(TIMEOUT_LOCK_SECTOR) as timeout:
if self.verbose:
print "Locking STM sector:", SECTOR
piksi_flash.lock_sector(SECTOR)
if self.verbose:
print "Attempting to program address:", hex(
ADDRESS)
piksi_flash.program(ADDRESS, '\x00')
with Timeout(TIMEOUT_READ_STM) as timeout:
byte_read = piksi_flash.read(ADDRESS,
1,
block=True)
self.assertEqual('\xFF', byte_read, \
"Address was programmed")
if self.verbose: print "Program failed as expected"
# Unlock the sector, and attempt to write to it.
with Timeout(TIMEOUT_LOCK_SECTOR) as timeout:
if self.verbose:
print "Unlocking STM sector:", SECTOR
piksi_flash.unlock_sector(SECTOR)
if self.verbose:
print "Attempting to program address:", hex(
ADDRESS)
piksi_flash.program(ADDRESS, '\x00')
with Timeout(TIMEOUT_READ_STM) as timeout:
byte_read = piksi_flash.read(ADDRESS,
1,
block=True)
self.assertEqual('\x00', byte_read, \
"Address was not programmed")
if self.verbose:
print "Program was successful as expected"
except Exception:
# If all else fails, make sure we unlock
# the sector before leaving this test.
with Timeout(TIMEOUT_LOCK_SECTOR) as timeout:
if self.verbose:
print "Had exception, unlocking STM sector:", SECTOR
piksi_flash.unlock_sector(SECTOR)
raise
# Clean up - write valid STM firmware over sector that was erased.
with Timeout(TIMEOUT_WRITE_STM) as timeout:
if self.verbose:
print "Cleaning up, writing firmware to STM flash"
piksi_flash.write_ihx(self.stm_fw,
sys.stdout,
mod_print=0x10)
else:
piksi_flash.write_ihx(self.stm_fw)
def main():
"""
Get configuration, get driver, and build handler and start it.
"""
args = get_args()
port = args.port[0]
baud = args.baud[0]
use_ftdi = args.ftdi
use_m25 = args.m25
use_stm = args.stm
erase = args.erase
# Driver with context
with serial_link.get_driver(use_ftdi, port, baud) as driver:
# Handler with context
with Handler(Framer(driver.read, driver.write)) as link:
link.add_callback(serial_link.log_printer, SBP_MSG_LOG)
link.add_callback(serial_link.printer, SBP_MSG_PRINT_DEP)
# Tell Bootloader we want to write to the flash.
with Bootloader(link) as piksi_bootloader:
print(
"Waiting for bootloader handshake message from Piksi ...",
end=' ')
sys.stdout.flush()
try:
handshake_received = piksi_bootloader.handshake(
args.timeout[0])
except KeyboardInterrupt:
return
if not (handshake_received
and piksi_bootloader.handshake_received):
print("No handshake received.")
sys.exit(1)
print("received.")
print("Piksi Onboard Bootloader Version:",
piksi_bootloader.version)
if piksi_bootloader.sbp_version > (0, 0):
print("Piksi Onboard SBP Protocol Version:",
piksi_bootloader.sbp_version)
# Catch all other errors and exit cleanly.
try:
from . import flash
with flash.Flash(
link,
flash_type=("STM" if use_stm else "M25"),
sbp_version=piksi_bootloader.sbp_version,
max_queued_ops=int(
args.max_queued_ops[0])) as piksi_flash:
if erase:
for s in range(1, 12):
print("\rErasing STM Sector", s, end=' ')
sys.stdout.flush()
piksi_flash.erase_sector(s)
print()
from intelhex import IntelHex
ihx = IntelHex(args.file)
piksi_flash.write_ihx(ihx, sys.stdout, mod_print=0x10)
print("Bootloader jumping to application")
piksi_bootloader.jump_to_app()
except:
import traceback
traceback.print_exc()
try:
self.ports = [p for p, _, _ in s.get_ports()]
if self.ports:
self.port = self.ports[0]
self.bauds = [4800, 9600, 19200, 38400, 43000, 56000, 57600, 115200]
except TypeError:
pass
if not port:
port_chooser = PortChooser()
is_ok = port_chooser.configure_traits()
port = port_chooser.port
baud = port_chooser.baud
if not port or not is_ok:
print "No serial device selected!"
sys.exit(1)
else:
print "Using serial device '%s', bauderate %d" % (port, baud)
with s.get_driver(False, port, baud) as driver:
with sbpc.Handler(sbpc.Framer(driver.read, driver.write, False)) as link:
with s.get_logger() as logger:
sbpc.Forwarder(link, logger).start()
SwiftConsole(link).configure_traits()
# Force exit, even if threads haven't joined
try:
os._exit(0)
except:
pass
self.port = self.ports[0]
self.bauds = [
4800, 9600, 19200, 38400, 43000, 56000, 57600, 115200
]
except TypeError:
pass
if not port:
port_chooser = PortChooser()
is_ok = port_chooser.configure_traits()
port = port_chooser.port
baud = port_chooser.baud
if not port or not is_ok:
print "No serial device selected!"
sys.exit(1)
else:
print "Using serial device '%s', bauderate %d" % (port, baud)
with s.get_driver(False, port, baud) as driver:
with sbpc.Handler(sbpc.Framer(driver.read, driver.write, False)) as link:
with s.get_logger() as logger:
sbpc.Forwarder(link, logger).start()
SwiftConsole(link).configure_traits()
# Force exit, even if threads haven't joined
try:
os._exit(0)
except:
pass
host, port = port.split(':')
selected_driver = TCPDriver(host, int(port))
except:
raise Exception('Invalid host and/or port')
else:
if not port:
port_chooser = PortChooser()
is_ok = port_chooser.configure_traits()
port = port_chooser.port
if not port or not is_ok:
print "No serial device selected!"
sys.exit(1)
else:
print "Using serial device '%s'" % port
selected_driver = s.get_driver(args.ftdi, port, baud, args.file)
with selected_driver as driver:
with sbpc.Handler(sbpc.Framer(driver.read, driver.write, args.verbose)) as link:
if os.path.isdir(log_filename):
log_filename = os.path.join(log_filename, s.LOG_FILENAME)
with s.get_logger(args.log, log_filename) as logger:
if args.reset:
link(MsgReset())
sbpc.Forwarder(link, logger).start()
log_filter = DEFAULT_LOG_LEVEL_FILTER
if args.initloglevel[0]:
log_filter = args.initloglevel[0]
SwiftConsole(link, args.update, log_filter, error=args.error).configure_traits()
# Force exit, even if threads haven't joined
def test_sector_lock_unlock(self):
""" Test if we can lock / unlock sectors. """
unittest.skipIf(self.skip_single, 'Skipping single Piksi tests')
SECTOR = 1
ADDRESS = 0x08004000
if self.verbose: print "--- test_sector_lock_unlock ---"
with serial_link.get_driver(use_ftdi=False, port=self.port1) as driver:
with Handler(driver.read, driver.write) as handler:
with Bootloader(handler) as piksi_bootloader:
with Timeout(TIMEOUT_BOOT) as timeout:
if self.verbose: print "Waiting for bootloader handshake"
piksi_bootloader.handshake()
if self.verbose: print "Handshaked with bootloader"
with Flash(handler, flash_type='STM',
sbp_version=piksi_bootloader.sbp_version) as piksi_flash:
try:
# Erase the sector, lock it, and attempt to write to it.
with Timeout(TIMEOUT_ERASE_SECTOR) as timeout:
if self.verbose: print "Erasing STM sector:", SECTOR
piksi_flash.erase_sector(SECTOR)
with Timeout(TIMEOUT_LOCK_SECTOR) as timeout:
if self.verbose: print "Locking STM sector:", SECTOR
piksi_flash.lock_sector(SECTOR)
if self.verbose: print "Attempting to program address:", hex(ADDRESS)
piksi_flash.program(ADDRESS, '\x00')
with Timeout(TIMEOUT_READ_STM) as timeout:
byte_read = piksi_flash.read(ADDRESS, 1, block=True)
self.assertEqual('\xFF', byte_read, \
"Address was programmed")
if self.verbose: print "Program failed as expected"
# Unlock the sector, and attempt to write to it.
with Timeout(TIMEOUT_LOCK_SECTOR) as timeout:
if self.verbose: print "Unlocking STM sector:", SECTOR
piksi_flash.unlock_sector(SECTOR)
if self.verbose: print "Attempting to program address:", hex(ADDRESS)
piksi_flash.program(ADDRESS, '\x00')
with Timeout(TIMEOUT_READ_STM) as timeout:
byte_read = piksi_flash.read(ADDRESS, 1, block=True)
self.assertEqual('\x00', byte_read, \
"Address was not programmed")
if self.verbose: print "Program was successful as expected"
except Exception:
# If all else fails, make sure we unlock
# the sector before leaving this test.
with Timeout(TIMEOUT_LOCK_SECTOR) as timeout:
if self.verbose: print "Had exception, unlocking STM sector:", SECTOR
piksi_flash.unlock_sector(SECTOR)
raise
# Clean up - write valid STM firmware over sector that was erased.
with Timeout(TIMEOUT_WRITE_STM) as timeout:
if self.verbose:
print "Cleaning up, writing firmware to STM flash"
piksi_flash.write_ihx(self.stm_fw, sys.stdout, mod_print=0x10)
else:
piksi_flash.write_ihx(self.stm_fw)
if not port:
port_chooser = PortChooser()
is_ok = port_chooser.configure_traits()
port = port_chooser.port
if not port or not is_ok:
print "No serial device selected!"
sys.exit(1)
else:
print "Using serial device '%s'" % port
# Make sure that SIGINT (i.e. Ctrl-C from command line) actually stops the
# application event loop (otherwise Qt swallows KeyboardInterrupt exceptions)
signal.signal(signal.SIGINT, signal.SIG_DFL)
with serial_link.get_driver(args.ftdi, port, baud) as driver:
with sbp.client.Handler(
sbp.client.Framer(driver.read, driver.write,
args.verbose)) as link:
with serial_link.get_logger(args.log, log_filename) as logger:
link.add_callback(logger)
if args.reset:
link(MsgReset())
log_level_filter = DEFAULT_LOG_LEVEL_FILTER
if args.initloglevel[0]:
log_level_filter = args.initloglevel[0]
console = SwiftConsole(link,
update=args.update,
log_level_filter=log_level_filter)
console.configure_traits()
def main():
"""
Get configuration, get driver, get logger, and build handler and start it.
Create relevant TestState object and perform associated actions.
Modeled after serial_link main function.
"""
args = get_args()
port = args.port[0]
baud = args.baud[0]
timeout = args.timeout[0]
log_filename = args.log_filename[0]
append_log_filename = args.append_log_filename[0]
watchdog = args.watchdog[0]
tags = args.tags[0]
interval = int(args.interval[0])
minsats = int(args.minsats[0])
# Driver with context
with sl.get_driver(args.ftdi, port, baud) as driver:
# Handler with context
with Handler(driver.read, driver.write, args.verbose) as link:
# Logger with context
with sl.get_logger(args.log, log_filename) as logger:
# Append logger iwth context
with sl.get_append_logger(append_log_filename, tags) as append_logger:
# print out SBP_MSG_PRINT messages
link.add_callback(sl.printer, SBP_MSG_PRINT)
# add logger callback
link.add_callback(logger)
# ad append logger callback
link.add_callback(append_logger)
# Reset device
if args.reset:
link.send(SBP_MSG_RESET, "")
# Setup watchdog
if watchdog:
link.add_callback(sl.Watchdog(float(watchdog), sl.watchdog_alarm),
SBP_MSG_HEARTBEAT)
try:
# Get device info
piksi_diag = ptd.Diagnostics(link)
while not piksi_diag.heartbeat_received:
time.sleep(0.1)
# add Teststates and associated callbacks
with DropSatsState(link, piksi_diag.sbp_version, interval,
minsats, debug=args.verbose) as drop:
link.add_callback(drop.process_message)
if timeout is not None:
expire = time.time() + float(args.timeout[0])
while True:
if timeout is None or time.time() < expire:
# Wait forever until the user presses Ctrl-C
time.sleep(1)
else:
print "Timer expired!"
break
if not link.is_alive():
sys.stderr.write("ERROR: Thread died!")
sys.exit(1)
except KeyboardInterrupt:
# Callbacks, such as the watchdog timer on SBP_HEARTBEAT call
# thread.interrupt_main(), which throw a KeyboardInterrupt
# exception. To get the proper error condition, return exit code
# of 1. Note that the finally block does get caught since exit
# itself throws a SystemExit exception.
sys.exit(1)
selected_driver = None
connection_description = ""
if port and args.tcp:
# Use the TPC driver and interpret port arg as host:port
try:
host, ip_port = port.split(':')
selected_driver = TCPDriver(host, int(ip_port))
connection_description = port
except:
raise Exception('Invalid host and/or port')
sys.exit(1)
elif port and args.file:
# Use file and interpret port arg as the file
print("Using file '%s'" % port)
selected_driver = s.get_driver(args.ftdi, port, baud, args.file)
connection_description = os.path.split(port)[-1]
elif not port:
# Use the gui to get our driver
port_chooser = PortChooser(baudrate=int(args.baud))
is_ok = port_chooser.configure_traits()
ip_address = port_chooser.ip_address
ip_port = port_chooser.ip_port
port = port_chooser.port
baud = port_chooser.baudrate
mode = port_chooser.mode
# todo, update for sfw flow control if ever enabled
rtscts = port_chooser.flow_control == flow_control_options_list[1]
if rtscts:
print("using flow control")
# if the user pressed cancel or didn't select anything
def main():
warnings.simplefilter(action="ignore", category=FutureWarning)
logging.basicConfig()
args = None
parser = get_args()
try:
args = parser.parse_args()
port = args.port
baud = args.baud
show_usage = args.help
error_str = ""
except (ArgumentParserError, argparse.ArgumentError,
argparse.ArgumentTypeError) as e:
print(e)
show_usage = True
error_str = "ERROR: " + str(e)
if args and args.toolkit[0] is not None:
ETSConfig.toolkit = args.toolkit[0]
else:
ETSConfig.toolkit = 'qt4'
# Make sure that SIGINT (i.e. Ctrl-C from command line) actually stops the
# application event loop (otherwise Qt swallows KeyboardInterrupt exceptions)
signal.signal(signal.SIGINT, signal.SIG_DFL)
if show_usage:
usage_str = parser.format_help()
print(usage_str)
usage = ShowUsage(usage_str, error_str)
usage.configure_traits()
sys.exit(1)
selected_driver = None
connection_description = ""
if port and args.tcp:
# Use the TPC driver and interpret port arg as host:port
try:
host, ip_port = port.split(':')
selected_driver = TCPDriver(host, int(ip_port))
connection_description = port
except:
raise Exception('Invalid host and/or port')
sys.exit(1)
elif port and args.file:
# Use file and interpret port arg as the file
print("Using file '%s'" % port)
selected_driver = s.get_driver(args.ftdi, port, baud, args.file)
connection_description = os.path.split(port)[-1]
elif not port:
# Use the gui to get our driver
port_chooser = PortChooser(baudrate=int(args.baud))
is_ok = port_chooser.configure_traits()
ip_address = port_chooser.ip_address
ip_port = port_chooser.ip_port
port = port_chooser.port
baud = port_chooser.baudrate
mode = port_chooser.mode
# todo, update for sfw flow control if ever enabled
rtscts = port_chooser.flow_control == flow_control_options_list[1]
if rtscts:
print("using flow control")
# if the user pressed cancel or didn't select anything
if not (port or (ip_address and ip_port)) or not is_ok:
print("No Interface selected!")
sys.exit(1)
else:
# Use either TCP/IP or serial selected from gui
if mode == cnx_type_list[1]:
print("Using TCP/IP at address %s and port %d" % (ip_address,
ip_port))
selected_driver = TCPDriver(ip_address, int(ip_port))
connection_description = ip_address + ":" + str(ip_port)
else:
print("Using serial device '%s'" % port)
selected_driver = s.get_driver(
args.ftdi, port, baud, args.file, rtscts=rtscts)
connection_description = os.path.split(port)[-1] + " @" + str(baud)
else:
# Use the port passed and assume serial connection
print("Using serial device '%s'" % port)
selected_driver = s.get_driver(
args.ftdi, port, baud, args.file, rtscts=args.rtscts)
connection_description = os.path.split(port)[-1] + " @" + str(baud)
with selected_driver as driver:
with sbpc.Handler(
sbpc.Framer(driver.read, driver.write, args.verbose)) as link:
if args.reset:
link(MsgReset(flags=0))
log_filter = DEFAULT_LOG_LEVEL_FILTER
if args.initloglevel[0]:
log_filter = args.initloglevel[0]
with SwiftConsole(
link,
args.update,
log_filter,
cnx_desc=connection_description,
error=args.error,
json_logging=args.log,
log_dirname=args.log_dirname,
override_filename=args.logfilename,
log_console=args.log_console,
networking=args.networking,
serial_upgrade=args.serial_upgrade) as console:
console.configure_traits()
# Force exit, even if threads haven't joined
try:
os._exit(0)
except:
pass
