def main(args): """ Get configuration, get driver, get logger, and build handler and start it. """ timeout = args.timeout log_filename = args.logfilename log_dirname = args.log_dirname if not log_filename: log_filename = logfilename() if log_dirname: log_filename = os.path.join(log_dirname, log_filename) # State for handling a networked base stations. channel = args.channel_id serial_id = int(args.serial_id) if args.serial_id is not None else None base = args.base use_broker = args.broker # Driver with context driver = get_base_args_driver(args) with Handler(Framer(driver.read, driver.write, args.verbose)) as link: # Logger with context with get_logger(args.log, log_filename, args.expand_json) as logger: link.add_callback(printer, SBP_MSG_PRINT_DEP) link.add_callback(log_printer, SBP_MSG_LOG) Forwarder(link, logger).start() if use_broker and base and serial_id: device_id = get_uuid(channel, serial_id) with HTTPDriver(str(device_id), base) as http: with Handler(Framer(http.read, http.write, args.verbose)) as slink: Forwarder(slink, swriter(link)).start() run(args, link) else: run(args, link)
def main(args): """ Get configuration, get driver, get logger, and build handler and start it. """ port = args.port baud = args.baud timeout = args.timeout log_filename = args.log_filename append_log_filename = args.append_log_filename tags = args.tags # State for handling a networked base stations. channel = args.channel_id serial_id = int(args.serial_id) if args.serial_id is not None else None base = args.base use_broker = args.broker # Driver with context with get_driver(args.ftdi, port, baud, args.file) as driver: # Handler with context with Handler(Framer(driver.read, driver.write, args.verbose)) as link: # Logger with context with get_logger(args.log, log_filename) as logger: with get_append_logger(append_log_filename, tags) as append_logger: link.add_callback(printer, SBP_MSG_PRINT_DEP) link.add_callback(log_printer, SBP_MSG_LOG) Forwarder(link, logger).start() Forwarder(link, append_logger).start() if use_broker and base and serial_id: device_id = get_uuid(channel, serial_id) with HTTPDriver(str(device_id), base) as http: with Handler(Framer(http.read, http.write, args.verbose)) as slink: Forwarder(slink, swriter(link)).start() run(args, link) else: run(args, link)
def main(args): """ Get configuration, get driver, get logger, and build handler and start it. """ port = args.port baud = args.baud timeout = args.timeout log_filename = args.logfilename log_dirname = args.log_dirname if not log_filename: log_filename = logfilename() if log_dirname: log_filename = os.path.join(log_dirname, log_filename) append_log_filename = args.append_log_filename tags = args.tags # State for handling a networked base stations. channel = args.channel_id serial_id = int(args.serial_id) if args.serial_id is not None else None base = args.base use_broker = args.broker # Driver with context if args.tcp: try: host, port = port.split(':') driver = TCPDriver(host, int(port)) except: # noqa raise Exception('Invalid host and/or port') else: driver = get_driver(args.ftdi, port, baud, args.file, rtscts=args.rtscts) # Handler with context with Handler(Framer(driver.read, driver.write, args.verbose)) as link: # Logger with context with get_logger(args.log, log_filename, args.expand_json) as logger: with get_append_logger(append_log_filename, tags) as append_logger: link.add_callback(printer, SBP_MSG_PRINT_DEP) link.add_callback(log_printer, SBP_MSG_LOG) Forwarder(link, logger).start() Forwarder(link, append_logger).start() if use_broker and base and serial_id: device_id = get_uuid(channel, serial_id) with HTTPDriver(str(device_id), base) as http: with Handler( Framer(http.read, http.write, args.verbose)) as slink: Forwarder(slink, swriter(link)).start() run(args, link) else: run(args, link)
def radio_corrections(): last_radio_epoch = None radio_epoch = None radio_tow = 0 with PySerialDriver(RADIO_PORT, baud=RADIO_BAUDRATE) as driver: print(driver.read) with Handler(Framer(driver.read, None, verbose=False)) as source: try: for msg, metadata in source.filter( [SBP_MSG_OBS, SBP_MSG_GLO_BIASES, SBP_MSG_BASE_POS_ECEF]): # change radio sender ID to ntrip to avoid temporal glitch #msg.sender = 65202 # update epoch if msg.msg_type == 74: radio_epoch = radio_tow = msg.header.t.tow rospy.loginfo("Radio, %i, %i, %s", radio_tow, msg.msg_type, hex(msg.header.n_obs)) if msg.msg_type == 117: rospy.loginfo("Radio, %i, %i, None", radio_tow, msg.msg_type) udp.call(msg) except KeyboardInterrupt: pass
def main(): with closing(socket.socket(socket.AF_INET, socket.SOCK_DGRAM)) as sbp_udp: sbp_udp.setblocking(1) sbp_udp.settimeout(None) sbp_udp.bind((DEFAULT_UDP_BIND_ADDRESS, DEFAULT_UDP_RECV_PORT)) def handle_incoming(msg, **metadata): sbp_udp.sendto(msg.pack(), (DEFAULT_UDP_SEND_ADDRESS, DEFAULT_UDP_SEND_PORT)) with PySerialDriver(DEFAULT_SERIAL_PORT, DEFAULT_SERIAL_BAUD) as driver: with Handler(Framer(driver.read, driver.write)) as handler: handler.add_callback(handle_incoming) print "***" print "*** Solo Relay Running" print "***" print "Sending to %s : %s" % (DEFAULT_UDP_SEND_ADDRESS, DEFAULT_UDP_SEND_PORT) print "Recving on %s : %s" % (DEFAULT_UDP_BIND_ADDRESS, DEFAULT_UDP_RECV_PORT) try: while True: data, addr = sbp_udp.recvfrom(4096) driver.write(data) except KeyboardInterrupt: pass
def main(args=None): """ Get configuration, get driver, and build handler and start it. """ args = get_args(args) command = args.command driver = serial_link.get_base_args_driver(args) with Handler(Framer(driver.read, driver.write, verbose=args.verbose)) as link: settings = Settings(link, timeout=args.timeout) with settings: 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(): parser = argparse.ArgumentParser( description="Export position suitable for KML file.") parser.add_argument("-a", "--host", default='192.168.5.51', help="specify the host address.") parser.add_argument("-p", "--port", default=55555, help="specify the port to use.") args = parser.parse_args() prev = None # Open a connection to Piksi using TCP with TCPDriver(args.host, args.port) as driver: with Handler(Framer(driver.read, None, verbose=True)) as source: try: for msg, metadata in source.filter(SBP_MSG_POS_LLH): cur = (msg.lat, msg.lon) if prev: dist = vincenty(prev, cur).meters #print(dist) if dist > 0.1: print("%.16f,%.16f,%.16f" % (msg.lon, msg.lat, msg.height)) prev = cur else: prev = cur except KeyboardInterrupt: pass
def __init__(self, host, port, callback): self._callback = callback self.driver = UDPDriver(host, port) self.framer = Framer(self.driver.read, None, verbose=False) self.piksi = Handler(self.framer) self.piksi.add_callback(self.callback) self.piksi.start()
def __init__(self, port, baud_rate, callback): self._callback = callback self.driver = PySerialDriver(port, baud=baud_rate) self.framer = Framer(self.driver.read, None, verbose=False) self.piksi = Handler(self.framer) self.piksi.add_callback(self.callback) self.piksi.start()
def write_ini_file(file_name, port='/dev/ttyUSB0', baud=115200): ''' Write setting from an ini file to the Multi Args: file_name: file name of the ini file port: serial port [default='/dev/ttyUSB0'] baud: baud rate [default=115200] Returns: None ''' print('Reading from {} at {}'.format(port, baud)) with PySerialDriver(port, baud) as driver: with Handler(Framer(driver.read, driver.write, verbose=True)) as source: parser = configparser.ConfigParser() parser.optionxform = str with open(file_name, 'r') as f: parser.read_file(f) source.add_callback(settings_callback, SBP_MSG_SETTINGS_READ_RESP) for section, settings in parser.items(): print('\nSECTION: {}'.format(section)) for setting, value in settings.items(): print('{} = {}'.format(setting, value)) write(source, section, setting, value) source(MsgSettingsSave())
def main(): args = get_args() selected_driver = serial_link.get_base_args_driver(args) # 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(raw_filename(args.write[1]), bytearray(open(args.write[0], 'rb').read())) elif args.read: if len(args.read) not in [1, 2]: sys.stderr.write("Error: fileio read requires either 1 or 2 arguments, SOURCE and optionally DEST.") sys.exit(1) data = f.read(raw_filename(args.read[0])) if len(args.read) == 2: with open(args.read[1], ('w' if args.hex else 'wb')) as fd: fd.write(hexdump(data) if args.hex else data) elif args.hex: print(hexdump(data)) else: print(printable_text_from_device(data)) elif args.delete: f.remove(raw_filename(args.delete[0])) elif args.list is not None: print_dir_listing(f.readdir(raw_filename(args.list[0]))) else: print("No command given, listing root directory:") print_dir_listing(f.readdir()) except KeyboardInterrupt: pass
def main(): parser = argparse.ArgumentParser( description="Swift Navigation SBP Example.") parser.add_argument( "-a", "--host", default='localhost', help="specify the host address.") parser.add_argument( "-p", "--port", default=55555, help="specify the port to use.") args = parser.parse_args() # Open a connection to Piksi using TCP with TCPDriver(args.host, args.port) as driver: with Handler(Framer(driver.read, None, verbose=True)) as source: try: for msg, metadata in source.filter(SBP_MSG_BASELINE_NED): # Print out the N, E, D coordinates of the baseline print("%.4f,%.4f,%.4f" % (msg.n * 1e-3, msg.e * 1e-3, msg.d * 1e-3)) except KeyboardInterrupt: pass
def connect_piksi(self): self.piksi_driver = TCPDriver(self.piksi_host, self.piksi_port) #self.piksi_driver = PySerialDriver(self.piksi_port, baud=1000000) self.piksi_framer = Framer(self.piksi_driver.read, self.piksi_driver.write, verbose=False) self.piksi = Handler(self.piksi_framer) # Only setup log and settings messages # We will wait to set up rest until piksi is configured self.piksi.add_callback(self.callback_sbp_heartbeat, msg_type=SBP_MSG_HEARTBEAT) self.piksi.add_callback(self.callback_sbp_log, msg_type=SBP_MSG_LOG) self.piksi.add_callback(self.callback_sbp_settings_read_resp, msg_type=SBP_MSG_SETTINGS_READ_RESP) self.piksi.add_callback(self.callback_sbp_settings_read_by_index_resp, msg_type=SBP_MSG_SETTINGS_READ_BY_INDEX_REQ) self.piksi.add_callback(self.callback_sbp_settings_read_by_index_resp, msg_type=SBP_MSG_SETTINGS_READ_BY_INDEX_RESP) self.piksi.add_callback(self.callback_sbp_settings_read_by_index_done, msg_type=SBP_MSG_SETTINGS_READ_BY_INDEX_DONE) self.piksi.add_callback(self.callback_sbp_startup, SBP_MSG_STARTUP) self.piksi.start()
def run(self): '''Thread loop here''' # Problems? See: https://pylibftdi.readthedocs.org/en/latest/troubleshooting.html # with PyFTDIDriver(self.sbp_baud) as driver: try: with PySerialDriver(self.sbp_port, baud=self.sbp_baud) as driver: self.driver = driver self.framer = Framer(driver.read, driver.write) with Handler(self.framer) as handler: self.handler = handler handler.add_callback(self.handle_basestation_obs, msg_type=[SBP_MSG_OBS, SBP_MSG_BASE_POS_LLH]) self.ready() #TODO: Get rid of "for msg, metadaya..." try: for msg, metadata in handler: if self.stopped(): return pass except KeyboardInterrupt: raise except socket.error: raise except SystemExit: print "Exit Forced. We're dead." return except: traceback.print_exc() self.ready()
def main(): """ Get configuration, get driver, and build handler and start it. """ args = get_args() driver = serial_link.get_base_args_driver(args) # Driver with context # Handler with context with Handler(Framer(driver.read, driver.write, verbose=args.verbose)) as link: data = bytearray(open(args.firmware, 'rb').read()) def progress_cb(size, _): sys.stdout.write("\rProgress: %d%% \r" % (100 * size / len(data))) sys.stdout.flush() print('Transferring image file...') FileIO(link).write(b"upgrade.image_set.bin", data, progress_cb=progress_cb) print('Committing file to flash...') link.add_callback(serial_link.log_printer, SBP_MSG_LOG) link.add_callback(serial_link.printer, SBP_MSG_PRINT_DEP) code = shell_command(link, b"upgrade_tool upgrade.image_set.bin", 300) if code != 0: print('Failed to perform upgrade (code = %d)' % code) return print('Resetting Piksi...') link(MsgReset(flags=0))
def main(): """ Get configuration, get driver, and build handler and start it. """ args = get_args() port = args.port[0] baud = args.baud[0] # Driver with context with serial_link.get_driver(args.ftdi, port, baud) as driver: # Handler with context with Handler(Framer(driver.read, driver.write)) as link: print("Resetting mask to 0xff") send_setting(link, "uart_ftdi", "sbp_message_mask", "65535") time.sleep(0.5) print("Resetting baudrate to 1Mbps") send_setting(link, "uart_ftdi", "baudrate", "1000000") time.sleep(0.5) print("Resetting mode to SBP") send_setting(link, "uart_ftdi", "mode", "SBP") time.sleep(0.5) print("Attempting to save settings") link.send(SBP_MSG_SETTINGS_SAVE, "") time.sleep(0.5) link.send(SBP_MSG_SETTINGS_SAVE, "") time.sleep(0.5) link.send(SBP_MSG_SETTINGS_SAVE, "") time.sleep(0.5) link.send(SBP_MSG_SETTINGS_SAVE, "") print("Sent Settings Reset message to return FTDI to defaults")
def radio_corrections(q_radio): global radio_sender # get radio sender id radio_rate = 5 #hz with PySerialDriver(RADIO_PORT, baud=RADIO_BAUDRATE) as driver: print(driver.read) with Handler(Framer(driver.read, None, verbose=False)) as source: try: for sbp_msg, metadata in source.filter(): start_time = rospy.get_time() if radio_sender is None: radio_sender = sbp_msg.sender q_radio.put(sbp_msg) if debug and sbp_msg.msg_type == sbp.observation.SBP_MSG_OBS: radio_txt_file.write(str(dispatch(sbp_msg)) + "\n") end_time = rospy.get_time() sleep_time = max( [0, 1 / radio_rate - (end_time - start_time)]) rospy.sleep(sleep_time) except KeyboardInterrupt: pass
def __init__(self, port, ext_callback): self._callback = ext_callback self.driver = UDPDriver(' ', port) self.framer = Framer(self.driver.read, None, verbose=False) self.piksi = Handler(self.framer) self.piksi.add_callback(self.recv_callback) self.piksi.start()
def test_tcp_logger(): handler = tcp_handler(MsgPrintDep(text=b'abc').to_binary()) ip, port = tcp_server(handler) t0 = time.time() sleep = 0.1 timeout = 5.0 cb_context = {'assert_logger_called': False} def assert_logger(s, **metadata): cb_context['assert_logger_called'] = True assert s.preamble == 0x55 assert s.msg_type == 0x10 assert s.sender == 66 assert s.length == 3 assert s.payload == b'abc' assert s.crc == 0xDAEE with TCPDriver(ip, port) as driver: with Handler(Framer(driver.read, None, verbose=False), autostart=False) as link: link.add_callback(assert_logger) link.start() while True: if time.time() - t0 > timeout or cb_context[ 'assert_logger_called']: break time.sleep(sleep) assert cb_context[ 'assert_logger_called'], "SBP msg callback function was not called"
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 # 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) data = open(args.file, 'rb').read() def progress_cb(size): sys.stdout.write("\rProgress: %d%% \r" % (100 * size / len(data))) sys.stdout.flush() print('Transferring image file...') FileIO(link).write("upgrade.image_set.bin", data, progress_cb=progress_cb) print('Committing file to flash...') code = shell_command(link, "upgrade_tool upgrade.image_set.bin", 300) if code != 0: print('Failed to perform upgrade (code = %d)' % code) return print('Resetting Piksi...') link(MsgReset(flags=0))
def main(): # Initialize ROS node. We imitate node name present in # http://github.com/ethz-asl/ethz_piksi_ros/tree/master/piksi_multi_rtk_ros rospy.init_node('piksi') # Initialize publisher. We imitate publisher names present in # http://github.com/ethz-asl/ethz_piksi_ros/tree/master/piksi_multi_rtk_ros pub = rospy.Publisher('~navsatfix_best_fix', NavSatFix, queue_size=10) # Retrive parameters from the ROS parameter serve # We imitate parameter names present in # http://github.com/ethz-asl/ethz_piksi_ros/tree/master/piksi_multi_rtk_ros host = rospy.get_param('~tcp_addr', '192.168.0.222') port = rospy.get_param('~tcp_port', 55555) # Start listening for GNSS data on a TCP socket with a ROS-param-provided # host and port. This code is almost copy-pasted from examples of the sbp # package with TCPDriver(host, port) as driver: with Handler(Framer(driver.read, None, verbose=True)) as source: try: # Filter on SBP_MSG_POS_LLH-messages (LLH stands for # Longitude Latitude Height) for msg, metadata in source.filter(SBP_MSG_POS_LLH): _publish_navsatfix(pub, msg) if rospy.is_shutdown(): break except KeyboardInterrupt: pass
def main(): parser = argparse.ArgumentParser( description="Swift Navigation SBP Example.") parser.add_argument("-a", "--host", default='localhost', help="specify the host address.") parser.add_argument("-p", "--port", default=55555, help="specify the port to use.") args = parser.parse_args() # Open a connection to Piksi using TCP with TCPDriver(args.host, args.port) as driver: with Handler(Framer(driver.read, None, verbose=True)) as source: try: for msg, metadata in source.filter(SBP_MSG_POS_LLH): # Print out the N, E, D coordinates of the baseline print( "%d,%.16f,%.16f,%.16f,%d,%d,%d,%d" % (msg.tow, msg.lat, msg.lon, msg.height, msg.h_accuracy, msg.v_accuracy, msg.n_sats, msg.flags)) except KeyboardInterrupt: pass
def getData(portNum): ''' Gets NED vector from Piksi GPS located at /dev/ttyUSB[portNum]. If two Piksi GPSs are talking, NED vector is in meters. ''' directory = '/dev/ttyUSB' + str(portNum) north = None east = None down = None # Open a connection to Piksi using the default baud rate (1Mbaud) try: with PySerialDriver(directory, baud=1000000) as driver: with Handler(Framer(driver.read, None)) as source: for msg, metadata in source.filter(SBP_MSG_BASELINE_NED): north = msg.n * 1e-3 east = msg.e * 1e-3 down = msg.d * 1e-3 if north != None and east != None and down != None: return north,east,down except Exception as e: print('Error: ' + str(e)) return
def test_http_test_pass(): assert is_enabled() msg = MsgPrintDep(text='abcd') register_uri(GET, BASE_STATION_URI, msg.to_binary(), content_type="application/vnd.swiftnav.broker.v1+sbp2") register_uri(PUT, BASE_STATION_URI, '', content_type="application/vnd.swiftnav.broker.v1+sbp2") with HTTPDriver(device_uid="Swift22", url=BASE_STATION_URI) as driver: assert not driver.read_ok assert driver.connect_read() assert driver.read_ok assert driver.read(size=255) == msg.to_binary() with pytest.raises(IOError): assert driver.read(size=255) assert not driver.read_close() assert driver.read_response is None assert not driver.read_ok with pytest.raises(ValueError): driver.read(size=255) with HTTPDriver(device_uid="Swift22", url=BASE_STATION_URI) as http: with Handler(Framer(http.read, http.write, False)) as link: def tester(sbp_msg, **metadata): assert sbp_msg.payload == msg.payload link.add_callback(SBP_MSG_PRINT_DEP, tester) t0 = time.time() sleep = 0.1 while True: if time.time() - t0 < sleep: break
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(): parser = argparse.ArgumentParser( description="Swift Navigation SBP Setting Monitor example.") parser.add_argument("-H", "--host", required=True, help="specify the host address.") parser.add_argument("-p", "--port", default=55556, help="specify the port to use.") args = parser.parse_args() monitor = SettingMonitor() with TCPDriver(args.host, args.port) as driver: with Handler(Framer(driver.read, driver.write, verbose=True)) as link: driver.flush() time.sleep(2) # Capture setting messages link.add_callback(monitor.capture_setting, SBP_MSG_SETTINGS_READ_RESP) link.add_callback(print_setting, SBP_MSG_SETTINGS_READ_RESP) # Disable spectrum analyzer link( MsgSettingsWrite( setting=b'%s\0%s\0%s\0' % (b'system_monitor', b'spectrum_analyzer', b'False'))) # Request the value of the system_monitor:spectrum_analyzer setting link( MsgSettingsReadReq( setting=b'%s\0%s\0' % (b'system_monitor', b'spectrum_analyzer'))) # Wait up to 5 seconds to see the setting we want specan_off = monitor.wait_for_setting_value( b'system_monitor', b'spectrum_analyzer', b'False') assert (specan_off == True) print("Spectrum analyzer turned off!") # Request the value of the system_monitor:spectrum_analyzer setting link( MsgSettingsReadReq( setting=b'%s\0%s\0' % (b'system_monitor', b'spectrum_analyzer'))) # Wait up to 5 seconds to see the setting we (don't) want specan_off = monitor.wait_for_setting_value( b'system_monitor', b'spectrum_analyzer', b'True') assert (specan_off == False) print("Spectrum analyzer still off!")
def get_position(): with PySerialDriver(SERIAL_PORT_IN, baud=SERIAL_BAUD_IN) as driver: with Handler(Framer(driver.read, None, verbose=True)) as source: try: for msg, metadata in source.filter(SBP_MSG_POS_LLH): pos = msg.lat, msg.lon, msg.flags, msg.n_sats break except KeyboardInterrupt: pass return pos
def get_imu(): with PySerialDriver(SERIAL_PORT_IN, baud=SERIAL_BAUD_IN) as driver: with Handler(Framer(driver.read, None, verbose=True)) as source: try: for msg, metadata in source.filter(SBP_MSG_IMU_RAW): rate = msg.acc_x/4095.75, msg.acc_y/4095.75, msg.acc_z/4095.75 break except KeyboardInterrupt: pass return rate
def simple_read(): with PySerialDriver(USB_Piksi, baud=1000000) as driver: with Handler(Framer(driver.read, None, verbose=False)) as source: for msg, metadata in source.filter(SBP_MSG_POS_LLH): # Store the latitude, longitude and number of satellites #print "Lat:", msg.lat, "Lon:", msg.lon, "nSats:", msg.n_sats SBPComm.lat, SBPComm.lon = msg.lat, msg.lon SBPComm.height = msg.height SBPComm.n_sats = msg.n_sats