Reuse I2CTransfer for I2CDevice

Author: eldruin

examples/pca9956b.rs

@@ -55,8 +55,8 @@ fn main() {
     // 2) Read 10 bytes from the current register onwards
     let mut data = [0; 10];
     let mut msgs = [
-        LinuxI2CMessage::write(ADDR, &[0b1000_0000]),
-        LinuxI2CMessage::read(ADDR, &mut data),
+        LinuxI2CMessage::write(&[0b1000_0000]).with_address(ADDR),
+        LinuxI2CMessage::read(&mut data).with_address(ADDR),
     ];
 
     // Send the messages to the kernel to process

src/core.rs

@@ -136,8 +136,8 @@ pub trait I2CTransfer<'a> {
 /// Read/Write I2C message
 pub trait I2CMessage<'a> {
     /// Read data from device
-    fn read(slave_address: u16, data: &'a mut [u8]) -> Self;
+    fn read(data: &'a mut [u8]) -> Self;
 
     /// Write data to device
-    fn write(slave_address: u16, data: &'a [u8]) -> Self;
+    fn write(data: &'a [u8]) -> Self;
 }

src/lib.rs

@@ -14,15 +14,15 @@
 //! https://www.kernel.org/doc/Documentation/i2c/dev-interface
 //! ```rust,no_run
 //! extern crate i2cdev;
-//! 
+//!
 //! use std::thread;
 //! use std::time::Duration;
 //!
 //! use i2cdev::core::*;
 //! use i2cdev::linux::{LinuxI2CDevice, LinuxI2CError};
 //!
 //! const NUNCHUCK_SLAVE_ADDR: u16 = 0x52;
-//! 
+//!
 //! // real code should probably not use unwrap()
 //! fn i2cfun() -> Result<(), LinuxI2CError> {
 //!     let mut dev = LinuxI2CDevice::new("/dev/i2c-1", NUNCHUCK_SLAVE_ADDR)?;
@@ -41,28 +41,53 @@
 //!     }
 //! }
 //! ```
-//! 
+//!
 //! ```rust,no_run
 //! extern crate i2cdev;
 //!
 //! use std::thread;
 //! use std::time::Duration;
 //!
 //! use i2cdev::core::*;
-//! use i2cdev::linux::{LinuxI2CBus, LinuxI2CError, LinuxI2CMessage};
+//! use i2cdev::linux::{LinuxI2CDevice, LinuxI2CError, LinuxI2CMessage};
 //!
 //! const SLAVE_ADDR: u16 = 0x57;
 //!
 //! fn write_read_transaction() -> Result<(), LinuxI2CError> {
+//!     let mut dev = LinuxI2CDevice::new("/dev/i2c-1", SLAVE_ADDR)?;
+//!
+//!     let mut read_data = [0; 2];
+//!     let mut msgs = [
+//!         LinuxI2CMessage::write(&[0x01]),
+//!         LinuxI2CMessage::read(&mut read_data)
+//!     ];
+//!     dev.transfer(&mut msgs)?;
+//!
+//!     println!("Reading: {:?}", read_data);
+//!     Ok(())
+//! }
+//! ```
+//!
+//! ```rust,no_run
+//! extern crate i2cdev;
+//!
+//! use std::thread;
+//! use std::time::Duration;
+//!
+//! use i2cdev::core::*;
+//! use i2cdev::linux::{LinuxI2CBus, LinuxI2CError, LinuxI2CMessage};
+//!
+//! const SLAVE_ADDR: u16 = 0x57;
+//!
+//! fn write_read_transaction_using_bus() -> Result<(), LinuxI2CError> {
 //!     let mut dev = LinuxI2CBus::new("/dev/i2c-1")?;
 //!
 //!     let mut read_data = [0; 2];
 //!     let mut msgs = [
-//!         LinuxI2CMessage::write(SLAVE_ADDR, &[0x01]),
-//!         LinuxI2CMessage::read(SLAVE_ADDR, &mut read_data)
+//!         LinuxI2CMessage::write(&[0x01]).with_address(SLAVE_ADDR),
+//!         LinuxI2CMessage::read(&mut read_data).with_address(SLAVE_ADDR)
 //!     ];
 //!     dev.transfer(&mut msgs)?;
-//!     thread::sleep(Duration::from_millis(100));
 //!
 //!     println!("Reading: {:?}", read_data);
 //!     Ok(())

src/linux.rs

@@ -235,6 +235,20 @@ impl I2CDevice for LinuxI2CDevice {
     }
 }
 
+impl<'a> I2CTransfer<'a> for LinuxI2CDevice {
+    type Error = LinuxI2CError;
+    type Message = LinuxI2CMessage<'a>;
+
+    /// Issue the provided sequence of I2C transactions
+    fn transfer(&mut self, messages: &'a mut [Self::Message]) -> Result<u32, LinuxI2CError> {
+        for msg in messages.iter_mut() {
+            (*msg).addr = self.slave_address;
+        }
+        ffi::i2c_rdwr(self.as_raw_fd(), messages).map_err(From::from)
+    }
+}
+
+
 impl LinuxI2CBus {
     /// Create a new LinuxI2CBus for the specified path
     pub fn new<P: AsRef<Path>>(path: P)
@@ -289,18 +303,18 @@ bitflags! {
 }
 
 impl<'a> I2CMessage<'a> for LinuxI2CMessage<'a> {
-    fn read(slave_address: u16, data: &'a mut [u8]) -> LinuxI2CMessage {
+    fn read(data: &'a mut [u8]) -> LinuxI2CMessage {
         Self {
-            addr: slave_address,
+            addr: 0, // will be filled later
             flags: I2CMessageFlags::READ.bits(),
             len: data.len() as u16,
             buf: data.as_ptr(),
         }
     }
 
-    fn write(slave_address: u16, data: &'a [u8]) -> LinuxI2CMessage {
+    fn write(data: &'a [u8]) -> LinuxI2CMessage {
         Self {
-            addr: slave_address,
+            addr: 0, // will be filled later
             flags: I2CMessageFlags::empty().bits(),
             len: data.len() as u16,
             buf: data.as_ptr(),
@@ -309,6 +323,15 @@ impl<'a> I2CMessage<'a> for LinuxI2CMessage<'a> {
 }
 
 impl<'a> LinuxI2CMessage<'a> {
+    pub fn with_address(self, slave_address: u16) -> Self {
+        Self {
+            addr: slave_address,
+            flags: self.flags,
+            len: self.len,
+            buf: self.buf,
+        }
+    }
+
     pub fn with_flags(self, flags: I2CMessageFlags) -> Self {
         Self {
             addr: self.addr,

src/mock.rs

@@ -5,7 +5,7 @@
 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 // option.  This file may not be copied, modified, or distributed
 // except according to those terms.
-use core::I2CDevice;
+use core::{I2CDevice, I2CMessage, I2CTransfer};
 use std::io;
 
 pub type I2CResult<T> = io::Result<T>;
@@ -100,3 +100,46 @@ impl I2CDevice for MockI2CDevice {
         unimplemented!()
     }
 }
+
+#[derive(Debug)]
+enum MessageType<'a> {
+    Write(&'a [u8]),
+    Read(&'a mut [u8]),
+}
+
+pub struct MockI2CMessage<'a> {
+    msg_type: MessageType<'a>
+}
+
+impl<'a> I2CMessage<'a> for MockI2CMessage<'a> {
+    fn read(data: &'a mut [u8]) -> Self {
+        Self {
+            msg_type: MessageType::Read(data),
+        }
+    }
+
+    /// Write data to device
+    fn write(data: &'a [u8]) -> Self {
+        Self {
+            msg_type: MessageType::Write(data),
+        }
+    }
+}
+
+impl<'a> I2CTransfer<'a> for MockI2CDevice
+where MockI2CDevice: I2CDevice {
+    type Error = io::Error;
+    type Message = MockI2CMessage<'a>;
+
+    /// Issue the provided sequence of I2C transactions
+    fn transfer(&mut self, messages: &'a mut [Self::Message]) -> Result<u32, Self::Error> {
+        for msg in messages.iter_mut() {
+            match &mut msg.msg_type {
+                MessageType::Read(data) => self.read(data)?,
+                MessageType::Write(data) => self.write(data)?,
+            }
+        }
+        Ok(messages.len() as u32)
+    }
+}
+