spi nb

Author: burrbull

src/spi.rs

@@ -34,11 +34,11 @@
 */
 
 mod hal_02;
+mod hal_1;
 
 use core::ops::Deref;
 
 use crate::pac::{self, RCC};
-pub use embedded_hal_02::spi::{Mode, Phase, Polarity};
 
 use crate::afio::MAPR;
 use crate::dma::dma1;
@@ -52,6 +52,33 @@ use crate::time::Hertz;
 use core::sync::atomic::{self, Ordering};
 use embedded_dma::{ReadBuffer, WriteBuffer};
 
+/// Clock polarity
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Polarity {
+    /// Clock signal low when idle
+    IdleLow,
+    /// Clock signal high when idle
+    IdleHigh,
+}
+
+/// Clock phase
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Phase {
+    /// Data in "captured" on the first clock transition
+    CaptureOnFirstTransition,
+    /// Data in "captured" on the second clock transition
+    CaptureOnSecondTransition,
+}
+
+/// SPI mode
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Mode {
+    /// Clock polarity
+    pub polarity: Polarity,
+    /// Clock phase
+    pub phase: Phase,
+}
+
 /// Interrupt event
 pub enum Event {
     /// New data has been received
@@ -601,6 +628,46 @@ where
     }
 }
 
+impl<SPI, REMAP, PINS, FrameSize, OP> Spi<SPI, REMAP, PINS, FrameSize, OP>
+where
+    SPI: Instance,
+    FrameSize: Copy,
+{
+    pub fn read_nonblocking(&mut self) -> nb::Result<FrameSize, Error> {
+        let sr = self.spi.sr.read();
+
+        Err(if sr.ovr().bit_is_set() {
+            Error::Overrun.into()
+        } else if sr.modf().bit_is_set() {
+            Error::ModeFault.into()
+        } else if sr.crcerr().bit_is_set() {
+            Error::Crc.into()
+        } else if sr.rxne().bit_is_set() {
+            // NOTE(read_volatile) read only 1 byte (the svd2rust API only allows
+            // reading a half-word)
+            return Ok(self.read_data_reg());
+        } else {
+            nb::Error::WouldBlock
+        })
+    }
+    pub fn write_nonblocking(&mut self, data: FrameSize) -> nb::Result<(), Error> {
+        let sr = self.spi.sr.read();
+
+        // NOTE: Error::Overrun was deleted in #408. Need check
+        Err(if sr.modf().bit_is_set() {
+            Error::ModeFault.into()
+        } else if sr.crcerr().bit_is_set() {
+            Error::Crc.into()
+        } else if sr.txe().bit_is_set() {
+            // NOTE(write_volatile) see note above
+            self.write_data_reg(data);
+            return Ok(());
+        } else {
+            nb::Error::WouldBlock
+        })
+    }
+}
+
 // DMA
 
 pub type SpiTxDma<SPI, REMAP, PINS, OP, CHANNEL> = TxDma<Spi<SPI, REMAP, PINS, u8, OP>, CHANNEL>;

src/spi/hal_02.rs

@@ -1,7 +1,35 @@
 use super::*;
 
+pub use embedded_hal_02::spi::{Mode, Phase, Polarity};
 use embedded_hal_02::{blocking::spi as blocking, spi};
 
+impl From<Polarity> for super::Polarity {
+    fn from(p: Polarity) -> Self {
+        match p {
+            Polarity::IdleLow => Self::IdleLow,
+            Polarity::IdleHigh => Self::IdleHigh,
+        }
+    }
+}
+
+impl From<Phase> for super::Phase {
+    fn from(p: Phase) -> Self {
+        match p {
+            Phase::CaptureOnFirstTransition => Self::CaptureOnFirstTransition,
+            Phase::CaptureOnSecondTransition => Self::CaptureOnSecondTransition,
+        }
+    }
+}
+
+impl From<Mode> for super::Mode {
+    fn from(m: Mode) -> Self {
+        Self {
+            polarity: m.polarity.into(),
+            phase: m.phase.into(),
+        }
+    }
+}
+
 impl<SPI, REMAP, PINS, FrameSize, OP> spi::FullDuplex<FrameSize>
     for Spi<SPI, REMAP, PINS, FrameSize, OP>
 where
@@ -11,38 +39,11 @@ where
     type Error = Error;
 
     fn read(&mut self) -> nb::Result<FrameSize, Error> {
-        let sr = self.spi.sr.read();
-
-        Err(if sr.ovr().bit_is_set() {
-            Error::Overrun.into()
-        } else if sr.modf().bit_is_set() {
-            Error::ModeFault.into()
-        } else if sr.crcerr().bit_is_set() {
-            Error::Crc.into()
-        } else if sr.rxne().bit_is_set() {
-            // NOTE(read_volatile) read only 1 byte (the svd2rust API only allows
-            // reading a half-word)
-            return Ok(self.read_data_reg());
-        } else {
-            nb::Error::WouldBlock
-        })
+        self.read_nonblocking()
     }
 
     fn send(&mut self, data: FrameSize) -> nb::Result<(), Error> {
-        let sr = self.spi.sr.read();
-
-        // NOTE: Error::Overrun was deleted in #408. Need check
-        Err(if sr.modf().bit_is_set() {
-            Error::ModeFault.into()
-        } else if sr.crcerr().bit_is_set() {
-            Error::Crc.into()
-        } else if sr.txe().bit_is_set() {
-            // NOTE(write_volatile) see note above
-            self.write_data_reg(data);
-            return Ok(());
-        } else {
-            nb::Error::WouldBlock
-        })
+        self.write_nonblocking(data)
     }
 }
 

src/spi/hal_1.rs

@@ -0,0 +1,62 @@
+use super::*;
+pub use embedded_hal::spi::{ErrorKind, ErrorType, Mode, Phase, Polarity};
+
+impl From<Polarity> for super::Polarity {
+    fn from(p: Polarity) -> Self {
+        match p {
+            Polarity::IdleLow => Self::IdleLow,
+            Polarity::IdleHigh => Self::IdleHigh,
+        }
+    }
+}
+
+impl From<Phase> for super::Phase {
+    fn from(p: Phase) -> Self {
+        match p {
+            Phase::CaptureOnFirstTransition => Self::CaptureOnFirstTransition,
+            Phase::CaptureOnSecondTransition => Self::CaptureOnSecondTransition,
+        }
+    }
+}
+
+impl From<Mode> for super::Mode {
+    fn from(m: Mode) -> Self {
+        Self {
+            polarity: m.polarity.into(),
+            phase: m.phase.into(),
+        }
+    }
+}
+
+impl embedded_hal::spi::Error for Error {
+    fn kind(&self) -> ErrorKind {
+        match self {
+            Self::Overrun => ErrorKind::Overrun,
+            Self::ModeFault => ErrorKind::ModeFault,
+            Self::Crc => ErrorKind::Other,
+        }
+    }
+}
+
+impl<SPI: Instance, REMAP, PINS, FrameSize, OP> ErrorType for Spi<SPI, REMAP, PINS, FrameSize, OP> {
+    type Error = Error;
+}
+
+mod nb {
+    use super::{Error, Instance, Spi};
+    use embedded_hal_nb::spi::FullDuplex;
+
+    impl<SPI, REMAP, PINS, FrameSize, OP> FullDuplex<FrameSize> for Spi<SPI, REMAP, PINS, FrameSize, OP>
+    where
+        SPI: Instance,
+        FrameSize: Copy,
+    {
+        fn read(&mut self) -> nb::Result<FrameSize, Error> {
+            self.read_nonblocking()
+        }
+
+        fn write(&mut self, data: FrameSize) -> nb::Result<(), Error> {
+            self.write_nonblocking(data)
+        }
+    }
+}