Refactor for [email protected]

Author: niclashoyer

.circleci/config.yml

@@ -2,7 +2,7 @@ version: 2
 jobs:
   build:
     docker:
-      - image: rust:1.35
+      - image: rust:1.46
     steps:
       - checkout
 

Cargo.toml

@@ -21,7 +21,7 @@ edition = "2021"
 rust-version = "1.60"
 
 [dependencies]
-embedded-hal = "=1.0.0-alpha.4"
+embedded-hal = "=1.0.0-alpha.6"
 embedded-time = { version = "0.12", optional = true }
 void = { version = "^1.0", optional = true }
 nb = "0.1.1"

README.md

@@ -67,7 +67,7 @@ embedded-hal = { git = "https://github.com/rust-embedded/embedded-hal" }
 
 # Minimum Supported Rust Version (MSRV)
 
-This crate is guaranteed to compile on stable Rust 1.35 and up. It *might*
+This crate is guaranteed to compile on stable Rust 1.46.0 and up. It *might*
 compile with older versions but that may change in any new patch release.
 
 

src/adc.rs

@@ -3,7 +3,7 @@
 //! ## Usage
 //!
 //! ```
-//! use embedded_hal::adc::OneShot;
+//! use embedded_hal::adc::nb::OneShot;
 //! use embedded_hal_mock::adc::Mock;
 //! use embedded_hal_mock::adc::Transaction;
 //! use embedded_hal_mock::adc::{MockChan0, MockChan1};
@@ -28,7 +28,7 @@
 //! Attach an error to test error handling. An error is returned when such a transaction is executed.
 //!
 //! ```
-//! use embedded_hal::adc::OneShot;
+//! use embedded_hal::adc::nb::OneShot;
 //! use embedded_hal_mock::adc::Mock;
 //! use embedded_hal_mock::adc::Transaction;
 //! use embedded_hal_mock::adc::MockChan1;
@@ -49,8 +49,8 @@
 //! adc.done();
 //! ```
 
-use embedded_hal::adc::Channel;
-use embedded_hal::adc::OneShot;
+use embedded_hal::adc::nb::Channel;
+use embedded_hal::adc::nb::OneShot;
 use nb;
 use std::fmt::Debug;
 
@@ -100,7 +100,7 @@ macro_rules! mock_channel {
             impl Channel<$ADC> for $pin {
                 type ID = u8;
 
-                fn channel() -> u8 { $chan }
+                fn channel(&self) -> u8 { $chan }
             }
         )+
     };
@@ -126,9 +126,9 @@ where
 {
     type Error = MockError;
 
-    fn read(&mut self, _pin: &mut Pin) -> nb::Result<T, Self::Error> {
+    fn read(&mut self, pin: &mut Pin) -> nb::Result<T, Self::Error> {
         let w = self.next().expect("unexpected read call");
-        assert_eq!(w.expected_chan, Pin::channel(), "unexpected channel");
+        assert_eq!(w.expected_chan, pin.channel(), "unexpected channel");
         match w.err {
             Some(e) => Err(nb::Error::Other(e)),
             None => Ok(w.response),
@@ -138,7 +138,7 @@ where
 
 #[cfg(test)]
 mod test {
-    use embedded_hal::adc::OneShot;
+    use embedded_hal::adc::nb::OneShot;
 
     use crate::adc::{Mock, MockChan0, MockChan1, MockChan2, Transaction};
     use crate::MockError;

src/delay.rs

@@ -16,7 +16,7 @@ use core::convert::Infallible;
 use std::thread;
 use std::time::Duration;
 
-use embedded_hal::blocking::delay;
+use embedded_hal::delay::blocking as delay;
 
 /// A `Delay` implementation that does not actually block.
 pub struct NoopDelay;
@@ -34,42 +34,15 @@ impl Default for NoopDelay {
     }
 }
 
-macro_rules! impl_noop_delay_us {
-    ($type:ty) => {
-        impl delay::DelayUs<$type> for NoopDelay {
-            type Error = Infallible;
+impl delay::DelayUs for NoopDelay {
+    type Error = Infallible;
 
-            /// A no-op delay implementation.
-            fn try_delay_us(&mut self, _n: $type) -> Result<(), Self::Error> {
-                Ok(())
-            }
-        }
-    };
-}
-
-impl_noop_delay_us!(u8);
-impl_noop_delay_us!(u16);
-impl_noop_delay_us!(u32);
-impl_noop_delay_us!(u64);
-
-macro_rules! impl_noop_delay_ms {
-    ($type:ty) => {
-        impl delay::DelayMs<$type> for NoopDelay {
-            type Error = Infallible;
-
-            /// A no-op delay implementation.
-            fn try_delay_ms(&mut self, _n: $type) -> Result<(), Self::Error> {
-                Ok(())
-            }
-        }
-    };
+    /// A no-op delay implementation.
+    fn delay_us(&mut self, _n: u32) -> Result<(), Self::Error> {
+        Ok(())
+    }
 }
 
-impl_noop_delay_ms!(u8);
-impl_noop_delay_ms!(u16);
-impl_noop_delay_ms!(u32);
-impl_noop_delay_ms!(u64);
-
 /// A `Delay` implementation that uses `std::thread::sleep`.
 pub struct StdSleep;
 
@@ -86,40 +59,12 @@ impl Default for StdSleep {
     }
 }
 
-macro_rules! impl_stdsleep_delay_us {
-    ($type:ty) => {
-        impl delay::DelayUs<$type> for StdSleep {
-            type Error = Infallible;
+impl delay::DelayUs for StdSleep {
+    type Error = Infallible;
 
-            /// A `Delay` implementation that uses `std::thread::sleep`.
-            fn try_delay_us(&mut self, n: $type) -> Result<(), Self::Error> {
-                thread::sleep(Duration::from_micros(n as u64));
-                Ok(())
-            }
-        }
-    };
-}
-
-impl_stdsleep_delay_us!(u8);
-impl_stdsleep_delay_us!(u16);
-impl_stdsleep_delay_us!(u32);
-impl_stdsleep_delay_us!(u64);
-
-macro_rules! impl_stdsleep_delay_ms {
-    ($type:ty) => {
-        impl delay::DelayMs<$type> for StdSleep {
-            type Error = Infallible;
-
-            /// A `Delay` implementation that uses `std::thread::sleep`.
-            fn try_delay_ms(&mut self, n: $type) -> Result<(), Self::Error> {
-                thread::sleep(Duration::from_millis(n as u64));
-                Ok(())
-            }
-        }
-    };
+    /// A `Delay` implementation that uses `std::thread::sleep`.
+    fn delay_us(&mut self, n: u32) -> Result<(), Self::Error> {
+        thread::sleep(Duration::from_micros(n as u64));
+        Ok(())
+    }
 }
-
-impl_stdsleep_delay_ms!(u8);
-impl_stdsleep_delay_ms!(u16);
-impl_stdsleep_delay_ms!(u32);
-impl_stdsleep_delay_ms!(u64);