Switch futures::Delay to take core::time::Duration and add futures::digital docs

Author: lachlansneff

src/futures/delay.rs

@@ -5,7 +5,7 @@
 //! The `Delay` trait provides an asynchronous delay abstraction and it's meant to be used either
 //! to build higher-level abstractions like I/O timeouts or by itself.
 
-use core::future::Future;
+use core::{future::Future, time::Duration};
 
 /// Asynchronously wait a duration of time.
 pub trait Delay {
@@ -17,11 +17,8 @@ pub trait Delay {
     where
         Self: 'a;
 
-    /// The unit of time used by this delay timer.
-    type Time;
-
     /// Returns a future that will resolve when `duration` has passed.
     /// It is not guaranteed that _exactly_ `duration` will pass, but it will
     /// be `duration` or longer.
-    fn delay<'a>(&mut self, duration: impl Into<Self::Time>) -> Self::DelayFuture<'a>;
+    fn delay<'a>(&mut self, duration: Duration) -> Self::DelayFuture<'a>;
 }

src/futures/digital.rs

@@ -2,8 +2,40 @@
 
 use core::future::Future;
 
+use crate::blocking::digital::InputPin;
+
 /// Asynchronously wait for a pin to become high or low.
-pub trait AsyncInputPin {
+///
+/// # Examples
+/// ```rust
+/// # use embedded_hal::futures::digital::AsyncInputPin;
+/// /// Asynchronously wait until the `ready_pin` becomes high.
+/// async fn wait_until_ready<P>(ready_pin: &P)
+/// where
+///     P: AsyncInputPin,
+/// {
+///     ready_pin.until_high().await
+/// }
+/// ```
+///
+/// ```rust,ignore
+/// # use embedded_hal::futures::digital::AsyncInputPin;
+/// # use embedded_hal::futures::delay::Delay;
+/// # use core::time::Duration;
+/// /// Wait until the `ready_pin` is high or timeout after 1 millisecond.
+/// /// Returns true is the pin became high or false if it timed-out.
+/// async fn wait_until_ready_or_timeout<P, D>(ready_pin: &P, delay: &mut D) -> bool
+/// where
+///     P: AsyncInputPin,
+///     D: Delay,
+/// {
+///     futures::select_biased! {
+///         _ => ready_pin.until_high() => true,
+///         _ => delay.delay(Duration::from_millis(1)) => false,
+///     }
+/// }
+/// ```
+pub trait AsyncInputPin: InputPin {
     /// The future returned by the `until_high` function.
     type UntilHighFuture<'a>: Future<Output=()> + 'a;