embedded-hal: 0.2 -> 1

Author: newAM

CHANGELOG.md

@@ -8,6 +8,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 - Added re-exports for `libftd2xx` and `ftdi` when the respective feature is used.
 
+### Changed
+- Updated `embedded-hal` from `0.2.4` to `1.0.0`.
+
 ## [0.11.0] - 2022-01-18
 ### Added
 - Added support for input pins.

Cargo.toml

@@ -17,7 +17,7 @@ default = []
 
 [dependencies]
 nb = "^1"
-embedded-hal = { version = "~0.2.4", features = ["unproven"] }
+embedded-hal = "1.0.0-alpha.8"
 ftdi-mpsse = "^0.1"
 libftd2xx = { version = "0.32.0", optional = true }
 ftdi = { version = "0.1.3", optional = true }

src/delay.rs

@@ -31,23 +31,16 @@ impl Default for Delay {
     }
 }
 
-macro_rules! impl_delay_for {
-    ($UXX:ty) => {
-        impl embedded_hal::blocking::delay::DelayMs<$UXX> for Delay {
-            fn delay_ms(&mut self, ms: $UXX) {
-                std::thread::sleep(std::time::Duration::from_millis(ms.into()))
-            }
-        }
+impl embedded_hal::delay::blocking::DelayUs for Delay {
+    type Error = std::convert::Infallible;
 
-        impl embedded_hal::blocking::delay::DelayUs<$UXX> for Delay {
-            fn delay_us(&mut self, us: $UXX) {
-                std::thread::sleep(std::time::Duration::from_micros(us.into()))
-            }
-        }
-    };
-}
+    fn delay_us(&mut self, us: u32) -> Result<(), Self::Error> {
+        std::thread::sleep(std::time::Duration::from_micros(us.into()));
+        Ok(())
+    }
 
-impl_delay_for!(u8);
-impl_delay_for!(u16);
-impl_delay_for!(u32);
-impl_delay_for!(u64);
+    fn delay_ms(&mut self, ms: u32) -> Result<(), Self::Error> {
+        std::thread::sleep(std::time::Duration::from_millis(ms.into()));
+        Ok(())
+    }
+}

src/gpio.rs

@@ -1,8 +1,8 @@
 use crate::error::Error;
 use crate::{FtInner, PinUse};
 use ftdi_mpsse::{MpsseCmdBuilder, MpsseCmdExecutor};
-use std::result::Result;
-use std::{cell::RefCell, sync::Mutex};
+use std::borrow::BorrowMut;
+use std::sync::{Arc, Mutex};
 
 /// FTDI output pin.
 ///
@@ -13,7 +13,7 @@ use std::{cell::RefCell, sync::Mutex};
 #[derive(Debug)]
 pub struct OutputPin<'a, Device: MpsseCmdExecutor> {
     /// Parent FTDI device.
-    mtx: &'a Mutex<RefCell<FtInner<Device>>>,
+    mtx: &'a Arc<Mutex<FtInner<Device>>>,
     /// GPIO pin index.  0-7 for the FT232H.
     idx: u8,
 }
@@ -25,11 +25,11 @@ where
     Error<E>: From<E>,
 {
     pub(crate) fn new(
-        mtx: &'a Mutex<RefCell<FtInner<Device>>>,
+        mtx: &'a Arc<Mutex<FtInner<Device>>>,
         idx: u8,
     ) -> Result<OutputPin<'a, Device>, Error<E>> {
-        let lock = mtx.lock().expect("Failed to aquire FTDI mutex");
-        let mut inner = lock.borrow_mut();
+        let mut lock = mtx.lock().expect("Failed to aquire FTDI mutex");
+        let inner = lock.borrow_mut();
         inner.direction |= 1 << idx;
         inner.allocate_pin(idx, PinUse::Output);
         let cmd: MpsseCmdBuilder = MpsseCmdBuilder::new()
@@ -40,8 +40,8 @@ where
     }
 
     pub(crate) fn set(&self, state: bool) -> Result<(), Error<E>> {
-        let lock = self.mtx.lock().expect("Failed to aquire FTDI mutex");
-        let mut inner = lock.borrow_mut();
+        let mut lock = self.mtx.lock().expect("Failed to aquire FTDI mutex");
+        let inner = lock.borrow_mut();
 
         if state {
             inner.value |= self.mask();
@@ -65,14 +65,21 @@ impl<'a, Device: MpsseCmdExecutor> OutputPin<'a, Device> {
     }
 }
 
-impl<'a, Device, E> embedded_hal::digital::v2::OutputPin for OutputPin<'a, Device>
+impl<'a, Device, E> embedded_hal::digital::ErrorType for OutputPin<'a, Device>
 where
     Device: MpsseCmdExecutor<Error = E>,
     E: std::error::Error,
     Error<E>: From<E>,
 {
     type Error = Error<E>;
+}
 
+impl<'a, Device, E> embedded_hal::digital::blocking::OutputPin for OutputPin<'a, Device>
+where
+    Device: MpsseCmdExecutor<Error = E>,
+    E: std::error::Error,
+    Error<E>: From<E>,
+{
     fn set_low(&mut self) -> Result<(), Error<E>> {
         self.set(false)
     }
@@ -91,7 +98,7 @@ where
 #[derive(Debug)]
 pub struct InputPin<'a, Device: MpsseCmdExecutor> {
     /// Parent FTDI device.
-    mtx: &'a Mutex<RefCell<FtInner<Device>>>,
+    mtx: &'a Arc<Mutex<FtInner<Device>>>,
     /// GPIO pin index.  0-7 for the FT232H.
     idx: u8,
 }
@@ -103,11 +110,11 @@ where
     Error<E>: From<E>,
 {
     pub(crate) fn new(
-        mtx: &'a Mutex<RefCell<FtInner<Device>>>,
+        mtx: &'a Arc<Mutex<FtInner<Device>>>,
         idx: u8,
     ) -> Result<InputPin<'a, Device>, Error<E>> {
-        let lock = mtx.lock().expect("Failed to aquire FTDI mutex");
-        let mut inner = lock.borrow_mut();
+        let mut lock = mtx.lock().expect("Failed to aquire FTDI mutex");
+        let inner = lock.borrow_mut();
         inner.direction &= !(1 << idx);
         inner.allocate_pin(idx, PinUse::Input);
         let cmd: MpsseCmdBuilder = MpsseCmdBuilder::new()
@@ -118,8 +125,8 @@ where
     }
 
     pub(crate) fn get(&self) -> Result<bool, Error<E>> {
-        let lock = self.mtx.lock().expect("Failed to aquire FTDI mutex");
-        let mut inner = lock.borrow_mut();
+        let mut lock = self.mtx.lock().expect("Failed to aquire FTDI mutex");
+        let inner = lock.borrow_mut();
 
         let mut buffer = [0u8; 1];
         let cmd: MpsseCmdBuilder = MpsseCmdBuilder::new().gpio_lower().send_immediate();
@@ -137,14 +144,21 @@ impl<'a, Device: MpsseCmdExecutor> InputPin<'a, Device> {
     }
 }
 
-impl<'a, Device, E> embedded_hal::digital::v2::InputPin for InputPin<'a, Device>
+impl<'a, Device, E> embedded_hal::digital::ErrorType for InputPin<'a, Device>
 where
     Device: MpsseCmdExecutor<Error = E>,
     E: std::error::Error,
     Error<E>: From<E>,
 {
     type Error = Error<E>;
+}
 
+impl<'a, Device, E> embedded_hal::digital::blocking::InputPin for InputPin<'a, Device>
+where
+    Device: MpsseCmdExecutor<Error = E>,
+    E: std::error::Error,
+    Error<E>: From<E>,
+{
     fn is_high(&self) -> Result<bool, Self::Error> {
         self.get()
     }

src/i2c.rs

@@ -2,8 +2,8 @@ use crate::error::Error;
 use crate::error::ErrorKind::I2cNoAck;
 use crate::{FtInner, PinUse};
 use ftdi_mpsse::{ClockBitsIn, ClockBitsOut, MpsseCmdBuilder, MpsseCmdExecutor};
-use std::result::Result;
-use std::{cell::RefCell, sync::Mutex};
+use std::borrow::BorrowMut;
+use std::sync::{Arc, Mutex};
 
 /// SCL bitmask
 const SCL: u8 = 1 << 0;
@@ -21,7 +21,7 @@ const BITS_OUT: ClockBitsOut = ClockBitsOut::MsbNeg;
 #[derive(Debug)]
 pub struct I2c<'a, Device: MpsseCmdExecutor> {
     /// Parent FTDI device.
-    mtx: &'a Mutex<RefCell<FtInner<Device>>>,
+    mtx: &'a Arc<Mutex<FtInner<Device>>>,
     /// Length of the start, repeated start, and stop conditions.
     ///
     /// The units for these are dimensionless number of MPSSE commands.
@@ -37,9 +37,9 @@ where
     E: std::error::Error,
     Error<E>: From<E>,
 {
-    pub(crate) fn new(mtx: &Mutex<RefCell<FtInner<Device>>>) -> Result<I2c<Device>, Error<E>> {
-        let lock = mtx.lock().expect("Failed to aquire FTDI mutex");
-        let mut inner = lock.borrow_mut();
+    pub(crate) fn new(mtx: &Arc<Mutex<FtInner<Device>>>) -> Result<I2c<Device>, Error<E>> {
+        let mut lock = mtx.lock().expect("Failed to aquire FTDI mutex");
+        let inner = lock.borrow_mut();
         inner.allocate_pin(0, PinUse::I2c);
         inner.allocate_pin(1, PinUse::I2c);
         inner.allocate_pin(2, PinUse::I2c);
@@ -127,8 +127,8 @@ where
     fn read_fast(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), Error<E>> {
         assert!(!buffer.is_empty(), "buffer must be a non-empty slice");
 
-        let lock = self.mtx.lock().expect("Failed to aquire FTDI mutex");
-        let mut inner = lock.borrow_mut();
+        let mut lock = self.mtx.lock().expect("Failed to aquire FTDI mutex");
+        let inner = lock.borrow_mut();
 
         // ST
         let mut mpsse_cmd: MpsseCmdBuilder = MpsseCmdBuilder::new();
@@ -198,8 +198,8 @@ where
     fn read_slow(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), Error<E>> {
         assert!(!buffer.is_empty(), "buffer must be a non-empty slice");
 
-        let lock = self.mtx.lock().expect("Failed to aquire FTDI mutex");
-        let mut inner = lock.borrow_mut();
+        let mut lock = self.mtx.lock().expect("Failed to aquire FTDI mutex");
+        let inner = lock.borrow_mut();
 
         // ST
         let mut mpsse_cmd: MpsseCmdBuilder = MpsseCmdBuilder::new();
@@ -272,8 +272,8 @@ where
     fn write_fast(&mut self, addr: u8, bytes: &[u8]) -> Result<(), Error<E>> {
         assert!(!bytes.is_empty(), "bytes must be a non-empty slice");
 
-        let lock = self.mtx.lock().expect("Failed to aquire FTDI mutex");
-        let mut inner = lock.borrow_mut();
+        let mut lock = self.mtx.lock().expect("Failed to aquire FTDI mutex");
+        let inner = lock.borrow_mut();
         let mut mpsse_cmd: MpsseCmdBuilder = MpsseCmdBuilder::new();
 
         // ST
@@ -333,8 +333,8 @@ where
     fn write_slow(&mut self, addr: u8, bytes: &[u8]) -> Result<(), Error<E>> {
         assert!(!bytes.is_empty(), "bytes must be a non-empty slice");
 
-        let lock = self.mtx.lock().expect("Failed to aquire FTDI mutex");
-        let mut inner = lock.borrow_mut();
+        let mut lock = self.mtx.lock().expect("Failed to aquire FTDI mutex");
+        let inner = lock.borrow_mut();
 
         // ST
         let mut mpsse_cmd: MpsseCmdBuilder = MpsseCmdBuilder::new();
@@ -414,8 +414,8 @@ where
 
         // lock at the start to prevent GPIO from being modified while we build
         // the MPSSE command
-        let lock = self.mtx.lock().expect("Failed to aquire FTDI mutex");
-        let mut inner = lock.borrow_mut();
+        let mut lock = self.mtx.lock().expect("Failed to aquire FTDI mutex");
+        let inner = lock.borrow_mut();
 
         let mut mpsse_cmd: MpsseCmdBuilder = MpsseCmdBuilder::new();
 
@@ -522,8 +522,8 @@ where
 
         // lock at the start to prevent GPIO from being modified while we build
         // the MPSSE command
-        let lock = self.mtx.lock().expect("Failed to aquire FTDI mutex");
-        let mut inner = lock.borrow_mut();
+        let mut lock = self.mtx.lock().expect("Failed to aquire FTDI mutex");
+        let inner = lock.borrow_mut();
 
         // ST
         let mut mpsse_cmd: MpsseCmdBuilder = MpsseCmdBuilder::new();