Merge pull request #53 from eldruin/refactoring

Refactoring + some simplifications

Author: posborne

examples/nunchuck.rs

@@ -53,7 +53,7 @@ mod nunchuck {
             }
         }
 
-        fn cause(&self) -> Option<&Error> {
+        fn cause(&self) -> Option<&dyn Error> {
             match *self {
                 NunchuckError::Error(ref e) => Some(e),
                 NunchuckError::ParseError => None,
@@ -82,9 +82,9 @@ mod nunchuck {
                 Some(NunchuckReading {
                     joystick_x: data[0],
                     joystick_y: data[1],
-                    accel_x: (data[2] as u16) << 2 | ((data[5] as u16 >> 6) & 0b11),
-                    accel_y: (data[3] as u16) << 2 | ((data[5] as u16 >> 4) & 0b11),
-                    accel_z: (data[4] as u16) << 2 | ((data[5] as u16 >> 2) & 0b11),
+                    accel_x: (u16::from(data[2]) << 2) | ((u16::from(data[5]) >> 6) & 0b11),
+                    accel_y: (u16::from(data[3]) << 2) | ((u16::from(data[5]) >> 4) & 0b11),
+                    accel_z: (u16::from(data[4]) << 2) | ((u16::from(data[5]) >> 2) & 0b11),
                     c_button_pressed: (data[5] & 0b10) == 0,
                     z_button_pressed: (data[5] & 0b01) == 0,
                 })
@@ -106,7 +106,7 @@ mod nunchuck {
         /// send the required init sequence in order to read data in
         /// the future.
         pub fn new(i2cdev: T) -> Result<Nunchuck<T>, T::Error> {
-            let mut nunchuck = Nunchuck { i2cdev: i2cdev };
+            let mut nunchuck = Nunchuck { i2cdev };
             nunchuck.init()?;
             Ok(nunchuck)
         }
@@ -122,8 +122,7 @@ mod nunchuck {
             // lacking but it appears this is some kind of handshake to
             // perform unencrypted data tranfers
             self.i2cdev.smbus_write_byte_data(0xF0, 0x55)?;
-            self.i2cdev.smbus_write_byte_data(0xFB, 0x00)?;
-            Ok(())
+            self.i2cdev.smbus_write_byte_data(0xFB, 0x00)
         }
 
         pub fn read(&mut self) -> Result<NunchuckReading, NunchuckError<T::Error>> {
@@ -198,7 +197,7 @@ use nunchuck::*;
 use docopt::Docopt;
 use std::env::args;
 
-const USAGE: &'static str = "
+const USAGE: &str = "
 Reading Wii Nunchuck data via Linux i2cdev.
 
 Usage:
@@ -217,7 +216,7 @@ fn main() {}
 #[cfg(any(target_os = "linux", target_os = "android"))]
 fn main() {
     let args = Docopt::new(USAGE)
-        .and_then(|d| d.argv(args().into_iter()).parse())
+        .and_then(|d| d.argv(args()).parse())
         .unwrap_or_else(|e| e.exit());
     let device = args.get_str("<device>");
     let i2cdev = LinuxI2CDevice::new(device, NUNCHUCK_SLAVE_ADDR).unwrap();

examples/pca9956b.rs

@@ -34,6 +34,9 @@ Options:
 
 const ADDR: u16 = 0x20;
 
+#[cfg(not(any(target_os = "linux", target_os = "android")))]
+fn main() {}
+
 #[cfg(any(target_os = "linux", target_os = "android"))]
 fn main() {
     let args = Docopt::new(USAGE)

examples/sensors.rs

@@ -183,7 +183,7 @@ mod sensors {
                 // put device in measurement mode
                 i2cdev.smbus_write_byte_data(REGISTER_POWER_CTL, 0x08)?;
 
-                Ok(ADXL345Accelerometer { i2cdev: i2cdev })
+                Ok(ADXL345Accelerometer { i2cdev })
             }
 
             /// Get the device id
@@ -212,9 +212,9 @@ mod sensors {
                 let y: i16 = LittleEndian::read_i16(&[buf[2], buf[3]]);
                 let z: i16 = LittleEndian::read_i16(&[buf[4], buf[5]]);
                 Ok(AccelerometerSample {
-                    x: (x as f32 / 1023.0) * (ACCEL_RANGE * 2.0),
-                    y: (y as f32 / 1023.0) * (ACCEL_RANGE * 2.0),
-                    z: (z as f32 / 1023.0) * (ACCEL_RANGE * 2.0),
+                    x: (f32::from(x) / 1023.0) * (ACCEL_RANGE * 2.0),
+                    y: (f32::from(y) / 1023.0) * (ACCEL_RANGE * 2.0),
+                    z: (f32::from(z) / 1023.0) * (ACCEL_RANGE * 2.0),
                 })
             }
         }
@@ -285,7 +285,7 @@ mod sensors {
             // If values are less than 16 bytes, need to adjust
             let extrabits = 16 - integer_bits - fractional_bits - 1;
             let rawval: i16 = BigEndian::read_i16(&[msb, lsb]);
-            let adj = (rawval as f32 / 2_f32.powi(fractional_bits + extrabits))
+            let adj = (f32::from(rawval) / 2_f32.powi(fractional_bits + extrabits))
                 / 10_f32.powi(dec_pt_zero_pad);
             adj
         }
@@ -297,7 +297,7 @@ mod sensors {
             /// order.  This gets the raw, unconverted value of each
             /// coefficient.
             pub fn new<E: Error>(
-                i2cdev: &mut I2CDevice<Error = E>,
+                i2cdev: &mut dyn I2CDevice<Error = E>,
             ) -> Result<MPL115A2Coefficients, E> {
                 let mut buf: [u8; 8] = [0; 8];
                 i2cdev.write(&[REGISTER_ADDR_A0])?;
@@ -314,7 +314,7 @@ mod sensors {
         impl MPL115A2RawReading {
             /// Create a new reading from the provided I2C Device
             pub fn new<E: Error>(
-                i2cdev: &mut I2CDevice<Error = E>,
+                i2cdev: &mut dyn I2CDevice<Error = E>,
             ) -> Result<MPL115A2RawReading, E> {
                 // tell the chip to do an ADC read so we can get updated values
                 i2cdev.smbus_write_byte_data(REGISTER_ADDR_START_CONVERSION, 0x00)?;
@@ -329,24 +329,21 @@ mod sensors {
                 i2cdev.read(&mut buf)?;
                 let padc: u16 = BigEndian::read_u16(&buf) >> 6;
                 let tadc: u16 = BigEndian::read_u16(&buf[2..]) >> 6;
-                Ok(MPL115A2RawReading {
-                    padc: padc,
-                    tadc: tadc,
-                })
+                Ok(MPL115A2RawReading { padc, tadc })
             }
 
             /// Calculate the temperature in centrigrade for this reading
             pub fn temperature_celsius(&self) -> f32 {
-                (self.tadc as f32 - 498.0) / -5.35 + 25.0
+                (f32::from(self.tadc) - 498.0) / -5.35 + 25.0
             }
 
             /// Calculate the pressure in pascals for this reading
             pub fn pressure_kpa(&self, coeff: &MPL115A2Coefficients) -> f32 {
                 // Pcomp = a0 + (b1 + c12 * Tadc) * Padc + b2 * Tadc
                 // Pkpa = Pcomp * ((115 - 50) / 1023) + 50
                 let pcomp: f32 = coeff.a0
-                    + (coeff.b1 + coeff.c12 * self.tadc as f32) * self.padc as f32
-                    + (coeff.b2 * self.tadc as f32);
+                    + (coeff.b1 + coeff.c12 * f32::from(self.tadc)) * f32::from(self.padc)
+                    + (coeff.b2 * f32::from(self.tadc));
 
                 // scale has 1023 bits of range from 50 kPa to 115 kPa
                 let pkpa: f32 = pcomp * ((115.0 - 50.0) / 1023.0) + 50.0;
@@ -361,10 +358,7 @@ mod sensors {
             /// Create sensor accessor for MPL115A2 on the provided i2c bus path
             pub fn new(mut i2cdev: T) -> Result<MPL115A2BarometerThermometer<T>, T::Error> {
                 let coeff = MPL115A2Coefficients::new(&mut i2cdev)?;
-                Ok(MPL115A2BarometerThermometer {
-                    i2cdev: i2cdev,
-                    coeff: coeff,
-                })
+                Ok(MPL115A2BarometerThermometer { i2cdev, coeff })
             }
         }
 
@@ -457,7 +451,7 @@ mod sensors {
     }
 }
 
-const USAGE: &'static str = "
+const USAGE: &str = "
 Reading sensor data from a variety of sensors
 
 Usage:
@@ -476,7 +470,7 @@ fn main() {}
 #[cfg(any(target_os = "linux", target_os = "android"))]
 fn main() {
     let args = Docopt::new(USAGE)
-        .and_then(|d| d.argv(args().into_iter()).parse())
+        .and_then(|d| d.argv(args()).parse())
         .unwrap_or_else(|e| e.exit());
     let device = args.get_str("<device>");
     let mpl115a2_i2cdev = LinuxI2CDevice::new(device, MPL115A2_I2C_ADDR).unwrap();

src/core.rs

@@ -42,7 +42,7 @@ pub trait I2CDevice {
     /// This is the opposite operation as smbus_read_byte.  As with read_byte,
     /// no register is specified.
     fn smbus_write_byte(&mut self, value: u8) -> Result<(), Self::Error> {
-        self.write(&mut [value])
+        self.write(&[value])
     }
 
     /// Read a single byte from a device, from a designated register
@@ -57,7 +57,7 @@ pub trait I2CDevice {
     ///
     /// The register is specified through the Comm byte.
     fn smbus_write_byte_data(&mut self, register: u8, value: u8) -> Result<(), Self::Error> {
-        self.write(&mut [register, value])
+        self.write(&[register, value])
     }
 
     /// Read 2 bytes from a given register on a device (lsb first)

src/ffi.rs

@@ -10,10 +10,8 @@
 #![allow(non_camel_case_types)]
 
 use byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
-use libc::c_int;
 use nix;
 use std::io::Cursor;
-use std::marker::PhantomData;
 use std::mem;
 use std::os::unix::prelude::*;
 use std::ptr;
@@ -34,24 +32,24 @@ pub struct i2c_msg {
 
 bitflags! {
     struct I2CFunctions: u32 {
-        const I2C_FUNC_I2C = 0x00000001;
-        const I2C_FUNC_10BIT_ADDR = 0x00000002;
-        const I2C_FUNC_PROTOCOL_MANGLING = 0x00000004; /* I2C_M_IGNORE_NAK etc. */
-        const I2C_FUNC_SMBUS_PEC = 0x00000008;
-        const I2C_FUNC_NOSTART = 0x00000010; /* I2C_M_NOSTART */
-        const I2C_FUNC_SMBUS_BLOCK_PROC_CALL = 0x00008000; /* SMBus 2.0 */
-        const I2C_FUNC_SMBUS_QUICK = 0x00010000;
-        const I2C_FUNC_SMBUS_READ_BYTE = 0x00020000;
-        const I2C_FUNC_SMBUS_WRITE_BYTE = 0x00040000;
-        const I2C_FUNC_SMBUS_READ_BYTE_DATA = 0x00080000;
-        const I2C_FUNC_SMBUS_WRITE_BYTE_DATA = 0x00100000;
-        const I2C_FUNC_SMBUS_READ_WORD_DATA = 0x00200000;
-        const I2C_FUNC_SMBUS_WRITE_WORD_DATA = 0x00400000;
-        const I2C_FUNC_SMBUS_PROC_CALL = 0x00800000;
-        const I2C_FUNC_SMBUS_READ_BLOCK_DATA = 0x01000000;
-        const I2C_FUNC_SMBUS_WRITE_BLOCK_DATA  = 0x02000000;
-        const I2C_FUNC_SMBUS_READ_I2C_BLOCK = 0x04000000; /* I2C-like block xfer  */
-        const I2C_FUNC_SMBUS_WRITE_I2C_BLOCK = 0x08000000; /* w/ 1-byte reg. addr. */
+        const I2C_FUNC_I2C = 0x0000_0001;
+        const I2C_FUNC_10BIT_ADDR = 0x0000_0002;
+        const I2C_FUNC_PROTOCOL_MANGLING = 0x0000_0004; /* I2C_M_IGNORE_NAK etc. */
+        const I2C_FUNC_SMBUS_PEC = 0x0000_0008;
+        const I2C_FUNC_NOSTART = 0x0000_0010; /* I2C_M_NOSTART */
+        const I2C_FUNC_SMBUS_BLOCK_PROC_CALL = 0x0000_8000; /* SMBus 2.0 */
+        const I2C_FUNC_SMBUS_QUICK = 0x0001_0000;
+        const I2C_FUNC_SMBUS_READ_BYTE = 0x0002_0000;
+        const I2C_FUNC_SMBUS_WRITE_BYTE = 0x0004_0000;
+        const I2C_FUNC_SMBUS_READ_BYTE_DATA = 0x0008_0000;
+        const I2C_FUNC_SMBUS_WRITE_BYTE_DATA = 0x0010_0000;
+        const I2C_FUNC_SMBUS_READ_WORD_DATA = 0x0020_0000;
+        const I2C_FUNC_SMBUS_WRITE_WORD_DATA = 0x0040_0000;
+        const I2C_FUNC_SMBUS_PROC_CALL = 0x0080_0000;
+        const I2C_FUNC_SMBUS_READ_BLOCK_DATA = 0x0100_0000;
+        const I2C_FUNC_SMBUS_WRITE_BLOCK_DATA  = 0x0200_0000;
+        const I2C_FUNC_SMBUS_READ_I2C_BLOCK = 0x0400_0000; /* I2C-like block xfer  */
+        const I2C_FUNC_SMBUS_WRITE_I2C_BLOCK = 0x0800_0000; /* w/ 1-byte reg. addr. */
 
         const I2C_FUNC_SMBUS_BYTE = (I2CFunctions::I2C_FUNC_SMBUS_READ_BYTE.bits |
                                      I2CFunctions::I2C_FUNC_SMBUS_WRITE_BYTE.bits);
@@ -164,7 +162,7 @@ mod ioctl {
 
 pub fn i2c_set_slave_address(fd: RawFd, slave_address: u16) -> Result<(), nix::Error> {
     unsafe {
-        ioctl::set_i2c_slave_address(fd, slave_address as i32)?;
+        ioctl::set_i2c_slave_address(fd, i32::from(slave_address))?;
     }
     Ok(())
 }
@@ -178,9 +176,9 @@ unsafe fn i2c_smbus_access(
 ) -> Result<(), I2CError> {
     let mut args = i2c_smbus_ioctl_data {
         read_write: read_write as u8,
-        command: command,
+        command,
         size: size as u32,
-        data: data,
+        data,
     };
 
     // remove type information
@@ -189,9 +187,10 @@ unsafe fn i2c_smbus_access(
 
 #[inline]
 pub fn i2c_smbus_write_quick(fd: RawFd, bit: bool) -> Result<(), I2CError> {
-    let read_write = match bit {
-        true => I2CSMBusReadWrite::I2C_SMBUS_READ,
-        false => I2CSMBusReadWrite::I2C_SMBUS_WRITE,
+    let read_write = if bit {
+        I2CSMBusReadWrite::I2C_SMBUS_READ
+    } else {
+        I2CSMBusReadWrite::I2C_SMBUS_WRITE
     };
     unsafe {
         i2c_smbus_access(
@@ -258,9 +257,8 @@ pub fn i2c_smbus_write_byte_data(fd: RawFd, register: u8, value: u8) -> Result<(
             register,
             I2CSMBusSize::I2C_SMBUS_BYTE_DATA,
             &mut data,
-        )?;
+        )
     }
-    Ok(())
 }
 
 #[inline]
@@ -295,9 +293,8 @@ pub fn i2c_smbus_write_word_data(fd: RawFd, register: u8, value: u16) -> Result<
             register,
             I2CSMBusSize::I2C_SMBUS_WORD_DATA,
             &mut data,
-        )?;
-    };
-    Ok(())
+        )
+    }
 }
 
 #[inline]
@@ -364,23 +361,30 @@ pub fn i2c_smbus_read_i2c_block_data(
 }
 
 #[inline]
-pub fn i2c_smbus_write_block_data(fd: RawFd, register: u8, values: &[u8]) -> Result<(), I2CError> {
+fn copy_to_i2c_block_data(values: &[u8], max_size: usize) -> i2c_smbus_data {
     let mut data = i2c_smbus_data::empty();
-    let len: usize = if values.len() > 32 { 32 } else { values.len() };
+    let len: usize = if values.len() > max_size {
+        max_size
+    } else {
+        values.len()
+    };
     data.block[0] = len as u8;
-    for i in 1..(len + 1) {
-        data.block[i] = values[i - 1];
-    }
+    data.block[1..=len].copy_from_slice(&values[..len]);
+    data
+}
+
+#[inline]
+pub fn i2c_smbus_write_block_data(fd: RawFd, register: u8, values: &[u8]) -> Result<(), I2CError> {
+    let mut data = copy_to_i2c_block_data(&values, 32);
     unsafe {
         i2c_smbus_access(
             fd,
             I2CSMBusReadWrite::I2C_SMBUS_WRITE,
             register,
             I2CSMBusSize::I2C_SMBUS_BLOCK_DATA,
             &mut data,
-        )?;
+        )
     }
-    Ok(())
 }
 
 #[inline]
@@ -389,22 +393,16 @@ pub fn i2c_smbus_write_i2c_block_data(
     register: u8,
     values: &[u8],
 ) -> Result<(), I2CError> {
-    let mut data = i2c_smbus_data::empty();
-    let len: usize = if values.len() > 32 { 32 } else { values.len() };
-    data.block[0] = len as u8;
-    for i in 1..(len + 1) {
-        data.block[i] = values[i - 1];
-    }
+    let mut data = copy_to_i2c_block_data(&values, 32);
     unsafe {
         i2c_smbus_access(
             fd,
             I2CSMBusReadWrite::I2C_SMBUS_WRITE,
             register,
             I2CSMBusSize::I2C_SMBUS_I2C_BLOCK_DATA,
             &mut data,
-        )?;
+        )
     }
-    Ok(())
 }
 
 #[inline]
@@ -413,12 +411,7 @@ pub fn i2c_smbus_process_call_block(
     register: u8,
     values: &[u8],
 ) -> Result<Vec<u8>, I2CError> {
-    let mut data = i2c_smbus_data::empty();
-    let len: usize = if values.len() > 31 { 31 } else { values.len() };
-    data.block[0] = len as u8;
-    for i in 1..(len + 1) {
-        data.block[i] = values[i - 1];
-    }
+    let mut data = copy_to_i2c_block_data(&values, 31);
     unsafe {
         i2c_smbus_access(
             fd,

src/lib.rs

@@ -97,10 +97,10 @@
 #![crate_name = "i2cdev"]
 #![crate_type = "lib"]
 
-extern crate byteorder;
-extern crate libc;
 #[macro_use]
 extern crate bitflags;
+extern crate byteorder;
+extern crate libc;
 #[macro_use]
 extern crate nix;