Merge #91

91: Update embedded-hal to 1.0.0-alpha.10 r=eldruin a=LehMaxence

I tested SPI and CDEV GPIO with hardware.
The major change is on the SPI protocol, but I could test i2c with hardware in a few days.

Co-authored-by: mlehurau <Max.Lehuraux@analog.com>

Author: bors[bot]

.github/bors.toml

@@ -4,5 +4,5 @@ required_approvals = 1
 status = [
   "CI (stable, x86_64-unknown-linux-gnu)",
   "CI (stable, armv7-unknown-linux-gnueabihf)",
-  "CI (1.54.0, x86_64-unknown-linux-gnu)",
+  "CI (1.60.0, x86_64-unknown-linux-gnu)",
 ]

.github/workflows/ci.yml

@@ -21,7 +21,7 @@ jobs:
 
         include:
           # Test MSRV
-          - rust: 1.54.0
+          - rust: 1.60.0
             TARGET: x86_64-unknown-linux-gnu
 
           # Test nightly but don't fail

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Changed
 - [breaking-change] Replace serial-rs with the serialport-rs crate. `Serial::open` now needs a baud-rate argument as well.
+- Updated to `embedded-hal` `1.0.0-alpha.10` release ([API changes](https://github.com/rust-embedded/embedded-hal/blob/master/embedded-hal/CHANGELOG.md#v100-alpha10---2023-04-04))
 
 ## [v0.4.0-alpha.3] - 2022-08-04
 

Cargo.toml

@@ -22,8 +22,8 @@ spi = ["spidev"]
 default = [ "gpio_cdev", "gpio_sysfs", "i2c", "spi" ]
 
 [dependencies]
-embedded-hal = "=1.0.0-alpha.9"
-embedded-hal-nb = "=1.0.0-alpha.1"
+embedded-hal = "=1.0.0-alpha.10"
+embedded-hal-nb = "=1.0.0-alpha.2"
 gpio-cdev = { version = "0.5.1", optional = true }
 sysfs_gpio = { version = "0.6.1", optional = true }
 i2cdev = { version = "0.5.1", optional = true }

README.md

@@ -29,7 +29,7 @@ With `default-features = false` you can enable the features `gpio_cdev`, `gpio_s
 
 ## Minimum Supported Rust Version (MSRV)
 
-This crate is guaranteed to compile on stable Rust 1.54.0 and up. It *might*
+This crate is guaranteed to compile on stable Rust 1.60.0 and up. It *might*
 compile with older versions but that may change in any new patch release.
 
 ## License

src/cdev_pin.rs

@@ -2,6 +2,8 @@
 //!
 //! [`embedded-hal`]: https://docs.rs/embedded-hal
 
+use std::fmt;
+
 /// Newtype around [`gpio_cdev::LineHandle`] that implements the `embedded-hal` traits
 ///
 /// [`gpio_cdev::LineHandle`]: https://docs.rs/gpio-cdev/0.5.0/gpio_cdev/struct.LineHandle.html
@@ -33,7 +35,7 @@ impl CdevPin {
         } else if self.1.is_open_source() {
             flags.insert(gpio_cdev::LineRequestFlags::OPEN_SOURCE);
         }
-        return flags;
+        flags
     }
 
     /// Set this pin to input mode
@@ -94,34 +96,79 @@ fn state_to_value(state: embedded_hal::digital::PinState, is_active_low: bool) -
     }
 }
 
+/// Error type wrapping [gpio_cdev::errors::Error](gpio_cdev::errors::Error) to implement [embedded_hal::digital::Error]
+#[derive(Debug)]
+pub struct CdevPinError {
+    err: gpio_cdev::errors::Error,
+}
+
+impl CdevPinError {
+    /// Fetch inner (concrete) [`gpio_cdev::errors::Error`]
+    pub fn inner(&self) -> &gpio_cdev::errors::Error {
+        &self.err
+    }
+}
+
+impl From<gpio_cdev::errors::Error> for CdevPinError {
+    fn from(err: gpio_cdev::errors::Error) -> Self {
+        Self { err }
+    }
+}
+
+impl fmt::Display for CdevPinError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.err)
+    }
+}
+
+impl std::error::Error for CdevPinError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        Some(&self.err)
+    }
+}
+
+impl embedded_hal::digital::Error for CdevPinError {
+    fn kind(&self) -> embedded_hal::digital::ErrorKind {
+        use embedded_hal::digital::ErrorKind;
+        ErrorKind::Other
+    }
+}
+
 impl embedded_hal::digital::ErrorType for CdevPin {
-    type Error = gpio_cdev::errors::Error;
+    type Error = CdevPinError;
 }
 
 impl embedded_hal::digital::OutputPin for CdevPin {
     fn set_low(&mut self) -> Result<(), Self::Error> {
-        self.0.set_value(state_to_value(
-            embedded_hal::digital::PinState::Low,
-            self.1.is_active_low(),
-        ))
+        self.0
+            .set_value(state_to_value(
+                embedded_hal::digital::PinState::Low,
+                self.1.is_active_low(),
+            ))
+            .map_err(CdevPinError::from)
     }
 
     fn set_high(&mut self) -> Result<(), Self::Error> {
-        self.0.set_value(state_to_value(
-            embedded_hal::digital::PinState::High,
-            self.1.is_active_low(),
-        ))
+        self.0
+            .set_value(state_to_value(
+                embedded_hal::digital::PinState::High,
+                self.1.is_active_low(),
+            ))
+            .map_err(CdevPinError::from)
     }
 }
 
 impl embedded_hal::digital::InputPin for CdevPin {
     fn is_high(&self) -> Result<bool, Self::Error> {
-        self.0.get_value().map(|val| {
-            val == state_to_value(
-                embedded_hal::digital::PinState::High,
-                self.1.is_active_low(),
-            )
-        })
+        self.0
+            .get_value()
+            .map(|val| {
+                val == state_to_value(
+                    embedded_hal::digital::PinState::High,
+                    self.1.is_active_low(),
+                )
+            })
+            .map_err(CdevPinError::from)
     }
 
     fn is_low(&self) -> Result<bool, Self::Error> {

src/delay.rs

@@ -3,7 +3,6 @@
 //! [`embedded-hal`]: https://docs.rs/embedded-hal
 
 use cast::u64;
-use core::convert::Infallible;
 use embedded_hal::delay::DelayUs;
 use std::thread;
 use std::time::Duration;
@@ -12,13 +11,10 @@ use std::time::Duration;
 pub struct Delay;
 
 impl DelayUs for Delay {
-    type Error = Infallible;
-
-    fn delay_us(&mut self, n: u32) -> Result<(), Self::Error> {
+    fn delay_us(&mut self, n: u32) {
         let secs = n / 1_000_000;
         let nsecs = (n % 1_000_000) * 1_000;
 
         thread::sleep(Duration::new(u64(secs), nsecs));
-        Ok(())
     }
 }

src/i2c.rs

@@ -2,6 +2,7 @@
 //!
 //! [`embedded-hal`]: https://docs.rs/embedded-hal
 
+use std::fmt;
 use std::ops;
 use std::path::{Path, PathBuf};
 
@@ -13,7 +14,7 @@ use embedded_hal::i2c::NoAcknowledgeSource;
 pub struct I2cdev {
     inner: i2cdev::linux::LinuxI2CDevice,
     path: PathBuf,
-    address: Option<u8>,
+    address: Option<u16>,
 }
 
 impl I2cdev {
@@ -32,9 +33,9 @@ impl I2cdev {
         Ok(dev)
     }
 
-    fn set_address(&mut self, address: u8) -> Result<(), i2cdev::linux::LinuxI2CError> {
+    fn set_address(&mut self, address: u16) -> Result<(), i2cdev::linux::LinuxI2CError> {
         if self.address != Some(address) {
-            self.inner = i2cdev::linux::LinuxI2CDevice::new(&self.path, u16::from(address))?;
+            self.inner = i2cdev::linux::LinuxI2CDevice::new(&self.path, address)?;
             self.address = Some(address);
         }
         Ok(())
@@ -58,65 +59,17 @@ impl ops::DerefMut for I2cdev {
 mod embedded_hal_impl {
     use super::*;
     use embedded_hal::i2c::ErrorType;
-    use embedded_hal::i2c::{I2c, Operation as I2cOperation};
-    use i2cdev::core::{I2CDevice, I2CMessage, I2CTransfer};
+    use embedded_hal::i2c::{I2c, Operation as I2cOperation, SevenBitAddress, TenBitAddress};
+    use i2cdev::core::{I2CMessage, I2CTransfer};
     use i2cdev::linux::LinuxI2CMessage;
     impl ErrorType for I2cdev {
         type Error = I2CError;
     }
 
-    impl I2c for I2cdev {
-        fn read(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), Self::Error> {
-            self.set_address(address)?;
-            self.inner.read(buffer).map_err(|err| I2CError { err })
-        }
-
-        fn write(&mut self, address: u8, bytes: &[u8]) -> Result<(), Self::Error> {
-            self.set_address(address)?;
-            self.inner.write(bytes).map_err(|err| I2CError { err })
-        }
-
-        fn write_iter<B>(&mut self, address: u8, bytes: B) -> Result<(), Self::Error>
-        where
-            B: IntoIterator<Item = u8>,
-        {
-            let bytes: Vec<_> = bytes.into_iter().collect();
-            self.write(address, &bytes)
-        }
-
-        fn write_read(
-            &mut self,
-            address: u8,
-            bytes: &[u8],
-            buffer: &mut [u8],
-        ) -> Result<(), Self::Error> {
-            self.set_address(address)?;
-            let mut messages = [LinuxI2CMessage::write(bytes), LinuxI2CMessage::read(buffer)];
-            self.inner
-                .transfer(&mut messages)
-                .map(drop)
-                .map_err(|err| I2CError { err })
-        }
-
-        fn write_iter_read<B>(
-            &mut self,
-            address: u8,
-            bytes: B,
-            buffer: &mut [u8],
-        ) -> Result<(), Self::Error>
-        where
-            B: IntoIterator<Item = u8>,
-        {
-            let bytes: Vec<_> = bytes.into_iter().collect();
-            self.transaction(
-                address,
-                &mut [I2cOperation::Write(&bytes), I2cOperation::Read(buffer)],
-            )
-        }
-
+    impl I2c<TenBitAddress> for I2cdev {
         fn transaction(
             &mut self,
-            address: u8,
+            address: u16,
             operations: &mut [I2cOperation],
         ) -> Result<(), Self::Error> {
             // Map operations from generic to linux objects
@@ -135,13 +88,15 @@ mod embedded_hal_impl {
                 .map(drop)
                 .map_err(|err| I2CError { err })
         }
+    }
 
-        fn transaction_iter<'a, O>(&mut self, address: u8, operations: O) -> Result<(), Self::Error>
-        where
-            O: IntoIterator<Item = I2cOperation<'a>>,
-        {
-            let mut ops: Vec<_> = operations.into_iter().collect();
-            self.transaction(address, &mut ops)
+    impl I2c<SevenBitAddress> for I2cdev {
+        fn transaction(
+            &mut self,
+            address: u8,
+            operations: &mut [I2cOperation],
+        ) -> Result<(), Self::Error> {
+            I2c::<TenBitAddress>::transaction(self, u16::from(address), operations)
         }
     }
 }
@@ -165,6 +120,18 @@ impl From<i2cdev::linux::LinuxI2CError> for I2CError {
     }
 }
 
+impl fmt::Display for I2CError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.err)
+    }
+}
+
+impl std::error::Error for I2CError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        Some(&self.err)
+    }
+}
+
 impl embedded_hal::i2c::Error for I2CError {
     fn kind(&self) -> embedded_hal::i2c::ErrorKind {
         use embedded_hal::i2c::ErrorKind;

src/lib.rs

@@ -34,11 +34,11 @@ mod cdev_pin;
 
 #[cfg(feature = "gpio_cdev")]
 /// Cdev pin re-export
-pub use cdev_pin::CdevPin;
+pub use cdev_pin::{CdevPin, CdevPinError};
 
 #[cfg(feature = "gpio_sysfs")]
 /// Sysfs pin re-export
-pub use sysfs_pin::SysfsPin;
+pub use sysfs_pin::{SysfsPin, SysfsPinError};
 
 mod delay;
 #[cfg(feature = "i2c")]

src/serial.rs

@@ -2,8 +2,8 @@
 //!
 //! [`embedded-hal`]: https://docs.rs/embedded-hal
 
-use nb;
 use serialport::{SerialPortBuilder, TTYPort};
+use std::fmt;
 use std::io::{ErrorKind as IoErrorKind, Read, Write};
 
 /// Newtype around [`serialport::TTYPort`] that implements
@@ -72,6 +72,14 @@ impl SerialError {
     }
 }
 
+impl fmt::Display for SerialError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.err)
+    }
+}
+
+impl std::error::Error for SerialError {}
+
 impl embedded_hal::serial::Error for SerialError {
     fn kind(&self) -> embedded_hal::serial::ErrorKind {
         use embedded_hal::serial::ErrorKind::*;