Update embedded-hal to 1.0.0-alpha.10

Author: LehMaxence

.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.59.0, x86_64-unknown-linux-gnu)",
 ]

.github/workflows/ci.yml

@@ -21,7 +21,7 @@ jobs:
 
         include:
           # Test MSRV
-          - rust: 1.54.0
+          - rust: 1.59.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.59.0 and up. It *might*
 compile with older versions but that may change in any new patch release.
 
 ## License

src/cdev_pin.rs

@@ -94,37 +94,70 @@ 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 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(),
-        ))
+    fn set_low(&mut self) -> Result<(), CdevPinError> {
+        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(),
-        ))
+    fn set_high(&mut self) -> Result<(), CdevPinError> {
+        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(),
-            )
-        })
+    fn is_high(&self) -> Result<bool, CdevPinError> {
+        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> {
+    fn is_low(&self) -> Result<bool, CdevPinError> {
         self.is_high().map(|val| !val)
     }
 }

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

@@ -13,7 +13,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 +32,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 +58,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 +87,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)
         }
     }
 }

src/spi.rs

@@ -41,7 +41,10 @@ impl ops::DerefMut for Spidev {
 mod embedded_hal_impl {
     use super::*;
     use embedded_hal::spi::ErrorType;
-    use embedded_hal::spi::{SpiBus, SpiBusFlush, SpiBusRead, SpiBusWrite, SpiDevice};
+    use embedded_hal::spi::{
+        Operation as SpiOperation, SpiBus, SpiBusFlush, SpiBusRead, SpiBusWrite, SpiDevice,
+        SpiDeviceRead, SpiDeviceWrite,
+    };
     use spidev::SpidevTransfer;
     use std::io::{Read, Write};
 
@@ -82,16 +85,39 @@ mod embedded_hal_impl {
         }
     }
 
-    impl SpiDevice for Spidev {
-        type Bus = Spidev;
+    impl SpiDeviceRead for Spidev {
+        fn read_transaction(&mut self, operations: &mut [&mut [u8]]) -> Result<(), Self::Error> {
+            for mut buf in operations {
+                SpiBusRead::read(self, &mut buf)?;
+            }
+            self.flush()?;
+            Ok(())
+        }
+    }
 
-        fn transaction<R>(
+    impl SpiDeviceWrite for Spidev {
+        fn write_transaction(&mut self, operations: &[&[u8]]) -> Result<(), Self::Error> {
+            for buf in operations {
+                SpiBusWrite::write(self, buf)?;
+            }
+            self.flush()?;
+            Ok(())
+        }
+    }
+
+    impl SpiDevice for Spidev {
+        fn transaction(
             &mut self,
-            f: impl FnOnce(&mut Self::Bus) -> Result<R, <Self::Bus as ErrorType>::Error>,
-        ) -> Result<R, Self::Error> {
-            let result = f(self)?;
+            operations: &mut [SpiOperation<'_, u8>],
+        ) -> Result<(), Self::Error> {
+            operations.iter_mut().try_for_each(|op| match op {
+                SpiOperation::Read(buf) => SpiBusRead::read(self, buf),
+                SpiOperation::Write(buf) => SpiBusWrite::write(self, buf),
+                SpiOperation::Transfer(read, write) => SpiBus::transfer(self, read, write),
+                SpiOperation::TransferInPlace(buf) => SpiBus::transfer_in_place(self, buf),
+            })?;
             self.flush()?;
-            Ok(result)
+            Ok(())
         }
     }
 }