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 __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 __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 __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 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 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(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 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().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(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:
print("Using detectors is only supported with the XM112 module")
sys.exit()
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)
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()
class Radar():
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
# Loop which collects data from the radar, tracks the maximum peak and filters it for further signal processing. The final filtered data is put into a queue.
def get_data(self):
self.client.start_streaming() # Starts Acconeers streaming server
while True:
self.info, self.data = self.client.get_next()
print("Getting data")
if self.interrupt_queue.empty() == False or time.time(
) >= self.timeout: # Interrupt from bluetooth
# self.interrupt_queue.get()
print('Breaking loop')
break
self.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:
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)
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()
class Radar(threading.Thread):
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
# Loop which collects data from the radar, tracks the maximum peak and filters it for further signal processing. The final filtered data is put into a queue.
def run(self):
self.client.start_streaming() # Starts Acconeers streaming server
# static variable impported from bluetooth_app class (In final version)
while self.go:
# for i in range(self.seq*2):
data = self.get_data()
tracked_data = self.tracking(data)
print("Tracked distance: ", tracked_data)
# self.filter_HeartRate()
# self.filter_RespRate()
self.data_getting += 1
if self.data_getting % self.config.sweep_rate == 0:
print("Still getting data")
self.HR_filter_queue.put(2)
# Resets matrix index to zero for printing getting data.
if self.data_getting >= self.config.sweep_rate:
self.data_getting = 0
print("End of getting data from radar")
self.client.disconnect()
# Method to collect data from the streaming server
def get_data(self):
# self.data should be accessable from all other methods
info, data = self.client.get_next()
#print("How long the data is ", data)
return np.array(data)
# Filter for heart rate using the last X sampels according to data_idx. Saves data to queue
# def filter_HeartRate(self):
# # HR_peak_vector = copy.copy(self.peak_vector)
# # for i in range(5):
# # HR_peak_vector[0][i] = 0
# # # self.HR_filter_queue.put(HR_peak_vector)
# pass
# Filter for Respitory rate. Saves data to queue
# def filter_RespRate(self):
# # RR_peak_vector = copy.copy(self.peak_vector)
# # for i in range(5):
# # RR_peak_vector[0][i] = 0
# # self.RR_filter_queue.put(RR_peak_vector)
# pass
# Tracks the maximum peak from collected data which is filtered for further signal processing
def tracking(self, data):
data = np.transpose(data)
# self.data = data # Removed because using local data variable. Easier to understand how data travells in class
# print("Length of data input ", str(len(data)))
if self.data_idx == 0 and self.counter == 0: # things that only happens first time
I = np.argmax(np.abs(data))
self.I_peaks[:] = I
self.I_peaks_filtered[0] = self.I_peaks[0]
self.tracked_distance[0] = self.real_dist[int(
self.I_peaks_filtered[0])]
self.tracked_amplitude[0] = np.abs(data[int(
self.I_peaks_filtered[0])])
self.tracked_phase[0] = np.angle(data[int(
self.I_peaks_filtered[0])])
# After first seq continous tracking
else:
self.locs, _ = signal.find_peaks(
np.abs(data)) # find local maximas in data
# removes local maxima if under threshhold
self.locs = [
x for x in self.locs if (np.abs(data[x]) > self.threshold)
]
difference = np.subtract(self.locs,
self.I_peaks_filtered[self.data_idx])
print("locks: ", self.locs)
print("Last I_peaks_filtered: ",
self.I_peaks_filtered[self.data_idx])
print("difference: ", difference)
abs = np.abs(difference)
argmin = np.argmin(abs)
Index_in_locks = argmin # index of closest peak in locs
# Index_in_locks = np.argmin(np.abs(self.locks - self.I_peaks_filtered[self.data_idx - 1])) # difference between current peak index and last peak index
if len(self.locs) == 0: # if no peak is found
self.I_peaks[self.data_idx] = self.I_peaks[self.data_idx - 1]
print("Last peak value. Not updated.")
else:
I = self.locs[int(Index_in_locks)]
self.I_peaks[self.data_idx] = I
print("I_peaks: ", self.I_peaks)
# if self.counter == 0: # Questions about this part.
# self.i_avg_start = 0 # this will be 0 as long as counter == 0
# if self.data_idx == self.N_avg - 1: # change dist to nmbr of sequences later
# self.counter = 1
# else:
# self.i_avg_start = self.data_idx - (self.N_avg - 1)
self.I_peaks_filtered[self.data_idx] = np.round(
np.mean(self.I_peaks)) # mean value of N_avg latest peaks
# determines threshold
self.threshold = np.abs(data[int(
self.I_peaks_filtered[self.data_idx])]) * 0.5
self.tracked_distance[self.data_idx] = self.real_dist[int(
self.I_peaks_filtered[self.data_idx])]
self.tracked_amplitude[self.data_idx] = np.abs(data[int(
self.I_peaks_filtered[self.data_idx])])
self.tracked_phase[self.data_idx] = np.angle(data[int(
self.I_peaks_filtered[self.data_idx])])
# print("I_peaks_filtered: ", self.I_peaks_filtered)
self.data_idx += 1
if self.data_idx == self.N_avg:
self.data_idx = 0
return self.tracked_distance[self.data_idx - 1]
def main():
# To simplify the examples, we use a generic argument parser. It
# lets you choose between UART/socket, set which sensor(s) to use,
# and the verbosity level of the logging.
args = example_utils.ExampleArgumentParser().parse_args()
# Logging is done using the logging module with a logger named
# acconeer_utils. We call another helper function which sets up the
# logging according to the verbosity level set in the arguments.
# -q or --quiet: ERROR (typically not used)
# default: WARNING
# -v or --verbose: INFO
# -vv or --debug: DEBUG
example_utils.config_logging(args)
# Pick client depending on whether socket, SPI, or UART is used
if args.socket_addr:
client = JSONClient(args.socket_addr)
elif args.spi:
client = RegSPIClient()
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
# Create a configuration to run on the sensor. A good first choice
# is the envelope service, so let's pick that one.
config = configs.EnvelopeServiceConfig()
# In all examples, we let you set the sensor(s) via the command line
config.sensor = args.sensors
# Set the measurement range [meter]
config.range_interval = [0.2, 0.3]
# Set the target measurement rate [Hz]
config.sweep_rate = 10
# Other configuration options might be available. Check out the
# example for the corresponding service/detector to see more.
client.connect()
# In most cases, explicitly calling connect is not necessary as
# setup_session below will call connect if not already connected.
# Set up the session with the config we created. If all goes well,
# some information/metadata for the configured session is returned.
session_info = client.setup_session(config)
print("Session info:\n", session_info, "\n")
# Now would be the time to set up plotting, signal processing, etc.
# Start streaming data from the session. This call will block until
# the sensor has confirmed that streaming has started.
client.start_streaming()
# Alternatively, start_streaming can be given the config instead. In
# that case, the client will call setup_session(config) for you
# before starting the stream. For example:
# session_info = client.start_streaming(config)
# As this will call setup_session in the background, this will also
# connect if not already connected.
# In this simple example, we just want to get a couple of sweeps.
# To get a sweep, call get_next. get_next will block until the sweep
# is recieved. Some information/metadata is returned together with
# the data.
for i in range(3):
sweep_info, sweep_data = client.get_next()
print("Sweep {}:\n".format(i + 1), sweep_info, "\n", sweep_data, "\n")
# We're done, stop streaming. All buffered/waiting sweeps are thrown
# away. This call will block until the sensor has confirmed that
# streaming/session has ended.
client.stop_streaming()
# Calling stop_streaming before disconnect is not necessary as
# disconnect will call stop_streaming if streaming is started.
# Remember to always call disconnect to do so gracefully
client.disconnect()
def 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()
class Radar(threading.Thread):
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 run(self):
# Metod för att hämta data från radarn
self.client.start_streaming()
for i in range(self.seq * 2):
self.get_data()
self.tracker()
self.filter_HeartRate()
self.filter_RespRate()
self.matrix_idx += 1
if self.matrix_idx >= self.seq:
self.matrix_idx = 0
self.client.disconnect()
def get_data(self):
# Spara fil sker inte senare. Hämtar data från radarn och sparar det i en matris.
# for i in range(0, self.seq):
if self.matrix_idx < self.seq:
self.info, self.data = self.client.get_next()
self.matrix[self.matrix_idx][:] = self.data[:]
print("Seq number {}".format(self.matrix_idx))
te.sleep(1)
#filename = "test.csv"
#np.savetxt(filename, self.matrix)
def filter_HeartRate(self):
pass
def filter_RespRate(self):
pass
def tracker(self):
self.matrix_copy = self.matrix
# matrix_row =
#tracker_max = np.argmax[np.abs(self.matrix_copy)]
# print(tracker_max)
pass
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()
class GUI(QMainWindow):
sig_scan = pyqtSignal(object)
use_cl = False
data = None
client = None
sweep_count = -1
acc_file = os.path.join(os.path.dirname(__file__), "acc.png")
last_file = os.path.join(os.path.dirname(__file__), "last_config.npy")
sweep_buffer = 500
env_plot_max_y = 0
cl_supported = False
def __init__(self):
super().__init__()
self.init_labels()
self.init_textboxes()
self.init_buttons()
self.init_dropdowns()
self.init_sublayouts()
self.start_up()
self.main_widget = QWidget()
self.main_layout = QtWidgets.QGridLayout(self.main_widget)
self.main_layout.sizeConstraint = QtWidgets.QLayout.SetDefaultConstraint
self.main_layout.addLayout(self.panel_sublayout, 0, 1)
self.main_layout.setColumnStretch(0, 1)
self.canvas = self.init_graphs()
self.main_layout.addWidget(self.canvas, 0, 0)
self.main_widget.setLayout(self.main_layout)
self.setCentralWidget(self.main_widget)
self.setGeometry(50, 50, 1200, 700)
self.setWindowTitle("Acconeer Exploration GUI")
self.show()
self.radar = data_processing.DataProcessing()
def init_labels(self):
text = {
"sensor": "Sensor",
"server": "Host address",
"scan": "Scan",
"gain": "Gain",
"frequency": "Sample frequency",
"sweeps": "Number of sweeps",
"sweep_buffer": "Sweep buffer",
"start_range": "Start (m)",
"end_range": "Stop (m)",
"clutter": "Background settings",
"clutter_file": "",
"interface": "Interface",
"power_bins": "Power bins",
}
self.labels = {}
for key in text:
self.labels[key] = QLabel(self)
for key, val in self.labels.items():
val.setText(text[key])
self.labels["power_bins"].setVisible(False)
def init_textboxes(self):
text = {
"sensor": "1",
"host": "192.168.1.100",
"frequency": "10",
"sweeps": "-1",
"gain": "0.4",
"start_range": "0.18",
"end_range": "0.72",
"sweep_buffer": "100",
"power_bins": "6",
}
self.textboxes = {}
for key in text:
self.textboxes[key] = QLineEdit(self)
self.textboxes[key].setText(text[key])
self.textboxes["power_bins"].setVisible(False)
def init_graphs(self, mode="Select service"):
axes = {
"Select service": [None, None],
"IQ": [None, None],
"Envelope": [None, None],
"Power bin": [None, None],
"Presence detection": [prd, prd.PresenceDetectionProcessor],
"Breathing": [br, br.BreathingProcessor],
"Phase tracking": [pht, pht.PhaseTrackingProcessor],
"Sleep breathing": [sb, sb.PresenceDetectionProcessor],
"Obstacle detection": [od, od.ObstacleDetectionProcessor],
}
self.external = axes[mode][1]
canvas = None
self.textboxes["power_bins"].setVisible(False)
self.labels["power_bins"].setVisible(False)
self.cl_supported = False
if "IQ" in self.mode.currentText() or "Envelope" in self.mode.currentText():
self.cl_supported = True
else:
self.load_clutter_file(force_unload=True)
self.buttons["create_cl"].setEnabled(self.cl_supported)
self.buttons["load_cl"].setEnabled(self.cl_supported)
self.current_canvas = mode
font = QFont()
font.setPixelSize(12)
ax_color = (0, 0, 0)
ax = ("bottom", "left")
if mode == "Select service":
canvas = QLabel()
pixmap = QPixmap(self.acc_file)
canvas.setPixmap(pixmap)
return canvas
pg.setConfigOption("background", "#f0f0f0")
pg.setConfigOption("foreground", "k")
pg.setConfigOption("leftButtonPan", False)
pg.setConfigOptions(antialias=True)
canvas = pg.GraphicsLayoutWidget()
if self.external:
self.service_widget = axes[mode][0].PGUpdater(self.update_sensor_config())
self.service_widget.setup(canvas)
self.external = axes[mode][1]
return canvas
elif "power" in mode.lower():
self.power_plot_window = canvas.addPlot(title="Power bin")
self.power_plot_window.showGrid(x=True, y=True)
for i in ax:
self.power_plot_window.getAxis(i).tickFont = font
self.power_plot_window.getAxis(i).setPen(ax_color)
pen = pg.mkPen(example_utils.color_cycler(0), width=2)
self.power_plot = pg.BarGraphItem(x=np.arange(1, 7),
height=np.linspace(0, 6, num=6),
width=.5,
pen=pen,
name="Power bins")
self.power_plot_window.setLabel("left", "Amplitude")
self.power_plot_window.setLabel("bottom", "Power bin range (mm)")
self.power_plot_window.setYRange(0, 10)
self.power_plot_window.setXRange(0.5, 6.5)
self.power_plot_window.addItem(self.power_plot)
self.textboxes["power_bins"].setVisible(True)
self.labels["power_bins"].setVisible(True)
else:
self.envelope_plot_window = canvas.addPlot(title="Envelope")
self.envelope_plot_window.showGrid(x=True, y=True)
self.envelope_plot_window.addLegend()
for i in ax:
self.envelope_plot_window.getAxis(i).tickFont = font
self.envelope_plot_window.getAxis(i).setPen(ax_color)
pen = example_utils.pg_pen_cycler()
self.envelope_plot = self.envelope_plot_window.plot(range(10),
np.zeros(10),
pen=pen,
name="Envelope")
self.envelope_plot_window.setYRange(0, 1)
pen = pg.mkPen(0.2, width=2, style=QtCore.Qt.DotLine)
self.clutter_plot = self.envelope_plot_window.plot(range(10),
np.zeros(10),
pen=pen,
name="Background")
self.clutter_plot.setZValue(2)
self.snr_text = pg.TextItem(text="", color=(1, 1, 1), anchor=(0, 1))
self.snr_text.setZValue(3)
self.envelope_plot_window.addItem(self.snr_text)
self.envelope_plot_window.setLabel("left", "Amplitude")
self.envelope_plot_window.setLabel("bottom", "Distance (mm)")
canvas.nextRow()
if mode.lower() == "iq":
self.iq_plot_window = canvas.addPlot(title="Phase")
self.iq_plot_window.showGrid(x=True, y=True)
self.iq_plot_window.addLegend()
for i in ax:
self.iq_plot_window.getAxis(i).tickFont = font
self.iq_plot_window.getAxis(i).setPen(ax_color)
pen = example_utils.pg_pen_cycler()
self.iq_plot = self.iq_plot_window.plot(range(10),
np.arange(10)*0,
pen=pen,
name="IQ Phase")
self.iq_plot_window.setLabel("left", "Normalized phase")
self.iq_plot_window.setLabel("bottom", "Distance (mm)")
canvas.nextRow()
self.hist_plot_image = canvas.addPlot()
self.hist_plot = pg.ImageItem(titel="History")
colormap = plt.get_cmap("viridis")
colormap._init()
lut = (colormap._lut * 255).view(np.ndarray)
self.hist_plot.setLookupTable(lut)
pen = example_utils.pg_pen_cycler(1)
self.hist_plot_peak = self.hist_plot_image.plot(range(10),
np.zeros(10),
pen=pen)
self.hist_plot_image.addItem(self.hist_plot)
self.hist_plot_image.setLabel("left", "Distance (mm)")
self.hist_plot_image.setLabel("bottom", "Time (Sweep number)")
for i in ax:
self.hist_plot_image.getAxis(i).tickFont = font
self.hist_plot_image.getAxis(i).setPen(ax_color)
return canvas
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 update_ports(self):
if "scan" not in self.ports.currentText().lower():
return
port_infos = serial.tools.list_ports.comports()
ports = [port_info[0] for port_info in port_infos]
self.ports.clear()
self.ports.addItem("Scan ports")
self.ports.addItems(ports)
def init_buttons(self):
self.buttons = {
"start": QtWidgets.QPushButton("Start", self),
"connect": QtWidgets.QPushButton("Connect", self),
"stop": QtWidgets.QPushButton("Stop", self),
"create_cl": QtWidgets.QPushButton("Scan Background", self),
"load_cl": QtWidgets.QPushButton("Load Background", self),
"load_scan": QtWidgets.QPushButton("Load Scan", self),
"save_scan": QtWidgets.QPushButton("Save Scan", self),
}
button_funcs = {
"start": self.start_scan,
"connect": self.connect_to_server,
"stop": self.stop_scan,
"create_cl": lambda: self.start_scan(create_cl=True),
"load_cl": self.load_clutter_file,
"load_scan": self.load_scan,
"save_scan": lambda: self.save_scan(self.data),
}
button_enabled = {
"start": False,
"connect": True,
"stop": True,
"create_cl": False,
"load_cl": True,
"load_scan": True,
"save_scan": False,
}
for key in button_funcs:
self.buttons[key].clicked.connect(button_funcs[key])
self.buttons[key].setEnabled(button_enabled[key])
def init_sublayouts(self):
# Panel sublayout
self.panel_sublayout = QtWidgets.QHBoxLayout()
panel_sublayout_inner = QtWidgets.QVBoxLayout()
# Server sublayout
server_sublayout_grid = QtWidgets.QGridLayout()
server_sublayout_grid.addWidget(self.labels["server"], 0, 0)
server_sublayout_grid.addWidget(self.labels["interface"], 0, 1)
server_sublayout_grid.addWidget(self.ports, 1, 0)
server_sublayout_grid.addWidget(self.textboxes["host"], 1, 0)
server_sublayout_grid.addWidget(self.interface, 1, 1)
server_sublayout_grid.addWidget(self.mode, 2, 0)
server_sublayout_grid.addWidget(self.buttons["connect"], 2, 1)
# Controls sublayout
control_sublayout_grid = QtWidgets.QGridLayout()
control_sublayout_grid.addWidget(self.labels["scan"], 0, 0)
control_sublayout_grid.addWidget(self.buttons["start"], 1, 0)
control_sublayout_grid.addWidget(self.buttons["stop"], 1, 1)
control_sublayout_grid.addWidget(self.buttons["save_scan"], 2, 0)
control_sublayout_grid.addWidget(self.buttons["load_scan"], 2, 1)
control_sublayout_grid.addWidget(self.labels["clutter"], 3, 0)
control_sublayout_grid.addWidget(self.buttons["create_cl"], 4, 0)
control_sublayout_grid.addWidget(self.buttons["load_cl"], 4, 1)
control_sublayout_grid.addWidget(self.labels["clutter_file"], 5, 0, 1, 2)
# Settings sublayout
settings_sublayout_grid = QtWidgets.QGridLayout()
settings_sublayout_grid.addWidget(self.labels["sensor"], 0, 0)
settings_sublayout_grid.addWidget(self.textboxes["sensor"], 0, 1)
settings_sublayout_grid.addWidget(self.labels["start_range"], 1, 0)
settings_sublayout_grid.addWidget(self.labels["end_range"], 1, 1)
settings_sublayout_grid.addWidget(self.textboxes["start_range"], 2, 0)
settings_sublayout_grid.addWidget(self.textboxes["end_range"], 2, 1)
settings_sublayout_grid.addWidget(self.labels["frequency"], 3, 0)
settings_sublayout_grid.addWidget(self.textboxes["frequency"], 3, 1)
settings_sublayout_grid.addWidget(self.labels["gain"], 4, 0)
settings_sublayout_grid.addWidget(self.textboxes["gain"], 4, 1)
settings_sublayout_grid.addWidget(self.labels["sweeps"], 5, 0)
settings_sublayout_grid.addWidget(self.textboxes["sweeps"], 5, 1)
settings_sublayout_grid.addWidget(self.labels["sweep_buffer"], 6, 0)
settings_sublayout_grid.addWidget(self.textboxes["sweep_buffer"], 6, 1)
settings_sublayout_grid.addWidget(self.labels["power_bins"], 7, 0)
settings_sublayout_grid.addWidget(self.textboxes["power_bins"], 7, 1)
panel_sublayout_inner.addStretch(10)
panel_sublayout_inner.addLayout(server_sublayout_grid)
panel_sublayout_inner.addStretch(2)
panel_sublayout_inner.addLayout(control_sublayout_grid)
panel_sublayout_inner.addStretch(4)
panel_sublayout_inner.addLayout(settings_sublayout_grid)
panel_sublayout_inner.addStretch(20)
self.panel_sublayout.addStretch(5)
self.panel_sublayout.addLayout(panel_sublayout_inner)
self.panel_sublayout.addStretch(10)
def update_canvas(self, force_update=False):
mode = self.mode.currentText()
if force_update or self.current_canvas not in mode:
self.main_layout.removeWidget(self.canvas)
self.canvas.setParent(None)
self.canvas.deleteLater()
self.canvas = None
self.canvas = self.init_graphs(mode)
self.main_layout.addWidget(self.canvas, 0, 0)
self.update_sensor_config()
def update_interface(self):
if self.buttons["connect"].text() == "Disconnect":
self.connect_to_server()
if "serial" in self.interface.currentText().lower():
self.ports.show()
self.textboxes["host"].hide()
self.labels["server"].setText("Serial port")
else:
self.ports.hide()
self.textboxes["host"].show()
self.labels["server"].setText("Host address")
def error_message(self, error):
em = QtWidgets.QErrorMessage(self.main_widget)
em.setWindowTitle("Error")
em.showMessage(error)
def start_scan(self, create_cl=False, from_file=False):
if "Select" in self.mode.currentText():
self.error_message("Please select a service")
return
if self.external:
self.update_canvas(force_update=True)
data_source = "stream"
if from_file:
data_source = "file"
sweep_buffer = 500
try:
sweep_buffer = int(self.textboxes["sweep_buffer"].text())
except Exception:
self.error_message("Sweep buffer needs to be a positive integer\n")
self.textboxes["sweep_buffer"].setText("500")
params = {
"sensor_config": self.update_sensor_config(),
"use_clutter": self.use_cl,
"create_clutter": create_cl,
"data_source": data_source,
"data_type": self.mode_to_param[self.mode.currentText()],
"service_type": self.mode.currentText(),
"sweep_buffer": sweep_buffer,
}
self.threaded_scan = Threaded_Scan(params, parent=self)
self.threaded_scan.sig_scan.connect(self.thread_receive)
self.sig_scan.connect(self.threaded_scan.receive)
self.buttons["start"].setEnabled(False)
self.buttons["load_scan"].setEnabled(False)
self.buttons["save_scan"].setEnabled(False)
self.buttons["create_cl"].setEnabled(False)
self.buttons["load_cl"].setEnabled(False)
self.mode.setEnabled(False)
self.interface.setEnabled(False)
self.threaded_scan.start()
def stop_scan(self):
self.sig_scan.emit("stop")
self.buttons["load_scan"].setEnabled(True)
if self.cl_supported:
self.buttons["load_cl"].setEnabled(True)
self.mode.setEnabled(True)
self.interface.setEnabled(True)
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 update_sensor_config(self):
conf, service = self.mode_to_config[self.mode.currentText()]
if not conf:
return None
external = ("internal" not in service.lower())
conf.sensor = int(self.textboxes["sensor"].text())
if external:
color = "grey"
self.textboxes["start_range"].setText(str(conf.range_interval[0]))
self.textboxes["end_range"].setText(str(conf.range_interval[1]))
self.textboxes["gain"].setText(str(conf.gain))
self.textboxes["frequency"].setText(str(conf.sweep_rate))
self.sweep_count = -1
else:
self.check_values(conf.mode)
color = "white"
conf.range_interval = [
float(self.textboxes["start_range"].text()),
float(self.textboxes["end_range"].text()),
]
conf.sweep_rate = int(self.textboxes["frequency"].text())
conf.gain = float(self.textboxes["gain"].text())
self.sweep_count = int(self.textboxes["sweeps"].text())
conf.bin_count = int(self.textboxes["power_bins"].text())
lock = {
"start_range": True,
"end_range": True,
"frequency": True,
"gain": True,
"sweeps": True,
}
for key in lock:
if "sensor" not in key and "host" not in key:
self.textboxes[key].setReadOnly(external)
style_sheet = "QLineEdit {{background-color: {}}}".format(color)
self.textboxes[key].setStyleSheet(style_sheet)
return conf
def check_values(self, mode):
errors = []
if not self.textboxes["frequency"].text().isdigit():
errors.append("Frequency must be an integer and not less than 0!\n")
self.textboxes["frequency"].setText("10")
if not self.textboxes["sensor"].text().isdigit():
errors.append("Sensor must be an integer between 1 and 4!\n")
self.textboxes["sensor"].setText("0")
else:
sensor = int(self.textboxes["sensor"].text())
sensor, e = self.check_limit(sensor, self.textboxes["sensor"], 1, 4)
if e:
errors.append("Sensor must be an integer between 1 and 4!\n")
sweeps = self.is_float(self.textboxes["sweeps"].text(), is_positive=False)
if sweeps == -1:
pass
elif sweeps >= 1:
if not self.textboxes["sweeps"].text().isdigit():
errors.append("Sweeps must be a -1 or an int larger than 0!\n")
self.textboxes["sensor"].setText("-1")
else:
errors.append("Sweeps must be -1 or an int larger than 0!\n")
self.textboxes["sweeps"].setText("-1")
gain = self.is_float(self.textboxes["gain"].text())
gain, e = self.check_limit(gain, self.textboxes["gain"], 0, 1, set_to=0.7)
if e:
errors.append("Gain must be between 0 and 1!\n")
start = self.is_float(self.textboxes["start_range"].text())
start, e = self.check_limit(start, self.textboxes["start_range"], 0.06, 6.94)
if e:
errors.append("Start range must be between 0.06m and 6.94m!\n")
end = self.is_float(self.textboxes["end_range"].text())
end, e = self.check_limit(end, self.textboxes["end_range"], 0.12, 7)
if e:
errors.append("End range must be between 0.12m and 7.0m!\n")
r = end - start
if r < 0:
errors.append("Range must not be less than 0!\n")
self.textboxes["end_range"].setText(str(start + 0.06))
end = start + 0.06
r = end - start
if "envelope" in mode.lower() and r > 0.96:
errors.append("Envelope range must be less than 0.96m!\n")
self.textboxes["end_range"].setText(str(start + 0.96))
end = start + 0.96
r = end - start
if "iq" in mode.lower() and r > 0.72:
errors.append("IQ range must be less than 0.72m!\n")
end = start + 0.72
r = end - start
if len(errors):
self.error_message("".join(errors))
def is_float(self, val, is_positive=True):
try:
f = float(val)
if is_positive and f <= 0:
raise ValueError("Not positive")
return f
except Exception:
return False
def check_limit(self, val, field, start, end, set_to=None):
out_of_range = False
if isinstance(val, bool):
val = start
out_of_range = True
if val < start:
val = start
out_of_range = True
if val > end:
val = end
out_of_range = True
if out_of_range:
if set_to:
val = set_to
field.setText(str(val))
return val, out_of_range
def load_clutter_file(self, force_unload=False):
if "unload" in self.buttons["load_cl"].text().lower() or force_unload:
self.use_cl = None
self.labels["clutter_file"].setText("")
self.buttons["load_cl"].setText("Load Background")
self.buttons["load_cl"].setStyleSheet("QPushButton {color: black}")
else:
options = QtWidgets.QFileDialog.Options()
options |= QtWidgets.QFileDialog.DontUseNativeDialog
fn, _ = QtWidgets.QFileDialog.getOpenFileName(
self,
"Load background file",
"",
"All Files (*);;NumPy data Files (*.npy)",
options=options
)
if fn:
self.use_cl = fn
self.labels["clutter_file"].setText("Background: {}".format(ntpath.basename(fn)))
self.buttons["load_cl"].setText("Unload background")
self.buttons["load_cl"].setStyleSheet("QPushButton {color: red}")
def load_scan(self):
options = QtWidgets.QFileDialog.Options()
options |= QtWidgets.QFileDialog.DontUseNativeDialog
filename, _ = QtWidgets.QFileDialog.getOpenFileName(
self,
"Load scan",
"",
"NumPy data files (*.npy)",
options=options
)
if filename:
try:
self.data = np.load(filename)
mode = self.data[0]["service_type"]
index = self.mode.findText(mode, QtCore.Qt.MatchFixedString)
if index >= 0:
self.mode.setCurrentIndex(index)
self.start_scan(from_file=True)
except Exception as e:
self.error_message("{}".format(e))
def save_scan(self, data, clutter=False):
if "sleep" in self.mode.currentText().lower():
if int(self.textboxes["sweep_buffer"].text()) < 1000:
self.error_message("Please set sweep buffer to >= 1000")
return
options = QtWidgets.QFileDialog.Options()
options |= QtWidgets.QFileDialog.DontUseNativeDialog
title = "Save scan"
if clutter:
title = "Save background"
filename, _ = QtWidgets.QFileDialog.getSaveFileName(
self, title, "", "NumPy data files (*.npy)", options=options)
if filename:
np.save(filename, data)
if clutter:
self.use_cl = filename
label_text = "Background: {}".format(ntpath.basename(filename))
self.labels["clutter_file"].setText(label_text)
self.buttons["load_cl"].setText("Unload background")
self.buttons["load_cl"].setStyleSheet("QPushButton {color: red}")
def thread_receive(self, message_type, message, data=None):
if "error" in message_type:
self.error_message("{}".format(message))
if "client" in message_type:
if self.buttons["connect"].text() == "Disconnect":
self.connect_to_server()
self.buttons["start"].setEnabled(False)
self.buttons["create_cl"].setEnabled(False)
self.mode.setEnabled(True)
self.interface.setEnabled(True)
elif message_type == "clutter_data":
self.save_scan(data, clutter=True)
elif message_type == "scan_data":
self.data = data
self.buttons["save_scan"].setEnabled(True)
elif message_type == "scan_done":
if "Disconnect" in self.buttons["connect"].text():
self.buttons["start"].setEnabled(True)
self.buttons["load_scan"].setEnabled(True)
if self.cl_supported:
self.buttons["create_cl"].setEnabled(True)
self.buttons["load_cl"].setEnabled(True)
self.mode.setEnabled(True)
elif "update_plots" in message_type:
if data:
self.update_plots(data)
elif "update_power_plots" in message_type:
if data:
self.update_power_plots(data)
elif "update_external_plots" in message_type:
if data:
self.update_external_plots(data)
else:
print(message_type, message, data)
def update_plots(self, data):
mode = self.mode.currentText()
update_ylims = False
xstart = data["x_mm"][0]
xend = data["x_mm"][-1]
xdim = data["hist_env"].shape[0]
if not data["sweep"]:
self.env_plot_max_y = 0
update_ylims = True
self.envelope_plot_window.setXRange(xstart, xend)
self.snr_text.setPos(xstart, 0)
if mode == "IQ":
self.iq_plot_window.setXRange(xstart, xend)
self.iq_plot_window.setYRange(-1.1, 1.1)
xax = self.hist_plot_image.getAxis("left")
x = np.round(np.arange(0, xdim+xdim/9, xdim/9))
labels = np.round(np.arange(xstart, xend+(xend-xstart)/9,
(xend-xstart)/9))
ticks = [list(zip(x, labels))]
xax.setTicks(ticks)
snr = "SNR@peak: N/A"
if data["snr"] and np.isfinite(data["snr"]):
snr = "SNR@peak: %.1fdB" % data["snr"]
self.snr_text.setText(snr, color=(1, 1, 1))
max_val = max(np.max(data["env_clutter"]+data["env_ampl"]), np.max(data["env_clutter"]))
peak_line = np.flip((data["hist_plot"]-xstart)/(xend - xstart)*xdim, axis=0)
self.envelope_plot.setData(data["x_mm"], data["env_ampl"] + data["env_clutter"])
self.clutter_plot.setData(data["x_mm"], data["env_clutter"])
ymax_level = min(1.5*np.max(np.max(data["hist_env"])), self.env_plot_max_y)
self.hist_plot.updateImage(data["hist_env"].T, levels=(0, ymax_level))
self.hist_plot_peak.setData(peak_line)
self.hist_plot_peak.setZValue(2)
if mode == "IQ":
self.iq_plot.setData(data["x_mm"], data["phase"])
if max_val > self.env_plot_max_y:
self.env_plot_max_y = 1.2 * max_val
update_ylims = True
if update_ylims:
self.envelope_plot_window.setYRange(0, self.env_plot_max_y)
if self.sweep_buffer > data["sweep"]:
self.hist_plot_image.setYRange(0, xdim)
def update_power_plots(self, data):
update_ylims = False
xstart = data["x_mm"][0]
xend = data["x_mm"][-1]
update_ylims = False
if not data["sweep"]:
bin_num = int(self.textboxes["power_bins"].text())
bin_width = (xend - xstart)/(bin_num + 1)
self.env_plot_max_y = 0
update_ylims = True
self.power_plot_window.setXRange(xstart, xend)
self.power_plot.setOpts(x=data["x_mm"], width=bin_width)
self.power_plot_window.setXRange(xstart - bin_width / 2,
xend + bin_width / 2)
self.power_plot.setOpts(height=data["iq_data"])
if max(data["iq_data"]) > self.env_plot_max_y:
self.env_plot_max_y = 1.2 * max(data["iq_data"])
update_ylims = True
if update_ylims:
self.power_plot_window.setYRange(0, self.env_plot_max_y)
def update_external_plots(self, data):
self.service_widget.update(data)
def start_up(self):
if os.path.isfile(self.last_file):
try:
last = np.load(self.last_file)
self.update_settings(last.item()["sensor_config"], last.item())
except Exception as e:
print("Could not load settings from last session\n{}".format(e))
def update_settings(self, sensor_config, last_config=None):
try:
self.textboxes["gain"].setText("{:.1f}".format(sensor_config.gain))
self.textboxes["frequency"].setText(str(sensor_config.sweep_rate))
self.textboxes["start_range"].setText("{:.2f}".format(sensor_config.range_interval[0]))
self.textboxes["end_range"].setText("{:.2f}".format(sensor_config.range_interval[1]))
self.textboxes["sweep_buffer"].setText(last_config["sweep_buffer"])
self.textboxes["sensor"].setText("{:d}".format(sensor_config.sensor[0]))
self.interface.setCurrentIndex(last_config["interface"])
self.ports.setCurrentIndex(last_config["port"])
except Exception as e:
print("Warning, could not restore last session\n{}".format(e))
if last_config:
self.textboxes["host"].setText(last_config["host"])
self.sweep_count = last_config["sweep_count"]
def closeEvent(self, event=None):
if "select" not in str(self.mode.currentText()).lower():
last_config = {
"sensor_config": self.update_sensor_config(),
"sweep_count": self.sweep_count,
"host": self.textboxes["host"].text(),
"sweep_buffer": self.textboxes["sweep_buffer"].text(),
"interface": self.interface.currentIndex(),
"port": self.ports.currentIndex(),
}
np.save(self.last_file, last_config)
try:
self.client.disconnect()
except Exception:
pass
self.close()
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()
class Radar(threading.Thread):
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):
# Metod för att hämta data från radarn
self.client.start_streaming() # Startar streaming tjänsten (Som ytterligare en egen tråd?)
for i in range(self.seq*2):
self.get_data() # Hämta data metoden
self.tracker()
self.filter_HeartRate()
self.filter_RespRate()
self.matrix_idx += 1
if self.matrix_idx >= self.seq:
self.matrix_idx = 0
self.client.disconnect()
def get_data(self):
# Spara fil sker inte senare. Hämtar data från radarn och sparar det i en matris.
# for i in range(0, self.seq):
if self.matrix_idx < self.seq: # När index är under totala sekvenser fylls matrisen och datan sparas i kön.
self.info, self.data = self.client.get_next()
self.temp_vector = np.abs(self.data)
#self.matrix[self.matrix_idx][:] = self.data[:]
#print("Seq number {}".format(self.matrix_idx))
self.q.put(self.data)
# print(self.q.get())
#filename = "test.csv"
#np.savetxt(filename, self.matrix)
def filter_HeartRate(self):
pass
def filter_RespRate(self):
pass
def tracker(self):
if self.matrix_idx == 0:
self.amplitude = np.abs(self.data)
self.peak = np.argmax(self.amplitude)
else:
# print(tracker_max)
pass
