Switch to a fixed point arithmatic library

Theoretically, this is the first step to getting to running on the pico

Cargo.lock

@@ -217,6 +217,19 @@ version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
 
+[[package]]
+name = "bike"
+version = "0.1.0"
+dependencies = [
+ "cortex-m",
+ "cortex-m-rt",
+ "embedded-hal",
+ "fugit",
+ "lights-core",
+ "panic-halt",
+ "rp-pico",
+]
+
 [[package]]
 name = "bit-set"
 version = "0.5.3"
@@ -2176,6 +2189,10 @@ dependencies = [
 [[package]]
 name = "lights-core"
 version = "0.1.0"
+dependencies = [
+ "az",
+ "fixed",
+]
 
 [[package]]
 name = "linux-raw-sys"

Cargo.toml

@@ -2,6 +2,7 @@
 resolver = "2"
 members = [
     "authdb",
+    "bike-lights/bike",
     "bike-lights/core",
     "bike-lights/simulator",
     "changeset",

bike-lights/bike/.cargo/config

@@ -0,0 +1,12 @@
+[build]
+target = "thumbv6m-none-eabi"
+
+[target.thumbv6m-none-eabi]
+rustflags = [
+    "-C", "link-arg=--nmagic",
+    "-C", "link-arg=-Tlink.x",
+    "-C", "inline-threshold=5",
+    "-C", "no-vectorize-loops",
+]
+
+runner = "elf2uf2-rs -d"

bike-lights/bike/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "bike"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+cortex-m = "0.7.7"
+cortex-m-rt = "0.7.3"
+embedded-hal = "0.2.7"
+fugit = "0.3.7"
+panic-halt = "0.2.0"
+rp-pico = "0.8.0"
+lights-core = { path = "../core" }

bike-lights/bike/src/main.rs

@@ -0,0 +1,10 @@
+#![no_main]
+#![no_std]
+
+use panic_halt as _;
+use rp_pico::entry;
+
+#[entry]
+fn main() -> ! {
+    loop {}
+}

bike-lights/core/Cargo.toml

@@ -6,3 +6,5 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+az      = { version = "1" }
+fixed   = { version = "1" }

bike-lights/core/src/lib.rs

@@ -1,69 +1,101 @@
+#![no_std]
+
+extern crate alloc;
+use alloc::boxed::Box;
+use az::*;
+use core::{clone::Clone, cmp::PartialEq, ops::Sub, option::Option};
+use fixed::types::{I16F0, I16F16, I48F16, I8F8, U128F0, U16F0};
+
 mod patterns;
 pub use patterns::*;
 
 mod types;
-pub use types::{DashboardPattern, Pattern, RGB};
+pub use types::{BodyPattern, DashboardPattern, RGB};
+
+fn calculate_frames(starting_time: U128F0, now: U128F0) -> U16F0 {
+    let frames_128 = (now - starting_time) / U128F0::from(FPS);
+    (frames_128 % U128F0::from(U16F0::MAX)).cast()
+}
+
+fn calculate_slope(start: I8F8, end: I8F8, frames: U16F0) -> I8F8 {
+    let slope_i16f16 = (I48F16::from(end) - I48F16::from(start)) / I48F16::from(frames);
+    slope_i16f16.saturating_as()
+}
+
+fn linear_ease(value: I8F8, frames: U16F0, slope: I8F8) -> I8F8 {
+    let value_i16f16 = I48F16::from(value) + I48F16::from(frames) * I48F16::from(slope);
+    value_i16f16.saturating_as()
+}
+
+#[derive(Clone, Copy)]
+pub struct Instant(pub U128F0);
+
+impl Sub for Instant {
+    type Output = Self;
+
+    fn sub(self, r: Self) -> Self::Output {
+        Self(self.0 - r.0)
+    }
+}
 
 pub const FPS: u8 = 30;
 
 pub trait UI {
     fn check_event(&self) -> Option<Event>;
-    fn update_lights(&self, dashboard_lights: DashboardPattern, lights: Pattern);
+    fn update_lights(&self, dashboard_lights: DashboardPattern, body_lights: BodyPattern);
 }
 
 pub trait Animation {
-    fn tick(&mut self, time: std::time::Instant) -> (DashboardPattern, Pattern);
+    fn tick(&mut self, time: Instant) -> (DashboardPattern, BodyPattern);
 }
 
 pub struct DefaultAnimation {}
 
 impl Animation for DefaultAnimation {
-    fn tick(&mut self, _: std::time::Instant) -> (DashboardPattern, Pattern) {
-        (PRIDE_DASHBOARD, PRIDE)
+    fn tick(&mut self, _: Instant) -> (DashboardPattern, BodyPattern) {
+        (PRIDE_DASHBOARD, PRIDE_BODY)
     }
 }
 
 pub struct Fade {
     starting_dashboard: DashboardPattern,
-    starting_lights: Pattern,
+    starting_lights: BodyPattern,
 
-    start_time: std::time::Instant,
-    dashboard_slope: Vec<RGB<f64>>,
-    body_slope: Vec<RGB<f64>>,
-    frames: u8,
+    start_time: Instant,
+    dashboard_slope: [RGB<I8F8>; 3],
+    body_slope: [RGB<I8F8>; 60],
+    frames: U16F0,
 }
 
 impl Fade {
     fn new(
         dashboard: DashboardPattern,
-        lights: Pattern,
+        lights: BodyPattern,
         ending_dashboard: DashboardPattern,
-        ending_lights: Pattern,
-        frames: u8,
-        time: std::time::Instant,
+        ending_lights: BodyPattern,
+        frames: U16F0,
+        time: Instant,
     ) -> Self {
-        let mut dashboard_slope = Vec::new();
-        let mut body_slope = Vec::new();
+        let mut dashboard_slope = [Default::default(); 3];
+        let mut body_slope = [Default::default(); 60];
         for i in 0..3 {
             let slope = RGB {
-                r: (ending_dashboard[i].r as f64 - dashboard[i].r as f64) / frames as f64,
-                g: (ending_dashboard[i].g as f64 - dashboard[i].g as f64) / frames as f64,
-                b: (ending_dashboard[i].b as f64 - dashboard[i].b as f64) / frames as f64,
+                r: calculate_slope(dashboard[i].r, ending_dashboard[i].r, frames),
+                g: calculate_slope(dashboard[i].g, ending_dashboard[i].g, frames),
+                b: calculate_slope(dashboard[i].b, ending_dashboard[i].b, frames),
             };
-            dashboard_slope.push(slope);
+            dashboard_slope[i] = slope;
         }
 
         for i in 0..60 {
             let slope = RGB {
-                r: (ending_lights[i].r as f64 - lights[i].r as f64) / frames as f64,
-                g: (ending_lights[i].g as f64 - lights[i].g as f64) / frames as f64,
-                b: (ending_lights[i].b as f64 - lights[i].b as f64) / frames as f64,
+                r: calculate_slope(lights[i].r, ending_lights[i].r, frames),
+                g: calculate_slope(lights[i].g, ending_lights[i].g, frames),
+                b: calculate_slope(lights[i].b, ending_lights[i].b, frames),
             };
-            body_slope.push(slope);
+            body_slope[i] = slope;
         }
 
-        println!("dashboard slope: {:?}", dashboard_slope);
-
         Self {
             starting_dashboard: dashboard,
             starting_lights: lights,
@@ -76,50 +108,39 @@ impl Fade {
 }
 
 impl Animation for Fade {
-    fn tick(&mut self, time: std::time::Instant) -> (DashboardPattern, Pattern) {
-        let mut frames: u8 = ((time - self.start_time).as_millis() as f64 / FPS as f64) as u8;
+    fn tick(&mut self, time: Instant) -> (DashboardPattern, BodyPattern) {
+        let mut frames = calculate_frames(self.start_time.0, time.0);
         if frames > self.frames {
             frames = self.frames
         }
         let mut dashboard_pattern: DashboardPattern = OFF_DASHBOARD;
-        let mut body_pattern: Pattern = OFF;
-
-        let apply = |value: f64, frames: f64, slope: f64| -> f64 { value + frames * slope };
+        let mut body_pattern: BodyPattern = OFF_BODY;
 
         for i in 0..3 {
-            dashboard_pattern[i].r = apply(
-                self.starting_dashboard[i].r as f64,
-                frames as f64,
-                self.dashboard_slope[i].r as f64,
-            ) as u8;
-            dashboard_pattern[i].g = apply(
-                self.starting_dashboard[i].g as f64,
-                frames as f64,
-                self.dashboard_slope[i].g as f64,
-            ) as u8;
-            dashboard_pattern[i].b = apply(
-                self.starting_dashboard[i].b as f64,
-                frames as f64,
-                self.dashboard_slope[i].b as f64,
-            ) as u8;
+            dashboard_pattern[i].r = linear_ease(
+                self.starting_dashboard[i].r,
+                frames,
+                self.dashboard_slope[i].r,
+            );
+            dashboard_pattern[i].g = linear_ease(
+                self.starting_dashboard[i].g,
+                frames,
+                self.dashboard_slope[i].g,
+            );
+            dashboard_pattern[i].b = linear_ease(
+                self.starting_dashboard[i].b,
+                frames,
+                self.dashboard_slope[i].b,
+            );
         }
 
         for i in 0..60 {
-            body_pattern[i].r = apply(
-                self.starting_lights[i].r as f64,
-                frames as f64,
-                self.body_slope[i].r as f64,
-            ) as u8;
-            body_pattern[i].g = apply(
-                self.starting_lights[i].g as f64,
-                frames as f64,
-                self.body_slope[i].g as f64,
-            ) as u8;
-            body_pattern[i].b = apply(
-                self.starting_lights[i].b as f64,
-                frames as f64,
-                self.body_slope[i].b as f64,
-            ) as u8;
+            body_pattern[i].r =
+                linear_ease(self.starting_lights[i].r, frames, self.body_slope[i].r);
+            body_pattern[i].g =
+                linear_ease(self.starting_lights[i].g, frames, self.body_slope[i].g);
+            body_pattern[i].b =
+                linear_ease(self.starting_lights[i].b, frames, self.body_slope[i].b);
         }
 
         (dashboard_pattern, body_pattern)
@@ -142,29 +163,29 @@ pub struct Blinker {
     fade_out: Fade,
     direction: FadeDirection,
 
-    start_time: std::time::Instant,
-    frames: u8,
+    start_time: Instant,
+    frames: U16F0,
 }
 
 impl Blinker {
     fn new(
         starting_dashboard: DashboardPattern,
-        starting_body: Pattern,
+        starting_body: BodyPattern,
         direction: BlinkerDirection,
-        time: std::time::Instant,
+        time: Instant,
     ) -> Self {
         let mut ending_dashboard = starting_dashboard.clone();
 
         match direction {
             BlinkerDirection::Left => {
-                ending_dashboard[0].r = LEFT_DASHBOARD[0].r;
-                ending_dashboard[0].g = LEFT_DASHBOARD[0].g;
-                ending_dashboard[0].b = LEFT_DASHBOARD[0].b;
+                ending_dashboard[0].r = LEFT_BLINKER_DASHBOARD[0].r;
+                ending_dashboard[0].g = LEFT_BLINKER_DASHBOARD[0].g;
+                ending_dashboard[0].b = LEFT_BLINKER_DASHBOARD[0].b;
             }
             BlinkerDirection::Right => {
-                ending_dashboard[2].r = RIGHT_DASHBOARD[2].r;
-                ending_dashboard[2].g = RIGHT_DASHBOARD[2].g;
-                ending_dashboard[2].b = RIGHT_DASHBOARD[2].b;
+                ending_dashboard[2].r = RIGHT_BLINKER_DASHBOARD[2].r;
+                ending_dashboard[2].g = RIGHT_BLINKER_DASHBOARD[2].g;
+                ending_dashboard[2].b = RIGHT_BLINKER_DASHBOARD[2].b;
             }
         }
 
@@ -172,16 +193,16 @@ impl Blinker {
         match direction {
             BlinkerDirection::Left => {
                 for i in 0..30 {
-                    ending_body[i].r = LEFT[i].r;
-                    ending_body[i].g = LEFT[i].g;
-                    ending_body[i].b = LEFT[i].b;
+                    ending_body[i].r = LEFT_BLINKER_BODY[i].r;
+                    ending_body[i].g = LEFT_BLINKER_BODY[i].g;
+                    ending_body[i].b = LEFT_BLINKER_BODY[i].b;
                 }
             }
             BlinkerDirection::Right => {
                 for i in 30..60 {
-                    ending_body[i].r = RIGHT[i].r;
-                    ending_body[i].g = RIGHT[i].g;
-                    ending_body[i].b = RIGHT[i].b;
+                    ending_body[i].r = RIGHT_BLINKER_BODY[i].r;
+                    ending_body[i].g = RIGHT_BLINKER_BODY[i].g;
+                    ending_body[i].b = RIGHT_BLINKER_BODY[i].b;
                 }
             }
         }
@@ -211,8 +232,8 @@ impl Blinker {
 }
 
 impl Animation for Blinker {
-    fn tick(&mut self, time: std::time::Instant) -> (DashboardPattern, Pattern) {
-        let frames: u8 = ((time - self.start_time).as_millis() as f64 / FPS as f64) as u8;
+    fn tick(&mut self, time: Instant) -> (DashboardPattern, BodyPattern) {
+        let frames = calculate_frames(self.start_time.0, time.0);
         if frames > self.frames {
             match self.direction {
                 FadeDirection::FadeIn => {
@@ -226,7 +247,6 @@ impl Animation for Blinker {
             }
             self.start_time = time;
         }
-        println!("anim: {:?} {}", self.direction, frames);
 
         match self.direction {
             FadeDirection::FadeIn => self.fade_in.tick(time),
@@ -261,7 +281,7 @@ pub struct App {
     home_state: State,
     current_animation: Box<dyn Animation>,
     dashboard_lights: DashboardPattern,
-    lights: Pattern,
+    lights: BodyPattern,
 }
 
 impl App {
@@ -272,18 +292,18 @@ impl App {
             home_state: State::Pattern(0),
             current_animation: Box::new(DefaultAnimation {}),
             dashboard_lights: OFF_DASHBOARD,
-            lights: OFF,
+            lights: OFF_BODY,
         }
     }
 
-    fn update_animation(&mut self, time: std::time::Instant) {
+    fn update_animation(&mut self, time: Instant) {
         match self.state {
             State::Pattern(0) => {
                 self.current_animation = Box::new(Fade::new(
                     self.dashboard_lights.clone(),
                     self.lights.clone(),
                     PRIDE_DASHBOARD,
-                    PRIDE,
+                    PRIDE_BODY,
                     DEFAULT_FRAMES,
                     time,
                 ))
@@ -293,7 +313,7 @@ impl App {
                     self.dashboard_lights.clone(),
                     self.lights.clone(),
                     TRANS_PRIDE_DASHBOARD,
-                    TRANS_PRIDE,
+                    TRANS_PRIDE_BODY,
                     DEFAULT_FRAMES,
                     time,
                 ))
@@ -303,9 +323,9 @@ impl App {
                 self.current_animation = Box::new(Fade::new(
                     self.dashboard_lights.clone(),
                     self.lights.clone(),
-                    BRAKE_DASHBOARD,
-                    BRAKES,
-                    BRAKE_FRAMES,
+                    BRAKES_DASHBOARD,
+                    BRAKES_BODY,
+                    BRAKES_FRAMES,
                     time,
                 ));
             }
@@ -374,7 +394,7 @@ impl App {
         }
     }
 
-    pub fn tick(&mut self, time: std::time::Instant) {
+    pub fn tick(&mut self, time: Instant) {
         match self.ui.check_event() {
             Some(event) => {
                 self.update_state(event);

bike-lights/core/src/types.rs

@@ -1,9 +1,17 @@
-#[derive(Clone, Default, Debug)]
+use core::default::Default;
+use fixed::types::I8F8;
+
+#[derive(Clone, Copy, Default, Debug)]
 pub struct RGB<T> {
     pub r: T,
     pub g: T,
     pub b: T,
 }
 
-pub type DashboardPattern = [RGB<u8>; 3];
-pub type Pattern = [RGB<u8>; 60];
+const DASHBOARD_LIGHT_COUNT: usize = 3;
+
+pub type DashboardPattern = [RGB<I8F8>; DASHBOARD_LIGHT_COUNT];
+
+const BODY_LIGHT_COUNT: usize = 60;
+
+pub type BodyPattern = [RGB<I8F8>; BODY_LIGHT_COUNT];

bike-lights/simulator/src/main.rs

@@ -1,7 +1,10 @@
 use adw::prelude::*;
+use fixed::types::{I8F8, U128F0};
 use glib::{Object, Sender};
 use gtk::subclass::prelude::*;
-use lights_core::{App, DashboardPattern, Event, Pattern, FPS, RGB, UI};
+use lights_core::{
+    App, BodyPattern, DashboardPattern, Event, Instant, FPS, OFF_BODY, OFF_DASHBOARD, RGB, UI,
+};
 use std::{
     cell::RefCell,
     env,
@@ -14,7 +17,7 @@ const HEIGHT: i32 = 480;
 
 pub struct Update {
     dashboard: DashboardPattern,
-    lights: Pattern,
+    lights: BodyPattern,
 }
 
 pub struct DashboardLightsPrivate {
@@ -29,11 +32,7 @@ impl ObjectSubclass for DashboardLightsPrivate {
 
     fn new() -> Self {
         Self {
-            lights: Rc::new(RefCell::new([
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-            ])),
+            lights: Rc::new(RefCell::new(OFF_DASHBOARD)),
         }
     }
 }
@@ -60,9 +59,9 @@ impl DashboardLights {
                 let lights = s.imp().lights.borrow();
                 for i in 0..3 {
                     context.set_source_rgb(
-                        lights[i].r as f64 / 256.,
-                        lights[i].g as f64 / 256.,
-                        lights[i].b as f64 / 256.,
+                        lights[i].r.into(),
+                        lights[i].g.into(),
+                        lights[i].b.into(),
                     );
                     context.rectangle(start + 100. * i as f64, 10., 80., 80.);
                     let _ = context.fill();
@@ -73,14 +72,14 @@ impl DashboardLights {
         s
     }
 
-    pub fn set_lights(&self, lights: [RGB<u8>; 3]) {
+    pub fn set_lights(&self, lights: DashboardPattern) {
         *self.imp().lights.borrow_mut() = lights;
         self.queue_draw();
     }
 }
 
 pub struct BikeLightsPrivate {
-    lights: Rc<RefCell<Pattern>>,
+    lights: Rc<RefCell<BodyPattern>>,
 }
 
 #[glib::object_subclass]
@@ -91,68 +90,7 @@ impl ObjectSubclass for BikeLightsPrivate {
 
     fn new() -> Self {
         Self {
-            lights: Rc::new(RefCell::new([
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-                RGB { r: 0, g: 0, b: 0 },
-            ])),
+            lights: Rc::new(RefCell::new(OFF_BODY)),
         }
     }
 }
@@ -180,18 +118,18 @@ impl BikeLights {
                 let lights = s.imp().lights.borrow();
                 for i in 0..30 {
                     context.set_source_rgb(
-                        lights[i].r as f64 / 256.,
-                        lights[i].g as f64 / 256.,
-                        lights[i].b as f64 / 256.,
+                        lights[i].r.into(),
+                        lights[i].g.into(),
+                        lights[i].b.into(),
                     );
                     context.rectangle(center - 45., 5. + 20. * i as f64, 15., 15.);
                     let _ = context.fill();
                 }
                 for i in 0..30 {
                     context.set_source_rgb(
-                        lights[i + 30].r as f64 / 256.,
-                        lights[i + 30].g as f64 / 256.,
-                        lights[i + 30].b as f64 / 256.,
+                        lights[i + 30].r.into(),
+                        lights[i + 30].g.into(),
+                        lights[i + 30].b.into(),
                     );
                     context.rectangle(center + 15., 5. + 20. * (30. - (i + 1) as f64), 15., 15.);
                     let _ = context.fill();
@@ -202,7 +140,7 @@ impl BikeLights {
         s
     }
 
-    pub fn set_lights(&self, lights: [RGB<u8>; 60]) {
+    pub fn set_lights(&self, lights: [RGB<I8F8>; 60]) {
         *self.imp().lights.borrow_mut() = lights;
         self.queue_draw();
     }
@@ -222,7 +160,7 @@ impl UI for GTKUI {
         }
     }
 
-    fn update_lights(&self, dashboard_lights: DashboardPattern, lights: Pattern) {
+    fn update_lights(&self, dashboard_lights: DashboardPattern, lights: BodyPattern) {
         self.tx
             .send(Update {
                 dashboard: dashboard_lights,
@@ -248,7 +186,12 @@ fn main() {
                 rx: event_rx,
             }));
             loop {
-                bike_app.tick(std::time::Instant::now());
+                bike_app.tick(Instant(U128F0::from(
+                    std::time::SystemTime::now()
+                        .duration_since(std::time::UNIX_EPOCH)
+                        .unwrap()
+                        .as_millis(),
+                )));
                 std::thread::sleep(std::time::Duration::from_millis(1000 / (FPS as u64)));
             }
         });