Add I2C address modes

Author: eldruin

src/blocking/i2c.rs

@@ -5,8 +5,32 @@
 //! Operations on 10-bit slave addresses are not supported by the API yet (but applications might
 //! be able to emulate some operations).
 
+use crate::private;
+
+/// Address mode (7-bit / 10-bit)
+///
+/// Note: This trait is sealed and should not be implemented outside of this crate.
+pub trait AddressMode: private::Sealed {
+    /// Address value type
+    type Address;
+}
+
+/// 7-bit address mode type
+pub struct SevenBitAddress(());
+
+/// 10-bit address mode type
+pub struct TenBitAddress(());
+
+impl AddressMode for SevenBitAddress {
+    type Address = u8;
+}
+
+impl AddressMode for TenBitAddress {
+    type Address = u16;
+}
+
 /// Blocking read
-pub trait Read {
+pub trait Read<A: AddressMode> {
     /// Error type
     type Error;
 
@@ -28,11 +52,11 @@ pub trait Read {
     /// - `MAK` = master acknowledge
     /// - `NMAK` = master no acknowledge
     /// - `SP` = stop condition
-    fn try_read(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), Self::Error>;
+    fn try_read(&mut self, address: A::Address, buffer: &mut [u8]) -> Result<(), Self::Error>;
 }
 
 /// Blocking write
-pub trait Write {
+pub trait Write<A: AddressMode> {
     /// Error type
     type Error;
 
@@ -52,11 +76,11 @@ pub trait Write {
     /// - `SAK` = slave acknowledge
     /// - `Bi` = ith byte of data
     /// - `SP` = stop condition
-    fn try_write(&mut self, address: u8, bytes: &[u8]) -> Result<(), Self::Error>;
+    fn try_write(&mut self, address: A::Address, bytes: &[u8]) -> Result<(), Self::Error>;
 }
 
 /// Blocking write (iterator version)
-pub trait WriteIter {
+pub trait WriteIter<A: AddressMode> {
     /// Error type
     type Error;
 
@@ -65,13 +89,13 @@ pub trait WriteIter {
     /// # I2C Events (contract)
     ///
     /// Same as `Write`
-    fn try_write<B>(&mut self, address: u8, bytes: B) -> Result<(), Self::Error>
+    fn try_write<B>(&mut self, address: A::Address, bytes: B) -> Result<(), Self::Error>
     where
         B: IntoIterator<Item = u8>;
 }
 
 /// Blocking write + read
-pub trait WriteRead {
+pub trait WriteRead<A: AddressMode> {
     /// Error type
     type Error;
 
@@ -99,14 +123,14 @@ pub trait WriteRead {
     /// - `SP` = stop condition
     fn try_write_read(
         &mut self,
-        address: u8,
+        address: A::Address,
         bytes: &[u8],
         buffer: &mut [u8],
     ) -> Result<(), Self::Error>;
 }
 
 /// Blocking write (iterator version) + read
-pub trait WriteIterRead {
+pub trait WriteIterRead<A: AddressMode> {
     /// Error type
     type Error;
 
@@ -118,7 +142,7 @@ pub trait WriteIterRead {
     /// Same as the `WriteRead` trait
     fn try_write_iter_read<B>(
         &mut self,
-        address: u8,
+        address: A::Address,
         bytes: B,
         buffer: &mut [u8],
     ) -> Result<(), Self::Error>

src/lib.rs

@@ -700,3 +700,11 @@ pub mod serial;
 pub mod spi;
 pub mod timer;
 pub mod watchdog;
+
+mod private {
+    use crate::blocking::i2c::{SevenBitAddress, TenBitAddress};
+    pub trait Sealed {}
+
+    impl Sealed for SevenBitAddress {}
+    impl Sealed for TenBitAddress {}
+}