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
