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) 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().parse_args() example_utils.config_logging(args) if args.socket_addr: raise Exception("Socket is not supported") elif args.spi: raise Exception("SPI is not supported") else: port = args.serial_port or example_utils.autodetect_serial_port() client = RegClient(port) client.connect() pin = RegClient._XM112_LED_PIN client._write_gpio(pin, 1) val = client._read_gpio(pin) print(val) for _ in range(3): sleep(0.1) client._write_gpio(pin, 0) # on sleep(0.1) client._write_gpio(pin, 1) # off client.disconnect()
def __init__(self, q): # Setup radar self.args = example_utils.ExampleArgumentParser().parse_args() example_utils.config_logging(self.args) if self.args.socket_addr: self.client = JSONClient(self.args.socket_addr) else: port = self.args.serial_port or example_utils.autodetect_serial_port() self.client = RegClient(port) self.client.squeeze = False self.config = configs.IQServiceConfig() self.config.sensor = self.args.sensors self.config.range_interval = [0.2, 0.6] # Intervall för mätningar self.config.sweep_rate = 1 # Frekvensen self.config.gain = 1 # Gain mellan 0 och 1, vi använder 1 self.time = 10 # Hur lång mätningen ska vara # totalt antal sekvenser som krävs för att få en specifik tid self.seq = self.config.sweep_rate * self.time self.info = self.client.setup_session(self.config) self.num_points = self.info["data_length"] # Antalet mätpunkter per sekvens # print(self.num_points) # Matris med nollor som fylls med rardardata self.matrix = np.zeros((self.seq, self.num_points), dtype=np.csingle) self.matrix_copy = np.zeros((self.seq, self.num_points), dtype=np.csingle) # En copy på ovanstående self.temp_vector = np.zeros((0, self.num_points), dtype=np.csingle) self.matrix_idx = 0 # Index för påfyllning av matris super(Radar, self).__init__() # En First In First Out (FIFO) kö där mätdata sparas och kan hämtas ut för signalbehandling self.q = q
def run(self): print("#### New thread for %s" % self.name) args = self._demo_ctrl.streaming_client_args print("args:", 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) try: client.connect() except Exception as e: print("Got exception:", e) session_info = client.setup_session(self.config) print("Session info:\n", session_info, "\n") client.start_streaming() while not self.terminating: sweep_info, sweep_data = client.get_next() d = self.process_data(sweep_data) if d is not None: self._demo_ctrl.put_cmd(str(d)) if self.terminating: break client.disconnect()
def __init__(self, radar_queue, interrupt_queue): # Setup for collecting data from radar self.args = example_utils.ExampleArgumentParser().parse_args() example_utils.config_logging(self.args) if self.args.socket_addr: self.client = JSONClient(self.args.socket_addr) else: port = self.args.serial_port or example_utils.autodetect_serial_port( ) self.client = RegClient(port) self.client.squeeze = False self.config = configs.IQServiceConfig() self.config.sensor = self.args.sensors self.config.range_interval = [0.2, 0.6] # Measurement interval self.config.sweep_rate = 1 # Frequency for collecting data self.config.gain = 1 # Gain between 0 and 1. self.time = 10 # Duration for a set amount of sequences self.seq = self.config.sweep_rate * self.time self.info = self.client.setup_session( self.config) # Setup acconeer radar session self.num_points = self.info[ "data_length"] # Amount of data points per sampel #### Det här kanske inte ska vara i den här klassen ##### # Vector for radar values from tracked data self.peak_vector = np.zeros((1, self.seq), dtype=np.csingle) self.data_idx = 0 # Inedex for peak vector used for filtering self.radar_queue = radar_queue self.interrupt_queue = interrupt_queue self.timeout = time.time() + self.time b = 0
def connect_to_server(self): if self.buttons["connect"].text() == "Connect": max_num = 4 if "Select service" in self.current_canvas: self.mode.setCurrentIndex(2) if self.interface.currentText().lower() == "socket": self.client = JSONClient(self.textboxes["host"].text()) else: port = self.ports.currentText() if "scan" in port.lower(): self.error_message("Please select port first!") return self.client = RegClient(port) max_num = 1 conf = self.update_sensor_config() sensor = 1 connection_success = False error = None while sensor <= max_num: conf.sensor = sensor try: self.client.setup_session(conf) self.client.start_streaming() self.client.stop_streaming() connection_success = True self.textboxes["sensor"].setText("{:d}".format(sensor)) break except Exception as e: sensor += 1 error = e if connection_success: self.buttons["start"].setEnabled(True) self.buttons["create_cl"].setEnabled(True) self.buttons["stop"].setEnabled(True) else: self.error_message("Could not connect to sever!\n{}".format(error)) return self.buttons["connect"].setText("Disconnect") self.buttons["connect"].setStyleSheet("QPushButton {color: red}") else: self.buttons["connect"].setText("Connect") self.buttons["connect"].setStyleSheet("QPushButton {color: black}") self.sig_scan.emit("stop") self.buttons["start"].setEnabled(False) self.buttons["create_cl"].setEnabled(False) if self.cl_supported: self.buttons["load_cl"].setEnabled(True) try: self.client.stop_streaming() except Exception: pass try: self.client.disconnect() except Exception: pass
def __init__(self): # Setup radar data self.args = example_utils.ExampleArgumentParser().parse_args() example_utils.config_logging(self.args) if self.args.socket_addr: self.client = JSONClient(self.args.socket_addr) else: port = self.args.serial_port or example_utils.autodetect_serial_port( ) self.client = RegClient(port) self.client.squeeze = False self.config = configs.IQServiceConfig() self.config.sensor = self.args.sensors self.config.range_interval = [0.2, 0.6] self.config.sweep_rate = 1 self.config.gain = 1 self.time = 5 self.seq = self.config.sweep_rate * self.time self.info = self.client.setup_session(self.config) self.num_points = self.info["data_length"] self.matrix = np.zeros((self.seq, self.num_points), dtype=np.csingle) self.matrix_copy = np.zeros((self.seq, self.num_points), dtype=np.csingle) self.matrix_idx = 0 super(Radar, self).__init__()
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 __init__(self, HR_filter_queue, go): # Lägg till RR_filter_queue som inputargument self.go = go # Setup for collecting data from radar self.args = example_utils.ExampleArgumentParser().parse_args() example_utils.config_logging(self.args) if self.args.socket_addr: self.client = JSONClient(self.args.socket_addr) # Test för att se vilken port som används av radarn print("RADAR Port = " + self.args.socket_addr) else: port = self.args.serial_port or example_utils.autodetect_serial_port( ) self.client = RegClient(port) self.client.squeeze = False self.config = configs.IQServiceConfig() self.config.sensor = self.args.sensors self.config.range_interval = [0.2, 0.6] # Measurement interval self.config.sweep_rate = 20 # Frequency for collecting data self.config.gain = 1 # Gain between 0 and 1. self.time = 1 # Duration for a set amount of sequences self.seq = self.config.sweep_rate * self.time # Amount of sequences during a set time and sweep freq self.info = self.client.setup_session( self.config) # Setup acconeer radar session self.num_points = self.info[ "data_length"] # Amount of data points per sampel self.data_getting = 0 # Inedex for printing still getting data once a second self.HR_filter_queue = HR_filter_queue # self.a = a # self.RR_filter_queue = RR_filter_queue # Initiation for tracking method self.N_avg = 10 # How manny peaks averaged over when calculating peaks_filtered self.I_peaks = np.zeros(self.N_avg) self.locs = np.zeros(self.N_avg) self.I_peaks_filtered = np.zeros(self.N_avg) self.tracked_distance = np.zeros(self.N_avg) self.tracked_amplitude = np.zeros(self.N_avg) self.tracked_phase = np.zeros(self.N_avg) self.threshold = 0 # variable for finding peaks above threshold self.data_idx = 0 # Index in vector for tracking. Puts new tracked peak into tracking vector # converts index to real length self.real_dist = np.linspace(self.config.range_interval[0], self.config.range_interval[1], num=self.num_points) self.counter = 0 # Used only for if statement only for first iteration and not when data_idx goes back to zero super(Radar, self).__init__() # Inherit threading vitals
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) # 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().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.EnvelopeServiceConfig() config.sensor = args.sensors config.range_interval = [0.2, 0.6] config.sweep_rate = 60 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) 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 sensor_config = get_sensor_config() sensor_config.sensor = args.sensors processing_config = get_processing_config() 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 = Processor(sensor_config, processing_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 setup(request): conn_type, *args = request.param if conn_type == "spi": client = RegSPIClient() sensor = 1 elif conn_type == "uart": port = args[0] or autodetect_serial_port() client = RegClient(port) sensor = 1 elif conn_type == "socket": client = JSONClient(args[0]) sensor = int(args[1]) else: pytest.fail() client.connect() yield (client, sensor) client.disconnect()
def check_connection(args): print("Checking connection to radar") try: 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.connect() client.disconnect() return True except Exception: print() traceback.print_exc() print() return False
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: 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.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: 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().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 # Setup parameters filename = "Lins50cmPuls_0328_Test1.csv" time = 300 config = setup_parameters() seq = config.sweep_rate * time config.sensor = args.sensors info = client.setup_session(config) num_points = info["data_length"] # print(num_points) info_file(filename, config, num_points, time, seq) # Setup info file print(num_points) matris = np.zeros((seq, num_points), dtype=np.csingle) client.start_streaming() print("Starting...") start = timer.time() for i in range(0, seq): info, sweep = client.get_next() matris[seq - i - 1][:] = sweep[:] end = timer.time() print(i + 1) print((end - start), "s") # print("Disconnecting...") matris = np.flip(matris, 0) np.savetxt(filename, matris, delimiter=";") matris = None 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 = 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 = 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() 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 = 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(): # 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()