From 618b68e5842252f0ba4df166d8d82f1e734e43fb Mon Sep 17 00:00:00 2001 From: David Irvine Date: Sun, 20 Nov 2016 17:28:16 +0000 Subject: [PATCH] refactorall replace try with ? --- src/core.rs | 12 ++--- src/ffi.rs | 75 +++++++++++++--------------- src/linux.rs | 29 ++++++----- src/mock.rs | 1 + src/sensors/adxl345_accelerometer.rs | 28 ++++++----- src/sensors/mpl115a2_barometer.rs | 41 ++++++++------- src/sensors/nunchuck.rs | 21 ++++---- 7 files changed, 106 insertions(+), 101 deletions(-) diff --git a/src/core.rs b/src/core.rs index cd716b3b..61e5633d 100644 --- a/src/core.rs +++ b/src/core.rs @@ -33,7 +33,7 @@ pub trait I2CDevice { /// the previous SMBus command. fn smbus_read_byte(&mut self) -> Result { let mut buf = [0_u8]; - try!(self.read(&mut buf)); + self.read(&mut buf)?; Ok(buf[0]) } @@ -49,7 +49,7 @@ pub trait I2CDevice { /// /// The register is specified through the Comm byte. fn smbus_read_byte_data(&mut self, register: u8) -> Result { - try!(self.smbus_write_byte(register)); + self.smbus_write_byte(register)?; self.smbus_read_byte() } @@ -63,8 +63,8 @@ pub trait I2CDevice { /// Read 2 bytes from a given register on a device (lsb first) fn smbus_read_word_data(&mut self, register: u8) -> Result { let mut buf: [u8; 2] = [0x00; 2]; - try!(self.smbus_write_byte(register)); - try!(self.read(&mut buf)); + self.smbus_write_byte(register)?; + self.read(&mut buf)?; Ok(LittleEndian::read_u16(&buf)) } @@ -78,8 +78,8 @@ pub trait I2CDevice { /// Select a register, send 16 bits of data to it, and read 16 bits of data fn smbus_process_word(&mut self, register: u8, value: u16) -> Result { let mut buf: [u8; 2] = [0x00; 2]; - try!(self.smbus_write_word_data(register, value)); - try!(self.read(&mut buf)); + self.smbus_write_word_data(register, value)?; + self.read(&mut buf)?; Ok(LittleEndian::read_u16(&buf)) } diff --git a/src/ffi.rs b/src/ffi.rs index 7f9794d6..e72e4411 100644 --- a/src/ffi.rs +++ b/src/ffi.rs @@ -9,12 +9,12 @@ #![allow(dead_code)] #![allow(non_camel_case_types)] +use byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt}; use nix; -use std::mem; -use std::ptr; use std::io::Cursor; +use std::mem; use std::os::unix::prelude::*; -use byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt}; +use std::ptr; pub type I2CError = nix::Error; @@ -175,12 +175,12 @@ ioctl!(bad ioctl_set_i2c_slave_address with I2C_SLAVE); ioctl!(bad ioctl_i2c_smbus with I2C_SMBUS); pub fn i2c_set_slave_address(fd: RawFd, slave_address: u16) -> Result<(), nix::Error> { - try!(unsafe { + unsafe { // NOTE: the generated ioctl call expected as pointer to a u8 but // we just want to provide the u8 directly, so we just cast to a pointer. // This is correct behavior. ioctl_set_i2c_slave_address(fd, slave_address as *mut u8) - }); + }?; Ok(()) } @@ -220,13 +220,13 @@ pub fn i2c_smbus_write_quick(fd: RawFd, bit: bool) -> Result<(), I2CError> { #[inline] pub fn i2c_smbus_read_byte(fd: RawFd) -> Result { let mut data = i2c_smbus_data::empty(); - try!(unsafe { + unsafe { i2c_smbus_access(fd, I2CSMBusReadWrite::I2C_SMBUS_READ, 0, I2CSMBusSize::I2C_SMBUS_BYTE, &mut data) - }); + }?; Ok(data.block[0]) } @@ -244,13 +244,13 @@ pub fn i2c_smbus_write_byte(fd: RawFd, value: u8) -> Result<(), I2CError> { #[inline] pub fn i2c_smbus_read_byte_data(fd: RawFd, register: u8) -> Result { let mut data = i2c_smbus_data::empty(); - try!(unsafe { + unsafe { i2c_smbus_access(fd, I2CSMBusReadWrite::I2C_SMBUS_READ, register, I2CSMBusSize::I2C_SMBUS_BYTE_DATA, &mut data) - }); + }?; Ok(data.block[0]) } @@ -258,30 +258,30 @@ pub fn i2c_smbus_read_byte_data(fd: RawFd, register: u8) -> Result pub fn i2c_smbus_write_byte_data(fd: RawFd, register: u8, value: u8) -> Result<(), I2CError> { let mut data = i2c_smbus_data::empty(); data.block[0] = value; - try!(unsafe { + unsafe { i2c_smbus_access(fd, I2CSMBusReadWrite::I2C_SMBUS_WRITE, register, I2CSMBusSize::I2C_SMBUS_BYTE_DATA, &mut data) - }); + }?; Ok(()) } #[inline] pub fn i2c_smbus_read_word_data(fd: RawFd, register: u8) -> Result { let mut data = i2c_smbus_data::empty(); - try!(unsafe { + unsafe { i2c_smbus_access(fd, I2CSMBusReadWrite::I2C_SMBUS_READ, register, I2CSMBusSize::I2C_SMBUS_WORD_DATA, &mut data) - }); + }?; Ok(Cursor::new(&data.block[..]) - .read_u16::() - .unwrap()) + .read_u16::() + .unwrap()) } @@ -292,13 +292,13 @@ pub fn i2c_smbus_write_word_data(fd: RawFd, register: u8, value: u16) -> Result< .write_u16::(value) .unwrap(); - try!(unsafe { + unsafe { i2c_smbus_access(fd, I2CSMBusReadWrite::I2C_SMBUS_WRITE, register, I2CSMBusSize::I2C_SMBUS_WORD_DATA, &mut data) - }); + }?; Ok(()) } @@ -309,28 +309,28 @@ pub fn i2c_smbus_process_call(fd: RawFd, register: u8, value: u16) -> Result(value) .unwrap(); - try!(unsafe { + unsafe { i2c_smbus_access(fd, I2CSMBusReadWrite::I2C_SMBUS_WRITE, register, I2CSMBusSize::I2C_SMBUS_PROC_CALL, &mut data) - }); + }?; Ok(Cursor::new(&data.block[..]) - .read_u16::() - .unwrap()) + .read_u16::() + .unwrap()) } #[inline] pub fn i2c_smbus_read_block_data(fd: RawFd, register: u8) -> Result, I2CError> { let mut data = i2c_smbus_data::empty(); - try!(unsafe { + unsafe { i2c_smbus_access(fd, I2CSMBusReadWrite::I2C_SMBUS_READ, register, I2CSMBusSize::I2C_SMBUS_BLOCK_DATA, &mut data) - }); + }?; // create a vector from the data in the block starting at byte // 1 and ending after count bytes after that @@ -338,16 +338,19 @@ pub fn i2c_smbus_read_block_data(fd: RawFd, register: u8) -> Result, I2C Ok((&data.block[1..(count + 1) as usize]).to_vec()) } -pub fn i2c_smbus_read_i2c_block_data(fd: RawFd, register: u8, len: u8) -> Result, I2CError> { +pub fn i2c_smbus_read_i2c_block_data(fd: RawFd, + register: u8, + len: u8) + -> Result, I2CError> { let mut data = i2c_smbus_data::empty(); data.block[0] = len; - try!(unsafe { + unsafe { i2c_smbus_access(fd, I2CSMBusReadWrite::I2C_SMBUS_READ, register, I2CSMBusSize::I2C_SMBUS_I2C_BLOCK_DATA, &mut data) - }); + }?; // create a vector from the data in the block starting at byte // 1 and ending after count bytes after that @@ -358,22 +361,18 @@ pub fn i2c_smbus_read_i2c_block_data(fd: RawFd, register: u8, len: u8) -> Result #[inline] pub fn i2c_smbus_write_block_data(fd: RawFd, register: u8, values: &[u8]) -> Result<(), I2CError> { let mut data = i2c_smbus_data::empty(); - let len: usize = if values.len() > 32 { - 32 - } else { - values.len() - }; + 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]; } - try!(unsafe { + unsafe { i2c_smbus_access(fd, I2CSMBusReadWrite::I2C_SMBUS_WRITE, register, I2CSMBusSize::I2C_SMBUS_BLOCK_DATA, &mut data) - }); + }?; Ok(()) } @@ -383,21 +382,17 @@ pub fn i2c_smbus_write_i2c_block_data(fd: RawFd, values: &[u8]) -> Result<(), I2CError> { let mut data = i2c_smbus_data::empty(); - let len: usize = if values.len() > 32 { - 32 - } else { - values.len() - }; + 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]; } - try!(unsafe { + unsafe { i2c_smbus_access(fd, I2CSMBusReadWrite::I2C_SMBUS_WRITE, register, I2CSMBusSize::I2C_SMBUS_I2C_BLOCK_DATA, &mut data) - }); + }?; Ok(()) } diff --git a/src/linux.rs b/src/linux.rs index 95eeb454..f10506d1 100644 --- a/src/linux.rs +++ b/src/linux.rs @@ -6,17 +6,17 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use ffi; use core::I2CDevice; +use ffi; +use nix; use std::error::Error; -use std::path::Path; -use std::fs::File; use std::fmt; -use nix; -use std::io; +use std::fs::File; use std::fs::OpenOptions; +use std::io; use std::io::prelude::*; use std::os::unix::prelude::*; +use std::path::Path; pub struct LinuxI2CDevice { devfile: File, @@ -93,15 +93,14 @@ impl LinuxI2CDevice { pub fn new>(path: P, slave_address: u16) -> Result { - let file = try!(OpenOptions::new() - .read(true) - .write(true) - .open(path)); + let file = OpenOptions::new().read(true) + .write(true) + .open(path)?; let mut device = LinuxI2CDevice { devfile: file, slave_address: 0, // will be set later }; - try!(device.set_slave_address(slave_address)); + device.set_slave_address(slave_address)?; Ok(device) } @@ -117,7 +116,7 @@ impl LinuxI2CDevice { /// necessary if you need to change the slave device and you do /// not want to create a new device. fn set_slave_address(&mut self, slave_address: u16) -> Result<(), LinuxI2CError> { - try!(ffi::i2c_set_slave_address(self.as_raw_fd(), slave_address)); + ffi::i2c_set_slave_address(self.as_raw_fd(), slave_address)?; self.slave_address = slave_address; Ok(()) } @@ -196,8 +195,12 @@ impl I2CDevice for LinuxI2CDevice { ffi::i2c_smbus_read_block_data(self.as_raw_fd(), register).map_err(From::from) } - /// Read a block of up to 32 bytes from a device via i2c_smbus_i2c_read_block_data - fn smbus_read_i2c_block_data(&mut self, register: u8, len: u8) -> Result, LinuxI2CError> { + /// Read a block of up to 32 bytes from a device via + /// i2c_smbus_i2c_read_block_data + fn smbus_read_i2c_block_data(&mut self, + register: u8, + len: u8) + -> Result, LinuxI2CError> { ffi::i2c_smbus_read_i2c_block_data(self.as_raw_fd(), register, len).map_err(From::from) } diff --git a/src/mock.rs b/src/mock.rs index 755cca00..7ecc1ffb 100644 --- a/src/mock.rs +++ b/src/mock.rs @@ -5,6 +5,7 @@ // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. + use core::I2CDevice; use std::io; diff --git a/src/sensors/adxl345_accelerometer.rs b/src/sensors/adxl345_accelerometer.rs index c91b34ff..024e9456 100644 --- a/src/sensors/adxl345_accelerometer.rs +++ b/src/sensors/adxl345_accelerometer.rs @@ -8,9 +8,9 @@ #![allow(dead_code)] // register map -use sensors::{Accelerometer, AccelerometerSample}; -use core::I2CDevice; use byteorder::{ByteOrder, LittleEndian}; +use core::I2CDevice; +use sensors::{Accelerometer, AccelerometerSample}; // TODO: read/write data format (for now, assumed 0x00) @@ -67,7 +67,8 @@ pub struct ADXL345Accelerometer { i2cdev: T, } -impl ADXL345Accelerometer where T: I2CDevice + Sized +impl ADXL345Accelerometer + where T: I2CDevice + Sized { /// Create a new accelerometer handle for the given path/addr /// @@ -76,17 +77,17 @@ impl ADXL345Accelerometer where T: I2CDevice + Sized /// address (dependent on `ALT ADDRESS` pin) pub fn new(mut i2cdev: T) -> Result, T::Error> { // setup standy mode to configure - try!(i2cdev.smbus_write_byte_data(REGISTER_POWER_CTL, 0x00)); + i2cdev.smbus_write_byte_data(REGISTER_POWER_CTL, 0x00)?; // configure some defaults - try!(i2cdev.smbus_write_byte_data(REGISTER_BW_RATE, ADXL345DataRate::RATE_1600HZ as u8)); - try!(i2cdev.smbus_write_byte_data(REGISTER_DATA_FORMAT, 0x08)); - try!(i2cdev.smbus_write_byte_data(REGISTER_OFSX, 0xFD)); - try!(i2cdev.smbus_write_byte_data(REGISTER_OFSY, 0x03)); - try!(i2cdev.smbus_write_byte_data(REGISTER_OFSZ, 0xFE)); + i2cdev.smbus_write_byte_data(REGISTER_BW_RATE, ADXL345DataRate::RATE_1600HZ as u8)?; + i2cdev.smbus_write_byte_data(REGISTER_DATA_FORMAT, 0x08)?; + i2cdev.smbus_write_byte_data(REGISTER_OFSX, 0xFD)?; + i2cdev.smbus_write_byte_data(REGISTER_OFSY, 0x03)?; + i2cdev.smbus_write_byte_data(REGISTER_OFSZ, 0xFE)?; // put device in measurement mode - try!(i2cdev.smbus_write_byte_data(REGISTER_POWER_CTL, 0x08)); + i2cdev.smbus_write_byte_data(REGISTER_POWER_CTL, 0x08)?; Ok(ADXL345Accelerometer { i2cdev: i2cdev }) } @@ -100,7 +101,8 @@ impl ADXL345Accelerometer where T: I2CDevice + Sized const ACCEL_RANGE: f32 = 2.0; // +- 2G (with defaults) const ACCEL_BITS: u8 = 10; // 10-bit resolution -impl Accelerometer for ADXL345Accelerometer where T: I2CDevice + Sized +impl Accelerometer for ADXL345Accelerometer + where T: I2CDevice + Sized { type Error = T::Error; @@ -108,8 +110,8 @@ impl Accelerometer for ADXL345Accelerometer where T: I2CDevice + Sized // datasheet recommends multi-byte read to avoid reading // an inconsistent set of data let mut buf: [u8; 6] = [0u8; 6]; - try!(self.i2cdev.write(&[REGISTER_X0])); - try!(self.i2cdev.read(&mut buf)); + self.i2cdev.write(&[REGISTER_X0])?; + self.i2cdev.read(&mut buf)?; let x: i16 = LittleEndian::read_i16(&[buf[0], buf[1]]); let y: i16 = LittleEndian::read_i16(&[buf[2], buf[3]]); diff --git a/src/sensors/mpl115a2_barometer.rs b/src/sensors/mpl115a2_barometer.rs index 316ada5e..15050a7a 100644 --- a/src/sensors/mpl115a2_barometer.rs +++ b/src/sensors/mpl115a2_barometer.rs @@ -8,12 +8,12 @@ #![allow(dead_code)] -use sensors::{Thermometer, Barometer}; +use byteorder::{BigEndian, ByteOrder}; +use core::I2CDevice; +use sensors::{Barometer, Thermometer}; +use std::error::Error; use std::thread; use std::time::Duration; -use std::error::Error; -use core::I2CDevice; -use byteorder::{ByteOrder, BigEndian}; pub const MPL115A2_I2C_ADDR: u16 = 0x60; // appears to always be this @@ -82,10 +82,10 @@ impl MPL115A2Coefficients { /// This should be built from a read of registers 0x04-0x0B in /// order. This gets the raw, unconverted value of each /// coefficient. - pub fn new(i2cdev: &mut I2CDevice) -> Result { + pub fn new(i2cdev: &mut I2CDevice) -> Result { let mut buf: [u8; 8] = [0; 8]; - try!(i2cdev.write(&[REGISTER_ADDR_A0])); - try!(i2cdev.read(&mut buf)); + i2cdev.write(&[REGISTER_ADDR_A0])?; + i2cdev.read(&mut buf)?; Ok(MPL115A2Coefficients { a0: calc_coefficient(buf[0], buf[1], 12, 3, 0), b1: calc_coefficient(buf[2], buf[3], 2, 13, 0), @@ -98,9 +98,9 @@ impl MPL115A2Coefficients { impl MPL115A2RawReading { /// Create a new reading from the provided I2C Device - pub fn new(i2cdev: &mut I2CDevice) -> Result { + pub fn new(i2cdev: &mut I2CDevice) -> Result { // tell the chip to do an ADC read so we can get updated values - try!(i2cdev.smbus_write_byte_data(REGISTER_ADDR_START_CONVERSION, 0x00)); + i2cdev.smbus_write_byte_data(REGISTER_ADDR_START_CONVERSION, 0x00)?; // maximum conversion time is 3ms thread::sleep(Duration::from_millis(3)); @@ -108,8 +108,8 @@ impl MPL115A2RawReading { // The SMBus functions read word values as little endian but that is not // what we want let mut buf = [0_u8; 4]; - try!(i2cdev.write(&[REGISTER_ADDR_PADC])); - try!(i2cdev.read(&mut buf)); + i2cdev.write(&[REGISTER_ADDR_PADC])?; + i2cdev.read(&mut buf)?; let padc: u16 = BigEndian::read_u16(&buf) >> 6; let tadc: u16 = BigEndian::read_u16(&buf[2..]) >> 6; Ok(MPL115A2RawReading { @@ -137,11 +137,12 @@ impl MPL115A2RawReading { } -impl MPL115A2BarometerThermometer where T: I2CDevice + Sized +impl MPL115A2BarometerThermometer + where T: I2CDevice + Sized { /// Create sensor accessor for MPL115A2 on the provided i2c bus path pub fn new(mut i2cdev: T) -> Result, T::Error> { - let coeff = try!(MPL115A2Coefficients::new(&mut i2cdev)); + let coeff = MPL115A2Coefficients::new(&mut i2cdev)?; Ok(MPL115A2BarometerThermometer { i2cdev: i2cdev, coeff: coeff, @@ -149,22 +150,24 @@ impl MPL115A2BarometerThermometer where T: I2CDevice + Sized } } -impl Barometer for MPL115A2BarometerThermometer where T: I2CDevice + Sized +impl Barometer for MPL115A2BarometerThermometer + where T: I2CDevice + Sized { type Error = T::Error; fn pressure_kpa(&mut self) -> Result { - let reading = try!(MPL115A2RawReading::new(&mut self.i2cdev)); + let reading = MPL115A2RawReading::new(&mut self.i2cdev)?; Ok(reading.pressure_kpa(&self.coeff)) } } -impl Thermometer for MPL115A2BarometerThermometer where T: I2CDevice + Sized +impl Thermometer for MPL115A2BarometerThermometer + where T: I2CDevice + Sized { type Error = T::Error; fn temperature_celsius(&mut self) -> Result { - let reading = try!(MPL115A2RawReading::new(&mut self.i2cdev)); + let reading = MPL115A2RawReading::new(&mut self.i2cdev)?; Ok(reading.temperature_celsius()) } } @@ -172,10 +175,10 @@ impl Thermometer for MPL115A2BarometerThermometer where T: I2CDevice + Siz #[cfg(test)] mod tests { + use mock::MockI2CDevice; + use sensors::*; use super::*; use super::calc_coefficient; - use sensors::*; - use mock::MockI2CDevice; macro_rules! assert_almost_eq { ($left:expr, $right:expr) => ({ diff --git a/src/sensors/nunchuck.rs b/src/sensors/nunchuck.rs index 4a196a97..97e0d898 100644 --- a/src/sensors/nunchuck.rs +++ b/src/sensors/nunchuck.rs @@ -8,12 +8,12 @@ // Reads data from Wii Nunchuck + +use core::I2CDevice; use std::error::Error; +use std::fmt; use std::thread; use std::time::Duration; -use std::fmt; - -use core::I2CDevice; pub const NUNCHUCK_SLAVE_ADDR: u16 = 0x52; @@ -83,7 +83,8 @@ pub struct Nunchuck { i2cdev: T, } -impl Nunchuck where T: I2CDevice +impl Nunchuck + where T: I2CDevice { /// Create a new Wii Nunchuck /// @@ -92,7 +93,7 @@ impl Nunchuck where T: I2CDevice /// the future. pub fn new(i2cdev: T) -> Result, T::Error> { let mut nunchuck = Nunchuck { i2cdev: i2cdev }; - try!(nunchuck.init()); + nunchuck.init()?; Ok(nunchuck) } @@ -106,8 +107,8 @@ impl Nunchuck where T: I2CDevice // These registers must be written; the documentation is a bit // lacking but it appears this is some kind of handshake to // perform unencrypted data tranfers - try!(self.i2cdev.smbus_write_byte_data(0xF0, 0x55)); - try!(self.i2cdev.smbus_write_byte_data(0xFB, 0x00)); + self.i2cdev.smbus_write_byte_data(0xF0, 0x55)?; + self.i2cdev.smbus_write_byte_data(0xFB, 0x00)?; Ok(()) } @@ -115,11 +116,11 @@ impl Nunchuck where T: I2CDevice let mut buf: [u8; 6] = [0; 6]; // tell the nunchuck to prepare a sample - try!(self.i2cdev.smbus_write_byte(0x00).map_err(NunchuckError::Error)); + self.i2cdev.smbus_write_byte(0x00).map_err(NunchuckError::Error)?; // now, read it! thread::sleep(Duration::from_millis(10)); - try!(self.i2cdev.read(&mut buf).map_err(NunchuckError::Error)); + self.i2cdev.read(&mut buf).map_err(NunchuckError::Error)?; NunchuckReading::from_data(&buf).ok_or(NunchuckError::ParseError) } } @@ -127,9 +128,9 @@ impl Nunchuck where T: I2CDevice #[cfg(test)] mod test { - use super::*; use core::I2CDevice; use mock::MockI2CDevice; + use super::*; #[test] fn test_intialization() {