spi: Update to new api

Author: GrantM11235

spi/Cargo.toml

@@ -20,4 +20,3 @@ all-features = true
 [dependencies]
 embedded-hal = "0.2.3"
 display-interface = "0.4"
-byte-slice-cast = { version = "0.3.5", default-features = false }

spi/src/lib.rs

@@ -5,105 +5,31 @@
 use embedded_hal as hal;
 use hal::digital::v2::OutputPin;
 
-use display_interface::{DataFormat, DisplayError, WriteOnlyDataCommand};
+use display_interface::{DisplayError, WriteOnlyDataCommand};
 
-fn send_u8<SPI: hal::blocking::spi::Write<u8>>(
+fn send_iter<SPI: hal::blocking::spi::Write<u8>, I: Iterator<Item = u8>>(
     spi: &mut SPI,
-    words: DataFormat<'_>,
+    iter: I,
 ) -> Result<(), DisplayError> {
-    match words {
-        DataFormat::U8(slice) => spi.write(slice).map_err(|_| DisplayError::BusWriteError),
-        DataFormat::U16(slice) => {
-            use byte_slice_cast::*;
-            spi.write(slice.as_byte_slice())
-                .map_err(|_| DisplayError::BusWriteError)
-        }
-        DataFormat::U16LE(slice) => {
-            use byte_slice_cast::*;
-            for v in slice.as_mut() {
-                *v = v.to_le();
-            }
-            spi.write(slice.as_byte_slice())
-                .map_err(|_| DisplayError::BusWriteError)
-        }
-        DataFormat::U16BE(slice) => {
-            use byte_slice_cast::*;
-            for v in slice.as_mut() {
-                *v = v.to_be();
-            }
-            spi.write(slice.as_byte_slice())
-                .map_err(|_| DisplayError::BusWriteError)
-        }
-        DataFormat::U8Iter(iter) => {
-            let mut buf = [0; 32];
-            let mut i = 0;
-
-            for v in iter.into_iter() {
-                buf[i] = v;
-                i += 1;
-
-                if i == buf.len() {
-                    spi.write(&buf).map_err(|_| DisplayError::BusWriteError)?;
-                    i = 0;
-                }
-            }
-
-            if i > 0 {
-                spi.write(&buf[..i])
-                    .map_err(|_| DisplayError::BusWriteError)?;
-            }
-
-            Ok(())
-        }
-        DataFormat::U16LEIter(iter) => {
-            use byte_slice_cast::*;
-            let mut buf = [0; 32];
-            let mut i = 0;
-
-            for v in iter.map(u16::to_le) {
-                buf[i] = v;
-                i += 1;
-
-                if i == buf.len() {
-                    spi.write(&buf.as_byte_slice())
-                        .map_err(|_| DisplayError::BusWriteError)?;
-                    i = 0;
-                }
-            }
-
-            if i > 0 {
-                spi.write(&buf[..i].as_byte_slice())
-                    .map_err(|_| DisplayError::BusWriteError)?;
-            }
-
-            Ok(())
-        }
-        DataFormat::U16BEIter(iter) => {
-            use byte_slice_cast::*;
-            let mut buf = [0; 64];
-            let mut i = 0;
-            let len = buf.len();
-
-            for v in iter.map(u16::to_be) {
-                buf[i] = v;
-                i += 1;
-
-                if i == len {
-                    spi.write(&buf.as_byte_slice())
-                        .map_err(|_| DisplayError::BusWriteError)?;
-                    i = 0;
-                }
-            }
-
-            if i > 0 {
-                spi.write(&buf[..i].as_byte_slice())
-                    .map_err(|_| DisplayError::BusWriteError)?;
-            }
-
-            Ok(())
+    let mut buf = [0; 32];
+    let mut i = 0;
+
+    for v in iter {
+        buf[i] = v;
+        i += 1;
+
+        if i == buf.len() {
+            spi.write(&buf).map_err(|_| DisplayError::BusWriteError)?;
+            i = 0;
         }
-        _ => Err(DisplayError::DataFormatNotImplemented),
     }
+
+    if i > 0 {
+        spi.write(&buf[..i])
+            .map_err(|_| DisplayError::BusWriteError)?;
+    }
+
+    Ok(())
 }
 
 /// SPI display interface.
@@ -139,31 +65,41 @@ where
     DC: OutputPin,
     CS: OutputPin,
 {
-    fn send_commands(&mut self, cmds: DataFormat<'_>) -> Result<(), DisplayError> {
+    type Word = u8;
+
+    #[inline]
+    fn send_command_iter<I>(&mut self, iter: I) -> Result<(), DisplayError>
+    where
+        I: Iterator<Item = Self::Word>,
+    {
         // Assert chip select pin
         self.cs.set_low().map_err(|_| DisplayError::CSError)?;
 
         // 1 = data, 0 = command
         self.dc.set_low().map_err(|_| DisplayError::DCError)?;
 
         // Send words over SPI
-        let err = send_u8(&mut self.spi, cmds);
+        let err = send_iter(&mut self.spi, iter);
 
         // Deassert chip select pin
         self.cs.set_high().ok();
 
         err
     }
 
-    fn send_data(&mut self, buf: DataFormat<'_>) -> Result<(), DisplayError> {
+    #[inline]
+    fn send_data_iter<I>(&mut self, iter: I) -> Result<(), DisplayError>
+    where
+        I: Iterator<Item = Self::Word>,
+    {
         // Assert chip select pin
         self.cs.set_low().map_err(|_| DisplayError::CSError)?;
 
         // 1 = data, 0 = command
         self.dc.set_high().map_err(|_| DisplayError::DCError)?;
 
         // Send words over SPI
-        let err = send_u8(&mut self.spi, buf);
+        let err = send_iter(&mut self.spi, iter);
 
         // Deassert chip select pin
         self.cs.set_high().ok();
@@ -202,19 +138,29 @@ where
     SPI: hal::blocking::spi::Write<u8>,
     DC: OutputPin,
 {
-    fn send_commands(&mut self, cmds: DataFormat<'_>) -> Result<(), DisplayError> {
+    type Word = u8;
+
+    #[inline]
+    fn send_command_iter<I>(&mut self, iter: I) -> Result<(), DisplayError>
+    where
+        I: Iterator<Item = Self::Word>,
+    {
         // 1 = data, 0 = command
         self.dc.set_low().map_err(|_| DisplayError::DCError)?;
 
         // Send words over SPI
-        send_u8(&mut self.spi, cmds)
+        send_iter(&mut self.spi, iter)
     }
 
-    fn send_data(&mut self, buf: DataFormat<'_>) -> Result<(), DisplayError> {
+    #[inline]
+    fn send_data_iter<I>(&mut self, iter: I) -> Result<(), DisplayError>
+    where
+        I: Iterator<Item = Self::Word>,
+    {
         // 1 = data, 0 = command
         self.dc.set_high().map_err(|_| DisplayError::DCError)?;
 
         // Send words over SPI
-        send_u8(&mut self.spi, buf)
+        send_iter(&mut self.spi, iter)
     }
 }