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 setup_parameters(): config = configs.IQServiceConfig() config.range_interval = [0.40, 0.70] config.sweep_rate = 20 config.gain = 1 # config.running_average_factor = 0.5 return config
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 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 __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 base_config(): config = configs.IQServiceConfig() config.range_interval = [0.2, 0.6] config.sweep_rate = 1 config.gain = 0.7 #config.session_profile = configs.EnvelopeServiceConfig.MAX_SNR return config
def get_base_config(): config = configs.IQServiceConfig() config.range_interval = [0.2, 0.5] config.sweep_rate = 13 config.gain = 0.8 config.running_average_factor = 0.9 return config
def config_setup(): config = configs.IQServiceConfig() config.range_interval = [0.3, 0.7] config.sweep_rate = 100 config.gain = 1 #config.session_profile = configs.EnvelopeServiceConfig.MAX_DEPTH_RESOLUTION # config.session_profile = configs.EnvelopeServiceConfig.MAX_SNR print(config.gain) return config
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 test_setup_twice(setup): client, sensor = setup config = configs.IQServiceConfig(sensor=sensor) config.range_length = 0.2 info_1 = client.setup_session(config) config.range_length = 0.3 info_2 = client.setup_session(config) assert abs(0.2 - info_1["actual_range_length"]) < 0.01 assert abs(0.3 - info_2["actual_range_length"]) < 0.01 assert info_1["data_length"] < info_2["data_length"]
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 init_dropdowns(self): self.mode = QComboBox(self) self.mode.addItem("Select service") self.mode.addItem("IQ") self.mode.addItem("Envelope") self.mode.addItem("Power bin") self.mode.addItem("Phase tracking") self.mode.addItem("Presence detection") self.mode.addItem("Breathing") self.mode.addItem("Sleep breathing") self.mode.addItem("Obstacle detection") self.mode.move(50, 250) self.mode_to_param = { "Select service": "", "IQ": "iq_data", "Envelope": "envelope_data", "Power bin": "power_bin", "Breathing": "iq_data", "Phase tracking": "iq_data", "Presence detection": "iq_data", "Sleep breathing": "iq_data", "Obstacle detection": "iq_data", } self.mode_to_config = { "Select service": ["", ""], "IQ": [configs.IQServiceConfig(), "internal"], "Envelope": [configs.EnvelopeServiceConfig(), "internal"], "Power bin": [configs.PowerBinServiceConfig(), "internal_power"], "Breathing": [br.get_base_config(), "external"], "Phase tracking": [pht.get_base_config(), "external"], "Presence detection": [prd.get_base_config(), "external"], "Sleep breathing": [sb.get_base_config(), "external"], "Obstacle detection": [od.get_base_config(), "external"] } self.mode.currentIndexChanged.connect(self.update_canvas) self.interface = QComboBox(self) self.interface.addItem("Socket") self.interface.addItem("Serial") self.interface.currentIndexChanged.connect(self.update_interface) self.ports = QComboBox(self) self.ports.addItem("Scan ports") self.ports.activated.connect(self.update_ports) self.update_ports()
def main(): args = example_utils.ExampleArgumentParser().parse_args() example_utils.config_logging(args) if args.socket_addr: client = SocketClient(args.socket_addr) elif args.spi: client = SPIClient() else: port = args.serial_port or example_utils.autodetect_serial_port() client = UARTClient(port) 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 get_sensor_config(): return configs.IQServiceConfig()
def get_sensor_config(): config = configs.IQServiceConfig() config.range_interval = [0.3, 0.6] config.sweep_rate = 80 config.gain = 0.7 return config
def recordData(): args = example_utils.ExampleArgumentParser().parse_args() example_utils.config_logging(args) # Pick client depending on whether socket, SPI, or UART is used 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.3, 0.8] config.sweep_rate = int(input("Sweep rate (Hz): ")) config.gain = 0.7 client.connect() session_info = client.setup_session(config) dataLength = session_info["data_length"] print(dataLength) client.start_streaming() # Array of sweeps data = [] numSweeps = int(input("Set number of sweeps: ")) #Control time ses_time_start = time() #Used for sleep time per_time = 1/config.sweep_rate # Loop to get data from sensor for i in range(numSweeps): start_time = time() # Get data sweep_info, sweep_data = client.get_next() # Append to list data.append(sweep_data) # Sleep time according to frequency end_time = time() sleep_time = per_time - (end_time - start_time) if sleep_time > 0: sleep(sleep_time) #Control of time ses_time = time() - ses_time_start print("ses_time: ", ses_time) object = input("Object: (W/D) ") direction = input("direction (I/O, only for door: ") # Save to file with open("data" + str(config.sweep_rate) + str(numSweeps) + object + direction + ".pkl", "wb") as outfile: pickle.dump(data, outfile, pickle.HIGHEST_PROTOCOL) with open("metadata" + str(config.sweep_rate) + str(numSweeps) + object + direction + ".pkl", "wb") as outfile: pickle.dump(session_info, outfile, pickle.HIGHEST_PROTOCOL) client.stop_streaming() client.disconnect()
def __init__(self, list_of_variables_for_threads, bluetooth_server): super(DataAcquisition, self).__init__() # Inherit threading vitals # Declaration of global variables self.go = list_of_variables_for_threads["go"] self.list_of_variables_for_threads = list_of_variables_for_threads self.bluetooth_server = bluetooth_server self.run_measurement = self.list_of_variables_for_threads['run_measurement'] self.window_slide = self.list_of_variables_for_threads["window_slide"] self.initiate_write_respitory_rate = list_of_variables_for_threads["initiate_write_heart_rate"] self.resp_rate_csv = [] # Setup for collecting data from Acconeer's radar files 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) # print("RADAR Port = " + self.args.socket_addr) # else: # print("Radar serial port: " + self.args.serial_port) # port = self.args.serial_port or example_utils.autodetect_serial_port() # self.client = RegClient(port) self.client = JSONClient('0.0.0.0') print("args: " + str(self.args)) self.client.squeeze = False self.config = configs.IQServiceConfig() self.config.sensor = self.args.sensors print(self.args.sensors) # self.config.sensor = 1 # Settings for radar setup self.config.range_interval = [0.4, 1.4] # Measurement interval # Frequency for collecting data. To low means that fast movements can't be tracked. self.config.sweep_rate = 20 # Probably 40 is the best without graph # For use of sample freq in other threads and classes. self.list_of_variables_for_threads["sample_freq"] = self.config.sweep_rate # The hardware of UART/SPI limits the sweep rate. self.config.gain = 0.7 # Gain between 0 and 1. Larger gain increase the SNR, but come at a cost # with more instability. Optimally is around 0.7 self.info = self.client.setup_session(self.config) # Setup acconeer radar session self.data_length = self.info["data_length"] # Length of data per sample # Variables for tracking method self.first_data = True # first time data is processed self.dt = 1 / self.list_of_variables_for_threads["sample_freq"] self.low_pass_const = self.low_pass_filter_constants_function( 0.25, self.dt) # Constant for a small # low-pass filter to smooth the changes. tau changes the filter weight, lower tau means shorter delay. # Usually tau = 0.25 is good. self.number_of_averages = 2 # Number of averages for tracked peak self.plot_time_length = 10 # Length of plotted data # Number of time samples when plotting self.number_of_time_samples = int(self.plot_time_length / self.dt) self.tracked_distance_over_time = np.zeros( self.number_of_time_samples) # Array for distance over time plot self.local_peaks_index = [] # Index of big local peaks self.track_peak_index = [] # Index of last tracked peaks self.track_peaks_average_index = None # Average of last tracked peaks self.threshold = 1 # Threshold for removing small local peaks. Start value not important # Returned variables self.tracked_distance = None # distance to the tracked peak (m) self.tracked_amplitude = None self.tracked_phase = None self.tracked_data = None # the final tracked data that is returned # Variables for phase to distance and plotting self.low_pass_amplitude = None # low pass filtered amplitude self.low_pass_track_peak = None self.track_peak_relative_position = None # used for plotting # the relative distance that is measured from phase differences (mm) self.relative_distance = 0 # relative distance to signal process self.real_time_breathing_amplitude = 0 # to send to the application self.last_phase = 0 # tracked phase from previous loop # saves old values to remove bias in real time breathing plot self.old_realtime_breathing_amplitude = np.zeros(1000) self.c = 2.998e8 # light speed (m/s) self.freq = 60e9 # radar frequency (Hz) self.wave_length = self.c / self.freq # wave length of the radar self.delta_distance = 0 # difference in distance between the last two phases (m) self.delta_distance_low_pass = 0 # low pass filtered delta distance for plotting self.noise_run_time = 0 # number of run times with noise, used to remove noise self.not_noise_run_time = 0 # number of run times without noise # other # how often values are plotted and sent to the app self.modulo_base = int(self.list_of_variables_for_threads["sample_freq"] / 10) if self.modulo_base == 0: self.modulo_base = 1 print('modulo base', self.modulo_base) self.run_times = 0 # number of times run in run self.calibrating_time = 5 # Time sleep for passing through filters. Used for Real time breathing # Graphs self.plot_graphs = False # if plot the graphs or not if self.plot_graphs: self.pg_updater = PGUpdater(self.config) self.pg_process = PGProcess(self.pg_updater) self.pg_process.start() # acconeer graph self.low_pass_vel = 0 self.hist_vel = np.zeros(self.number_of_time_samples) self.hist_pos = np.zeros(self.number_of_time_samples) self.last_data = None # saved old data # filter self.highpass_HR = filter.Filter('highpass_HR') self.lowpass_HR = filter.Filter('lowpass_HR') self.highpass_RR = filter.Filter('highpass_RR') self.lowpass_RR = filter.Filter('lowpass_RR') self.HR_filtered_queue = list_of_variables_for_threads["HR_filtered_queue"] self.RR_filtered_queue = list_of_variables_for_threads["RR_filtered_queue"] # TODO remove self.RTB_final_queue = list_of_variables_for_threads["RTB_final_queue"] self.amp_data = []
def __init__(self, demo_ctrl, params): super().__init__(demo_ctrl, self.detector_name) self.config = configs.IQServiceConfig() self.update_config(params)
def get_base_config(): config = configs.IQServiceConfig() config.range_interval = [0.4, 0.8] config.sweep_rate = 60 config.gain = 0.6 return config
def get_base_config(): config = configs.IQServiceConfig() config.range_interval = [0.1, 0.5] config.sweep_rate = int(np.ceil(max_speed * 4 / wavelength)) config.gain = 0.7 return config
def get_base_config(): config = configs.IQServiceConfig() config.range_interval = [0.3, 0.9] config.sweep_rate = 40 config.gain = 0.7 return config
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 get_sensor_config(): config = configs.IQServiceConfig() config.range_interval = [0.1, 0.5] config.sweep_rate = int(np.ceil(MAX_SPEED * 4 / WAVELENGTH)) config.gain = 0.7 return config