Inluded frequency selector at start.

src/app.rs

@@ -4,15 +4,15 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use atomic_float::AtomicF32;
 use tokio::{sync::mpsc::{Sender}};
 
-use eframe::egui::{self, Color32, DragValue, Key, Layout, Modifiers, };
+use eframe::egui::{self, Color32, DragValue, Key, Label, Layout, Modifiers};
 use egui_plot::{Corner, Legend, Line, Plot, PlotPoints, Points, PlotBounds};
 
 use crate::plot::TimeSeriesPlot;
 
-use crate::signals::FrequencySignal;
+use crate::signals::SingleFrequencySignal;
 
 pub struct App {
-    run_impedancemeter_tx: Sender<FrequencySignal>,
+    run_impedancemeter_tx: Sender<SingleFrequencySignal>,
     pub magnitude: Arc<Mutex<f32>>,
     pub phase: Arc<Mutex<f32>>,
     pub magnitude_series: Arc<Mutex<TimeSeriesPlot>>,
@@ -20,10 +20,11 @@ pub struct App {
     pub connected: Arc<AtomicBool>,
     pub on: bool,
     pub data_frequency: Arc<AtomicF32>,
+    pub single_frequency: u32
 }
 
 impl App {
-    pub fn new(run_impedancemeter_tx: Sender<FrequencySignal>) -> Self {
+    pub fn new(run_impedancemeter_tx: Sender<SingleFrequencySignal>) -> Self {
         let app = App {
             run_impedancemeter_tx,
             magnitude: Arc::new(Mutex::new(0.0)),
@@ -33,6 +34,7 @@ impl App {
             connected: Arc::new(AtomicBool::new(false)),
             on: true,
             data_frequency: Arc::new(AtomicF32::new(0.0)),
+            single_frequency: 50000,
         };
         app.update_start_stop();
         app
@@ -41,12 +43,12 @@ impl App {
     pub fn update_start_stop(&self) {
         match self.on {
             true => {
-                if let Err(e) = self.run_impedancemeter_tx.try_send(FrequencySignal::Start(0.0)) {
+                if let Err(e) = self.run_impedancemeter_tx.try_send(SingleFrequencySignal::Start(self.single_frequency)) {
                     eprintln!("Failed to send start command: {:?}", e);
                 }
             },
             false => {
-                if let Err(e) = self.run_impedancemeter_tx.try_send(FrequencySignal::Stop) {
+                if let Err(e) = self.run_impedancemeter_tx.try_send(SingleFrequencySignal::Stop) {
                     eprintln!("Failed to send stop command: {:?}", e);
                 }
             },
@@ -68,6 +70,13 @@ impl eframe::App for App {
 
                 ui.separator();
 
+                ui.add_enabled_ui(!self.on, |ui| {
+                    ui.add(DragValue::new(&mut self.single_frequency));
+                    ui.add(Label::new("Hz"));
+                });
+
+                ui.separator();
+
                 if ui.add_enabled(connected, toggle_start_stop(&mut self.on)).changed() {
                     self.update_start_stop();
                 };

src/bin/main_cli.rs

@@ -64,7 +64,7 @@ async fn main() {
             }
 
             ["imp", "listen", freq, dur] => {
-                let Ok(freq) = freq.parse::<f32>() else {
+                let Ok(freq) = freq.parse::<u32>() else {
                     println!("Bad freq: {freq}");
                     continue;
                 };
@@ -81,6 +81,7 @@ async fn main() {
                 client.start_impedancemeter(freq).await.unwrap();
                 println!("Started!");
                 let dur = Duration::from_millis(dur.into());
+                
                 let start = Instant::now();
                 while start.elapsed() < dur {
                     let val = sub.recv().await.unwrap();
@@ -90,9 +91,10 @@ async fn main() {
                 println!("Stopped!");
             }
             ["imp", "start", freq] => {
-                let Ok(freq) = freq.parse::<f32>() else {
+                let Ok(freq) = freq.parse::<u32>() else {
                     println!("Bad freq: {freq}");
                     continue;
+                    
                 };
 
                 match client.start_impedancemeter(freq).await {

src/bin/main_gui.rs

@@ -8,7 +8,7 @@ use bioz_host_rs::communication::communicate_with_hardware;
 
 use tokio::sync::mpsc::{self};
 
-use bioz_host_rs::signals::FrequencySignal;
+use bioz_host_rs::signals::SingleFrequencySignal;
 
 fn main() {
     SimpleLogger::new().init().expect("Failed to initialize logger");
@@ -20,7 +20,7 @@ fn main() {
     // Enter the runtime so that `tokio::spawn` is available immediately.
     // let _enter = rt.enter();
 
-    let (run_impedancemeter_tx, run_impedancemeter_rx) = mpsc::channel::<FrequencySignal>(2);
+    let (run_impedancemeter_tx, run_impedancemeter_rx) = mpsc::channel::<SingleFrequencySignal>(2);
     let run_impedancemeter_tx_clone = run_impedancemeter_tx.clone();
 
     let app = App::new(run_impedancemeter_tx);

src/client.rs

@@ -63,7 +63,7 @@ impl WorkbookClient {
 
     pub async fn start_impedancemeter(
         &self,
-        frequency: f32,
+        frequency: u32,
     ) -> Result<(), WorkbookError<Infallible>> {
         self.client
             .send_resp::<StartImpedanceEndpoint>(&StartImpedance { update_frequency: 60, sinus_frequency: frequency })

src/communication.rs

@@ -13,11 +13,11 @@ use crate::client::WorkbookClient;
 
 use crate::plot::TimeSeriesPlot;
 
-use crate::signals::FrequencySignal;
+use crate::signals::SingleFrequencySignal;
 
 pub async fn communicate_with_hardware(
-    mut run_impedancemeter_rx: Receiver<FrequencySignal>,
-    run_impedancemeter_tx: Sender<FrequencySignal>,
+    mut run_impedancemeter_rx: Receiver<SingleFrequencySignal>,
+    run_impedancemeter_tx: Sender<SingleFrequencySignal>,
     magnitude: Arc<Mutex<f32>>,
     phase: Arc<Mutex<f32>>,
     magnitude_series: Arc<Mutex<TimeSeriesPlot>>,
@@ -37,7 +37,7 @@ pub async fn communicate_with_hardware(
 
     #[derive(Default)]
     struct Settings {
-        frequency: Option<FrequencySignal>,
+        frequency: Option<SingleFrequencySignal>,
     }
     let mut settings = Settings::default();
     
@@ -90,19 +90,19 @@ pub async fn communicate_with_hardware(
             select! {
                 Some(frequency) = run_impedancemeter_rx.recv() => {
                     match frequency {
-                        FrequencySignal::Start(freq) => {
+                        SingleFrequencySignal::Start(freq) => {
                             if let Err(e) = workbook_client.start_impedancemeter(freq).await {
                                 error!("Failed to start impedancemeter: {:?}", e);
                             } else {
-                                settings.frequency = Some(FrequencySignal::Start(freq));
+                                settings.frequency = Some(SingleFrequencySignal::Start(freq));
                                 info!("Impedancemeter started at frequency: {}", freq);
                             }
                         },
-                        FrequencySignal::Stop => {
+                        SingleFrequencySignal::Stop => {
                             if let Err(e) = workbook_client.stop_impedancemeter().await {
                                 error!("Failed to stop impedancemeter: {:?}", e);
                             } else {
-                                settings.frequency = Some(FrequencySignal::Stop);
+                                settings.frequency = Some(SingleFrequencySignal::Stop);
                                 info!("Impedancemeter stopped.");
                             }
                         },

src/signals.rs

@@ -1,5 +1,5 @@
 #[derive(Copy, Clone)]
-pub enum FrequencySignal {
-    Start(f32),
+pub enum SingleFrequencySignal {
+    Start(u32),
     Stop,
 }