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_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)
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