Update embedded-hal

Author: LehMaxence

Cargo.toml

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

src/serial.rs

@@ -81,6 +81,7 @@ impl fmt::Display for SerialError {
 impl std::error::Error for SerialError {}
 
 impl embedded_hal::serial::Error for SerialError {
+    #[allow(clippy::match_single_binding)]
     fn kind(&self) -> embedded_hal::serial::ErrorKind {
         use embedded_hal::serial::ErrorKind::*;
         // TODO: match any errors here if we can find any that are relevant

src/spi.rs

@@ -8,20 +8,25 @@ use std::io;
 use std::ops;
 use std::path::Path;
 
+use crate::Delay;
+use spidev::SpidevTransfer;
+
 /// Newtype around [`spidev::Spidev`] that implements the `embedded-hal` traits
 ///
-/// [`spidev::Spidev`]: https://docs.rs/spidev/0.5.0/spidev/struct.Spidev.html
-pub struct Spidev(pub spidev::Spidev);
+/// [`spidev::Spidev`]: https://docs.rs/spidev/0.5.spidev/spidev/struct.Spidev.html
+pub struct Spidev(pub spidev::Spidev, Delay);
 
 impl Spidev {
     /// See [`spidev::Spidev::open`][0] for details.
     ///
-    /// [0]: https://docs.rs/spidev/0.5.0/spidev/struct.Spidev.html#method.open
+    /// [0]: https://docs.rs/spidev/0.5.spidev/spidev/struct.Spidev.html#method.open
     pub fn open<P>(path: P) -> Result<Self, SPIError>
     where
         P: AsRef<Path>,
     {
-        spidev::Spidev::open(path).map(Spidev).map_err(|e| e.into())
+        spidev::Spidev::open(path)
+            .map(|spidev| Spidev(spidev, Delay {}))
+            .map_err(|e| e.into())
     }
 }
 
@@ -41,37 +46,25 @@ impl ops::DerefMut for Spidev {
 
 mod embedded_hal_impl {
     use super::*;
+    use embedded_hal::delay::DelayUs;
     use embedded_hal::spi::ErrorType;
-    use embedded_hal::spi::{
-        Operation as SpiOperation, SpiBus, SpiBusFlush, SpiBusRead, SpiBusWrite, SpiDevice,
-        SpiDeviceRead, SpiDeviceWrite,
-    };
+    use embedded_hal::spi::{Operation as SpiOperation, SpiBus, SpiDevice};
     use spidev::SpidevTransfer;
     use std::io::{Read, Write};
 
     impl ErrorType for Spidev {
         type Error = SPIError;
     }
 
-    impl SpiBusFlush for Spidev {
-        fn flush(&mut self) -> Result<(), Self::Error> {
-            self.0.flush().map_err(|err| SPIError { err })
-        }
-    }
-
-    impl SpiBusRead<u8> for Spidev {
+    impl SpiBus<u8> for Spidev {
         fn read(&mut self, words: &mut [u8]) -> Result<(), Self::Error> {
             self.0.read_exact(words).map_err(|err| SPIError { err })
         }
-    }
 
-    impl SpiBusWrite<u8> for Spidev {
         fn write(&mut self, words: &[u8]) -> Result<(), Self::Error> {
             self.0.write_all(words).map_err(|err| SPIError { err })
         }
-    }
 
-    impl SpiBus<u8> for Spidev {
         fn transfer(&mut self, read: &mut [u8], write: &[u8]) -> Result<(), Self::Error> {
             self.0
                 .transfer(&mut SpidevTransfer::read_write(write, read))
@@ -84,33 +77,9 @@ mod embedded_hal_impl {
                 .transfer(&mut SpidevTransfer::read_write(&tx, words))
                 .map_err(|err| SPIError { err })
         }
-    }
-
-    impl SpiDeviceRead for Spidev {
-        fn read_transaction(&mut self, operations: &mut [&mut [u8]]) -> Result<(), Self::Error> {
-            let mut transfers: Vec<_> = operations
-                .iter_mut()
-                .map(|op| SpidevTransfer::read(op))
-                .collect();
-            self.0
-                .transfer_multiple(&mut transfers)
-                .map_err(|err| SPIError { err })?;
-            self.flush()?;
-            Ok(())
-        }
-    }
 
-    impl SpiDeviceWrite for Spidev {
-        fn write_transaction(&mut self, operations: &[&[u8]]) -> Result<(), Self::Error> {
-            let mut transfers: Vec<_> = operations
-                .iter()
-                .map(|op| SpidevTransfer::write(op))
-                .collect();
-            self.0
-                .transfer_multiple(&mut transfers)
-                .map_err(|err| SPIError { err })?;
-            self.flush()?;
-            Ok(())
+        fn flush(&mut self) -> Result<(), Self::Error> {
+            self.0.flush().map_err(|err| SPIError { err })
         }
     }
 
@@ -119,30 +88,62 @@ mod embedded_hal_impl {
             &mut self,
             operations: &mut [SpiOperation<'_, u8>],
         ) -> Result<(), Self::Error> {
-            let mut transfers: Vec<_> = operations
-                .iter_mut()
-                .map(|op| match op {
-                    SpiOperation::Read(buf) => SpidevTransfer::read(buf),
-                    SpiOperation::Write(buf) => SpidevTransfer::write(buf),
-                    SpiOperation::Transfer(read, write) => SpidevTransfer::read_write(write, read),
+            let mut spidev_ops: Vec<Operation> = vec![];
+            let mut spidev_transfers: Vec<SpidevTransfer> = vec![];
+
+            for op in operations {
+                match op {
+                    SpiOperation::Read(buf) => spidev_transfers.push(SpidevTransfer::read(buf)),
+                    SpiOperation::Write(buf) => spidev_transfers.push(SpidevTransfer::write(buf)),
+                    SpiOperation::Transfer(read, write) => {
+                        spidev_transfers.push(SpidevTransfer::read_write(write, read))
+                    }
                     SpiOperation::TransferInPlace(buf) => {
                         let tx = unsafe {
                             let p = buf.as_ptr();
                             std::slice::from_raw_parts(p, buf.len())
                         };
-                        SpidevTransfer::read_write(tx, buf)
+                        spidev_transfers.push(SpidevTransfer::read_write(tx, buf))
                     }
-                })
-                .collect();
-            self.0
-                .transfer_multiple(&mut transfers)
-                .map_err(|err| SPIError { err })?;
-            self.flush()?;
+                    SpiOperation::DelayUs(us) => {
+                        if !spidev_transfers.is_empty() {
+                            let mut transfers: Vec<SpidevTransfer> = vec![];
+                            std::mem::swap(&mut transfers, &mut spidev_transfers);
+                            spidev_ops.push(Operation::Transfers(transfers));
+                        }
+                        spidev_ops.push(Operation::Delay(us.to_owned()));
+                    }
+                }
+            }
+
+            if !spidev_transfers.is_empty() {
+                spidev_ops.push(Operation::Transfers(spidev_transfers));
+            }
+
+            for op in spidev_ops {
+                match op {
+                    Operation::Transfers(mut transfers) => {
+                        self.0
+                            .transfer_multiple(&mut transfers)
+                            .map_err(|err| SPIError { err })?;
+                        self.flush()?;
+                    }
+                    Operation::Delay(us) => {
+                        self.1.delay_us(us);
+                    }
+                }
+            }
+
             Ok(())
         }
     }
 }
 
+enum Operation<'a, 'b> {
+    Transfers(Vec<SpidevTransfer<'a, 'b>>),
+    Delay(u32),
+}
+
 /// Error type wrapping [io::Error](io::Error) to implement [embedded_hal::spi::ErrorKind]
 #[derive(Debug)]
 pub struct SPIError {
@@ -163,6 +164,7 @@ impl From<io::Error> for SPIError {
 }
 
 impl embedded_hal::spi::Error for SPIError {
+    #[allow(clippy::match_single_binding)]
     fn kind(&self) -> embedded_hal::spi::ErrorKind {
         use embedded_hal::spi::ErrorKind;
         // TODO: match any errors here if we can find any that are relevant