improve time management

src/patterns/stars_random.rs

@@ -27,9 +27,9 @@ impl<const N: usize> Pattern for StarsRandom<N> {
     fn init(&mut self) -> Option<Self::Strip> {
         if let Some(color) = self.background_color {
             self.strip = Strip::<N>::new(color);
-            let red = (self.color.red as i16 - color.red as i16);
+            let red = self.color.red as i16 - color.red as i16;
-            let green = (color.green as i16 - self.color.green as i16);
+            let green = color.green as i16 - self.color.green as i16;
-            let blue = (self.color.blue as i16 - color.blue as i16);
+            let blue = self.color.blue as i16 - color.blue as i16;
             self.step = (
                 -(red / self.steps as i16) as i8,
                 -(green / self.steps as i16) as i8,

src/runner.rs

@@ -9,6 +9,7 @@ use std::future::Future;
 use std::str::FromStr;
 use std::time::Duration;
 use tokio::sync::watch::{Receiver, Sender};
+use tokio::time::Instant;
 
 pub(crate) mod period {
     use serde::{de::Error as _, Deserialize, Deserializer};
@@ -56,17 +57,19 @@ async fn runner_loop<const N: usize>(runner: DeviceSequence<N>, tx: Sender<Strip
     for mut context in runner {
         let mut strip = context.pattern.init().unwrap_or(background);
         let delay = context.period;
+        let mut next_instant = Instant::now() + delay;
         while tx.send(strip).is_ok() {
             if let Some(value) = context.pattern.next() {
                 strip = apply_mask(background, value);
             } else {
                 break;
             }
-            tokio::time::sleep(delay).await;
+            tokio::time::sleep_until(next_instant).await;
+            next_instant += delay;
         }
         background = strip;
-        println!("{:?}", background);
     }
+    
 }
 
 fn apply_mask<const N: usize>(previous_strip: Strip<N>, strip: Strip<{ N }>) -> Strip<N> {