Skip to content

Commit e2dd1bf

Browse files
posborneposborne
authored
Merge pull request #43 from RandomInsano/updating_try_macro
Move from `try!` to `?`
2 parents 1645280 + d7c8aaa commit e2dd1bf

File tree

6 files changed

+70
-70
lines changed

6 files changed

+70
-70
lines changed

‎README.md

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -43,11 +43,11 @@ const NUNCHUCK_SLAVE_ADDR: u16 = 0x52;
4343
4444
// real code should probably not use unwrap()
4545
fn i2cfun() -> Result<(), LinuxI2CError> {
46-
let mut dev = try!(LinuxI2CDevice::new("/dev/i2c-1", NUNCHUCK_SLAVE_ADDR));
46+
let mut dev = LinuxI2CDevice::new("/dev/i2c-1", NUNCHUCK_SLAVE_ADDR)?;
4747
4848
// init sequence
49-
try!(dev.smbus_write_byte_data(0xF0, 0x55));
50-
try!(dev.smbus_write_byte_data(0xFB, 0x00));
49+
dev.smbus_write_byte_data(0xF0, 0x55)?;
50+
dev.smbus_write_byte_data(0xFB, 0x00)?;
5151
thread::sleep(Duration::from_millis(100));
5252
5353
loop {

‎examples/nunchuck.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -107,7 +107,7 @@ mod nunchuck {
107107
/// the future.
108108
pub fn new(i2cdev: T) -> Result<Nunchuck<T>, T::Error> {
109109
let mut nunchuck = Nunchuck { i2cdev: i2cdev };
110-
try!(nunchuck.init());
110+
nunchuck.init()?;
111111
Ok(nunchuck)
112112
}
113113

@@ -121,8 +121,8 @@ mod nunchuck {
121121
// These registers must be written; the documentation is a bit
122122
// lacking but it appears this is some kind of handshake to
123123
// perform unencrypted data tranfers
124-
try!(self.i2cdev.smbus_write_byte_data(0xF0, 0x55));
125-
try!(self.i2cdev.smbus_write_byte_data(0xFB, 0x00));
124+
self.i2cdev.smbus_write_byte_data(0xF0, 0x55)?;
125+
self.i2cdev.smbus_write_byte_data(0xFB, 0x00)?;
126126
Ok(())
127127
}
128128

@@ -138,7 +138,7 @@ mod nunchuck {
138138

139139
// now, read it!
140140
thread::sleep(Duration::from_millis(10));
141-
try!(self.i2cdev.read(&mut buf).map_err(NunchuckError::Error));
141+
self.i2cdev.read(&mut buf).map_err(NunchuckError::Error)?;
142142
NunchuckReading::from_data(&buf).ok_or(NunchuckError::ParseError)
143143
}
144144
}

‎examples/sensors.rs

Lines changed: 17 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -91,7 +91,7 @@ mod sensors {
9191
type Error = <Self as Barometer>::Error;
9292

9393
fn altitude_meters(&mut self, sea_level_kpa: f32) -> Result<f32, Self::Error> {
94-
let pressure = try!(self.pressure_kpa()) * 1000.;
94+
let pressure = self.pressure_kpa()? * 1000.;
9595
let sea_level_pa = sea_level_kpa * 1000.;
9696

9797
let altitude = 44330. * (1. - (pressure / sea_level_pa).powf(0.1903));
@@ -170,7 +170,7 @@ mod sensors {
170170
/// address (dependent on `ALT ADDRESS` pin)
171171
pub fn new(mut i2cdev: T) -> Result<ADXL345Accelerometer<T>, T::Error> {
172172
// setup standy mode to configure
173-
try!(i2cdev.smbus_write_byte_data(REGISTER_POWER_CTL, 0x00));
173+
i2cdev.smbus_write_byte_data(REGISTER_POWER_CTL, 0x00)?;
174174

175175
// configure some defaults
176176
try!(
@@ -179,13 +179,13 @@ mod sensors {
179179
ADXL345DataRate::RATE_1600HZ as u8
180180
)
181181
);
182-
try!(i2cdev.smbus_write_byte_data(REGISTER_DATA_FORMAT, 0x08));
183-
try!(i2cdev.smbus_write_byte_data(REGISTER_OFSX, 0xFD));
184-
try!(i2cdev.smbus_write_byte_data(REGISTER_OFSY, 0x03));
185-
try!(i2cdev.smbus_write_byte_data(REGISTER_OFSZ, 0xFE));
182+
i2cdev.smbus_write_byte_data(REGISTER_DATA_FORMAT, 0x08)?;
183+
i2cdev.smbus_write_byte_data(REGISTER_OFSX, 0xFD)?;
184+
i2cdev.smbus_write_byte_data(REGISTER_OFSY, 0x03)?;
185+
i2cdev.smbus_write_byte_data(REGISTER_OFSZ, 0xFE)?;
186186

187187
// put device in measurement mode
188-
try!(i2cdev.smbus_write_byte_data(REGISTER_POWER_CTL, 0x08));
188+
i2cdev.smbus_write_byte_data(REGISTER_POWER_CTL, 0x08)?;
189189

190190
Ok(ADXL345Accelerometer { i2cdev: i2cdev })
191191
}
@@ -209,8 +209,8 @@ mod sensors {
209209
// datasheet recommends multi-byte read to avoid reading
210210
// an inconsistent set of data
211211
let mut buf: [u8; 6] = [0u8; 6];
212-
try!(self.i2cdev.write(&[REGISTER_X0]));
213-
try!(self.i2cdev.read(&mut buf));
212+
self.i2cdev.write(&[REGISTER_X0])?;
213+
self.i2cdev.read(&mut buf)?;
214214

215215
let x: i16 = LittleEndian::read_i16(&[buf[0], buf[1]]);
216216
let y: i16 = LittleEndian::read_i16(&[buf[2], buf[3]]);
@@ -304,8 +304,8 @@ mod sensors {
304304
i2cdev: &mut I2CDevice<Error = E>,
305305
) -> Result<MPL115A2Coefficients, E> {
306306
let mut buf: [u8; 8] = [0; 8];
307-
try!(i2cdev.write(&[REGISTER_ADDR_A0]));
308-
try!(i2cdev.read(&mut buf));
307+
i2cdev.write(&[REGISTER_ADDR_A0])?;
308+
i2cdev.read(&mut buf)?;
309309
Ok(MPL115A2Coefficients {
310310
a0: calc_coefficient(buf[0], buf[1], 12, 3, 0),
311311
b1: calc_coefficient(buf[2], buf[3], 2, 13, 0),
@@ -321,16 +321,16 @@ mod sensors {
321321
i2cdev: &mut I2CDevice<Error = E>,
322322
) -> Result<MPL115A2RawReading, E> {
323323
// tell the chip to do an ADC read so we can get updated values
324-
try!(i2cdev.smbus_write_byte_data(REGISTER_ADDR_START_CONVERSION, 0x00));
324+
i2cdev.smbus_write_byte_data(REGISTER_ADDR_START_CONVERSION, 0x00)?;
325325

326326
// maximum conversion time is 3ms
327327
thread::sleep(Duration::from_millis(3));
328328

329329
// The SMBus functions read word values as little endian but that is not
330330
// what we want
331331
let mut buf = [0_u8; 4];
332-
try!(i2cdev.write(&[REGISTER_ADDR_PADC]));
333-
try!(i2cdev.read(&mut buf));
332+
i2cdev.write(&[REGISTER_ADDR_PADC])?;
333+
i2cdev.read(&mut buf)?;
334334
let padc: u16 = BigEndian::read_u16(&buf) >> 6;
335335
let tadc: u16 = BigEndian::read_u16(&buf[2..]) >> 6;
336336
Ok(MPL115A2RawReading {
@@ -364,7 +364,7 @@ mod sensors {
364364
{
365365
/// Create sensor accessor for MPL115A2 on the provided i2c bus path
366366
pub fn new(mut i2cdev: T) -> Result<MPL115A2BarometerThermometer<T>, T::Error> {
367-
let coeff = try!(MPL115A2Coefficients::new(&mut i2cdev));
367+
let coeff = MPL115A2Coefficients::new(&mut i2cdev)?;
368368
Ok(MPL115A2BarometerThermometer {
369369
i2cdev: i2cdev,
370370
coeff: coeff,
@@ -379,7 +379,7 @@ mod sensors {
379379
type Error = T::Error;
380380

381381
fn pressure_kpa(&mut self) -> Result<f32, T::Error> {
382-
let reading = try!(MPL115A2RawReading::new(&mut self.i2cdev));
382+
let reading = MPL115A2RawReading::new(&mut self.i2cdev)?;
383383
Ok(reading.pressure_kpa(&self.coeff))
384384
}
385385
}
@@ -391,7 +391,7 @@ mod sensors {
391391
type Error = T::Error;
392392

393393
fn temperature_celsius(&mut self) -> Result<f32, T::Error> {
394-
let reading = try!(MPL115A2RawReading::new(&mut self.i2cdev));
394+
let reading = MPL115A2RawReading::new(&mut self.i2cdev)?;
395395
Ok(reading.temperature_celsius())
396396
}
397397
}

‎src/core.rs

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -33,7 +33,7 @@ pub trait I2CDevice {
3333
/// the previous SMBus command.
3434
fn smbus_read_byte(&mut self) -> Result<u8, Self::Error> {
3535
let mut buf = [0_u8];
36-
try!(self.read(&mut buf));
36+
self.read(&mut buf)?;
3737
Ok(buf[0])
3838
}
3939

@@ -49,7 +49,7 @@ pub trait I2CDevice {
4949
///
5050
/// The register is specified through the Comm byte.
5151
fn smbus_read_byte_data(&mut self, register: u8) -> Result<u8, Self::Error> {
52-
try!(self.smbus_write_byte(register));
52+
self.smbus_write_byte(register)?;
5353
self.smbus_read_byte()
5454
}
5555

@@ -63,8 +63,8 @@ pub trait I2CDevice {
6363
/// Read 2 bytes from a given register on a device (lsb first)
6464
fn smbus_read_word_data(&mut self, register: u8) -> Result<u16, Self::Error> {
6565
let mut buf: [u8; 2] = [0x00; 2];
66-
try!(self.smbus_write_byte(register));
67-
try!(self.read(&mut buf));
66+
self.smbus_write_byte(register)?;
67+
self.read(&mut buf)?;
6868
Ok(LittleEndian::read_u16(&buf))
6969
}
7070

@@ -78,8 +78,8 @@ pub trait I2CDevice {
7878
/// Select a register, send 16 bits of data to it, and read 16 bits of data
7979
fn smbus_process_word(&mut self, register: u8, value: u16) -> Result<u16, Self::Error> {
8080
let mut buf: [u8; 2] = [0x00; 2];
81-
try!(self.smbus_write_word_data(register, value));
82-
try!(self.read(&mut buf));
81+
self.smbus_write_word_data(register, value)?;
82+
self.read(&mut buf)?;
8383
Ok(LittleEndian::read_u16(&buf))
8484
}
8585

‎src/ffi.rs

Lines changed: 36 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -181,9 +181,9 @@ mod ioctl {
181181

182182

183183
pub fn i2c_set_slave_address(fd: RawFd, slave_address: u16) -> Result<(), nix::Error> {
184-
try!(unsafe {
185-
ioctl::set_i2c_slave_address(fd, slave_address as i32)
186-
});
184+
unsafe {
185+
ioctl::set_i2c_slave_address(fd, slave_address as i32)?;
186+
}
187187
Ok(())
188188
}
189189

@@ -222,13 +222,13 @@ pub fn i2c_smbus_write_quick(fd: RawFd, bit: bool) -> Result<(), I2CError> {
222222
#[inline]
223223
pub fn i2c_smbus_read_byte(fd: RawFd) -> Result<u8, I2CError> {
224224
let mut data = i2c_smbus_data::empty();
225-
try!(unsafe {
225+
unsafe {
226226
i2c_smbus_access(fd,
227227
I2CSMBusReadWrite::I2C_SMBUS_READ,
228228
0,
229229
I2CSMBusSize::I2C_SMBUS_BYTE,
230-
&mut data)
231-
});
230+
&mut data)?
231+
}
232232
Ok(data.block[0])
233233
}
234234

@@ -246,40 +246,40 @@ pub fn i2c_smbus_write_byte(fd: RawFd, value: u8) -> Result<(), I2CError> {
246246
#[inline]
247247
pub fn i2c_smbus_read_byte_data(fd: RawFd, register: u8) -> Result<u8, I2CError> {
248248
let mut data = i2c_smbus_data::empty();
249-
try!(unsafe {
249+
unsafe {
250250
i2c_smbus_access(fd,
251251
I2CSMBusReadWrite::I2C_SMBUS_READ,
252252
register,
253253
I2CSMBusSize::I2C_SMBUS_BYTE_DATA,
254-
&mut data)
255-
});
254+
&mut data)?;
255+
}
256256
Ok(data.block[0])
257257
}
258258

259259
#[inline]
260260
pub fn i2c_smbus_write_byte_data(fd: RawFd, register: u8, value: u8) -> Result<(), I2CError> {
261261
let mut data = i2c_smbus_data::empty();
262262
data.block[0] = value;
263-
try!(unsafe {
263+
unsafe {
264264
i2c_smbus_access(fd,
265265
I2CSMBusReadWrite::I2C_SMBUS_WRITE,
266266
register,
267267
I2CSMBusSize::I2C_SMBUS_BYTE_DATA,
268-
&mut data)
269-
});
268+
&mut data)?;
269+
}
270270
Ok(())
271271
}
272272

273273
#[inline]
274274
pub fn i2c_smbus_read_word_data(fd: RawFd, register: u8) -> Result<u16, I2CError> {
275275
let mut data = i2c_smbus_data::empty();
276-
try!(unsafe {
276+
unsafe {
277277
i2c_smbus_access(fd,
278278
I2CSMBusReadWrite::I2C_SMBUS_READ,
279279
register,
280280
I2CSMBusSize::I2C_SMBUS_WORD_DATA,
281-
&mut data)
282-
});
281+
&mut data)?;
282+
};
283283

284284
Ok(Cursor::new(&data.block[..])
285285
.read_u16::<NativeEndian>()
@@ -294,13 +294,13 @@ pub fn i2c_smbus_write_word_data(fd: RawFd, register: u8, value: u16) -> Result<
294294
.write_u16::<NativeEndian>(value)
295295
.unwrap();
296296

297-
try!(unsafe {
297+
unsafe {
298298
i2c_smbus_access(fd,
299299
I2CSMBusReadWrite::I2C_SMBUS_WRITE,
300300
register,
301301
I2CSMBusSize::I2C_SMBUS_WORD_DATA,
302-
&mut data)
303-
});
302+
&mut data)?;
303+
};
304304
Ok(())
305305
}
306306

@@ -311,13 +311,13 @@ pub fn i2c_smbus_process_call(fd: RawFd, register: u8, value: u16) -> Result<u16
311311
.write_u16::<NativeEndian>(value)
312312
.unwrap();
313313

314-
try!(unsafe {
314+
unsafe {
315315
i2c_smbus_access(fd,
316316
I2CSMBusReadWrite::I2C_SMBUS_WRITE,
317317
register,
318318
I2CSMBusSize::I2C_SMBUS_PROC_CALL,
319-
&mut data)
320-
});
319+
&mut data)?;
320+
}
321321
Ok(Cursor::new(&data.block[..])
322322
.read_u16::<NativeEndian>()
323323
.unwrap())
@@ -326,13 +326,13 @@ pub fn i2c_smbus_process_call(fd: RawFd, register: u8, value: u16) -> Result<u16
326326
#[inline]
327327
pub fn i2c_smbus_read_block_data(fd: RawFd, register: u8) -> Result<Vec<u8>, I2CError> {
328328
let mut data = i2c_smbus_data::empty();
329-
try!(unsafe {
329+
unsafe {
330330
i2c_smbus_access(fd,
331331
I2CSMBusReadWrite::I2C_SMBUS_READ,
332332
register,
333333
I2CSMBusSize::I2C_SMBUS_BLOCK_DATA,
334-
&mut data)
335-
});
334+
&mut data)?;
335+
}
336336

337337
// create a vector from the data in the block starting at byte
338338
// 1 and ending after count bytes after that
@@ -343,13 +343,13 @@ pub fn i2c_smbus_read_block_data(fd: RawFd, register: u8) -> Result<Vec<u8>, I2C
343343
pub fn i2c_smbus_read_i2c_block_data(fd: RawFd, register: u8, len: u8) -> Result<Vec<u8>, I2CError> {
344344
let mut data = i2c_smbus_data::empty();
345345
data.block[0] = len;
346-
try!(unsafe {
346+
unsafe {
347347
i2c_smbus_access(fd,
348348
I2CSMBusReadWrite::I2C_SMBUS_READ,
349349
register,
350350
I2CSMBusSize::I2C_SMBUS_I2C_BLOCK_DATA,
351-
&mut data)
352-
});
351+
&mut data)?;
352+
}
353353

354354
// create a vector from the data in the block starting at byte
355355
// 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
369369
for i in 1..(len + 1) {
370370
data.block[i] = values[i - 1];
371371
}
372-
try!(unsafe {
372+
unsafe {
373373
i2c_smbus_access(fd,
374374
I2CSMBusReadWrite::I2C_SMBUS_WRITE,
375375
register,
376376
I2CSMBusSize::I2C_SMBUS_BLOCK_DATA,
377-
&mut data)
378-
});
377+
&mut data)?;
378+
}
379379
Ok(())
380380
}
381381

@@ -394,13 +394,13 @@ pub fn i2c_smbus_write_i2c_block_data(fd: RawFd,
394394
for i in 1..(len + 1) {
395395
data.block[i] = values[i - 1];
396396
}
397-
try!(unsafe {
397+
unsafe {
398398
i2c_smbus_access(fd,
399399
I2CSMBusReadWrite::I2C_SMBUS_WRITE,
400400
register,
401401
I2CSMBusSize::I2C_SMBUS_I2C_BLOCK_DATA,
402-
&mut data)
403-
});
402+
&mut data)?;
403+
}
404404
Ok(())
405405
}
406406

@@ -416,13 +416,13 @@ pub fn i2c_smbus_process_call_block(fd: RawFd, register: u8, values: &[u8]) -> R
416416
for i in 1..(len + 1) {
417417
data.block[i] = values[i - 1];
418418
}
419-
try!(unsafe {
419+
unsafe {
420420
i2c_smbus_access(fd,
421421
I2CSMBusReadWrite::I2C_SMBUS_WRITE,
422422
register,
423423
I2CSMBusSize::I2C_SMBUS_BLOCK_PROC_CALL,
424-
&mut data)
425-
});
424+
&mut data)?;
425+
};
426426

427427
// create a vector from the data in the block starting at byte
428428
// 1 and ending after count bytes after that

0 commit comments

Comments
 (0)