Merge spi ExclusiveDevice implementations

Author: bugadani

embedded-hal-bus/src/asynch/mod.rs

@@ -6,7 +6,3 @@
 
 pub mod i2c;
 pub mod spi;
-
-#[cfg(feature = "async")]
-#[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-pub mod asynch;

embedded-hal-bus/src/asynch/spi/exclusive.rs

@@ -3,6 +3,11 @@
 use embedded_hal::delay::DelayUs;
 use embedded_hal::digital::OutputPin;
 use embedded_hal::spi::{ErrorType, Operation, SpiBus, SpiDevice};
+#[cfg(feature = "async")]
+use embedded_hal_async::{
+    delay::DelayUs as AsyncDelayUs,
+    spi::{SpiBus as AsyncSpiBus, SpiDevice as AsyncSpiDevice},
+};
 
 use super::DeviceError;
 
@@ -21,6 +26,16 @@ impl<BUS, CS, D> ExclusiveDevice<BUS, CS, D> {
     pub fn new(bus: BUS, cs: CS, delay: D) -> Self {
         Self { bus, cs, delay }
     }
+
+    /// Returns a reference to the underlying bus object.
+    pub fn bus(&self) -> &BUS {
+        &self.bus
+    }
+
+    /// Returns a mutable reference to the underlying bus object.
+    pub fn bus_mut(&mut self) -> &mut BUS {
+        &mut self.bus
+    }
 }
 
 impl<BUS, CS> ExclusiveDevice<BUS, CS, super::NoDelay> {
@@ -79,3 +94,51 @@ where
         Ok(())
     }
 }
+
+#[cfg(feature = "async")]
+#[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+impl<Word: Copy + 'static, BUS, CS, D> AsyncSpiDevice<Word> for ExclusiveDevice<BUS, CS, D>
+where
+    BUS: AsyncSpiBus<Word>,
+    CS: OutputPin,
+    D: AsyncDelayUs,
+{
+    async fn transaction(
+        &mut self,
+        operations: &mut [Operation<'_, Word>],
+    ) -> Result<(), Self::Error> {
+        self.cs.set_low().map_err(DeviceError::Cs)?;
+
+        let op_res = 'ops: {
+            for op in operations {
+                let res = match op {
+                    Operation::Read(buf) => self.bus.read(buf).await,
+                    Operation::Write(buf) => self.bus.write(buf).await,
+                    Operation::Transfer(read, write) => self.bus.transfer(read, write).await,
+                    Operation::TransferInPlace(buf) => self.bus.transfer_in_place(buf).await,
+                    Operation::DelayUs(us) => match self.bus.flush().await {
+                        Err(e) => Err(e),
+                        Ok(()) => {
+                            self.delay.delay_us(*us).await;
+                            Ok(())
+                        }
+                    },
+                };
+                if let Err(e) = res {
+                    break 'ops Err(e);
+                }
+            }
+            Ok(())
+        };
+
+        // On failure, it's important to still flush and deassert CS.
+        let flush_res = self.bus.flush().await;
+        let cs_res = self.cs.set_high();
+
+        op_res.map_err(DeviceError::Spi)?;
+        flush_res.map_err(DeviceError::Spi)?;
+        cs_res.map_err(DeviceError::Cs)?;
+
+        Ok(())
+    }
+}