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.IQServiceConfig()
config.sensor = args.sensors
config.range_interval = [0.2, 0.6]
config.sweep_rate = 50
info = client.start_streaming(config)
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
fc = example_utils.FreqCounter(num_bits=(4 * 8 * info["data_length"]))
while not interrupt_handler.got_signal:
info, data = client.get_next()
fc.tick()
print("\nDisconnecting...")
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser(num_sens=1).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)
sensor_config = get_sensor_config()
sensor_config.sensor = args.sensors
processing_config = get_processing_config()
session_info = client.setup_session(sensor_config)
pg_updater = PGUpdater(sensor_config, processing_config)
pg_process = PGProcess(pg_updater)
pg_process.start()
client.start_streaming()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
processor = PhaseTrackingProcessor(sensor_config, processing_config)
# Record data
data = []
counter = 0
while not interrupt_handler.got_signal:
info, sweep = client.get_next()
plot_data = processor.process(sweep)
data.append(sweep)
counter += 1
if plot_data is not None:
try:
pg_process.put_data(plot_data)
except PGProccessDiedException:
break
# Save to file
with open(
"data" + str(get_sensor_config().sweep_rate) + str(counter) +
".pkl", "wb") as outfile:
pickle.dump(data, outfile, pickle.HIGHEST_PROTOCOL)
with open(
"metadata" + str(get_sensor_config().sweep_rate) + str(counter) +
".pkl", "wb") as outfile:
pickle.dump(session_info, outfile, pickle.HIGHEST_PROTOCOL)
print("Disconnecting...")
pg_process.close()
client.disconnect()
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 = config_setup()
config.sensor = args.sensors
info = client.setup_session(config)
num_points = info["data_length"]
tracking = Tracking(num_points, config.range_interval)
fig, (amplitude_ax) = plt.subplots(1)
fig.set_size_inches(12, 6)
fig.canvas.set_window_title("filename")
for ax in [amplitude_ax]:
ax.set_xlabel("time (s)")
ax.set_xlim(0, num_points / config.sweep_rate)
amplitude_ax.set_ylabel("Distance (m)")
amplitude_ax.set_ylim(config.range_interval[0], config.range_interval[1])
xs = np.linspace(0, num_points / config.sweep_rate, num=num_points)
amplitude_line = amplitude_ax.plot(xs, np.zeros_like(xs))[0]
fig.tight_layout()
plt.ion()
plt.show()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
client.start_streaming()
counter = 0
while not interrupt_handler.got_signal:
info, sweep = client.get_next()
amplitude = np.abs(sweep)
track = tracking.tracking(sweep, counter)
peak = track
counter += 1
if counter == num_points:
counter = 0
# print(peak)
amplitude_line.set_ydata(peak)
# amplitude_line.set_ydata(amplitude)
fig.canvas.flush_events()
print("Disconnecting...")
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser().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)
client.squeeze = False
config = configs.IQServiceConfig()
config.sensor = args.sensors
config.range_interval = [1, 8]
config.sweep_rate = 1
config.gain = 0.8
#config.running_average_factor = 0.5
tid = 5
sekvenser = config.sweep_rate * tid
info = client.setup_session(config)
num_points = info["data_length"]
fig_updater = ExampleFigureUpdater(config, num_points)
plot_process = PlotProcess(fig_updater)
plot_process.start()
client.start_streaming()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
start = time.time()
# while not interrupt_handler.got_signal:
for i in range(0, sekvenser):
#info, data = client.get_next()
data = get_data(client)
plot_data = {
"amplitude": np.abs(data),
"phase": np.angle(data),
}
try:
plot_process.put_data(plot_data)
except PlotProccessDiedException:
break
end = time.time()
# print(i+1)
print((end - start), "s")
# print("Disconnecting...")
plot_process.close()
client.disconnect()
def sensor_read():
args = example_utils.ExampleArgumentParser(num_sens=1).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)
sensor_config = get_sensor_config()
sensor_config.sensor = args.sensors
# Extract metadata
session_info = client.setup_session(sensor_config)
range_start = session_info["actual_range_start"]
range_length = session_info["actual_range_length"]
#sweep_rate = session_info["frequency"]
data_length = session_info["data_length"]
client.start_streaming()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
# Instantiate customProcess
custom_processor = customProcess(range_length, range_start, AMPL_THRESHOLD, DIST_THRESHOLD, data_length, -1)
processor = PhaseTrackingProcessor(sensor_config.sweep_rate)
while not interrupt_handler.got_signal:
info, sweep = client.get_next()
plot_data = processor.process(sweep)
if plot_data is not None:
try:
print(np.amax(plot_data["abs"]))
if custom_processor.process(plot_data):
person_counter = custom_processor.person_counter
if person_counter == 1:
print("1 person in the room")
input("Enter")
else:
print(person_counter, " persons in the room")
input("Enter")
except PGProccessDiedException:
break
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)
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 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.IQServiceConfig()
config.sensor = args.sensors
config.range_interval = [0.2, 0.6]
config.sweep_rate = 30
config.gain = 0.6
# config.running_average_factor = 0.5
info = client.setup_session(config)
num_points = info["data_length"]
fig_updater = ExampleFigureUpdater(config, num_points)
plot_process = PlotProcess(fig_updater)
plot_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()
plot_data = {
"amplitude": np.abs(data),
"phase": np.angle(data),
}
try:
plot_process.put_data(plot_data)
except PlotProccessDiedException:
break
print("Disconnecting...")
plot_process.close()
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)
# 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(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 = config_setup()
config.sensor = args.sensors
tid = 10
sekvenser = tid * config.sweep_rate
filename = "Reflektor_2.csv"
info = client.setup_session(config)
num_points = info["data_length"]
fig_updater = FigureUpdater2(config, num_points)
plot_process = PlotProcess(fig_updater)
plot_process.start()
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()
amplitude = np.abs(sweep)
plot_data = {
"amplitude": np.abs(sweep),
"phase": np.angle(sweep),
"ymax": amplitude.max(),
"xmax": config.range_interval[0] + (config.range_interval[1] - config.range_interval[0]) *
(np.argmax(amplitude)/num_points),
}
try:
plot_process.put_data(plot_data)
except PlotProccessDiedException:
break
print("Disconnecting...")
plot_process.close()
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser(num_sens=1).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)
sensor_config = get_sensor_config()
processing_config = get_processing_config()
sensor_config.sensor = args.sensors
session_info = client.setup_session(sensor_config)
client.start_streaming()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
processor = Processor(sensor_config, processing_config, session_info)
global speedLimit
global waitForCompletingSpeedLimitDetection
while not interrupt_handler.got_signal:
info, sweep = client.get_next()
speed = processor.process(sweep)
# speed = speed * 3.6
if speed > speedLimit:
speedLimit = speed
print("Maximal current Speed: " + str(speedLimit))
if not waitForCompletingSpeedLimitDetection:
waitForCompletingSpeedLimitDetection = True
timer1 = threading.Timer(0.1, captureImageFromCamera)
timer1.start()
timer2 = threading.Timer(2.0, sendSpeedCatImage)
timer2.start()
print(speed)
print("Disconnecting...")
# pg_process.close()
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)
client.squeeze = False
config = configs.IQServiceConfig()
config.sensor = args.sensors
config.range_interval = [0.2, 0.6]
config.sweep_rate = 30
config.gain = 0.6
config.sampling_mode = config.SAMPLING_MODE_A
# config.running_average_factor = 0.5
# config.hw_accelerated_average_samples = 7
# config.stepsize = 1
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)
except PGProccessDiedException:
break
print("Disconnecting...")
pg_process.close()
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)
client.squeeze = False
sensor_config = get_sensor_config()
sensor_config.sensor = args.sensors
processing_config = get_processing_config()
session_info = client.setup_session(sensor_config)
pg_updater = PGUpdater(sensor_config, processing_config, session_info)
pg_process = PGProcess(pg_updater)
pg_process.start()
client.start_streaming()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
processor = Processor(sensor_config, processing_config, session_info)
while not interrupt_handler.got_signal:
info, sweep = client.get_next()
plot_data = processor.process(sweep)
if plot_data is not None:
try:
pg_process.put_data(plot_data)
except PGProccessDiedException:
break
print("Disconnecting...")
pg_process.close()
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)
client.squeeze = False
config = configs.SparseServiceConfig()
config.sensor = args.sensors
config.range_interval = [0.24, 1.20]
config.sweep_rate = 60
config.number_of_subsweeps = 16
# config.hw_accelerated_average_samples = 60
# config.stepsize = 1
client.setup_session(config)
pg_updater = PGUpdater(config)
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)
except PGProccessDiedException:
break
print("Disconnecting...")
pg_process.close()
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser().parse_args()
example_utils.config_logging(args)
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)
client.squeeze = False
config = configs.PowerBinServiceConfig()
config.sensor = args.sensors
config.range_interval = [0.1, 0.7]
config.sweep_rate = 60
config.gain = 0.6
# config.bin_count = 8
client.setup_session(config)
pg_updater = PGUpdater(config)
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)
except PGProccessDiedException:
break
print("Disconnecting...")
pg_process.close()
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser().parse_args()
example_utils.config_logging(args)
if args.socket_addr:
print("Using detectors is only supported with the XM112 module")
sys.exit()
elif args.spi:
client = RegSPIClient()
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
config = configs.DistancePeakDetectorConfig()
config.sensor = args.sensors
config.range_interval = [0.1, 0.7]
config.sweep_rate = 60
config.gain = 0.5
client.setup_session(config)
pg_updater = PGUpdater(config)
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)
except PGProccessDiedException:
break
print("Disconnecting...")
pg_process.close()
client.disconnect()
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 = get_base_config()
config.sensor = args.sensors
client.setup_session(config)
pg_updater = PGUpdater(config)
pg_process = PGProcess(pg_updater)
pg_process.start()
client.start_streaming()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
processor = ObstacleDetectionProcessor(config)
while not interrupt_handler.got_signal:
info, sweep = client.get_next()
plot_data = processor.process(sweep)
if plot_data is not None:
try:
pg_process.put_data(plot_data)
except PGProccessDiedException:
break
print("Disconnecting...")
pg_process.close()
client.disconnect()
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 = config_setup()
config.sensor = args.sensors
tid = 10
sekvenser = tid * config.sweep_rate
filename = "Reflektor_2.csv"
info = client.setup_session(config)
num_points = info["data_length"]
amplitude_y_max = 22000
N_avg = 10
tracking = Tracking(num_points, config.range_interval, N_avg)
print("numpoints: ", num_points)
fig, (amplitude_ax) = plt.subplots(1)
fig.set_size_inches(12, 6)
fig.canvas.set_window_title(filename)
for ax in [amplitude_ax]:
# ax.set_xlabel("Depth (m)")
# ax.set_xlim(config.range_interval)
ax.set_xlabel("Time (s)")
ax.set_xlim(0, 100)
# amplitude_ax.set_ylabel("Amplitude")
# amplitude_ax.set_ylim(0, 1.1 * amplitude_y_max)
amplitude_ax.set_ylabel("tracked distance (m)")
amplitude_ax.set_ylim(config.range_interval)
xs = np.linspace(0, 100, num=100)
amplitude_line = amplitude_ax.plot(xs, np.zeros_like(xs))[0]
fig.tight_layout()
plt.ion()
plt.show()
list = np.zeros(100)
i = 0
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
client.start_streaming()
matris = np.zeros((sekvenser, 2))
counter = 0
while not interrupt_handler.got_signal:
# for i in range(0, sekvenser):
info, sweep = client.get_next()
start = round(time.time() * 1000) / 1000
track = tracking.tracking(sweep)
end = round(time.time() * 1000) / 1000
print("Time for tracking loop {}".format(end - start))
list[i] = track
amplitude_line.set_ydata(list)
i += 1
if i == 100:
i = 0
list = np.zeros(100)
if not plt.fignum_exists(1): # Simple way to check if plot is closed
break
fig.canvas.flush_events()
# annotate.remove()
# matris = np.mean(matris, axis=0)
# np.savetxt(filename, matris, delimiter=",")
print("Disconnecting...")
plt.close()
client.disconnect()
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():
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 = base_config()
config.sensor = args.sensors
info = client.setup_session(config)
num_points = info["data_length"]
# Setup plot window for amplitude and phase filled with zeros.
amplitude_y_max = 1
fig, (amplitude_ax, phase_ax1) = plt.subplots(2)
fig.set_size_inches(12, 6)
fig.canvas.set_window_title("Annotate test")
fig, (ny_ax2) = plt.subplots(1)
fig.set_size_inches(8, 5)
fig.canvas.set_window_title("test två fönster")
for ax in [amplitude_ax]:
ax.set_xlabel("Depth (m)")
ax.set_xlim(config.range_interval)
ax.grid(True)
for ax1 in [phase_ax1]:
ax1.set_xlabel("Depth(m)")
ax1.set_xlim(config.range_interval)
ax1.grid(True)
for ax2 in [ny_ax2]:
ax2.set_xlabel("Depth (m)")
ax2.set_xlim(config.range_interval)
ax2.grid(True)
amplitude_ax.set_ylabel("Amplitude")
amplitude_ax.set_ylim(0, 1.0 * amplitude_y_max)
phase_ax1.set_ylabel("Phase")
example_utils.mpl_setup_yaxis_for_phase(phase_ax1)
ny_ax2.set_ylim(-1, 1)
xs = np.linspace(*config.range_interval, num_points)
amplitude_line = amplitude_ax.plot(xs, np.zeros_like(xs))[0]
phase_line = phase_ax1.plot(xs, np.zeros_like(xs))[0]
ny_line = ny_ax2.plot(xs, np.zeros_like(xs))[0]
fig.tight_layout()
plt.ion()
plt.show()
# Setup box for annotation with maximum
bbox_props = dict(boxstyle="square,pad=0.3", fc="w", ec="k", lw=0.72)
arrowprops = dict(arrowstyle="->",
connectionstyle="angle,angleA=0,angleB=90")
kw = dict(xycoords='data',
textcoords="axes fraction",
arrowprops=arrowprops,
bbox=bbox_props,
ha="right",
va="top")
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
client.start_streaming()
while not interrupt_handler.got_signal:
# for i in range(0, 1):
# Get new sensor data
info, sweep = client.get_next()
amplitude = np.abs(sweep)
phase = np.angle(sweep)
# Update annotation with the new amplitude and position
ymax = amplitude.max()
xmax = config.range_interval[0] + (config.range_interval[1] - config.range_interval[0]) * \
(np.argmax(amplitude)/num_points)
text = "x={:.2f}, y={:.2f}".format(xmax, ymax)
annotate = ax.annotate(text,
xy=(xmax, ymax),
xytext=(0.96, 0.96),
**kw)
vline_ax0 = ax.axvline(x=xmax,
ymin=0,
ymax=ymax,
linewidth=2,
color='k')
vline_ax1 = ax1.axvline(x=xmax,
ymin=-np.pi,
ymax=np.pi,
linewidth=2,
color='k')
# update plot with new sensor data
amplitude_line.set_ydata(amplitude)
phase_line.set_ydata(phase)
if not plt.fignum_exists(1): # Simple way to check if plot is closed
break
fig.canvas.flush_events()
annotate.remove()
vline_ax0.remove()
vline_ax1.remove()
print("Disconnecting...")
plt.close()
client.disconnect()
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 = get_base_config()
config.sensor = args.sensors
info1 = client.setup_session(config)
num_points = info1["data_length"]
fig_updater = ExampleFigureUpdater(config)
plot_process = PlotProcess(fig_updater)
plot_process.start()
client.start_streaming()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
processor = PhaseTrackingProcessor(config)
start = time.time()
i = 0
while not interrupt_handler.got_signal:
info, sweep = client.get_next()
plot_data = processor.process(sweep)
try:
plot_process.put_data(
plot_data) # Will ignore the first None from processor
except PlotProccessDiedException:
break
i += 1
end = time.time()
print(i + 1)
print((end - start), "s")
print("Disconnecting...")
plot_process.close()
client.disconnect()
# k = 1
# m = num_points
# n = 50
# matris_real = np.zeros((n, m), dtype=np.csingle)
# matris_imag = np.zeros((n, m), dtype=np.csingle)
# while not interrupt_handler.got_signal:
# if k < 100:
# k += 1
# matris_imag = np.roll(matris_imag, 1, axis=0)
# matris_real = np.roll(matris_real, 1, axis=0)
# info, sweep = client.get_next()
# vector_real_temp = np.real(sweep)
# vector_imag_temp = np.imag(sweep)
# matris_real[[0], :] = vector_real_temp
# matris_imag[[0], :] = vector_imag_temp
# vector_real = np.mean(matris_real, axis=0)
# vector_imag = np.mean(matris_imag, axis=0)
# vector = vector_real + 1j*vector_imag
# plot_data = processor.process(vector)
# if plot_data is not None:
# try:
# plot_process.put_data(plot_data)
# except PlotProccessDiedException:
# break
# Fungerande test av medelvärdesbildning
# k=100
# while not interrupt_handler.got_signal:
# info, sweep = client.get_next()
# real_tot = np.zeros(num_points)
# imag_tot = np.zeros(num_points)
# for i in range(1, k):
# info, sweep = client.get_next()
# real = sweep.real
# imag = sweep.imag
# imag_tot = list(map(operator.add, imag_tot, imag))
# real_tot = np.add(real_tot, real)
# imag_tot = [x / k for x in imag_tot]
# real = [x / k for x in real_tot]
# plot_data = processor.process(sweep)
# if plot_data is not None:
# try:
# plot_process.put_data(plot_data)
# except PlotProccessDiedException:
# break
print("Disconnecting...")
plot_process.close()
client.disconnect()
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)
elif args.spi:
client = RegSPIClient()
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
config = configs.IQServiceConfig()
config.sensor = args.sensors
config.range_interval = [0.2, 0.6]
config.sweep_rate = 10
config.gain = 0.6
info = client.setup_session(config)
num_points = info["data_length"]
amplitude_y_max = 0.3
fig, (amplitude_ax, phase_ax) = plt.subplots(2)
fig.set_size_inches(8, 6)
fig.canvas.set_window_title("Acconeer matplotlib example")
for ax in [amplitude_ax, phase_ax]:
ax.set_xlabel("Depth (m)")
ax.set_xlim(config.range_interval)
ax.grid(True)
amplitude_ax.set_ylabel("Amplitude")
amplitude_ax.set_ylim(0, 1.1 * amplitude_y_max)
phase_ax.set_ylabel("Phase")
example_utils.mpl_setup_yaxis_for_phase(phase_ax)
xs = np.linspace(*config.range_interval, num_points)
amplitude_line = amplitude_ax.plot(xs, np.zeros_like(xs))[0]
phase_line = phase_ax.plot(xs, np.zeros_like(xs))[0]
fig.tight_layout()
plt.ion()
plt.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()
amplitude = np.abs(sweep)
phase = np.angle(sweep)
max_amplitude = np.max(amplitude)
if max_amplitude > amplitude_y_max:
amplitude_y_max = max_amplitude
amplitude_ax.set_ylim(0, 1.1 * max_amplitude)
amplitude_line.set_ydata(amplitude)
phase_line.set_ydata(phase)
if not plt.fignum_exists(1): # Simple way to check if plot is closed
break
fig.canvas.flush_events()
print("Disconnecting...")
plt.close()
client.disconnect()
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 = config_setup()
config.sensor = args.sensors
tid = 10
sekvenser = tid * config.sweep_rate
filename = "Reflektor_2.csv"
info = client.setup_session(config)
num_points = info["data_length"]
amplitude_y_max = 22000
fig, (amplitude_ax) = plt.subplots(1)
fig.set_size_inches(12, 6)
fig.canvas.set_window_title(filename)
for ax in [amplitude_ax]:
ax.set_xlabel("Depth (m)")
ax.set_xlim(config.range_interval)
ax.set_xticks(np.linspace(0.4, 0.8, num=5))
ax.set_xticks(np.concatenate([
np.linspace(0.41, 0.49, num=9),
np.linspace(0.51, 0.59, num=9),
np.linspace(0.61, 0.69, num=9),
np.linspace(0.71, 0.79, num=9)
]),
minor=True)
ax.grid(True, which='major')
ax.grid(True, which='minor')
amplitude_ax.set_ylabel("Amplitude")
amplitude_ax.set_ylim(0, 1.1 * amplitude_y_max)
xs = np.linspace(*config.range_interval, num_points)
amplitude_line = amplitude_ax.plot(xs, np.zeros_like(xs))[0]
fig.tight_layout()
plt.ion()
plt.show()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
client.start_streaming()
matris = np.zeros((sekvenser, 2))
while not interrupt_handler.got_signal:
# for i in range(0, sekvenser):
info, sweep = client.get_next()
amplitude = np.abs(sweep)
ymax = amplitude.max()
xmax = config.range_interval[0] + (config.range_interval[1] - config.range_interval[0]) * \
(np.argmax(amplitude)/num_points)
matris[0][:] = [xmax, ymax]
matris = np.roll(matris, 1, axis=0)
text = "x={:.2f}, y={:.2f}".format(xmax, ymax)
bbox_props = dict(boxstyle="square,pad=0.3", fc="w", ec="k", lw=0.72)
arrowprops = dict(arrowstyle="->",
connectionstyle="angle,angleA=0,angleB=90")
kw = dict(xycoords='data',
textcoords="axes fraction",
arrowprops=arrowprops,
bbox=bbox_props,
ha="right",
va="top")
annotate = ax.annotate(text,
xy=(xmax, ymax),
xytext=(0.96, 0.96),
**kw)
amplitude_line.set_ydata(amplitude)
if not plt.fignum_exists(1): # Simple way to check if plot is closed
break
fig.canvas.flush_events()
annotate.remove()
# matris = np.mean(matris, axis=0)
# np.savetxt(filename, matris, delimiter=",")
print("Disconnecting...")
plt.close()
client.disconnect()
def main():
#args = example_utils.ExampleArgumentParser(num_sens=1).parse_args()
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.SparseServiceConfig()
config.sensor = args.sensors
num_of_sensors = len(config.sensor)
config.range_interval = [0.3, 1.3]
config.sweep_rate = 80
config.gain = 0.6
config.number_of_subsweeps = 32
sensor_config = config
processing_config = ProcessingConfiguration()
session_info = client.setup_session(sensor_config)
pg_updaters = []
for i in range(num_of_sensors):
pg_updaters.append(
PGUpdater(sensor_config,
processing_config,
session_info,
sensor_num=i + 1))
pg_processes = []
for i in range(num_of_sensors):
pg_processes.append(PGProcess(pg_updaters[i]))
pg_processes[i].start()
client.start_streaming()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
processors = []
for i in range(num_of_sensors):
processors.append(
PresenceDetectionSparseProcessor(sensor_config, processing_config,
session_info))
while not interrupt_handler.got_signal:
info, sweep = client.get_next()
if (num_of_sensors > 1):
for i in range(num_of_sensors):
plot_data = processors[i].process(sweep[i])
if plot_data is not None:
try:
pg_processes[i].put_data(plot_data)
except PGProccessDiedException:
break
else:
plot_data = processors[0].process(sweep)
if plot_data is not None:
try:
pg_processes[0].put_data(plot_data)
except PGProccessDiedException:
break
print("Disconnecting...")
for i in range(num_of_sensors):
pg_processes[i].close()
client.disconnect()
def main():
parser = example_utils.ExampleArgumentParser(num_sens=2)
add_args(parser)
args = parser.parse_args()
if args.model_file_name:
filename = args.model_file_name
else:
print("Not implemented!")
sys.exit(1)
keras_proc = kp.MachineLearning()
model_data = keras_proc.load_model(filename)
print(model_data["message"])
if not model_data["loaded"]:
return False
config = model_data["sensor_config"]
feature_list = model_data["feature_list"]
frame_settings = model_data["frame_settings"]
feature_process = feature_proc.FeatureProcessing(config)
feature_process.set_feature_list(feature_list)
feature_process.set_frame_settings(frame_settings)
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)
info = client.setup_session(config)
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
client.start_streaming()
init = True
while not interrupt_handler.got_signal:
info, sweep = client.get_next()
if init:
init = False
num_sensors, data_len = sweep.shape
start_x = config.range_interval[0]
stop_x = config.range_interval[1]
x_mm = np.linspace(start_x, stop_x, data_len) * 1000
data = {
"x_mm": x_mm,
"iq_data": sweep,
"env_ampl": abs(sweep),
"sensor_config": config,
"num_sensors": num_sensors,
}
ml_frame_data = feature_process.feature_extraction(data)
feature_map = ml_frame_data["current_frame"]["feature_map"]
complete = ml_frame_data["current_frame"]["frame_complete"]
if complete and feature_map is not None:
predict = keras_proc.predict(feature_map)[0]
prediction_label = predict["prediction"]
print(prediction_label)
print("Disconnecting...")
client.disconnect()
