spi: add Operation::DelayUs(u32).

Dirbaio · Dirbaio · commit fae73e0496b2 · 2023-05-10T23:11:22.000+02:00
diff --git a/embedded-hal-async/src/spi.rs b/embedded-hal-async/src/spi.rs
@@ -8,6 +8,8 @@ pub use embedded_hal::spi::{
     Error, ErrorKind, ErrorType, Mode, Operation, Phase, Polarity, MODE_0, MODE_1, MODE_2, MODE_3,
 };
 
+use crate::delay::DelayUs;
+
 /// SPI device trait
 ///
 /// `SpiDevice` represents ownership over a single SPI device on a (possibly shared) bus, selected
@@ -195,30 +197,32 @@ where
 ///
 /// 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> {
+pub struct ExclusiveDevice<BUS, CS, D> {
     bus: BUS,
     cs: CS,
+    delay: D,
 }
 
-impl<BUS, CS> ExclusiveDevice<BUS, CS> {
+impl<BUS, CS, D> ExclusiveDevice<BUS, CS, D> {
     /// Create a new ExclusiveDevice
-    pub fn new(bus: BUS, cs: CS) -> Self {
-        Self { bus, cs }
+    pub fn new(bus: BUS, cs: CS, delay: D) -> Self {
+        Self { bus, cs, delay }
     }
 }
 
-impl<BUS, CS> ErrorType for ExclusiveDevice<BUS, CS>
+impl<BUS, CS, D> ErrorType for ExclusiveDevice<BUS, CS, D>
 where
     BUS: ErrorType,
     CS: OutputPin,
 {
     type Error = ExclusiveDeviceError<BUS::Error, CS::Error>;
 }
 
-impl<Word: Copy + 'static, BUS, CS> blocking::SpiDevice<Word> for ExclusiveDevice<BUS, CS>
+impl<Word: Copy + 'static, BUS, CS, D> blocking::SpiDevice<Word> for ExclusiveDevice<BUS, CS, D>
 where
     BUS: blocking::SpiBus<Word>,
     CS: OutputPin,
+    D: embedded_hal::delay::DelayUs,
 {
     fn transaction(&mut self, operations: &mut [Operation<'_, Word>]) -> Result<(), Self::Error> {
         self.cs.set_low().map_err(ExclusiveDeviceError::Cs)?;
@@ -230,6 +234,7 @@ where
                     Operation::Write(buf) => self.bus.write(buf),
                     Operation::Transfer(read, write) => self.bus.transfer(read, write),
                     Operation::TransferInPlace(buf) => self.bus.transfer_in_place(buf),
+                    Operation::DelayUs(us) => Ok(self.delay.delay_us(*us)),
                 };
                 if let Err(e) = res {
                     break 'ops Err(e);
@@ -250,10 +255,11 @@ where
     }
 }
 
-impl<Word: Copy + 'static, BUS, CS> SpiDevice<Word> for ExclusiveDevice<BUS, CS>
+impl<Word: Copy + 'static, BUS, CS, D> SpiDevice<Word> for ExclusiveDevice<BUS, CS, D>
 where
     BUS: SpiBus<Word>,
     CS: OutputPin,
+    D: DelayUs,
 {
     async fn transaction(
         &mut self,
@@ -268,6 +274,7 @@ where
                     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) => Ok(self.delay.delay_us(*us).await),
                 };
                 if let Err(e) = res {
                     break 'ops Err(e);
diff --git a/embedded-hal-bus/src/spi/critical_section.rs b/embedded-hal-bus/src/spi/critical_section.rs
@@ -1,5 +1,6 @@
 use core::cell::RefCell;
 use critical_section::Mutex;
+use embedded_hal::delay::DelayUs;
 use embedded_hal::digital::OutputPin;
 use embedded_hal::spi::{ErrorType, Operation, SpiBus, SpiDevice};
 
@@ -15,34 +16,35 @@ use super::DeviceError;
 /// The downside is critical sections typically require globally disabling interrupts, so `CriticalSectionDevice` will likely
 /// negatively impact real-time properties, such as interrupt latency. If you can, prefer using
 /// [`RefCellDevice`](super::RefCellDevice) instead, which does not require taking critical sections.
-pub struct CriticalSectionDevice<'a, BUS, CS> {
-    bus: &'a Mutex<RefCell<BUS>>,
+pub struct CriticalSectionDevice<'a, BUS, CS, D> {
+    bus: &'a Mutex<RefCell<(BUS, D)>>,
     cs: CS,
 }
 
-impl<'a, BUS, CS> CriticalSectionDevice<'a, BUS, CS> {
+impl<'a, BUS, CS, D> CriticalSectionDevice<'a, BUS, CS, D> {
     /// Create a new ExclusiveDevice
-    pub fn new(bus: &'a Mutex<RefCell<BUS>>, cs: CS) -> Self {
+    pub fn new(bus: &'a Mutex<RefCell<(BUS, D)>>, cs: CS) -> Self {
         Self { bus, cs }
     }
 }
 
-impl<'a, BUS, CS> ErrorType for CriticalSectionDevice<'a, BUS, CS>
+impl<'a, BUS, CS, D> ErrorType for CriticalSectionDevice<'a, BUS, CS, D>
 where
     BUS: ErrorType,
     CS: OutputPin,
 {
     type Error = DeviceError<BUS::Error, CS::Error>;
 }
 
-impl<'a, Word: Copy + 'static, BUS, CS> SpiDevice<Word> for CriticalSectionDevice<'a, BUS, CS>
+impl<'a, Word: Copy + 'static, BUS, CS, D> SpiDevice<Word> for CriticalSectionDevice<'a, BUS, CS, D>
 where
     BUS: SpiBus<Word>,
     CS: OutputPin,
+    D: DelayUs,
 {
     fn transaction(&mut self, operations: &mut [Operation<'_, Word>]) -> Result<(), Self::Error> {
         critical_section::with(|cs| {
-            let bus = &mut *self.bus.borrow_ref_mut(cs);
+            let (bus, delay) = &mut *self.bus.borrow_ref_mut(cs);
 
             self.cs.set_low().map_err(DeviceError::Cs)?;
 
@@ -51,6 +53,7 @@ where
                 Operation::Write(buf) => bus.write(buf),
                 Operation::Transfer(read, write) => bus.transfer(read, write),
                 Operation::TransferInPlace(buf) => bus.transfer_in_place(buf),
+                Operation::DelayUs(us) => Ok(delay.delay_us(*us)),
             });
 
             // On failure, it's important to still flush and deassert CS.
diff --git a/embedded-hal-bus/src/spi/exclusive.rs b/embedded-hal-bus/src/spi/exclusive.rs
@@ -1,5 +1,6 @@
 //! SPI bus sharing mechanisms.
 
+use embedded_hal::delay::DelayUs;
 use embedded_hal::digital::OutputPin;
 use embedded_hal::spi::{ErrorType, Operation, SpiBus, SpiDevice};
 
@@ -9,30 +10,32 @@ use super::DeviceError;
 ///
 /// This is the most straightforward way of obtaining an [`SpiDevice`] from an [`SpiBus`](embedded_hal::spi::SpiBus),
 /// ideal for when no sharing is required (only one SPI device is present on the bus).
-pub struct ExclusiveDevice<BUS, CS> {
+pub struct ExclusiveDevice<BUS, CS, D> {
     bus: BUS,
     cs: CS,
+    delay: D,
 }
 
-impl<BUS, CS> ExclusiveDevice<BUS, CS> {
+impl<BUS, CS, D> ExclusiveDevice<BUS, CS, D> {
     /// Create a new ExclusiveDevice
-    pub fn new(bus: BUS, cs: CS) -> Self {
-        Self { bus, cs }
+    pub fn new(bus: BUS, cs: CS, delay: D) -> Self {
+        Self { bus, cs, delay }
     }
 }
 
-impl<BUS, CS> ErrorType for ExclusiveDevice<BUS, CS>
+impl<BUS, CS, D> ErrorType for ExclusiveDevice<BUS, CS, D>
 where
     BUS: ErrorType,
     CS: OutputPin,
 {
     type Error = DeviceError<BUS::Error, CS::Error>;
 }
 
-impl<Word: Copy + 'static, BUS, CS> SpiDevice<Word> for ExclusiveDevice<BUS, CS>
+impl<Word: Copy + 'static, BUS, CS, D> SpiDevice<Word> for ExclusiveDevice<BUS, CS, D>
 where
     BUS: SpiBus<Word>,
     CS: OutputPin,
+    D: DelayUs,
 {
     fn transaction(&mut self, operations: &mut [Operation<'_, Word>]) -> Result<(), Self::Error> {
         self.cs.set_low().map_err(DeviceError::Cs)?;
@@ -42,6 +45,7 @@ where
             Operation::Write(buf) => self.bus.write(buf),
             Operation::Transfer(read, write) => self.bus.transfer(read, write),
             Operation::TransferInPlace(buf) => self.bus.transfer_in_place(buf),
+            Operation::DelayUs(us) => Ok(self.delay.delay_us(*us)),
         });
 
         // On failure, it's important to still flush and deassert CS.
diff --git a/embedded-hal-bus/src/spi/mutex.rs b/embedded-hal-bus/src/spi/mutex.rs
@@ -1,3 +1,4 @@
+use embedded_hal::delay::DelayUs;
 use embedded_hal::digital::OutputPin;
 use embedded_hal::spi::{ErrorType, Operation, SpiBus, SpiDevice};
 use std::sync::Mutex;
@@ -12,33 +13,34 @@ use super::DeviceError;
 /// Sharing is implemented with a `std` [`Mutex`](std::sync::Mutex). It allows a single bus across multiple threads,
 /// with finer-grained locking than [`CriticalSectionDevice`](super::CriticalSectionDevice). The downside is
 /// it is only available in `std` targets.
-pub struct MutexDevice<'a, BUS, CS> {
-    bus: &'a Mutex<BUS>,
+pub struct MutexDevice<'a, BUS, CS, D> {
+    bus: &'a Mutex<(BUS, D)>,
     cs: CS,
 }
 
-impl<'a, BUS, CS> MutexDevice<'a, BUS, CS> {
+impl<'a, BUS, CS, D> MutexDevice<'a, BUS, CS, D> {
     /// Create a new ExclusiveDevice
-    pub fn new(bus: &'a Mutex<BUS>, cs: CS) -> Self {
+    pub fn new(bus: &'a Mutex<(BUS, D)>, cs: CS) -> Self {
         Self { bus, cs }
     }
 }
 
-impl<'a, BUS, CS> ErrorType for MutexDevice<'a, BUS, CS>
+impl<'a, BUS, CS, D> ErrorType for MutexDevice<'a, BUS, CS, D>
 where
     BUS: ErrorType,
     CS: OutputPin,
 {
     type Error = DeviceError<BUS::Error, CS::Error>;
 }
 
-impl<'a, Word: Copy + 'static, BUS, CS> SpiDevice<Word> for MutexDevice<'a, BUS, CS>
+impl<'a, Word: Copy + 'static, BUS, CS, D> SpiDevice<Word> for MutexDevice<'a, BUS, CS, D>
 where
     BUS: SpiBus<Word>,
     CS: OutputPin,
+    D: DelayUs,
 {
     fn transaction(&mut self, operations: &mut [Operation<'_, Word>]) -> Result<(), Self::Error> {
-        let bus = &mut *self.bus.lock().unwrap();
+        let (bus, delay) = &mut *self.bus.lock().unwrap();
 
         self.cs.set_low().map_err(DeviceError::Cs)?;
 
@@ -47,6 +49,7 @@ where
             Operation::Write(buf) => bus.write(buf),
             Operation::Transfer(read, write) => bus.transfer(read, write),
             Operation::TransferInPlace(buf) => bus.transfer_in_place(buf),
+            Operation::DelayUs(us) => Ok(delay.delay_us(*us)),
         });
 
         // On failure, it's important to still flush and deassert CS.
diff --git a/embedded-hal-bus/src/spi/refcell.rs b/embedded-hal-bus/src/spi/refcell.rs
@@ -1,4 +1,5 @@
 use core::cell::RefCell;
+use embedded_hal::delay::DelayUs;
 use embedded_hal::digital::OutputPin;
 use embedded_hal::spi::{ErrorType, Operation, SpiBus, SpiDevice};
 
@@ -12,33 +13,34 @@ use super::DeviceError;
 /// Sharing is implemented with a `RefCell`. This means it has low overhead, but `RefCellDevice` instances are not `Send`,
 /// so it only allows sharing within a single thread (interrupt priority level). If you need to share a bus across several
 /// threads, use [`CriticalSectionDevice`](super::CriticalSectionDevice) instead.
-pub struct RefCellDevice<'a, BUS, CS> {
-    bus: &'a RefCell<BUS>,
+pub struct RefCellDevice<'a, BUS, CS, D> {
+    bus: &'a RefCell<(BUS, D)>,
     cs: CS,
 }
 
-impl<'a, BUS, CS> RefCellDevice<'a, BUS, CS> {
+impl<'a, BUS, CS, D> RefCellDevice<'a, BUS, CS, D> {
     /// Create a new ExclusiveDevice
-    pub fn new(bus: &'a RefCell<BUS>, cs: CS) -> Self {
+    pub fn new(bus: &'a RefCell<(BUS, D)>, cs: CS) -> Self {
         Self { bus, cs }
     }
 }
 
-impl<'a, BUS, CS> ErrorType for RefCellDevice<'a, BUS, CS>
+impl<'a, BUS, CS, D> ErrorType for RefCellDevice<'a, BUS, CS, D>
 where
     BUS: ErrorType,
     CS: OutputPin,
 {
     type Error = DeviceError<BUS::Error, CS::Error>;
 }
 
-impl<'a, Word: Copy + 'static, BUS, CS> SpiDevice<Word> for RefCellDevice<'a, BUS, CS>
+impl<'a, Word: Copy + 'static, BUS, CS, D> SpiDevice<Word> for RefCellDevice<'a, BUS, CS, D>
 where
     BUS: SpiBus<Word>,
     CS: OutputPin,
+    D: DelayUs,
 {
     fn transaction(&mut self, operations: &mut [Operation<'_, Word>]) -> Result<(), Self::Error> {
-        let bus = &mut *self.bus.borrow_mut();
+        let (bus, delay) = &mut *self.bus.borrow_mut();
 
         self.cs.set_low().map_err(DeviceError::Cs)?;
 
@@ -47,6 +49,7 @@ where
             Operation::Write(buf) => bus.write(buf),
             Operation::Transfer(read, write) => bus.transfer(read, write),
             Operation::TransferInPlace(buf) => bus.transfer_in_place(buf),
+            Operation::DelayUs(us) => Ok(delay.delay_us(*us)),
         });
 
         // On failure, it's important to still flush and deassert CS.
diff --git a/embedded-hal/CHANGELOG.md b/embedded-hal/CHANGELOG.md
@@ -7,6 +7,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+### Added
+- spi: added `Operation::DelayUs(u32)`.
+
 ### Removed
 - spi: removed read-only and write-only traits.
 
diff --git a/embedded-hal/src/spi.rs b/embedded-hal/src/spi.rs
@@ -313,6 +313,8 @@ pub enum Operation<'a, Word: 'static> {
     ///
     /// Equivalent to [`SpiBus::transfer_in_place`].
     TransferInPlace(&'a mut [Word]),
+    /// Delay for at least the specified number of microseconds
+    DelayUs(u32),
 }
 
 /// SPI device trait

Original file line number	Diff line number	Diff line change
`@@ -313,6 +313,8 @@ pub enum Operation<'a, Word: 'static> {`
`313`	`313`	`///`
`314`	`314`	/// Equivalent to [`SpiBus::transfer_in_place`].
`315`	`315`	`TransferInPlace(&'a mut [Word]),`
	`316`	`+ /// Delay for at least the specified number of microseconds`
	`317`	`+ DelayUs(u32),`
`316`	`318`	`}`
`317`	`319`
`318`	`320`	`/// SPI device trait`