Forward communication errors

Author: eldruin

src/builder.rs

@@ -96,9 +96,9 @@ impl Builder {
     }
 
     /// Finish the builder and use I2C to communicate with the display
-    pub fn connect_i2c<I2C>(&self, i2c: I2C) -> DisplayMode<RawMode<I2cInterface<I2C>>>
+    pub fn connect_i2c<I2C, CommE>(&self, i2c: I2C) -> DisplayMode<RawMode<I2cInterface<I2C>>>
     where
-        I2C: hal::blocking::i2c::Write,
+        I2C: hal::blocking::i2c::Write<Error = CommE>,
     {
         let properties = DisplayProperties::new(
             I2cInterface::new(i2c, self.i2c_addr),
@@ -109,13 +109,14 @@ impl Builder {
     }
 
     /// Finish the builder and use SPI to communicate with the display
-    pub fn connect_spi<SPI, DC>(
+    pub fn connect_spi<SPI, DC, CommE>(
         &self,
         spi: SPI,
         dc: DC,
     ) -> DisplayMode<RawMode<SpiInterface<SPI, DC>>>
     where
-        SPI: hal::blocking::spi::Transfer<u8> + hal::blocking::spi::Write<u8>,
+        SPI: hal::blocking::spi::Transfer<u8, Error = CommE>
+            + hal::blocking::spi::Write<u8, Error = CommE>,
         DC: OutputPin,
     {
         let properties =

src/command.rs

@@ -84,7 +84,7 @@ pub enum Command {
 
 impl Command {
     /// Send command to SSD1306
-    pub fn send<DI>(self, iface: &mut DI) -> Result<(), ()>
+    pub fn send<DI>(self, iface: &mut DI) -> Result<(), DI::Error>
     where
         DI: DisplayInterface,
     {
@@ -156,9 +156,7 @@ impl Command {
         };
 
         // Send command over the interface
-        iface.send_commands(&data[0..len])?;
-
-        Ok(())
+        iface.send_commands(&data[0..len])
     }
 }
 

src/interface/i2c.rs

@@ -3,6 +3,7 @@
 use hal;
 
 use super::DisplayInterface;
+use crate::Error;
 
 // TODO: Add to prelude
 /// SSD1306 I2C communication interface
@@ -11,33 +12,33 @@ pub struct I2cInterface<I2C> {
     addr: u8,
 }
 
-impl<I2C> I2cInterface<I2C>
+impl<I2C, CommE> I2cInterface<I2C>
 where
-    I2C: hal::blocking::i2c::Write,
+    I2C: hal::blocking::i2c::Write<Error = CommE>,
 {
     /// Create new SSD1306 I2C interface
     pub fn new(i2c: I2C, addr: u8) -> Self {
         Self { i2c, addr }
     }
 }
 
-impl<I2C> DisplayInterface for I2cInterface<I2C>
+impl<I2C, CommE> DisplayInterface for I2cInterface<I2C>
 where
-    I2C: hal::blocking::i2c::Write,
+    I2C: hal::blocking::i2c::Write<Error = CommE>,
 {
-    fn send_commands(&mut self, cmds: &[u8]) -> Result<(), ()> {
+    type Error = Error<CommE>;
+
+    fn send_commands(&mut self, cmds: &[u8]) -> Result<(), Self::Error> {
         // Copy over given commands to new aray to prefix with command identifier
         let mut writebuf: [u8; 8] = [0; 8];
         writebuf[1..=cmds.len()].copy_from_slice(&cmds[0..cmds.len()]);
 
         self.i2c
             .write(self.addr, &writebuf[..=cmds.len()])
-            .map_err(|_| ())?;
-
-        Ok(())
+            .map_err(Error::Comm)
     }
 
-    fn send_data(&mut self, buf: &[u8]) -> Result<(), ()> {
+    fn send_data(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
         // Noop if the data buffer is empty
         if buf.is_empty() {
             return Ok(());
@@ -57,7 +58,7 @@ where
 
             self.i2c
                 .write(self.addr, &writebuf[..=chunklen])
-                .map_err(|_| ())?;
+                .map_err(Error::Comm)?;
         }
 
         Ok(())

src/interface/mod.rs

@@ -56,10 +56,12 @@ pub mod spi;
 
 /// A method of communicating with SSD1306
 pub trait DisplayInterface {
+    /// Interface error type
+    type Error;
     /// Send a batch of up to 8 commands to display.
-    fn send_commands(&mut self, cmd: &[u8]) -> Result<(), ()>;
+    fn send_commands(&mut self, cmd: &[u8]) -> Result<(), Self::Error>;
     /// Send data to display.
-    fn send_data(&mut self, buf: &[u8]) -> Result<(), ()>;
+    fn send_data(&mut self, buf: &[u8]) -> Result<(), Self::Error>;
 }
 
 pub use self::i2c::I2cInterface;

src/interface/spi.rs

@@ -4,6 +4,7 @@ use hal;
 use hal::digital::OutputPin;
 
 use super::DisplayInterface;
+use crate::Error;
 
 // TODO: Add to prelude
 /// SPI display interface.
@@ -14,9 +15,9 @@ pub struct SpiInterface<SPI, DC> {
     dc: DC,
 }
 
-impl<SPI, DC> SpiInterface<SPI, DC>
+impl<SPI, DC, CommE> SpiInterface<SPI, DC>
 where
-    SPI: hal::blocking::spi::Write<u8>,
+    SPI: hal::blocking::spi::Write<u8, Error = CommE>,
     DC: OutputPin,
 {
     /// Create new SPI interface for communciation with SSD1306
@@ -25,27 +26,28 @@ where
     }
 }
 
-impl<SPI, DC> DisplayInterface for SpiInterface<SPI, DC>
+impl<SPI, DC, CommE> DisplayInterface for SpiInterface<SPI, DC>
 where
-    SPI: hal::blocking::spi::Write<u8>,
+    SPI: hal::blocking::spi::Write<u8, Error = CommE>,
     DC: OutputPin,
 {
-    fn send_commands(&mut self, cmds: &[u8]) -> Result<(), ()> {
+    type Error = Error<CommE>;
+
+    fn send_commands(&mut self, cmds: &[u8]) -> Result<(), Self::Error> {
         self.dc.set_low();
 
-        self.spi.write(&cmds).map_err(|_| ())?;
+        self.spi.write(&cmds).map_err(Error::Comm)?;
 
         self.dc.set_high();
 
         Ok(())
     }
 
-    fn send_data(&mut self, buf: &[u8]) -> Result<(), ()> {
+    fn send_data(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
         // 1 = data, 0 = command
         self.dc.set_high();
 
-        self.spi.write(&buf).map_err(|_| ())?;
 
-        Ok(())
+        self.spi.write(&buf).map_err(Error::Comm)
     }
 }

src/lib.rs

@@ -166,6 +166,13 @@
 #![deny(unused_import_braces)]
 #![deny(unused_qualifications)]
 
+/// Errors in this crate
+#[derive(Debug)]
+pub enum Error<CommE> {
+    /// Communication error
+    Comm(CommE),
+}
+
 extern crate embedded_hal as hal;
 
 pub mod builder;

src/mode/graphics.rs

@@ -76,7 +76,7 @@ where
     }
 
     /// Write out data to display
-    pub fn flush(&mut self) -> Result<(), ()> {
+    pub fn flush(&mut self) -> Result<(), DI::Error> {
         let display_size = self.properties.get_size();
 
         // Ensure the display buffer is at the origin of the display before we send the full frame
@@ -144,9 +144,8 @@ where
 
     /// Display is set up in column mode, i.e. a byte walks down a column of 8 pixels from
     /// column 0 on the left, to column _n_ on the right
-    pub fn init(&mut self) -> Result<(), ()> {
-        self.properties.init_column_mode()?;
-        Ok(())
+    pub fn init(&mut self) -> Result<(), DI::Error> {
+        self.properties.init_column_mode()
     }
 
     /// Get display dimensions, taking into account the current rotation of the display
@@ -155,7 +154,7 @@ where
     }
 
     /// Set the display rotation
-    pub fn set_rotation(&mut self, rot: DisplayRotation) -> Result<(), ()> {
+    pub fn set_rotation(&mut self, rot: DisplayRotation) -> Result<(), DI::Error> {
         self.properties.set_rotation(rot)
     }
 }

src/mode/terminal.rs

@@ -165,7 +165,7 @@ where
     DI: DisplayInterface,
 {
     /// Clear the display
-    pub fn clear(&mut self) -> Result<(), ()> {
+    pub fn clear(&mut self) -> Result<(), DI::Error> {
         let display_size = self.properties.get_size();
 
         let numchars = match display_size {
@@ -205,24 +205,22 @@ where
     }
 
     /// Print a character to the display
-    pub fn print_char<T>(&mut self, c: T) -> Result<(), ()>
+    pub fn print_char<T>(&mut self, c: T) -> Result<(), DI::Error>
     where
         TerminalMode<DI>: CharacterBitmap<T>,
     {
         // Send the pixel data to the display
-        self.properties.draw(&Self::to_bitmap(c))?;
-        Ok(())
+        self.properties.draw(&Self::to_bitmap(c))
     }
 
     /// Initialise the display in column mode (i.e. a byte walks down a column of 8 pixels) with
     /// column 0 on the left and column _(display_width - 1)_ on the right.
-    pub fn init(&mut self) -> Result<(), ()> {
-        self.properties.init_column_mode()?;
-        Ok(())
+    pub fn init(&mut self) -> Result<(), DI::Error> {
+        self.properties.init_column_mode()
     }
 
     /// Set the display rotation
-    pub fn set_rotation(&mut self, rot: DisplayRotation) -> Result<(), ()> {
+    pub fn set_rotation(&mut self, rot: DisplayRotation) -> Result<(), DI::Error> {
         self.properties.set_rotation(rot)
     }
 }

src/properties.rs

@@ -31,7 +31,7 @@ where
 
     /// Initialise the display in column mode (i.e. a byte walks down a column of 8 pixels) with
     /// column 0 on the left and column _(display_width - 1)_ on the right.
-    pub fn init_column_mode(&mut self) -> Result<(), ()> {
+    pub fn init_column_mode(&mut self) -> Result<(), DI::Error> {
         // TODO: Break up into nice bits so display modes can pick whathever they need
         let (_, display_height) = self.display_size.dimensions();
 
@@ -60,26 +60,22 @@ where
         Command::AllOn(false).send(&mut self.iface)?;
         Command::Invert(false).send(&mut self.iface)?;
         Command::EnableScroll(false).send(&mut self.iface)?;
-        Command::DisplayOn(true).send(&mut self.iface)?;
-
-        Ok(())
+        Command::DisplayOn(true).send(&mut self.iface)
     }
 
     /// Set the position in the framebuffer of the display where any sent data should be
     /// drawn. This method can be used for changing the affected area on the screen as well
     /// as (re-)setting the start point of the next `draw` call.
-    pub fn set_draw_area(&mut self, start: (u8, u8), end: (u8, u8)) -> Result<(), ()> {
+    pub fn set_draw_area(&mut self, start: (u8, u8), end: (u8, u8)) -> Result<(), DI::Error> {
         Command::ColumnAddress(start.0, end.0 - 1).send(&mut self.iface)?;
-        Command::PageAddress(start.1.into(), (end.1 - 1).into()).send(&mut self.iface)?;
-        Ok(())
+        Command::PageAddress(start.1.into(), (end.1 - 1).into()).send(&mut self.iface)
     }
 
     /// Send the data to the display for drawing at the current position in the framebuffer
     /// and advance the position accordingly. Cf. `set_draw_area` to modify the affected area by
     /// this method.
-    pub fn draw(&mut self, buffer: &[u8]) -> Result<(), ()> {
-        self.iface.send_data(&buffer)?;
-        Ok(())
+    pub fn draw(&mut self, buffer: &[u8]) -> Result<(), DI::Error> {
+        self.iface.send_data(&buffer)
     }
 
     /// Get the configured display size
@@ -131,28 +127,26 @@ where
     }
 
     /// Set the display rotation
-    pub fn set_rotation(&mut self, display_rotation: DisplayRotation) -> Result<(), ()> {
+    pub fn set_rotation(&mut self, display_rotation: DisplayRotation) -> Result<(), DI::Error> {
         self.display_rotation = display_rotation;
 
         match display_rotation {
             DisplayRotation::Rotate0 => {
                 Command::SegmentRemap(true).send(&mut self.iface)?;
-                Command::ReverseComDir(true).send(&mut self.iface)?;
+                Command::ReverseComDir(true).send(&mut self.iface)
             }
             DisplayRotation::Rotate90 => {
                 Command::SegmentRemap(false).send(&mut self.iface)?;
-                Command::ReverseComDir(true).send(&mut self.iface)?;
+                Command::ReverseComDir(true).send(&mut self.iface)
             }
             DisplayRotation::Rotate180 => {
                 Command::SegmentRemap(false).send(&mut self.iface)?;
-                Command::ReverseComDir(false).send(&mut self.iface)?;
+                Command::ReverseComDir(false).send(&mut self.iface)
             }
             DisplayRotation::Rotate270 => {
                 Command::SegmentRemap(true).send(&mut self.iface)?;
-                Command::ReverseComDir(false).send(&mut self.iface)?;
+                Command::ReverseComDir(false).send(&mut self.iface)
             }
-        };
-
-        Ok(())
+        }
     }
 }