def main():
args = example_utils.ExampleArgumentParser().parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
elif args.spi:
client = RegSPIClient()
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
config = configs.IQServiceConfig()
config.sensor = args.sensors
config.range_interval = [0.2, 0.6]
config.sweep_rate = 50
info = client.start_streaming(config)
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
fc = example_utils.FreqCounter(num_bits=(4 * 8 * info["data_length"]))
while not interrupt_handler.got_signal:
info, data = client.get_next()
fc.tick()
print("\nDisconnecting...")
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser().parse_args()
example_utils.config_logging(args)
if args.socket_addr:
raise Exception("Socket is not supported")
elif args.spi:
raise Exception("SPI is not supported")
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
client.connect()
pin = RegClient._XM112_LED_PIN
client._write_gpio(pin, 1)
val = client._read_gpio(pin)
print(val)
for _ in range(3):
sleep(0.1)
client._write_gpio(pin, 0) # on
sleep(0.1)
client._write_gpio(pin, 1) # off
client.disconnect()
def __init__(self, q):
# Setup radar
self.args = example_utils.ExampleArgumentParser().parse_args()
example_utils.config_logging(self.args)
if self.args.socket_addr:
self.client = JSONClient(self.args.socket_addr)
else:
port = self.args.serial_port or example_utils.autodetect_serial_port()
self.client = RegClient(port)
self.client.squeeze = False
self.config = configs.IQServiceConfig()
self.config.sensor = self.args.sensors
self.config.range_interval = [0.2, 0.6] # Intervall för mätningar
self.config.sweep_rate = 1 # Frekvensen
self.config.gain = 1 # Gain mellan 0 och 1, vi använder 1
self.time = 10 # Hur lång mätningen ska vara
# totalt antal sekvenser som krävs för att få en specifik tid
self.seq = self.config.sweep_rate * self.time
self.info = self.client.setup_session(self.config)
self.num_points = self.info["data_length"] # Antalet mätpunkter per sekvens
# print(self.num_points)
# Matris med nollor som fylls med rardardata
self.matrix = np.zeros((self.seq, self.num_points), dtype=np.csingle)
self.matrix_copy = np.zeros((self.seq, self.num_points),
dtype=np.csingle) # En copy på ovanstående
self.temp_vector = np.zeros((0, self.num_points), dtype=np.csingle)
self.matrix_idx = 0 # Index för påfyllning av matris
super(Radar, self).__init__()
# En First In First Out (FIFO) kö där mätdata sparas och kan hämtas ut för signalbehandling
self.q = q
def run(self):
print("#### New thread for %s" % self.name)
args = self._demo_ctrl.streaming_client_args
print("args:", args)
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
try:
client.connect()
except Exception as e:
print("Got exception:", e)
session_info = client.setup_session(self.config)
print("Session info:\n", session_info, "\n")
client.start_streaming()
while not self.terminating:
sweep_info, sweep_data = client.get_next()
d = self.process_data(sweep_data)
if d is not None:
self._demo_ctrl.put_cmd(str(d))
if self.terminating:
break
client.disconnect()
def __init__(self, radar_queue, interrupt_queue):
# Setup for collecting data from radar
self.args = example_utils.ExampleArgumentParser().parse_args()
example_utils.config_logging(self.args)
if self.args.socket_addr:
self.client = JSONClient(self.args.socket_addr)
else:
port = self.args.serial_port or example_utils.autodetect_serial_port(
)
self.client = RegClient(port)
self.client.squeeze = False
self.config = configs.IQServiceConfig()
self.config.sensor = self.args.sensors
self.config.range_interval = [0.2, 0.6] # Measurement interval
self.config.sweep_rate = 1 # Frequency for collecting data
self.config.gain = 1 # Gain between 0 and 1.
self.time = 10 # Duration for a set amount of sequences
self.seq = self.config.sweep_rate * self.time
self.info = self.client.setup_session(
self.config) # Setup acconeer radar session
self.num_points = self.info[
"data_length"] # Amount of data points per sampel
#### Det här kanske inte ska vara i den här klassen #####
# Vector for radar values from tracked data
self.peak_vector = np.zeros((1, self.seq), dtype=np.csingle)
self.data_idx = 0 # Inedex for peak vector used for filtering
self.radar_queue = radar_queue
self.interrupt_queue = interrupt_queue
self.timeout = time.time() + self.time
b = 0
def connect_to_server(self):
if self.buttons["connect"].text() == "Connect":
max_num = 4
if "Select service" in self.current_canvas:
self.mode.setCurrentIndex(2)
if self.interface.currentText().lower() == "socket":
self.client = JSONClient(self.textboxes["host"].text())
else:
port = self.ports.currentText()
if "scan" in port.lower():
self.error_message("Please select port first!")
return
self.client = RegClient(port)
max_num = 1
conf = self.update_sensor_config()
sensor = 1
connection_success = False
error = None
while sensor <= max_num:
conf.sensor = sensor
try:
self.client.setup_session(conf)
self.client.start_streaming()
self.client.stop_streaming()
connection_success = True
self.textboxes["sensor"].setText("{:d}".format(sensor))
break
except Exception as e:
sensor += 1
error = e
if connection_success:
self.buttons["start"].setEnabled(True)
self.buttons["create_cl"].setEnabled(True)
self.buttons["stop"].setEnabled(True)
else:
self.error_message("Could not connect to sever!\n{}".format(error))
return
self.buttons["connect"].setText("Disconnect")
self.buttons["connect"].setStyleSheet("QPushButton {color: red}")
else:
self.buttons["connect"].setText("Connect")
self.buttons["connect"].setStyleSheet("QPushButton {color: black}")
self.sig_scan.emit("stop")
self.buttons["start"].setEnabled(False)
self.buttons["create_cl"].setEnabled(False)
if self.cl_supported:
self.buttons["load_cl"].setEnabled(True)
try:
self.client.stop_streaming()
except Exception:
pass
try:
self.client.disconnect()
except Exception:
pass
def __init__(self):
# Setup radar data
self.args = example_utils.ExampleArgumentParser().parse_args()
example_utils.config_logging(self.args)
if self.args.socket_addr:
self.client = JSONClient(self.args.socket_addr)
else:
port = self.args.serial_port or example_utils.autodetect_serial_port(
)
self.client = RegClient(port)
self.client.squeeze = False
self.config = configs.IQServiceConfig()
self.config.sensor = self.args.sensors
self.config.range_interval = [0.2, 0.6]
self.config.sweep_rate = 1
self.config.gain = 1
self.time = 5
self.seq = self.config.sweep_rate * self.time
self.info = self.client.setup_session(self.config)
self.num_points = self.info["data_length"]
self.matrix = np.zeros((self.seq, self.num_points), dtype=np.csingle)
self.matrix_copy = np.zeros((self.seq, self.num_points),
dtype=np.csingle)
self.matrix_idx = 0
super(Radar, self).__init__()
def main():
args = example_utils.ExampleArgumentParser(num_sens=1).parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
config = config_setup()
config.sensor = args.sensors
info = client.setup_session(config)
num_points = info["data_length"]
tracking = Tracking(num_points, config.range_interval)
fig, (amplitude_ax) = plt.subplots(1)
fig.set_size_inches(12, 6)
fig.canvas.set_window_title("filename")
for ax in [amplitude_ax]:
ax.set_xlabel("time (s)")
ax.set_xlim(0, num_points / config.sweep_rate)
amplitude_ax.set_ylabel("Distance (m)")
amplitude_ax.set_ylim(config.range_interval[0], config.range_interval[1])
xs = np.linspace(0, num_points / config.sweep_rate, num=num_points)
amplitude_line = amplitude_ax.plot(xs, np.zeros_like(xs))[0]
fig.tight_layout()
plt.ion()
plt.show()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
client.start_streaming()
counter = 0
while not interrupt_handler.got_signal:
info, sweep = client.get_next()
amplitude = np.abs(sweep)
track = tracking.tracking(sweep, counter)
peak = track
counter += 1
if counter == num_points:
counter = 0
# print(peak)
amplitude_line.set_ydata(peak)
# amplitude_line.set_ydata(amplitude)
fig.canvas.flush_events()
print("Disconnecting...")
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser().parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
client.squeeze = False
config = configs.IQServiceConfig()
config.sensor = args.sensors
config.range_interval = [1, 8]
config.sweep_rate = 1
config.gain = 0.8
#config.running_average_factor = 0.5
tid = 5
sekvenser = config.sweep_rate * tid
info = client.setup_session(config)
num_points = info["data_length"]
fig_updater = ExampleFigureUpdater(config, num_points)
plot_process = PlotProcess(fig_updater)
plot_process.start()
client.start_streaming()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
start = time.time()
# while not interrupt_handler.got_signal:
for i in range(0, sekvenser):
#info, data = client.get_next()
data = get_data(client)
plot_data = {
"amplitude": np.abs(data),
"phase": np.angle(data),
}
try:
plot_process.put_data(plot_data)
except PlotProccessDiedException:
break
end = time.time()
# print(i+1)
print((end - start), "s")
# print("Disconnecting...")
plot_process.close()
client.disconnect()
def __init__(self, HR_filter_queue,
go): # Lägg till RR_filter_queue som inputargument
self.go = go
# Setup for collecting data from radar
self.args = example_utils.ExampleArgumentParser().parse_args()
example_utils.config_logging(self.args)
if self.args.socket_addr:
self.client = JSONClient(self.args.socket_addr)
# Test för att se vilken port som används av radarn
print("RADAR Port = " + self.args.socket_addr)
else:
port = self.args.serial_port or example_utils.autodetect_serial_port(
)
self.client = RegClient(port)
self.client.squeeze = False
self.config = configs.IQServiceConfig()
self.config.sensor = self.args.sensors
self.config.range_interval = [0.2, 0.6] # Measurement interval
self.config.sweep_rate = 20 # Frequency for collecting data
self.config.gain = 1 # Gain between 0 and 1.
self.time = 1 # Duration for a set amount of sequences
self.seq = self.config.sweep_rate * self.time # Amount of sequences during a set time and sweep freq
self.info = self.client.setup_session(
self.config) # Setup acconeer radar session
self.num_points = self.info[
"data_length"] # Amount of data points per sampel
self.data_getting = 0 # Inedex for printing still getting data once a second
self.HR_filter_queue = HR_filter_queue
# self.a = a
# self.RR_filter_queue = RR_filter_queue
# Initiation for tracking method
self.N_avg = 10 # How manny peaks averaged over when calculating peaks_filtered
self.I_peaks = np.zeros(self.N_avg)
self.locs = np.zeros(self.N_avg)
self.I_peaks_filtered = np.zeros(self.N_avg)
self.tracked_distance = np.zeros(self.N_avg)
self.tracked_amplitude = np.zeros(self.N_avg)
self.tracked_phase = np.zeros(self.N_avg)
self.threshold = 0 # variable for finding peaks above threshold
self.data_idx = 0 # Index in vector for tracking. Puts new tracked peak into tracking vector
# converts index to real length
self.real_dist = np.linspace(self.config.range_interval[0],
self.config.range_interval[1],
num=self.num_points)
self.counter = 0 # Used only for if statement only for first iteration and not when data_idx goes back to zero
super(Radar, self).__init__() # Inherit threading vitals
def main():
args = example_utils.ExampleArgumentParser().parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
elif args.spi:
client = RegSPIClient()
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
# Normally when using a single sensor, get_next will return
# (info, data). When using mulitple sensors, get_next will return
# lists of info and data for each sensor, i.e. ([info], [data]).
# This is commonly called squeezing. To disable squeezing, making
# get_next _always_ return lists, set:
# client.squeeze = False
config = configs.EnvelopeServiceConfig()
config.sensor = args.sensors
config.range_interval = [0.2, 0.3]
config.sweep_rate = 5
session_info = client.setup_session(config)
print("Session info:\n", session_info, "\n")
# Now would be the time to set up plotting, signal processing, etc.
client.start_streaming()
# Normally, hitting Ctrl-C will raise a KeyboardInterrupt which in
# most cases immediately terminates the script. This often becomes
# an issue when plotting and also doesn't allow us to disconnect
# gracefully. Setting up an ExampleInterruptHandler will capture the
# keyboard interrupt signal so that a KeyboardInterrupt isn't raised
# and we can take care of the signal ourselves. In case you get
# impatient, hitting Ctrl-C a couple of more times will raise a
# KeyboardInterrupt which hopefully terminates the script.
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session\n")
while not interrupt_handler.got_signal:
info, data = client.get_next()
print(info, "\n", data, "\n")
print("Disconnecting...")
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser(num_sens=1).parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
config = config_setup()
config.sensor = args.sensors
tid = 10
sekvenser = tid * config.sweep_rate
filename = "Reflektor_2.csv"
info = client.setup_session(config)
num_points = info["data_length"]
fig_updater = FigureUpdater2(config, num_points)
plot_process = PlotProcess(fig_updater)
plot_process.start()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
client.start_streaming()
while not interrupt_handler.got_signal:
info, sweep = client.get_next()
amplitude = np.abs(sweep)
plot_data = {
"amplitude": np.abs(sweep),
"phase": np.angle(sweep),
"ymax": amplitude.max(),
"xmax": config.range_interval[0] + (config.range_interval[1] - config.range_interval[0]) *
(np.argmax(amplitude)/num_points),
}
try:
plot_process.put_data(plot_data)
except PlotProccessDiedException:
break
print("Disconnecting...")
plot_process.close()
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser().parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
elif args.spi:
client = RegSPIClient()
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
client.squeeze = False
config = configs.EnvelopeServiceConfig()
config.sensor = args.sensors
config.range_interval = [0.2, 0.6]
config.sweep_rate = 60
config.gain = 0.6
# config.experimental_stitching = True
# config.session_profile = configs.EnvelopeServiceConfig.MAX_SNR
# config.running_average_factor = 0.5
# config.compensate_phase = False # not recommended
info = client.setup_session(config)
num_points = info["data_length"]
pg_updater = PGUpdater(config, num_points)
pg_process = PGProcess(pg_updater)
pg_process.start()
client.start_streaming()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
while not interrupt_handler.got_signal:
info, data = client.get_next()
try:
pg_process.put_data(data)
except PGProccessDiedException:
break
print("Disconnecting...")
pg_process.close()
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser().parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
elif args.spi:
client = RegSPIClient()
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
client.squeeze = False
sensor_config = get_sensor_config()
sensor_config.sensor = args.sensors
processing_config = get_processing_config()
client.setup_session(sensor_config)
pg_updater = PGUpdater(sensor_config, processing_config)
pg_process = PGProcess(pg_updater)
pg_process.start()
client.start_streaming()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
processor = Processor(sensor_config, processing_config)
while not interrupt_handler.got_signal:
info, sweep = client.get_next()
plot_data = processor.process(sweep)
if plot_data is not None:
try:
pg_process.put_data(plot_data)
except PGProccessDiedException:
break
print("Disconnecting...")
pg_process.close()
client.disconnect()
def setup(request):
conn_type, *args = request.param
if conn_type == "spi":
client = RegSPIClient()
sensor = 1
elif conn_type == "uart":
port = args[0] or autodetect_serial_port()
client = RegClient(port)
sensor = 1
elif conn_type == "socket":
client = JSONClient(args[0])
sensor = int(args[1])
else:
pytest.fail()
client.connect()
yield (client, sensor)
client.disconnect()
def check_connection(args):
print("Checking connection to radar")
try:
if args.socket_addr:
client = JSONClient(args.socket_addr)
elif args.spi:
client = RegSPIClient()
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
client.connect()
client.disconnect()
return True
except Exception:
print()
traceback.print_exc()
print()
return False
def main():
args = example_utils.ExampleArgumentParser().parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
elif args.spi:
client = RegSPIClient()
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
client.squeeze = False
config = configs.PowerBinServiceConfig()
config.sensor = args.sensors
config.range_interval = [0.1, 0.7]
config.sweep_rate = 60
config.gain = 0.6
# config.bin_count = 8
client.setup_session(config)
pg_updater = PGUpdater(config)
pg_process = PGProcess(pg_updater)
pg_process.start()
client.start_streaming()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
while not interrupt_handler.got_signal:
info, data = client.get_next()
try:
pg_process.put_data(data)
except PGProccessDiedException:
break
print("Disconnecting...")
pg_process.close()
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser().parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
elif args.spi:
client = RegSPIClient()
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
config = configs.EnvelopeServiceConfig()
config.sensor = args.sensors
config.range_interval = [0.2, 0.6]
config.sweep_rate = 10
client.start_streaming(config)
client.get_next()
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser().parse_args()
example_utils.config_logging(args)
if args.socket_addr:
print("Using detectors is only supported with the XM112 module")
sys.exit()
elif args.spi:
client = RegSPIClient()
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
config = configs.DistancePeakDetectorConfig()
config.sensor = args.sensors
config.range_interval = [0.1, 0.7]
config.sweep_rate = 60
config.gain = 0.5
client.setup_session(config)
pg_updater = PGUpdater(config)
pg_process = PGProcess(pg_updater)
pg_process.start()
client.start_streaming()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
while not interrupt_handler.got_signal:
info, data = client.get_next()
try:
pg_process.put_data(data)
except PGProccessDiedException:
break
print("Disconnecting...")
pg_process.close()
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser().parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
client.squeeze = False
# Setup parameters
filename = "Lins50cmPuls_0328_Test1.csv"
time = 300
config = setup_parameters()
seq = config.sweep_rate * time
config.sensor = args.sensors
info = client.setup_session(config)
num_points = info["data_length"]
# print(num_points)
info_file(filename, config, num_points, time, seq) # Setup info file
print(num_points)
matris = np.zeros((seq, num_points), dtype=np.csingle)
client.start_streaming()
print("Starting...")
start = timer.time()
for i in range(0, seq):
info, sweep = client.get_next()
matris[seq - i - 1][:] = sweep[:]
end = timer.time()
print(i + 1)
print((end - start), "s")
# print("Disconnecting...")
matris = np.flip(matris, 0)
np.savetxt(filename, matris, delimiter=";")
matris = None
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser(num_sens=1).parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
config = config_setup()
config.sensor = args.sensors
tid = 10
sekvenser = tid * config.sweep_rate
filename = "Reflektor_2.csv"
info = client.setup_session(config)
num_points = info["data_length"]
amplitude_y_max = 22000
N_avg = 10
tracking = Tracking(num_points, config.range_interval, N_avg)
print("numpoints: ", num_points)
fig, (amplitude_ax) = plt.subplots(1)
fig.set_size_inches(12, 6)
fig.canvas.set_window_title(filename)
for ax in [amplitude_ax]:
# ax.set_xlabel("Depth (m)")
# ax.set_xlim(config.range_interval)
ax.set_xlabel("Time (s)")
ax.set_xlim(0, 100)
# amplitude_ax.set_ylabel("Amplitude")
# amplitude_ax.set_ylim(0, 1.1 * amplitude_y_max)
amplitude_ax.set_ylabel("tracked distance (m)")
amplitude_ax.set_ylim(config.range_interval)
xs = np.linspace(0, 100, num=100)
amplitude_line = amplitude_ax.plot(xs, np.zeros_like(xs))[0]
fig.tight_layout()
plt.ion()
plt.show()
list = np.zeros(100)
i = 0
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
client.start_streaming()
matris = np.zeros((sekvenser, 2))
counter = 0
while not interrupt_handler.got_signal:
# for i in range(0, sekvenser):
info, sweep = client.get_next()
start = round(time.time() * 1000) / 1000
track = tracking.tracking(sweep)
end = round(time.time() * 1000) / 1000
print("Time for tracking loop {}".format(end - start))
list[i] = track
amplitude_line.set_ydata(list)
i += 1
if i == 100:
i = 0
list = np.zeros(100)
if not plt.fignum_exists(1): # Simple way to check if plot is closed
break
fig.canvas.flush_events()
# annotate.remove()
# matris = np.mean(matris, axis=0)
# np.savetxt(filename, matris, delimiter=",")
print("Disconnecting...")
plt.close()
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser(num_sens=1).parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
config = base_config()
config.sensor = args.sensors
info = client.setup_session(config)
num_points = info["data_length"]
# Setup plot window for amplitude and phase filled with zeros.
amplitude_y_max = 1
fig, (amplitude_ax, phase_ax1) = plt.subplots(2)
fig.set_size_inches(12, 6)
fig.canvas.set_window_title("Annotate test")
fig, (ny_ax2) = plt.subplots(1)
fig.set_size_inches(8, 5)
fig.canvas.set_window_title("test två fönster")
for ax in [amplitude_ax]:
ax.set_xlabel("Depth (m)")
ax.set_xlim(config.range_interval)
ax.grid(True)
for ax1 in [phase_ax1]:
ax1.set_xlabel("Depth(m)")
ax1.set_xlim(config.range_interval)
ax1.grid(True)
for ax2 in [ny_ax2]:
ax2.set_xlabel("Depth (m)")
ax2.set_xlim(config.range_interval)
ax2.grid(True)
amplitude_ax.set_ylabel("Amplitude")
amplitude_ax.set_ylim(0, 1.0 * amplitude_y_max)
phase_ax1.set_ylabel("Phase")
example_utils.mpl_setup_yaxis_for_phase(phase_ax1)
ny_ax2.set_ylim(-1, 1)
xs = np.linspace(*config.range_interval, num_points)
amplitude_line = amplitude_ax.plot(xs, np.zeros_like(xs))[0]
phase_line = phase_ax1.plot(xs, np.zeros_like(xs))[0]
ny_line = ny_ax2.plot(xs, np.zeros_like(xs))[0]
fig.tight_layout()
plt.ion()
plt.show()
# Setup box for annotation with maximum
bbox_props = dict(boxstyle="square,pad=0.3", fc="w", ec="k", lw=0.72)
arrowprops = dict(arrowstyle="->",
connectionstyle="angle,angleA=0,angleB=90")
kw = dict(xycoords='data',
textcoords="axes fraction",
arrowprops=arrowprops,
bbox=bbox_props,
ha="right",
va="top")
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
client.start_streaming()
while not interrupt_handler.got_signal:
# for i in range(0, 1):
# Get new sensor data
info, sweep = client.get_next()
amplitude = np.abs(sweep)
phase = np.angle(sweep)
# Update annotation with the new amplitude and position
ymax = amplitude.max()
xmax = config.range_interval[0] + (config.range_interval[1] - config.range_interval[0]) * \
(np.argmax(amplitude)/num_points)
text = "x={:.2f}, y={:.2f}".format(xmax, ymax)
annotate = ax.annotate(text,
xy=(xmax, ymax),
xytext=(0.96, 0.96),
**kw)
vline_ax0 = ax.axvline(x=xmax,
ymin=0,
ymax=ymax,
linewidth=2,
color='k')
vline_ax1 = ax1.axvline(x=xmax,
ymin=-np.pi,
ymax=np.pi,
linewidth=2,
color='k')
# update plot with new sensor data
amplitude_line.set_ydata(amplitude)
phase_line.set_ydata(phase)
if not plt.fignum_exists(1): # Simple way to check if plot is closed
break
fig.canvas.flush_events()
annotate.remove()
vline_ax0.remove()
vline_ax1.remove()
print("Disconnecting...")
plt.close()
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser(num_sens=1).parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
config = config_setup()
config.sensor = args.sensors
tid = 10
sekvenser = tid * config.sweep_rate
filename = "Reflektor_2.csv"
info = client.setup_session(config)
num_points = info["data_length"]
amplitude_y_max = 22000
fig, (amplitude_ax) = plt.subplots(1)
fig.set_size_inches(12, 6)
fig.canvas.set_window_title(filename)
for ax in [amplitude_ax]:
ax.set_xlabel("Depth (m)")
ax.set_xlim(config.range_interval)
ax.set_xticks(np.linspace(0.4, 0.8, num=5))
ax.set_xticks(np.concatenate([
np.linspace(0.41, 0.49, num=9),
np.linspace(0.51, 0.59, num=9),
np.linspace(0.61, 0.69, num=9),
np.linspace(0.71, 0.79, num=9)
]),
minor=True)
ax.grid(True, which='major')
ax.grid(True, which='minor')
amplitude_ax.set_ylabel("Amplitude")
amplitude_ax.set_ylim(0, 1.1 * amplitude_y_max)
xs = np.linspace(*config.range_interval, num_points)
amplitude_line = amplitude_ax.plot(xs, np.zeros_like(xs))[0]
fig.tight_layout()
plt.ion()
plt.show()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
client.start_streaming()
matris = np.zeros((sekvenser, 2))
while not interrupt_handler.got_signal:
# for i in range(0, sekvenser):
info, sweep = client.get_next()
amplitude = np.abs(sweep)
ymax = amplitude.max()
xmax = config.range_interval[0] + (config.range_interval[1] - config.range_interval[0]) * \
(np.argmax(amplitude)/num_points)
matris[0][:] = [xmax, ymax]
matris = np.roll(matris, 1, axis=0)
text = "x={:.2f}, y={:.2f}".format(xmax, ymax)
bbox_props = dict(boxstyle="square,pad=0.3", fc="w", ec="k", lw=0.72)
arrowprops = dict(arrowstyle="->",
connectionstyle="angle,angleA=0,angleB=90")
kw = dict(xycoords='data',
textcoords="axes fraction",
arrowprops=arrowprops,
bbox=bbox_props,
ha="right",
va="top")
annotate = ax.annotate(text,
xy=(xmax, ymax),
xytext=(0.96, 0.96),
**kw)
amplitude_line.set_ydata(amplitude)
if not plt.fignum_exists(1): # Simple way to check if plot is closed
break
fig.canvas.flush_events()
annotate.remove()
# matris = np.mean(matris, axis=0)
# np.savetxt(filename, matris, delimiter=",")
print("Disconnecting...")
plt.close()
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser(num_sens=1).parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
config = configs.EnvelopeServiceConfig()
config.sensor = args.sensors
config.range_interval = [0.2, 0.6]
config.sweep_rate = 60
config.gain = 0.65
info = client.setup_session(config)
num_points = info["data_length"]
xs = np.linspace(*config.range_interval, num_points)
num_hist = 2 * config.sweep_rate
hist_data = np.zeros([num_hist, num_points])
hist_max = np.zeros(num_hist)
smooth_max = example_utils.SmoothMax(config.sweep_rate)
app = QtGui.QApplication([])
pg.setConfigOption("background", "w")
pg.setConfigOption("foreground", "k")
pg.setConfigOptions(antialias=True)
win = pg.GraphicsLayoutWidget()
win.closeEvent = lambda _: interrupt_handler.force_signal_interrupt()
win.setWindowTitle("Acconeer PyQtGraph example")
env_plot = win.addPlot(title="Envelope")
env_plot.showGrid(x=True, y=True)
env_plot.setLabel("bottom", "Depth (m)")
env_plot.setLabel("left", "Amplitude")
env_curve = env_plot.plot(pen=pg.mkPen("k", width=2))
win.nextRow()
hist_plot = win.addPlot()
hist_plot.setLabel("bottom", "Time (s)")
hist_plot.setLabel("left", "Depth (m)")
hist_image_item = pg.ImageItem()
hist_image_item.translate(-2, config.range_start)
hist_image_item.scale(2 / num_hist, config.range_length / num_points)
hist_plot.addItem(hist_image_item)
# try to get a colormap from matplotlib
try:
hist_image_item.setLookupTable(example_utils.pg_mpl_cmap("viridis"))
except ImportError:
pass
win.show()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
client.start_streaming()
while not interrupt_handler.got_signal:
info, sweep = client.get_next()
hist_data = np.roll(hist_data, -1, axis=0)
hist_data[-1] = sweep
hist_max = np.roll(hist_max, -1)
hist_max[-1] = np.max(sweep)
y_max = smooth_max.update(np.amax(hist_max))
env_curve.setData(xs, sweep)
env_plot.setYRange(0, y_max)
hist_image_item.updateImage(hist_data, levels=(0, y_max))
app.processEvents()
print("Disconnecting...")
app.closeAllWindows()
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser(num_sens=1).parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
config = get_base_config()
config.sensor = args.sensors
info1 = client.setup_session(config)
num_points = info1["data_length"]
fig_updater = ExampleFigureUpdater(config)
plot_process = PlotProcess(fig_updater)
plot_process.start()
client.start_streaming()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
processor = PhaseTrackingProcessor(config)
start = time.time()
i = 0
while not interrupt_handler.got_signal:
info, sweep = client.get_next()
plot_data = processor.process(sweep)
try:
plot_process.put_data(
plot_data) # Will ignore the first None from processor
except PlotProccessDiedException:
break
i += 1
end = time.time()
print(i + 1)
print((end - start), "s")
print("Disconnecting...")
plot_process.close()
client.disconnect()
# k = 1
# m = num_points
# n = 50
# matris_real = np.zeros((n, m), dtype=np.csingle)
# matris_imag = np.zeros((n, m), dtype=np.csingle)
# while not interrupt_handler.got_signal:
# if k < 100:
# k += 1
# matris_imag = np.roll(matris_imag, 1, axis=0)
# matris_real = np.roll(matris_real, 1, axis=0)
# info, sweep = client.get_next()
# vector_real_temp = np.real(sweep)
# vector_imag_temp = np.imag(sweep)
# matris_real[[0], :] = vector_real_temp
# matris_imag[[0], :] = vector_imag_temp
# vector_real = np.mean(matris_real, axis=0)
# vector_imag = np.mean(matris_imag, axis=0)
# vector = vector_real + 1j*vector_imag
# plot_data = processor.process(vector)
# if plot_data is not None:
# try:
# plot_process.put_data(plot_data)
# except PlotProccessDiedException:
# break
# Fungerande test av medelvärdesbildning
# k=100
# while not interrupt_handler.got_signal:
# info, sweep = client.get_next()
# real_tot = np.zeros(num_points)
# imag_tot = np.zeros(num_points)
# for i in range(1, k):
# info, sweep = client.get_next()
# real = sweep.real
# imag = sweep.imag
# imag_tot = list(map(operator.add, imag_tot, imag))
# real_tot = np.add(real_tot, real)
# imag_tot = [x / k for x in imag_tot]
# real = [x / k for x in real_tot]
# plot_data = processor.process(sweep)
# if plot_data is not None:
# try:
# plot_process.put_data(plot_data)
# except PlotProccessDiedException:
# break
print("Disconnecting...")
plot_process.close()
client.disconnect()
def main():
args = example_utils.ExampleArgumentParser(num_sens=1).parse_args()
example_utils.config_logging(args)
if args.socket_addr:
client = JSONClient(args.socket_addr)
elif args.spi:
client = RegSPIClient()
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
config = configs.IQServiceConfig()
config.sensor = args.sensors
config.range_interval = [0.2, 0.6]
config.sweep_rate = 10
config.gain = 0.6
info = client.setup_session(config)
num_points = info["data_length"]
amplitude_y_max = 0.3
fig, (amplitude_ax, phase_ax) = plt.subplots(2)
fig.set_size_inches(8, 6)
fig.canvas.set_window_title("Acconeer matplotlib example")
for ax in [amplitude_ax, phase_ax]:
ax.set_xlabel("Depth (m)")
ax.set_xlim(config.range_interval)
ax.grid(True)
amplitude_ax.set_ylabel("Amplitude")
amplitude_ax.set_ylim(0, 1.1 * amplitude_y_max)
phase_ax.set_ylabel("Phase")
example_utils.mpl_setup_yaxis_for_phase(phase_ax)
xs = np.linspace(*config.range_interval, num_points)
amplitude_line = amplitude_ax.plot(xs, np.zeros_like(xs))[0]
phase_line = phase_ax.plot(xs, np.zeros_like(xs))[0]
fig.tight_layout()
plt.ion()
plt.show()
interrupt_handler = example_utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
client.start_streaming()
while not interrupt_handler.got_signal:
info, sweep = client.get_next()
amplitude = np.abs(sweep)
phase = np.angle(sweep)
max_amplitude = np.max(amplitude)
if max_amplitude > amplitude_y_max:
amplitude_y_max = max_amplitude
amplitude_ax.set_ylim(0, 1.1 * max_amplitude)
amplitude_line.set_ydata(amplitude)
phase_line.set_ydata(phase)
if not plt.fignum_exists(1): # Simple way to check if plot is closed
break
fig.canvas.flush_events()
print("Disconnecting...")
plt.close()
client.disconnect()
def main():
# To simplify the examples, we use a generic argument parser. It
# lets you choose between UART/socket, set which sensor(s) to use,
# and the verbosity level of the logging.
args = example_utils.ExampleArgumentParser().parse_args()
# Logging is done using the logging module with a logger named
# acconeer_utils. We call another helper function which sets up the
# logging according to the verbosity level set in the arguments.
# -q or --quiet: ERROR (typically not used)
# default: WARNING
# -v or --verbose: INFO
# -vv or --debug: DEBUG
example_utils.config_logging(args)
# Pick client depending on whether socket, SPI, or UART is used
if args.socket_addr:
client = JSONClient(args.socket_addr)
elif args.spi:
client = RegSPIClient()
else:
port = args.serial_port or example_utils.autodetect_serial_port()
client = RegClient(port)
# Create a configuration to run on the sensor. A good first choice
# is the envelope service, so let's pick that one.
config = configs.EnvelopeServiceConfig()
# In all examples, we let you set the sensor(s) via the command line
config.sensor = args.sensors
# Set the measurement range [meter]
config.range_interval = [0.2, 0.3]
# Set the target measurement rate [Hz]
config.sweep_rate = 10
# Other configuration options might be available. Check out the
# example for the corresponding service/detector to see more.
client.connect()
# In most cases, explicitly calling connect is not necessary as
# setup_session below will call connect if not already connected.
# Set up the session with the config we created. If all goes well,
# some information/metadata for the configured session is returned.
session_info = client.setup_session(config)
print("Session info:\n", session_info, "\n")
# Now would be the time to set up plotting, signal processing, etc.
# Start streaming data from the session. This call will block until
# the sensor has confirmed that streaming has started.
client.start_streaming()
# Alternatively, start_streaming can be given the config instead. In
# that case, the client will call setup_session(config) for you
# before starting the stream. For example:
# session_info = client.start_streaming(config)
# As this will call setup_session in the background, this will also
# connect if not already connected.
# In this simple example, we just want to get a couple of sweeps.
# To get a sweep, call get_next. get_next will block until the sweep
# is recieved. Some information/metadata is returned together with
# the data.
for i in range(3):
sweep_info, sweep_data = client.get_next()
print("Sweep {}:\n".format(i + 1), sweep_info, "\n", sweep_data, "\n")
# We're done, stop streaming. All buffered/waiting sweeps are thrown
# away. This call will block until the sensor has confirmed that
# streaming/session has ended.
client.stop_streaming()
# Calling stop_streaming before disconnect is not necessary as
# disconnect will call stop_streaming if streaming is started.
# Remember to always call disconnect to do so gracefully
client.disconnect()