Merge pull request #124 from hacknus/performance_increase_2

Performance increase 2

Author: hacknus

src/gui.rs

@@ -1220,6 +1220,18 @@ impl MyApp {
  egui_logger::logger_ui().show(ui);
  });
 
+ ctx.input(|i| {
+ // Check if files were dropped
+ if let Some(dropped_file) = i.raw.dropped_files.last() {
+ let path = dropped_file.clone().path.unwrap();
+ self.picked_path = path.to_path_buf();
+ self.file_opened = true;
+ if let Err(e) = self.load_tx.send(self.picked_path.clone()) {
+ log::error!("load_tx thread send failed: {:?}", e);
+ }
+ }
+ });
+
  match self.file_dialog_state {
  FileDialogState::Open => {
  if let Some(path) = self

src/io.rs

@@ -57,7 +57,7 @@ pub fn open_from_csv(
  // Parse the remaining columns and populate the dataset
  for (i, value) in record.iter().skip(1).enumerate() {
  if let Some(dataset_column) = data.dataset.get_mut(i) {
- dataset_column.push(value.parse()?);
+ dataset_column.push(value.trim().parse().unwrap_or(0.0));
  } else {
  return Err("Unexpected number of data columns in the CSV".into());
  }

src/main.rs

@@ -8,7 +8,7 @@ extern crate serde;
 use crate::data::{DataContainer, GuiOutputDataContainer, Packet, SerialDirection};
 use crate::gui::{load_gui_settings, GuiCommand, MyApp, RIGHT_PANEL_WIDTH};
 use crate::io::{open_from_csv, save_to_csv, FileOptions};
-use crate::serial::{load_serial_settings, serial_thread, Device};
+use crate::serial::{load_serial_settings, serial_devices_thread, serial_thread, Device};
 use crossbeam_channel::{select, Receiver, Sender};
 use eframe::egui::{vec2, ViewportBuilder, Visuals};
 use eframe::{egui, icon_data};
@@ -96,19 +96,18 @@ fn main_thread(
  sync_tx.send(true).expect("unable to send sync tx");
  data.raw_traffic.push(packet.clone());
 
- if let Ok(mut gui_data) = data_lock.write() {
- if let Some(text) = console_text(show_timestamps, show_sent_cmds, &packet) {
- // append prints
- gui_data.prints.push(text);
- }
- }
+ let text = console_text(show_timestamps, show_sent_cmds, &packet);
 
  let split_data = split(&packet.payload);
  if data.dataset.is_empty() || failed_format_counter > 10 {
  // resetting dataset
  data.time = vec![];
  data.dataset = vec![vec![]; max(split_data.len(), 1)];
  if let Ok(mut gui_data) = data_lock.write() {
+ // append prints
+ if let Some(text) = text {
+ gui_data.prints.push(text);
+ }
  gui_data.plots = (0..max(split_data.len(), 1))
  .map(|i| (format!("Column {i}"), vec![]))
  .collect();
@@ -127,6 +126,10 @@ fn main_thread(
 
  // appending data for GUI thread
  if let Ok(mut gui_data) = data_lock.write() {
+ // append prints
+ if let Some(text) = text {
+ gui_data.prints.push(text);
+ }
  // append plot-points
  for ((_label, graph), data_i) in
  gui_data.plots.iter_mut().zip(&data.dataset)
@@ -200,8 +203,6 @@ fn main_thread(
 
  gui_data.prints = raw_data;
 
- dbg!(&gui_data.prints);
-
  gui_data.plots = (0..data.dataset.len())
  .map(|i| (file_options.names[i].to_string(), vec![]))
  .collect();
@@ -257,7 +258,7 @@ fn main_thread(
  }
  }
  }
- default(Duration::from_millis(10)) => {
+ default(Duration::from_millis(1)) => {
  // occasionally push data to GUI
  }
  }
@@ -287,6 +288,12 @@ fn main() {
  crossbeam_channel::unbounded();
  let (sync_tx, sync_rx): (Sender<bool>, Receiver<bool>) = crossbeam_channel::unbounded();
 
+ let serial_2_devices_lock = devices_lock.clone();
+
+ let _serial_devices_thread_handler = thread::spawn(|| {
+ serial_devices_thread(serial_2_devices_lock);
+ });
+
  let serial_device_lock = device_lock.clone();
  let serial_devices_lock = devices_lock.clone();
  let serial_connected_lock = connected_lock.clone();

src/serial.rs

@@ -89,6 +89,15 @@ impl Default for Device {
  }
 }
 
+pub fn serial_devices_thread(devices_lock: Arc<RwLock<Vec<String>>>) {
+ loop {
+ if let Ok(mut write_guard) = devices_lock.write() {
+ *write_guard = available_devices();
+ }
+ std::thread::sleep(Duration::from_millis(500));
+ }
+}
+
 fn serial_write(
  port: &mut BufReader<Box<dyn SerialPort>>,
  cmd: &[u8],
@@ -165,19 +174,17 @@ pub fn serial_thread(
  .create();
 
  'connected_loop: loop {
- let devices = available_devices();
- if let Ok(mut write_guard) = devices_lock.write() {
- *write_guard = devices.clone();
- }
-
- if disconnected(&device, &devices, &device_lock, &mut last_connected_device) {
+ if disconnected(
+  &device,
+ &device_lock,
+  &devices_lock,
+ &mut last_connected_device,
+ ) {
  break 'connected_loop;
  }
 
  perform_writes(&mut port, &send_rx, &raw_data_tx, t_zero);
  perform_reads(&mut port, &raw_data_tx, t_zero);
-
- //std::thread::sleep(Duration::from_millis(10));
  }
  std::mem::drop(port);
  }
@@ -222,28 +229,30 @@ fn get_device(
 
 fn disconnected(
  device: &Device,
- devices: &[String],
  device_lock: &Arc<RwLock<Device>>,
+ devices_lock: &Arc<RwLock<Vec<String>>>,
  last_connected_device: &mut Device,
 ) -> bool {
  // disconnection by button press
- if let Ok(read_guard) = device_lock.read() {
+ if let Ok(read_guard) = device_lock.try_read() {
  if device.name != read_guard.name {
  *last_connected_device = Device::default();
  log::info!("Disconnected from serial port: {}", device.name);
  return true;
  }
  }
 
- // other types of disconnection (e.g. unplugging, power down)
- if !devices.contains(&device.name) {
- if let Ok(mut write_guard) = device_lock.write() {
- write_guard.name.clear();
- }
- *last_connected_device = device.clone();
- log::error!("Device has disconnected from serial port: {}", device.name);
- return true;
- };
+ if let Ok(devices) = devices_lock.try_read() {
+ // other types of disconnection (e.g. unplugging, power down)
+ if !devices.contains(&device.name) {
+ if let Ok(mut write_guard) = device_lock.try_write() {
+ write_guard.name.clear();
+ }
+ *last_connected_device = device.clone();
+ log::error!("Device has disconnected from serial port: {}", device.name);
+ return true;
+ };
+ }
  false
 }
 
@@ -279,7 +288,15 @@ fn perform_reads(
  let mut buf = "".to_string();
  match serial_read(port, &mut buf) {
  Ok(_) => {
- let delimiter = if buf.contains("\r\n") { "\r\n" } else { "\0\0" };
+ let delimiter = if buf.contains("\r\n") {
+ "\r\n"
+ } else if buf.contains("\r") {
+ "\r"
+ } else if buf.contains("\n") {
+ "\n"
+ } else {
+ "\0\0"
+ };
  buf.split_terminator(delimiter).for_each(|s| {
  let packet = Packet {
  relative_time: Instant::now().duration_since(t_zero).as_millis() as f64,