Update to embedded-hal-1.0.0-alpha.5

Author: eldruin

Cargo.toml

@@ -20,7 +20,7 @@ async-tokio = ["gpio-cdev/async-tokio"]
 default = [ "gpio_cdev", "gpio_sysfs" ]
 
 [dependencies]
-embedded-hal = "=1.0.0-alpha.4"
+embedded-hal = "=1.0.0-alpha.5"
 gpio-cdev = { version = "0.4", optional = true }
 sysfs_gpio = { version = "0.5", optional = true }
 

examples/transactional-i2c.rs

@@ -1,4 +1,4 @@
-use embedded_hal::blocking::i2c::{Operation as I2cOperation, Transactional};
+use embedded_hal::i2c::blocking::{Operation as I2cOperation, Transactional};
 use linux_embedded_hal::I2cdev;
 
 const ADDR: u8 = 0x12;
@@ -21,7 +21,7 @@ where
             I2cOperation::Write(&[0xAB]),
             I2cOperation::Read(&mut read_buffer),
         ];
-        self.i2c.try_exec(ADDR, &mut ops).and(Ok(read_buffer[0]))
+        self.i2c.exec(ADDR, &mut ops).and(Ok(read_buffer[0]))
     }
 }
 

src/cdev_pin.rs

@@ -17,18 +17,18 @@ impl CdevPin {
     }
 }
 
-impl embedded_hal::digital::OutputPin for CdevPin {
+impl embedded_hal::digital::blocking::OutputPin for CdevPin {
     type Error = gpio_cdev::errors::Error;
 
-    fn try_set_low(&mut self) -> Result<(), Self::Error> {
+    fn set_low(&mut self) -> Result<(), Self::Error> {
         if self.1 {
             self.0.set_value(1)
         } else {
             self.0.set_value(0)
         }
     }
 
-    fn try_set_high(&mut self) -> Result<(), Self::Error> {
+    fn set_high(&mut self) -> Result<(), Self::Error> {
         if self.1 {
             self.0.set_value(0)
         } else {
@@ -37,19 +37,19 @@ impl embedded_hal::digital::OutputPin for CdevPin {
     }
 }
 
-impl embedded_hal::digital::InputPin for CdevPin {
+impl embedded_hal::digital::blocking::InputPin for CdevPin {
     type Error = gpio_cdev::errors::Error;
 
-    fn try_is_high(&self) -> Result<bool, Self::Error> {
+    fn is_high(&self) -> Result<bool, Self::Error> {
         if !self.1 {
             self.0.get_value().map(|val| val != 0)
         } else {
             self.0.get_value().map(|val| val == 0)
         }
     }
 
-    fn try_is_low(&self) -> Result<bool, Self::Error> {
-        self.try_is_high().map(|val| !val)
+    fn is_low(&self) -> Result<bool, Self::Error> {
+        self.is_high().map(|val| !val)
     }
 }
 

src/delay.rs

@@ -4,7 +4,7 @@
 
 use cast::{u32, u64};
 use core::convert::Infallible;
-use embedded_hal::blocking::delay::{DelayMs, DelayUs};
+use embedded_hal::delay::blocking::{DelayMs, DelayUs};
 use std::thread;
 use std::time::Duration;
 
@@ -14,7 +14,7 @@ pub struct Delay;
 impl DelayUs<u8> for Delay {
     type Error = Infallible;
 
-    fn try_delay_us(&mut self, n: u8) -> Result<(), Self::Error> {
+    fn delay_us(&mut self, n: u8) -> Result<(), Self::Error> {
         thread::sleep(Duration::new(0, u32(n) * 1000));
         Ok(())
     }
@@ -23,7 +23,7 @@ impl DelayUs<u8> for Delay {
 impl DelayUs<u16> for Delay {
     type Error = Infallible;
 
-    fn try_delay_us(&mut self, n: u16) -> Result<(), Self::Error> {
+    fn delay_us(&mut self, n: u16) -> Result<(), Self::Error> {
         thread::sleep(Duration::new(0, u32(n) * 1000));
         Ok(())
     }
@@ -32,7 +32,7 @@ impl DelayUs<u16> for Delay {
 impl DelayUs<u32> for Delay {
     type Error = Infallible;
 
-    fn try_delay_us(&mut self, n: u32) -> Result<(), Self::Error> {
+    fn delay_us(&mut self, n: u32) -> Result<(), Self::Error> {
         let secs = n / 1_000_000;
         let nsecs = (n % 1_000_000) * 1_000;
 
@@ -44,7 +44,7 @@ impl DelayUs<u32> for Delay {
 impl DelayUs<u64> for Delay {
     type Error = Infallible;
 
-    fn try_delay_us(&mut self, n: u64) -> Result<(), Self::Error> {
+    fn delay_us(&mut self, n: u64) -> Result<(), Self::Error> {
         let secs = n / 1_000_000;
         let nsecs = ((n % 1_000_000) * 1_000) as u32;
 
@@ -56,7 +56,7 @@ impl DelayUs<u64> for Delay {
 impl DelayMs<u8> for Delay {
     type Error = Infallible;
 
-    fn try_delay_ms(&mut self, n: u8) -> Result<(), Self::Error> {
+    fn delay_ms(&mut self, n: u8) -> Result<(), Self::Error> {
         thread::sleep(Duration::from_millis(u64(n)));
         Ok(())
     }
@@ -65,7 +65,7 @@ impl DelayMs<u8> for Delay {
 impl DelayMs<u16> for Delay {
     type Error = Infallible;
 
-    fn try_delay_ms(&mut self, n: u16) -> Result<(), Self::Error> {
+    fn delay_ms(&mut self, n: u16) -> Result<(), Self::Error> {
         thread::sleep(Duration::from_millis(u64(n)));
         Ok(())
     }
@@ -74,7 +74,7 @@ impl DelayMs<u16> for Delay {
 impl DelayMs<u32> for Delay {
     type Error = Infallible;
 
-    fn try_delay_ms(&mut self, n: u32) -> Result<(), Self::Error> {
+    fn delay_ms(&mut self, n: u32) -> Result<(), Self::Error> {
         thread::sleep(Duration::from_millis(u64(n)));
         Ok(())
     }
@@ -83,7 +83,7 @@ impl DelayMs<u32> for Delay {
 impl DelayMs<u64> for Delay {
     type Error = Infallible;
 
-    fn try_delay_ms(&mut self, n: u64) -> Result<(), Self::Error> {
+    fn delay_ms(&mut self, n: u64) -> Result<(), Self::Error> {
         thread::sleep(Duration::from_millis(n));
         Ok(())
     }

src/i2c.rs

@@ -55,7 +55,7 @@ impl ops::DerefMut for I2cdev {
 
 mod embedded_hal_impl {
     use super::*;
-    use embedded_hal::blocking::i2c::{
+    use embedded_hal::i2c::blocking::{
         Operation as I2cOperation, Read, Transactional, Write, WriteRead,
     };
     use i2cdev::core::{I2CDevice, I2CMessage, I2CTransfer};
@@ -64,7 +64,7 @@ mod embedded_hal_impl {
     impl Read for I2cdev {
         type Error = i2cdev::linux::LinuxI2CError;
 
-        fn try_read(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), Self::Error> {
+        fn read(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), Self::Error> {
             self.set_address(address)?;
             self.inner.read(buffer)
         }
@@ -73,7 +73,7 @@ mod embedded_hal_impl {
     impl Write for I2cdev {
         type Error = i2cdev::linux::LinuxI2CError;
 
-        fn try_write(&mut self, address: u8, bytes: &[u8]) -> Result<(), Self::Error> {
+        fn write(&mut self, address: u8, bytes: &[u8]) -> Result<(), Self::Error> {
             self.set_address(address)?;
             self.inner.write(bytes)
         }
@@ -82,7 +82,7 @@ mod embedded_hal_impl {
     impl WriteRead for I2cdev {
         type Error = i2cdev::linux::LinuxI2CError;
 
-        fn try_write_read(
+        fn write_read(
             &mut self,
             address: u8,
             bytes: &[u8],
@@ -97,7 +97,7 @@ mod embedded_hal_impl {
     impl Transactional for I2cdev {
         type Error = i2cdev::linux::LinuxI2CError;
 
-        fn try_exec(
+        fn exec(
             &mut self,
             address: u8,
             operations: &mut [I2cOperation],

src/serial.rs

@@ -29,10 +29,10 @@ fn translate_io_errors(err: std::io::Error) -> nb::Error<IoErrorKind> {
     }
 }
 
-impl embedded_hal::serial::Read<u8> for Serial {
+impl embedded_hal::serial::nb::Read<u8> for Serial {
     type Error = IoErrorKind;
 
-    fn try_read(&mut self) -> nb::Result<u8, Self::Error> {
+    fn read(&mut self) -> nb::Result<u8, Self::Error> {
         let mut buffer = [0; 1];
         let bytes_read = self.0.read(&mut buffer).map_err(translate_io_errors)?;
         if bytes_read == 1 {
@@ -43,15 +43,15 @@ impl embedded_hal::serial::Read<u8> for Serial {
     }
 }
 
-impl embedded_hal::serial::Write<u8> for Serial {
+impl embedded_hal::serial::nb::Write<u8> for Serial {
     type Error = IoErrorKind;
 
-    fn try_write(&mut self, word: u8) -> nb::Result<(), Self::Error> {
+    fn write(&mut self, word: u8) -> nb::Result<(), Self::Error> {
         self.0.write(&[word]).map_err(translate_io_errors)?;
         Ok(())
     }
 
-    fn try_flush(&mut self) -> nb::Result<(), Self::Error> {
+    fn flush(&mut self) -> nb::Result<(), Self::Error> {
         self.0.flush().map_err(translate_io_errors)
     }
 }
@@ -60,7 +60,7 @@ impl embedded_hal::serial::Write<u8> for Serial {
 mod test {
     use std::path::Path;
 
-    use embedded_hal::serial::{Read, Write};
+    use embedded_hal::serial::nb::{Read, Write};
     use std::io::{Read as IoRead, Write as IoWrite};
 
     use super::*;
@@ -75,20 +75,20 @@ mod test {
     #[test]
     fn test_empty_read() {
         let (mut _master, mut serial) = create_pty_and_serial();
-        assert_eq!(Err(nb::Error::WouldBlock), serial.try_read());
+        assert_eq!(Err(nb::Error::WouldBlock), serial.read());
     }
 
     #[test]
     fn test_read() {
         let (mut master, mut serial) = create_pty_and_serial();
         master.write(&[1]).expect("Write failed");
-        assert_eq!(Ok(1), serial.try_read());
+        assert_eq!(Ok(1), serial.read());
     }
 
     #[test]
     fn test_write() {
         let (mut master, mut serial) = create_pty_and_serial();
-        serial.try_write(2).expect("Write failed");
+        serial.write(2).expect("Write failed");
         let mut buf = [0; 2];
         assert_eq!(1, master.read(&mut buf).unwrap());
         assert_eq!(buf, [2, 0]);

src/spi.rs

@@ -40,25 +40,24 @@ impl ops::DerefMut for Spidev {
 
 mod embedded_hal_impl {
     use super::*;
-    use embedded_hal::blocking::spi::{Operation as SpiOperation, Transactional, Transfer, Write};
+    use embedded_hal::spi::blocking::{Operation as SpiOperation, Transactional, Transfer, Write};
     use spidev::SpidevTransfer;
     use std::io::Write as _;
 
     impl Transfer<u8> for Spidev {
         type Error = io::Error;
 
-        fn try_transfer<'b>(&mut self, buffer: &'b mut [u8]) -> io::Result<&'b [u8]> {
+        fn transfer<'b>(&mut self, buffer: &'b mut [u8]) -> io::Result<()> {
             let tx = buffer.to_owned();
             self.0
-                .transfer(&mut SpidevTransfer::read_write(&tx, buffer))?;
-            Ok(buffer)
+                .transfer(&mut SpidevTransfer::read_write(&tx, buffer))
         }
     }
 
     impl Write<u8> for Spidev {
         type Error = io::Error;
 
-        fn try_write(&mut self, buffer: &[u8]) -> io::Result<()> {
+        fn write(&mut self, buffer: &[u8]) -> io::Result<()> {
             self.0.write_all(buffer)
         }
     }
@@ -67,10 +66,7 @@ mod embedded_hal_impl {
     impl Transactional<u8> for Spidev {
         type Error = io::Error;
 
-        fn try_exec<'a>(
-            &mut self,
-            operations: &mut [SpiOperation<'a, u8>],
-        ) -> Result<(), Self::Error> {
+        fn exec<'a>(&mut self, operations: &mut [SpiOperation<'a, u8>]) -> Result<(), Self::Error> {
             // Map types from generic to linux objects
             let mut messages: Vec<_> = operations
                 .iter_mut()

src/sysfs_pin.rs

@@ -28,18 +28,18 @@ impl SysfsPin {
     }
 }
 
-impl embedded_hal::digital::OutputPin for SysfsPin {
+impl embedded_hal::digital::blocking::OutputPin for SysfsPin {
     type Error = sysfs_gpio::Error;
 
-    fn try_set_low(&mut self) -> Result<(), Self::Error> {
+    fn set_low(&mut self) -> Result<(), Self::Error> {
         if self.0.get_active_low()? {
             self.0.set_value(1)
         } else {
             self.0.set_value(0)
         }
     }
 
-    fn try_set_high(&mut self) -> Result<(), Self::Error> {
+    fn set_high(&mut self) -> Result<(), Self::Error> {
         if self.0.get_active_low()? {
             self.0.set_value(0)
         } else {
@@ -48,19 +48,19 @@ impl embedded_hal::digital::OutputPin for SysfsPin {
     }
 }
 
-impl embedded_hal::digital::InputPin for SysfsPin {
+impl embedded_hal::digital::blocking::InputPin for SysfsPin {
     type Error = sysfs_gpio::Error;
 
-    fn try_is_high(&self) -> Result<bool, Self::Error> {
+    fn is_high(&self) -> Result<bool, Self::Error> {
         if !self.0.get_active_low()? {
             self.0.get_value().map(|val| val != 0)
         } else {
             self.0.get_value().map(|val| val == 0)
         }
     }
 
-    fn try_is_low(&self) -> Result<bool, Self::Error> {
-        self.try_is_high().map(|val| !val)
+    fn is_low(&self) -> Result<bool, Self::Error> {
+        self.is_high().map(|val| !val)
     }
 }