use ErrorKind-like error names for I2c::Error

Author: burrbull

CHANGELOG.md

@@ -28,7 +28,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ### Added
 
 - Missing `DelayMs<u8>` / `DelayUs<u8>` impls for fugit::Delay
-- Support of embedded-hal 1.0.0-alpha.7
+- Support of embedded-hal 1.0.0-alpha.7 [#443]
 - Aliases for peripheral wrappers [#434]
 - `WithPwm` trait implemented for timers with channels (internals) [#425]
 - `Pwm` struct with `split` method and implementation of embedded-hal::Pwm (similar to f1xx-hal) [#425]
@@ -51,6 +51,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 [#438]: https://github.com/stm32-rs/stm32f4xx-hal/pull/438
 [#439]: https://github.com/stm32-rs/stm32f4xx-hal/pull/439
 [#440]: https://github.com/stm32-rs/stm32f4xx-hal/pull/440
+[#443]: https://github.com/stm32-rs/stm32f4xx-hal/pull/443
 
 ### Changed
 

src/fmpi2c.rs

@@ -1,6 +1,6 @@
 use core::ops::Deref;
 
-use crate::i2c::{Error, Pins};
+use crate::i2c::{Error, NoAcknowledgeSource, Pins};
 use crate::pac::{fmpi2c1, FMPI2C1, RCC};
 use crate::rcc::{Enable, Reset};
 use crate::time::{Hertz, U32Ext};
@@ -168,12 +168,19 @@ where
             self.i2c
                 .icr
                 .write(|w| w.stopcf().set_bit().nackcf().set_bit());
-            return Err(Error::NACK);
+            return Err(Error::NoAcknowledge(NoAcknowledgeSource::Unknown));
         }
 
         Ok(())
     }
 
+    fn end_transaction(&self) -> Result<(), Error> {
+        // Check and clear flags if they somehow ended up set
+        self.check_and_clear_error_flags(&self.i2c.isr.read())
+            .map_err(Error::nack_data)?;
+        Ok(())
+    }
+
     fn send_byte(&self, byte: u8) -> Result<(), Error> {
         // Wait until we're ready for sending
         while {
@@ -186,9 +193,7 @@ where
         // Push out a byte of data
         self.i2c.txdr.write(|w| unsafe { w.bits(u32::from(byte)) });
 
-        self.check_and_clear_error_flags(&self.i2c.isr.read())
-            .map_err(Error::nack_data)?;
-        Ok(())
+        self.end_transaction()
     }
 
     fn recv_byte(&self) -> Result<u8, Error> {
@@ -225,11 +230,7 @@ where
             *c = self.recv_byte()?;
         }
 
-        // Check and clear flags if they somehow ended up set
-        self.check_and_clear_error_flags(&self.i2c.isr.read())
-            .map_err(Error::nack_data)?;
-
-        Ok(())
+        self.end_transaction()
     }
 
     pub fn write(&mut self, addr: u8, bytes: &[u8]) -> Result<(), Error> {
@@ -253,11 +254,7 @@ where
             self.send_byte(*c)?;
         }
 
-        // Check and clear flags if they somehow ended up set
-        self.check_and_clear_error_flags(&self.i2c.isr.read())
-            .map_err(Error::nack_data)?;
-
-        Ok(())
+        self.end_transaction()
     }
 
     pub fn write_read(&mut self, addr: u8, bytes: &[u8], buffer: &mut [u8]) -> Result<(), Error> {
@@ -318,10 +315,6 @@ where
             *c = self.recv_byte()?;
         }
 
-        // Check and clear flags if they somehow ended up set
-        self.check_and_clear_error_flags(&self.i2c.isr.read())
-            .map_err(Error::nack_data)?;
-
-        Ok(())
+        self.end_transaction()
     }
 }

src/i2c.rs

@@ -99,31 +99,34 @@ where
     }
 }
 
+pub use embedded_hal_one::i2c::NoAcknowledgeSource;
+
 #[derive(Debug, Eq, PartialEq, Copy, Clone)]
 #[non_exhaustive]
 pub enum Error {
-    OVERRUN,
-    NACK,
-    NACK_ADDR,
-    NACK_DATA,
-    TIMEOUT,
-    // Note: The BUS error type is not currently returned, but is maintained for backwards
-    // compatibility.
-    BUS,
-    CRC,
-    ARBITRATION,
+    Overrun,
+    NoAcknowledge(NoAcknowledgeSource),
+    Timeout,
+    // Note: The Bus error type is not currently returned, but is maintained for compatibility.
+    Bus,
+    Crc,
+    ArbitrationLoss,
 }
 
 impl Error {
     pub(crate) fn nack_addr(self) -> Self {
         match self {
-            Error::NACK => Error::NACK_ADDR,
+            Error::NoAcknowledge(NoAcknowledgeSource::Unknown) => {
+                Error::NoAcknowledge(NoAcknowledgeSource::Address)
+            }
             e => e,
         }
     }
     pub(crate) fn nack_data(self) -> Self {
         match self {
-            Error::NACK => Error::NACK_DATA,
+            Error::NoAcknowledge(NoAcknowledgeSource::Unknown) => {
+                Error::NoAcknowledge(NoAcknowledgeSource::Data)
+            }
             e => e,
         }
     }
@@ -243,27 +246,27 @@ impl<I2C: Instance, PINS> I2c<I2C, PINS> {
 
         if sr1.timeout().bit_is_set() {
             self.i2c.sr1.modify(|_, w| w.timeout().clear_bit());
-            return Err(Error::TIMEOUT);
+            return Err(Error::Timeout);
         }
 
         if sr1.pecerr().bit_is_set() {
             self.i2c.sr1.modify(|_, w| w.pecerr().clear_bit());
-            return Err(Error::CRC);
+            return Err(Error::Crc);
         }
 
         if sr1.ovr().bit_is_set() {
             self.i2c.sr1.modify(|_, w| w.ovr().clear_bit());
-            return Err(Error::OVERRUN);
+            return Err(Error::Overrun);
         }
 
         if sr1.af().bit_is_set() {
             self.i2c.sr1.modify(|_, w| w.af().clear_bit());
-            return Err(Error::NACK);
+            return Err(Error::NoAcknowledge(NoAcknowledgeSource::Unknown));
         }
 
         if sr1.arlo().bit_is_set() {
             self.i2c.sr1.modify(|_, w| w.arlo().clear_bit());
-            return Err(Error::ARBITRATION);
+            return Err(Error::ArbitrationLoss);
         }
 
         // The errata indicates that BERR may be incorrectly detected. It recommends ignoring and
@@ -414,7 +417,7 @@ impl<I2C: Instance, PINS> I2c<I2C, PINS> {
             // Fallthrough is success
             Ok(())
         } else {
-            Err(Error::OVERRUN)
+            Err(Error::Overrun)
         }
     }
 
@@ -449,18 +452,14 @@ impl<I2C: Instance, PINS> I2c<I2C, PINS> {
 
     pub fn write_read(&mut self, addr: u8, bytes: &[u8], buffer: &mut [u8]) -> Result<(), Error> {
         self.write_bytes(addr, bytes.iter().cloned())?;
-        self.read(addr, buffer)?;
-
-        Ok(())
+        self.read(addr, buffer)
     }
 
     pub fn write_iter_read<B>(&mut self, addr: u8, bytes: B, buffer: &mut [u8]) -> Result<(), Error>
     where
         B: IntoIterator<Item = u8>,
     {
         self.write_bytes(addr, bytes.into_iter())?;
-        self.read(addr, buffer)?;
-
-        Ok(())
+        self.read(addr, buffer)
     }
 }

src/i2c/hal_1.rs

@@ -1,15 +1,13 @@
-use embedded_hal_one::i2c::{Error, ErrorKind, ErrorType, NoAcknowledgeSource};
+use embedded_hal_one::i2c::{Error, ErrorKind, ErrorType};
 
 impl Error for super::Error {
     fn kind(&self) -> ErrorKind {
-        match self {
-            Self::OVERRUN => ErrorKind::Overrun,
-            Self::BUS => ErrorKind::Bus,
-            Self::ARBITRATION => ErrorKind::ArbitrationLoss,
-            Self::NACK_ADDR => ErrorKind::NoAcknowledge(NoAcknowledgeSource::Address),
-            Self::NACK_DATA => ErrorKind::NoAcknowledge(NoAcknowledgeSource::Data),
-            Self::NACK => ErrorKind::NoAcknowledge(NoAcknowledgeSource::Unknown),
-            Self::CRC | Self::TIMEOUT => ErrorKind::Other,
+        match *self {
+            Self::Overrun => ErrorKind::Overrun,
+            Self::Bus => ErrorKind::Bus,
+            Self::ArbitrationLoss => ErrorKind::ArbitrationLoss,
+            Self::NoAcknowledge(nack) => ErrorKind::NoAcknowledge(nack),
+            Self::Crc | Self::Timeout => ErrorKind::Other,
         }
     }
 }