Added start stop toggle, included log.

src/app.rs

@@ -1,32 +1,56 @@
 use std::sync::{Arc, Mutex};
+use std::sync::atomic::{AtomicBool, Ordering};
 
 use std::ops::RangeInclusive;
 
 use tokio::{sync::mpsc::{Sender}};
 
-use eframe::egui::{self, Color32, DragValue, Key, Layout, Modifiers};
+use eframe::egui::{self, Color32, DragValue, Key, Layout, Modifiers, };
 use egui_plot::{Corner, Legend, Line, Plot, PlotPoints, Points, PlotBounds};
 
 use crate::plot::TimeSeriesPlot;
 
+use crate::signals::FrequencySignal;
+
 pub struct App {
-    frequency: u32,
-    run_impedancemeter_tx: Sender<u32>,
+    frequency: f32,
+    run_impedancemeter_tx: Sender<FrequencySignal>,
     pub magnitude: Arc<Mutex<f32>>,
     pub phase: Arc<Mutex<f32>>,
     pub magnitude_series: Arc<Mutex<TimeSeriesPlot>>,
     pub phase_series: Arc<Mutex<TimeSeriesPlot>>,
+    pub connected: Arc<AtomicBool>,
+    pub on: bool,
 }
 
 impl App {
-    pub fn new(run_impedancemeter_tx: Sender<u32>) -> Self {
-        App {
-            frequency: 2, // Default frequency
+    pub fn new(run_impedancemeter_tx: Sender<FrequencySignal>) -> Self {
+        let app = App {
+            frequency: 2.0, // Default frequency
             run_impedancemeter_tx,
             magnitude: Arc::new(Mutex::new(0.0)),
             phase: Arc::new(Mutex::new(0.0)),
             magnitude_series: Arc::new(Mutex::new(TimeSeriesPlot::new())),
             phase_series: Arc::new(Mutex::new(TimeSeriesPlot::new())),
+            connected: Arc::new(AtomicBool::new(false)),
+            on: true,
+        };
+        app.update_start_stop();
+        app
+    }
+
+    pub fn update_start_stop(&self) {
+        match self.on {
+            true => {
+                if let Err(e) = self.run_impedancemeter_tx.try_send(FrequencySignal::Start(self.frequency)) {
+                    eprintln!("Failed to send start command: {:?}", e);
+                }
+            },
+            false => {
+                if let Err(e) = self.run_impedancemeter_tx.try_send(FrequencySignal::Stop) {
+                    eprintln!("Failed to send stop command: {:?}", e);
+                }
+            },
         }
     }
 }
@@ -36,34 +60,45 @@ impl eframe::App for App {
         // Egui add a top bar
         egui::TopBottomPanel::top("top_bar").show(ctx, |ui| {
             egui::MenuBar::new().ui(ui, |ui| {
+                let connected = self.connected.load(Ordering::Relaxed);
+                
                 egui::widgets::global_theme_preference_switch(ui);
                 ui.separator();
 
-                if ui.add(DragValue::new(&mut self.frequency).speed(0.1).range(RangeInclusive::new(0, 50)).update_while_editing(false)).changed() {
-                    if let Err(e) = self.run_impedancemeter_tx.try_send(0) {
-                        eprintln!("Failed to send stop command: {:?}", e);
-                    }
-                    // Delay
-                    if let Err(e) = self.run_impedancemeter_tx.try_send(self.frequency) {
-                        eprintln!("Failed to send frequency update: {:?}", e);
-                    }
+                let response = ui.add_enabled(connected, DragValue::new(&mut self.frequency).speed(0.1).update_while_editing(false).range(RangeInclusive::new(0, 50)));
+
+                if response.changed() && response.lost_focus() {
+                    self.update_start_stop();
+                }
+
+                ui.separator();
+
+                if ui.add_enabled(connected, toggle_start_stop(&mut self.on)).changed() {
+                    self.update_start_stop();
                 };
 
-                ui.separator();
+                // Spacer to push the LED to the right
+                ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                    ui.scope(|ui| {
+                    let is_connected = self.connected.load(Ordering::Relaxed);
+                    let color = if is_connected { Color32::GREEN } else { Color32::RED };
+                    let tooltip = if is_connected { "Connected" } else { "Disconnected" };
 
-                if ui.button("Start").clicked() {
-                    if let Err(e) = self.run_impedancemeter_tx.try_send(self.frequency) {
-                        eprintln!("Failed to send start command: {:?}", e);
-                    }
-                }
+                    // Allocate a fixed-size rectangle for the LED
+                    let led_size = egui::Vec2::splat(12.0);
+                    let (rect, response) = ui.allocate_exact_size(led_size, egui::Sense::hover());
 
-                ui.separator();
-            
-                if ui.button("Stop").clicked() {
-                    if let Err(e) = self.run_impedancemeter_tx.try_send(0) {
-                        eprintln!("Failed to send stop command: {:?}", e);
+                    // Draw the circle
+                    let center = rect.center();
+                    let radius = 5.0;
+                    ui.painter().circle_filled(center, radius, color);
+
+                    // Tooltip
+                    if response.hovered() {
+                        response.on_hover_text(tooltip);
                     }
-                }
+                    });
+                });
             });
         });
 
@@ -130,5 +165,49 @@ impl eframe::App for App {
             ctx.send_viewport_cmd(egui::ViewportCommand::Close);
         }
 
+        // CMD- or control-W to close window
+        if ctx.input(|i| i.key_pressed(Key::Space))
+        {
+            self.on = !self.on;
+            self.update_start_stop();
+        }
+
         ctx.request_repaint();
     }}
+
+
+fn toggle_ui_start_stop(ui: &mut egui::Ui, on: &mut bool) -> egui::Response {
+    let desired_size = ui.spacing().interact_size.y * egui::vec2(2.0, 1.0);
+    let (rect, mut response) = ui.allocate_exact_size(desired_size, egui::Sense::click());
+    if response.clicked() {
+        *on = !*on;
+        response.mark_changed();
+    }
+    response.widget_info(|| {
+        egui::WidgetInfo::selected(egui::WidgetType::Checkbox, ui.is_enabled(), *on, "")
+    });
+
+    if ui.is_rect_visible(rect) {
+        let how_on = ui.ctx().animate_bool_responsive(response.id, *on);
+        let visuals = ui.style().interact_selectable(&response, *on);
+        let rect = rect.expand(visuals.expansion);
+        let radius = 0.5 * rect.height();
+        ui.painter().rect(
+            rect,
+            radius,
+            visuals.bg_fill,
+            visuals.bg_stroke,
+            egui::StrokeKind::Inside,
+        );
+        let circle_x = egui::lerp((rect.left() + radius)..=(rect.right() - radius), how_on);
+        let center = egui::pos2(circle_x, rect.center().y);
+        ui.painter()
+            .circle(center, 0.75 * radius, visuals.bg_fill, visuals.fg_stroke);
+    }
+
+    response
+}
+
+pub fn toggle_start_stop(on: &mut bool) -> impl egui::Widget + '_ {
+    move |ui: &mut egui::Ui| toggle_ui_start_stop(ui, on)
+}