Update embedded-hal dependency to 1.0.0-alpha.7

Author: ahmedcharles

Cargo.toml

@@ -10,7 +10,7 @@ license = "ISC"
 edition = "2018"
 
 [dependencies]
-embedded-hal = "=1.0.0-alpha.1"
+embedded-hal = "=1.0.0-alpha.7"
 nb = "1.0.0"
 riscv = "0.7.0"
 e310x = { version = "0.9.0", features = ["rt"] }

src/delay.rs

@@ -3,7 +3,7 @@
 use crate::clock::Clocks;
 use crate::core::clint::{MTIME, MTIMECMP};
 use core::convert::Infallible;
-use embedded_hal::blocking::delay::{DelayMs, DelayUs};
+use embedded_hal::delay::blocking::DelayUs;
 use riscv::register::{mie, mip};
 
 /// Machine timer (mtime) as a busyloop delay provider
@@ -18,10 +18,10 @@ impl Delay {
     }
 }
 
-impl DelayUs<u32> for Delay {
+impl DelayUs for Delay {
     type Error = Infallible;
 
-    fn try_delay_us(&mut self, us: u32) -> Result<(), Infallible> {
+    fn delay_us(&mut self, us: u32) -> Result<(), Infallible> {
         let ticks = (us as u64) * TICKS_PER_SECOND / 1_000_000;
 
         let mtime = MTIME;
@@ -31,72 +31,6 @@ impl DelayUs<u32> for Delay {
     }
 }
 
-// This is a workaround to allow `delay_us(42)` construction without specifying a type.
-impl DelayUs<i32> for Delay {
-    type Error = Infallible;
-
-    #[inline(always)]
-    fn try_delay_us(&mut self, us: i32) -> Result<(), Infallible> {
-        assert!(us >= 0);
-        self.try_delay_us(us as u32)
-    }
-}
-
-impl DelayUs<u16> for Delay {
-    type Error = Infallible;
-
-    #[inline(always)]
-    fn try_delay_us(&mut self, us: u16) -> Result<(), Infallible> {
-        self.try_delay_us(u32::from(us))
-    }
-}
-
-impl DelayUs<u8> for Delay {
-    type Error = Infallible;
-
-    #[inline(always)]
-    fn try_delay_us(&mut self, us: u8) -> Result<(), Infallible> {
-        self.try_delay_us(u32::from(us))
-    }
-}
-
-impl DelayMs<u32> for Delay {
-    type Error = Infallible;
-
-    fn try_delay_ms(&mut self, ms: u32) -> Result<(), Infallible> {
-        self.try_delay_us(ms * 1000)
-    }
-}
-
-// This is a workaround to allow `delay_ms(42)` construction without specifying a type.
-impl DelayMs<i32> for Delay {
-    type Error = Infallible;
-
-    #[inline(always)]
-    fn try_delay_ms(&mut self, ms: i32) -> Result<(), Infallible> {
-        assert!(ms >= 0);
-        self.try_delay_ms(ms as u32)
-    }
-}
-
-impl DelayMs<u16> for Delay {
-    type Error = Infallible;
-
-    #[inline(always)]
-    fn try_delay_ms(&mut self, ms: u16) -> Result<(), Infallible> {
-        self.try_delay_ms(u32::from(ms))
-    }
-}
-
-impl DelayMs<u8> for Delay {
-    type Error = Infallible;
-
-    #[inline(always)]
-    fn try_delay_ms(&mut self, ms: u8) -> Result<(), Infallible> {
-        self.try_delay_ms(u32::from(ms))
-    }
-}
-
 /// Machine timer (mtime) as a sleep delay provider using mtimecmp
 pub struct Sleep {
     clock_freq: u32,
@@ -113,11 +47,11 @@ impl Sleep {
     }
 }
 
-impl DelayMs<u32> for Sleep {
+impl DelayUs for Sleep {
     type Error = Infallible;
 
-    fn try_delay_ms(&mut self, ms: u32) -> Result<(), Infallible> {
-        let ticks = (ms as u64) * (self.clock_freq as u64) / 1000;
+    fn delay_us(&mut self, us: u32) -> Result<(), Infallible> {
+        let ticks = (us as u64) * (self.clock_freq as u64) / 1_000_000;
         let t = MTIME.mtime() + ticks;
 
         self.mtimecmp.set_mtimecmp(t);
@@ -150,32 +84,3 @@ impl DelayMs<u32> for Sleep {
         Ok(())
     }
 }
-
-// This is a workaround to allow `delay_ms(42)` construction without specifying a type.
-impl DelayMs<i32> for Sleep {
-    type Error = Infallible;
-
-    #[inline(always)]
-    fn try_delay_ms(&mut self, ms: i32) -> Result<(), Infallible> {
-        assert!(ms >= 0);
-        self.try_delay_ms(ms as u32)
-    }
-}
-
-impl DelayMs<u16> for Sleep {
-    type Error = Infallible;
-
-    #[inline(always)]
-    fn try_delay_ms(&mut self, ms: u16) -> Result<(), Infallible> {
-        self.try_delay_ms(u32::from(ms))
-    }
-}
-
-impl DelayMs<u8> for Sleep {
-    type Error = Infallible;
-
-    #[inline(always)]
-    fn try_delay_ms(&mut self, ms: u8) -> Result<(), Infallible> {
-        self.try_delay_ms(u32::from(ms))
-    }
-}

src/gpio.rs

@@ -142,7 +142,8 @@ macro_rules! gpio {
             use core::marker::PhantomData;
             use core::convert::Infallible;
 
-            use embedded_hal::digital::{InputPin, OutputPin, StatefulOutputPin,
+            use embedded_hal::digital::ErrorType;
+            use embedded_hal::digital::blocking::{InputPin, OutputPin, StatefulOutputPin,
                                ToggleableOutputPin};
             use e310x::$GPIOX;
             use super::{Unknown, IOF0, IOF1, Drive, Floating, GpioExt, Input, Invert,
@@ -275,48 +276,50 @@ macro_rules! gpio {
                     }
                 }
 
-                impl<MODE> InputPin for $PXi<Input<MODE>> {
+                impl<MODE> ErrorType for $PXi<Input<MODE>> {
                     type Error = Infallible;
+                }
 
-                    fn try_is_high(&self) -> Result<bool, Infallible> {
+                impl<MODE> InputPin for $PXi<Input<MODE>> {
+                    fn is_high(&self) -> Result<bool, Infallible> {
                         Ok($GPIOX::input_value(Self::INDEX))
 
                     }
 
-                    fn try_is_low(&self) -> Result<bool, Infallible> {
-                        Ok(!self.try_is_high()?)
+                    fn is_low(&self) -> Result<bool, Infallible> {
+                        Ok(!self.is_high()?)
                     }
                 }
 
                 impl<MODE> StatefulOutputPin for $PXi<Output<MODE>> {
-                    fn try_is_set_high(&self) -> Result<bool, Infallible> {
+                    fn is_set_high(&self) -> Result<bool, Infallible> {
                         Ok($GPIOX::input_value(Self::INDEX))
                     }
 
-                    fn try_is_set_low(&self) -> Result<bool, Infallible> {
-                        Ok(!self.try_is_set_high()?)
+                    fn is_set_low(&self) -> Result<bool, Infallible> {
+                        Ok(!self.is_set_high()?)
                     }
                 }
 
-                impl<MODE> OutputPin for $PXi<Output<MODE>> {
+                impl<MODE> ErrorType for $PXi<Output<MODE>> {
                     type Error = Infallible;
+                }
 
-                    fn try_set_high(&mut self) -> Result<(), Infallible> {
+                impl<MODE> OutputPin for $PXi<Output<MODE>> {
+                    fn set_high(&mut self) -> Result<(), Infallible> {
                         $GPIOX::set_output_value(Self::INDEX, true);
                         Ok(())
                     }
 
-                    fn try_set_low(&mut self) -> Result<(), Infallible> {
+                    fn set_low(&mut self) -> Result<(), Infallible> {
                         $GPIOX::set_output_value(Self::INDEX, false);
                         Ok(())
                     }
                 }
 
                 impl<MODE> ToggleableOutputPin for $PXi<Output<MODE>> {
-                    type Error = Infallible;
-
                     /// Toggles the pin state.
-                    fn try_toggle(&mut self) -> Result<(), Infallible> {
+                    fn toggle(&mut self) -> Result<(), Infallible> {
                         $GPIOX::toggle_pin(Self::INDEX);
                         Ok(())
                     }