removed chip select pin from ExclusiveDevice in embedded-hal-bus

Author: uliano

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

@@ -9,31 +9,54 @@ use embedded_hal_async::{
     spi::{SpiBus as AsyncSpiBus, SpiDevice as AsyncSpiDevice},
 };
 
+use core::convert::Infallible;
+use embedded_hal::digital::ErrorType as NoPinErrorType;
+
+/// A dummy pin that does nothing.
+/// This can be used for devices that do not require a Chip Select (CS) pin.
+#[derive(Debug, Default, Copy, Clone)]
+pub struct NoPin;
+
+// Implement `ErrorType` for NoPin (Explicitly Using `digital::ErrorType`)
+impl NoPinErrorType for NoPin {
+    type Error = Infallible;
+}
+
+// Implement `OutputPin`
+impl OutputPin for NoPin {
+    fn set_low(&mut self) -> Result<(), Infallible> {
+        Ok(())
+    }
+
+    fn set_high(&mut self) -> Result<(), Infallible> {
+        Ok(())
+    }
+}
+
 use super::shared::transaction;
 use super::DeviceError;
 
 /// [`SpiDevice`] implementation with exclusive access to the bus (not shared).
 ///
 /// This is the most straightforward way of obtaining an [`SpiDevice`] from an [`SpiBus`],
 /// ideal for when no sharing is required (only one SPI device is present on the bus).
-pub struct ExclusiveDevice<BUS, CS, D> {
+/// As this is meant for exclusive access, it doesn't require a Chip Select (CS) pin.
+pub struct ExclusiveDevice<BUS, D> {
     bus: BUS,
-    cs: CS,
+    cs: NoPin,
     delay: D,
 }
 
-impl<BUS, CS, D> ExclusiveDevice<BUS, CS, D> {
+impl<BUS, D> ExclusiveDevice<BUS, D> {
     /// Create a new [`ExclusiveDevice`].
     ///
-    /// This sets the `cs` pin high, and returns an error if that fails. It is recommended
-    /// to set the pin high the moment it's configured as an output, to avoid glitches.
     #[inline]
-    pub fn new(bus: BUS, mut cs: CS, delay: D) -> Result<Self, CS::Error>
-    where
-        CS: OutputPin,
-    {
-        cs.set_high()?;
-        Ok(Self { bus, cs, delay })
+    pub fn new(bus: BUS, delay: D) -> Result<Self, Infallible> {
+        Ok(Self {
+            bus,
+            cs: NoPin,
+            delay,
+        })
     }
 
     /// Returns a reference to the underlying bus object.
@@ -49,12 +72,9 @@ impl<BUS, CS, D> ExclusiveDevice<BUS, CS, D> {
     }
 }
 
-impl<BUS, CS> ExclusiveDevice<BUS, CS, super::NoDelay> {
+impl<BUS> ExclusiveDevice<BUS, super::NoDelay> {
     /// Create a new [`ExclusiveDevice`] without support for in-transaction delays.
     ///
-    /// This sets the `cs` pin high, and returns an error if that fails. It is recommended
-    /// to set the pin high the moment it's configured as an output, to avoid glitches.
-    ///
     /// **Warning**: The returned instance *technically* doesn't comply with the `SpiDevice`
     /// contract, which mandates delay support. It is relatively rare for drivers to use
     /// in-transaction delays, so you might still want to use this method because it's more practical.
@@ -70,31 +90,25 @@ impl<BUS, CS> ExclusiveDevice<BUS, CS, super::NoDelay> {
     /// The returned device will panic if you try to execute a transaction
     /// that contains any operations of type [`Operation::DelayNs`].
     #[inline]
-    pub fn new_no_delay(bus: BUS, mut cs: CS) -> Result<Self, CS::Error>
-    where
-        CS: OutputPin,
-    {
-        cs.set_high()?;
+    pub fn new_no_delay(bus: BUS) -> Result<Self, Infallible> {
         Ok(Self {
             bus,
-            cs,
+            cs: NoPin,
             delay: super::NoDelay,
         })
     }
 }
 
-impl<BUS, CS, D> ErrorType for ExclusiveDevice<BUS, CS, D>
+impl<BUS, D> ErrorType for ExclusiveDevice<BUS, D>
 where
     BUS: ErrorType,
-    CS: OutputPin,
 {
-    type Error = DeviceError<BUS::Error, CS::Error>;
+    type Error = DeviceError<BUS::Error, Infallible>;
 }
 
-impl<Word: Copy + 'static, BUS, CS, D> SpiDevice<Word> for ExclusiveDevice<BUS, CS, D>
+impl<Word: Copy + 'static, BUS, D> SpiDevice<Word> for ExclusiveDevice<BUS, D>
 where
     BUS: SpiBus<Word>,
-    CS: OutputPin,
     D: DelayNs,
 {
     #[inline]
@@ -105,10 +119,9 @@ where
 
 #[cfg(feature = "async")]
 #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-impl<Word: Copy + 'static, BUS, CS, D> AsyncSpiDevice<Word> for ExclusiveDevice<BUS, CS, D>
+impl<Word: Copy + 'static, BUS, D> AsyncSpiDevice<Word> for ExclusiveDevice<BUS, D>
 where
     BUS: AsyncSpiBus<Word>,
-    CS: OutputPin,
     D: AsyncDelayNs,
 {
     #[inline]
@@ -142,11 +155,9 @@ where
 
         // 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(())
     }