add DelayNs providers to spi devices

Author: almindor

src/spi/bus.rs

@@ -1,4 +1,5 @@
 use core::convert::Infallible;
+use embedded_hal::delay::DelayNs;
 pub use embedded_hal::spi::{Mode, Phase, Polarity, MODE_0, MODE_1, MODE_2, MODE_3};
 pub use embedded_io::Write;
 
@@ -248,8 +249,11 @@ where
     PINS: Pins<SPI>,
 {
     /// Create a new [SpiExclusiveDevice] for exclusive use on this bus
-    pub fn new_device(self, config: &SpiConfig) -> SpiExclusiveDevice<SPI, PINS> {
-        SpiExclusiveDevice::new(self, config)
+    pub fn new_device<D>(self, config: &SpiConfig, delay: D) -> SpiExclusiveDevice<SPI, PINS, D>
+    where
+        D: DelayNs,
+    {
+        SpiExclusiveDevice::new(self, config, delay)
     }
 }
 

src/spi/exclusive_device.rs

@@ -1,30 +1,35 @@
 use core::convert::Infallible;
 
-use embedded_hal::spi::{ErrorType, Operation, SpiBus as HalBus, SpiDevice};
+use embedded_hal::{
+    delay::DelayNs,
+    spi::{ErrorType, Operation, SpiBus as HalBus, SpiDevice},
+};
 
 use crate::spi::SpiConfig;
 
 use super::{Pins, SpiBus, SpiX};
 
 /// SPI exclusive device abstraction
-pub struct SpiExclusiveDevice<SPI, PINS> {
+pub struct SpiExclusiveDevice<SPI, PINS, D> {
     bus: SpiBus<SPI, PINS>,
+    delay: D,
 }
 
-impl<SPI, PINS> SpiExclusiveDevice<SPI, PINS>
+impl<SPI, PINS, D> SpiExclusiveDevice<SPI, PINS, D>
 where
     SPI: SpiX,
     PINS: Pins<SPI>,
+    D: DelayNs,
 {
     /// Create [SpiExclusiveDevice] using the existing [SpiBus](super::SpiBus)
     /// with the given [SpiConfig]
-    pub fn new(mut bus: SpiBus<SPI, PINS>, config: &SpiConfig) -> Self
+    pub fn new(mut bus: SpiBus<SPI, PINS>, config: &SpiConfig, delay: D) -> Self
     where
         PINS: Pins<SPI>,
     {
         bus.configure(config, PINS::CS_INDEX);
 
-        Self { bus }
+        Self { bus, delay }
     }
 
     /// Releases the Bus back deconstructing it
@@ -45,30 +50,31 @@ where
     }
 }
 
-impl<SPI, PINS> ErrorType for SpiExclusiveDevice<SPI, PINS>
+impl<SPI, PINS, D> ErrorType for SpiExclusiveDevice<SPI, PINS, D>
 where
     SPI: SpiX,
     PINS: Pins<SPI>,
 {
     type Error = Infallible;
 }
 
-impl<SPI, PINS> SpiDevice for SpiExclusiveDevice<SPI, PINS>
+impl<SPI, PINS, D> SpiDevice for SpiExclusiveDevice<SPI, PINS, D>
 where
     SPI: SpiX,
     PINS: Pins<SPI>,
+    D: DelayNs,
 {
     fn transaction(&mut self, operations: &mut [Operation<'_, u8>]) -> Result<(), Self::Error> {
         self.bus.start_frame();
 
         for operation in operations {
             match operation {
-                Operation::Read(words) => self.bus.read(words),
-                Operation::Write(words) => self.bus.write(words),
-                Operation::Transfer(read, write) => self.bus.transfer(read, write),
-                Operation::TransferInPlace(words) => self.bus.transfer_in_place(words),
-                Operation::DelayNs(_ns) => Ok(()), // TODO: NOOP?
-            }?;
+                Operation::Read(words) => self.bus.read(words)?,
+                Operation::Write(words) => self.bus.write(words)?,
+                Operation::Transfer(read, write) => self.bus.transfer(read, write)?,
+                Operation::TransferInPlace(words) => self.bus.transfer_in_place(words)?,
+                Operation::DelayNs(ns) => self.delay.delay_ns(*ns),
+            }
         }
         self.bus.end_frame();
 

src/spi/shared_bus.rs

@@ -1,5 +1,6 @@
 use core::cell::RefCell;
 use core::ops::Deref;
+use embedded_hal::delay::DelayNs;
 use riscv::interrupt;
 
 use super::{PinCS, PinsNoCS, SpiBus, SpiConfig, SpiSharedDevice, SpiX};
@@ -18,15 +19,17 @@ where
     }
 
     /// Create a new shared device on this SPI bus.
-    pub fn new_device<'bus, CS>(
+    pub fn new_device<'bus, CS, D>(
         &'bus self,
         cs: CS,
         config: &SpiConfig,
-    ) -> SpiSharedDevice<'bus, SPI, PINS, CS>
+        delay: D,
+    ) -> SpiSharedDevice<'bus, SPI, PINS, CS, D>
     where
         CS: PinCS<SPI>,
+        D: DelayNs,
     {
-        SpiSharedDevice::new(self, cs, config)
+        SpiSharedDevice::new(self, cs, config, delay)
     }
 }
 

src/spi/shared_device.rs

@@ -1,33 +1,39 @@
 use core::convert::Infallible;
 
-use embedded_hal::spi::{ErrorType, Operation, SpiBus, SpiDevice};
+use embedded_hal::{
+    delay::DelayNs,
+    spi::{ErrorType, Operation, SpiBus, SpiDevice},
+};
 use riscv::interrupt;
 
 use super::{PinCS, Pins, PinsNoCS, SharedBus, SpiConfig, SpiX};
 
 /// SPI shared device abstraction
-pub struct SpiSharedDevice<'bus, SPI, PINS, CS> {
+pub struct SpiSharedDevice<'bus, SPI, PINS, CS, D> {
     bus: &'bus SharedBus<SPI, PINS>,
     cs: CS,
     config: SpiConfig,
+    delay: D,
 }
 
-impl<'bus, SPI, PINS, CS> SpiSharedDevice<'bus, SPI, PINS, CS>
+impl<'bus, SPI, PINS, CS, D> SpiSharedDevice<'bus, SPI, PINS, CS, D>
 where
     SPI: SpiX,
     PINS: PinsNoCS<SPI>,
     CS: PinCS<SPI>,
+    D: DelayNs,
 {
     /// Create shared [SpiSharedDevice] using the existing [SharedBus]
     /// and given [SpiConfig]. The config gets cloned.
-    pub fn new(bus: &'bus SharedBus<SPI, PINS>, cs: CS, config: &SpiConfig) -> Self
+    pub fn new(bus: &'bus SharedBus<SPI, PINS>, cs: CS, config: &SpiConfig, delay: D) -> Self
     where
         PINS: PinsNoCS<SPI>,
     {
         Self {
             bus,
             cs,
             config: config.clone(),
+            delay,
         }
     }
 
@@ -55,20 +61,22 @@ where
     }
 }
 
-impl<SPI, PINS, CS> ErrorType for SpiSharedDevice<'_, SPI, PINS, CS>
+impl<SPI, PINS, CS, D> ErrorType for SpiSharedDevice<'_, SPI, PINS, CS, D>
 where
     SPI: SpiX,
     PINS: Pins<SPI>,
     CS: PinCS<SPI>,
+    D: DelayNs,
 {
     type Error = Infallible;
 }
 
-impl<SPI, PINS, CS> SpiDevice for SpiSharedDevice<'_, SPI, PINS, CS>
+impl<SPI, PINS, CS, D> SpiDevice for SpiSharedDevice<'_, SPI, PINS, CS, D>
 where
     SPI: SpiX,
     PINS: Pins<SPI>,
     CS: PinCS<SPI>,
+    D: DelayNs,
 {
     fn transaction(&mut self, operations: &mut [Operation<'_, u8>]) -> Result<(), Infallible> {
         interrupt::free(|| {
@@ -79,12 +87,12 @@ where
             bus.start_frame();
             for operation in operations {
                 match operation {
-                    Operation::Read(words) => bus.read(words),
-                    Operation::Write(words) => bus.write(words),
-                    Operation::Transfer(read, write) => bus.transfer(read, write),
-                    Operation::TransferInPlace(words) => bus.transfer_in_place(words),
-                    Operation::DelayNs(_ns) => Ok(()), // TODO: NOOP?
-                }?;
+                    Operation::Read(words) => bus.read(words)?,
+                    Operation::Write(words) => bus.write(words)?,
+                    Operation::Transfer(read, write) => bus.transfer(read, write)?,
+                    Operation::TransferInPlace(words) => bus.transfer_in_place(words)?,
+                    Operation::DelayNs(ns) => self.delay.delay_ns(*ns),
+                };
             }
             bus.end_frame();