def get_base_config():
config = configs.EnvelopeServiceConfig()
config.session_profile = configs.EnvelopeServiceConfig.MAX_SNR
config.range_interval = [0.3, 0.8]
config.sweep_rate = 50
config.gain = 0.7
return config
def get_sensor_config():
config = configs.EnvelopeServiceConfig()
config.session_profile = configs.EnvelopeServiceConfig.DIRECT_LEAKAGE
config.range_interval = [0.04, 0.05]
config.running_average_factor = 0.01
config.sweep_rate = 60
config.gain = 0.2
return config
def config_setup():
config = configs.EnvelopeServiceConfig()
# config = configs.IQServiceConfig()
config.range_interval = [0.4, 0.8]
config.sweep_rate = 10
config.gain = 1
config.session_profile = configs.EnvelopeServiceConfig.MAX_SNR
return config
def config_setup():
config = configs.EnvelopeServiceConfig()
config.range_interval = [0.3, 0.7]
config.sweep_rate = 2
config.gain = 1
config.session_profile = configs.EnvelopeServiceConfig.MAX_DEPTH_RESOLUTION
#config.session_profile = configs.EnvelopeServiceConfig.MAX_SNR
print(config.gain)
return config
def test_envelope(setup):
client, sensor = setup
config = configs.EnvelopeServiceConfig(sensor=sensor)
session_info = client.start_streaming(config)
_, sweep = client.get_next()
client.stop_streaming()
assert sweep.shape == (session_info["data_length"], )
def __init__(self, demo_ctrl, params):
super().__init__(demo_ctrl, self.detector_name)
self.config = configs.EnvelopeServiceConfig()
self.update_config(params)
if "profile" in params:
if params["profile"] == "0":
self.config.session_profile = configs.EnvelopeServiceConfig.MAX_SNR
elif params["profile"] == "1":
self.config.session_profile = configs.EnvelopeServiceConfig.MAX_DEPTH_RESOLUTION
else:
print("Unknown profile")
def main():
args = example_utils.ExampleArgumentParser().parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = SocketClient(args.socket_addr)
elif args.spi:
client = SPIClient()
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = UARTClient(port)
client.squeeze = False
config = configs.EnvelopeServiceConfig()
config.sensor = args.sensors
config.range_interval = [0.3, 0.8]
config.sweep_rate = 70
config.gain = 0.6
# config.experimental_stitching = True
# config.session_profile = configs.EnvelopeServiceConfig.MAX_SNR
# config.running_average_factor = 0.5
# config.compensate_phase = False # not recommended
info = client.setup_session(config)
num_points = info["data_length"]
pg_updater = PGUpdater(config, num_points)
pg_process = PGProcess(pg_updater)
pg_process.start()
client.start_streaming()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
while not interrupt_handler.got_signal:
info, data = client.get_next()
try:
pg_process.put_data(data)
print(data)
input("Enter")
except PGProccessDiedException:
break
print("Disconnecting...")
pg_process.close()
client.disconnect()
def init_dropdowns(self):
self.mode = QComboBox(self)
self.mode.addItem("Select service")
self.mode.addItem("IQ")
self.mode.addItem("Envelope")
self.mode.addItem("Power bin")
self.mode.addItem("Phase tracking")
self.mode.addItem("Presence detection")
self.mode.addItem("Breathing")
self.mode.addItem("Sleep breathing")
self.mode.addItem("Obstacle detection")
self.mode.move(50, 250)
self.mode_to_param = {
"Select service": "",
"IQ": "iq_data",
"Envelope": "envelope_data",
"Power bin": "power_bin",
"Breathing": "iq_data",
"Phase tracking": "iq_data",
"Presence detection": "iq_data",
"Sleep breathing": "iq_data",
"Obstacle detection": "iq_data",
}
self.mode_to_config = {
"Select service": ["", ""],
"IQ": [configs.IQServiceConfig(), "internal"],
"Envelope": [configs.EnvelopeServiceConfig(), "internal"],
"Power bin": [configs.PowerBinServiceConfig(), "internal_power"],
"Breathing": [br.get_base_config(), "external"],
"Phase tracking": [pht.get_base_config(), "external"],
"Presence detection": [prd.get_base_config(), "external"],
"Sleep breathing": [sb.get_base_config(), "external"],
"Obstacle detection": [od.get_base_config(), "external"]
}
self.mode.currentIndexChanged.connect(self.update_canvas)
self.interface = QComboBox(self)
self.interface.addItem("Socket")
self.interface.addItem("Serial")
self.interface.currentIndexChanged.connect(self.update_interface)
self.ports = QComboBox(self)
self.ports.addItem("Scan ports")
self.ports.activated.connect(self.update_ports)
self.update_ports()
def main():
args = example_utils.ExampleArgumentParser().parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = SocketClient(args.socket_addr)
elif args.spi:
client = SPIClient()
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = UARTClient(port)
# Normally when using a single sensor, get_next will return
# (info, data). When using mulitple sensors, get_next will return
# lists of info and data for each sensor, i.e. ([info], [data]).
# This is commonly called squeezing. To disable squeezing, making
# get_next _always_ return lists, set:
# client.squeeze = False
config = configs.EnvelopeServiceConfig()
config.sensor = args.sensors
config.range_interval = [0.2, 0.3]
config.sweep_rate = 5
session_info = client.setup_session(config)
print("Session info:\n", session_info, "\n")
# Now would be the time to set up plotting, signal processing, etc.
client.start_streaming()
# Normally, hitting Ctrl-C will raise a KeyboardInterrupt which in
# most cases immediately terminates the script. This often becomes
# an issue when plotting and also doesn't allow us to disconnect
# gracefully. Setting up an ExampleInterruptHandler will capture the
# keyboard interrupt signal so that a KeyboardInterrupt isn't raised
# and we can take care of the signal ourselves. In case you get
# impatient, hitting Ctrl-C a couple of more times will raise a
# KeyboardInterrupt which hopefully terminates the script.
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session\n")
while not interrupt_handler.got_signal:
info, data = client.get_next()
print(info, "\n", data, "\n")
print("Disconnecting...")
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser().parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = SocketClient(args.socket_addr)
elif args.spi:
client = SPIClient()
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = UARTClient(port)
config = configs.EnvelopeServiceConfig()
config.sensor = args.sensors
config.range_interval = [0.2, 0.6]
config.sweep_rate = 10
client.start_streaming(config)
client.get_next()
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser().parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = SocketClient(args.socket_addr)
elif args.spi:
client = SPIClient()
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = UARTClient(port)
config = configs.EnvelopeServiceConfig()
config.sensor = args.sensors
info = client.connect()
print("connect info:", info)
client.start_streaming(config)
client.get_next()
client.disconnect()
def get_sensor_config():
return configs.EnvelopeServiceConfig()
def main():
args = example_utils.ExampleArgumentParser(num_sens=1).parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
config = configs.EnvelopeServiceConfig()
config.sensor = args.sensors
config.range_interval = [0.2, 0.6]
config.sweep_rate = 60
config.gain = 0.65
info = client.setup_session(config)
num_points = info["data_length"]
xs = np.linspace(*config.range_interval, num_points)
num_hist = 2 * config.sweep_rate
hist_data = np.zeros([num_hist, num_points])
hist_max = np.zeros(num_hist)
smooth_max = example_utils.SmoothMax(config.sweep_rate)
app = QtGui.QApplication([])
pg.setConfigOption("background", "w")
pg.setConfigOption("foreground", "k")
pg.setConfigOptions(antialias=True)
win = pg.GraphicsLayoutWidget()
win.closeEvent = lambda _: interrupt_handler.force_signal_interrupt()
win.setWindowTitle("Acconeer PyQtGraph example")
env_plot = win.addPlot(title="Envelope")
env_plot.showGrid(x=True, y=True)
env_plot.setLabel("bottom", "Depth (m)")
env_plot.setLabel("left", "Amplitude")
env_curve = env_plot.plot(pen=pg.mkPen("k", width=2))
win.nextRow()
hist_plot = win.addPlot()
hist_plot.setLabel("bottom", "Time (s)")
hist_plot.setLabel("left", "Depth (m)")
hist_image_item = pg.ImageItem()
hist_image_item.translate(-2, config.range_start)
hist_image_item.scale(2 / num_hist, config.range_length / num_points)
hist_plot.addItem(hist_image_item)
# try to get a colormap from matplotlib
try:
hist_image_item.setLookupTable(example_utils.pg_mpl_cmap("viridis"))
except ImportError:
pass
win.show()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
client.start_streaming()
while not interrupt_handler.got_signal:
info, sweep = client.get_next()
hist_data = np.roll(hist_data, -1, axis=0)
hist_data[-1] = sweep
hist_max = np.roll(hist_max, -1)
hist_max[-1] = np.max(sweep)
y_max = smooth_max.update(np.amax(hist_max))
env_curve.setData(xs, sweep)
env_plot.setYRange(0, y_max)
hist_image_item.updateImage(hist_data, levels=(0, y_max))
app.processEvents()
print("Disconnecting...")
app.closeAllWindows()
client.disconnect()
def main():
# To simplify the examples, we use a generic argument parser. It
# lets you choose between UART/socket, set which sensor(s) to use,
# and the verbosity level of the logging.
args = example_utils.ExampleArgumentParser().parse_args()
# Logging is done using the logging module with a logger named
# acconeer_utils. We call another helper function which sets up the
# logging according to the verbosity level set in the arguments.
# -q or --quiet: ERROR (typically not used)
# default: WARNING
# -v or --verbose: INFO
# -vv or --debug: DEBUG
example_utils.config_logging(args)
# Pick client depending on whether socket, SPI, or UART is used
if args.socket_addr:
client = JSONClient(args.socket_addr)
elif args.spi:
client = RegSPIClient()
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
# Create a configuration to run on the sensor. A good first choice
# is the envelope service, so let's pick that one.
config = configs.EnvelopeServiceConfig()
# In all examples, we let you set the sensor(s) via the command line
config.sensor = args.sensors
# Set the measurement range [meter]
config.range_interval = [0.2, 0.3]
# Set the target measurement rate [Hz]
config.sweep_rate = 10
# Other configuration options might be available. Check out the
# example for the corresponding service/detector to see more.
client.connect()
# In most cases, explicitly calling connect is not necessary as
# setup_session below will call connect if not already connected.
# Set up the session with the config we created. If all goes well,
# some information/metadata for the configured session is returned.
session_info = client.setup_session(config)
print("Session info:\n", session_info, "\n")
# Now would be the time to set up plotting, signal processing, etc.
# Start streaming data from the session. This call will block until
# the sensor has confirmed that streaming has started.
client.start_streaming()
# Alternatively, start_streaming can be given the config instead. In
# that case, the client will call setup_session(config) for you
# before starting the stream. For example:
# session_info = client.start_streaming(config)
# As this will call setup_session in the background, this will also
# connect if not already connected.
# In this simple example, we just want to get a couple of sweeps.
# To get a sweep, call get_next. get_next will block until the sweep
# is recieved. Some information/metadata is returned together with
# the data.
for i in range(3):
sweep_info, sweep_data = client.get_next()
print("Sweep {}:\n".format(i + 1), sweep_info, "\n", sweep_data, "\n")
# We're done, stop streaming. All buffered/waiting sweeps are thrown
# away. This call will block until the sensor has confirmed that
# streaming/session has ended.
client.stop_streaming()
# Calling stop_streaming before disconnect is not necessary as
# disconnect will call stop_streaming if streaming is started.
# Remember to always call disconnect to do so gracefully
client.disconnect()
def config_setup():
config = configs.EnvelopeServiceConfig()
config.range_interval = [0.4, 0.8]
config.sweep_rate = 2
config.gain = 1
return config
