Add pressure visual modes and breakout game

src/connection.rs

@@ -4,7 +4,7 @@ use std::time::Duration;
 
 use crossbeam_channel::{self, Receiver, Sender, TryRecvError};
 
-use crate::serial_core::serial::{SerialPortReadWrite, run_serial_loop};
+use crate::serial_core::serial::{SerialIoStats, SerialPortReadWrite, run_serial_loop};
 
 /// Connection state visible to the UI.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -27,6 +27,7 @@ struct Session {
     cancel_tx: Sender<()>,
     handle: JoinHandle<()>,
     sample_rx: Receiver<Vec<i32>>,
+    stats_rx: Receiver<SerialIoStats>,
 }
 
 /// Thread-safe connection manager that the UI and renderer can share.
@@ -34,6 +35,7 @@ pub struct ConnectionManager {
     state: Arc<Mutex<ConnectionState>>,
     session: Arc<Mutex<Option<Session>>>,
     latest_sample: Arc<Mutex<Option<PressureSample>>>,
+    stats: Arc<Mutex<SerialIoStats>>,
 }
 
 impl ConnectionManager {
@@ -42,6 +44,7 @@ impl ConnectionManager {
             state: Arc::new(Mutex::new(ConnectionState::Disconnected)),
             session: Arc::new(Mutex::new(None)),
             latest_sample: Arc::new(Mutex::new(None)),
+            stats: Arc::new(Mutex::new(SerialIoStats::default())),
         }
     }
 
@@ -53,6 +56,21 @@ impl ConnectionManager {
         *self.state.lock().unwrap() = new_state;
     }
 
+    pub fn stats(&self) -> SerialIoStats {
+        let session = self.session.lock().unwrap();
+        if let Some(ref session) = *session {
+            loop {
+                match session.stats_rx.try_recv() {
+                    Ok(stats) => *self.stats.lock().unwrap() = stats,
+                    Err(TryRecvError::Empty) => break,
+                    Err(TryRecvError::Disconnected) => break,
+                }
+            }
+        }
+
+        *self.stats.lock().unwrap()
+    }
+
     /// Connect to the given serial port and start streaming in a background thread.
     pub fn connect(&self, port_name: &str, rows: u32, cols: u32) {
         self.disconnect();
@@ -64,6 +82,8 @@ impl ConnectionManager {
         let latest_sample = Arc::clone(&self.latest_sample);
         let (cancel_tx, cancel_rx) = crossbeam_channel::bounded::<()>(1);
         let (sample_tx, sample_rx) = crossbeam_channel::bounded::<Vec<i32>>(16);
+        let (stats_tx, stats_rx) = crossbeam_channel::bounded::<SerialIoStats>(16);
+        *self.stats.lock().unwrap() = SerialIoStats::default();
 
         let handle = thread::spawn(move || {
             let result = run_device_loop(
@@ -73,6 +93,7 @@ impl ConnectionManager {
                 &state,
                 &cancel_rx,
                 &sample_tx,
+                &stats_tx,
                 &latest_sample,
             );
             if let Err(e) = result {
@@ -85,6 +106,7 @@ impl ConnectionManager {
             cancel_tx,
             handle,
             sample_rx,
+            stats_rx,
         });
     }
 
@@ -102,6 +124,7 @@ impl ConnectionManager {
 
         self.set_state(ConnectionState::Disconnected);
         *self.latest_sample.lock().unwrap() = None;
+        *self.stats.lock().unwrap() = SerialIoStats::default();
     }
 
     /// Drain pending samples (non-blocking) and return the last one.
@@ -143,6 +166,7 @@ fn run_device_loop(
     state: &Arc<Mutex<ConnectionState>>,
     cancel_rx: &Receiver<()>,
     sample_tx: &Sender<Vec<i32>>,
+    stats_tx: &Sender<SerialIoStats>,
     latest_sample: &Arc<Mutex<Option<PressureSample>>>,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     let port = serialport::new(port_name, 921_600)
@@ -154,36 +178,17 @@ fn run_device_loop(
     let mut rw = SerialPortReadWrite::new(port);
     *state.lock().unwrap() = ConnectionState::Streaming;
 
-    // We need to also forward samples to latest_sample
-    let (inner_tx, inner_rx) = crossbeam_channel::bounded::<Vec<i32>>(16);
-    let latest = Arc::clone(latest_sample);
-    let outer_tx = sample_tx.clone();
+    run_serial_loop(
+        &mut rw,
+        rows as usize,
+        cols as usize,
+        cancel_rx,
+        sample_tx,
+        Some(stats_tx),
+    );
 
-    // Bridge thread: reads from inner channel, forwards to both sample_tx and latest_sample
-    let bridge_cancel = cancel_rx.clone();
-    let bridge_handle = thread::spawn(move || {
-        loop {
-            if bridge_cancel.try_recv().is_ok() {
-                break;
-            }
-            match inner_rx.try_recv() {
-                Ok(vals) => {
-                    // Store latest
-                    let matrix = vals.iter().map(|v| (*v).max(0) as u32).collect();
-                    *latest.lock().unwrap() = Some(PressureSample { matrix, rows, cols });
-                    // Forward
-                    let _ = outer_tx.try_send(vals);
-                }
-                Err(TryRecvError::Empty) => {
-                    std::thread::sleep(Duration::from_millis(1));
-                }
-                Err(TryRecvError::Disconnected) => break,
-            }
-        }
-    });
-
-    run_serial_loop(&mut rw, rows as usize, cols as usize, cancel_rx, &inner_tx);
-
-    let _ = bridge_handle.join();
+    if let Ok(mut latest) = latest_sample.lock() {
+        *latest = None;
+    }
     Ok(())
 }