Impliment Wait from embedded-hal-async

ryankurte · Jan 28, 2025 · 653e88f · 653e88f
1 parent 89aba1c
commit 653e88f
Show file tree

Hide file tree

Showing 2 changed files with 101 additions and 0 deletions.
diff --git a/Cargo.toml b/Cargo.toml
@@ -27,6 +27,9 @@ features = [ "unproven" ]
 package = "embedded-hal"
 version = "1.0.0"
 
+[dependencies.eh1_0_async]
+package = "embedded-hal-async"
+version = "1.0.0"
 
 [package.metadata.docs.rs]
 # To build locally:

diff --git a/src/forward.rs b/src/forward.rs
@@ -98,6 +98,38 @@ mod digital {
         }
     }
 
+    impl<T, E> eh1_0_async::digital::Wait for Forward<T, ForwardInputPin>
+    where
+        T: eh0_2::digital::v2::InputPin<Error = E> + eh1_0_async::digital::Wait<Error = E>,
+        E: core::fmt::Debug,
+    {
+        async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
+            self.inner.wait_for_high().await.map_err(ForwardError)
+        }
+
+        async fn wait_for_low(&mut self) -> Result<(), Self::Error> {
+            self.inner.wait_for_low().await.map_err(ForwardError)
+        }
+
+        async fn wait_for_rising_edge(&mut self) -> Result<(), Self::Error> {
+            self.inner
+                .wait_for_rising_edge()
+                .await
+                .map_err(ForwardError)
+        }
+
+        async fn wait_for_falling_edge(&mut self) -> Result<(), Self::Error> {
+            self.inner
+                .wait_for_falling_edge()
+                .await
+                .map_err(ForwardError)
+        }
+
+        async fn wait_for_any_edge(&mut self) -> Result<(), Self::Error> {
+            self.inner.wait_for_any_edge().await.map_err(ForwardError)
+        }
+    }
+
     impl<T, E> eh1_0::digital::ErrorType for Forward<T, ForwardOutputPin>
     where
         T: eh0_2::digital::v2::OutputPin<Error = E>,
@@ -122,6 +154,38 @@ mod digital {
         }
     }
 
+    impl<T, E> eh1_0_async::digital::Wait for Forward<T, ForwardOutputPin>
+    where
+        T: eh0_2::digital::v2::OutputPin<Error = E> + eh1_0_async::digital::Wait<Error = E>,
+        E: core::fmt::Debug,
+    {
+        async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
+            self.inner.wait_for_high().await.map_err(ForwardError)
+        }
+
+        async fn wait_for_low(&mut self) -> Result<(), Self::Error> {
+            self.inner.wait_for_low().await.map_err(ForwardError)
+        }
+
+        async fn wait_for_rising_edge(&mut self) -> Result<(), Self::Error> {
+            self.inner
+                .wait_for_rising_edge()
+                .await
+                .map_err(ForwardError)
+        }
+
+        async fn wait_for_falling_edge(&mut self) -> Result<(), Self::Error> {
+            self.inner
+                .wait_for_falling_edge()
+                .await
+                .map_err(ForwardError)
+        }
+
+        async fn wait_for_any_edge(&mut self) -> Result<(), Self::Error> {
+            self.inner.wait_for_any_edge().await.map_err(ForwardError)
+        }
+    }
+
     impl<T, E> eh1_0::digital::ErrorType for Forward<T, ForwardIoPin>
     where
         T: eh0_2::digital::v2::OutputPin<Error = E> + eh0_2::digital::v2::InputPin<Error = E>,
@@ -161,6 +225,40 @@ mod digital {
             self.inner.set_low().map_err(ForwardError)
         }
     }
+
+    impl<T, E> eh1_0_async::digital::Wait for Forward<T, ForwardIoPin>
+    where
+        T: eh0_2::digital::v2::InputPin<Error = E>
+            + eh0_2::digital::v2::OutputPin<Error = E>
+            + eh1_0_async::digital::Wait<Error = E>,
+        E: core::fmt::Debug,
+    {
+        async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
+            self.inner.wait_for_high().await.map_err(ForwardError)
+        }
+
+        async fn wait_for_low(&mut self) -> Result<(), Self::Error> {
+            self.inner.wait_for_low().await.map_err(ForwardError)
+        }
+
+        async fn wait_for_rising_edge(&mut self) -> Result<(), Self::Error> {
+            self.inner
+                .wait_for_rising_edge()
+                .await
+                .map_err(ForwardError)
+        }
+
+        async fn wait_for_falling_edge(&mut self) -> Result<(), Self::Error> {
+            self.inner
+                .wait_for_falling_edge()
+                .await
+                .map_err(ForwardError)
+        }
+
+        async fn wait_for_any_edge(&mut self) -> Result<(), Self::Error> {
+            self.inner.wait_for_any_edge().await.map_err(ForwardError)
+        }
+    }
 }
 
 /// Delays (blocking)