Added docs & made errors public

Author: caemor

src/i2c.rs

@@ -124,6 +124,7 @@ mod embedded_hal_impl {
     }
 }
 
+/// Error type wrapping [LinuxI2CError](i2cdev::linux::LinuxI2CError) to implement [embedded_hal::i2c::ErrorKind]
 #[derive(Debug)]
 pub struct I2CError {
     err: i2cdev::linux::LinuxI2CError,

src/lib.rs

@@ -46,7 +46,7 @@ mod spi;
 mod timer;
 
 pub use crate::delay::Delay;
-pub use crate::i2c::I2cdev;
-pub use crate::serial::Serial;
-pub use crate::spi::Spidev;
+pub use crate::i2c::{I2CError, I2cdev};
+pub use crate::serial::{Serial, SerialError};
+pub use crate::spi::{SPIError, Spidev};
 pub use crate::timer::SysTimer;

src/serial.rs

@@ -20,17 +20,17 @@ impl Serial {
 }
 
 /// Helper to convert std::io::Error to the nb::Error
-fn translate_io_errors(err: std::io::Error) -> nb::Error<IoError> {
+fn translate_io_errors(err: std::io::Error) -> nb::Error<SerialError> {
     match err.kind() {
         IoErrorKind::WouldBlock | IoErrorKind::TimedOut | IoErrorKind::Interrupted => {
             nb::Error::WouldBlock
         }
-        err => nb::Error::Other(IoError { err }),
+        err => nb::Error::Other(SerialError { err }),
     }
 }
 
 impl embedded_hal::serial::nb::Read<u8> for Serial {
-    type Error = IoError;
+    type Error = SerialError;
 
     fn read(&mut self) -> nb::Result<u8, Self::Error> {
         let mut buffer = [0; 1];
@@ -44,7 +44,7 @@ impl embedded_hal::serial::nb::Read<u8> for Serial {
 }
 
 impl embedded_hal::serial::nb::Write<u8> for Serial {
-    type Error = IoError;
+    type Error = SerialError;
 
     fn write(&mut self, word: u8) -> nb::Result<(), Self::Error> {
         self.0.write(&[word]).map_err(translate_io_errors)?;
@@ -56,12 +56,13 @@ impl embedded_hal::serial::nb::Write<u8> for Serial {
     }
 }
 
+/// Error type wrapping [io::ErrorKind](IoErrorKind) to implement [embedded_hal::serial::ErrorKind]
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct IoError {
+pub struct SerialError {
     err: IoErrorKind,
 }
 
-impl embedded_hal::serial::Error for IoError {
+impl embedded_hal::serial::Error for SerialError {
     fn kind(&self) -> embedded_hal::serial::ErrorKind {
         use embedded_hal::serial::ErrorKind::*;
         match &self.err {

src/spi.rs

@@ -47,37 +47,37 @@ mod embedded_hal_impl {
     use std::io::Write as _;
 
     impl Transfer<u8> for Spidev {
-        type Error = IoError;
+        type Error = SPIError;
 
         fn transfer<'b>(&mut self, read: &'b mut [u8], write: &[u8]) -> Result<(), Self::Error> {
             self.0
                 .transfer(&mut SpidevTransfer::read_write(&write, read))
-                .map_err(|err| IoError { err })
+                .map_err(|err| SPIError { err })
         }
     }
 
     impl TransferInplace<u8> for Spidev {
-        type Error = IoError;
+        type Error = SPIError;
 
         fn transfer_inplace<'b>(&mut self, buffer: &'b mut [u8]) -> Result<(), Self::Error> {
             let tx = buffer.to_owned();
             self.0
                 .transfer(&mut SpidevTransfer::read_write(&tx, buffer))
-                .map_err(|err| IoError { err })
+                .map_err(|err| SPIError { err })
         }
     }
 
     impl Write<u8> for Spidev {
-        type Error = IoError;
+        type Error = SPIError;
 
         fn write(&mut self, buffer: &[u8]) -> Result<(), Self::Error> {
-            self.0.write_all(buffer).map_err(|err| IoError { err })
+            self.0.write_all(buffer).map_err(|err| SPIError { err })
         }
     }
 
     /// Transactional implementation batches SPI operations into a single transaction
     impl Transactional<u8> for Spidev {
-        type Error = IoError;
+        type Error = SPIError;
 
         fn exec<'a>(&mut self, operations: &mut [SpiOperation<'a, u8>]) -> Result<(), Self::Error> {
             // Map types from generic to linux objects
@@ -105,23 +105,24 @@ mod embedded_hal_impl {
             // Execute transfer
             self.0
                 .transfer_multiple(&mut messages)
-                .map_err(|err| IoError { err })
+                .map_err(|err| SPIError { err })
         }
     }
 }
 
+/// Error type wrapping [io::Error](io::Error) to implement [embedded_hal::spi::ErrorKind]
 #[derive(Debug)]
-pub struct IoError {
+pub struct SPIError {
     err: io::Error,
 }
 
-impl From<io::Error> for IoError {
+impl From<io::Error> for SPIError {
     fn from(err: io::Error) -> Self {
         Self { err }
     }
 }
 
-impl embedded_hal::spi::Error for IoError {
+impl embedded_hal::spi::Error for SPIError {
     fn kind(&self) -> embedded_hal::spi::ErrorKind {
         use embedded_hal::spi::ErrorKind::*;
         match self.err.kind() {