Add a ReadWriteInterface for displays.

spi/Cargo.toml

@@ -19,5 +19,5 @@ all-features = true
 
 [dependencies]
 embedded-hal = "0.2.3"
-display-interface = "0.4"
+display-interface = { git = "https://github.com/chrismoos/display-interface", branch = "rw-interface"}
 byte-slice-cast = { version = "0.3.5", default-features = false }

spi/src/lib.rs

@@ -5,6 +5,7 @@
 use embedded_hal as hal;
 use hal::digital::v2::OutputPin;
 
+use display_interface::v2::{ReadInterface, WriteInterface, WriteMode};
 use display_interface::{DataFormat, DisplayError, WriteOnlyDataCommand};
 
 fn send_u8<SPI: hal::blocking::spi::Write<u8>>(
@@ -133,6 +134,95 @@ where
     }
 }
 
+impl<SPI, DC, CS> ReadInterface<u8> for SPIInterface<SPI, DC, CS>
+where
+    SPI: hal::spi::FullDuplex<u8>,
+    DC: OutputPin,
+    CS: OutputPin,
+{
+    fn read_stream(&mut self, f: &mut dyn FnMut(u8) -> bool) -> Result<(), DisplayError> {
+        // Assert chip select pin
+        self.cs.set_low().map_err(|_| DisplayError::CSError)?;
+
+        // 1 = data for reads
+        self.dc.set_high().map_err(|_| DisplayError::DCError)?;
+
+        loop {
+            let b = self.spi.read().map_err(|_| DisplayError::BusReadError)?;
+            if !f(b) {
+                break;
+            }
+        }
+
+        // Deassert chip select pin
+        self.cs.set_high().map_err(|_| DisplayError::CSError)
+    }
+}
+
+impl<SPI, DC, CS> WriteInterface<u8> for SPIInterface<SPI, DC, CS>
+where
+    SPI: hal::blocking::spi::Write<u8>,
+    DC: OutputPin,
+    CS: OutputPin,
+{
+    fn write(&mut self, mode: WriteMode, buf: &[u8]) -> Result<(), DisplayError> {
+        // Assert chip select pin
+        self.cs.set_low().map_err(|_| DisplayError::CSError)?;
+
+        // 1 = data, 0 = command
+        match mode {
+            WriteMode::Command => {
+                self.dc.set_low().map_err(|_| DisplayError::DCError)?;
+            }
+            WriteMode::Data => {
+                self.dc.set_high().map_err(|_| DisplayError::DCError)?;
+            }
+        }
+
+        self.spi
+            .write(buf)
+            .map_err(|_| DisplayError::BusWriteError)?;
+
+        // Deassert chip select pin
+        self.cs.set_high().map_err(|_| DisplayError::CSError)
+    }
+
+    fn write_stream<'a>(
+        &mut self,
+        mode: WriteMode,
+        func: &mut dyn FnMut() -> Option<&'a u8>,
+    ) -> Result<(), DisplayError> {
+        // Assert chip select pin
+        self.cs.set_low().map_err(|_| DisplayError::CSError)?;
+
+        // 1 = data, 0 = command
+        match mode {
+            WriteMode::Command => {
+                self.dc.set_low().map_err(|_| DisplayError::DCError)?;
+            }
+            WriteMode::Data => {
+                self.dc.set_high().map_err(|_| DisplayError::DCError)?;
+            }
+        }
+
+        loop {
+            match func() {
+                Some(b) => {
+                    self.spi
+                        .write(&[*b])
+                        .map_err(|_| DisplayError::BusWriteError)?;
+                }
+                None => {
+                    break;
+                }
+            }
+        }
+
+        // Deassert chip select pin
+        self.cs.set_high().map_err(|_| DisplayError::CSError)
+    }
+}
+
 impl<SPI, DC, CS> WriteOnlyDataCommand for SPIInterface<SPI, DC, CS>
 where
     SPI: hal::blocking::spi::Write<u8>,

src/lib.rs

@@ -18,6 +18,8 @@ pub enum DisplayError {
     InvalidFormatError,
     /// Unable to write to bus
     BusWriteError,
+    // Unable to read from bus
+    BusReadError,
     /// Unable to assert or de-assert data/command switching signal
     DCError,
     /// Unable to assert chip select signal
@@ -57,3 +59,5 @@ pub trait WriteOnlyDataCommand {
     /// Send pixel data to display
     fn send_data(&mut self, buf: DataFormat<'_>) -> Result<(), DisplayError>;
 }
+
+pub mod v2;

src/v2.rs

@@ -0,0 +1,88 @@
+use crate::DisplayError;
+
+#[derive(Clone, Debug)]
+pub enum WriteMode {
+    Data,
+    Command,
+}
+
+pub trait WriteInterface<DataFormat> {
+    fn write(&mut self, mode: WriteMode, buf: &[DataFormat]) -> Result<(), DisplayError> {
+        self.write_iter(mode, &mut buf.into_iter())
+    }
+
+    fn write_iter(
+        &mut self,
+        mode: WriteMode,
+        iter: &mut dyn Iterator<Item = &DataFormat>,
+    ) -> Result<(), DisplayError> {
+        self.write_stream(mode, &mut || iter.next())
+    }
+
+    fn write_stream<'a>(
+        &mut self,
+        mode: WriteMode,
+        func: &mut dyn FnMut() -> Option<&'a DataFormat>,
+    ) -> Result<(), DisplayError>;
+}
+
+pub trait ReadInterface<DataFormat> {
+    fn read(&mut self, buf: &mut [DataFormat]) -> Result<(), DisplayError> {
+        let mut n = 0;
+        self.read_stream(&mut |b| {
+            if n == buf.len() {
+                return false;
+            }
+            buf[n] = b;
+            n += 1;
+            true
+        })
+    }
+
+    fn read_stream(&mut self, f: &mut dyn FnMut(DataFormat) -> bool) -> Result<(), DisplayError>;
+}
+
+pub trait ReadWriteInterface<T>: ReadInterface<T> + WriteInterface<T> {}
+impl<DataFormat, T> ReadWriteInterface<DataFormat> for T where
+    T: ReadInterface<DataFormat> + WriteInterface<DataFormat>
+{
+}
+
+pub struct ReadIterator<'a, DataFormat> {
+    reader: &'a mut dyn ReadInterface<DataFormat>,
+}
+
+impl<'a, DataFormat> ReadIterator<'a, DataFormat> {
+    fn new(reader: &'a mut dyn ReadInterface<DataFormat>) -> ReadIterator<'a, DataFormat> {
+        ReadIterator { reader: reader }
+    }
+}
+
+impl<'a, DataFormat> Iterator for ReadIterator<'a, DataFormat>
+where
+    DataFormat: Default,
+{
+    type Item = Result<DataFormat, DisplayError>;
+    fn next(&mut self) -> Option<Self::Item> {
+        let mut next: DataFormat = Default::default();
+        match self.reader.read_stream(&mut |b| {
+            next = b;
+            false
+        }) {
+            Ok(_) => Some(Ok(next)),
+            Err(e) => Some(Err(e)),
+        }
+    }
+}
+
+impl<'a, DataFormat> IntoIterator for &'a mut dyn ReadInterface<DataFormat>
+where
+    DataFormat: Default,
+{
+    type Item = Result<DataFormat, DisplayError>;
+    type IntoIter = ReadIterator<'a, DataFormat>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        ReadIterator::new(self)
+    }
+}