Moved serial communication to its own file

hostsoftware/src/main.rs

@@ -2,18 +2,13 @@
 
 use eframe::egui::{self};
 
-use std::io;
-
-use std::io::Write;
-use std::time::Duration;
-
 use crossbeam_channel::{select, unbounded, Receiver, Sender};
 
 use cheapsdo_protocol::*;
-use postcard::{from_bytes_cobs, to_stdvec_cobs};
 
 mod formatters;
 mod plots;
+mod serial;
 mod widgets;
 
 fn main() -> Result<(), eframe::Error> {
@@ -28,22 +23,12 @@ fn main() -> Result<(), eframe::Error> {
     )
 }
 
-#[derive(PartialEq, Debug)]
-enum SerialPortCmd {
-    Disconnect,
-}
-
-#[derive(PartialEq, Debug)]
-enum SerialPortData {
-    DeviceState(StatusMessage),
-}
-
 struct CheapsdoControl {
     serial_device: String,
     serial_connected: bool,
 
-    data_rx: Option<Receiver<SerialPortData>>,
-    cmd_tx: Option<Sender<SerialPortCmd>>,
+    data_rx: Option<Receiver<serial::Data>>,
+    cmd_tx: Option<Sender<serial::Cmd>>,
 
     device_state: StatusMessage,
     average_points: Vec<[f64; 2]>,
@@ -93,7 +78,7 @@ impl eframe::App for CheapsdoControl {
                 select! {
                     recv(data_rx) -> data => {
                         match data {
-                        Ok(SerialPortData::DeviceState(status_msg)) => {
+                        Ok(serial::Data::DeviceState(status_msg)) => {
                             self.device_state = status_msg.clone();
                             self.average_points.push([
                                 self.average_points.len() as f64,
@@ -147,7 +132,7 @@ impl eframe::App for CheapsdoControl {
                     self.data_rx = Some(data_rx);
 
                     std::thread::spawn(move || {
-                        poll_device(serial_device, cmd_rx, data_tx, ctx);
+                        serial::poll_device(serial_device, cmd_rx, data_tx, ctx);
                     });
                 }
 
@@ -156,7 +141,7 @@ impl eframe::App for CheapsdoControl {
                     .clicked()
                 {
                     if let Some(cmd_tx) = &self.cmd_tx {
-                        cmd_tx.send(SerialPortCmd::Disconnect).unwrap();
+                        cmd_tx.send(serial::Cmd::Disconnect).unwrap();
                     }
                     self.serial_connected = false;
                 }
@@ -237,55 +222,3 @@ impl eframe::App for CheapsdoControl {
         });
     }
 }
-
-fn poll_device(
-    port: String,
-    cmd_rx: Receiver<SerialPortCmd>,
-    data_tx: Sender<SerialPortData>,
-    ctx: egui::Context,
-) {
-    let mut port = serialport::new(port, 115_200)
-        .timeout(Duration::from_millis(10))
-        .open()
-        .expect("Failed to open port");
-
-    let host_msg = HostMessage::RequestStatus;
-    let msg_bytes = to_stdvec_cobs(&host_msg).unwrap();
-    port.write_all(&msg_bytes).unwrap();
-
-    loop {
-        let mut serial_buf: Vec<u8> = vec![0; 128];
-        match port.read(serial_buf.as_mut_slice()) {
-            Ok(t) => {
-                serial_buf.truncate(t);
-                println!("Data: {:?}", serial_buf);
-
-                let dev_msg = from_bytes_cobs::<DeviceMessage>(&mut serial_buf).unwrap();
-
-                match dev_msg {
-                    DeviceMessage::Status(status_msg) => {
-                        data_tx
-                            .send(SerialPortData::DeviceState(status_msg))
-                            .unwrap();
-                        ctx.request_repaint();
-                    }
-                    DeviceMessage::PLLSettings(_) => {}
-                }
-            }
-            Err(ref e) if e.kind() == io::ErrorKind::TimedOut => (),
-            Err(e) => eprintln!("{:?}", e),
-        }
-
-        select! {
-            recv(cmd_rx) -> cmd => match cmd {
-                Ok(SerialPortCmd::Disconnect) => return,
-                Err(_) => {},
-            },
-            default(Duration::from_secs(1)) => {
-                let host_msg = HostMessage::RequestStatus;
-                let msg_bytes = to_stdvec_cobs(&host_msg).unwrap();
-                port.write_all(&msg_bytes).unwrap();
-            },
-        }
-    }
-}

hostsoftware/src/serial.rs

@@ -0,0 +1,63 @@
+use std::io;
+use std::time::Duration;
+
+use crossbeam_channel::{select, Receiver, Sender};
+use eframe::egui;
+use postcard::{from_bytes_cobs, to_stdvec_cobs};
+
+use cheapsdo_protocol::*;
+
+#[derive(PartialEq, Debug)]
+pub enum Cmd {
+    Disconnect,
+}
+
+#[derive(PartialEq, Debug)]
+pub enum Data {
+    DeviceState(StatusMessage),
+}
+
+pub fn poll_device(port: String, cmd_rx: Receiver<Cmd>, data_tx: Sender<Data>, ctx: egui::Context) {
+    let mut port = serialport::new(port, 115_200)
+        .timeout(Duration::from_millis(10))
+        .open()
+        .expect("Failed to open port");
+
+    let host_msg = HostMessage::RequestStatus;
+    let msg_bytes = to_stdvec_cobs(&host_msg).unwrap();
+    port.write_all(&msg_bytes).unwrap();
+
+    loop {
+        let mut serial_buf: Vec<u8> = vec![0; 128];
+        match port.read(serial_buf.as_mut_slice()) {
+            Ok(t) => {
+                serial_buf.truncate(t);
+                println!("Data: {:?}", serial_buf);
+
+                let dev_msg = from_bytes_cobs::<DeviceMessage>(&mut serial_buf).unwrap();
+
+                match dev_msg {
+                    DeviceMessage::Status(status_msg) => {
+                        data_tx.send(Data::DeviceState(status_msg)).unwrap();
+                        ctx.request_repaint();
+                    }
+                    DeviceMessage::PLLSettings(_) => {}
+                }
+            }
+            Err(ref e) if e.kind() == io::ErrorKind::TimedOut => (),
+            Err(e) => eprintln!("{:?}", e),
+        }
+
+        select! {
+            recv(cmd_rx) -> cmd => match cmd {
+                Ok(Cmd::Disconnect) => return,
+                Err(_) => {},
+            },
+            default(Duration::from_secs(1)) => {
+                let host_msg = HostMessage::RequestStatus;
+                let msg_bytes = to_stdvec_cobs(&host_msg).unwrap();
+                port.write_all(&msg_bytes).unwrap();
+            },
+        }
+    }
+}