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)
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)
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 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, 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, 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 = JSONClient(args.socket_addr)
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.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:
client = JSONClient(args.socket_addr)
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
info = client.setup_session(config)
num_points = info["actual_bin_count"]
pg_updater = PGUpdater(config, num_points)
pg_process = PGProcess(pg_updater)
pg_process.start()
client.start_streaming()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
while not interrupt_handler.got_signal:
info, data = client.get_next()
try:
pg_process.put_data(data)
except PGProccessDiedException:
break
print("Disconnecting...")
pg_process.close()
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser().parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
elif args.spi:
client = RegSPIClient()
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
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(num_sens=1).parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
config = get_base_config()
config.sensor = args.sensors
client.setup_session(config)
pg_updater = PGUpdater(config)
pg_process = PGProcess(pg_updater)
pg_process.start()
client.start_streaming()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
processor = ObstacleDetectionProcessor(config)
while not interrupt_handler.got_signal:
info, sweep = client.get_next()
plot_data = processor.process(sweep)
if plot_data is not None:
try:
pg_process.put_data(plot_data)
except PGProccessDiedException:
break
print("Disconnecting...")
pg_process.close()
client.disconnect()
def __init__(self, HR_filter_queue,
go): # Lägg till RR_filter_queue som inputargument
self.go = go
# Setup for collecting data from radar
self.args = example_utils.ExampleArgumentParser().parse_args()
example_utils.config_logging(self.args)
if self.args.socket_addr:
self.client = JSONClient(self.args.socket_addr)
# Test för att se vilken port som används av radarn
print("RADAR Port = " + self.args.socket_addr)
else:
port = self.args.serial_port or example_utils.autodetect_serial_port(
)
self.client = RegClient(port)
self.client.squeeze = False
self.config = configs.IQServiceConfig()
self.config.sensor = self.args.sensors
self.config.range_interval = [0.2, 0.6] # Measurement interval
self.config.sweep_rate = 20 # Frequency for collecting data
self.config.gain = 1 # Gain between 0 and 1.
self.time = 1 # Duration for a set amount of sequences
self.seq = self.config.sweep_rate * self.time # Amount of sequences during a set time and sweep freq
self.info = self.client.setup_session(
self.config) # Setup acconeer radar session
self.num_points = self.info[
"data_length"] # Amount of data points per sampel
self.data_getting = 0 # Inedex for printing still getting data once a second
self.HR_filter_queue = HR_filter_queue
# self.a = a
# self.RR_filter_queue = RR_filter_queue
# Initiation for tracking method
self.N_avg = 10 # How manny peaks averaged over when calculating peaks_filtered
self.I_peaks = np.zeros(self.N_avg)
self.locs = np.zeros(self.N_avg)
self.I_peaks_filtered = np.zeros(self.N_avg)
self.tracked_distance = np.zeros(self.N_avg)
self.tracked_amplitude = np.zeros(self.N_avg)
self.tracked_phase = np.zeros(self.N_avg)
self.threshold = 0 # variable for finding peaks above threshold
self.data_idx = 0 # Index in vector for tracking. Puts new tracked peak into tracking vector
# converts index to real length
self.real_dist = np.linspace(self.config.range_interval[0],
self.config.range_interval[1],
num=self.num_points)
self.counter = 0 # Used only for if statement only for first iteration and not when data_idx goes back to zero
super(Radar, self).__init__() # Inherit threading vitals
def main():
args = example_utils.ExampleArgumentParser().parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
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 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 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 main():
args = example_utils.ExampleArgumentParser(num_sens=1).parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
config = config_setup()
config.sensor = args.sensors
tid = 10
sekvenser = tid * config.sweep_rate
filename = "Reflektor_2.csv"
info = client.setup_session(config)
num_points = info["data_length"]
amplitude_y_max = 22000
N_avg = 10
tracking = Tracking(num_points, config.range_interval, N_avg)
print("numpoints: ", num_points)
fig, (amplitude_ax) = plt.subplots(1)
fig.set_size_inches(12, 6)
fig.canvas.set_window_title(filename)
for ax in [amplitude_ax]:
# ax.set_xlabel("Depth (m)")
# ax.set_xlim(config.range_interval)
ax.set_xlabel("Time (s)")
ax.set_xlim(0, 100)
# amplitude_ax.set_ylabel("Amplitude")
# amplitude_ax.set_ylim(0, 1.1 * amplitude_y_max)
amplitude_ax.set_ylabel("tracked distance (m)")
amplitude_ax.set_ylim(config.range_interval)
xs = np.linspace(0, 100, num=100)
amplitude_line = amplitude_ax.plot(xs, np.zeros_like(xs))[0]
fig.tight_layout()
plt.ion()
plt.show()
list = np.zeros(100)
i = 0
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
client.start_streaming()
matris = np.zeros((sekvenser, 2))
counter = 0
while not interrupt_handler.got_signal:
# for i in range(0, sekvenser):
info, sweep = client.get_next()
start = round(time.time() * 1000) / 1000
track = tracking.tracking(sweep)
end = round(time.time() * 1000) / 1000
print("Time for tracking loop {}".format(end - start))
list[i] = track
amplitude_line.set_ydata(list)
i += 1
if i == 100:
i = 0
list = np.zeros(100)
if not plt.fignum_exists(1): # Simple way to check if plot is closed
break
fig.canvas.flush_events()
# annotate.remove()
# matris = np.mean(matris, axis=0)
# np.savetxt(filename, matris, delimiter=",")
print("Disconnecting...")
plt.close()
client.disconnect()
def __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 = []
class DataAcquisition(threading.Thread):
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 run(self):
self.client.start_streaming() # Starts Acconeers streaming server
while self.go:
self.run_times = self.run_times + 1
# This data is an 1D array in terminal print, not in Python script however....
data = self.get_data()
tracked_data = self.tracking(data) # processing data and tracking peaks
# Test with acconeer filter for schmitt.
if tracked_data is not None:
# filter the data
highpass_filtered_data_HR = self.highpass_HR.filter(
tracked_data["relative distance"])
bandpass_filtered_data_HR = self.lowpass_HR.filter(highpass_filtered_data_HR)
highpass_filtered_data_RR = self.highpass_RR.filter(
tracked_data["relative distance"])
bandpass_filtered_data_RR = self.lowpass_RR.filter(highpass_filtered_data_RR)
if self.run_measurement:
self.HR_filtered_queue.put(
bandpass_filtered_data_HR) # Put filtered data in output queue to send to SignalProcessing
self.RR_filtered_queue.put(bandpass_filtered_data_RR)
# self.RTB_final_queue.put(bandpass_filtered_data_RR)
# Send to app
if self.run_times % self.modulo_base == 0:
# Send real time breathing amplitude to the application
self.bluetooth_server.write_data_to_app(
tracked_data["real time breathing amplitude"], 'real time breath')
# self.bluetooth_server.write_data_to_app(
# bandpass_filtered_data_HR, 'real time breath')
self.csv_filtered_respitory(bandpass_filtered_data_RR)
if self.plot_graphs and self.run_times % self.modulo_base == 0:
try:
self.pg_process.put_data(tracked_data) # plot data
except PGProccessDiedException:
self.go.pop(0)
break
self.RR_filtered_queue.put(0) # to quit the signal processing thread
# print('before for loop to fill HR queue')
for i in range(600):
# print("Data acq filling HR queue with 0:s")
self.HR_filtered_queue.put(0)
print("out of while go in radar")
self.client.disconnect()
self.pg_process.close()
def get_data(self):
# self.client.get_next()
info, data = self.client.get_next() # get the next data from the radar
# print('info',info[-1]['sequence_number'],'run_times',self.run_times)
if info[-1]['sequence_number'] > self.run_times + 10:
# to remove delay if handling the data takes longer time than for the radar to get it
print("sequence diff over 10, removing difference",
info[-1]['sequence_number']-self.run_times)
for i in range(0, info[-1]['sequence_number']-self.run_times):
self.client.get_next() # getting the data without using it
info, data = self.client.get_next()
self.run_times = info[-1]['sequence_number']
return data
def tracking(self, data):
data = np.array(data).flatten()
data_length = len(data)
amplitude = np.abs(data)
power = amplitude * amplitude
# Find and track peaks
if np.sum(amplitude)/data_length > 1e-6:
max_peak_index = np.argmax(power)
max_peak_amplitude = amplitude[max_peak_index]
if self.first_data: # first time
self.track_peak_index.append(max_peak_index) # global max peak
self.track_peaks_average_index = max_peak_index
else:
self.local_peaks_index, _ = signal.find_peaks(power) # find local max in data
index = 0
index_list = []
for peak in self.local_peaks_index:
if np.abs(amplitude[peak]) < self.threshold:
index_list.append(index)
index += 1
# deletes all indexes with amplitude < threshold
np.delete(self.local_peaks_index, index_list)
if len(self.local_peaks_index) == 0: # if no large peaks were found, use the latest value instead
print("No local peak found")
self.track_peak_index.append(self.track_peak_index[-1])
else:
# Difference between found local peaks and last tracked peak
peak_difference_index = np.subtract(
self.local_peaks_index, self.track_peaks_average_index)
# The tracked peak is expected to be the closest local peak found
self.track_peak_index.append(
self.local_peaks_index[np.argmin(np.abs(peak_difference_index))])
if len(self.track_peak_index) > self.number_of_averages:
self.track_peak_index.pop(0) # remove oldest value
if amplitude[self.track_peak_index[-1]] < 0.5 * max_peak_amplitude: # if there is a much larger peak
self.track_peak_index.clear() # reset the array
self.track_peak_index.append(max_peak_index) # new peak is global max
self.track_peaks_average_index = int( # Average and smooth the movements of the tracked peak
np.round(self.low_pass_const * (np.average(self.track_peak_index))
+ (1 - self.low_pass_const) * self.track_peaks_average_index))
# threshold for next peak
self.threshold = np.abs(amplitude[self.track_peaks_average_index]) * 0.8
# so it won't follow a much smaller peak
self.track_peak_relative_position = self.track_peaks_average_index / \
len(data) # Position of the peak
# relative the range of the data
# Converts relative distance to absolute distance
self.tracked_distance = (1 - self.track_peaks_average_index / len(data)) * self.config.range_interval[
0] + self.track_peaks_average_index / len(data) * self.config.range_interval[1]
# Tracked amplitude is absolute value of data for the tracked index
# TODO byt till denna
self.tracked_amplitude = amplitude[self.track_peaks_average_index]
# Tracked phase is the angle between I and Q in data for tracked index
self.tracked_phase = np.angle(data[self.track_peaks_average_index])
else:
# track_peak_relative_position = 0
self.not_noise_run_time = 0
self.tracked_distance = 0
self.tracked_phase = 0
self.tracked_amplitude = 0
if self.first_data: # first time
self.track_peaks_average_index = 0
# Plots, phase to distance and noise ignoring
if self.first_data:
self.tracked_data = None
self.low_pass_amplitude = amplitude
else:
# Amplitude of data for plotting
self.low_pass_amplitude = self.low_pass_const * amplitude + \
(1 - self.low_pass_const) * self.low_pass_amplitude
# real time graph over the whole range
# self.tracked_distance_over_time = np.roll(
# self.tracked_distance_over_time, -1) # Distance over time
# self.tracked_distance_over_time[-1] = self.tracked_distance
# real time graph zoomed in
# com_idx = int(self.track_peak_relative_position * data_length)
# delta_angle = np.angle(data[com_idx] * np.conj(self.last_data[com_idx]))
# vel = self.list_of_variables_for_threads["sample_freq"] * 2.5 * delta_angle / (2 * np.pi)
# self.low_pass_vel = self.low_pass_const * vel + \
# (1 - self.low_pass_const) * self.low_pass_vel
# dp = self.low_pass_vel / self.list_of_variables_for_threads["sample_freq"]
# self.hist_pos = np.roll(self.hist_pos, -1)
# self.hist_pos[-1] = self.hist_pos[-2] + dp
# plot_hist_pos = self.hist_pos - self.hist_pos.mean()
plot_hist_pos = None
# self.RTB_final_queue.put(plot_hist_pos[-1]*10) # Gets tracked breathing in mm
# self.RR_filtered_queue.put(plot_hist_pos[-1]*10)
# Phase to distance and unwrapping
discount = 2 # TODO optimize for movements
if self.tracked_phase < -np.pi + discount and self.last_phase > np.pi - discount:
wrapped_phase = self.tracked_phase + 2 * np.pi
elif self.tracked_phase > np.pi - discount and self.last_phase < -np.pi + discount:
wrapped_phase = self.tracked_phase - 2 * np.pi
else:
wrapped_phase = self.tracked_phase
# Delta distance
self.delta_distance = self.wave_length * \
(wrapped_phase - self.last_phase) / (4 * np.pi)
# Low pass filtered delta distance
self.delta_distance_low_pass = self.wave_length * (wrapped_phase - self.last_phase) / (4 * np.pi) * self.low_pass_const + \
(1 - self.low_pass_const) * \
self.delta_distance_low_pass # calculates the distance traveled from phase differences
# TODO testa med konjugat
# delta_angle = np.angle(data[self.track_peaks_average_index] * np.conj(self.last_data[self.track_peaks_average_index]))
# vel = self.list_of_variables_for_threads["sample_freq"] * 2.5 * delta_angle / (2 * np.pi)
# self.low_pass_vel = self.low_pass_const * vel + \
# (1 - self.low_pass_const) * self.low_pass_vel
# self.delta_distance = self.low_pass_vel / self.list_of_variables_for_threads["sample_freq"] / 1000
# Remove Noise
# Indicate if the current measurement is noise or not, to not use the noise in signal_processing
if np.amax(self.low_pass_amplitude) < 0.01:
# Noise
self.noise_run_time += 1
if self.noise_run_time >= 10 and self.not_noise_run_time >= 5:
self.not_noise_run_time = 0
else:
# Real value
self.not_noise_run_time += 1
if self.noise_run_time >= 10 and self.not_noise_run_time >= 5:
self.noise_run_time = 0
if self.noise_run_time >= 10 and self.not_noise_run_time < 5:
# If there has been noise at least 10 times with less than 5 real values, the data is considered to be purely noise.
self.tracked_distance = 0
self.delta_distance = 0
self.delta_distance_low_pass = 0
if self.real_time_breathing_amplitude == 0:
self.old_realtime_breathing_amplitude = np.zeros(1000)
self.relative_distance = self.relative_distance - self.delta_distance # relative distance in m
self.real_time_breathing_amplitude = self.real_time_breathing_amplitude - \
self.delta_distance_low_pass # real time breathing in m
# The minus sign comes from changing coordinate system; what the radar think is outward is inward for the person that is measured on
self.last_phase = self.tracked_phase
# Code to remove bias that comes from larger movements that is not completely captured by the radar.
self.old_realtime_breathing_amplitude = np.roll(
self.old_realtime_breathing_amplitude, -1)
self.old_realtime_breathing_amplitude[-1] = self.real_time_breathing_amplitude
self.old_realtime_breathing_amplitude = self.old_realtime_breathing_amplitude - \
self.old_realtime_breathing_amplitude.mean() / 4
self.real_time_breathing_amplitude = self.old_realtime_breathing_amplitude[-1]
# self.amp_data.append(self.relative_distance*1000)
# if len(self.amp_data) > 500:
# print('mean', np.mean(self.amp_data))
# print('variance', np.var(self.amp_data))
# print('min', np.amin(self.amp_data))
# print('max', np.amax(self.amp_data))
# print('std', np.std(self.amp_data))
# print('diff', np.amax(self.amp_data) - np.amin(self.amp_data))
# self.amp_data.clear()
# Tracked data to return and plot
self.tracked_data = {"tracked distance": self.tracked_distance,
"tracked amplitude": self.tracked_amplitude, "tracked phase": self.tracked_phase,
"abs": self.low_pass_amplitude, "tracked distance over time": plot_hist_pos,
"tracked distance over time 2": self.tracked_distance_over_time,
"relative distance": self.relative_distance * 1000,
"real time breathing amplitude": self.real_time_breathing_amplitude*1000}
self.last_data = data
self.first_data = False
return self.tracked_data
# Creates low-pass filter constants for a very small low-pass filter
def low_pass_filter_constants_function(self, tau, dt):
return 1 - np.exp(-dt / tau)
def csv_filtered_respitory(self, bandpass_filtered_data_RR):
if self.initiate_write_respitory_rate and time.time() - self.list_of_variables_for_threads["start_write_to_csv_time"] < 5*60:
#print("Inside save to csv respitory rate")
self.resp_rate_csv.append(bandpass_filtered_data_RR)
# lf.heart_rate_reliability_csv.append(found_peak_reliability_int)
elif self.initiate_write_respitory_rate:
self.go.pop(0)
self.list_of_variables_for_threads["go"] = self.go
# print("Out of while go heart_rate")
np_csv = np.asarray(self.resp_rate_csv)
# print("Saved as numpy array")
np.savetxt("respitory_rate.csv", np_csv, delimiter=";")
print("Should have saved CSV")
self.resp_rate_csv.clear()
# Remove Bluetooth clients
for client in self.bluetooth_server.client_list:
print('try to remove client ' +
str(self.bluetooth_server.address_list[self.bluetooth_server.client_list.index(client)]))
client.close()
print('remove client ' +
str(self.bluetooth_server.address_list[self.bluetooth_server.client_list.index(client)]))
self.bluetooth_server.server.close()
print("server is now closed")
os.system("echo 'power off\nquit' | bluetoothctl")
def main():
args = example_utils.ExampleArgumentParser(num_sens=1).parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
config = configs.EnvelopeServiceConfig()
config.sensor = args.sensors
config.range_interval = [0.2, 0.6]
config.sweep_rate = 60
config.gain = 0.65
info = client.setup_session(config)
num_points = info["data_length"]
xs = np.linspace(*config.range_interval, num_points)
num_hist = 2 * config.sweep_rate
hist_data = np.zeros([num_hist, num_points])
hist_max = np.zeros(num_hist)
smooth_max = example_utils.SmoothMax(config.sweep_rate)
app = QtGui.QApplication([])
pg.setConfigOption("background", "w")
pg.setConfigOption("foreground", "k")
pg.setConfigOptions(antialias=True)
win = pg.GraphicsLayoutWidget()
win.closeEvent = lambda _: interrupt_handler.force_signal_interrupt()
win.setWindowTitle("Acconeer PyQtGraph example")
env_plot = win.addPlot(title="Envelope")
env_plot.showGrid(x=True, y=True)
env_plot.setLabel("bottom", "Depth (m)")
env_plot.setLabel("left", "Amplitude")
env_curve = env_plot.plot(pen=pg.mkPen("k", width=2))
win.nextRow()
hist_plot = win.addPlot()
hist_plot.setLabel("bottom", "Time (s)")
hist_plot.setLabel("left", "Depth (m)")
hist_image_item = pg.ImageItem()
hist_image_item.translate(-2, config.range_start)
hist_image_item.scale(2 / num_hist, config.range_length / num_points)
hist_plot.addItem(hist_image_item)
# try to get a colormap from matplotlib
try:
hist_image_item.setLookupTable(example_utils.pg_mpl_cmap("viridis"))
except ImportError:
pass
win.show()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
client.start_streaming()
while not interrupt_handler.got_signal:
info, sweep = client.get_next()
hist_data = np.roll(hist_data, -1, axis=0)
hist_data[-1] = sweep
hist_max = np.roll(hist_max, -1)
hist_max[-1] = np.max(sweep)
y_max = smooth_max.update(np.amax(hist_max))
env_curve.setData(xs, sweep)
env_plot.setYRange(0, y_max)
hist_image_item.updateImage(hist_data, levels=(0, y_max))
app.processEvents()
print("Disconnecting...")
app.closeAllWindows()
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser(num_sens=1).parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
config = get_base_config()
config.sensor = args.sensors
info1 = client.setup_session(config)
num_points = info1["data_length"]
fig_updater = ExampleFigureUpdater(config)
plot_process = PlotProcess(fig_updater)
plot_process.start()
client.start_streaming()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
processor = PhaseTrackingProcessor(config)
start = time.time()
i = 0
while not interrupt_handler.got_signal:
info, sweep = client.get_next()
plot_data = processor.process(sweep)
try:
plot_process.put_data(
plot_data) # Will ignore the first None from processor
except PlotProccessDiedException:
break
i += 1
end = time.time()
print(i + 1)
print((end - start), "s")
print("Disconnecting...")
plot_process.close()
client.disconnect()
# k = 1
# m = num_points
# n = 50
# matris_real = np.zeros((n, m), dtype=np.csingle)
# matris_imag = np.zeros((n, m), dtype=np.csingle)
# while not interrupt_handler.got_signal:
# if k < 100:
# k += 1
# matris_imag = np.roll(matris_imag, 1, axis=0)
# matris_real = np.roll(matris_real, 1, axis=0)
# info, sweep = client.get_next()
# vector_real_temp = np.real(sweep)
# vector_imag_temp = np.imag(sweep)
# matris_real[[0], :] = vector_real_temp
# matris_imag[[0], :] = vector_imag_temp
# vector_real = np.mean(matris_real, axis=0)
# vector_imag = np.mean(matris_imag, axis=0)
# vector = vector_real + 1j*vector_imag
# plot_data = processor.process(vector)
# if plot_data is not None:
# try:
# plot_process.put_data(plot_data)
# except PlotProccessDiedException:
# break
# Fungerande test av medelvärdesbildning
# k=100
# while not interrupt_handler.got_signal:
# info, sweep = client.get_next()
# real_tot = np.zeros(num_points)
# imag_tot = np.zeros(num_points)
# for i in range(1, k):
# info, sweep = client.get_next()
# real = sweep.real
# imag = sweep.imag
# imag_tot = list(map(operator.add, imag_tot, imag))
# real_tot = np.add(real_tot, real)
# imag_tot = [x / k for x in imag_tot]
# real = [x / k for x in real_tot]
# plot_data = processor.process(sweep)
# if plot_data is not None:
# try:
# plot_process.put_data(plot_data)
# except PlotProccessDiedException:
# break
print("Disconnecting...")
plot_process.close()
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser(num_sens=1).parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
elif args.spi:
client = RegSPIClient()
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
config = configs.IQServiceConfig()
config.sensor = args.sensors
config.range_interval = [0.2, 0.6]
config.sweep_rate = 10
config.gain = 0.6
info = client.setup_session(config)
num_points = info["data_length"]
amplitude_y_max = 0.3
fig, (amplitude_ax, phase_ax) = plt.subplots(2)
fig.set_size_inches(8, 6)
fig.canvas.set_window_title("Acconeer matplotlib example")
for ax in [amplitude_ax, phase_ax]:
ax.set_xlabel("Depth (m)")
ax.set_xlim(config.range_interval)
ax.grid(True)
amplitude_ax.set_ylabel("Amplitude")
amplitude_ax.set_ylim(0, 1.1 * amplitude_y_max)
phase_ax.set_ylabel("Phase")
example_utils.mpl_setup_yaxis_for_phase(phase_ax)
xs = np.linspace(*config.range_interval, num_points)
amplitude_line = amplitude_ax.plot(xs, np.zeros_like(xs))[0]
phase_line = phase_ax.plot(xs, np.zeros_like(xs))[0]
fig.tight_layout()
plt.ion()
plt.show()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
client.start_streaming()
while not interrupt_handler.got_signal:
info, sweep = client.get_next()
amplitude = np.abs(sweep)
phase = np.angle(sweep)
max_amplitude = np.max(amplitude)
if max_amplitude > amplitude_y_max:
amplitude_y_max = max_amplitude
amplitude_ax.set_ylim(0, 1.1 * max_amplitude)
amplitude_line.set_ydata(amplitude)
phase_line.set_ydata(phase)
if not plt.fignum_exists(1): # Simple way to check if plot is closed
break
fig.canvas.flush_events()
print("Disconnecting...")
plt.close()
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser(num_sens=1).parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
config = config_setup()
config.sensor = args.sensors
tid = 10
sekvenser = tid * config.sweep_rate
filename = "Reflektor_2.csv"
info = client.setup_session(config)
num_points = info["data_length"]
amplitude_y_max = 22000
fig, (amplitude_ax) = plt.subplots(1)
fig.set_size_inches(12, 6)
fig.canvas.set_window_title(filename)
for ax in [amplitude_ax]:
ax.set_xlabel("Depth (m)")
ax.set_xlim(config.range_interval)
ax.set_xticks(np.linspace(0.4, 0.8, num=5))
ax.set_xticks(np.concatenate([
np.linspace(0.41, 0.49, num=9),
np.linspace(0.51, 0.59, num=9),
np.linspace(0.61, 0.69, num=9),
np.linspace(0.71, 0.79, num=9)
]),
minor=True)
ax.grid(True, which='major')
ax.grid(True, which='minor')
amplitude_ax.set_ylabel("Amplitude")
amplitude_ax.set_ylim(0, 1.1 * amplitude_y_max)
xs = np.linspace(*config.range_interval, num_points)
amplitude_line = amplitude_ax.plot(xs, np.zeros_like(xs))[0]
fig.tight_layout()
plt.ion()
plt.show()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
client.start_streaming()
matris = np.zeros((sekvenser, 2))
while not interrupt_handler.got_signal:
# for i in range(0, sekvenser):
info, sweep = client.get_next()
amplitude = np.abs(sweep)
ymax = amplitude.max()
xmax = config.range_interval[0] + (config.range_interval[1] - config.range_interval[0]) * \
(np.argmax(amplitude)/num_points)
matris[0][:] = [xmax, ymax]
matris = np.roll(matris, 1, axis=0)
text = "x={:.2f}, y={:.2f}".format(xmax, ymax)
bbox_props = dict(boxstyle="square,pad=0.3", fc="w", ec="k", lw=0.72)
arrowprops = dict(arrowstyle="->",
connectionstyle="angle,angleA=0,angleB=90")
kw = dict(xycoords='data',
textcoords="axes fraction",
arrowprops=arrowprops,
bbox=bbox_props,
ha="right",
va="top")
annotate = ax.annotate(text,
xy=(xmax, ymax),
xytext=(0.96, 0.96),
**kw)
amplitude_line.set_ydata(amplitude)
if not plt.fignum_exists(1): # Simple way to check if plot is closed
break
fig.canvas.flush_events()
annotate.remove()
# matris = np.mean(matris, axis=0)
# np.savetxt(filename, matris, delimiter=",")
print("Disconnecting...")
plt.close()
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser(num_sens=1).parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
config = base_config()
config.sensor = args.sensors
info = client.setup_session(config)
num_points = info["data_length"]
# Setup plot window for amplitude and phase filled with zeros.
amplitude_y_max = 1
fig, (amplitude_ax, phase_ax1) = plt.subplots(2)
fig.set_size_inches(12, 6)
fig.canvas.set_window_title("Annotate test")
fig, (ny_ax2) = plt.subplots(1)
fig.set_size_inches(8, 5)
fig.canvas.set_window_title("test två fönster")
for ax in [amplitude_ax]:
ax.set_xlabel("Depth (m)")
ax.set_xlim(config.range_interval)
ax.grid(True)
for ax1 in [phase_ax1]:
ax1.set_xlabel("Depth(m)")
ax1.set_xlim(config.range_interval)
ax1.grid(True)
for ax2 in [ny_ax2]:
ax2.set_xlabel("Depth (m)")
ax2.set_xlim(config.range_interval)
ax2.grid(True)
amplitude_ax.set_ylabel("Amplitude")
amplitude_ax.set_ylim(0, 1.0 * amplitude_y_max)
phase_ax1.set_ylabel("Phase")
example_utils.mpl_setup_yaxis_for_phase(phase_ax1)
ny_ax2.set_ylim(-1, 1)
xs = np.linspace(*config.range_interval, num_points)
amplitude_line = amplitude_ax.plot(xs, np.zeros_like(xs))[0]
phase_line = phase_ax1.plot(xs, np.zeros_like(xs))[0]
ny_line = ny_ax2.plot(xs, np.zeros_like(xs))[0]
fig.tight_layout()
plt.ion()
plt.show()
# Setup box for annotation with maximum
bbox_props = dict(boxstyle="square,pad=0.3", fc="w", ec="k", lw=0.72)
arrowprops = dict(arrowstyle="->",
connectionstyle="angle,angleA=0,angleB=90")
kw = dict(xycoords='data',
textcoords="axes fraction",
arrowprops=arrowprops,
bbox=bbox_props,
ha="right",
va="top")
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
client.start_streaming()
while not interrupt_handler.got_signal:
# for i in range(0, 1):
# Get new sensor data
info, sweep = client.get_next()
amplitude = np.abs(sweep)
phase = np.angle(sweep)
# Update annotation with the new amplitude and position
ymax = amplitude.max()
xmax = config.range_interval[0] + (config.range_interval[1] - config.range_interval[0]) * \
(np.argmax(amplitude)/num_points)
text = "x={:.2f}, y={:.2f}".format(xmax, ymax)
annotate = ax.annotate(text,
xy=(xmax, ymax),
xytext=(0.96, 0.96),
**kw)
vline_ax0 = ax.axvline(x=xmax,
ymin=0,
ymax=ymax,
linewidth=2,
color='k')
vline_ax1 = ax1.axvline(x=xmax,
ymin=-np.pi,
ymax=np.pi,
linewidth=2,
color='k')
# update plot with new sensor data
amplitude_line.set_ydata(amplitude)
phase_line.set_ydata(phase)
if not plt.fignum_exists(1): # Simple way to check if plot is closed
break
fig.canvas.flush_events()
annotate.remove()
vline_ax0.remove()
vline_ax1.remove()
print("Disconnecting...")
plt.close()
client.disconnect()
def 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)
client.squeeze = False
config = configs.SparseServiceConfig()
config.sensor = args.sensors
config.range_interval = [0.24, 1.20]
config.sweep_rate = 60
config.number_of_subsweeps = 16
# config.hw_accelerated_average_samples = 60
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():
# 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()
