From 8c23e178f3838bcdd13662a2ffefd39ec144e869 Mon Sep 17 00:00:00 2001
From: Finomnis <Finomnis@users.noreply.github.com>
Date: Thu, 11 Apr 2024 00:00:38 +0200
Subject: Monotonic rewrite (#874)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Rework timer_queue and monotonic architecture

Goals:
 * make Monotonic purely internal
 * make Monotonic purely tick passed, no fugit involved
 * create a wrapper struct in the user's code via a macro that then
   converts the "now" from the tick based monotonic to a fugit based
   timestamp

We need to proxy the delay functions of the timer queue anyway,
so we could simply perform the conversion in those proxy functions.

* Update cargo.lock

* Update readme of rtic-time

* CI: ESP32: Redact esp_image: Too volatile

* Fixup: Changelog double entry rebase mistake

---------

Co-authored-by: Henrik Tjäder <henrik@tjaders.com>
---
 rtic-time/src/monotonic/embedded_hal_macros.rs | 77 ++++++++++++++++++++++++++
 1 file changed, 77 insertions(+)
 create mode 100644 rtic-time/src/monotonic/embedded_hal_macros.rs

(limited to 'rtic-time/src/monotonic/embedded_hal_macros.rs')

diff --git a/rtic-time/src/monotonic/embedded_hal_macros.rs b/rtic-time/src/monotonic/embedded_hal_macros.rs
new file mode 100644
index 0000000..25ac791
--- /dev/null
+++ b/rtic-time/src/monotonic/embedded_hal_macros.rs
@@ -0,0 +1,77 @@
+//! Macros that implement embedded-hal traits for Monotonics
+
+/// Implements [`embedded_hal::delay::DelayNs`] for a given monotonic.
+#[macro_export]
+macro_rules! impl_embedded_hal_delay_fugit {
+    ($t:ty) => {
+        impl $crate::embedded_hal::delay::DelayNs for $t {
+            fn delay_ns(&mut self, ns: u32) {
+                let now = <Self as $crate::Monotonic>::now();
+                let mut done =
+                    now + <Self as $crate::Monotonic>::Duration::nanos_at_least(ns.into());
+                if now != done {
+                    // Compensate for sub-tick uncertainty
+                    done = done + <Self as $crate::Monotonic>::Duration::from_ticks(1);
+                }
+
+                while <Self as $crate::Monotonic>::now() < done {}
+            }
+
+            fn delay_us(&mut self, us: u32) {
+                let now = <Self as $crate::Monotonic>::now();
+                let mut done =
+                    now + <Self as $crate::Monotonic>::Duration::micros_at_least(us.into());
+                if now != done {
+                    // Compensate for sub-tick uncertainty
+                    done = done + <Self as $crate::Monotonic>::Duration::from_ticks(1);
+                }
+
+                while <Self as $crate::Monotonic>::now() < done {}
+            }
+
+            fn delay_ms(&mut self, ms: u32) {
+                let now = <Self as $crate::Monotonic>::now();
+                let mut done =
+                    now + <Self as $crate::Monotonic>::Duration::millis_at_least(ms.into());
+                if now != done {
+                    // Compensate for sub-tick uncertainty
+                    done = done + <Self as $crate::Monotonic>::Duration::from_ticks(1);
+                }
+
+                while <Self as $crate::Monotonic>::now() < done {}
+            }
+        }
+    };
+}
+
+/// Implements [`embedded_hal_async::delay::DelayNs`] for a given monotonic.
+#[macro_export]
+macro_rules! impl_embedded_hal_async_delay_fugit {
+    ($t:ty) => {
+        impl $crate::embedded_hal_async::delay::DelayNs for $t {
+            #[inline]
+            async fn delay_ns(&mut self, ns: u32) {
+                <Self as $crate::Monotonic>::delay(
+                    <Self as $crate::Monotonic>::Duration::nanos_at_least(ns.into()),
+                )
+                .await;
+            }
+
+            #[inline]
+            async fn delay_us(&mut self, us: u32) {
+                <Self as $crate::Monotonic>::delay(
+                    <Self as $crate::Monotonic>::Duration::micros_at_least(us.into()),
+                )
+                .await;
+            }
+
+            #[inline]
+            async fn delay_ms(&mut self, ms: u32) {
+                <Self as $crate::Monotonic>::delay(
+                    <Self as $crate::Monotonic>::Duration::millis_at_least(ms.into()),
+                )
+                .await;
+            }
+        }
+    };
+}
-- 
cgit v1.2.3