Added log and automatic reconnect.

src/communication.rs

@@ -1,3 +1,5 @@
+use log::{error, info};
+
 use tokio::select;
 use tokio::sync::mpsc::Receiver;
 
@@ -15,52 +17,78 @@ pub async fn communicate_with_hardware(
     magnitude_series: Arc<Mutex<TimeSeriesPlot>>,
     phase_series: Arc<Mutex<TimeSeriesPlot>>,
 ) {
-    let workbook_client = WorkbookClient::new();
-
-    let mut sub = workbook_client
-        .client
-        .subscribe_multi::<icd::ImpedanceTopic>(8)
-        .await
-        .unwrap();
-
-    tokio::spawn(async move {
-        while let Ok(val) = sub.recv().await {
-            let mut mag_plot = magnitude_series.lock().unwrap();
-            let mut phase_plot = phase_series.lock().unwrap();
-
-            *magnitude.lock().unwrap() = val.magnitude;
-            *phase.lock().unwrap() = val.phase;
-
-            mag_plot.add(val.magnitude as f64);
-            phase_plot.add(val.phase as f64);
-        }
-    });
-    
     loop {
-        select! {
-            Some(run) = run_impedancemeter_rx.recv() => {
-                if run > 0 {
-                    // Start the impedancemeter
-                    if let Err(e) = workbook_client.start_impedancemeter(run as f32).await {
-                        eprintln!("Failed to start impedancemeter: {:?}", e);
+        let workbook_client = match WorkbookClient::new() {
+            Ok(client) => {
+                info!("Connected to hardware successfully.");
+                client
+            },
+            Err(e) => {
+                error!("Failed to connect to hardware: {:?}", e);
+                tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+                continue;
+            }
+        };
+
+        let mut sub = workbook_client
+            .client
+            .subscribe_multi::<icd::ImpedanceTopic>(8)
+            .await
+            .unwrap();
+
+        let data = (magnitude_series.clone(), phase_series.clone(), magnitude.clone(), phase.clone());
+
+        tokio::spawn(async move {
+            while let Ok(val) = sub.recv().await {
+                let mut mag_plot = data.0.lock().unwrap();
+                let mut phase_plot = data.1.lock().unwrap();
+                let mut mag_val = data.2.lock().unwrap();
+                let mut phase_val = data.3.lock().unwrap();
+
+                *mag_val = val.magnitude;
+                *phase_val = val.phase;
+    
+                mag_plot.add(val.magnitude as f64);
+                phase_plot.add(val.phase as f64);
+            }
+        info!("ImpedanceTopic subscription ended.");
+
+        });
+        
+        loop {
+            select! {
+                Some(run) = run_impedancemeter_rx.recv() => {
+                    if run > 0 {
+                        // Start the impedancemeter
+                        if let Err(e) = workbook_client.start_impedancemeter(run as f32).await {
+                            error!("Failed to start impedancemeter: {:?}", e);
+                        } else {
+                            info!("Impedancemeter started.");
+                        }
                     } else {
-                        println!("Impedancemeter started.");
-                    }
-                } else {
-                    // Stop the impedancemeter
-                    if let Err(e) = workbook_client.stop_impedancemeter().await {
-                        eprintln!("Failed to stop impedancemeter: {:?}", e);
-                    } else {
-                        println!("Impedancemeter stopped.");
+                        // Stop the impedancemeter
+                        if let Err(e) = workbook_client.stop_impedancemeter().await {
+                            error!("Failed to stop impedancemeter: {:?}", e);
+                        } else {
+                            info!("Impedancemeter stopped.");
+                        }
                     }
                 }
-            }
+                _ = workbook_client.wait_closed() => {
+                    // Handle client closure
+                    info!("Client connection closed.");
+                    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+                    break;
+                }
 
-            else => {
-                // All channels closed
-                break;
-            }
+                else => {
+                    // All channels closed
+                    break;
+                }
 
+            }
         }
+        info!("Communication with hardware ended.");
+        // Wait for a short period before trying to reconnect
     }
 }