fix graph update interval bug and simplify repaint logic

Author: markusdd

src/app/mod.rs

@@ -156,8 +156,6 @@ pub struct MyApp {
     #[serde(skip)]
     poll_interval_shared: Arc<Mutex<u64>>, // Shared poll interval for live updates
     #[serde(skip)]
-    graph_update_interval_shared: Arc<Mutex<u64>>, // Shared graph update interval
-    #[serde(skip)]
     last_graph_update: f64, // Track last graph update time
     #[serde(skip)]
     last_hist_collect_time: f64, // Track last histogram collection time
@@ -248,14 +246,13 @@ impl Default for MyApp {
             lock_remote: true,            // Default to locking remote mode
             value_debug_shared: Arc::new(Mutex::new(false)),
             poll_interval_shared: Arc::new(Mutex::new(20)),
-            graph_update_interval_shared: Arc::new(Mutex::new(20)), // Default shared value to 20ms
-            last_graph_update: 0.0,                                 // Initialize to 0
-            last_hist_collect_time: 0.0,                            // Initialize to 0
-            connection_state: ConnectionState::Disconnected,        // Initially disconnected
-            connection_error: None,                                 // No error initially
-            meas_count: 0,         // Initialize measurement counter
-            last_record_time: 0.0, // Initialize last recording time
-            graph_config: graph::GraphConfig::default(), // Default graph config
+            last_graph_update: 0.0,                          // Initialize to 0
+            last_hist_collect_time: 0.0,                     // Initialize to 0
+            connection_state: ConnectionState::Disconnected, // Initially disconnected
+            connection_error: None,                          // No error initially
+            meas_count: 0,                                   // Initialize measurement counter
+            last_record_time: 0.0,                           // Initialize last recording time
+            graph_config: graph::GraphConfig::default(),     // Default graph config
             plot_dock_state: DockState::new(vec![]), // Initialize empty, populated in update
             cont_disable_unit_scaling: false,
         }
@@ -291,30 +288,15 @@ impl MyApp {
             let app: MyApp = eframe::get_value(storage, eframe::APP_KEY).unwrap_or_default();
             *app.value_debug_shared.lock().unwrap() = app.value_debug;
             *app.poll_interval_shared.lock().unwrap() = app.poll_interval_ms;
-            *app.graph_update_interval_shared.lock().unwrap() = app.graph_update_interval_ms;
             return app;
         }
 
         let app = Self::default();
         *app.value_debug_shared.lock().unwrap() = app.value_debug;
         *app.poll_interval_shared.lock().unwrap() = app.poll_interval_ms;
-        *app.graph_update_interval_shared.lock().unwrap() = app.graph_update_interval_ms;
         app
     }
 
-    fn spawn_graph_update_task(&mut self, ctx: Context) {
-        let graph_update_interval_shared = self.graph_update_interval_shared.clone();
-        let ctx = ctx.clone();
-
-        tokio::spawn(async move {
-            loop {
-                let interval = *graph_update_interval_shared.lock().unwrap();
-                ctx.request_repaint(); // Trigger a repaint to update the graph
-                tokio::time::sleep(Duration::from_millis(interval)).await;
-            }
-        });
-    }
-
     fn set_mode(
         &mut self,
         mode: MeterMode,

src/app/settings.rs

@@ -147,8 +147,6 @@ impl super::MyApp {
                                     {
                                         self.graph_update_interval_ms =
                                             self.graph_update_interval_max;
-                                        *self.graph_update_interval_shared.lock().unwrap() =
-                                            self.graph_update_interval_max;
                                     }
                                 }
                             }

src/app/ui.rs

@@ -189,7 +189,7 @@ impl super::MyApp {
 
         // Handle graph and histogram updates and recording based on the configured interval
         let current_time = ui.ctx().input(|i| i.time); // Get current time in seconds
-        let graph_interval = *self.graph_update_interval_shared.lock().unwrap() as f64 / 1000.0; // Convert ms to seconds
+        let graph_interval = self.graph_update_interval_ms as f64 / 1000.0; // Convert ms to seconds
         if current_time - self.last_graph_update >= graph_interval {
             if !self.curr_meas.is_nan() {
                 self.values.push_back(self.curr_meas);
@@ -277,7 +277,6 @@ impl super::MyApp {
                                             self.connection_state =
                                                 super::ConnectionState::Connected;
                                             self.spawn_serial_task();
-                                            self.spawn_graph_update_task(ui.ctx().clone());
                                         }
                                     }
                                     Err(e) => {
@@ -727,6 +726,13 @@ impl super::MyApp {
             // Show settings and recording windows
             self.show_settings(ui.ctx());
             self.show_recording_window(ui);
+
+            // ensure repaint based on update intervals
+            ui.ctx()
+                .request_repaint_after(std::time::Duration::from_millis(std::cmp::min(
+                    self.graph_update_interval_ms,
+                    self.poll_interval_ms,
+                )));
         });
     }
 }