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