diff --git a/README.md b/README.md index 47f3f799..428cc8b6 100644 --- a/README.md +++ b/README.md @@ -43,11 +43,11 @@ const NUNCHUCK_SLAVE_ADDR: u16 = 0x52; // real code should probably not use unwrap() fn i2cfun() -> Result<(), LinuxI2CError> { - let mut dev = try!(LinuxI2CDevice::new("/dev/i2c-1", NUNCHUCK_SLAVE_ADDR)); + let mut dev = LinuxI2CDevice::new("/dev/i2c-1", NUNCHUCK_SLAVE_ADDR)?; // init sequence - try!(dev.smbus_write_byte_data(0xF0, 0x55)); - try!(dev.smbus_write_byte_data(0xFB, 0x00)); + dev.smbus_write_byte_data(0xF0, 0x55)?; + dev.smbus_write_byte_data(0xFB, 0x00)?; thread::sleep(Duration::from_millis(100)); loop { diff --git a/examples/nunchuck.rs b/examples/nunchuck.rs index 696ed827..d2170c47 100644 --- a/examples/nunchuck.rs +++ b/examples/nunchuck.rs @@ -107,7 +107,7 @@ mod nunchuck { /// the future. pub fn new(i2cdev: T) -> Result, T::Error> { let mut nunchuck = Nunchuck { i2cdev: i2cdev }; - try!(nunchuck.init()); + nunchuck.init()?; Ok(nunchuck) } @@ -121,8 +121,8 @@ mod nunchuck { // 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(()) } @@ -138,7 +138,7 @@ mod nunchuck { // 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) } } diff --git a/examples/sensors.rs b/examples/sensors.rs index fc7d960c..9572e9f5 100644 --- a/examples/sensors.rs +++ b/examples/sensors.rs @@ -91,7 +91,7 @@ mod sensors { type Error = ::Error; fn altitude_meters(&mut self, sea_level_kpa: f32) -> Result { - let pressure = try!(self.pressure_kpa()) * 1000.; + let pressure = self.pressure_kpa()? * 1000.; let sea_level_pa = sea_level_kpa * 1000.; let altitude = 44330. * (1. - (pressure / sea_level_pa).powf(0.1903)); @@ -170,7 +170,7 @@ mod sensors { /// 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!( @@ -179,13 +179,13 @@ mod sensors { 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_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 }) } @@ -209,8 +209,8 @@ mod sensors { // 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]]); @@ -304,8 +304,8 @@ mod sensors { 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), @@ -321,7 +321,7 @@ mod sensors { 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)); @@ -329,8 +329,8 @@ mod sensors { // 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 { @@ -364,7 +364,7 @@ mod sensors { { /// 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, @@ -379,7 +379,7 @@ mod sensors { 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)) } } @@ -391,7 +391,7 @@ mod sensors { 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()) } } diff --git a/src/core.rs b/src/core.rs index f73e8f71..092974b8 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 b5bdcbd1..c4c08f7e 100644 --- a/src/ffi.rs +++ b/src/ffi.rs @@ -181,9 +181,9 @@ mod ioctl { pub fn i2c_set_slave_address(fd: RawFd, slave_address: u16) -> Result<(), nix::Error> { - try!(unsafe { - ioctl::set_i2c_slave_address(fd, slave_address as i32) - }); + unsafe { + ioctl::set_i2c_slave_address(fd, slave_address as i32)?; + } Ok(()) } @@ -222,13 +222,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) - }); + &mut data)? + } Ok(data.block[0]) } @@ -246,13 +246,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) - }); + &mut data)?; + } Ok(data.block[0]) } @@ -260,26 +260,26 @@ 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) - }); + &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) - }); + &mut data)?; + }; Ok(Cursor::new(&data.block[..]) .read_u16::() @@ -294,13 +294,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) - }); + &mut data)?; + }; Ok(()) } @@ -311,13 +311,13 @@ 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) - }); + &mut data)?; + } Ok(Cursor::new(&data.block[..]) .read_u16::() .unwrap()) @@ -326,13 +326,13 @@ pub fn i2c_smbus_process_call(fd: RawFd, register: u8, value: u16) -> Result 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) - }); + &mut data)?; + } // create a vector from the data in the block starting at byte // 1 and ending after count bytes after that @@ -343,13 +343,13 @@ pub fn i2c_smbus_read_block_data(fd: RawFd, register: u8) -> Result, I2C 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) - }); + &mut data)?; + } // create a vector from the data in the block starting at byte // 1 and ending after count bytes after that @@ -369,13 +369,13 @@ pub fn i2c_smbus_write_block_data(fd: RawFd, register: u8, values: &[u8]) -> Res 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) - }); + &mut data)?; + } Ok(()) } @@ -394,13 +394,13 @@ pub fn i2c_smbus_write_i2c_block_data(fd: RawFd, 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) - }); + &mut data)?; + } Ok(()) } @@ -416,13 +416,13 @@ pub fn i2c_smbus_process_call_block(fd: RawFd, register: u8, values: &[u8]) -> R 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_PROC_CALL, - &mut data) - }); + &mut data)?; + }; // create a vector from the data in the block starting at byte // 1 and ending after count bytes after that diff --git a/src/linux.rs b/src/linux.rs index a2b976a3..5320d6ab 100644 --- a/src/linux.rs +++ b/src/linux.rs @@ -93,15 +93,15 @@ impl LinuxI2CDevice { pub fn new>(path: P, slave_address: u16) -> Result { - let file = try!(OpenOptions::new() + let file = OpenOptions::new() .read(true) .write(true) - .open(path)); + .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 +117,7 @@ impl LinuxI2CDevice { /// necessary if you need to change the slave device and you do /// not want to create a new device. pub 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(()) }